Aller au contenu principal

Structure JWT

Un JSON Web Token est constitué de trois segments Base64url reliés par des points : un en-tête qui nomme l’algorithme de signature, un payload qui porte des revendications sur qui vous êtes et jusqu’à quand, et une signature cryptographique calculée sur les deux premiers. Définie dans la RFC 7519, la structure est inspectable par n’importe qui — la signature protège l’intégrité, pas la confidentialité.

100 % local

Structure JWT en clair

Quand un service veut vous remettre une preuve de connexion que n’importe lequel de ses serveurs peut vérifier sans magasin de sessions partagé, il vous remet un JWT. Le token est une chaîne compacte et compatible URL — vous en avez déjà vu : trois blocs de charabia apparent séparés par deux points, transportés dans un en-tête Authorization ou un cookie. Ce charabia n’est pas du chiffrement ; c’est du Base64url, et cela se décode en une ligne de code.

Le format descend d’une famille de spécifications : la RFC 7519 définit le token lui-même, la RFC 7515 (JWS) définit comment la signature l’enveloppe, et le groupe de travail JOSE a fourni les noms de revendications enregistrées et les identifiants d’algorithmes. Cette filiation explique la propriété la plus mal comprise du format, exposée plus bas sans détour — signé signifie que toute altération se détecte, pas que c’est secret.

Ce guide décode un vrai token segment par segment, liste les revendications enregistrées avec leur sémantique exacte, compare les deux familles de signatures que vous rencontrerez — HS256 et RS256 — et énonce les règles qui gardent les tokens sûrs, y compris pourquoi la vérification a sa place sur le serveur, avec la clé de l’émetteur, à chaque requête.

Tout ce qui suit, vous pouvez le faire sur un vrai token en quelques secondes — le décodeur JWT découpe et décode les trois segments en local, en signalant les horodatages au passage.

Comme chaque segment est en Base64url, le guide Base64 est la lecture complémentaire idéale : il explique l’alphabet, le padding omis et pourquoi les tokens sont compatibles URL.

Trois segments, deux points

La sérialisation compacte est header.payload.signature — chaque segment encodé indépendamment en Base64url, les points servant de séparateurs littéraux. L’encodage omet délibérément le padding, si bien qu’un token ne contient que des lettres, des chiffres, des tirets et des underscores : sans danger dans les URL, les en-têtes et les cookies, sans échappement. Décoder les deux premiers segments n’est pas un piratage — c’est la manière prévue d’inspecter un token ; le troisième segment est celui où intervient la vérification.

Un vrai token, avec une signature calculée sur lui, se décode exactement comme ceci :

Un token avec une signature HS256 valide

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJodHRwczovL2F1dGguZXhhbXBsZS5jb20iLCJzdWIiOiJ1c2VyXzg0OTIiLCJhdWQiOiJhcGkuZXhhbXBsZS5jb20iLCJpYXQiOjE3NjcyMjU2MDAsImV4cCI6MTc2NzMxMjAwMCwianRpIjoiYjBmNmMyZDQtNGU3YS00YzFmLTlhMmItM2Q1ZTdmOWExYzNlIn0.iDPqw4BRxZtM064Y3EH83XLB0cgEjbj5snSXeM846VY

Les deux premiers segments, décodés

{"alg":"HS256","typ":"JWT"}

{"iss":"https://auth.example.com","sub":"user_8492",
 "aud":"api.example.com","iat":1767225600,
 "exp":1767312000,
 "jti":"b0f6c2d4-4e7a-4c1f-9a2b-3d5e7f9a1c3e"}

L’en-tête : la table des matières du token

L’en-tête est un petit objet JSON — formellement le JWS Protected Header. Deux champs font presque tout le travail : alg nomme l’algorithme de signature, et typ enregistre le type de média, JWT par convention. Un troisième, kid (identifiant de clé), oriente le vérificateur vers la bonne clé quand un émetteur en publie plusieurs. L’en-tête est signé mais jamais chiffré, et il n’est fiable qu’une fois la signature vérifiée — jusque-là, alg est une revendication, pas un fait.

ChampSignificationExemple
algAlgorithme de signature — première décision de routage du vérificateurHS256, RS256, ES256
typType de média ; JWT par convention, ignoré par la plupart des bibliothèquesJWT
kidQuelle clé utiliser pour la vérification, quand plusieurs sont publiées2026-01-signing
noneLe pseudo-algorithme qui signifie « non signé » — à rejeter sauf si c’est réellement demandé(cible d’attaque connue)

Le payload : les revendications enregistrées et ce que chacune promet

Le payload est un objet JSON de revendications. Sept d’entre elles sont enregistrées par la RFC 7519 avec des significations précises et interopérables ; tout le reste est privé, propre à l’émetteur et à l’audience. Les heures sont des valeurs NumericDate — des secondes depuis l’epoch Unix, pas des millisecondes — et les revendications temporelles n’ont qu’une valeur indicative pour le vérificateur : c’est à lui de les contrôler, ce n’est pas le format qui l’impose.

RevendicationNom completCe qu’elle affirme
issÉmetteurQui a créé et signé le token — une URL ou un nom
subSujetÀ qui s’adresse le token — un identifiant d’utilisateur ou de client
audAudienceÀ quels destinataires le token est destiné ; les vérificateurs le rejettent s’ils n’y figurent pas
expExpirationÉchéance en secondes depuis l’epoch ; invalide une fois passée
nbfPas avantInstant le plus précoce où le token peut être accepté
iatÉmis leQuand le token a été créé — une preuve d’ancienneté, pas une expiration
jtiJWT IDUn identifiant unique pour ce token — le point d’accroche des listes de révocation

La signature : HS256, RS256 et le fonctionnement de la vérification

La signature est calculée sur l’entrée à signer — l’en-tête encodé, un point, le payload encodé — avec l’algorithme que nomme l’en-tête. HS256 est du HMAC-SHA256 avec un secret partagé : rapide et symétrique, approprié uniquement quand le signataire et chaque vérificateur forment un même domaine de confiance, car quiconque détient le secret peut fabriquer des tokens. RS256 est du RSA : l’émetteur signe avec une clé privée et n’importe qui — y compris un navigateur — peut vérifier avec la clé publique publiée, ce qui en fait le choix par défaut des protocoles fédérés comme OAuth 2.0 et OpenID Connect.

La vérification recalcule la signature et compare. C’est tout le mécanisme — et c’est pourquoi l’en-tête alg, à lui seul, décide comment le contrôle s’effectue. Les bibliothèques se sont durcies après les attaques de confusion d’algorithme du début des années 2010 : un token déclarant alg none, ou un token RS256 rejoué comme HS256 en utilisant la clé publique comme secret HMAC, ne passe la vérification qu’auprès des vérificateurs qui omettent d’épingler leur algorithme attendu.

Les deux familles en un coup d'œil

HS256: HMAC-SHA256(secret, header + '.' + payload)
       le signataire et le vérificateur partagent le secret

RS256: RSA-SHA256(private key, header + '.' + payload)
       l’émetteur signe ; n’importe qui vérifie avec la clé publique

La règle qui en découle

Fixez l’algorithme attendu pour chaque émetteur.
Ne le déduisez jamais du seul en-tête du jeton.
N’acceptez jamais alg: none.

Signé, pas scellé : ce que la signature ne fait pas

La signature prouve que le token a été émis par celui qui détient la clé et qu’il n’a pas été altéré depuis — intégrité et authenticité. Elle n’offre aucune confidentialité : Base64url est un encodage, et le payload est lisible par quiconque voit passer le token, y compris les extensions de navigateur, les proxys quand les tokens circulent dans des URL, et les collecteurs de logs. Les règles permanentes en découlent : ne jamais placer de secrets dans un payload JWT, ne jamais envoyer de tokens dans des URL, et traiter chaque revendication décodée comme une donnée plutôt que comme une décision.

Ce dernier point est le piège côté client. Un navigateur peut décoder un token et lire exp ou sub — mais il ne peut pas vérifier le token de manière significative, parce qu’il ne détient pas la clé de l’émetteur : avec HS256, le secret ne doit jamais atteindre un navigateur du tout, et avec RS256, un contrôle côté client ne prouve rien sur ce à quoi le détenteur a accès. Les clients peuvent inspecter des tokens pour l’affichage — montrer un nom, avertir d’une expiration prochaine — mais c’est au serveur de vérifier la signature et chaque revendication à chaque requête. Inspecter n’est pas vérifier, et lisible ne veut pas dire autorisé.

Inspecter des tokens en toute sécurité — la boucle pratique

Une boucle d’inspection disciplinée prend quelques secondes : décoder l’en-tête et le payload, vérifier exp et nbf par rapport à l’horloge, confirmer que iss et aud sont bien ceux attendus, et seulement alors — sur le serveur — vérifier la signature avec un algorithme épinglé et la bonne clé. Tout, sauf la vérification finale, n’est que traitement de texte, et c’est pourquoi un décodeur qui s’exécute entièrement dans votre navigateur est le bon outil : les vrais tokens sont des secrets de type bearer, et un secret a sa place dans les onglets que vous contrôlez, pas sur des sites qui pourraient les faire suivre.

Gardez en mémoire ce que la structure ne peut pas vous donner : la révocation — les listes de blocage fondées sur jti doivent être construites et consultées côté serveur ; la confidentialité — utilisez JWE si vous avez besoin de tokens chiffrés ; et la confiance — un token structurellement parfait, émanant d’un émetteur que vous n’avez jamais configuré, ne vaut rien. La structure vous dit ce qui a été promis ; seule la vérification vous dit que la promesse est intacte.

Questions fréquentes

Est-il sûr de coller mon vrai token dans un décodeur JWT ?

Ici, oui, parce que le décodeur de ce site s’exécute entièrement dans votre navigateur : le token n’est jamais envoyé, aucun serveur ne peut le journaliser, et la Content-Security-Policy du site bloque les requêtes sortantes, si bien que la page ne peut rien transmettre, même par accident. Soyez bien plus prudent avec n’importe quel autre décodeur en ligne — un JWT est un secret de type bearer, et quiconque le lit peut l’utiliser jusqu’à son expiration.

La signature chiffre-t-elle le contenu du token ?

Non — la signature ne fait que détecter les altérations. Base64url est un encodage réversible, pas du chiffrement : quiconque détient le token peut lire chaque revendication, et c’est pourquoi mots de passe et secrets ne doivent jamais entrer dans le payload. Il existe des variantes confidentielles, les JWE — des JSON Web Tokens chiffrés — mais les tokens des en-têtes Authorization ordinaires sont des JWS : signés, lisibles, et révélateurs de toute altération.

Quelle est la différence entre HS256 et RS256 ?

Le modèle de clés. HS256 est du HMAC-SHA256 avec un secret partagé unique : toute partie capable de vérifier des tokens peut aussi en fabriquer, donc il convient aux services isolés qui contrôlent les deux bouts. RS256 est du RSA : l’émetteur signe avec une clé privée et les vérificateurs contrôlent avec une clé publique — la vérification ne confère jamais le pouvoir de falsifier. Les normes d’identité fédérée s’appuient sur RS256 pour exactement cette raison.

Pourquoi les JWT doivent-ils être vérifiés sur le serveur ?

Parce que la vérification a besoin de la clé de l’émetteur et d’une décision d’autorisation, et seul le serveur possède les deux. Avec HS256, le secret partagé ne doit jamais atteindre un navigateur du tout ; avec RS256, un navigateur pourrait vérifier cryptographiquement une signature, mais sa propre conclusion ne prouve rien sur l’accès — les clients peuvent être modifiés. Le serveur revérifie la signature et contrôle iss, aud et exp à chaque requête.

Que se passe-t-il quand un JWT expire ?

Rien d’automatique — exp est une revendication que le vérificateur doit contrôler. Un serveur conforme la compare à l’heure courante et rejette le token une fois l’échéance passée ; un serveur négligent continue de l’accepter indéfiniment. Les flux de rafraîchissement existent pour cette raison : des tokens d’accès à courte durée de vie, contrôlés à chaque requête, plus un refresh token à plus longue durée de vie que le serveur peut révoquer au besoin.

Puis-je faire confiance à un token dont je n’ai pas vérifié la signature ?

Tout au plus comme un indice non authentifié. Un token non vérifié a pu être écrit par n’importe qui — son iss, son sub et même son exp ne sont que du texte tant que le contrôle de signature n’est pas passé. Le modèle mental sûr : le décodage vous dit ce que le token affirme ; la vérification vous dit qui a signé ces affirmations et qu’elles sont inchangées. Ne fondez jamais un contrôle d’accès sur le décodage seul.

Où puis-je lire les normes citées ici ?