Une introduction à TOTP et HOTP

L’une des méthodes d’authentification les plus populaires reste le mot de passe. Dans un article précédent, nous avons discuté de la bonne implémentation de l’authentification par mot de passe. Cependant, compter uniquement sur un mot de passe comme moyen d’authentification n’est plus suffisant, en particulier pour les comptes critiques, tels que les comptes bancaires ou les comptes de messagerie personnels, qui servent de point d’accès à d’autres services.

L’authentification à deux facteurs (2FA) améliore considérablement la sécurité du compte en ajoutant une étape supplémentaire dans le processus de connexion. Dans cet article, nous discuterons des options 2FA et examinerons de plus près les implémentations des protocoles de mot de passe à usage unique (TOTP) couramment utilisés et des protocoles de mot de passe et de mot de passe à usage unique (HOTP) basés sur HMAC.

Authentification à deux facteurs

En ce qui concerne 2FA, cela implique une étape supplémentaire dans l’authentification des utilisateurs. Cela pourrait être réalisé par divers moyens, notamment :

Un mot de passe à usage unique (OTP) est envoyé au téléphone de l’utilisateur via une communication cellulaire (SMS).
Un OTP est envoyé à l’adresse e-mail de l’utilisateur (ou via un lien magique).
Une notification push à l’application mobile de l’utilisateur, qui peut inclure un code ou la nécessité de confirmer la connexion dans l’application.
L’utilisation des protocoles TOTP/HOTP.

Si une partie malveillante a obtenu votre mot de passe par vol ou devinette, elle ne pourra pas accéder à votre compte sans confirmer le deuxième facteur.

Examinons de plus près les protocoles TOTP/HOTP et leur implémentation.

TOTP/HOTP

La principale caractéristique distinctive de ces protocoles est que le serveur n’a pas besoin d’envoyer un OTP au téléphone ou à l’e-mail de l’utilisateur. Le processus d’authentification est illustré dans le schéma suivant :

Une fois que l’utilisateur s’est connecté avec son nom d’utilisateur et son mot de passe, il est invité à saisir un OTP. L’utilisateur ouvre ensuite une application génératrice d’OTP, telle que Google Authenticator, et saisit le code généré.

Pour configurer 2FA sur le serveur, une clé secrète est générée et transférée à l’application génératrice d’OTP de l’utilisateur. Le processus de transmission de la clé secrète peut être le suivant : soit l’utilisateur scanne le code QR, soit il saisit la clé secrète manuellement. Sur la base de cette clé, nous générerons les mots de passe à usage unique. Pour que le mot de passe change constamment, nous devons entrer une variable et l’utiliser dans l’algorithme.

HOTP : Algorithme de mot de passe à usage unique basé sur HMAC

L’algorithme est basé sur HMAC (SHA-1). Il utilise un compteur comme variable :

code = HMAC-SHA-1(secretKey, counter)

Le résultat de l’exécution est une valeur assez longue, donc le code est réduit à 6-8 caractères pour la commodité de l’utilisateur. Si le serveur et le client connaissent la clé secrète et incrémentent le compteur de manière égale à chaque entrée de l’utilisateur, la valeur de code résultante sera la même et un OTP changera à chaque entrée. Ainsi, si un attaquant intercepte le code OTP, il ne pourra plus l’utiliser.

Cet algorithme n’est pas très pratique, mais il était souvent utilisé dans les années 2000 lorsqu’il n’y avait pas d’applications pratiques. Par exemple, une liste de mots de passe générés fournis par la banque a été utilisée pour confirmer l’accès ou les transactions sur le compte bancaire d’un utilisateur. Une fois que l’utilisateur a utilisé tous les mots de passe de la liste, il a dû se rendre au bureau de la banque pour obtenir une nouvelle liste.

Algorithme de mot de passe à usage unique basé sur le temps (TOTP)

Cet algorithme est basé sur le précédent et utilise un pas de temps comme variable. En règle générale, l’étape est choisie avec une durée de 30 secondes et un OTP est automatiquement généré dans l’application toutes les 30 secondes.

code = HMAC-SHA-1(secretKey, currentTime/step)

Si nous prenons la valeur actuelle du temps Unix et la divisons par 30 secondes, nous obtenons la valeur du compteur. Si les horloges du serveur et du client sont synchronisées, la valeur du code sera la même.

Pour éviter les erreurs lorsque l’heure n’est pas synchronisée lorsque vous vérifiez le code sur le backend, vous pouvez également authentifier avec succès l’utilisateur s’il a envoyé le code à partir d’un intervalle adjacent.

Mise en œuvre

Selon les exigences de la RFC4226, nous devons générer une longueur de clé de 160 bits :

SecureRandom random = new SecureRandom();
byte[] secretKeyBytes = new byte[20];
random.nextBytes(secretKeyBytes);
String secretKey = new Base32().encodeToString(secretKeyBytes);

Nous devons enregistrer la valeur résultante pour le compte et générer un lien pour l’utilisateur :

otpauth://totp/{LOGIN}?secret={BASE32(SECRET_BYTES)}&issuer={ISSUER}

Ici ISSUER est une valeur de chaîne indiquant le fournisseur ou le service auquel ce compte est associé (encodé en URL).

Par exemple:

otpauth://totp/alice?secret=LLZYIV5MTMMNI4H6CIPB6IBAQW34NRDG&issuer=Example

Il est possible de générer un QR code à partir de ce lien et de montrer à l’utilisateur :

Scannez-le à l’aide de Google Authenticator :

Désormais, un OTP sera généré sur l’appareil de l’utilisateur toutes les 30 secondes. Pour vérifier sur le serveur, nous devons également générer un OTP en utilisant la clé secrète enregistrée et un horodatage.

private static final int TOTP_DEFAULT_TIME_STEP = 30;
private static final int TOTP_DEFAULT_CODE_DIGITS = 6;
private static final String secretKey = "LLZYIV5MTMMNI4H6CIPB6IBAQW34NRDG";
...
long timeStep = System.currentTimeMillis() / 1000 / TOTP_DEFAULT_TIME_STEP;

//convert long to byte array
byte[] timeStepBytes = new byte[8];
for (int i = 7; i >= 0; i--) {
    timeStepBytes[i] = (byte) (timeStep & 0xFF);
    timeStep >>= 8;
}

//Compute HMAC
byte[] secretKeyBytes = new Base32().decode(secretKey);
SecretKeySpec signingKey = new SecretKeySpec(secretKeyBytes, "RAW");

Mac mac = Mac.getInstance("HmacSHA1");
mac.init(signingKey);

byte[] hmac = mac.doFinal(timeStepBytes);

La valeur de hachage résultante est beaucoup plus grande que les six caractères dont nous avons besoin. Nous devons tronquer cette valeur. L’algorithme de troncature est décrit dans RFC4226.

int offset = hmac[hmac.length - 1] & 0xF;
int binary = 
        ((hmac[offset] & 0x7F) << 24) 
        | ((hmac[offset + 1] & 0xFF) << 16) 
        | ((hmac[offset + 2] & 0xFF) << 8) 
        | (hmac[offset + 3] & 0xFF);

String totp = Integer.toString(binary % (int) Math.pow(10, TOTP_DEFAULT_CODE_DIGITS));

if (totp.length() < TOTP_DEFAULT_CODE_DIGITS) {
    totp = "0".repeat(TOTP_DEFAULT_CODE_DIGITS - totp.length()) + totp;
}

La valeur résultante doit être la même valeur générée par l’application mobile.

Conclusion

L’authentification à deux facteurs (2FA) est un aspect crucial de l’amélioration de la sécurité de tout système. TOTP et HOTP sont deux des algorithmes 2FA les plus couramment utilisés, offrant une couche de sécurité supplémentaire à l’approche traditionnelle du nom d’utilisateur et du mot de passe. La mise en œuvre de 2FA à l’aide de TOTP ou HOTP peut améliorer considérablement la sécurité de vos applications et vous protéger contre les risques potentiels posés par un accès non autorisé.