La chiave, 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.
1 · Fare la chiave
In italiano.
fai_chiavechiede asecrets16 byte a caso, scritti in esadecimale: 32 caratteri.riga_envmette insieme il nome, l'uguale e una chiave nuova.
import secrets
def fai_chiave() -> str:
return secrets.token_hex(16)
def riga_env(nome: str) -> str:
return nome + "=" + fai_chiave()riga_env chiama fai_chiave: non rifà il lavoro, e ogni riga ha la sua chiave nuova.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
random.choice("0123456789abcdef") 32 volte | Sembra una chiave vera: 32 caratteri esadecimali. Ma random segue una regola che si può ricostruire: chi vede qualche chiave prevede le prossime. Nessun errore: lo vede solo il test apposta | test_non_usa_random, test_usa_secrets |
secrets.token_hex(8) | Sono 8 byte: 16 caratteri. Una chiave più corta si indovina prima | test_lunga_32_caratteri, test_non_usa_random, test_riga_env_nome_uguale_chiave |
| Una chiave scritta a mano nel codice, sempre la stessa | Non è «a caso»: ogni programma avrebbe la stessa chiave, e chi legge il codice la conosce | test_mai_due_uguali, test_riga_env_ogni_volta_una_chiave_nuova, test_usa_secrets |
nome + " = " + fai_chiave() | Gli spazi attorno all'uguale: nel .env la riga non è più NOME=valore, e la chiave letta avrebbe uno spazio davanti | test_riga_env_nome_uguale_chiave, test_riga_env_senza_spazi_e_a_capo |
La prima è la più utile da ricordare: con random il programma funziona, e il buco di sicurezza non si vede.
2 · La chiave dall'ambiente
In italiano.
- Prendo la variabile con
os.environ.get:Nonese non c'è. - Se è
Noneoppure vuota, mi fermo con unRuntimeErrorche dice quale variabile manca. - Altrimenti la restituisco com'è.
def chiave_dal_ambiente(nome: str) -> str:
chiave = os.environ.get(nome) # None se la variabile non c'è
if not chiave: # None oppure ""
raise RuntimeError(f"Manca {nome}: crea il file .env")
return chiaveif not chiave è vero per None e per "": una riga CHIAVE= scritta e lasciata vuota nel .env è un guaio come una riga che manca.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
return os.environ[nome] | Se la variabile non c'è: KeyError, non il tuo RuntimeError. Il messaggio dice solo 'CHIAVE_RITARDI' e non dice cosa fare | test_manca_la_variabile, test_il_messaggio_ha_il_nome_vero, test_la_variabile_vuota_vale_come_mancante |
if chiave is None: al posto di if not chiave: | La variabile mancante è gestita. Ma una variabile vuota passa: il programma parte con una chiave vuota, e tutte le richieste prendono 401 | test_la_variabile_vuota_vale_come_mancante |
Il nome scritto nel codice: os.environ.get("CHIAVE_RITARDI") | Funziona per un nome solo: con qualunque altro nome legge la variabile sbagliata | test_un_altro_nome, test_il_messaggio_ha_il_nome_vero |
3 · Il programma che chiama
In italiano.
chiedi_ritardi: faccioGET /ritardicon un dizionario di header che haX-API-Keye la chiave. Restituisco la risposta intera, anche se è un 401: chi chiama decide cosa farne.ritardo_massimo: chiedo i ritardi. Se il codice non è 200, mi fermo con unRuntimeError. Altrimenti prendo il massimo dei minuti.
def chiedi_ritardi(client: TestClient, chiave: str):
return client.get("/ritardi", headers={"X-API-Key": chiave})
def ritardo_massimo(client: TestClient, chiave: str) -> int:
risposta = chiedi_ritardi(client, chiave)
if risposta.status_code != 200:
raise RuntimeError(f"Il server ha risposto {risposta.status_code}")
return max(treno["minuti"] for treno in risposta.json())Passo per passo. Due chiamate di ritardo_massimo:
| Chiave | Risposta del server | status_code | Cosa fa la funzione |
|---|---|---|---|
| quella giusta | la lista dei ritardi | 200 | max(4, 0, 11): restituisce 11 |
| sbagliata | {"detail": "Chiave sbagliata"} | 401 | RuntimeError("Il server ha risposto 401") |
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
headers={"Authorization": "Bearer " + chiave} | È l'header del biglietto (capitolo 5), non della chiave. Il server cerca X-API-Key, non lo trova, e risponde 401 «Manca la chiave» | test_con_la_chiave_giusta_il_server_risponde, test_la_chiave_viaggia_nell_header_x_api_key, test_con_una_chiave_sbagliata_risposta_intera, test_ritardo_massimo, test_ritardo_massimo_segue_i_dati |
params={"chiave": chiave} | La chiave va nell'indirizzo (/ritardi?chiave=…). Il server non la guarda, e rimarrebbe in tutti i registri | gli stessi cinque |
ritardo_massimo senza guardare il codice | Con la chiave sbagliata risposta.json() è {"detail": …}, non una lista: il max si rompe con un errore che non c'entra con la chiave | test_ritardo_massimo_con_la_chiave_sbagliata, test_ritardo_massimo_con_la_chiave_vuota |
La terza è sottile: con la chiave giusta funziona tutto. L'errore sta nel messaggio: «TypeError» non dice al programmatore che la chiave è sbagliata.
4 · Il controllore
In italiano.
- L'header non c'è (
chiaveèNone): 401 «Manca la chiave». - C'è, ma non è la chiave nel
.env: 401 «Chiave sbagliata». - Altrimenti restituisco il cliente.
def controlla_chiave(chiave: str | None = Header(default=None, alias="X-API-Key")) -> str:
"""Dall'header al cliente. Header che manca, chiave sbagliata: 401."""
if chiave is None:
raise HTTPException(status_code=401, detail="Manca la chiave")
if chiave != CHIAVE_PONTE_CICLO:
raise HTTPException(status_code=401, detail="Chiave sbagliata")
return CLIENTEIl disegno.
Passo per passo.
| Richiesta | chiave | is None | != CHIAVE_PONTE_CICLO | Risposta |
|---|---|---|---|---|
| nessun header | None | sì | non si guarda | 401 Manca la chiave |
| header vuoto | "" | no | sì | 401 Chiave sbagliata |
la chiave giusta più una x | "chiave-dei-test-…x" | no | sì | 401 Chiave sbagliata |
| la chiave giusta | la chiave | no | no | "App Sella Verde" |
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Header(alias="X-API-Key"), senza default=None | Senza header FastAPI risponde da solo, con un 422 e il suo messaggio. Le righe che hai scritto tu non partono mai | test_senza_chiave, test_la_chiave_nell_url_non_vale |
Header(default=None), senza alias | Il parametro si chiama chiave, e FastAPI cerca un header chiave, non X-API-Key. Non lo trova mai: tutte le richieste sono «Manca la chiave», anche quella giusta | test_chiave_giusta_apre_la_porta, test_il_controllore_da_il_cliente, test_chiave_sbagliata, test_chiave_quasi_giusta, test_chiave_vuota_non_e_chiave_mancante |
Niente return CLIENTE in fondo | La chiave giusta passa, ma la funzione restituisce None: il parametro cliente della rotta vale None, e la risposta dice "cliente": null | test_il_controllore_da_il_cliente |
if not chiave: al posto di if chiave is None: | Un header vuoto, che c'è, viene detto «mancante». Il messaggio è sbagliato, anche se il codice è giusto | test_chiave_vuota_non_e_chiave_mancante |
L'ultima non rompe niente di visibile: il 401 c'è, solo il messaggio è un altro. È il tipo di errore che vedi solo se qualcuno lo cerca.
5 · La rotta protetta
In italiano. Alla rotta aggiungo il parametro del controllore. Dentro, cliente è già quello che il controllore ha restituito: lo metto nella risposta.
@app.get("/uscite")
def leggi_uscite(cliente: str = Depends(controlla_chiave)) -> dict:
return {"cliente": cliente, "uscite": USCITE}Il 401 non è nella rotta: lo manda controlla_chiave, prima. Se la chiave non va, il codice di leggi_uscite non viene eseguito.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
def leggi_uscite(cliente: str) -> dict: (manca = Depends(controlla_chiave)) | Per FastAPI cliente è un parametro di query, obbligatorio: senza ?cliente=… risponde 422. Il controllore non parte mai | test_chiave_giusta_apre_la_porta, test_senza_chiave, test_chiave_sbagliata, test_il_cliente_e_nella_risposta |
{"cliente": "nessuno", …} lasciato com'era | La rotta è protetta (i 401 ci sono), ma la risposta non dice chi ha chiesto: il valore del controllore non è usato | test_il_cliente_e_nella_risposta |
La prima fa quattro test rossi, ed è un buon segno: la protezione stava in quel parametro.
6 · Una chiave per programma
In italiano.
- Header assente: 401 «Manca la chiave».
- Cerco la chiave nel dizionario con
get: l'officina, oppureNone. - Se è
None, la chiave non è di nessuno: 401 «Chiave sbagliata». - Altrimenti restituisco l'officina.
def controlla_chiave(chiave: str | None = Header(default=None, alias="X-API-Key")) -> str:
"""Dall'header all'officina. Header che manca, chiave che non c'è nel dizionario: 401."""
if chiave is None:
raise HTTPException(status_code=401, detail="Manca la chiave")
officina = CHIAVI.get(chiave) # None se la chiave non c'è
if officina is None:
raise HTTPException(status_code=401, detail="Chiave sbagliata")
return officinaPasso per passo. Il test toglie la chiave dell'Officina Sud mentre il programma gira:
| Richiesta | CHIAVI.get(chiave) | Risposta |
|---|---|---|
chiave-nord-4e81 | "Officina Nord" | 200, officina Nord |
chiave-sud-d02b, prima di togliere | "Officina Sud" | 200, officina Sud |
chiave-sud-d02b, dopo del CHIAVI[…] | None | 401 Chiave sbagliata |
chiave-est-7a9c, dopo | "Officina Est" | 200: le altre non si accorgono di niente |
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
return CHIAVI[chiave] | Con una chiave che non c'è: KeyError, cioè un 500 al posto del 401 | test_chiave_sbagliata, test_chiave_vuota_e_sbagliata, test_chiave_tolta_non_apre_piu |
Una copia dell'elenco fatta all'inizio del file (ELENCO_COPIATO = dict(CHIAVI)), e il controllore che guarda la copia | Funziona finché l'elenco non cambia. Una chiave tolta (o aggiunta) dopo la partenza non conta: la copia è rimasta com'era | test_chiave_tolta_non_apre_piu, test_chiave_nuova_apre |
return "Officina Nord" | Tutte le chiavi valide si presentano come Nord: la rotta non sa chi chiama davvero | test_ogni_chiave_la_sua_officina, test_chiave_nuova_apre |
La seconda è la più utile: se l'elenco è un dizionario che cambia, il controllore lo legge a ogni richiesta, non una volta sola.
7 · Un controllore, due rotte
In italiano. /orari resta com'è: chiunque può leggerlo. Alle altre due aggiungo il parametro del controllore, la stessa riga che hai scritto nell'esercizio 5. Il controllore è uno solo: ogni rotta lo nomina nel suo Depends, e non ne ricopia il codice.
@app.get("/orari")
def orari_dell_ufficio() -> dict:
return {"apertura": "7:00-19:00"}
@app.get("/smarriti")
def elenco_smarriti(programma: str = Depends(controlla_chiave)) -> dict:
return {"oggetti": OGGETTI}
@app.get("/smarriti/{numero}")
def un_oggetto_smarrito(numero: int, programma: str = Depends(controlla_chiave)) -> dict:
oggetto = OGGETTI.get(numero)
if oggetto is None:
raise HTTPException(status_code=404, detail="Oggetto non trovato")
return {"numero": numero, "oggetto": oggetto}Il parametro programma non è usato nella rotta: serve solo perché la riga con Depends faccia partire il controllore. Va bene così.
Guarda /smarriti/99 senza chiave: risponde 401, non 404. Il controllore parte prima della rotta, e a chi non ha la chiave non si dice nemmeno se l'oggetto c'è: lo stesso ordine del capitolo 1, prima «chi sei?» e poi «la cosa c'è?».
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Protetta solo /smarriti, non /smarriti/{numero} | L'elenco è chiuso, ma il singolo oggetto lo legge chiunque: la porta di servizio è rimasta aperta. Con /smarriti/99 senza chiave si ottiene un 404, e così si scopre cosa esiste | test_un_oggetto_senza_chiave, test_un_oggetto_con_chiave_sbagliata, test_senza_chiave_il_404_non_svela_niente |
Protetta anche /orari | Tutto chiuso: chi vuole solo sapere quando apre l'ufficio prende un 401 | test_gli_orari_restano_aperti |
La prima è un buco di sicurezza senza errori: quando proteggi un gruppo di rotte, ne controlli una per una.
8 · Una chiave che legge, una che scrive
In italiano.
- Se la chiave non può scrivere (
programma["scrive"]èFalse): 403 «Questa chiave non può scrivere». Non serve nemmeno guardare l'armadietto. - Se l'armadietto non c'è: 404 «Armadietto non trovato».
- Altrimenti lo metto a
"libero"e lo racconto nella risposta.
@app.post("/armadietti/{numero}/libera")
def libera_armadietto(numero: str, programma: dict = Depends(controlla_chiave)) -> dict:
if not programma["scrive"]:
raise HTTPException(status_code=403, detail="Questa chiave non può scrivere")
if numero not in ARMADIETTI:
raise HTTPException(status_code=404, detail="Armadietto non trovato")
ARMADIETTI[numero] = "libero"
return {"numero": numero, "stato": "libero"}Il disegno.
Perché il 403 prima del 404? Il permesso dipende solo da chi sei: si sa già dalla chiave, e non serve cercare l'armadietto per negarlo. (Nel capitolo 1 il 404 veniva prima del 403 perché lì il permesso dipendeva dalla cosa: «la tessera è tua?» si può dire solo dopo aver letto la tessera.) I test non decidono l'ordine per una chiave senza permesso su un armadietto che non c'è: la scelta è tua.
Passo per passo.
| Richiesta | programma["scrive"] | numero in ARMADIETTI | Risposta |
|---|---|---|---|
chiave del banco, A2 | True | sì | 200, A2 diventa libero |
chiave dell'app, A2 | False | non si guarda | 403 |
chiave del banco, Z9 | True | no | 404 |
| nessuna chiave | il controllore ferma tutto | non si arriva | 401 Manca la chiave |
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
| Nessun controllo del permesso | Qualunque chiave valida libera gli armadietti: l'app dei viaggiatori, che doveva solo guardare, ora scrive | test_la_chiave_di_sola_lettura_prende_403, test_la_chiave_di_sola_lettura_non_cambia_niente |
status_code=401 per «Questa chiave non può scrivere» | Il 401 dice «non so chi sei». Qui lo sai: la chiave è buona, e il programma ha un nome. È un 403, e chi riceve 401 proverebbe a cambiare la chiave, inutilmente | test_la_chiave_di_sola_lettura_prende_403 |
| Niente 404 per l'armadietto che non c'è | La rotta crea un armadietto Z9 dal nulla e risponde 200 | test_armadietto_che_non_c_e_prende_404 |
if programma["chi"] != "Banco bagagli": | Funziona con le due chiavi di oggi. Ma il permesso sta nel campo scrive, non nel nome: un secondo banco, con il permesso e un altro nome, prenderebbe 403 | test_un_banco_nuovo_con_il_permesso_scrive |
L'ultima è l'errore più facile da fare: i test «normali» restano verdi, e si rompe solo quando arriva una chiave nuova.