CloudAcademia
FR

Cybersécurité · Module 07 · Authentification et authentification multifacteur

Lab : stocker des mots de passe et construire des codes TOTP

Lab45 minDébutantMarkdown

Affichage du Markdown brut : le moteur de rendu n'a pas pu être chargé.

## Objectif
Constatez par vous-même pourquoi un hachage simple est une mauvaise façon de stocker des mots de passe, stockez des mots de passe de manière sûre avec un sel et un hachage lent, puis construisez vous-même le code à six chiffres d'une application d'authentification en une vingtaine de lignes de Python. Vous vérifiez ensuite votre code avec les valeurs de test officielles de la RFC 6238.

## Objectifs
- Montrer qu'un hachage SHA-256 simple donne la même valeur pour le même mot de passe, et qu'un mot de passe courant peut être retrouvé par recherche.
- Stocker des mots de passe avec un sel aléatoire et `hashlib.scrypt`, et les vérifier avec une comparaison en temps constant.
- Générer des codes TOTP et les comparer aux vecteurs de test de l'annexe B de la RFC 6238.
- Dire quel second facteur arrêterait un site de phishing qui relaie les codes en temps réel.

## Prérequis
- Python 3.9 ou version ultérieure (`python3 --version`). Vous collez de courts scripts et vous les exécutez ; vous n'avez pas besoin d'être programmeur.
- Un terminal et un endroit où coller du texte (les commandes ci-dessous créent les fichiers pour vous).
- Facultatif (étape 4) : une application d'authentification sur votre téléphone qui permet d'ajouter un compte en saisissant une clé (la plupart le permettent).
- [La leçon Authentification et MFA](lesson.fr.md) de ce module.
- Aucun compte, aucun réseau et aucune coordonnée de paiement.

> [!WARNING]
> Tout se déroule ici sur votre propre ordinateur, avec des utilisateurs et des mots de passe inventés. N'utilisez jamais un mot de passe que vous employez réellement, et ne collez jamais le secret TOTP d'un vrai compte dans un script. Le secret que vous créez à l'étape 4 est **réservé à ce lab** : supprimez-le de l'application de votre téléphone dans la section Nettoyage.

## Architecture
<figure class="diagram" style="--dg-w: 1000px"><svg xmlns="http://www.w3.org/2000/svg" class="dg" viewBox="0 0 1000 440" width="1000" height="440" role="img" aria-labelledby="auth-lab-architecture-fr-title auth-lab-architecture-fr-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="fr">
<title id="auth-lab-architecture-fr-title">Vue d&#x27;ensemble du lab : quatre scripts sur votre ordinateur et une application facultative sur téléphone</title>
<desc id="auth-lab-architecture-fr-desc">À gauche, une zone pour votre ordinateur, dossier ~/auth-lab, avec quatre étapes : l&#x27;étape 1 plain_hash.py montre le même mot de passe donnant le même SHA-256 ; l&#x27;étape 2 store.py enregistre avec un sel et scrypt pour que les valeurs diffèrent ; l&#x27;étape 3 totp.py vérifie les vecteurs de test de la RFC 6238 ; l&#x27;étape 4 show_code.py affiche un secret aléatoire et un code en direct. À droite, une zone facultative de téléphone avec une application d&#x27;authentification où vous saisissez à la main le secret du lab. Un lien intitulé même secret, même heure relie l&#x27;étape 4 à l&#x27;application, et vous comparez si les deux affichent les mêmes six chiffres. Une note indique de supprimer le secret du téléphone au nettoyage.</desc>
<rect class="dg-bg" x="0.5" y="0.5" width="999" height="439" rx="16" fill="#ffffff" stroke="#e3e3dd"/>
<g class="dg-l1"><rect class="dg-tint" x="20" y="20" width="520" height="400" rx="16" fill="#f0f6f9" stroke="#9ac3d9" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(36 33) scale(0.7500)" fill="none" stroke="#0369a1" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M20 16V7a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v9m16 0H4m16 0 1.28 2.55a1 1 0 0 1-.9 1.45H3.62a1 1 0 0 1-.9-1.45L4 16"/></g>
<text x="62" y="47" font-size="13" class="dg-ink" fill="#0369a1" font-weight="700">Votre ordinateur : ~/auth-lab</text></g>
<g class="dg-l2"><rect class="dg-tint" x="640" y="20" width="340" height="400" rx="16" fill="#f1f7f3" stroke="#a1ccb1" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(656 33) scale(0.7500)" fill="none" stroke="#15803d" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect width="14" height="20" x="5" y="2" rx="2"/><path d="M12 18h.01"/></g>
<text x="682" y="47" font-size="13" class="dg-ink" fill="#15803d" font-weight="700">Votre téléphone (facultatif)</text></g>
<rect class="dg-card" x="40" y="56" width="480" height="82" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l1"><g class="dg-icon" transform="translate(56 72) scale(1.2500)" fill="none" stroke="#0369a1" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><ellipse cx="12" cy="5" rx="9" ry="3"/><path d="M3 5V19A9 3 0 0 0 21 19V5"/><path d="M3 12A9 3 0 0 0 21 12"/></g></g>
<g class="dg-l1"><text x="98" y="93" font-size="14" class="dg-ink" fill="#0369a1" font-weight="700">Étape 1 : plain_hash.py</text></g>
<text x="58" y="124" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">même mot de passe, même SHA-256</text>
<rect class="dg-card" x="40" y="146" width="480" height="82" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l1"><g class="dg-icon" transform="translate(56 162) scale(1.2500)" fill="none" stroke="#0369a1" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M5 22h14"/><path d="M5 2h14"/><path d="M17 22v-4.17a2 2 0 0 0-.59-1.42L12 12l-4.41 4.41A2 2 0 0 0 7 17.83V22"/><path d="M7 2v4.17a2 2 0 0 0 .59 1.42L12 12l4.41-4.41A2 2 0 0 0 17 6.17V2"/></g></g>
<g class="dg-l1"><text x="98" y="183" font-size="14" class="dg-ink" fill="#0369a1" font-weight="700">Étape 2 : store.py</text></g>
<text x="58" y="214" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">sel + scrypt, valeurs différentes</text>
<rect class="dg-card" x="40" y="236" width="480" height="82" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l1"><g class="dg-icon" transform="translate(56 252) scale(1.2500)" fill="none" stroke="#0369a1" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><path d="M12 6v6l4 2"/></g></g>
<g class="dg-l1"><text x="98" y="273" font-size="14" class="dg-ink" fill="#0369a1" font-weight="700">Étape 3 : totp.py</text></g>
<text x="58" y="304" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">vecteurs de test de la RFC 6238</text>
<rect class="dg-card" x="40" y="326" width="480" height="82" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l1"><g class="dg-icon" transform="translate(56 342) scale(1.2500)" fill="none" stroke="#0369a1" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><circle cx="7.5" cy="15.5" r="5.5"/><path d="m21 2-9.6 9.6"/><path d="m15.5 7.5 3 3L22 7l-3-3"/></g></g>
<g class="dg-l1"><text x="98" y="363" font-size="14" class="dg-ink" fill="#0369a1" font-weight="700">Étape 4 : show_code.py</text></g>
<text x="58" y="394" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">un secret et un code en direct</text>
<rect class="dg-card" x="660" y="326" width="300" height="82" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l2"><g class="dg-icon" transform="translate(676 342) scale(1.2500)" fill="none" stroke="#15803d" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><rect width="14" height="20" x="5" y="2" rx="2"/><path d="M12 18h.01"/></g></g>
<g class="dg-l2"><text x="718" y="363" font-size="14" class="dg-ink" fill="#15803d" font-weight="700">Application d&#x27;authentification</text></g>
<text x="678" y="394" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">saisie manuelle du secret du lab</text>
<g class="dg-l3"><path class="dg-stroke" d="M522 367H636" stroke="#b45309" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l3"><path class="dg-stroke" d="M631 361l8 6-8 6" stroke="#b45309" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<text x="810" y="80" font-size="13" class="dg-text" fill="#17171c" font-weight="700" text-anchor="middle">Même secret, même heure</text>
<text x="810" y="102" font-size="13" class="dg-text" fill="#17171c" font-weight="700" text-anchor="middle">Les deux affichent-elles les mêmes 6 chiffres ?</text>
<text x="810" y="134" font-size="12" class="dg-muted" fill="#5c5c68" font-weight="500" text-anchor="middle">Saisissez le secret à la main ; supprimez-le au nettoyage.</text>
</svg></figure>

*Figure 1. Quatre petits scripts dans un seul dossier. Seule l'étape 4 touche votre téléphone, et seulement si vous le souhaitez.*

## Étapes

### Étape 1 — Voir pourquoi les hachages simples sont mauvais (8 min)
Un hachage transforme un mot de passe en une empreinte de longueur fixe qui ne peut pas être inversée. Stocker `SHA-256(password)` paraît sûr. Voyons ce que peut faire un attaquant qui vole une telle table. Créez le dossier et un script :

```bash
mkdir ~/auth-lab
cd ~/auth-lab
cat > plain_hash.py <<'EOF2'
import hashlib

def sha256(text):
    return hashlib.sha256(text.encode()).hexdigest()

# A pretend user table where passwords are stored as a plain SHA-256 hash.
users = {"alice": sha256("sunshine1"), "bob": sha256("sunshine1"), "carol": sha256("c0rrect horse battery")}
for name, stored in users.items():
    print(name, stored)

# An attacker who stole the table tries a short list of common passwords.
common = ["123456", "password", "qwerty", "letmein", "sunshine1"]
lookup = {sha256(word): word for word in common}
print()
for name, stored in users.items():
    print(name, "->", lookup.get(stored, "not in my list"))
EOF2
python3 plain_hash.py
```

Sortie attendue :
```text
alice 284fff3bd254b48cca05a8bfc4fad69e05cad0d086513a034a66a118829e6fa4
bob 284fff3bd254b48cca05a8bfc4fad69e05cad0d086513a034a66a118829e6fa4
carol af2de743ce77cb99a82cda058f8a04c158bf7f8109e06f302539ba2107320f8d

alice -> sunshine1
bob -> sunshine1
carol -> not in my list
```

En clair :

- **alice et bob ont la même valeur stockée.** Le même mot de passe donne le même hachage. Quiconque lit la table voit que deux personnes partagent un mot de passe, et casser l'un casse les deux.
- **La seconde moitié, c'est l'attaquant.** Il hache une fois chaque mot de passe courant, construit une table de recherche et la compare à la table volée. Alice et bob tombent en une seule recherche. Les listes réelles comptent des milliards d'entrées, et des hachages rapides comme SHA-256 permettent à une carte graphique d'en tester des milliards par seconde.
- **carol n'est en sécurité que parce que sa phrase secrète ne figure pas sur la liste.** C'est de la chance, pas de la conception.

<details>
<summary>Pourquoi ne pas simplement hacher deux fois ?</summary>

Hacher deux fois avec la même fonction rapide reste rapide, et donne toujours la même valeur pour le même mot de passe. Les deux remèdes sont un **sel** (une valeur différente pour chaque utilisateur) et un hachage **lent** (coûteux à chaque essai). L'étape 2 utilise les deux.

</details>

### Étape 2 — Stocker les mots de passe avec un sel et scrypt (10 min)
Voici maintenant la bonne méthode. Pour chaque utilisateur, créez un **sel** aléatoire, puis hachez ensemble le mot de passe et le sel avec **scrypt**, une fonction délibérément lente et gourmande en mémoire. Stockez le sel à côté du résultat. Pour la connexion, refaites le calcul avec le sel stocké et comparez.

```bash
cat > store.py <<'EOF2'
import hashlib, hmac, os

def make_record(password):
    salt = os.urandom(16)  # random, different for every user
    digest = hashlib.scrypt(password.encode(), salt=salt, n=2**14, r=8, p=1, dklen=32)
    return salt, digest

def check(password, salt, digest):
    attempt = hashlib.scrypt(password.encode(), salt=salt, n=2**14, r=8, p=1, dklen=32)
    return hmac.compare_digest(attempt, digest)

alice = make_record("sunshine1")
bob = make_record("sunshine1")
print("alice salt:  ", alice[0].hex())
print("alice stored:", alice[1].hex())
print("bob salt:    ", bob[0].hex())
print("bob stored:  ", bob[1].hex())
print("same stored value?", alice[1] == bob[1])
print("alice, right password:", check("sunshine1", *alice))
print("alice, wrong password:", check("sunshine2", *alice))
EOF2
python3 store.py
```

Sortie attendue (les valeurs hexadécimales sont aléatoires et **changent à chaque exécution** ; les trois dernières lignes ne changent jamais) :
```text
alice salt:   193e9e110d6fa0c36ea40a17ebd745be
alice stored: a58c567800dd4b22ff91e798bf0d25af061a5bbb06988decd854e812ea7d7729
bob salt:     ecca3df25d21df01104b2ad8b5795727
bob stored:   a7e5da3f8effd62fda91f6dabfeadafe9511c49457f9a28ef35761d10a5b750c
same stored value? False
alice, right password: True
alice, wrong password: False
```

En clair :

- **alice et bob utilisent le même mot de passe, mais les valeurs stockées diffèrent.** Leurs sels sont différents, donc leurs hachages le sont aussi. Une table de recherche préparée à l'avance est inutile, et l'attaquant doit attaquer chaque compte séparément.
- **Le sel est stocké en clair.** C'est normal : son rôle est d'être unique, pas secret.
- **La vérification** refait scrypt avec le sel enregistré. `True` pour le bon mot de passe, `False` pour le mauvais.
- **`hmac.compare_digest`** compare deux valeurs en temps constant. Un `==` ordinaire peut s'arrêter au premier octet différent, et cette infime différence de durée peut laisser fuiter des informations.
- **Lent volontairement.** Un scrypt prend ici quelques centièmes de seconde. Personne ne le remarque à la connexion, mais pour un attaquant, cela multiplie le coût de chaque essai.

> [!NOTE]
> `n=2**14` est choisi pour que le lab s'exécute rapidement sur n'importe quel ordinateur. Les systèmes réels utilisent des paramètres plus élevés, ou Argon2id. Consultez les recommandations actuelles dans l'OWASP Password Storage Cheat Sheet plutôt que de copier des valeurs depuis un lab.

Exécutez-le une seconde fois et regardez les sels :

```bash
python3 store.py | head -2
```

Le sel et la valeur stockée sont de nouveau différents, alors que le mot de passe n'a pas changé.

### Étape 3 — Construire le TOTP et le vérifier avec la RFC (12 min)
Un code TOTP est un calcul sur un secret partagé et l'heure. Vous allez l'écrire sous forme d'un petit module que les étapes suivantes réutilisent. Lisez les commentaires : chaque ligne correspond à une case de la figure de la leçon.

```bash
cat > totp.py <<'EOF2'
import hashlib, hmac, struct, time

def totp(secret_bytes, t=None, digits=6, step=30):
    counter = int((time.time() if t is None else t) // step)  # the time step T
    mac = hmac.new(secret_bytes, struct.pack(">Q", counter), hashlib.sha1).digest()
    offset = mac[-1] & 0x0F                                   # dynamic truncation
    number = struct.unpack(">I", mac[offset:offset + 4])[0] & 0x7FFFFFFF
    return str(number % 10**digits).zfill(digits)

if __name__ == "__main__":
    secret = b"12345678901234567890"   # RFC 6238 test secret
    for t, expected in [(59, "94287082"), (1111111109, "07081804"), (1111111111, "14050471"),
                        (1234567890, "89005924"), (2000000000, "69279037")]:
        code = totp(secret, t, digits=8)
        print(t, code, expected, "OK" if code == expected else "WRONG")
EOF2
python3 totp.py
```

Sortie attendue :
```text
59 94287082 94287082 OK
1111111109 07081804 07081804 OK
1111111111 14050471 14050471 OK
1234567890 89005924 89005924 OK
2000000000 69279037 69279037 OK
```

En clair :

- **Chaque ligne** donne un temps Unix en secondes, le code calculé par votre fonction, le code que la RFC indique comme correct, et OK ou WRONG.
- Les cinq instants de test et les codes à 8 chiffres attendus proviennent de l'**annexe B de la RFC 6238** (la colonne SHA-1). Obtenir cinq lignes OK signifie que votre code fait exactement ce que font les applications d'authentification.
- Les lignes de la fonction correspondent à la leçon : `// step` est le pas de temps, `hmac.new(...)` est le HMAC-SHA1, `& 0x0F` et la tranche forment la troncature dynamique, `% 10**digits` donne les chiffres.
- Les applications réelles utilisent 6 chiffres, ce qui est la valeur par défaut (`digits=6`) ; les vecteurs de la RFC en utilisent 8.

Vérification rapide : la première ligne correspond à l'instant 59, soit 59 secondes après le 1er janvier 1970. Le pas de temps `59 // 30` vaut 1. Quel code à 6 chiffres une application afficherait-elle alors ?

<details>
<summary>Afficher la réponse</summary>

Les six derniers chiffres de la valeur à 8 chiffres : `287082`. Vous pouvez le vérifier :

```bash
python3 -c "from totp import totp; print(totp(b'12345678901234567890', 59))"
```

Sortie : `287082`. (Le code à 6 chiffres est le même nombre modulo un million, donc ce sont les six derniers chiffres de `94287082`.)

</details>

### Étape 4 — Un vrai secret et un code en direct (10 min)
Les applications d'authentification conservent le secret sous forme de texte en **base32** (lettres A-Z et chiffres 2-7). Créons-en un au hasard et affichons le code courant toutes les cinq secondes.

```bash
cat > show_code.py <<'EOF2'
import base64, secrets, time
from totp import totp

secret_b32 = base64.b32encode(secrets.token_bytes(10)).decode()  # 80 random bits -> 16 letters
print("Secret (lab only):", secret_b32)
key = base64.b32decode(secret_b32)
for _ in range(6):
    left = 30 - int(time.time()) % 30
    print(time.strftime("%H:%M:%S"), totp(key), f"(changes in {left}s)")
    time.sleep(5)
EOF2
python3 show_code.py
```

Sortie attendue (le secret, les heures et les codes **sont différents chez vous** ; la forme est la même) :
```text
Secret (lab only): EM35V2C6LLWLHA47
20:35:52 297598 (changes in 8s)
20:35:57 297598 (changes in 3s)
20:36:02 434430 (changes in 28s)
20:36:07 434430 (changes in 23s)
20:36:12 434430 (changes in 18s)
20:36:17 434430 (changes in 13s)
```

En clair : le code reste identique pendant 30 secondes (le même pas de temps), puis il change. Le compteur « changes in » atteint zéro quand le pas suivant commence. Le serveur et votre téléphone suivent la même horloge : ils sont donc d'accord sans communiquer entre eux.

**Facultatif : comparez avec votre téléphone.** Exécutez de nouveau le script pour que le secret reste affiché à l'écran, et dans votre application d'authentification choisissez « ajouter un compte » puis « saisir une clé de configuration » (le libellé varie selon l'application) :

1. Nom du compte : `auth-lab`.
2. Clé : les 16 lettres affichées après `Secret (lab only):`.
3. Type de clé : **basée sur le temps**. Conservez les valeurs par défaut (6 chiffres, 30 secondes, SHA-1).

Comparez les six chiffres de l'application avec ceux du terminal. Ils doivent correspondre. Si le téléphone affiche un code juste avant un changement et le terminal un instant après, attendez le suivant.

Vous venez de faire ce que fait le scan d'un code QR : un code QR n'est que ce secret, plus un nom, écrit sous forme de lien `otpauth://` en image.

### Étape 5 — Exercice de réflexion : qui arrête le relais ? (5 min)
Un site de phishing affiche une copie de la page de connexion de votre entreprise. Vous saisissez votre mot de passe et le code à six chiffres de votre application. En arrière-plan, le site envoie les deux au vrai site en quelques secondes et se connecte en tant que vous.

Question : pour chaque méthode, arrêterait-elle cette attaque ? Répondez oui ou non et expliquez pourquoi : (a) un mot de passe seul, (b) un code SMS, (c) le code TOTP que vous venez de construire, (d) une notification push avec correspondance de numéro, (e) une clé de sécurité FIDO2 ou une clé d'accès.

<details>
<summary>Afficher la réponse</summary>

| Méthode | Arrête le relais en temps réel ? | Pourquoi |
|---|---|---|
| (a) Mot de passe seul | Non | La page de phishing le collecte directement. |
| (b) Code SMS | Non | Vous saisissez le code dans la fausse page, qui le relaie. |
| (c) Code TOTP | Non | Le code est valable 30 secondes et n'est lié à aucun site web. Votre script le prouve : la fonction ne prend qu'un secret et une heure, jamais une adresse web. |
| (d) Push avec correspondance de numéro | Partiellement | C'est plus difficile, car l'utilisateur doit faire correspondre le nombre affiché sur la vraie connexion. Mais un relais peut tout de même afficher ce nombre sur la fausse page : un utilisateur fatigué ou pressé peut donc se faire piéger. |
| (e) Clé FIDO2 ou clé d'accès | **Oui** | La clé signe un challenge avec l'adresse web que voit le navigateur. Sur le faux site, il n'existe aucun identifiant correspondant, et une signature pour la fausse adresse est inutile sur le vrai site. |

C'est pourquoi les recommandations privilégient désormais les méthodes résistantes au phishing pour les administrateurs et les comptes de grande valeur.

</details>

## Vérification
Contrôlez ces points, dans l'ordre :

```bash
cd ~/auth-lab
python3 totp.py
python3 store.py | tail -3
```

Vous réussissez si :
- `totp.py` affiche cinq lignes qui se terminent toutes par `OK`.
- `store.py` affiche `same stored value? False`, puis `True` pour le bon mot de passe et `False` pour le mauvais.
- À l'étape 1, alice et bob avaient le même SHA-256 et une recherche a retrouvé `sunshine1`.
- (Facultatif) Votre téléphone et `show_code.py` affichaient les mêmes six chiffres.

## Dépannage
| Symptôme | Cause probable | Solution |
|---|---|---|
| `AttributeError: module 'hashlib' has no attribute 'scrypt'` | Ce Python a été compilé sans la prise en charge de scrypt d'OpenSSL | Utilisez un Python standard 3.9 ou ultérieur fourni par votre système ou par python.org ; sur un conteneur minimal, installez le paquet `python3` complet |
| `ModuleNotFoundError: No module named 'totp'` | Vous n'êtes pas dans `~/auth-lab`, ou `totp.py` est absent ou renommé | Exécutez `cd ~/auth-lab`, vérifiez avec `ls` et relancez le bloc de l'étape 3 |
| `SyntaxError` ou `IndentationError` | Le collage a perdu des lignes ou des espaces | Supprimez ce fichier et collez de nouveau tout le bloc, y compris la dernière ligne `EOF2` |
| `totp.py` affiche `WRONG` | Une faute de frappe dans le code, dans une valeur de la RFC ou dans le secret | Comparez le fichier avec le bloc ; le secret doit être exactement `12345678901234567890` |
| Le téléphone affiche un code différent | Faute de frappe dans le secret ; l'application n'est pas réglée sur le mode basé sur le temps ; l'horloge du téléphone est décalée de plus de quelques secondes | Saisissez de nouveau la clé, vérifiez que le type est basé sur le temps, activez la date et l'heure automatiques sur le téléphone |
| `mkdir: cannot create directory ... File exists` | Vous avez déjà exécuté l'étape 1 | Aucun problème : exécutez `cd ~/auth-lab` et continuez |

## Défi (facultatif)
1. Écrivez `verify(secret, code)` qui accepte le code du pas courant et des pas juste avant et après (une fenêtre d'un pas, comme un vrai serveur). Testez-la en lui passant le code d'il y a 30 secondes, puis celui d'il y a 90 secondes.
2. Mesurez la durée de `make_record` avec `n=2**14` et avec `n=2**17` (pour la valeur la plus grande, ajoutez `maxmem=2**28` à l'appel `hashlib.scrypt`, sinon Python refuse d'utiliser autant de mémoire). De combien la vérification d'un mot de passe devient-elle plus lente ? Qu'est-ce que cela signifie pour un attaquant ?
3. Passez une longue phrase secrète dans `check` avec et sans un caractère modifié. La valeur stockée se ressemble-t-elle ? Pourquoi non ?

## Nettoyage
Supprimez le dossier, ainsi que le secret du lab sur votre téléphone :

```bash
cd ~
rm -r ~/auth-lab
```

Sur votre téléphone, ouvrez l'application d'authentification et supprimez le compte `auth-lab` si vous l'avez ajouté. Rien d'autre n'a été installé ni modifié.

## Ce que vous avez appris
- Un hachage simple donne la même valeur pour le même mot de passe et peut être retrouvé par recherche : ce n'est donc pas un stockage de mots de passe sûr.
- Un sel aléatoire par utilisateur et un hachage lent comme scrypt font paraître différents des mots de passe identiques et rendent chaque essai coûteux. Comparez en temps constant.
- Un code TOTP n'est que le HMAC-SHA1 du pas de temps de 30 secondes avec un secret partagé, tronqué en chiffres. Vous l'avez vérifié avec la RFC 6238.
- Un code que vous saisissez n'est lié à aucun site web : un site de phishing peut donc le relayer. Une clé FIDO2 ou une clé d'accès signe l'origine, donc elle ne peut pas être relayée.