Codificador y Generador JWT

¿Qué es un Codificador 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....

Características Clave

Ejemplos

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

Cómo Usar

1. 1

   Edita las Reclamaciones de la Carga Útil

   Escribe las reclamaciones que tu token necesita como JSON en el editor de carga útil. Usa los chips de reclamación rápida para insertar iss, sub, aud, iat, nbf o una exp de una hora sin escribir marcas de tiempo.

2. 2

   Elige el Algoritmo e Introduce la Clave

   Elige un algoritmo de firma. Para HS256/384/512 introduce un secreto; para los algoritmos RS, PS o ES pega una clave privada PKCS8 PEM. El token se firma localmente mientras escribes.

3. 3

   Copia el JWT Firmado

   El token firmado aparece al instante, codificado por color por segmento. Haz clic en Copiar para llevarlo a un encabezado Authorization, un comando curl o una prueba. Tu clave nunca salió de tu navegador.

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

Casos de Uso Comunes

Genera Tokens para Pruebas de API

Genera un token Bearer HS256 en segundos para ejercitar un endpoint protegido desde curl, Postman o una prueba de integración.

Reproduce Tokens OAuth y OIDC

Construye un token RS256 o ES256 que refleje lo que emite tu servidor de autorización, para depurar desajustes de reclamación y audiencia.

Crea Fixtures de Prueba

Produce tokens firmados deterministas para pruebas unitarias y de integración sin levantar un servidor de autenticación completo.

Depura Fallos de Autorización

Recrea la forma del token de un cliente — emisor, audiencia, scope, expiración — para encontrar por qué un backend lo rechaza.

Valida un Verificador

Firma tokens con una clave conocida para confirmar que tu middleware de verificación acepta tokens válidos y rechaza los manipulados.

Prototipa Flujos de Autenticación

Entrega a tus compañeros tokens listos para usar mientras configuráis un nuevo login, microservicio o llamada de servicio a servicio.

Detalles Técnicos

Conforme con RFC 7519 / 7515 / 7518

Produce tokens JWS conformes a RFC 7519 (JWT), RFC 7515 (JWS) y RFC 7518 (JWA), con los identificadores de algoritmo registrados en el encabezado.

Firma Nativa con Web Crypto

Firma mediante crypto.subtle para HMAC, RSASSA-PKCS1-v1_5, RSA-PSS y ECDSA. Las firmas ECDSA se emiten como r||s en bruto, exactamente como exige JWS.

Base64URL, Cero Dependencias

El encabezado y la carga útil se codifican en Base64URL con el alfabeto seguro para URL (RFC 4648), sin relleno. Sin bibliotecas externas, sin llamadas de red, sin telemetría.

Mejores Prácticas

Establece Siempre una Expiración

Incluye una reclamación exp para que un token filtrado deje de ser válido. Las vidas cortas reducen el radio de impacto — minutos para tokens de acceso, no días.

Mantén los Secretos Fuera de la Carga Útil

Una carga útil JWT es legible por cualquiera con el token. Pon identificadores y scopes en ella; nunca contraseñas, claves API o PII completa.

Firma del Lado del Servidor en Producción

Usa esta herramienta para pruebas y depuración. En sistemas reales, firma tokens en el servidor con una biblioteca mantenida y una clave de tu gestor de secretos.

Preguntas Frecuentes