Vai al contenuto
code-to-code

Apro l'indice…

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

Login e sicurezza2. La chiave: API Keyp. 46

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.

login-la-chiave-soluzioni.zip22 KB

1 · Fare la chiave

In italiano.

  1. fai_chiave chiede a secrets 16 byte a caso, scritti in esadecimale: 32 caratteri.
  2. riga_env mette insieme il nome, l'uguale e una chiave nuova.
Python
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 sbagliatoCosa succedeIl test rosso
random.choice("0123456789abcdef") 32 volteSembra 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 appostatest_non_usa_random, test_usa_secrets
secrets.token_hex(8)Sono 8 byte: 16 caratteri. Una chiave più corta si indovina primatest_lunga_32_caratteri, test_non_usa_random, test_riga_env_nome_uguale_chiave
Una chiave scritta a mano nel codice, sempre la stessaNon è «a caso»: ogni programma avrebbe la stessa chiave, e chi legge il codice la conoscetest_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 davantitest_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.

  1. Prendo la variabile con os.environ.get: None se non c'è.
  2. Se è None oppure vuota, mi fermo con un RuntimeError che dice quale variabile manca.
  3. Altrimenti la restituisco com'è.
Python
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 chiave

if 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 sbagliatoCosa succedeIl 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 faretest_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 401test_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 sbagliatatest_un_altro_nome, test_il_messaggio_ha_il_nome_vero

3 · Il programma che chiama

In italiano.

  • chiedi_ritardi: faccio GET /ritardi con un dizionario di header che ha X-API-Key e 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 un RuntimeError. Altrimenti prendo il massimo dei minuti.
Python
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:

ChiaveRisposta del serverstatus_codeCosa fa la funzione
quella giustala lista dei ritardi200max(4, 0, 11): restituisce 11
sbagliata{"detail": "Chiave sbagliata"}401RuntimeError("Il server ha risposto 401")

Le trappole.

Il codice sbagliatoCosa succedeIl 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 registrigli stessi cinque
ritardo_massimo senza guardare il codiceCon la chiave sbagliata risposta.json() è {"detail": …}, non una lista: il max si rompe con un errore che non c'entra con la chiavetest_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.

  1. L'header non c'è (chiave è None): 401 «Manca la chiave».
  2. C'è, ma non è la chiave nel .env: 401 «Chiave sbagliata».
  3. Altrimenti restituisco il cliente.
Python
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 CLIENTE

Il disegno.

inizio controlla_chiave(chiave) se chiave is None sì: errore 401 Manca la chiave se chiave != CHIAVE_PONTE_CICLO sì: errore 401 Chiave sbagliata restituisci CLIENTEcontrolla_chiave(chiave)chiave is None401 Manca la chiavechiave !=CHIAVE_PONTE_CICLO401 Chiave sbagliatarestituisci CLIENTEnosìnosì
Il controllore di Ponte Ciclo

Passo per passo.

Richiestachiaveis None!= CHIAVE_PONTE_CICLORisposta
nessun headerNonesìnon si guarda401 Manca la chiave
header vuoto""nosì401 Chiave sbagliata
la chiave giusta più una x"chiave-dei-test-…x"nosì401 Chiave sbagliata
la chiave giustala chiavenono"App Sella Verde"

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
Header(alias="X-API-Key"), senza default=NoneSenza header FastAPI risponde da solo, con un 422 e il suo messaggio. Le righe che hai scritto tu non partono maitest_senza_chiave, test_la_chiave_nell_url_non_vale
Header(default=None), senza aliasIl 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 giustatest_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 fondoLa chiave giusta passa, ma la funzione restituisce None: il parametro cliente della rotta vale None, e la risposta dice "cliente": nulltest_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 è giustotest_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.

Python
@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 sbagliatoCosa succedeIl 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 maitest_chiave_giusta_apre_la_porta, test_senza_chiave, test_chiave_sbagliata, test_il_cliente_e_nella_risposta
{"cliente": "nessuno", …} lasciato com'eraLa rotta è protetta (i 401 ci sono), ma la risposta non dice chi ha chiesto: il valore del controllore non è usatotest_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.

  1. Header assente: 401 «Manca la chiave».
  2. Cerco la chiave nel dizionario con get: l'officina, oppure None.
  3. Se è None, la chiave non è di nessuno: 401 «Chiave sbagliata».
  4. Altrimenti restituisco l'officina.
Python
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 officina

Passo per passo. Il test toglie la chiave dell'Officina Sud mentre il programma gira:

RichiestaCHIAVI.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[…]None401 Chiave sbagliata
chiave-est-7a9c, dopo"Officina Est"200: le altre non si accorgono di niente

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
return CHIAVI[chiave]Con una chiave che non c'è: KeyError, cioè un 500 al posto del 401test_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 copiaFunziona finché l'elenco non cambia. Una chiave tolta (o aggiunta) dopo la partenza non conta: la copia è rimasta com'eratest_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 davverotest_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.

Python
@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 sbagliatoCosa succedeIl 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 esistetest_un_oggetto_senza_chiave, test_un_oggetto_con_chiave_sbagliata, test_senza_chiave_il_404_non_svela_niente
Protetta anche /orariTutto chiuso: chi vuole solo sapere quando apre l'ufficio prende un 401test_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.

  1. Se la chiave non può scrivere (programma["scrive"] è False): 403 «Questa chiave non può scrivere». Non serve nemmeno guardare l'armadietto.
  2. Se l'armadietto non c'è: 404 «Armadietto non trovato».
  3. Altrimenti lo metto a "libero" e lo racconto nella risposta.
Python
@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.

inizio POST /armadietti/{numero}/libera se la chiave non può scrivere sì: errore 403 Questa chiave non può scrivere se numero non è in ARMADIETTI sì: errore 404 Armadietto non trovato ARMADIETTI[numero] = "libero" restituisci numero e statoPOST/armadietti/{numero}/liberala chiave non puòscrivere403 Questa chiave non puòscriverenumero non è inARMADIETTI404 Armadietto non trovatoARMADIETTI[numero] ="libero"restituisci numero e statonosìnosì
Liberare un armadietto

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.

Richiestaprogramma["scrive"]numero in ARMADIETTIRisposta
chiave del banco, A2Truesì200, A2 diventa libero
chiave dell'app, A2Falsenon si guarda403
chiave del banco, Z9Trueno404
nessuna chiaveil controllore ferma tuttonon si arriva401 Manca la chiave

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
Nessun controllo del permessoQualunque chiave valida libera gli armadietti: l'app dei viaggiatori, che doveva solo guardare, ora scrivetest_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, inutilmentetest_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 200test_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 403test_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.