GuiguiAbloc

En juillet de l’année dernière, j’avais écrit un billet sur l’authentification système par jeton tournant.

Je vous propose aujourd’hui de mettre en place une autre technique, l’authentification sur un serveur RADIUS par mot de passe unique, mot de passe généré sur votre téléphone portable.

Le principe reste assez simple. Pour vous identifier sur votre site web/équipement réseau/connexion wifi (etc, etc, la liste n’est pas exhaustive, du moment que l’authentification se base sur un serveur RADIUS), vous devrez saisir un code PIN sur votre téléphone, qui en retour vous générera un mot de passe, valable 1 seule fois et durant quelques minutes seulement.

Sympa comme moyen d’authentification (qui a dit « la frime » ?)

Pour mettre en œuvre cette solution, nous allons nous utiliser deux produits :

• FREERADIUS

Pour le serveur RADIUS

• MOTP

Pour le système d’authentification unique

RADIUS est un protocole client/serveur permettant de centraliser des données d’authentification.

Je vous invite à lire cette page :

http://fr.wikipedia.org/wiki/RADIUS_(informatique)

Vous l’utilisez tous les jours sans vous en rendre compte, tout simplement par votre accès au Nain Ternet de votre Fournisseur d’accès qui vous authentifie sur ses serveurs RADIUS avant de vous donner accès (ou pas) au réseau informatique mondial.

Bien sûr, tout cela est transparent pour vous, la plupart du temps, c’est votre box adsl qui négocie avec le RADIUS votre authentification.

(Pour les puristes, oui je résume énormément , si en plus on rajoute des proxy radius sur les BAS, on va y passer la nuit :-p )

Bref, pour résumer simplement, un serveur RADIUS sert à 3 choses :

1. L’authentification

Qui es-tu ?

1. L’autorisation

A quoi tu as le droit ?

1. L’accounting (ou traçabilité)

Combien tu consommes et qu’est ce que tu utilises ?

C’est le fameux AAA que vous avez déjà peut-être croisé au fil de vos pérégrinations informatiques.

Maintenant que nous avons survolé le but de ce billet, mettons-nous à la tâche :

• Installation et configuration de FreeRadius

Que vous soyez sous Linux ou *BSD, FreeRadius est disponible.

L’installation reste des plus triviales, a coup de pkg_add, apt-get install, yum install ou compilation directe depuis les sources sur le site web :

http://freeradius.org/download.html

Je me baserais sur la version 2.x de Freeradius, si vous êtes encore en version 1.x, il serait peut être temps de migrer…

Je ne m’attarderais pas sur son installation, il existe un excellent tutoriel de Thuso, ici :

http://www.pervasive-network.org/SPIP/Installation-de-freeradius-2-4

Passons à la phase MOTP proprement dite :

Téléchargement et installation du script et du dictionnaire MOTP :

serveur:# cd /etc/raddb
serveur:/etc/raddb# wget http://motp.sourceforge.net/otpverify.sh
serveur:/etc/raddb# chmod +x otpverify.sh
 
serveur:/etc/raddb# wget http://motp.sourceforge.net/dictionary.motp
 
Modification du fichier /etc/raddb/dictionary
 
serveur:/etc/raddb#  cat /etc/raddb/dictionary
#
#       This is the master dictionary file, which references the
#       pre-defined dictionary files included with the server.
#
#       Any new/changed attributes MUST be placed in this file, as
#       the pre-defined dictionaries SHOULD NOT be edited.
#
#       $Id: dictionary.in,v 1.4 2004/04/14 15:26:20 aland Exp $
#
#
$INCLUDE        /usr/local/share/freeradius/dictionary
$INCLUDE        dictionary.motp

Dans /var, créer un répertoire motp et lui donner les droits au user « freeradius »

serveur:# mkdir /var/motp
serveur:# mkdir /var/motp/cache
serveur:# mkdir /var/motp/users
serveur:# chown -R _freeradius:_freeradius /var/motp

On va ajouter un module exec à la configuration (/etc/raddb/radiusd.conf)

modules {
          ...
 
        exec MOTP {
                wait = yes
                program = "/etc/raddb/otpverify.sh %{User-Name} %{User-Password} %{reply:Secret
} %{reply:Pin} %{reply:Offset}"
                input_pairs = request
                output_pairs = reply
 
               ....
 
(vérifier bien que vous avez "exec" dans la partie Instantiate :)
 
instantiate {
        exec
        expr
        expiration
        logintime
 
}

Depuis la version 2, Freeradius utilise des hôtes virtuels (comme Apache), modifier votre fichier vhost comme suit (la partie importante étant l’auth-type external)

serveur:/etc/raddb/sites-enabled# more radius.guiguiabloc.fr
#####################################
authorize {
        preprocess
        chap
        suffix
        sql
        files
        expiration
        logintime
        pap
}
 
#  Authentication.
#
authenticate {
        Auth-Type PAP {
                pap
        }
 
        Auth-Type CHAP {
                chap
        }
        Auth-Type External {
                 MOTP
        }
        unix
}
 
preacct {
        preprocess
        acct_unique
        suffix
        files
}
accounting {
        detail
        unix
        radutmp
        sql
        attr_filter.accounting_response
}
session {
        radutmp
        sql
}
post-auth {
        Post-Auth-Type REJECT {
                attr_filter.access_reject
        }
}
pre-proxy {
}
post-proxy {
}

On va s’arrêter la pour la partie Freeradius et nous occuper de notre téléphone portable.

• Installation de MOTP

MOTP (Mobile One Time Password), est le projet source de Freeauth dont j’avais parlé dans mon précédent billet.

Le principe est simple, comme dans toute base d’authentification forte à deux facteurs.

- 1 code secret connu également du serveur Radius (ce que JE connais)

- 1 objet unique capable de générer mon code (ce que JE détiens)

Le téléphone ET le serveur RADIUS se partageant ensemble une clé hexadécimale unique.

• Avoir le téléphone ne sert à rien (j’ignore le code PIN qui n’est pas enregistré dedans)

• Avoir le code PIN et un autre téléphone avec le même programme ne sert à rien (je ne peux régénérer la même clé hexadécimale)

Une fois tout cela en main, quand vous tapez votre code PIN (pas celui du téléphone hein celui choisi pour l’authentification), le programme génère 1 mot de passe unique en utilisant un hash MD5 qui cumule le code pin, la clé hexadécimale et l’heure EPOCH (avec une granularité de 10 secondes) et vous donne les 6 premiers caractères qui sont votre mot de passe pour vous connecter.

Ce mot de passe est vérifié par le serveur qui connait le code PIN, l’init-key (la clé hexadécimale) et l’heure actuelle.

Pour pallier les variations de temps entre le téléphone et le serveur, celui accepte le mot de passe 3 minutes dans le passé et dans le futur par rapport à son heure actuelle.

C’est bien pour cela que je vous conseille fortement de synchroniser votre téléphone portable et votre serveur à intervalles réguliers sur un serveur de temps NTP (cf. précédent billet)

Le mot de passe n’est accepté qu’UNE seule fois et en cas de 8 échecs consécutifs, l’utilisateur est verrouillé et ne peux plus se connecter.

Le JAR que vous devez installer sur votre téléphone compatible JAVA est disponible ici :

http://motp.sourceforge.net/MobileOTP.jar

Vous trouverez d’autres formes du client MOTP sur le site du projet (BlackBerry par exemple) :

http://motp.sourceforge.net/#2

Bien sûr, les sources sont également disponibles.

L’installation faite, un nouvel icône fait son apparition

MOTP

Dans le menu Options, Time Zone, vérifier votre temps UTC (+0 pour moi) qui doit être identique sur le serveur.

(voir le précédent billet pour plus d’infos sur cette partie)

Commençons par initialiser le programme pour générer la clé Hexadécimale unique

Lancer le programme et en code PIN tapez : #**#

MOTP

Appuyez aléatoirement sur 20 touches

MOTP

Le programme vous affiche votre clé Hexadécimale unique (l’init Secret), NOTEZ LA BIEN !!!

MOTP

Vous pouvez déjà vérifier que cela fonctionne en lançant le script otpverify.sh sur votre serveur RADIUS, suivi de 5 variables :
- le user
- le mot de passe unique généré par votre téléphone
- la clé hexadécimale
- le code PIN
- l’offset (0 pour un UTC +0)

serveur:/etc/raddb# ./otpverify.sh guiguiabloc b662de e37629f6d057dcc5 1234 0
ACCEPT

Maintenant, avec cette clé, retournons à la configuration du serveur RADIUS.

Paramétrage du fichier « users » de RADIUS :

serveur:/etc/raddb# cat /etc/raddb/users
DEFAULT Auth-Type = External
        Exec-Program-Wait = "/etc/raddb/otpverify.sh '%{User-Name}' '%{User-Password}' '%{reply:Secret}' '%{reply:Pin}' '%{reply:Offset}'",
        Fall-Through = Yes
guiguiabloc
        Secret = e37629f6d057dcc5,
        PIN = 1234,
        Offset = 0

Explication :
On ajoute un utilisateur, guiguiabloc
Secret = la clé hexadécimale générée sur le téléphone
PIN = le code secret a 4 chiffres choisi par l’utilisateur
Offset = variation de temps UTC (voir le site pour une explication détaillée)

Ne reste qu’à démarrer votre serveur RADIUS (en mode debug pour l’instant) et tenter une authentification via l’utilitaire RADTEST

serveur:/etc/raddb# /usr/local/sbin/radiusd -X
FreeRADIUS Version 2.0.5, for host i386-unknown-openbsd4.4, built on Aug 13 2008 at 01:30:16
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 v2.
Starting - reading configuration files ...
....
Listening on authentication address 192.168.18.100 port 1812
Listening on accounting address 192.168.18.100 port 1813
Ready to process requests.

Demande du mot de passe unique sur le téléphone :

MOTP

serveur:/etc/raddb# radtest guiguiabloc 356c18  192.168.18.100 0 secret_radius_client
Sending Access-Request of id 41 to 192.168.18.100 port 1812
        User-Name = "guiguiabloc"
        User-Password = "356c18"
        NAS-IP-Address = 192.168.18.70
        NAS-Port = 0
rad_recv: Access-Accept packet from host 192.168.18.100 port 1812, id=41, length=20
 
Côté serveur RADIUS on voit l'authentification se dérouler :
 
auth: type "External"
+- entering group External
        expand: %{User-Name} -> guiguiabloc
        expand: %{User-Password} -> 356c18
        expand: %{reply:Secret} -> e37629f6d057dcc5
        expand: %{reply:Pin} -> 1234
        expand: %{reply:Offset} -> 0
Exec-Program output: ACCEPT
Exec-Program-Wait: plaintext: ACCEPT
Exec-Program: returned: 0
++[MOTP] returns ok
Sending Access-Accept of id 41 to 192.168.18.100 port 29470
Finished request 2.
Going to the next request
Waking up in 4.9 seconds.
Cleaning up request 2 ID 41 with timestamp +215
Ready to process requests.

Un succès

Désormais vous pouvez demander à vos équipements d’interroger le serveur RADIUS pour valider l’authentification et utiliser votre téléphone pour générer votre mot de passe unique et jetable.

Ca fait « classe » quand même

Bonus, il existe un module mod_auth_radius pour Apache

Un petit .htaccess bien placé :

    AuthType Basic
    AuthName "RADIUS Authentication"
    AuthUserFile /dev/null
    AuthRadiusAuthoritative on
    AuthBasicAuthoritative off
    AuthRadiusCookieValid 5
    AuthRadiusActive On
    require valid-user

Et hop, authentification sur votre site web via RADIUS et MOTP…

Amusez-vous bien

Alors ça si c’est pas du titre bien poilu

Le but de billet est de vous montrer comment mettre en oeuvre une Authentification forte via OTP et un téléphone portable qui générera des mots de passes aléatoires et jetables toutes les 60 secondes. Ces mots de passes étant bien sur, en plus du secret partagé, générés en fonction du temps UTC entre le serveur et le téléphone (ce qu’on appelle un token basé sur le temps).

Oui, je sais, ça tue…

Si vous travaillez (allez travailler ) dans un grosse société qui vous offre un accès VPN externe, il y a de fortes chances que vous rencontriez ce genre de joujou :

ou plus proche de notre époque celui ci :

On appelle cela des « OTP Token basé sur le temps réel ».

NB: j’ignore si ses images sont libres de droits, et si tel n’est pas le cas, merci de m’avertir (en même temps je fais de la pub pour RSA SecurID alors bon…)

Je ne vais pas détailler ici que qu’est l’Authentification forte et les tokens basés sur le temps car il existe un excellent article sur Wikipédia qui vous expliquera tout et que je vous invite fortement a lire avant de continuer. Lire ICI.

Ce schéma résume l’ensemble :

Pour simplifier, lorsque vous vous connectez, vous devez taper le mot de passe qu’affiche le Token dans les 60 secondes avant qu’il change. Une fois utilisé, ce mot de passe n’est plus valable.

Utilisant ce produit professionnellement, je me demandais si je pouvais monter la même chose à titre personnel.

La première question était « Qu’est ce qui pourrait bien remplacer l’afficheur Token, qui ne soit pas trop encombrant que j’ai toujours sur moi ?… » Réponse : mon téléphone portable.

Ni une, ni deux, fouille laborieuse du nain ternet ou je trouvais quelques projets dont le plus important : Mobile OTP.

J’utilise déja l’authentification OTP chez moi (via OPIE) et ce programme s’en rapproche mais je voulais encore plus ressemblant au clé RSA SecurID.

Ce projet existe et s’appelle FreeAuth.

La seule chose que l’on peut reprocher est son manque de documentation et d’explication.

Voici donc un petit tuto pour mettre en place cette solution.

D’abord, le plus important, synchroniser l’heure du serveur et du téléphone via NTP.

• Synchronisation NTP du serveur

La partie surement la plus simple. Installer le package ntpdate. Puis une crontab « ntpdate serveur de temps ». (exemple : ntpdate fr.pool.ntp.org)

• Synchronisation NTP du téléphone

Après quelques recherches sur le net, j’ai découvert un logiciel permettant une synchronisation NTP d’un téléphone équipé de Symbian S60 r3.

Ce soft s’appelle FreeTimeSync et vous le trouverez sur le site du développeur ICI .

Par contre son installation demande quelques manipulations, le logiciel étant toujours en développement.

- Télécharger l’application.

Ensuite il vous faut signer l’application (Certificat Symbian Open Signed).

- Rendez vous sur le site de Symbiansigned :
https://www.symbiansigned.com/app/page/public/openSignedOnline.do

- Récupérer le numéro IMEI de votre téléphone (séquence *#06# sur la plupart des téléphones).

- Renseigner un email valide, puis le chemin où vous avez sauvegarder l’appli.

- Dans le champ « Capability information » , cliquez sur « select all »

Puis enfin, taper les lettres aléatoires qui s’affichent (une horreur complètement illisible et j’ai du essayer 4 ou 5 fois avant d’avoir bon).

Vous recevrez un email de confirmation avec une URL qu’il faudra valider et quelques minutes plus tard, vous recevrez un nouvel email avec le lien pour télécharger votre application signée.

ATTENTION : la synchronisation NTP ne peut se faire qu’en WiFi, par un accès Data ou GPS, le WAP ne laisse pas passer les requètes NTP.

Quelques captures d’écrans :

• Installation de FreeAuth sur le nokia e65

Télécharger le programme FreeAuth MIDLet sur le site :

http://www.freeauth.org/site/wiki/FreeAuth%20MIDLet

Personnellement, j’ai téléchargé le .JAD et le .JAR sur :

http://wap.freeauth.org/2.4/

Puis j’ai édité le .JAR (qui est un fichier de paramètres) ou j’ai remplacer « networking Y » par « N ».

Il existe une solution de backup/restore en MD5 intégré à l’application mais j’ai du mal a saisir son fonctionnement en mode backup. En mode DB Restore, en traçant les trames réseaux, je le vois bien essayer de recuperer le fichier .bin sur le serveur que j’ai mis en paramètres dans le .JAD mais il échoue (je n’ai pas trop compris la mise en forme de la clé RSA privée )

Ayant peu fouillé cette fonctionnalité, je n’en parlerais pas ici, bien qu’elle me paraisse fortement prometteuse et intéressante.

Ensuite, transférer les 2 fichiers sur le nokia e65 (via bluetooth, wifi, cable usb… ce que vous voulez quoi) et avec le navigateur de fichiers du téléphone, lancer le FreeAuth.JAD.

L’installation se passe sans soucis et vous pouvez lancer le programme (options, Next pour la page suivante) :

Tout d’abord entrer un code pin qui vous servira a protéger votre configuration :

Vous devez maintener taper aléatoirement 20 fois sur différentes touches afin de génerer l’entropie de cryptage :

Donner un nom de configuration :

Le programme affiche maintenant le code d’initialisation :

On reste à cette étape pour l’instant !!!

• Installation de FreeAuth sur le Serveur Linux

Il vous faut les headers pam (libpam-dev)

apt-get install libpam0g-dev

Récupérer ensuite pam_freeauth sur le site :

wget http://www.freeauth.org/images/pam_freeauth.tgz
tar xzvf pam_freeauth.tgz

cd pam_freeauth
make clean
make install

Cela installe le module pam freeauth dans /lib/security.

Copier le fichier de conf :

cp -a freeauth.conf /etc/security
chmod 600 /etc/security/freeauth.conf

Créer un répertoire de cache

mkdir -p /var/cache/freeauth/
chmod 700 /var/cache/freeauth/

Ensuite dans /etc/pam.d, modifier le service PAM associé (ici SSH):

- commenter « @include common-auth »

- Ajouter

auth required pam_freeauth.so

Je vous laisse peaufiner votre configuration PAM (google est votre ami…), si vous préférer directement modifier votre common-auth et common-password, c’est vous qui voyez.

Modifier le /etc/sshd_config pour positionner la variable ChallengeResponseAuthentication avec YES
Redémarrer le service SSH.

Ensuite, avec le code d’initialisation donné par le nokia e65 plus haut, éditer le fichier :

/etc/security/freeauth.conf

Virer la ligne de test et remplacer par vos valeurs :

user code_initialisation

Exemple ici :

root D58]Nmaa-vdZ-m!P

Pour le compte root (vous pouvez avoir plusieurs code d’initialisation pour un utilisateur, utile si vous avez plusieurs FreeAuth )

Sur le téléphone, on peut lancer les séquences :

Connectez vous en ssh sur le serveur:

ssh root@192.168.0.111
passcode:

Il vous reste qu’à taper le code afficher sur le téléphone

La classe

Si cela ne fonctionne pas, vérifier que le serveur et le télephone nokia sont à la même heure UTC (en Epoch time) :

Sur le serveur :

echo « `date +%s` / 60″ | bc

20261111

Sinon, modifier UTC en + ou en – et surtout mettez vous à l’heure NTP (entre nous, rien ne vous interdit d’être en UTC+12 )

Et voila comment monter un système d’authentification forte digne d’une offre commerciale chère avec « peu » de moyens

Ne vous méprenez pas, cette solution est largement aussi satisfaisante pour peu que vous construisiez votre architecture en conséquence.

Si maintenant je vous annonce que l’on peut coupler tout cela avec un serveur RADIUS… (avec XTRadius que vous trouverez ICI ) vous vous dites « omg » et je vous comprends…

Vous verrez qu’a force de fouiller le sujet, les possiblités sont nombreuses.

NB: Il subsiste encore quelques bugs dans l’appli FreeAuth sur le nokia e65, surtout pour le backup. La bidouille que j’ai trouver est de toujours cliquer sur « About » avant de faire un « DB backup » et surtout, être cool….