Vai al contenuto
code-to-code

Apro l'indice…

↑ ↓ per scegliere, Invio per aprire, Esc per chiudere

Login e sicurezza4. Le passwordp. 88

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:

Python
abbonati = {
    "rosa": "metro-milano",
    "teo": "metro-milano",
}
abbonati = {"rosa": "metro-milano", "teo": "metro-milano"}abbonatidict"rosa""metro-milano""teo""metro-milano"
Le password in chiaro nel dizionario

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 impronte

Il 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:

  1. la stessa password dà sempre la stessa impronta;
  2. basta una lettera diversa, e l'impronta cambia tutta;
  3. 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:

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 password

Il 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…     diverse

Il 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:

Python
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 secondi

Due 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:

Python
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
False
  • hash(password) dà l'impronta, ogni volta diversa: il sale lo sceglie lui, a caso. Le tue impronte saranno diverse da queste.
  • verify(password, impronta) dice True se 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:

PezzoCosa dice
argon2idL'algoritmo: argon2, nella variante id
v=19La versione dell'algoritmo
m=65536,t=3,p=4Quanto è pesante il calcolo: memoria (65536 KB, cioè 64 MB), passaggi, calcoli in parallelo
OCqvYxRzvFcmIsG3/fJ/OAIl sale: il pezzo a caso, diverso per ogni impronta
TRx1EfTaf4QwvSJDOmCXYLezVmf/XFEpt4HSheSOAOwIl 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:

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

Python
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: str
IL 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:

Python
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:

utenti = {"rosa": UtenteSalvato(username="rosa", nome="Rosa Bellini", password_hash="$argon2id$…$hSc2…")}utentidict"rosa"UtenteSalvatousername"rosa"nome"Rosa Bellini"password_hash"$argon2id$…$hSc2…"
Il dizionario dopo la registrazione di Rosa

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 con calcola_hash(password) == impronta.
  • La risposta è un Utente: la freccia del def lascia fuori l'impronta.