Aviso

Este artigo pode ser distribuído, publicado, impresso e copiado de todas as formas e meios possíveis, desde que se mantenha o nome, a página web e o e-mail do autor no cabeçalho, em local visível, abaixo do título e com a letra maior ou igual a usada no texto.

Meu primeiro contato com o serviço radius foi com uma solução comercial chamada Steel-Belted Radius (http://www.funk.com/radius/), na época ele atendia minhas necessidades. O único problema era que eu não podia compartilhar a base de dados com outras aplicações e isso estava ficando chato: a senha do e-mail era uma, a senha de acesso outra, não dava pra criar formulários de mudança de senha on-line e fazer uma migração de base de dados e mantendo o software era inviável.

Quando decidi migrar para uma solução livre, comecei analisar tecnicamente os produtos do mercado, gostei de dois: freeradius e openradius, porém o freeradius ganhou favoritismo, por que? Você vai saber nesse artigo!

As configurações de hardware não são muito relevantes, um servidor radius não é pesado nem exigente. Seu velho 486 daria pro gasto!

SOFTWARES USADOS NO ARTIGO

• Linux: Slackware 10.0 (instalação Full)
• Freeradius 1.0.1
• MySQL 3.xx ou 4.xx

Esse artigo é uma abordagem completa do serviço radius, tire um tempo para ler e preste atenção! Bons lucros com o conhecimento (aceito gratificações$$!!!).

ftp://ftp.freeradius.org/pub/radius/freeradius-1.0.1.tar.gz

Caso este link esteja quebrado hoje, tente procurar no site www.freeradius.org a versão atual para download ou entre no endereço ftp://ftp.freeradius.org/pub e procure pelo pacote diretamente.

# cd /usr/local/src
# wget ftp://ftp.freeradius.org/pub/radius/freeradius-1.0.1.tar.gz
# tar -xvzf freeradius-1.0.1.tar.gz
# cd freeradius-1.0.1/
# ./configure
# make
# make install

Como você pode ver, na instalação não há segredos, se você se deparar com algum problema na hora de compilar, consulte o comando:

# ./configure –help

para ver opções que possam burlar os erros.

Por exemplo, se ele reclamar a ausência do modulo kerberos, você pode usar a opção –without-krb5 no ./configure para resolver, digo isso pois uma vez encarei esse problema na distribuição Fedora.

O simples ./configure fará com que todos os módulos do freeradius que se comunicam com outras tecnologias como MySQL, LDAP, etc sejam instalados, alguns poderão pedir bibliotecas, mas no Slackware 10 isso não acontece.

Ao usar simplesmente ./configure antes de compilar, ele irá programar o freeradius para ser instalado em /usr/local nas subpastas de sistema, tipo:

• /urs/local/etc -> arquivos de configuração;
• /usr/local/sbin -> comandos do administrador;
• /usr/local/share -> arquivos de dicionário de radius e outros arquivos compartilhados;
• /usr/local/var -> arquivos de pid e logs;

e assim por diante. Então, se nesse artigo eu falar da localização de algum comando ou arquivo de configuração, farei considerando que seu ./configure não alterou o “–prefix” padrão (/urs/local).

Os seguintes comandos serão adicionados ao seu Linux:

• /usr/local/bin/radclient
• /usr/local/bin/radeapclient
• /usr/local/bin/radlast
• /usr/local/bin/radrelay
• /usr/local/bin/radtest
• /usr/local/bin/radwho
• /usr/local/bin/radzap
• /usr/local/bin/rlm_ippool_tool
• /usr/local/bin/smbencrypt

Para o administrador:

• /usr/local/sbin/check-radiusd-config
• /usr/local/sbin/checkrad
• /usr/local/sbin/radiusd
• /usr/local/sbin/radwatch
• /usr/local/sbin/rc.radiusd

Vejamos mais detalhes de como configurá-lo no próximo capítulo.

1 – radiusd.conf

Arquivo de configuração principal responsável pelo daemon do radius e fazer inclusões dos demais arquivos de configuração.

prefix = /usr/local/src
exec_prefix = ${prefix}
sysconfdir = ${prefix}/etc
localstatedir = ${prefix}/var
sbindir = ${exec_prefix}/sbin
logdir = ${localstatedir}/log/radius
raddbdir = ${sysconfdir}/raddb
radacctdir = ${logdir}/radacct
confdir = ${raddbdir}
run_dir = ${localstatedir}/run/radiusd
# variáveis definidas na instalação, essas opções
# foram disponibilizadas para que você não precise
# recompilar para mudar os arquivos de lugar
# você pode usar essas variáveis quando definir o
# valor de algum parâmetro ao longo desse arquivo.

log_file = ${logdir}/radius.log
# arquivo de log principal, nesse arquivo ficarão
# todas as mensagem de erro, tentativas de
# conexão, etc…

libdir = ${exec_prefix}/lib
# pasta de bibliotecas, se elas
# se encontrarem em varias pastas,
# separe as localizações
# por : , tipo: libdir = /usr/lib:/usr/local/lib

pidfile = ${run_dir}/radiusd.pid
# arquivo onde será armazenado o id
# do processo principal do freeradius

user = nobody
group = nobody
# definição do usuário e grupo dos processos filhos do radiusd
# se você não especificar, o usuário que deu partida
# será usado (root), se
# você usar o arquivo /etc/shadow para autenticação,
# defina o grupo como shadow, vale lembrar
# que o usuário que executa o radiusd deve ter permissão
# de escrita no diretório de log

max_request_time = 30
# define o tempo que o processo filho segura o pedido,
# caso o tempo limite seja atingido, o servidor retorna
# acesso negado. Por exemplo: se você define 2 segundos
# e usa um banco de dados mysql sobrecarregado que demora
# 5 segundos para concluir uma pesquisa, seu servidor nunca
# vai dar acesso a ninguém!

delete_blocked_requests = no
# se no parâmetro max_request_time você
# definiu o valor 30 segundos, e o cliente
# perdeu a paciência e enviou outra solicitação sem
# ter concluído a primeira,
# o freeradius não ficara fazendo trabalho
# repetitivo simultaneamente. Se você definir
# esse parâmetro como yes, ao chegar a segunda
# requisição do mesmo cliente com a mesma
# “pergunta”, ele desistirá da primeira para
# atender a nova solicitação.

cleanup_delay = 5
# esse valor funciona da seguinte maneira:
# se o NAS ou RAS enviou uma pergunta e
# a resposta foi perdida na rede, o NAS tornará
# fazer a pergunta, todo o processo de autenticação
# será realizado novamente. Para evitar isso o freeradius
# manter a resposta no cache pelo tempo definido aqui
# (em segundos), assim, se o pacote resposta for perdido
# e a pergunta for repetida, a resposta será imediata,
# usando assim o mínimo de processamento.

max_requests = 1024
# define o número máximo de
# requisições que o freeradius pode atender
# simultaneamente, somando todas as requisições
# atendidas pelos processos filhos, assim,
# se você tem 4 processo filhos, cada um
# poderá atender 256 perguntas simultaneamente
# ATENÇÃO: as respostas cacheadas pela opção
# cleanup_delay são contabilizadas. Se você colocou
# cleanup_delay com um valor alto, seu radius
# ficará exposto a um DOS

bind_address = *
# isso fará o freeradius escutar em
# um endereço especifico, * inclui todos
# os endereços ip do host, você pode
# usar um FQDN, mas antes tenha certeza
# de que a resolução de dns estará disponível
# no momento em que o servidor radius inicia

port = 0
# porta de escuta. Equipamentos antigos tem a porta
# 1645 como padrão de autenticação e 1646 como
# contabilidade. A RFC 2138 mudou essa porta para
# 1812 autenticação e 1813 contabilidade. Equipamentos
# novos provavelmente terá essa porta como padrão.
# 0 (zero) fará com que a porta seja pesquisada
# em /etc/services, esse parâmetro pode ser
# sobreposto pela opção -p do comando radiusd

#listen {
# ipaddr = *
# endereço ip ou FQDN, mesmos critérios
# usados em bind_address
# port = 0
# porta de escuta, mesmos critérios
# usados em port

#  Type of packets to listen for.
#  Allowed values are:
#    auth    listen for authentication packets
#    acct    listen for accounting packets
#
# type = auth
# tipo de escuta:
# auth -> autenticação
# acct -> contabilidade
#}
# Se você quiser que o freeradius escute
# a porta de autenticação em um ip, e
# a porta de contabilidade em outro, ou
# em postas distantes no mesmo ip, o
# modelo acima de listagem será útil
# Esse recurso apareceu a partir da versão
# 1.0 e resolve o problema se você
# tem equipamentos novos e antigos
# servidos pelo mesmo radius

hostname_lookups = no
# define se o nome DNS dos clientes
# será pesquisado a partir do ip. Se definir como yes,
# toda vez que uma requisição chegar de
# um endereço ip, o freeradius irá consultar
# o dns para usar o nome no log de atividades.
# o valor no é a melhor opção, não sobrecarrega
# o servidor DNS

allow_core_dumps = no
# ative essa opção para depurar erros no
# servidor, caso contrario deixe como está

regular_expressions = yes
extended_expressions = yes
# ativa ou desativa expressões regulares
# nos parâmetros dos pacotes, desativar
# é uma boa idéia embora o padrão seja
# yes

log_stripped_names = no
# registra nos logs os dados completos do
# campo User-Name do pacote de autenticação,
# se definido como yes, do jeito que chegar,
# será usado.

log_auth = no
# deseja logar atividades de autenticação?
# se você tem milhares de clientes logando
# simultaneamente, significa
# que seu log vai crescer muito com essa
# opção ativa. Eu sempre coloco yes pois
# fica fácil e rápido descobrir por que
# certo cliente (leigo) não consegue autenticar

log_auth_badpass = no
# Logar senhas quando a autenticação falhar?
# embora seja útil para dar suporte – usuário
# digitando senha incorretamente (branco, maiúsculas, etc…),
# a privacidade do usuário fica reduzida e uma brecha de segurança,
# todas as senhas serão registradas no log

log_auth_goodpass = no
# idêntica a opção acima, porém se
# aplica para autenticações bem sucedidas.

usercollide = no

lower_user = no
lower_pass = no
# essas duas opções são muito importantes:
# se o usuário deixar o CapsLock ligado,
# significa que não conseguirá se autenticar
# e isso significa uma insatisfação ou uma
# chamada desnecessária no suporte.
# Temos 3 opções: after, before e no
# suponhamos que eu informe meu login: PatrickBrandao
# “after” fará com que a autenticação
# seja primeiro testada com o valor
# informado, se falhar, aplica um lowercase
# nos valores e tenta novamente. Sendo a primeira
# tentativa com “PatrickBrandao” e a segunda com “patrickbrandao”
# “before” fará com que um lowercase seja
# aplicado antes de pesquisar a base de
# dados, que receberá “patrickbrandao”
# “no” desativa esse efeito passando para
# a base de dados o mesmo valor recebido: “PatrickBrandao”

nospace_user = no
nospace_pass = no
# as duas opções acima
# servem para retirar espaços de nome
# de usuário e senha. Os seus clientes
# podem, sem perceber, colocar
# um espaço no final ou no começo
# das credenciais, o que gera uma
# chamada desnecessária no suporte técnico
# três valores poderão ser escolhidos:
# after, before e no

checkrad = ${sbindir}/checkrad
# comando ao usar para checar conexões simultâneas

# sessão de segurança —————————-
security {
max_attributes = 200
# define o número máximo de atributos
# num pacote enviado para o servidor.
# um número muito baixo faria o servidor
# negar pacotes, número muito alto deixará
# o servidor vulnerável. O atacante pode emitir
# um pedido com um número exagerado
# de parâmetros e esgotar os recursos de memória

reject_delay = 1
# define o tempo de espera antes de enviar
# uma resposta de acesso negado.
# essa opção proteje seu servidor
# contra ataques de força bruta
# Escolha de 0 a 5, 0 (zero) fará com que
# a resposta seja enviada imediatamente

status_server = no
# permite ou nega o envio de pacotes
# de status do usuário. Não é muito importante
# mas alguns NAS’s com keep-alive podem
# precisar desse recurso para checar o
# status de uma sessão.
}

# sessão de proxy ——————————
proxy_requests = yes
$INCLUDE ${confdir}/proxy.conf

# configuração de clientes NAS —————

$INCLUDE ${confdir}/clients.conf
# quando falo de clientes NAS não
# estou me referindo a seus clientes de
# conexão discada, mas sim aos dispositivos
# em contato com eles que se encarregam de
# procurar o radius para validar o usuário,
# esses equipamentos podem ser RAS como
# cyclades, cisco, etc… ou mesmo serviços
# em qualquer servidor que se baseia numa
# autenticação com radius

# sessão de snmp —————————-

snmp = no
$INCLUDE ${confdir}/snmp.conf
# ativa o suporte a monitoramento por snmp
# no freeradius

# configuração de processos filhos ————————
thread pool {
start_servers = 5
# número de processos filhos a serem criados quando
# o serviço for iniciado

max_servers = 32
# número máximo de processos filhos
# atendendo solicitações

min_spare_servers = 3
max_spare_servers = 10
# regula o número de processos para manter
# um bom desempenho

max_requests_per_server = 0
# número máximo de solicitações feitas
# a um processo filho antes de ser destruído
# 0 (zero) para infinito, mas não recomendável
# pois um processo filho pode consumir recursos
# que nunca irá liberar, 250 é um bom valor.
}

# sessão de definição de módulos ———————–
modules {
# formato:
#    name [ instance ] {
#        config_item = value
#        …
#    }
# name -> se refere ao nome do
# modulo rlm_?????, muitos módulos
# são fornecidos com o freeradius, esse
# recurso permite que você crie seus próprios
# módulos.

pap {
encryption_scheme = crypt
}
# define o tipo de
# criptografia usada na autenticação PAP
# valores disponíveis:
#  clear: sem criptografia, texto plano
#  crypt: criptografia do unix
#  md5: criptografia MD5
#  sha1: criptografia SHA1
# padrão: crypt

chap {
authtype = CHAP
}
# adiciona suporte a autenticações
# usando CHAP

pam {
pam_auth = radiusd
}
# suporte PAM dos sistemas unix, configura
# o pamd em /etc/pam.d/ para usar esse tipo
# de autenticação

# autenticação baseada nas credenciais do sistema
# /etc/passwd e /etc/shadow
unix {
cache = no
# criar caches de dados de login?
# habilitar essa opção pode melhorar
# o desempenho se você tem muitos
# usuários de sistema

cache_reload = 600
# tempo em segundos para recarregar
# o cache de logins do sistema

# define a localização dos seus
# arquivos de autenticação de sistema
# encontra-se comentado, usando o
# valor padrão
#
#    passwd = /etc/passwd
#    shadow = /etc/shadow
#    group = /etc/group

radwtmp = ${logdir}/radwtmp
}

#  Extensible Authentication Protocol
$INCLUDE ${confdir}/eap.conf

# Micro$oft CHAP authentication
# esses módulos suportam MS-CHAP e MS-CHAPv2
mschap {
authtype = MS-CHAP
# protocolo M$ usado
#use_mppe = no
#require_encryption = yes
#require_strong = yes
#with_ntdomain_hack = no
#ntlm_auth = “/path/to/ntlm_auth –request-nt-key –username=%{Stripped-User-Name:-%{User-Name:-None}} –challenge=%{mschap:Challenge:-00} –nt-response=%{mschap:NT-Response:-00}”
}

# Lightweight Directory Access Protocol (LDAP)
# permite usa autenticação LDAP (Auth-Type := LDAP)
ldap {
server = “ldap.your.domain”
# identity = “cn=admin,o=My Org,c=UA”
# password = senhadnaqui
basedn = “o=My Org,c=UA”
filter = “(uid=%{Stripped-User-Name:-%{User-Name}})”
# base_filter = “(objectclass=radiusprofile)”

start_tls = no
# coloque yes se deseja usar tls para criptografar
# os dados nas conexões com o LDAP e
# configure e descomente os valores abaixo
# tls_cacertfile    = /path/to/cacert.pem
# tls_cacertdir        = /path/to/ca/dir/
# tls_certfile        = /path/to/radius.crt
# tls_keyfile        = /path/to/radius.key
# tls_randfile        = /path/to/rnd
# tls_require_cert    = “demand”

# default_profile = “cn=radprofile,ou=dialup,o=My Org,c=UA”
# profile_attribute = “radiusProfileDn”
access_attr = “dialupAccess”

dictionary_mapping = ${raddbdir}/ldap.attrmap
# define o arquivo de mapas de atributos
# do seu diretorio
ldap_connections_number = 5

# password_header = “{clear}”
# password_attribute = userPassword
# groupname_attribute = cn
# groupmembership_filter = “(|(&(objectClass=GroupOfNames) (member=%{Ldap-UserDn})) (&(objectClass=GroupOfUniqueNames) (uniquemember=%{Ldap-UserDn})))”
# groupmembership_attribute = radiusGroupName
timeout = 4
timelimit = 3
net_timeout = 1
# compare_check_items = yes
# do_xlat = yes
# access_attr_used_for_allow = yes
}

# —————————————-

# modulo Realm, para proxy
#  ’realm/username’
realm IPASS {
format = prefix
delimiter = “/”
ignore_default = no
ignore_null = no
}
#  ’username@realm’
realm suffix {
format = suffix
delimiter = “@”
ignore_default = no
ignore_null = no
}
#  ’username%realm’
realm realmpercent {
format = suffix
delimiter = “%”
ignore_default = no
ignore_null = no
}
#  ’domain\user’
realm ntdomain {
format = prefix
delimiter = “\\”
ignore_default = no
ignore_null = no
}

checkval {
item-name = Calling-Station-Id
check-name = Calling-Station-Id
data-type = string
#notfound-reject = no
}

# reescrita de pacotes. Usado para autorização e contabilidade
#attr_rewrite sanecallerid {
#    attribute = Called-Station-Id
# may be “packet”, “reply”, “proxy”, “proxy_reply” or “config”
#    searchin = packet
#    searchfor = “[+ ]“
#    replacewith = “”
#    ignore_case = no
#    new_attribute = no
#    max_matches = 10
#    ## If set to yes then the replace string will be appended to the original string
#    append = no
#}

preprocess {
huntgroups = ${confdir}/huntgroups
hints = ${confdir}/hints
with_ascend_hack = no
ascend_channels_per_line = 23
with_ntdomain_hack = no
with_specialix_jetstream_hack = no
with_cisco_vsa_hack = no
}

files {
usersfile = ${confdir}/users
acctusersfile = ${confdir}/acct_users

compat = no
}

detail {
detailfile = ${radacctdir}/%{Client-IP-Address}/detail-%Y%m%d
detailperm = 0600
}
# detail auth_log {
# detailfile = ${radacctdir}/%{Client-IP-Address}/auth-detail-%Y%m%d
# detailperm = 0600
# }
# detail reply_log {
# detailfile = ${radacctdir}/%{Client-IP-Address}/reply-detail-%Y%m%d
# detailperm = 0600
# }
# detail pre_proxy_log {
# detailfile = ${radacctdir}/%{Client-IP-Address}/pre-proxy-detail-%Y%m%d
# detailperm = 0600
# }
# detail post_proxy_log {
# detailfile = ${radacctdir}/%{Client-IP-Address}/post-proxy-detail-%Y%m%d
# detailperm = 0600
# }
acct_unique {
key = “User-Name, Acct-Session-Id, NAS-IP-Address, Client-IP-Address, NAS-Port”
}

#  Para Postgresql, use:        ${confdir}/postgresql.conf
#  Para MS-SQL, use:         ${confdir}/mssql.conf
#  For Oracle, use:         ${confdir}/oraclesql.conf
#
$INCLUDE  ${confdir}/sql.conf
# inclusão de arquivo de configuração contendo
# módulos de autenticação, sessão e contabilidade
# controlados em banco de dados SQL

# módulos responsáveis por controlar usuários conectados
# para evitar conexão simultânea quanto esta é
# usada
radutmp {
filename = ${logdir}/radutmp
username = %{User-Name}
case_sensitive = yes
check_with_nas = yes
perm = 0600
callerid = “yes”
}
radutmp sradutmp {
filename = ${logdir}/sradutmp
perm = 0644
callerid = “no”
}
attr_filter {
attrsfile = ${confdir}/attrs
}
counter daily {
filename = ${raddbdir}/db.daily
key = User-Name
count-attribute = Acct-Session-Time
reset = daily
counter-name = Daily-Session-Time
check-name = Max-Daily-Session
allowed-servicetype = Framed-User
cache-size = 5000
}
always fail {
rcode = fail
}
always reject {
rcode = reject
}
always ok {
rcode = ok
simulcount = 0
mpp = no
}
expr {
}
digest {
}
exec {
wait = yes
input_pairs = request
}
exec echo {
wait = yes
program = “/bin/echo %{User-Name}”
input_pairs = request
output_pairs = reply
#packet_type = Access-Accept
}

ippool main_pool {
range-start = 192.168.1.1
range-stop = 192.168.3.254
netmask = 255.255.255.0
cache-size = 800
session-db = ${raddbdir}/db.ippool
ip-index = ${raddbdir}/db.ipindex
override = no
maximum-timeout = 0
}

}

# controle de acesso, sessão e contabilidade ———–

# sessão instantiate – inicia módulos, se não for usar, não inicie.
instantiate {
exec
expr
#    daily
}

# sessão authorization – controla os módulos
# responsáveis por autorizar o acesso das
# requisições

authorize {
preprocess
#    auth_log
#    attr_filter
chap
mschap
#    digest
#    IPASS
#    suffix
#    ntdomain
#    eap
#    files
sql
#    etc_smbpasswd
#    ldap
#    daily
#    checkval
}

# Sessão authentication
# responsável por conferir o tipo de autenticação usado
authenticate {
Auth-Type PAP {
pap
}
Auth-Type CHAP {
chap
}
Auth-Type MS-CHAP {
mschap
}
#    digest
#    pam
#    unix
#    Auth-Type LDAP {
#        ldap
#    }
#    eap
}

#  Sessão Pre-accounting.  Decide qual tipo de contabilidade usar
preacct {
#    preprocess
#    acct_unique
#  home server as authentication requests.
#    IPASS
#    suffix
#    ntdomain

#
#  Read the ‘acct_users’ file
#    files
}

# Sessao Accounting.  Registra dados de contabilidade
accounting {
#    detail
#    daily
#    unix
#    radutmp
#    sradutmp
#    main_pool
sql
#    pgsql-voip
}

# Controle de sessão
# quando se faz o controle de sessão para
# evitar conexões simultâneas (impede o
# nome de usuário de se conectar varias vezes de
# locais diferentes ao mesmo tempo com o mesmo login)
session {
#    radutmp
#    sql
}

post-auth {
#    main_pool
#    reply_log
#    sql
#    Post-Auth-Type REJECT {
#        insert-module-name-here
#    }
}

pre-proxy {
#    attr_rewrite
#    pre_proxy_log
}

post-proxy {
#    post_proxy_log
#    attr_rewrite
#    attr_filter
eap
}
# fim radiusd.conf

2 – clients.conf

Responsável pela lista de clientes NAS que desfrutam do serviço radius.

client 127.0.0.1 {
secret = raioceleste
# segredo do servidor. Somente
# os NAS’s que conhecem esse
# segredo poderão fazer pedidos
# de autenticação. OBRIGATÓRIO

shortname = localhost
# nome do cliente. Normalmente
# você pode colocar uma parte do FQDN
# esse nome é usado no arquivo de log
# e referencias de contabilidade
# OBRIGATÓRIO

nastype = other
# define o tipo de NAS ó cliente.
# Muito importante pois um
# NAS especifico pode ter campos
# definidos nos arquivos de dicionários
# de parâmetros. OPCIONAL. Padrão: other
}

# o exemplo acima trata um cliente
# em especifico, mas você pode
# abrir uma rede inteira no freeradius

client 192.168.10.0/24 {
secret = raioceleste10
shortname = intranet-10
}

# Importante: se seu NAS não estiver cadastrado
# aqui, possivelmente você vai ver no arquivo
# de log:
# Thu Aug 12 17:06:16 2004 : Error: Ignoring request from unknown client 192.168.10.24:41747
#
# sempre que adicionar um novo cliente, você terá que reiniciar o freeradius
# fim clients.conf

Certifique-se de que no arquivo radiusd.conf, a seguinte linha está declarada:

server = “localhost”
# diz ao freeradius em qual
# host está o servidor mysql

login = “root”
# define o nome de usuário registrado no mysql

password = “senhadologinaqui”
# senha do usuário definido no parâmetro “login”

radius_db = “radius”
# nome do banco de dados que contem
# as tabelas

# abaixo deste texto (arquivo truncado aqui) se encontram definições de SQL para
# pesquisa de dados, não altere, ao menos
# que tenha um propósito
# ……
# ….
}

src/modules/rlm_sql/drivers/rlm_sql_mysql

Se você descompactou em /usr/local/src, o caminho completo é:

/usr/local/src/freeradius-1.0.1/src
/modules/rlm_sql/drivers/rlm_sql_mysql

Dentro desta pasta existe um arquivo chamado db_mysql.sql contendo todos os comandos para criar as tabelas. Crie o banco de dados com o comando:

# mysqladmin -psenharoot create radius

E crie as tabelas com o comando:

# mysql -psenharoot radius < db_mysql.sql

Agora edite o radiusd.conf, vamos configurá-lo para autenticar os dados no MySQL. Procure no final do arquivo pela sessão “authorize” e adicione “sql”, ficando assim:

Próximo passo é registrar a contabilidade dos acessos, muito útil para provedores que tem planos limitados de horas. Vá até a sessão “accounting” e adicione “sql”, ficando assim:

Um recurso interessante é o controle de conexão simultânea. Isso impede que um usuário passe suas credencias (login/senha) para amigos e todos usem ao mesmo tempo, dando “preju”. Na sessão “session” adicione “sql”, ficando assim:

# mysql -psenharoot radius

Criar usuário:

mysql> INSERT INTO radcheck (username, attribute, op, value)
mysql> VALUES (‘joao’, ‘Password’, ‘==’, ‘senhasecreta’);

Criar grupo com direito a uma conexão chamado ‘sessaounica’:

mysql> INSERT INTO radgroupcheck (groupname, attribute,
mysql> op, value) VALUES (‘sessaounica’, ‘Simultaneous-Use’,
mysql> ‘:=’, 1);

Inserir joao nesse grupo:

mysql> INSERT INTO usergroup (username, groupname) VALUES (‘joao’, ‘sessaounica’);

Pronto. João agora não pode passar seu login pra ninguém, senão ficará sem acesso! Para conexões ISDN 128k, crie um grupo de dupla permissão, pois senão o segundo canal não conseguirá conectar-se. Veja como aparece no log, uma tentativa de conexão simultânea após o usuário já estar conectado de outro lugar:

Auth: Login OK: [joao/senhasecreta] (from client pr4k port 326 cli 31555xxxx)
Auth: Multiple logins (max 1) : [joao/senhasecreta] (from client pr4k port 315 cli 31552xxxx)

Acontece, de vez em quando, do usuário ficar “agarrado” no radius. Ele é desconectado do RAS ou NAS, porém o radius não da baixa na sessão, os motivos podem ser, principalmente, perda do pacote no caminho até o radius, problema muito comum para provedores que lidam com ADSL de outras operadoras. A próxima vez que o usuário tenta logar, o acesso é negado – o servidor radius pensa que é sessão simultânea. Para resolver esse problema, sempre que um usuário (joao por exemplo) ficar “agarrado”, você libera ele com a SQL:

mysql> DELETE FROM radacct WHERE username = ‘joao’ AND acctsessiontime = 0 ORDER BY radacctid DESC LIMIT 1;

A desvantagem é que João terá que solicitar suporte técnico para ter o problema resolvido!

Quando você cria o banco de dados MySQL do radius a partir da DDL fornecida nos fontes do módulo, as seguintes tabelas são criadas:

• radacct – contém informações de contabilidade dos usuários, descrita no capítulo “Extrato de horas”;
• radcheck – contém a lista de atributos que serão usados para autenticar um usuário específico. O atributo mais necessário para que o usuário tenha acesso seguro é “Password”, exemplo:

  mysql> SELECT UserName, Attribute, op, Value FROM radcheck WHERE UserName = ‘joao’;

  UserName         |    Attribute         |   op   | Value
  -----------------------------------------------------------
  joao             |    Password          |  ==   | senhasecreta
  joao             |    NASIPAddress      |  ==   | 192.168.0.1
  -----------------------------------------------------------

  Quando João tentar se autenticar, será checado os dois parâmetros, Password e NASIPAddress, só será retornado um Access-Accept se a senha estiver certa e a pergunta vier do NAS 192.168.0.1. Muitos parâmetros podem ser adicionados para limitar a fonte de acesso, até mesmo restringir um usuário dial-up a um único número de telefone (parâmetro CallingStationID)!

• radreply – contém uma lista de atributos devolvidos ao usuário. Estes atributos só serão enviados numa resposta diferente de Access-Reject, parâmetros de resposta influenciam na conexão do usuário, você poderá interagir com o NAS (ou RAS), desde que ele tenha flexibilidade para os valores retornados (adquira o manual do seu RAS, é muito interessante saber o que pode ser feito nele pelas respostas do radius).

  mysql> SELECT UserName, Attribute, op, Value FROM radreply WHERE UserName = ‘joao’;

  UserName  | Attribute         |  op  | Value
  ----------------------------------------------------------
  joao      | Reply-Message     |  ==  | Bem Vindo Sr. Diretor!
  joao      | Framed-IP-Address |  ==  | 10.0.0.121
  joao      | Framed-IP-Netmask |  ==  | 255.255.255.0
  ----------------------------------------------------------

  Com os registros acima, João receberá uma mensagem de boas vindas e o endereço ip 10.0.0.121/24.

• usergroup – Bom, seria muito desagradável administrar centenas de usuários inserindo atributos em um por um. Você pode criar grupos de checagem e inserir os usuários neles. A tabela usergroup serve exatamente para isso: você adiciona grupos de checagem e retorno nas tabelas radgroupcheck e radgroupreply respectivamente, e, ao criar um relacionamento entre o grupo e a usuário nessa tabela, os parâmetros do grupo são usados nas operações com o usuário.

  mysql> SELECT UserName, GroupName FROM usergroup;

  UserName     |    GroupName
  ----------------------------------
  joao         |    Diretoria
  patrick      |    Admin
  anamaria     |    Dialup
  kairan       |    Dialup
  milene       |    Dialup
  marcos       |    Velox
  ----------------------------------

• radgroupcheck – contém informações dos grupos referenciados em usergroup para checagem de parâmetros:

  mysql> SELECT GroupName, Attribute, op, Value FROM radgroupcheck ORDER BY GroupName;

  GroupName   | Attribute      |  op  | Value
  ---------------------------------------------------
  Admin       | NAS-IP-Address |  ==  |  192.168.0.1
  Dialup      | NASPortType    |  ==  |  Async
  Diretoria   | NAS-IP-Address |  ==  |  192.168.0.1
  Velox       | NASPortType    |  ==  |  Virtual
  ---------------------------------------------------

  Acima, podemos ver que: Quem é do grupo Admin e Diretoria só pode se autenticar se a conexão for intermediada pelo NAS 192.168.0.1. Quem é do grupo Dialup só pode autenticar se o tipo da porta (NASPortType) for assíncrona. E assim vai!

• radgroupcheck – contém informações dos grupos referenciados em usergroup para retorno de parâmetros:

  mysql> SELECT GroupName, Attribute, op, Value FROM radgroupreply ORDER BY GroupName;

  GroupName | Attribute      |  op   | Value
  -------------------------------------------------------------------
  Admin     | Reply-Message  |  ==   | Bem vindo Manda-chuva!
  Dialup    | Reply-Message  |  ==   | Um site de cada vez por favor.
  Diretoria | Reply-Message  |  ==   | Acesso bloqueado as 19:00
  Velox     | Reply-Message  |  ==   | É proibido compartilhar conexão
                                       com terceiros
  --------------------------------------------------------------------

• radpostauth – salva informações de respostas enviadas para os usuários. Com ele você pode tirar um relatório das tentativas de acesso, por exemplo:

  mysql> SELECT user, pass, reply, date FROM radpostauth WHERE user = ‘joao’;

  user  | pas          | reply          | date
  -------------------------------------------------------
  joao  | senhasecreta | Access-Accept  |  20041228125413
  joao  | senhasecreta | Access-Accept  |  20041229182318
  -------------------------------------------------------

  Acima, o relatório diz que o usuário autenticou com sucesso nas duas tentativas. O campo date é timestamp: ano, mês, dia, hora, minuto e segundo.

Agora que você já sabe como manipular o retorno e a autorização dos usuários, leia o manual do seu NAS e veja quais parâmetros ele aceita e crie seus próprios grupos de acesso. Boa sorte!

Edite sql.conf e você verá as seguintes linhas:

Mudando o driver de banco de dados, defina os valores apropriados às variáveis:

• server
• login
• password
• radius_db

As demais podem permanecer inalteradas. Se você mudar a estrutura de algumas SQL’s do sql.conf para algum propósito particular, recomendo que faça testes manuais no banco de dados para se certificar que estão funcionando. Digo isso porque uma vez alterei algumas e meu servidor radius estava se comportando de forma estranha, no log não aparecia nada, quando passei um pente fino, era uma SQL mal escrita.

É muito interessante manter os dados do cliente no banco de dados, pois ele pode retornar a ativa um dia. Assim, quando ele ligar dizendo:

- Por favor, quero quitar minha dívida e ter meu acesso restabelecido.

Você não terá o problema de ter que colocar senha em branco ou uma senha fácil e pedí-lo para mudar na página. A maioria dos clientes desconfia que os provedores têm acesso à senha deles.

Minha experiência diz também que a maioria dos usuários que retornam a usar o serviço de um provedor, vão optar por usar o mesmo login e senha que usavam antes de serem suspensos, principalmente o e-mail.

Por isso, manter os dados dele no db vai possibilitar essa vantagem.

Como você já viu, se estiver usando uma base de dados, uma SQL será emitida para extrair dados de login do db, o que vamos fazer é manipular essa SQL e alterar a estrutura do banco para suportá-la.

1 – Altere a estrutura da tabela radacct no seu db radius adicionando uma coluna chamada “enable”, essa coluna poderá suportar dois valores: Y ou N.

O padrão será Y, quanto o usuário for desabilitado, o valor deve mudar para N. Acrescente a nova coluna com o seguinte comando no CLI no MySQL:

mysql> ALTER TABLE radacct ADD enable enum(‘Y’,'N’) NOT NULL DEFAULT ‘Y’;

2 – Altere a SQL para chegar o status do usuário no campo “enable”. No arquivo /usr/local/etc/raddb/sql.conf, procure pela linha:

authorize_check_query = “SELECT id, UserName, Attribute, Value,op FROM ${authreply_table} WHERE Username = ‘%{SQL-User-Name}’ ORDER BY id”

E acrescente a cláusula WHERE a seguinte comparação:

AND enable = ‘Y’

Ficando assim:

mysql> UPDATE radcheck SET enable = ‘N’ WHERE username = ‘joao’;

Se ele pagar, você ativa com a SQL:

mysql> UPDATE radcheck SET enable = ‘Y’ WHERE username = ‘joao’;

authorize {
chap
mschap
files
}

authenticate {
Auth-Type PAP {
pap
}
Auth-Type CHAP {
chap
}
unix
}

Usando desta maneira, o método usado para inserir usuários no radius é o mesmo para adicionar um usuário ao sistema: usando os comandos “useradd” ou a ferramenta de administração usada na sua distribuição Linux. Assim, qualquer usuário que puder se autenticar no sistema também poderá se autenticar no radius, mas caso isso não for seguro, você pode editar no radiusd.conf, as opções do módulo “unix” e apontar para novos arquivos passwd e shadow.

Eu costumo usa duas ferramentas para me certificar se um servidor radius presta:

1 – radtest

O comando radtest acompanha o pacote do freeradius e é instalado com os demais aplicativos. Embora sirva apenas para testar autenticação e retorno de parâmetros, é uma ferramenta muito útil em um Linux.

Sintaxe:

radtest USUÁRIO SENHA SERVIDOR:PORTAAUTH PORTANAS SEGREDORADIUS

onde:

• USUÁRIO, SENHA – o óbvio, login do usuário e senha;
• SERVIDOR – endereço ip ou FQDN do servidor radius;
• PORTAAUTH – porta no SERVIDOR onde o serviço radius atende solicitações de autenticação;
• PORTANAS – porta do NAS, pode ser uma porta eletrônica (número do modem) ou virtual, apenas para controle. Para testes, coloque qualquer valor numérico.
• SEGREDORADIUS – quando você faz uma solicitação de autenticação, seu endereço ip tem que estar cadastrado no arquivo clients.conf do servidor num par de IP/SEGREDO. O ip será descoberto pelo SERVIDOR através do parâmetro NAS-IP-Address, o segredo você tem que informar aqui.

Após uma solicitação, o radtest informa quais parâmetros está enviando para o servidor, seguido do retorno.

Exemplo:

# radtest joao senhasecreta 127.0.0.1:1645 0 reioceleste
Sending Access-Request of id 176 to 127.0.0.1:1645
User-Name = “joao”
User-Password = “senhasecreta”
NAS-IP-Address = localhost
NAS-Port = 0

rad_recv: Access-Accept packet from host 127.0.0.1:1645, id=176, length=58
Reply-Message = “Bem vindo chefe!”

Como você pode ver acima, o servidor retornou uma resposta de acesso aceito “Access-Accept” e um parâmetro que eu configurei em radreply para o usuário joao (“Reply-Message”).

2 – NTRadPing

Ferramenta muito boa, para Windows (triste!), mas serve para testar todos os tipos de pacotes radius: Autenticação, Autorização, Contabilidade e Status. Como ele tem uma interface gráfica, não preciso ficar ensinando, a tela é bem obvia, dê uma olhada abaixo, o mesmo teste feito no radtest com o NTRadPing:

• http://www.mastersoft-group.com/download/

ou direto:
http://www.mastersoft-group.com/download/step2.asp?frm_prod=9

• instale zlib
• instale libjpeg
• instale gd
• instale mrtg

Por padrão, os programas do mrtg são instalados em /usr/local/mrtg-2/bin.

Criar gráficos com dados do banco de dados do radius é muito importante. Você pode ter o controle de quantas sessões são abertas em horários diferentes, ter o controle do número de registros no banco de dados, etc.

Por exemplo: Implementando um simples gráfico de mrtg para monitorar o número de conexões abertas, pude saber que tenho muitas linhas telefônicas sobrando, podendo bolar uma estratégia para compensar os gastos. É importante também monitorar a quantidade de banda que é consumida pelos clientes dial-up, entre outros valores que podem decidir a expansão do negócio.

Considerando que você vai armazenar os gráficos na pasta /www/graficos que está publicada no seu Apache.

Gráfico de sessões abertas:

Crie o arquivo /www/graficos/sessoes.conf com o conteúdo:

Title[sessoes] : Radius – Sessões abertas
MaxBytes[index] : 10000
AbsMax[index] : 20000
Options[index]: growright,noinfo,gauge
Target[index]: `/etc/mrtg/radius-sessoes.sh`
PageTop[index]: Radius
ShortLegend[index]: Sessões
YLegend[index]: Sessões/hora
Legend1[index]: Total de sessões
WithPeak[index]: ymwd
XSize[index]: 350
YSize[index]: 150
# fim

#————–
número<quebra de linha>
número<quebra de linha>
#————–

Exemplo:

# ./etc/mrtg/radius-sessoes.sh
30
0

Nesse caso, o número 30 é o número de sessões que estão abertas. No script /etc/mrtg/radius-sessoes.sh, coloque o seguinte conteúdo:

servidormysql=localhost
usuario=root
senha=mysql2005
banco=radius
tabelaacct=radacct

sessoes=`mysql -N -p$senha -h $servidormysql -u $login $banco -e “SELECT count(*) FROM $tabelaacct WHERE AcctStopTime = 0;”`

echo $sessoes
echo 0
# fim

# chmod +x /etc/mrtg/radius-sessoes.sh

O comando para gerar o gráfico será:

# /usr/local/bin/mrtg-2/bin/mrtg /www/graficos/sessoes.conf

As 3 primeiras vezes que você o executar, erros serão gerados, mas não se preocupe, certifique-se de que novos arquivos foram gerados em /www/graficos/, o arquivo sessoes.html nessa pasta mostra os gráficos que começaram a ser exibidos uns 15 minutos depois.

Coloque o comando para gerar os gráficos de 5 em 5 minutos pelo crontab:

Em muitas empresas, provedores, etc é importante relatar o uso do serviço (conexão a internet) de forma legível e acessível. Os provedores de acesso, por exemplo, tem planos de acesso limitados a certa quantia de horas e quando o usuário abusa, uma multa é cobrada sobre o excedente.

Quando uma quantia é cobrada do usuário, como cliente, ele tem o direito de saber pelo que está pagando, então é hora de dar contas.

O freeradius, junto com os módulos de SQL, salva os dados de sessão na tabela radacct(contabilidade), cada registro nesta tabela é composto pelas seguintes colunas:

• RadAcctId -> número único de identificação do registro;
• AcctSessionId -> caracteres de identificação da sessão;
• AcctUniqueId -> número único da sessão;
• UserName -> nome de usuário;
• Realm -> Realm usado;
• NASIPAddress -> RAS (ou NAS) que participou da autenticação e contabilidade;
• NASPortId -> porta do NAS usada;
• NASPortType -> tipo da porta (Async{56kbps}, ISDN {64 ou 128kb}, Virtual {adsl e outros});
• AcctStartTime -> data hora do início da sessão, hora em que a conexão foi estabelecida;
• AcctStopTime -> data hora do fim da sessão, hora em que a conexão foi encerrada;
• AcctSessionTime -> tempo da sessão em segundos (diferença entre AcctStopTime e AcctStartTime);
• AcctAuthentic -> Protocolo de autenticação usado (ex.: RADIUS);
• ConnectInfo_start -> informações da conexão quando ela se iniciou, informando o protocolo eletrônico, a velocidade de upload, velocidade de download, etc… (ex.: V90 31200 52000 LAPM/V42Bis);
• ConnectInfo_stop -> informações da conexão quando ela terminou. Vide ConnectInfo_start
• AcctInputOctets -> quantidade de dados recebidos;
• AcctOutputOctets -> quantidade de dados enviados;
• Os dois campos acima são, sem dúvida, a melhor maneira de controlar o volume de dados de um cliente;
• CalledStationId -> Em caso de RAS (cyclades, cisco, etc…) com diversos números, informa o número que o cliente discou;
• CallingStationId -> Número do telefone do cliente. Eu amo esse campo! Com ele, você acha o cliente em qualquer lugar! Tem como você saber de onde o cliente anda conectando, se ele ficar usando em casa e no trabalho, etc;
• AcctTerminateCause -> Informa o motivo da desconexão. Os valores mais comuns são:
  • Host-Request = o usuário (ou algum software no PC dele) requisitou a desconexão.
  • Lost-Carrier = sinal de linha perdido ou muita interferência na transmissão. Ocorre muito quando há varias extensões na mesma linha telefônica ou a presença de umidade, gato, etc.

    Veja mais detalhes sobre motivos de desconexão em /usr/local/share/freeradius/dictionary.

  • ServiceType = tipo de serviço.
  • FramedProtocol = protocolo usado (ex.: PPP).
  • FramedIPAddress = endereço ip concedido ao cliente durante a sessão. Se a polícia federal der uma batida aí, você vai poder informar pelo endereço ip, de qual telefone partiu a conexão do hacker!
  • AcctStartDelay = tempo demorado para registrar o início da sessão.
  • AcctStopDelay = tempo demorado para registrar o fim da sessão.

Quanto o usuário se conecta ao dispositivo de rede (NAS) e inicia uma sessão, um registro em radacct é criado, mas nem todas as informações estão disponíveis nele. O campo AcctStopTime é 0 (valor zero), entre outros.

Assim, você pode descobrir quais usuários estão conectados no momento com a SQL:

mysql> SELECT username, date_format(AcctStartTime, ‘%d/%m/%Y %T’) AS AcctStartTime, NASPortType FROM radacct WHERE AcctStopTime = 0 ORDER BY AcctStartTime;

Exemplo do resultado:

UserName   | AcctStartTime        |   NASPortType
+--------------------+---------------------------
 paulinho  | 30/12/2004  07:30:06 |   Virtual
 francisco | 30/12/2004  09:28:18 |   Async
+--------------------+---------------------------

Na tabela, vejo que um usuário de velox (paulinho) e outro de conexão discada (francisco) estão conectados.

Assim que a desconexão é registrada pelo NAS ou RAS, é transmitido para porta de contabilidade do freeradius um pedido de encerramento da sessão, os dados restantes são preenchidos (data e hora, tempo total da sessão, velocidade na hora da desconexão, motivo, etc).

Bom, agora que você já sabe o caminho das pedras, é hora de desenvolver um software que te dê isso de forma acessível e que você possa integrar com outros sistemas, como o de cobrança, por exemplo. Boa sorte no desenvolvimento!

1 – desenvolver um, escolhendo a tecnologia, se baseando nas suas necessidades e nos relacionamentos do seu banco de dados de clientes, cobrança, etc.

Não existe nenhum segredo para se fazer isso, basta ter conhecimento em alguma linguagem de programação com API do banco de dados usado (exemplo: PHP e MySQL). Assim você pode oferecer para seus clientes, formulários de mudança de senha, extrato de horas de acesso, help-desk, etc. Eu mesmo já desenvolvi um software do tipo, que instalo para meus clientes.

2 – usar o software “dial-up admin”, GNU, distribuído junto com o freeradius.

O dial-up admin é um software completo para administração de um servidor radius baseado em banco de dados. Ele possui total controle das tabelas do radius, para alterar atributos, administrar usuários, grupos e uma interface básica de administração de clientes (nome, telefone, endereço).

Será necessário ter instalado no seu servidor:

• Apache
• PHP
• Perl – módulo Date::Manip

Na pasta de fontes do freeradius, existe uma pasta chamada dialup_admin, coloque-a em /usr/local e se assegure de que somente o usuário que executa o Apache (nobody normalmente) tenha permissões nessa pasta.

Você não irá publicar a pasta /usr/local/dialup_admin no seu Apache, mas sim uma subpasta chamada htdocs (/usr/local/dialup_admin/htdocs), que deverá ser protegida por senha. Insira no seu httpd.conf:

# htpasswd -c /usr/local/dialup_admin/.htpasswd -m administrador senha

Vá até a pasta /usr/local/dialup_admin/sql, você deve executar todas estes arquivos de SQL no seu banco de dados de radius (banco “radius”):

# cd /usr/local/dialup_admin/sql
# mysql -pSENHA -u USUARIO -h SERVIDOR radius -e badusers.sql
# mysql -pSENHA -u USUARIO -h SERVIDOR radius < mtotacct.sql
# mysql -pSENHA -u USUARIO -h SERVIDOR radius < totacct.sql
# mysql -pSENHA -u USUARIO -h SERVIDOR radius < userinfo.sql

Onde: SENHA, USUÁRIO e SERVIDOR devem ser substituídos pelos valores corretos no seu servidor MySQL.

Com as tabelas criadas e o Apache configurado, edite o arquivo /usr/local/dialup_admin/conf/admin.conf e altere os valores das variáveis de acordo com sua instalação (mysql, arquivos de configuração do freeradius, etc).

Agora reinicie seu Apache, você irá acessar pelo endereço:

http://192.168.10.1/dialup_admin

Onde 192.168.10.1 deve ser substituído pelo ip ou nome FQDN do servidor.

Com esses passos você deve conseguir usar o software com sucesso!

A versão atualizada e corrigida dia-a-dia estará disponível no endereço:

• http://www.patrick.eti.br/

Como o própria licença do freeradius diz, não dou quaisquer garantia quanto ao software freeradius nem nenhum dos software citados nesse artigo, use por sua própria conta e risco.

Primeiramente, se tiver dúvidas, coloque-as nesse artigo, no vivaolinux.com.br, por favor, não me mande e-mails sem antes ler bem o artigo e se certificar de que você fez um mínimo de esforço para fazê-lo funcional!