Le password, le soluzioni
Il ragionamento, il codice, le trappole
Per ogni esercizio, sempre lo stesso ordine: in italiano → il codice → le trappole. Per i più difficili, anche il passo per passo.
La tua soluzione è diversa ma i test sono verdi? Probabilmente va bene: spesso ci sono più strade giuste. Confronta il ragionamento, non le singole parole. E leggi comunque le trappole: alcune sono errori che non fanno nessun rumore.
Le soluzioni complete
La stessa cartella, con il codice al posto di pass. Aprila dopo averci provato: i test sono gli stessi.
La palestra
1 · Il sale nell'impronta
In italiano. Taglio l'impronta dove c'è un $. Il sale è il quinto pezzo, quello che viene subito dopo m=65536,t=3,p=4: ha numero 4, perché si conta da 0.
def sale_di(impronta: str) -> str:
pezzi = impronta.split("$") # ["", "argon2id", "v=19", "m=65536,t=3,p=4", sale, risultato]
return pezzi[4]Il pezzo 0 è la stringa vuota: l'impronta comincia con un $, e split ti consegna anche il niente che c'è prima.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
return impronta.split("$")[-1] | Prende l'ultimo pezzo: è il risultato del calcolo, non il sale. Nessun errore, solo la stringa sbagliata | test_il_sale_di_lucia, test_il_sale_di_sergio |
return impronta.split("$")[3] | Si dimentica del pezzo vuoto, e conta da 1: prende m=65536,t=3,p=4, le impostazioni | test_il_sale_di_lucia, test_il_sale_di_sergio, test_stessa_password_sali_diversi |
Nella seconda, il test sulle due impronte della stessa password diventa rosso per un motivo furbo: le impostazioni sono uguali in tutte e due le impronte, quindi i due «sali» che hai preso sono uguali, e il test dice «due impronte, due sali diversi».
2 · Le iscrizioni al portale
In italiano.
- Se lo username è già nel dizionario, mi fermo con il 409. Prima di scrivere: dopo, Lucia sarebbe già stata sovrascritta.
- Costruisco l'utente 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
Utente: FastAPI fa uscire solo username e nome.
@app.post("/utenti", status_code=status.HTTP_201_CREATED)
def registra(dati: UtenteNuovo) -> Utente:
if dati.username in utenti:
raise HTTPException(status_code=409, detail="Username già preso")
utente = UtenteSalvato(username=dati.username, nome=dati.nome, password_hash=calcola_hash(dati.password))
utenti[utente.username] = utente
return utente # -> Utente: l'impronta resta fuori dalla rispostaIl disegno.
Passo per passo. Tre richieste, una dopo l'altra:
| Richiesta | Lo stampo UtenteNuovo | dati.username in utenti? | Cosa succede | Risposta |
|---|---|---|---|---|
tommaso, binario-sette | va bene | no | impronta, dizionario | 201, username e nome |
lucia, una password qualunque | va bene | sì | raise del 409 | 409, «Username già preso» |
tommaso, corta | password di 5 caratteri: no | non si arriva | FastAPI risponde da solo | 422 |
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
password_hash=dati.password | La password finisce in chiaro nel dizionario, e nella risposta non si vede niente. Poi password_giusta si ferma con UnknownHashError: non è un'impronta | test_nel_dizionario_c_e_l_impronta, test_l_impronta_riconosce_la_password |
def registra(dati: UtenteNuovo) -> UtenteSalvato: | La risposta è 201, nessun errore: ma ora dentro c'è anche password_hash. L'impronta è uscita dal server | test_la_risposta_non_ha_ne_password_ne_impronta |
Niente if dati.username in utenti | Con lucia la risposta è 201 e la vera Lucia viene sostituita: chi si iscrive per secondo prende il posto del primo, con la sua password | test_username_gia_preso |
| Il controllo del 409 dopo il salvataggio | Tommaso si salva, e poi la rotta lo trova: «lo username c'è già», 409 a chi si è iscritto bene. Il 201 non arriva mai | test_iscrizione_201, test_la_risposta_non_ha_ne_password_ne_impronta, test_username_gia_preso |
UtenteSalvato(**dati.model_dump()) | Passa username, nome e password: manca password_hash. ValidationError: Field required | test_iscrizione_201, test_la_risposta_non_ha_ne_password_ne_impronta, test_nel_dizionario_c_e_l_impronta, test_l_impronta_riconosce_la_password |
utenti[dati.username] = dati e return dati | Nel dizionario va lo stampo del corpo, con la password in chiaro e senza password_hash. La risposta sembra giusta (la freccia filtra), ma il dizionario è rotto: AttributeError: 'UtenteNuovo' object has no attribute 'password_hash' | test_nel_dizionario_c_e_l_impronta, test_l_impronta_riconosce_la_password |
Le due più pericolose sono le prime due, e tutte e due non fanno rumore: il programma sembra funzionare. Sono le trappole che i test della palestra esistono per prendere.
3 · Il terminale dell'armadietto
In italiano.
- Cerco l'utente con
get: se lo username non c'è, ricevoNone. - Se è
None, rispondoFalse, come a una password sbagliata. - Altrimenti chiedo a
password_giusta: prima la password, poi l'impronta, che sta inutente.password_hash.
def accesso_consentito(utenti: dict[str, UtenteSalvato], username: str, password: str) -> bool:
utente = utenti.get(username) # None se lo username non c'è
if utente is None:
return False
return password_giusta(password, utente.password_hash)Il disegno.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
utente = utenti[username] | Con mapelli: KeyError: 'mapelli'. Il terminale si pianta per uno che non è nel portale | test_username_che_non_esiste |
get senza l'if … is None | Con mapelli: AttributeError: 'NoneType' object has no attribute 'password_hash'. Un altro modo di piantarsi | test_username_che_non_esiste |
password_giusta(utente.password_hash, password) | Argomenti invertiti: UnknownHashError, la password non è un'impronta | test_password_giusta, test_password_sbagliata, test_ognuno_ha_la_sua_password |
return calcola_hash(password) == utente.password_hash | Il sale nuovo dà un'impronta nuova: sempre False, anche con la password giusta. Lucia non entra mai | test_password_giusta, test_ognuno_ha_la_sua_password |
if utente is not None and password_giusta(…): return True, senza altro | Se non entra nessuno la funzione finisce senza return: Python restituisce None, non False. Un if lo tratta come False, ma il test chiede proprio False | test_password_sbagliata, test_username_che_non_esiste, test_ognuno_ha_la_sua_password, test_l_impronta_non_e_la_password |
La quarta è la trappola della teoria: per controllare non si rifà l'impronta, si chiede a password_giusta. La quinta è lo stesso errore dei dizionari e delle funzioni: se un ramo dell'if non ha il suo return, la funzione risponde None.
4 · Il trasloco del vecchio archivio
In italiano.
- Parto da un dizionario nuovo, vuoto. Il vecchio non lo tocco.
- Per ogni username e password del vecchio:
- se la password è vuota, quel collega ha lasciato il deposito: lo salto;
- altrimenti scrivo nel nuovo, alla stessa chiave, l'impronta della sua password.
- Restituisco il nuovo.
def trasloca(vecchio: dict[str, str]) -> dict[str, str]:
nuovo = {}
for username, password in vecchio.items():
if password != "":
nuovo[username] = calcola_hash(password)
return nuovoIl disegno.
Passo per passo. Con vecchio = {"ivo": "manutentore-B02", "gino": ""}:
| Giro | username, password | password != ""? | Cosa succede | Il dizionario nuovo dopo il giro |
|---|---|---|---|---|
| 1 | ivo, manutentore-B02 | sì | calcola_hash, e lo scrivo | un'impronta, alla chiave ivo |
| 2 | gino, `` (vuota) | no | salto | invariato |
Un calcolo per ognuno: Ivo ed Ernesto hanno la stessa password, e ognuno ha la sua impronta, con il suo sale. Calcolare l'impronta una volta sola e riusarla per tutti quelli con la stessa password sarebbe un errore da evitare: vorrebbe dire lo stesso sale per tutti.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Niente if password != "" | Gino entra nel portale nuovo con l'impronta della password vuota. password_giusta("", impronta) dà True: chi scrive gino e niente come password, passa | test_ci_sono_tutti_tranne_chi_e_andato_via, test_chi_e_andato_via_non_trasloca |
hashlib.sha256(password.encode()).hexdigest() al posto di calcola_hash | Non è argon2: veloce e senza sale. Ivo ed Ernesto avrebbero la stessa impronta, e password_giusta si fermerebbe con UnknownHashError | test_nessuna_password_in_chiaro, test_ogni_impronta_riconosce_la_sua_password, test_stessa_password_impronte_diverse |
nuovo = vecchio e poi si cambia nuovo | Non è una copia: sono due etichette sulla stessa scatola. Si cambia il dizionario mentre lo si scorre: RuntimeError: dictionary changed size during iteration. E anche se non si fermasse, il vecchio archivio sarebbe già distrutto | tutti e sei: test_ci_sono_tutti_tranne_chi_e_andato_via, test_nessuna_password_in_chiaro, test_ogni_impronta_riconosce_la_sua_password, test_stessa_password_impronte_diverse, test_chi_e_andato_via_non_trasloca, test_il_vecchio_archivio_non_cambia |
L'ultima è una vecchia conoscenza: il capitolo sulle etichette e scatole. Un dizionario nuovo si fa con {}, non con un secondo nome per quello vecchio.