Sie melden sich bei einer Web-App an, und ab diesem Moment schickt Ihr Browser bei jeder Anfrage eine lange Zeichenkette mit, die mit eyJ beginnt. Kopieren Sie diese Zeichenkette in ein beliebiges Online-Tool, sehen Sie plötzlich Ihren Benutzernamen, Ihre Rolle und ein Ablaufdatum, und zwar im Klartext.
Was ist JWT? Ein JWT (JSON Web Token, ausgesprochen „Dschott“) ist ein kompaktes, digital signiertes Datenpaket aus drei Teilen: einem Header, einem Payload mit Angaben wie Benutzer-ID und Ablaufzeit und einer Signatur. Der Server stellt das Token beim Login aus, der Client schickt es bei jeder Anfrage mit, und der Server prüft anhand der Signatur, dass niemand den Inhalt verändert hat. Wichtig dabei: Ein JWT ist signiert, aber normalerweise nicht verschlüsselt. Jeder, der das Token sieht, kann es lesen.
In diesem Artikel erklären wir JWT von Grund auf: wie ein Token aufgebaut ist, wie Sie es selbst dekodieren, wann es besser ist als eine klassische Session und wo die bekannten Fallen liegen. Dabei verlassen wir uns nicht nur auf die Spezifikation. Am 19. November 2026 haben wir auf unserem eigenen Server mit den beiden verbreitetsten Node.js-Bibliotheken (jsonwebtoken 9.0.3 und jose 6.2.18) Tokens gefälscht, manipuliert, abgelaufen lassen und ein schwaches Secret geknackt. Ein paar Ergebnisse sollte jeder kennen, der JWTs einsetzt.
Eine ruhige deutschsprachige Einführung von predic8. Weiter unten folgt ein aktuelles englisches Video zu Authentifizierung und Autorisierung.
Was ist JWT? Die kurze Antwort in fünf Sätzen
- Ein JWT ist ein Text-Token aus drei Base64URL-kodierten Teilen, getrennt durch Punkte:
header.payload.signatur. - Der Payload enthält sogenannte Claims, also Aussagen wie „Benutzer 42“, „Rolle: user“, „gültig bis 08:18 Uhr“.
- Die Signatur entsteht aus Header, Payload und einem geheimen Schlüssel. Ändert jemand auch nur ein Zeichen im Payload, passt die Signatur nicht mehr.
- Der Server muss sich deshalb nichts merken: Er prüft die Signatur und weiß, dass der Inhalt von ihm selbst stammt. Das nennt man stateless.
- Weil der Inhalt nur kodiert und nicht verschlüsselt ist, gehören keine Geheimnisse in ein JWT. Und weil der Server sich nichts merkt, lässt sich ein ausgestelltes Token nicht ohne Weiteres zurückziehen.
Der Standard dahinter ist RFC 7519 aus dem Jahr 2015. Die Signatur-Seite regelt RFC 7515 (JWS), die Verschlüsselung RFC 7516 (JWE). Wenn im Alltag von „JWT“ die Rede ist, ist fast immer ein signiertes, unverschlüsseltes Token gemeint, also ein JWS.
Wie ist ein JWT aufgebaut? Header, Payload und Signatur
Dieses Token haben wir für den Test mit jsonwebtoken erzeugt (Secret: geheim, Gültigkeit 15 Minuten):
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiI0MiIsIm5hbWUiOiJBbm5hIiwicm9sZSI6InVzZXIiLCJpYXQiOjE3OTUwNzU0MDgsImV4cCI6MTc5NTA3NjMwOH0.85aOKP5abpyjvNv8jmqqXj1Eah1osQOUS9o83G4I0C4
180 Zeichen, zwei Punkte, drei Teile. Dekodiert sieht das so aus:
1. Header
{"alg":"HS256","typ":"JWT"}
Der Header sagt, wie das Token signiert ist. HS256 bedeutet HMAC mit SHA-256, also ein gemeinsames Geheimnis. Dass fast jedes JWT mit eyJ beginnt, liegt übrigens genau hier: {" gefolgt von einem Buchstaben ergibt in Base64 immer eyJ.
2. Payload
{"sub":"42","name":"Anna","role":"user","iat":1795075408,"exp":1795076308}
Das sind die Claims. Einige Namen sind im Standard festgelegt („registered claims“):
| Claim | Bedeutung | Beispiel |
|---|---|---|
sub | Subject: um wen geht es | Benutzer-ID 42 |
iat | Issued at: Ausstellungszeit (Unix-Sekunden) | 1795075408 |
exp | Expiration: läuft ab um | 1795076308 = 19.11.2026, 08:18:28 UTC |
nbf | Not before: gilt erst ab | selten genutzt |
iss | Issuer: wer hat es ausgestellt | https://auth.example.com |
aud | Audience: für wen ist es gedacht | api |
jti | JWT-ID: eindeutige Kennung | nützlich für Sperrlisten |
Alles andere (name, role) sind eigene Claims, die die Anwendung frei wählt.
3. Signatur
85aOKP5abpyjvNv8jmqqXj1Eah1osQOUS9o83G4I0C4
Das ist HMAC-SHA256(secret, base64url(header) + "." + base64url(payload)), wieder Base64URL-kodiert. Nur wer das Secret kennt, kann diese 43 Zeichen erzeugen.

JWT selbst dekodieren: ohne Online-Tool
Viele Tutorials schicken Sie für das Dekodieren auf jwt.io oder ähnliche Seiten. Das funktioniert, aber Sie kopieren dabei ein echtes, gültiges Login-Token in eine fremde Website. Bei einem Test-Token egal, bei einem Produktions-Token aus dem Admin-Bereich keine gute Idee. Dekodieren geht auch lokal, mit einer kleinen Falle.
Der naheliegende Weg mit base64 scheitert halb:
$ echo "$TOKEN" | cut -d. -f2 | base64 -d
{"sub":"42","name":"Anna","role":"user","iat":1795075408,"exp":1795076308}base64: invalid input
Die Ausgabe ist zwar da, aber base64 meldet einen Fehler und endet mit Exit-Code 1. In einem Skript mit set -e bricht das ab. Der Grund: JWT nutzt Base64URL. Dabei werden + und / durch - und _ ersetzt, und die =-Füllzeichen am Ende fehlen. Auch basenc --base64url -d aus den GNU coreutils meckert in unserem Test über die fehlende Auffüllung.
Zuverlässig mit Python (in jeder Linux-Distribution vorhanden):
python3 -c "import base64,sys;p=sys.argv[1].split('.')[1];print(base64.urlsafe_b64decode(p+'='*(-len(p)%4)).decode())" "$TOKEN"
In Node.js:
const [h, p] = token.split('.');
console.log(JSON.parse(Buffer.from(p, 'base64url').toString()));
Im Browser (DevTools-Konsole):
JSON.parse(atob(token.split('.')[1].replace(/-/g, '+').replace(/_/g, '/')))
Und die Ablaufzeit lesen Sie mit date -u -d @1795076308.
Das wichtigste Ergebnis dieses Abschnitts: Für das Lesen eines JWT braucht man keinen Schlüssel. Jeder, der das Token abfängt, im Log findet oder im LocalStorage sieht, kann den Inhalt lesen. Deshalb gehören keine Passwörter, keine Adressen, keine Kontonummern und keine internen Details in den Payload.
Wie funktioniert die Anmeldung mit JWT?
Der typische Ablauf in einer Web-App oder API:
- Der Nutzer schickt Benutzername und Passwort an
/login. - Der Server prüft die Daten und erzeugt ein JWT mit
sub, Rollen undexp. - Der Client speichert das Token (Cookie, Arbeitsspeicher oder LocalStorage) und schickt es bei jeder Anfrage mit, meist als Header:
Authorization: Bearer eyJ…. - Der Server prüft bei jeder Anfrage die Signatur und die Ablaufzeit. Passt beides, vertraut er dem Inhalt, ohne die Datenbank zu fragen.
Genau so arbeitet zum Beispiel unser eigener Agenten-Spieleserver: Beim Login gibt er ein HS256-Token mit Benutzer-ID, Name und Typ aus, gültig 30 Tage. Als Test haben wir dasselbe Token einmal ohne Signatur geschickt (nur header.payload.). Antwort: HTTP 401. So muss es sein.
Access-Token und Refresh-Token
Weil sich ein JWT schlecht zurückziehen lässt (dazu gleich mehr), haben sich in der Praxis zwei Tokens durchgesetzt:
- Access-Token: ein JWT mit kurzer Laufzeit, typischerweise 5 bis 15 Minuten. Es wird bei jeder Anfrage mitgeschickt.
- Refresh-Token: ein langlebiges, meist zufälliges Token, das der Server in der Datenbank speichert. Mit ihm holt sich der Client ein neues Access-Token, wenn das alte abgelaufen ist.
Damit bekommt man beides: Die meisten Anfragen laufen ohne Datenbank, und trotzdem kann man einen Nutzer aussperren, indem man sein Refresh-Token löscht. Spätestens nach 15 Minuten ist er dann draußen.
Englisch, aktuell (November 2026): TechPrep erklärt Authentifizierung vs. Autorisierung und die drei Teile eines JWT.
Unser Test: Was passiert, wenn man ein JWT manipuliert?
Für den Test haben wir in einem Wegwerf-Ordner auf unserem Server (Node.js 22.23.5) die beiden meistgenutzten JavaScript-Bibliotheken installiert: jsonwebtoken 9.0.3 (der Klassiker von Auth0) und jose 6.2.18 (moderner, ohne Abhängigkeiten). Zum Vergleich kam für einen Test die alte Version jsonwebtoken 8.5.1 dazu, bei deren Installation npm audit sofort „1 high severity vulnerability“ meldete. Alle Angriffe liefen nur gegen lokale Testfunktionen, nicht gegen echte Dienste.
Test 1: Rolle ändern von „user“ auf „admin“
Der einfachste Angriff: Payload dekodieren, "role":"user" durch "role":"admin" ersetzen, wieder kodieren, alte Signatur dranhängen.
| Prüfung | Ergebnis |
|---|---|
jwt.verify(token, secret) | abgelehnt: invalid signature |
jwt.decode(token) | role: "admin", kein Fehler |
Die Signatur macht ihren Job. Aber die zweite Zeile ist der eigentliche Befund: decode() prüft nichts. Die Funktion liest das Token nur aus. Wer im Code versehentlich decode statt verify benutzt, etwa weil es „schneller“ ist oder weil man nur kurz die Benutzer-ID braucht, hat überhaupt keinen Schutz. Dieser Fehler taucht in Code-Reviews erstaunlich oft auf.

Test 2: Die alg=none-Falle
Der Standard erlaubt im Header "alg":"none", also ein unsigniertes Token. Es endet mit einem Punkt und hat keine Signatur:
eyJhbGciOiJub25lIiwidHlwIjoiSldUIn0.eyJzdWIiOiI0MiIsIm5hbWUiOiJBbm5hIiwicm9sZSI6ImFkbWluIn0.
Die Idee eines Angreifers: Wenn der Server dem alg-Feld im Header glaubt, prüft er bei none einfach gar nichts. Unsere Ergebnisse:
| Szenario | Ergebnis |
|---|---|
jsonwebtoken 9.0.3, normal mit Secret | abgelehnt: jwt signature is required |
9.0.3, Schlüssel fehlt (undefined) | abgelehnt: please specify "none" in "algorithms" to verify unsigned tokens |
9.0.3, Schreibweisen None, NONE, nOnE | alle abgelehnt |
9.0.3, algorithms: ['none'] und kein Schlüssel | akzeptiert, role: admin |
jsonwebtoken 8.5.1, Schlüssel fehlt | akzeptiert, role: admin |
| 8.5.1, mit Secret | abgelehnt |
jose 6.2.18 | abgelehnt: alg none is not supported |
| selbstgeschriebene Prüffunktion (siehe unten) | akzeptiert, role: admin |
Drei Lehren daraus:
Erstens: Aktuelle Bibliotheken sind sicher, solange man sie nicht ausdrücklich unsicher konfiguriert. jsonwebtoken 9 akzeptiert ein unsigniertes Token nur, wenn Sie selbst none erlauben. jose kennt none beim Prüfen überhaupt nicht.
Zweitens: Alte Versionen sind ein echtes Risiko. In jsonwebtoken 8.5.1 reichte ein fehlender Schlüssel, und das gefälschte Admin-Token ging durch. Das ist die Lücke CVE-2022-23540, behoben mit Version 9.0.0 im Dezember 2022. Wie kann ein Schlüssel „fehlen“? Typischerweise durch eine Umgebungsvariable, die auf dem Server nicht gesetzt ist: jwt.verify(token, process.env.JWT_SECRET) mit leerem JWT_SECRET. Prüfen Sie Ihre Abhängigkeiten mit npm ls jsonwebtoken.
Drittens: Selbst gebaut ist die gefährlichste Variante. Unsere absichtlich naive Prüffunktion sah so aus, und so ähnlich findet man sie in Tutorials und Stack-Overflow-Antworten:
function verifyNaive(token, key) {
const [h, p, s] = token.split('.');
const header = JSON.parse(Buffer.from(h, 'base64url'));
if (header.alg === 'none') return JSON.parse(Buffer.from(p, 'base64url')); // ← Fehler
const sig = crypto.createHmac('sha256', key).update(h + '.' + p).digest('base64url');
if (sig !== s) throw new Error('bad signature'); // ← auch schlecht
return JSON.parse(Buffer.from(p, 'base64url'));
}
Sie fällt sofort auf alg: none herein. Zusätzlich vergleicht sie die Signatur mit !==, was theoretisch Timing-Angriffe erlaubt (richtig wäre crypto.timingSafeEqual), und sie prüft exp überhaupt nicht. Bauen Sie die JWT-Prüfung nicht selbst.

Test 3: Algorithmus-Verwechslung (RS256 → HS256)
Bei RS256 signiert der Server mit einem privaten RSA-Schlüssel und prüft mit dem öffentlichen, der oft frei abrufbar ist (zum Beispiel unter /.well-known/jwks.json). Der klassische Angriff: Man nimmt den öffentlichen Schlüssel, signiert damit ein Token per HS256 und setzt im Header "alg":"HS256". Eine schlecht gebaute Bibliothek benutzt dann den öffentlichen Schlüssel als HMAC-Secret, und die Signatur stimmt.
| Bibliothek | Ergebnis |
|---|---|
jsonwebtoken 9.0.3 | abgelehnt: invalid algorithm |
jsonwebtoken 8.5.1 | abgelehnt: invalid algorithm |
jose 6.2.18 | abgelehnt: KeyObject instances must be of type "secret" for the HS256 algorithm |
Beide Bibliotheken erkennen am Format des PEM-Schlüssels, dass es ein öffentlicher Schlüssel ist, und lehnen HMAC damit ab. Der Angriff ist trotzdem nicht erledigt: Bibliotheken in anderen Sprachen und ältere Versionen waren in der Vergangenheit betroffen. Die saubere Abwehr kostet eine Zeile: Legen Sie den Algorithmus beim Prüfen fest, statt ihn aus dem Header zu übernehmen.
jwt.verify(token, publicKey, { algorithms: ['RS256'] });
Test 4: Ablaufzeit
| Szenario | Ergebnis |
|---|---|
| Token seit 5 Sekunden abgelaufen | abgelehnt: jwt expired |
dasselbe mit clockTolerance: 10 | akzeptiert |
dasselbe mit ignoreExpiration: true | akzeptiert |
Token ohne exp | akzeptiert, für immer gültig |
Der letzte Punkt ist der wichtigste: jwt.sign() setzt kein Ablaufdatum, wenn Sie keins angeben. Ein solches Token bleibt gültig, solange das Secret gleich bleibt, also möglicherweise jahrelang. Geben Sie immer expiresIn an. Eine kleine clockTolerance (ein paar Sekunden) ist dagegen sinnvoll, wenn mehrere Server mit leicht unterschiedlichen Uhren arbeiten.
Test 5: Ein schwaches Secret knacken
Wer ein HS256-Token in die Hände bekommt, kann das Secret offline erraten: Er probiert einfach Kandidaten durch und vergleicht die Signatur. Der Server bekommt davon nichts mit, kein Rate-Limit, kein fail2ban greift.
Unser Test: ein Token mit dem Secret sommer2026, dazu eine Wortliste aus der Standardliste von John the Ripper (3.546 Einträge) mit typischen Anhängseln wie 123, !, 2025, plus Jahreszeiten mit Jahreszahlen. Insgesamt 25.004 Kandidaten.
- Gefunden nach 24.869 Versuchen in 52 Millisekunden, mit einfachem Node.js auf einem CPU-Kern.
- Reine Rechenleistung: rund 504.000 HMAC-SHA256-Prüfungen pro Sekunde auf einem Kern. Unser Server hat zwölf.
- Spezialwerkzeuge wie hashcat auf einer Grafikkarte schaffen ein Vielfaches davon.
Und: Keine der beiden Bibliotheken hat uns gewarnt. jsonwebtoken signierte klaglos mit dem Secret a (ein Zeichen), jose mit geheim. Das Secret muss also ein langer Zufallswert sein, kein Wort:
openssl rand -base64 48
Das ergibt 64 Zeichen mit 384 Bit Zufall, und dagegen ist jede Wortliste machtlos. Unser Spieleserver liest sein Secret aus einer Datei mit 96 Zeichen. Speichern Sie das Secret wie ein Passwort: nicht im Git-Repository, nicht im Frontend-Code, nicht in Docker-Images.
HS256, RS256 oder ES256: welcher Algorithmus?
| HS256 | RS256 | ES256 | |
|---|---|---|---|
| Verfahren | HMAC, ein gemeinsames Secret | RSA, privater + öffentlicher Schlüssel | Elliptische Kurve P-256 |
| Wer kann prüfen? | nur wer das Secret hat (kann damit auch fälschen) | jeder mit dem öffentlichen Schlüssel | jeder mit dem öffentlichen Schlüssel |
| Tokenlänge im Test* | 180 Zeichen | 438 Zeichen | 182 Zeichen |
| Prüfzeit im Test | 24 µs | 40 µs | 56 µs |
| Typischer Einsatz | ein einziger Dienst prüft seine eigenen Tokens | Identity-Provider (Keycloak, Auth0, Entra ID) | wie RS256, kompakter |
* HS256 mit fünf Claims; RS256 und ES256 mit identischem, kleinerem Payload. Gemessen mit jsonwebtoken 9.0.3, Mittelwert aus je 20.000 Prüfungen.
Unsere Faustregel: Prüft nur ein einziger Dienst seine eigenen Tokens, reicht HS256 mit einem langen Zufalls-Secret. Sobald mehrere Dienste Tokens prüfen sollen, nehmen Sie ein asymmetrisches Verfahren. Sonst müssen alle Dienste das Secret kennen, und jeder von ihnen könnte damit auch Tokens ausstellen. ES256 liefert dabei kürzere Tokens als RS256. Die Prüfzeit ist bei allen drei so klein, dass sie in einer echten Anwendung nicht ins Gewicht fällt.
JWT oder Session: was ist besser?
Die ehrliche Antwort: Für eine normale Website mit Login ist eine klassische Session oft die bessere Wahl. Beide Ansätze im Vergleich:
| Session-Cookie | JWT | |
|---|---|---|
| Was der Client hat | zufällige ID (bei uns 43 Zeichen) | das komplette Token (180 bis 725 Zeichen im Test) |
| Wo die Daten liegen | auf dem Server (Datenbank, Redis) | im Token selbst |
| Abmelden / Sperren | sofort: Session löschen | erst nach Ablauf, außer mit Sperrliste |
| Rechte ändern | wirkt sofort | wirkt erst mit dem nächsten Token |
| Mehrere Server | brauchen einen gemeinsamen Session-Speicher | prüfen unabhängig voneinander |
| Fremde Dienste / Mobile Apps | umständlich | dafür gemacht |
Unser „fettes“ Testtoken mit E-Mail, drei Rollen, 30 Berechtigungen, iss und aud war 725 Zeichen lang. Diese Bytes reisen bei jeder Anfrage mit, Bilder und Skripte eingeschlossen, wenn das Token im Cookie liegt. Bei einer Session ist es eine ID mit 43 Zeichen.
JWT lohnt sich vor allem, wenn: mehrere Dienste dieselbe Anmeldung prüfen müssen, ein externer Login-Anbieter Tokens ausstellt (OpenID Connect nutzt JWTs als ID-Token), Mobile Apps oder andere Programme eine API aufrufen oder Dienste untereinander kurzlebige Berechtigungen weitergeben.
Eine Session ist meist besser, wenn: es ein einzelner Server mit einer eigenen Login-Seite ist, Nutzer sich sofort abmelden lassen sollen oder Rechte sich häufig ändern.

Wo speichert man ein JWT im Browser?
Die Frage wird seit Jahren gestritten. Kurz zusammengefasst:
- LocalStorage / SessionStorage: bequem, aber jedes JavaScript auf der Seite kann das Token lesen. Eine einzige XSS-Lücke, etwa durch ein kompromittiertes npm-Paket oder ein Werbeskript, und das Token ist weg. Dafür ist es nicht anfällig für CSRF, weil der Browser es nicht automatisch mitschickt.
- HttpOnly-Cookie: JavaScript kommt nicht an das Token heran. Dafür schickt der Browser es automatisch mit, und Sie brauchen Schutz vor CSRF:
SameSite=LaxoderStrict, dazu Token- oder Origin-Prüfung. - Nur im Arbeitsspeicher (JavaScript-Variable) plus Refresh-Token im HttpOnly-Cookie: gilt als guter Kompromiss für Single-Page-Apps. Nach einem Neuladen holt die App sich über den Refresh-Endpoint ein neues Access-Token.
Für die meisten Web-Apps empfehlen wir HttpOnly + Secure + SameSite=Lax und eine kurze Laufzeit. Gegen XSS schützt keine der Varianten vollständig, denn ein Angreifer mit Skript-Zugriff kann auch ohne das Token Anfragen im Namen des Nutzers stellen. Er kann es mit dem HttpOnly-Cookie aber nicht mitnehmen und später von woanders benutzen.
Egal wo: Das Token muss immer über HTTPS übertragen werden. Wer es mitliest, ist bis zum Ablauf der Nutzer.
Ein JWT zurückziehen: das eingebaute Problem
Gestohlenes Laptop, gekündigter Mitarbeiter, geändertes Passwort: Ein bereits ausgestelltes JWT bleibt gültig, bis exp erreicht ist. Der Server hat ja bewusst nichts gespeichert. Die üblichen Gegenmittel:
- Kurze Laufzeit für Access-Tokens (5 bis 15 Minuten) und Refresh-Tokens in der Datenbank. Das ist die Standardlösung.
- Sperrliste mit der
jtigesperrter Tokens, zum Beispiel in Redis, bis zu deren Ablauf. Damit ist man allerdings wieder bei einem Speicherzugriff pro Anfrage. - Token-Version pro Nutzer: Im Token steht
ver: 7, in der Datenbank ebenfalls. Beim Passwortwechsel wird sie auf 8 erhöht, und alle alten Tokens fallen durch. Auch das kostet eine Abfrage. - Secret wechseln: macht auf einen Schlag alle Tokens ungültig, also alle Nutzer müssen sich neu anmelden. Das ist das Notfallmittel, wenn das Secret selbst kompromittiert ist.
Laufzeiten von 30 Tagen, wie bei unserem Spieleserver, sind bequem, aber eben auch 30 Tage, in denen ein gestohlenes Token funktioniert. Für einen Spieleserver mit Bot-Accounts ist das vertretbar, für ein Admin-Panel oder Online-Banking nicht.
Checkliste: JWT sicher einsetzen
- Etablierte Bibliothek nutzen und aktuell halten (
jsonwebtoken≥ 9,jose, in PythonPyJWT≥ 2, in PHPfirebase/php-jwt≥ 6). Keine eigene Prüfung bauen. verify, niedecode, wenn Sie dem Inhalt vertrauen wollen.- Algorithmus festlegen:
algorithms: ['HS256']bzw.['RS256'], nie aus dem Header übernehmen,nonenie erlauben. - Secret mit mindestens 256 Bit Zufall (
openssl rand -base64 48), außerhalb des Codes gespeichert. Beim Start prüfen, dass es gesetzt ist, und sonst abbrechen. - Immer
expsetzen, Access-Tokens kurz halten, Refresh-Tokens serverseitig speichern. issundaudprüfen, sobald mehr als ein Dienst Tokens ausstellt oder annimmt. Sonst kann ein Token für Dienst A auch bei Dienst B funktionieren.- Keine Geheimnisse in den Payload. Er ist für jeden lesbar.
- Payload klein halten. Keine kompletten Berechtigungslisten, wenn eine Rolle genügt.
- Tokens nicht in URLs (
?token=…): Die landen in Server-Logs, im Browserverlauf und im Referer-Header. - Nur über HTTPS, im Cookie mit
HttpOnly,SecureundSameSite.
Was wir nicht getestet haben
Damit niemand mehr aus unserem Test liest, als drinsteht: Wir haben nur zwei JavaScript-Bibliotheken in je einer bzw. zwei Versionen geprüft, nicht PHP, Python, Java oder Go. Verschlüsselte Tokens (JWE) haben wir ausgelassen, ebenso Angriffe über den kid- oder jku-Header, bei denen ein Angreifer den Server dazu bringt, einen von ihm gewählten Schlüssel zu laden. Auch das Knacken per Grafikkarte haben wir nicht gemessen. Die 504.000 Versuche pro Sekunde sind eine Untergrenze auf einem einzelnen CPU-Kern. Alle Tests liefen gegen lokale Funktionen, nicht gegen fremde Systeme. Der Testordner wurde danach gelöscht.
FAQ: Häufige Fragen zu JWT
Was bedeutet JWT?
JWT steht für JSON Web Token. Es ist ein offener Standard (RFC 7519) für kompakte, signierte Datenpakete im JSON-Format. Ausgesprochen wird es laut Spezifikation wie das englische Wort „jot“.
Ist ein JWT verschlüsselt?
Nein, in aller Regel nicht. Ein normales JWT ist nur Base64URL-kodiert und signiert. Jeder kann den Inhalt lesen, aber niemand kann ihn unbemerkt ändern. Verschlüsselte Tokens gibt es als JWE (RFC 7516), sie sind in Web-Apps aber selten.
Kann man ein JWT dekodieren, ohne den Schlüssel zu kennen?
Ja. Header und Payload lassen sich mit jedem Base64-Werkzeug lesen, wie oben gezeigt. Der Schlüssel wird nur gebraucht, um die Signatur zu prüfen oder ein neues Token zu erstellen.
Was ist die alg=none-Lücke?
Ein Angreifer setzt im Header "alg":"none" und lässt die Signatur weg. Prüft der Server blind nach dem Header-Algorithmus, akzeptiert er das gefälschte Token. Aktuelle Bibliotheken lehnen das ab. In unserem Test fielen aber eine alte jsonwebtoken-Version (8.5.1, bei fehlendem Schlüssel) und eine selbstgeschriebene Prüffunktion darauf herein.
Wie lange sollte ein JWT gültig sein?
Access-Tokens 5 bis 15 Minuten, Refresh-Tokens Tage bis wenige Wochen, gespeichert in der Datenbank, damit man sie widerrufen kann. Ein Token ohne exp ist unbegrenzt gültig.
Was passiert, wenn ein JWT gestohlen wird?
Der Dieb kann sich bis zum Ablauf als der Nutzer ausgeben. Darum kurze Laufzeiten, HTTPS, HttpOnly-Cookies und eine Möglichkeit zum Widerruf (Refresh-Token löschen, Token-Version erhöhen). Ist das Secret gestohlen, kann der Dieb beliebige Tokens ausstellen. Dann hilft nur ein neues Secret.
Ist JWT besser als Session-Cookies?
Nicht grundsätzlich. JWT spielt seine Stärken aus, wenn mehrere Dienste oder externe Clients die Anmeldung prüfen. Für eine einzelne Website mit eigenem Login ist eine Session oft einfacher und lässt sich sofort beenden.
Wo sollte ich ein JWT im Browser speichern?
Am besten in einem Cookie mit HttpOnly, Secure und SameSite=Lax, oder nur im Arbeitsspeicher mit einem Refresh-Token im HttpOnly-Cookie. LocalStorage ist bequem, aber für jedes Skript auf der Seite lesbar.
Wie lang muss das JWT-Secret sein?
Für HS256 mindestens 256 Bit echter Zufall, also 32 zufällige Bytes oder mehr. Ein Wort mit Jahreszahl hat unser Test in 52 Millisekunden gefunden.
Was ist der Unterschied zwischen JWT und OAuth?
OAuth 2.0 ist ein Verfahren, mit dem eine App Zugriff auf ein fremdes Konto bekommt. JWT ist ein Format für Tokens. OAuth kann JWTs als Access-Tokens benutzen, muss es aber nicht. OpenID Connect, die Login-Erweiterung von OAuth, schreibt für das ID-Token dagegen JWT vor.
Sind JWTs anfällig für CSRF?
Nur wenn sie in einem Cookie liegen, denn den schickt der Browser automatisch mit. Im Authorization-Header sind sie nicht CSRF-anfällig. Die Einzelheiten haben wir in unserem Artikel Was ist CSRF? selbst getestet.
Kann ich die Rolle im JWT einfach ändern?
Lesen ja, ändern nein. In unserem Test führte die geänderte Rolle sofort zu invalid signature, solange der Server verify() benutzt. Benutzt er nur decode(), ist die Änderung erfolgreich. Genau deshalb ist dieser Unterschied so wichtig.
Fazit: Was ist JWT, und wann sollten Sie es einsetzen?
Ein JWT ist ein signierter Ausweis, den der Server einmal ausstellt und danach nur noch prüft. Das ist elegant, weil kein Session-Speicher nötig ist, und es ist der Standard für APIs, Mobile Apps und Login-Anbieter. Es bringt aber zwei Eigenschaften mit, die man kennen muss: Der Inhalt ist öffentlich lesbar, und ein ausgestelltes Token lässt sich nicht einfach zurückholen.
Unser Test hat gezeigt, dass die aktuellen Bibliotheken die bekannten Angriffe (alg=none, Algorithmus-Verwechslung, manipulierte Payloads) zuverlässig abwehren. Gefährlich wird es an den Rändern: bei alten Versionen, bei decode() statt verify(), bei Tokens ohne Ablaufzeit, bei selbstgebauter Prüfung und vor allem bei schwachen Secrets, die keine Bibliothek beanstandet und die offline in Millisekunden fallen.
Wenn Sie heute nur drei Dinge tun: Prüfen Sie mit npm ls jsonwebtoken (oder dem Gegenstück Ihrer Sprache) die Version, legen Sie den Algorithmus beim Prüfen fest, und ersetzen Sie jedes Secret, das kein langer Zufallswert ist.
Weiterlesen: Was ist eine API?, Was ist CSRF?, HTTPS verstehen und einrichten und unser Überblick über die häufigsten IT-Sicherheitslücken.
