L'Internet Rapide et Permanent

2-1-1-1. Un LAN▲

Nous sommes ici, c'est sous-entendu tout au long de cet exposé, sur un réseau Ethernet.

Un LAN est un réseau local dans lequel toutes les trames Ethernet sont visibles depuis tous les nœuds si le LAN est construit avec un hub. Si nous avons affaire à un switch, seules les trames de diffusions (broadcast) seront visibles depuis tous les nœuds, le switch agissant comme un pont Ethernet entre chaque nœud du LAN.

Aujourd'hui, les hubs ont quasiment disparu des catalogues des constructeurs. Compte tenu de l'usage grandissant des réseaux, il est clair que le hub ne peut être considéré comme une bonne solution que sur les tout petits réseaux.

Au-dessus de tout ceci, nous construirons un réseau IP, mais c'est à la limite assez peu notre problème ici. Que le réseau de niveau 3 soit IP, NetBEUI ou AppleTalk n'a aucune importance. Bien entendu, dans la suite, nous n'utiliserons qu'IP.

Ce qu'il est fondamental de comprendre, c'est que nous raisonnons au niveau Ethernet, que nous ne parlons que d'adresses MAC.

Un switch, c'est le composant que nous utiliserons par la suite, à l'exclusion des hubs, est capable d'apprendre et de retenir la ou les adresses MAC qui se présentent sur chacun de ses ports. Hormis les trames de diffusion qui seront systématiquement répercutées sur tous les ports, le switch ne laissera communiquer entre eux que les ports concernés par un dialogue entre deux nœuds. C'est sa fonction principale de pont Ethernet.

2-1-1-2. Deux LAN (ou plus)▲

Lorsque nous avons deux LAN et que nous souhaitons les interconnecter, tout en conservant dans chaque LAN les mêmes propriétés au niveau Ethernet, nous devons faire appel à la couche 3 (IP) pour assurer l'interconnexion. Il nous faut donc un routeur.

Le routeur agit au niveau 3 (IP). Ce qu'il est absolument fondamental de comprendre, c'est qu'au niveau Ethernet, le LAN bleu ignore complètement l'existence du LAN vert, et réciproquement. Les trames Ethernet, qu'elles soient de la diffusion ou non, n'iront jamais dans l'autre LAN. Il y a isolation complète des deux LAN au niveau Ethernet et la présence du routeur n'y change rien. Les trames Ethernet qui transportent des données depuis le LAN vert dans le LAN bleu ne seront rien d'autre que des trames Ethernet issues du routeur côté LAN bleu (et réciproquement). Comme dans un roman de science-fiction de bonne facture, les mondes Ethernet bleu et vert sont des mondes parallèles, avec de temps en temps, une porte mystérieuse qui s'ouvre pour laisser passer des choses d'un monde à l'autre, mais en leur faisant perdre la mémoire de leur origine réelle (nous sommes au niveau 2, n'oublions pas).

Il faut monter au niveau de conscience supérieur (niveau IP), pour commencer à démythifier le fonctionnement de ces portes.

Mais à cette hauteur, les détails lointains s'estompent. Ce qu'il y a exactement dans chaque LAN au niveau Ethernet importe finalement assez peu. À première vue, le panorama serait plutôt le suivant :

Parce que, finalement, lors de l'interconnexion de réseaux, peu importe ce qu'il y a dans chaque réseau, ce sont les routes qui importent le plus.

Entendons par là que les équipements utilisés pour construire chaque LAN, qu'il s'agisse de hubs ou de switches ou d'un mélange des deux n'a aucune importance.

2-1-1-3. Où intervient le virtuel▲

Jusqu'ici, un switch appartenait à un et un seul LAN. L'idée de base est de pouvoir assigner certains ports du switch à un LAN, certains autres ports à un autre LAN, etc. :

Sur un même switch physique, nous allons pouvoir créer plusieurs LAN et assigner certains de ses ports aux divers LAN créés. Ici, nous avons un LAN bleu et un LAN vert. Le port orangé est un peu spécial, il appartient à la fois aux deux LAN, mais il ne va pas nous servir tout de suite.

Tout va (presque) se passer comme si l'on avait découpé notre switch en deux morceaux (sans pour autant le détruire).

Dans une première approche, notre maquette deviendrait ceci :

Le switch a été virtuellement coupé en deux. Les deux VLAN sont complètement étanches au niveau Ethernet (un switch est en principe un outil qui ne va pas au-delà du niveau 2). Pour interconnecter ces deux LAN, un routeur est toujours nécessaire.

Il y a bien entendu quelques avantages à pratiquer de la sorte. Nous pouvons au moins en citer deux :

• optimisation du matériel. En effet, c'est évident sur l'illustration, nous n'avons plus besoin que d'un seul switch, là où il nous en fallait deux au départ ;
• passer d'un poste de travail d'un LAN à l'autre devrait pouvoir se faire de façon « soft ». Plutôt que de débrancher puis de rebrancher ailleurs le lien du poste, nous pourrons le faire par l'outil de configuration du switch.

Voilà pour le principe de base. Vous devinez que si je prends la peine de rédiger un chapitre sur les VLAN, c'est qu'il y a d'autres choses encore derrière ce concept. Jusqu'ici, c'est assez simple. Les choses vont maintenant se compliquer progressivement pour arriver à des solutions qui peuvent vite devenir un casse-tête. Il faudra alors résister à la tentation de réaliser des « usines à gaz » là où ce n'est pas nécessaire. Les solutions les plus simples, pourvu qu'elles répondent au cahier des charges, sont toujours les meilleures.

Ici, l'idée serait d'arriver à ce que certains ports du switch puissent être assignés à plusieurs VLAN, ça fera économiser du câble (et aussi des ports sur le switch).

Le principe consiste à ajouter dans l'en-tête de la trame Ethernet un marqueur qui va identifier le VLAN. Il existe quelques solutions propriétaires pour réaliser ceci, mais le système s'est avéré tellement intéressant qu'une norme a été définie, il s'agit de la norme 802.1q.

Alors qu'une trame Ethernet « normale » est constituée comme ceci :

Une trame modifiée par la norme 802.1q se trouve allongée de 4 octets :

Il n'est peut-être pas nécessaire de détailler le contenu de ces deux nouveaux champs. Pour l'instant, retenons que le VID (Identifiant du VLAN) est codé sur 12 bits, ce qui laisse une latitude confortable.

Il est aussi nécessaire de rappeler qu'une trame Ethernet ne doit pas dépasser 1518 octets et que donc, quatre octets de plus dans l'en-tête risquent d'aboutir à une fragmentation des trames, ce qui n'est jamais bien bon. Si l'on doit avoir recours à des VLAN « tagués », il sera sans doute nécessaire de prévoir ce détail.

Finalement, notre switch a donc la possibilité d'ajouter ces marqueurs aux trames Ethernet. Si c'est le cas, il sera alors possible théoriquement d'assigner un même port à 212 VLAN différents. Grâce au VID de chaque VLAN, les données seront acheminées correctement.

Si nous appliquons cette technique à notre maquette, nous obtenons ceci :

Que les esprits sensibles gardent leur sérénité. Il n'y a effectivement qu'un seul câble qui relie l'unique switch au routeur, et pourtant, nous allons effectivement router les données entre les deux LAN. Il y a tout de même une condition à respecter : le routeur doit être « 802.1q compliant », c'est-à-dire qu'il doit savoir lire les tags que le switch a posés sur au moins l'un des deux VLAN.

2-1-3-1. Explications au niveau 2▲

2-1-3-2. Explications au niveau 3▲

Il y a plusieurs façons de s'y prendre. Vous trouverez sans doute de nombreuses pages qui traitent ce sujet, en vous parlant des VLAN de niveau 1, 2, voire 3. Nous allons essayer de voir ceci de façon plus pragmatique.

2-1-4-1. Attribution statique (niveau 1)▲

2-1-4-2. Attribution dynamique (niveaux > 1)▲

Dans notre exemple, le switch est configuré pour supporter deux VLAN, respectivement d'ID 1 et 2. Les ports verts appartiennent au VLAN d'ID 1 et les ports bleus au VLAN d'ID 2. Aucun de ces ports n'a besoin d'être « tagué » puisqu'ils n'appartiennent qu'à un seul VLAN.

En revanche, sur les ports qui vont véhiculer les trames des deux VLAN, au moins l'un des deux devra être « tagué » au passage de ces ports. Encore une fois, c'est l'interface d'administration du switch qui permettra de réaliser cette configuration. Disons pour fixer les idées que le VLAN vert, d'ID 1  ne sera pas marqué et que le VLAN bleu, d'ID 2 le sera, sur les ports du « trunk » VLAN 1 + VLAN 2.

Pratiquement, admettons que le VLAN 1 supporte un réseau IP 192.168.10.0/24 et que le VLAN 2 soit adressé en 192.168.11.0/24.

Sur le routeur (une machine Debian Etch), nous devons configurer l'unique interface Ethernet physique de manière à ce qu'elle présente deux interfaces IP, chacune pour un VLAN. Il nous faut d'abord installer le paquetage « vlan ».

~# apt-get install vlan
Lecture des listes de paquets... Fait
Construction de l'arbre des dépendances... Fait
....

Nous devons également monter le module noyau qui permet de gérer les tags :

~# modprobe 8021q

Nous venons d'installer les outils nécessaires à la gestion des VLAN (le paquetage VLAN et le montage du module 8021q).

Nous devons maintenant créer une interface réseau virtuelle, qui sera chargée de traiter le VLAN bleu d'ID 2 (celui qui est « tagué »). La commande « vconfig » va le permettre :

~# vconfig add eth0 2
Added VLAN with VID == 2 to IF -:eth0:-

Vérifions avec la commande ifconfig :

~# ifconfig -a
eth0      Lien encap:Ethernet  HWaddr 00:20:18:54:99:F9
          inet adr:192.168.10.1  Bcast:192.168.10.255  Masque:255.255.255.0
          adr inet6: fe80::220:18ff:fe54:99f9/64 Scope:Lien
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:1631 errors:0 dropped:0 overruns:0 frame:0
          TX packets:1233 errors:0 dropped:0 overruns:0 carrier:0
          collisions:2 lg file transmission:1000
          RX bytes:993172 (969.8 KiB)  TX bytes:118423 (115.6 KiB)
          Interruption:11 Adresse de base:0xa800

 eth0.2    Lien encap:Ethernet  HWaddr 00:20:18:54:99:F9
          BROADCAST MULTICAST  MTU:1500  Metric:1
          RX packets:1 errors:0 dropped:0 overruns:0 frame:0
          TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 lg file transmission:0
          RX bytes:332 (332.0 b)  TX bytes:0 (0.0 b)
...

L'argument « -a » est nécessaire pour visualiser les interfaces « down ». eth0.2 existe maintenant, mais n'est pas encore montée.

Nous disposons maintenant sur notre Debian d'un unique adaptateur Ethernet (eth0) qui pourra recevoir nativement le VLAN bleu, puisqu'il n'a pas de tag, et un adaptateur virtuel (eth0.2) qui traitera les trames Ethernet du VLAN vert, d'ID 2. Reste à fixer une adresse IP à eth0.2 et à la monter :

~# ip addr add 192.168.11.1/24 broadcast 192.168.11.255 dev eth0.2
~# ifconfig eth0.2 up

~# ifconfig
eth0      Lien encap:Ethernet  HWaddr 00:20:18:54:99:F9
          inet adr:192.168.10.1  Bcast:192.168.10.255  Masque:255.255.255.0
          adr inet6: fe80::220:18ff:fe54:99f9/64 Scope:Lien
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:1631 errors:0 dropped:0 overruns:0 frame:0
          TX packets:1233 errors:0 dropped:0 overruns:0 carrier:0
          collisions:2 lg file transmission:1000
          RX bytes:993172 (969.8 KiB)  TX bytes:118423 (115.6 KiB)
          Interruption:11 Adresse de base:0xa800

eth0.2    Lien encap:Ethernet  HWaddr 00:20:18:54:99:F9
          inet adr:192.168.11.1  Bcast:192.168.11.255  Masque:255.255.255.0
          adr inet6: fe80::220:18ff:fe54:99f9/64 Scope:Lien
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:0 errors:0 dropped:0 overruns:0 frame:0
          TX packets:4 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 lg file transmission:0
          RX bytes:0 (0.0 b)  TX bytes:344 (344.0 b)

La dernière étape consistera à :

• vérifier que le kernel autorise le routage ;
• écrire éventuellement des règles iptables pour le filtrage de paquets, en fonction des besoins.

Cette méthode offre l'avantage de pouvoir réaliser facilement des manipulations pour la mise en œuvre de la solution, mais offre en revanche l'inconvénient d'être totalement manuelle. Il est bien sûr possible d'arranger ça avec un script bien placé, mais il existe sur Debian (et probablement aussi sur d'autres distributions) une autre solution, qui passe par le fichier de configuration des interfaces (/etc/network/interfaces), dont voici un exemple :

...
auto eth0
iface eth0 inet static
    address 192.168.10.1
    netmask 255.255.255.0
    network 192.168.10.0
    broadcast 192.168.10.255

auto vlan2
iface vlan2 inet static
    address 192.168.11.1
    netmask 255.255.255.0
    broadcast 192.168.11.255
    vlan_raw_device eth0
...

Nous aurons alors une interface vlan2 en lieu et place de eth0.2, mais qui remplira exactement le même rôle. Pour éviter d'éventuels problèmes de montage du module 8021q, autant l'ajouter dans le fichier /etc/modules.

La manipulation qui suit est faite avec un switch de type D-Link DES-3326s. Lorsque nous configurons notre switch, nous créons plusieurs VLAN. Chacun de ces VLAN dispose d'un VID.

Ensuite, nous attribuons chaque port à un VLAN particulier. Encore une fois, un port (ou plus) peut appartenir à plusieurs VLAN. Voyons ceci sur l'interface d'administration du D-Link DES-3326s :

	Nous constatons qu'ici, il n'existe pour l'instant qu'un seul VLAN, de VID 1. Tous les ports de 1 à 24 lui sont assignés de façon « untagged ».
	Nous allons commencer par créer un second VLAN de démonstration, puis nous nous occuperons des ports laissés libres (25 et 26). Comme nous le voyons, le second VLAN est créé, mais pour l'instant, aucun port ne lui est assigné.
	Enfin, nous assignons le port 25 au VLAN 2 de façon « untagged », puis le port 26 aux deux VLAN. Ici, il faudra utiliser les tags : * « untagged » dur le VLAN 1, * « tagged » sur le VLAN 2

Finalement, si nous relions le port 26 à notre Debian Sarge sur son interface physique eth0, nous aurons la possibilité de router les paquets entre les VLAN 1 et 2.

Le principe des VLAN étant compris, la dernière étape va consister à mettre en œuvre une commutation automatique des ports du switch sur l'un ou l'autre VLAN, suivant que la machine qui s'y connecte sera authentifiée ou non.

Conformément au cahier des charges, nous utilisons simplement l'adresse MAC de la machine, ce qui évitera d'avoir à installer sur chaque client un système d'authentification plus sophistiqué (un certificat, par exemple, comme nous le verrons avec WPA2-TLS). Cette méthode n'est pas parfaite, loin de là, dans la mesure où une adresse MAC peut être falsifiée, mais elle a le mérite d'être simple à mettre en œuvre.

Il nous faudra tout de même disposer de switches capables d'interroger un serveur RADIUS, en lui envoyant l'adresse MAC du client en guise de nom d'utilisateur et de mot de passe. Nous utilisons ici un switch HP Procurve 2650.

Lorsqu'il sort de sa boîte, ce switch est configuré avec un seul VLAN, nommé « DEFAULT_VLAN » (et qui est aussi le « PRIMARY_VLAN »). Tous les ports du switch sont affectés à ce VLAN, si bien que sans aucune configuration particulière, ce switch fonctionnera comme un switch de base.

Pour le configurer, plusieurs solutions sont proposées, à commencer par une liaison série RS232 (gardez au moins un vieux PC), qui est initialement le seul moyen possible pour accéder à la configuration (In the factory default configuration, the switch has no IP (Internet Protocol) address and subnet mask, and no passwords. In this state, it can be managed only through a direct console connection).

Par la suite, nous pourrons accéder au switch par le réseau, via Telnet, un miniserveur web embarqué (mais vraiment minimaliste), ou même ssh. En effet les switches administrables peuvent recevoir une adresse IP pour accéder à l'administration par le réseau. Sur ce modèle de switch, nous pourrons même assigner une adresse IP par VLAN, ce qui n'est absolument pas nécessaire, voire dangereux. Comme notre propos est plutôt de parler des VLAN, nous passerons ces détails sordides.

Nous supposons donc que la configuration de base du switch est faite, et principalement la configuration IP du DEFAULT_VLAN :

Internet (IP) Service

  IP Routing : Disabled

  Default Gateway : 192.168.10.1
  Default TTL     : 64
  Arp Age         : 20

  VLAN         | IP Config  IP Address      Subnet Mask
  ------------ + ---------- --------------- ---------------
  DEFAULT_VLAN | Manual     192.168.10.11   255.255.255.0

Donc, nous avons un « DEFAULT_VLAN » qui est aussi le « PRIMARY_VLAN », et qui contient tous les ports du switch. Il y a quelques contraintes à connaître à propos de ces deux VLAN :

• DEFAULT_VLAN ne peut pas être supprimé et a le VID 1, en revanche, rien n'interdit de ne lui assigner aucun port ;
• PRIMARY_VLAN est nécessaire à certaines fonctions d'administration que nous n'utiliserons pas forcément ici, comme le pseudoempilage de switches. Cette fonction de PRIMARY_VLAN peut être assignée à n'importe quel VLAN existant, pas forcément au DEFAULT_VLAN, mais il doit exister. Nous laissons la configuration par défaut.

Nous n'allons conserver que quelques ports, dont les deux ports 1GB/s sur DEFAULT_VLAN, laisser PRIMARY_VLAN  dessus, tous les autres ports étant réservés à deux autres VLAN qu'il nous reste à créer :

• PARADIS_VLAN, de VID 2, qui accueillera le LAN des hôtes connus ;
• ENFER_VLAN de VID 3, qui accueillera toutes les machines que l'on ne sait pas identifier.

Nous allons restreindre le DEFAULT_VLAN aux ports 33-50 (sans tag). Ce VLAN nous servira à administrer le switch, à accueillir les DNS, DHCP, RADIUS et autres services « administratifs ».

Les ports 1 à 6 seront assignés au PARADIS_VLAN de façon statique (sans tag). Nous y placerons par la suite les ressources du réseau à offrir aux stations « connues ».

Comme ce switch ne supporte pas d'avoir des ports assignés à aucun VLAN, nous allons mettre les ports 7 à 32 dans le ENFER_VLAN. Nous reviendrons éventuellement sur ce choix plus tard.

Les ports 49 et 50 seront quant à eux assignés aux trois VLAN. Bien entendu, ici, il faudra utiliser les tags. L'un des deux ports servira à connecter le routeur et l'autre sera réservé aux extensions futures (un second switch, par exemple).

Finalement, la (magnifique) interface web nous montrera ceci :

Mais qu'importe la beauté lorsque le travail est bien fait, n'est-ce pas ?

Notez que tout le travail fait jusqu'ici a pu l'être par l'entremise de cette interface. Pour la suite, ce sera quelque peu différent.

2-3-2-1. Choix VLAN suivant l'authentification▲

configure

aaa port-access mac-based addr-format multi-colon
aaa port-access mac-based 7-32

aaa port-access mac-based 7-32 auth-vid 2
aaa port-access mac-based 7-32 unauth-vid 3

show port-access 7-32 mac-based config

Port Access MAC-Based Configuration
  MAC Address Format : multi-colon

                 Client Client Logoff    Re-Auth   Unauth   Auth
  Port  Enabled  Limit  Moves  Period    Period    VLAN ID  VLAN ID
  ----- -------- ------ ------ --------- --------- -------- --------
  7     Yes      1      No     300       0         3        2
  8     Yes      1      No     300       0         3        2
  9     Yes      1      No     300       0         3        2
  10    Yes      1      No     300       0         3        2
  11    Yes      1      No     300       0         3        2
  12    Yes      1      No     300       0         3        2
  13    Yes      1      No     300       0         3        2
  14    Yes      1      No     300       0         3        2
  15    Yes      1      No     300       0         3        2
  16    Yes      1      No     300       0         3        2
  17    Yes      1      No     300       0         3        2
  18    Yes      1      No     300       0         3        2
  19    Yes      1      No     300       0         3        2
  20    Yes      1      No     300       0         3        2
  21    Yes      1      No     300       0         3        2
  22    Yes      1      No     300       0         3        2
  23    Yes      1      No     300       0         3        2
  24    Yes      1      No     300       0         3        2
  25    Yes      1      No     300       0         3        2
  26    Yes      1      No     300       0         3        2
  27    Yes      1      No     300       0         3        2
  28    Yes      1      No     300       0         3        2
  29    Yes      1      No     300       0         3        2
  30    Yes      1      No     300       0         3        2
  31    Yes      1      No     300       0         3        2
  32    Yes      1      No     300       0         3        2

write memory

radius-server host 192.168.10.2 key epikoi

show radius

Status and Counters - General RADIUS Information

  Deadtime(min) : 0
  Timeout(secs) : 5
  Retransmit Attempts : 3
  Global Encryption Key :

                  Auth  Acct
  Server IP Addr  Port  Port  Encryption Key
  --------------- ----- ----- --------------------------------
  192.168.10.2    1812  1813  epikoi

write memory

2-3-2-2. Revenir en arrière▲

configure
no aaa port-access mac-based 30-32
no aaa port-access mac-based 30-32 auth-vid
no aaa port-access mac-based 30-32 unauth-vid
write memory

show port-access 7-32 mac-based config

Port Access MAC-Based Configuration
  MAC Address Format : multi-colon

                 Client Client Logoff    Re-Auth   Unauth   Auth
  Port  Enabled  Limit  Moves  Period    Period    VLAN ID  VLAN ID
  ----- -------- ------ ------ --------- --------- -------- --------
 ...
  24    Yes      1      No     300       0         3        2
  25    Yes      1      No     300       0         3        2
  26    Yes      1      No     300       0         3        2
  27    Yes      1      No     300       0         3        2
  28    Yes      1      No     300       0         3        2
  29    Yes      1      No     300       0         3        2
  30    No       1      No     300       0         0        0
  31    No       1      No     300       0         0        0
  32    No       1      No     300       0         0        0

D'une manière générale, dans le domaine des systèmes d'information, nous sommes confrontés à divers types de risques, qui découlent tous d'une intrusion sur notre réseau, hormis les DoS (Deny of Service) qui n'ont pour but que de « simplement » rendre le système inutilisable. Ce dernier aspect ne sera pas traité ici, la façon que nous avons d'utiliser le spectre radio n'offrant que très peu de moyens de nous protéger de la méthode d'attaque la plus simple : le brouillage radio. Tout de même, il faut en parler un tout petit peu, dans la mesure où la promiscuité de réseaux sans fil, montés de façon anarchique, peut arriver de façon involontaire à cet état de fait.

3-1-1-1. Intrusion en vue d'une compromission des postes▲

3-1-1-2. Intrusion en vue d'exploitation d'un accès à l'internet▲

3-1-1-3. Intrusion « passive » en vue d'extraire des informations▲

Il existe un certain nombre de règles de base, qu'il faudra mettre en œuvre pour tenter de minimiser ces risques.

3-1-2-1. Savoir qui est présent sur votre réseau▲

3-1-2-2. Cacher les informations échangées▲

3-1-2-3. Assurer un minimum de sécurité au client▲

(Wired Equivalent Privacy). Basée sur une solution de clé de chiffrement statique partagée par tous les membres d'un même réseau Wi-Fi, avec un algorithme de chiffrement devenu aujourd'hui plutôt faible, il a été clairement démontré que cette protection n'en est plus une, et nous ne nous attarderons pas dessus.

Sachez simplement qu'avec des outils comme airodump, aircrack et aireplay, il est possible, de découvrir une clé WEP en quelques dizaines de minutes, voire moins.

Devant la panique générée par la découverte des failles de WEP, et alors même que les différents partenaires travaillaient à l'élaboration d'une norme destinée à sécuriser les réseaux sans fil, il a fallu mettre en place un procédé de secours : le « Wifi Protected Access », issu des travaux non encore aboutis de la norme qui est depuis finalisée et connue sous le doux nom de 802.11i.

WPA apparaît comme un ensemble de rustines logicielles, destinées à boucher les plus gros trous de sécurité du WEP, tout en ayant comme contrainte de pouvoir fonctionner sur le matériel existant. Il est donc possible en général d'exploiter WPA sur du matériel conçu pour WEP.

WPA n'est finalement qu'un compromis, acceptable si l'on doit intégrer à son réseau du matériel ancien, ne supportant pas les méthodes de chiffrement préconisées par 802.11i.

Ce n'est rien de plus que l'appellation commerciale de la norme 802.11i. Cette norme a été finalisée en 2004 et donc, le matériel n'a des chances d'être compatible que s'il a été conçu aux environs de cette date. Le chiffrement préconisé nécessite la présence d'un composant matériel dédié.

WPA comme WPA2 peuvent s'utiliser de deux manières.

3-2-4-1. Mode « personnel »▲

3-2-4-2. Mode « entreprise »▲

Nous allons avoir besoin de plusieurs briques logicielles, dont certaines nous sont déjà familières, d'autres moins.

Un serveur d'authentification est connecté au point d'accès, par réseau filaire. Le type de serveur d'authentification n'est pas défini par les normes, mais clairement, c'est le protocole RADIUS qui est sous-entendu, c'est celui que nous utiliserons. RADIUS est un protocole applicatif, qui s'appuie sur UDP, IP et Ethernet.

Entre le point d'accès et la station cliente, nous sommes sur du 802.11 (WI-FI). Au-dessus, nous trouverons 802.1x.

EAP (Extensible Authentication Protocol) va passer au-dessus de 802.1x dans les airs et au-dessus de RADIUS sur les fils, pour transporter le mode d'authentification choisi (TLS, PEAP, TTLS ou d'autres encore, mais considérés comme moins sûrs).

Dans la suite de cet exposé, nous nous intéresserons surtout à TLS (Transport Layer Security), qui fait appel à des certificats x509 sur le serveur RADIUS comme sur le client.

L'authenticator utilise le protocole 802.1x. C'est un protocole qui a été défini dans le but d'autoriser l'accès physique à un réseau local après une phase d'authentification. Ce protocole peut aussi bien s'appliquer à un « port » physique (un point d'entrée sur un switch, par exemple), que sur un « port » virtuel (l'attachement à un point d'accès Wi-Fi).

Il est peut-être nécessaire de passer un peu de temps à bien comprendre le principe d'un port contrôlé par 802.1x (authenticator). Lorsque le client (supplicant) se connecte (Ethernet) ou s'attache à un point d'accès (802.11), l'accès au LAN lui est fermé. Le seul trafic autorisé sera constitué des échanges entre le supplicant et le serveur d'authentification. Le port ne pourra s'ouvrir sur le LAN sans restrictions qu'une fois l'authentification réussie.

Bien entendu, physiquement, il n'y a qu'un seul port. Ce port physique est composé de deux ports virtuels : * l'un, non contrôlé, mais qui ne laisse passer que le trafic d'authentification (RADIUS), * l'autre, contrôlé, qui est destiné à laisser passer tout le trafic Ethernet, mais qui est fermé jusqu'à ce que l'authentification soit réussie.

802.1x ne peut se jouer qu'à trois personnages :

• le supplicant, qui est le client souhaitant se raccorder au réseau ;
• l'authenticator, ou network access server (NAS) qui est l'équipement sur lequel le « supplicant » désire se connecter ;
• l'authentication server (AS), qui est le serveur d'authentification.

Il est primordial de comprendre qu'une station cliente qui ne sait pas jouer le rôle de « supplicant » ne pourra jamais accéder au LAN. Pour jouer ce rôle, il faut un bout de logiciel spécifique sur le client. Windows XP intègre ce logiciel depuis le SP1. Sous Linux, il faudra installer wpasupplicant, par exemple. La plupart des distributions modernes installent par défaut ce composant.

Typiquement, dans le cadre de notre étude :

• le supplicant sera un PC (GNU/Linux, Mac OS, ou même Windows) ;
• l'authenticator sera un point d'accès Wi-Fi (mais ce pourrait être aussi bien un switch sur un réseau filaire) ;
• l'authentication server sera un serveur RADIUS. (FreeRADIUS 1.1.3, sur une Debian « etch », ou encore sur une Ubuntu 6.10).

Mais 802.1x n'est qu'un support. 802.1x va servir à transporter un protocole d'authentification, comme EAP (Extensible Authentication Protocol). Comme son nom le laisse supposer, EAP est plutôt souple et permet diverses méthodes d'authentification, plus ou moins efficaces. Il faut bien comprendre qu'EAP n'apporte pas à lui seul la moindre authentification, il sert lui-même à supporter diverses méthodes d'authentification.

Nous retiendrons trois de ces méthodes :

• TLS, qui nécessite un certificat pour le serveur comme pour le supplicant ;
• PEAP, où seul un certificat côté serveur est nécessaire, le supplicant utilisant un couple « utilisateur/mot de passe » ;
• TTLS, assez similaire à PEAP, mais non supporté par Microsoft Windows.

Pratiquement, nous ferons du TLS si nous avons le courage de créer un certificat par supplicant, et la liste de révocation qui doit aller avec ; nous ferons du PEAP sinon, puisque c'est possible sur les clients GNU/Linux comme sur les clients Windows et Mac OS X. Les deux solutions apportent un niveau de sécurité technique que l'on peut, au moment où ces lignes sont écrites, considérer comme suffisant.

Cependant, un couple « utilisateur/mot de passe » valide peut s'obtenir plus facilement qu'un certificat. Aussi préfèrerons-nous utiliser TLS que PEAP (ou TTLS).

3-3-1-1. Note importante▲

Lorsque le « supplicant » découvre le point d'accès, ce dernier ne lui ouvre pas de port, jusqu'à ce que le « supplicant » soit authentifié par le serveur. Seul le trafic nécessaire à 802.1x sera toléré avant une authentification réussie.

Entre le supplicant et l'authenticator, aussi longtemps que l'authentification n'est pas entièrement réussie (réponse positive du serveur RADIUS), le seul trafic permis est le dialogue d'authentification, le client n'a pas accès au réseau (depuis le temps que je le dis, j'espère maintenant que c'est bien compris).

Entre l'authenticator et le serveur, le trafic se fait classiquement sur UDP/IP, ce qui permet de disposer d'un serveur d'authentification très éloigné, si besoin est. Ce trafic est appelé « EAP over RADIUS ».

D'une manière générale, les échanges se font de la sorte (cas d'une authentification réussie) :

Compte tenu des divers risques introduits (faux serveur d'authentification, faux point d'accès, faux client), il convient de mettre en place des stratégies qui permettent de minimiser les risques de leurre.

3-3-3-1. Authentification du serveur▲

3-3-3-2. Authentification du client▲

3-3-3-3. Authentification du point d'accès▲

802.11i (WPA2) est une norme tendant à sécuriser un accès sans fil (Wi-Fi). Dans la version « WPA2-Enterprise », celle qui nous intéresse ici, il nous faut 802.1x pour assurer l'attachement du « supplicant » au point d'accès et RADIUS pour la partie authentification. RADIUS n'est pas obligé par la norme, mais c'est un standard de fait.

Dans une connexion sans fil, il convient de prendre un soin particulier à être sûr que :

• l'on s'adresse au bon serveur d'authentification ;
• le point d'accès est bien celui que l'on croit ;
• le client est bien autorisé ;
• le client est bien celui qu'il prétend être ;
• il n'y a pas de « man in the middle » ;
• un point d'accès « voleur » ne peut prendre en cours de session la place du point d'accès « officiel » ;
• un espion ne pourra pas, dans un délai raisonnable, déchiffrer les informations qui circulent dans l'air.

Il y a donc du travail.

Les protocoles d'authentification (TLS, PEAP, TTLS...) ne sont pas du domaine de 802.1X, RADIUS non plus.

Cependant, compte tenu de ce qui a été déjà vu, il est clair qu'il n'y a pas d'alternative.

• Quand le client (supplicant) et le serveur d'authenticication (AS) s'authentifient, un des derniers messages envoyés par le serveur, contient la « Master Key » (MK). Cette clé n'est connue que par le client et le serveur. La MK n'est valable que pour cette session, entre ce client et ce serveur.
  
• Le client et le serveur calculent, à partir de la MK, une nouvelle clé, nommée « Pairwise Master Key » (PMK).
• La PMK est déplacée du serveur vers le point d'accès.  Seuls le client et le serveur savent calculer cette PMK, sinon, le point d'accès pourrait prendre des décisions de contrôle d'accès à la place du serveur. La PMK est une nouvelle clé symétrique, valable uniquement pour cette session, entre ce client et ce point d'accès.
  
• La PMK et une poignée de main en quatre passes (« 4-way handshake ») sont utilisées entre le client et le point d'accès pour calculer et vérifier une « Pairwise Transcient Key » (PTK), qui sera utilisée uniquement dans cette session entre ce client et ce point d'accès. La PTK est en réalité un trousseau de trois clés :
  1. la « Key Confirmation Key » (KCK) qui, comme son nom l'indique, est utilisée pour prouver la possession de la PMK et pour attacher la PMK au point d'accès ;
  2. la « Key Encryption Key » (KEK) est utilisée pour distribuer la « Group Transcient Key » (GTK), décrite plus loin ;
  3. les « Temporal Key 1 & 2 » (TK1/TK2) sont utilisées pour le chiffrement.
• la KEK et un autre « 4-way handshake » sont alors utilisés pour envoyer une « Group Transcient Key » (GTK) du point d'accès vers le client. La GTK est partagée par tous les clients connectés au même point d'accès. Elle est utilisée uniquement pour sécuriser le multicast et le broadcast.

En résumé :

• La MK représente la décision d'accès (positive).
• La PMK représente l'autorisation d'accès au medium 802.11.
• La PTK, contient :
  1. la KCK, utilisée pour attacher la PMK au point d'accès et pour prouver que le point d'accès dispose lui aussi de la PMK (authentification mutuelle entre le point d'accès et le client) ;
  2. la KEK, utilisée pour distribuer la GTK ;
  3. les TK, utilisées pour sécuriser le transfert de données.

Finalement, nous avons bien :

• le client authentifié par le serveur RADIUS ;
• le serveur authentifié par le client,
• le client authentifié par le point d'accès ;
• le point d'accès authentifié par le client ;
• les données sont sécurisées. Chaque paquet (et même chaque fragment de paquet) est authentifié, si bien qu'il n'est normalement pas possible d'injecter frauduleusement des paquets forgés.

Le point d'accès et le serveur sont reliés par le réseau filaire. A priori, il y a moins de dangers. L'authentification mutuelle se fait par un « secret partagé », comme nous le verrons dans la mise en œuvre.

Il en existe de très officielles, leurs services coûtent généralement une fortune. Nous nous contenterons, au sein de notre système, de créer notre propre CA. Pratiquement, il faut créer un certificat de CA, qui permettra d'authentifier tous les autres certificats que nous devrons créer.

TLS (Transport Layer Security) n'est autre que SSL v3 (Secure Socket Layer). Ici, nous aurons besoin d'un certificat x509 sur le serveur et sur le client. L'authentification se fait au moyen des clés privées (un message chiffré par une clé privée authentifie son auteur).

Avec cette méthode, il faut donc créer un certificat pour le serveur mais aussi un certificat par client. Le client n'a pas besoin de disposer d'un « login/password », le certificat suffit à l'authentifier.

Ici, seul le certificat du serveur suffit. Il permettra de construire un « tunnel chiffré » dans lequel voyagera le mot de passe du client. Une interception du trafic ne permettra que de récupérer un mot de passe chiffré.

Très similaire à TTLS, mais en plus le mot de passe ne circule pas dans le tunnel. Il s'agit ici d'un « challenge », réalisé au moyen du protocole MSCHAP v2 (d'origine Microsoft). PEAP est réputé encore plus sûr que TTLS.

Cette méthode peut être employée si l'on dispose d'un domaine Microsoft, avec ActiveDirectory, et que l'on souhaite que les utilisateurs s'authentifient avec leur « login/password » du domaine. Il « suffira » dans ce cas de configurer convenablement le serveur FreeRADIUS pour qu'il puisse consulter l'annuaire de ActiveDirectory, ce qui, en contrepartie, dispense de créer un certificat par client.

Il existe d'autres méthodes supportées par 802.1x, mais ce sont ces trois méthodes réputées les plus sécurisées.

C'est bien sûr la première opération à réaliser. D'ailleurs la fenêtre qui suit est la première que vous verrez au premier lancement de tinyca :

Puis vient la configuration. Pour les tests, nous garderons les valeurs par défaut :

Le temps que les clés se construisent, et nous obtenons :

Le menu « préférences » va nous permettre de donner quelques directives fondamentales pour ce que nous avons à faire.

Pour les certificats du serveur, nous devons ajouter l'extension 1.3.6.1.5.5.7.3.1, ce qui, en français, signifie que le certificat est destiné à un serveur d'authentification. De même, choisissez la durée de validité du certificat (ici, un an). À l'échéance, il faudra penser faire un nouveau certificat.

Pour les certificats des clients, nous devons ajouter l'extension 1.3.6.1.5.5.7.3.2, qui signifie que les certificats sont destinés à authentifier les clients. Pensez aussi à leur durée de validité.

La création des divers certificats (serveur et clients) suit la même procédure, en utilisant le paramétrage par défaut effectué plus haut. Il suffit de compléter les champs vides :

En réalité, nous n'avons créé qu'une requête de certificat. Cette requête doit maintenant être validée par la CA, ce qui se traduit par l'apposition de la signature de la CA. Il s'agit du mot de passe choisi lors de la création de la CA :

Notez que lors de cette opération, il est possible de modifier la durée de validité. C'est important surtout pour les certificats clients. Il est en effet possible d'envisager la création de certificats à durée très courte, dans le cas de clients de passage, par exemple, ou pour des autorisations ponctuelles.

À l'issue de la signature, assurez-vous que le compte-rendu est positif. Nous devons retrouver le certificat inscrit dans la liste :

Procédure identique :

Je passe les détails de signature. Finalement, nous avons :

Ce certificat, qui représente la racine de confiance, devra être présent sur le serveur RADIUS et sur tous les clients. Nous devons donc l'exporter dans des formats compatibles avec OpenSSL (pem) et Windows (der).

Rappelons que c'est ce certificat qui permettra :

• au serveur de s'assurer que les certificats présentés par les clients sont bien authentiques ;
• aux clients de s'assurer que le certificat présenté par le serveur est bien authentique.

Vérifions que l'exportation est réussie :

Et recommençons l'opération, mais au format .der (je passe les détails).

Ce certificat ne sera installé que sur le serveur FreeRADIUS, donc le format pem (avec la clé privée et l'empreinte intégrées) suffira :

Ce certificat servira à « user1 ». Suivant qu'il utilisera Windows ou GNU/Linux, il lui faudra un .pem ou un .pkcs#12 (clé privée intégrée). C'est un utilisateur bicéphale, son portable est en « dual-boot ».

L'exportation au format .pem se fait de la même manière que pour le serveur, passons les détails. En revanche, pour le format pkcs#12, c'est un petit peu plus compliqué :

Deux mots de passe sont demandés :

• le premier (Key password) correspond à celui qui a été saisi lors de la création du certificat ;
• le second (Export Password) sera nécessaire lors de l'installation du certificat chez le client.

Finalement, nous avons dans notre répertoire d'exportation :

• root_maison_CA-cacert.der ;
• root_maison_CA-cacert.pem (les certificats de l'autorité) ;
• sysop@maison.mrs-cert.pem  (le certificat du serveur) ;
• user1@maison.mrs-cert.pem ;
• user1@maison.mrs-cert.p12 (le certificat du client, dans les deux formats nécessaires).

Il peut se faire, pour de multiples raisons, que l'on doive rendre inopérant un certificat avant sa date d'expiration :

• la clé privée est compromise ;
• le possesseur du certificat n'en a plus besoin plus tôt que prévu ;
• le possesseur du certificat a enfreint les règles et doit se voir banni du réseau ;
• et tant d'autres raisons.

Il faut donc disposer d'un moyen pour que le serveur RADIUS puisse rejeter des certificats non expirés, mais désormais interdits d'accès.

Dans un tel cas, il faut alors pouvoir créer un certificat de révocations qu'il sera nécessaire d'installer sur le serveur, et le configurer pour qu'il le consulte à chaque authentification. Tinyca sait réaliser de tels certificats. Ici, nous avons révoqué le certificat de « user2 » :

Il nous faut maintenant exporter un certificat des révocations :

Attention à la durée de validité d'un tel certificat. Bien entendu, ce certificat ne doit jamais expirer.

Nous retrouvons dans le répertoire d'exportation le certificat :

root_maison_CA-crl.pem.

RADIUS (Remote Authentication Dial-In User Service) est un vaste programme. Pour essayer de faire simple (donc schématique et incomplet), ce service est capable :

• d'authentifier un utilisateur distant, suivant de multiples modes plus ou moins sécurisés, en s'appuyant sur une base de connaissances allant du simple fichier texte à l'annuaire LDAP, en passant par une base de données de type SQL ;
• d'enregistrer des informations sur chaque « login » ;
• de renvoyer au demandeur des paramètres variés pouvant, suivant le cas, être une configuration IP, un numéro de LAN virtuel, etc.

Étudier dans le détail toutes les possibilités de RADIUS est hors de la portée de cet exposé. (c'est, de toute façon, également hors de ma propre portée). Nous nous contenterons ici de le mettre en œuvre dans les deux cas qui nous intéressent :

• authentification depuis leur adresse MAC des stations « connues » sur notre réseau filaire, en utilisant un système de type « login/password », avec le protocole CHAP (Challenge-Handshake Authentication Protocol), éventuellement en assignant un numéro de VLAN suivant la machine ;
• authentification avec un certificat x.509 sur le réseau Wi-Fi, en utilisant EAP-TLS.

Installer et surtout configurer un serveur radius pour la première fois a quelque chose d'assez rebutant, voire repoussant. Nous allons passer un peu de temps à détailler cette opération, ceci aidera probablement ceux qui n'ont encore jamais tenté l'aventure. Nous utilisons FreeRADIUS sur une Debian Lenny.

FreeRadius peut fonctionner en s'appuyant uniquement sur des fichiers texte. Ce n'est pas forcément ce qu'il y a de plus simple à gérer, si l'on doit manipuler un grand nombre de clients. Ici, nous utiliserons MySQL pour stocker les adresses MAC des clients. Outre la souplesse qu'apportent des outils comme phpmyadmin pour gérer la liste des clients, cette solution offre l'avantage de ne pas nécessiter de redémarrage de FreeRADIUS à chaque modification de la base.

Pour des raisons de compatibilité de licences, FreeRadius est compilé par défaut sur Debian (Lenny) sans le support de TLS. TLS nous servira pour le WPA2. Nous allons donc reconstruire un paquet binaire à partir du paquet source, en tenant compte de cet usage.

Notons que ceci n'a plus lieu d'être sur Squeeze, ce qui simplifiera notre tâche, l'installation du binaire standard suffira à nos besoins.

4-1-2-1. Préparatifs▲

# aptitude install build-essential
...
# aptitude install apt-src

# apt-src update

# mkdir ~/build_freeradius
# cd ~/build_freeradius
# apt-src install freeradius

# ls -l
total 2908
drwxr-xr-x 15 root root    4096 mar  4 15:14 freeradius-2.0.4+dfsg
-rw-r--r--  1 root root    4860 sep  7 20:02 freeradius_2.0.4+dfsg-6.diff.gz
-rw-r--r--  1 root root    1476 sep  7 20:02 freeradius_2.0.4+dfsg-6.dsc
-rw-r--r--  1 root root 2953674 mai 19  2008 freeradius_2.0.4+dfsg.orig.tar.gz

4-1-2-2. Configuration de la compilation▲

        ./configure $(confflags) \
                --prefix=/usr \
                --exec-prefix=/usr \
                --mandir=$(mandir) \
                --sysconfdir=/etc \
                --libdir=$(libdir) \
                --datadir=/usr/share \
                --localstatedir=/var \
                --with-raddbdir=$(raddbdir) \
                --with-logdir=/var/log/$(package) \
                --enable-ltdl-install=no --enable-strict-dependencies \
                --with-large-files --with-udpfromto --with-edir \
                --enable-developer \
                --config-cache \
                --without-rlm_eap_tls \
                --without-rlm_eap_ttls \
                --without-rlm_eap_peap \
                --without-rlm_eap_tnc \
                --without-rlm_otp \
                --with-rlm_sql_postgresql_lib_dir=`pg_config --libdir` \
                --with-rlm_sql_postgresql_include_dir=`pg_config --includedir` \
                --without-openssl \
                --without-rlm_eap_ikev2 \
                --without-rlm_sql_oracle \
                --without-rlm_sql_unixodbc \
                --with-system-libtool

    ./configure $(confflags) \
        --prefix=/usr \
        --exec-prefix=/usr \
        --mandir=$(mandir) \
        --sysconfdir=/etc \
        --libdir=$(libdir) \
        --datadir=/usr/share \
        --localstatedir=/var \
        --with-raddbdir=$(raddbdir) \
        --with-logdir=/var/log/$(package) \
        --enable-ltdl-install=no --enable-strict-dependencies \
        --with-large-files --with-udpfromto --with-edir \
        --enable-developer \
        --config-cache \
        --without-rlm_eap_tnc \
        --with-rlm_sql_postgresql_lib_dir=`pg_config --libdir` \
        --with-rlm_sql_postgresql_include_dir=`pg_config --includedir` \
        --without-rlm_eap_ikev2 \
        --without-rlm_sql_oracle \
        --without-rlm_sql_unixodbc \
        --with-system-libtool

    for pkg in ${pkgs} ; do \
      if dh_shlibdeps -p $$pkg -- -O 2>/dev/null | grep -q libssl; then \
        echo "$$pkg links to openssl" ;\
        exit 1 ;\
      fi ;\
    done

    for pkg in ${pkgs} ; do \
      if dh_shlibdeps -p $$pkg -- -O 2>/dev/null | grep -q libssl; then \
        echo "$$pkg links to openssl" ;\
#        exit 1 ;\
      fi ;\
    done

#!/usr/bin/make -f
# -*- makefile -*-
# Sample debian/rules that uses debhelper.
#
# This file was originally written by Joey Hess and Craig Small.
# As a special exception, when this file is copied by dh-make into a
# dh-make output file, you may use that output file without restriction.
# This special exception was added by Craig Small in version 0.37 of dh-make.
#
# Modified to make a template file for a multi-binary package with separated
# build-arch and build-indep targets  by Bill Allombert 2001

# Uncomment this to turn on verbose mode.
export DH_VERBOSE=1

.NOTPARALLEL:

SHELL           =/bin/bash

package         = freeradius
freeradius_dir  = $(CURDIR)/debian/tmp/

mandir          = /usr/share/man
libdir          = /usr/lib/$(package)
logdir          = /var/log/$(package)
pkgdocdir       = /usr/share/doc/$(package)
raddbdir        = /etc/$(package)

modulelist=krb5 ldap sql_mysql sql_iodbc sql_postgresql
pkgs=$(shell dh_listpackages)

# This has to be exported to make some magic below work.
export DH_OPTIONS

# These are used for cross-compiling and for saving the configure cript
# from having to guess our platform (since we know it already)
export DEB_HOST_GNU_TYPE  ?= $(shell dpkg-architecture -qDEB_HOST_GNU_TYPE)
export DEB_BUILD_GNU_TYPE ?= $(shell dpkg-architecture -qDEB_BUILD_GNU_TYPE)

ifneq (,$(findstring noopt,$(DEB_BUILD_OPTIONS)))
        CFLAGS += -O0
else
        CFLAGS += -O2
endif

ifeq ($(DEB_BUILD_GNU_TYPE), $(DEB_HOST_GNU_TYPE))
        confflags += --build $(DEB_HOST_GNU_TYPE)
else
        confflags += --build $(DEB_BUILD_GNU_TYPE) --host $(DEB_HOST_GNU_TYPE)
endif

config.status: configure
        dh_testdir

ifeq (config.sub.dist,$(wildcard config.sub.dist))
        rm config.sub
else
        mv config.sub config.sub.dist
endif
ifeq (config.guess.dist,$(wildcard config.guess.dist))
        rm config.guess
else
        mv config.guess config.guess.dist
endif
        ln -s /usr/share/misc/config.sub config.sub
        ln -s /usr/share/misc/config.guess config.guess
        

        ./configure $(confflags) \
                --prefix=/usr \
                --exec-prefix=/usr \
                --mandir=$(mandir) \
                --sysconfdir=/etc \
                --libdir=$(libdir) \
                --datadir=/usr/share \
                --localstatedir=/var \
                --with-raddbdir=$(raddbdir) \
                --with-logdir=/var/log/$(package) \
                --enable-ltdl-install=no --enable-strict-dependencies \
                --with-large-files --with-udpfromto --with-edir \
                --enable-developer \
                --config-cache \
                --without-rlm_eap_tnc \
                --with-rlm_sql_postgresql_lib_dir=`pg_config --libdir` \
                --with-rlm_sql_postgresql_include_dir=`pg_config --includedir` \
                --without-rlm_eap_ikev2 \
                --without-rlm_sql_oracle \
                --without-rlm_sql_unixodbc \
                --with-system-libtool

#Architecture 
build: build-arch build-indep

build-arch: build-arch-stamp
build-arch-stamp: config.status
        $(MAKE) 
        touch $@

build-indep: build-indep-stamp
build-indep-stamp: config.status
        touch $@

clean:
        dh_testdir
        dh_testroot
        rm -f build-arch-stamp build-indep-stamp 
        rm -f config.cache config.log
        
        [ ! -d src/modules/lib ] || rm -fr src/modules/lib || true
        [ ! -d src/binary ] || rm -fr src/binary || true

        # Add here commands to clean up after the build process.
ifeq (Make.inc,$(wildcard Make.inc))
        $(MAKE) distclean
endif
ifeq (config.sub.dist,$(wildcard config.sub.dist))
        rm -f config.sub
        mv config.sub.dist config.sub
endif
ifeq (config.guess.dist,$(wildcard config.guess.dist))
        rm -f config.guess
        mv config.guess.dist config.guess
endif
        dh_clean 

install: install-indep install-arch
install-indep: build-indep-stamp
        dh_testdir
        dh_testroot
        dh_installdirs -i

        $(MAKE) -C dialup_admin DIALUP_PREFIX=/usr/share/freeradius-dialupadmin \
                                DIALUP_DOCDIR=/usr/share/doc/freeradius-dialupadmin \
                                DIALUP_CONFDIR=/etc/freeradius-dialupadmin \
                                R=$(freeradius_dir) install

        mv $(freeradius_dir)/usr/share/freeradius-dialupadmin/bin/dialup_admin.cron \
               $(freeradius_dir)/usr/share/freeradius-dialupadmin/bin/freeradius-dialupadmin.cron
        mv $(freeradius_dir)/usr/share/doc/freeradius-dialupadmin/Changelog \
               $(freeradius_dir)/usr/share/doc/freeradius-dialupadmin/changelog

        install -m0644 debian/apache2.conf $(freeradius_dir)/etc/freeradius-dialupadmin/

        dh_install -i --sourcedir=$(freeradius_dir)
        dh_installdocs -p freeradius-dialupadmin dialup_admin/README

install-arch: build-arch-stamp
        dh_testdir
        dh_testroot
        dh_installdirs -s
        test -d $(freeradius_dir)/usr/lib/freeradius || mkdir -p $(freeradius_dir)/usr/lib/freeradius
        ln -s rlm_sql.so $(freeradius_dir)/usr/lib/freeradius/librlm_sql.so
        $(MAKE) install R=$(freeradius_dir)
        
        # rename radius binary to play nicely with others
        mv $(freeradius_dir)/usr/sbin/radiusd $(freeradius_dir)/usr/sbin/$(package)
        mv $(freeradius_dir)/$(mandir)/man8/radiusd.8 $(freeradius_dir)/$(mandir)/man8/$(package).8
        
        dh_install --sourcedir=$(freeradius_dir) -p libfreeradius2
        dh_install --sourcedir=$(freeradius_dir) -p libfreeradius-dev

        for mod in ${modulelist}; do \
          pkg=$${mod##sql_} ; \
          dh_install --sourcedir=$(freeradius_dir) -p freeradius-$$pkg ; \
          rm -f $(freeradius_dir)/usr/lib/freeradius/rlm_$$mod*.so ; \
        done

        dh_install --sourcedir=$(freeradius_dir) -p freeradius-utils
        dh_install --sourcedir=$(freeradius_dir) -p freeradius
        
        dh_strip -a --dbg-package=freeradius-dbg

        dh_makeshlibs -a -n
        for pkg in ${pkgs} ; do \
          if dh_shlibdeps -p $$pkg -- -O 2>/dev/null | grep -q libssl; then \
            echo "$$pkg links to openssl" ;\
#           exit 1 ;\
          fi ;\
        done
        dh_shlibdeps

binary-common:
        dh_testdir
        dh_testroot
        dh_installchangelogs 
        dh_installdocs
        dh_installexamples
        dh_installlogrotate     
        dh_installpam --name=radiusd 
        dh_installinit --noscripts
        dh_installman
        dh_lintian
        dh_link
        dh_compress -Xexamples
        dh_fixperms
        dh_installdeb
        dh_gencontrol
        dh_md5sums
        dh_builddeb

# Build architecture independant packages using the common target.
binary-indep: build-indep install-indep
        $(MAKE) -f debian/rules DH_OPTIONS=-i binary-common

# Build architecture dependant packages using the common target.
binary-arch: build-arch install-arch
        $(MAKE) -f debian/rules DH_OPTIONS=-s binary-common

binary: binary-arch binary-indep
.PHONY: build clean binary-indep binary-arch binary install install-indep install-arch

4-1-2-3. Le fichier « control »▲

Source: freeradius
Build-Depends: autotools-dev, debhelper (>= 6.0.7), libgdbm-dev, libiodbc2-dev, libkrb5-dev, libldap2-dev, libltdl3-dev, libmysqlclient15-dev | libmysqlclient-dev, libpam0g-dev, libpcap-dev, libperl-dev, libpq-dev, libsasl2-dev, libsnmp-dev, libtool, python-dev, libssl-dev
Section: net
Priority: optional
Maintainer: Stephen Gran 
Uploaders: Mark Hymers 
Standards-Version: 3.7.3
...

aptitude install libssl-dev

4-1-2-4. construction des binaires▲

cd ~/build_freeradius
apt-src build freeradius

ls -l *.deb
-rw-r--r-- 1 root root 513228 fév 22 16:20 freeradius_2.0.4+dfsg-6_i386.deb
-rw-r--r-- 1 root root 205030 fév 22 16:21 freeradius-common_2.0.4+dfsg-6_all.deb
-rw-r--r-- 1 root root 949458 fév 22 16:20 freeradius-dbg_2.0.4+dfsg-6_i386.deb
-rw-r--r-- 1 root root 132748 fév 22 16:21 freeradius-dialupadmin_2.0.4+dfsg-6_all.deb
-rw-r--r-- 1 root root  17184 fév 22 16:20 freeradius-iodbc_2.0.4+dfsg-6_i386.deb
-rw-r--r-- 1 root root  18082 fév 22 16:20 freeradius-krb5_2.0.4+dfsg-6_i386.deb
-rw-r--r-- 1 root root  34426 fév 22 16:20 freeradius-ldap_2.0.4+dfsg-6_i386.deb
-rw-r--r-- 1 root root  24874 fév 22 16:20 freeradius-mysql_2.0.4+dfsg-6_i386.deb
-rw-r--r-- 1 root root  35364 fév 22 16:20 freeradius-postgresql_2.0.4+dfsg-6_i386.deb
-rw-r--r-- 1 root root  71282 fév 22 16:20 freeradius-utils_2.0.4+dfsg-6_i386.deb
-rw-r--r-- 1 root root  85212 fév 22 16:20 libfreeradius2_2.0.4+dfsg-6_i386.deb
-rw-r--r-- 1 root root 103672 fév 22 16:20 libfreeradius-dev_2.0.4+dfsg-6_i386.deb

4-1-2-5. Installation des paquets utiles▲

dpkg -i libfreeradius2_2.0.4+dfsg-6_i386.deb freeradius-common_2.0.4+dfsg-6_all.deb freeradius_2.0.4+dfsg-6_i386.deb freeradius-mysql_2.0.4+dfsg-6_i386.deb freeradius-utils_2.0.4+dfsg-6_i386.deb

4-1-2-6. Se protéger des mises à jour de « aptitude »▲

:~# dpkg --get-selections > packages

aptitude search freeradius | grep ^i
i   freeradius                      - a high-performance and highly configurable
i   freeradius-common               - FreeRadius common files
i   freeradius-mysql                - MySQL module for FreeRADIUS server
i   freeradius-utils                - FreeRadius client utilities
i   libfreeradius2                  - FreeRADIUS shared library

cat packages | grep radius
freeradius                    install
freeradius-common                install
freeradius-mysql                install
freeradius-utils                install
libfreeradius2                    install

cat packages | grep radius
freeradius                    hold
freeradius-common                hold
freeradius-mysql                hold
freeradius-utils                hold
libfreeradius2                    hold

:~# dpkg --set-selections < packages

aptitude search freeradius | grep ^i
ih  freeradius                      - a high-performance and highly configurable
ih  freeradius-common               - FreeRadius common files
ih  freeradius-mysql                - MySQL module for FreeRADIUS server
ih  freeradius-utils                - FreeRadius client utilities
ih  libfreeradius2                  - FreeRADIUS shared library

4-1-3-1. Création de la base MySQL▲

# mysql -V
mysql  Ver 14.12 Distrib 5.0.51a, for debian-linux-gnu (i486) using readline 5.2
Création de la base : 
# mysql -u root -p
Enter password: 
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 42
Server version: 5.0.51a-24 (Debian)

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql> CREATE DATABASE radius;
Query OK, 1 row affected (0.01 sec)

CREATE USER 'radius'@'localhost' IDENTIFIED BY 'epikoi';
GRANT SELECT ON radius . * TO 'radius'@'localhost';

# mysql -uroot -pepikoi radius
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 83
Server version: 5.0.51a-24-log (Debian)

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql> show tables;
+------------------+
| Tables_in_radius |
+------------------+
| nas              |
| radacct          |
| radcheck         |
| radgroupcheck    |
| radgroupreply    |
| radpostauth      |
| radreply         |
| radusergroup     |
+------------------+
8 rows in set (0.00 sec)

4-1-3-2. Configuration de FreeRADIUS▲

# cat radiusd.conf | egrep -v -e '[[:blank:]]*#|^$' | grep \$INCLUDE
$INCLUDE proxy.conf
$INCLUDE clients.conf
$INCLUDE snmp.conf
$INCLUDE eap.conf
$INCLUDE policy.conf
$INCLUDE sites-enabled/

cd /etc/freeradius
mv radiusd.conf radiusd.conf.dist

cat radiusd.conf.dist | egrep -v -e '^[[:blank:]]*#|^$' > radiusd.conf

prefix = /usr
exec_prefix = /usr
sysconfdir = /etc
localstatedir = /var
sbindir = ${exec_prefix}/sbin
logdir = /var/log/freeradius
raddbdir = /etc/freeradius
radacctdir = ${logdir}/radacct
confdir = ${raddbdir}
run_dir = ${localstatedir}/run/freeradius
db_dir = $(raddbdir)
libdir = /usr/lib/freeradius
pidfile = ${run_dir}/freeradius.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 = no
        auth = no
        auth_badpass = no
        auth_goodpass = no
}
checkrad = ${sbindir}/checkrad
security {
        max_attributes = 200
        reject_delay = 1
        status_server = yes
}
#proxy_requests  = yes
#$INCLUDE proxy.conf
#$INCLUDE clients.conf
snmp    = no
#$INCLUDE snmp.conf
thread pool {
        start_servers = 5
        max_servers = 32
        min_spare_servers = 3
        max_spare_servers = 10
        max_requests_per_server = 0
}
modules {
#       pap {
#               auto_header = no
#       }
        chap {
                authtype = CHAP
        }
#       pam {
#               pam_auth = radiusd
#       }
#       unix {
#               radwtmp = ${logdir}/radwtmp
#       }
$INCLUDE eap.conf
        mschap {
        }
        ldap {
                server = "ldap.your.domain"
                basedn = "o=My Org,c=UA"
                filter = "(uid=%{Stripped-User-Name:-%{User-Name}})"
                ldap_connections_number = 5
                timeout = 4
                timelimit = 3
                net_timeout = 1
                tls {
                        start_tls = no
                }
                dictionary_mapping = ${confdir}/ldap.attrmap
                edir_account_policy_check = no
        }
        realm IPASS {
                format = prefix
                delimiter = "/"
        }
        realm suffix {
                format = suffix
                delimiter = "@"
        }
        realm realmpercent {
                format = suffix
                delimiter = "%"
        }
        realm ntdomain {
                format = prefix
                delimiter = "\\"
        }       
        checkval {
                item-name = Calling-Station-Id
                check-name = Calling-Station-Id
                data-type = string
        }
        
        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
                preproxy_usersfile = ${confdir}/preproxy_users
                compat = no
        }
        detail {
                detailfile = ${radacctdir}/%{Client-IP-Address}/detail-%Y%m%d
                detailperm = 0600
                header = "%t"
        }
        acct_unique {
                key = "User-Name, Acct-Session-Id, NAS-IP-Address, Client-IP-Address, NAS-Port"
        }
        $INCLUDE ${confdir}/sql.conf
        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 attr_filter.post-proxy {
                attrsfile = ${confdir}/attrs
        }
        attr_filter attr_filter.pre-proxy {
                attrsfile = ${confdir}/attrs.pre-proxy
        }
        attr_filter attr_filter.access_reject {
                key = %{User-Name}
                attrsfile = ${confdir}/attrs.access_reject
        }
        attr_filter attr_filter.accounting_response {
                key = %{User-Name}
                attrsfile = ${confdir}/attrs.accounting_response
        }
        counter daily {
                filename = ${db_dir}/db.daily
                key = User-Name
                count-attribute = Acct-Session-Time
                reset = daily
                counter-name = Daily-Session-Time
                check-name = Max-Daily-Session
                reply-name = Session-Timeout
                allowed-servicetype = Framed-User
                cache-size = 5000
        }
        always fail {
                rcode = fail
        }
        always reject {
                rcode = reject
        }
        always noop {
                rcode = noop
        }
        always handled {
                rcode = handled
        }
        always updated {
                rcode = updated
        }
        always notfound {
                rcode = notfound
        }
        always ok {
                rcode = ok
                simulcount = 0
                mpp = no
        }
        expr {
        }
        digest {
        }
        expiration {
                reply-message = "Password Has Expired\r\n" 
        }
        logintime {
                reply-message = "You are calling outside your allowed timespan\r\n"
                minimum-timeout = 60
        }
        exec {
                wait = yes
                input_pairs = request
                shell_escape = yes
                output = none
        }
        exec echo {
                wait = yes
                program = "/bin/echo %{User-Name}"
                input_pairs = request
                output_pairs = reply
                shell_escape = yes
        }
        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 = ${db_dir}/db.ippool
                ip-index = ${db_dir}/db.ipindex
                override = no
                maximum-timeout = 0
        }
        policy {
               filename = ${confdir}/policy.txt
        }
}
instantiate {
        exec
        expr
        expiration
        logintime
}
$INCLUDE policy.conf
$INCLUDE sites-enabled/

authorize {
        preprocess
        eap {
                ok = return
        }
        sql
}
authenticate {
        Auth-Type CHAP {
                chap
        }
        eap
}
session {
        sql
}

openssl dhparam -check -text -5 512 -out dh

dd if=/dev/urandom of=random count=2

/etc/freeradius/certs# ls -l
total 12
-rw-r----- 1 root freerad    0 2007-03-12 11:11 dh
-rw-r----- 1 root freerad 3242 2007-03-12 15:38 maison.mrs-cert.pem
-rw-r----- 1 root freerad 1024 2007-03-12 11:11 random
-rw-r----- 1 root freerad 2610 2007-03-12 15:25 root_maison_CA-cacert.pem

        eap {
                default_eap_type = tls
                timer_expire     = 60
                ignore_unknown_eap_types = no
                cisco_accounting_username_bug = no
                tls {
                        private_key_password = epikoi
                        private_key_file = ${raddbdir}/certs/maison.mrs-cert.pem
                        certificate_file = ${raddbdir}/certs/maison.mrs-cert.pem
                        CA_file = ${raddbdir}/certs/Root_maison_CA-cacert.pem
                        CA_path = ${raddbdir}/certs/
                        dh_file = ${raddbdir}/certs/dh
                        random_file = ${raddbdir}/certs/random
                        fragment_size = 1024
                        include_length = yes
                        check_crl = no
                }

                mschapv2 {
                }
        }

sql {
    database = "mysql"
    driver = "rlm_sql_${database}"
    server = "localhost"
    login = "radius"
    password = "epikoi"
    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 = 5
    connect_failure_retry_delay = 60
    nas_table = "nas"
    $INCLUDE sql/${database}/dialup.conf
    readclients = yes
}

4-1-4-1. Essai chap▲

echo "INSERT INTO nas(nasname,shortname,secret) VALUES ('127.0.0.1','localhost','naspassword');" | mysql -u root -p radius

echo "INSERT INTO radcheck(UserName,Attribute,op,Value) VALUES ('test0','Cleartext-Password',':=','userpassword');" | mysql -u root -p radius

freeradius -X

FreeRADIUS Version 2.0.4, for host i486-pc-linux-gnu, built on Feb 22 2009 at 16:19:09
Copyright (C) 1999-2008 The FreeRADIUS server project and contributors. 
There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A 
PARTICULAR PURPOSE. 
You may redistribute copies of FreeRADIUS under the terms of the 
GNU General Public License. 
Starting - reading configuration files ...
including configuration file /etc/freeradius/radiusd.conf
including configuration file /etc/freeradius/eap.conf
including configuration file /etc/freeradius/sql.conf
including configuration file /etc/freeradius/sql/mysql/dialup.conf
including configuration file /etc/freeradius/policy.conf
including files in directory /etc/freeradius/sites-enabled/
including configuration file /etc/freeradius/sites-enabled/default
including dictionary file /etc/freeradius/dictionary
main {
        prefix = "/usr"
        localstatedir = "/var"
        logdir = "/var/log/freeradius"
        libdir = "/usr/lib/freeradius"
        radacctdir = "/var/log/freeradius/radacct"
        hostname_lookups = no
        max_request_time = 30
        cleanup_delay = 5
        max_requests = 1024
        allow_core_dumps = no
        pidfile = "/var/run/freeradius/freeradius.pid"
        user = "freerad"
        group = "freerad"
        checkrad = "/usr/sbin/checkrad"
        debug_level = 0
        proxy_requests = yes
 security {
        max_attributes = 200
        reject_delay = 1
        status_server = yes
 }
}
radiusd: #### Loading Realms and Home Servers ####
radiusd: #### Instantiating modules ####
 instantiate {
 Module: Linked to module rlm_exec
 Module: Instantiating exec
  exec {
        wait = yes
        input_pairs = "request"
        shell_escape = yes
  }
 Module: Linked to module rlm_expr
 Module: Instantiating expr
 Module: Linked to module rlm_expiration
 Module: Instantiating expiration
  expiration {
        reply-message = "Password Has Expired  "
  }
 Module: Linked to module rlm_logintime
 Module: Instantiating logintime
  logintime {
        reply-message = "You are calling outside your allowed timespan  "
        minimum-timeout = 60
  }
 }
radiusd: #### Loading Virtual Servers ####
server {
 modules {
 Module: Checking authenticate {...} for more modules to load
 Module: Linked to module rlm_eap
 Module: Instantiating eap
  eap {
        default_eap_type = "tls"
        timer_expire = 60
        ignore_unknown_eap_types = no
        cisco_accounting_username_bug = no
  }
 Module: Linked to sub-module rlm_eap_tls
 Module: Instantiating eap-tls
   tls {
        rsa_key_exchange = no
        dh_key_exchange = yes
        rsa_key_length = 512
        dh_key_length = 512
        verify_depth = 0
        CA_path = "/etc/freeradius/certs/"
        pem_file_type = yes
        private_key_file = "/etc/freeradius/certs/radius.eme.org-cert.pem"
        certificate_file = "/etc/freeradius/certs/radius.eme.org-cert.pem"
        CA_file = "/etc/freeradius/certs/Root_EME_CA-cacert.pem"
        private_key_password = "ph34rl3r4dius"
        dh_file = "/etc/freeradius/certs/dh"
        random_file = "/etc/freeradius/certs/random"
        fragment_size = 1024
        include_length = yes
        check_crl = no
   }
 Module: Linked to sub-module rlm_eap_mschapv2
 Module: Instantiating eap-mschapv2
   mschapv2 {
        with_ntdomain_hack = no
   }
 Module: Linked to module rlm_chap
 Module: Instantiating chap
 Module: Checking authorize {...} for more modules to load
 Module: Linked to module rlm_preprocess
 Module: Instantiating preprocess
  preprocess {
        huntgroups = "/etc/freeradius/huntgroups"
        hints = "/etc/freeradius/hints"
        with_ascend_hack = no
        ascend_channels_per_line = 23
        with_ntdomain_hack = no
        with_specialix_jetstream_hack = no
        with_cisco_vsa_hack = no
        with_alvarion_vsa_hack = no
  }
 Module: Linked to module rlm_sql
 Module: Instantiating sql
  sql {
        driver = "rlm_sql_mysql"
        server = "localhost"
        port = ""
        login = "radius"
        password = "epikoi"
        radius_db = "radius"
        read_groups = yes
        sqltrace = yes
        sqltracefile = "/var/log/freeradius/sqltrace.sql"
        readclients = yes
        deletestalesessions = yes
        num_sql_socks = 5
        sql_user_name = "%{User-Name}"
        default_user_profile = ""
        nas_query = "SELECT id, nasname, shortname, type, secret FROM nas"
        authorize_check_query = "SELECT id, username, attribute, value, op FROM radcheck WHERE username = '%{SQL-User-Name}' ORDER BY id"
        authorize_reply_query = "SELECT id, username, attribute, value, op FROM radreply WHERE username = '%{SQL-User-Name}' ORDER BY id"
        authorize_group_check_query = "SELECT id, groupname, attribute, value, op FROM radgroupcheck WHERE groupname = '%{Sql-Group}' ORDER BY id"
        authorize_group_reply_query = "SELECT id, groupname, attribute, value, op FROM radgroupreply WHERE groupname = '%{Sql-Group}' ORDER BY id"
        accounting_onoff_query = ""
        accounting_update_query = ""
        accounting_update_query_alt = ""
        accounting_start_query = ""
        accounting_start_query_alt = ""
        accounting_stop_query = ""
        accounting_stop_query_alt = ""
        group_membership_query = "SELECT groupname FROM radusergroup WHERE username = '%{SQL-User-Name}' ORDER BY priority"
        connect_failure_retry_delay = 60
        simul_count_query = ""
        simul_verify_query = ""
        postauth_query = "INSERT INTO radpostauth (username, pass, reply, authdate) VALUES ('%{User-Name}','%{%{User-Password}:-%{Chap-Password}}','%{reply:Packet-Type}', '%S')"
        safe-characters = "@abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-_: /"
  }
rlm_sql (sql): Driver rlm_sql_mysql (module rlm_sql_mysql) loaded and linked
rlm_sql (sql): Attempting to connect to radius@localhost:/radius
rlm_sql (sql): starting 0
rlm_sql (sql): Attempting to connect rlm_sql_mysql #0
rlm_sql_mysql: Starting connect to MySQL server for #0
rlm_sql (sql): Connected new DB handle, #0
rlm_sql (sql): starting 1
rlm_sql (sql): Attempting to connect rlm_sql_mysql #1
rlm_sql_mysql: Starting connect to MySQL server for #1
rlm_sql (sql): Connected new DB handle, #1
rlm_sql (sql): starting 2
rlm_sql (sql): Attempting to connect rlm_sql_mysql #2
rlm_sql_mysql: Starting connect to MySQL server for #2
rlm_sql (sql): Connected new DB handle, #2
rlm_sql (sql): starting 3
rlm_sql (sql): Attempting to connect rlm_sql_mysql #3
rlm_sql_mysql: Starting connect to MySQL server for #3
rlm_sql (sql): Connected new DB handle, #3
rlm_sql (sql): starting 4
rlm_sql (sql): Attempting to connect rlm_sql_mysql #4
rlm_sql_mysql: Starting connect to MySQL server for #4
rlm_sql (sql): Connected new DB handle, #4
rlm_sql (sql): Processing generate_sql_clients
rlm_sql (sql) in generate_sql_clients: query is SELECT id, nasname, shortname, type, secret FROM nas
rlm_sql (sql): Reserving sql socket id: 4
rlm_sql_mysql: query:  SELECT id, nasname, shortname, type, secret FROM nas
rlm_sql (sql): Read entry nasname=127.0.0.1,shortname=localhost,secret=naspassword
rlm_sql (sql): Adding client 127.0.0.1 (localhost, server=) to clients list
rlm_sql (sql): Released sql socket id: 4
 Module: Checking session {...} for more modules to load
 }
}
radiusd: #### Opening IP addresses and Ports ####
listen {
        type = "auth"
        ipaddr = *
        port = 0
}
listen {
        type = "acct"
        ipaddr = *
        port = 0
}
main {
        snmp = no
        smux_password = ""
        snmp_write_access = no
}
Listening on authentication address * port 1812
Listening on accounting address * port 1813
Listening on proxy address * port 1814
Ready to process requests.

radtest test0 userpassword 127.0.0.1 0 naspassword

Sending Access-Request of id 197 to 127.0.0.1 port 1812
        User-Name = "test0"
        User-Password = "userpassword"
        NAS-IP-Address = 127.0.1.1
        NAS-Port = 0
rad_recv: Access-Accept packet from host 127.0.0.1 port 1812, id=197, length=20

rad_recv: Access-Request packet from host 127.0.0.1 port 50494, id=197, length=57
        User-Name = "test0"
        User-Password = "userpassword"
        NAS-IP-Address = 127.0.1.1
        NAS-Port = 0
+- entering group authorize
++[preprocess] returns ok
  rlm_eap: No EAP-Message, not doing EAP
++[eap] returns noop
        expand: %{User-Name} -> test0
rlm_sql (sql): sql_set_user escaped user --> 'test0'
rlm_sql (sql): Reserving sql socket id: 3
        expand: SELECT id, username, attribute, value, op FROM radcheck WHERE username = '%{SQL-User-Name}'  ORDER BY id -> SELECT id, username, attribute, value, op FROM radcheck WHERE username = 'test0' ORDER BY id
rlm_sql_mysql: query:  SELECT id, username, attribute, value, op FROM radcheck WHERE username = 'test0' ORDER BY id
rlm_sql (sql): User found in radcheck table
        expand: SELECT id, username, attribute, value, op FROM radreply WHERE username = '%{SQL-User-Name}' ORDER BY id -> SELECT id, username, attribute, value, op FROM radreply  WHERE username = 'test0' ORDER BY id
rlm_sql_mysql: query:  SELECT id, username, attribute, value, op FROM radreply WHERE username = 'test0' ORDER BY id
        expand: SELECT groupname FROM radusergroup WHERE username = '%{SQL-User-Name}' ORDER BY priority -> SELECT groupname FROM radusergroup WHERE username = 'test0' ORDER BY priority
rlm_sql_mysql: query:  SELECT groupname FROM radusergroup WHERE username = 'test0' ORDER BY priority
rlm_sql (sql): Released sql socket id: 3
++[sql] returns ok
auth: type Local
auth: user supplied User-Password matches local User-Password
Login OK: [test0/userpassword] (from client localhost port 0)
Sending Access-Accept of id 197 to 127.0.0.1 port 50494
Finished request 0.
Going to the next request
Waking up in 4.9 seconds.
Cleaning up request 0 ID 197 with timestamp +6
Ready to process requests.

La table qui doit accueillir les « utilisateurs » s'appelle « radcheck ». Voyons de plus près la structure de cette table :

mysql> describe radcheck;
+-----------+------------------+------+-----+---------+----------------+
| Field     | Type             | Null | Key | Default | Extra          |
+-----------+------------------+------+-----+---------+----------------+
| id        | int(11) unsigned | NO   | PRI | NULL    | auto_increment |
| UserName  | varchar(64)      | NO   | MUL |         |                |
| Attribute | varchar(32)      | NO   |     |         |                |
| op        | char(2)          | NO   |     | ==      |                |
| Value     | varchar(253)     | NO   |     |         |                |
+-----------+------------------+------+-----+---------+----------------+
5 rows in set (0.01 sec)

Entrer dans le détail des nombreuses possibilités de FreeRADIUS nous mènerait beaucoup trop loin. Dans le cadre de notre projet, nous devons créer une ligne par client de la manière suivante :

• Username contiendra l'adresse MAC du client, au format xx:yy:zz:aa:bb:cc, en lettres minuscules ;
• Attribute contiendra le texte : « Cleartext-Password » ;
• op contiendra « := » ;
• Value contiendra également l'adresse MAC du client, au format xx:yy:zz:aa:bb:cc, en lettres minuscules.

Comme pour gérer dans la suite une telle collection de valeurs, il faudra savoir à quel client correspond une adresse MAC, je vous conseille d'ajouter dans cette table une rubrique supplémentaire destinée à contenir, par exemple, le nom du client associé. De plus, les valeurs par défaut de Attribute et de op gagnent à être créées/modifiées comme suit :

mysql> describe radcheck;
+-----------+------------------+------+-----+--------------------+----------------+
| Field     | Type             | Null | Key | Default            | Extra          |
+-----------+------------------+------+-----+--------------------+----------------+
| id        | int(11) unsigned | NO   | PRI | NULL               | auto_increment | 
| UserName  | varchar(64)      | NO   | MUL |                    |                | 
| Attribute | varchar(32)      | NO   |     | Cleartext-Password |                | 
| op        | char(2)          | NO   |     | :=                 |                |
| Value     | varchar(253)     | NO   |     |                    |                | 
| COMMENT   | varchar(50)      | YES  |     | NULL               |                |
+-----------+------------------+------+-----+--------------------+----------------+
6 rows in set (0.01 sec)

Il « suffit » ensuite de peupler cette base avec vos adresses MAC par la méthode qui vous conviendra le mieux. Ceci devrait aboutir à quelque chose de la forme :

mysql> select *  from radcheck;
+----+-------------------+--------------------+----+-------------------+-----------------------+
| id | UserName          | Attribute          | op | Value             | COMMENT               |
+----+-------------------+--------------------+----+-------------------+-----------------------+
|  1 | test0             | Cleartext-Password | := | userpassword      | NULL                  | 
|  5 | 00:05:5d:df:f4:5b | Cleartext-Password | := | 00:05:5d:df:f4:5b | Poste 1               | 
|  7 | 00:13:46:2f:93:f5 | Cleartext-Password | := | 00:13:46:2f:93:f5 | Poste 2               | 
|  8 | 00:13:46:2f:93:ef | Cleartext-Password | := | 00:13:46:2f:93:ef | Poste 3               | 
|  9 | 00:15:e9:f1:2d:e6 | Cleartext-Password | := | 00:15:e9:f1:2d:e6 | Poste 4               |
....

Il n'est pas nécessaire de relancer FreeRADIUS après modification de cette table.

Il ne faut pas oublier non plus d'ajouter dans la table « nas » les informations concernant vos switches. La table « nas » est de structure suivante :

mysql> describe nas;
+-------------+--------------+------+-----+---------------+----------------+
| Field       | Type         | Null | Key | Default       | Extra          |
+-------------+--------------+------+-----+---------------+----------------+
| id          | int(10)      | NO   | PRI | NULL          | auto_increment |
| nasname     | varchar(128) | NO   | MUL |               |                |
| shortname   | varchar(32)  | YES  |     | NULL          |                |
| type        | varchar(30)  | YES  |     | other         |                |
| ports       | int(5)       | YES  |     | NULL          |                |
| secret      | varchar(60)  | NO   |     | secret        |                |
| community   | varchar(50)  | YES  |     | NULL          |                |
| description | varchar(200) | YES  |     | RADIUS Client |                |
+-------------+--------------+------+-----+---------------+----------------+
8 rows in set (0.00 sec)

Nous devons avoir dans cette table, quelque chose qui ressemble à ceci :

mysql> select *  from nas;
+----+---------------+-----------+-------+-------+--------------+-----------+---------------------+
| id | nasname       | shortname | type  | ports | secret       | community | description         |
+----+---------------+-----------+-------+-------+--------------+-----------+---------------------+
|  1 | 127.0.0.1     | localhost | other |  NULL | naspassword  | NULL      | RADIUS Client       |
|  2 | 192.168.10.11 | sw1       | other |  NULL | chutt        | NULL      | switch 1            |
...

Notez qu'une modification de la table « nas » nécessite (pour l'instant) un redémarrage de FreeRADIUS.

Normalement, tout devrait fonctionner correctement. Le client d'adresse MAC 00:05:5d:df:f4:5b devrait se retrouver sur le VLAN d'IP 2 (PARADIS_VLAN) alors qu'un client d'adresse MAC ne figurant pas dans la table « radcheck » se retrouvera dans le VLAN d'ID 3 (ENFER_VLAN).

Si vous rencontrez des problèmes, la première chose à faire est d'arrêter FreeRADIUS, puis de le relancer en « foreground » (avant-plan) en mode « debug », par la commande :

freeradius -X

ou, pour encore plus de détails :

si, lors de la connexion d'un client, vous n'observez rien, c'est tout simplement que le switch ne dialogue pas avec le radius. Il faut alors en trouver la raison ;

si le dialogue démarre, il vous faudra déchiffrer le discours pour trouver la raison du dysfonctionnement. Les raisons les plus probables étant :

• le radius ne reconnait pas le switch (problème de secret partagé, de configuration du radius sur le switch, de configuration du switch dans la table « nas » du radius),
• le radius ne trouve pas le client dans sa base (erreur dans la table « radcheck »).

Il nous faut ajouter notre borne Wi-Fi dans la table « nas ». Ici, nous utilisons une borne de type Netgear GW302, qui aura dans notre réseau l'adresse IP 192.168.10.3, comme nom « netgear » et qui utilisera « re-chutt » comme secret partagé avec le serveur radius. Nous devrions avoir dans notre table, quelque chose de ce genre :

mysql> select *  from nas;
+----+---------------+-----------+-------+-------+--------------+-----------+---------------------+
| id | nasname       | shortname | type  | ports | secret       | community | description         |
+----+---------------+-----------+-------+-------+--------------+-----------+---------------------+
|  1 | 127.0.0.1     | localhost | other |  NULL | password     | NULL      | RADIUS Client       |
|  2 | 192.168.10.11 | sw1       | other |  NULL | chutt        | NULL      | switch 1            |
|  3 | 192.168.10.3  | netgear   | other |  NULL | re-epikoi    | NULL      | Borne wi-fi         |
...

Ici, la configuration va être extrêmement simple. Comme nous avons choisi d'utiliser WPA2-TLS, qui nécessite un certificat chez le client, il n'y aura a priori pas de base de noms d'utilisateurs à construire. Le serveur RADIUS va se contenter de vérifier l'authenticité du certificat présenté par le client. Si un client dispose d'un certificat valide, c'est bien qu'il est autorisé à se connecter.

4-3-2-1. Installation des certificats sur une machine Windows▲

4-3-2-1-1. Certificat de l'autorité▲

	Dans le cas de Windows XP, nous avons besoin du certificat de notre racine de confiance (root_maison_CA) ainsi que du certificat client (user1). Ces certificats sont à installer par l'utilisateur et serviront à authentifier l'utilisateur. Entendez par là deux points importants : - l'attachement à la borne Wi-Fi ne pourra se faire qu'après ouverture d'une session ; - seule la session de l'utilisateur qui aura installé les certificats pourra permettre un attachement. Commençons par le certificat de la racine de confiance. Double-clic dessus, ce qui nous amène à :
	Cette Autorité de certification étant inconnue de Microsoft, il nous appartient de décider si oui ou non, nous l'acceptons. Nous allons bien sûr installer ce certificat, non sans être certain que c'est bien le bon. Autrement dit, il nous appartient de vérifier que ce certificat provient bien de chez nous. « Installer ce certificat... » va nous conduire à un assistant :
	dont le texte explicatif ne nécessite aucun commentaire. Suivant :
	Nous allons choisir nous-même l'emplacement où ce certificat sera stocké. « Parcourir... »
	Nous choisissons logiquement les Autorités de certification racines de confiance.
	L'assistant a fini son travail.
Mais, tout de même, nous avons encore droit à un bon gros avertissement de sécurité.Encore une fois, si nous sommes certains de l'origine de ce certificat, nous pouvons y aller.

4-3-2-1-2. Certificat du client▲

Double-clic sur le certificat client.

	Ceci démarre un nouvel assistant. Suivant >
	La seconde permet de vérifier le chemin d'accès au certificat que nous voulons enregistrer. Suivant >
	Le mot de passe demandé ici est celui qui a été spécifié lors de l'exportation au format PKCS#12 avec TinyCA (« Export password »).
	Ici, nous pouvons choisir de sélectionner automatiquement le magasin. Suivant >

Le reste ne présente pas d'intérêt particulier, l'installation doit se terminer sans encombre.

4-3-2-1-3. WPA2 et Windows XP▲

Windows XP, même avec le SP2, ne gère pas WPA2. Il faut lui ajouter un correctif à télécharger chez Microsoft (validation d'intégrité « Genuine Advantage » requise). Ce correctif s'appelle : WindowsXP-KB893357-v2-x86-FRA.exe. À l'heure où ces lignes sont écrites, ce lien est valide. Sans ce correctif, vous devrez vous contenter de WPA. Ceci n'est pas nécessaire pour les heureux possesseurs de Vista ™.

Une fois tout ceci réalisé, avec un peu de chance, la connexion devrait s'établir automatiquement pour l'utilisateur qui a installé les certificats.

4-3-2-1-4. En cas de problèmes▲

Voici quelques éléments qui devraient vous aider à trouver la solution.

4-3-2-1-5. Voir les certificats installés▲

Une console « mmc » va nous venir en aide. Créons une console de gestion des certificats.

	exécuter mmc...
	Ajouter un composant logiciel enfichable...
	Choisir le composant « certificats »... « Fermer »
	Si vous avez un compte d'administrateur (ce qui, rappelons-le, n'est pas une bonne idée, même si c'est le comportement par défaut de Windows XP), vous aurez droit à choisir s'il s'agit de vos certificats (utilisateur) ou d'autres certificats, comme ceux qui concernent l'ordinateur. Si votre compte est celui d'un simple utilisateur, vous n'aurez pas ce choix et ne pourrez gérer que vos propres certificats, ce qui est suffisant dans notre cas. « Terminer »
	Si nous double-cliquons sur le certificat :
	Nous voyons apparaitre la racine de confiance associée.

La suite sous-entend que les connexions WI-FI sont gérées par les outils Windows. Même si l'on peut admettre qu'ils sont plutôt rébarbatifs, peu ergonomiques à première vue, mon expérience personnelle ne m'en a pas fait découvrir de meilleurs parmi les nombreux « gadgets » fournis par les constructeurs de matériel Wi-Fi.

Faites apparaitre les propriétés des connexions réseau sans fil :

	Sélectionnez votre réseau et affichez ses propriétés,
	Sur l'onglet « Association », assurez-vous que vous êtes bien sur le mode WPA2, avec un chiffrement AES,
	Sur l'onglet « Authentification », le type EAP doit être « Carte à puce ou autre certificat ». Affichez ses propriétés,
	Utilisez la sélection de certificats recommandée (simple), indiquez le nom complet du serveur RADIUS, tel qu'il a été défini dans son certificat, sélectionnez enfin le certificat de la racine d'autorité. Ceci devrait enlever toute ambiguïté, en cas de troubles.

4-3-2-2. Installation du certificat sur une machine Linux▲

# This file describes the network interfaces available on your system 
# and how to activate them. For more information, see interfaces(5). 
# The loopback network interface 
auto lo 
iface lo inet loopback 

  auto ath0 
  iface ath0 inet dhcp 
        wpa-driver madwifi 
        wpa-conf /etc/wpa_supplicant.conf
  ...

ctrl_interface=/var/run/wpa_supplicant
ap_scan=1

network={
        ssid="maison"
        scan_ssid=0
        key_mgmt=WPA-EAP
        eap=TLS
        proto=WPA2
        pairwise=CCMP TKIP
        group=CCMP TKIP
        identity="user1"
        ca_cert="/etc/wpa_supplicant/certs/root_maison_CA-cacert.pem"
        client_cert="/etc/wpa_supplicant/certs/user1@maison.mrs-cert.pem"
        private_key="/etc/wpa_supplicant/certs/user1@maison.mrs-cert.pem"
        private_key_passwd="epikoi"
}

Cette solution ne nous permet pas de gérer les « coups durs ». Comment faire en effet si l'on apprend qu'un certificat encore valide a été compromis ? Car dans cette configuration, une fois un certificat installé, il sera accepté par FreeRADIUS tant qu'il n'aura pas expiré.

Dans notre solution globale, nous gérons le réseau filaire par une authentification de type « login/password » où l'adresse MAC joue le rôle des deux composants. Nous disposons d'une base de données MySQL (ou Postgresql) qui recense toutes les adresses MAC connues. Nous avons pu tester son bon fonctionnement en utilisant un « login/password » introduit dans la base de données.

En ce qui concerne le réseau Wi-Fi, nous avons confié à EAP l'authentification, via le protocole TLS. Nous avons vu que, dans ce cas, tout se passe par l'intermédiaire des certificats, et qu'il n'y a aucune information dans la base de données.

Comment faire alors si pour une raison ou une autre, nous devions être amenés à bloquer un utilisateur disposant d'un certificat en cours de validité ? Il peut y avoir plusieurs raisons qui pourraient amener à cette résolution, comme :

• un vol déclaré de la machine sur laquelle le certificat a été installé ;
• un utilisateur autorisé pour une certaine durée, mais qui pour une raison ou une autre, n'a plus rien à faire sur notre réseau, temporairement ou définitivement (non-respect de la charte des utilisateurs, démission, etc.).

Dans notre configuration actuelle, ce type de situation ne peut être géré, il nous faut trouver une solution, si possible pas trop complexe à maintenir.

Deux voies sont à explorer :

• l'utilisation de certificats de révocation ;
• trouver un moyen pour qu'en plus de l'authentification par certificats, le nom d'utilisateur doive être présent dans la base de données pour autoriser l'attachement.

4-4-1-1. Certificat de révocation▲

4-4-1-2. Usage de la base de données▲

Certificate:
    Data:
        Version: 3 (0x2)
        Serial Number: 20 (0x14)
        Signature Algorithm: sha1WithRSAEncryption
        Issuer: C=FR, ST=France, L=Marseille, O=Maison, OU=Reseau_maison, CN=root_maison_CA/emailAddress=chris@maison.mrs
        Validity
            Not Before: Jan  6 12:17:58 2009 GMT
            Not After : Nov 13 12:17:58 2016 GMT
        Subject: C=FR, ST=France, L=Marseille, O=Maison, OU=Reseau_maison, CN=user1/emailAddress=user1@maison.mrs
        Subject Public Key Info:
            Public Key Algorithm: rsaEncryption
            RSA Public Key: (4096 bit)
...

authorize {
    preprocess
    eap {
        ok = return
    }
    sql
}
authenticate {
    Auth-Type CHAP {
        chap
    }
    eap
}

4-4-1-3. Authentification EAP sélective▲

authorize {
    preprocess
    sql
}
...

rad_recv: Access-Request packet from host 192.168.1.254 port 1285, id=0, length=199
        Message-Authenticator = 0xcb9362792c3a93b83a28b6153462c2db
        Service-Type = Framed-User
        User-Name = "user1\000"
        Framed-MTU = 1488
        Called-Station-Id = "00-0F-3D-AB-66-E8:maisonwifi"
        Calling-Station-Id = "00-1F-3C-4B-07-9C"
        NAS-Identifier = "D-Link Access Poi"
        NAS-Port-Type = Wireless-802.11
        Connect-Info = "CONNECT 54Mbps 802.11g"
        EAP-Message = 0x0200000e016c61702d70726f6673
        NAS-IP-Address = 192.168.1.254
        NAS-Port = 1
        NAS-Port-Id = "STA port # 1"
+- entering group authorize
++[preprocess] returns ok
        expand: %{User-Name} -> user1
rlm_sql (sql): sql_set_user escaped user --> 'user1'
rlm_sql (sql): Reserving sql socket id: 3
        expand: SELECT id, username, attribute, value, op FROM radcheck WHERE username = '%{SQL-User-Name}' ORDER BY id -> SELECT id, username, attribute, value, op FROM radcheck WHERE username = 'user1' ORDER BY id
        expand: SELECT groupname FROM radusergroup WHERE username = '%{SQL-User-Name}' ORDER BY priority -> SELECT groupname FROM radusergroup WHERE username = 'user1' ORDER BY priority
rlm_sql (sql): Released sql socket id: 3
rlm_sql (sql): User user1 not found
++[sql] returns notfound
auth: No authenticate method (Auth-Type) configuration found for the request: Rejecting the user
auth: Failed to validate the user.
Login incorrect: [user1\000/] (from client dwl2100ap port 1 cli 00-1F-3C-4B-07-9C)
Delaying reject of request 10 for 1 seconds
Going to the next request
Waking up in 0.9 seconds.
Sending delayed reject for request 10
Sending Access-Reject of id 0 to 192.168.1.254 port 1285
Waking up in 3.9 seconds.

mysql> INSERT INTO radgroupcheck(GroupName,Attribute,op,Value) VALUES ('wifiGroup','Auth-Type',':=','EAP');
Query OK, 1 row affected (0.00 sec)

mysql> INSERT INTO usergroup(UserName,GroupName) VALUES ('user1','wifiGroup');
Query OK, 1 row affected (0.00 sec)

ad_recv: Access-Request packet from host 192.168.1.254 port 1287, id=5, length=1703
        Message-Authenticator = 0x5a717acfbd03837c04baa4ff01be6399
        Service-Type = Framed-User
        User-Name = "user1\000"
        Framed-MTU = 1488
        State = 0x411d49f94518440d3eeebef8b48bd82c
        Called-Station-Id = "00-0F-3D-AB-66-E8:maisonwifi"
        Calling-Station-Id = "00-1F-3C-4B-07-9C"
        NAS-Identifier = "D-Link Access Poi"
        NAS-Port-Type = Wireless-802.11
        Connect-Info = "CONNECT 54Mbps 802.11g"
        EAP-Message = 0x020505d20dc000000a901603010a600b00075000074d00074a308207463082052ea003020102020114300d06092a864886f70d0101050500308199310b3009060355040613024652310f300d060355040813064672616e636531123010060355040713094d61727365696c6c65310c300a060355040a1303454d453110300e060355040b130752657365617578311430120603550403140b526f6f745f454d455f4341312f302d06092a864886f70d0109011620736572766963652e696e666f40656d652d656e736569676e656d656e742e6672301e170d3039303130363132313735385a170d3136313131333132313735385a308185310b30090603
        EAP-Message = 0x55040613024652310f300d060355040813064672616e636531123010060355040713094d61727365696c6c65310c300a060355040a1303454d453110300e060355040b13075265736561757831123010060355040313096c61702d70726f6673311d301b06092a864886f70d010901160e63616c65636140656d652e6f726730820222300d06092a864886f70d01010105000382020f003082020a02820201009e200fbbd6d82d2e6187673e7d4ca8fbd7696a564c550e782a40030cf67af8509402a4085765c329804c850bc7f629c0bff57690f7aa879422bb7ebf47cd3efa7e7bd3d6f8ad3c4718e1ba584f73d50fb146fde97aa3d52501b746b63c
        EAP-Message = 0x597d42670715fb9f0dc758c3efca14ea6efdc1ace976f9dc5346205c04e0b42de56aa643dec29cd0e8aa37223b78748490e089790962226f930d756851fb3fe720be5c65d06fa57c6c1f01a2cf45dd5613ff543d68fe5a10fd94c377e42cb665d7dd8413ce97bae64a00316a8947d33251e0c87b5a514c63854301548305c3ca82b1066f3d59e1be77a96031c08c1dc0606ab45fc4122d6bd7ba5e109c5b36b8529fe7c8e0faae713ebcc143baba93374d78de699814170794caa720559840589f7b71d3390667b20c7a39bf312e68ca48b2a9ea45cab51fdd3451b2753c7d9be63109f8d33bf51993ff0778f4fded95f834d81fe7f499d8e8e025867a
        EAP-Message = 0x8b9b1ecb74502381f8ce29f3b94ef2808da6438ec64cca64a2644ea659e747b6287bd674b5fcaa4efbcedb4d4b8146c2d831ab675844e2856512f5e5b385c4a7403cc7871114a0c5d645663dfb17f38e3f842c20c688fba23303d1b7b3982d811c9e14af8dfc13129e5d5a3646712f35cacdd850bfe300b0d954cfc041024c2e5adf0f3c2589479df978c1685f8eaf7c6525e70fb9058d2aae777ceb8d9880734d040a51b6d90203010001a38201a9308201a530090603551d1304023000301106096086480186f84201010404030204b0302b06096086480186f842010d041e161c54696e7943412047656e6572617465642043657274696669636174
        EAP-Message = 0x65301d0603551d0e0416041447069b70658e7d9f0f4ffe350b37543da59b7f1f3081ce0603551d230481c63081c380143cabad8ef6977ba1e75c1ec13a2221e66e91f252a1819fa4819c308199310b3009060355040613024652310f300d060355040813064672616e636531123010060355040713094d61727365696c6c65310c300a060355040a1303454d453110300e060355040b130752657365617578311430120603550403140b526f6f745f454d455f4341312f302d06092a864886f70d0109011620736572766963652e696e666f40656d652d656e736569676e656d656e742e667282090083382b812e0c60d7302b0603551d120424302281
        EAP-Message = 0x20736572766963652e696e666f40656d652d656e736569676e656d656e742e667230190603551d1104123010810e63616c65636140656d652e6f7267300b0603551d0f0404030205a030130603551d25040c300a06082b06010505070302300d06092a864886f70d010105050003820201006ba84b0aa33cf563f4581aa849ce83c46cd8dfdcb87c3c57487b26d46dad9683e29e03edcbe5633e2b2b263b9a9f30c18678317a8e6f2db9d6e3961b74af15f45f93b1f8ffbf76f0d598b433c7a025e15777e19053d22fd62934dc5ae268c6d7f839a59f0e6922ff861fce27683d89
        NAS-IP-Address = 192.168.1.254
        NAS-Port = 1
        NAS-Port-Id = "STA port # 1"
+- entering group authorize
++[preprocess] returns ok
        expand: %{User-Name} -> user1
rlm_sql (sql): sql_set_user escaped user --> 'user1'
rlm_sql (sql): Reserving sql socket id: 1
        expand: SELECT id, username, attribute, value, op FROM radcheck WHERE username = '%{SQL-User-Name}' ORDER BY id -> SELECT id, username, attribute, value, op FROM radcheck WHERE username = 'user1' ORDER BY id
        expand: SELECT groupname FROM radusergroup WHERE username = '%{SQL-User-Name}' ORDER BY priority -> SELECT groupname FROM radusergroup WHERE username = 'user1' ORDER BY priority
        expand: SELECT id, groupname, attribute, Value, op FROM radgroupcheck WHERE groupname = '%{Sql-Group}' ORDER BY id -> SELECT id, groupname, attribute, Value, op FROM radgroupcheck WHERE groupname = 'wifiUsers' ORDER BY id
rlm_sql (sql): User found in group wifiUsers
        expand: SELECT id, groupname, attribute, value, op FROM radgroupreply WHERE groupname = '%{Sql-Group}' ORDER BY id -> SELECT id, groupname, attribute, value, op FROM radgroupreply WHERE groupname = 'wifiUsers' ORDER BY id
rlm_sql (sql): Released sql socket id: 1
++[sql] returns ok
 rad_check_password: Found Auth-Type EAP
auth: type "EAP"
+- entering group authenticate
 rlm_eap: Request found, released from the list
 rlm_eap: EAP/tls
 rlm_eap: processing type tls
 rlm_eap_tls: Authenticate
 rlm_eap_tls: processing TLS
....

Nous sommes loin d'avoir vu tout ce qu'il est possible de faire avec RADIUS, mais nous avons réalisé ce que nous voulions faire.

Dans le cas du réseau filaire, il est également possible d'attribuer un ID de VLAN différent suivant l'utilisateur authentifié, de même qu'il est possible de remplacer EAP-TLS par PEAP, si l'on dispose par exemple d'un annuaire ActiveDirectory et que l'on souhaite que les clients Wi-Fi soient authentifiés avec leur « login/password » du réseau Microsoft, plutôt que par un certificat. La machine qui héberge FreeRadius doit alors être intégrée au domaine Microsoft et pouvoir interroger l'annuaire ActiveDirectory. À mon sens, EAP-TLS reste largement préférable, ne serait-ce qu'à cause des fuites (toujours possibles) de login/passwords.