Decodificatore, Verificatore e Generatore JWT

Raccomandazioni correlate

Casi d'uso

• Decodificare JWT online: dividi rapidamente un token durante il debug dell'accesso OAuth 2.0 / OIDC per ispezionare l'algoritmo dell'Header e i Claims del Payload
• Verificare le firme JWT: usa un Secret / chiave pubblica per convalidare le firme dei token in tempo reale e decidere se un 401 è 'firma errata', 'scaduto' o 'mancata corrispondenza dell'algoritmo'
• Generare JWT di test durante l'integrazione: emetti un JWT nel browser con una coppia di chiavi di test, senza dover chiedere al backend di modificare temporaneamente il codice per emettere un token
• Conversione PEM ↔ JWK: l'IdP OIDC ti ha dato JWK ma il server ha bisogno di PEM (o viceversa) — converti sul posto invece di scrivere uno script OpenSSL
• Diagnosticare 401 Unauthorized: scorri la scadenza, la corrispondenza alg con il gateway, la corrispondenza delle chiavi e la formattazione PEM uno alla volta
• Confrontare RS256 vs PS256: molti provider OIDC usano RS256 per impostazione predefinita mentre AWS SigV4 preferisce PS256 — cambia algoritmi con la stessa coppia di chiavi RSA e confronta i risultati
• Imparare il funzionamento interno di JWT: cambia l'alg, modifica il Payload, scambia la chiave nel browser e guarda la firma rompersi in tempo reale — molto più veloce che leggere l'RFC

Funzionalità

• Decodificare + Verificare + Generare in un unico posto: incolla un token per separare Header/Payload/Signature, cambia algoritmo e chiave per verificare la firma, modifica i Claims e firma di nuovo per produrre un nuovo token — copre l'intera catena di risoluzione dei problemi JWT
• 13 algoritmi supportati: HS256/HS384/HS512 (HMAC), RS256/RS384/RS512 (RSA-PKCS1-v1_5), ES256/ES384/ES512 (ECDSA), PS256/PS384/PS512 (RSA-PSS), EdDSA — copre OAuth 2.0, OIDC, JWS, gateway API e SSO aziendale
• Formati PEM e JWK: le chiavi RSA, ECDSA e Ed25519 accettano stringhe PEM (con intestazioni -----BEGIN PUBLIC KEY-----) e JSON JWK (campi kid/kty/n/e) — incolla direttamente l'output OIDC /.well-known/jwks.json
• Molteplici forme di input per il Secret HMAC: stringa UTF-8 grezza, byte esadecimali o Secret codificato in Base64/Base64URL — cambia con un clic, così 'sembra uguale ma la firma fallisce' non accade mai
• Generazione automatica di coppie di chiavi: coppie di chiavi RSA-2048, RSA-4096, P-256, P-384 e Ed25519 generate nel browser, presentate in formati PEM e JWK per uso immediato nei test
• Evidenziazione semantica dei Claims: exp / iat / nbf vengono automaticamente convertiti in tempo leggibile dall'uomo con lo stato scaduto / non ancora valido / emesso evidenziato; alg / typ / kid nell'Header etichettati individualmente
• 100% lato client, zero caricamenti: ogni analisi, verifica e firma viene eseguita tramite l'API Web Crypto nativa del browser — token, chiavi e payload non lasciano mai il browser, in linea con il principio di sicurezza di 'non incollare mai token di produzione in strumenti online sconosciuti'
• Copia con un clic: Header, Payload, Signature e il token appena generato sono ciascuno copiabili indipendentemente per documentazione, ticket e comandi curl

Come utilizzare

1. Incolla o digita il token: inserisci la stringa JWT nella casella di input; lo strumento separa automaticamente Header, Payload e Signature e visualizza ciascuno come JSON formattato
2. Seleziona l'algoritmo: passa tra HS256 / RS256 / ES256 / PS256 / EdDSA; lo strumento deduce da Header.alg e segnala qualsiasi mancata corrispondenza
3. Importa una chiave: incolla un Secret HMAC, una stringa PEM o un JSON JWK; per gli algoritmi asimmetrici, fai clic su 'Genera coppia di chiavi' per ottenere immediatamente una chiave di test
4. Verifica o firma di nuovo: in modalità Decode verifica con una chiave pubblica e vedi '✅ firma valida / ❌ firma non valida'; in modalità Encode modifica i Claims e firma con una chiave privata per produrre un nuovo token

Domande frequenti

Cos'è il Decodificatore, Verificatore e Generatore 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'],     // critico: la whitelist di algoritmi blocca gli attacchi alg:none e di sostituzione HS256
    }
  )
  console.log('alg =', protectedHeader.alg)
  console.log('sub  =', payload.sub)
} catch (err) {
  console.error('verify failed:', err.code, err.message)
  // comune: ERR_JWT_EXPIRED / ERR_JWS_INVALID / ERR_JWS_SIGNATURE_VERIFICATION_FAILED
}

import jwt

token = 'eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjM0In0.SflKxw'

# Analizza (senza verifica della firma, guarda solo Header e Payload)
print(jwt.get_unverified_header(token))
# {'alg': 'HS256', 'typ': 'JWT'}

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

# Verifica completa
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 decodificato:
  {
    "alg": "HS256",
    "typ": "JWT"
  }

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

Privacy & Security

Questo banco di lavoro JWT viene eseguito al 100% nel tuo browser, supportato dall'API Web Crypto nativa del browser. Il token che incolli, l'Header, il Payload, la Signature, il Secret HMAC, qualsiasi chiave privata RSA/ECDSA, qualsiasi coppia di chiavi generata e ogni calcolo di firma/verifica rimangono sul tuo dispositivo — non viaggiano mai verso un server, non vengono mai registrati, mai analizzati e mai memorizzati nella cache. La pagina può essere usata offline una volta caricata. Migliori pratiche: non incollare mai token di produzione a lunga durata o chiavi private di produzione in nessuno strumento online, incluso questo. Questo strumento è appropriato per debug, test di integrazione, apprendimento e creazione di token di test — i secret di produzione e le chiavi private devono essere gestiti in un ambiente controllato e locale.

Authoritative References

• IETFRFC 7519: JSON Web Token (JWT)
• IETFRFC 7515: JSON Web Signature (JWS)
• IETFRFC 7517: JSON Web Key (JWK)
• Auth0JWT.io — debugger ufficiale e indice delle librerie
• OWASPOWASP JSON Web Token Cheat Sheet
• IETFPanoramica del gruppo di lavoro JOSE

Troubleshooting