JSON Web Tokens (JWT): Authentifizierung erklärt

Wenn sich ein Nutzer einloggt, muss dein Server bei jeder weiteren Anfrage wissen, wer da gerade spricht. Eine moderne und weit verbreitete Lösung dafür sind JSON Web Tokens, kurz JWT. Sie ermöglichen eine zustandslose Authentifizierung, bei der dein Server keine Sitzungsdaten speichern muss. In diesem Beitrag schauen wir uns an, wie das funktioniert.

Was ist ein JWT?

Ein JWT ist ein kompakter, signierter Token, der Informationen über einen Nutzer enthält. Der Server stellt ihn nach erfolgreichem Login aus, der Client schickt ihn bei jeder Anfrage mit, und der Server kann seine Echtheit prüfen, ohne in einer Datenbank nachzuschlagen. Genau das meint zustandslos: Der Token trägt alle nötigen Informationen selbst.

Der Aufbau eines Tokens

Ein JWT besteht aus drei durch Punkte getrennten Teilen: Header.Payload.Signature. Der Header beschreibt den Algorithmus, der Payload enthält die Daten (die "Claims"), und die Signatur sichert das Ganze ab.

{
  "sub": "1234567890",
  "name": "Anton",
  "role": "admin",
  "iat": 1516239022,
  "exp": 1516242622
}

Wichtig zu wissen: Der Payload ist nur kodiert, nicht verschlüsselt. Jeder kann ihn lesen. Schreibe deshalb niemals Passwörter oder sensible Geheimnisse hinein.

Einen Token erzeugen

In Node.js nutzt du dafür das beliebte Paket jsonwebtoken. Nach erfolgreicher Anmeldung signierst du einen Token mit einem geheimen Schlüssel.

npm install jsonwebtoken

const jwt = require('jsonwebtoken');

const geheim = process.env.JWT_SECRET;

function erstelleToken(user) {
  return jwt.sign(
    { sub: user.id, name: user.name, role: user.role },
    geheim,
    { expiresIn: '1h' }
  );
}

const token = erstelleToken({ id: 42, name: 'Anton', role: 'admin' });
console.log('Token:', token);

Mit expiresIn legst du fest, wie lange der Token gültig ist. Kurze Laufzeiten erhöhen die Sicherheit.

Einen Token prüfen

Bei jeder geschützten Anfrage prüfst du, ob der Token gültig und nicht abgelaufen ist. Schlägt die Prüfung fehl, wirft jwt.verify einen Fehler.

function pruefeToken(token) {
  try {
    const daten = jwt.verify(token, geheim);
    console.log('Gültig, Nutzer:', daten.name);
    return daten;
  } catch (err) {
    console.error('Ungültiger Token:', err.message);
    return null;
  }
}

Nur wer den geheimen Schlüssel kennt, kann gültige Token erzeugen. Deshalb gehört dieser Schlüssel in eine Umgebungsvariable und niemals in den Code.

JWT als Express-Middleware

In der Praxis prüfst du Token zentral mit einer Middleware, die du vor deine geschützten Routen hängst. Der Client sendet den Token üblicherweise im Authorization-Header.

function authMiddleware(req, res, next) {
  const header = req.headers.authorization;

  if (!header || !header.startsWith('Bearer ')) {
    return res.status(401).json({ fehler: 'Kein Token' });
  }

  const token = header.split(' ')[1];

  try {
    req.user = jwt.verify(token, geheim);
    next();
  } catch (err) {
    res.status(401).json({ fehler: 'Token ungültig' });
  }
}

// Geschützte Route
app.get('/profil', authMiddleware, (req, res) => {
  res.json({ nachricht: `Hallo ${req.user.name}` });
});

Sicherheitstipps

Damit deine JWT-Authentifizierung wirklich sicher ist, beachte ein paar Grundregeln:

• Übertrage Token immer über HTTPS, niemals unverschlüsselt.
• Halte die Gültigkeitsdauer mit expiresIn kurz.
• Speichere keine sensiblen Daten im Payload, da er lesbar ist.
• Verwende einen langen, zufälligen geheimen Schlüssel aus den Umgebungsvariablen.

Fazit

JSON Web Tokens bieten eine elegante, zustandslose Möglichkeit, Nutzer zu authentifizieren. Du erzeugst einen signierten Token mit jwt.sign, der Client schickt ihn im Authorization-Header zurück, und du prüfst ihn mit jwt.verify oder einer Middleware. Wenn du den geheimen Schlüssel schützt, HTTPS nutzt und kurze Laufzeiten setzt, hast du eine solide Basis für die Authentifizierung deiner Web-Anwendung.