API (Application Programming Interface)
Eine definierte Schnittstelle, über die Softwaresysteme miteinander kommunizieren können – der Standard für die Integration von KI-Diensten in Anwendungen.
Ein kompakter, URL-sicherer Token-Standard für die signierte Übertragung von Informationen zwischen Parteien – häufig genutzt für API-Authentifizierung.
Ein JWT (JSON Web Token) ist ein signierter Token, der Informationen enthält und bei API-Requests zur Authentifizierung oder Autorisierung mitgesendet werden kann. Der Server kann den Token oft prüfen, ohne eine klassische Session-Datenbank abzufragen.
Der Ablauf:
1. Login
User → [email + password] → Server
Server → [JWT] → User
2. API-Requests
User → [Request + JWT im Header] → Server
Server prüft JWT-Signatur
Server → [Response] → User
JWT-Struktur:
base64url(header).
base64url(payload).
base64url(signature)
Header.Payload.Signature
| Teil | Inhalt | Beispiel |
|---|---|---|
| Header | Algorithmus, Typ | {"alg": "HS256", "typ": "JWT"} |
| Payload | Claims (Daten) | {"sub": "user-id", "exp": expiry_timestamp} |
| Signature | Signatur | HMAC-SHA256(header + payload, secret) |
Node.js Beispiel:
const jwt = require('jsonwebtoken');
const token = jwt.sign(
{
sub: userId,
role: userRole,
iat: Math.floor(Date.now() / 1000),
exp: Math.floor(Date.now() / 1000) + accessTokenLifetime
},
process.env.JWT_SECRET,
{ algorithm: 'HS256' }
);
try {
const decoded = jwt.verify(token, process.env.JWT_SECRET);
console.log(decoded);
// { sub: userId, role: userRole, ... }
} catch (err) {
if (err.name === 'TokenExpiredError') {
// Token abgelaufen
} else if (err.name === 'JsonWebTokenError') {
// Ungültige Signatur
}
}
| Claim | Name | Beschreibung |
|---|---|---|
iss | Issuer | Wer hat den Token ausgestellt? |
sub | Subject | Für wen ist der Token? (User ID) |
aud | Audience | Für welchen Service? |
exp | Expiration | Wann läuft er ab? |
iat | Issued At | Wann wurde er ausgestellt? |
nbf | Not Before | Ab wann gültig? |
jti | JWT ID | Eindeutige Token-ID |
Login:
Server → kurzlebiges Access Token + länger geschütztes Refresh Token
API-Request:
Client → Access Token → Server
↓
Abgelaufen?
↓
Client → Refresh Token → Server
Server → Neuer Access Token → Client
Warum zwei Tokens?
Do:
Don’t:
none-Algorithmus oder unerwartete Algorithmen nicht akzeptieren| Aspekt | JWT | Session |
|---|---|---|
| Speicherort | Client | Server |
| Skalierung | oft einfacher stateless möglich | benötigt Session Store oder Replikation |
| Invalidierung | ohne Zusatzmechanismen schwieriger | zentral oft einfacher |
| Größe | größer, weil Claims enthalten sein können | klein, meist nur ID |
| Microservices | häufig gut nutzbar | abhängig von Session-Architektur |
| Algorithmus | Typ | Empfehlung |
|---|---|---|
| HS256 | Symmetric (HMAC) | passend bei sicher geteilter Secret-Verwaltung |
| RS256 | Asymmetric (RSA) | häufig bei verteilter Verifikation |
| ES256 | Asymmetric (ECDSA) | kompaktere Signaturen möglich |
| none | keine Signatur | in produktiven Auth-Flows nicht akzeptieren |
Ein JWT ist wie ein Konzertticket mit Hologramm: Es enthält deine Infos (Name, Sitzplatz), ist fälschungssicher (Signatur), und der Türsteher kann es prüfen, ohne die Ticketdatenbank zu fragen.
Selbstbeschreibend: Enthält relevante Claims im Token selbst
Signiert: Manipulation kann bei korrekter Prüfung erkannt werden
Stateless möglich: Server muss nicht zwingend klassische Sessions speichern
API-Authentifizierung
User loggt ein, erhält JWT, sendet es bei jedem Request
Single Sign-On (SSO)
Ein Login für mehrere Anwendungen
Microservices
Service-zu-Service-Authentifizierung ohne zentrale Session
Mobile Apps
Stateless Auth kann für mobile Clients nützlich sein
JWTs können sicher sein, wenn sie korrekt implementiert werden: starke Schlüssel, passende Laufzeiten, TLS, Algorithmusprüfung und keine sensiblen Daten im Payload. Häufige Fehler sind schwache Secrets, falsche Algorithmusprüfung oder fehlende Expiration.
Session: Server speichert Zustand, Client hat meist nur eine Session-ID. JWT: Client trägt Claims im Token, und der Server kann stateless prüfen. JWTs können Skalierung vereinfachen, Sessions sind oft leichter zentral zu invalidieren.
Die Laufzeit hängt von Risiko, Client-Typ und Architektur ab. Häufig werden kurze Access Tokens mit länger lebenden, stärker geschützten Refresh Tokens kombiniert.
Bei vollständig stateless JWTs nicht ohne zusätzliche Mechanismen. Optionen sind kurze Laufzeiten, Revocation-Listen, Token-Versionen, Rotation oder introspektionsbasierte Ansätze.