Decodificador, Verificador i Generador JWT

Relacionats

Casos d'ús

• Decodifica JWT en línia: separa ràpidament un token durant la depuració d'inici de sessió OAuth 2.0 / OIDC per inspeccionar l'algoritme del Header i els Claims del Payload
• Verifica signatures JWT: utilitza un Secret / clau pública per validar signatures de tokens en temps real i decidir si un 401 és 'signatura incorrecta', 'expirat' o 'incompatibilitat d'algoritme'
• Genera JWTs de prova durant la integració: emet un JWT al navegador amb un parell de claus de prova, sense necessitat de demanar al backend que canviï temporalment el codi per generar un token
• Conversió PEM ↔ JWK: l'IdP OIDC et va donar JWK però el servidor necessita PEM (o viceversa) — converteix al lloc en lloc d'escriure un script OpenSSL
• Diagnostica 401 Unauthorized: revisa pas a pas l'expiració, la coincidència d'algoritme amb la passarel·la, la coincidència de claus i el format PEM
• Compara RS256 vs PS256: molts proveïdors OIDC utilitzen RS256 per defecte mentre que AWS SigV4 prefereix PS256 — canvia d'algoritme amb el mateix parell de claus RSA i compara resultats
• Aprèn els internals de JWT: canvia l'algoritme, edita el Payload, intercanvia la clau al navegador i observa com es trenca la signatura en temps real — molt més ràpid que llegir el RFC

Característiques

• Decodifica + Verifica + Genera en un sol lloc: enganxa un token per separar Header/Payload/Signature, canvia l'algoritme i la clau per verificar la signatura, edita Claims i torna a signar per produir un nou token — cobreix tota la cadena de resolució de problemes JWT
• Tots els 13 algoritmes suportats: HS256/HS384/HS512 (HMAC), RS256/RS384/RS512 (RSA-PKCS1-v1_5), ES256/ES384/ES512 (ECDSA), PS256/PS384/PS512 (RSA-PSS), EdDSA — cobreix OAuth 2.0, OIDC, JWS, passarel·les API i SSO empresarial
• Formats PEM i JWK: les claus RSA, ECDSA i Ed25519 accepten cadenes PEM (amb capçaleres -----BEGIN PUBLIC KEY-----) i JSON JWK (camps kid/kty/n/e) — deixa anar directament una sortida OIDC /.well-known/jwks.json
• Múltiples formes d'entrada de secret HMAC: cadena UTF-8 crua, bytes hexadecimals o secret codificat en Base64/Base64URL — canvia amb un clic, perquè 'sembla igual però la signatura falla' mai passi
• Generació automàtica de parells de claus: parells de claus RSA-2048, RSA-4096, P-256, P-384 i Ed25519 generats al navegador, presentats en formats PEM i JWK per a ús immediat en proves
• Ressaltat semàntic de Claims: exp / iat / nbf convertits automàticament a temps llegible per humans amb estat expirat / encara no vàlid / emès ressaltat; alg / typ / kid al Header etiquetats individualment
• 100% client-side, zero càrrega: cada anàlisi, verificació i signatura s'executa a través de la Web Crypto API nativa del navegador — els tokens, claus i payload mai surten del navegador, coincident amb el principi de seguretat de 'mai enganxar tokens de producció en eines en línia aleatòries'
• Còpia amb un clic: Header, Payload, Signature i el token generat recentment són cadascun copiables independentment per a documentació, tiquets i comandes curl

Com usar-ho

1. Enganxa o escriu el token: deixa la cadena JWT al quadre d'entrada; l'eina separa automàticament Header, Payload i Signature i mostra cadascun amb format JSON
2. Selecciona l'algoritme: canvia entre HS256 / RS256 / ES256 / PS256 / EdDSA; l'eina infereix del Header.alg i marca qualsevol incompatibilitat
3. Importa una clau: enganxa un secret HMAC, una cadena PEM o un JSON JWK; per a algoritmes asimètrics, fes clic a 'Generar parell de claus' per obtenir una clau de prova immediatament
4. Verifica o torna a signar: en mode Decode verifica amb una clau pública i veu '✅ signatura vàlida / ❌ signatura invàlida'; en mode Encode edita Claims i signa amb una clau privada per produir un nou token

Preguntes freqients

Què és el Decodificador, Verificador i Generador 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'],     // crític: la llista blanca d'algoritmes bloqueja atacs alg:none i substitució HS256
    }
  )
  console.log('alg =', protectedHeader.alg)
  console.log('sub  =', payload.sub)
} catch (err) {
  console.error('verify failed:', err.code, err.message)
  // comú: ERR_JWT_EXPIRED / ERR_JWS_INVALID / ERR_JWS_SIGNATURE_VERIFICATION_FAILED
}

import jwt

token = 'eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjM0In0.SflKxw'

# Analitza (sense comprovació de signatura, només mira Header i Payload)
print(jwt.get_unverified_header(token))
# {'alg': 'HS256', 'typ': 'JWT'}

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

# Verificació 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 descodificat:
  {
    "alg": "HS256",
    "typ": "JWT"
  }

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

Privacy & Security

Aquest banc de treball JWT s'executa 100% al teu navegador, amb el suport de la Web Crypto API nativa del navegador. El token que enganxes, el Header, el Payload, la Signature, el Secret HMAC, qualsevol clau privada RSA/ECDSA, qualsevol parell de claus generat, i cada càlcul de signatura/verificació es queden al teu dispositiu — mai viatgen a un servidor, mai es registren, mai s'analitzen i mai es guarden en memòria cau. La pàgina es pot utilitzar fora de línia un cop carregada. Millor pràctica: mai enganxis tokens de producció de llarga durada o claus privades de producció a cap eina en línia, inclosa aquesta. Aquesta eina és adequada per a depuració, proves d'integració, aprenentatge i generació de tokens de prova — els secrets de producció i les claus privades s'han de gestionar en un entorn local controlat.

Authoritative References

• IETFRFC 7519: JSON Web Token (JWT)
• IETFRFC 7515: JSON Web Signature (JWS)
• IETFRFC 7517: JSON Web Key (JWK)
• Auth0JWT.io — depurador oficial i índex de biblioteques
• OWASPOWASP JSON Web Token Cheat Sheet
• IETFVisió general del grup de treball JOSE

Troubleshooting