100% Clientseitige Berechnung • Keine Server-Logs • Sofortige Ausführung
Curious TechieEntwickler-Toolbox
JWT8 Min. Lesezeit•Deutsch Edition100% Client-seitige Ausführung

Was ist ein JWT? JSON Web Token Architektur (RFC 7519)

Stateless-Authentifizierung, Header/Payload/Signatur-Aufbau, Base64URL, Algorithmus-Verwirrung und Verifikation.

CT
Curious-Techie Engineering TeamVerifizierter Autor

Web Protocols & Security Architecture Research

Veröffentlicht:
•
Aktualisiert:
•8 Min. Lesezeit
Maßgebliche Spezifikation:RFC 7519(IETF)
Geprüft von Curious-Techie Architecture Peer Review Group
Hauptfrage • Sofortige Technische Antwort

Was ist ein JWT? JSON Web Token Architektur (RFC 7519)

TL;DR — Wichtigste Entwicklungs-Erkenntnisse

  • Ein JWT besteht aus drei durch Punkte getrennten Teilen: Header, Payload und Signatur.
  • Die Nutzdaten sind lediglich in Base64URL kodiert und können von jedem ohne Geheimnis eingesehen werden.
  • Ein JWT zu dekodieren bedeutet NICHT, es zu verifizieren: Gültigkeit erfordert die Signaturprüfung.
  • Die gefährliche alg: "none"-Schwachstelle entsteht, wenn Backends unsignierte Token akzeptieren.
  • Aufgrund des zustandslosen Charakters erfordert sofortiger Widerruf Sperrlisten oder kurze Laufzeiten.
// GRUNDLAGEN

Kernkonzepte & Architektur

Compact Serialization

Structure

String format structured as `header.payload.signature` optimized for HTTP Authorization headers and URL parameters.

Registered Claims

Claims

Standard predefined metadata fields (`iss` issuer, `sub` subject, `aud` audience, `exp` expiration, `iat` issued-at).

Symmetric Signing (HS256)

Signing

Both the identity provider and the API gateway share the identical secret key to sign and verify tokens.

Asymmetric Signing (RS256 / ES256)

PKI

Identity provider signs tokens with a private key; multiple microservices verify tokens using a public JWKS endpoint.

Stateless Verification

Scalability

Services verify authorization cryptographically using keys in memory without database lookups.

Zweitfrage • Ausführungsablauf

Wie funktioniert Was ist ein JWT? JSON Web Token Architektur (RFC 7519)?

Direkte Antwort:

When an authentication server validates a user’s credentials, it constructs a JSON payload containing user identity and authorization claims. It serializes the header and payload as Base64URL strings, concatenates them with a dot, and feeds the resulting string into a cryptographic signing function along with a private secret or key. The resulting signature is appended. Downstream services verify the token by recomputing or validating the signature against the received header and payload.

1

Header Construction

Declare the signing algorithm (e.g. HS256) and type.

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

Payload Construction

Populate registered claims (`exp`, `iat`) and domain-specific roles.

{"sub": "usr_9918", "role": "admin", "exp": 1799000000}
3

Base64URL Encoding

Convert JSON bytes into URL-safe strings without padding (= characters replaced).

header_b64 = base64url(header);
payload_b64 = base64url(payload);
4

Cryptographic Signature

Hash the concatenated header and payload with secret key.

sig = HMAC_SHA256(header_b64 + "." + payload_b64, secret);
5

Token Assembly

Join all 3 components with periods to form the final compact token string.

jwt = header_b64 + "." + payload_b64 + "." + base64url(sig);
6

Bearer Token Transmission

Client includes token in Authorization header for subsequent API requests.

Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...
Technische Beispiele • Implementierung

Wie implementiert man Was ist ein JWT? JSON Web Token Architektur (RFC 7519) in der Praxis?

Verifying a JWT Signature in Node.js (Crypto Native API)

javascript
import crypto from "crypto";

function verifyHS256(jwt, secret) {
  const [headerB64, payloadB64, signatureB64] = jwt.split(".");
  if (!headerB64 || !payloadB64 || !signatureB64) return false;

  const data = `${headerB64}.${payloadB64}`;
  const expectedSig = crypto
    .createHmac("sha256", secret)
    .update(data)
    .digest("base64url");

  // Constant-time comparison to prevent timing attacks
  return crypto.timingSafeEqual(
    Buffer.from(signatureB64),
    Buffer.from(expectedSig)
  );
}

Engineering-Details: Native cryptographic verification using timing-safe buffer comparison to prevent side-channel timing attacks.

Decoding JWT Claims in Browser JavaScript (Client-Side Safe)

javascript
function parseJwtPayload(token) {
  const base64Url = token.split(".")[1];
  const base64 = base64Url.replace(/-/g, "+").replace(/_/g, "/");
  const jsonPayload = decodeURIComponent(
    atob(base64)
      .split("")
      .map((c) => "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2))
      .join("")
  );
  return JSON.parse(jsonPayload);
}

Engineering-Details: Pure client-side parsing without third-party dependencies, properly handling Unicode UTF-8 character boundaries.

Produktions-Architektur • Fallstudien

Wo und warum wird Was ist ein JWT? JSON Web Token Architektur (RFC 7519) in der Produktion eingesetzt?

Decentralized Microservices Architecture

API gateway receives user login, issues RS256 token; 50 downstream microservices independently verify claims.

Services download the gateway’s public JWKS (`/.well-known/jwks.json`) once and cache it, avoiding auth server query bottlenecks.

Mobile App API Authorization

iOS and Android native applications maintaining offline access tokens with refresh rotation.

Access token valid for 15 minutes; refresh token stored in OS Keychain used to request fresh JWTs silently.

Fallstricke & Anti-Pattern • Missverständnisse

Was sind häufige Fehler und Missverständnisse bei Was ist ein JWT? JSON Web Token Architektur (RFC 7519)?

Anti-Pattern: Treating JWT payload claims as encrypted private data

Auswirkung: Sensitive passwords, SSNs, or PII stored in payload are visible to anyone who intercepts the token.

Empfohlene Behebung: Remember that standard JWS tokens are signed, not encrypted. Use JWE (RFC 7516) or store only non-sensitive IDs in claims.

Anti-Pattern: Failing to validate the `alg` header (The "alg: none" Vulnerability)

Auswirkung: Attackers modify the header to `"alg": "none"`, strip the signature, and forge arbitrary admin permissions.

Empfohlene Behebung: Hardcode expected verification algorithms on the server (e.g. `algorithms: ["HS256"]`) and reject any `"alg": "none"`.

Anti-Pattern: Failing to validate expiration (`exp`) claim timestamps

Auswirkung: Stolen tokens remain valid perpetually, enabling indefinite account takeovers.

Empfohlene Behebung: Always mandate strict expiration checks against current UTC timestamp (`exp < Math.floor(Date.now() / 1000)`).

Bedrohungsmodellierung • Angriffsvektoren

Welche Sicherheitsrisiken und Implikationen hat Was ist ein JWT? JSON Web Token Architektur (RFC 7519)?

Algorithm Confusion Attack (HMAC vs RSA Key Confusion)

CVE-2015-9235 (Algorithm Confusion)

Schwachstelle: Server expects RS256 with public key; attacker signs token using HMAC-SHA256 with the server’s public key as the symmetric secret.

Abwehrmaßnahme: Explicitly enforce the expected algorithm; never allow client header `alg` to dictate whether verification uses a public or symmetric key.

Weak Symmetric Secrets & Brute-Forcing

CWE-326 Inadequate Encryption Strength

Schwachstelle: Using a weak HMAC secret (e.g. "secret123") allows attackers to brute-force the key offline using Hashcat at billions of guesses per second.

Abwehrmaßnahme: Generate cryptographically random secrets with at least 256 bits of entropy (32 random bytes from `/dev/urandom`).
Diagnose • Ursachenbehebung

Wie behebt man Fehler bei Was ist ein JWT? JSON Web Token Architektur (RFC 7519)?

Fehlersymptome & Anzeichen: JsonWebTokenError: invalid signature

Detaillierte Ursachenanalyse:
  • Secret key mismatch between issuer and validator
  • Payload mutated in transit
  • Trailing whitespace or padding corrupted Base64URL string
Produktionserprobte Lösung: Inspect token in Curious-Techie JWT Decoder; verify environment variable `JWT_SECRET` matches across both services.

Fehlersymptome & Anzeichen: TokenExpiredError: jwt expired

Detaillierte Ursachenanalyse:
  • `exp` timestamp in the past
  • Server clock drift between issuer and verifier servers
Produktionserprobte Lösung: Configure small clock tolerance (`clockTolerance: 10` seconds) in verifier library; ensure NTP synchronization on servers.
Wissensbasis • Direkte Technische Antworten

Häufig gestellte Fragen zu Was ist ein JWT? JSON Web Token Architektur (RFC 7519)

Q:Is the data inside a standard JWT encrypted?

Direkte Antwort:No. Standard JWTs (RFC 7519 JSON Web Signatures) are only signed and Base64URL-encoded, not encrypted. Anyone who intercepts the token can decode and view all payload claims in plaintext.

A signature guarantees integrity (that data was not tampered with) and authenticity (who created it), but provides zero confidentiality. If confidential payload data is required, JSON Web Encryption (JWE, RFC 7516) must be used.

Q:What is the difference between HS256 and RS256?

Direkte Antwort:HS256 is symmetric (both signer and verifier share one secret key). RS256 is asymmetric (the identity provider signs with a private key, and anyone can verify using the public key).

HS256 is ideal for monolithic apps where only one backend needs to verify the token. RS256 is preferred in microservices because worker services only need the public key and cannot forge their own tokens.

Q:How do you revoke a JWT before it expires?

Direkte Antwort:Because JWTs are stateless, instant revocation requires checking a centralized blacklist (e.g. in Redis) or keeping token lifetimes very short (e.g. 10 minutes) and revoking the refresh token.

Pure statelessness means the token is self-contained. To revoke immediately, architectures typically store a `jti` (JWT ID) blacklist in a low-latency Redis cache or invalidate the user’s token generation counter.

Abschnitt 12 • Interaktive Werkzeuge

Verwandte Entwickler-Werkzeuge

100% Client-seitige Ausführung

Companion Interactive Tool100% Client-Side Execution

Test & Verify with JWT Decoder

Decode and inspect JWT headers, payloads, and signatures securely.

Open JWT Decoder→
Companion Interactive Tool100% Client-Side Execution

Test & Verify with JWT Security Inspector

Audit JWT vulnerabilities: none algorithm, weak signing, and claim flaws.

Open JWT Security Inspector→
Companion Interactive Tool100% Client-Side Execution

Test & Verify with Base64 Encoder / Decoder

Encode and decode Base64 strings and UTF-8 text client-side.

Open Base64 Encoder / Decoder→
Companion Interactive Tool100% Client-Side Execution

Test & Verify with Cryptographic Hash Generator

Generate SHA-256, SHA-384, SHA-512, SHA-1, and MD5 hashes locally.

Open Cryptographic Hash Generator→

Glossar

JWT
JSON Web Token: Compact URL-safe means of representing claims to be transferred between two parties.
Claim
A piece of information asserted about a subject, represented as a key-value pair in the JSON payload.
Base64URL
URL-safe Base64 encoding where + is replaced with -, / is replaced with _, and padding = is omitted.
JWKS
JSON Web Key Set: A JSON data structure representing a set of public cryptographic keys.
Authoritative Sourcing & Verification

References & Primary Sources

Every source below directly substantiates technical statements and protocol behaviors explained in Was ist ein JWT? JSON Web Token Architektur (RFC 7519). Curious-Techie prioritizes official Internet standards (IETF RFCs, W3C Recommendations, WHATWG specifications) and established security bodies (OWASP, NIST). Zero sponsored or secondary links.

  1. [1]IETFPrimary SpecificationRFC 7519 • Section 3 & 4
    Verified Primary Source
    RFC 7519: JSON Web Token (JWT)
    Technical Claim Supported:

    Defines the compact, URL-safe format of JSON Web Tokens consisting of three Base64URL segments (Header, Payload, Signature) and registered claims (iss, sub, aud, exp, nbf, iat, jti).

    “A JWT is represented as the concatenation of the Encoded JWT Header, the Encoded JWT Claims Set, and the Encoded JWT Signature or Encoded JWT Encryption Data, with the parts being separated by period ('.') characters.”
    Source URI: https://datatracker.ietf.org/doc/html/rfc7519
  2. [2]IETFPrimary SpecificationRFC 7515 • Section 4 (Cryptographic Signatures)
    Verified Primary Source
    RFC 7515: JSON Web Signature (JWS)
    Technical Claim Supported:

    Defines digital signatures and MAC algorithms (HS256, RS256, ES256) used to secure JWT integrity and verify token authorship.

    Source URI: https://datatracker.ietf.org/doc/html/rfc7515
  3. [3]IETFAuthoritative Security StandardRFC 8725 • Security Considerations § 3
    Verified Primary Source
    RFC 8725: JSON Web Token Best Current Practices
    Technical Claim Supported:

    Mandates explicit algorithm validation on receiving servers, prohibiting the insecure "alg: none" algorithm and enforcing strict signature verification.

    Source URI: https://datatracker.ietf.org/doc/html/rfc8725
  4. [4]OWASPAuthoritative Security StandardOWASP Cheat Sheet Series • Token Storage & Revocation
    Verified Primary Source
    OWASP JSON Web Token Cheat Sheet
    Technical Claim Supported:

    Details token theft mitigation, recommending storage in secure HttpOnly cookies over localStorage and outlining token revocation strategies.

    Source URI: https://cheatsheetseries.owasp.org/cheatsheets/JSON_Web_Token_for_Java_Cheat_Sheet.html
Semantic Internal Links (GEO)

Zugehöriges technisches Ökosystem & nächste Schritte

Context: JSON Web Tokens & Stateless Auth

Verwandte Entwickler-Werkzeuge

100% Client-seitige Ausführung
100% Client-Side→

JWT Decoder & Inspector

Inspect decoded header and payload claims with real-time signature validity checking in browser memory.

Security Audit→

JWT Security Inspector

Audit tokens for algorithm confusion (alg: none), weak HMAC secrets, and sensitive claim exposure.

Verwandte Fachartikel

Architektur-Definitionen
Comparison→

JWT vs Session-Based Authentication: Architecture & Performance

Compare database session lookups with stateless JWT verification across scalability and revocation.

Troubleshooting→

Troubleshooting: JWT Works in Postman but Fails in Browser

Diagnose and remediate CORS header stripping, HttpOnly cookie constraints, and preflight authorization failures.

Verwandte technische Fragen

Direkte Antwort (AEO-Zusammenfassung)
Q&A

Can a JWT Be Decrypted by Anyone?

→

Answer: Yes, standard JSON Web Tokens (JWS) are signed, not encrypted. Anyone can decode and inspect the payload without the secret key.

Q&A

Why Shouldn't You Store JWTs in LocalStorage?

→

Answer: Storing tokens in localStorage exposes them to instant exfiltration by any Cross-Site Scripting (XSS) vulnerability.

Q&A

Can an Expired JWT Token Still Be Verified?

→

Answer: Yes, the cryptographic signature remains mathematically valid, but compliant libraries reject the token because exp is checked after signature verification.

Entwickler-Spezifikationen & Referenzen

Schnellübersichtstabelle
RFC 7519→

JWT Claims Reference & Specifications

Standard registered claims (sub, iss, exp, nbf, iat) and custom claim dictionaries.

RFC 6749→

OAuth 2.0 Concepts & Grant Types Matrix

Authorization Code with PKCE, Client Credentials, and token exchange flows.

Themen-Cluster erkunden →

Weiterlernen

Theory → Hands-On Lab Verification
Engineering-Empfehlung

JWT Interactive Tampering & Validation Lab

Put your theoretical understanding into practice by tampering with claims and testing signature rejection in the live sandbox.

Zum nächsten Schritt →JWT Topic Architecture Cluster→