Generador de secreto JWT — HS256/384/512

¿Qué es un generador de secreto JWT?

// The secret you generate here goes straight into your signing code.
// Node.js with jsonwebtoken — the JWT_SECRET env var holds the key.
import jwt from 'jsonwebtoken';

const secret = process.env.JWT_SECRET; // e.g. base64url value from this tool

// Sign a token with HS256 (HMAC-SHA-256).
const token = jwt.sign({ sub: 'user-42', role: 'member' }, secret, {
  algorithm: 'HS256',
  expiresIn: '15m'
});

// Verify it — pin the algorithm to a whitelist; never trust the token's alg.
const payload = jwt.verify(token, secret, { algorithms: ['HS256'] });

// ---------------------------------------------------------------
// Python with PyJWT — same secret, same algorithm pinning.
// import jwt
// token = jwt.encode({"sub": "user-42"}, key, algorithm="HS256")
// payload = jwt.decode(token, key, algorithms=["HS256"])  # whitelist!

// ---------------------------------------------------------------
// Equivalent-strength CLI generation (32 bytes for HS256):
//   openssl rand -base64 32
//   node -e "console.log(require('crypto').randomBytes(32).toString('base64url'))"
//   python -c "import secrets; print(secrets.token_urlsafe(32))"

Características principales

Ejemplos prácticos

Algorithm: HS256 · Format: base64url

3sJ9aFq2kP7mWcZ1xL0nVtRbYdGhU8eAoI4QpNlKj0

Algorithm: HS512 · Format: base64url

k2Lp9XqA0mNbVcZ7rT4wYsHfGjUe8RoIdPlNkBvM3xQ1aWtCyZuS6FhEgJ (86 chars)

Click "Copy for .env"

JWT_SECRET=3sJ9aFq2kP7mWcZ1xL0nVtRbYdGhU8eAoI4QpNlKj0

Show the CLI command

openssl rand -base64 32

Toggle the eye icon

•••••••••••••••••••••••••••••••••••••••••••  ↔  3sJ9aFq2kP7m…

Cómo usar el generador de secreto JWT

1. 1

   Elige el algoritmo de firma

   Selecciona HS256, HS384 o HS512. El generador aplica al instante la longitud mínima de clave de la RFC 7518 §3.2 para esa variante HMAC — 32, 48 o 64 bytes — así que nunca tienes que consultar el número ni arriesgar una clave demasiado corta.

2. 2

   Elige el formato de salida

   base64url es el valor por defecto — la codificación nativa de JWT, segura para URL y sin relleno. Cambia a base64 estándar si un cargador lo espera, o hex cuando un sistema solo acepta caracteres 0–f. Las tres codifican los mismos bytes aleatorios con idéntica entropía.

3. 3

   Revela y copia el secreto

   El secreto está enmascarado por defecto para mantenerlo fuera de pantalla durante una demo o un uso compartido de pantalla. Pulsa el icono del ojo para revelarlo, luego Copiar para tomar el valor en bruto o Copiar para .env para copiar una línea JWT_SECRET=… lista para un archivo .env o una variable de CI.

4. 4

   Regenera cuando lo necesites

   Pulsa Regenerar para un secreto nuevo e independiente extraído de crypto.getRandomValues. Genera uno por entorno — nunca reutilices la misma clave de firma entre desarrollo, staging y producción.

5. 5

   Usa el equivalente de CLI o pasa a firmar

   El panel de CLI muestra las líneas correspondientes de openssl, Node y Python para aprovisionamiento por script. Con tu secreto en mano, firma un token con el Codificador JWT y confirma la firma con el Decodificador JWT.

Errores comunes con secretos JWT

JWT_SECRET=mySuperSecret123  →  low entropy, brute-forceable

JWT_SECRET=3sJ9aFq2kP7mWcZ1xL0nVtRbYdGhU8eAoI4QpNlKj0  →  32 random bytes

16-byte key with HS256  →  below the 32-byte minimum

32-byte key with HS256  →  meets RFC 7518 §3.2

Math.random()-based key  →  predictable, unsafe

crypto.getRandomValues key  →  full entropy

Service A: raw string · Service B: base64-decoded  →  signatures never match

Both services use the identical stored string  →  signatures verify

Same JWT_SECRET in dev, staging, prod  →  one leak breaks all

A unique secret per environment  →  blast radius contained

jwt.verify(token, secret)  →  accepts the token's alg

jwt.verify(token, secret, { algorithms: ['HS256'] })  →  pinned

Quién usa esta herramienta

Aprovisionar un JWT_SECRET para un servicio nuevo

¿Levantando una API que emite tokens firmados con HMAC? Elige el algoritmo que usa tu biblioteca, copia el secreto como una línea JWT_SECRET=… y ponlo en el entorno del servicio. Genera una clave distinta para desarrollo, staging y producción — nunca compartas un secreto entre entornos.

Rotar un secreto comprometido o envejecido

Cuando se sospecha que una clave se ha filtrado o simplemente toca rotarla, genera aquí un secreto nuevo, asígnale un nuevo kid y despliégalo con una ventana de solapamiento para que los tokens activos sigan verificándose hasta que expiren. Ante un compromiso confirmado, rota de inmediato y elimina la clave antigua del conjunto aceptado.

Reemplazar una clave débil o escrita a mano

¿Heredaste un código cuyo JWT_SECRET es una frase corta o un valor de ejemplo copiado? Esa clave es forzable por fuerza bruta offline. Genera un reemplazo de 32 bytes con entropía plena, cámbialo detrás de una ventana de rotación y cierra el agujero de falsificación de tokens antes de que se explote.

Programar la generación de claves en un pipeline

¿Necesitas crear la clave en CI o en un Dockerfile en lugar de a mano? Usa la línea de openssl, Node o Python del panel de CLI para acuñar un secreto de fuerza equivalente dentro de tu script de aprovisionamiento, y usa esta página para entender las longitudes de byte y las codificaciones que produce cada comando.

Enseñar la firma de JWT de forma segura

Guía a un equipo por cómo funciona HS256 sin exponer nunca una clave de producción real — genera un secreto desechable en pantalla (enmascarado hasta que lo reveles), firma un token de ejemplo con el Codificador JWT y verifícalo con el Decodificador JWT para que todo el ciclo de firmar y verificar sea visible.

Comparar los tamaños de clave de HS256, HS384 y HS512

¿Decidiendo qué variante HMAC estandarizar? Alterna entre los algoritmos para ver cómo crecen la longitud de clave requerida y la cadena codificada — 43, 64 y 86 caracteres base64url — y elige el equilibrio entre fortaleza y tamaño de token que encaje en tu sistema antes de fijarlo en la configuración.

Generar claves para desarrollo local

¿Necesitas un secreto rápido y válido para poner en marcha un flujo de autenticación local? Genera uno en un clic, cópialo para .env y quedas desbloqueado — con una clave de CSPRNG real en lugar de un marcador de posición que olvidarás reemplazar antes de desplegar.

Cómo funciona el generador

crypto.getRandomValues (CSPRNG)

Los secretos se generan rellenando un Uint8Array con crypto.getRandomValues, el generador de números pseudoaleatorios criptográficamente seguro de Web Crypto. Es la misma fuente de entropía que respalda la generación de claves de Web Crypto. Math.random no se usa nunca en ningún sitio — es estadísticamente predecible e inadecuado para cualquier clave criptográfica.

Dimensionado de clave de la RFC 7518 §3.2

El número de bytes por algoritmo sigue el requisito de los JSON Web Algorithms de que una clave HMAC sea al menos del tamaño de la salida del hash: 32 bytes para HS256 (SHA-256), 48 para HS384 (SHA-384), 64 para HS512 (SHA-512). Seleccionar el algoritmo fija el mínimo; el generador no emitirá una clave por debajo del suelo de la especificación.

Codificaciones RFC 4648 (base64url / base64 / hex)

Los bytes en bruto se codifican con los alfabetos RFC 4648. base64url usa el alfabeto seguro para URL sin relleno (32 bytes → 43 caracteres), base64 estándar usa relleno +, / y = (→ 44 caracteres), y hex escribe dos caracteres por byte (→ 64 caracteres). Cambiar de formato recodifica los mismos bytes — la entropía subyacente no cambia.

Por qué base64url es el valor por defecto

Los componentes de JWT están ellos mismos codificados en base64url, y el alfabeto seguro para URL y sin relleno significa que un secreto en base64url nunca necesita escaparse en una cabecera, una URL o un archivo de configuración. El + y la / y el = final de base64 estándar pueden romperse en esos contextos, así que base64url es el valor por defecto conservador para un JWT_SECRET.

Formato de Copiar-para-.env

Copiar para .env emite JWT_SECRET= en una sola línea sin comillas alrededor — la forma que los cargadores estilo dotenv analizan sin modificación. El secreto en bruto nunca incluye caracteres que requerirían comillas en un archivo .env, así que la línea es segura para pegar tal cual.

Comandos de CLI de fuerza equivalente, no idénticos byte a byte

Los comandos del panel de CLI openssl rand -base64 N, Node randomBytes(N).toString('base64url') y Python secrets.token_urlsafe(N) extraen todos N bytes aleatorios seguros para el algoritmo elegido. Producen claves de fuerza equivalente, no la misma cadena — openssl emite base64 estándar con relleno, así que el alfabeto y los caracteres finales difieren del valor base64url por defecto de esta herramienta.

Buenas prácticas de secretos JWT

Ajusta la longitud de clave al algoritmo

Usa al menos 32 bytes para HS256, 48 para HS384 y 64 para HS512, como exige la RFC 7518 §3.2. Este generador lo hace por ti, pero si dimensionas una clave a mano, nunca bajes de la longitud de la salida del hash — una clave HMAC demasiado corta debilita la firma y puede ser rechazada por bibliotecas estrictas.

Genera siempre con un CSPRNG, nunca con una contraseña

Un secreto JWT es una credencial de máquina que nadie necesita memorizar, así que gasta toda la entropía: usa una clave aleatoria criptográficamente segura, no una frase de contraseña, una palabra de diccionario o una cadena escrita a mano. Los secretos elegidos por humanos son el objetivo más fácil para los ataques de fuerza bruta offline que las herramientas de cracking de JWT automatizan.

Usa un secreto único por entorno

Desarrollo, staging y producción deberían tener cada uno su propio JWT_SECRET. Compartir una clave significa que una filtración en un entorno de bajo riesgo falsifica tokens en todas partes, y hace que la rotación sea de todo o nada. Genera aquí un secreto separado para cada entorno y guarda cada uno en su propio ámbito de gestor de secretos.

Fija el algoritmo cuando verifiques

En el lado verificador, pasa siempre una lista blanca explícita de algoritmos — algorithms: ['HS256'] en jsonwebtoken, algorithms=["HS256"] en PyJWT — y nunca confíes en el campo alg dentro del token. Aceptar el algoritmo autodeclarado del token habilita los clásicos ataques de confusión de algoritmo y de falsificación con alg:none, por muy fuerte que sea tu secreto.

Rota con una cabecera kid y claves solapadas

Etiqueta los tokens firmados con un identificador de clave (kid) y publica las claves activas a través de un endpoint JWKS para poder rotar sin tiempo de inactividad: firma tokens nuevos con la clave nueva mientras sigues aceptando la antigua hasta que sus tokens expiren. Ante una sospecha de compromiso, sáltate el solapamiento y revoca la clave antigua de inmediato.

Preguntas frecuentes