Dopo aver effettuato l’accesso, come fa un server a sapere che ogni richiesta successiva proviene davvero da te? Una risposta popolare è un JSON Web Token, o JWT, solitamente pronunciato “jot”. Si tratta di un piccolo dato firmato che il client invia con ogni richiesta e il server può controllarlo senza toccare un database.

Il modo più veloce per comprendere un JWT è costruirne uno e poi provare a romperlo. Lo abbiamo fatto utilizzando solo la libreria standard di Python, su Python 3.13, e l’output seguente proviene da quell’esecuzione. Questo codice è per l’apprendimento. In un’applicazione reale, utilizzare una libreria ben mantenuta, perché i dettagli della verifica sono facili da sbagliare.

Cos’è un JWT?

JWT è uno standard aperto, definito nella RFC 7519, per il passaggio delle rivendicazioni tra due parti come una stringa compatta. Un’attestazione è semplicemente un’affermazione, ad esempio “l’ID di questo utente è 42”. Poiché il token è firmato, il destinatario può confermare chi lo ha emesso e che nessuno lo ha modificato.

Pensa a un braccialetto da festival. Il personale al gate controlla il tuo biglietto una volta e ti dà una fascia difficile da falsificare. Dopodiché ogni stallo guarda solo la band, senza bisogno di telefonare alla biglietteria. Un JWT funziona più o meno allo stesso modo per un’API.

Come funziona l’accesso JWT

1. L’utente invia un nome utente e una password all’endpoint di accesso.
2. Il server li controlla e crea un token firmato.
3. Il client memorizza il token.
4. Ogni richiesta successiva lo include, in genere in un’intestazione: Authorization: Bearer <token>.
5. Il server verifica la firma e la scadenza, quindi legge le attestazioni.

Il vantaggio principale si trova nel passaggio 5. Il server non deve cercare una sessione, il che è utile quando molti servizi o server devono controllare lo stesso token. Se non conosci le API, inizia con cos’è un’API.

Le tre parti di un JWT

Un JWT sembra testo casuale, ma è composto da tre sezioni con codifica Base64URL separate da punti. Eccone uno che abbiamo generato:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9
.eyJzdWIiOiI0MiIsInJvbGUiOiJ1c2VyIiwiaWF0IjoxNzkzNTAwMDAwLCJleHAiOjE3OTM1MDA5MDB9
.7YfUDH_T-iDh8bMmUT8mmKYwOstzT8Ty--DTTAmQGWM

Abbiamo aggiunto interruzioni di riga per facilitare la lettura. La decodifica delle prime due parti fornisce un semplice JSON:

Header:  {"alg":"HS256","typ":"JWT"}
Payload: {"sub":"42","role":"user","iat":1793500000,"exp":1793500900}

Affermazioni standard

Puoi anche aggiungere attestazioni personalizzate, come role. I tempi sono timestamp Unix, in secondi. Mantieni piccolo il carico utile, poiché il token viaggia con ogni richiesta.

Costruiscine uno tu stesso

La creazione di un token implica la codifica delle due parti JSON e la successiva firma con un segreto utilizzando HMAC-SHA256:

import base64, hashlib, hmac, json

SECRET = b"demo-secret-do-not-use-in-production"

def b64url(data):
    return base64.urlsafe_b64encode(data).rstrip(b"=").decode()

def sign(message):
    return b64url(hmac.new(SECRET, message.encode(), hashlib.sha256).digest())

def create_token(payload):
    header = {"alg": "HS256", "typ": "JWT"}
    parts = [
        b64url(json.dumps(header, separators=(",", ":")).encode()),
        b64url(json.dumps(payload, separators=(",", ":")).encode()),
    ]
    message = ".".join(parts)
    return message + "." + sign(message)

La verifica funziona ricalcolando la firma e confrontandola con quella nel token. Solo qualcuno con il segreto può produrne uno corrispondente:

def verify_token(token, now):
    header, payload, signature = token.split(".")
    expected = sign(header + "." + payload)
    if not hmac.compare_digest(signature, expected):
        raise ValueError("bad signature")
    claims = json.loads(b64url_decode(payload))
    if claims["exp"] < now:
        raise ValueError("token expired")
    return claims

Un token valido ha restituito le proprie attestazioni come previsto. compare_digest viene utilizzato poiché funziona in tempo costante, il che evita perdite di informazioni a causa di differenze temporali.

Prova a manometterlo

Supponiamo che un utente malintenzionato decodifichi il payload, cambi "role":"user" in "role":"admin", lo codifichi nuovamente e mantenga la vecchia firma. Abbiamo provato questo, insieme ad altri due attacchi:

Quest’ultimo tentativo prende di mira una vera debolezza storica. Alcune librerie una volta si fidavano dell’intestazione del token, quindi un utente malintenzionato poteva semplicemente dichiarare che non era necessaria alcuna firma. Il nostro codice utilizza sempre un algoritmo fisso, motivo per cui è stato rifiutato. In una biblioteca reale, specifica sempre gli algoritmi che accetti.

Firmato, non crittografato

Questo è il punto più frainteso sui JWT. Il nostro token contraffatto è stato rifiutato, ma il suo contenuto era ancora perfettamente leggibile:

{"sub":"42","role":"admin","iat":1793500000,"exp":1793500900}

Base64URL è una codifica, non una crittografia, e chiunque può invertirla senza alcuna chiave. La firma impedisce alle persone di modificare i dati, ma non di leggerli. Quindi non inserire mai password, numeri di carta o dati personali privati ​​in un payload JWT. Se i contenuti devono essere nascosti, utilizzare token crittografati (JWE) o semplicemente conservare i dati sul server.

HS256 contro RS256

Con la firma asimmetrica, altri servizi possono verificare i token senza poterne coniare di propri, il che limita il danno se uno viene compromesso.

JWT vs sessioni

I JWT sono spesso presentati come un moderno sostituto delle sessioni. In realtà, ognuno ha dei compromessi:

Per un sito Web tradizionale reso dal server, un cookie di sessione è spesso più semplice e sicuro. I JWT tendono ad avere più senso per le API utilizzate da diversi servizi o per i client mobili.

Dove archiviare i token in un browser

Molte guide sulla sicurezza preferiscono HttpOnly, Secure, SameSite i cookie per le app web. Qualunque cosa tu scelga, usa sempre HTTPS. Per inviare un token da JavaScript, consulta il nostro tutorial sull’API JavaScript Fetch.

Aggiorna i token

La scadenza breve limita il danno derivante da un token rubato, ma nessuno vuole accedere ogni 15 minuti. La solita soluzione utilizza due token:

• Token di accesso: di breve durata, ad esempio minuti, e inviato con ogni richiesta API.
• Token di aggiornamento: di più lunga durata, archiviato con maggiore attenzione e utilizzato solo per ottenere nuovi token di accesso.

Il server tiene traccia dei token di aggiornamento, quindi può revocarli, il che ti offre un pratico logout. Ruotarli a ogni utilizzo ti aiuta anche a rilevare il furto, perché un vecchio token rubato viene riprodotto.

Errori comuni di sicurezza

• Decodifica senza verifica. La lettura di un payload non lo rende affidabile. Controlla sempre la firma.
• Accetta qualsiasi algoritmo. Imposta un elenco esplicito di algoritmi consentiti.
• Utilizzo di un segreto debole. I segreti brevi possono essere violati offline. Utilizzare un valore casuale lungo e mantenerlo fuori dal controllo del codice sorgente.
• Saltare la scadenza. I token senza exp possono funzionare per sempre se rubati.
• Non controllare iss e aud. Altrimenti un token emesso per un servizio potrebbe essere accettato da un altro.
• Affidarsi ad affermazioni obsolete. Un ruolo all’interno di un token può non essere aggiornato fino alla scadenza.
• Token di registrazione. Chiunque legga i tuoi log potrebbe riutilizzarli.
• Non testare i percorsi di errore. Aggiungi test per i token scaduti e modificati, nonché per quelli validi. La nostra guida Test API con Postman può aiutarti.

Considerazioni finali

Un JWT è un dato firmato di cui un server può fidarsi senza una ricerca, non un contenitore segreto e non un aggiornamento automatico durante le sessioni. Utilizza una scadenza breve, verifica tutto con una libreria mantenuta e mantieni i dati privati ​​fuori dal carico utile. Per vederlo di persona, esegui un piccolo script come il nostro, cambia un carattere di un token e guarda la verifica fallire.

Domande frequenti

Continua a imparare