Verificador de firma JWT y claims
Valide firmas criptográficas de JSON Web Tokens en HS256/384/512, RS256/384/512, PS256/384/512 y ES256/384/512 junto con los timestamps exp y nbf dentro de su navegador mediante WebCrypto. Todos los cálculos permanecen en memoria local sin subir claves ni tokens.
Cómo funciona
Un JSON Web Token firmado consta de tres segmentos Base64URL unidos por puntos: el encabezado JOSE, la carga útil JSON y la firma generada sobre los bytes ASCII de encabezado.payload. A diferencia de un simple decodificador, verificar un JWT exige comprobar matemáticamente esa firma con la API nativa WebCrypto (crypto.subtle) en la memoria de su navegador, sin enviar claves ni tokens por la red.
En algoritmos simétricos HMAC (HS256, HS384, HS512), el verificador interpreta el secreto en texto UTF-8, hexadecimal, Base64 o Base64URL y advierte si es más corto que el mínimo exigido por RFC 7518 sección 3.2. Para algoritmos asimétricos, importa claves públicas PEM SPKI o JWK/JWKS compatibles con RSASSA-PKCS1-v1_5, RSA-PSS o ECDSA en formato bruto r||s (ES256, ES384, ES512), rechazando siempre alg: "none" e informando con claridad cuando EdDSA o ES256K quedan fuera de WebCrypto.
Guía paso a paso con ejemplo real
Siga estos cuatro pasos para confirmar tanto la autenticidad criptográfica como la vigencia temporal de cualquier JWT en local.
1. Pegue el JWT compacto de tres partes
Introduzca la cadena header.payload.signature en el campo principal o cargue un vector oficial del Apéndice A de RFC 7515 para realizar pruebas inmediatas.
2. Fije el algoritmo esperado
Deje la autodetección para depurar rápidamente o elija un algoritmo explícito (como RS256 o ES256) para simular una lista blanca estricta de servidor.
3. Ingrese el secreto HMAC o la clave pública
Seleccione la codificación exacta en HMAC o pegue una clave pública SPKI PEM, un objeto JWK o un conjunto JWKS para firmas asimétricas.
4. Revise la firma y el margen de reloj
Configure la tolerancia en segundos ante posibles desfases entre servidores y examine el resultado junto a los estados de exp, nbf e iat.
Ejemplo real: Vector RFC 7515 Apéndice A.1 (HS256)
Token: eyJ0eXAiOiJKV1QiLA0KICJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJqb2UiLA0KICJleHAiOjEzMDA4MTkzODAsDQogImh0dHA6Ly9leGFtcGxlLmNvbS9pc19yb290Ijp0cnVlfQ.dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk | Secreto: AyM1SysPpbyDfgZld3umj1qzKObwVMkoqQ-EstJQLr_T-1qS0gZH75aKtMN3Yj0iPS4hcgUuTwjAzZr1Z9CAowFirma VÁLIDA (HS256, firma de 32 bytes, clave de 512 bits) · exp=1300819380 (2011-03-22T18:43:00Z, expirado) · claims iss="joe", is_root=true.La firma matemática resulta válida aunque el token haya caducado hace años, lo que separa claramente errores de clave de relojes desfasados.
Errores comunes y notas de seguridad
Confiar ciegamente en el campo "alg" del encabezado
Si un servidor lee el algoritmo desde el token sin restricción, un atacante puede cambiar RS256 por HS256 y firmar usando la clave pública distribuida.
No bloquear tokens con alg: "none"
Los tokens sin firma carecen de garantía criptográfica. Rechace siempre alg: "none" en sus APIs; esta herramienta los bloquea automáticamente.
Elegir secretos HMAC debajo del estándar RFC 7518
HS256 requiere mínimo 256 bits (32 bytes), HS384 necesita 384 bits y HS512 exige 512 bits. Las contraseñas cortas facilitan ataques de diccionario.
Pegar claves privadas donde basta la pública
Para comprobar firmas RS256, PS256 o ES256 solo hace falta la clave pública SPKI o JWK público. Conserve siempre las claves privadas fuera del navegador.
Comparativa de algoritmos de firma JWT
| Algoritmo | Tipo de clave | Formato de firma | Escenario ideal |
|---|---|---|---|
| HS256 / HS384 / HS512 | Secreto compartido simétrico | Resumen HMAC-SHA (32–64 B) | Servicios internos con emisor y verificador único |
| RS256 / RS384 / RS512 | RSA asimétrico (PKCS#1) | Firma tamaño módulo RSA | Compatibilidad amplia con OIDC y JWKS |
| PS256 / PS384 / PS512 | RSA-PSS asimétrico | Relleno probabilístico seguro | Entornos modernos con requisitos PSS |
| ES256 / ES384 / ES512 | ECDSA asimétrico (P-256..521) | IEEE P1363 r||s (64–132 B) | Tokens ligeros para móviles y gateways |
Ejemplos de código (Node.js, Python, Java)
Implemente la verificación en servidor fijando siempre el algoritmo esperado con librerías estándar:
import { createHmac, timingSafeEqual } from 'node:crypto';
export function verifyHs256(token: string, secret: Buffer) {
if (secret.length < 32) throw new Error('Key < 256 bits');
const [hdr, pay, sig] = token.split('.');
const { alg } = JSON.parse(Buffer.from(hdr, 'base64url').toString());
if (alg !== 'HS256') throw new Error('Invalid alg');
const expected = createHmac('sha256', secret).update(`${hdr}.${pay}`).digest();
const actual = Buffer.from(sig, 'base64url');
if (expected.length !== actual.length || !timingSafeEqual(expected, actual)) throw new Error('Bad signature');
return JSON.parse(Buffer.from(pay, 'base64url').toString());
}import jwt
def verify_rs256(token: str, public_pem: str, aud: str) -> dict:
return jwt.decode(
token, public_pem, algorithms=["RS256"],
audience=aud, leeway=30, options={"require": ["exp", "sub"]},
)DecodedJWT jwt = JWT.require(Algorithm.ECDSA256(ecPublicKey, null))
.withIssuer("https://auth.example.com")
.acceptLeeway(15)
.build()
.verify(token);Preguntas frecuentes
¿En qué se diferencia decodificar un JWT de verificar su firma?
Decodificar solo traduce Base64URL a JSON legible. Verificar recalcula la prueba criptográfica con la clave confiable para confirmar que nadie alteró los claims.
¿Por qué advierte el selector cuando se cambia o usa autodetección?
Autodetectar sirve en pruebas locales, pero en servidores reales debe exigir un algoritmo fijo para impedir ataques de confusión entre algoritmos.
¿Por qué EdDSA y ES256K aparecen como no compatibles aquí?
Este verificador usa exclusivamente WebCrypto estándar (crypto.subtle) sin dependencias externas; ES256K y ciertas curvas EdDSA no tienen soporte universal en navegadores.
¿Qué significa que la firma sea válida pero exp esté caducado?
Significa que el token fue emitido con la clave auténtica sin alteraciones posteriores, pero su fecha límite ya venció frente al reloj actual más el margen.
¿Puedo pegar un documento JWKS completo con varias claves?
Sí. Si el encabezado del JWT declara un kid, el verificador selecciona de forma automática la clave coincidente dentro del arreglo keys.
¿Se envían tokens o claves a un servidor durante la comprobación?
Nunca. Todo el procesamiento criptográfico ocurre en la memoria local de su navegador mediante crypto.subtle.
Herramientas relacionadas
Acerca del autor
Avada Labs crea herramientas gratuitas para desarrolladores, incluido este sitio, con seis años de experiencia en desarrollo web y herramientas en línea. Los proyectos y el código fuente están en GitHub.