---
title: "Laboratorio: conservare le password e costruire codici TOTP"
domain: cybersecurity
level: beginner
duration: "45 min"
cost: "gratuito"
environment: "il tuo computer (Linux, macOS o Windows con WSL2) con Python 3.9 o successivo; un'app di autenticazione sul telefono è facoltativa"
lang: it
source_hash: c069a4b1d609
---

# Laboratorio: conservare le password e costruire codici TOTP

## 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
![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 conserva 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 stampa un segreto casuale e un codice in tempo reale. A destra, una zona facoltativa del telefono con un'app di autenticazione in cui digiti a mano il segreto del laboratorio. Una freccia collega il passo 4 all'app e confronti se entrambi mostrano le stesse sei cifre. Una nota indica di rimuovere il segreto dal telefono durante la pulizia.](../../../assets/diagrams/auth-lab-architecture.it.svg)

*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.
