Le principe de l’authentification One-Time Password est d’avoir des mots de passes qui changent régulièrement pour éviter les attaques par force brute sur les sites Web.
En me basant sur le module apache mod_authn_otp, je reprend dans cet article les étapes importantes de l’installation de cet module en version simplifié (pas de code PIN).
En premier téléchargement et compilation sur Ubuntu 14.4 du module apache mod_authn_opt en version 1.1.7:
wget https://s3.amazonaws.com/archie-public/mod-authn-otp/mod_authn_otp-1.1.7.tar.gz
Note de mise à jours: test sur Ubuntu 16.04 du module apache mod_authn_opt en version 1.1.8:
wget https://s3.amazonaws.com/archie-public/mod-authn-otp/mod_authn_otp-1.1.8.tar.gz
N’oublier de dézipper ce fichier:
tar xvfz mod_authn_otp-1.1.8.tar.gz cd mod_authn_otp-1.1.8
Avec les outils de compilation installés:
sudo aptitude install apache2-devel sudo aptitude install openssl-devel sudo aptitude install apache2-dev sudo aptitude install build-essential
Note de mise à jours: le package openssl-devel ne semble plus disponible mais il ne parait plus nécessaire.
Réaliser la compilation du module avec les commandes suivantes:
./configure make make install
nous obtenons un module pour apache installé mais aucunement activé:
/usr/lib/apache2/modules/mod_authn_otp.so
Réalisation l’ajout en tant que module dans apache avec la création du fichier suivant:
/etc/apache2/mods-available/authn_otp.load
Contenant la ligne suivante:
LoadModule authn_otp_module /usr/lib/apache2/modules/mod_authn_otp.so
Le module est configuré dans apache mais pas activé car pour cela nous devons faire un lien symbolique vers ce fichier depuis le dossier des modules activés
cd /etc/apache2/mods-enabled/ ln -s ../mods-available/authn_otp.load .
Le lien est réalisé pour symbolisé que le module est à activer au prochain redémarrage d’apache que nous réalisons avec cette commande:
service apache2 restart
Nota j’ai eu une erreur à cause du nom du module. L’erreur était:
undefined symbol: mod_authn_otp
Car le fichier ( /etc/apache2/mods-available/authn_otp.load) avait comme nom de module mod_authn_otp alors qu’il faut indiquer authn_otp_module.
Je modifie la configuration d’apache pour protéger le dossier test d’un accès avec un mot de passe à utilisation unique :
<Directory /var/www/html/test/ > AuthType Basic AuthName intranet AuthBasicProvider OTP Require valid-user OTPAuthUsersFile "/etc/otp/otp-users.txt" </Directory>
Tout ce passe ensuite sur le nouveau fichier /etc/otp/otp-users.txt.
Nota: il faut que le dossier et le fichier soit propriété de l’utilisateur www-data qui est sous Ubuntu l’utilisateur qui exécute le logiciel apache2. Création du dossier, du fichier et changement de droit avec les commandes suivantes:
mkdir /etc/otp/ touch /etc/otp/otp-users.txt chown -R www-data.www-data /etc/otp/
Et maintenant le contenu du fichier otp-users.txt sachant que je souhaite une authentification basé sur le temps et non sur un jeton.
HOTP/T30 jean - 01234567890101112130
J’indique je veux une authentification sur T avec une fenêtre de 30 secondes basé sur un décalage de 01234567890101112130. (Par défaut cette authentification attendra un One-Time Password de 6 chiffres).
Le tiret indique que je n’utilise pas de code PIN au moins dans un premier temps.
Je peux utiliser un exécutable pour calculer le mot de passe pour la fenêtre de 30 secondes avec la commande suivante:
otptool -t '01234567890101112130' -i 30
J’obtient en sortie 3 chiffres: token: password counter
480455332: 458789 cf8081
Le mot de passe valide est 458789.
Que je peux vérifier par la commande de vérification suivante:
otptool -t '01234567890101112130' -i 30 458789
Maintenant je souhaite utiliser une application Android pour générer le mot de passe depuis mon téléphone.
Avec la commande suivante je vais convertir le décalage en temps dans le bon format:
python -c "import base64,binascii;
print base64.b32encode(binascii.unhexlify('01234567890101112130'))"
J’obtient l’encodage suivant: AERUKZ4JAEARCIJQ
J’installe l’application de Google Authenticator qui semble un peu décrier mais qui fonctionne très bien pour mon premier exemple dans cette technologie.
Je lance l’application en indiquant « Ajouter un compte » et « Saisir la clé fournie ».
Dans l’interface, le premier champ est un texte libre pour identifier le serveur.
Ensuite j’indique la clé AERUKZ4JAEARCIJQ et je laisse le dernier champ sur « Basée sur l’heure » vu qu’il s’agit de mon type d’authentification et non sur un jeton/token.
L’authentification fonctionne en générant des mots de passes toutes les minutes.
De nombreuses options sont disponibles pour améliorer ce processus d’authentification avec un nombre limite de tentative, un code PIN qui s’ajoute avant le code à utilisation unique.
Pour éviter d’avoir à entrer le code, on peut utiliser un qrcode qui peut être par exemple généré avec inkscape (http://goinkscape.com/how-to-make-qr-codes-in-inkscape/) via le menu Extensions > Rendu > Codes-barres > QR code…
Ensuite, il suffit d’entrer dans la zone Texte le code pour généré un QR Code que l’application Google Authenticator comprend pour entrer la longue suite de code sans erreur.
Sources :
- https://code.google.com/p/mod-authn-otp/
- https://github.com/archiecobbs/mod-authn-otp
- http://blog.nemik.net/2011/12/generate-your-own-one-time-passcodes-to-use-with-android/
