CloudAcademia
IT

Cybersecurity · Modulo 07 · Autenticazione e autenticazione a più fattori

Laboratorio: conservare le password e costruire codici TOTP

Laboratorio45 minPrincipianteMarkdown

Viene mostrato il Markdown grezzo: non è stato possibile caricare il visualizzatore.

## Obiettivo
Vedere con i tuoi occhi perché un semplice hash è un cattivo modo di conservare le password, conservare le password nel modo sicuro con un salt e un hash lento, e costruire tu stesso il codice a sei cifre di un'app di autenticazione in circa 20 righe di Python. Verificherai poi il tuo codice con i valori di test ufficiali della RFC 6238.

## Obiettivi
- Dimostrare che un semplice hash SHA-256 produce lo stesso valore per la stessa password e che una password comune può essere cercata in una tabella.
- Conservare le password con un salt casuale e `hashlib.scrypt`, e verificarle con un confronto in tempo costante.
- Generare codici TOTP e verificarli con i vettori di test dell'Appendice B della RFC 6238.
- Indicare quale secondo fattore fermerebbe un sito di phishing che inoltra i codici in tempo reale.

## Prerequisiti
- Python 3.9 o successivo (`python3 --version`). Incolli brevi script e li esegui; non occorre essere programmatori.
- Un terminale e un posto dove incollare il testo (i comandi qui sotto creano i file per te).
- Facoltativo (passo 4): un'app di autenticazione sul telefono che possa aggiungere un account digitando una chiave (la maggior parte può farlo).
- [La lezione su autenticazione e MFA](lesson.it.md) di questo modulo.
- Nessun account, nessuna rete e nessun dato di pagamento.

> [!WARNING]
> Tutto ciò che segue viene eseguito sul tuo computer con utenti e password inventati. Non usare mai una password che utilizzi davvero e non incollare mai in nessuno script il segreto TOTP di un account reale. Il segreto che crei nel passo 4 è **solo per questo laboratorio**: rimuovilo dall'app del telefono nella sezione Pulizia.

## Architettura
<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-it-title auth-lab-architecture-it-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="it">
<title id="auth-lab-architecture-it-title">Panoramica del lab: quattro script sul computer e un&#x27;app facoltativa sul telefono</title>
<desc id="auth-lab-architecture-it-desc">A sinistra, una zona per il tuo computer, cartella ~/auth-lab, con quattro passaggi: il passo 1 plain_hash.py mostra la stessa password che dà lo stesso SHA-256; il passo 2 store.py salva con un salt e scrypt così i valori differiscono; il passo 3 totp.py verifica i vettori di test della RFC 6238; il passo 4 show_code.py mostra un segreto casuale e un codice in tempo reale. A destra, una zona facoltativa del telefono con un&#x27;app di autenticazione in cui digiti a mano il segreto del lab. Un collegamento con l&#x27;etichetta stesso segreto, stessa ora unisce il passo 4 all&#x27;app, e confronti se entrambe mostrano le stesse sei cifre. Una nota dice di rimuovere il segreto dal telefono alla pulizia.</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">Il tuo computer: ~/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">Il tuo telefono (facoltativo)</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">Passo 1: plain_hash.py</text></g>
<text x="58" y="124" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">stessa password, stesso 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">Passo 2: store.py</text></g>
<text x="58" y="214" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">salt + scrypt, valori diversi</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">Passo 3: totp.py</text></g>
<text x="58" y="304" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">vettori di test della 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">Passo 4: show_code.py</text></g>
<text x="58" y="394" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">un segreto e un codice in tempo reale</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">App di autenticazione</text></g>
<text x="678" y="394" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">inserimento manuale del segreto del 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">Stesso segreto, stessa ora</text>
<text x="810" y="102" font-size="13" class="dg-text" fill="#17171c" font-weight="700" text-anchor="middle">Entrambe mostrano le stesse 6 cifre?</text>
<text x="810" y="134" font-size="12" class="dg-muted" fill="#5c5c68" font-weight="500" text-anchor="middle">Digita il segreto a mano; rimuovilo alla pulizia.</text>
</svg></figure>

*Figura 1. Quattro piccoli script in una sola cartella. Solo il passo 4 coinvolge il tuo telefono, e solo se lo desideri.*

## Passaggi

### Passo 1 — Scopri perché i semplici hash sono inadatti (8 min)
Un hash trasforma una password in un'impronta di lunghezza fissa che non può essere invertita. Conservare `SHA-256(password)` sembra sicuro. Vediamo che cosa può fare un attaccante che rubi una tabella di questo tipo. Crea la cartella e uno 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
```

Output atteso:
```text
alice 284fff3bd254b48cca05a8bfc4fad69e05cad0d086513a034a66a118829e6fa4
bob 284fff3bd254b48cca05a8bfc4fad69e05cad0d086513a034a66a118829e6fa4
carol af2de743ce77cb99a82cda058f8a04c158bf7f8109e06f302539ba2107320f8d

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

In parole semplici:

- **alice e bob hanno lo stesso valore conservato.** Stessa password, stesso hash. Chiunque legga la tabella vede che due persone condividono una password, e violarne una significa violarle entrambe.
- **La seconda metà è l'attaccante.** Calcola una sola volta l'hash di ogni password comune, costruisce una tabella di ricerca e la confronta con la tabella rubata. Alice e bob cadono con una sola ricerca. Gli elenchi reali contengono miliardi di voci, e hash veloci come SHA-256 permettono a una scheda grafica di provarne miliardi al secondo.
- **carol è al sicuro solo perché la sua passphrase non è nell'elenco.** È fortuna, non progettazione.

<details>
<summary>Perché non calcolare semplicemente l'hash due volte?</summary>

Calcolare l'hash due volte con la stessa funzione veloce resta veloce e dà comunque lo stesso valore per la stessa password. Le due soluzioni sono un **salt** (valore diverso per ogni utente) e un hash **lento** (costoso per ogni tentativo). Il passo 2 usa entrambi.

</details>

### Passo 2 — Conserva le password con un salt e scrypt (10 min)
Ora il modo corretto. Per ogni utente crea un **salt** casuale, poi calcola l'hash della password e del salt insieme con **scrypt**, una funzione deliberatamente lenta e onerosa in memoria. Conserva il salt accanto al risultato. Per accedere, ripeti il calcolo con il salt conservato e confronta.

```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
```

Output atteso (i valori esadecimali sono casuali e **cambiano a ogni esecuzione**; le ultime tre righe non cambiano mai):
```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
```

In parole semplici:

- **alice e bob usano la stessa password, ma i valori conservati differiscono.** I loro salt sono diversi, quindi gli hash sono diversi. Una tabella di ricerca preparata in anticipo è inutile, e l'attaccante deve attaccare ogni account separatamente.
- **Il salt è conservato in chiaro.** Va bene: il suo compito è essere univoco, non segreto.
- **La verifica** ripete scrypt con il salt salvato. `True` per la password giusta, `False` per quella sbagliata.
- **`hmac.compare_digest`** confronta due valori in tempo costante. Un normale `==` può fermarsi al primo byte diverso, e quella minima differenza di tempo può rivelare informazioni.
- **Lento di proposito.** Qui un singolo scrypt richiede pochi centesimi di secondo. Nessuno se ne accorge all'accesso, ma per un attaccante moltiplica il costo di ogni singolo tentativo.

> [!NOTE]
> `n=2**14` è scelto perché il laboratorio sia veloce su qualsiasi computer. I sistemi reali usano impostazioni più robuste, oppure Argon2id. Consulta le raccomandazioni attuali nell'OWASP Password Storage Cheat Sheet anziché copiare i valori da un laboratorio.

Esegui lo script una seconda volta e osserva i salt:

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

Il salt e il valore conservato sono di nuovo diversi, anche se la password non è cambiata.

### Passo 3 — Costruisci il TOTP e verificalo con la RFC (12 min)
Un codice TOTP è un calcolo su un segreto condiviso e sul tempo. Lo scriverai come un piccolo modulo che i passi successivi riutilizzano. Leggi i commenti: ogni riga corrisponde a un riquadro della figura della lezione.

```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
```

Output atteso:
```text
59 94287082 94287082 OK
1111111109 07081804 07081804 OK
1111111111 14050471 14050471 OK
1234567890 89005924 89005924 OK
2000000000 69279037 69279037 OK
```

In parole semplici:

- **Ogni riga** riporta un tempo Unix in secondi, il codice calcolato dalla tua funzione, il codice che la RFC indica come corretto, e OK o WRONG.
- I cinque tempi di test e i codici attesi a 8 cifre provengono dalla **RFC 6238, Appendice B** (la colonna SHA-1). Ottenere cinque righe OK significa che il tuo codice fa esattamente ciò che fanno le app di autenticazione.
- Le righe della funzione corrispondono alla lezione: `// step` è l'intervallo di tempo, `hmac.new(...)` è l'HMAC-SHA1, `& 0x0F` e la selezione dei byte sono il troncamento dinamico, `% 10**digits` produce le cifre.
- Le app reali usano 6 cifre, che è il valore predefinito (`digits=6`); i vettori della RFC ne usano 8.

Verifica rapida: la prima riga è il tempo 59, cioè 59 secondi dopo il 1° gennaio 1970. L'intervallo di tempo `59 // 30` è 1. Quale codice a 6 cifre mostrerebbe allora un'app?

<details>
<summary>Mostra la risposta</summary>

Le ultime sei cifre del valore a 8 cifre: `287082`. Puoi verificarlo:

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

Output: `287082`. (Il codice a 6 cifre è lo stesso numero modulo un milione, quindi corrisponde alle ultime sei cifre di `94287082`.)

</details>

### Passo 4 — Un segreto reale e un codice in tempo reale (10 min)
Le app di autenticazione conservano il segreto come testo in **base32** (lettere A-Z e cifre 2-7). Creiamone uno casuale e stampiamo il codice corrente ogni cinque secondi.

```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
```

Output atteso (il segreto, gli orari e i codici **sono diversi per te**; la forma è la stessa):
```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)
```

In parole semplici: il codice resta lo stesso per 30 secondi (lo stesso intervallo di tempo), poi cambia. Il contatore «changes in» arriva a zero quando inizia l'intervallo successivo. Il server e il tuo telefono seguono lo stesso orologio, quindi concordano senza comunicare tra loro.

**Facoltativo: confronta con il tuo telefono.** Esegui di nuovo lo script, in modo che il segreto resti sullo schermo, e nella tua app di autenticazione scegli «aggiungi un account» e poi «inserisci una chiave di configurazione» (la dicitura varia a seconda dell'app):

1. Nome dell'account: `auth-lab`.
2. Chiave: le 16 lettere stampate dopo `Secret (lab only):`.
3. Tipo di chiave: **basata sul tempo**. Lascia i valori predefiniti (6 cifre, 30 secondi, SHA-1).

Confronta le sei cifre nell'app con quelle nel terminale. Dovrebbero coincidere. Se il telefono mostra un codice poco prima di un cambio e il terminale un attimo dopo, attendi il successivo.

Hai appena fatto ciò che fa l'inquadratura di un codice QR: un codice QR è solo questo segreto, più un nome, scritto come link `otpauth://` in forma di immagine.

### Passo 5 — Esercizio di riflessione: chi ferma l'inoltro? (5 min)
Un sito di phishing mostra una copia della pagina di accesso della tua azienda. Digiti la password e il codice a sei cifre della tua app. In background, il sito invia entrambi al sito vero nel giro di pochi secondi e ottiene l'accesso come te.

Domanda: per ciascun metodo, fermerebbe questo attacco? Rispondi sì o no e spiega perché: (a) la sola password, (b) un codice SMS, (c) il codice TOTP che hai appena costruito, (d) una notifica push con corrispondenza del numero, (e) una chiave di sicurezza FIDO2 o una passkey.

<details>
<summary>Mostra la risposta</summary>

| Metodo | Ferma l'inoltro in tempo reale? | Perché |
|---|---|---|
| (a) Solo la password | No | La pagina di phishing la raccoglie direttamente. |
| (b) Codice SMS | No | Digiti il codice nella pagina falsa, che lo inoltra. |
| (c) Codice TOTP | No | Il codice è valido per 30 secondi e non è legato a un sito web. Il tuo script lo dimostra: la funzione riceve solo un segreto e un tempo, mai un indirizzo web. |
| (d) Push con corrispondenza del numero | In parte | È più difficile, perché l'utente deve far corrispondere il numero mostrato nell'accesso vero. Ma un inoltro può comunque mostrare quel numero nella pagina falsa, quindi un utente stanco o frettoloso può essere ingannato. |
| (e) Chiave FIDO2 o passkey | **Sì** | La chiave firma una sfida insieme all'indirizzo web che vede il browser. Sul sito falso non esiste alcuna credenziale corrispondente, e una firma per l'indirizzo falso è inutile sul sito vero. |

Per questo le linee guida oggi privilegiano i metodi resistenti al phishing per gli amministratori e gli account di alto valore.

</details>

## Verifica
Controlla questi punti, in ordine:

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

Il laboratorio è superato se:
- `totp.py` stampa cinque righe che terminano tutte con `OK`.
- `store.py` stampa `same stored value? False`, poi `True` per la password giusta e `False` per quella sbagliata.
- Nel passo 1, alice e bob mostravano lo stesso SHA-256 e una ricerca ha recuperato `sunshine1`.
- (Facoltativo) Il tuo telefono e `show_code.py` mostravano le stesse sei cifre.

## Risoluzione dei problemi
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| `AttributeError: module 'hashlib' has no attribute 'scrypt'` | Questo Python è stato compilato senza il supporto scrypt di OpenSSL | Usa un Python standard 3.9 o successivo del tuo sistema o di python.org; in un container minimale installa il pacchetto `python3` completo |
| `ModuleNotFoundError: No module named 'totp'` | Non sei in `~/auth-lab`, oppure `totp.py` manca o è stato rinominato | Esegui `cd ~/auth-lab`, controlla con `ls` e riesegui il blocco del passo 3 |
| `SyntaxError` o `IndentationError` | Nell'incolla sono andate perse alcune righe o alcuni spazi | Elimina quel file e incolla di nuovo l'intero blocco, compresa l'ultima riga `EOF2` |
| `totp.py` stampa `WRONG` | Un errore di battitura nel codice, in un valore della RFC o nel segreto | Confronta il file con il blocco; il segreto deve essere esattamente `12345678901234567890` |
| Il telefono mostra un codice diverso | Errore di battitura nel segreto; l'app non è impostata sul tipo basato sul tempo; l'orologio del telefono è sfasato di più di qualche secondo | Reinserisci la chiave, verifica che il tipo sia basato sul tempo, attiva data e ora automatiche sul telefono |
| `mkdir: cannot create directory ... File exists` | Hai già eseguito il passo 1 | Nessun problema: esegui `cd ~/auth-lab` e continua |

## Sfida (facoltativa)
1. Scrivi `verify(secret, code)` che accetti il codice per l'intervallo corrente e per quelli immediatamente precedente e successivo (una finestra di un intervallo, come un vero server). Provala passando il codice di 30 secondi fa e quello di 90 secondi fa.
2. Misura il tempo di `make_record` con `n=2**14` e con `n=2**17` (per il valore più grande aggiungi `maxmem=2**28` alla chiamata `hashlib.scrypt`, altrimenti Python rifiuta di usare tanta memoria). Quanto diventa più lenta una singola verifica della password? Che cosa significa per un attaccante?
3. Passa una lunga passphrase a `check` con e senza un carattere modificato. Il valore conservato appare simile? Perché no?

## Pulizia
Rimuovi la cartella e il segreto del laboratorio dal telefono:

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

Sul telefono, apri l'app di autenticazione ed elimina l'account `auth-lab`, se lo hai aggiunto. Nient'altro è stato installato o modificato.

## Cosa hai imparato
- Un semplice hash produce lo stesso valore per la stessa password e può essere cercato in una tabella, quindi non è una conservazione sicura delle password.
- Un salt casuale per ogni utente e un hash lento come scrypt fanno apparire diverse password identiche e rendono costoso ogni tentativo. Confronta in tempo costante.
- Un codice TOTP è semplicemente l'HMAC-SHA1 dell'intervallo di tempo di 30 secondi con un segreto condiviso, troncato a cifre. L'hai verificato con la RFC 6238.
- Un codice che digiti non è legato a un sito web, quindi un sito di phishing può inoltrarlo. Una chiave FIDO2 o una passkey firma l'origine, quindi non può essere inoltrata.