Encodeur & Générateur JWT

Qu'est-ce qu'un encodeur JWT ?

// Sign a JWT in the browser with the Web Crypto API (HS256)
async function encodeJwt(payload, secret) {
  const b64url = (bytes) =>
    btoa(String.fromCharCode(...new Uint8Array(bytes)))
      .replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
  const enc = (obj) =>
    b64url(new TextEncoder().encode(JSON.stringify(obj)));

  const header = { alg: 'HS256', typ: 'JWT' };
  const signingInput = `${enc(header)}.${enc(payload)}`;

  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, new TextEncoder().encode(signingInput));

  return `${signingInput}.${b64url(sig)}`;
}

const token = await encodeJwt({ sub: 'user_123', exp: 1999999999 }, 'my-secret');
// → eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyXzEyMyIsImV4cCI6MTk5OTk5OTk5OX0....

Fonctionnalités clés

Exemples

{
  "sub": "user_123",
  "name": "Alice",
  "role": "admin",
  "iat": 1715000000,
  "exp": 1999999999
}
secret: a-string-secret-at-least-256-bits-long

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyXzEyMyIsIm5hbWUiOiJBbGljZSIsInJvbGUiOiJhZG1pbiIsImlhdCI6MTcxNTAwMDAwMCwiZXhwIjoxOTk5OTk5OTk5fQ.<HMAC-SHA256 signature>

{
  "iss": "https://auth.example.com",
  "aud": "api.example.com",
  "sub": "90087165",
  "scope": "read:user write:post",
  "iat": 1715000000,
  "exp": 1999999999
}
private key: -----BEGIN PRIVATE KEY----- (PKCS8)

eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJodHRwczovL2F1dGguZXhhbXBsZS5jb20iLCJhdWQiOiJhcGkuZXhhbXBsZS5jb20iLCJzdWIiOiI5MDA4NzE2NSIsInNjb3BlIjoicmVhZDp1c2VyIHdyaXRlOnBvc3QiLCJpYXQiOjE3MTUwMDAwMDAsImV4cCI6MTk5OTk5OTk5OX0.<RSA signature>

{
  "sub": "device-42",
  "iat": 1715000000,
  "exp": 1999999999
}
private key: -----BEGIN PRIVATE KEY----- (P-256)

eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJkZXZpY2UtNDIiLCJpYXQiOjE3MTUwMDAwMDAsImV4cCI6MTk5OTk5OTk5OX0.<ECDSA P-256 signature>

Comment utiliser

1. 1

   Modifiez les réclamations de la charge utile

   Écrivez les réclamations dont votre jeton a besoin en JSON dans l'éditeur de charge utile. Utilisez les puces de réclamation rapide pour insérer iss, sub, aud, iat, nbf ou une exp d'une heure sans taper d'horodatages.

2. 2

   Choisissez l'algorithme & saisissez la clé

   Choisissez un algorithme de signature. Pour HS256/384/512, saisissez un secret ; pour les algorithmes RS, PS ou ES, collez une clé privée PEM PKCS8. Le jeton est signé localement à mesure que vous tapez.

3. 3

   Copiez le JWT signé

   Le jeton signé apparaît instantanément, codé par couleur par segment. Cliquez sur Copier pour l'insérer dans un en-tête Authorization, une commande curl ou un test. Votre clé n'a jamais quitté votre navigateur.

Common Errors

secret: "password123"  // guessable, low entropy

secret: base64(crypto.randomBytes(32))  // >=256 random bits

{ "sub": "user_123", "role": "admin" }  // no exp

{ "sub": "user_123", "role": "admin", "exp": 1715003600 }

-----BEGIN RSA PRIVATE KEY-----  // PKCS1, not supported

openssl pkcs8 -topk8 -nocrypt -in pkcs1.pem -out pkcs8.pem

Cas d'usage courants

Générer des jetons pour les tests d'API

Générez un jeton Bearer HS256 en quelques secondes pour exercer un point d'accès protégé depuis curl, Postman ou un test d'intégration.

Reproduire des jetons OAuth & OIDC

Construisez un jeton RS256 ou ES256 qui reflète celui qu'émet votre serveur d'autorisation, afin de déboguer les incohérences de réclamation et d'audience.

Créer des fixtures de test

Produisez des jetons signés déterministes pour les tests unitaires et d'intégration sans mettre en place un serveur d'authentification complet.

Déboguer les échecs d'autorisation

Recréez la forme du jeton d'un client — émetteur, audience, scope, expiration — pour trouver pourquoi un backend le rejette.

Valider un vérificateur

Signez des jetons avec une clé connue pour confirmer que votre middleware de vérification accepte les jetons valides et rejette ceux qui ont été altérés.

Prototyper des flux d'authentification

Remettez à vos coéquipiers des jetons prêts à l'emploi pendant la mise en place d'une nouvelle connexion, d'un microservice ou d'un appel de service à service.

Détails techniques

Conforme aux RFC 7519 / 7515 / 7518

Produit des jetons JWS conformes à la RFC 7519 (JWT), à la RFC 7515 (JWS) et à la RFC 7518 (JWA), avec les identifiants d'algorithme enregistrés dans l'en-tête.

Signature native Web Crypto

Signe via crypto.subtle pour HMAC, RSASSA-PKCS1-v1_5, RSA-PSS et ECDSA. Les signatures ECDSA sont émises sous forme de r||s brut, exactement comme JWS l'exige.

Base64URL, zéro dépendance

L'en-tête et la charge utile sont encodés en Base64URL avec l'alphabet sûr pour les URL (RFC 4648), sans remplissage. Aucune bibliothèque externe, aucun appel réseau, aucune télémétrie.

Bonnes pratiques

Toujours définir une expiration

Incluez une réclamation exp afin qu'un jeton ayant fuité cesse d'être valide. Des durées de vie courtes réduisent le rayon d'impact — des minutes pour les jetons d'accès, pas des jours.

Garder les secrets hors de la charge utile

Une charge utile JWT est lisible par quiconque possède le jeton. Mettez-y des identifiants et des scopes ; jamais de mots de passe, de clés d'API ni d'informations personnelles complètes.

Signer côté serveur en production

Utilisez cet outil pour les tests et le débogage. Dans les vrais systèmes, signez les jetons sur le serveur avec une bibliothèque maintenue et une clé issue de votre gestionnaire de secrets.

Questions fréquentes