MENU
  1. Startseite
  2. Python
  3. Vollständiger Leitfaden zur Erstellung und Validierung von JWT (JSON Web Token) mit Python

Vollständiger Leitfaden zur Erstellung und Validierung von JWT (JSON Web Token) mit Python

Python

Dieser Artikel erläutert die Authentifizierung und Sicherheitsverbesserung mit JWT (JSON Web Token) in Python, von der Erstellung bis hin zur Validierung. Wir decken alle Aspekte ab, damit Sie den Authentifizierungsprozess mit JWT vollständig verstehen können, einschließlich grundlegender Konzepte, Implementierungsbeispiele und Sicherheitsmaßnahmen. Vertiefen Sie Ihr Wissen, um eine zuverlässige Authentifizierungsfunktion für Webanwendungen und API-Entwicklungen zu erstellen.

Inhaltsverzeichnis

Grundlagen und Funktionsweise von JWT

JWT (JSON Web Token) ist eines der am häufigsten verwendeten Token-Formate für Webauthentifizierung. Es basiert auf einem Standard (RFC 7519), der die sichere Übertragung von Informationen zwischen Client und Server ermöglicht und durch eine Signatur Manipulationen verhindert.

Struktur von JWT

JWT besteht aus drei Teilen, die durch einen Punkt (.) getrennt sind:

  1. Header
  • Gibt den Token-Typ (z. B. JWT) und den Signaturalgorithmus (z. B. HS256) an.
   {
       "alg": "HS256",
       "typ": "JWT"
   }
  1. Payload
  • Enthält die zu übertragenden Daten (Claims) im JSON-Format.
   {
       "sub": "1234567890",
       "name": "John Doe",
       "admin": true
   }
  1. Signature
  • Eine Signatur, die auf Basis des Headers und Payload mit einem geheimen oder öffentlichen Schlüssel generiert wird. Sie dient dem Schutz vor Manipulationen.

Funktionsweise von JWT

  1. Wenn der Client beim Login Authentifizierungsdaten sendet, erzeugt der Server basierend auf diesen Informationen ein JWT.
  2. Das generierte JWT wird an den Client gesendet und in der Regel in einem Cookie oder HTTP-Header gespeichert.
  3. Der Client sendet bei jeder Anfrage das JWT an den Server, der das Token überprüft und die Anfrage autorisiert.

Dieser Prozess ermöglicht eine zustandslose Authentifizierung, die sowohl die Skalierbarkeit als auch die Sicherheit erhöht.

Auswahl von JWT-Bibliotheken in Python

Für die Arbeit mit JWT in Python gibt es verschiedene nützliche Bibliotheken. Jede dieser Bibliotheken hat ihre eigenen Merkmale, und es ist wichtig, die passende für Ihr Projekt auszuwählen.

Wichtige Bibliotheken

  1. PyJWT
  • Die am häufigsten verwendete und leichtgewichtige Bibliothek. Sie ermöglicht eine einfache Erstellung und Validierung von JWT.
  • Offizielle Webseite: PyJWT GitHub
  • Merkmale:
    • Einfach zu verwendende API
    • Unterstützt eine Vielzahl von Signaturalgorithmen, wie HMAC (HS256, HS512) und RSA (RS256, RS512)
  • Installation:
    bash pip install pyjwt
  1. Authlib
  • Unterstützt fortgeschrittene Authentifizierungsframeworks wie OAuth2 und OpenID Connect. JWT wird ebenfalls unterstützt.
  • Offizielle Webseite: Authlib
  • Merkmale:
    • Fortgeschrittene Sicherheitsfunktionen
    • Spezialisiert auf die Handhabung von Tokens
  • Installation:
    bash pip install authlib
  1. python-jose
  • Unterstützt JSON Web Token, JSON Web Signature (JWS) und JSON Web Encryption (JWE).
  • Merkmale:
    • Ausgezeichnete Unterstützung für Verschlüsselung (JWE)
    • Ermöglicht fortgeschrittene Anpassungen
  • Installation:
    bash pip install python-jose

Auswahlkriterien für Bibliotheken

  • Einfacher Authentifizierungsbedarf: PyJWT ist am besten geeignet. Es ist leichtgewichtig und intuitiv zu verwenden.
  • Komplexe Authentifizierungsflüsse: Wenn Sie OAuth oder OpenID Connect verwenden, ist Authlib zu empfehlen.
  • Verschlüsselung erforderlich: Wenn die Verschlüsselung von Tokens erforderlich ist, sollten Sie python-jose wählen.

Je nach Größe des Projekts und Sicherheitsanforderungen können Sie diese Bibliotheken effektiv einsetzen, um JWT effizient zu nutzen.

Implementierung der JWT-Erstellung in Python

Die JWT-Erstellung kann effizient umgesetzt werden, indem die geeignete Python-Bibliothek verwendet wird. Im Folgenden zeigen wir, wie man JWT mit der am häufigsten verwendeten Bibliothek PyJWT erstellt.

Einfaches JWT mit PyJWT erstellen

Der folgende Code zeigt ein Beispiel, wie man JWT mit PyJWT erstellt.

import jwt
import datetime

# Geheimen Schlüssel festlegen
SECRET_KEY = "your-secret-key"

# Payload erstellen
payload = {
    "sub": "1234567890",       # Benutzer-ID oder andere Identifikation
    "name": "John Doe",        # Beliebige Benutzerinformationen
    "iat": datetime.datetime.utcnow(),  # Ausstellungszeit des Tokens
    "exp": datetime.datetime.utcnow() + datetime.timedelta(hours=1)  # Ablaufzeit (1 Stunde später)
}

# Token generieren
token = jwt.encode(payload, SECRET_KEY, algorithm="HS256")

print("Generiertes JWT:", token)

Erklärung des Codes

  1. Geheimer Schlüssel festlegen
  • Der geheime Schlüssel, der für die Signatur des Tokens verwendet wird, muss sicher auf dem Server verwaltet werden.
  1. Payload erstellen
  • Claims wie sub und name sind enthalten.
  • Wenn gewünscht, können auch Ausstellungszeit (iat) und Ablaufzeit (exp) festgelegt werden.
  1. Token generieren
  • Verwenden Sie jwt.encode, um den Payload zu kodieren und das Token zu generieren.
  • Für die Signatur wird normalerweise der Algorithmus HS256 oder RS256 verwendet.

JWT mit RSA-Signatur erstellen

Wenn Sie eine Signatur mit einem öffentlichen und privaten Schlüssel verwenden möchten, zeigt das folgende Beispiel, wie man ein JWT erstellt.

import jwt

# RSA-private und öffentliche Schlüssel
private_key = """-----BEGIN RSA PRIVATE KEY-----
... (Inhalt des privaten Schlüssels) ...
-----END RSA PRIVATE KEY-----"""
public_key = """-----BEGIN PUBLIC KEY-----
... (Inhalt des öffentlichen Schlüssels) ...
-----END PUBLIC KEY-----"""

# Payload erstellen
payload = {
    "sub": "1234567890",
    "name": "John Doe",
    "exp": datetime.datetime.utcnow() + datetime.timedelta(hours=1)
}

# Token mit RSA-Signatur generieren
token = jwt.encode(payload, private_key, algorithm="RS256")
print("Generiertes JWT mit RSA:", token)

Wichtige Hinweise

  1. Geheimer Schlüssel verwalten
  • Der geheime Schlüssel muss sorgfältig verwaltet werden, um eine Offenlegung zu verhindern.
  1. Ablaufzeit festlegen
  • Die Festlegung einer exp-Claim ist sicherheitsrelevant, um das Token zu begrenzen.
  1. Token-Größe
  • Wenn unnötige Informationen im Payload enthalten sind, kann das Token unnötig groß werden und die Kommunikation ineffizient machen.

Nutzen Sie diese Codebeispiele, um die entsprechenden JWT zu erstellen und ein sicheres Authentifizierungssystem zu implementieren.

Entwurf der in Payload enthaltenen Daten von JWT

Die Payload von JWT enthält Benutzerinformationen und Token-Attribute. Der Entwurf der Payload ist wichtig, da er Einfluss auf die Größe des Tokens und die Sicherheit hat.

Grundstruktur der Payload

Die Payload von JWT kann drei Arten von Claims enthalten:

  1. Registrierte Claims
  • Standardisierte Claims gemäß der Spezifikation. Diese haben eine spezifische Bedeutung und sollten korrekt verwendet werden.
  • Wichtige Beispiele:
    • iss (Issuer): Der Aussteller des Tokens.
    • sub (Subject): Die Zielperson des Tokens (z. B. Benutzer-ID).
    • aud (Audience): Die Zielgruppe des Tokens (z. B. ein spezifischer Service).
    • exp (Expiration): Ablaufzeit des Tokens als Unix-Timestamp.
    • iat (Issued At): Der Ausstellungszeitpunkt des Tokens als Unix-Timestamp.
  1. Public Claims
  • Definierbare Daten, die auf Ihre Anwendung zugeschnitten sind.
  • Verwenden Sie Namensräume, um Konflikte mit anderen Systemen zu vermeiden (z. B. namespace/attribute).
  1. Private Claims
  • Daten, die nur innerhalb Ihrer Anwendung verwendet werden. Sie benötigen keinen Namensraum.

Best Practices beim Entwurf

Nur notwendige Daten einbeziehen

JWT ist grundsätzlich ein Base64-codierter String, und die Größe des Tokens beeinflusst die Effizienz der Kommunikation. Daher sollten nur die für Authentifizierung und Autorisierung erforderlichen Daten im Payload enthalten sein.

{
    "sub": "1234567890",
    "name": "John Doe",
    "roles": ["admin", "user"]
}

Berücksichtigen Sie die Sensibilität der Daten

JWT verhindert Manipulationen durch Signaturen, aber es ist nicht verschlüsselt. Daher sollten Sie vertrauliche Informationen wie:

  • Passwörter
  • Kreditkarteninformationen
  • Persönliche Daten (PII)

Verfallen von Tokens klar definieren

Stellen Sie sicher, dass Sie immer eine exp-Claim im Payload festlegen und die Ablaufzeit so kurz wie möglich halten, um das Sicherheitsrisiko zu verringern.

Beispiel für Payload-Design

Hier ein praktisches Beispiel für eine JWT-Payload:

{
    "iss": "https://example.com",   // Aussteller
    "sub": "user123",               // Benutzer-ID
    "aud": "https://myapi.example.com", // Empfänger
    "exp": 1701209952,              // Ablaufzeit (Unix-Timestamp)
    "iat": 1701206352,              // Ausstellungszeit
    "roles": ["user", "admin"],     // Benutzerrechte
    "preferences": {
        "theme": "dark",            // Benutzerpräferenzen
        "notifications": true
    }
}

Berücksichtigung der Token-Größe

Wenn der Payload groß wird, kann die Gesamtgröße des Tokens steigen, was zu folgenden Problemen führen kann:

  • Erhöhte Request-Größe bei Übertragung über HTTP-Header
  • Erhöhter Datenverbrauch auf mobilen Geräten

Reduzieren Sie nach Bedarf benutzerdefinierte Claims und optimieren Sie das Token.

Zusammenfassung

Der Entwurf der Payload ist entscheidend für die Effizienz und Sicherheit des Tokens. Verwenden Sie Standard-Claims und beinhalten Sie nur die benötigten Informationen, um das optimale Token-Design zu erreichen.

Signaturmechanismus mit privatem und öffentlichem Schlüssel

Die Signatur spielt eine entscheidende Rolle bei der Sicherstellung der JWT-Sicherheit. Besonders die Verwendung von öffentlichen und privaten Schlüsseln für die Signatur (asymmetrische Signatur) ist ideal für Manipulationsschutz und Vertrauensbildung. In diesem Abschnitt wird der Signaturmechanismus und die Implementierung in Python erläutert.

Funktionsweise der Signatur

JWT-Signaturen gibt es in zwei Varianten:

  1. Symmetrische Signatur (HMAC)
  • Verwendet einen gemeinsamen geheimen Schlüssel für Signierung und Verifizierung.
  • Einfach und schnell, aber die Schlüsselverwaltung kann problematisch sein.
  • Verwendete Algorithmen: HS256, HS512
  1. Asymmetrische Signatur (RSA, ECDSA)
  • Signiert mit dem privaten Schlüssel und verifiziert mit dem öffentlichen Schlüssel.
  • Ideal für Kommunikation zwischen Servern oder mit externen Systemen.
  • Verwendete Algorithmen: RS256, ES256

Vorteile der asymmetrischen Signatur:

  • Solange der private Schlüssel sicher verwaltet wird, bleibt die Sicherheit auch bei einem Leck des öffentlichen Schlüssels gewahrt.
  • Besonders nützlich, wenn mehrere Validierer beteiligt sind.

RSA-Signaturimplementierung in Python

Im Folgenden wird gezeigt, wie JWT mit einer asymmetrischen Signatur in Python mit der PyJWT-Bibliothek erstellt und validiert wird.

Vorbereitung der Signaturschlüssel

Erzeugen Sie im Vorfeld den privaten und öffentlichen Schlüssel.

openssl genrsa -out private.pem 2048
openssl rsa -in private.pem -pubout -out public.pem

JWT-Erstellung

Erstellen Sie das JWT mit dem privaten Schlüssel.

import jwt
import datetime

# Laden des privaten Schlüssels
with open("private.pem", "r") as key_file:
    private_key = key_file.read()

# Payload erstellen
payload = {
    "sub": "1234567890",
    "name": "John Doe",
    "exp": datetime.datetime.utcnow() + datetime.timedelta(hours=1)
}

# JWT generieren (mit Signatur)
token = jwt.encode(payload, private_key, algorithm="RS256")
print("Generiertes JWT:", token)

JWT-Validierung

Validieren Sie das JWT mit dem öffentlichen Schlüssel.

# Laden des öffentlichen Schlüssels
with open("public.pem", "r") as key_file:
    public_key = key_file.read()

# JWT validieren
try:
    decoded = jwt.decode(token, public_key, algorithms=["RS256"])
    print("Dekodierter Payload:", decoded)
except jwt.ExpiredSignatureError:
    print("Das Token ist abgelaufen.")
except jwt.InvalidTokenError:
    print("Das Token ist ungültig.")

Auswahl der Signaturalgorithmen

  • HS256 (HMAC): Geeignet für einfache Server-Authentifizierungssysteme
  • RS256 (RSA): Ideal für die Kommunikation zwischen Servern oder mit externen Systemen
  • ES256 (ECDSA): Effektiv für leichtere öffentliche Schlüssel-Signaturen

Best Practices

  1. Sichere Verwaltung des geheimen Schlüssels
  • Schützen Sie den geheimen Schlüssel und implementieren Sie Zugriffsberechtigungen.
  1. Festlegung der Ablaufzeit
  • Verwenden Sie die exp-Claim, um die Ablaufzeit festzulegen und das Token regelmäßig zu erneuern.
  1. Explizite Angabe des Algorithmus
  • Vermeiden Sie die Verwendung von Standardalgorithmen, die Sicherheitslücken verursachen können.

Zusammenfassung

Die Verwendung von privaten und öffentlichen Schlüsseln zur Signatur bietet eine hohe Sicherheit. RSA-Signaturen sind besonders nützlich für Server-zu-Server-Kommunikation oder Systeme, die eine Verteilung des öffentlichen Schlüssels erfordern. Erstellen Sie ein sicheres Authentifizierungssystem auf Basis der gezeigten Beispiele in Python.

JWT-Validierungsprozess

Bei der Authentifizierung mit JWT ist der „Validierungsprozess“ entscheidend. Durch die Validierung wird überprüft, ob das Token nicht manipuliert wurde, ob es mit dem richtigen geheimen oder öffentlichen Schlüssel signiert wurde und ob es noch innerhalb des Gültigkeitszeitraums liegt. Hier wird der JWT-Validierungsprozess und ein Beispiel zur Implementierung in Python erklärt.

Grundlagen des JWT-Validierungsprozesses

  1. Überprüfung der Signatur
  • Überprüfen Sie, ob das Token mit dem richtigen geheimen oder öffentlichen Schlüssel signiert wurde. Wenn die Signatur nicht übereinstimmt, ist das Token ungültig.
  1. Überprüfung der Ablaufzeit
  • Überprüfen Sie die exp-Claim im Payload, um sicherzustellen, dass das Token noch gültig ist. Abgelaufene Tokens sind ungültig.
  1. Überprüfung der weiteren Claims
  • Verifizieren Sie, falls erforderlich, Claims wie iss (Issuer) oder aud (Audience), um sicherzustellen, dass das Token nur im vorgesehenen System verwendet wird.

JWT-Validierung in Python

Das folgende Beispiel zeigt, wie man JWT mit der PyJWT-Bibliothek in Python validiert.

Einfache Validierung

import jwt

# Geheimer Schlüssel oder öffentlicher Schlüssel
SECRET_KEY = "your-secret-key"

# Token, das validiert werden soll
token = "your.jwt.token"

# Decodieren und Validieren des JWT
try:
    decoded = jwt.decode(token, SECRET_KEY, algorithms=["HS256"])
    print("Verifizierter Payload:", decoded)
except jwt.ExpiredSignatureError:
    print("Das Token ist abgelaufen.")
except jwt.InvalidTokenError:
    print("Das Token ist ungültig.")

RS256 (öffentlicher Schlüssel) Validierung

Wenn eine asymmetrische Signatur (RS256) verwendet wird, validieren Sie das Token mit dem öffentlichen Schlüssel.

# Öffentlichen Schlüssel laden
with open("public.pem", "r") as key_file:
    public_key = key_file.read()

# Decodieren und Validieren des JWT
try:
    decoded = jwt.decode(token, public_key, algorithms=["RS256"])
    print("Verifizierter Payload:", decoded)
except jwt.ExpiredSignatureError:
    print("Das Token ist abgelaufen.")
except jwt.InvalidTokenError:
    print("Das Token ist ungültig.")

Überprüfung zusätzlicher Claims bei der Validierung

Sie können zusätzliche Claims wie folgt spezifizieren, um die Validierung zu verstärken:

decoded = jwt.decode(
    token,
    SECRET_KEY,
    algorithms=["HS256"],
    options={"verify_exp": True},  # Aktiviert die Überprüfung des Ablaufdatums
    audience="https://myapi.example.com",  # Überprüft den Empfänger
    issuer="https://example.com"  # Überprüft den Aussteller
)

Wichtige Punkte bei der Validierung

  1. Angabe des Algorithmus
  • Geben Sie immer explizit den verwendeten Algorithmus an. Die Verwendung von None oder unerwarteten Algorithmen kann ein Sicherheitsrisiko darstellen.
  1. Umgang mit abgelaufenen Tokens
  • Abgelaufene Tokens (ExpiredSignatureError) sollten den Benutzer zur erneuten Anmeldung oder Token-Erneuerung auffordern.
  1. Überprüfung der Token-Quelle
  • Stellen Sie sicher, dass das Token aus einer vertrauenswürdigen Quelle stammt.

Gesamtübersicht des Token-Validierungsprozesses

  1. Token empfangen
  2. Überprüfen der Struktur des Tokens (Header, Payload, Signature)
  3. Überprüfen des Algorithmus im Header und Validierung der Signatur
  4. Überprüfen der exp und iss Claims im Payload
  5. Annahme der Anfrage nur bei erfolgreicher Validierung

Zusammenfassung

Die Validierung von JWT ist ein zentraler Bestandteil des Authentifizierungsprozesses. Durch die Überprüfung der Signatur und der Ablaufzeit stellen Sie sicher, dass nur vertrauenswürdige Tokens verwendet werden. Verwenden Sie die Python-Implementierung als Grundlage, um einen sicheren JWT-Validierungsprozess zu integrieren.

Token-Ablaufzeit und Implementierung der Token-Erneuerung

Die Festlegung einer Ablaufzeit für JWT und die Implementierung von Refresh-Token sind für die Sicherheit unerlässlich. In diesem Abschnitt wird gezeigt, wie man die Ablaufzeit festlegt und Token-Erneuerung in Python implementiert.

Festlegen der Ablaufzeit

Die Ablaufzeit für JWT kann mit dem exp Claim festgelegt werden. Das folgende Beispiel zeigt, wie dies in Python umgesetzt wird.

import jwt
import datetime

# Geheimer Schlüssel festlegen
SECRET_KEY = "your-secret-key"

# Payload mit Ablaufzeit hinzufügen
payload = {
    "sub": "1234567890",       # Benutzer-ID
    "name": "John Doe",        # Beliebige Benutzerinformationen
    "iat": datetime.datetime.utcnow(),  # Ausstellungszeit
    "exp": datetime.datetime.utcnow() + datetime.timedelta(minutes=30)  # Gültig für 30 Minuten
}

# Token generieren
token = jwt.encode(payload, SECRET_KEY, algorithm="HS256")
print("Access Token:", token)

Wichtige Hinweise

  • Die Ablaufzeit sollte relativ kurz (5 bis 30 Minuten) festgelegt werden, um das Risiko bei einem gestohlenen Token zu minimieren.
  • Falls das Token abgelaufen ist, sollte der Benutzer zur erneuten Authentifizierung oder Token-Erneuerung aufgefordert werden.

Design von Refresh-Token

Refresh-Token werden separat vom Access-Token generiert und verwendet, um abgelaufene Access-Tokens zu erneuern. Merkmale von Refresh-Token:

  1. Längere Ablaufzeiten (mehrere Tage bis Wochen)
  2. Werden oft auf der Serverseite gespeichert und verwaltet

Beispiel für die Erstellung eines Refresh-Tokens

# Payload für Refresh-Token
refresh_payload = {
    "sub": "1234567890",       # Benutzer-ID
    "iat": datetime.datetime.utcnow(),  # Ausstellungszeit
    "exp": datetime.datetime.utcnow() + datetime.timedelta(days=7)  # 7 Tage gültig
}

# Refresh-Token generieren
refresh_token = jwt.encode(refresh_payload, SECRET_KEY, algorithm="HS256")
print("Refresh Token:", refresh_token)

Implementierung des Refresh-Prozesses

Wenn das Token abgelaufen ist, kann es mit einem Refresh-Token erneuert werden.

# Decodieren des Refresh-Tokens und Ausstellen eines neuen Access-Tokens
try:
    decoded_refresh = jwt.decode(refresh_token, SECRET_KEY, algorithms=["HS256"])

    # Neues Access-Token ausstellen
    new_access_payload = {
        "sub": decoded_refresh["sub"],
        "name": "John Doe",
        "iat": datetime.datetime.utcnow(),
        "exp": datetime.datetime.utcnow() + datetime.timedelta(minutes=30)
    }
    new_access_token = jwt.encode(new_access_payload, SECRET_KEY, algorithm="HS256")
    print("New Access Token:", new_access_token)
except jwt.ExpiredSignatureError:
    print("Das Refresh-Token ist abgelaufen.")
except jwt.InvalidTokenError:
    print("Das Refresh-Token ist ungültig.")

Sicherheitsüberlegungen bei Refresh-Token

  1. Verwaltung auf Serverseite
  • Speichern Sie Refresh-Tokens sicher auf dem Server, um Diebstahl oder Manipulationen zu verhindern.
  1. Einmalige Verwendung
  • Verwenden Sie Refresh-Tokens nur einmal und machen Sie sie nach Gebrauch ungültig, um Sitzungshijacking zu verhindern.
  1. Zusätzliche Authentifizierung bei Verwendung
  • Erforderlich ist eine zusätzliche Benutzer-Authentifizierung beim Verwenden von Refresh-Tokens, um die Sicherheit zu erhöhen.

API-Design für Refresh-Token

Hier ist ein Beispiel für die API-Design des Token-Erneuerungsprozesses:

  1. Der Client sendet ein abgelaufenes Access-Token und ein Refresh-Token
  2. Der Server validiert das Refresh-Token
  3. Wenn gültig, stellt der Server ein neues Access-Token aus und sendet es an den Client zurück

Beispiel API-Endpunkt

POST /api/token/refresh
Authorization: Bearer {refresh_token}

Antwortbeispiel:

{
    "access_token": "new_access_token",
    "expires_in": 1800
}

Zusammenfassung

Die ordnungsgemäße Implementierung der Ablaufzeit und der Refresh-Tokens stellt die Sicherheit sicher und verbessert gleichzeitig die Benutzererfahrung. Durch die Kombination der Verkürzung der Ablaufzeit und der Verwendung von Refresh-Tokens kann ein zuverlässiges Authentifizierungssystem geschaffen werden.

Sicherheitsrisiken und Gegenmaßnahmen

JWT ist eine praktische Lösung für Authentifizierung und Sitzungsmanagement, aber es gibt Sicherheitsrisiken, wenn es nicht richtig implementiert oder verwaltet wird. In diesem Abschnitt werden die häufigsten Risiken und ihre Lösungen behandelt.

Allgemeine Sicherheitsrisiken

1. Leck des geheimen Schlüssels

Wenn der geheime Schlüssel für JWT-Signaturen offengelegt wird, könnte ein Angreifer ungültige Tokens generieren und das System übernehmen.

Maßnahmen:

  • Speichern Sie den geheimen Schlüssel in einer sicheren Umgebung (z. B. Umgebungsvariablen, Secrets Management Services).
  • Routinemäßige Schlüsselrotation (Austausch) durchführen.

2. Token-Manipulation

Wenn die Signatur des Tokens nicht korrekt überprüft wird, könnte ein Angreifer den Inhalt des Tokens manipulieren.

Maßnahmen:

  • Überprüfen Sie immer die Signatur des Tokens.
  • Geben Sie den Algorithmus explizit an und erlauben Sie keine ungültigen Algorithmen (z. B. none).

3. Token-Diebstahl

Ein gestohlenes Token könnte es einem Angreifer ermöglichen, sich als berechtigter Benutzer auszugeben.

Maßnahmen:

  • Verwenden Sie HTTPS, um die Kommunikation zu verschlüsseln.
  • Speichern Sie Tokens sicher (z. B. HttpOnly-Cookies).
  • Setzen Sie die Ablaufzeit des Tokens kurz an.

4. Token-Replay-Angriffe

Ein gestohlenes Token könnte wiederverwendet werden, um dieselbe Sitzung zu übernehmen.

Maßnahmen:

  • Fügen Sie jeder Token-Übertragung eine eindeutige Kennung (jti) hinzu und verfolgen Sie die Verwendung des Tokens auf dem Server.
  • Setzen Sie verwendete Tokens auf eine Blacklist.

5. Schwierige Invalidierung

Da JWT zustandslos ist, kann ein einmal ausgestelltes Token möglicherweise nicht invalidiert werden.

Maßnahmen:

  • Kombinieren Sie Refresh-Tokens und eine Blacklist, um Invalidierung zu ermöglichen.
  • Setzen Sie die Ablaufzeit des Tokens niedrig an und aktualisieren Sie es regelmäßig.

Konkrete Gegenmaßnahmen in Python implementieren

1. Schlüsselverwaltung

Beispiel zur Schlüsselverwaltung aus Umgebungsvariablen:

import os

SECRET_KEY = os.getenv("JWT_SECRET_KEY")
if not SECRET_KEY:
    raise ValueError("Secret key must be set!")

2. Explizite Angabe des Algorithmus

Um unzulässige Algorithmen zu vermeiden, geben Sie den zu verwendenden Algorithmus explizit an:

import jwt

# Token validieren
decoded = jwt.decode(token, SECRET_KEY, algorithms=["HS256"])

3. Verwendung von HTTPS

Aktivieren Sie HTTPS in Flask:

from flask import Flask

app = Flask(__name__)
app.config['PREFERRED_URL_SCHEME'] = 'https'

4. Schutz vor Replay-Angriffen

Fügen Sie jedem Token eine eindeutige Kennung (jti) hinzu und verfolgen Sie die Nutzung:

import uuid

payload = {
    "sub": "1234567890",
    "jti": str(uuid.uuid4()),  # Eindeutige ID
    "exp": datetime.datetime.utcnow() + datetime.timedelta(minutes=30)
}

5. Implementierung einer Blacklist

Ein Beispiel zur Invalidierung von Tokens mit Redis:

import redis

# Redis-Client
redis_client = redis.StrictRedis(host='localhost', port=6379, db=0)

# Token invalidieren
redis_client.setex("blacklist:" + token, 1800, "true")  # Ungültig nach 1800 Sekunden

Weitere empfohlene Maßnahmen

  • Schutz vor Cross-Site Scripting (XSS)
    Verwenden Sie HttpOnly-Cookies, um Tokens zu schützen.
  • Protokollüberwachung
    Überwachen Sie die Nutzung von Tokens, um verdächtige Aktivitäten zu erkennen.

Zusammenfassung

Obwohl JWT viele Vorteile bietet, kann es erhebliche Risiken mit sich bringen, wenn es nicht sicher implementiert wird. Durch die richtige Verwaltung von geheimen Schlüsseln, die Validierung von Tokensignaturen und die Begrenzung der Token-Ablaufzeit können Sie ein sicheres Authentifizierungssystem aufbauen.

Zusammenfassung

Dieser Artikel hat die Erstellung und Validierung von JWT (JSON Web Token) mit Python behandelt, von den Grundlagen über die Implementierung bis hin zu Sicherheitsmaßnahmen.

JWT ist ein sehr effektives Mittel zur Erstellung von zustandslosen und skalierbaren Authentifizierungssystemen, jedoch müssen auch Sicherheitsaspekte wie die Verwaltung von geheimen Schlüsseln, die Ablaufzeit von Tokens und die Gestaltung von Refresh-Tokens berücksichtigt werden.

Durch die Nutzung von Python-Bibliotheken können Sie ein sicheres und effizientes System aufbauen, das eine vertrauenswürdige Benutzer-Authentifizierung und zuverlässige Sitzungsverwaltung gewährleistet.

Python
API-Entwicklung Authentifizierung Authlib JSON Web Token JWT PyJWT Python python-jose sicherheit Sicherheitsmaßnahmen Token-Erstellung Token-Verifizierung Webanwendungsentwicklung Zustandslose Authentifizierung
Inhaltsverzeichnis