Codificatore e Generatore JWT

Cos'è un codificatore 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....

Caratteristiche principali

Esempi

{
  "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>

Come si usa

1. 1

   Modifica le attestazioni del payload

   Scrivi come JSON le attestazioni che il tuo token richiede nell'editor del payload. Usa i chip per le attestazioni rapide per inserire iss, sub, aud, iat, nbf o un exp di un'ora senza digitare timestamp.

2. 2

   Scegli l'algoritmo e inserisci la chiave

   Scegli un algoritmo di firma. Per HS256/384/512 inserisci un segreto; per gli algoritmi RS, PS o ES incolla una chiave privata PEM PKCS8. Il token viene firmato localmente mentre digiti.

3. 3

   Copia il JWT firmato

   Il token firmato appare all'istante, evidenziato a colori per segmento. Clicca Copia per inserirlo in un header Authorization, un comando curl o un test. La tua chiave non ha mai lasciato il browser.

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

Casi d'uso comuni

Genera token per il test delle API

Genera un Bearer token HS256 in pochi secondi per esercitare un endpoint protetto da curl, Postman o un test di integrazione.

Riproduci token OAuth e OIDC

Costruisci un token RS256 o ES256 che rispecchi ciò che emette il tuo server di autorizzazione, così puoi fare il debug di mismatch di attestazioni e audience.

Crea fixture di test

Produci token firmati deterministici per test unitari e di integrazione senza dover avviare un server di autenticazione completo.

Debug dei fallimenti di autorizzazione

Ricrea la forma del token di un cliente — issuer, audience, scope, scadenza — per scoprire perché un backend lo rifiuta.

Convalida un verificatore

Firma token con una chiave nota per confermare che il tuo middleware di verifica accetti i token validi e rifiuti quelli manomessi.

Prototipa i flussi di autenticazione

Consegna ai colleghi token pronti all'uso mentre allestisci un nuovo login, un microservizio o una chiamata service-to-service.

Dettagli tecnici

Conforme a RFC 7519 / 7515 / 7518

Produce token JWS conformi a RFC 7519 (JWT), RFC 7515 (JWS) e RFC 7518 (JWA), con gli identificatori di algoritmo registrati nell'intestazione.

Firma nativa con Web Crypto

Firma tramite crypto.subtle per HMAC, RSASSA-PKCS1-v1_5, RSA-PSS ed ECDSA. Le firme ECDSA vengono emesse come r||s grezzo, esattamente come richiede JWS.

Base64URL, zero dipendenze

Intestazione e payload sono codificati in Base64URL con l'alfabeto URL-safe (RFC 4648), senza padding. Nessuna libreria esterna, nessuna chiamata di rete, nessuna telemetria.

Buone pratiche

Imposta sempre una scadenza

Includi un'attestazione exp così un token trapelato smette di essere valido. I tempi di vita brevi riducono il raggio d'azione — minuti per gli access token, non giorni.

Tieni i segreti fuori dal payload

Un payload JWT è leggibile da chiunque abbia il token. Metti identificatori e scope al suo interno; mai password, chiavi API o PII completi.

Firma lato server in produzione

Usa questo strumento per test e debug. Nei sistemi reali, firma i token sul server con una libreria mantenuta e una chiave presa dal tuo gestore di segreti.

Domande frequenti