Generador de Tokens JWT

Crea y firma JSON Web Tokens RFC 7519 localmente en tu navegador usando Web Crypto HMAC (HS256, HS384, HS512) con claims JSON registrados y personalizados.

Sin subidasSin registroResultados instantáneos
HS256 · HS384 · HS512 · noneClaims rápidos (iat / exp / jti)100% Local • Cero Subidas
Crear y firmar JWT
Motor local listoEspacio de trabajo 100% privado en el navegador • Sin subidas a la nube
100 % Privado • Sin cargas de archivos a servidores

¿Por qué usar Generador de Tokens JWT gratis en Utiliome?

Diseñado para máxima privacidad, ejecución instantánea y sin fricción. Sin suscripciones ni registros.

Firma HMAC con Web Crypto en el Navegador

Calcula firmas JWS HS256, HS384 y HS512 localmente mediante SubtleCrypto para que las claves secretas de prueba y los payloads nunca salgan de tu máquina.

Claims Registrados RFC 7519 y Personalizados

Configura campos estándar iss, sub, aud, exp, nbf, iat y jti junto con claims JSON personalizados anidados, arreglos de roles RBAC y scopes de OAuth2.

Serialización Estricta Base64URL sin Relleno

Serializa encabezados JSON UTF-8, payloads y etiquetas MAC binarias usando el alfabeto seguro para URL RFC 4648 eliminando el relleno final según RFC 7515.

Fixtures Deterministas de Autenticación y Casos Borde

Emite tokens activos, con fecha pasada, expirados o con nbf futuro bajo demanda para probar middlewares de API gateway, tolerancia de desfase horario y reglas de autorización.

Utiliome vs Alternativas en la nube tradicionales

Compara nuestro motor local en WebAssembly frente a herramientas en la nube.

Característica Utiliome (Navegador local) Convertidores en la nube tradicionales
Firma HMAC con Web Crypto en el Navegador Calcula firmas JWS HS256, HS384 y HS512 localmente mediante SubtleCrypto para que las claves secretas de prueba y los payloads nunca salgan de tu máquina. Opciones limitadas sin personalización avanzada
Claims Registrados RFC 7519 y Personalizados Configura campos estándar iss, sub, aud, exp, nbf, iat y jti junto con claims JSON personalizados anidados, arreglos de roles RBAC y scopes de OAuth2. Requiere herramientas externas o ajustes manuales
Privacidad y Procesamiento 100% local en tu navegador (cero subidas al servidor) Sube los datos a servidores externos en la nube
Precio y Registro 100% gratis para siempre y sin crear cuenta Requiere registro de cuenta o suscripción de pago
Cómo funciona

Cómo usar Generador de Tokens JWT en 3 sencillos pasos

Sin instalación de software. Todo funciona directamente dentro de tu navegador web.

1

Selecciona el Algoritmo HMAC y Encabezado JOSE

Elige HS256, HS384 o HS512 para poblar el encabezado protegido JOSE (alg y typ: JWT), junto con parámetros opcionales como kid.

2

Configura Claims Registrados y Personalizados

Establece marcas de tiempo NumericDate de Unix (iat, nbf, exp) y campos de identidad estándar (iss, sub, aud, jti), o pega y sube claims JSON personalizados.

3

Firma con Clave Secreta y Copia el Token

Ingresa tu secreto compartido HMAC para generar la firma criptográfica en el navegador y copia el JWT compacto para tus encabezados Authorization Bearer.

Cómo Construir y Firmar un JSON Web Token RFC 7519

Respuesta rápida: Serializa el encabezado JOSE y el payload de claims JSON como cadenas UTF-8 minificadas, codifica cada segmento usando Base64URL sin relleno, únelos con un punto para formar la entrada de firma ASCII, calcula el digest HMAC-SHA2 usando tu clave secreta y añade la firma codificada en Base64URL.

Generar un JWT que cumpla con los estándares en la Serialización Compacta JWS (RFC 7515 Sección 3.1) transforma un encabezado JOSE, un conjunto de claims JSON y una clave secreta simétrica en una cadena de tres partes con el formato <header>.<payload>.<signature>.

1. Construir el Encabezado JOSE y el Payload de Claims para la API

Comienza con un encabezado protegido HS256 y un payload JSON que combine claims registrados de RFC 7519 (iss, sub, aud, iat, exp) con claims personalizados de la aplicación (role):

{
  "alg": "HS256",
  "typ": "JWT"
}
{
  "iss": "https://auth.example.com",
  "sub": "usr_9481",
  "aud": "api.example.com",
  "iat": 1767225600,
  "exp": 1767229200,
  "role": "admin"
}

Aquí 1767225600 representa 2026-01-01T00:00:00Z y 1767229200 representa 2026-01-01T01:00:00Z (un tiempo de vida del token de 1 hora).

2. Construir la Entrada de Firma Base64URL sin Relleno

Cada objeto JSON se minifica a bytes UTF-8 sin espacios en blanco adicionales, se codifica con Base64URL (alfabeto - y _, eliminando el relleno =) y se une con un punto ASCII (.):

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJodHRwczovL2F1dGguZXhhbXBsZS5jb20iLCJzdWIiOiJ1c3JfOTQ4MSIsImF1ZCI6ImFwaS5leGFtcGxlLmNvbSIsImlhdCI6MTc2NzIyNTYwMCwiZXhwIjoxNzY3MjI5MjAwLCJyb2xlIjoiYWRtaW4ifQ

3. Vector de Firma Reproducible HMAC-SHA256

Web Crypto importa los bytes de tu secreto mediante crypto.subtle.importKey("raw", secretBytes, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]) y firma exactamente los bytes ASCII <base64url-header>.<base64url-payload>. Puedes verificar la paridad determinista entre OpenSSL, crypto de Node.js, PyJWT de Python y este generador utilizando el vector de prueba canónico HS256 con el secreto UTF-8 your-256-bit-secret:

{
  "sub": "1234567890",
  "name": "John Doe",
  "iat": 1516239022
}

Firmar el encabezado {"alg":"HS256","typ":"JWT"} y el payload anterior con your-256-bit-secret produce siempre exactamente este token de 147 caracteres, listo para un encabezado HTTP Authorization: Bearer <token> o para su verificación de ida y vuelta en el Decodificador e Inspector JWT:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

Pipeline de Firma HMAC JWS, Semántica de Claims y Reglas de Entropía de Claves

Respuesta rápida: El RFC 7518 exige que las claves de firma HMAC igualen o superen la longitud de salida del hash: al menos 256 bits (32 bytes) para HS256, 384 bits (48 bytes) para HS384 y 512 bits (64 bytes) para HS512. Las frases de contraseña ASCII débiles dejan a los JWT simétricos vulnerables a ataques de diccionario por fuerza bruta offline.

Implementar o probar la emisión de JWT requiere cumplir estrictamente con las reglas a nivel de bytes de RFC 7515 (JWS), RFC 7518 (JWA) y RFC 7519 (JWT).

Entrada Exacta de Firma JWS y Codificación Binaria del Digest

Según RFC 7515 Sección 5.1, la firma JWS se calcula sobre los bytes ASCII de los segmentos codificados en Base64URL, nunca sobre las cadenas JSON sin procesar:

SigningInput = ASCII(BASE64URL(UTF8(Header))) || '.' || ASCII(BASE64URL(UTF8(Payload)))
Signature    = BASE64URL(HMAC_SHA2(SecretKeyBytes, SigningInput))

Dos matices de serialización afectan la interoperabilidad entre distintos lenguajes:

  1. Digest Binario vs Cadena Hexadecimal: HMAC_SHA2 genera bytes binarios puros (32 bytes para HS256, 48 bytes para HS384, 64 bytes para HS512). Debes codificar en Base64URL esos bytes binarios directamente (obteniendo 43, 64 u 86 caracteres respectivamente), no una cadena hexadecimal intermedia en minúsculas.
  2. Determinismo en la Serialización JSON: Aunque los objetos JSON según RFC 8259 son mapas clave-valor sin orden, JWS firma la secuencia exacta de bytes UTF-8 serializada en el momento de la creación. Reordenar las claves o aplicar formato con espacios en blanco altera el payload Base64URL y produce una firma completamente diferente.

Tamaño del Algoritmo HMAC y Resistencia a la Fuerza Bruta (RFC 7518 Sección 3.2)

  • HS256 (SHA-256, bloque interno de 512 bits): Digest de 256 bits (32 bytes), firma Base64URL de 43 caracteres. Secreto CSPRNG mínimo de 32 bytes.
  • HS384 (SHA-384, bloque interno de 1024 bits): Digest de 384 bits (48 bytes), firma Base64URL de 64 caracteres. Secreto CSPRNG mínimo de 48 bytes.
  • HS512 (SHA-512, bloque interno de 1024 bits): Digest de 512 bits (64 bytes), firma Base64URL de 86 caracteres. Secreto CSPRNG mínimo de 64 bytes.

Dado que cada cliente que posee un JWT tiene tanto la entrada de firma en texto plano (<header>.<payload>) como la etiqueta MAC resultante, un atacante puede probar secretos candidatos completamente offline a millones de hashes por segundo sin activar límites de tasa en la API. Genera siempre los secretos a partir de un generador de números aleatorios criptográficamente seguro en lugar de palabras fáciles de recordar.

Tipos de Claims Registrados en RFC 7519 Sección 4.1

  • iss (Issuer) y sub (Subject): StringOrURI sensible a mayúsculas y minúsculas que identifica a la autoridad que emitió el token y al principal (ID de usuario o cuenta de servicio) que representa.
  • aud (Audience): StringOrURI sensible a mayúsculas y minúsculas o arreglo JSON de valores StringOrURI que identifican a los destinatarios previstos. Según RFC 8725, los servidores de recursos deben validar aud para evitar que un token válido emitido para el Servicio A sea reutilizado contra el Servicio B.
  • exp (Expiration), nbf (Not Before) e iat (Issued At): Valores NumericDate en segundos de época Unix (Math.floor(Date.now() / 1000)).
  • jti (JWT ID): Identificador único del token sensible a mayúsculas y minúsculas (como un UUIDv4) utilizado para listas de denegación por revocación y prevención de ataques de repetición.

Generador de JWT vs Decodificador JWT vs Generador HMAC: Cómo Elegir la Herramienta Adecuada

Respuesta rápida: Usa el Generador de Tokens JWT para construir y firmar nuevos tokens Bearer RFC 7519 de tres partes a partir de claims JSON. Usa el Decodificador e Inspector JWT para analizar y verificar JWTs existentes, o usa el Generador HMAC cuando necesites firmas hash con clave en formato hexadecimal o Base64 puro para payloads de webhooks como Stripe o GitHub.

Aunque las tres utilidades se basan en el hashing nativo de Web Crypto del navegador, cada una apunta a un formato de protocolo y una etapa distinta de la ingeniería de APIs.

Característica Generador de Tokens JWT (Esta Herramienta) Decodificador e Inspector JWT Generador y Verificador HMAC
Objetivo Principal Redactar claims JSON y emitir un JWT firmado Decodificar, inspeccionar timestamps y verificar un JWT existente Calcular un MAC hash con clave independiente sobre una entrada arbitraria
Entrada Requerida Encabezado alg + claims JSON + clave secreta JWT compacto de tres partes + clave secreta opcional Texto sin formato o mensaje JSON + clave secreta
Formato de Salida JWT en Base64URL de tres partes (<header>.<payload>.<signature>) Encabezado/payload JSON decodificado, estado de expiración, chequeo de validez Cadena de digest independiente en hexadecimal o Base64
Especificación Base RFC 7519 (JWT) y RFC 7515 (JWS) RFC 7519 (JWT) y RFC 7515 (JWS) RFC 2104 (HMAC) y FIPS 198-1
Caso de Uso Ideal Crear tokens Bearer para pruebas locales de APIs y middlewares Diagnosticar errores 401, ID tokens de OIDC y tiempos de vida (TTL) Verificar X-Hub-Signature-256 de webhooks o MACs de peticiones API

Después de emitir un token de prueba aquí, puedes pegar el resultado en el Decodificador e Inspector JWT para simular la verificación en servicios posteriores e inspeccionar cómo se comportan sus cuentas regresivas de exp y nbf.

Preguntas frecuentes

Preguntas frecuentes y guía técnica de Generador de Tokens JWT

Todo lo que necesitas saber sobre el uso gratuito en línea de generador jwt en Utiliome.

¿Cuál es la longitud mínima de clave secreta requerida para HS256, HS384 y HS512?

El RFC 7518 Sección 3.2 exige que una clave HMAC tenga un tamaño igual o superior a la longitud de salida del hash: al menos 32 bytes (256 bits) para HS256, 48 bytes (384 bits) para HS384 y 64 bytes (512 bits) para HS512. Las bibliotecas de backend estrictas como Nimbus JOSE+JWT, jjwt y PyJWT lanzan excepciones o advertencias de clave débil si proporcionas cadenas ASCII más cortas.

¿Por qué mi código personalizado para HS256 produce una firma de 86 caracteres en lugar de 43 caracteres?

Una firma HS256 de 86 caracteres ocurre cuando el código convierte primero el digest HMAC-SHA256 de 32 bytes en una cadena hexadecimal de 64 caracteres y luego codifica en Base64URL esos 64 caracteres ASCII. El RFC 7515 requiere codificar en Base64URL los 32 bytes binarios puros directamente, lo que siempre produce exactamente 43 caracteres Base64URL sin relleno.

¿Cuándo debo elegir HMAC simétrico (HS256) en lugar de RSA o ECDSA asimétrico (RS256 o ES256)?

Usa HS256, HS384 o HS512 simétrico cuando el mismo servicio de backend de confianza (o entorno de pruebas local) tanto firma como verifica el token, ya que ambas operaciones comparten una única clave secreta y se ejecutan con una sobrecarga mínima de CPU. Cuando múltiples microservicios posteriores o clientes de terceros necesiten verificar tokens sin obtener la capacidad de emitir otros nuevos, utiliza ES256, RS256 o EdDSA asimétrico, donde solo el proveedor de identidad posee la clave privada de firma.

¿Cómo debo formatear las marcas de tiempo exp, nbf e iat al generar un JWT?

Formatea exp, nbf e iat como segundos numéricos de época Unix (por ejemplo, 1767225600), nunca como cadenas de fecha ISO 8601 entre comillas ni como milisegundos de JavaScript de 13 dígitos. Para un token de acceso de 15 minutos, establece iat en el tiempo epoch actual en segundos y define exp como iat + 900.

¿Puedo generar JWTs expirados o con fecha futura para probar el manejo de errores de mi API?

Sí. A diferencia de los servidores OAuth2 de producción que solo emiten tokens válidos en el momento actual, este generador del lado del cliente te permite configurar deliberadamente exp en el pasado o nbf en el futuro. Esto facilita la escritura de pruebas de integración deterministas para confirmar que tu middleware de autenticación rechaza tokens expirados o prematuros con un error 401 Unauthorized mientras respeta la tolerancia configurada de desfase de reloj (clock-skew).