Gerador de Tokens JWT

Crie e assine JSON Web Tokens RFC 7519 localmente no navegador usando Web Crypto HMAC (HS256, HS384, HS512) com claims JSON registradas e personalizadas.

Sem uploadsSem cadastroResultados instantâneos
HS256 · HS384 · HS512 · noneClaims Rápidas (iat / exp / jti)100% Local • Zero Envios
Criar e Assinar JWT
Motor offline prontoEspaço de trabalho 100% privado no navegador • Sem uploads para a nuvem
100% Privado • Sem Upload de Arquivos para Servidor

Por que usar o Gerador de Tokens JWT gratuito do Utiliome?

Criado do zero para privacidade estrita, execução instantânea e sem atrito. Sem assinaturas, paywalls ou cadastro.

Assinatura HMAC via Web Crypto no Navegador

Calcula assinaturas JWS HS256, HS384 e HS512 localmente via SubtleCrypto para que segredos de teste e payloads de claims nunca saiam da sua máquina.

Claims Registradas RFC 7519 e Personalizadas

Configure os campos padrão iss, sub, aud, exp, nbf, iat e jti junto com claims JSON personalizadas aninhadas, arrays de roles RBAC e escopos OAuth2.

Serialização Estrita em Base64URL sem Padding

Serializa cabeçalhos JSON UTF-8, payloads e tags MAC binárias usando o alfabeto seguro para URL da RFC 4648 com o padding final removido conforme a RFC 7515.

Fixtures Determinísticas de Auth e Casos Extremos

Gere tokens ativos, retroativos, expirados ou com nbf futuro sob demanda para testar middlewares de API gateway, tolerância de clock-skew e regras de autorização.

Utiliome vs Alternativas Tradicionais em Nuvem

Compare nosso motor WebAssembly local contra ferramentas de nuvem legadas.

Recurso Utiliome (Navegador Local) Conversores de Nuvem Legados
Assinatura HMAC via Web Crypto no Navegador Calcula assinaturas JWS HS256, HS384 e HS512 localmente via SubtleCrypto para que segredos de teste e payloads de claims nunca saiam da sua máquina. Opções limitadas sem personalização avançada
Claims Registradas RFC 7519 e Personalizadas Configure os campos padrão iss, sub, aud, exp, nbf, iat e jti junto com claims JSON personalizadas aninhadas, arrays de roles RBAC e escopos OAuth2. Requer ferramentas externas ou ajuste manual
Privacidade e Processamento 100% local no navegador (zero upload para servidor) Envia os dados para servidores externos na nuvem
Preço e Cadastro 100% gratuito para sempre e sem criar conta Exige cadastro de conta ou assinatura paga
Como funciona

Como usar o Gerador de Tokens JWT em 3 passos simples

Nenhuma instalação necessária. Tudo roda diretamente dentro do seu navegador.

1

Selecione o Algoritmo HMAC e o Cabeçalho JOSE

Escolha HS256, HS384 ou HS512 para preencher o cabeçalho protegido JOSE (alg e typ: JWT), além de quaisquer parâmetros de cabeçalho opcionais como kid.

2

Configure Claims Registradas e Personalizadas

Defina timestamps NumericDate Unix (iat, nbf, exp) e campos de identidade padrão (iss, sub, aud, jti), ou cole e envie claims JSON personalizadas.

3

Assine com a Chave Secreta e Copie o Token

Insira seu segredo compartilhado HMAC para gerar a assinatura criptográfica no navegador e copie o JWT compacto para cabeçalhos Authorization Bearer.

Como Construir e Assinar um JSON Web Token RFC 7519

Resposta Rápida: Serialize o cabeçalho JOSE e o payload de claims JSON como strings UTF-8 minificadas, codifique cada segmento usando Base64URL sem padding, junte-os com um ponto para formar a entrada de assinatura ASCII, calcule o digest HMAC-SHA2 usando sua chave secreta e anexe a assinatura codificada em Base64URL.

A geração de um JWT compatível com os padrões na JWS Compact Serialization (RFC 7515 Seção 3.1) transforma um cabeçalho JOSE, um conjunto de claims JSON e uma chave secreta simétrica em uma string de três partes formatada como <header>.<payload>.<signature>.

1. Construa o Cabeçalho JOSE e o Payload de Claims da API

Comece com um cabeçalho protegido HS256 e um payload JSON combinando claims registradas da RFC 7519 (iss, sub, aud, iat, exp) com claims personalizadas da aplicação (role):

{
  "alg": "HS256",
  "typ": "JWT"
}
{
  "iss": "https://auth.example.com",
  "sub": "usr_9481",
  "aud": "api.example.com",
  "iat": 1767225600,
  "exp": 1767229200,
  "role": "admin"
}

Aqui 1767225600 representa 2026-01-01T00:00:00Z e 1767229200 representa 2026-01-01T01:00:00Z (um tempo de vida de token de 1 hora).

2. Construa a Entrada de Assinatura em Base64URL sem Padding

Cada objeto JSON é minificado em bytes UTF-8 sem espaços em branco extras, codificado com Base64URL (alfabeto - e _, com padding = removido) e unido por um ponto ASCII (.):

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJodHRwczovL2F1dGguZXhhbXBsZS5jb20iLCJzdWIiOiJ1c3JfOTQ4MSIsImF1ZCI6ImFwaS5leGFtcGxlLmNvbSIsImlhdCI6MTc2NzIyNTYwMCwiZXhwIjoxNzY3MjI5MjAwLCJyb2xlIjoiYWRtaW4ifQ

3. Vetor de Assinatura HMAC-SHA256 Reprodutível

A Web Crypto importa os bytes do seu segredo via crypto.subtle.importKey("raw", secretBytes, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]) e assina exatamente os bytes ASCII <base64url-header>.<base64url-payload>. Você pode verificar a paridade determinística entre OpenSSL, crypto do Node.js, PyJWT do Python e este gerador usando o vetor de teste canônico HS256 com o segredo UTF-8 your-256-bit-secret:

{
  "sub": "1234567890",
  "name": "John Doe",
  "iat": 1516239022
}

Assinar o cabeçalho {"alg":"HS256","typ":"JWT"} e o payload acima com your-256-bit-secret sempre produz exatamente este token de 147 caracteres, pronto para um cabeçalho HTTP Authorization: Bearer <token> ou verificação completa no Decodificador e Inspetor JWT:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

Pipeline de Assinatura JWS HMAC, Semântica de Claims e Regras de Entropia de Chaves

Resposta Rápida: A RFC 7518 exige que as chaves de assinatura HMAC igualem ou excedam o comprimento de saída do hash: pelo menos 256 bits (32 bytes) para HS256, 384 bits (48 bytes) para HS384 e 512 bits (64 bytes) para HS512. Senhas ASCII fracas deixam JWTs simétricos vulneráveis a ataques de dicionário por força bruta offline.

Implementar ou testar a emissão de JWT exige adesão estrita às regras em nível de byte das especificações RFC 7515 (JWS), RFC 7518 (JWA) e RFC 7519 (JWT).

Entrada Exata de Assinatura JWS e Codificação Binária do Digest

Conforme a RFC 7515 Seção 5.1, a assinatura JWS é calculada sobre os bytes ASCII dos segmentos codificados em Base64URL, nunca sobre strings JSON brutas:

SigningInput = ASCII(BASE64URL(UTF8(Header))) || '.' || ASCII(BASE64URL(UTF8(Payload)))
Signature    = BASE64URL(HMAC_SHA2(SecretKeyBytes, SigningInput))

Duas nuances de serialização afetam a interoperabilidade entre linguagens:

  1. Digest Binário vs String Hexadecimal: O HMAC_SHA2 gera bytes binários brutos (32 bytes para HS256, 48 bytes para HS384, 64 bytes para HS512). Você deve codificar esses bytes brutos diretamente em Base64URL (gerando 43, 64 ou 86 caracteres, respectivamente), e não uma string hexadecimal intermediária em letras minúsculas.
  2. Determinismo na Serialização JSON: Embora objetos JSON da RFC 8259 sejam mapas de chave-valor não ordenados, o JWS assina a sequência exata de bytes UTF-8 serializada no momento da criação. Reordenar chaves ou formatar com espaços em branco (pretty-printing) altera o payload Base64URL e produz uma assinatura completamente diferente.

Dimensionamento do Algoritmo HMAC e Resistência à Força Bruta (RFC 7518 Seção 3.2)

  • HS256 (SHA-256, bloco interno de 512 bits): Digest de 256 bits (32 bytes), assinatura Base64URL de 43 caracteres. Segredo CSPRNG mínimo de 32 bytes.
  • HS384 (SHA-384, bloco interno de 1024 bits): Digest de 384 bits (48 bytes), assinatura Base64URL de 64 caracteres. Segredo CSPRNG mínimo de 48 bytes.
  • HS512 (SHA-512, bloco interno de 1024 bits): Digest de 512 bits (64 bytes), assinatura Base64URL de 86 caracteres. Segredo CSPRNG mínimo de 64 bytes.

Como todo cliente que possui um JWT detém tanto a entrada de assinatura em texto simples (<header>.<payload>) quanto a tag MAC resultante, um invasor pode testar segredos candidatos totalmente offline a milhões de hashes por segundo sem acionar limites de taxa (rate limits) da API. Sempre gere segredos a partir de um gerador de números aleatórios criptograficamente seguro em vez de palavras memorizáveis por humanos.

Tipos de Claims Registradas na RFC 7519 Seção 4.1

  • iss (Issuer) e sub (Subject): StringOrURI sensível a maiúsculas e minúsculas que identifica a autoridade que emitiu o token e o principal (ID do usuário ou conta de serviço) que ele representa.
  • aud (Audience): StringOrURI sensível a maiúsculas e minúsculas ou array JSON de valores StringOrURI identificando os destinatários pretendidos. Pela RFC 8725, servidores de recursos devem validar aud para impedir que um token válido emitido para o Serviço A seja reutilizado contra o Serviço B.
  • exp (Expiration), nbf (Not Before) e iat (Issued At): Valores NumericDate em segundos da época Unix (Math.floor(Date.now() / 1000)).
  • jti (JWT ID): Identificador exclusivo de token sensível a maiúsculas e minúsculas (como um UUIDv4) usado para listas de revogação (denylists) e prevenção de replay único.

Gerador de JWT vs Decodificador JWT vs Gerador HMAC: Escolhendo a Ferramenta Certa

Resposta Rápida: Use o Gerador de Tokens JWT para construir e assinar novos tokens Bearer RFC 7519 de três partes a partir de claims JSON. Use o Decodificador e Inspetor JWT para analisar e verificar JWTs existentes, ou use o Gerador HMAC quando precisar de assinaturas hash com chave em hexadecimal bruto ou Base64 para payloads de webhook como Stripe ou GitHub.

Embora todos os três utilitários dependam de hashing Web Crypto nativo do navegador, cada um atende a um formato de protocolo e estágio distinto da engenharia de APIs.

Recurso Gerador de Tokens JWT (Esta Ferramenta) Decodificador e Inspetor JWT Gerador e Verificador HMAC
Objetivo Principal Criar claims JSON e emitir um JWT assinado Decodificar, inspecionar timestamps e verificar um JWT existente Calcular um MAC de hash com chave autônomo sobre entrada arbitrária
Entrada Necessária Cabeçalho alg + claims JSON + chave secreta JWT compacto de três partes + chave secreta opcional Texto bruto ou mensagem JSON + chave secreta
Formato de Saída JWT Base64URL de três partes (<header>.<payload>.<signature>) Cabeçalho/payload JSON decodificado, status de expiração, verificação de validade String de digest hexadecimal ou Base64 autônoma
Especificação Base RFC 7519 (JWT) e RFC 7515 (JWS) RFC 7519 (JWT) e RFC 7515 (JWS) RFC 2104 (HMAC) e FIPS 198-1
Caso de Uso Ideal Criar tokens Bearer para testes locais de API e middleware Diagnosticar erros 401, ID tokens OIDC e TTLs Verificar X-Hub-Signature-256 de webhooks ou MACs de requisições de API

Depois de gerar um token de teste aqui, você pode colar o token resultante no Decodificador e Inspetor JWT para simular a verificação nos serviços consumidores e inspecionar como as contagens regressivas de exp e nbf se comportam.

Perguntas frequentes

FAQ e Guia Técnico do Gerador de Tokens JWT

Tudo o que você precisa saber sobre o gerador jwt online e gratuito do Utiliome.

Qual é o comprimento mínimo de chave secreta necessário para HS256, HS384 e HS512?

A RFC 7518 Seção 3.2 determina que uma chave HMAC deve ter um tamanho maior ou igual ao comprimento de saída do hash: pelo menos 32 bytes (256 bits) para HS256, 48 bytes (384 bits) para HS384 e 64 bytes (512 bits) para HS512. Bibliotecas de backend estritas como Nimbus JOSE+JWT, jjwt e PyJWT lançam exceções ou avisos de chave fraca se você fornecer strings ASCII mais curtas.

Por que meu código HS256 personalizado produz uma assinatura de 86 caracteres em vez de 43 caracteres?

Uma assinatura HS256 de 86 caracteres acontece quando o código converte primeiro o digest HMAC-SHA256 de 32 bytes em uma string hexadecimal de 64 caracteres e depois codifica em Base64URL esses 64 caracteres ASCII. A RFC 7515 exige a codificação em Base64URL diretamente dos 32 bytes binários brutos, o que sempre produz exatamente 43 caracteres Base64URL sem padding.

Quando devo escolher HMAC simétrico (HS256) em vez de RSA ou ECDSA assimétrico (RS256 ou ES256)?

Use HS256, HS384 ou HS512 simétrico quando o mesmo serviço de backend confiável (ou ambiente de teste local) assina e verifica o token, já que ambas as operações compartilham uma única chave secreta e são executadas com sobrecarga mínima de CPU. Quando vários microsserviços posteriores ou clientes de terceiros precisarem verificar tokens sem ganhar o poder de emitir novos, use ES256, RS256 ou EdDSA assimétrico, onde apenas o provedor de identidade detém a chave privada de assinatura.

Como devo formatar os timestamps exp, nbf e iat ao gerar um JWT?

Formate exp, nbf e iat como segundos numéricos da época Unix (por exemplo, 1767225600), nunca como strings de data ISO 8601 entre aspas e nunca como milissegundos de 13 dígitos do JavaScript. Para um token de acesso de 15 minutos, defina iat para o tempo epoch atual em segundos e defina exp como iat + 900.

Posso gerar JWTs expirados ou com data futura para testar o tratamento de erros da API?

Sim. Ao contrário dos servidores OAuth2 de produção que só emitem tokens válidos no momento, este gerador client-side permite que você defina deliberadamente exp no passado ou nbf no futuro. Isso torna simples escrever testes de integração determinísticos confirmando que seu middleware de autenticação rejeita tokens expirados ou prematuros com 401 Unauthorized enquanto respeita a tolerância configurada de atraso de relógio (clock-skew).