Vai al contenuto
code-to-code

Apro l'indice…

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

Login e sicurezza5. Il biglietto: JWTp. 131

Il biglietto, JWT, 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.

Il codice è una delle soluzioni possibili. Se il tuo è diverso e i test sono verdi, va bene: confronta il ragionamento, non le lettere.

Le soluzioni complete

La stessa cartella, con il codice al posto di pass. Aprila dopo averci provato: i test sono gli stessi.

login-jwt-soluzioni.zip13 KB

1 · Il biglietto nella giacca ★

In italiano. Un biglietto vero ha tre pezzi separati da due punti. Se i pezzi non sono tre, non è un biglietto e ci si ferma con il ValueError della consegna. Se lo è, si apre il payload senza controllare firma e scadenza: è quello che fa jwt.io.

Python
def leggi_senza_chiave(biglietto: str) -> dict:
    pezzi = biglietto.split(".")
    if len(pezzi) != 3:
        raise ValueError("Non è un biglietto: servono tre pezzi separati da due punti")
    return jwt.decode(biglietto, options={"verify_signature": False})  # legge, non controlla

Il lancio a mano, python palestra/tre_pezzi.py, dà:

['eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9', 'eyJzdWIiOiJpdm8iLCJleHAiOjE3OTUwNDAxMDB9', 'QPnViFL8ilRv1Yl4DdiaVI71j6HC6Mu0wHTEtMi9C98']
{'sub': 'ivo', 'exp': 1795040100}
Scadeva: 2026-11-18 22:15:00+00:00

Il biglietto di Ivo era di Ivo, e scadeva il 18 novembre alle 22:15 (UTC).

Le trappole.

Il codice sbagliatoCosa succedeI test rossi
Niente controllo dei pezzi: solo return jwt.decode(biglietto, options={"verify_signature": False})Con "scontrino-del-bar" la libreria alza il suo errore (DecodeError), non il ValueError della consegna. Chi usa la funzione si aspettava un errore, ma un altrotest_un_pezzo_solo_non_e_un_biglietto, test_quattro_pezzi_non_sono_un_biglietto
jwt.decode(biglietto), senza optionsLa libreria vuole controllare la firma, e non ha chiave né algorithms: DecodeError: It is required that you pass in a value for the "algorithms" argumenttest_dentro_ci_sono_sub_ed_exp, test_si_legge_anche_il_biglietto_di_ieri, test_si_legge_anche_senza_la_chiave_giusta
jwt.decode(biglietto, os.environ["SECRET_KEY"], algorithms=["HS256"]), cioè controllareVa bene per un biglietto buono. Ma qui si legge: il biglietto di ieri è scaduto (ExpiredSignatureError), quello con l'altra chiave ha la firma sbagliata (InvalidSignatureError). Lo stesso Ivo non ha la chiave del portaletest_si_legge_anche_il_biglietto_di_ieri, test_si_legge_anche_senza_la_chiave_giusta
biglietto.count(".") != 3 per contare i pezziTre pezzi hanno due punti, non tre. Il controllo respinge i biglietti veri, e lascia passare quelli con quattro punti, che non sono bigliettitest_dentro_ci_sono_sub_ed_exp, test_si_legge_anche_il_biglietto_di_ieri, test_si_legge_anche_senza_la_chiave_giusta, test_quattro_pezzi_non_sono_un_biglietto

L'ultima è un classico degli errori «uno in più, uno in meno»: i pezzi sono tre, i punti che li separano due.


2 · La macchinetta dei biglietti ★★

In italiano. Il biglietto deve dire due cose: chi è (sub, lo username così com'è) e quando scade (exp). La scadenza è «adesso, in UTC, più i minuti che mi hanno chiesto». Il portale la firma con la chiave segreta e l'algoritmo del blocco in cima al file.

Python
def crea_biglietto(username: str, minuti: int = 30) -> str:
    scadenza = datetime.now(timezone.utc) + timedelta(minutes=minuti)
    dati = {"sub": username, "exp": scadenza}
    return jwt.encode(dati, SECRET_KEY, algorithm=ALGORITMO)

Passo per passo. Con crea_biglietto("lucia"):

RigaCosa vale
minuti30, il valore di partenza
scadenzaadesso in UTC, più 30 minuti
dati{"sub": "lucia", "exp": <la scadenza>}
il returnil biglietto: una stringa in tre pezzi

python palestra/stampa_biglietto.py stampa il biglietto e il suo payload (il tuo avrà un'altra firma, e un altro exp: dentro c'è la tua chiave e l'ora in cui lo fai):

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJsdWNpYSIsImV4cCI6MTc5NTExMzIwM30.Ifyp3Ur0wvZomb7vOURn1Zu5VwFGXNFbxS43gQRtkjI
{'sub': 'lucia', 'exp': 1795113203}

Le trappole.

Il codice sbagliatoCosa succedeI test rossi
datetime.now() + timedelta(minutes=minuti), senza timezone.utcPython legge l'ora del computer, e jwt la prende come se fosse UTC. Sul computer di Milano d'inverno (UTC più 1) il biglietto vale un'ora in più: exp è sbagliato di circa 3600 secondi. Sul tuo computer, se è in UTC, non si vede: il test lo mette apposta sull'ora di Milanotest_scade_tra_30_minuti, test_la_durata_si_puo_cambiare
timedelta(seconds=minuti)Una parola diversa, e il biglietto dura 30 secondi invece di 30 minuti. Nessun errore: si vede solo quando il biglietto scade subitotest_scade_tra_30_minuti, test_la_durata_si_puo_cambiare
timedelta(minutes=30), con il 30 scritto dentroIl parametro minuti non conta più: il biglietto di prova da 5 minuti ne dura 30test_la_durata_si_puo_cambiare
dati = {"sub": username}, senza expIl biglietto non scade mai. jwt.decode non lo nota (esempio C): chi lo ruba lo tiene per sempretest_scade_tra_30_minuti, test_la_durata_si_puo_cambiare
jwt.encode(dati, "segreto", algorithm=ALGORITMO), la chiave scritta nel codiceI biglietti non sono firmati con la chiave del .env: chi legge il codice (o GitHub) li falsifica. I test aprono il biglietto con la chiave giusta, e la firma non tornatest_dentro_c_e_lo_username, test_scade_tra_30_minuti, test_la_durata_si_puo_cambiare
jwt.encode(…).decode("utf-8")Nelle vecchie versioni di pyjwt encode restituiva byte e serviva decode. Oggi dà già una stringa: AttributeError: 'str' object has no attribute 'decode'test_e_una_stringa_in_tre_pezzi, test_dentro_c_e_lo_username, test_scade_tra_30_minuti, test_la_durata_si_puo_cambiare

L'ultima è un consiglio che si trova su vecchi esempi in rete: guarda sempre da quando è scritto.


3 · La lettera cambiata ★★

In italiano. Apro il biglietto con la chiave del portale. Se la libreria è soddisfatta (firma giusta, non scaduto), restituisco lo username. Se non lo è, qualunque sia il motivo, restituisco None: chi chiama vuole sapere solo «chi è?». Tutti gli errori del biglietto sono di una famiglia, jwt.InvalidTokenError: un solo except li prende.

Python
def leggi_biglietto(biglietto: str) -> str | None:
    try:
        dati = jwt.decode(biglietto, SECRET_KEY, algorithms=[ALGORITMO])  # controlla firma e scadenza
    except jwt.InvalidTokenError:
        return None
    return dati.get("sub")

Il disegno.

inizio leggi_biglietto(biglietto) se non è un JWT sì: restituisci None se la firma non torna sì: restituisci None se exp è passata sì: restituisci None restituisci dati.get("sub")leggi_biglietto(biglietto)non è un JWTrestituisci Nonela firma non tornarestituisci Noneexp è passatarestituisci Nonerestituisci dati.get("sub")nosìnosìnosì
Leggere il biglietto

Passo per passo. Il trucco di Marta, e gli altri biglietti:

BigliettoCosa fa jwt.decodeRisultato
buono, di Martafirma giusta, scadenza nel futuro"marta"
scaduto da un minutoExpiredSignatureError, catturatoNone
firmato con un'altra chiaveInvalidSignatureError, catturatoNone
payload di Lucia, firma di Martala firma non torna: InvalidSignatureError, catturatoNone
"biglietto-disegnato-a-mano"DecodeError: Not enough segments, catturatoNone

python palestra/controlla_biglietto.py rifà il trucco:

buono:      marta
cambiato:   None
disegnato:  None

Le trappole.

Il codice sbagliatoCosa succedeI test rossi
jwt.decode(biglietto, SECRET_KEY), senza algorithmsDecodeError: It is required that you pass in a value for the "algorithms" argument, che fa parte della famiglia: il try lo cattura in silenzio e ogni biglietto è non valido, anche quello buonotest_biglietto_buono_da_lo_username
options={"verify_signature": False} dentro il decodeIl biglietto si legge senza controllare la firma: quello cambiato a mano, e quello con un'altra chiave, passano. Marta entra come Lucia. Resta solo il controllo della scadenzatest_biglietto_scaduto_da_none, test_biglietto_firmato_con_un_altra_chiave_da_none, test_biglietto_cambiato_a_mano_da_none
Niente tryI biglietti cattivi fanno esplodere la funzione: ExpiredSignatureError, InvalidSignatureError, DecodeError, invece di un Nonetest_biglietto_scaduto_da_none, test_biglietto_firmato_con_un_altra_chiave_da_none, test_biglietto_cambiato_a_mano_da_none, test_biglietto_disegnato_a_mano_da_none
except jwt.ExpiredSignatureError soltantoIl biglietto scaduto va bene, ma la firma sbagliata e il biglietto disegnato a mano passano di là, e fanno esplodere la funzionetest_biglietto_firmato_con_un_altra_chiave_da_none, test_biglietto_cambiato_a_mano_da_none, test_biglietto_disegnato_a_mano_da_none
except jwt.DecodeError soltantoIl disegnato a mano va bene. Ma il biglietto scaduto fa esplodere la funzione: ExpiredSignatureError non è un DecodeErrortest_biglietto_scaduto_da_none

Quando un except è troppo stretto, i biglietti cattivi che non rientrano escono dalla funzione. Quando è troppo largo (except Exception) si nascondono anche gli errori tuoi. La famiglia InvalidTokenError è la misura giusta.

Una cosa che i test non guardano: un biglietto senza scadenza (esempio C degli esercizi spiegati) per jwt.decode vale. Se vuoi pretenderla, si aggiunge options={"require": ["exp"]}. Qui non serve: il biglietto lo stampi tu, e lo stampi con exp.


4 · La chiave del portale ★★★

In italiano. La chiave sta nell'ambiente, alla voce SECRET_KEY. Si leggono tre cose, nell'ordine: c'è? è lunga abbastanza? E si restituisce com'è. «Non c'è» e «è vuota» sono lo stesso caso: if not chiave li prende tutti e due. Solo dopo si può chiedere la lunghezza, che di None non esiste.

Python
def leggi_chiave() -> str:
    chiave = os.environ.get("SECRET_KEY")
    if not chiave:
        raise RuntimeError("Manca SECRET_KEY: crea il file .env (README, «Una volta sola»)")
    if len(chiave) < LUNGHEZZA_MINIMA:
        raise RuntimeError(f"SECRET_KEY è troppo corta: servono almeno {LUNGHEZZA_MINIMA} caratteri")
    return chiave

Il disegno.

inizio leggi_chiave() chiave = os.environ.get("SECRET_KEY") se not chiave sì: errore RuntimeError Manca SECRET_KEY se len(chiave) < 32 sì: errore RuntimeError SECRET_KEY è troppo corta restituisci chiaveleggi_chiave()chiave =os.environ.get("SECRET_KEY")not chiaveRuntimeError MancaSECRET_KEYlen(chiave) < 32RuntimeError SECRET_KEY ètroppo cortarestituisci chiavenosìnosì
I due controlli sulla chiave

Passo per passo.

SECRET_KEYnot chiavelen(chiave) < 32Cosa succede
non c'èveronon si arrivaRuntimeError: manca
""veronon si arrivaRuntimeError: manca
"1234"falsoveroRuntimeError: troppo corta
31 caratterifalsoveroRuntimeError: troppo corta
32 caratterifalsofalsola chiave

python palestra/chiave.py, con il .env fatto dal comando del README:

La chiave c'è, ed è lunga 64 caratteri.

La chiave non si stampa: si conta.

Le trappole.

Il codice sbagliatoCosa succedeI test rossi
os.environ["SECRET_KEY"], con le quadreSe la chiave manca, esce un KeyError: 'SECRET_KEY' invece della frase che dice cosa faretest_senza_chiave_si_ferma
if chiave is None invece di if not chiaveIl file .env con la sola riga SECRET_KEY= dà una stringa vuota, non None. Passa il primo controllo, e si ferma al secondo con il messaggio sbagliato («troppo corta»)test_chiave_vuota_e_come_se_mancasse
La lunghezza controllata prima di «manca»len(None) non esiste: TypeError. E la stringa vuota riceve il messaggio sbagliatotest_senza_chiave_si_ferma, test_chiave_vuota_e_come_se_mancasse
len(chiave) <= LUNGHEZZA_MINIMA«Almeno 32» vuol dire che 32 caratteri bastano. Con <= una chiave di 32 viene respintatest_32_caratteri_bastano
SECRET_KEY = os.environ.get("SECRET_KEY") fuori dalla funzione, e dentro si usa quellaLa chiave viene letta una volta sola, quando il file parte. Quello che cambia dopo (i test cambiano l'ambiente a ogni prova) non lo vede. In un programma vero funziona per caso: sembra giusto finché la chiave non cambiatutti e sei i test di test_chiave.py

L'ultima non è un errore del portale, ma una scelta: qui la funzione si chiama in momenti diversi e con ambienti diversi. Nel blocco della chiave dei primi esercizi, invece, la lettura è in cima al file, una volta sola: è giusto così, perché la chiave serve per tutta la vita del programma.