Vai al contenuto
code-to-code

Apro l'indice…

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

Login e sicurezza6. Login e rotte protettep. 150

Login e rotte protette, esercizi spiegati

Cinque esempi nell'app degli abbonati

  • 30 minuti di lettura

Cinque esempi, dal più semplice, tutti nell'app degli abbonati della Linea Menta: Rosa Bellini e Teo Galbiati hanno un abbonamento, e vogliono entrare. Ognuno ha lo stesso ritmo:

  1. Prevedi: leggi il codice e scrivi su un foglio cosa risponde. Prima di aprire la risposta.
  2. In italiano: cosa fa il programma, a parole.
  3. Passo per passo: cosa succede a ogni richiesta.
  4. Cosa portiamo a casa: la cosa da ricordare.

Gli esempi usano sicurezza.py e il file .env che trovi nello zip della palestra (se non l'hai ancora creato, il README dello zip dice come). Per provarli: salva il codice in un file dentro palestra/, per esempio palestra/abbonati_login.py, e dalla cartella dello zip, con il venv acceso, accendi il server con fastapi dev palestra/abbonati_login.py. Le richieste si lanciano da un secondo terminale, sempre con il venv acceso (curl c'è anche su Windows, nel terminale di Ubuntu). I biglietti che vedrai tu saranno diversi da questi: dentro c'è l'ora di scadenza, e la chiave è la tua.


A · Il login dell'app

Rosa si iscrive e vuole entrare. L'app ha due abbonati e una rotta, POST /login. Le password le trasformiamo in impronte qui nel codice solo per comodità: in un programma vero non ci sono password scritte nel codice.

Python
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

from sicurezza import calcola_hash, crea_biglietto, password_giusta

app = FastAPI(title="L'app degli abbonati")


class Abbonato(BaseModel):
    username: str
    nome: str


class AbbonatoSalvato(Abbonato):
    password_hash: str


class Credenziali(BaseModel):
    username: str
    password: str


class Biglietto(BaseModel):
    access_token: str
    token_type: str


abbonati = {
    "rosa": AbbonatoSalvato(username="rosa", nome="Rosa Bellini", password_hash=calcola_hash("metro-milano")),
    "teo": AbbonatoSalvato(username="teo", nome="Teo Galbiati", password_hash=calcola_hash("tram-di-notte")),
}


@app.post("/login")
def login(dati: Credenziali) -> Biglietto:
    abbonato = abbonati.get(dati.username)
    if abbonato is None or not password_giusta(dati.password, abbonato.password_hash):
        raise HTTPException(status_code=401, detail="Username o password sbagliati")
    return Biglietto(access_token=crea_biglietto(abbonato.username), token_type="bearer")

Tre richieste: Rosa con la password giusta, Rosa con uno zero al posto della «o», e Ugo, che non è abbonato, con la password di Rosa.

Terminale
curl -s -X POST http://127.0.0.1:8000/login -H "Content-Type: application/json" -d '{"username": "rosa", "password": "metro-milano"}'
curl -s -X POST http://127.0.0.1:8000/login -H "Content-Type: application/json" -d '{"username": "rosa", "password": "metro-milan0"}'
curl -s -X POST http://127.0.0.1:8000/login -H "Content-Type: application/json" -d '{"username": "ugo", "password": "metro-milano"}'
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
{"access_token":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJyb3NhIiwiZXhwIjoxNzk1MTEzNzI2fQ.M7KuEDCwFXv8YzSpj63wXRINoWlUWo0wAZ29m2eIfuo","token_type":"bearer"}
{"detail":"Username o password sbagliati"}
{"detail":"Username o password sbagliati"}

La prima risposta è il biglietto: un access_token lungo e un token_type che dice bearer. Le altre due sono uguali: stesso messaggio, parola per parola. Nel registro del server, tutte e due sono un 401 Unauthorized.

In italiano.

  1. Cerco l'abbonato per username.
  2. Se non c'è, oppure c'è ma la password non è la sua: 401, con un solo messaggio.
  3. Altrimenti stampo un biglietto con dentro lo username, e lo restituisco.

Il disegno.

inizio POST /login abbonato = abbonati.get(dati.username) se abbonato is None sì: errore 401 Username o password sbagliati se not password_giusta(…) sì: errore 401 Username o password sbagliati restituisci il bigliettoPOST /loginabbonato =abbonati.get(dati.username)abbonato is None401 Username o passwordsbagliatinotpassword_giusta(…)401 Username o passwordsbagliatirestituisci il bigliettonosìnosì
Il login

Passo per passo.

Richiestaabbonati.get(...)password_giusta(...)Risposta
rosa, metro-milanol'abbonato RosaTrue200 e il biglietto
rosa, metro-milan0l'abbonato RosaFalse401 Username o password sbagliati
ugo, metro-milanoNonenon si arriva nemmeno a chiederlo401 Username o password sbagliati

Cosa portiamo a casa. Il login ha due uscite: il biglietto, oppure un 401 che non dice il motivo. Chi riceve il 401 non impara se ha sbagliato lo username o la password, e così nessuno può usare il login per scoprire chi è abbonato.


B · Cosa vede il controllore

Prima di usare il biglietto, guardiamo come arriva. Una rotta di prova non fa altro che raccontare quello che controllore (l'HTTPBearer(auto_error=False) di sicurezza.py) le consegna.

Python
from fastapi import Depends, FastAPI
from fastapi.security import HTTPAuthorizationCredentials

from sicurezza import controllore

app = FastAPI(title="Cosa vede il controllore")


@app.get("/cosa-vedo")
def cosa_vedo(header: HTTPAuthorizationCredentials | None = Depends(controllore)) -> dict[str, str | None]:
    if header is None:
        return {"schema": None, "credentials": None}
    return {"schema": header.scheme, "credentials": header.credentials}

Quattro richieste, con lo stesso finto biglietto eyJabc.def.ghi: con Bearer, senza header, con un altro tipo di accesso (Basic), e con il biglietto ma senza la parola Bearer.

Terminale
curl -s http://127.0.0.1:8000/cosa-vedo -H "Authorization: Bearer eyJabc.def.ghi"
curl -s http://127.0.0.1:8000/cosa-vedo
curl -s http://127.0.0.1:8000/cosa-vedo -H "Authorization: Basic cm9zYTptZXRyby1taWxhbm8="
curl -s http://127.0.0.1:8000/cosa-vedo -H "Authorization: eyJabc.def.ghi"
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
{"schema":"Bearer","credentials":"eyJabc.def.ghi"}
{"schema":null,"credentials":null}
{"schema":null,"credentials":null}
{"schema":null,"credentials":null}

Solo la prima è un Bearer come si deve. Nelle altre tre la rotta riceve None (in JSON, null): non c'è l'header, o non è del tipo giusto, o manca la parola. Nessun errore: auto_error=False vuol dire proprio «non rispondere tu, dammi None».

header = HTTPAuthorizationCredentials(scheme="Bearer", credentials="eyJabc.def.ghi")headerHTTPAuthorizationCredentialsscheme"Bearer"credentials"eyJabc.def.ghi"
La prima richiesta: cosa riceve la rotta

In italiano. Il controllore legge l'header Authorization. Se comincia con Bearer e uno spazio, tiene da parte le due metà: scheme (la parola) e credentials (il biglietto). Altrimenti consegna None. La rotta guarda se è None e risponde di conseguenza.

Passo per passo.

HeaderCosa riceve la rottaschemacredentials
Bearer eyJabc.def.ghiun oggettoBearereyJabc.def.ghi
(nessuno)Nonenullnull
Basic cm9z…Nonenullnull
eyJabc.def.ghiNonenullnull

Cosa portiamo a casa. header.credentials è il biglietto senza la parola Bearer: è quello che si dà a leggi_biglietto. E header può essere None: prima di scrivere header.credentials, si controlla. È il pezzo che manca a chi vede AttributeError: 'NoneType' object has no attribute 'credentials'.


C · La prima rotta protetta

Mettiamo insieme il login, il controllore (abbonato_corrente: nel capitolo lo chiamiamo utente_corrente, qui è un abbonato) e una rotta protetta, GET /me.

Python
from fastapi import Depends, FastAPI, HTTPException
from fastapi.security import HTTPAuthorizationCredentials
from pydantic import BaseModel

from sicurezza import calcola_hash, controllore, crea_biglietto, leggi_biglietto, password_giusta

app = FastAPI(title="L'app degli abbonati")


class Abbonato(BaseModel):
    username: str
    nome: str


class AbbonatoSalvato(Abbonato):
    password_hash: str


class Credenziali(BaseModel):
    username: str
    password: str


class Biglietto(BaseModel):
    access_token: str
    token_type: str


abbonati = {
    "rosa": AbbonatoSalvato(username="rosa", nome="Rosa Bellini", password_hash=calcola_hash("metro-milano")),
    "teo": AbbonatoSalvato(username="teo", nome="Teo Galbiati", password_hash=calcola_hash("tram-di-notte")),
}



@app.post("/login")
def login(dati: Credenziali) -> Biglietto:
    abbonato = abbonati.get(dati.username)
    if abbonato is None or not password_giusta(dati.password, abbonato.password_hash):
        raise HTTPException(status_code=401, detail="Username o password sbagliati")
    return Biglietto(access_token=crea_biglietto(abbonato.username), token_type="bearer")


def abbonato_corrente(header: HTTPAuthorizationCredentials | None = Depends(controllore)) -> AbbonatoSalvato:
    if header is None:
        raise HTTPException(status_code=401, detail="Manca il biglietto")
    username = leggi_biglietto(header.credentials)
    abbonato = abbonati.get(username)
    if abbonato is None:
        raise HTTPException(status_code=401, detail="Biglietto non valido")
    return abbonato


@app.get("/me")
def chi_sono(abbonato: AbbonatoSalvato = Depends(abbonato_corrente)) -> Abbonato:
    return abbonato

Rosa fa il login e tiene il biglietto in una variabile. Poi tre richieste a /me: con il biglietto, senza niente, con un biglietto disegnato a mano.

Terminale
BIGLIETTO=$(curl -s -X POST http://127.0.0.1:8000/login -H "Content-Type: application/json" -d '{"username": "rosa", "password": "metro-milano"}' | python3 -c "import json, sys; print(json.load(sys.stdin)['access_token'])")
curl -s http://127.0.0.1:8000/me -H "Authorization: Bearer $BIGLIETTO"
curl -s http://127.0.0.1:8000/me
curl -s http://127.0.0.1:8000/me -H "Authorization: Bearer biglietto-disegnato-a-mano"

La prima riga fa il login con curl e infila access_token in BIGLIETTO: python3 -c legge la risposta e stampa solo quel campo. Non stampa niente a schermo, ed è giusto così.

Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
{"username":"rosa","nome":"Rosa Bellini"}
{"detail":"Manca il biglietto"}
{"detail":"Biglietto non valido"}

Il biglietto buono apre la porta e /me risponde con Rosa: username e nome, niente impronta, perché la freccia è -> Abbonato. Senza header: «Manca il biglietto». Con il biglietto falso: «Biglietto non valido». Sono due messaggi diversi per due guai diversi.

abbonati = { "rosa": AbbonatoSalvato(username="rosa", nome="Rosa Bellini", password_hash="$argon2id$v=19$m=65536,t=3,p=4$…"), "teo": AbbonatoSalvato(username="teo", nome="Teo Galbiati", password_hash="$argon2id$v=19$m=65536,t=3,p=4$…"), } abbonato = abbonati["rosa"]abbonatiabbonatodict"rosa""teo"AbbonatoSalvatousername"rosa"nome"Rosa Bellini"password_hash"$argon2id$v=19$m=65536,t=3,p=4$…"AbbonatoSalvatousername"teo"nome"Teo Galbiati"password_hash"$argon2id$v=19$m=65536,t=3,p=4$…"
L'abbonato che arriva a chi_sono, con il biglietto di Rosa

In italiano.

  1. FastAPI vede che chi_sono vuole Depends(abbonato_corrente), e che questa vuole Depends(controllore).
  2. Chiama il controllore, che legge l'header.
  3. Chiama abbonato_corrente: se header è None, 401; se il biglietto non si legge, 401; se l'abbonato non c'è più, 401.
  4. Solo se arriva fin qui, chiama chi_sono con l'abbonato nel parametro.

Il disegno.

inizio GET /me se header is None sì: errore 401 Manca il biglietto username = leggi_biglietto(…) abbonato = abbonati.get(username) se abbonato is None sì: errore 401 Biglietto non valido restituisci l'abbonatoGET /meheader is None401 Manca il bigliettousername =leggi_biglietto(…)abbonato =abbonati.get(username)abbonato is None401 Biglietto non validorestituisci l'abbonatonosìnosì
Il controllore, poi la rotta

Passo per passo.

Richiestaheaderleggi_biglietto(...)abbonati.get(...)Risposta
biglietto di Rosal'oggetto con il biglietto"rosa"l'abbonato Rosa200, Rosa
nessun headerNonenon si chiamanon si chiama401 Manca il biglietto
biglietto disegnato a manol'oggetto con biglietto-disegnato-a-manoNoneNone401 Biglietto non valido

Cosa portiamo a casa. Tutta la protezione è nel parametro Depends(abbonato_corrente). Nella rotta non c'è nessun if: il controllo avviene prima, e la funzione parte solo se è andato bene.


D · I cinque 401

Un biglietto può non andare bene in cinque modi. Facciamoli tutti e cinque, uno dopo l'altro, contro la rotta dell'esempio C. Non serve il server: lo script usa TestClient, che chiama l'API senza accenderla (come i test). Salva questo come palestra/cinque_401.py, accanto ad abbonati_me.py, e lancia python palestra/cinque_401.py.

Python
import os
from datetime import datetime, timedelta, timezone

import jwt
from fastapi.testclient import TestClient

from abbonati_me import app
from sicurezza import crea_biglietto

client = TestClient(app)
chiave = os.environ["SECRET_KEY"]

# Un biglietto di Rosa: scaduto ieri
scaduto = jwt.encode({"sub": "rosa", "exp": datetime.now(timezone.utc) - timedelta(days=1)}, chiave, algorithm="HS256")

# Un biglietto di Rosa con il payload di Teo: testa e firma sono di Rosa, il resto no
testa, _, firma = crea_biglietto("rosa").split(".")
payload_di_teo = crea_biglietto("teo").split(".")[1]
cambiato = f"{testa}.{payload_di_teo}.{firma}"

casi = [
    ("nessun header", {}),
    ("disegnato a mano", {"Authorization": "Bearer biglietto-disegnato-a-mano"}),
    ("payload cambiato", {"Authorization": f"Bearer {cambiato}"}),
    ("scaduto", {"Authorization": f"Bearer {scaduto}"}),
    ("abbonato sparito", {"Authorization": f"Bearer {crea_biglietto('ugo')}"}),
    ("biglietto buono", {"Authorization": f"Bearer {crea_biglietto('rosa')}"}),
]
for nome, headers in casi:
    risposta = client.get("/me", headers=headers)
    print(f"{nome:<18} {risposta.status_code}  {risposta.json()}")

Ogni riga stampa il caso, il codice e la risposta. Prima di guardare: quanti dei sei casi risponderanno 401? E quali messaggi?

Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
nessun header      401  {'detail': 'Manca il biglietto'}
disegnato a mano   401  {'detail': 'Biglietto non valido'}
payload cambiato   401  {'detail': 'Biglietto non valido'}
scaduto            401  {'detail': 'Biglietto non valido'}
abbonato sparito   401  {'detail': 'Biglietto non valido'}
biglietto buono    200  {'username': 'rosa', 'nome': 'Rosa Bellini'}

Cinque 401 e un 200 (l'ultimo, con il biglietto buono, per confronto). Il messaggio è «Manca il biglietto» solo per il primo caso: gli altri quattro, pur diversi tra loro, dicono tutti «Biglietto non valido». Chi riceve il 401 non impara perché: scaduto, firma sbagliata, cambiato a mano e utente sparito non si distinguono da fuori.

In italiano. Preparo i biglietti cattivi con pyjwt, come nel capitolo 5, poi li mando uno per uno a /me.

Passo per passo.

CasoCom'è fattoChi lo ferma
nessun headerniente Authorizationabbonato_corrente: header è None
disegnato a manonon è un JWTleggi_biglietto: restituisce None
payload cambiatotesta e firma di Rosa, payload di Teoleggi_biglietto: la firma non torna
scadutoexp di ierileggi_biglietto: la scadenza è passata
abbonato sparitobiglietto vero, ma Ugo non è nel dizionarioabbonato_corrente: abbonati.get("ugo") dà None
biglietto buonobiglietto vero di Rosanessuno: passa

Cosa portiamo a casa. Il controllore non ha cinque if per cinque guai: leggi_biglietto ne ferma tre con una funzione sola, e un if utente is None ne ferma uno. E l'ultimo caso è il più sottile: il biglietto è vero, ma l'utente non c'è più (cancellato, oppure, in un programma con dizionario, il server è ripartito). Il biglietto vale, la persona no.


E · La tessera di Rosa

L'app ha un saldo per ogni tessera. La rotta GET /tessera/saldo mostra il saldo di chi ha il biglietto. Il resto del file è quello dell'esempio C; qui ci sono solo i saldi e la rotta nuova.

Python
SALDI = {"rosa": 12.5, "teo": 3.0}  # euro rimasti sulla tessera


@app.get("/tessera/saldo")
def saldo(abbonato: AbbonatoSalvato = Depends(abbonato_corrente)) -> dict[str, float | str]:
    return {"abbonato": abbonato.username, "saldo": SALDI[abbonato.username]}

Salva tutto come palestra/abbonati_saldo.py (è l'esempio C, più queste righe, senza /me). Rosa fa il login e chiede il saldo. Poi lo chiede ancora, ma scrivendo nell'indirizzo ?abbonato=teo: vuole sbirciare la tessera di Teo. Infine Teo fa il suo login e chiede il saldo.

Terminale
BIGLIETTO=$(curl -s -X POST http://127.0.0.1:8000/login -H "Content-Type: application/json" -d '{"username": "rosa", "password": "metro-milano"}' | python3 -c "import json, sys; print(json.load(sys.stdin)['access_token'])")
curl -s http://127.0.0.1:8000/tessera/saldo -H "Authorization: Bearer $BIGLIETTO"
curl -s "http://127.0.0.1:8000/tessera/saldo?abbonato=teo" -H "Authorization: Bearer $BIGLIETTO"
BIGLIETTO_TEO=$(curl -s -X POST http://127.0.0.1:8000/login -H "Content-Type: application/json" -d '{"username": "teo", "password": "tram-di-notte"}' | python3 -c "import json, sys; print(json.load(sys.stdin)['access_token'])")
curl -s http://127.0.0.1:8000/tessera/saldo -H "Authorization: Bearer $BIGLIETTO_TEO"
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
{"abbonato":"rosa","saldo":12.5}
{"abbonato":"rosa","saldo":12.5}
{"abbonato":"teo","saldo":3.0}

La seconda risposta è ancora il saldo di Rosa. Il ?abbonato=teo è arrivato nella richiesta, ma la rotta non ha nessun parametro che lo legga: non c'è abbonato tra gli argomenti della funzione, quindi FastAPI lo ignora. Con il biglietto di Teo, invece, la stessa rotta risponde con il saldo di Teo.

In italiano. La rotta non chiede «di chi vuoi il saldo?». Chiede al controllore «chi sei?», e risponde con il saldo di quella persona. Non c'è nessun posto, nella richiesta, dove scrivere un altro nome.

Passo per passo.

Biglietto diRichiestaabbonato.usernameRisposta
Rosa/tessera/saldorosasaldo di Rosa
Rosa/tessera/saldo?abbonato=teorosa (lo dice il biglietto)saldo di Rosa
Teo/tessera/saldoteosaldo di Teo

Cosa portiamo a casa. Chi sei lo dice il biglietto, mai la richiesta. Se la rotta leggesse abbonato dall'indirizzo, chiunque avrebbe il saldo di chiunque: basterebbe cambiare una parola. Questo schema, «la mia roba», funziona senza controllare niente di più, perché ognuno vede solo la propria. Quando una rotta deve decidere se tu puoi toccare la roba di un altro, serve un controllo in più: è il capitolo sui permessiin arrivo.


Pronto? Gli stessi schemi ti aspettano nella palestra, nel portale del personale: cinque esercizi da scaricare, con i test, e una storia in fondo.