Projet authentification wifi et logging http/https

De WIKI Les fourmis du libre
Révision de 7 avril 2016 à 20:50 par Simon (discussion | contributions) (Test de connexion RADIUS)

Aller à : navigation, rechercher

Présentation

FreeRADIUS est un logiciel libre et gratuit, version libre du protocole RADIUS (Remote Authentication Dial-In User Service) service d'authentification réseau interfaçable avec plusieurs sources d'identité (LDAP/SQL entre autres).

C'est un service utilisé notamment par les FAI pour identifier leurs clients. Dans notre cas il va nous être utile pour identifier les utilisateurs sur le réseau quand ils veulent accéder a Internet au travers d'un proxy ou se connecter au réseau WiFi.

Schéma descriptif du fonctionnement de FreeRadius

Voici un schéma représentatif d'une architecture réseau sans-fil avec un contrôleur de borne (dans notre cas Unifi) qui s'interface avec le serveur FreeRadius pour demander l'authentification 802.1x, serveur Radius qui contrôle l'identité auprès de l'Active Directory. Tout ce cheminement amène enfin à l’autorisation du client par le contrôleur et lui donner l'accès au réseau sans-fil.

Schema-radius.png

Petit glossaire

Certains termes techniques pour la suite du tutoriel qui pourrait porter a question ou confusion :

  • NAS - Network Access Server : Boitier distant d'accès, un client RADIUS
  • PAP : Protocole de mot de passe en clair, a éviter donc
  • CHAP : Protocole d'echage basé sur un hachage, c'est déjà mieux
  • MS-CHAP et MS-CHAPv2 : Variante Microsoft du protocole CHAP
  • EAP - Extensible Authentication Protocol : Ensemble de protocoles extensibles d'authentification et ses variantes (EAP-TLS - EAP-TTLS/MSCHAPv2 - PEAPv0/EAP-MS-CHAPv2 - PEAPv1/EAP-GTC - EAP-SIM)

De ce que j'ai pu lire/comprendre le protocole qu'on pourrait utiliser notamment pour les réseaux WiFi est EAP-TTLS/MSCHAPv2

Pré-requis

  • Machine virtuelle Debian 8 + Utilitaires de base du système (SSH, Vim, coloration syntaxique, etc)
  • Paramétrage fixe IP/Mask/Gateway de la VM serveur RADIUS
  • Synchronisation NTP avec openntpd : /etc/openntpd/ntpd.conf

<syntaxhighlight lang="bash">

  1. Choose servers announced from Debian NTP Pool

server 0.fr.pool.ntp.org server 1.fr.pool.ntp.org server 2.fr.pool.ntp.org server 3.fr.pool.ntp.org </syntaxhighlight>

  • Configuration DNS en accord avec le domain : /etc/resolv.conf

<syntaxhighlight lang="bash"> domain syrius.lan search syrius.lan nameserver 172.16.0.1 nameserver 8.8.8.8 </syntaxhighlight>

Dans ce tutoriel j'utiliserais les variables suivantes :

  • Domaine dns : syrius.lan
  • domaine NetBios : SYRIUS
  • Serveur AD : serveur.syrius.lan
  • Serveur DNS AD : 172.16.0.1
  • Serveur RADIUS : 172.16.0.200

Samba

Dans un premier temps il nous faut les outils nécessaires afin d'intégrer le domaine Active Directory donc Samba/windbind/Kerberos

Installation Samba

<syntaxhighlight lang="bash"> aptitude update && aptitude upgrade -y aptitude install samba winbind samba-common-bin krb5-user -y </syntaxhighlight>

Configuration Samba

Modification de la configuration Kerberos

<syntaxhighlight lang="bash" highlight="3,23-27,30-31">

  1. /etc/krb5.conf

[libdefaults] default_realm = SYRIUS.LAN krb4_config = /etc/krb.conf krb4_realms = /etc/krb.realms kdc_timesync = 1 ccache_type = 4 forwardable = true proxiable = true v4_instance_resolve = false v4_name_convert = {

   host = {
       rcmd = host
       ftp = ftp
   }
   plain = {
       something = something-else
   }

} fcc-mit-ticketflags = true

[realms] SYRIUS.LAN = {

               kdc = Serveur.syrius.lan
               admin_server = Serveur.syrius.lan
               default_domain = syrius.lan
       }

[domain_realm] .syrius.lan = SYRIUS.LAN syrius.lan = SYRIUS.LAN

[login] krb4_convert = true krb4_get_tickets = false </syntaxhighlight>

Initialisation Kerberos

On récupère un ticket Kerberos avec un compte Administrateur AD <syntaxhighlight lang="bash"> kinit Administrateur@syrius.lan </syntaxhighlight>

On doit ensuite vérifier si ce ticket est valide avec la commande klist, la réponse doit être la suivante : <syntaxhighlight lang="bash" highlight="1"> klist Ticket cache: FILE:/tmp/krb5cc_0 Default principal: Administrateur@SYRIUS.LAN

Valid starting Expires Service principal 04/03/2016 14:23:51 05/03/2016 00:23:51 krbtgt/SYRIUS.LAN@SYRIUS.LAN

       renew until 05/03/2016 14:23:48

</syntaxhighlight>

C'est terminé pour cette partie

Modification de la configuration Samba

Faites une copie du fichier de configuration de base de Samba on va lui coller un fichier raccourci/optimisé plus simple

<syntaxhighlight lang="bash" > mv /etc/samba/smb.conf /etc/samba/smb.conf.bak touch /etc/samba/smb.conf </syntaxhighlight>

On modifie le fichier /etc/samba/smb.conf en conséquence (voir lignes surlignés)

<syntaxhighlight lang="bash" highlight="3,11-12">

  1. /etc/samba/smb.conf

[global] workgroup = SYRIUS server string = %h server dns proxy = no log file = /var/log/samba/log.%m max log size = 1000 syslog = 0 panic action = /usr/share/samba/panic-action %d security = ads realm = SYRIUS.LAN password server = Serveur.syrius.lan winbind use default domain = yes domain master = no local master = no preferred master = no winbind enum groups = yes winbind enum users = yes winbind use default domain = no encrypt passwords = true </syntaxhighlight>

Il ne reste plus qu'a redémarrer Samba

<syntaxhighlight lang="bash"> service smbd restart </syntaxhighlight>

Intégration du Serveur RADIUS dans Active Directory

Pour ajouter notre serveur dans Active Directory <syntaxhighlight lang="bash"> net ads join -U Administrateur </syntaxhighlight>

En théorie si tout se passe bien vous devriez obtenir le message suivant <syntaxhighlight lang="bash"> Enter Administrateur's password: Using short domain name -- SYRIUS Joined 'RADIUS' to dns domain 'syrius.lan' </syntaxhighlight>

Notre serveur RADIUS fait maintenant partie du domaine, il faut redémarrer windbind qu'il récupère la liste des comptes

<syntaxhighlight lang="bash"> service winbind restart </syntaxhighlight>

On vérifie que la connexion winbind s'effectue correctement :

<syntaxhighlight lang="bash" highlight="1"> wbinfo -t checking the trust secret for domain SYRIUS via RPC calls succeeded </syntaxhighlight>

Et enfin on affiche la liste des comptes accessibles <syntaxhighlight lang="bash" highlight="1"> wbinfo -u SYRIUS\administrateur SYRIUS\invité SYRIUS\krbtgt SYRIUS\bernard SYRIUS\michel SYRIUS\christian ... </syntaxhighlight>

On peut enfin tenter une connexion en clair qui échouera pour vérifier que la transaction est acceptée par l'annuaire <syntaxhighlight lang="bash" highlight="1"> wbinfo -a bernard%Password123@ Could not authenticate user bernard%Password123@ with plaintext password challenge/response password authentication succeeded </syntaxhighlight>

On peut par contre tester une authentification NTLM qui devrait fonctionner <syntaxhighlight lang="bash" highlight="1"> ntlm_auth --request-nt-key --domain=SYRIUS --username=michel Password: NT_STATUS_OK: Success (0x0) </syntaxhighlight>

FreeRADIUS

Installation FreeRADIUS

<syntaxhighlight lang="bash"> aptitude update && aptitude upgrade -y aptitude install freeradius freeradius-utils -y </syntaxhighlight>

Configuration FreeRADIUS

Il y'a 4 fichiers a modifier pour que cela fonctionne

  • /etc/freeradius/eap.conf : il contient la configuration des méthodes EAP
  • /etc/freeradius/modules/mschap : c’est ce module qui fera l’authentification sur l’AD
  • /etc/freeradius/proxy.conf : sert à relayer les requêtes sur d’autres serveurs radius
  • /etc/freeradius/clients.conf : c’est ici que sont déclarés les NAS autorisés à utiliser le radius

Fichier eap.conf

eap {
   default_eap_type = peap
   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_file = ${certdir}/letsencrypt/privkey.pem
       certificate_file = ${certdir}/letsencrypt/cert.pem
       CA_file = ${certdir}/letsencrypt/fullchain.pem
       random_file = /dev/urandom
       CA_path = ${cadir}
       cipher_list = "DEFAULT"
       make_cert_command = "${certdir}/bootstrap"
       ecdh_curve = "prime256v1"
       cache {
           enable = no
           lifetime = 24 # hours
           max_entries = 255
       }
   }
   ttls {
       default_eap_type = mschapv2
       copy_request_to_tunnel = yes
       use_tunneled_reply = yes
       virtual_server = "inner-tunnel"
   }
   peap {
       default_eap_type = mschapv2
       copy_request_to_tunnel = yes
       use_tunneled_reply = yes
       virtual_server = "inner-tunnel"
   }
   mschapv2 {
   }
}

Fichier modules/mschap

  1. /etc/freeradius/modules/mschap
mschap {
   use_mppe=yes
   require_encryption = yes
   require_strong = yes
   with_ntdomain_hack = yes
   ntlm_auth = "/usr/bin/ntlm_auth --request-nt-key --username=%{%{Stripped-User-Name}:-%{%{User-Name}:-None}} --challenge=%{%{mschap:Challenge}:-00} --nt-response=%{%{mschap:NT-Response}:-00}"
}

Fichier proxy.conf

#/etc/freeradius/proxy.conf
proxy server {
   default_fallback = no
}
realm NULL {
}
realm LOCAL {
}
realm syrius.lan {
    authhost = LOCAL
    accthost = LOCAL
}

realm DEFAULT {
    type = radius
    authhost = LOCAL
    accthost = LOCAL
    secret = proxysharedsecret
    nostrip
}

Fichier clients.conf

Ce fichier contient vos clients RADIUS/NAS qui vont pouvoir demander au serveur des authentification.

Dans notre cas j'ai ajouté le serveur Unifi contrôleur des bornes Ubiquiti qui dispose du paramétrage RADIUS


#/etc/freeradius/clients.conf
client 172.16.0.214/21 {
   secret          = Password123!@$
   shortname       = unifi
}
client localhost {
   ipaddr = 127.0.0.1
   secret          = testing123
   require_message_authenticator = no
   nastype     = other
}

Changement du groupe sur un dossier Samba

J'ai du changer le groupe d'un dossier Samba pour que l'authentification RADIUS fonctionne.

chown root:freerad /var/lib/samba/winbindd_privileged/

Redémarrage du service

service freeradius restart

Test de connexion RADIUS

On teste une connexion par le protocole mschap

radtest -t mschap bernard Password123@ 127.0.0.1 0 testing123


La réponse correcte doit être

Sending Access-Request of id 237 to 127.0.0.1 port 1812
       User-Name = "bernard"
       NAS-IP-Address = 127.0.1.1
       NAS-Port = 0
       Message-Authenticator = 0x00000000000000000000000000000000
       MS-CHAP-Challenge = 0xb8201fd266435b59
       MS-CHAP-Response = 0x00010000000000000000000000000000000000000000000000007c5fcd6b544c28a727a4495f718daa00bf8d80d25895e3cd
rad_recv: Access-Accept packet from host 127.0.0.1 port 1812, id=237, length=84
       MS-CHAP-MPPE-Keys = 0x0000000000000000f98feb08ceddb78964978130258e020b0000000000000000
       MS-MPPE-Encryption-Policy = 0x00000002
       MS-MPPE-Encryption-Types = 0x00000004

Certificats SSL

On a besoin maintenant de générer des certificats SSL pour que la connexion chiffrée puisse avoir lieu entre un poste client Windows et le serveur RADIUS

Modification du fichier openssl.cnf

Vérifiez que les chemins sont corrects, j'ai du corriger le chemin dir par défaut qui me donnait des résultats incohérents.

<syntaxhighlight lang="bash" line start="39">

  1. /etc/ssl/openssl.cnf

[ CA_default ]

dir = /etc/ssl # Where everything is kept certs = $dir/certs # Where the issued certs are kept crl_dir = $dir/crl # Where the issued crl are kept database = $dir/index.txt # database index file.

  1. unique_subject = no # Set to 'no' to allow creation of
                                       # several ctificates with same subject.

new_certs_dir = $dir/newcerts # default place for new certs.

certificate = $dir/cacert.pem # The CA certificate serial = $dir/serial # The current serial number crlnumber = $dir/crlnumber # the current crl number

                                       # must be commented out to leave a V1 CRL

crl = $dir/crl.pem # The current CRL private_key = $dir/private/cakey.pem # The private key RANDFILE = $dir/private/.rand # private random number file </syntaxhighlight>

Ensuite vous pouvez personnaliser les champs par défaut qui vous permettrons d’accélérer la manœuvre lors de la création des certificats

<syntaxhighlight lang="bash" line start="127" highlight="4,9,12,15,26,30">

  1. /etc/ssl/openssl.cnf

[ req_distinguished_name ] countryName = Country Name (2 letter code) countryName_default = FR countryName_min = 2 countryName_max = 2

stateOrProvinceName = State or Province Name (full name) stateOrProvinceName_default = Vendee

localityName = Locality Name (eg, city) localityName_default = Saint-Petzouille

0.organizationName = Organization Name (eg, company) 0.organizationName_default = Etab

  1. we can do this but it is not needed normally :-)
  2. 1.organizationName = Second Organization Name (eg, company)
  3. 1.organizationName_default = World Wide Web Pty Ltd

organizationalUnitName = Organizational Unit Name (eg, section)

  1. organizationalUnitName_default =

commonName = Common Name (e.g. server FQDN or YOUR name) commonName_max = 64 commonName_default = Etab

emailAddress = Email Address emailAddress_max = 64 emailAddress_default = admin@syrius-truc.fr </syntaxhighlight>

Pré-requis

<syntaxhighlight lang="bash" > cd /etc/ssl/ mkdir /etc/ssl/private /etc/ssl/newcerts /etc/ssl/crl echo '1001' > serial touch index.txt </syntaxhighlight>

Génération du certificat Racine/Root

On génère dans un premier temps le certificat racine du serveur à l'aide du fichier complété précédemment

<syntaxhighlight lang="bash" > openssl req -new -x509 -newkey rsa:4096 -days 3650 -keyout ./private/cakey.pem -out cacert.pem -config /etc/ssl/openssl.cnf </syntaxhighlight>

Conversion du certificat pour Windows PEAP/MSCHAP

Pour notre utilisation il faut convertir le certificat dans un format intelligible pour Microsoft Windows <syntaxhighlight lang="bash" > openssl x509 -in cacert.pem -inform PEM -out cacert.der -outform DER </syntaxhighlight>

Création du certificat pour le serveur RADIUS

On génère maintenant le certificat pour le serveur RADIUS, on répond aux questions par Entrée puisque renseignés dans le fichier openssl.cnf

<syntaxhighlight lang="bash" > openssl req -new -nodes -out reqserver.pem -keyout private/server.key -config /etc/ssl/openssl.cnf </syntaxhighlight>

Signature du certificat par l’autorité de certification

<syntaxhighlight lang="bash" > openssl ca -out server.pem -config /etc/ssl/openssl.cnf -infiles reqserver.pem </syntaxhighlight>

Recreation des liens dans le dossier certs de RADIUS

<syntaxhighlight lang="bash" > cd /etc/freeradius/certs/ rm server.pem rm server.key rm ca.pem ln -s /etc/ssl/server.pem server.pem ln -s /etc/ssl/private/server.key server.key ln -s /etc/ssl/cacert.pem ca.pem </syntaxhighlight>

Modification dans /etc/freeradius/eap.conf

Ligne 11 dans le fichier /etc/freeradius/eap.conf :

<syntaxhighlight lang="bash"> private_key_password = Password1234 </syntaxhighlight>

Fin de la configuration SSL et test de connexion

On arrête FreeRADIUS et on voit si on obtient une connexion correcte en mode debug <syntaxhighlight lang="bash"> service freeradius stop freeradius -X </syntaxhighlight>

Exemple de ce qu'on reçoit en mode debug lors d'une Connexion Wifi RADIUS PEAP+MSCHAPV2 depuis un PC Portable Windows 10

<syntaxhighlight lang="bash" highlight="40,54"> rad_recv: Access-Request packet from host 172.16.4.100 port 37783, id=194, length=220

       User-Name = "bernard"
       NAS-IP-Address = 172.16.4.100
       NAS-Identifier = "24a43cbc73f1"
       NAS-Port = 0
       Called-Station-Id = "32-A4-24-00-23-F1:Wifi-RADIUS"
       Calling-Station-Id = "DC-AE-DE-AE-00-A9"
       Framed-MTU = 1400
       NAS-Port-Type = Wireless-802.11
       Connect-Info = "CONNECT 0Mbps 802.11b"
       EAP-Message = 0x0259002b19001703010020a90ad9e241d05304dcee18770cbd802d7b2be65273204ba4d640ad7e87af1dfa
       State = 0x00433a040a1a2342adba70ad11866fc3
       Message-Authenticator = 0x4e8080a628b556fb24150c9cf49d98c9
  1. Executing section authorize from file /etc/freeradius/sites-enabled/default

+group authorize { ++[preprocess] = ok ++[chap] = noop ++[mschap] = noop ++[digest] = noop [suffix] No '@' in User-Name = "bernard", looking up realm NULL [suffix] Found realm "NULL" [suffix] Adding Stripped-User-Name = "bernard" [suffix] Adding Realm = "NULL" [suffix] Authentication realm is LOCAL. ++[suffix] = ok [eap] EAP packet type response id 89 length 43 [eap] Continuing tunnel setup. ++[eap] = ok +} # group authorize = ok Found Auth-Type = EAP

  1. Executing group from file /etc/freeradius/sites-enabled/default

+group authenticate { [eap] Request found, released from the list [eap] EAP/peap [eap] processing type peap [peap] processing EAP-TLS [peap] eaptls_verify returned 7 [peap] Done initial handshake [peap] eaptls_process returned 7 [peap] EAPTLS_OK [peap] Session established. Decoding tunneled attributes. [peap] Peap state send tlv success [peap] Received EAP-TLV response. [peap] Success [peap] Using saved attributes from the original Access-Accept

       User-Name = "bernard"

[eap] Freeing handler ++[eap] = ok +} # group authenticate = ok

  1. Executing section post-auth from file /etc/freeradius/sites-enabled/default

+group post-auth { ++[exec] = noop +} # group post-auth = noop Sending Access-Accept of id 194 to 172.16.4.100 port 37783

       User-Name = "bernard"
       MS-MPPE-Recv-Key = 0xafd1450a10bc295cb3822f8a9125b1f5ddad7f9fd4d44492142e89a41ca7a798
       MS-MPPE-Send-Key = 0xb6767475d8c87636dfb2d10154c0ccff0f3dd6b6e233f29969628eb15507902c
       EAP-Message = 0x03590004
       Message-Authenticator = 0x00000000000000000000000000000000

Finished request 17. </syntaxhighlight>

Log des connexions

Afin de conserver toutes les authentifications qui passent pas RADIUS il faut modifier le fichier de configuration /etc/freeradius/radiusd.conf

Voici un exemple (sans la tonne de commentaires) de ce qui peut être mis en place :

  • Log des connexions dans un fichier : /var/log/radius.log
  • Log des connexions réussies
  • Log des échecs de connexions


<syntaxhighlight lang="bash"> log {

 destination = files
 file = /var/log/radius.log
 syslog_facility = daemon
 stripped_names = yes
 auth = yes
 auth_badpass = yes
 auth_goodpass = yes
 msg_goodpass = "Authentification Radius OK"
 msg_badpass = "Tentative de Connexion - Bad Password"

} </syntaxhighlight>

Le resultat dans le fichier de logs :

<syntaxhighlight lang="bash"> Thu Mar 17 15:39:19 2016 : Auth: Login OK: [Gauvrit/<via Auth-Type = EAP>] (from client unifi port 0 cli XX-XX-XX-XX-XX-XX via TLS tunnel) Authentification Radius OK Thu Mar 17 15:39:19 2016 : Auth: Login OK: [Gauvrit/<via Auth-Type = EAP>] (from client unifi port 0 cli XX-XX-XX-XX-XX-XX) Authentification Radius OK </syntaxhighlight>

Configuration Postes Clients

Android

Rien à faire, connectez vous sur le réseau Wifi avec RADIUS, rentrez identifiant/mot de passe AD et ça fonctionne !

Windows

  • Installer le certificat SSL *.der
  • Dans les paramètres du réseau WiFi désactivez la validation des certificats : voir captures d'écrans (ENG)
  • Séléctionné le réseau WiFi concerné
  • Se connecter et renseigner les identifiants/mot de passe AD

Mac OSX/iOS

Don't know

Sources

Voici les différentes sources qui nous ont aidé a élaborer cette documentation :