Python DRF Authenticatie: Token vs. JWT Implementatie voor Robuuste API's

Het beveiligen van uw API's is van het grootste belang. Wanneer u API's bouwt met Python en het Django REST Framework (DRF), heeft u verschillende authenticatie-opties tot uw beschikking. Dit artikel duikt in twee populaire methoden: Token-authenticatie en JWT (JSON Web Token)-authenticatie, waarbij hun sterke en zwakke punten worden vergeleken en praktische implementatievoorbeelden worden gegeven.

Authenticatie in API's Begrijpen

Authenticatie is het proces waarbij de identiteit van een gebruiker of applicatie die toegang zoekt tot uw API wordt geverifieerd. Een goed geïmplementeerd authenticatiesysteem zorgt ervoor dat alleen geautoriseerde entiteiten toegang hebben tot beschermde bronnen. In de context van RESTful API's omvat authenticatie doorgaans het verzenden van inloggegevens (bijv. gebruikersnaam en wachtwoord) bij elk verzoek. De server verifieert vervolgens deze gegevens en verleent, indien geldig, toegang.

Token Authenticatie

Token-authenticatie is een eenvoudig en rechtlijnig mechanisme. Wanneer een gebruiker succesvol inlogt, genereert de server een uniek, willekeurig token en slaat dit op in de database, gekoppeld aan de gebruiker. De client stuurt dit token vervolgens in de 'Authorization'-header van volgende verzoeken. De server haalt het token uit de database, verifieert de geldigheid ervan en verleent dienovereenkomstig toegang.

Implementatie met DRF

DRF biedt ingebouwde ondersteuning voor Token-authenticatie. Hier is hoe u het implementeert:

1. Installeer DRF en registreer het in uw Django-project:

Zorg er eerst voor dat u Django REST Framework heeft geïnstalleerd:

            pip install djangorestframework
            

              
                Copy
              
            
          

Voeg het vervolgens toe aan uw `INSTALLED_APPS` in `settings.py`:

            INSTALLED_APPS = [
    ...
    'rest_framework',
]
            

              
                Copy
              
            
          

2. Voeg het TokenAuthentication-schema toe als een standaard authenticatieklasse (optioneel, maar aanbevolen):

Voeg in uw `settings.py`-bestand het volgende toe:

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

              
                Copy
              
            
          

Dit past Token Authenticatie wereldwijd toe op uw API. `SessionAuthentication` is inbegrepen voor browser-gebaseerde interactie, maar u kunt dit verwijderen voor een puur API-gestuurde applicatie.

3. Maak een Token voor elke gebruiker:

U kunt automatisch tokens aanmaken voor gebruikers bij het aanmaken door een signaalhandler toe te voegen. Maak een bestand genaamd `signals.py` in uw app (bijv. `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
              
            
          

Importeer vervolgens dit `signals.py`-bestand in uw `users/apps.py`-bestand binnen de `ready`-methode van uw app-configuratieklasse. Voorbeeld voor `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
              
            
          

Nu kunt u tokens beheren via de command line:

            python manage.py drf_create_token <username>
            

              
                Copy
              
            
          

4. Implementeer uw API-views:

Hier is een eenvoudig voorbeeld van een view die Token-authenticatie vereist:

            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': 'Hallo, ' + request.user.username + '! U bent geauthenticeerd.',
        }
        return Response(content)
            

              
                Copy
              
            
          

In dit voorbeeld specificeert `authentication_classes` dat Token-authenticatie moet worden gebruikt, en `permission_classes` specificeert dat alleen geauthenticeerde gebruikers toegang hebben tot de view.

5. Voeg een Login API View toe:

U heeft ook een endpoint nodig om het token aan te maken bij een succesvolle login:

            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': 'Ongeldige inloggegevens'}, status=status.HTTP_401_UNAUTHORIZED)
            

              
                Copy
              
            
          

Voordelen van Token Authenticatie

• Eenvoud: Makkelijk te implementeren en te begrijpen.
• Stateless: Elk token-verzoek bevat informatie waardoor het op zichzelf kan staan.

Nadelen van Token Authenticatie

• Database-afhankelijkheid: Vereist een database-lookup voor elk verzoek om het token te valideren. Dit kan de prestaties beïnvloeden, vooral op grote schaal.
• Token Intrekking: Het intrekken van een token vereist het verwijderen uit de database, wat complex kan zijn.
• Schaalbaarheid: Is mogelijk niet de meest schaalbare oplossing voor grote API's met veel verkeer vanwege de database-overhead.

JWT (JSON Web Token) Authenticatie

JWT-authenticatie is een modernere en geavanceerdere aanpak. Een JWT is een compact, URL-veilig JSON-object dat claims over de gebruiker bevat. Deze claims zijn digitaal ondertekend met een geheime sleutel of een publiek/privaat sleutelpaar. Wanneer een gebruiker inlogt, genereert de server een JWT en stuurt deze naar de client. De client neemt deze JWT vervolgens op in de 'Authorization'-header van volgende verzoeken. De server kan de handtekening van de JWT verifiëren zonder toegang tot een database te hebben, wat het een efficiëntere en schaalbaardere oplossing maakt.

Implementatie met DRF

DRF biedt geen ingebouwde ondersteuning voor JWT-authenticatie, maar diverse uitstekende bibliotheken maken de integratie eenvoudig. Een van de populairste is `djangorestframework-simplejwt`.

1. Installeer `djangorestframework-simplejwt`:

            pip install djangorestframework-simplejwt
            

              
                Copy
              
            
          

2. Configureer DRF-instellingen:

Voeg in uw `settings.py`-bestand het volgende toe:

            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
              
            
          

Uitleg van de instellingen:

• `ACCESS_TOKEN_LIFETIME`: Hoe lang een access token geldig is (voorbeeld: 5 minuten).
• `REFRESH_TOKEN_LIFETIME`: Hoe lang het refresh token geldig is (voorbeeld: 1 dag). Refresh tokens worden gebruikt om nieuwe access tokens te verkrijgen zonder dat de gebruiker opnieuw hoeft in te loggen.
• `ROTATE_REFRESH_TOKENS`: Of refresh tokens na elk gebruik moeten worden geroteerd.
• `BLACKLIST_AFTER_ROTATION`: Of oude refresh tokens na rotatie op een zwarte lijst moeten worden geplaatst.
• `ALGORITHM`: Het algoritme dat wordt gebruikt om de JWT te ondertekenen (HS256 is een veelvoorkomende keuze).
• `SIGNING_KEY`: De geheime sleutel die wordt gebruikt om de JWT te ondertekenen (meestal uw Django SECRET_KEY).
• `AUTH_HEADER_TYPES`: Het type autorisatie-header (meestal "Bearer").

3. Voeg Login en Refresh Token API Views toe:

`djangorestframework-simplejwt` biedt views voor het verkrijgen en vernieuwen van tokens. Neem ze op in uw `urls.py`:

            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` levert access en refresh tokens na succesvolle authenticatie. `TokenRefreshView` levert een nieuw access token wanneer een geldig refresh token wordt aangeboden.

4. Implementeer uw API-views:

Hier is een eenvoudig voorbeeld van een view die JWT-authenticatie vereist:

            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': 'Hallo, ' + request.user.username + '! U bent geauthenticeerd.',
        }
        return Response(content)
            

              
                Copy
              
            
          

Net als in het Token-authenticatievoorbeeld, specificeert `authentication_classes` dat JWT-authenticatie moet worden gebruikt, en beperkt `permission_classes` de toegang tot alleen geauthenticeerde gebruikers.

Voordelen van JWT Authenticatie

• Schaalbaarheid: Er is geen database-lookup nodig voor tokenvalidatie, wat het schaalbaarder maakt.
• Stateless: De JWT bevat alle benodigde informatie voor authenticatie.
• Gestandaardiseerd: JWT is een wijdverbreide standaard, ondersteund door vele bibliotheken en platforms.
• Vriendelijk voor Microservices: Geschikt voor microservices-architecturen, omdat services onafhankelijk JWT's kunnen verifiëren.

Nadelen van JWT Authenticatie

• Complexiteit: Complexer om te implementeren dan Token-authenticatie.
• Token Grootte: JWT's kunnen groter zijn dan simpele tokens, wat het bandbreedtegebruik kan verhogen.
• Token Intrekking: Het intrekken van een JWT is een uitdaging. Eenmaal uitgegeven, is het geldig tot de vervaldatum. Oplossingen omvatten het op een zwarte lijst plaatsen van ingetrokken tokens, wat de database-afhankelijkheid weer introduceert.

Strategieën voor Token Intrekking

Zowel Token- als JWT-authenticatiemethoden vereisen mechanismen om toegang in te trekken. Hier is hoe u tokenintrekking kunt benaderen:

Intrekking bij Token Authenticatie

Bij Token-authenticatie is intrekking eenvoudig: verwijder simpelweg het token uit de database:

            from rest_framework.authtoken.models import Token

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

            

              
                Copy
              
            
          

Intrekking bij JWT Authenticatie

Het intrekken van een JWT is complexer omdat het token zelfstandig is en niet afhankelijk is van een database-lookup voor validatie (in eerste instantie). Veelvoorkomende strategieën zijn:

• Token Blacklisting: Sla ingetrokken tokens op in een zwarte lijst (bijv. een databasetabel of een Redis-cache). Controleer voordat u een JWT valideert of deze op de zwarte lijst staat. `djangorestframework-simplejwt` biedt ingebouwde ondersteuning voor het op een zwarte lijst plaatsen van refresh tokens.
• Korte Vervaltijden: Gebruik korte vervaltijden voor access tokens en vertrouw op refresh tokens om regelmatig nieuwe access tokens te verkrijgen. Dit beperkt de tijd waarin een gecompromitteerd token kan worden gebruikt.
• Roteer Refresh Tokens: Roteer refresh tokens na elk gebruik. Dit maakt oude tokens ongeldig en voorkomt diefstal van tokens.

OAuth2 en OpenID Connect

Voor complexere authenticatie- en autorisatiescenario's kunt u overwegen OAuth2 en OpenID Connect te gebruiken. Deze standaarden bieden een robuust raamwerk voor het delegeren van toegang tot bronnen zonder inloggegevens te delen. OAuth2 is voornamelijk een autorisatieprotocol, terwijl OpenID Connect voortbouwt op OAuth2 om authenticatiediensten te bieden. Verschillende Django-pakketten, zoals `django-oauth-toolkit` en `django-allauth`, vergemakkelijken de integratie van OAuth2 en OpenID Connect in uw DRF API's.

Voorbeeldscenario: Een gebruiker wil een externe applicatie toegang geven tot zijn gegevens die zijn opgeslagen in uw API. Met OAuth2 kan de gebruiker de applicatie autoriseren zonder zijn gebruikersnaam en wachtwoord te delen. In plaats daarvan ontvangt de applicatie een access token dat het kan gebruiken om toegang te krijgen tot de gegevens van de gebruiker binnen de gedefinieerde reikwijdte van de machtigingen.

De Juiste Authenticatiemethode Kiezen

De beste authenticatiemethode hangt af van uw specifieke vereisten:

• Eenvoud en Snelheid van Implementatie: Token-authenticatie is over het algemeen eenvoudiger om in eerste instantie te implementeren.
• Schaalbaarheid: JWT-authenticatie is schaalbaarder voor API's met veel verkeer.
• Beveiligingseisen: Overweeg de gevoeligheid van uw gegevens en het vereiste beveiligingsniveau. OAuth2/OpenID Connect bieden de meest robuuste beveiligingsfuncties, maar vereisen een complexere implementatie.
• Microservices Architectuur: JWT's zijn zeer geschikt voor microservices, aangezien elke service onafhankelijk tokens kan verifiëren.

Best Practices voor API Authenticatie

• Gebruik HTTPS: Gebruik altijd HTTPS om de communicatie tussen de client en de server te versleutelen, en zo inloggegevens te beschermen tegen afluisteren.
• Sla Geheimen Veilig Op: Sla nooit geheime sleutels of wachtwoorden op in platte tekst. Gebruik omgevingsvariabelen of veilige configuratiebeheertools.
• Implementeer Rate Limiting: Bescherm uw API tegen misbruik door rate limiting te implementeren om het aantal verzoeken dat een client binnen een bepaalde periode kan doen, te beperken.
• Valideer Input: Valideer alle invoergegevens grondig om injectie-aanvallen te voorkomen.
• Monitor en Log: Monitor uw API op verdachte activiteiten en log authenticatiegebeurtenissen voor auditdoeleinden.
• Update Bibliotheken Regelmatig: Houd uw Django-, DRF- en authenticatiebibliotheken up-to-date om te profiteren van beveiligingspatches en verbeteringen.
• Implementeer CORS (Cross-Origin Resource Sharing): Configureer CORS correct om alleen vertrouwde domeinen toegang te geven tot uw API vanuit webbrowsers.

Conclusie

Het selecteren van de juiste authenticatiemethode is cruciaal voor het beveiligen van uw DRF API's. Token-authenticatie biedt eenvoud, terwijl JWT-authenticatie schaalbaarheid en flexibiliteit biedt. Door de voor- en nadelen van elke methode te begrijpen, samen met de best practices voor API-beveiliging, kunt u robuuste en veilige API's bouwen die uw gegevens en gebruikers beschermen.

Vergeet niet uw specifieke behoeften in overweging te nemen en de oplossing te kiezen die de beste balans biedt tussen beveiliging, prestaties en implementatiegemak. Verken OAuth2 en OpenID Connect voor complexere autorisatiescenario's.