Arquivos psk - Remontti

Entendendo o funcionamento do FreeRadius e fazendo autenticações PPPoE, Hotspot e Wireless PSK/EAP (Lab Mikrotik/Ubiquiti)

Rudimar Remontti — Fri, 13 Mar 2020 20:33:59 +0000

Neste tutorial você irá aprender como integrar o freeradius 3.0.>16 para fazer autenticações PPPoE, Hotspot, Wireless PSK/EAP entre outras. Aprendendo mais sobre os atributos do banco de dados radius.

Para demonstrar irei criar um cenário ilustrativo de “nossa rede” com Mikrotik e Ubiquiti mas basicamente as autenticações podem serem para outras marcas. (Com algumas exceções para os atributos da Mikrotik)

Cenário ilustrativo

# Servidores
FreeRadius: 180.255.0.3

# Concentradores
MK HotSpot: 180.255.1.1
MK PPPoE: 180.255.1.3

# Torre 1 
UBNT AP1 WPA EAP: 10.0.0.2
UBNT AP2 WPA EAP: 10.0.0.3
UBNT AP3 WPA EAP: 10.0.0.4

# Torre 2 
MK AP1 WPA PSK: 10.1.0.2
MK AP2 WPA PSK: 10.1.0.3
MK AP3 WPA PSK: 10.1.0.4

Vou tomar como base a instalação do FreeRadius no tutorial: (requisito)
Criando um servidor de autenticação com FreeRadius 3.0.x no Debian Buster

Entendo as tabelas do banco de dados

• nas
A tabela NAS contém dados de hosts clientes, seria uma “substituição” do arquivo clients.conf. É muito mais fácil alimentar os hosts clientes no banco de dados do que dentro do arquivo de configuração. Então quem do nosso cenário será vamos incluir nesta tabela? Todos os equipamentos que precisarem comunicar com seu servidor para de alguma forma fazer a autenticação. Para inserir os dados na tabela nas você pode usar o terminal ou então acessando o phpMyAdmin:
Os principais campos são:
‣ nasname: IP Adress (Único)
‣ shortname: Nome (Único)
‣ type: Tipo [other]
‣ secret: Sua “senha de autorização”
‣ description: Obs

Em nosso exemplo serão os dois concentradores e os APs das torres que serão inseridos em nossa tabela nas. Ex.:

INSERT INTO `nas` (`nasname`, `shortname`, `type`, `ports`, `secret`, `server`, `community`, `description`) VALUES
-- Mikrotik PPPoE Server --
('180.255.1.1', 'RB-RouterOS-PPPoE', 'other', NULL, 'SEU_SECRET', NULL, NULL, 'RouterOS PPPoE'),
-- Mikrotik Hotspot Server --
('180.255.1.3', 'RB-RouterOS-HotSpot', 'other', NULL, 'SEU_SECRET', NULL, NULL, 'RouterOS HotSpot'),
-- Torre Ubiquiti --
('10.0.0.2', 'UBNT-AP-A', 'other', NULL, 'SEU_SECRET', NULL, NULL, 'U-POP1-A'),
('10.0.0.3', 'UBNT-AP-B', 'other', NULL, 'SEU_SECRET', NULL, NULL, 'U-POP1-B'),
('10.0.0.4', 'UBNT-AP-C', 'other', NULL, 'SEU_SECRET', NULL, NULL, 'U-POP1-C'),
-- Torre Mikrotik  --
('10.1.0.2', 'MK-AP-A', 'other', NULL, 'SEU_SECRET', NULL, NULL, 'M-POP2-A'),
('10.1.0.3', 'MK-AP-B', 'other', NULL, 'SEU_SECRET', NULL, NULL, 'M-POP2-B'),
('10.1.0.4', 'MK-AP-C', 'other', NULL, 'SEU_SECRET', NULL, NULL, 'M-POP2-B');

Algo extremamente importa é que sempre que adicionar, editar ou apagar dados da tabela NAS é necessário reiniciar o serviço FreeRadius para atualizar os hosts clientes, está é a unica tabela que é necessário um restart no serviço.

# systemctl restart freeradius

Dando continuidade as demais tabelas:

• radcheck – Armazena os registo de cada usuário com os respectivos atributos associados. Exemplo o usuário vs senha, usuário vs MAC.

• radgroupcheck – Associa atributos a um determinado grupo de usuários.

• radgroupreply – Armazena os atributos que são devolvidos a todos os usuários de um grupo.

• radusergroup – Associa um usuário a um grupo (radgroupcheck/radgroupreply) simplificando os insert em suas tabelas.

• radreply – Contém lista de atributos enviados a um único usuário.

• radpostauth – Armazena informações acerca das respostas enviadas para os usuários (Desativada).

• radacct – Se encontra toda a informação de contabilização, é dela que você consultará por exemplo um extrato de conexões, descobrir qual IP estava sendo utilizado por um usuário.

Vamos começar configurando o RouterOS/Mikrotik para fazer autenticações PPPoE (Básico)

– Criamos uma pool chamada failover (pode ser qualquer nome) nesse primeiro momento. Mais a frente veremos como configurar usando a radippool.

/ip pool
add name=failover ranges=100.100.100.0/23

– Criar um profile informando nossa pool, bem como DNS e velocidades. (Tudo isso migraremos para as tabelas mais a frente)

/ppp profile
add dns-server=8.8.8.8,8.8.4.4 local-address=180.255.1.1 name=Profile50M rate-limit=50M/50M remote-address=failover

– Criamos o PPPoE Server em uma de suas interfaces que está ouvindo os roteadores que irão “discar”, bem como informando o profile que foi
criado.

/interface pppoe-server server
add authentication=pap,chap disabled=no keepalive-timeout=30 service-name=pppoe-service default-profile=Profile50M interface=ether2

– Configuramos os usuários para serem buscado do freeradius, bem como que que o intervalo de atualização das tabelas seja de 5min.

/ppp aaa
set interim-update=5m use-radius=yes

– Adicionamos nossa conexão o servidor radius informando os tipos de autenticações que serão utilizados.

/radius
add address=180.255.0.3 secret="SEU_SECRET" service=ppp

Vamos autenticar nosso primeiro usuário o jose@provedor.com o “plano/profile” 50Mb. Para isso insira em seu banco de dados:

INSERT INTO `radcheck` (`username`, `attribute`, `op`, `value`) VALUES
('jose@provedor.com', 'Cleartext-Password', ':=', 'senha_do_usuario');

Agora configuro em nosso roteador que irá autenticar o pppoe-cliente, exemplo em um outro Mikroik:

/interface pppoe-client
add add-default-route=yes disabled=no interface=ether1 name=pppoe-out1 password=senha_do_usuario use-peer-dns=yes user=jose@provedor.com

Acessando seu concentrador já é possível ver nosso usuário jose@provedor.com autenticado:

Bom até aí nenhum mistério, mas é extremamente perigoso você ter um usuário em seu banco de dados radius sem nenhum outro atributo, pois o com apenas usuário e senha poderia ser feito qualquer autenticação sem exigir muito mais, conheço muitos sistemas que fazem isso!

Vamos supor que na conexão com o radius você tenha marcado login, e nos usuário tenha marcado para autenticar via radius (Já vi sistemas bem famosos fazerem isso!)

/radius
add address=180.255.0.3 secret="SEU_SECRET" service=ppp,login
/user aaa
set use-radius=yes

Vamos ao teste? Abra seu winbox e tente acessar seu router:

Bingo! Respiramos aliviado em ver que é apenas um usuário de leitura, mas não seria nada legal alguém acessar seu router, e além do mais esse usuário somente leitura em [AAA] –> Default Group poderia ter sido alterado para full e a M* estaria feita. Mas quem sabe você queira ter seus usuários do router no radius, então para isso precisamos pensar na segurança e adicionar outros atributos que prendam ele a este serviço. Veja como ficaria um exemplo seguro onde o atributo Service-Type prende o mesmo ao tipo Login-User, e na tabela radreply insira o atributo Mikrotik-Group informando qual o seu grupo de permissões (full/write/read/personalizada)

INSERT INTO `radcheck` (`id`, `username`, `attribute`, `op`, `value`) VALUES 
(NULL, 'usuario_router', 'Cleartext-Password', ':=', 'senha_do_usuario'),
(NULL, 'usuario_router', 'Service-Type', '==', 'Login-User');

INSERT INTO `radreply` (`id`, `username`, `attribute`, `op`, `value`) VALUES
(NULL, 'usuario_router', 'Mikrotik-Group', ':=', 'full');

Da para melhorar isso? Claro! Podemos dizer que este usuário só pode ser acessado de um determinado IP, ex.: “180.255.3.33”

INSERT INTO `radcheck` (`id`, `username`, `attribute`, `op`, `value`) VALUES 
(NULL, 'usuario_router', 'Calling-Station-Id', '==', '180.255.3.33');

Também pode informar que este usuário só poderá acessar somente o IP deste concentrador

INSERT INTO `radcheck` (`id`, `username`, `attribute`, `op`, `value`) VALUES 
(NULL, 'usuario_router', 'NAS-IP-Address', '==', '180.255.1.1');

Agora que já aprendemos como deixar nosso login seguro, não podemos esquecer que os o jose@provedor.com ainda consegue logar no seu router, pois ele não tem nenhum outro atributo vinculado, entendeu o perigo? Isso que não chegamos na parte do WPA-EAP, ele poderia ser utilizado lá também.

Bom para nossa segurança vamos incluir os atributos Service-Type com valor Framed-User e Framed-Protocol com valor PPP

INSERT INTO `radcheck` (`id`, `username`, `attribute`, `op`, `value`) VALUES 
(NULL, 'jose@provedor.com', 'Service-Type', '==', 'Framed-User'),
(NULL, 'jose@provedor.com', 'Framed-Protocol', ':=', 'PPP');

E porque não prender nosso usuário ao MAC Adress dele?

INSERT INTO `radcheck` (`id`, `username`, `attribute`, `op`, `value`) VALUES 
(NULL, 'jose@provedor.com', 'Calling-Station-Id', '==', '08:00:00:00:00:B2');

Fazendo um SELECT em nossa tabelas temos 4 atributos atrelado ao nosso usuário jose@provedor.com que deixam de certa foma muito mais seguro. Existe ainda o atributo Simultaneous-Use que falarei dele mais a frente.

MariaDB [radius]> SELECT * FROM `radcheck` WHERE `username` = 'jose@provedor.com';
+----+-------------------+--------------------+----+-------------------+
| id | username          | attribute          | op | value             |
+----+-------------------+--------------------+----+-------------------+
|  1 | jose@provedor.com | Cleartext-Password | := | senha_do_usuario  |
|  2 | jose@provedor.com | Service-Type       | == | Framed-User       |
|  3 | jose@provedor.com | Framed-Protocol    | := | PPP               |
|  4 | jose@provedor.com | Calling-Station-Id | == | 08:00:00:00:00:B2 |
+----+-------------------+--------------------+----+-------------------+
4 rows in set (0.001 sec)

Para que nosso controle de banda (queues) também seja configurado através do freeradius, o mikrotik possui uma bliblioteca Mikrotik-Rate-Limit.
Para demonstrar que realmente o jose@provedor.com não irá mais pegar os 50MB do profile irei colocar no valor 100Mb de Donw e 30 de Upload.

INSERT INTO `radreply` (`id`, `username`, `attribute`, `op`, `value`) VALUES
(NULL, 'jose@provedor.com', 'Mikrotik-Rate-Limit', ':=', '30M/100M');

Desconecte o usuário jose@provedor.com para que as novas configurações sejam atribuidas:

E se a velocidade utilizar Burst? Exemplo você quer mandar no seu plano de de 10Mb Up/50Mb Down, uma experiencia que por 1 minuto ele tenha o dobro da velocidade.

INSERT INTO `radreply` (`id`, `username`, `attribute`, `op`, `value`) VALUES
(NULL, 'jose@provedor.com', 'Mikrotik-Rate-Limit', ':=', '10M/50M 20M/100M 10M/50M 120/120 0');

INSERT INTO `radreply` (`id`, `username`, `attribute`, `op`, `value`) VALUES
(NULL, 'jose@provedor.com', 'Framed-IP-Address', ':=', '180.255.0.150');

Infelizmente o Mikrotik ainda não compreende o atributo Delegated-IPv6-Prefix (IPv6PD da LAN do cliente), no forum foram proposto algumas gambiarras pela própria mikrotik como criando script para deixar estatico os IPv6s (gambiarra que na maoria das vezes nada da certo dependendo do modelo do router) no entanto ele aceita os atributo Framed-IPv6-Prefix (IPv6 WAN) e o Mikrotik-Delegated-IPv6-Pool com o nome do da Pool que foi criada manualmente lá no seu router.

INSERT INTO `radreply` (`id`, `username`, `attribute`, `op`, `value`) VALUES
-- IPv6 WAN --
(NULL, 'jose@provedor.com', 'Framed-IPv6-Prefix', ':=', '2001:db8:A:B::/64'),
-- IPv6PD LAN Nome da Pool --
(NULL, 'jose@provedor.com', 'Mikrotik-Delegated-IPv6-Pool', '=', 'nome_da_pool6');

Lembrando q Delegated-IPv6-Prefix não funciona no Mikrotik (hj), oremos para que um dia seja implementado Ficaria assim:

INSERT INTO `radreply` (`id`, `username`, `attribute`, `op`, `value`) VALUES
(NULL, 'jose@provedor.com', 'Delegated-IPv6-Prefix', '=', '2001:db8:C::/56');

Se você deseja saber mais acesse o tutorial:
Como entregar IPv6+IPv4 no Mikrotik/RouterOS através de PPPoE/DHCPv6 PD e registrando os logs em um banco de dados

Entregando os DNS pelo radius, lembra que em nosso profile configuramos para entregar 8.8.8.8 e 8.8.4.4? Vamos entregar agora ao usuário jose@provedor.com os DNS 1.1.1.1 e 9.9.9.9, para isso adicione a tabela radreply os atributos MS-Primary-DNS-Server e MS-Secondary-DNS-Server.

INSERT INTO `radreply` (`id`, `username`, `attribute`, `op`, `value`) VALUES
(NULL, 'jose@provedor.com', 'MS-Primary-DNS-Server', ':=', '1.1.1.1'),
(NULL, 'jose@provedor.com', 'MS-Secondary-DNS-Server', ':=', '9.9.9.9');

Fazendo um SELECT na tabelas radreply temos 4 atributos vinculados a configurações que serão entregue ao usuário jose@provedor.com.

MariaDB [radius]> SELECT * FROM `radreply` WHERE `username` = 'jose@provedor.com';
+----+-------------------+-------------------------+----+----------------------------------+
| id | username          | attribute               | op | value                            |
+----+-------------------+-------------------------+----+----------------------------------+
|  3 | jose@provedor.com | Mikrotik-Rate-Limit     | := | 10M/50M 20M/100M 10M/50M 120/120 |
|  6 | jose@provedor.com | MS-Primary-DNS-Server   | := | 1.1.1.1                          |
|  7 | jose@provedor.com | MS-Secondary-DNS-Server | := | 9.9.9.9                          |
|  8 | jose@provedor.com | Framed-IP-Address       | := | 180.255.0.150                    |
+----+-------------------+-------------------------+----+----------------------------------+
4 rows in set (0.001 sec)

Podemos dispensar as configurações feita no profile já que o controle de banda e DNS são entregues pelo radius? Sim, porém eu particularmente deixo os DNS como uma especie de “failover” caso não seja informado, apesar que no caso do Mikrotik se o DNS não estiver informado no Profile ele irá usar o DNS do router (/ip dns). Normalmente no concentrador PPPoE eu tenho apenas um profile qual é usado para todos PPPoE Servers onde altero o Rate Limit (rx/tx) para uma velocidade extremamente baixa (100k/100k), pois assim se algum usuário autenticar e não receber as configurações de banda do radius ele estará autenticando com velocidade ilimitada.

# No seu RouteOS
/ppp profile set Profile50M rate-limit=100k/100k

Iremos ver agora como buscar nosso IPv4 através da pool do radius, tabela radippool
Vamos inserir apenas 3 entradas para demonstrar sendo 3 de IPs Validos e 3 para bloqueios. No seu caso você irá inserir todos seus IPs um a um.

INSERT INTO `radippool` 
(`pool_name`, `framedipaddress`, `calledstationid`, `callingstationid`, `username`, `pool_key`) VALUES
('pool_valido', '180.255.3.128','','','','0'),
('pool_valido', '180.255.3.129','','','','0'),
('pool_valido', '180.255.3.130','','','','0'),
('pool_bloq','100.127.0.0','','','','0'),
('pool_bloq','100.127.0.1','','','','0'),
('pool_bloq','100.127.0.2','','','','0');

Agora para testarmos vamos remover primeiro o IP 180.255.0.150 que setamos para o usuário jose@provedor.com anteriormente, pois se você utilizar o atributo Framed-IP-Address ele terá prioridade a pool.

DELETE FROM `radreply` WHERE `username` LIKE 'jose@provedor.com' AND `attribute` LIKE 'Framed-IP-Address'

Para entregar ao usuário jose@provedor.com a pool_valido utilizaremos o atributo Pool-Name

INSERT INTO `radcheck` (`id`, `username`, `attribute`, `op`, `value`) VALUES 
(NULL, 'jose@provedor.com', 'Pool-Name', ':=', 'pool_valido');

Desconectamos nosso usuário para ver qual IP ele vai receber.

RouterOS

[usuario_router@PPP-SERVER-LAB] > ppp active print
Flags: R - radius
 #   NAME         SERVICE CALLER-ID         ADDRESS         UPTIME   ENCODING 
 0 R jose@prov... pppoe   08:00:00:00:00:B2 45.250.3.129    7m51s

Radius

MariaDB [radius]> SELECT pool_name,framedipaddress,username,pool_key FROM `radippool`;
+-------------+-----------------+-------------------+-------------------+
| pool_name   | framedipaddress | username          | pool_key          |
+-------------+-----------------+-------------------+-------------------+
| pool_valido | 45.250.3.128    |                   | 0                 |
| pool_valido | 45.250.3.129    | jose@provedor.com | 08:00:00:00:00:B2 |
| pool_valido | 45.250.3.130    |                   | 0                 |
| pool_bloq   | 100.127.0.0     |                   | 0                 |
| pool_bloq   | 100.127.0.1     |                   | 0                 |
| pool_bloq   | 100.127.0.2     |                   | 0                 |
+-------------+-----------------+-------------------+-------------------+

Podemos ver que o usuário jose@provedor.com recebeu o IP 45.250.3.129. Lembrando que esse endereço IP é entregue randomicamente, configurado lá no tutorial: Criando um servidor de autenticação com FreeRadius 3.0.x no Debian Buster
Se você quiser bloquear o cliente basta alterar sua Pool-Name para pool_bloq.

Talvez você esteja pensando: “Putz mas para cada usuário vai ter vários inserts!”. E é por isso que as tabelas radgroupcheck , radgroupreply e radusergroup existem para simplificar. É nela então que vamos criar nossos “planos”, onde podemos agrupar os atributos Service-Type, Framed-Protocol, Mikrotik-Rate-Limit, MS-Primary-DNS-Server e MS-Secondary-DNS-Server assim não sendo mais necessário informar para cada usuário.

Vamos então criar nosso Plano 10MB. Teremos um novo atributo que acho importante o uso, o Acct-Interim-Interval, ele se “equivale” ao interim-update=5m lá do mikrotik “/ppp aaa”, isso fará que se o mikrotik não atualizar os valores o freeradius solicite, em uma tradução simples é o tempo em que a tabela radacct é atualizada.

INSERT INTO `radgroupcheck` (`groupname`, `attribute`, `op`, `value`) VALUES
('PLANO_10MB', 'Service-Type', '==', 'Framed-User'),
('PLANO_10MB', 'Framed-Protocol', ':=', 'PPP'),
('PLANO_10MB', 'Pool-Name', ':=', 'pool_valido');

INSERT INTO `radgroupreply` (`groupname`, `attribute`, `op`, `value`) VALUES
('PLANO_10MB', 'Acct-Interim-Interval', ':=', '300'),
('PLANO_10MB', 'Mikrotik-Rate-Limit', ':=', '5M/10M'),
('PLANO_10MB', 'MS-Primary-DNS-Server', ':=', '9.9.9.9'),
('PLANO_10MB', 'MS-Secondary-DNS-Server', ':=', '149.112.112.112');

Aproveitando irei criar um Plano de bloqueio.

INSERT INTO `radgroupcheck` (`groupname`, `attribute`, `op`, `value`) VALUES
('BLOQUEADO', 'Service-Type', '==', 'Framed-User'),
('BLOQUEADO', 'Framed-Protocol', ':=', 'PPP'),
('BLOQUEADO', 'Pool-Name', ':=', 'pool_bloq');

INSERT INTO `radgroupreply` (`groupname`, `attribute`, `op`, `value`) VALUES
('BLOQUEADO', 'Acct-Interim-Interval', ':=', '300'),
('BLOQUEADO', 'Mikrotik-Rate-Limit', ':=', '666k/666k'),
('BLOQUEADO', 'MS-Primary-DNS-Server', ':=', '8.8.8.8'),
('BLOQUEADO', 'MS-Secondary-DNS-Server', ':=', '8.8.4.4');

Para melhor entendimento e simplificar vamos apagar do usuário jose@provedor.com das tabelas radcheck e radreply.

DELETE FROM `radcheck` WHERE `username` LIKE 'jose@provedor.com';
DELETE FROM `radreply` WHERE `username` LIKE 'jose@provedor.com';

Logo nossa radcheck precisa se preocupar com apenas de dois atributos Cleartext-Password (usuário vs senha) e Calling-Station-Id (usuário vs MAC), adicionamos então:

INSERT INTO `radcheck` (`username`, `attribute`, `op`, `value`) VALUES
('jose@provedor.com', 'Cleartext-Password', ':=', 'senha_do_usuario'),
('jose@provedor.com', 'Calling-Station-Id', '==', '08:00:00:00:00:B2');

Se nesse momento o usuário conectar ele estaria sem um grupo e as configurações que estaria recebendo seriam as do profile do mikrotik (IP/DNS/Velocidade). Como fazer? Simples, você irá usar a tabela radusergroup onde você irá inserir o nome do usuário e qual o nome do grupo ele pertence. Muito mais simples não?!

INSERT INTO `radusergroup` (`username`, `groupname`) VALUES 
('jose@provedor.com', 'PLANO_10MB');

Desconecte o usuário e verifique se o mesmo irá receber as novas configurações com base em grupos.
PPPoE Server: IP Randômico [OK] / Controle de Banda [OK]

PPPoE Cliente: IP [OK] / DNS [OK]

Agora para bloquear o usuário basta fazer um UPDATE trocando o plano do usuário para BLOQUEADO.

UPDATE `radusergroup` SET `groupname` = 'BLOQUEADO' WHERE `username` LIKE 'jose@provedor.com';

Desconectamos novamente e verificamos as configurações recebidas.

Podemos ver que nossas regras estão funcionado. Vale lembrar que se for bloquear um usuário qual esteja com o atributo Framed-IP-Address onde você setou um IP fixo para o mesmo será necessário remover, caso contrario o cliente não irá receber o IP da faixa bloqueada.

Qualquer atributo que você queira que sobrescreva a radusergroup basta adicionar diretamente nas tabelas, como é o exemplo do IP fixo, vamos supor que um determinado usuário queira receber um DNS personalizado, basta adicionar o usuário dele na radreply.

Vamos ver como estão nossas tabelas até o momento:

MariaDB [radius]> SELECT * FROM `radgroupcheck`;
+----+------------+-----------------+----+-------------+
| id | groupname  | attribute       | op | value       |
+----+------------+-----------------+----+-------------+
|  1 | PLANO_10MB | Service-Type    | == | Framed-User |
|  2 | PLANO_10MB | Framed-Protocol | := | PPP         |
|  3 | PLANO_10MB | Pool-Name       | := | pool_valido |
|  4 | BLOQUEADO  | Service-Type    | == | Framed-User |
|  5 | BLOQUEADO  | Framed-Protocol | := | PPP         |
|  6 | BLOQUEADO  | Pool-Name       | := | pool_bloq   |
+----+------------+-----------------+----+-------------+
6 rows in set (0.000 sec)

MariaDB [radius]> SELECT * FROM `radgroupreply`;
+----+------------+-------------------------+----+-----------------+
| id | groupname  | attribute               | op | value           |
+----+------------+-------------------------+----+-----------------+
|  1 | PLANO_10MB | Acct-Interim-Interval   | := | 300             |
|  2 | PLANO_10MB | Mikrotik-Rate-Limit     | := | 5M/10M          |
|  3 | PLANO_10MB | MS-Primary-DNS-Server   | := | 9.9.9.9         |
|  4 | PLANO_10MB | MS-Secondary-DNS-Server | := | 149.112.112.112 |
|  5 | BLOQUEADO  | Acct-Interim-Interval   | := | 300             |
|  6 | BLOQUEADO  | Mikrotik-Rate-Limit     | := | 666k/666k       |
|  7 | BLOQUEADO  | MS-Primary-DNS-Server   | := | 8.8.8.8         |
|  8 | BLOQUEADO  | MS-Secondary-DNS-Server | := | 8.8.4.4         |
+----+------------+-------------------------+----+-----------------+
8 rows in set (0.000 sec)

MariaDB [radius]> SELECT * FROM `radcheck` WHERE `username` = 'jose@provedor.com';
+----+-------------------+--------------------+----+-------------------+
| id | username          | attribute          | op | value             |
+----+-------------------+--------------------+----+-------------------+
| 15 | jose@provedor.com | Cleartext-Password | := | senha_do_usuario  |
| 16 | jose@provedor.com | Calling-Station-Id | == | 08:00:00:00:00:B2 |
+----+-------------------+--------------------+----+-------------------+
2 rows in set (0.000 sec)

MariaDB [radius]> SELECT * FROM `radusergroup`;
+----+-------------------+-----------+----------+
| id | username          | groupname | priority |
+----+-------------------+-----------+----------+
|  1 | jose@provedor.com | BLOQUEADO |        1 |
+----+-------------------+-----------+----------+
1 row in set (0.000 sec)

Simultaneous-Use

Existe um atributo chamado Simultaneous-Use qual você pode limitar o número de vezes que aquele usuário pode autenticar, aplicando na radgroupcheck ficaria:

INSERT INTO `radgroupcheck` (`groupname`, `attribute`, `op`, `value`) VALUES
('PLANO_X', 'Simultaneous-Use', ':=', '1');

Porém para funcionar o Simultaneous-Use é necessário ajustes em dois arquivos:
– /etc/freeradius/3.0/sites-enabled/inner-tunnel
– /etc/freeradius/3.0/sites-enabled/default
Incluindo dentro de session o valor radutmp

session { 
    radutmp
    sql
}

Mas é extremamente importante você saber que qualquer falha de comunicação entre o roteador e o servidor a conexão ira ficar “pendurada“, como vimos na radacct todas as conexões são registradas lá, logo quando um cliente está conectado o campo de stop ainda não foi atualizado, então imagine que seu router sofreu uma falha elétrica e desligou, logo nenhuma informação será enviada para o servidor deixando todas as conexões em aberta, ao iniciar novamente o roteador todos usuários não irão conseguir logar, pois já existe uma conexão. Resumindo se você não estiver preparado para esse tipo de situação é melhor não utiliza-lo. Eu costumo deixar no pppoe server a opção one-session-per-host=yes assim apenas um login pode acessar (que vai fazer a mesma coisa) o ponto negativo é que em distintos concentradores seria possível logar. Mas se você é um cara inteligente você facilmente monta um script para verificar se o existe por exemplo dois usuários iguais na radippool vindo de diferentes nasipaddress e podendo executar uma ação, ex envia um alerta de gatonet

radippool Duplicando IPs

Um outro ponto frequente que me perguntam é sobre a radippool e o problema com duplicidades de IPs. Sim existia alguns problemas em versões mais antigas. Como no caso de uma falha elétrica ou um rompimento irá causar falha de comunicação entre servidor e concentrador. Após a versão 3.0.16 o freeradius teve alguma melhorias. Na radippool existe um campo chamado expiry_time que por padrão é de 1 hora.

Lembra que configuramos o interim-update no mikrotik e Acct-Interim-Interval na tabela radgroupreply qual montamos o “plano” com valores de 5 minutos? Logo o valor de expiry_time sempre será atualizado a cada 5 min (acrecentando o valor do lease_duration) e o prazo de expiração passará ser de +1h, porém se a falta de comunicação for por um curto tempo inferior à 1h e o mesmo usuário reautenticar ele vai manter o IP antigo pois ele ainda não expirou, e o usuário vai receber um novo IP, então o IP antigo só irá sair da tabela na próxima vez que o usuário autenticar e o prazo for maior que 1h, sabemos que uma nova autenticação pode até levar dias para acontecer novamente, e quando der um problema normalmente são muitos usuários, e com isso nossa tabelas de ips acabará facilmente ficando sem IPs livres na pool.

Oque fazer então? Este tempo pode ser ajustado no arquivo /etc/freeradius/3.0/mods-available/sqlippool na variável lease_duration = 3600, eu irei alterar para 10 min, assim será dificil algum usuário autenticar sem remover seu antigo IP alocado. Mas você pode ajustar de acordo com suas necessidades/realidade.

# sed -i 's/lease_duration = 3600/lease_duration = 600/' /etc/freeradius/3.0/mods-available/sqlippool
# systemctl restart freeradius

Algo que você pode criar é uma rotina com um script de sua linguagem preferia, fazendo um simples select na radippool e verifica se existe dois usuários, e tomando uma ação.

Porém é interessante você ajustar as querys em /etc/freeradius/3.0/mods-config/sql/ippool/mysql/queries.conf Eu levei um bom tempo para deixar isso funcionando de forma que não tivesse mais dor de cabeça, (não irei compartilhar pois é algo que é bem para minha realidade, mais pode me chama no telegram @remontti)

Uma solução simples que encontrei para resolver isso no passado foi criar um script executado a cada 5 min no concentrador PPPoE, onde ele verifica se a conexão com o IP do servidor freeradius está respondendo, e caso não responda ele desative/ative os pppoe-servers fazendo com que os clientes desconectem (Na minha situação quando o concentrador não tem comunicação com o freeradius o cliente também não tem) assim quando estabilizar a comunicação todos irão reautenticar novamente. Tenho isso até hoje, confesso que me sinto mais confortável, caso deseje saber como ele é segue o script:

Altere 180.255.0.3 para o IP do seu servidor Freeradius. O script vai disparar 10 ping e caso não responde ele irá então desativar e ativar todos os pppoe-server. Lembre-se de não pode nenhum firewall bloqueando ICMP.

/system scheduler
add interval=5m name=checa-radius on-event="{ \r\
    \n  :local cont 0\r\
    \n  :local services [/interface pppoe-server server print count-only]\r\
    \n  /interface pppoe-server server print\r\
    \n  :if ([/ping 180.255.0.3 count=10] = 0) do={\r\
    \n    :log error message=\"COMUNICACAO RADIUS [ OFF ]\";\r\
    \n    :while (\$cont < \$services) do={\r\
    \n      /interface pppoe-server server disable numbers=\$cont\r\
    \n      /interface pppoe-server server enable numbers=\$cont\r\
    \n      :set cont (\$cont+1)\r\
    \n    }\r\
    \n  }\r\
    \n}" policy=ftp,reboot,read,write,policy,test,password,sniff,sensitive,romon start-time=startup

{ 
  :local cont 0
  :local services [/interface pppoe-server server print count-only]
  /interface pppoe-server server print
  :if ([/ping 180.255.0.3 count=10] = 0) do={
    :log error message="COMUNICACAO RADIUS [ OFF ]";
    :while ($cont < $services) do={
      /interface pppoe-server server disable numbers=$cont
      /interface pppoe-server server enable numbers=$cont
      :set cont ($cont+1)
    }
  }
}

Personalizando a alocação dos IPS para escolher uma Pool padrão quando esgotar uma Pool-Name. `Opcional`

Ao término de uma pools na maioria dos casos (provedores) subentender-se que acabou os IPs válidos e será necessários entregar IPs inválidos para fazer o CGNAT. Então porque não ajustar o allocate_find para que se caso uma Pool-Name não contenha mais IPs disponível ela lhe entregar os de uma nova Pool? Bom vale lembrar para nunca deixar a pool de bloqueio/aviso/etc faltar IPs pois se isso acontecer o cliente vai receber um IP de CGNAT. Eu particularmente gosto assim, quanto menos informação no roteador mais controle se tem.

Se desejar fazer isso vamos editar o /etc/freeradius/3.0/mods-config/sql/ippool/mysql/queries.conf.

# vim /etc/freeradius/3.0/mods-config/sql/ippool/mysql/queries.conf

Comentando as linhas atuais da variável allocate_find:

##allocate_find = "\
##        SELECT framedipaddress FROM ${ippool_table} \
##        WHERE pool_name = '%{control:Pool-Name}' \
##        AND expiry_time IS NULL \
##        ORDER BY \
##                RAND() \
##        LIMIT 1 \
##        FOR UPDATE"

E adicionando as seguintes: (Perceba que o nome da pool alternativa/failover/backup é pool_cgnat)

allocate_find = "\
    SELECT framedipaddress FROM ${ippool_table} \
    WHERE ( \
    CASE WHEN (SELECT COUNT(framedipaddress) FROM ${ippool_table} WHERE pool_name = '%{control:Pool-Name}' AND expiry_time IS NULL LIMIT 1) > 0 THEN \
    (pool_name = '%{control:Pool-Name}' AND expiry_time IS NULL) \
    ELSE \
    (pool_name = 'pool_cgnat' AND expiry_time IS NULL) \
    END) \
    ORDER BY RAND() \
    LIMIT 1 \
    FOR UPDATE"

Lembre-se que toda a ateração nos arquivos de configurações é necessário reiniciar o serviço.

# systemctl restart freeradius

Você vai precisar adicionar agora todos seus IPs de CGNAT (cgnat.sql) ex.:

INSERT INTO `radippool` 
(`pool_name`, `framedipaddress`, `nasipaddress`, `calledstationid`, `callingstationid`, `expiry_time`, `username`, `pool_key`) VALUES
('pool_cgnat', '100.64.0.0', '', '', '', NULL, '', '0'),
('pool_cgnat', '100.64.0.1', '', '', '', NULL, '', '0'),
('pool_cgnat', '100.64.0.2', '', '', '', NULL, '', '0'),
('pool_cgnat', '100.64.0.3', '', '', '', NULL, '', '0');

Agora em seu laboratório você pode deixar apenas 1 IP válido e autenticar mais usuários para ver se a regra funcionou.

Autenticação Wireless

Conheço muitos provedores que tem apenas uma senha para todos seus POPs, ou uma diferente para cada, mas são fixas e isso é muito perigoso!!!
Vamos pensar agora só pelas piores possibilidades OK? Imagine um funcionário seu que saiu da sua empresa sabendo a senha de todas as setoriais de suas torres. Imaginou? Você pode até me dizer: "-Grande coisa ele não vai saber meus usuários e senhas dos PPPoE." Realmente ele pode não saber (mas eu nem estou preocupado com isso, pois eu prendo usuário ao MAC, agora se seu sistema não faz isso pode brotar uns gatinhos ai na rede) mas o que realmente me preocupa é o fato das "malvadezas" que podem serem feitas, vamos para primeira? Pego um NanoStation e conecto em sua setorial (para piorar essa setorial esta em bridge com mais alguma coisa... quem sabe com toda a rede?), agora que estou "dentro" da rede posso criar um pppoe-server e autenticar todas as solicitações (é só configurar para ignorar as senhas) toda vez q um um cliente solicita uma conexão um pacote broadcast é enviado na rede e quem responde primeiro ganha, posso ainda gerar um alto trafego (DDoS) bagunçar. Ai você me diz: "-Mas aqui na minha cidade o pessoal nem sabe fazer isso." Realmente, mas se esse infeliz agora pegar e conectar outro NanoStation e interligar um NanoStation no outro? Precisa ser inteligente para fazer isso? (Putz posso estar dando idéias, não faça isso com seu concorrente) Um loop esta feito, e toda essa rede vai parar de funcionar. (Conheco uma galera que usa ONUs na sua rede GPON em brid e esquece isso da para fazer também)... Parei se não vou acabar ser acusado, mas o que quero alertar é que existe uma infinidade de possibilidades ao deixar uma pessoa maliciosa conectar em sua rede.

WPA-PSK

É por isso que uma autenticação com o radius para sua rede wireless é o melhor caminho. Como isso funciona? Para cada dispositivo/antena que for conectar você terá uma senha exclusiva só para ela, vou começar explicando como fazer isso com senhas PSK com o atributo Mikrotik-Wireless-PSK da Mikrotik.

Com base no nosso diagrama da rede vamos ver como seria para autenticar o usuário joao@provedor.com, primeiramente vamos configurar nosso AP-Mikrotik.

Crie um novo profile de segurança

/interface wireless security-profiles 
add name=WPA2-PSK-Radius \
    mode=dynamic-keys management-protection=allowed \
    authentication-types=wpa2-psk radius-called-format=ssid \
    radius-mac-authentication=yes \
    wpa2-pre-shared-key=dZluej6SCdcFvRWd

Configurando a interface wireless "wlan1" setamos o security-profile para WPA2-PSK-Radius que acabamos de criar e darei o nome do sinal (ssid) de SSID-PSK-Radius.

/interface wireless
set [ find default-name=wlan1 ] \
    disabled=no mode=ap-bridge \
    security-profile=WPA2-PSK-Radius \
    ssid=SSID-PSK-Radius

Fizemos a nossa conexão com o radius, informando que vamos usar neste caso apenas o serviço wireless.

/radius
add address=180.255.0.3 secret=SEU_SECRET service=wireless

Não esqueça que sempre que adicionar um novo autenticador ao seu servidor é necessário que o mesmo seja adicionado a tabela NAS e restartado o freeradius, ex:

INSERT INTO `nas` (`nasname`, `shortname`, `type`, `ports`, `secret`, `server`, `community`, `description`) VALUES
('10.1.0.4', 'MK-AP-C', 'other', NULL, 'SEU_SECRET', NULL, NULL, 'SSID-PSK-Radius');

# systemctl restart freeradius

Para você que está estudando é sempre deixar o radius parado e rado-lo em modo debug com o comando `freeradius -X` e observar tudo que rola. Para minha bancada estou usando um mikrotik hAp e vou tentar conectar meu celular, sem cadastrar nada no radius ainda, logo em algumas linhas veremos o seguinte:

(16)   Service-Type = Framed-User
(16)   NAS-Port-Id = "wlan1"
(16)   NAS-Port-Type = Wireless-802.11
(16)   User-Name = "44:45:4D:45:4B:4D"
(16)   Calling-Station-Id = "44-45-4D-45-4B-4D"
(16)   Called-Station-Id = "SSID-PSK-Radius"
(16)   User-Password = ""
(16)   NAS-Identifier = "MikroTik"
(16)   NAS-IP-Address = 10.1.0.4

Podemos observar que chegaram informações como o nome da interface wireless NAS-Port-Id = "wlan1", o tipo da autenticação NAS-Port-Type = Wireless-802.11, o mac do dispositivo User-Name = "44:45:4D:45:4B:4D", o nome do sinal Called-Station-Id = "SSID-PSK-Radius", o nome da router (system -> identity) NAS-Identifier = "MikroTik", e o IP NAS-IP-Address = 10.1.0.4.

Com base nessas informações vamos alimentar nossa base de dados, e é claro que pensando na segurança! Lembra criar usuário sem prender ele a outros atributos é um perigo!

Primeiro atributo então é os Mikrotik-Wireless-PSK que vamos gravar na radreply, logo nosso usuário será nosso MAC. (Estou usando o MAC Format lá do profile separado por dois pontos, mas se necessário para sua aplicação existe outros formatos `"XX XX XX XX XX XX" XX-XX-XX-XX-XX-XX XX:XX:XX:XX:XX:XX XXXX:XXXX:XXXX XXXXXX-XXXXXX XXXXXX:XXXXXX XXXXXXXXXXXX`)

INSERT INTO `radreply` (`username`, `attribute`, `op`, `value`) VALUES
('44:45:4D:45:4B:4D', 'Mikrotik-Wireless-PSK', ':=', '3ZKEG5mMq0ZRSUQy');

Na radcheck vamos então primeiro autorizar a autenticação Auth-Type (Se só gravar isso na tabela seria um perigo pois você esta autorizando esse MAC que é um usuário a autenticar mesmo sem senha) e é por isso que vamos definir que NAS-Port-Type vai ser Wireless-802.11m assim esse user só pode autenticar vindo de uma conexão wireless, e por ultimo você também pode informar que ele só irá poder conectar no SSID com nome "SSID-PSK-Radius".

INSERT INTO `radcheck` (`username`, `attribute`, `op`, `value`) VALUES
('44:45:4D:45:4B:4D', 'Auth-Type', ':=', 'Accept'),
('44:45:4D:45:4B:4D', 'NAS-Port-Type', '==', 'Wireless-802.11'),
('44:45:4D:45:4B:4D', 'Called-Station-Id', '==', 'SSID-PSK-Radius');

Seria ainda possível prender ao Identity (NAS-Identifier) do MK, bem como o IP dele (NAS-IP-Address), mas eu acho mais complicado, mas é possível! Caso você queira que o cliente consiga se conectar em qualquer sinal basta não gravar o atributo Called-Station-Id.

WPA-EAP

No mikrotik:
Crie um novo profile de segurança, para diferenciar usarei o mac-format=XXXXXXXXXXXX. Vale lembrar que tem outras formas de configurar o EAP, mas para nosso lab podemos subi-lo da forma mais simples.

/interface wireless security-profiles
add authentication-types=wpa2-eap \
    management-protection=allowed mode=dynamic-keys \
    name=WPA2-EAP-Radius radius-called-format=ssid \
    radius-eap-accounting=yes radius-mac-format=XXXXXXXXXXXX\
    supplicant-identity=MikroTik

Ajuste sua interface

/interface wireless
set [ find default-name=wlan1 ] disabled=no \
    mode=ap-bridge security-profile=WPA2-EAP-Radius ssid=WPA2-EAP-Radius

Conecte ao radius.

/radius
add address=180.255.0.3 secret=SEU_SECRET service=wireless

No Ubiquiti (Não tem suporte PSK com Radius):

No EAP não é necessariamente ser o MAC o usuário, mas fica mais pratico até para programar, logo precisamos de um usuário e senha e prender ele ao tipo EAP. Eu particularmente NÃO uso EAP no mikrotik, por mais que PSK seja mais facil quebrar com o uso do radius fica muito complicado, e além do mais fica exclusivo ao MAC, já no EAP poderá autenticar com a mesma senha em vários dispositivos.

Inseremos então nosso user EAP no banco de dados.

INSERT INTO `radcheck` (`username`, `attribute`, `op`, `value`) VALUES
('44454D454B4D', 'Cleartext-Password', ':=', 'enIkMVfhq3WIqyKq'),
('44454D454B4D', 'Auth-Type', ':=', 'eap');

Hotspot

Vamos falar primeiro do módulo contador (sqlcounter). O módulo sqlcounter permite um contador de pacotes usando registros contábeis gravados no banco de dados.

Com este módulo é possível criar alguns cenários de interessantes no mundo do Hotspot, exemplo:
- limitar o tempo de conexão (ex.: 2h por dia/mês/único vez)

Se desejar habilite o mod sqlcounter.

# ln -s /etc/freeradius/3.0/mods-available/sqlcounter /etc/freeradius/3.0/mods-enabled/sqlcounter

Adicione em instantiate {...} dailycounter, monthlycounter e noresetcounter do arquivo /etc/freeradius/3.0/radiusd.conf

# sed -i '683i\        dailycounter' /etc/freeradius/3.0/radiusd.conf
# sed -i '684i\        monthlycounter' /etc/freeradius/3.0/radiusd.conf
# sed -i '685i\        noresetcounter' /etc/freeradius/3.0/radiusd.conf

Adicione em authorize {...} dailycounter, monthlycounter e noresetcounter do arquivo /etc/freeradius/3.0/sites-enabled/default

# sed -i '406i\        dailycounter' /etc/freeradius/3.0/sites-enabled/default
# sed -i '407i\        monthlycounter' /etc/freeradius/3.0/sites-enabled/default
# sed -i '408i\        noresetcounter' /etc/freeradius/3.0/sites-enabled/default

Restart o freeradius

# systemctl restart freeradius

Aproveitando o Mk hAp do nosso Lab vou criar um hotspot server.

Com o comando /ip hotspot setup demos um inicio a um "wizard" que fará toda as configurações automaticamente.

/ip hotspot setup  
Select interface to run HotSpot on 

hotspot interface: wlan1 #--> Defina a interface que vai rodar o server
Set HotSpot address for interface 

local address of network: 10.5.50.1/24 #--> Informe o IP/mascara da rede
masquerade network: yes #--> Ativa o NAT já para a classe
Set pool for HotSpot addresses 

address pool of network: 10.5.50.2-10.5.50.254 #--> Range da pool de IPs 
Select hotspot SSL certificate 

select certificate: no #--> Sem certificado
Select SMTP server 

ip address of smtp server: 0.0.0.0 #--> Pode deixar 0.0.0.0
Setup DNS configuration 

dns servers: 8.8.8.8,1.1.1.1 #--> Servidores DNS
DNS name of local hotspot server 

dns name: hotspot.remontti.com.br #--> Domínio qualquer (Se acessado irá mostrar o status)
Create local hotspot user 

name of local hotspot user: admin #--> Vai ser necessário criar um usuario
password for the user: admin #--> que vamos remover

Remova o usuário admin criado no wizard, defina o porfile para usar o radius e na conexão com o radius marque hotspot.

/ip hotspot user remove admin 

/ip hotspot profile
set hsprof1 use-radius=yes

/radius
add address=180.255.0.3 secret=SEU_SECRET service=hotspot

Caso você ira programar um sistema para fazer cadastro lembre-se de liberar o IP do servidor em walled-garden, assim não é necessário estar autenticado para o usuário acessar-la. Ex onde seria no mesmo serivor, irei permitir a consultas de DNS també.

/ip hotspot walled-garden ip
add action=accept disabled=no \
    dst-address=180.255.0.3 !dst-port !protocol !src-address
add action=accept disabled=no !dst-address \
    !dst-address-list dst-port=53 protocol=udp \
    !src-address !src-address-list

Com nosso AP configurado acessamos:

Vou tentar logar com tadeu@remontti.com.br com qualquer senha e visualizar no freeradius -X (debug) o que chega lá:

(6)   NAS-Port-Type = Wireless-802.11
(6)   Calling-Station-Id = "44:45:4D:45:4B:4D"
(6)   Called-Station-Id = "hotspot1"
(6)   NAS-Port-Id = "wlan1"
(6)   User-Name = "tadeu@remontti.com.br"
(6)   NAS-Port = 2151677963
(6)   Acct-Session-Id = "8040000b"
(6)   Framed-IP-Address = 10.5.50.254
(6)   Mikrotik-Host-IP = 10.5.50.254
(6)   CHAP-Challenge = 0xaf9b9672cf915d68fd7244fc43035d7a
(6)   CHAP-Password = 0x647d5c258b16ca7841803bfb3b0d376b79
(6)   Service-Type = Login-User
(6)   WISPr-Logoff-URL = "http://10.5.50.1/logout"
(6)   NAS-Identifier = "LAB"
(6)   NAS-IP-Address = 180.255.1.3

Vimos que chegaram alguns valores interessantes, podemos fazer filtro com MAC Calling-Station-Id = "44:45:4D:45:4B:4D", nome do serviço do hotspot Called-Station-Id = "hotspot1", nome da interface, nome da interface NAS-Port-Id = "wlan1" entre outros.

Agora criamos nosso usuário na tabela radcheck.

INSERT INTO `radcheck` (`username`, `attribute`, `op`, `value`) VALUES
('tadeu@remontti.com.br', 'Cleartext-Password', ':=', 'enIkMVfhq3WIqyKq');

Vamos ao teste:

100% funcionando, agora que já conhecemos os outros comandos poremos prender o usuário ao NAS-Port-Type para Wireless-802.11, criando um grupo, já vou criar 4 grupos "planos".
1º - Plano 30 minutos ao diários - Velocidade 2Mb/8Mb
3º - Plano 7 horas por mês - Velocidade 3Mb/10Mb
2º - Plano 2 Horas unica - Velocidade 8Mb/20Mb
4º - Plano Ilimitado - Velocidade 10Mb/30Mb

INSERT INTO `radgroupcheck` (`groupname`, `attribute`, `op`, `value`) VALUES
('30MIN-DIA', 'Max-Daily-Session', ':=', '1800'),
('30MIN-DIA', 'NAS-Port-Type', '==', 'Wireless-802.11'),
('7h-MES', 'Max-Monthly-Session', ':=', '25200'),
('7h-MES', 'NAS-Port-Type', '==', 'Wireless-802.11'),
('2h-UNICA', 'Max-All-Session', ':=', '7200'),
('2h-UNICA', 'NAS-Port-Type', '==', 'Wireless-802.11'),
('ILIMITADO', 'NAS-Port-Type', '==', 'Wireless-802.11');

INSERT INTO `radgroupreply` (`groupname`, `attribute`, `op`, `value`) VALUES
('30MIN-DIA', 'Acct-Interim-Interval', ':=', '300'),
('30MIN-DIA', 'Mikrotik-Rate-Limit', ':=', '2M/8M'),
('7h-MES', 'Acct-Interim-Interval', ':=', '300'),
('7h-MES', 'Mikrotik-Rate-Limit', ':=', '3072K/10240K'),
('2h-UNICO', 'Acct-Interim-Interval', ':=', '300'),
('2h-UNICO', 'Mikrotik-Rate-Limit', ':=', '8M/20240K'),
('ILIMITADO', 'Acct-Interim-Interval', ':=', '300'),
('ILIMITADO', 'Mikrotik-Rate-Limit', ':=', '10M/30M');

Agora vamos vincular o usuário a um grupo.

INSERT INTO `radusergroup` (`username`, `groupname`) VALUES 
('tadeu@remontti.com.br', '30MIN-DIA');

No caso dos planos com contabilidade de tempo ao término do seu tempo o login não conseguirá mais logar. Essas verificação de tempo é realizada na bom base na tabela radacct.

Um dica final é: Nunca use o mesmo freeradius para PPPoE e Hotspot, crie servidores separados, pois é muito fácil de bagunçar e qualquer inser feita indevida você pode está deixando uma brecha de segurança.

Bônus - Logs: Framed-IPv6-Prefix e Delegated-IPv6-Prefix

Só realize isso em versões antigas do freeradius, a versão do freeradius no Debian 11 por exemplo já foram implementadas as tabelas para registro de IPv6.

Em algumas autenticações (Ex accel-ppp) passam os valores de IPv6, para poder registrar os mesmo serão necessários criar os campos na radacct e ajustar o arquivo de queries.

mariadb -p -u radius

Crie dois campos framedipv6prefix e delegatedipv6prefix

USE radius;
ALTER TABLE `radacct` 
ADD `framedipv6prefix` VARCHAR(41) NULL DEFAULT NULL AFTER `framedipaddress`, 
ADD `delegatedipv6prefix` VARCHAR(41) NULL DEFAULT NULL AFTER `framedipv6prefix`;

Agora ajuste as queries em queries.conf

# vim /etc/freeradius/3.0/mods-config/sql/main/mysql/queries.conf

Vou destacar as linhas que foram alteradas, ajuste seu arquivo: (linhas 208,262-264,292-294,331-333,382-384)

# -*- text -*-
#
#  main/mysql/queries.conf-- MySQL configuration for default schema (schema.sql)
#
#  $Id: 40508024d5fd6a319bbb85775c3fe1e8388be656 $

# Safe characters list for sql queries. Everything else is replaced
# with their mime-encoded equivalents.
# The default list should be ok
#safe_characters = "@abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-_: /"

#######################################################################
#  Connection config
#######################################################################
# The character set is not configurable. The default character set of
# the mysql client library is used. To control the character set,
# create/edit my.cnf (typically in /etc/mysql/my.cnf or /etc/my.cnf)
# and enter
# [client]
# default-character-set = utf8
#

#######################################################################
#  Query config:  Username
#######################################################################
# This is the username that will get substituted, escaped, and added
# as attribute 'SQL-User-Name'. '%{SQL-User-Name}' should be used below
# everywhere a username substitution is needed so you you can be sure
# the username passed from the client is escaped properly.
#
# Uncomment the next line, if you want the sql_user_name to mean:
#
#	Use Stripped-User-Name, if it's there.
#	Else use User-Name, if it's there,
#	Else use hard-coded string "DEFAULT" as the user name.
#sql_user_name = "%{%{Stripped-User-Name}:-%{%{User-Name}:-DEFAULT}}"
#
sql_user_name = "%{User-Name}"

#######################################################################
# Default profile
#######################################################################
# This is the default profile. It is found in SQL by group membership.
# That means that this profile must be a member of at least one group
# which will contain the corresponding check and reply items.
# This profile will be queried in the authorize section for every user.
# The point is to assign all users a default profile without having to
# manually add each one to a group that will contain the profile.
# The SQL module will also honor the User-Profile attribute. This
# attribute can be set anywhere in the authorize section (ie the users
# file). It is found exactly as the default profile is found.
# If it is set then it will *overwrite* the default profile setting.
# The idea is to select profiles based on checks on the incoming packets,
# not on user group membership. For example:
# -- users file --
# DEFAULT	Service-Type == Outbound-User, User-Profile := "outbound"
# DEFAULT	Service-Type == Framed-User, User-Profile := "framed"
#
# By default the default_user_profile is not set
#
#default_user_profile = "DEFAULT"

#######################################################################
# NAS Query
#######################################################################
# This query retrieves the radius clients
#
# 0. Row ID (currently unused)
# 1. Name (or IP address)
# 2. Shortname
# 3. Type
# 4. Secret
# 5. Server
#######################################################################

client_query = "\
	SELECT id, nasname, shortname, type, secret, server \
	FROM ${client_table}"

#######################################################################
# Authorization Queries
#######################################################################
# These queries compare the check items for the user
# in ${authcheck_table} and setup the reply items in
# ${authreply_table}. You can use any query/tables
# you want, but the return data for each row MUST
# be in the following order:
#
# 0. Row ID (currently unused)
# 1. UserName/GroupName
# 2. Item Attr Name
# 3. Item Attr Value
# 4. Item Attr Operation
#######################################################################
# Use these for case sensitive usernames.

#authorize_check_query = "\
#	SELECT id, username, attribute, value, op \
#	FROM ${authcheck_table} \
#	WHERE username = BINARY '%{SQL-User-Name}' \
#	ORDER BY id"

#authorize_reply_query = "\
#	SELECT id, username, attribute, value, op \
#	FROM ${authreply_table} \
#	WHERE username = BINARY '%{SQL-User-Name}' \
#	ORDER BY id"

#
#  The default queries are case insensitive. (for compatibility with
#  older versions of FreeRADIUS)
#
authorize_check_query = "\
	SELECT id, username, attribute, value, op \
	FROM ${authcheck_table} \
	WHERE username = '%{SQL-User-Name}' \
	ORDER BY id"

authorize_reply_query = "\
	SELECT id, username, attribute, value, op \
	FROM ${authreply_table} \
	WHERE username = '%{SQL-User-Name}' \
	ORDER BY id"

#
#  Use these for case sensitive usernames.
#
#group_membership_query = "\
#	SELECT groupname \
#	FROM ${usergroup_table} \
#	WHERE username = BINARY '%{SQL-User-Name}' \
#	ORDER BY priority"

group_membership_query = "\
	SELECT groupname \
	FROM ${usergroup_table} \
	WHERE username = '%{SQL-User-Name}' \
	ORDER BY priority"

authorize_group_check_query = "\
	SELECT id, groupname, attribute, \
	Value, op \
	FROM ${groupcheck_table} \
	WHERE groupname = '%{${group_attribute}}' \
	ORDER BY id"

authorize_group_reply_query = "\
	SELECT id, groupname, attribute, \
	value, op \
	FROM ${groupreply_table} \
	WHERE groupname = '%{${group_attribute}}' \
	ORDER BY id"

#######################################################################
# Simultaneous Use Checking Queries
#######################################################################
# simul_count_query	- query for the number of current connections
#			- If this is not defined, no simultaneous use checking
#			- will be performed by this module instance
# simul_verify_query	- query to return details of current connections
#				for verification
#			- Leave blank or commented out to disable verification step
#			- Note that the returned field order should not be changed.
#######################################################################

simul_count_query = "\
	SELECT COUNT(*) \
	FROM ${acct_table1} \
	WHERE username = '%{SQL-User-Name}' \
	AND acctstoptime IS NULL"

simul_verify_query = "\
	SELECT \
		radacctid, acctsessionid, username, nasipaddress, nasportid, framedipaddress, \
		callingstationid, framedprotocol \
	FROM ${acct_table1} \
	WHERE username = '%{SQL-User-Name}' \
	AND acctstoptime IS NULL"

#######################################################################
# Accounting and Post-Auth Queries
#######################################################################
# These queries insert/update accounting and authentication records.
# The query to use is determined by the value of 'reference'.
# This value is used as a configuration path and should resolve to one
# or more 'query's. If reference points to multiple queries, and a query
# fails, the next query is executed.
#
# Behaviour is identical to the old 1.x/2.x module, except we can now
# fail between N queries, and query selection can be based on any
# combination of attributes, or custom 'Acct-Status-Type' values.
#######################################################################
accounting {
	reference = "%{tolower:type.%{Acct-Status-Type}.query}"

	# Write SQL queries to a logfile. This is potentially useful for bulk inserts
	# when used with the rlm_sql_null driver.
#	logfile = ${logdir}/accounting.sql

	column_list = "\
		acctsessionid,		acctuniqueid,		username, \
		realm,			nasipaddress,		nasportid, \
		nasporttype,		acctstarttime,		acctupdatetime, \
		acctstoptime,		acctsessiontime, 	acctauthentic, \
		connectinfo_start,	connectinfo_stop, 	acctinputoctets, \
		acctoutputoctets,	calledstationid, 	callingstationid, \
		acctterminatecause,	servicetype,		framedprotocol, \
        framedipaddress,    framedipv6prefix,   delegatedipv6prefix"

	type {
		accounting-on {
			#
			#  Bulk terminate all sessions associated with a given NAS
			#
			query = "\
				UPDATE ${....acct_table1} \
				SET \
					acctstoptime = FROM_UNIXTIME(\
						%{integer:Event-Timestamp}), \
					acctsessiontime	= '%{integer:Event-Timestamp}' \
						- UNIX_TIMESTAMP(acctstarttime), \
					acctterminatecause = '%{%{Acct-Terminate-Cause}:-NAS-Reboot}' \
				WHERE acctstoptime IS NULL \
				AND nasipaddress   = '%{NAS-IP-Address}' \
				AND acctstarttime <= FROM_UNIXTIME(\
					%{integer:Event-Timestamp})"
		}

		accounting-off {
			query = "${..accounting-on.query}"
		}

		start {
			#
			#  Insert a new record into the sessions table
			#
			query = "\
				INSERT INTO ${....acct_table1} \
					(${...column_list}) \
				VALUES \
					('%{Acct-Session-Id}', \
					'%{Acct-Unique-Session-Id}', \
					'%{SQL-User-Name}', \
					'%{Realm}', \
					'%{NAS-IP-Address}', \
					'%{%{NAS-Port-ID}:-%{NAS-Port}}', \
					'%{NAS-Port-Type}', \
					FROM_UNIXTIME(%{integer:Event-Timestamp}), \
					FROM_UNIXTIME(%{integer:Event-Timestamp}), \
					NULL, \
					'0', \
					'%{Acct-Authentic}', \
					'%{Connect-Info}', \
					'', \
					'0', \
					'0', \
					'%{Called-Station-Id}', \
					'%{Calling-Station-Id}', \
					'', \
					'%{Service-Type}', \
					'%{Framed-Protocol}', \
					'%{Framed-IP-Address}', \
                    '%{Framed-IPv6-Prefix}', \
                    '%{Delegated-IPv6-Prefix}')"

			#
			#  Key constraints prevented us from inserting a new session,
			#  use the alternate query to update an existing session.
			#
			query = "\
				UPDATE ${....acct_table1} SET \
					acctstarttime	= FROM_UNIXTIME(%{integer:Event-Timestamp}), \
					acctupdatetime	= FROM_UNIXTIME(%{integer:Event-Timestamp}), \
					connectinfo_start = '%{Connect-Info}' \
				WHERE AcctUniqueId = '%{Acct-Unique-Session-Id}'"
		}

		interim-update {
			#
			#  Update an existing session and calculate the interval
			#  between the last data we received for the session and this
			#  update. This can be used to find stale sessions.
			#
			query = "\
				UPDATE ${....acct_table1} \
				SET \
					acctupdatetime  = (@acctupdatetime_old:=acctupdatetime), \
					acctupdatetime  = FROM_UNIXTIME(\
						%{integer:Event-Timestamp}), \
					acctinterval    = %{integer:Event-Timestamp} - \
						UNIX_TIMESTAMP(@acctupdatetime_old), \
					framedipaddress = '%{Framed-IP-Address}', \
                    framedipv6prefix = '%{Framed-IPv6-Prefix}', \
                    delegatedipv6prefix = '%{Delegated-IPv6-Prefix}', \
					acctsessiontime = %{%{Acct-Session-Time}:-NULL}, \
					acctinputoctets = '%{%{Acct-Input-Gigawords}:-0}' \
						<< 32 | '%{%{Acct-Input-Octets}:-0}', \
					acctoutputoctets = '%{%{Acct-Output-Gigawords}:-0}' \
						<< 32 | '%{%{Acct-Output-Octets}:-0}' \
				WHERE AcctUniqueId = '%{Acct-Unique-Session-Id}'"

			#
			#  The update condition matched no existing sessions. Use
			#  the values provided in the update to create a new session.
			#
			query = "\
				INSERT INTO ${....acct_table1} \
					(${...column_list}) \
				VALUES \
					('%{Acct-Session-Id}', \
					'%{Acct-Unique-Session-Id}', \
					'%{SQL-User-Name}', \
					'%{Realm}', \
					'%{NAS-IP-Address}', \
					'%{%{NAS-Port-ID}:-%{NAS-Port}}', \
					'%{NAS-Port-Type}', \
					FROM_UNIXTIME(%{integer:Event-Timestamp} - %{%{Acct-Session-Time}:-0}), \
					FROM_UNIXTIME(%{integer:Event-Timestamp}), \
					NULL, \
					%{%{Acct-Session-Time}:-NULL}, \
					'%{Acct-Authentic}', \
					'%{Connect-Info}', \
					'', \
					'%{%{Acct-Input-Gigawords}:-0}' << 32 | '%{%{Acct-Input-Octets}:-0}', \
					'%{%{Acct-Output-Gigawords}:-0}' << 32 | '%{%{Acct-Output-Octets}:-0}', \
					'%{Called-Station-Id}', \
					'%{Calling-Station-Id}', \
					'', \
					'%{Service-Type}', \
					'%{Framed-Protocol}', \
					'%{Framed-IP-Address}', \
                    '%{Framed-IPv6-Prefix}', \
                    '%{Delegated-IPv6-Prefix}')"
		}

		stop {
			#
			#  Session has terminated, update the stop time and statistics.
			#
			query = "\
				UPDATE ${....acct_table2} SET \
					acctstoptime	= FROM_UNIXTIME(\
						%{integer:Event-Timestamp}), \
					acctsessiontime	= %{%{Acct-Session-Time}:-NULL}, \
					acctinputoctets	= '%{%{Acct-Input-Gigawords}:-0}' \
						<< 32 | '%{%{Acct-Input-Octets}:-0}', \
					acctoutputoctets = '%{%{Acct-Output-Gigawords}:-0}' \
						<< 32 | '%{%{Acct-Output-Octets}:-0}', \
					acctterminatecause = '%{Acct-Terminate-Cause}', \
					connectinfo_stop = '%{Connect-Info}' \
				WHERE AcctUniqueId = '%{Acct-Unique-Session-Id}'"

			#
			#  The update condition matched no existing sessions. Use
			#  the values provided in the update to create a new session.
			#
			query = "\
				INSERT INTO ${....acct_table2} \
					(${...column_list}) \
				VALUES \
					('%{Acct-Session-Id}', \
					'%{Acct-Unique-Session-Id}', \
					'%{SQL-User-Name}', \
					'%{Realm}', \
					'%{NAS-IP-Address}', \
					'%{%{NAS-Port-ID}:-%{NAS-Port}}', \
					'%{NAS-Port-Type}', \
					FROM_UNIXTIME(%{integer:Event-Timestamp} - %{%{Acct-Session-Time}:-0}), \
					FROM_UNIXTIME(%{integer:Event-Timestamp}), \
					FROM_UNIXTIME(%{integer:Event-Timestamp}), \
					%{%{Acct-Session-Time}:-NULL}, \
					'%{Acct-Authentic}', \
					'', \
					'%{Connect-Info}', \
					'%{%{Acct-Input-Gigawords}:-0}' << 32 | '%{%{Acct-Input-Octets}:-0}', \
					'%{%{Acct-Output-Gigawords}:-0}' << 32 | '%{%{Acct-Output-Octets}:-0}', \
					'%{Called-Station-Id}', \
					'%{Calling-Station-Id}', \
					'%{Acct-Terminate-Cause}', \
					'%{Service-Type}', \
					'%{Framed-Protocol}', \
					'%{Framed-IP-Address}', \
                    '%{Framed-IPv6-Prefix}', \
                    '%{Delegated-IPv6-Prefix}')"
		}
	}
}


#######################################################################
# Authentication Logging Queries
#######################################################################
# postauth_query	- Insert some info after authentication
#######################################################################

post-auth {
	# Write SQL queries to a logfile. This is potentially useful for bulk inserts
	# when used with the rlm_sql_null driver.
#	logfile = ${logdir}/post-auth.sql

	query =	"\
		INSERT INTO ${..postauth_table} \
			(username, pass, reply, authdate) \
		VALUES ( \
			'%{SQL-User-Name}', \
			'%{%{User-Password}:-%{Chap-Password}}', \
			'%{reply:Packet-Type}', \
			'%S')"
}

Espero que tenha aprendido um pouco mais de como o FreeRadius funciona.

Curtiu o conteúdo? Quer me ajudar?

Se quiser fazer uma doação para o café ficarei muito feliz pelo seu reconhecimento! (Esse deu trabalho!)

Se não puder doar pode deixar seu agradecimento nos comentário também ficarei feliz em saber que ajudei. Se tiver qualquer pergunta deixe-a também. Se preferir entrar em Contato clique aqui.

Participe do canal no telegram para ficar atualizado sempre que publicar um novo tutorial.

Abraço!

Fontes:
https://wiki.freeradius.org/guide/SQL-HOWTO
https://wiki.freeradius.org/modules/Rlm_sql
https://wiki.freeradius.org/modules/Rlm_sqlippool
https://wiki.freeradius.org/modules/Rlm_sqlcounter

O post Entendendo o funcionamento do FreeRadius e fazendo autenticações PPPoE, Hotspot e Wireless PSK/EAP (Lab Mikrotik/Ubiquiti) apareceu primeiro em Remontti.

Criando um servidor de autenticação com FreeRadius no Debian 10 Buster (Extra sqlippool)

Rudimar Remontti — Fri, 13 Mar 2020 20:25:16 +0000

Esse tutorial é ideal para provedores que desejam criar seu próprio sistema de autenticação com freeradius, fazendo autenticação do tipo PPPoE, hotspot, Wireless (PSK/EAP) entre outras.

Neste tutorial iremos instalar e configurar o FreeRadius 3.0.x sobre o Debina 10, com integração dos na base de dados MariaDB (frok do MySQL), ativaremos ainda o módulos SQLIPPOOL para armazenar nossa pool de IPs na base de dados.

REQUISITOS
1 – Debian 10 bustes – Instalação limpa
2 – WEB Apache + PHP + MariaDB + phpMyAdmin no Debian 10 Buster “LAMP” (Se desejar usar o phpMyAdmin)

Instalação do FreeRadius 3.0.`>17`

Primeiramente iremos criar o banco de dados e usuário e conceder as permissões de acesso.

Abra o terminal de comando do MariaDB e crie a base e o usuario chamados de radius e defina a senha para este usuário.

# mariadb -u root

Altere SENHA_USER_RADIUS. Você pode gerar uma senha forte e segura em https://senhasegura.remontti.com.br

CREATE DATABASE radius;
GRANT ALL PRIVILEGES ON radius.* TO 'radius'@'localhost' IDENTIFIED BY 'SENHA_USER_RADIUS';
FLUSH PRIVILEGES;
quit;

Instale os pacotes do freeradius

# apt install freeradius freeradius-mysql freeradius-utils

Com o o banco de dados radius criado iremos importar as tabelas padrões do freeradius:

# mariadb -u radius -p radius < /etc/freeradius/3.0/mods-config/sql/main/mysql/schema.sql
# mariadb -u radius -p radius < /etc/freeradius/3.0/mods-config/sql/ippool/mysql/schema.sql

Após comando será solicitado a senha do usuario radius (SENHA_USER_RADIUS).

Caso deseje logs mais detalhados (recomendo) edite o arquivo /etc/freeradius/3.0/radiusd.conf, mas antes faça um backup do mesmo.

# cp /etc/freeradius/3.0/radiusd.conf /etc/freeradius/3.0/radiusd.conf.orig
# vim /etc/freeradius/3.0/radiusd.conf

Localize as variáveis e altere para yes

[...]
log {
    [...]
        stripped_names = yes
        auth = yes
        auth_badpass = yes
        auth_goodpass = yes
    [...]
}
[...]

Ajustaremos o mod SQL para trabalhar com conexão do tipo mysql, e informamos os dados para conexão com o banco de dados. Arquivo /etc/freeradius/3.0/mods-available/sql.orig

# cp /etc/freeradius/3.0/mods-available/sql /etc/freeradius/3.0/mods-available/sql.orig

Usarei o comando sed para facilitar sua vida mas preste atenção nos comandos, se desejar pode editar o arquivo manualmente e alterar as entradas.

# sed -i 's/driver = "rlm_sql_null"/driver = "rlm_sql_mysql"/' /etc/freeradius/3.0/mods-available/sql
# sed -i 's/dialect = "sqlite"/dialect = "mysql"/' /etc/freeradius/3.0/mods-available/sql
# sed -i '/server = "localhost"/s/^#//g' /etc/freeradius/3.0/mods-available/sql
# sed -i '/port = 3306/s/^#//g' /etc/freeradius/3.0/mods-available/sql
# sed -i '/login = "radius"/s/^#//g' /etc/freeradius/3.0/mods-available/sql
# sed -i '/password = "radpass"/s/^#//g' /etc/freeradius/3.0/mods-available/sql
# sed -i '/read_clients = yes/s/^#//g' /etc/freeradius/3.0/mods-available/sql

No próximo comando altere SENHA_USER_RADIUS para a senha de conexão do usuário radius.

# sed -i 's/radpass/SENHA_USER_RADIUS/' /etc/freeradius/3.0/mods-available/sql

Habilite o mod:

# ln -s /etc/freeradius/3.0/mods-available/sql /etc/freeradius/3.0/mods-enabled/sql

Agora no arquivo /etc/freeradius/3.0/sites-enabled/default vamos comentar alguns componentes que não nos interessa (Se você entrar no arquivo e editar manualmente ele está todo comentado, auto explicativo.) e incluir alguns componentes como o SQL.

# cp /etc/freeradius/3.0/sites-available/default  /etc/freeradius/3.0/sites-available/default.org

# sed -i '/digest/s/^/#/g' /etc/freeradius/3.0/sites-available/default
# sed -i '/suffix/s/^/#/g' /etc/freeradius/3.0/sites-available/default
# sed -i '/files/s/^/#/g' /etc/freeradius/3.0/sites-available/default
# sed -i '/ldap/s/^/#/g' /etc/freeradius/3.0/sites-available/default
# sed -i '/exec/s/^/#/g' /etc/freeradius/3.0/sites-available/default
# sed -i '/detail/s/^/#/g' /etc/freeradius/3.0/sites-available/default
# sed -i '/unix/s/^/#/g' /etc/freeradius/3.0/sites-available/default
# sed -i '/attr_filter.accounting_response/s/^/#/g' /etc/freeradius/3.0/sites-available/default
# sed -i 's/-sql/sql/' /etc/freeradius/3.0/sites-available/default
# sed -i '682 s/# *//' /etc/freeradius/3.0/sites-available/default
# sed -i '829,849 {s/^/##/}' /etc/freeradius/3.0/sites-available/default

Habilitando o mod sqlippool
Como o mod sqlippool você poderá ter sua pool de IPs direto no banco de dados.

# ln -s /etc/freeradius/3.0/mods-available/sqlippool /etc/freeradius/3.0/mods-enabled/sqlippool

Vou alterar (Descomentando e comentado) a chave pool_key = "%{NAS-Port}" por "%{Calling-Station-Id}", desta forma a chave será o MAC, e "allow_duplicates = no" para não termos duplicidades de IPs. Mais adiante iremos também ajustar o allocate_clear.

# sed -i '65 {s/^/#/}' /etc/freeradius/3.0/mods-available/sqlippool
# sed -i '66 s/# *//' /etc/freeradius/3.0/mods-available/sqlippool
# sed -i '58 s/# *//' /etc/freeradius/3.0/mods-available/sqlippool

Precisamos adicionar o mod sqlippool no nosso arquivo default, você acrescentará sqlippool em accounting {...} e post-auth {...} logo abaixo de sql:

# sed -i '641i\        sqlippool' /etc/freeradius/3.0/sites-available/default
# sed -i '734i\        sqlippool' /etc/freeradius/3.0/sites-available/default

Verifique com o comando abaixo se a saída do seu arquivo ficou assim:

# cat /etc/freeradius/3.0/sites-enabled/default |grep -v "#" |awk 'NF>0'

server default {
listen {
        type = auth
        ipaddr = *
        port = 0
        limit {
              max_connections = 16
              lifetime = 0
              idle_timeout = 30
        }
}
listen {
        ipaddr = *
        port = 0
        type = acct
        limit {
        }
}
listen {
        type = auth
        port = 0
        limit {
              max_connections = 16
              lifetime = 0
              idle_timeout = 30
        }
}
listen {
        ipv6addr = ::
        port = 0
        type = acct
        limit {
        }
}
authorize {
        filter_username
        preprocess
        chap
        mschap
        eap {
                ok = return
        }
        sql
        expiration
        logintime
        pap
}
authenticate {
        Auth-Type PAP {
                pap
        }
        Auth-Type CHAP {
                chap
        }
        Auth-Type MS-CHAP {
                mschap
        }
        mschap
        eap
}
preacct {
        preprocess
        acct_unique
}
accounting {
        sql
        sqlippool
}
session {
        sql
}
post-auth {
        update {
                &reply: += &session-state:
        }
        sql
        sqlippool
        remove_reply_message_if_eap
}
pre-proxy {
}
post-proxy {
        eap
}
}

Faremos os ajustes no arquivo inner-tunnel

# cp /etc/freeradius/3.0/sites-available/inner-tunnel /etc/freeradius/3.0/sites-available/inner-tunnel.org

# sed -i '/suffix/s/^/#/g' /etc/freeradius/3.0/sites-available/inner-tunnel
# sed -i '/files/s/^/#/g' /etc/freeradius/3.0/sites-available/inner-tunnel
# sed -i '/-ldap/s/^/#/g' /etc/freeradius/3.0/sites-available/inner-tunnel
# sed -i 's/-sql/sql/' /etc/freeradius/3.0/sites-available/inner-tunnel
# sed -i 's/radutmp/#radutmp/' /etc/freeradius/3.0/sites-available/inner-tunnel
# sed -i '269 s/# *//' /etc/freeradius/3.0/sites-available/inner-tunnel
# sed -i '331,356 {s/^/##/}' /etc/freeradius/3.0/sites-available/inner-tunnel
# sed -i '365,376 {s/^/##/}' /etc/freeradius/3.0/sites-available/inner-tunnel

Verifique com o comando abaixo se a saída do seu arquivo ficou assim:

# cat /etc/freeradius/3.0/sites-enabled/inner-tunnel |grep -v "#" |awk 'NF>0'

server inner-tunnel {
listen {
       ipaddr = 127.0.0.1
       port = 18120
       type = auth
}
authorize {
        filter_username
        chap
        mschap
        update control {
                &Proxy-To-Realm := LOCAL
        }
        eap {
                ok = return
        }
        sql
        expiration
        logintime
        pap
}
authenticate {
        Auth-Type PAP {
                pap
        }
        Auth-Type CHAP {
                chap
        }
        Auth-Type MS-CHAP {
                mschap
        }
        mschap
        eap
}
session {
        sql
}
post-auth {
        sql
}
pre-proxy {
}
post-proxy {
        eap
}

Uma alteração que acho válida é para que para cada alocação de IP ela seja randômica, isso pode solucionar alguns problemas como o balanceamento dos prefixo no seu BGP, ou daqueles clientes que jogam online, fazem download e até mesmo que estão sofrendo algum ataque. Assim ao reiniciar seu equipamento o mesmo irá receber um novo endereço IP. Para que funcione desta forma iremos apenas comentar algumas linhas e descomentar outras, pois em /etc/freeradius/3.0/mods-config/sql/ippool/mysql/queries.conf variável allocate_find já vem com o modelo pronto

Comentar:

# sed -i '41,50 {s/^/##/}' /etc/freeradius/3.0/mods-config/sql/ippool/mysql/queries.conf

##allocate_find = "\
##      SELECT framedipaddress FROM ${ippool_table} \
##      WHERE pool_name = '%{control:Pool-Name}' \
##      AND (expiry_time < NOW() OR expiry_time IS NULL) \
##      ORDER BY \
##              (username <> '%{User-Name}'), \
##              (callingstationid <> '%{Calling-Station-Id}'), \
##              expiry_time \
##      LIMIT 1 \
##      FOR UPDATE"

Descomentar:

# sed -i '55,62 s/# *//' /etc/freeradius/3.0/mods-config/sql/ippool/mysql/queries.conf

allocate_find = "\
        SELECT framedipaddress FROM ${ippool_table} \
        WHERE pool_name = '%{control:Pool-Name}' \
        AND expiry_time IS NULL \
        ORDER BY \
                RAND() \
        LIMIT 1 \
        FOR UPDATE"

Como alteramos a pool_key para Calling-Station-Id em /etc/freeradius/3.0/mods-enabled/sqlippool vamos ajustar o allocate_clear para quando for liberar um IP use a chave pool_key e não a NAS, caso contrário ira liberar IPs indevidos que estão sendo utilizado por usuários ativos e assim evitamos que surjam IPs duplicados, para isso:

Comentar:

# sed -i '26,35 {s/^/##/}' /etc/freeradius/3.0/mods-config/sql/ippool/mysql/queries.conf

##allocate_clear = "\
##      UPDATE ${ippool_table} \
##      SET \
##              nasipaddress = '', \
##              pool_key = 0, \
##              callingstationid = '', \
##              username = '', \
##              expiry_time = NULL \
##      WHERE expiry_time <= NOW() - INTERVAL 1 SECOND \
##      AND nasipaddress = '%{%{Nas-IP-Address}:-%{Nas-IPv6-Address}}'"

Descomentar

# sed -i '10,18 s/# *//' /etc/freeradius/3.0/mods-config/sql/ippool/mysql/queries.conf

allocate_clear = "\
        UPDATE ${ippool_table} \
        SET \
                nasipaddress = '', \
                pool_key = 0, \
                callingstationid = '', \
                username = '', \
                expiry_time = NULL \
        WHERE pool_key = '${pool_key}'"

É interessante você ajustar o tempo lease_duration = 3600 no arquivo /etc/freeradius/3.0/mods-available/sqlippool talvez para um menor intervalo,porém sempre respeitando que o Acct-Interim-Interval seja um tempo menor, para não ter duplicidades de ips. Falo sobre isso no tutorial https://blog.remontti.com.br/4085 recomendo a leitura!

Opcional
Eu particularmente não gosto da ideia da tabela radusergroup não ter um ID, em alguma programação ela pode ser útil, então para fazer isso se desejar faça:

# mariadb -u radius -p

Entre com suasenha do usuário radius.

USE radius;
ALTER TABLE `radusergroup` ADD `id` INT(20) NOT NULL AUTO_INCREMENT FIRST, ADD PRIMARY KEY (`id`) ;
ALTER TABLE `radusergroup` ADD UNIQUE(`id`);
quit;

Caso você tenha uma alta demanda de requisições você pode fazer algumas alterações no radiusd.conf.
Altere conforme sua necessidade, e hardware de seu servidor. Vale lembrar que fazendo essas alterações pode ser necessário alterar o limite de conexões ao MariaDB. Não abuse nessas configurações recomendo ler a documentação.

# vim /etc/freeradius/3.0/radiusd.conf

Você pode começar dobrando os valores, ex.:

[...]
thread pool {
        start_servers = 10
        max_servers = 64
        min_spare_servers = 6
        max_spare_servers = 20
        max_queue_size = 131072
        max_requests_per_server = 0
        auto_limit_acct = no
}
[...]

Finalizando

Habilite o freeradius para começar junto com a inicialização do sistema

# systemctl enable freeradius

Pare o serviço e inicie em modo debug

# systemctl stop freeradius
# freeradius -X

Se nenhum erro acontecer uma mensagem com: Ready to process requests aparecer parabéns seu freeradius está funcionando. Através do comando debug você consegue acompanhar as ações que o freeradius irá fazer, ótimo para estudos e entendimento. Para encerrar o modo debig use Crtl+c, e então inicie o serviço de forma normal.

# systemctl start freeradius

Para integrar seu servidor freeradius para fazer autenticações PPPoE, Hotspot, Wireless PSK/EAP entre outras, você precisa aprender mais sobre as tabelas do banco de dados e quais atributos usar em cada situação sempre pensando na segurança. Você pode acessar https://blog.remontti.com.br/4085 onde irá encontra alguns modelos de autenticação que atente praticamente todos os cenários de provedores.

Gostou? Quer me ajudar?

Se quiser fazer uma doação para o café ficarei muito feliz pelo seu reconhecimento!

Se não puder doar pode deixar seu agradecimento nos comentário também ficarei feliz em saber que ajudei. Se tiver qualquer pergunta deixe-a também. Se preferir entrar em Contato clique aqui.

Participe do canal no telegram para ficar atualizado sempre que publicar um novo tutorial.

Abraço!

Fonte:
https://wiki.freeradius.org/guide/SQL-HOWTO
https://wiki.freeradius.org/modules/Rlm_sql
https://wiki.freeradius.org/modules/Rlm_sqlippool

O post Criando um servidor de autenticação com FreeRadius no Debian 10 Buster (Extra sqlippool) apareceu primeiro em Remontti.

Servidor FreeRadius com integração MySQL + Autenticação PPPoE & Hotspot VS Mikrotik + Ubiquiti EAP/PSK [Descontinuado]

Rudimar Remontti — Tue, 14 Feb 2017 01:28:29 +0000

Versão mais atual deste tutorial:

https://blog.remontti.com.br/4063
https://blog.remontti.com.br/4085

(Descontinuado)

Neste tutorial vamos configurar o FreeRadius de forma simples em um servidor linux (Debina 8), armazenando nossos usuários e atributos de configurações em uma base de dados MySQL, qual será utilizada para autenticações PPPoE ou Hotspot, no RouterOS (Mikrotik). Vamos tratar ainda do módulos IPPOOL para armazenar nossa pool de IPs no banco de dados e o módulo COUNTER muito usado em configurações de Hotspot para controle de tempo da conexão. E por fim um extra de como configurar seu Access Point (AP)/ Station (Clientes/CPE) para fazer autenticação Wireless (PSK / EAP) em seus equipamentos Ubiquiti/Mikrotik entre outros.

Resumindo é um dos cenário mais encontrado em provedores de internet. Se você gostou do tutorial ou tem dúvidas deixe seu comentário. Se precisar de alguma consultoria ou trocar uma ideia pode me chamar lá no Telegram @remontti (Não garanto que irei responder rápido, mas sempre tiver um tempinho…)

REQUISITOS
1 – Debian 8 Jessie recomendo uma instalação limpa do Debian (Debian 8 Jessie / Instalação Limpa)
2 – Serviço Web Rodando (Passo-a-passo como criar um servidor web Apache2, PHP5, MySQL, PHPMyAdmin “LAMP” no Debian 8)
3 – Servidor Atualizado:

# apt update && apt upgrade

INSTALAÇÃO

# apt install freeradius freeradius-mysql freeradius-utils

Integração com MySQL

Após instalação vamos criar nossa base de dados chamada de “radius”, e após criar nosso usuário que também se chamara “radius” para ter acesso a mesma.

# mysql -u root -p

informe a senha do seus usuário root do MySQL.

CREATE DATABASE radius;
GRANT ALL PRIVILEGES ON radius.* TO 'radius'@'localhost' IDENTIFIED BY 'SUA-SENHA';
FLUSH PRIVILEGES;
quit;

Importamos as tabelas para nosso banco de dados, a cado comando será solicitado senha so usuário mysql radius (SUA-SENHA).

# mysql -u radius -p radius < /etc/freeradius/sql/mysql/schema.sql
# mysql -u radius -p radius < /etc/freeradius/sql/mysql/nas.sql
# mysql -u radius -p radius < /etc/freeradius/sql/mysql/ippool.sql
# mysql -u radius -p radius < /etc/freeradius/sql/mysql/cui.sql
# mysql -u radius -p radius < /etc/freeradius/sql/mysql/wimax.sql

Entramos no diretório onde o FreeRadius tem seus arquivos de configuração.

# cd /etc/freeradius

Antes de editar o radiusd.conf crie um backup do mesmo, farei o mesmo em todos os arquivos que irei editar, assim temos um backup caso cometer algum erro.

# cp radiusd.conf radiusd.conf.orig
# vim radiusd.conf

Descomente

[...]
  ipv6addr = ::
[...]
  $INCLUDE sql.conf
[...]
  $INCLUDE sqlippool.conf
[...]

Se deseja ter logs mais detalhados altere os valores abaixo para yes.

[...]
log {
    [...]
        stripped_names = yes
        auth = yes
        auth_badpass = yes
        auth_goodpass = yes
    [...]
}
[...]

 # cat radiusd.conf |grep -v "#" |awk 'NF>0'

radius.conf ficará assim:

prefix = /usr
exec_prefix = /usr
sysconfdir = /etc
localstatedir = /var
sbindir = ${exec_prefix}/sbin
logdir = /var/log/freeradius
raddbdir = /etc/freeradius
radacctdir = ${logdir}/radacct
name = freeradius
confdir = ${raddbdir}
run_dir = ${localstatedir}/run/${name}
db_dir = ${raddbdir}
libdir = /usr/lib/freeradius
pidfile = ${run_dir}/${name}.pid
user = freerad
group = freerad
max_request_time = 30
cleanup_delay = 5
max_requests = 1024
listen {
        type = auth
        ipaddr = *
        port = 0
}
listen {
        ipaddr = *
        port = 0
        type = acct
}
hostname_lookups = no
allow_core_dumps = no
regular_expressions     = yes
extended_expressions    = yes
log {
        destination = files
        file = ${logdir}/radius.log
        syslog_facility = daemon
        stripped_names = yes
        auth = yes
        auth_badpass = yes
        auth_goodpass = yes
}
checkrad = ${sbindir}/checkrad
security {
        max_attributes = 200
        reject_delay = 1
        status_server = yes
        allow_vulnerable_openssl = no
}
proxy_requests  = yes
$INCLUDE proxy.conf
$INCLUDE clients.conf
thread pool {
        start_servers = 5
        max_servers = 32
        min_spare_servers = 3
        max_spare_servers = 10
        max_requests_per_server = 0
}
modules {
        $INCLUDE ${confdir}/modules/
        $INCLUDE eap.conf
        $INCLUDE sql.conf
        $INCLUDE sqlippool.conf
}
instantiate {
        exec
        expr
        expiration
        logintime
}
$INCLUDE policy.conf
$INCLUDE sites-enabled/

# cp sql.conf sql.conf.orig
# vim sql.conf

Alterar
password = "SUA-SENHA"

Descomente
readclients = yes

# cat sql.conf |grep -v "#" |awk 'NF>0'

sql.conf ficará assim:

sql {
        database = "mysql"
        driver = "rlm_sql_${database}"
        server = "localhost"
        login = "radius"
        password = "MINHA-SENHA"
        radius_db = "radius"
        acct_table1 = "radacct"
        acct_table2 = "radacct"
        postauth_table = "radpostauth"
        authcheck_table = "radcheck"
        authreply_table = "radreply"
        groupcheck_table = "radgroupcheck"
        groupreply_table = "radgroupreply"
        usergroup_table = "radusergroup"
        deletestalesessions = yes
        sqltrace = no
        sqltracefile = ${logdir}/sqltrace.sql
        num_sql_socks = ${thread[pool].max_servers}
        connect_failure_retry_delay = 60
        lifetime = 0
        max_queries = 0
        readclients = yes
        nas_table = "nas"
        $INCLUDE sql/${database}/dialup.conf
}

# cd /etc/freeradius/sites-available
# cp inner-tunnel  inner-tunnel.orig
# vim inner-tunnel

Descomente os sql encontrado em authorize/session/post-auth

authorize {
        [...]
        sql
        [...]
}
[...]
session {
         #radutmp
        sql
}
post-auth {
        sql
}

Comente

#       Post-Auth-Type REJECT {
#               # log failed authentications in SQL, too.
##              sql
#               attr_filter.access_reject
#       }

# cat /etc/freeradius/sites-available/inner-tunnel  |grep -v "#" |awk 'NF>0'

inner-tunne ficará assim:

server inner-tunnel {
listen {
       ipaddr = 127.0.0.1
       port = 18120
       type = auth
}
authorize {
        chap
        mschap
        suffix
        update control {
               Proxy-To-Realm := LOCAL
        }
        eap {
                ok = return
        }
        files
        sql
        expiration
        logintime
        pap
}
authenticate {
        Auth-Type PAP {
                pap
        }
        Auth-Type CHAP {
                chap
        }
        Auth-Type MS-CHAP {
                mschap
        }
        unix
        eap
}
session {
        sql
}
post-auth {
        sql
}
pre-proxy {
}
post-proxy {
        eap
}

# cp default default.orig
# vim default

Comente / Descomente

authorize {
	#digest
	#suffix
	#files
        sql
}

Comente:

authenticate {
        #digest
        #unix
}
preacct {
        #suffix
        #files
}

Comente / Descomente / inclua abaixo de sql sqlippool

accounting {
        #detail
        sql 
        sqlippool
        #exec
        #attr_filter.accounting_response
}
session {
	#radutmp
        sql
}

post-auth {
        sql 
        sqlippool

        #exec
#       Post-Auth-Type REJECT {
#               # log failed authentications in SQL, too.
##              sql
#               attr_filter.access_reject
#       }
}

# cat /etc/freeradius/sites-available/default  |grep -v "#" |awk 'NF>0'

default ficará assim:

authorize {
        preprocess
        chap
        mschap
        eap {
                ok = return
        }
        sql
        expiration
        logintime
        pap
}
authenticate {
        Auth-Type PAP {
                pap
        }
        Auth-Type CHAP {
                chap
        }
        Auth-Type MS-CHAP {
                mschap
        }
        eap
}
preacct {
        preprocess
        acct_unique
}
accounting {
        sql
        sqlippool
}
session {
        sql
}
post-auth {
        sql
        sqlippool
}
pre-proxy {
}
post-proxy {
        eap
}

Habilite o control-socket

# cd /etc/freeradius/sites-enabled
# ln -s ../sites-available/control-socket

SQLIPOOL
https://wiki.freeradius.org/modules/Rlm_sqlippool

Como dito este é um cenário bem tipico de provedores, então vou usar o modulo sqlipool para deixar meus blocos de IPs diretamente no banco de dados, assim temos um aproveitamento de 100% dos IPs, ainda mais com o esgotamenteo de IPv4 no mundo.
IMPORTANTE: Esse formato pode gerar problemas, um deles é a duplicidade de IPs em sua rede, isso acontece se você tiver varios Servidores PPPoE/Hotspot (se bem que em hotspot eu não usaria), espalhados na sua rede, caso haja alguma interrupção entre seu PPPoE Server e o Freeradius, o Freeradius poderá liberar o IP da da tabela radippool, e assim algum outro PPPoE Sever acabar alocando o mesmo. Então tome cuidado. Eu particularmente usei um script que em caso o Servidor PPPoE perder comunicação com o Servidor Freeradius ele desconecta todos os usuários conectados, assim quando voltar a comunicação seja feito uma nova conexão aos clientes.

# vim /etc/freeradius/sqlippool.conf

Altere
$INCLUDE sql/postgresql/ippool.conf
Por
$INCLUDE sql/mysql/ippool.conf

Este é um valor que você pode trabalhar caso tenha algum problema (eu uso o padrão)
## IP lease duration. (Leases expire even if Acct Stop packet is lost)
lease-duration = 3600

Para evitar duplicidade uso o MAC com key (Pois as NAS-port pode se repetir quando se tem mais de um PPPoE Serv)
Comente:
#pool-key = "%{NAS-Port}"
Descomente:
pool-key = "%{Calling-Station-Id}"

Como é bem possível que seu servidor não autentique apenas usuários pppoe ou hotspot, para não termos cada vez que por exemplo um autenticação wireless psk/eap aparece o log que não foi definido uma pool, eu comentei:
#sqlippool_log_nopool = "No Pool-Name defined \
# (did %{Called-Station-Id} cli %{Calling-Station-Id} port %{NAS-Port} user %{User-Name})"

# cat sqlippool.conf |grep -v "#" |awk 'NF>0'

sqlippool.conf ficará assim:

sqlippool {
 sql-instance-name = "sql"
 ippool_table = "radippool"
 lease-duration = 3600
 pool-key = "%{Calling-Station-Id}"
$INCLUDE sql/mysql/ippool.conf
 sqlippool_log_exists = "Existing IP: %{reply:Framed-IP-Address} \
  (did %{Called-Station-Id} cli %{Calling-Station-Id} port %{NAS-Port} user %{User-Name})"
 sqlippool_log_success = "Allocated IP: %{reply:Framed-IP-Address} from %{control:Pool-Name} \
  (did %{Called-Station-Id} cli %{Calling-Station-Id} port %{NAS-Port} user %{User-Name})"
 sqlippool_log_clear = "Released IP %{Framed-IP-Address}\
 (did %{Called-Station-Id} cli %{Calling-Station-Id} user %{User-Name})"
 sqlippool_log_failed = "IP Allocation FAILED from %{control:Pool-Name} \
  (did %{Called-Station-Id} cli %{Calling-Station-Id} port %{NAS-Port} user %{User-Name})"
 #sqlippool_log_nopool = "No Pool-Name defined \
 # (did %{Called-Station-Id} cli %{Calling-Station-Id} port %{NAS-Port} user %{User-Name})"
}

Umas das alterações que acho interessante alterar no ippool, é para que a cada nova alocação de IP ela seja randômica, isso pode solucionar alguns problemas como o daqueles clientes que jogam online, que fazem download, que estão sendo atacados, que ao reiniciar seu equipamento o mesmo irá receber um novo IP. Para isso vamos editar o /etc/freeradius/sql/mysql/ippool.conf

# vim /etc/freeradius/sql/mysql/ippool.conf

Comente

### The ORDER BY clause of this query tries to allocate the same IP-address
### which user had last session...
#allocate-find = "SELECT framedipaddress FROM ${ippool_table} \
# WHERE pool_name = '%{control:Pool-Name}' AND (expiry_time < NOW() OR expiry_time IS NULL) \
# ORDER BY (username <> '%{User-Name}'), \
# (callingstationid <> '%{Calling-Station-Id}'), \
# expiry_time \
# LIMIT 1 \
# FOR UPDATE"

Descomente

### If you prefer to allocate a random IP address every time, i
### use this query instead
allocate-find = "SELECT framedipaddress FROM ${ippool_table} \
 WHERE pool_name = '%{control:Pool-Name}' \
 AND expiry_time IS NULL \
 ORDER BY RAND() \
 LIMIT 1 \
 FOR UPDATE"

COUNTER

Modulo counter é legal para criar alguns cenários de hotspot, ode você deseja limitar o tempo de conexão. Exemplo limitar que um usuário tenha acesso apenas durante 2h por dia/mês/único... E com um pouco de trabalho e personalização no /etc/freeradius/sql/mysql/counter.conf você consegue personalizar para contabilizar até mesmo tráfego de dados.

Caso você deseje habilitar-lo faça o seguinte:

# vim radius.conf

Descomenta

modules {
[...]
       $INCLUDE sql/mysql/counter.conf
[...]
}

Adicione

instantiate {
[...]
        # Habilite o mesmo no inner-tunnel
        # Modulos em  /etc/freeradius/sql/mysql/counter.conf
        dailycounter
        monthlycounter
        noresetcounter
[...]
}

# vim /etc/freeradius/sites-available/inner-tunnel

Adicione abaixo de sql

authorize {
[...]
        sql

        #Mod Counter
        noresetcounter
        dailycounter
        monthlycounter
[...]
}

# vim /etc/freeradius/sites-available/default

Adicione abaixo de sql

authorize {
[...]
        sql

        noresetcounter
        dailycounter
        monthlycounter
[...]
}

Corrigindo um bug. Acerte o nome da tabela (AcctSessionTime ==> acctsessiontime)

# vim /etc/freeradius/sql/mysql/counter.conf

Altere
query = "SELECT IFNULL(SUM(AcctSessionTime),0) FROM radacct WHERE UserName='%{%k}'"
Para
query = "SELECT IFNULL(SUM(acctsessiontime),0) FROM radacct WHERE username='%{%k}'"

ALIMENTANDO NOSSA BASE DE DADOS

Inicialmente eu particularmente não gosto da ideia da radusergroup não ter uma ID então para alterar isso faça. (Se desejar)

# mysql -u radius -p

Entre com SUA-SENHA do radius no MySQL.

USE radius;
ALTER TABLE `radusergroup` ADD `id` INT(20) NOT NULL AUTO_INCREMENT FIRST, ADD PRIMARY KEY (`id`) ;
ALTER TABLE `radusergroup` ADD UNIQUE(`id`);

Agora vamos inserir alguns valores na nossa base de dados com alguns exemplos que explicarei no decorrer.
Se você preferir pode usar os comando mysql direto no PHPMyAdmin.

Primeiramente precisamos de um cenário de rede para montar nossas configurações.
FreeRadius: 250.250.0.10
RB/RouterOS HotSpot: 250.250.1.2
RB/RouterOS PPPoE: 250.250.1.3 / 10.10.0.1
UBNT AP: 10.10.0.2

Note que nosso UBNT não está na mesma classe de IPs do FreeRadius, então possivelmente sua rede deve ter configurado algum tipo roteamento como OSPF / iBGP, que faça com que seu AP vs FreeRadius consiga comunicação. Caso exista um NAT para seu AP explicarei o que munda em seguida.

TABELAS

• nas
A tabela NAS contém dados sobre (radius clientes) e é uma "substituição" para o arquivo clients.conf. É muito mais fácil manter os clientes no banco de dados do que dentro do arquivo de configuração. Ou seja, sua RB/RouterOS e seu UBNT AP são clientes, são eles que irão fazer consultas em nosso servidor. Para devemos autorizá-los inserindo na tabela nas:

INSERT INTO `nas` (`nasname`, `shortname`, `type`, `ports`, `secret`, `server`, `community`, `description`) VALUES
('250.250.1.2', 'RB-RouterOS-PPPoE', 'other', NULL, 'SEU-SECRET', NULL, NULL, 'RouterOS PPPoE'),
('250.250.1.3', 'RB-RouterOS-HotSpot', 'other', NULL, 'SEU-SECRET', NULL, NULL, 'RouterOS HotSpot'),
('10.10.0.2', 'UBNT-AP', 'other', NULL, 'SEU-SECRET', NULL, NULL, 'POP1');

Depois de adicionar, editar ou apagar dados da tabela nas é necessário reiniciar o serviço FreeRadius para atualizar os dados.

# /etc/init.d/freeradius restart

• radcheck - Armazena os registo de cada utilizador com os respectivos atributos associados;
• radgroupcheck – Associa atributos a um determinado grupo de utilizadores;
• radgroupreply – Armazena os atributos que são devolvidos a todos os utilizadores de um grupo;
• radusergroup - Associa um utilizador a um grupo de utilizadores;
• radreply – Contém lista de atributos enviados ao utilizador;
• radpostauth – Armazena informações acerca das respostas enviadas para os utilizadores;
• radacct - Se encontra toda a informação de contabilização (extrato);

Vamos criar algumas configurações padrões, "nossos planos". Lembre-se que os atributos especificados não são necessariamente os mesmos, dependendo do seu cenário, uma boa alternativa é você rodar o freeradius em modo debug (# freeradius -X), e visualizar quais os valores estão vindo, assim você pode observar o que cada autenticação esta lhe trazendo e assim configurando seu grupo de forma segura. Fique atento pois se você cadastrar apenas um atributo poderá estar deixando grandes falhas de segurança.

INSERT INTO `radgroupcheck` (`groupname`, `attribute`, `op`, `value`) VALUES
('PLANO_1', 'Pool-Name', ':=', 'minhapool'), /* Definimos o nome da pool de IPs*/
('PLANO_1', 'Simultaneous-Use', ':=', '1'), /* Permitimos apenas uma autenticação simultânea */
('PLANO_1', 'Framed-Protocol', ':=', 'PPP'), /* Apenas protocolo PPP então isso não server para Hotspot */
('PLANO_1', 'Service-Type', ':=', 'Framed-User'), /* Tipo de serviço  */
('PLANO_2', 'Pool-Name', ':=', 'minhapool'),
('PLANO_2', 'Simultaneous-Use', ':=', '1'),
('PLANO_2', 'Framed-Protocol', ':=', 'PPP'),
('PLANO_2', 'Service-Type', ':=', 'Framed-User'),
('AVISO', 'Pool-Name', ':=', 'avisoPool'),
('AVISO', 'Simultaneous-Use', ':=', '1'),
('AVISO', 'Framed-Protocol', ':=', 'PPP'),
('AVISO', 'Service-Type', ':=', 'Framed-User'),
('BLOQUEIO', 'Pool-Name', ':=', 'bloqPool'),
('BLOQUEIO', 'Simultaneous-Use', ':=', '1'),
('BLOQUEIO', 'Framed-Protocol', ':=', 'PPP'),
('BLOQUEIO', 'Service-Type', ':=', 'Framed-User'),
('PLANO_HOT', 'NAS-Port-Type', '==', 'Wireless-802.11'),
('PLANO_HOT(naonecessariamente)', 'Pool-Name', ':=', 'poolHot'),
('PLANO_HOT', 'Simultaneous-Use', ':=', '1'),
('30MIN-DIA', 'Max-Daily-Session', ':=', '1800'), /* Modulo counter */
('30MIN-DIA', 'NAS-Port-Type', '==', 'Wireless-802.11'),
('30MIN-DIA', 'Simultaneous-Use', ':=', '1'),
('2h-UNICO', 'Max-All-Session', ':=', '7200'),
('2h-UNICO', 'NAS-Port-Type', '==', 'Wireless-802.11'),
('2h-UNICO', 'Simultaneous-Use', ':=', '1'),
('7.5h-MES', 'Max-Monthly-Session', ':=', '27000'),
('7.5h-MES', 'NAS-Port-Type', '==', 'Wireless-802.11'),
('7.5h-MES', 'Simultaneous-Use', ':=', '1');

INSERT INTO `radgroupreply` (`groupname`, `attribute`, `op`, `value`) VALUES
('PLANO_1', 'Acct-Interim-Interval', ':=', '300'), /* Intervalo em seg que a radcct será atualizada */
('PLANO_1', 'Mikrotik-Rate-Limit', ':=', '1024k/2048k'), /* Velocidade da queues */
('PLANO_2', 'Mikrotik-Rate-Limit', ':=', '512k/1024k 1024k/2048k 512k/1024k 600/600'), /* Velocidade com Burst */
('PLANO_2', 'Acct-Interim-Interval', ':=', '300'),
('AVISO', 'Acct-Interim-Interval', ':=', '300'),
('AVISO', 'Mikrotik-Rate-Limit', ':=', '999K/999K'),
('BLOQUEIO', 'Mikrotik-Rate-Limit', ':=', '999K/999K'),
('BLOQUEIO', 'Acct-Interim-Interval', ':=', '300'),
('PLANO_HOT', 'Acct-Interim-Interval', ':=', '300'),
('PLANO_HOT', 'Mikrotik-Rate-Limit', ':=', '1024K/1024K'),
('30MIN-DIA', 'Acct-Interim-Interval', ':=', '300'),
('30MIN-DIA', 'Mikrotik-Rate-Limit', ':=', '1024K/1024K'),
('2h-UNICO', 'Acct-Interim-Interval', ':=', '300'),
('2h-UNICO', 'Mikrotik-Rate-Limit', ':=', '1024K/1024K'),
('7.5h-MES', 'Acct-Interim-Interval', ':=', '300'),
('7.5h-MES', 'Mikrotik-Rate-Limit', ':=', '1024K/1024K');

Criamos alguns planos para atribuir aos nossos usuários PPPoE e Hotspot. Vamos aos nossos usuários:

INSERT INTO `radcheck` (`username`, `attribute`, `op`, `value`) VALUES
/*Autenticacao de um cliente CPE UBNT WIFI WPA2 EAP */
('cliente5.8@dominio.com.br', 'Cleartext-Password', ':=', 'senha'),
('cliente5.8@dominio.com.br', 'Calling-Station-Id', '==', '00:11:22:33:44:55'),
('cliente5.8@dominio.com.br', 'Service-Type', '==', 'Framed-User'),
('cliente5.8@dominio.com.br', 'Simultaneous-Use', ':=', '1'),
('cliente5.8@dominio.com.br', 'Pool-Name', ':=', 'minhapool'),
('cliente5.8@dominio.com.br', 'Framed-Protocol', ':=', 'PPP'),
('001122334455', 'Cleartext-Password', ':=', 'minhasenha'),
('001122334455', 'Auth-Type', '==', 'EAP'),

/*Autenticacao de um cliente CPE UBNT 2.4 vs WIFI WPA/WPA2 PSK RouterOS */
('cliente2.4@dominio.com.br', 'Cleartext-Password', ':=', 'senha'),
('cliente2.4@dominio.com.br', 'Calling-Station-Id', '==', '55:44:33:22:11:00'),
('cliente2.4@dominio.com.br', 'Service-Type', '==', 'Framed-User'),
('cliente2.4@dominio.com.br', 'Simultaneous-Use', ':=', '1'),
('cliente2.4@dominio.com.br', 'Pool-Name', ':=', 'minhapool'),
('cliente2.4@dominio.com.br', 'Framed-Protocol', ':=', 'PPP'),
('55:44:33:22:11:00', 'Auth-Type', ':=', 'Accept'),
('55:44:33:22:11:00', 'NAS-Port-Type', '==', 'Wireless-802.11');

INSERT INTO `radreply` (`username`, `attribute`, `op`, `value`) VALUES
('55:44:33:22:11:00', 'Mikrotik-Wireless-PSK', ':=', 'senha-psk');
/* A senha PSK fica na radreply */

E por fim vamos alimentar nossa tabela de ippool, como nossos IPs que serão entregue. No cenário fiz 3 pool, minhapool ounde vão ficar os IPs válidos, avisoPool que receberão um bloco de ips diferenciado, por ex. para direcionar os clientes para algum tipo de aviso. E bloqPool para clientes que ficarão bloqueado.

INSERT INTO `radippool` (`pool_name`, `framedipaddress`, `nasipaddress`, `calledstationid`, 
`callingstationid`, `expiry_time`, `username`, `pool_key`) VALUES
('minhapool', '100.64.0.1', '', '', '', NULL, '', '0'),
('minhapool', '100.64.0.2', '', '', '', NULL, '', '0'),
('minhapool', '100.64.0.3', '', '', '', NULL, '', '0'),
('minhapool', '100.64.0.4', '', '', '', NULL, '', '0'),
('bloqPool', '172.16.0.1', '', '', '', NULL, '', '0'),
('bloqPool', '172.16.0.2', '', '', '', NULL, '', '0'),
('bloqPool', '172.16.0.3', '', '', '', NULL, '', '0'),
('bloqPool', '172.16.0.4', '', '', '', NULL, '', '0'),
('avisoPool', '172.16.1.1', '', '', '', NULL, '', '0'),
('avisoPool', '172.16.1.2', '', '', '', NULL, '', '0'),
('avisoPool', '172.16.1.3', '', '', '', NULL, '', '0'),
('avisoPool', '172.16.1.4', '', '', '', NULL, '', '0');

Ainda pode fixar algumas configurações especificadamente ao usuário, vamos a alguns exemplos.

INSERT INTO `radreply` (`username`, `attribute`, `op`, `value`) VALUES
('usuario@dominio.com.br', 'Mikrotik-Rate-Limit', ':=', '2000k/4000k'), /* Setando velocidade */
('usuario@dominio.com.br', 'Framed-IP-Address', ':=', '250.250.0.150'), /* Setando IP Fixo */
('usuario@dominio.com.br', 'Framed-IPv6-Prefix', ':=', '2001:db8:A:B::/64'), /* IPv6 "Wan" */
('usuario@dominio.com.br', 'Mikrotik-Delegated-IPv6-Pool', ':=', '2001:db8:C::/56'); /* IPv6 "Lan" */

Configuração Simples do PPPoE Server no RouterOS (Mikrotik)

/interface pppoe-server server
add authentication=pap,chap disabled=no interface=ether1 keepalive-timeout=30 max-mru=1480 \
 max-mtu=1480 one-session-per-host=yes service-name=PPPoE-Server

/ppp profile
set *0 change-tcp-mss=default dns-server=250.250.0.2,250.250.0.3 local-address=250.250.0.10 

/ppp aaa
set interim-update=5m use-radius=yes

/radius
add address=250.250.250.2 secret="SEU-SECRET" service=ppp,hotspot,wireless

####################
### Wireless PSK ###
####################
/interface wireless security-profiles
add authentication-types=wpa2-psk management-protection=allowed mode=dynamic-keys name=WPA2 \ 
 radius-mac-authentication=yes wpa2-pre-shared-key=3n20oXOPjohONpEK

/interface wireless
set [ find default-name=wlan1 ] security-profile=WPA2

Configuração UBNT AP (10.10.0.2)

Configuração UBNT Cliente EAP 5.8Mhz

Configuração UBNT Cliente PSK 2.4Mhz Conectando no Cartão do MK

Fontes:
https://wiki.freeradius.org/guide/SQL-HOWTO
https://wiki.freeradius.org/modules/Rlm_sql
https://wiki.freeradius.org/modules/Rlm_sqlippool
https://wiki.freeradius.org/modules/Rlm_sqlcounter
https://www.draw.io/ (Gráficos)

O post Servidor FreeRadius com integração MySQL + Autenticação PPPoE & Hotspot VS Mikrotik + Ubiquiti EAP/PSK [Descontinuado] apareceu primeiro em Remontti.