Python DRF-autentisering: Token kontra JWT-implementering för robusta API:er

Att säkra dina API:er är av största vikt. När du bygger API:er med Python och Django REST Framework (DRF) har du flera autentiseringsalternativ tillgängliga. Den här artikeln går in på två populära metoder: Token-autentisering och JWT-autentisering (JSON Web Token), jämför deras styrkor och svagheter och ger praktiska implementeringsexempel.

Förstå autentisering i API:er

Autentisering är processen att verifiera identiteten hos en användare eller applikation som ansluter till ditt API. Ett väl implementerat autentiseringssystem säkerställer att endast behöriga entiteter kan komma åt skyddade resurser. I samband med RESTful API:er innebär autentisering vanligtvis att autentiseringsuppgifter (t.ex. användarnamn och lösenord) skickas med varje begäran. Servern verifierar sedan dessa uppgifter och ger, om de är giltiga, åtkomst.

Token-autentisering

Token-autentisering är en enkel och okomplicerad mekanism. När en användare loggar in genererar servern en unik, slumpmässig token och lagrar den i databasen och associerar den med användaren. Klienten skickar sedan denna token i 'Authorization'-huvudet för efterföljande förfrågningar. Servern hämtar token från databasen, verifierar dess giltighet och ger åtkomst i enlighet därmed.

Implementering med DRF

DRF har inbyggt stöd för Token-autentisering. Så här implementerar du det:

1. Installera DRF och registrera det i ditt Django-projekt:

Se först till att du har Django REST Framework installerat:

            pip install djangorestframework
            

              
                Copy
              
            
          

Lägg sedan till det i dina `INSTALLED_APPS` i `settings.py`:

            INSTALLED_APPS = [
    ...
    'rest_framework',
]
            

              
                Copy
              
            
          

2. Lägg till TokenAuthentication-schemat som en standardautentiseringsklass (valfritt, men rekommenderas):

Lägg till följande i din `settings.py`-fil:

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

              
                Copy
              
            
          

Detta kommer att tillämpa Token-autentisering globalt över hela ditt API. `SessionAuthentication` ingår för webbläsarbaserad interaktion, men du kan ta bort det för en helt API-driven applikation.

3. Skapa en Token för varje användare:

Du kan automatiskt skapa tokens för användare vid skapandet genom att lägga till en signalhanterare. Skapa en fil med namnet `signals.py` i din app (t.ex. `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
              
            
          

Importera sedan den här `signals.py`-filen i din `users/apps.py`-fil inom `ready`-metoden i din appkonfigurationsklass. Exempel 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
              
            
          

Nu kan du hantera tokes med kommandoraden:

            python manage.py drf_create_token <username>
            

              
                Copy
              
            
          

4. Implementera dina API-vyer:

Här är ett enkelt exempel på en vy som kräver Token-autentisering:

            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
              
            
          

I det här exemplet anger `authentication_classes` att Token-autentisering ska användas, och `permission_classes` anger att endast autentiserade användare kan komma åt vyn.

5. Inkludera API-vy för inloggning:

Du behöver också en slutpunkt för att skapa token vid lyckad inloggning:

            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
              
            
          

Fördelar med Token-autentisering

• Enkelhet: Lätt att implementera och förstå.
• Tillståndslös: Varje token-begäran innehåller information som gör att den kan stå ensam.

Nackdelar med Token-autentisering

• Databasberoende: Kräver en databasuppslagning för varje begäran för att validera token. Detta kan påverka prestandan, särskilt i stor skala.
• Återkallande av token: Att återkalla en token kräver att den raderas från databasen, vilket kan vara komplext.
• Skalbarhet: Kanske inte den mest skalbara lösningen för stora API:er med hög trafik på grund av databasomkostnaderna.

JWT-autentisering (JSON Web Token)

JWT-autentisering är ett modernare och mer sofistikerat tillvägagångssätt. En JWT är ett kompakt, URL-säkert JSON-objekt som innehåller anspråk om användaren. Dessa anspråk är digitalt signerade med en hemlig nyckel eller ett offentligt/privat nyckelpar. När en användare loggar in genererar servern en JWT och skickar den till klienten. Klienten inkluderar sedan denna JWT i 'Authorization'-huvudet för efterföljande förfrågningar. Servern kan verifiera JWT:s signatur utan att behöva komma åt en databas, vilket gör det till en mer effektiv och skalbar lösning.

Implementering med DRF

DRF har inte inbyggt stöd för JWT-autentisering, men flera utmärkta bibliotek gör det enkelt att integrera. Ett av de mest populära är `djangorestframework-simplejwt`.

1. Installera `djangorestframework-simplejwt`:

            pip install djangorestframework-simplejwt
            

              
                Copy
              
            
          

2. Konfigurera DRF-inställningar:

Lägg till följande i din `settings.py`-fil:

            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
              
            
          

Förklaring av inställningar:

• `ACCESS_TOKEN_LIFETIME`: Hur länge åtkomsttoken är giltig (exempel, 5 minuter).
• `REFRESH_TOKEN_LIFETIME`: Hur länge uppdateringstoken är giltig (exempel, 1 dag). Uppdateringstokens används för att erhålla nya åtkomsttokens utan att kräva att användaren loggar in igen.
• `ROTATE_REFRESH_TOKENS`: Om uppdateringstokens ska roteras efter varje användning.
• `BLACKLIST_AFTER_ROTATION`: Om gamla uppdateringstokens ska svartlistas efter rotation.
• `ALGORITHM`: Algoritmen som används för att signera JWT (HS256 är ett vanligt val).
• `SIGNING_KEY`: Den hemliga nyckeln som används för att signera JWT (vanligtvis din Django SECRET_KEY).
• `AUTH_HEADER_TYPES`: Typen av auktoriseringshuvud (vanligtvis "Bearer").

3. Inkludera API-vyer för inloggning och uppdatering av token:

`djangorestframework-simplejwt` tillhandahåller vyer för att erhålla och uppdatera tokens. Inkludera dem i din `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` ger åtkomst och uppdateringstokens efter lyckad autentisering. `TokenRefreshView` ger en ny åtkomsttoken när den tillhandahålls med en giltig uppdateringstoken.

4. Implementera dina API-vyer:

Här är ett enkelt exempel på en vy som kräver JWT-autentisering:

            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
              
            
          

I likhet med Token-autentiseringsexemplet anger `authentication_classes` att JWT-autentisering ska användas, och `permission_classes` begränsar åtkomsten till endast autentiserade användare.

Fördelar med JWT-autentisering

• Skalbarhet: Ingen databasuppslagning krävs för tokenvalidering, vilket gör den mer skalbar.
• Tillståndslös: JWT innehåller all nödvändig information för autentisering.
• Standardiserad: JWT är en allmänt vedertagen standard som stöds av många bibliotek och plattformar.
• Mikrotjänstevänlig: Lämplig för mikrotjänstarkitekturer, eftersom tjänster oberoende kan verifiera JWT:er.

Nackdelar med JWT-autentisering

• Komplexitet: Mer komplex att implementera än Token-autentisering.
• Tokenstorlek: JWT:er kan vara större än enkla tokens, vilket potentiellt ökar bandbreddsanvändningen.
• Återkallande av token: Att återkalla en JWT är utmanande. När den väl har utfärdats är den giltig fram till dess utgång. Lösningar involverar svartlistning av återkallade tokens, vilket återinför databasberoende.

Strategier för återkallande av token

Både Token- och JWT-autentiseringsmetoder kräver mekanismer för att återkalla åtkomst. Så här kan du närma dig återkallande av token:

Återkallande av Token-autentisering

Med Token-autentisering är återkallande okomplicerat: radera helt enkelt token från databasen:

            from rest_framework.authtoken.models import Token

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

            

              
                Copy
              
            
          

Återkallande av JWT-autentisering

JWT-återkallande är mer komplext eftersom token i sig är fristående och inte förlitar sig på en databasuppslagning för validering (initialt). Vanliga strategier inkluderar:

• Svartlistning av token: Lagra återkallade tokens i en svartlista (t.ex. en databastabell eller en Redis-cache). Innan du validerar en JWT, kontrollera om den finns i svartlistan. `djangorestframework-simplejwt` har inbyggt stöd för svartlistning av uppdateringstokens.
• Korta utgångstider: Använd korta utgångstider för åtkomsttokens och förlita dig på uppdateringstokens för att erhålla nya åtkomsttokens ofta. Detta begränsar möjlighetsfönstret för en komprometterad token att användas.
• Rotera uppdateringstokens: Rotera uppdateringstokens efter varje användning. Detta kommer att ogiltigförklara gamla tokens varje gång och förhindra tokenstöld.

OAuth2 och OpenID Connect

För mer komplexa autentiserings- och auktoriseringsscenarier, överväg att använda OAuth2 och OpenID Connect. Dessa standarder tillhandahåller ett robust ramverk för att delegera åtkomst till resurser utan att dela autentiseringsuppgifter. OAuth2 är främst ett auktoriseringsprotokoll, medan OpenID Connect bygger på OAuth2 för att tillhandahålla autentiseringstjänster. Flera Django-paket, såsom `django-oauth-toolkit` och `django-allauth`, underlättar integrationen av OAuth2 och OpenID Connect i dina DRF-API:er.

Exempelscenario: En användare vill ge en tredje parts applikation åtkomst till sina data som lagras i ditt API. Med OAuth2 kan användaren auktorisera applikationen utan att dela sitt användarnamn och lösenord. Istället får applikationen en åtkomsttoken som den kan använda för att komma åt användarens data inom den definierade behörighetsomfattningen.

Välja rätt autentiseringsmetod

Den bästa autentiseringsmetoden beror på dina specifika krav:

• Enkelhet och implementeringshastighet: Token-autentisering är generellt sett lättare att implementera initialt.
• Skalbarhet: JWT-autentisering är mer skalbar för API:er med hög trafik.
• Säkerhetskrav: Tänk på känsligheten hos dina data och den säkerhetsnivå som krävs. OAuth2/OpenID Connect erbjuder de mest robusta säkerhetsfunktionerna men kräver mer komplex implementering.
• Mikrotjänstarkitektur: JWT:er är väl lämpade för mikrotjänster, eftersom varje tjänst oberoende kan verifiera tokens.

Bästa praxis för API-autentisering

• Använd HTTPS: Använd alltid HTTPS för att kryptera kommunikationen mellan klienten och servern, vilket skyddar autentiseringsuppgifter från avlyssning.
• Lagra hemligheter säkert: Lagra aldrig hemliga nycklar eller lösenord i klartext. Använd miljövariabler eller säkra verktyg för konfigurationshantering.
• Implementera hastighetsbegränsning: Skydda ditt API från missbruk genom att implementera hastighetsbegränsning för att begränsa antalet förfrågningar som en klient kan göra inom en given tidsperiod.
• Validera indata: Validera noggrant all indata för att förhindra injektionsattacker.
• Övervaka och logga: Övervaka ditt API för misstänkt aktivitet och logga autentiseringshändelser för granskningsändamål.
• Uppdatera bibliotek regelbundet: Håll dina Django-, DRF- och autentiseringsbibliotek uppdaterade för att dra nytta av säkerhetskorrigeringar och förbättringar.
• Implementera CORS (Cross-Origin Resource Sharing): Konfigurera CORS korrekt för att tillåta att endast betrodda domäner får åtkomst till ditt API från webbläsare.

Slutsats

Att välja lämplig autentiseringsmetod är avgörande för att säkra dina DRF-API:er. Token-autentisering erbjuder enkelhet, medan JWT-autentisering ger skalbarhet och flexibilitet. Att förstå fördelarna och nackdelarna med varje metod, tillsammans med bästa praxis för API-säkerhet, gör att du kan bygga robusta och säkra API:er som skyddar dina data och användare.

Kom ihåg att överväga dina specifika behov och välj den lösning som bäst balanserar säkerhet, prestanda och enkel implementering. Utforska OAuth2 och OpenID Connect för mer komplexa auktoriseringsscenarier.