Décodeur, Vérificateur et Générateur JWT

Recommandations connexes

Cas d'utilisation

• Décoder JWT en ligne : divisez rapidement un token lors du débogage de connexion OAuth 2.0 / OIDC pour inspecter l'algorithme du Header et les Claims du Payload
• Vérifier les signatures JWT : utilisez un Secret / clé publique pour valider les signatures de token en temps réel et décider si un 401 est 'mauvaise signature', 'expiré' ou 'discordance d'algorithme'
• Générer des JWTs de test pendant l'intégration : émettez un JWT dans le navigateur avec une paire de clés de test, sans avoir à demander au backend de modifier temporairement le code pour émettre un token
• Conversion PEM ↔ JWK : l'IdP OIDC vous a donné du JWK mais le serveur a besoin de PEM (ou vice versa) — convertissez sur place au lieu d'écrire un script OpenSSL
• Diagnostiquer 401 Unauthorized : parcourez l'expiration, la correspondance alg avec la passerelle, la correspondance de clé et le formatage PEM un par un
• Comparer RS256 vs PS256 : de nombreux fournisseurs OIDC utilisent RS256 par défaut tandis qu'AWS SigV4 préfère PS256 — changez d'algorithmes avec la même paire de clés RSA et comparez les résultats
• Apprendre le fonctionnement interne de JWT : changez l'alg, modifiez le Payload, échangez la clé dans le navigateur et regardez la signature se casser en temps réel — bien plus rapide que de lire le RFC

Fonctionnalités

• Décoder + Vérifier + Générer en un seul endroit : collez un token pour séparer Header/Payload/Signature, changez d'algorithme et de clé pour vérifier la signature, modifiez les Claims et resignez pour produire un nouveau token — couvre toute la chaîne de dépannage JWT
• 13 algorithmes pris en charge : HS256/HS384/HS512 (HMAC), RS256/RS384/RS512 (RSA-PKCS1-v1_5), ES256/ES384/ES512 (ECDSA), PS256/PS384/PS512 (RSA-PSS), EdDSA — couvre OAuth 2.0, OIDC, JWS, passerelles API et SSO d'entreprise
• Formats PEM et JWK : les clés RSA, ECDSA et Ed25519 acceptent les chaînes PEM (avec en-têtes -----BEGIN PUBLIC KEY-----) et JSON JWK (champs kid/kty/n/e) — collez directement la sortie OIDC /.well-known/jwks.json
• Multiples formes d'entrée pour le Secret HMAC : chaîne UTF-8 brute, octets hexadécimaux ou Secret encodé en Base64/Base64URL — changez en un clic, pour que 'ça ressemble au même mais la signature échoue' n'arrive jamais
• Génération automatique de paires de clés : paires de clés RSA-2048, RSA-4096, P-256, P-384 et Ed25519 générées dans le navigateur, présentées aux formats PEM et JWK pour une utilisation immédiate dans les tests
• Mise en évidence sémantique des Claims : exp / iat / nbf sont automatiquement convertis en temps lisible par l'homme avec l'état expiré / pas encore valide / émis mis en évidence ; alg / typ / kid dans le Header étiquetés individuellement
• 100% côté client, zéro téléchargement : chaque analyse, vérification et signature s'exécute via l'API Web Crypto native du navigateur — les tokens, clés et payload ne quittent jamais le navigateur, conformément au principe de sécurité de 'ne jamais coller de tokens de production dans des outils en ligne aléatoires'
• Copie en un clic : Header, Payload, Signature et le token nouvellement généré sont chacun copiables indépendamment pour la documentation, les tickets et les commandes curl

Comment utiliser

1. Collez ou tapez le token : déposez la chaîne JWT dans la zone de saisie ; l'outil sépare automatiquement Header, Payload et Signature et affiche chacun en JSON formaté
2. Sélectionnez l'algorithme : basculez entre HS256 / RS256 / ES256 / PS256 / EdDSA ; l'outil déduit de Header.alg et signale toute discordance
3. Importez une clé : collez un Secret HMAC, une chaîne PEM ou un JSON JWK ; pour les algorithmes asymétriques, cliquez sur 'Générer une paire de clés' pour obtenir une clé de test immédiatement
4. Vérifiez ou resignez : en mode Decode, vérifiez avec une clé publique et voyez '✅ signature valide / ❌ signature invalide' ; en mode Encode, modifiez les Claims et signez avec une clé privée pour produire un nouveau token

FAQ

Qu'est-ce que Décodeur, Vérificateur et Générateur JWT ?

Code Examples

const crypto = require('node:crypto')

function b64url(input) {
  return Buffer.from(input)
    .toString('base64')
    .replace(/\+/g, '-')
    .replace(/\//g, '_')
    .replace(/=+$/, '')
}

function hmacSign(data, secret) {
  return b64url(crypto.createHmac('sha256', secret).update(data).digest())
}

function sign(payload, secret) {
  const header = b64url(JSON.stringify({ alg: 'HS256', typ: 'JWT' }))
  const body = b64url(JSON.stringify(payload))
  const signature = hmacSign(`${header}.${body}`, secret)
  return `${header}.${body}.${signature}`
}

function verify(token, secret) {
  const [h, p, s] = token.split('.')
  const expected = hmacSign(`${h}.${p}`, secret)
  const a = Buffer.from(s)
  const b = Buffer.from(expected)
  return a.length === b.length && crypto.timingSafeEqual(a, b)
}

const SECRET = 'my-super-secret-key'
const payload = { userId: 42, role: 'admin', exp: Math.floor(Date.now() / 1000) + 3600 }
const token = sign(payload, SECRET)

console.log(token)
console.log(verify(token, SECRET))       // true
console.log(verify(token, 'wrong-key'))  // false

<!doctype html>
<html>
  <body>
    <pre id="out"></pre>
    <script>
      const out = document.getElementById('out')

      const b64url = buf =>
        btoa(String.fromCharCode(...new Uint8Array(buf)))
          .replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')

      const b64urlStr = str => b64url(new TextEncoder().encode(str))

      async function sign(payload, secret) {
        const header = b64urlStr(JSON.stringify({ alg: 'HS256', typ: 'JWT' }))
        const body = b64urlStr(JSON.stringify(payload))
        const data = new TextEncoder().encode(`${header}.${body}`)

        const key = await crypto.subtle.importKey(
          'raw',
          new TextEncoder().encode(secret),
          { name: 'HMAC', hash: 'SHA-256' },
          false,
          ['sign']
        )

        const sig = await crypto.subtle.sign('HMAC', key, data)
        return `${header}.${body}.${b64url(sig)}`
      }

      ;(async () => {
        const token = await sign({ user: 'alice', role: 'admin' }, 'browser-demo-secret')
        out.textContent = token
      })()
    </script>
  </body>
</html>

import { jwtVerify, importSPKI } from 'jose'
import { readFile } from 'node:fs/promises'

const token = 'eyJhbGciOiJSUzI1NiIsImtpZCI6IjEifQ.payload.signature'
const publicKeyPem = await readFile('public.pem', 'utf8')

try {
  const { payload, protectedHeader } = await jwtVerify(
    token,
    await importSPKI(publicKeyPem, 'RS256'),
    {
      issuer: 'https://idp.example.com',
      audience: 'my-app',
      algorithms: ['RS256'],     // critique : la liste blanche d'algorithmes bloque les attaques alg:none et de substitution HS256
    }
  )
  console.log('alg =', protectedHeader.alg)
  console.log('sub  =', payload.sub)
} catch (err) {
  console.error('verify failed:', err.code, err.message)
  // commun : ERR_JWT_EXPIRED / ERR_JWS_INVALID / ERR_JWS_SIGNATURE_VERIFICATION_FAILED
}

import jwt

token = 'eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjM0In0.SflKxw'

# Analyser (sans vérification de signature, regardez simplement le Header et le Payload)
print(jwt.get_unverified_header(token))
# {'alg': 'HS256', 'typ': 'JWT'}

print(jwt.decode(token, options={'verify_signature': False}))
# {'sub': '1234'}

# Vérification complète
claims = jwt.decode(
    token,
    'my-super-secret-key',
    algorithms=['HS256'],
    audience='my-app',
    issuer='my-service',
)
print(claims['sub'])

Supported Video Formats

Output Example

A real MP3 file encoded to a Data URI — copy-ready:

Header (Base64URL):  eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9
Payload(Base64URL):  eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkphbmUgRG9lIiwiaWF0IjoxNzE2MjM5MDIyfQ
Signature:           kZJfaYjK3iCkVFL5EL9zGRZ5SmD8_x2h6B5c7pVFfVGo

Header décodé:
  {
    "alg": "HS256",
    "typ": "JWT"
  }

Payload décodé:
  {
    "sub": "1234567890",
    "name": "Jane Doe",
    "iat": 1716239022        // 2024-05-20 14:23:42 UTC
  }

Privacy & Security

Cet établi JWT s'exécute à 100% dans votre navigateur, soutenu par l'API Web Crypto native du navigateur. Le token que vous collez, le Header, le Payload, la Signature, le Secret HMAC, toute clé privée RSA/ECDSA, toute paire de clés générée et chaque calcul de signature/vérification restent sur votre appareil — ils ne voyagent jamais vers un serveur, ne sont jamais journalisés, jamais analysés et jamais mis en cache. La page peut être utilisée hors ligne une fois chargée. Meilleures pratiques : ne collez jamais de tokens de production à longue durée de vie ou de clés privées de production dans aucun outil en ligne, y compris celui-ci. Cet outil est approprié pour le débogage, les tests d'intégration, l'apprentissage et la création de tokens de test — les secrets de production et les clés privées doivent être gérés dans un environnement contrôlé et local.

Authoritative References

• IETFRFC 7519: JSON Web Token (JWT)
• IETFRFC 7515: JSON Web Signature (JWS)
• IETFRFC 7517: JSON Web Key (JWK)
• Auth0JWT.io — débogueur officiel et index des bibliothèques
• OWASPOWASP JSON Web Token Cheat Sheet
• IETFAperçu du groupe de travail JOSE

Troubleshooting