Le password
Si salva l'impronta, mai la password
- 12 minuti di lettura
Al login qualcuno ti scrive una password. Il server deve riconoscerla subito, tra una settimana, tra un anno. Quindi deve tenere qualcosa da parte. La domanda di questo capitolo è una sola: cosa tiene?
La risposta corta: non la password. La sua impronta.
Mai in chiaro
L'app degli abbonati della Linea Menta tiene gli iscritti in un dizionario, come le API del libro HTTP. La prima idea è salvare la password così com'è, in chiaro:
abbonati = {
"rosa": "metro-milano",
"teo": "metro-milano",
}Funziona, ed è un disastro. Basta che qualcuno metta le mani sul dizionario (una copia del database, un backup dimenticato, un portatile perso) e legge tutte le password. Peggio: tanta gente usa la stessa password dappertutto. Chi ha rubato quella di Rosa la prova sulla sua mail, sulla sua banca.
COSÌ NO · IN CHIARO
username password
rosa metro-milano
teo metro-milano chi ruba il dizionario legge le password
COSÌ SÌ · SOLO L'IMPRONTA
username password_hash
rosa $argon2id$v=19$m=65536,t=3,p=4$hSc2OgvdWjD6lRgUILBbSw$ArPZNtvC…
teo $argon2id$v=19$m=65536,t=3,p=4$FFl6xP6MI64VnDwfJLQw5g$u/MqkA56…
chi ruba il dizionario trova impronteIl campo si chiama password_hash: il nome dice cosa c'è dentro. Un campo password nel dizionario non deve esistere.
L'impronta
Hash, in italiano impronta: un calcolo che dalla password tira fuori una stringa lunga e strana. Ha tre proprietà, e servono tutte e tre:
- la stessa password dà sempre la stessa impronta;
- basta una lettera diversa, e l'impronta cambia tutta;
- dall'impronta non si torna indietro: è un calcolo a senso unico.
L'hai già usato: il verifica.py delle storie conosce solo l'impronta della risposta giusta, non la risposta. Il calcolo si chiama sha256, ed è nella libreria di Python:
import hashlib
print(hashlib.sha256("metro-milano".encode()).hexdigest())
print(hashlib.sha256("metro-milano".encode()).hexdigest())
print(hashlib.sha256("metro-milanO".encode()).hexdigest())7d080224a4c1eb9ee9fcb2217386d8e9168b3032bf31e10e46eda2c1d23442be
7d080224a4c1eb9ee9fcb2217386d8e9168b3032bf31e10e46eda2c1d23442be
baea5361e3c19cff165bc5b50922746aea181affa623609ac97f9ec28b0959f7.encode() trasforma il testo in byte (sha256 lavora sui byte), .hexdigest() dà l'impronta come testo: 64 caratteri, sempre. Le prime due righe sono uguali; nella terza è cambiata una lettera sola, la O finale, e non resta niente in comune.
"metro-milano" ───── calcolo ─────▶ 7d080224a4c1eb9e…
◀────── ✕ ────────── dall'impronta non si torna alla passwordIl sale
Con sha256 nudo resta un problema. Rosa e Teo hanno la stessa password, quindi la stessa impronta: chi ruba il dizionario vede subito che le due password sono uguali. E c'è di peggio: esistono tabelle già pronte con le impronte delle password più comuni. «7d080224…»? Basta cercarla nella tabella.
La cura è il sale: un pezzo a caso, diverso per ogni impronta, che si aggiunge alla password prima del calcolo. Stessa password, sali diversi, impronte diverse. Le tabelle già pronte non servono più: andrebbero rifatte per ogni sale.
SENZA SALE
rosa "metro-milano" ── calcolo ──▶ 7d080224…
teo "metro-milano" ── calcolo ──▶ 7d080224… uguali: si vede
CON IL SALE
rosa "metro-milano" + hSc2… ── calcolo ──▶ ArPZNtvC…
teo "metro-milano" + FFl6… ── calcolo ──▶ u/MqkA56… diverseIl sale non è un segreto: è scritto dentro l'impronta, in chiaro. Deve esserci, perché al login serve per rifare il calcolo. Lo vedi tra poco.
Lento apposta: argon2
sha256 è velocissimo. Per controllare una risposta va benissimo; per le password è un difetto: chi ha rubato le impronte prova miliardi di password al secondo, finché ne trova una che dà la stessa impronta. Per le password si usa un calcolo lento apposta, e che vuole tanta memoria: argon2. Un cronometro (time.perf_counter(): lo leggi prima e dopo, e fai la differenza) lo fa vedere:
import hashlib
import time
from pwdlib import PasswordHash
calcolatore = PasswordHash.recommended()
inizio = time.perf_counter()
hashlib.sha256("metro-milano".encode()).hexdigest()
print(f"sha256: {time.perf_counter() - inizio:.6f} secondi")
inizio = time.perf_counter()
calcolatore.hash("metro-milano")
print(f"argon2: {time.perf_counter() - inizio:.6f} secondi")sha256: 0.000012 secondi
argon2: 0.024822 secondiDue centesimi di secondo: per te, al login, non è niente. Per chi deve provare miliardi di password, è circa duemila volte più lavoro, ognuna.
pwdlib: due mosse
Il calcolo non lo scriviamo noi: lo fa pwdlib, una libreria che si installa con pip install "pwdlib[argon2]" (le quadre dicono: anche argon2). Nello zip c'è già nel requirements.txt. Ha due mosse:
from pwdlib import PasswordHash
calcolatore = PasswordHash.recommended() # argon2, con le impostazioni consigliate
prima = calcolatore.hash("metro-milano")
seconda = calcolatore.hash("metro-milano")
print(prima)
print(seconda)
print(calcolatore.verify("metro-milano", prima)) # la password giusta
print(calcolatore.verify("metro-milano", seconda))
print(calcolatore.verify("metro-milanO", prima)) # una lettera diversa$argon2id$v=19$m=65536,t=3,p=4$OCqvYxRzvFcmIsG3/fJ/OA$TRx1EfTaf4QwvSJDOmCXYLezVmf/XFEpt4HSheSOAOw
$argon2id$v=19$m=65536,t=3,p=4$WACEb3A5edW3gqZWQz+GhQ$73zUU5kYqDDq6LwTA8dB9o7+xTkCQoe3W4g35skJUL4
True
True
Falsehash(password)dà l'impronta, ogni volta diversa: il sale lo sceglie lui, a caso. Le tue impronte saranno diverse da queste.verify(password, impronta)diceTruese la password è quella dell'impronta. Prima la password, poi l'impronta.
Com'è fatta un'impronta
Un'impronta argon2 è una riga sola, divisa in pezzi dal simbolo $. Prendiamo la prima qui sopra:
| Pezzo | Cosa dice |
|---|---|
argon2id | L'algoritmo: argon2, nella variante id |
v=19 | La versione dell'algoritmo |
m=65536,t=3,p=4 | Quanto è pesante il calcolo: memoria (65536 KB, cioè 64 MB), passaggi, calcoli in parallelo |
OCqvYxRzvFcmIsG3/fJ/OA | Il sale: il pezzo a caso, diverso per ogni impronta |
TRx1EfTaf4QwvSJDOmCXYLezVmf/XFEpt4HSheSOAOw | Il risultato del calcolo |
Tutto quello che serve per rifare il calcolo è lì, in chiaro. Tranne una cosa: la password.
Controllare senza sapere
Al login arriva una password. Il server non la conosce: ha solo l'impronta. Fa così:
al login arriva: "metro-milano"
l'impronta salvata: $argon2id$v=19$m=65536,t=3,p=4$OCqvYxRzvFcmIsG3/fJ/OA$TRx1EfTa…
└───── il sale ──────┘
1. leggo dall'impronta le impostazioni e il sale
2. rifaccio il calcolo: "metro-milano" + OCqv… ── argon2 ──▶ TRx1EfTa…
3. è uguale al risultato salvato? sì → True no → FalseÈ quello che fa verify. La password giusta non la sa nessuno: basta la sua impronta per riconoscerla.
sicurezza.py: gli attrezzi, già pronti
Negli esercizi pwdlib non lo chiami direttamente: c'è un file, palestra/sicurezza.py, che si legge e non si tocca. Due funzioni, e in tutto il programma solo loro toccano le password:
from pwdlib import PasswordHash
# recommended(): argon2, con le impostazioni sicure scelte da chi ne sa.
calcolatore = PasswordHash.recommended()
def calcola_hash(password: str) -> str:
"""Dalla password, l'impronta. Ogni volta diversa: c'è il sale."""
return calcolatore.hash(password)
def password_giusta(password: str, impronta: str) -> bool:
"""Rifà il calcolo con il sale scritto nell'impronta, e confronta."""
return calcolatore.verify(password, impronta)calcola_hash si usa alla registrazione, password_giusta al login.
La registrazione: tre stampi
Nell'API la password passa per tre stampi Pydantic, come gli stampi del capitolo su Pydantic: uno per quello che arriva, uno per quello che resta, uno per quello che esce.
class Utente(BaseModel): # la risposta: niente password, niente impronta
username: str
nome: str
class UtenteNuovo(BaseModel): # il corpo della richiesta: 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 UtenteSalvato(Utente): # nel dizionario: tutto quello di Utente, più l'impronta
password_hash: strIL CORPO · UtenteNuovo NEL DIZIONARIO · UtenteSalvato LA RISPOSTA · Utente
username rosa username rosa username rosa
nome Rosa Bellini ──▶ nome Rosa Bellini ──▶ nome Rosa Bellini
password metro-milano password_hash $argon2id$…$hSc2…$…
│ ▲
└──── calcola_hash ──────┘La riga che conta è una:
salvato = UtenteSalvato(username=dati.username, nome=dati.nome, password_hash=calcola_hash(dati.password))La password in chiaro vive per una riga sola, quella di calcola_hash. Poi c'è solo l'impronta. Il resto della rotta è il POST di sempre: lo username già preso dà 409, una password più corta di 8 caratteri la ferma lo stampo con il 422, e tutto a posto dà 201. La rotta intera, riga per riga, è negli esercizi spiegati.
Dopo la registrazione di Rosa, nel dizionario c'è solo l'impronta:
La risposta senza impronta
L'impronta non serve a nessuno fuori dal server. Anzi, aiuta chi vuole indovinare: con l'impronta in mano può provare password sul suo computer, quante ne vuole, senza che nessuno se ne accorga.
Per questo la rotta dichiara la risposta con la freccia -> Utente. Anche se la funzione restituisce un UtenteSalvato, FastAPI fa passare solo i campi di Utente: username e nome. Lo stampo della risposta è un filtro. Scrivi -> UtenteSalvato e l'impronta esce, senza nessun errore: lo vedi nell'esempio E.
Dove porta
Con la registrazione l'utente ha un'impronta nel dizionario. Al login, nel capitolo 6, la password arriva di nuovo e password_giusta la confronta con l'impronta. Se è giusta, il server non chiede più la password: consegna un biglietto, che è il capitolo 5.
Ricorda
- Mai la password in chiaro: nel dizionario va solo l'impronta, in un campo che si chiama
password_hash. - L'impronta è un calcolo a senso unico; il sale la fa diversa ogni volta, e sta scritto dentro.
- argon2 è lento apposta: un attimo per te, un'eternità per chi prova miliardi di password.
- Si controlla con
password_giusta(password, impronta), mai concalcola_hash(password) == impronta. - La risposta è un
Utente: la freccia deldeflascia fuori l'impronta.