Le password, esercizi spiegati
Cinque esempi nell'app degli abbonati
- 25 minuti di lettura
Cinque esempi, dal più semplice, tutti nell'app degli abbonati della Linea Menta. Ognuno ha lo stesso ritmo:
- Prevedi: leggi il codice e scrivi su un foglio cosa stampa. Prima di aprire la risposta.
- In italiano: cosa fa il programma, a parole.
- Passo per passo: cosa succede a ogni riga, o a ogni richiesta.
- Cosa portiamo a casa: la cosa da ricordare.
Gli esempi usano sicurezza.py, il file degli attrezzi che trovi nello zip della palestra. Per provarli: salva il codice in un file dentro palestra/, per esempio palestra/prova.py, e dalla cartella dello zip, con il venv acceso, lancia python palestra/prova.py. Le impronte argon2 che vedrai tu saranno diverse da queste: c'è il sale.
A · Rosa e Teo, la stessa password
Rosa Bellini e Teo Galbiati non si conoscono, ma per l'app hanno scelto la stessa password: metro-milano. Succede più spesso di quanto si pensi.
import hashlib
from sicurezza import calcola_hash, password_giusta
rosa_sha = hashlib.sha256("metro-milano".encode()).hexdigest()
teo_sha = hashlib.sha256("metro-milano".encode()).hexdigest()
print(rosa_sha == teo_sha)
rosa = calcola_hash("metro-milano")
teo = calcola_hash("metro-milano")
print(rosa == teo)
print(password_giusta("metro-milano", rosa))
print(password_giusta("metro-milano", teo))Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
True
False
True
True- Riga 1: sha256 non ha sale. Stessa password, stessa impronta: chi guarda il dizionario capisce che Rosa e Teo hanno la stessa password.
- Riga 2:
calcola_hashmette un sale a caso ogni volta. Due impronte diverse. - Righe 3 e 4: eppure tutte e due riconoscono
metro-milano. Ognuna ha dentro il suo sale, epassword_giustalo usa.
In italiano.
- Calcolo due volte l'impronta sha256 della stessa password, e le confronto.
- Calcolo due volte l'impronta argon2, con
calcola_hash, e le confronto. - Chiedo a
password_giustase la password è quella di ognuna delle due impronte.
Passo per passo. Ecco cosa c'era nelle quattro etichette in un lancio vero:
| Etichetta | Cosa c'è dentro | Perché |
|---|---|---|
rosa_sha | 7d080224a4c1eb9e… | sha256, nessun sale |
teo_sha | 7d080224a4c1eb9e… | la stessa: stessa password, stesso calcolo |
rosa | $argon2id$v=19$m=65536,t=3,p=4$hSc2OgvdWjD6lRgUILBbSw$ArPZNtvC… | un sale a caso: hSc2… |
teo | $argon2id$v=19$m=65536,t=3,p=4$FFl6xP6MI64VnDwfJLQw5g$u/MqkA56… | un altro sale: FFl6… |
Cosa portiamo a casa. Con il sale, due impronte diverse non vogliono dire due password diverse. Per sapere se una password è giusta non si confrontano impronte: si chiede a password_giusta.
B · Dentro l'impronta di Rosa
L'impronta di Rosa, quella dell'esempio A, è una stringa sola. La smontiamo con split, come una riga di un file.
impronta = "$argon2id$v=19$m=65536,t=3,p=4$hSc2OgvdWjD6lRgUILBbSw$ArPZNtvC2CqKPSOVxN/9o9LrDspojWMWFPcBKcw/JvE"
pezzi = impronta.split("$")
print(len(pezzi))
print(pezzi)
print(pezzi[1])
print(pezzi[4])Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
6
['', 'argon2id', 'v=19', 'm=65536,t=3,p=4', 'hSc2OgvdWjD6lRgUILBbSw', 'ArPZNtvC2CqKPSOVxN/9o9LrDspojWMWFPcBKcw/JvE']
argon2id
hSc2OgvdWjD6lRgUILBbSwI $ sono cinque, i pezzi sono sei. L'impronta comincia con un $: prima di lui non c'è niente, e split ti consegna proprio quel niente, la stringa vuota ''. È lo stesso motivo per cui "Piazza Query".split(" ") lascia un pezzo vuoto in mezzo (lo trovi nel capitolo sulle stringhe).
In italiano. Taglio l'impronta dove c'è un $, conto i pezzi, li stampo tutti, poi prendo il secondo e il quinto.
Passo per passo. I pezzi, con il loro numero:
| Numero | Pezzo | Cosa dice |
|---|---|---|
pezzi[0] | '' | niente: c'era solo il $ iniziale |
pezzi[1] | 'argon2id' | l'algoritmo |
pezzi[2] | 'v=19' | la versione |
pezzi[3] | 'm=65536,t=3,p=4' | memoria, passaggi, parallelo |
pezzi[4] | 'hSc2OgvdWjD6lRgUILBbSw' | il sale |
pezzi[5] | 'ArPZNtvC2CqKPSOVxN/9o9LrDspojWMWFPcBKcw/JvE' | il risultato del calcolo |
Cosa portiamo a casa. Il sale è lì, scritto in chiaro: non è un segreto, ed è il motivo per cui password_giusta può rifare il calcolo. E quando conti i pezzi di split, conta anche quelli vuoti.
C · Il tornello dell'app
Il tornello dell'app chiede username e password, e ha solo un dizionario username → impronta. Deve dire sì o no. Ugo Pirola non si è ancora iscritto, ma ci prova lo stesso.
from sicurezza import calcola_hash, password_giusta
abbonati = {
"rosa": calcola_hash("metro-milano"),
"teo": calcola_hash("metro-milano"),
}
def puo_entrare(abbonati: dict[str, str], username: str, password: str) -> bool:
impronta = abbonati.get(username)
if impronta is None:
return False
return password_giusta(password, impronta)
print(puo_entrare(abbonati, "rosa", "metro-milano"))
print(puo_entrare(abbonati, "rosa", "metro-roma"))
print(puo_entrare(abbonati, "ugo", "metro-milano"))
print(calcola_hash("metro-milano") == abbonati["rosa"])Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
True
False
False
FalseLa quarta è la più importante: Rosa ha proprio la password metro-milano, eppure == dice False. calcola_hash ha messo un sale nuovo, quindi è un'impronta nuova.
Il dizionario, con le impronte:
In italiano.
- Cerco l'impronta dello username con
get: se lo username non c'è, ricevoNone. - Se è
None, rispondoFalse, come a una password sbagliata. Così nessuno scopre chi è iscritto e chi no (è la regola del capitolo 1: stessa risposta per i due casi). - Altrimenti chiedo a
password_giusta: prima la password, poi l'impronta.
Passo per passo.
| Chiamata | abbonati.get(username) | È None? | password_giusta(…) | Risultato |
|---|---|---|---|---|
"rosa", "metro-milano" | l'impronta di Rosa | no | il calcolo torna | True |
"rosa", "metro-roma" | l'impronta di Rosa | no | il calcolo non torna | False |
"ugo", "metro-milano" | None | sì | non si arriva | False |
Con le quadre, abbonati["ugo"], la terza chiamata si fermerebbe con KeyError: 'ugo': il tornello bloccato da uno che non è nemmeno iscritto.
Cosa portiamo a casa. Tre righe che tornano sempre: get, l'if … is None, poi password_giusta(password, impronta). Al login del capitolo 6 sono le stesse.
D · L'iscrizione di un abbonato
Adesso l'app ha la sua API: POST /abbonati iscrive un abbonato nuovo. Tre stampi, come nella teoria: il corpo, quello che resta nel dizionario, la risposta.
from fastapi import FastAPI, HTTPException, status
from pydantic import BaseModel, Field
from sicurezza import calcola_hash
app = FastAPI(title="L'app degli abbonati")
class Abbonato(BaseModel): # la risposta: niente password, niente impronta
username: str
nome: str
class AbbonatoNuovo(BaseModel): # il corpo: la password arriva in chiaro, una volta sola
username: str = Field(min_length=3, max_length=30)
nome: str = Field(min_length=1)
password: str = Field(min_length=8)
class AbbonatoSalvato(Abbonato): # nel dizionario: al posto della password, l'impronta
password_hash: str
abbonati: dict[str, AbbonatoSalvato] = {}
@app.post("/abbonati", status_code=status.HTTP_201_CREATED)
def iscrivi(dati: AbbonatoNuovo) -> Abbonato:
if dati.username in abbonati:
raise HTTPException(status_code=409, detail="Username già preso")
abbonato = AbbonatoSalvato(username=dati.username, nome=dati.nome, password_hash=calcola_hash(dati.password))
abbonati[abbonato.username] = abbonato
print(abbonato) # provvisoria: per vedere, nel terminale del server, cosa è finito nel dizionario
return abbonatoSalvalo come palestra/abbonati.py e accendilo con fastapi dev palestra/abbonati.py. Poi, in un secondo terminale, quattro richieste: Rosa, Teo con la stessa password, qualcun altro che vuole lo username rosa, Ugo con una password di quattro lettere.
curl -i -X POST http://127.0.0.1:8000/abbonati -H "Content-Type: application/json" -d '{"username": "rosa", "nome": "Rosa Bellini", "password": "metro-milano"}'
curl -s -X POST http://127.0.0.1:8000/abbonati -H "Content-Type: application/json" -d '{"username": "teo", "nome": "Teo Galbiati", "password": "metro-milano"}'
curl -i -X POST http://127.0.0.1:8000/abbonati -H "Content-Type: application/json" -d '{"username": "rosa", "nome": "Rosa Rossi", "password": "un-altra-ancora"}'
curl -s -X POST http://127.0.0.1:8000/abbonati -H "Content-Type: application/json" -d '{"username": "ugo", "nome": "Ugo Pirola", "password": "tram"}'Prevedi, per ognuna: il codice e il corpo della risposta. E nel terminale del server, cosa stampa il print?
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
$ curl -i -X POST http://127.0.0.1:8000/abbonati -H "Content-Type: application/json" -d '{"username": "rosa", "nome": "Rosa Bellini", "password": "metro-milano"}'
HTTP/1.1 201 Created
date: Thu, 19 Nov 2026 16:15:22 GMT
server: uvicorn
content-length: 41
content-type: application/json
{"username":"rosa","nome":"Rosa Bellini"}
$ curl -s -X POST http://127.0.0.1:8000/abbonati -H "Content-Type: application/json" -d '{"username": "teo", "nome": "Teo Galbiati", "password": "metro-milano"}'
{"username":"teo","nome":"Teo Galbiati"}
$ curl -i -X POST http://127.0.0.1:8000/abbonati -H "Content-Type: application/json" -d '{"username": "rosa", "nome": "Rosa Rossi", "password": "un-altra-ancora"}'
HTTP/1.1 409 Conflict
date: Thu, 19 Nov 2026 16:15:22 GMT
server: uvicorn
content-length: 32
content-type: application/json
{"detail":"Username già preso"}
$ curl -s -X POST http://127.0.0.1:8000/abbonati -H "Content-Type: application/json" -d '{"username": "ugo", "nome": "Ugo Pirola", "password": "tram"}'
{"detail":[{"type":"string_too_short","loc":["body","password"],"msg":"String should have at least 8 characters","input":"tram","ctx":{"min_length":8}}]}E nel terminale del server, tra le righe del registro:
username='rosa' nome='Rosa Bellini' password_hash='$argon2id$v=19$m=65536,t=3,p=4$ORfGD4rP9zeV7tnecI+o5Q$LAlE1L8Cy3or+n+ASuAdXIgUkr0DYE+oOgnK1M+rnJc'
INFO: 127.0.0.1:60689 - "POST /abbonati HTTP/1.1" 201 Created
username='teo' nome='Teo Galbiati' password_hash='$argon2id$v=19$m=65536,t=3,p=4$LHIOo3WNdfCOKiG8yJNHnw$33d0WIOuLqkrj0o3L/j6kxiZ6wT1gSisNgtOmIPdx/k'
INFO: 127.0.0.1:60690 - "POST /abbonati HTTP/1.1" 201 Created
INFO: 127.0.0.1:60691 - "POST /abbonati HTTP/1.1" 409 Conflict
INFO: 127.0.0.1:60692 - "POST /abbonati HTTP/1.1" 422 Unprocessable EntityNel dizionario Rosa e Teo hanno impronte diverse, anche se la password è la stessa. Fuori, nelle risposte, nessuna impronta. Il 409 e il 422 non stampano niente: la funzione si ferma prima del print (il 409), o non parte nemmeno (il 422).
In italiano.
- Se lo username è già nel dizionario, mi fermo con il 409. Prima di scrivere: dopo, Rosa sarebbe già stata sovrascritta.
- Costruisco l'abbonato da salvare: username e nome dal corpo, e al posto della password la sua impronta.
- Lo metto nel dizionario, con lo username come chiave.
- Lo restituisco. La freccia dice
Abbonato: FastAPI fa uscire solo username e nome.
Il disegno.
Passo per passo.
| Richiesta | Lo stampo AbbonatoNuovo | dati.username in abbonati? | Cosa succede | Risposta |
|---|---|---|---|---|
| Rosa | va bene | no | impronta, dizionario | 201, username e nome |
| Teo | va bene | no | impronta (un altro sale), dizionario | 201, username e nome |
| «Rosa Rossi» | va bene | sì | raise del 409 | 409, «Username già preso» |
| Ugo | password di 4 caratteri: no | non si arriva | FastAPI risponde da solo | 422, e loc dice dove: body, password |
Cosa portiamo a casa. La password in chiaro vive per una riga sola, quella di calcola_hash. E la riga del print era provvisoria: toglila. Un'impronta non deve finire da nessuna parte, nemmeno nel terminale.
E · L'impronta che scappa
Parti dall'API dell'esempio D, senza la riga del print, e cambia una parola sola: la freccia.
@app.post("/abbonati", status_code=status.HTTP_201_CREATED)
-def iscrivi(dati: AbbonatoNuovo) -> Abbonato:
+def iscrivi(dati: AbbonatoNuovo) -> AbbonatoSalvato:Riaccendi il server e iscrivi Ugo, stavolta con una password lunga abbastanza.
curl -s -X POST http://127.0.0.1:8000/abbonati -H "Content-Type: application/json" -d '{"username": "ugo", "nome": "Ugo Pirola", "password": "tram-di-notte"}'Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
{"username":"ugo","nome":"Ugo Pirola","password_hash":"$argon2id$v=19$m=65536,t=3,p=4$jE3xvwSeN6iZQA4G1iJy9A$KGKeHumHW8DPDUTjPtQgR1ZHLAsWWeKK+I7mSYPQhaA"}Il codice è sempre 201, nessun errore, nel registro del server nessun avviso. Ma l'impronta di Ugo è uscita: è nella risposta, e chiunque l'abbia ricevuta (o intercettata) può provare password sul suo computer finché una torna.
In italiano. La funzione restituisce sempre la stessa cosa: un AbbonatoSalvato, con l'impronta. A decidere cosa esce è la freccia. Con -> Abbonato, FastAPI tiene solo username e nome; con -> AbbonatoSalvato, tiene tutto.
Passo per passo.
| La freccia | Cosa restituisce la funzione | Cosa esce nella risposta |
|---|---|---|
-> Abbonato | AbbonatoSalvato (con l'impronta) | username, nome |
-> AbbonatoSalvato | AbbonatoSalvato (con l'impronta) | username, nome, password_hash |
Cosa portiamo a casa. È un errore che non fa rumore: niente traceback, niente 500. Lo vedi solo leggendo la risposta, o con un test che la guarda, come quelli della palestra. Lo stampo della risposta non ha mai il campo password_hash.
Pronto? Gli stessi schemi ti aspettano nella palestra, nel portale del personale: quattro esercizi da scaricare, con i test.