Encodeur JWT

Qu'est-ce que l'encodage JWT ?

L'encodage JWT est le processus de création d'un JSON Web Token — une chaîne compacte et sécurisée pour les URL qui porte un ensemble de revendications signées avec une clé cryptographique. Le résultat est un token en trois parties (en-tête.charge.signature) défini par RFC 7519 que les serveurs peuvent vérifier sans maintenir l'état de la session. L'encodage JWT en ligne te permet de créer et de signer des tokens directement dans ton navigateur pour les tests et le développement.

L'en-tête déclare l'algorithme de signature (par exemple HS256) et le type de token. La charge utile contient des revendications — des paires clé-valeur comme le sujet (sub), le temps d'expiration (exp) et toute donnée personnalisée dont ton application a besoin. Les deux parties sont sérialisées en JSON, puis encodées en base64url. La signature est calculée sur l'en-tête et la charge codifiés à l'aide d'une clé secrète, liant les trois segments ensemble.

Contrairement aux cookies de session, les JWT sont autonomes : le vérificateur n'a pas besoin d'interroger une base de données ou d'appeler un service externe. Cela rend l'authentification basée sur JWT populaire dans les API REST, les microservices et les applications monopage où l'autorisation sans état réduit la latence et simplifie la scalabilité horizontale.

Pourquoi utiliser un encodeur JWT ?

La génération manuelle de JWT nécessite l'encodage base64url, la sérialisation JSON et le calcul HMAC. Cet outil gère les trois étapes instantanément pour que tu puisses te concentrer sur l'obtention des bonnes revendications.

Cas d'usage de l'encodeur JWT

HS256 vs HS384 vs HS512 : Comparaison des algorithmes HMAC

Les trois algorithmes utilisent HMAC (Hash-based Message Authentication Code) avec un secret partagé. La différence réside dans la fonction de hachage sous-jacente, qui affecte la longueur de la signature et la marge de sécurité. Pour la plupart des applications, HS256 offre une sécurité suffisante. Choisis HS384 ou HS512 lorsque les exigences de conformité (par exemple FIPS-140) exigent un hachage plus fort ou lorsque tes tokens portent des décisions d'autorisation de haute valeur.

Référence des revendications JWT standard

RFC 7519 définit sept revendications enregistrées. Aucune n'est obligatoire, mais les utiliser correctement améliore l'interopérabilité et la sécurité. La revendication exp est particulièrement importante — les tokens sans expiration sont valides indéfiniment si le secret n'est pas rotaté.

Encodage JWT dans le code

Ces exemples montrent comment créer et signer les JWT par programmation. Chaque extrait produit un token valide signé avec HS256. Pour les systèmes de production, définissez toujours la revendication exp et utilisez un secret cryptographiquement aléatoire d'au moins 256 bits.

async function signJWT(payload, secret, alg = 'HS256') {
  const header = { alg, typ: 'JWT' }
  const enc = new TextEncoder()

  // Base64url encode header and payload
  const b64url = (obj) =>
    btoa(JSON.stringify(obj)).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')

  const h = b64url(header)
  const p = b64url(payload)

  // Sign with HMAC-SHA256
  const key = await crypto.subtle.importKey(
    'raw', enc.encode(secret),
    { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']
  )
  const sig = await crypto.subtle.sign('HMAC', key, enc.encode(`${h}.${p}`))
  const s = btoa(String.fromCharCode(...new Uint8Array(sig)))
    .replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')

  return `${h}.${p}.${s}`
}

// Usage
const token = await signJWT(
  { sub: 'user-123', name: 'Alice', iat: Math.floor(Date.now() / 1000) },
  'your-256-bit-secret'
)
// → "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOi..."

import jwt
import time

payload = {
    "sub": "user-123",
    "name": "Alice",
    "iat": int(time.time()),
    "exp": int(time.time()) + 3600,  # expires in 1 hour
}

# Sign with HS256 (default)
token = jwt.encode(payload, "your-256-bit-secret", algorithm="HS256")
# → "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOi..."

# Verify and decode
decoded = jwt.decode(token, "your-256-bit-secret", algorithms=["HS256"])
# → {"sub": "user-123", "name": "Alice", "iat": 1717200000, "exp": 1717203600}

const jwt = require('jsonwebtoken')

const payload = {
  sub: 'user-123',
  name: 'Alice',
  role: 'admin',
}

// Sign — iat is added automatically
const token = jwt.sign(payload, 'your-256-bit-secret', {
  algorithm: 'HS256',
  expiresIn: '1h',    // sets exp claim
  issuer: 'auth.example.com',  // sets iss claim
})

// Verify
const decoded = jwt.verify(token, 'your-256-bit-secret')
// → { sub: 'user-123', name: 'Alice', role: 'admin', iat: ..., exp: ... }

package main

import (
    "fmt"
    "time"
    "github.com/golang-jwt/jwt/v5"
)

func main() {
    claims := jwt.MapClaims{
        "sub":  "user-123",
        "name": "Alice",
        "iat":  time.Now().Unix(),
        "exp":  time.Now().Add(time.Hour).Unix(),
    }

    token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
    signed, _ := token.SignedString([]byte("your-256-bit-secret"))
    fmt.Println(signed)
    // → eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOi...
}

Questions fréquemment posées