JWT : structure, création et vérification
Décodez manuellement la structure d’un JWT, créez des jetons signés avec un secret et vérifiez les revendications sans framework.
JWT : structure, création et vérification est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.
Qu’est-ce qu’un JWT ?
Un JSON Web Token (JWT) est un format compact et compatible avec les URL, conçu pour transmettre des revendications entre parties. Un JWT est signé et peut éventuellement être chiffré. Il est autonome : aucune recherche dans une base de données n’est nécessaire pour vérifier les revendications.
Structure d’un JWT : Header.Payload.Signature
Un JWT comporte trois parties encodées en Base64URL et séparées par des points : header.payload.signature. L’en-tête indique l’algorithme. La charge utile contient les revendications. La signature vérifie l’intégrité.
// Example JWT:
// eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9 <- header
// .eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkFsaWNlIn0 <- payload
// .SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c <- signatureEn-tête et charge utile décodés
Décodez chaque partie avec Base64URL pour afficher le JSON. La charge utile contient des « revendications » — les revendications standard sont : sub (sujet), iss (émetteur), exp (expiration) et iat (date d’émission).
// Header:
{ "alg": "HS256", "typ": "JWT" }
// Payload:
{ "sub": "user-42", "name": "Alice", "role": "ADMIN",
"iat": 1716000000, "exp": 1716003600 }Créer manuellement un JWT (HS256)
Construisez le JSON de l’en-tête et de la charge utile, encodez chacun en Base64URL, concaténez-les avec un point, puis calculez le HMAC-SHA256 de header.payload et ajoutez-le comme signature.
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);Vérifier manuellement un JWT
Séparez les parties sur les points, décodez l’en-tête et la charge utile, recalculez le HMAC sur header.payload, comparez-le à la signature et vérifiez que exp se situe dans le futur.
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 > nowUtiliser la bibliothèque java-jwt (Auth0)
La bibliothèque com.auth0:java-jwt simplifie la création et la vérification des JWT grâce à une API fluide.
// 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 ou RS256
HS256 utilise une clé symétrique partagée : c’est simple, mais l’émetteur et le vérificateur doivent tous deux se faire confiance pour protéger la clé. RS256 utilise RSA : signature avec la clé privée et vérification avec la clé publique. Il convient aux architectures composées de plusieurs services, où n’importe quel service peut vérifier une signature sans connaître la clé de signature.
Stocker les JWT : cookies HttpOnly ou localStorage
Stockez les JWT dans des cookies HttpOnly (inaccessibles depuis JS, ce qui empêche leur vol par XSS) avec les attributs Secure et SameSite=Strict. Évitez localStorage : les attaques XSS peuvent le lire.
// 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());Jetons d’actualisation
Les JWT ont une courte durée de validité (15 minutes). Les jetons d’actualisation (opaques et stockés côté serveur) ont une durée de validité plus longue. Le client échange un jeton d’actualisation contre un nouveau JWT sans devoir s’authentifier à nouveau.
Difficulté de la révocation des JWT
Les JWT sont sans état : aucune révocation n’est intégrée. Utilisez une courte durée de validité et une liste de blocage des identifiants de JWT révoqués (revendication jti) dans Redis afin de permettre la déconnexion avant l’expiration.
// 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");Intégration des JWT à Spring Security
Dans Spring Security, implémentez JwtAuthenticationFilter extends OncePerRequestFilter pour extraire, vérifier et définir le SecurityContext à partir du JWT à chaque requête.
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);Vérification rapide
Quelle est la différence structurelle essentielle entre la signature JWT HS256 et RS256 ?
Récapitulatif
JWT = header.payload.signature (Base64URL). Signez avec HMAC (HS256) ou RSA (RS256). Vérifiez la signature et la revendication exp. Stockez les JWT dans des cookies HttpOnly. Utilisez une courte durée de validité et des jetons d’actualisation. Révoquez-les au moyen d’une liste de blocage jti dans Redis.
Questions Fréquemment Posées
La leçon « JWT : structure, création et vérification » est-elle gratuite ?
Oui — le texte complet de « JWT : structure, création et vérification » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « JWT : structure, création et vérification » ?
Décodez manuellement la structure d’un JWT, créez des jetons signés avec un secret et vérifiez les revendications sans framework. Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Java Academy ?
Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.
Combien de temps prend la leçon « JWT : structure, création et vérification » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?
Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Hachage cryptographique avec MessageDigest
- Chiffrement symétrique AES
- HMAC-SHA256 pour l’intégrité des messages
- JWT : structure, création et vérification