Ferramenta JWT

Sugestões Relacionadas

Casos de uso

• Decodificar JWT online: dividir rapidamente um token durante a depuração de login OAuth 2.0 / OIDC para inspecionar algoritmo do Header e Claims do Payload
• Verificar assinaturas JWT: use um Secret / chave pública para validar assinaturas de token em tempo real e decidir se um 401 é 'assinatura ruim', 'expirado' ou 'algoritmo incompatível'
• Gerar JWTs de teste durante integração: emita um JWT no navegador com um par de chaves de teste, sem precisar que o backend altere temporariamente o código para gerar um token
• Conversão PEM ↔ JWK: o OIDC IdP te deu JWK mas o servidor precisa de PEM (ou vice-versa) — converta no lugar em vez de escrever um script OpenSSL
• Diagnosticar 401 Unauthorized: verifique expiração, correspondência alg-vs-gateway, correspondência de chave e formatação PEM passo a passo
• Comparar RS256 vs PS256: muitos provedores OIDC usam RS256 por padrão enquanto AWS SigV4 prefere PS256 — troque algoritmos com o mesmo par de chaves RSA e compare resultados
• Aprender internals do JWT: mude o alg, edite o Payload, troque a chave no navegador e veja a assinatura quebrar em tempo real — muito mais rápido que ler o RFC

Recursos

• Decodificar + Verificar + Gerar em um só lugar: cole um token para dividir Header/Payload/Signature, troque algoritmo e chave para verificar a assinatura, edite Claims e reassine para produzir um novo token — cobre toda a cadeia de solução de problemas JWT
• Todos os 13 algoritmos suportados: HS256/HS384/HS512 (HMAC), RS256/RS384/RS512 (RSA-PKCS1-v1_5), ES256/ES384/ES512 (ECDSA), PS256/PS384/PS512 (RSA-PSS), EdDSA — cobre OAuth 2.0, OIDC, JWS, gateways de API e SSO empresarial
• Formatos PEM e JWK: chaves RSA, ECDSA e Ed25519 aceitam strings PEM (com cabeçalhos -----BEGIN PUBLIC KEY-----) e JSON JWK (campos kid/kty/n/e) — insira diretamente a saída OIDC /.well-known/jwks.json
• Múltiplas formas de entrada de segredo HMAC: string UTF-8 bruta, bytes hex ou codificado Base64/Base64URL — troque com um clique, para que 'parece igual mas assinatura falha' nunca aconteça
• Geração automática de par de chaves: pares de chaves RSA-2048, RSA-4096, P-256, P-384 e Ed25519 gerados no navegador, apresentados em formatos PEM e JWK para uso imediato em testes
• Destaque semântico de Claims: exp / iat / nbf convertidos automaticamente para hora legível com status expirado / ainda-não-válido / emitido destacado; alg / typ / kid no Header rotulados individualmente
• 100% no lado do cliente, zero upload: cada parse, verify e sign roda via Web Crypto API nativo do navegador — tokens, chaves e payload nunca saem do navegador, seguindo o princípio de segurança de 'nunca colar tokens de produção em ferramentas online aleatórias'
• Cópia com um clique: Header, Payload, Signature e o token recém-gerado são copiáveis independentemente para documentação, tickets e comandos curl

Como Usar

1. Cole ou digite o token: coloque a string JWT no campo de entrada; a ferramenta divide automaticamente Header, Payload e Signature e exibe cada um como JSON formatado
2. Selecione o algoritmo: alterne entre HS256 / RS256 / ES256 / PS256 / EdDSA; a ferramenta infere do Header.alg e sinaliza qualquer incompatibilidade
3. Importe uma chave: cole um segredo HMAC, uma string PEM ou um JSON JWK; para algoritmos assimétricos, clique em 'Gerar par de chaves' para obter uma chave de teste imediatamente
4. Verifique ou reassine: no modo Decode, verifique com chave pública e veja '✅ assinatura válida / ❌ assinatura inválida'; no modo Encode, edite Claims e assine com chave privada para produzir um novo token

Perguntas frequentes

O que é Decodificar, Verificar e Gerar JWT?

Code Examples

const crypto = require('node:crypto')

function b64url(input) {
  return Buffer.from(input)
    .toString('base64')
    .replace(/\+/g, '-')
    .replace(/\//g, '_')
    .replace(/=+$/, '')
}

function hmacSign(data, secret) {
  return b64url(crypto.createHmac('sha256', secret).update(data).digest())
}

function sign(payload, secret) {
  const header = b64url(JSON.stringify({ alg: 'HS256', typ: 'JWT' }))
  const body = b64url(JSON.stringify(payload))
  const signature = hmacSign(`${header}.${body}`, secret)
  return `${header}.${body}.${signature}`
}

function verify(token, secret) {
  const [h, p, s] = token.split('.')
  const expected = hmacSign(`${h}.${p}`, secret)
  const a = Buffer.from(s)
  const b = Buffer.from(expected)
  return a.length === b.length && crypto.timingSafeEqual(a, b)
}

const SECRET = 'my-super-secret-key'
const payload = { userId: 42, role: 'admin', exp: Math.floor(Date.now() / 1000) + 3600 }
const token = sign(payload, SECRET)

console.log(token)
console.log(verify(token, SECRET))       // true
console.log(verify(token, 'wrong-key'))  // false

<!doctype html>
<html>
  <body>
    <pre id="out"></pre>
    <script>
      const out = document.getElementById('out')

      const b64url = buf =>
        btoa(String.fromCharCode(...new Uint8Array(buf)))
          .replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')

      const b64urlStr = str => b64url(new TextEncoder().encode(str))

      async function sign(payload, secret) {
        const header = b64urlStr(JSON.stringify({ alg: 'HS256', typ: 'JWT' }))
        const body = b64urlStr(JSON.stringify(payload))
        const data = new TextEncoder().encode(`${header}.${body}`)

        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, data)
        return `${header}.${body}.${b64url(sig)}`
      }

      ;(async () => {
        const token = await sign({ user: 'alice', role: 'admin' }, 'browser-demo-secret')
        out.textContent = token
      })()
    </script>
  </body>
</html>

import { jwtVerify, importSPKI } from 'jose'
import { readFile } from 'node:fs/promises'

const token = 'eyJhbGciOiJSUzI1NiIsImtpZCI6IjEifQ.payload.signature'
const publicKeyPem = await readFile('public.pem', 'utf8')

try {
  const { payload, protectedHeader } = await jwtVerify(
    token,
    await importSPKI(publicKeyPem, 'RS256'),
    {
      issuer: 'https://idp.example.com',
      audience: 'my-app',
      algorithms: ['RS256'],     // critical: algorithm whitelist blocks alg:none and HS256-substitution attacks
    }
  )
  console.log('alg =', protectedHeader.alg)
  console.log('sub  =', payload.sub)
} catch (err) {
  console.error('verify failed:', err.code, err.message)
  // common: ERR_JWT_EXPIRED / ERR_JWS_INVALID / ERR_JWS_SIGNATURE_VERIFICATION_FAILED
}

import jwt

token = 'eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjM0In0.SflKxw'

# Parse (no signature check, just look at Header and Payload)
print(jwt.get_unverified_header(token))
# {'alg': 'HS256', 'typ': 'JWT'}

print(jwt.decode(token, options={'verify_signature': False}))
# {'sub': '1234'}

# Full verification
claims = jwt.decode(
    token,
    'my-super-secret-key',
    algorithms=['HS256'],
    audience='my-app',
    issuer='my-service',
)
print(claims['sub'])

Supported Video Formats

Output Example

A real MP3 file encoded to a Data URI — copy-ready:

Header (Base64URL): eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9
Payload (Base64URL): eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkphbmUgRG9lIiwiaWF0IjoxNzE2MjM5MDIyfQ
Signature: kZJfaYjK3iCkVFL5EL9zGRZ5SmD8_x2h6B5c7pVFfVGo

Privacy & Security

Esta bancada JWT roda 100% no seu navegador, apoiada pelo Web Crypto API nativo do navegador. O token que você cola, o Header, o Payload, a Signature, o Segredo HMAC, quaisquer chaves privadas RSA/ECDSA, quaisquer pares de chaves gerados e cada cálculo de assinatura/verificação permanecem no seu dispositivo — eles nunca viajam para um servidor, nunca são registrados, nunca analisados e nunca armazenados em cache. A página pode ser usada offline após ser carregada. Melhor prática: nunca cole tokens de produção de longa duração ou chaves privadas de produção em nenhuma ferramenta online, incluindo esta. Esta ferramenta é apropriada para depuração, teste de integração, aprendizado e geração de tokens de teste — segredos de produção e chaves privadas devem ser tratados em um ambiente controlado e local.

Authoritative References

• IETFRFC 7519: JSON Web Token (JWT)
• IETFRFC 7515: JSON Web Signature (JWS)
• IETFRFC 7517: JSON Web Key (JWK)
• Auth0JWT.io — official debugger and library index
• OWASPOWASP JSON Web Token Cheat Sheet
• IETFJOSE working group overview

Troubleshooting