JSON Web-Signatur entschlüsseln: Fallstricke bei der Verifizierung, Schlüsselverwirrung und echte Sicherheitslücken

JSON-Web-Signatur (JWS) Bei der Dekodierung werden die Komponenten eines JWS-Tokens - Kopfzeile, Nutzdaten und Signatur - analysiert und überprüft, um die signierten Daten zu extrahieren und ihre Integrität zu prüfen. Im Zusammenhang mit Sicherheits- und Penetrationstests hilft die Dekodierung eines JWS den Analysten zu verstehen, welche Ansprüche eingebettet sind, Fehlkonfigurationen zu erkennen und schwache Signierungspraktiken zu identifizieren, die zu Schwachstellen wie Signaturumgehung oder Tokenfälschung führen können.

Dieser Artikel erklärt warum JWS-Dekodierung wichtig istwie man Signaturen anhand von echtem Code entschlüsselt und verifiziert, häufige Fallstricke, Auswirkungen auf die Sicherheit und Verteidigungsstrategien, die Sie im Jahr 2025 kennen sollten.

Was ist eine JSON-Web-Signatur (JWS)?

JSON-Web-Signatur (JWS) ist ein kompaktes, URL-sicheres Mittel zur Darstellung einer signierten Nachricht. Es ist definiert in RFC 7515 und wird üblicherweise verwendet, um die Authentizität und Integrität von Daten zu gewährleisten, die über REST-APIs, Single Sign-On (SSO) und Microservices-Authentifizierungsabläufe übertragen werden.

Ein typischer JWS-Token sieht so aus:

nginx

eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9. eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvZSJ9 . MEUCIQDh...

Jedes Segment ist Base64URL verschlüsselt:

1. Kopfzeile - beschreibt den Algorithmus und den Token-Typ
2. Nutzlast (Claims) - die signierten Daten
3. Unterschrift - Integritätsnachweis

Die Dekodierung eines JWS ohne Überprüfung der Signatur offenbart Behauptungen, aber nur die Überprüfung beweist, dass sie von einer vertrauenswürdigen Quelle stammen.

Maßgebliche Norm: RFC 7515 - https://tools.ietf.org/html/rfc7515

Warum einen JWS entschlüsseln? Perspektiven der Sicherheit und Prüfung

Die Entschlüsselung eines JWS dient mehreren Zwecken:

• Verstehen Sie eingebettete Ansprüche: Wer ist der Benutzer? Was sind Berechtigungen?
• Identifizieren Sie den Signieralgorithmus: Schwache Algorithmen (z.B., keine oder HS256 mit vorhersehbaren Schlüsseln)
• Bewertung der Integrität: Manipulierte Token erkennen
• Entdecken Sie Schwachstellen: Signaturumgehung, Algorithmus-Downgrade-Angriffe

Aus dem Blickwinkel der offensiven Sicherheit kann die Entdeckung schwacher JWS-Signierungspraktiken zu Exploits führen, bei denen Angreifer Token fälschen und ihre Privilegien ausweiten.

Anatomie eines JWS-Tokens

Hier ist eine Aufschlüsselung eines typischen Tokens:

Ein dekodierter JWS zeigt reines JSON für Header und Payload:

ini

HeaderJSON = base64url_decode(part1)PayloadJSON = base64url_decode(part2)

Die Entschlüsselung beweist nicht die Echtheit, sondern nur die Überprüfung der Unterschrift.

Einfache JWS-Dekodierung (ohne Verifizierung)

Bei der Sicherheitstriage besteht der erste Schritt oft darin, zu sehen, was drin ist:

Python-Beispiel (nur Dekodierung)

python

import base64import json def base64url_decode(input_str): rem = len(input_str) % 4 input_str += "=" * (4 - rem)return base64.urlsafe_b64decode(input_str) token = "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjMifQ.SflKxw... "header, payload, signature = token.split('.') header_json = json.loads(base64url_decode(header)) payload_json = json.loads(base64url_decode(payload)) print("Header:", header_json)print("Payload:", payload_json)

Dies gibt lesbares JSON aus, überprüft aber nicht, ob die Signatur korrekt ist.

Verifizierung einer JWS-Signatur (sicherheitskritisch)

Um sicher zu sein, dass das Token legitim ist, müssen Sie die Signatur mit dem erwarteten Algorithmus und Schlüssel überprüfen. So geht's:

JavaScript (Node.js) Beispiel mit jose

javaScript

import { jwtVerify } from "jose"; const token = "eyJ..."; const publicKey = /* passenden öffentlichen Schlüssel laden, z.B. vom JWKS-Endpunkt */; async function verifyToken() {try {const { payload } = await jwtVerify(token, publicKey);console.log("Verified payload:", payload); } catch (e) {console.error("Verification failed:", e); } } verifyToken();

Dadurch wird sichergestellt, dass das Token mit dem richtigen privaten Schlüssel signiert wurde, der dem öffentlichen Schlüssel entspricht.

Real-World Beispiel: Dekodierung eines OAuth-Tokens

Viele APIs geben JWS-Tokens für die Zugangskontrolle aus. Die Dekodierung offenbart Benutzer- und Sitzungsinformationen:

json

{ "iss": "", "sub": "alice", "exp": 1700000000, "scope": "read write" }

Die Sicherheitsteams überprüfen die entschlüsselten Token, um die Geltungsbereiche und Ablaufzeiten zu kontrollieren.

Häufige Schwachstellen in JWS-Implementierungen

Algorithmus Herabstufung

Einige Bibliotheken erlauben fälschlicherweise das Ändern von alg zu keineso dass Angreifer die Überprüfung umgehen können.

Beispiel für eine unsichere Kopfzeile:

json

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

Angriffsabwehr: Weisen Sie immer Token mit alg: keine es sei denn, sie sind im Kontext ausdrücklich sicher.

Schwache symmetrische Schlüssel (HS256)

Die Verwendung schwacher oder vorhersehbarer symmetrischer Schlüssel ermöglicht es Angreifern, den Schlüssel zu erraten und Token zu fälschen.

Milderung:

• Verwendung starker geheimer Schlüssel (≥ 256 Bit)
• Bevorzugen Sie asymmetrische Algorithmen (RS256, ES256)

CLI-Tools für schnelle JWS-Dekodierung

Beispiel CLI-Dekodierung:

bash

jwt decode eyJhbGciOi...

Schwachstellen-Szenario: Fälschen eines Tokens (Proof-of-Concept)

Wenn ein Server fälschlicherweise akzeptiert, dass alg: keinekann ein Angreifer fälschen:

css

Kopfzeile: {"alg":"none","typ":"JWT"} Nutzdaten: {"sub":"attacker","role":"admin"} Signatur: ""

Proof-of-Concept-Skript (Python):

python

import base64import json def b64url(x): return base64.urlsafe_b64encode(x).rstrip(b'=').decode() header = {"alg": "none", "typ": "JWT"} payload = {"sub": "attacker", "role": "admin"} token = f"{b64url(json.dumps(header).encode())}.{b64url(json.dumps(payload).encode())}. "print("Gefälschter Token:", token)

Verteidigung:

• Token ablehnen, bei denen alg ist keine sofern nicht ausdrücklich sicher
• Algorithmus-Whitelist erzwingen

Warum die Überprüfung von Unterschriften im Jahr 2025 wichtig ist

In modernen Microservices und verteilten APIs bestimmen Token die Zugriffsentscheidungen. Eine unsachgemäße Überprüfung kann dazu führen:

• Eskalation von Privilegien
• Unbefugter Zugang
• Session-Hijacking

Penetrationstester und Verteidiger müssen in der Lage sein, Token programmatisch und in großem Umfang zu entschlüsseln und zu validieren.

Erkennung fehlerhafter Verifizierung in APIs

Automatisierte Scanner können prüfen, ob eine API versucht, ungültige JWS-Signaturen zu akzeptieren.

Python-Pseudocode (Sicherheitsüberprüfung)

python

def test_broken_verification(api_url, forged_token): headers = {"Authorization": f "Bearer {forged_token}"} response = requests.get(api_url, headers=headers)return response.status_code bad_api = test_broken_verification("", forged_token)if bad_api == 200:print("Möglicherweise anfällig für JWS-Fälschungen")

Antwortet die API mit 200 OKkann die Logik der Token-Annahme fehlerhaft sein.

Bewährte Defensivpraktiken

Integration der Token-Dekodierung in die CI/CD-Sicherheit

Im Jahr 2025 validieren Sicherheits-Pipelines häufig automatisch JWS-Praktiken:

• Automatisiertes Linting von JWT-Konfigurationen
• CI-Test, der unsichere Bibliotheken ablehnt
• Laufzeitüberwachung auf fehlerhafte Token-Akzeptanz

Beispiel für ein CI-Skript-Snippet (Bash):

bash

#Reject, wenn irgendein Code "alg: none" verwendet "grep -R '"alg": *"none"' ./src && exit 1

Verwandte Konzepte: JWE vs. JWS

JWE schützt die Vertraulichkeit, JWS die Integrität und Authentizität. Viele Systeme verwenden beides zusammen.

Tools und Bibliotheken (2025 Security Stack)

• Node.js jose - JWT/JWS dekodieren und verifizieren
• Python python-jose - Flexible Kryptographie-Unterstützung
• OpenSSL - Krypto-Verifizierung auf niedriger Ebene
• jwt.io - Schneller Web-Decoder