Herramientas mencionadas en este artículo
Abre la herramienta en el navegador mientras lees y prueba el flujo al instante.

Por qué la seguridad de JWT merece una atención cuidadosa
JWT es uno de los mecanismos de seguridad que peor se implementan en el desarrollo web. Las bibliotecas facilitan conseguir que algo funcione: los tokens se emiten, los tokens se verifican y todo parece ir bien. Los problemas aparecen después: en una auditoría de seguridad, durante un incidente o cuando un atacante explota una configuración errónea sutil.
Esta guía repasa los vectores de ataque conocidos, cómo funciona la distribución de claves mediante JWKS y una lista de comprobación práctica para los despliegues en producción.
Repaso rápido: qué es un JWT
Un JWT (JSON Web Token) consta de tres partes codificadas en Base64Url y separadas por puntos:
header.payload.signature
- Header: especifica el algoritmo (
alg) y el tipo de token. - Payload: contiene los claims: datos sobre el sujeto y metadatos.
- Signature: prueba criptográfica de que la cabecera y el payload no han sido manipulados.
El payload está codificado, no cifrado. Cualquiera que intercepte un JWT puede leer el payload. La firma solo demuestra la integridad; no proporciona confidencialidad.
Vector de ataque 1: el ataque alg: none
La especificación de JWT permitía originalmente el valor de algoritmo "none", lo que significa que el token no lleva firma. Algunas de las primeras implementaciones lo aceptaban sin comprobar si había una clave, lo que permitía a los atacantes falsificar tokens con payloads arbitrarios.
Escenario de ataque:
- El atacante intercepta un JWT legítimo.
- El atacante decodifica la cabecera y el payload (decodificación Base64Url, sin necesidad de clave).
- El atacante modifica el payload:
"role": "admin". - El atacante vuelve a codificarlo con
"alg": "none"y envía un segmento de firma vacío. - El servidor vulnerable acepta el token.
Defensa:
// Biblioteca jose: lista de algoritmos permitidos explícita
import * as jose from 'jose';
const { payload } = await jose.jwtVerify(token, secret, {
algorithms: ['HS256'], // nunca incluyas 'none'
});
No confíes nunca en el algoritmo indicado en el propio token para decidir cuál usar en la verificación. El algoritmo debe imponerse en el servidor.
Vector de ataque 2: confusión de algoritmos (RS256 → HS256)
El JWT asimétrico usa una clave privada para firmar y una clave pública para verificar. Algunas implementaciones vulnerables determinan el algoritmo de verificación leyendo el campo alg de la cabecera del JWT, el campo que controla el atacante.
Escenario de ataque (servidores con clave pública):
- El servidor usa normalmente RS256. Firma con una clave privada y los clientes verifican con la clave pública.
- El atacante conoce la clave pública del servidor (es pública, al fin y al cabo).
- El atacante crea un JWT con
"alg": "HS256". - El atacante firma el JWT con HMAC-SHA256 usando la clave pública como secreto.
- El servidor vulnerable lee
alg: HS256de la cabecera, cambia a la verificación HMAC y usa la clave pública como secreto HMAC, verificando sin saberlo el token falsificado del atacante.
Defensa: fija en el código el algoritmo esperado en el servidor. No confíes nunca en el claim alg para elegir el método de verificación:
// Exige RS256 de forma explícita: ignora el claim alg del token
import * as jose from 'jose';
const publicKey = await jose.importSPKI(publicKeyPem, 'RS256');
const { payload } = await jose.jwtVerify(token, publicKey, {
algorithms: ['RS256'],
});
Vector de ataque 3: secretos débiles o expuestos
Con HS256 (HMAC simétrico) se usa el mismo secreto para firmar y verificar. Si ese secreto es:
- Corto (menos de 32 bytes)
- Predecible (por ejemplo, la palabra “secret”)
- Está escrito en el código fuente y este es visible públicamente
…un atacante puede obtenerlo por fuerza bruta o adivinarlo. Una vez que tiene el secreto, puede falsificar cualquier JWT que quiera.
Defensa:
- Usa un secreto aleatorio criptográficamente seguro de al menos 256 bits (32 bytes).
- Guarda los secretos en variables de entorno o en un gestor de secretos (AWS Secrets Manager, HashiCorp Vault).
- No subas nunca secretos al control de versiones.
# Genera un secreto fuerte (Linux/Mac)
openssl rand -base64 32
# → "K8aJz3mP9xQrTvN2wY5oHiE7uLbCdF1s"
Vector de ataque 4: validación de claims omitida
Emitir y verificar la firma no basta. Una firma válida no significa que el token deba aceptarse para esta petición:
| Claim | Ataque si no se valida |
|---|---|
exp |
Se aceptan indefinidamente tokens caducados |
nbf |
Se acepta el token antes de su momento de activación previsto |
iss |
Se acepta un token emitido por otro servicio |
aud |
El Servicio B acepta un token destinado al Servicio A |
Defensa: valida todos los claims relevantes:
const { payload } = await jose.jwtVerify(token, secret, {
issuer: 'https://auth.example.com',
audience: 'https://api.example.com',
// exp y nbf los valida automáticamente jose
});
Gestión de claves con JWKS
En los sistemas de producción, sobre todo los que tienen varios servicios o integraciones de terceros, los secretos simétricos compartidos se vuelven ingobernables. Todo servicio que deba verificar tokens tiene que conocer el secreto, lo que crea una gran superficie de ataque.
JWKS (JSON Web Key Set) lo resuelve con criptografía asimétrica:
- El servidor de autorización genera un par de claves (privada y pública).
- La clave privada permanece en el servidor de autorización y se usa para firmar los JWT.
- La clave pública se publica en una URL conocida, el endpoint JWKS, en un formato JSON estandarizado.
- Cualquier servicio puede verificar los JWT obteniendo la clave pública del endpoint JWKS.
La cabecera del JWT incluye un claim kid (Key ID) que indica al verificador qué clave del JWKS debe usar:
{
"alg": "RS256",
"typ": "JWT",
"kid": "2026-01-key"
}
Un documento JWKS tiene este aspecto:
{
"keys": [
{
"kty": "RSA",
"use": "sig",
"alg": "RS256",
"kid": "2026-01-key",
"n": "0vx7agoebGcQSuuPiLJXZptN...",
"e": "AQAB"
}
]
}
Ventajas de JWKS:
- Rotación de claves: añade una clave nueva, espera a que caduquen los tokens antiguos y retira la clave vieja, sin reiniciar servicios ni distribuir secretos.
- Sin compartir secretos: los servicios solo necesitan la clave pública. Si se compromete un servicio de verificación, no se compromete la capacidad de firmar.
- Compatibilidad con varios emisores: verifica tokens de varios proveedores (por ejemplo, Auth0, Okta o tu propio servicio) consultando varios endpoints JWKS.
Obtención y caché de JWKS:
import * as jose from 'jose';
// el cliente JWKS de jose guarda las claves en caché y las actualiza ante un kid desconocido
const JWKS = jose.createRemoteJWKSet(
new URL('https://auth.example.com/.well-known/jwks.json')
);
const { payload } = await jose.jwtVerify(token, JWKS, {
issuer: 'https://auth.example.com',
audience: 'https://api.example.com',
});
Estrategias de revocación de tokens
Los JWT no tienen estado: una vez emitidos, son válidos hasta que caducan. Eso plantea un reto: ¿qué ocurre si necesitas invalidar un token de inmediato (por ejemplo, tras un cierre de sesión, un cambio de contraseña o el compromiso de una cuenta)?
Estrategia 1: caducidad corta + tokens de renovación
- Los tokens de acceso caducan en 15–60 minutos.
- Los tokens de renovación (guardados como cookies
HttpOnly) duran de 7 a 30 días. - La revocación solo debe hacerse a nivel del token de renovación.
Estrategia 2: lista de bloqueo de tokens
Guarda los claims jti (JWT ID) revocados en un almacén rápido (Redis) con un TTL igual a la caducidad del token:
// Al cerrar sesión
await redis.set(`blocklist:${payload.jti}`, '1', { EX: remainingSeconds });
// En cada petición, comprueba antes de confiar en el token
const isRevoked = await redis.exists(`blocklist:${payload.jti}`);
if (isRevoked) throw new Error('Token has been revoked');
Estrategia 3: claves de firma de corta duración
Genera una clave de firma nueva cada hora. Conserva en el endpoint JWKS solo las últimas N claves. Los tokens antiguos firmados con claves caducadas se rechazan automáticamente. No hace falta lista de bloqueo, pero sí infraestructura de rotación de claves.
Almacenamiento seguro en el cliente
Dónde guarda el cliente el JWT determina su superficie de vulnerabilidad:
| Almacenamiento | Riesgo XSS | Riesgo CSRF | Recomendación |
|---|---|---|---|
localStorage |
Alto | Ninguno | Evitar para tokens |
sessionStorage |
Alto | Ninguno | Evitar para tokens |
| Variable de JavaScript | Medio | Ninguno | Válido en memoria a corto plazo |
Cookie HttpOnly |
Ninguno | Sí (se mitiga con SameSite) |
Recomendado |
El enfoque más seguro para las aplicaciones web: guardar el token de acceso en memoria (una variable de JavaScript) y el token de renovación en una cookie HttpOnly, Secure y SameSite=Strict.
Lista de comprobación de seguridad para producción
- El secreto de firma tiene al menos 256 bits y se ha generado de forma aleatoria
- El secreto se guarda en variables de entorno o en un gestor de secretos, no en el código
-
algse especifica explícitamente en el servidor, no se lee de la cabecera del token - No se acepta nunca
alg: none - Se establece el claim
exp(recomendado: 15–60 minutos para los tokens de acceso) - Los claims
issyaudse validan en cada petición - Se incluyen claims
jtien los tokens que puedan necesitar revocación - Se exige HTTPS en todos los endpoints que emiten o verifican tokens
- Los tokens de renovación se guardan en cookies
HttpOnly, no enlocalStorage - Se usa un endpoint JWKS para distribuir claves asimétricas (en sistemas con varios servicios)
- El proceso de rotación de claves está documentado y probado
Preguntas frecuentes
¿Debo usar HS256 o RS256?
HS256 (simétrico): sencillo de implementar, adecuado para sistemas de un solo servicio en los que un mismo servicio emite y verifica los tokens. La clave debe mantenerse secreta en todos los sitios donde se use.
RS256 (asimétrico): recomendado para arquitecturas con varios servicios. La clave privada solo la tiene el servidor de autorización. Todos los demás servicios usan la clave pública (mediante JWKS) para verificar. La configuración es más compleja, pero la postura de seguridad es notablemente mejor.
¿Cómo gestiono la rotación de claves sin tiempo de inactividad?
Publica a la vez la clave pública nueva y la antigua en el endpoint JWKS. Firma los tokens nuevos con la clave nueva (con un kid nuevo). Los tokens antiguos firmados con la clave vieja seguirán verificándose con la clave pública antigua del JWKS. Cuando todos los tokens antiguos hayan caducado, retira la clave vieja del JWKS.
¿Existe el cifrado de JWT?
Sí: JWE (JSON Web Encryption) cifra el payload, de modo que su contenido es ilegible sin la clave de descifrado. El JWT estándar (JWS) firma, pero no cifra: el payload lo puede leer cualquiera. Usa JWE solo cuando el propio payload deba mantenerse confidencial durante el tránsito.
¿Se puede usar el mismo JWT para autenticación y autorización?
Es habitual incluir ambas en el payload: el claim sub identifica al usuario (autenticación), mientras que claims personalizados como role o scope controlan lo que puede hacer (autorización). Ten presente el tamaño del token y evita incluir grandes cantidades de datos de autorización que cambian con frecuencia.
