Il biglietto, JWT, esercizi spiegati
Cinque esempi nell'app degli abbonati
- 25 minuti di lettura
Cinque esempi, dal più semplice, tutti nell'app degli abbonati della Linea Menta. Ognuno ha lo stesso ritmo:
- Prevedi: leggi il codice e scrivi su un foglio cosa stampa. Prima di aprire la risposta.
- In italiano: cosa fa il programma, a parole.
- Passo per passo: cosa succede a ogni riga.
- Cosa portiamo a casa: la cosa da ricordare.
Per provarli: salva il codice in un file dentro palestra/ dello zip della palestra, per esempio palestra/prova.py, e dalla cartella dello zip, con il venv acceso, lancia python palestra/prova.py. Gli esempi A, B, C e D usano una chiave finta scritta nel codice, solo per provare, così funzionano subito. L'esempio E usa il file .env.
A · Rosa e Teo, due biglietti
Rosa Bellini e Teo Galbiati hanno un abbonamento nell'app. Il portale stampa un biglietto a ciascuno, con la stessa chiave e la stessa scadenza (il 1 gennaio 2100, un numero lontano apposta). Cambia solo chi sono.
import jwt
CHIAVE = "chiave-finta-solo-per-gli-esempi-del-libro"
rosa = jwt.encode({"sub": "rosa", "exp": 4102444800}, CHIAVE, algorithm="HS256")
teo = jwt.encode({"sub": "teo", "exp": 4102444800}, CHIAVE, algorithm="HS256")
rosa_ancora = jwt.encode({"sub": "rosa", "exp": 4102444800}, CHIAVE, algorithm="HS256")
pezzi_rosa = rosa.split(".")
pezzi_teo = teo.split(".")
print(pezzi_rosa[0] == pezzi_teo[0])
print(pezzi_rosa[1] == pezzi_teo[1])
print(pezzi_rosa[2] == pezzi_teo[2])
print(rosa == rosa_ancora)Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
True
False
False
True- Riga 1: il header è uguale, dice solo «HS256, JWT».
- Riga 2: il payload è diverso: dentro c'è
rosaoteo. - Riga 3: la firma è diversa: è calcolata anche sul payload, e il payload è cambiato.
- Riga 4: due biglietti di Rosa, stessi dati, stessa chiave, sono identici. Non c'è un sale: la firma si rifà sempre uguale. Per questo, nel biglietto, la scadenza conta: due biglietti stampati con la stessa scadenza di Rosa sarebbero lo stesso biglietto.
In italiano. Stampo tre biglietti. Taglio i primi due nei loro tre pezzi, e confronto il pezzo 0, il pezzo 1 e il pezzo 2. Poi confronto i due biglietti di Rosa interi.
Passo per passo.
| Confronto | Cosa c'è dentro | Risultato |
|---|---|---|
| Header di Rosa e di Teo | tutti e due {"alg":"HS256","typ":"JWT"} | True |
| Payload di Rosa e di Teo | {"sub":"rosa",…} contro {"sub":"teo",…} | False |
| Firma di Rosa e di Teo | calcolate su payload diversi | False |
| Rosa contro Rosa | stessi dati, stessa chiave, stessa firma | True |
Cosa portiamo a casa. Il biglietto è fatto di tre pezzi indipendenti: cambia il contenuto, cambia anche la firma. Le impronte delle password hanno il sale, i biglietti no: una firma si può rifare sempre uguale, da chi ha la chiave.
B · Cosa c'è nella tessera
Ugo ha un vecchio biglietto nell'app e vuole sapere di chi è e fino a quando valeva. Non ha la chiave, e non gli serve: legge.
from datetime import datetime, timezone
import jwt
TESSERA = jwt.encode({"sub": "ugo", "exp": 1795040100}, "chiave-finta-solo-per-gli-esempi-del-libro", algorithm="HS256")
dentro = jwt.decode(TESSERA, options={"verify_signature": False})
print(dentro)
scadenza = datetime.fromtimestamp(dentro["exp"], timezone.utc)
print(scadenza)
print(scadenza < datetime.now(timezone.utc))
print(dentro["sub"].upper())Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
{'sub': 'ugo', 'exp': 1795040100}
2026-11-18 22:15:00+00:00
True
UGOLa terza riga dice True se la scadenza è prima di adesso, cioè se il biglietto è scaduto: lo era già, dal 18 novembre 2026. Il biglietto, però, si legge lo stesso.
In italiano.
- Apro il biglietto senza controllare niente (
verify_signaturespento): ottengo il payload, un dizionario. - Traduco
exp, un numero di secondi, in una data in UTC. - Confronto la data con adesso: due
datetimesi confrontano con<. - Il payload è un dizionario:
dentro["sub"]è una stringa, e ha tutti i metodi delle stringhe (quiupper).
Passo per passo.
| Etichetta | Cosa c'è dentro |
|---|---|
dentro | {'sub': 'ugo', 'exp': 1795040100} |
dentro["exp"] | 1795040100, secondi dal 1 gennaio 1970 |
scadenza | 2026-11-18 22:15:00+00:00 (il +00:00 dice: UTC) |
Cosa portiamo a casa. Il payload è un dizionario normale. Leggerlo non vuol dire fidarsi: è quello che fa jwt.io, e serve a curiosare. Per decidere chi entra, mai.
C · Quattro biglietti, una funzione
La funzione leggi_biglietto dell'app dà lo username, oppure None. Ecco quattro biglietti: quello buono, uno scaduto, uno con la firma ritoccata (l'ultima lettera sostituita), e uno stampato senza la voce exp.
import jwt
CHIAVE = "chiave-finta-solo-per-gli-esempi-del-libro"
def leggi_biglietto(biglietto: str) -> str | None:
try:
dati = jwt.decode(biglietto, CHIAVE, algorithms=["HS256"])
except jwt.InvalidTokenError:
return None
return dati.get("sub")
buono = jwt.encode({"sub": "rosa", "exp": 4102444800}, CHIAVE, algorithm="HS256")
scaduto = jwt.encode({"sub": "rosa", "exp": 1795040100}, CHIAVE, algorithm="HS256")
senza_scadenza = jwt.encode({"sub": "rosa"}, CHIAVE, algorithm="HS256")
print(leggi_biglietto(buono))
print(leggi_biglietto(scaduto))
print(leggi_biglietto(buono[:-1] + "A"))
print(leggi_biglietto(senza_scadenza))Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
rosa
None
None
rosaL'ultima è la sorpresa: un biglietto senza exp vale. jwt.decode controlla la scadenza solo se c'è. Un biglietto senza data è un biglietto che non scade mai: se qualcuno lo ruba, è suo per sempre. Ecco perché chi stampa il biglietto deve sempre mettere exp: non c'è nessuno, dopo, che lo pretende.
In italiano.
jwt.decodecontrolla la firma e, se c'è, la scadenza. Se tutto torna, dà il payload.- Se qualcosa non va, alza un errore della famiglia
InvalidTokenError: iltrylo prende e la funzione rispondeNone. - Altrimenti restituisco
dati.get("sub"): lo username.
Il disegno.
Passo per passo.
| Biglietto | Cosa succede in jwt.decode | Risultato |
|---|---|---|
buono | firma giusta, scadenza nel 2100 | rosa |
scaduto | firma giusta, ma exp è passato: ExpiredSignatureError | None |
buono[:-1] + "A" | l'ultima lettera della firma è cambiata: InvalidSignatureError | None |
senza_scadenza | firma giusta, e nessuna scadenza da controllare | rosa |
buono[:-1] è il biglietto senza l'ultimo carattere: un taglio di stringa, come nel capitolo sulle stringhe. Poi + "A" ci attacca una lettera diversa.
Cosa portiamo a casa. jwt.decode non dice «questo biglietto è vero»: dice solo che la firma torna e che, se c'è, la scadenza non è passata. La scadenza la mette chi crea il biglietto.
D · Quanto dura il biglietto
Il portale stampa biglietti da 30 minuti, e per le prove biglietti più corti. Una funzione stampa, un'altra conta quanti secondi di vita restano.
from datetime import datetime, timedelta, timezone
import jwt
CHIAVE = "chiave-finta-solo-per-gli-esempi-del-libro"
def crea_biglietto(username: str, minuti: int = 30) -> str:
scadenza = datetime.now(timezone.utc) + timedelta(minutes=minuti)
return jwt.encode({"sub": username, "exp": scadenza}, CHIAVE, algorithm="HS256")
def secondi_di_vita(biglietto: str) -> int:
dentro = jwt.decode(biglietto, options={"verify_signature": False})
return dentro["exp"] - int(datetime.now(timezone.utc).timestamp())
print(secondi_di_vita(crea_biglietto("ugo")))
print(secondi_di_vita(crea_biglietto("ugo", minuti=5)))
print(secondi_di_vita(crea_biglietto("ugo", minuti=-1)))Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
1800
300
-6030 minuti sono 1800 secondi, 5 minuti sono 300. L'ultimo è meno 60: una durata negativa è una scadenza nel passato, cioè un biglietto già scaduto da un minuto. Nei test, è il modo più rapido di avere un biglietto scaduto.
In italiano.
crea_biglietto: adesso in UTC, piùminutiminuti, è la scadenza. Il biglietto porta chi è e quando scade. Se non dico i minuti, sono 30.secondi_di_vita: apro il biglietto senza controllare, prendoexp, e ci tolgo «adesso» in secondi.
Passo per passo. Per la prima chiamata:
| Riga | Cosa vale |
|---|---|
minuti | 30 (il valore di partenza) |
timedelta(minutes=minuti) | una durata di 30 minuti |
scadenza | adesso più 30 minuti |
dentro["exp"] | la scadenza in secondi |
| risultato | exp meno adesso, in secondi: 1800 |
Il secondo e il terzo lancio sono uguali, con minuti=5 e minuti=-1. Se per un attimo di troppo passa un secondo tra la stampa e il conteggio, nel tuo lancio puoi vedere 1799. È normale: per questo i test della palestra hanno una piccola tolleranza.
Cosa portiamo a casa. timedelta(minutes=…) per i minuti, datetime.now(timezone.utc) per «adesso». Con seconds= al posto di minutes= il biglietto durerebbe trenta secondi: una lettera diversa, e nessun errore. Lo trovi nelle trappole.
E · La chiave: tre guai, tre messaggi
Ernesto Pozzi, il capo deposito, prova a sistemare la chiave del portale. Una funzione la legge dall'ambiente e si ferma se non va bene. La proviamo in quattro situazioni: non c'è, è vuota, è 1234, è di 32 lettere.
import os
LUNGHEZZA_MINIMA = 32
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
for valore in [None, "", "1234", "x" * 32]:
if valore is None:
os.environ.pop("SECRET_KEY", None)
else:
os.environ["SECRET_KEY"] = valore
try:
print("lunga", len(leggi_chiave()))
except RuntimeError as errore:
print(errore)Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
Manca SECRET_KEY: crea il file .env (README, «Una volta sola»)
Manca SECRET_KEY: crea il file .env (README, «Una volta sola»)
SECRET_KEY è troppo corta: servono almeno 32 caratteri
lunga 32Le prime due righe sono uguali: una chiave vuota è come una chiave che non c'è. Il file .env con la sola riga SECRET_KEY= dà proprio una stringa vuota, non None.
In italiano.
- Prendo la chiave con
os.environ.get:Nonese non c'è. if not chiaveè vero sia perNonesia per la stringa vuota: stesso messaggio.- Se c'è ma è più corta di 32 caratteri, un altro messaggio.
- Altrimenti la restituisco, così com'è.
Il disegno.
Il for mette nell'ambiente quattro valori uno dopo l'altro: os.environ.pop toglie la voce, os.environ[...] = ... la scrive. In un programma vero è load_dotenv() a metterla, leggendo il file .env. Tra poco: nella palestra, i test usano proprio questo trucco per provare ogni caso.
Passo per passo.
SECRET_KEY | not chiave | len(chiave) | Cosa succede |
|---|---|---|---|
| non c'è | vero (è None) | RuntimeError: manca | |
"" | vero (stringa vuota) | RuntimeError: manca | |
"1234" | falso | 4, minore di 32 | RuntimeError: troppo corta |
32 volte x | falso | 32, non minore di 32 | la chiave, così com'è |
Con il vero file .env. Nella cartella dello zip, una volta sola:
python3 -c "import secrets; print('SECRET_KEY=' + secrets.token_hex(32))" > .env
ls
ls -als non mostra .env (comincia con un punto), ls -a sì. Se la tua cartella non ha un .env, python palestra/stampa_biglietto.py si ferma con il RuntimeError che hai visto. I test no: usano una chiave loro, scritta da conftest.py. È una cosa buona e una trappola: pytest verde non vuol dire che il tuo .env ci sia.
Cosa portiamo a casa. Una chiave che manca o che è troppo corta deve fermare il programma subito, con una frase che dice cosa fare. Un programma che parte con una chiave debole sembra funzionare: i biglietti li stampa lo stesso. E la firma vale quanto la chiave.