Gerador JWT
Crie JSON Web Token com Header e Payload personalizados
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
- Selecione o algoritmo de assinatura (padrão HS256)
- Insira ou clique em 'Gerar' para criar um segredo de assinatura
- Edite o Payload JSON e use os botões de adição rápida para incluir claims padrão
- Defina os horários de emissão (iat) e expiração (exp)
- Clique no botão 'Gerar JWT Token'
- 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
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.7Hk2L9oP3qR1mN4vK8xJ2wE5yT6sB0fA9cZ1dG3hI4UValidade 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.