Codificador JWT

O que é codificação JWT?

Codificação JWT é o processo de criar um JSON Web Token — uma string compacta e segura para URLs que carrega um conjunto de declarações assinadas com uma chave criptográfica. O resultado é um token de três partes (header.payload.signature) definido por RFC 7519 que servidores podem verificar sem manter estado de sessão. Codificação JWT online permite criar e assinar tokens diretamente em seu navegador para testes e desenvolvimento.

O cabeçalho declara o algoritmo de assinatura (p.ex. HS256) e o tipo de token. O payload contém declarações — pares chave-valor como o assunto (sub), tempo de expiração (exp) e qualquer dado personalizado que sua aplicação necessite. Ambas as partes são serializadas como JSON, então codificadas em base64url. A assinatura é calculada sobre o cabeçalho e payload codificados usando uma chave secreta, vinculando todos os três segmentos.

Diferentemente de cookies de sessão, JWTs são autocontidos: o verificador não precisa consultar um banco de dados ou chamar um serviço externo. Isso torna a autenticação baseada em JWT popular em APIs REST, microsserviços e aplicações de página única onde autorização sem estado reduz latência e simplifica escalabilidade horizontal.

Por que usar um codificador JWT?

Gerar JWTs manualmente requer codificação base64url, serialização JSON e computação HMAC. Esta ferramenta manipula todos os três passos instantaneamente para que você possa focar em acertar as declarações.

Casos de uso do codificador JWT

HS256 vs HS384 vs HS512: Comparação de algoritmos HMAC

Os três algoritmos usam HMAC (Hash-based Message Authentication Code) com uma chave compartilhada. A diferença está na função hash subjacente, que afeta o comprimento da assinatura e margem de segurança. Para a maioria das aplicações, HS256 fornece segurança suficiente. Escolha HS384 ou HS512 quando requisitos de conformidade (p.ex. FIPS-140) exigem um hash mais forte ou quando seus tokens carregam decisões de autorização de alto valor.

Referência de declarações JWT padrão

RFC 7519 define sete declarações registradas. Nenhuma é obrigatória, mas usá-las corretamente melhora interoperabilidade e segurança. A declaração exp é especialmente importante — tokens sem expiração são válidos indefinidamente se a chave secreta não for rotacionada.

Codificação JWT em código

Estes exemplos mostram como criar e assinar JWTs programaticamente. Cada trecho produz um token válido assinado com HS256. Para sistemas em produção, sempre defina a declaração exp e use uma chave secreta criptograficamente aleatória de pelo 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...
}

Perguntas frequentes