Autenticazione Python DRF: Implementazione Token vs. JWT per API Robuste

Proteggere le tue API è fondamentale. Quando crei API con Python e Django REST Framework (DRF), hai diverse opzioni di autenticazione disponibili. Questo articolo approfondisce due metodi popolari: l'autenticazione Token e l'autenticazione JWT (JSON Web Token), confrontando i loro punti di forza e debolezza e fornendo esempi pratici di implementazione.

Comprendere l'autenticazione nelle API

L'autenticazione è il processo di verifica dell'identità di un utente o di un'applicazione che accede alla tua API. Un sistema di autenticazione ben implementato garantisce che solo le entità autorizzate possano accedere alle risorse protette. Nel contesto delle API RESTful, l'autenticazione in genere comporta l'invio di credenziali (ad esempio, nome utente e password) con ogni richiesta. Il server quindi verifica queste credenziali e, se valide, concede l'accesso.

Autenticazione Token

L'autenticazione Token è un meccanismo semplice e diretto. Quando un utente effettua l'accesso con successo, il server genera un token univoco e casuale e lo memorizza nel database, associandolo all'utente. Il client invia quindi questo token nell'intestazione 'Authorization' delle richieste successive. Il server recupera il token dal database, ne verifica la validità e concede l'accesso di conseguenza.

Implementazione con DRF

DRF fornisce supporto integrato per l'autenticazione Token. Ecco come implementarla:

1. Installa DRF e registralo nel tuo progetto Django:

Innanzitutto, assicurati di avere Django REST Framework installato:

            pip install djangorestframework
            

              
                Copy
              
            
          

Quindi, aggiungilo a `INSTALLED_APPS` in `settings.py`:

            INSTALLED_APPS = [
    ...
    'rest_framework',
]
            

              
                Copy
              
            
          

2. Aggiungi lo schema TokenAuthentication come classe di autenticazione predefinita (opzionale, ma consigliato):

Nel tuo file `settings.py`, aggiungi quanto segue:

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

              
                Copy
              
            
          

Questo applicherà l'autenticazione Token globalmente su tutta la tua API. `SessionAuthentication` è incluso per l'interazione basata su browser, ma puoi rimuoverlo per un'applicazione puramente basata su API.

3. Crea un token per ogni utente:

Puoi creare automaticamente token per gli utenti al momento della creazione aggiungendo un gestore di segnali. Crea un file denominato `signals.py` nella tua app (ad esempio, `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
              
            
          

Quindi, importa questo file `signals.py` nel tuo file `users/apps.py` all'interno del metodo `ready` della classe di configurazione della tua app. Esempio per `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
              
            
          

Ora puoi gestire i token usando la riga di comando:

            python manage.py drf_create_token <username>
            

              
                Copy
              
            
          

4. Implementa le tue viste API:

Ecco un semplice esempio di una vista che richiede l'autenticazione Token:

            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': 'Ciao, ' + request.user.username + '! Sei autenticato.',
        }
        return Response(content)
            

              
                Copy
              
            
          

In questo esempio, `authentication_classes` specifica che deve essere utilizzata l'autenticazione Token e `permission_classes` specifica che solo gli utenti autenticati possono accedere alla vista.

5. Includi la vista API di login:

Hai anche bisogno di un endpoint per creare il token al momento del login riuscito:

            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': 'Credenziali non valide'}, status=status.HTTP_401_UNAUTHORIZED)
            

              
                Copy
              
            
          

Vantaggi dell'autenticazione Token

• Semplicità: facile da implementare e comprendere.
• Senza stato: ogni richiesta di token contiene informazioni che le consentono di essere autonoma.

Svantaggi dell'autenticazione Token

• Dipendenza dal database: richiede una ricerca nel database per ogni richiesta per convalidare il token. Ciò può influire sulle prestazioni, soprattutto su larga scala.
• Revoca del token: la revoca di un token richiede l'eliminazione dal database, che può essere complessa.
• Scalabilità: potrebbe non essere la soluzione più scalabile per API di grandi dimensioni e ad alto traffico a causa del sovraccarico del database.

Autenticazione JWT (JSON Web Token)

L'autenticazione JWT è un approccio più moderno e sofisticato. Un JWT è un oggetto JSON compatto e sicuro per URL che contiene asserzioni sull'utente. Queste asserzioni sono firmate digitalmente utilizzando una chiave segreta o una coppia di chiavi pubblica/privata. Quando un utente effettua l'accesso, il server genera un JWT e lo invia al client. Il client include quindi questo JWT nell'intestazione 'Authorization' delle richieste successive. Il server può verificare la firma del JWT senza la necessità di accedere a un database, rendendola una soluzione più efficiente e scalabile.

Implementazione con DRF

DRF non fornisce supporto integrato per l'autenticazione JWT, ma diverse librerie eccellenti semplificano l'integrazione. Uno dei più popolari è `djangorestframework-simplejwt`.

1. Installa `djangorestframework-simplejwt`:

            pip install djangorestframework-simplejwt
            

              
                Copy
              
            
          

2. Configura le impostazioni DRF:

Nel tuo file `settings.py`, aggiungi quanto segue:

            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
              
            
          

Spiegazione delle impostazioni:

• `ACCESS_TOKEN_LIFETIME`: per quanto tempo è valido il token di accesso (esempio, 5 minuti).
• `REFRESH_TOKEN_LIFETIME`: per quanto tempo è valido il token di aggiornamento (esempio, 1 giorno). I token di aggiornamento vengono utilizzati per ottenere nuovi token di accesso senza richiedere all'utente di accedere di nuovo.
• `ROTATE_REFRESH_TOKENS`: se ruotare i token di aggiornamento dopo ogni utilizzo.
• `BLACKLIST_AFTER_ROTATION`: se inserire nella lista nera i vecchi token di aggiornamento dopo la rotazione.
• `ALGORITHM`: l'algoritmo utilizzato per firmare il JWT (HS256 è una scelta comune).
• `SIGNING_KEY`: la chiave segreta utilizzata per firmare il JWT (in genere la tua Django SECRET_KEY).
• `AUTH_HEADER_TYPES`: il tipo di intestazione di autorizzazione (in genere "Bearer").

3. Includi le viste API di login e aggiornamento token:

`djangorestframework-simplejwt` fornisce viste per l'ottenimento e l'aggiornamento dei token. Includili nel tuo `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` fornisce token di accesso e aggiornamento dopo l'autenticazione riuscita. `TokenRefreshView` fornisce un nuovo token di accesso quando viene fornito un token di aggiornamento valido.

4. Implementa le tue viste API:

Ecco un semplice esempio di una vista che richiede l'autenticazione JWT:

            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': 'Ciao, ' + request.user.username + '! Sei autenticato.',
        }
        return Response(content)
            

              
                Copy
              
            
          

Simile all'esempio di autenticazione Token, `authentication_classes` specifica che deve essere utilizzata l'autenticazione JWT e `permission_classes` limita l'accesso solo agli utenti autenticati.

Vantaggi dell'autenticazione JWT

• Scalabilità: non è richiesta alcuna ricerca nel database per la convalida del token, rendendola più scalabile.
• Senza stato: il JWT contiene tutte le informazioni necessarie per l'autenticazione.
• Standardizzato: JWT è uno standard ampiamente adottato, supportato da molte librerie e piattaforme.
• Compatibile con i microservizi: adatto per architetture di microservizi, poiché i servizi possono verificare in modo indipendente i JWT.

Svantaggi dell'autenticazione JWT

• Complessità: più complesso da implementare rispetto all'autenticazione Token.
• Dimensione del token: i JWT possono essere più grandi dei semplici token, aumentando potenzialmente l'utilizzo della larghezza di banda.
• Revoca del token: la revoca di un JWT è impegnativa. Una volta emesso, è valido fino alla sua scadenza. Le soluzioni alternative prevedono l'inserimento nella lista nera dei token revocati, il che reintroduce la dipendenza dal database.

Strategie di revoca del token

Entrambi i metodi di autenticazione Token e JWT richiedono meccanismi per revocare l'accesso. Ecco come puoi affrontare la revoca del token:

Revoca dell'autenticazione Token

Con l'autenticazione Token, la revoca è semplice: basta eliminare il token dal database:

            from rest_framework.authtoken.models import Token

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

            

              
                Copy
              
            
          

Revoca dell'autenticazione JWT

La revoca JWT è più complessa perché il token stesso è autonomo e non si basa su una ricerca nel database per la convalida (inizialmente). Le strategie comuni includono:

• Inserimento del token nella lista nera: memorizza i token revocati in una lista nera (ad esempio, una tabella di database o una cache Redis). Prima di convalidare un JWT, controlla se è presente nella lista nera. `djangorestframework-simplejwt` fornisce supporto integrato per l'inserimento nella lista nera dei token di aggiornamento.
• Tempi di scadenza brevi: utilizza tempi di scadenza brevi del token di accesso e fai affidamento sui token di aggiornamento per ottenere frequentemente nuovi token di accesso. Ciò limita la finestra di opportunità per l'utilizzo di un token compromesso.
• Ruota i token di aggiornamento: ruota i token di aggiornamento dopo ogni utilizzo. Questo invaliderà i vecchi token ogni volta e impedirà il furto di token.

OAuth2 e OpenID Connect

Per scenari di autenticazione e autorizzazione più complessi, prendi in considerazione l'utilizzo di OAuth2 e OpenID Connect. Questi standard forniscono un framework robusto per delegare l'accesso alle risorse senza condividere le credenziali. OAuth2 è principalmente un protocollo di autorizzazione, mentre OpenID Connect si basa su OAuth2 per fornire servizi di autenticazione. Diversi pacchetti Django, come `django-oauth-toolkit` e `django-allauth`, facilitano l'integrazione di OAuth2 e OpenID Connect nelle tue API DRF.

Scenario di esempio: un utente desidera concedere a un'applicazione di terze parti l'accesso ai propri dati archiviati nella tua API. Con OAuth2, l'utente può autorizzare l'applicazione senza condividere il proprio nome utente e password. Invece, l'applicazione riceve un token di accesso che può utilizzare per accedere ai dati dell'utente all'interno dell'ambito di autorizzazioni definito.

Scegliere il metodo di autenticazione corretto

Il metodo di autenticazione migliore dipende dai tuoi requisiti specifici:

• Semplicità e velocità di implementazione: l'autenticazione Token è generalmente più facile da implementare inizialmente.
• Scalabilità: l'autenticazione JWT è più scalabile per API ad alto traffico.
• Requisiti di sicurezza: considera la sensibilità dei tuoi dati e il livello di sicurezza richiesto. OAuth2/OpenID Connect offrono le funzionalità di sicurezza più robuste, ma richiedono un'implementazione più complessa.
• Architettura di microservizi: i JWT sono adatti per i microservizi, poiché ogni servizio può verificare i token in modo indipendente.

Best practice per l'autenticazione API

• Usa HTTPS: usa sempre HTTPS per crittografare la comunicazione tra il client e il server, proteggendo le credenziali dall'intercettazione.
• Archivia i segreti in modo sicuro: non archiviare mai chiavi segrete o password in testo normale. Usa variabili di ambiente o strumenti di gestione della configurazione sicuri.
• Implementa la limitazione della frequenza: proteggi la tua API dagli abusi implementando la limitazione della frequenza per limitare il numero di richieste che un client può effettuare entro un determinato periodo di tempo.
• Valida l'input: valida accuratamente tutti i dati di input per prevenire attacchi di injection.
• Monitora e registra: monitora la tua API per attività sospette e registra gli eventi di autenticazione a fini di controllo.
• Aggiorna regolarmente le librerie: mantieni aggiornate le tue librerie Django, DRF e di autenticazione per beneficiare di patch di sicurezza e miglioramenti.
• Implementa CORS (Condivisione delle risorse tra origini diverse): configura correttamente CORS per consentire solo a domini attendibili di accedere alla tua API dai browser web.

Conclusione

La scelta del metodo di autenticazione appropriato è fondamentale per proteggere le tue API DRF. L'autenticazione Token offre semplicità, mentre l'autenticazione JWT offre scalabilità e flessibilità. Comprendere i vantaggi e gli svantaggi di ciascun metodo, insieme alle best practice per la sicurezza delle API, ti consentirà di creare API robuste e sicure che proteggono i tuoi dati e i tuoi utenti.

Ricorda di considerare le tue esigenze specifiche e di scegliere la soluzione che meglio bilancia sicurezza, prestazioni e facilità di implementazione. Esplora OAuth2 e OpenID Connect per scenari di autorizzazione più complessi.