Vai al contenuto
code-to-code

Apro l'indice…

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

Login e sicurezza6. Login e rotte protettep. 166

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.

login-rotte-protette-soluzioni.zip36 KB

La palestra

1 · Il login

In italiano.

  1. Cerco l'utente per username. Se non c'è, ho None.
  2. Se l'utente non c'è, oppure la sua password non è giusta: 401, con il messaggio unico.
  3. Altrimenti stampo il biglietto con dentro lo username, e lo restituisco.
Python
@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 sbagliatoCosa succedeIl test rosso
Due if e due messaggi: Username non trovato e Password sbagliataFunziona, ma il login racconta a chiunque quali username esistono: uno scrive un elenco di nomi e legge le rispostetest_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 401test_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 401test_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 UnknownHashErrortest_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.

Python
@app.get("/me")
def chi_sono(utente: UtenteSalvato = Depends(utente_corrente)) -> Utente:
    return utente

Il 401 non è nella rotta: lo manda utente_corrente, prima. E la freccia -> Utente taglia l'impronta dalla risposta.

Le trappole.

Il codice sbagliatoCosa succedeIl 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 maitest_me_con_il_biglietto, test_me_niente_impronta_nella_risposta, test_me_senza_biglietto, test_me_biglietto_falso
-> UtenteSalvato al posto di -> UtenteNessun errore, ma nella risposta esce anche password_hashtest_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.

  1. Se non c'è nessun header, 401 «Manca il biglietto».
  2. Leggo lo username dal biglietto, con leggi_biglietto. Può essere None.
  3. Cerco l'utente con quello username. Può essere None anche lui.
  4. Se non l'ho trovato, 401 «Biglietto non valido»: per qualsiasi motivo.
  5. Altrimenti restituisco l'utente.
Python
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 utente

Il disegno.

inizio utente_corrente(header) se header is None sì: errore 401 Manca il biglietto username = leggi_biglietto(…) utente = utenti.get(username) se utente is None sì: errore 401 Biglietto non valido restituisci utenteutente_corrente(header)header is None401 Manca il bigliettousername =leggi_biglietto(…)utente =utenti.get(username)utente is None401 Biglietto non validorestituisci utentenosìnosì
Il controllore

Passo per passo. Cinque biglietti, e cosa succede a ognuno:

BigliettoheaderusernameutenteRisposta
nessunoNonenon si calcolanon si calcola401 Manca il biglietto
biglietto-disegnato-a-manol'oggettoNone (non è un JWT)None401 Biglietto non valido
scaduto ieril'oggettoNoneNone401 Biglietto non valido
payload cambiato a manol'oggettoNone (la firma non torna)None401 Biglietto non valido
buono, ma di fantasmal'oggetto"fantasma"None401 Biglietto non valido
buono, di Ivol'oggetto"ivo"l'utente Ivol'utente

Le trappole.

Il codice sbagliatoCosa succedeIl 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 maitest_senza_biglietto, test_header_che_non_e_un_bearer
Niente if header is NoneSenza header: AttributeError: 'NoneType' object has no attribute 'credentials', cioè un 500test_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 401test_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 401gli 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.

  1. Aggiungo alla rotta il parametro del controllore: utente è chi ha il biglietto.
  2. Cerco il suo turno in TURNI, per username. Può non esserci.
  3. Se non c'è, 404 «Turno non trovato». Altrimenti rispondo con lo username e il turno.
Python
@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.

inizio GET /turni/mio turno = TURNI.get(utente.username) se turno is None sì: errore 404 Turno non trovato restituisci username e turnoGET /turni/mioturno =TURNI.get(utente.username)turno is None404 Turno non trovatorestituisci username e turnonosì
La rotta del mio turno

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 sbagliatoCosa succedeIl test rosso
TURNI[utente.username] con le quadrePer Nadia (che non ha un turno): KeyError, un 500 al posto del 404test_chi_non_ha_un_turno_prende_404
200 con "turno": "nessun turno" al posto del 404La 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 bigliettoCon il biglietto di Sergio e ?username=lucia, la rotta risponde con il turno di Lucia: chiunque ha un biglietto può leggere il turno di chiunquetest_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: faccio POST /login con il corpo JSON. Se il codice è 200, prendo access_token dalla risposta e lo metto in variabili["biglietto"]. In ogni caso restituisco il codice.
  • chiedi: preparo gli header vuoti. Se variabili ha un biglietto, scrivo Authorization: Bearer <biglietto>. Faccio GET e restituisco la risposta.
Python
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 MartaPostmanvariabili dopoRisposta
/me senza aver fatto il loginAuthorization vuota{}401 Manca il biglietto
Login di LuciaScript post-response{"biglietto": "eyJ…"}200
/meBearer Token {{biglietto}}uguale200, Lucia
Login con la password sbagliataLo script non salva (non c'è access_token)uguale401
/me ancoraIl biglietto di primauguale200, Lucia

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
Salvare sempre, senza if risposta.status_code == 200Con 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, notest_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 riuscitotest_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

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

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

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

Sono 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 sbagliatoCosa succedeIl 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 vuoletest_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 sempretest_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

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

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

Terminale
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 trappolaChi 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ì.