Codificador JWT

¿Qué es la codificación JWT?

La codificación JWT es el proceso de crear un JSON Web Token (JWT) — una cadena compacta y segura para URLs que contiene un conjunto de afirmaciones firmadas con una clave criptográfica. El resultado es un token de tres partes (header.payload.signature) definido por RFC 7519 que los servidores pueden verificar sin mantener estado de sesión. La codificación JWT en línea te permite crear y firmar tokens directamente en tu navegador para pruebas y desarrollo.

El encabezado declara el algoritmo de firma (p. ej. HS256) y el tipo de token. La carga útil contiene afirmaciones — pares clave-valor como el asunto (sub), tiempo de vencimiento (exp) y cualquier dato personalizado que tu aplicación necesite. Ambas partes se serializan como JSON, luego se codifican en base64url. La firma se calcula sobre el encabezado y la carga útil codificados usando una clave secreta, vinculando los tres segmentos.

A diferencia de las cookies de sesión, los JWT son autocontenidos: el verificador no necesita consultar una base de datos ni llamar a un servicio externo. Esto hace que la autenticación basada en JWT sea popular en APIs REST, microservicios y aplicaciones de una sola página donde la autorización sin estado reduce la latencia y simplifica el escalado horizontal.

¿Por qué usar un codificador JWT?

Generar JWTs a mano requiere codificación base64url, serialización JSON y cálculo HMAC. Esta herramienta maneja los tres pasos al instante para que puedas enfocarte en obtener las afirmaciones correctas.

Casos de uso del codificador JWT

HS256 vs HS384 vs HS512: Comparación de algoritmos HMAC

Los tres algoritmos usan HMAC (Código de Autenticación de Mensajes Basado en Hash) con una clave compartida. La diferencia está en la función hash subyacente, que afecta la longitud de la firma y el margen de seguridad. Para la mayoría de aplicaciones, HS256 proporciona seguridad suficiente. Elige HS384 o HS512 cuando los requisitos de conformidad (p. ej. FIPS-140) exigen un hash más fuerte o cuando tus tokens portan decisiones de autorización de alto valor.

Referencia de afirmaciones JWT estándar

RFC 7519 define siete afirmaciones registradas. Ninguna es obligatoria, pero usarlas correctamente mejora la interoperabilidad y la seguridad. La afirmación exp es especialmente importante — los tokens sin vencimiento son válidos indefinidamente si la clave secreta no se rota.

Codificación JWT en código

Estos ejemplos muestran cómo crear y firmar JWTs mediante programación. Cada fragmento produce un token válido firmado con HS256. Para sistemas en producción, siempre establece la afirmación exp y usa una clave secreta criptográficamente aleatoria de al menos 256 bits.

async function signJWT(payload, secret, alg = 'HS256') {
  const header = { alg, typ: 'JWT' }
  const enc = new TextEncoder()

  // Base64url encode header and payload
  const b64url = (obj) =>
    btoa(JSON.stringify(obj)).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')

  const h = b64url(header)
  const p = b64url(payload)

  // Sign with HMAC-SHA256
  const key = await crypto.subtle.importKey(
    'raw', enc.encode(secret),
    { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']
  )
  const sig = await crypto.subtle.sign('HMAC', key, enc.encode(`${h}.${p}`))
  const s = btoa(String.fromCharCode(...new Uint8Array(sig)))
    .replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')

  return `${h}.${p}.${s}`
}

// Usage
const token = await signJWT(
  { sub: 'user-123', name: 'Alice', iat: Math.floor(Date.now() / 1000) },
  'your-256-bit-secret'
)
// → "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOi..."

import jwt
import time

payload = {
    "sub": "user-123",
    "name": "Alice",
    "iat": int(time.time()),
    "exp": int(time.time()) + 3600,  # expires in 1 hour
}

# Sign with HS256 (default)
token = jwt.encode(payload, "your-256-bit-secret", algorithm="HS256")
# → "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOi..."

# Verify and decode
decoded = jwt.decode(token, "your-256-bit-secret", algorithms=["HS256"])
# → {"sub": "user-123", "name": "Alice", "iat": 1717200000, "exp": 1717203600}

const jwt = require('jsonwebtoken')

const payload = {
  sub: 'user-123',
  name: 'Alice',
  role: 'admin',
}

// Sign — iat is added automatically
const token = jwt.sign(payload, 'your-256-bit-secret', {
  algorithm: 'HS256',
  expiresIn: '1h',    // sets exp claim
  issuer: 'auth.example.com',  // sets iss claim
})

// Verify
const decoded = jwt.verify(token, 'your-256-bit-secret')
// → { sub: 'user-123', name: 'Alice', role: 'admin', iat: ..., exp: ... }

package main

import (
    "fmt"
    "time"
    "github.com/golang-jwt/jwt/v5"
)

func main() {
    claims := jwt.MapClaims{
        "sub":  "user-123",
        "name": "Alice",
        "iat":  time.Now().Unix(),
        "exp":  time.Now().Add(time.Hour).Unix(),
    }

    token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
    signed, _ := token.SignedString([]byte("your-256-bit-secret"))
    fmt.Println(signed)
    // → eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOi...
}

Preguntas frecuentes