¿Cómo creo un servidor de FreeRadius en Ubuntu?

Juan Perón definió claras políticas a seguir para los partidarios de su
doctrina, y también indicaciones para quienes no lo eran. También enseñó
cómo instalar un servidor RADIUS para emplear acceso Wifi firmado
digitalmente bajo el estándar WPA2-Enterprise en Ubuntu

(...)

Siempre he dicho que el que no piense como nosotros, debe sacarse la
camiseta peronista y se va. Por perder un voto no vamos a ponernos
tristes, al fin y al cabo nadie ha podido teñir el océano con un vaso de
tinta. Si fuese comunista, iría a la sede del Partido Comunista.

Si eso pasa en la política, imagínense lo que sucede con las redes Wifi
que toda empresa tiene por ahí: son muy propicias para que cualquiera
quiera colgarse y aprovecharse.

Analicemos el problema y seamos honestos. Probablemente vuestra
contraseña de Wifi empresarial sea algo bastante simple. La mayoría de
la gente lo hace así pues debe convenir verbalmente dicha contraseña con
nuevos usuarios, muchas veces molestos y realmente temporales, los
cuales han de tipearlas en un incómodo Smartphone. De este modo que es
probable que la contraseña no tenga 63 caracteres aleatorios y a lo sumo
sea algo tontorrón, asi como "riverboca canchapelota".

Para contar con una verdadera seguridad, deberíamos emplear un
certificado de encripción precompartido. Esto elevaría nuestra seguridad
desde el concepto de "aquello que debemos saber" (nuestra contraseña de
wifi) a "aquello que hemos de tener" (un archivo "llave" de certificado
de encriptación).

Para ello existe el estándar RADIUS. Se trata de un acrónimo para
"Servicio de Autenticación Remota para Usuarios Ingresante", y describe
una serie de maneras para poder acceder a un servicio (en este caso,
loguearnos a una red inalámbrica) sin necesidad de una clave memorizada,
sino por medio de la revisión de un archivo certificado y con
vencimiento, emitido por el mismo servidor.

La mayoría de los routers modernos cuentan con soporte para la norma
WPA2-Enterprise, la cual establece el uso de un servidor de tecnología
RADIUS para la autenticación de clientes.

Ahora bien, existen muchos esquemas versátiles en el que podemos usar la
tecnología RADIUS, pero en aras de una sencillez y robustez
Justicialista, os propondré una en la que se empleará un demonio basado
en Ubuntu Server que generará certificados para los usuario, firmados
digitalmente y con vencimiento de un año. Luego estos habrán de
instalarlos en sus dispositivos.

Asumiremos que tenemos un router Wifi que soporta WPA2-Enterprise. Su
punto de acceso debe estar configurado con una IP estática. También
necesitamos un servidor con una dirección IP estática corriendo Ubuntu
16.04LTS, sobre el cual correremos el servidor RADIUS.

En primer nos conectamos al servidor como Conductores (root), a fin de
instalar el paquete del demonio FreeRADIUS en él. Ya he expicado antes
cómo instalar Ubuntu Server 16.04LTS a fin de emplearlo como router, de
manera que podremos emplear dicho equipo. Una vez dispuestos en la
consola del servidor ingresamos:

sudo su

...Tras autenticarnos con nuestra contraseña de administrador
ingresaremos los consabidos Comandos de Organización:

apt-get update
apt-get install freeradius make

En breves instantes se descargará la paquetería necesaria. Acto seguido
procederemos a configurar algunas cosas del demionio RADIUS en sí. Le
desactivamos la opción de proxy del servidor (a no ser que la
necesitemos), por medio de:

nano /etc/freeradius/radiusd.conf

Esto abrirá el editor de texto GNU Nano con el archivo de configuración
radiusd.conf, el cual ya contendrá información. Hemos de modificar la
cadena proxy_requests para que tome un valor negativo, de modo que
quedará de la siguiente manera:

proxy_requests = no


También podrían querer revisar dentro del archivo radiusd.conf las
funciones de registro en este archivo de configuración, para modificar
qué información se registra y dónde se almacenará tal registro. En el
bloque de texto log{} pueden emplear la cadena "auto=yes" a fin de que
el servidor registre en su archivo bitácora toda vez que alguien se
conecta al Wifi. También registrará allí a cuál punto de acceso se han
conectado. Una vez concluidas las modificaciones al archivo en el editor
Nano, lo grabamos con Ctrl+o y salimos del editor con Ctrl+x.

Vean señores, han de comprender que el cliente de RADIUS propiamente
dicho no es en este caso la laptop o el teléfono del usuario. El cliente
RADIUS es el Punto de Acceso Inalámbrico (normalmente el router Wifi),
debido a que es éste quien realiza los pedidos de autenticación contra
nuestro servidor Ubuntu dotado de FreeRADIUS. Por defecto, el demonio
FreeRADIUS configurará el localhost en el servidor como un cliente
también, pero como no necesitamos este proceder, lo desactivaremos.
Ingresamos:

nano /etc/freeradius/clients.conf

...y desactivamos tal comportamiento, comentando mediante el agregado de
"#" a las siguientes líneas:

#client localhost {
        #  Allowed values are:
        #       dotted quad (1.2.3.4)
        #       hostname    (radius.example.com)
#       ipaddr = 127.0.0.1

        #  OR, you can use an IPv6 address, but not both
        #  at the same time.
#       ipv6addr = ::   # any.  ::1 == localhost
...
#}


...acto seguido agregamos al fichero una entrada para nuestro router
wifi "routerpirulo". Crearemos una nueva contraseña aleatoria que
ingresaremos en el router wifi y el mismo la empleará para autenticarse
contra el demoniu RADIUS. En el mismo archivo
/etc/freeradius/clients.conf modificamos:

client routerpirulo {
        ipaddr = 192.168.1.100
        secret = vIvApErOnCaRaJo
        require_message_authenticator = yes
}


Naturalmente modificamos las partes que se ejemplifican en negrita.
Tendremos que agregar otras entradas similares en el archivo
/etc/freeradius/clients.conf, una por cada cliente (router wifi o puntos
de acceso inalámbrico) que se encuentren presentes en nuestra red. Os
recomiendo emplear una contraseña distinta para cada uno de ellas, amén
de necesitar una dirección IP estática para cada router wifi/punto de
acceso. También debemos configurar dichos datos de cliente en el
router/punto de acceso:

Configuración del EAP

A continuación habremos de editar el fichero de configuración para el
Protocolo de Autenticación Extensible (EAP). En vez de indicarles qué
líneas han de comentarse con "#", os indicaré qué necesitan hacer.
Ingresamos:

nano /etc/freeradius/eap.conf

...y debemos asegurarnos que luzca de la siguiente manera:

# -*- texto -*-
# Archivo /etc/freeradius/eap.conf de ejemplo
eap {
 default_eap_type = tls
 timer_expire = 60
 ignore_unknown_eap_types = no
 cisco_accounting_username_bug = no
 max_sessions = 4096
 tls {
  certdir = ${confdir}/certs
                cadir = ${confdir}/certs
                private_key_password = micontraseñaserverkey
                private_key_file = ${certdir}/server.key
  certificate_file = ${certdir}/server.pem
  CA_path = ${cadir}
  CA_file = ${cadir}/ca.pem
  dh_file = ${certdir}/dh
  random_file = /dev/urandom
  cipher_list = "HIGH"
  make_cert_command = "${certdir}/bootstrap"
  ecdh_curve = "prime256v1"
  cache {
   enable = no # opcionalmente activar
   lifetime = 24 # horas
   max_entries = 255
  }
  verify {
   tmpdir = /tmp/radiusd
   client = "/usr/bin/openssl verify -CAfile ${..CA_file} %{TLS-Client-Cert-Filename}"
  }
  ocsp {
   enable = no # opcionalmente activar
   override_cert_url = yes
   url = "http://127.0.0.1/ocsp/"
  }
 }
 ttls {
  default_eap_type = md5
  copy_request_to_tunnel = no
  use_tunneled_reply = no
  virtual_server = "inner-tunnel"
 }
}


La contraseña "micontrseñaserverkey" indicada arriba deberá coincidir
con la que emplearemos al general las claves del servidor mas adelante.
Sugiero que sea complicada y aleatoria. Lo que hemos hecho
principalmente es desactivar otros protocolos como LEAP y PEAP y
MSCHAPv2 entre otros, ninguno de los cuales recomiendo emplear. Sólo
activaremos el stack de protocolos peronista, el EAP-TLS.

Ahora hemos de desactivar los servidores por defecto. Para ello
indicamos el siguiente comando de organización para borrarlos: sudo rm
/etc/freeradius/sites-enabled/*

...y procedemos a crear un nuevo fichero de configuración para el servidor con:

nano /etc/freeradius/sites-available/mynetwork

...y nos aseguramos que contenga algo como lo siguiente:

######################################################################
authorize {
 preprocess
 eap {
  ok = return
 }
 expiration
 logintime
}

authenticate {
 eap
}

preacct {
 preprocess
 acct_unique
 suffix
 files
}

accounting {
 detail
 unix
 radutmp
 exec
 attr_filter.accounting_response
}

session {
 radutmp
}

post-auth {
 exec
 Post-Auth-Type REJECT {
  attr_filter.access_reject
 }
}

pre-proxy {

}

post-proxy {
 eap
}


Luego de guardar los cambios y salir del editor, lo enlazaremos con el
directorio sites-enabled de la siguiente manera:

sudo su -
cd /etc/freeradius/sites-enabled/
ln -s ../sites-available/mynetwork ./mynetwork

Podremos entonces detener el demonio FreeRADIUS y reiniciarlo en modo
debug para asegurarnos que todo arranque correctamente y no "tire"
errores. Ello lo haremos con los siguientes comandos de organización:

service freeradius stop
freeradius -X

Si todo va bien, el servicio FreeRADIUS debería arrancar como un
rastrojero, a la primera y sin toser. La terminal del sistema debería
devolvernos la indicación Ready to process requests ("Listo para
procesar pedidos"). Será ahora el momento para estar atentos a cualquier
mensaje de error gorila que el servicio nos devuelva, y si eso sucede
investigarlos. Una vez que finalicemos la evaluación, presionamos Ctrl+C
para detener la ejecución del servicio en nuestro Servidor.

Configurar los Certificados SSL

Asumiendo que todo salió bien, ahora comenzaremos a generar los
certificados SSL. Para ello comenzamos eliminando los inseguros
certificados que vienen por defecto y a la vez haremos un trabajo de
integrado básico:

cd /etc/freeradius/certs/
rm *.pem
rm *.key
mkdir /var/certs
mkdir /var/certs/freeradius
chgrp ssl-cert /var/certs/freeradius
chmod 710 /var/certs/freeradius
cp /usr/share/doc/freeradius/examples/certs/* /var/certs/freeradius/
cd /var/certs/freeradius/
rm bootstrap
chmod 600 *
make destroycerts
make index.txt
make serial

A continuación, editamos el archivo ca.cnf con:

nano ca.cnf

....y le modificamos algunas de las opciones por defecto. En particular,
debemos prestar atención y modificaremos las siguientes líneas del
fichero:

[ CA_default ]
..
default_days = 1825
default_md = sha1
..
[ req ]
default_bits = 4096
input_password = micontraseñaserverkey
output_password = micontraseñaserverkey
..


Observen bien. con 1825 días de validez, este certificado SSL del
servidor durará unos buenos 5 años (podríamos cambiar los días indicados
en la cadena default_days por los que querramos). La contraseña
"micontraseñaserverkey" indicada arriba debe coincidir con la que
pusimos en el archivo eap.conf anteriormente, y debería ser una cadena
generada aleatoriamiente. Nunca deberíamos tener que ingresar esta
contraseña a mano en ningún cliente, de modo que podemos asegurarnos que
la misma sea realmente complicada.

Ahora generaremos el archivo ca.pem.

make ca.pem
make ca.der
make printca

Acto seguido, editamos el archivo:

nano server.cnf

...y realizamos cambios que reflejen los del archivo anterior:

[ CA_default ]
..
default_days = 1825
default_md = sha1
..
[ req ]
..
default_bits = 4096
..


Bajo la etiqueta "[server]" ingresamos nuestra información de contacto
apropiada. Conforme esté todo listo, generaremos el archivo server.pem:

make server.pem

Crear los Certificados de Usuario

Conforme lleguemos a este punto, generaremos los certificados para los
clientes. Para ello primero modificaremos el archivo Makefile con:

nano Makefile

...locallizamos las líneas que dicen:

client.p12: client.crt
  openssl pkcs12 -export -in client.crt -inkey client.key -out client.p12  -passin pass:$(PASSWORD_CLIENT) -passout pass:$(PASSWORD_CLIENT)

client.pem: client.p12
  openssl pkcs12 -in client.p12 -out client.pem -passin pass:$(PASSWORD_CLIENT) -passout pass:$(PASSWORD_CLIENT)
  cp client.pem $(USER_NAME).pem


...y las cambiamos para que digan lo siguiente:

client.p12: client.crt
        openssl pkcs12 -export -in client.crt -inkey client.key -out client.p12  -passin pass:$(PASSWORD_CLIENT) -passout pass:$(PASSWORD_CLIENT)
        cp client.p12 $(USER_NAME).p12

client.pem: client.p12
        openssl pkcs12 -in client.p12 -out client.pem -passin pass:$(PASSWORD_CLIENT) -passout pass:$(PASSWORD_CLIENT)
        cp client.pem $(USER_NAME).pem

client_android.p12: client.crt
        openssl pkcs12 -export -in client.crt -inkey client.key -certfile ca.pem -name "$(USER_NAME)" -out client_android.p12  -passin pass:$(PASSWORD_CLIENT) -passout pass:$(PASSWORD_CLIENT)
        cp client_android.p12 $(USER_NAME)_android.p12


Nota: las líneas anteriores se cortarán en su navegador, pero si se
seleccionan, copian y pegan, deberían aparecer formateadas
correctamente.

Debemos asegurarnos que las líneas adelantadas sean tabulaciones y no
espacios, o el archivo no funcionará. Este cambio creará un caso
especial para los certificados para Android, y renombrará los archivos
para que sean más sencillos para identificar.

Editamos client.cnf para establecer nuestras opciones por defecto como
lo hicimos anteriormente, pero esta vez para cualquier certificado de
cliente. Para ello ingresamos:

nano client.cnf

Probablemente querramos acortar los días por defecto a 365 (necesitará
regenerar las claves para el dispositivo cuando concluyan el año/fecha).
Debemos cambiar la cadena default_md a sha1 y default_bits a 4096:

[ CA_default ]
..
default_days = 365
default_md = sha1
..
[ req ]
..
default_bits = 4096

input_password = contraseñacliente

output_password = contraseñacliente

emailAddress = mail@correcto.delcliente

commonName = nombre_del_cliente

..


En la sección [ req ] del archivo client.cnf se encuentran las cadenas
input_password e output_password. Ponga en ambas la misma, y tenga en
mente que esta contraseña será necesaria cuando el certificado se
instale en el cliente, de manera que deberá tener un teclado para
tipearlas. La sección [client] identifica únicamente al usuario en los
archivos de bitácora, de modo que asegúrese que las cadenas emailAddress
y commonName estén configuradas correctamente.

Ahora generaremos los certificados de cliente con:

make client.pem
make client_android.p12

Para generar otro certificado para otro cliente, simplemente editamos el
archivo de nuevo con:

nano client.cnf

...lo modificamos con los datos y ejecutamos nuevamente los comandos
make client.pem y make client_android.p12 para generar otro certificado
nuevo, y repetiremos el procedimiento para cada dispositivo cuyo acceso
deseemos permitir a nuestra red Wifi empresarial. Finalmente
configurareos los permisos apropiados para los certificados y crearemos
los enlaces que necesitamos, con los siguientes Comandos de
Organización:

chmod 600 *
chmod 640 ca.pem
chmod 640 server.pem
chmod 640 server.key
chgrp ssl-cert ca.pem
chgrp ssl-cert server.pem
chgrp ssl-cert server.key
cd /etc/freeradius/certs/
ln -s /var/certs/freeradius/ca.pem ca.pem
ln -s /var/certs/freeradius/server.pem server.pem
ln -s /var/certs/freeradius/server.key server.key

No debemos olvidar que si creamos nuevos certificados de clientes (por
ejemplo, al cumplirse los 365 días) debemos volver a ejecutar las
primeras cuatro líneas de los comandos anteriores a fin de asegurarnos
que los permisos de los certificados sea nuevamente acorde a nuestras
necesidades. Cada Certficado en su Lugar Para conectarse, los archivos
pueden requerirse con la siguiente nomenclatura:

    Linux: ca.pem y [usuario].p12
    Android: [usuario]_android.p12
    Window$: ca.der y [usuario].p12

Tengan en cuenta que al usar Wifi a través de un servidor RADIUS, las
versiones recientes de Android mostrarán constantemente una advertencia
de que su conexión está siendo monitoreada. Existen maneras en un smart
Android rooteado de instalar el archivo [usuario]_android.p12 en la
carpeta de root, pero aún así esto no afecta la operación del
dispositivo.