JWT: struttura, creazione e verifica
Decodifichi manualmente la struttura dei JWT, crei token firmati con un segreto e verifichi le claim senza framework.
JWT: struttura, creazione e verifica è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.
Che cos'è un JWT?
JSON Web Token (JWT) è un formato compatto di token, sicuro per gli URL, per trasmettere claim tra parti. Un JWT è firmato (e facoltativamente cifrato). È autonomo: non è necessaria alcuna ricerca nel database per verificare i claim.
Struttura del JWT: Header.Payload.Signature
Un JWT ha tre parti codificate in Base64URL e separate da punti: header.payload.signature. L'header specifica l'algoritmo. Il payload contiene i claim. La firma verifica l'integrità.
// Example JWT:
// eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9 <- header
// .eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkFsaWNlIn0 <- payload
// .SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c <- signatureHeader e payload decodificati
Decodifichi ogni parte con Base64URL per visualizzare il JSON. Il payload contiene i "claim" — quelli standard sono: sub (soggetto), iss (emittente), exp (scadenza), iat (emesso il).
// Header:
{ "alg": "HS256", "typ": "JWT" }
// Payload:
{ "sub": "user-42", "name": "Alice", "role": "ADMIN",
"iat": 1716000000, "exp": 1716003600 }Creazione manuale di un JWT (HS256)
Crei il JSON dell'header e del payload, codifichi ciascuno in Base64URL, concateni con un punto, quindi calcoli l'HMAC-SHA256 di header.payload e lo aggiunga come firma.
String header = Base64.getUrlEncoder().withoutPadding()
.encodeToString("{\"alg\":\"HS256\",\"typ\":\"JWT\"}".getBytes());
String payload = Base64.getUrlEncoder().withoutPadding()
.encodeToString("{\"sub\":\"user-42\",\"exp\":9999999999}".getBytes());
String sigInput = header + "." + payload;
byte[] sig = computeHmac(secretKey, sigInput);
String jwt = sigInput + "." + Base64.getUrlEncoder().withoutPadding().encodeToString(sig);Verifica manuale di un JWT
Divida in corrispondenza dei punti, decodifichi l'header e il payload, ricalcoli l'HMAC su header.payload, lo confronti con la firma e verifichi che exp sia nel futuro.
String[] parts = jwt.split("\\.");
String sigInput = parts[0] + "." + parts[1];
byte[] expectedSig = computeHmac(secretKey, sigInput);
byte[] actualSig = Base64.getUrlDecoder().decode(parts[2]);
if (!MessageDigest.isEqual(expectedSig, actualSig)) throw new SecurityException("Invalid signature");
// Decode payload and check exp:
String payloadJson = new String(Base64.getUrlDecoder().decode(parts[1]));
// parse JSON and check exp > nowUtilizzo della libreria java-jwt (Auth0)
La libreria com.auth0:java-jwt semplifica la creazione e la verifica dei JWT con un'API fluente.
// Create:
Algorithm alg = Algorithm.HMAC256(secretKey);
String token = JWT.create()
.withSubject("user-42")
.withClaim("role", "ADMIN")
.withExpiresAt(Instant.now().plusSeconds(3600))
.sign(alg);
// Verify:
JWTVerifier verifier = JWT.require(alg).withIssuer("my-service").build();
DecodedJWT decoded = verifier.verify(token);
System.out.println(decoded.getSubject());HS256 e RS256
HS256 usa una chiave simmetrica condivisa: è semplice, ma sia l'emittente sia il verificatore devono fidarsi l'uno dell'altro per quanto riguarda la chiave. RS256 usa RSA: firma con la chiave privata e verifica con la chiave pubblica; è adatto alle architetture composte da più servizi, in cui ogni servizio può verificare senza conoscere la chiave di firma.
Memorizzazione dei JWT: cookie HttpOnly o localStorage
Memorizzi i JWT nei cookie HttpOnly (non accessibili da JS, impediscono il furto tramite XSS) con i flag Secure e SameSite=Strict. Eviti localStorage: gli attacchi XSS possono leggerlo.
// Set JWT as HttpOnly cookie in Spring:
ResponseCookie cookie = ResponseCookie.from("jwt", token)
.httpOnly(true).secure(true).sameSite("Strict")
.path("/").maxAge(3600).build();
response.addHeader(HttpHeaders.SET_COOKIE, cookie.toString());Refresh token
I JWT hanno una scadenza breve (15 min). I refresh token (opachi, memorizzati sul server) hanno una scadenza più lunga. Il client scambia un refresh token con un nuovo JWT senza riautenticarsi.
Problema della revoca dei JWT
I JWT sono stateless: non esiste un meccanismo di revoca integrato. Utilizzi una scadenza breve e una blocklist degli ID dei JWT revocati (claim jti) in Redis per supportare il logout prima della scadenza.
// On logout, add the jti to a Redis blocklist with TTL = token expiry:
redis.set("revoked:" + jti, "1", ex, 3600);
// On verify, check blocklist:
if (redis.exists("revoked:" + decoded.getId())) throw new SecurityException("Token revoked");Integrazione dei JWT con Spring Security
In Spring Security, implementi JwtAuthenticationFilter extends OncePerRequestFilter per estrarre e verificare il JWT e impostare il SecurityContext a ogni richiesta.
String token = request.getHeader("Authorization").replace("Bearer ","");
DecodedJWT decoded = verifier.verify(token);
String userId = decoded.getSubject();
UsernamePasswordAuthenticationToken auth =
new UsernamePasswordAuthenticationToken(userId, null, authorities);
SecurityContextHolder.getContext().setAuthentication(auth);Verifica rapida
Qual è la differenza strutturale fondamentale tra la firma JWT HS256 e quella RS256?
Riepilogo
JWT = header.payload.signature (Base64URL). Firmi con HMAC (HS256) o RSA (RS256). Verifichi la firma e il claim exp. Memorizzi i JWT nei cookie HttpOnly. Utilizzi una scadenza breve e refresh token. Revochi i token tramite una blocklist del claim jti in Redis.
Domande Frequenti
La lezione «JWT: struttura, creazione e verifica» è gratuita?
Sì — il testo completo di «JWT: struttura, creazione e verifica» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.
Cosa imparerò in «JWT: struttura, creazione e verifica»?
Decodifichi manualmente la struttura dei JWT, crei token firmati con un segreto e verifichi le claim senza framework. Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Java Academy?
Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.
Quanto tempo richiede la lezione «JWT: struttura, creazione e verifica»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Java Academy?
Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Hash crittografico con MessageDigest
- Crittografia simmetrica AES
- HMAC-SHA256 per l'integrità dei messaggi
- JWT: struttura, creazione e verifica