Débogueur JWT

Décodeur JWT (Décodage & Vérification)

Déboguez vos jetons JWT en ligne en toute sécurité. Décodez l'en-tête et le payload, vérifiez les signatures HS256, RS256 et ES256, et inspectez l'expiration en local.

Préréglages :
Jeton JWT encodé
En-tête (JOSE)(74B)
.
Payload (Claims)(248B)
.
Signature cryptographique(342B)
PKCS#1 / X.509 SPKI
Tolérance de dérive d'horloge:
60s
Expiration (exp): 244d ago
En-tête décodé (JOSE)alg: RS256
{
  "alg": "RS256",
  "typ": "JWT",
  "kid": "auth0-key-2026-prod"
}
Payload décodé (Claims & Données)6 registered & custom claims
{
  "iss": "https://auth.example.com/",
  "sub": "auth0|64f1a2b3c4d5e6f7",
  "aud": "https://api.example.com/v2/",
  "iat": 1772500000,
  "exp": 1772586400,
  "scope": "read:profile write:reports openid email"
}
iss (Issuer): https://auth.example.com/
sub (Subject): auth0|64f1a2b3c4d5e6f7
aud (Audience): "https://api.example.com/v2/"
iat (Issued At): 245d ago
Taille du jeton666 B
AlgorithmeRS256
Statut d'expirationJeton expiré
Santé de sécurité85/100
État de la signatureClé ou certificat requis pour vérification
Total des claims6 Claims
Référence technique et guide d'architecture

Débogueur JWT (Décoder & Vérifier) — Guide de référence

Déboguez vos jetons JWT en ligne en toute sécurité. Décodez l'en-tête et les claims du payload, vérifiez les signatures HS256, RS256 et ES256, et contrôlez l'expiration localement.

Débogueur JWT (Décoder & Vérifier) — Guide de référence — Architecture en mémoire côté client et flux de données
Débogueur JWT (Décoder & Vérifier) — Guide de référence — Architecture en mémoire côté client et flux de données

Paramètres clés et contrôles

En-tête JOSE (Javascript Object Signing and Encryption)Objet JSON (Spécification JWS RFC 7515)

Spécifie l'algorithme cryptographique ('alg' : HS256, RS256, ES256) et le type de jeton ('typ' : 'JWT'). Le vérificateur doit appliquer une liste d'autorisation stricte d'algorithmes (allowlist) afin de bloquer les attaques par confusion d'algorithme. Analysé en temps linéaire O(n) sans rétrogradation d'expression régulière (regex backtracking).

Par défaut : {"alg":"HS256","typ":"JWT"}
Charge Utile des Claims JWT (Jeu de Revendications RFC 7519)Objet JSON (Spécification RFC 7519)

Contient les assertions d'identité, les métadonnées d'entité et les périmètres d'accès (scopes). Les claims standards enregistrés incluent 'sub' (sujet), 'iss' (émetteur), 'aud' (audience), 'iat' (émis à) et 'exp' (expiration en secondes epoch POSIX). Le bac à sable local Web Crypto API décode les claims en temps O(n) sans aucune transmission réseau vers l'extérieur.

Par défaut : {"sub":"user_123","iat":1772500000,"exp":1772503600}
Signature Compacte JWSEmpreinte Cryptographique Binaire Base64URL

Condensat cryptographique généré en signant 'Base64URL(Header) + "." + Base64URL(Payload)' avec la clé privée ou le secret partagé. Garantit l'authenticité du message et l'intégrité de la charge utile grâce à une comparaison en temps constant prévenant les attaques par canaux auxiliaires temporels (timing attacks).

Par défaut : Signature HMAC ou RSA encodée en Base64URL
Secret Partagé HMAC / Clé Publique PEMMatériel Cryptographique (SPKI PEM / Secret Brut)

Clé cryptographique utilisée pour vérifier la signature. HS256 requiert un secret d'au moins 256 bits (32 octets) afin d'empêcher les attaques par dictionnaire ou force brute hors ligne ; RS256 exige une clé publique RSA SPKI PEM de 2048 ou 4096 bits ; ES256 nécessite une clé publique P-256 (secp256r1) importée via Web Crypto API crypto.subtle.importKey().

Par défaut : votre-secret-256-bits
Tolérance de Dérive d'Horloge (Leeway)Marge Temporelle Tolérée (Secondes)

Écart opérationnel temporel admissible (intervalle standard : 30 à 120 secondes, valeur de référence : 60 secondes) compensant la dérive d'horloge NTP (Network Time Protocol) entre le serveur d'authentification émetteur et les vérificateurs de ressources lors de la validation des claims 'exp' et 'nbf'.

Par défaut : 60 secondes

Conseils de pro et bonnes pratiques

Ne Vous Fiez Jamais au Seul Décodage Côté Client (Vérifiez la Signature sur le Serveur)

Décoder un JWT via Base64URL en JavaScript frontend permet d'extraire les claims pour personnaliser l'interface utilisateur (par ex. afficher le nom d'utilisateur), mais n'offre aucune garantie d'authenticité. Un utilisateur malveillant peut falsifier les claims du payload tels que 'role: admin' en quelques secondes. Les passerelles d'API (API Gateways) de production et les serveurs backend doivent impérativement vérifier mathématiquement la signature JWS à l'aide d'un secret de confiance ou d'une clé publique avant d'autoriser la moindre requête.

Se Prémunir Contre l'Attaque par Contournement Cryptographique 'alg: none' (RFC 8725 §3.1)

La norme RFC 7519 autorise le type de jeton 'alg: none' pour les environnements non sécurisés. Les bibliothèques de validation vulnérables acceptent ces jetons avec un bloc de signature vide, permettant à des attaquants de forger des claims arbitraires. Configurez systématiquement vos intergiciels (middlewares) de vérification JWT avec une liste d'algorithmes autorisés stricte (par ex. algorithms: ['RS256']), et rejetez impérativement les jetons dont le champ 'alg' vaut 'none' ou ne correspond pas au chiffrement attendu.

Appliquer le Seuil Minimal d'Entropie de 256 Bits pour les Secrets HS256 (RFC 7518 §3.2)

La robustesse des signatures symétriques HMAC dépend exclusivement de celle du secret partagé. Si un secret HS256 repose sur un mot du dictionnaire ou mesure moins de 32 octets (256 bits), des outils de cassage hors ligne comme hashcat peuvent retrouver la clé en quelques secondes à partir d'un simple jeton intercepté. Utilisez des clés cryptographiquement aléatoires de 256 bits générées via 'crypto.getRandomValues(new Uint8Array(32))' ou un CSPRNG certifié.

Neutraliser les Attaques par Confusion de Clés Symétriques et Asymétriques (RFC 8725 §3.2)

Lors d'une attaque par confusion d'algorithme, un attaquant modifie l'en-tête d'un jeton RS256 en 'HS256' et le signe en utilisant la clé publique RSA du serveur comme secret partagé HMAC. Si la bibliothèque de vérification backend résout dynamiquement les algorithmes sans contrôle strict du type de clé, elle validera le jeton falsifié. Protégez-vous en verrouillant l'algorithme attendu par point de terminaison (endpoint) et en isolant hermétiquement les magasins de clés HMAC et RSA.

Le Payload JWT Est Encodé, NON Chiffré (Ne Stockez Jamais de Données Sensibles ou DCP)

Un JWT standard est un jeton signé JWS (JSON Web Signature) et non un jeton chiffré JWE (JSON Web Encryption). La charge utile est simplement encodée en Base64URL et peut être lue en clair par quiconque intercepte le trafic réseau ou ouvre la console du navigateur. Ne stockez jamais d'identifiants de base de données, de mots de passe bruts, de numéros de sécurité sociale ou de données bancaires dans les claims JWT (conformément au RGPD et aux règles de sécurité).

Pièges courants et dépannage

⚠️Erreur de Signature Invalide (SignatureVerificationException) Malgré un Secret Correct

Cette erreur se produit fréquemment lorsque la clé secrète est encodée en Base64 sur le serveur d'authentification (cas fréquent avec Supabase et Auth0) mais injectée comme texte brut UTF-8 dans le vérificateur. Activez l'option 'Secret en Base64' si votre clé utilise cet encodage. Vérifiez également qu'aucun saut de ligne final ('\n') ni guillemet parasite n'a été copié par inadvertance avec le secret.

⚠️Erreur Jeton Expiré (TokenExpiredError: jwt expired) Immédiatement Après la Génération

Les claims JWT 'exp' et 'iat' doivent être exprimés en secondes depuis l'epoch Unix (10 chiffres), et non en millisecondes (13 chiffres). Si votre backend définit 'exp: Date.now()', l'horodatage sera interprété dans un futur très lointain, ou en cas de division erronée, en l'an 1970. Utilisez impérativement 'Math.floor(Date.now() / 1000) + dureeDeVieEnSecondes', et configurez une tolérance de dérive d'horloge (leeway) de 60 secondes sur le vérificateur.

⚠️Échec de Vérification RS256 avec Erreur 'Format de Clé Invalide' ou Erreur SPKI PEM

L'algorithme RS256 requiert une clé publique PEM au format SubjectPublicKeyInfo (SPKI) débutant par '-----BEGIN PUBLIC KEY-----' et s'achevant par '-----END PUBLIC KEY-----'. Si vous utilisez une clé au format PKCS#1 commençant par '-----BEGIN RSA PUBLIC KEY-----' ou un endpoint JWKS, convertissez la clé au format standard SPKI ou extrayez la chaîne de certificats x5c dans une enveloppe PEM conforme.

⚠️Erreur Jeton Malformé : Le JWT ne Contient Pas Exactement Deux Points Séparateurs

Un jeton compact conforme à la norme RFC 7519 comporte obligatoirement deux points séparant trois segments Base64URL (En-tête.ChargeUtile.Signature). Si vous copiez le jeton depuis un en-tête de requête HTTP, supprimez le préfixe 'Bearer ', les séquences d'échappement URL ('%2E') ainsi que les retours chariot ('\r\n') avant l'analyse.

Foire aux questions (FAQ)

Comment vérifie-t-on la signature d'un JWT et quels sont les composants mathématiques requis ?▼

Pour vérifier la signature d'un JWT, on concatène la chaîne exacte de l'en-tête et de la charge utile encodées en Base64URL avec un point ('en-tete.payload'), puis on calcule le condensat cryptographique à l'aide de l'algorithme spécifié dans l'en-tête ('alg') et de la clé du serveur. On compare enfin ce condensat à la signature décodée en Base64URL. Pour HS256, l'opération repose sur HMAC-SHA256 avec un secret partagé ; pour RS256, elle nécessite une vérification RSA-SHA256 via la clé publique de l'émetteur.

Quelle est la différence entre HS256 et RS256 dans l'authentification par JWT ?▼

HS256 est un algorithme symétrique où la même clé secrète sert à la fois à signer et à vérifier les jetons. Il convient parfaitement aux architectures monolithiques ou aux environnements où l'émetteur et la passerelle d'API partagent un périmètre réseau sécurisé. RS256 est un algorithme asymétrique où le serveur d'authentification signe les jetons avec une clé privée, tandis que les serveurs de ressources vérifient les signatures à l'aide d'un certificat ou d'une clé publique. Cela permet aux microservices et applications tierces de valider l'authenticité des jetons sans jamais avoir accès à la clé de signature.

Un jeton JWT peut-il être modifié ou falsifié sans invalider sa signature ?▼

Non. Toute modification apportée à l'en-tête ou à la charge utile (par exemple, promouvoir le rôle d'un utilisateur de 'user' à 'admin' ou repousser la date d'expiration) altère immédiatement l'entrée cryptographique servant au calcul de l'empreinte. Sans la clé privée ou le secret partagé d'origine, un attaquant est dans l'impossibilité mathématique de générer une signature valide, et tout vérificateur conforme rejettera instantanément le jeton avec une erreur de signature invalide.

Pourquoi ne faut-il jamais stocker de données sensibles comme des mots de passe ou des cartes bancaires dans un payload JWT ?▼

Parce qu'un jeton JWT standard est uniquement signé numériquement (JWS) et non chiffré (JWE). La charge utile est simplement encodée en Base64URL, ce qui n'offre aucune confidentialité. Quiconque intercepte le jeton en transit, analyse le trafic réseau ou accède au stockage local du navigateur peut instantanément décoder la chaîne Base64URL et lire l'ensemble des claims en clair.

Que sont les claims JWT enregistrés et que signifient iat, exp et nbf ?▼

Les claims enregistrés sont des clés de métadonnées standardisées définies par la RFC 7519 : 'iat' (Issued At) indique l'horodatage Unix de création ; 'exp' (Expiration Time) définit l'instant au-delà duquel le jeton doit être rejeté ; 'nbf' (Not Before) spécifie l'heure à partir de laquelle le jeton devient valide ; 'iss' (Issuer) identifie l'émetteur du jeton ; 'sub' (Subject) désigne le sujet principal (utilisateur ou service) ; et 'aud' (Audience) identifie les destinataires cibles auxquels le jeton est réservé.

Outils et utilitaires connexes

Tous les outils →