Les uti­li­sa­teurs d’Internet sont ré­gu­liè­re­ment amenés à saisir des mots de passe pour se connecter aux réseaux sociaux, en faisant leur shopping en ligne ou pour consulter leur compte sur Internet. Les mots de passe per­met­tent de sécuriser les données sensibles contre un accès non autorisé par des tiers. Toutefois, de nombreux uti­li­sa­teurs ne se donnent pas la peine de prendre les pré­cau­tions né­ces­saires : les mots de passe simples peuvent être craqués par les pro­fes­sion­nels en quelques secondes seulement. D’autres personnes prennent soin de bien choisir leurs mots de passe, mais elles les con­ser­vent d’une mauvaise façon et offrent ainsi une porte d’entrée aux criminels. Les points faibles des services auxquels on se connecte en tant qu’uti­li­sa­teur ne doivent pas non plus être négligés. Si les mots de passe n’y sont pas conservés de façon sécurisée, ce sont les données de milliers d’uti­li­sa­teurs qui sont alors en péril.

L’au­then­ti­fi­ca­tion à double facteur ou l’au­then­ti­fi­ca­tion mul­ti­fac­to­rielle permet de réduire ce risque. Plutôt que d’utiliser uni­que­ment un mot de passe, il est au minimum né­ces­saire d’indiquer un autre facteur d’au­then­ti­fi­ca­tion. Ce facteur est envoyé à l’uti­li­sa­teur de cette tech­no­lo­gie par smart­phone ou via un token (jeton d’au­then­ti­fi­ca­tion). La plupart du temps, les facteurs sup­plé­men­taires ont en commun d’être générés une unique fois et d’être valables pour une durée limitée générant ainsi un Time-based One-time Password. Nous vous ex­pli­quons son fonc­tion­ne­ment.

À quoi sert un TOTP ?

Aussi sécurisés et mi­nu­tieu­se­ment choisis qu’ils puissent être, les mots de passe habituels pré­sen­tent un in­con­vé­nient de taille : la sécurité est com­pro­mise dès qu’une autre personne connaît cette suite de ca­rac­tères. Une solution serait de changer ré­gu­liè­re­ment de mot de passe, mais même les uti­li­sa­teurs les plus exem­plaires ne le font que rarement. La solution est un TOTP : un mot de passe valable uni­que­ment pour un bref laps de temps avant d’expirer à nouveau. L’Internet En­gi­nee­ring Task Force (IETF) a publié l’al­go­rithme Time-based One-time Password en 2011 dans la RFC 6238 afin d’apporter une plus grande sécurité sur Internet.

Ces mots de passe uniques sont tout par­ti­cu­liè­re­ment po­pu­laires dans le cadre d’une au­then­ti­fi­ca­tion mul­ti­fac­to­rielle. Dans ce type d’au­then­ti­fi­ca­tion, les uti­li­sa­teurs sai­sis­sent tout d’abord leur mot de passe personnel, qui reste identique, pour se connecter à un service en ligne ; un mot de passe à durée limitée dédié à ce processus de connexion est par ailleurs généré. L’uti­li­sa­teur peut obtenir ce mot de passe via une ap­pli­ca­tion ou à l’aide d’un dis­po­si­tif sup­plé­men­taire prévu à cet effet (token).

Le mot de passe expire s’il est utilisé ne serait-ce qu’une seule fois ou s’il n’est pas utilisé pendant une période donnée. Il est ainsi très difficile pour les cy­ber­cri­mi­nels de récupérer le second facteur. Même s’ils con­nais­sent le mot de passe permanent, ils n’ont que peu de pos­si­bi­li­tés d’acquérir le TOTP, et pas assez de temps pour le craquer.

Comment fonc­tionne l’al­go­rithme Time-based One-time Password ?

Le TOTP est basé sur une fonction de hachage, c’est-à-dire un procédé cryp­to­gra­phique. On utilise un mot de passe secret et un ho­ro­da­tage pour créer une séquence de ca­rac­tères chiffrée. Le mot de passe est aussi bien connu de l’uti­li­sa­teur que du serveur. L’in­di­ca­tion tem­po­relle est effectuée en temps Unix.

Remarque

Le temps Unix est une valeur indiquant les secondes écoulées depuis le 1er janvier 1970.

Le TOTP est en fait une amé­lio­ra­tion du « HMAC-based One-time Password » abrégé en HOTP. Le TOTP est également basé sur la procédure HMAC, l’opération de hachage qui se déroule en arrière-plan. En associant le mot de passe secret à un compteur, l’appareil de l’uti­li­sa­teur et le serveur génèrent tous deux une valeur de hachage. Les deux valeurs sont iden­tiques, per­met­tant ainsi l’au­then­ti­fi­ca­tion.

La fonction de hachage elle-même n’est pas fixe ; en pratique, on peut utiliser SHA-1 (c’est par exemple le cas du Google Au­then­ti­ca­tor), qui génère une valeur de hachage d’une longueur de 160 bits. Dans un souci de sim­pli­cité, cette valeur est encore rac­cour­cie à l’aide d’une fonction de com­pres­sion. À terme, on obtient par exemple un nombre à six chiffres, que les uti­li­sa­teurs peuvent alors saisir en toute sim­pli­cité lors de leur connexion au service en ligne.

Note

Dans le cas d’un token, le mot de passe secret est ancré dans l’appareil. La plupart du temps, cette in­for­ma­tion n’est pas connue de l’uti­li­sa­teur. Dans le cas contraire, la SecretKey doit être conservée en sécurité, si possible hors ligne en l’imprimant et en la stockant dans un endroit sécurisé. En cas de perte de ce mot de passe, il ne sera plus possible de se connecter au service.

Pour le second élément de la fonction, le HOTP utilise un compteur partagé par le serveur et l’uti­li­sa­teur. Dans ce cas, le problème est que le mot de passe généré est valable jusqu’à ce qu’il soit utilisé. TOTP y ajoute une res­tric­tion : le code généré ne peut être utilisé que pendant une période limitée. Quel en est le fonc­tion­ne­ment ?

Trois formules sont es­sen­tielles pour l’al­go­rithme Time-based-One-time :

TOTP = HOTP(SecretKey,Cur­rent­Time)

Cette formule simple établit uni­que­ment que TOTP est une procédure HOTP disposant des mêmes pa­ra­mètres SecretKey et Cur­rent­Time :

  • SecretKey : mot de passe généré au hasard et connu aussi bien du serveur que du client
  • Cur­rent­Time : moment actuel en temps Unix

Cependant, l’in­di­ca­tion tem­po­relle change toutes les secondes et ce délai n’est pas suffisant pour trans­mettre le code à l’ap­pli­ca­tion. Une seconde suffirait pour que le TOTP ne soit plus valide et pour que le serveur génère une nouvelle valeur de hachage. C’est la raison pour laquelle on utilise une autre formule :

Cur­rent­Time = floor((unixtime(now) – unixtime(T0))/T1)

Le paramètre Cur­rent­Time est donc défini :

  • unixtime(now) : moment actuel en temps Unix
  • unixtime(T0) : le temps Unix à l’instant T0 à partir duquel le décompte est effectué, dans la plupart des cas le 01/01/1970 à minuit (= 0)
  • T1 : in­ter­valle dans lequel le TOTP doit être valide, gé­né­ra­le­ment 30 secondes
  • floor : fonction per­met­tant d’arrondir la valeur calculée à un nombre entier
Note

En théorie, il est également possible de choisir une autre valeur que 0 pour T0. Il est sim­ple­ment essentiel que le client et le serveur choi­sis­sent la même valeur.

La division et l’ar­ron­dis­se­ment ont pour effet de modifier le résultat à in­ter­valles réguliers.

La valeur de hachage générée est ensuite rac­cour­cie une nouvelle fois pour être plus con­vi­viale :

Result = TOTPmod10d

Le calcul du modulo nous permet de générer une somme de contrôle :

  • mod 10 : modulo en cas de diviseur 10
  • d : le nombre de chiffres que le TOTP doit comporter

On multiplie donc la base 10 par le nombre de chiffres que le code doit comporter, on divise le TOTP par cette valeur et on retranche le reste.

Calcul du TOTP à travers un exemple

Supposons que l’on souhaite générer un TOTP disposant d’une validité de 30 secondes. Nous pouvons déjà calculer le Cur­rent­Time et voir comment la période de validité est garantie. Nous prenons comme unixtime(now) 1548322860, le 24/01/2019 à 10 h 41. Si l’on divise cette valeur par 30, on obtient pré­ci­sé­ment 51610762. Étant donné qu’il s’agit déjà d’un nombre entier, l’ar­ron­dis­se­ment donne le même résultat. Si nous utilisons le temps actuel 15 secondes plus tard (c’est-à-dire 1548322875), nous obtenons le résultat 51610762,5 après la division. Cette valeur est également arrondie en 51610762. Le Cur­rent­Time reste donc identique. Dans le tableau suivant, on peut voir que l’on obtient uni­que­ment une autre valeur après 30 secondes :

unixtime(now) unixtime(now)/30 floor(unixtime(now)/30)
1548322857 51610761,9000 51610761
1548322858 51610761,9333 51610761
1548322859 51610761,9667 51610761
1548322860 51610762,0000 51610762
1548322861 51610762,0333 51610762
1548322862 51610762,0667 51610762
1548322863 51610762,1000 51610762
1548322864 51610762,1333 51610762
1548322865 51610762,1667 51610762
1548322866 51610762,2000 51610762
1548322867 51610762,2333 51610762
1548322868 51610762,2667 51610762
1548322869 51610762,3000 51610762
1548322870 51610762,3333 51610762
1548322871 51610762,3667 51610762
1548322872 51610762,4000 51610762
1548322873 51610762,4333 51610762
1548322874 51610762,4667 51610762
1548322875 51610762,5000 51610762
1548322876 51610762,5333 51610762
1548322877 51610762,5667 51610762
1548322878 51610762,6000 51610762
1548322879 51610762,6333 51610762
1548322880 51610762,6667 51610762
1548322881 51610762,7000 51610762
1548322882 51610762,7333 51610762
1548322883 51610762,7667 51610762
1548322884 51610762,8000 51610762
1548322885 51610762,8333 51610762
1548322886 51610762,8667 51610762
1548322887 51610762,9000 51610762
1548322888 51610762,9333 51610762
1548322889 51610762,9667 51610762
1548322890 51610763,0000 51610763
1548322891 51610763,0333 51610763

Nous avons donc déterminé le Cur­rent­Time (51610762). Nous générons la SecretKey à l’aide du gé­né­ra­teur de mot de passe : >cHSB_UQ#O5m;~b

HMAC avec SHA-1 crée une valeur de hachage (en notation hexa­dé­ci­male) à partir de ce mot de passe et de l’heure : c0 62 37 94 dd 37 7a 3a f0 91 22 08 1f 21 6f 9b 17 4b 17 45. Cette valeur de 160 bits ou de 20 bytes est à présent rac­cour­cie à 31 bits par une Dynamic Trun­ca­tion. Pour ce faire, on considère tout d’abord les 4 premiers bits, c’est-à-dire le nombre 0x5, que l’on note 5 en notation hexa­dé­ci­male. Cela cor­res­pond à la valeur Offset de la Dynamic Trun­ca­tion et signifie que l’on extrait quatre bytes en partant du byte avec l’index 5 (compter en partant de la gauche en com­men­çant par 0) : 0x377a3af0. Dans ce cas, la valeur commence déjà avec un bit sur 0. Si tel n’était pas le cas, on le mo­di­fie­rait pour obtenir un bit de départ sur 0. La valeur de 31 bits est donc également de : 0x377a3af0 ou 930757360.

Afin de réduire cette séquence de neuf chiffres à six chiffres, on effectue une opération de modulo et on ajoute si besoin des zéros à gauche : 930757360 mod (106) = 757360. Ce chiffre est donc le TOTP qui sera valide pendant 30 secondes. Associé à un autre facteur, il permet d’obtenir une procédure de connexion re­la­ti­ve­ment sûre.

Aller au menu principal