Decodificador e Inspetor JWT

Decodifique, inspecione e verifique localmente tokens JWT RFC 7519 no navegador.

Sem uploadsSem cadastroResultados instantâneos
Claims e Datas RFC 7519Verificação HS256 / HS384 / HS512100% Local • Zero Envios
Decodificar 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 Decodificador e Inspetor JWT gratuito do Utiliome?

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

Inspeção de Tokens 100% Client-Side

Tokens de acesso OAuth2 de produção, ID tokens OIDC e segredos de assinatura compartilhados são processados exclusivamente na memória do navegador sem nenhuma transmissão de rede.

Verificação Web Crypto HS256, HS384 e HS512

Recalcula e valida assinaturas JWS HMAC-SHA2 (RFC 7515) localmente via SubtleCrypto usando chaves secretas em UTF-8 puro ou codificadas em Base64URL.

Auditoria em Tempo Real de exp, nbf e iat

Converte campos NumericDate em segundos Unix (RFC 7519) para timestamps ISO 8601 em UTC e fuso local com contagens regressivas de expiração e ativação ao vivo.

Conformidade Estrita com RFC 7519 e Base64URL

Decodifica segmentos Base64URL sem padding com suporte total a UTF-8 multibyte, remove prefixos Authorization Bearer e sinaliza cabeçalhos inseguros com alg:none.

Utiliome vs Alternativas Tradicionais em Nuvem

Compare nosso motor WebAssembly local contra ferramentas de nuvem legadas.

Recurso Utiliome (Navegador Local) Conversores de Nuvem Legados
Inspeção de Tokens 100% Client-Side Tokens de acesso OAuth2 de produção, ID tokens OIDC e segredos de assinatura compartilhados são processados exclusivamente na memória do navegador sem nenhuma transmissão de rede. Opções limitadas sem personalização avançada
Verificação Web Crypto HS256, HS384 e HS512 Recalcula e valida assinaturas JWS HMAC-SHA2 (RFC 7515) localmente via SubtleCrypto usando chaves secretas em UTF-8 puro ou codificadas em Base64URL. 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 Decodificador e Inspetor JWT em 3 passos simples

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

1

Cole ou Envie seu JSON Web Token

Cole uma string JWT de três partes separadas por pontos (com ou sem o prefixo Authorization Bearer) ou arraste um arquivo local .jwt ou .txt para o inspetor.

2

Inspecione o Cabeçalho JOSE, Claims e Ciclo de Vida

Analise o cabeçalho e o payload JSON formatados ao lado dos timestamps UTC e locais decodificados para as claims exp, nbf e iat a fim de diagnosticar expiração ou desvios de relógio (clock skew).

3

Verifique a Assinatura HMAC Localmente

Insira sua chave secreta compartilhada HS256, HS384 ou HS512 para validar a integridade do token diretamente no navegador usando a Web Crypto API.

Como Decodificar e Verificar um JSON Web Token Passo a Passo

Resposta Rápida: Divida o JWT compacto nos seus dois pontos delimitadores em segmentos Base64URL de cabeçalho, payload e assinatura. Decodifique os dois primeiros segmentos como JSON UTF-8 para inspecionar as claims e os timestamps NumericDate e, em seguida, recalcule o digest HMAC sobre a string ASCII original header.payload usando sua chave secreta para confirmar a autenticidade.

Um JSON Web Token padrão RFC 7519 transmitido em Serialização Compacta JWS consiste em três strings Base64URL sem preenchimento (unpadded) unidas por pontos: <header>.<payload>.<signature>. Se você copiar o valor de um cabeçalho HTTP como Authorization: Bearer <token>, o decodificador remove automaticamente o prefixo Bearer antes de dividir a string no caractere ..

Considere este token compacto padrão assinado com HS256:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

1. Cabeçalho Protegido JOSE Decodificado

A decodificação Base64URL do primeiro segmento (eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9) resulta em 27 bytes UTF-8 que descrevem o algoritmo criptográfico e o tipo de mídia:

{
  "alg": "HS256",
  "typ": "JWT"
}

2. Payload de Claims Decodificado e Timestamps NumericDate

A decodificação Base64URL do segundo segmento (eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ) revela o conjunto de claims em JSON:

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

Aqui, iat (1516239022) corresponde a 2018-01-18T01:30:22Z em UTC. Ao inspecionar um token de acesso de produção que inclui limites completos de ciclo de vida, o inspetor avalia cada claim NumericDate em relação ao relógio atual do seu sistema:

{
  "iss": "https://auth.example.com",
  "sub": "usr_9481",
  "iat": 1735689600,
  "nbf": 1735689600,
  "exp": 1735693200
}
  • iat (1735689600): Emitido em 2025-01-01T00:00:00Z.
  • nbf (1735689600): Não válido antes de 2025-01-01T00:00:00Z.
  • exp (1735693200): Expira em 2025-01-01T01:00:00Z (TTL exato de 3.600 segundos).

3. Verificação Local da Assinatura HMAC-SHA256

A decodificação prova apenas que os dois primeiros segmentos são JSON válidos codificados em Base64URL; ela não prova que as claims não foram adulteradas. Quando você fornece o segredo compartilhado your-256-bit-secret para o primeiro exemplo acima, o verificador passa a entrada de assinatura ASCII exata (eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ) e a assinatura Base64URL de 43 caracteres (SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c) para crypto.subtle.verify("HMAC", key, signatureBytes, signingInputBytes). Qualquer edição de um único bit no payload JSON decodificado altera a tag MAC esperada de 32 bytes e aciona imediatamente um erro de assinatura inválida.

Estrutura RFC 7519, Codificação Base64URL e Nuances de Segurança JWS

Resposta Rápida: Um JWT RFC 7519 em Serialização Compacta JWS consiste em três segmentos Base64URL sem padding separados por pontos. A decodificação apenas reverte a codificação Base64URL para JSON UTF-8 legível; a integridade e a autenticidade dependem estritamente da verificação da assinatura criptográfica contra uma lista de permissões (allowlist) explícita de algoritmos.

Compreender como as especificações JOSE (RFC 7515 JWS, RFC 7518 JWA, RFC 7519 JWT e as Melhores Práticas Atuais para JWT na RFC 8725) interagem evita bugs sutis de autenticação e vulnerabilidades graves de segurança.

Base64URL vs Base64 Padrão (RFC 4648 Seção 5)

O Base64 padrão utiliza os caracteres +, / e o preenchimento (padding) =, que colidem com delimitadores de query string em URLs, segmentos de caminho e parsers de cookies. O JWS exige a codificação Base64URL sem padding:

  • O índice 62 é mapeado para - (hífen) em vez de +.
  • O índice 63 é mapeado para _ (sublinhado) em vez de /.
  • Os caracteres = de preenchimento final são omitidos na serialização e restaurados durante a decodificação através da fórmula (4 - (segment.length % 4)) % 4.
  • Os bytes decodificados devem ser interpretados como UTF-8 via TextDecoder("utf-8"), e não como strings Latin-1 da função atob() do navegador, que corrompem caracteres Unicode multibyte em nomes ou claims localizadas. Para payloads independentes que não sejam JWT, utilize o Codificador e Decodificador Base64.

Especificações dos Algoritmos JWA HMAC-SHA2 (RFC 7518 Seção 3.2)

  • HS256 (HMAC com SHA-256): Produz uma tag de autenticação de 256 bits (32 bytes) codificada como 43 caracteres Base64URL. Requer uma chave secreta de pelo menos 256 bits (32 bytes).
  • HS384 (HMAC com SHA-384): Produz uma tag de autenticação de 384 bits (48 bytes) codificada como 64 caracteres Base64URL. Requer uma chave secreta de pelo menos 384 bits (48 bytes).
  • HS512 (HMAC com SHA-512): Produz uma tag de autenticação de 512 bits (64 bytes) codificada como 86 caracteres Base64URL. Requer uma chave secreta de pelo menos 512 bits (64 bytes).

Precisão do NumericDate e Tolerância de Relógio (Clock-Skew Leeway)

A Seção 2 da RFC 7519 define NumericDate como um valor numérico JSON representando segundos (e não milissegundos) desde 1970-01-01T00:00:00Z UTC, ignorando segundos bissextos. Verificadores compatíveis rejeitam um token a menos que current_time < exp + leeway (o token não expirou) e current_time >= nbf - leeway (o token está ativo), onde leeway é tipicamente de 30 a 60 segundos para absorver desvios de sincronização NTP entre servidores distribuídos.

Vulnerabilidades Críticas na Verificação (RFC 8725)

  1. Downgrade Inseguro para alg: "none": Nunca confie dinamicamente no campo alg do cabeçalho. Se um backend aceitar {"alg":"none","typ":"JWT"} com um segmento de assinatura vazio (header.payload.), um invasor pode forjar claims administrativas arbitrárias sem precisar de nenhuma chave.
  2. Confusão de Algoritmo (RS256 para HS256): Se um servidor espera um token assimétrico RS256 verificado com uma chave pública RSA, mas sua biblioteca JWT escolhe o método de verificação apenas com base no cabeçalho alg recebido, um invasor pode alterar alg para HS256 e assinar o token simetricamente usando os bytes da chave pública RSA (que é pública) como segredo HMAC.
  3. Chamadas decode() Não Verificadas em Produção: Chamar métodos auxiliares como jwt.decode(token) em vez de jwt.verify(token, secret, { algorithms: ["HS256"] }) apenas faz o parse de dados não confiáveis enviados pelo usuário sem validar a assinatura.

Decodificador JWT vs Gerador JWT: Qual Ferramenta Você Precisa?

Resposta Rápida: Use o Decodificador e Inspetor JWT para fazer o parse, auditar timestamps e verificar a assinatura de um token existente capturado de uma requisição de API ou provedor de identidade. Use o Gerador JWT quando precisar criar claims personalizadas e assinar criptograficamente um novo token HS256, HS384 ou HS512 para testes.

Ambas as ferramentas executam 100% localmente no seu navegador usando a Web Crypto API, mas atendem a lados opostos do ciclo de depuração de autenticação. Use o Decodificador e Inspetor JWT ao inspecionar um token opaco que você já possui; alterne para o Gerador JWT quando precisar emitir novos tokens de teste assinados do zero.

Recurso Decodificador e Inspetor JWT (Esta Ferramenta) Gerador JWT
Fluxo de Trabalho Principal Fazer parse, auditar e verificar um JWT existente Construir claims e assinar um novo JWT
Formato de Entrada Token compacto (<header>.<payload>.<signature>) + segredo opcional Opções de cabeçalho JOSE + claims JSON + chave secreta HMAC
Saída Produzida JSON do cabeçalho/payload formatado, auditoria de datas, validade da assinatura Token Bearer Base64URL compacto de três partes assinado
Operação Web Crypto SubtleCrypto.verify() (HMAC-SHA256/384/512) SubtleCrypto.sign() (HMAC-SHA256/384/512)
Tratamento de Timestamps Converte exp, nbf e iat em datas UTC/locais e contagens regressivas Preenche segundos Unix epoch NumericDate para TTLs personalizados
Melhor Caso de Uso em Engenharia Depurar respostas 401 Unauthorized, tokens OIDC e clock skew Gerar fixtures locais de autenticação de API, testes RBAC e testes de tokens expirados

Se você estiver trabalhando com strings Base64 ou Base64URL brutas que não são tokens JOSE de três partes (como credenciais HTTP Basic Auth ou blobs de dados binários), utilize o Codificador e Decodificador Base64.

Perguntas frequentes

FAQ e Guia Técnico do Decodificador e Inspetor JWT

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

É seguro colar JWTs de produção em um decodificador online?

Colar bearer tokens ativos em sites que processam dados no servidor traz o risco de vazar credenciais de sessão ativas em logs de acesso remotos, payloads de analytics ou sincronização de histórico do navegador. Este decodificador analisa os segmentos Base64URL e executa a verificação HMAC via Web Crypto inteiramente dentro da aba local do seu navegador, com zero requisições de rede. Ainda assim, siga boas práticas de privilégio mínimo: oculte ou rotacione segredos compartilhados caso eles tenham sido expostos fora de ambientes confiáveis.

Por que qualquer pessoa consegue decodificar o payload do meu JWT sem saber minha chave secreta?

Um JWT padrão de três partes é uma JSON Web Signature (JWS, RFC 7515), e não um token de JSON Web Encryption (JWE, RFC 7516). Em um JWS, o cabeçalho e o payload são apenas JSON UTF-8 codificados em Base64URL para transporte seguro em URLs. A chave secreta protege a integridade e a autenticidade por meio da assinatura para que ninguém possa modificar as claims sem ser detectado, mas oferece confidencialidade zero. Nunca armazene senhas em texto puro, segredos de API ou dados pessoais sensíveis (PII) não criptografados dentro de claims JWS.

Por que a verificação da assinatura falha mesmo quando minha chave secreta parece correta?

Quatro problemas causam quase todos os falsos negativos na validação HMAC: (1) incompatibilidade de codificação da chave, onde o emissor assinou com bytes binários brutos decodificados de uma string secreta em Base64/Base64URL enquanto você verificou usando os caracteres UTF-8 literais (ou vice-versa); (2) espaços em branco ou quebras de linha no início ou no fim copiados acidentalmente junto com o segredo ou token; (3) recodificar o JSON formatado (pretty-printed) em vez de verificar contra os segmentos ASCII Base64URL originais exatos; ou (4) tentar verificar um token assimétrico RS256 ou ES256 usando um segredo compartilhado HMAC em vez da chave pública do emissor.

Por que o timestamp exp do meu JWT mostra uma data dezenas de milhares de anos no futuro?

A Seção 2 da RFC 7519 define o NumericDate em segundos da época Unix (10 dígitos, como 1767225600), enquanto o método Date.now() do JavaScript retorna milissegundos da época Unix (13 dígitos, como 1767225600000). Passar milissegundos diretamente para exp ou iat multiplica o deslocamento de tempo por 1000, empurrando um timestamp de 2026 para além do ano 58000 e impedindo a expiração normal do token.

Como posso saber se um JWT é assinado (JWS) ou criptografado (JWE)?

Conte os pontos delimitadores e inspecione o cabeçalho JOSE decodificado. Um JWS assinado possui dois pontos separando três partes Base64URL (cabeçalho, payload e assinatura) e apresenta um parâmetro alg como HS256, RS256 ou ES256. Um JWE criptografado segundo a RFC 7516 possui quatro pontos separando cinco partes Base64URL (cabeçalho, chave criptografada, vetor de inicialização, texto cifrado e tag de autenticação) e inclui um parâmetro enc de criptografia de conteúdo, como A256GCM.