Python DRF Authentifizierung: Token- vs. JWT-Implementierung für robuste APIs

Die Absicherung Ihrer APIs ist von größter Bedeutung. Beim Erstellen von APIs mit Python und dem Django REST Framework (DRF) stehen Ihnen verschiedene Authentifizierungsoptionen zur Verfügung. Dieser Artikel befasst sich mit zwei gängigen Methoden: der Token-Authentifizierung und der JWT (JSON Web Token)-Authentifizierung, vergleicht deren Stärken und Schwächen und liefert praktische Implementierungsbeispiele.

Authentifizierung in APIs verstehen

Authentifizierung ist der Prozess der Überprüfung der Identität eines Benutzers oder einer Anwendung, die auf Ihre API zugreift. Ein gut implementiertes Authentifizierungssystem stellt sicher, dass nur autorisierte Entitäten auf geschützte Ressourcen zugreifen können. Im Kontext von RESTful APIs beinhaltet die Authentifizierung typischerweise das Senden von Anmeldeinformationen (z. B. Benutzername und Passwort) mit jeder Anfrage. Der Server überprüft dann diese Anmeldeinformationen und gewährt, falls gültig, den Zugriff.

Token-Authentifizierung

Die Token-Authentifizierung ist ein einfacher und unkomplizierter Mechanismus. Wenn sich ein Benutzer erfolgreich anmeldet, generiert der Server ein eindeutiges, zufälliges Token und speichert es in der Datenbank, wobei er es dem Benutzer zuordnet. Der Client sendet dieses Token dann im 'Authorization'-Header nachfolgender Anfragen. Der Server ruft das Token aus der Datenbank ab, überprüft seine Gültigkeit und gewährt entsprechend Zugriff.

Implementierung mit DRF

DRF bietet eine integrierte Unterstützung für die Token-Authentifizierung. So implementieren Sie sie:

1. DRF installieren und in Ihrem Django-Projekt registrieren:

Stellen Sie zunächst sicher, dass Sie Django REST Framework installiert haben:

            pip install djangorestframework
            

              
                Copy
              
            
          

Fügen Sie es dann zu Ihren `INSTALLED_APPS` in `settings.py` hinzu:

            INSTALLED_APPS = [
    ...
    'rest_framework',
]
            

              
                Copy
              
            
          

2. Fügen Sie das TokenAuthentication-Schema als Standard-Authentifizierungsklasse hinzu (optional, aber empfohlen):

Fügen Sie in Ihrer Datei `settings.py` Folgendes hinzu:

            REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': [
        'rest_framework.authentication.TokenAuthentication',
        'rest_framework.authentication.SessionAuthentication',
    ],
}
            

              
                Copy
              
            
          

Dies wendet die Token-Authentifizierung global auf Ihre API an. `SessionAuthentication` ist für browserbasierte Interaktionen enthalten, kann aber für eine rein API-gesteuerte Anwendung entfernt werden.

3. Erstellen Sie ein Token für jeden Benutzer:

Sie können Tokens für Benutzer bei der Erstellung automatisch erstellen, indem Sie einen Signal-Handler hinzufügen. Erstellen Sie eine Datei namens `signals.py` in Ihrer App (z. B. `users/signals.py`):

            from django.conf import settings
from django.db.models.signals import post_save
from django.dispatch import receiver
from rest_framework.authtoken.models import Token

@receiver(post_save, sender=settings.AUTH_USER_MODEL)
def create_auth_token(sender, instance=None, created=False, **kwargs):
    if created:
        Token.objects.create(user=instance)
            

              
                Copy
              
            
          

Importieren Sie dann diese Datei `signals.py` in Ihrer Datei `users/apps.py` innerhalb der `ready`-Methode Ihrer App-Konfigurationsklasse. Beispiel für `users/apps.py`:

            from django.apps import AppConfig

class UsersConfig(AppConfig):
    default_auto_field = 'django.db.BigAutoField'
    name = 'users'

    def ready(self):
        import users.signals
            

              
                Copy
              
            
          

Jetzt können Sie Tokens über die Befehlszeile verwalten:

            python manage.py drf_create_token <username>
            

              
                Copy
              
            
          

4. Implementieren Sie Ihre API-Views:

Hier ist ein einfaches Beispiel für eine View, die eine Token-Authentifizierung erfordert:

            from rest_framework import permissions
from rest_framework.response import Response
from rest_framework.views import APIView

class ExampleView(APIView):
    authentication_classes = [TokenAuthentication]
    permission_classes = [permissions.IsAuthenticated]

    def get(self, request):
        content = {
            'message': 'Hello, ' + request.user.username + '! You are authenticated.',
        }
        return Response(content)
            

              
                Copy
              
            
          

In diesem Beispiel gibt `authentication_classes` an, dass die Token-Authentifizierung verwendet werden soll, und `permission_classes` gibt an, dass nur authentifizierte Benutzer auf die View zugreifen können.

5. Login API View einbinden:

Sie benötigen außerdem einen Endpunkt, um das Token bei erfolgreicher Anmeldung zu erstellen:

            from django.contrib.auth import authenticate
from rest_framework import status
from rest_framework.authtoken.models import Token
from rest_framework.decorators import api_view, permission_classes
from rest_framework.permissions import AllowAny
from rest_framework.response import Response

@api_view(['POST'])
@permission_classes([AllowAny])
def login(request):
    username = request.data.get('username')
    password = request.data.get('password')
    user = authenticate(username=username, password=password)
    if user:
        token, _ = Token.objects.get_or_create(user=user)
        return Response({'token': token.key})
    else:
        return Response({'error': 'Invalid Credentials'}, status=status.HTTP_401_UNAUTHORIZED)
            

              
                Copy
              
            
          

Vorteile der Token-Authentifizierung

• Einfachheit: Leicht zu implementieren und zu verstehen.
• Zustandslos: Jede Token-Anfrage enthält Informationen, die sie eigenständig machen.

Nachteile der Token-Authentifizierung

• Datenbankabhängigkeit: Erfordert für jede Anfrage eine Datenbankabfrage zur Validierung des Tokens. Dies kann die Leistung beeinträchtigen, insbesondere bei großen Systemen.
• Token-Widerruf: Das Widerrufen eines Tokens erfordert dessen Löschung aus der Datenbank, was komplex sein kann.
• Skalierbarkeit: Aufgrund des Datenbank-Overheads möglicherweise nicht die skalierbarste Lösung für große, stark frequentierte APIs.

JWT (JSON Web Token) Authentifizierung

Die JWT-Authentifizierung ist ein modernerer und ausgeklügelterer Ansatz. Ein JWT ist ein kompaktes, URL-sicheres JSON-Objekt, das Claims über den Benutzer enthält. Diese Claims werden digital mit einem geheimen Schlüssel oder einem Public/Private-Key-Paar signiert. Wenn sich ein Benutzer anmeldet, generiert der Server ein JWT und sendet es an den Client. Der Client fügt dieses JWT dann im 'Authorization'-Header nachfolgender Anfragen ein. Der Server kann die Signatur des JWT überprüfen, ohne auf eine Datenbank zugreifen zu müssen, was es zu einer effizienteren und skalierbareren Lösung macht.

Implementierung mit DRF

DRF bietet keine integrierte Unterstützung für die JWT-Authentifizierung, aber mehrere hervorragende Bibliotheken erleichtern die Integration. Eine der beliebtesten ist `djangorestframework-simplejwt`.

1. `djangorestframework-simplejwt` installieren:

            pip install djangorestframework-simplejwt
            

              
                Copy
              
            
          

2. DRF-Einstellungen konfigurieren:

Fügen Sie in Ihrer Datei `settings.py` Folgendes hinzu:

            REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': (
        'rest_framework_simplejwt.authentication.JWTAuthentication',
        'rest_framework.authentication.SessionAuthentication',
    ),
}

SIMPLE_JWT = {
    'ACCESS_TOKEN_LIFETIME': timedelta(minutes=5),
    'REFRESH_TOKEN_LIFETIME': timedelta(days=1),
    'ROTATE_REFRESH_TOKENS': False,
    'BLACKLIST_AFTER_ROTATION': True,

    'ALGORITHM': 'HS256',
    'SIGNING_KEY': settings.SECRET_KEY,
    'VERIFYING_KEY': None,
    'AUTH_HEADER_TYPES': ('Bearer',),
    'USER_ID_FIELD': 'id',
    'USER_ID_CLAIM': 'user_id',

    'AUTH_TOKEN_CLASSES': ('rest_framework_simplejwt.tokens.AccessToken',),
    'TOKEN_TYPE_CLAIM': 'token_type',
}
            

              
                Copy
              
            
          

Erläuterung der Einstellungen:

• `ACCESS_TOKEN_LIFETIME`: Wie lange der Access Token gültig ist (Beispiel, 5 Minuten).
• `REFRESH_TOKEN_LIFETIME`: Wie lange der Refresh Token gültig ist (Beispiel, 1 Tag). Refresh Tokens werden verwendet, um neue Access Tokens zu erhalten, ohne dass sich der Benutzer erneut anmelden muss.
• `ROTATE_REFRESH_TOKENS`: Ob Refresh Tokens nach jeder Verwendung rotiert werden sollen.
• `BLACKLIST_AFTER_ROTATION`: Ob alte Refresh Tokens nach der Rotation auf eine Blacklist gesetzt werden sollen.
• `ALGORITHM`: Der Algorithmus, der zum Signieren des JWT verwendet wird (HS256 ist eine gängige Wahl).
• `SIGNING_KEY`: Der geheime Schlüssel, der zum Signieren des JWT verwendet wird (typischerweise Ihr Django SECRET_KEY).
• `AUTH_HEADER_TYPES`: Der Typ des Autorisierungsheaders (typischerweise "Bearer").

3. Login- und Refresh Token API Views einbinden:

`djangorestframework-simplejwt` stellt Views zum Abrufen und Aktualisieren von Tokens bereit. Fügen Sie diese in Ihre `urls.py` ein:

            from django.urls import path
from rest_framework_simplejwt.views import (
    TokenObtainPairView,
    TokenRefreshView,
)

urlpatterns = [
    path('token/', TokenObtainPairView.as_view(), name='token_obtain_pair'),
    path('token/refresh/', TokenRefreshView.as_view(), name='token_refresh'),
]
            

              
                Copy
              
            
          

`TokenObtainPairView` stellt nach erfolgreicher Authentifizierung Access- und Refresh-Tokens bereit. `TokenRefreshView` stellt einen neuen Access Token bereit, wenn ein gültiger Refresh Token übergeben wird.

4. Implementieren Sie Ihre API-Views:

Hier ist ein einfaches Beispiel für eine View, die eine JWT-Authentifizierung erfordert:

            from rest_framework import permissions
from rest_framework.response import Response
from rest_framework.views import APIView
from rest_framework_simplejwt.authentication import JWTAuthentication

class ExampleView(APIView):
    authentication_classes = [JWTAuthentication]
    permission_classes = [permissions.IsAuthenticated]

    def get(self, request):
        content = {
            'message': 'Hello, ' + request.user.username + '! You are authenticated.',
        }
        return Response(content)
            

              
                Copy
              
            
          

Ähnlich dem Beispiel zur Token-Authentifizierung gibt `authentication_classes` an, dass die JWT-Authentifizierung verwendet werden soll, und `permission_classes` beschränkt den Zugriff nur auf authentifizierte Benutzer.

Vorteile der JWT-Authentifizierung

• Skalierbarkeit: Für die Token-Validierung ist keine Datenbankabfrage erforderlich, was sie skalierbarer macht.
• Zustandslos: Das JWT enthält alle notwendigen Informationen für die Authentifizierung.
• Standardisiert: JWT ist ein weit verbreiteter Standard, der von vielen Bibliotheken und Plattformen unterstützt wird.
• Microservices-freundlich: Geeignet für Microservices-Architekturen, da Dienste JWTs unabhängig voneinander überprüfen können.

Nachteile der JWT-Authentifizierung

• Komplexität: Komplizierter zu implementieren als die Token-Authentifizierung.
• Token-Größe: JWTs können größer sein als einfache Tokens, was möglicherweise den Bandbreitenverbrauch erhöht.
• Token-Widerruf: Das Widerrufen eines JWTs ist eine Herausforderung. Einmal ausgestellt, ist es bis zu seinem Ablauf gültig. Workarounds beinhalten das Blacklisting widerrufener Tokens, was die Datenbankabhängigkeit wieder einführt.

Strategien zum Token-Widerruf

Sowohl die Token- als auch die JWT-Authentifizierung erfordern Mechanismen zum Widerrufen des Zugriffs. So können Sie den Token-Widerruf angehen:

Token-Authentifizierung Widerruf

Bei der Token-Authentifizierung ist der Widerruf unkompliziert: Löschen Sie einfach das Token aus der Datenbank:

            from rest_framework.authtoken.models import Token

try:
    token = Token.objects.get(user=request.user)
    token.delete()
except Token.DoesNotExist:
    pass

            

              
                Copy
              
            
          

JWT-Authentifizierung Widerruf

Der JWT-Widerruf ist komplexer, da das Token selbst eigenständig ist und (anfänglich) nicht auf eine Datenbankabfrage zur Validierung angewiesen ist. Gängige Strategien umfassen:

• Token-Blacklisting: Speichern Sie widerrufene Tokens in einer Blacklist (z. B. einer Datenbanktabelle oder einem Redis-Cache). Überprüfen Sie vor der Validierung eines JWT, ob es sich auf der Blacklist befindet. `djangorestframework-simplejwt` bietet integrierte Unterstützung für das Blacklisting von Refresh Tokens.
• Kurze Ablaufzeiten: Verwenden Sie kurze Ablaufzeiten für Access Tokens und verlassen Sie sich auf Refresh Tokens, um häufig neue Access Tokens zu erhalten. Dies begrenzt das Zeitfenster, in dem ein kompromittiertes Token verwendet werden kann.
• Refresh Tokens rotieren: Rotieren Sie Refresh Tokens nach jeder Verwendung. Dies invalidiert alte Tokens jedes Mal und verhindert Token-Diebstahl.

OAuth2 und OpenID Connect

Für komplexere Authentifizierungs- und Autorisierungsszenarien sollten Sie OAuth2 und OpenID Connect in Betracht ziehen. Diese Standards bieten ein robustes Framework zur Delegierung des Zugriffs auf Ressourcen, ohne Anmeldeinformationen zu teilen. OAuth2 ist in erster Linie ein Autorisierungsprotokoll, während OpenID Connect auf OAuth2 aufbaut, um Authentifizierungsdienste bereitzustellen. Mehrere Django-Pakete, wie z. B. `django-oauth-toolkit` und `django-allauth`, erleichtern die Integration von OAuth2 und OpenID Connect in Ihre DRF APIs.

Beispielszenario: Ein Benutzer möchte einer Drittanbieteranwendung Zugriff auf seine in Ihrer API gespeicherten Daten gewähren. Mit OAuth2 kann der Benutzer die Anwendung autorisieren, ohne seinen Benutzernamen und sein Passwort zu teilen. Stattdessen erhält die Anwendung einen Access Token, den sie verwenden kann, um auf die Benutzerdaten innerhalb des definierten Berechtigungsbereichs zuzugreifen.

Die Wahl der richtigen Authentifizierungsmethode

Die beste Authentifizierungsmethode hängt von Ihren spezifischen Anforderungen ab:

• Einfachheit und Implementierungsgeschwindigkeit: Die Token-Authentifizierung ist anfangs in der Regel einfacher zu implementieren.
• Skalierbarkeit: Die JWT-Authentifizierung ist skalierbarer für APIs mit hohem Datenverkehr.
• Sicherheitsanforderungen: Berücksichtigen Sie die Sensibilität Ihrer Daten und das erforderliche Sicherheitsniveau. OAuth2/OpenID Connect bieten die robustesten Sicherheitsfunktionen, erfordern jedoch eine komplexere Implementierung.
• Microservices-Architektur: JWTs eignen sich gut für Microservices, da jeder Dienst Tokens unabhängig voneinander überprüfen kann.

Best Practices für die API-Authentifizierung

• HTTPS verwenden: Verwenden Sie immer HTTPS, um die Kommunikation zwischen Client und Server zu verschlüsseln und Anmeldeinformationen vor Lauschangriffen zu schützen.
• Geheimnisse sicher speichern: Speichern Sie geheime Schlüssel oder Passwörter niemals im Klartext. Verwenden Sie Umgebungsvariablen oder sichere Konfigurationsverwaltungstools.
• Ratenbegrenzung implementieren: Schützen Sie Ihre API vor Missbrauch, indem Sie eine Ratenbegrenzung implementieren, um die Anzahl der Anfragen, die ein Client innerhalb eines bestimmten Zeitraums stellen kann, zu begrenzen.
• Eingaben validieren: Validieren Sie alle Eingabedaten gründlich, um Injection-Angriffe zu verhindern.
• Überwachen und protokollieren: Überwachen Sie Ihre API auf verdächtige Aktivitäten und protokollieren Sie Authentifizierungsereignisse zu Prüfzwecken.
• Bibliotheken regelmäßig aktualisieren: Halten Sie Ihre Django-, DRF- und Authentifizierungsbibliotheken auf dem neuesten Stand, um von Sicherheitspatches und Verbesserungen zu profitieren.
• CORS (Cross-Origin Resource Sharing) implementieren: Konfigurieren Sie CORS ordnungsgemäß, um nur vertrauenswürdigen Domains den Zugriff auf Ihre API von Webbrowsern aus zu gestatten.

Fazit

Die Auswahl der geeigneten Authentifizierungsmethode ist entscheidend für die Absicherung Ihrer DRF APIs. Die Token-Authentifizierung bietet Einfachheit, während die JWT-Authentifizierung Skalierbarkeit und Flexibilität bietet. Das Verständnis der Vor- und Nachteile jeder Methode, zusammen mit Best Practices für die API-Sicherheit, ermöglicht es Ihnen, robuste und sichere APIs zu erstellen, die Ihre Daten und Benutzer schützen.

Denken Sie daran, Ihre spezifischen Anforderungen zu berücksichtigen und die Lösung zu wählen, die Sicherheit, Leistung und einfache Implementierung am besten ausbalanciert. Erforschen Sie OAuth2 und OpenID Connect für komplexere Autorisierungsszenarien.