Login e rotte protette, 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, e alcune sono buchi di sicurezza che i test, qui, non lasciano passare.
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 login
In italiano.
- Cerco l'utente per username. Se non c'è, ho
None. - Se l'utente non c'è, oppure la sua password non è giusta: 401, con il messaggio unico.
- Altrimenti stampo il biglietto con dentro lo username, e lo restituisco.
@app.post("/login")
def login(dati: Credenziali) -> Biglietto:
utente = utenti.get(dati.username) # None se lo username non c'è
if utente is None or not password_giusta(dati.password, utente.password_hash):
raise HTTPException(status_code=401, detail="Username o password sbagliati")
return Biglietto(access_token=crea_biglietto(utente.username), token_type="bearer")Il get serve perché lo username potrebbe non esserci. E nell'or, se utente è None la prima metà è già vera: Python non guarda la seconda, e utente.password_hash (che su un None sarebbe un errore) non viene mai letto.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Due if e due messaggi: Username non trovato e Password sbagliata | Funziona, ma il login racconta a chiunque quali username esistono: uno scrive un elenco di nomi e legge le risposte | test_login_password_sbagliata, test_login_username_che_non_esiste_stesso_401 |
utente = utenti[dati.username] | Con uno username che non c'è: KeyError, cioè un 500 al posto del 401 | test_login_username_che_non_esiste_stesso_401 |
crea_biglietto(utente.nome) | Il login risponde 200, ma nel biglietto c'è «Lucia Ferri» al posto di lucia: il controllore non la ritroverà nel dizionario, e ogni richiesta dopo sarà un 401 | test_login_giusto_da_un_biglietto_con_dentro_lo_username, test_il_biglietto_del_login_vale |
password_giusta(utente.password_hash, dati.password) | Gli argomenti sono invertiti: la password è letta come se fosse un'impronta, e pwdlib si ferma con UnknownHashError | test_login_giusto_da_un_biglietto_con_dentro_lo_username, test_login_la_risposta_e_solo_il_biglietto, test_il_biglietto_del_login_vale, test_login_password_sbagliata |
La seconda è la più utile da ricordare: l'errore c'è solo quando qualcuno sbaglia username, cioè proprio quello che un utente distratto (o uno che ci prova) fa.
2 · Chi sono
In italiano. Alla rotta aggiungo il parametro del controllore. Dentro, utente è già l'utente del biglietto: lo restituisco.
@app.get("/me")
def chi_sono(utente: UtenteSalvato = Depends(utente_corrente)) -> Utente:
return utenteIl 401 non è nella rotta: lo manda utente_corrente, prima. E la freccia -> Utente taglia l'impronta dalla risposta.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
def chi_sono(utente: UtenteSalvato) -> Utente: (manca = Depends(utente_corrente)) | Per FastAPI utente è un corpo da leggere dalla richiesta: ma un GET non ne ha. Risposta 422, e il controllore non parte mai | test_me_con_il_biglietto, test_me_niente_impronta_nella_risposta, test_me_senza_biglietto, test_me_biglietto_falso |
-> UtenteSalvato al posto di -> Utente | Nessun errore, ma nella risposta esce anche password_hash | test_me_con_il_biglietto, test_me_niente_impronta_nella_risposta |
La prima fa tutti e quattro i test rossi, ed è un buon segno: la protezione stava in quel parametro. Senza, la rotta non è protetta (qui non risponde nemmeno).
3 · Il controllore
In italiano.
- Se non c'è nessun header, 401 «Manca il biglietto».
- Leggo lo username dal biglietto, con
leggi_biglietto. Può essereNone. - Cerco l'utente con quello username. Può essere
Noneanche lui. - Se non l'ho trovato, 401 «Biglietto non valido»: per qualsiasi motivo.
- Altrimenti restituisco l'utente.
def utente_corrente(header: HTTPAuthorizationCredentials | None = Depends(controllore)) -> UtenteSalvato:
"""Dal biglietto all'utente. Niente biglietto, biglietto che non vale, utente sparito: 401."""
if header is None:
raise HTTPException(status_code=401, detail="Manca il biglietto")
username = leggi_biglietto(header.credentials) # None se il biglietto non vale
utente = utenti.get(username) # None anche se l'utente non c'è più
if utente is None:
raise HTTPException(status_code=401, detail="Biglietto non valido")
return utenteIl disegno.
Passo per passo. Cinque biglietti, e cosa succede a ognuno:
| Biglietto | header | username | utente | Risposta |
|---|---|---|---|---|
| nessuno | None | non si calcola | non si calcola | 401 Manca il biglietto |
biglietto-disegnato-a-mano | l'oggetto | None (non è un JWT) | None | 401 Biglietto non valido |
| scaduto ieri | l'oggetto | None | None | 401 Biglietto non valido |
| payload cambiato a mano | l'oggetto | None (la firma non torna) | None | 401 Biglietto non valido |
buono, ma di fantasma | l'oggetto | "fantasma" | None | 401 Biglietto non valido |
| buono, di Ivo | l'oggetto | "ivo" | l'utente Ivo | l'utente |
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
HTTPBearer() al posto di controllore (senza auto_error=False) | Senza header risponde il controllore, da solo: 401 giusto, ma con il messaggio inglese Not authenticated. Le righe che hai scritto tu non partono mai | test_senza_biglietto, test_header_che_non_e_un_bearer |
Niente if header is None | Senza header: AttributeError: 'NoneType' object has no attribute 'credentials', cioè un 500 | test_senza_biglietto, test_header_che_non_e_un_bearer |
utente = utenti[username] | Con un biglietto che non vale, username è None: KeyError: None. Anche con un utente sparito: KeyError: 'fantasma'. Un 500 al posto del 401 | test_biglietto_disegnato_a_mano, test_biglietto_scaduto, test_biglietto_firmato_con_un_altra_chiave, test_biglietto_con_il_payload_cambiato_a_mano, test_biglietto_buono_di_un_utente_sparito |
status_code=403 per «Biglietto non valido» | Il 403 vuol dire «so chi sei, ma qui non entri». Qui non sappiamo chi è: è un 401 | gli stessi cinque |
La seconda trappola è la più comune: per leggerne il traceback, dal basso: l'ultima riga dice AttributeError, quella con i ^^^ dice quale pezzo. La terza è una trappola sottile: con utenti[username] tutto sembra funzionare finché i biglietti sono buoni.
4 · Il mio turno
In italiano.
- Aggiungo alla rotta il parametro del controllore:
utenteè chi ha il biglietto. - Cerco il suo turno in
TURNI, per username. Può non esserci. - Se non c'è, 404 «Turno non trovato». Altrimenti rispondo con lo username e il turno.
@app.get("/turni/mio")
def il_mio_turno(utente: UtenteSalvato = Depends(utente_corrente)) -> dict[str, str]:
turno = TURNI.get(utente.username)
if turno is None:
raise HTTPException(status_code=404, detail="Turno non trovato")
return {"username": utente.username, "turno": turno}Il disegno.
Il 401 per chi non ha biglietto arriva prima di tutto, dal controllore. Il 404 solo per chi ha un biglietto buono: l'ordine delle domande è «chi sei?» e poi «la cosa c'è?».
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
TURNI[utente.username] con le quadre | Per Nadia (che non ha un turno): KeyError, un 500 al posto del 404 | test_chi_non_ha_un_turno_prende_404 |
200 con "turno": "nessun turno" al posto del 404 | La rotta non si rompe, ma risponde come se la cosa ci fosse: chi legge non capisce che un turno non c'è | test_chi_non_ha_un_turno_prende_404 |
Un parametro username nella rotta, usato al posto di quello del biglietto | Con il biglietto di Sergio e ?username=lucia, la rotta risponde con il turno di Lucia: chiunque ha un biglietto può leggere il turno di chiunque | test_lo_username_in_piu_non_conta |
L'ultima è la trappola più seria di tutte le palestre: non dà nessun errore, e tutti gli altri test restano verdi. Passa i test di chi usa il suo biglietto e si rompe solo se qualcuno scrive un nome che non è il suo. Per questo c'è un test apposta.
5 · Postman, in Python
In italiano.
login: faccioPOST /logincon il corpo JSON. Se il codice è 200, prendoaccess_tokendalla risposta e lo metto invariabili["biglietto"]. In ogni caso restituisco il codice.chiedi: preparo gli header vuoti. Sevariabiliha un biglietto, scrivoAuthorization: Bearer <biglietto>. FaccioGETe restituisco la risposta.
class Collezione:
def __init__(self, client):
self.client = client
self.variabili: dict[str, str] = {} # le variabili della collezione, per nome
def login(self, username: str, password: str) -> int:
risposta = self.client.post("/login", json={"username": username, "password": password})
if risposta.status_code == 200:
self.variabili["biglietto"] = risposta.json()["access_token"]
return risposta.status_code
def chiedi(self, percorso: str):
headers = {}
if "biglietto" in self.variabili:
headers["Authorization"] = f"Bearer {self.variabili['biglietto']}"
return self.client.get(percorso, headers=headers)Passo per passo. Un giro intero, come in Postman:
| Cosa fa Marta | Postman | variabili dopo | Risposta |
|---|---|---|---|
/me senza aver fatto il login | Authorization vuota | {} | 401 Manca il biglietto |
| Login di Lucia | Script post-response | {"biglietto": "eyJ…"} | 200 |
/me | Bearer Token {{biglietto}} | uguale | 200, Lucia |
| Login con la password sbagliata | Lo script non salva (non c'è access_token) | uguale | 401 |
/me ancora | Il biglietto di prima | uguale | 200, Lucia |
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Salvare sempre, senza if risposta.status_code == 200 | Con una password sbagliata la risposta è {"detail": …}: ["access_token"] non c'è e il programma si ferma con KeyError. In Postman lo script darebbe errore e la variabile resterebbe com'era: qui, no | test_un_login_sbagliato_non_cancella_il_biglietto |
L'header senza la parola: {"Authorization": biglietto} | Il controllore non vede un Bearer: nessun biglietto, 401 anche dopo un login riuscito | test_dopo_il_login_il_biglietto_viaggia_con_Bearer, test_un_altro_login_sostituisce_il_biglietto, test_un_login_sbagliato_non_cancella_il_biglietto, test_biglietto_scaduto_poi_nuovo_login |
L'header sempre, anche senza biglietto: f"Bearer {self.variabili.get('biglietto')}" | Prima del login parte Bearer None: il controllore vede un biglietto, non lo legge, e risponde «Biglietto non valido» al posto di «Manca il biglietto» | test_prima_del_login_niente_biglietto |
La seconda è quella che chi usa Postman conosce: {{biglietto}} va nel campo Bearer Token, che aggiunge la parola da solo. Se lo scrivi a mano nella scheda Headers, la parola Bearer e lo spazio devono esserci.
La storia
La storia si gioca con main.py, e i livelli sono gli stessi esercizi della palestra, in un solo programma. Qui sotto, le soluzioni e le trappole che i test della storia non lasciano passare.
Livello 1 · La registrazione
@app.post("/personale", 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 rispostaÈ la registrazione del capitolo sulle password. Il 409 viene prima del salvataggio, altrimenti la persona che c'era già verrebbe sovrascritta.
La trappola. -> UtenteSalvato al posto di -> Utente: nessun errore, ma la risposta mostra l'impronta. Rosso: test_livello_1_registra_una_persona.
Livello 2 · Il login
@app.post("/login")
def login(dati: Credenziali) -> Biglietto:
utente = utenti.get(dati.username) # None se lo username non c'è
if utente is None or not password_giusta(dati.password, utente.password_hash):
raise HTTPException(status_code=401, detail="Username o password sbagliati")
return Biglietto(access_token=crea_biglietto(utente.username), token_type="bearer")È l'esercizio 1 della palestra, con le sue trappole.
La trappola. crea_biglietto(utente.nome): il login risponde 200 e il biglietto sembra a posto. Ma dentro c'è «Greta Sala» al posto di greta. Rosso: test_livello_2_login_giusto.
Livello 3 · Il controllore
def utente_corrente(header: HTTPAuthorizationCredentials | None = Depends(controllore)) -> UtenteSalvato:
if header is None:
raise HTTPException(status_code=401, detail="Manca il biglietto")
username = leggi_biglietto(header.credentials) # None se il biglietto non vale
utente = utenti.get(username) # None anche se l'utente non c'è più
if utente is None:
raise HTTPException(status_code=401, detail="Biglietto non valido")
return utente
@app.get("/me")
def chi_sono(utente: UtenteSalvato = Depends(utente_corrente)) -> Utente:
return utenteSono gli esercizi 2 e 3 della palestra, insieme.
Le trappole. Queste due sono i modi in cui un controllore sembra controllare e invece no: la notte di prova, ora, ti fa vedere il danno.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Leggere il biglietto con jwt.decode(..., options={"verify_signature": False}) | Il biglietto si legge ma non si controlla: un payload cambiato a mano passa, un biglietto con la chiave vecchia passa, uno scaduto passa. Chiunque può scrivere il nome che vuole | test_livello_3_biglietto_scaduto, test_livello_3_biglietto_con_un_altra_chiave, test_livello_3_biglietto_cambiato_a_mano |
jwt.decode(..., options={"verify_exp": False}) | La firma si controlla, la scadenza no: un biglietto vero ma di ieri apre ancora le porte, per sempre | test_livello_3_biglietto_scaduto |
Nel capitolo sul biglietto c'è il perché: un JWT si legge senza chiave, la chiave serve per controllare la firma. Per questo leggi_biglietto è già scritto in sicurezza.py, e usarlo non è una pigrizia: è il pezzo che non va riscritto.
Livello 4 · Aprire una porta
@app.post("/porte/{porta}/apri")
def apri_porta(porta: str, utente: UtenteSalvato = Depends(utente_corrente)) -> Apertura:
if porta not in PORTE:
raise HTTPException(status_code=404, detail="Porta non trovata")
registro.append({"porta": porta, "username": utente.username})
return Apertura(porta=porta, aperta_da=utente.nome)Il 401 è già successo prima di entrare. Dentro: prima il 404 (senza scrivere niente nel registro: una porta che non esiste non lascia tracce), poi la riga nel registro con lo username preso da utente, poi la risposta.
La trappola. Una funzione che prende anche un corpo, e scrive nel registro lo username che trova lì dentro ((corpo or {}).get("username", utente.username)). Con un corpo vero funziona tutto uguale. Se qualcuno manda nel corpo il nome di un altro, il registro scrive quello. Rosso: test_livello_4_chi_apre_lo_dice_il_biglietto_non_il_corpo.
Livello 5 · Il registro
@app.get("/registro")
def leggi_registro(
porta: str | None = Query(default=None),
utente: UtenteSalvato = Depends(utente_corrente),
) -> list[Voce]:
if porta is None:
return registro
if porta not in PORTE:
raise HTTPException(status_code=404, detail="Porta non trovata")
return [voce for voce in registro if voce["porta"] == porta]Senza ?porta=, tutto il registro. Con una porta, il setaccio: le righe di quella porta soltanto.
La trappola. return registro e basta, senza guardare porta. Con ?porta=sala-comandi esce anche il cancello. Rossi: test_livello_5_una_porta_sola, test_livello_5_porta_che_non_esiste.
Il finale
Con le soluzioni giuste, python storia/notte.py scrive:
Il personale si registra.
6 persone registrate.
La notte, tentativo per tentativo.
01:55 nadia login con la password sbagliata -> 401 Username o password sbagliati
01:56 nadia login giusto -> 200 ok
01:56 nadia chi sono (GET /me) -> 200 ok
01:56 nadia apre il cancello -> 200 ok
02:40 marta un biglietto con il nome cambiato a mano -> 401 Biglietto non valido
02:44 ivo il biglietto di ieri -> 401 Biglietto non valido
02:47 sergio un biglietto firmato con la chiave vecchia -> 401 Biglietto non valido
02:52 silvia il suo biglietto, con nel corpo il nome di Marta -> 200 ok
Il registro della sala comandi (GET /registro?porta=sala-comandi):
sala-comandi aperta da Silvia Rigamonti (silvia)
Mapelli: «Chi è entrato davvero nella sala comandi?» python storia/verifica.py "Nome Cognome"Dei quattro tentativi alla sala comandi, tre sono 401 con lo stesso messaggio: un biglietto con il nome di Marta cambiato a mano, quello scaduto di Ivo, uno di Sergio firmato con la chiave vecchia. Non valgono, e la porta li ferma tutti. L'ultimo è un biglietto vero, di Silvia Rigamonti, tecnica della manutenzione assunta da un mese: nel corpo della richiesta, per confondere le acque, c'era scritto il nome di Marta. La porta ha letto il biglietto, non il corpo.
python storia/verifica.py "Silvia Rigamonti"Cosa dice il registro, e cosa dicono i biglietti sbagliati. Ogni nome sbagliato che il commissario riconosce è un'API sbagliata. Rilanciando la notte con le trappole dei livelli 3, 4 e 5, il registro della sala comandi cambia:
| La trappola | Chi compare nel registro della sala comandi |
|---|---|
| Firma non controllata (livello 3) | Marta Villa, Ivo Brambati, Sergio Colombo e Silvia Rigamonti: la porta ha creduto a tutti |
| Scadenza non controllata (livello 3) | Ivo Brambati e Silvia Rigamonti: il biglietto di ieri apre ancora |
| Username dal corpo (livello 4) | Marta Villa: l'unico nome, perché il biglietto vero di Silvia ha lasciato scrivere quello del corpo |
| Registro non filtrato (livello 5) | Con ?porta=sala-comandi esce anche la riga di Nadia Russo al cancello: è entrata, ma non lì |
Se rispondi «Marta Villa», «Ivo Brambati», «Nadia Russo» o «Sergio Colombo», il commissario ti dice quale livello hai sbagliato. E la risposta giusta non dice solo chi è entrato: dice che la porta ha fatto il suo mestiere. Il biglietto diceva chi era, e nessuno le ha chiesto se in sala comandi poteva stare. È una domanda diversa, e il capitolo sui permessiin arrivo comincia da lì.