Codificador e Gerador JWT

O que é um Codificador JWT?

// Sign a JWT in the browser with the Web Crypto API (HS256)
async function encodeJwt(payload, secret) {
  const b64url = (bytes) =>
    btoa(String.fromCharCode(...new Uint8Array(bytes)))
      .replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
  const enc = (obj) =>
    b64url(new TextEncoder().encode(JSON.stringify(obj)));

  const header = { alg: 'HS256', typ: 'JWT' };
  const signingInput = `${enc(header)}.${enc(payload)}`;

  const key = await crypto.subtle.importKey(
    'raw', new TextEncoder().encode(secret),
    { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
  const sig = await crypto.subtle.sign(
    'HMAC', key, new TextEncoder().encode(signingInput));

  return `${signingInput}.${b64url(sig)}`;
}

const token = await encodeJwt({ sub: 'user_123', exp: 1999999999 }, 'my-secret');
// → eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyXzEyMyIsImV4cCI6MTk5OTk5OTk5OX0....

Recursos principais

Exemplos

{
  "sub": "user_123",
  "name": "Alice",
  "role": "admin",
  "iat": 1715000000,
  "exp": 1999999999
}
secret: a-string-secret-at-least-256-bits-long

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyXzEyMyIsIm5hbWUiOiJBbGljZSIsInJvbGUiOiJhZG1pbiIsImlhdCI6MTcxNTAwMDAwMCwiZXhwIjoxOTk5OTk5OTk5fQ.<HMAC-SHA256 signature>

{
  "iss": "https://auth.example.com",
  "aud": "api.example.com",
  "sub": "90087165",
  "scope": "read:user write:post",
  "iat": 1715000000,
  "exp": 1999999999
}
private key: -----BEGIN PRIVATE KEY----- (PKCS8)

eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJodHRwczovL2F1dGguZXhhbXBsZS5jb20iLCJhdWQiOiJhcGkuZXhhbXBsZS5jb20iLCJzdWIiOiI5MDA4NzE2NSIsInNjb3BlIjoicmVhZDp1c2VyIHdyaXRlOnBvc3QiLCJpYXQiOjE3MTUwMDAwMDAsImV4cCI6MTk5OTk5OTk5OX0.<RSA signature>

{
  "sub": "device-42",
  "iat": 1715000000,
  "exp": 1999999999
}
private key: -----BEGIN PRIVATE KEY----- (P-256)

eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJkZXZpY2UtNDIiLCJpYXQiOjE3MTUwMDAwMDAsImV4cCI6MTk5OTk5OTk5OX0.<ECDSA P-256 signature>

Como usar

1. 1

   Edite as Reivindicações da Carga Útil

   Escreva as reivindicações que seu token precisa como JSON no editor de carga útil. Use os chips de reivindicação rápida para inserir iss, sub, aud, iat, nbf ou um exp de uma hora sem digitar timestamps.

2. 2

   Escolha o Algoritmo e Insira a Chave

   Escolha um algoritmo de assinatura. Para HS256/384/512 insira um segredo; para os algoritmos RS, PS ou ES cole uma chave privada PEM PKCS8. O token é assinado localmente conforme você digita.

3. 3

   Copie o JWT Assinado

   O token assinado aparece instantaneamente, destacado por cores por segmento. Clique em Copiar para levá-lo a um cabeçalho Authorization, comando curl ou teste. Sua chave nunca saiu do seu navegador.

Common Errors

secret: "password123"  // guessable, low entropy

secret: base64(crypto.randomBytes(32))  // >=256 random bits

{ "sub": "user_123", "role": "admin" }  // no exp

{ "sub": "user_123", "role": "admin", "exp": 1715003600 }

-----BEGIN RSA PRIVATE KEY-----  // PKCS1, not supported

openssl pkcs8 -topk8 -nocrypt -in pkcs1.pem -out pkcs8.pem

Casos de uso comuns

Gere Tokens para Teste de API

Gere um token Bearer HS256 em segundos para exercitar um endpoint protegido a partir do curl, Postman ou um teste de integração.

Reproduza Tokens OAuth e OIDC

Monte um token RS256 ou ES256 que espelha o que seu servidor de autorização emite, para que você possa depurar incompatibilidades de reivindicações e audiência.

Crie Fixtures de Teste

Produza tokens assinados determinísticos para testes unitários e de integração sem precisar subir um servidor de autenticação completo.

Depure Falhas de Autorização

Recrie o formato de token de um cliente — issuer, audience, scope, expiração — para descobrir por que um backend o rejeita.

Valide um Verificador

Assine tokens com uma chave conhecida para confirmar que seu middleware de verificação aceita tokens válidos e rejeita os adulterados.

Prototipe Fluxos de Autenticação

Entregue aos colegas tokens prontos para uso enquanto configura um novo login, microsserviço ou chamada entre serviços.

Detalhes técnicos

Conforme a RFC 7519 / 7515 / 7518

Produz tokens JWS em conformidade com a RFC 7519 (JWT), RFC 7515 (JWS) e RFC 7518 (JWA), com os identificadores de algoritmo registrados no cabeçalho.

Assinatura Nativa via Web Crypto

Assina via crypto.subtle para HMAC, RSASSA-PKCS1-v1_5, RSA-PSS e ECDSA. As assinaturas ECDSA são emitidas como r||s bruto, exatamente como o JWS requer.

Base64URL, Zero Dependências

Cabeçalho e carga útil são codificados em Base64URL com o alfabeto seguro para URL (RFC 4648), sem preenchimento. Sem bibliotecas externas, sem chamadas de rede, sem telemetria.

Melhores práticas

Sempre Defina uma Expiração

Inclua uma reivindicação exp para que um token vazado deixe de ser válido. Tempos de vida curtos reduzem o raio de impacto — minutos para tokens de acesso, não dias.

Mantenha Segredos Fora da Carga Útil

Uma carga útil JWT é legível por qualquer um com o token. Coloque nela identificadores e escopos; nunca senhas, chaves de API ou PII completa.

Assine no Servidor em Produção

Use esta ferramenta para testes e depuração. Em sistemas reais, assine tokens no servidor com uma biblioteca mantida e uma chave do seu gerenciador de segredos.

Perguntas frequentes