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.
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.
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 controllaIl lancio a mano, python palestra/tre_pezzi.py, dà:
['eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9', 'eyJzdWIiOiJpdm8iLCJleHAiOjE3OTUwNDAxMDB9', 'QPnViFL8ilRv1Yl4DdiaVI71j6HC6Mu0wHTEtMi9C98']
{'sub': 'ivo', 'exp': 1795040100}
Scadeva: 2026-11-18 22:15:00+00:00Il biglietto di Ivo era di Ivo, e scadeva il 18 novembre alle 22:15 (UTC).
Le trappole.
| Il codice sbagliato | Cosa succede | I 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 altro | test_un_pezzo_solo_non_e_un_biglietto, test_quattro_pezzi_non_sono_un_biglietto |
jwt.decode(biglietto), senza options | La libreria vuole controllare la firma, e non ha chiave né algorithms: DecodeError: It is required that you pass in a value for the "algorithms" argument | test_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è controllare | Va 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 portale | test_si_legge_anche_il_biglietto_di_ieri, test_si_legge_anche_senza_la_chiave_giusta |
biglietto.count(".") != 3 per contare i pezzi | Tre pezzi hanno due punti, non tre. Il controllo respinge i biglietti veri, e lascia passare quelli con quattro punti, che non sono biglietti | test_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.
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"):
| Riga | Cosa vale |
|---|---|
minuti | 30, il valore di partenza |
scadenza | adesso in UTC, più 30 minuti |
dati | {"sub": "lucia", "exp": <la scadenza>} |
il return | il 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 sbagliato | Cosa succede | I test rossi |
|---|---|---|
datetime.now() + timedelta(minutes=minuti), senza timezone.utc | Python 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 Milano | test_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 subito | test_scade_tra_30_minuti, test_la_durata_si_puo_cambiare |
timedelta(minutes=30), con il 30 scritto dentro | Il parametro minuti non conta più: il biglietto di prova da 5 minuti ne dura 30 | test_la_durata_si_puo_cambiare |
dati = {"sub": username}, senza exp | Il biglietto non scade mai. jwt.decode non lo nota (esempio C): chi lo ruba lo tiene per sempre | test_scade_tra_30_minuti, test_la_durata_si_puo_cambiare |
jwt.encode(dati, "segreto", algorithm=ALGORITMO), la chiave scritta nel codice | I 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 torna | test_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.
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.
Passo per passo. Il trucco di Marta, e gli altri biglietti:
| Biglietto | Cosa fa jwt.decode | Risultato |
|---|---|---|
| buono, di Marta | firma giusta, scadenza nel futuro | "marta" |
| scaduto da un minuto | ExpiredSignatureError, catturato | None |
| firmato con un'altra chiave | InvalidSignatureError, catturato | None |
| payload di Lucia, firma di Marta | la firma non torna: InvalidSignatureError, catturato | None |
"biglietto-disegnato-a-mano" | DecodeError: Not enough segments, catturato | None |
python palestra/controlla_biglietto.py rifà il trucco:
buono: marta
cambiato: None
disegnato: NoneLe trappole.
| Il codice sbagliato | Cosa succede | I test rossi |
|---|---|---|
jwt.decode(biglietto, SECRET_KEY), senza algorithms | DecodeError: 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 buono | test_biglietto_buono_da_lo_username |
options={"verify_signature": False} dentro il decode | Il 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 scadenza | test_biglietto_scaduto_da_none, test_biglietto_firmato_con_un_altra_chiave_da_none, test_biglietto_cambiato_a_mano_da_none |
Niente try | I biglietti cattivi fanno esplodere la funzione: ExpiredSignatureError, InvalidSignatureError, DecodeError, invece di un None | test_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 soltanto | Il biglietto scaduto va bene, ma la firma sbagliata e il biglietto disegnato a mano passano di là, e fanno esplodere la funzione | 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.DecodeError soltanto | Il disegnato a mano va bene. Ma il biglietto scaduto fa esplodere la funzione: ExpiredSignatureError non è un DecodeError | test_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.
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 chiaveIl disegno.
Passo per passo.
SECRET_KEY | not chiave | len(chiave) < 32 | Cosa succede |
|---|---|---|---|
| non c'è | vero | non si arriva | RuntimeError: manca |
"" | vero | non si arriva | RuntimeError: manca |
"1234" | falso | vero | RuntimeError: troppo corta |
| 31 caratteri | falso | vero | RuntimeError: troppo corta |
| 32 caratteri | falso | falso | la 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 sbagliato | Cosa succede | I test rossi |
|---|---|---|
os.environ["SECRET_KEY"], con le quadre | Se la chiave manca, esce un KeyError: 'SECRET_KEY' invece della frase che dice cosa fare | test_senza_chiave_si_ferma |
if chiave is None invece di if not chiave | Il 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 sbagliato | test_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 respinta | test_32_caratteri_bastano |
SECRET_KEY = os.environ.get("SECRET_KEY") fuori dalla funzione, e dentro si usa quella | La 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 cambia | tutti 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.