JWT Decoder, Verifizierer & Generator

Ähnliche Tools

Anwendungsfälle

• JWT online decodieren: Token schnell während des OAuth 2.0 / OIDC Login-Debuggings aufteilen, um Header-Algorithmus und Payload-Claims zu inspizieren
• JWT-Signaturen verifizieren: Secret / öffentlichen Schlüssel verwenden, um Token-Signaturen in Echtzeit zu validieren und zu entscheiden, ob ein 401 'falsche Signatur', 'abgelaufen' oder 'Algorithmus-Mismatch' ist
• Test-JWTs während der Integration generieren: JWT im Browser mit einem Test-Schlüsselpaar ausstellen, keine Notwendigkeit, das Backend zu bitten, den Code vorübergehend zu ändern, um ein Token zu erstellen
• PEM ↔ JWK-Konvertierung: der OIDC IdP hat Ihnen JWK gegeben, aber der Server benötigt PEM (oder umgekehrt) — vor Ort konvertieren, anstatt ein OpenSSL-Skript zu schreiben
• 401 Unauthorized diagnostizieren: Ablauf, Algorithmus-zu-Gateway-Übereinstimmung, Schlüsselübereinstimmung und PEM-Formatierung nacheinander durchgehen
• RS256 vs PS256 vergleichen: viele OIDC-Provider verwenden standardmäßig RS256, während AWS SigV4 PS256 bevorzugt — Algorithmen mit demselben RSA-Schlüsselpaar wechseln und Ergebnisse vergleichen
• JWT-Interna lernen: Algorithmus ändern, Payload bearbeiten, Schlüssel im Browser austauschen und beobachten, wie die Signatur in Echtzeit bricht — viel schneller als das RFC lesen

Funktionen

• Decodieren + Verifizieren + Generieren an einem Ort: Token einfügen, um Header/Payload/Signature zu trennen, Algorithmus und Schlüssel wechseln, um die Signatur zu verifizieren, Claims bearbeiten und neu signieren, um ein neues Token zu erzeugen — deckt die gesamte JWT-Fehlerbehebungskette ab
• Alle 13 Algorithmen unterstützt: HS256/HS384/HS512 (HMAC), RS256/RS384/RS512 (RSA-PKCS1-v1_5), ES256/ES384/ES512 (ECDSA), PS256/PS384/PS512 (RSA-PSS), EdDSA — deckt OAuth 2.0, OIDC, JWS, API-Gateways und Enterprise-SSO ab
• PEM- und JWK-Formate: RSA-, ECDSA- und Ed25519-Schlüssel akzeptieren PEM-Zeichenketten (mit -----BEGIN PUBLIC KEY----- Kopfzeilen) und JWK-JSON (kid/kty/n/e-Felder) — OIDC /.well-known/jwks.json Ausgabe direkt einfügen
• Mehrere HMAC-Secret-Eingabeformen: rohe UTF-8-Zeichenkette, Hex-Bytes oder Base64/Base64URL-kodiertes Secret — mit einem Klick wechseln, damit 'sieht gleich aus, aber Signatur schlägt fehl' nie passiert
• Automatische Schlüsselpaar-Generierung: RSA-2048, RSA-4096, P-256, P-384 und Ed25519 Schlüsselpaare im Browser generiert, in beiden PEM- und JWK-Formaten für sofortige Testnutzung präsentiert
• Semantische Claims-Hervorhebung: exp / iat / nbf automatisch in menschenlesbare Zeit umgewandelt mit abgelaufen / noch-nicht-gültig / ausgestellt Status hervorgehoben; alg / typ / kid im Header einzeln beschriftet
• 100% clientseitig, kein Upload: jede Analyse, Verifizierung und Signatur läuft über die native Web Crypto API des Browsers — Tokens, Schlüssel und Payload verlassen nie den Browser, entsprechend dem Sicherheitsprinzip 'niemals Produktions-Tokens in zufällige Online-Tools einfügen'
• Ein-Klick-Kopieren: Header, Payload, Signature und das neu generierte Token sind jeweils unabhängig kopierbar für Dokumentation, Tickets und curl-Befehle

Anleitung

1. Token einfügen oder eingeben: JWT-Zeichenkette in das Eingabefeld ablegen; das Tool teilt automatisch Header, Payload und Signature auf und gibt jedes als JSON formatiert aus
2. Algorithmus auswählen: zwischen HS256 / RS256 / ES256 / PS256 / EdDSA wechseln; das Tool leitet aus Header.alg ab und markiert jeden Mismatch
3. Schlüssel importieren: HMAC-Secret, PEM-Zeichenkette oder JWK-JSON einfügen; für asymmetrische Algorithmen auf 'Schlüsselpaar generieren' klicken, um sofort einen Test-Schlüssel zu erhalten
4. Verifizieren oder neu signieren: im Decode-Modus mit öffentlichem Schlüssel verifizieren und '✅ Signatur gültig / ❌ Signatur ungültig' sehen; im Encode-Modus Claims bearbeiten und mit privatem Schlüssel signieren, um ein neues Token zu erzeugen

Häufig gestellte Fragen

Was ist JWT Decoder, Verifizierer & Generator?

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'],     // kritisch: Algorithmus-Whitelist blockiert alg:none und HS256-Substitutionsangriffe
    }
  )
  console.log('alg =', protectedHeader.alg)
  console.log('sub  =', payload.sub)
} catch (err) {
  console.error('verify failed:', err.code, err.message)
  // häufig: ERR_JWT_EXPIRED / ERR_JWS_INVALID / ERR_JWS_SIGNATURE_VERIFICATION_FAILED
}

import jwt

token = 'eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjM0In0.SflKxw'

# Analysieren (keine Signaturprüfung, nur Header und Payload ansehen)
print(jwt.get_unverified_header(token))
# {'alg': 'HS256', 'typ': 'JWT'}

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

# Vollständige Verifizierung
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

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

Payload decodiert:
  {
    "sub": "1234567890",
    "name": "Jane Doe",
    "iat": 1716239022        // 2024-05-20 14:23:42 UTC
  }

Privacy & Security

Diese JWT-Werkbank läuft zu 100% in Ihrem Browser, unterstützt durch die native Web Crypto API des Browsers. Das Token, das Sie einfügen, der Header, die Payload, die Signature, das HMAC-Secret, alle RSA/ECDSA-Privatschlüssel, alle generierten Schlüsselpaare und jede Signatur/Verifizierungsberechnung bleiben auf Ihrem Gerät — sie reisen niemals zu einem Server, werden niemals protokolliert, niemals analysiert und niemals zwischengespeichert. Die Seite kann nach dem Laden offline verwendet werden. Best Practice: niemals langlebige Produktions-Tokens oder Produktions-Privatschlüssel in ein Online-Tool einfügen, einschließlich dieses. Dieses Tool ist geeignet zum Debuggen, Integrationstesten, Lernen und Erstellen von Test-Tokens — Produktions-Secrets und Privatschlüssel sollten in einer kontrollierten, lokalen Umgebung verarbeitet werden.

Authoritative References

• IETFRFC 7519: JSON Web Token (JWT)
• IETFRFC 7515: JSON Web Signature (JWS)
• IETFRFC 7517: JSON Web Key (JWK)
• Auth0JWT.io — offizieller Debugger und Bibliotheksindex
• OWASPOWASP JSON Web Token Cheat Sheet
• IETFJOSE-Arbeitsgruppenübersicht

Troubleshooting