JWT Encoder

Was ist JWT-Kodierung?

JWT-Kodierung ist der Prozess der Erstellung eines JSON Web Token — eine kompakte, URL-sichere Zeichenkette, die eine Reihe von Claims trägt, die mit einem kryptografischen Schlüssel signiert sind. Das Ergebnis ist ein dreiteiliges Token (Header.Payload.Signatur), das in RFC 7519 definiert ist und von Servern ohne Sitzungsverwaltung verifiziert werden kann. JWT-Online-Kodierung ermöglicht es Ihnen, Token direkt in Ihrem Browser zu erstellen und zu signieren, um Tests und Entwicklung durchzuführen.

Der Header deklariert den Signaturalgorithmus (z.B. HS256) und den Token-Typ. Die Payload enthält Claims — Schlüssel-Wert-Paare wie das Subjekt (sub), Ablaufzeit (exp) und alle benutzerdefinierten Daten, die Ihre Anwendung benötigt. Beide Teile werden als JSON serialisiert und dann base64url-kodiert. Die Signatur wird über den kodierten Header und die Payload mit einem geheimen Schlüssel berechnet, wodurch alle drei Segmente verbunden werden.

Im Gegensatz zu Session-Cookies sind JWTs selbstständig: Der Prüfer muss nicht auf eine Datenbank zugreifen oder einen externen Dienst aufrufen. Dies macht JWT-basierte Authentifizierung in REST-APIs, Microservices und Single-Page-Anwendungen beliebt, wo zustandslose Autorisierung die Latenz reduziert und die horizontale Skalierung vereinfacht.

Warum einen JWT Encoder verwenden?

Die manuelle JWT-Generierung erfordert base64url-Kodierung, JSON-Serialisierung und HMAC-Berechnung. Dieses Tool führt alle drei Schritte sofort durch, damit Sie sich auf die richtigen Claims konzentrieren können.

JWT Encoder Anwendungsfälle

HS256 vs HS384 vs HS512: HMAC-Algorithmen Vergleich

Alle drei Algorithmen verwenden HMAC (Hash-based Message Authentication Code) mit einem gemeinsamen Geheimnis. Der Unterschied liegt in der zugrunde liegenden Hash-Funktion, die die Signaturgröße und den Sicherheitsrand beeinflusst. Für die meisten Anwendungen bietet HS256 ausreichende Sicherheit. Wählen Sie HS384 oder HS512, wenn Compliance-Anforderungen (z.B. FIPS-140) einen stärkeren Hash erfordern oder wenn Ihre Tokens hochwertige Autorisierungsentscheidungen tragen.

Standard JWT Claims Referenz

RFC 7519 definiert sieben registrierte Claims. Keine sind erforderlich, aber die korrekte Verwendung verbessert Interoperabilität und Sicherheit. Der exp-Claim ist besonders wichtig — Tokens ohne Ablaufzeit sind auf unbegrenzte Zeit gültig, wenn das Geheimnis nicht rotiert wird.

JWT-Kodierung in Code

Diese Beispiele zeigen, wie man JWTs programmatisch erstellt und signiert. Jedes Snippet produziert einen gültigen HS256-signierten Token. Für Produktionssysteme setzen Sie immer den exp-Claim und verwenden ein kryptografisch zufälliges Geheimnis von mindestens 256 Bits.

async function signJWT(payload, secret, alg = 'HS256') {
  const header = { alg, typ: 'JWT' }
  const enc = new TextEncoder()

  // Base64url encode header and payload
  const b64url = (obj) =>
    btoa(JSON.stringify(obj)).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')

  const h = b64url(header)
  const p = b64url(payload)

  // Sign with HMAC-SHA256
  const key = await crypto.subtle.importKey(
    'raw', enc.encode(secret),
    { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']
  )
  const sig = await crypto.subtle.sign('HMAC', key, enc.encode(`${h}.${p}`))
  const s = btoa(String.fromCharCode(...new Uint8Array(sig)))
    .replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')

  return `${h}.${p}.${s}`
}

// Usage
const token = await signJWT(
  { sub: 'user-123', name: 'Alice', iat: Math.floor(Date.now() / 1000) },
  'your-256-bit-secret'
)
// → "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOi..."

import jwt
import time

payload = {
    "sub": "user-123",
    "name": "Alice",
    "iat": int(time.time()),
    "exp": int(time.time()) + 3600,  # expires in 1 hour
}

# Sign with HS256 (default)
token = jwt.encode(payload, "your-256-bit-secret", algorithm="HS256")
# → "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOi..."

# Verify and decode
decoded = jwt.decode(token, "your-256-bit-secret", algorithms=["HS256"])
# → {"sub": "user-123", "name": "Alice", "iat": 1717200000, "exp": 1717203600}

const jwt = require('jsonwebtoken')

const payload = {
  sub: 'user-123',
  name: 'Alice',
  role: 'admin',
}

// Sign — iat is added automatically
const token = jwt.sign(payload, 'your-256-bit-secret', {
  algorithm: 'HS256',
  expiresIn: '1h',    // sets exp claim
  issuer: 'auth.example.com',  // sets iss claim
})

// Verify
const decoded = jwt.verify(token, 'your-256-bit-secret')
// → { sub: 'user-123', name: 'Alice', role: 'admin', iat: ..., exp: ... }

package main

import (
    "fmt"
    "time"
    "github.com/golang-jwt/jwt/v5"
)

func main() {
    claims := jwt.MapClaims{
        "sub":  "user-123",
        "name": "Alice",
        "iat":  time.Now().Unix(),
        "exp":  time.Now().Add(time.Hour).Unix(),
    }

    token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
    signed, _ := token.SignedString([]byte("your-256-bit-secret"))
    fmt.Println(signed)
    // → eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOi...
}

Häufig gestellte Fragen