ToolActToolAct

Gerador JWT

Crie JSON Web Token com Header e Payload personalizados

HEADERConfiguração do Header JWT
SECRETSegredo de Assinatura
PAYLOADConfiguração do Payload JWT
Adição Rápida:
JWT Token Gerado
Clique o botão acima para gerar um JWT Token

O que é JWT?

O gerador JWT cria JSON Web Tokens a partir de header, payload e configurações de assinatura. Um JWT tem três partes codificadas em Base64URL e costuma carregar claims como ID de usuário, papéis, expiração, emissor e audiência entre serviços. A ferramenta é útil para testes de API, desenvolvimento local, aprendizado, depuração e criação rápida de tokens de exemplo. Um token gerado só é confiável quando gestão de chaves, escolha de algoritmo, expiração e validação no servidor são tratadas corretamente. Segredos não devem ser usados em exemplos públicos, algoritmos fracos ou validade longa são arriscados, e dados sensíveis não devem ficar em payload sem criptografia.

Como Usar

Fluxo de Geração de JWT

  1. Selecione o algoritmo de assinatura (padrão HS256)
  2. Insira ou clique em 'Gerar' para criar um segredo de assinatura
  3. Edite o Payload JSON e use os botões de adição rápida para incluir claims padrão
  4. Defina os horários de emissão (iat) e expiração (exp)
  5. Clique no botão 'Gerar JWT Token'
  6. Copie o Token gerado para testes ou desenvolvimento

Segurança do Token

  • Use segredos fortes para algoritmos HMAC e proteja as chaves privadas para algoritmos RSA/ECDSA.
  • Defina claims de exp, iat, issuer e audience realistas; um JWT sintaticamente válido ainda pode ser inseguro ou rejeitado pelo seu serviço.

Casos de uso

Criar tokens de teste de curta duração para serviços locaisEscolha HS256, HS384 ou HS512, defina o segredo compartilhado (32+ bytes recomendados conforme RFC 7518), ajuste a predefinição de expiração para 1 hora / 24 horas / 7 dias / 30 dias e gere um JWT completo para uma API de desenvolvimento ou teste de middleware. O header, payload, assinatura e token final são exibidos separadamente para que cada parte possa ser copiada onde necessário. A chave HMAC nunca sai da aba do navegador.
Modelar combinações de claims para fluxos de autenticaçãoO editor de payload e os botões de claims rápidos facilitam adicionar valores de subject (sub), issuer (iss), audience (aud), JWT ID (jti), issued-at (iat) e expiration (exp) sem memorizar timestamps Unix. Os campos de data permanecem vinculados a iat e exp, o que é útil ao reproduzir casos extremos relacionados a desvio de relógio, janelas de nbf e fluxos de rotação de refresh token.
Gerar tokens de demonstração isolados sem backendPara documentação, protótipos de frontend ou scripts de QA que precisam apenas de um token de exemplo assinado com HMAC, esta ferramenta pode criar um segredo alfanumérico aleatório e assinar tudo localmente via Web Crypto. Ela é intencionalmente focada em algoritmos simétricos em vez de assinatura em produção com chave privada — o segredo de assinatura permanece dentro da aba local e nunca atinge um endpoint de rede.
Reproduzir o comportamento de alg=none e tokens não assinadosMude o seletor de algoritmo para 'none' para produzir um JWT não assinado destinado a clientes que o aceitem explicitamente. O header mostra alg e typ separadamente, então você consegue ver como a biblioteca a jusante reage a uma assinatura ausente ou a um algoritmo inesperado antes de enviar o token a um endpoint real.
Exportar header e payload como JSON independenteCopie apenas o header ou apenas o payload para uma requisição curl, variável de ambiente do Postman ou fixture de teste. Manter essas partes separadas evita assinar um novo token toda vez que você quiser ajustar uma única claim durante a experimentação de API, o que é especialmente útil ao iterar sobre campos de scope, role ou tenant em um ciclo de feedback rápido.

Princípio técnico

O gerador e o parser de JWT são processos inversos: o parser separa as três partes, o gerador as monta. O núcleo é calcular o segmento de Signature. Fluxo de montagem: 1) Construir o Header JSON, por exemplo {"alg":"HS256","typ":"JWT"}; 2) Construir o Payload JSON com claims padrão e privadas; 3) Codificar Header e Payload separadamente em Base64URL para obter h_b64 e p_b64; 4) Juntar h_b64 e p_b64 com um ponto, formando input = h_b64 + '.' + p_b64; 5) Calcular a assinatura conforme alg: HMAC-SHA256/384/512(secret, input); 6) Codificar o resultado da assinatura em Base64URL; 7) O token final é input + '.' + sig_b64. Assinatura HMAC-SHA256: usar o segredo como chave (>= 32 bytes) e rodar HMAC sobre input. Internamente, HMAC executa duas rodadas de SHA-256: primeiro deriva chaves ipad/opad do segredo, depois calcula SHA256(secret XOR ipad || msg) XOR opad. Força da chave: o comprimento do segredo determina a segurança. RFC 7518 exige chaves HS256 >= 256 bits (32 bytes). Em produção, use sempre um RNG criptograficamente seguro (por exemplo, crypto.randomBytes); nunca use strings como 'secret', 'password' ou '123456'. Armadilhas comuns: 1) Ataque de substituição de alg: o servidor deve validar alg estritamente e não deve ler alg do header do token para despachar ao algoritmo correspondente; 2) Chaves fracas: um segredo curto demais é quebrado por força bruta; 3) Adulteração de payload: HMAC garante integridade — se um atacante alterar o payload, a verificação no servidor falha; 4) Vazamento de token: JWT não pode ser revogado; uma vez fora, só resta aguardar o exp. Escopo desta ferramenta: somente HS256/HS384/HS512 são gerados. Algoritmos assimétricos como RS256 (RSA) e ES256 (ECDSA) exigem chave privada no emissor e são produzidos por um serviço de assinatura no backend ou por um SDK específico, não por esta página.

  • Núcleo da assinatura HMAC-SHA256: HMAC(secret, header_b64 + '.' + payload_b64), gera uma assinatura de 256 bits e a codifica em Base64URL.
  • O comprimento da chave HS256 deve ser >= 32 bytes (256 bits); recomenda-se gerar com crypto.getRandomValues ou crypto.randomBytes — chaves curtas são vulneráveis a ataques de dicionário.
  • Esta ferramenta gera apenas tokens assinados com HMAC (HS256/HS384/HS512). Algoritmos assimétricos como RS256 ou ES256 exigem uma chave privada guardada pelo emissor e não são produzidos aqui — use um serviço de assinatura no backend ou um SDK específico para esses casos.
  • iat/exp/nbf são todos timestamps Unix em segundos (não milissegundos); servidores geralmente exigem exp > agora(), nbf <= agora() e iat <= agora().
  • Ataque alg=none: mantenha uma whitelist de algoritmos permitidos no lado do servidor (ex. ['HS256']); nunca escolha o algoritmo dinamicamente a partir do header do token. Muitas bibliotecas JWT historicamente permitiam alg=none por padrão — isso é uma vulnerabilidade conhecida.
  • Um JWT não pode ser revogado após emitido — o único recurso é esperar o exp. Para revogação ativa, mantenha uma blacklist de jti ou use um access token de curta duração mais um refresh token.

Exemplos

Exemplo básico HS256

Header:  {"alg":"HS256","typ":"JWT"}
Payload: {"sub":"user-123","name":"Alice","role":"admin","iat":1705312800,"exp":1705399200}
Secret:  my-super-secret-key-32-bytes-long

Token: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyLTEyMyIsIm5hbWUiOiJBbGljZSIsInJvbGUiOiJhZG1pbiIsImlhdCI6MTcwNTMxMjgwMCwiZXhwIjoxNzA1Mzk5MjAwfQ.7Hk2L9oP3qR1mN4vK8xJ2wE5yT6sB0fA9cZ1dG3hI4U

Validade personalizada com iat e exp

Header:  {"alg":"HS256","typ":"JWT"}
Payload: {"iss":"https://auth.example.com","sub":"user-456","aud":"api.example.com","iat":1705312800,"exp":1705316400}
Secret:  another-strong-secret-32-bytes-long

A página codifica header e payload em Base64URL, junta-os com um ponto e aplica HMAC-SHA256 com o segredo compartilhado. O campo Token mostra a string final de três segmentos pronta para colar em cabeçalhos Authorization.

Claims personalizadas

Header: {"alg":"HS256","typ":"JWT"}
Payload: {
  "sub": "user-789",
  "name": "Bob",
  "role": "editor",
  "tenant": "acme-corp",
  "permissions": ["read:docs", "write:docs"],
  "scope": "docs.read docs.write",
  "iat": 1705312800,
  "exp": 1705399200,
  "jti": "550e8400-e29b-41d4-a716-446655440000"
}

Perguntas frequentes

O JWT é gerado localmente?

Sim. O header, o payload e a assinatura são calculados no seu navegador usando a Web Crypto API. O segredo de assinatura ou a chave privada nunca sai da página. Trate o token em si como dado que pode ser registrado em log ou exposto, especialmente se você colá-lo em um serviço real.

Quais algoritmos de assinatura são suportados?

Esta ferramenta gera HS256, HS384 e HS512 (HMAC com segredo compartilhado). Algoritmos assimétricos como RS256/RS384/RS512 (RSA) e ES256/ES384/ES512 (ECDSA) não são produzidos aqui — se o seu verificador exigir, use um serviço de assinatura no backend ou um SDK específico. Evite alg=none em produção: qualquer verificador sensato rejeita tokens não assinados.

O que vai no payload?

Claims padrão como sub, iss, aud, exp, iat, nbf, mais quaisquer claims customizados que seu serviço use. Mantenha o payload pequeno — JWTs viajam em headers e crescem a cada requisição. Nunca coloque senhas, números completos de cartão de crédito ou outros segredos dentro; o payload é Base64URL, não criptografado.

Como defino o tempo de expiração?

Defina exp como o timestamp Unix (em segundos, não milissegundos) em que o token deve deixar de ser válido. Tokens sem exp são tecnicamente legais, mas a maioria dos serviços de produção exige um. Valores comuns são 5-60 minutos para tokens de acesso e 7-30 dias para tokens de refresh.

Por que meu JWT gerado falha na verificação?

Causas comuns: o alg no header não corresponde ao que o verificador espera; o segredo/chave é diferente; claims do payload (iss, aud) não batem com a configuração do servidor; a diferença de relógio entre emissor e verificador excede a margem permitida (normalmente ±60 s); uma edição manual quebrou a codificação Base64URL (não adicione quebras de linha).

Meu segredo ou chave privada é enviado para algum servidor?

Não. A assinatura acontece inteiramente no navegador via Web Crypto. Dito isso, nunca cole uma chave de assinatura de produção em qualquer ferramenta web — teste com uma chave fora de produção e depois assine no seu backend real.

Devo usar HS256 ou RS256?

HS256 exige que os dois lados compartilhem um segredo, então só serve para situações em que o mesmo serviço emite e verifica o token. RS256 (ou ES256) permite que o emissor mantenha uma chave privada enquanto cada consumidor verifica com a chave pública — a escolha certa para OAuth/OIDC e qualquer arquitetura com múltiplos serviços. Esta ferramenta só gera tokens da família HS; para RS256/ES256, use um serviço de assinatura no backend ou um SDK específico.