Authentification DRF en Python : Implémentation Token vs JWT pour des API Robustes

La sécurisation de vos API est primordiale. Lors de la création d'API avec Python et le Django REST Framework (DRF), plusieurs options d'authentification s'offrent à vous. Cet article explore deux méthodes populaires : l'authentification par Token et l'authentification par JWT (JSON Web Token), en comparant leurs forces et faiblesses, et en fournissant des exemples d'implémentation pratiques.

Comprendre l'authentification dans les API

L'authentification est le processus de vérification de l'identité d'un utilisateur ou d'une application accédant à votre API. Un système d'authentification bien implémenté garantit que seules les entités autorisées peuvent accéder aux ressources protégées. Dans le contexte des API RESTful, l'authentification implique généralement l'envoi d'identifiants (par exemple, nom d'utilisateur et mot de passe) à chaque requête. Le serveur vérifie ensuite ces identifiants et, s'ils sont valides, accorde l'accès.

Authentification par Token

L'authentification par Token est un mécanisme simple et direct. Lorsqu'un utilisateur se connecte avec succès, le serveur génère un token unique et aléatoire et le stocke dans la base de données, l'associant à l'utilisateur. Le client envoie ensuite ce token dans l'en-tête 'Authorization' des requêtes ultérieures. Le serveur récupère le token de la base de données, vérifie sa validité et accorde l'accès en conséquence.

Implémentation avec DRF

DRF offre un support intégré pour l'authentification par Token. Voici comment l'implémenter :

1. Installer DRF et l'enregistrer dans votre projet Django :

Tout d'abord, assurez-vous d'avoir installé Django REST Framework :

            pip install djangorestframework
            

              
                Copy
              
            
          

Ensuite, ajoutez-le à votre `INSTALLED_APPS` dans `settings.py` :

            INSTALLED_APPS = [
    ...
    'rest_framework',
]
            

              
                Copy
              
            
          

2. Ajouter le schéma d'authentification par Token comme classe d'authentification par défaut (facultatif, mais recommandé) :

Dans votre fichier `settings.py`, ajoutez ceci :

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

              
                Copy
              
            
          

Cela appliquera l'authentification par Token globalement à votre API. `SessionAuthentication` est inclus pour l'interaction basée sur le navigateur, mais vous pouvez le supprimer pour une application purement pilotée par API.

3. Créer un Token pour chaque utilisateur :

Vous pouvez créer automatiquement des tokens pour les utilisateurs lors de leur création en ajoutant un gestionnaire de signaux. Créez un fichier nommé `signals.py` dans votre application (par exemple, `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
              
            
          

Ensuite, importez ce fichier `signals.py` dans votre fichier `users/apps.py` dans la méthode `ready` de votre classe de configuration d'application. Exemple pour `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
              
            
          

Vous pouvez maintenant gérer les tokens en ligne de commande :

            python manage.py drf_create_token <nom_utilisateur>
            

              
                Copy
              
            
          

4. Implémenter vos vues API :

Voici un exemple simple de vue qui nécessite l'authentification par 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': 'Bonjour, ' + request.user.username + "! Vous êtes authentifié.",
        }
        return Response(content)
            

              
                Copy
              
            
          

Dans cet exemple, `authentication_classes` spécifie que l'authentification par Token doit être utilisée, et `permission_classes` spécifie que seuls les utilisateurs authentifiés peuvent accéder à la vue.

5. Inclure la vue API de connexion :

Vous avez également besoin d'un point d'accès pour créer le token lors d'une connexion réussie :

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

              
                Copy
              
            
          

Avantages de l'authentification par Token

• Simplicité : Facile à implémenter et à comprendre.
• Sans état : Chaque requête de token contient des informations qui lui permettent d'être autonome.

Inconvénients de l'authentification par Token

• Dépendance à la base de données : Nécessite une requête à la base de données pour chaque requête afin de valider le token. Cela peut impacter les performances, surtout à grande échelle.
• Révocation de token : La révocation d'un token nécessite sa suppression de la base de données, ce qui peut être complexe.
• Scalabilité : Peut ne pas être la solution la plus évolutive pour les API volumineuses à fort trafic en raison de la surcharge de la base de données.

Authentification JWT (JSON Web Token)

L'authentification par JWT est une approche plus moderne et sophistiquée. Un JWT est un objet JSON compact et utilisable dans une URL qui contient des informations sur l'utilisateur. Ces informations sont signées numériquement à l'aide d'une clé secrète ou d'une paire de clés publique/privée. Lorsqu'un utilisateur se connecte, le serveur génère un JWT et l'envoie au client. Le client inclut ensuite ce JWT dans l'en-tête 'Authorization' des requêtes ultérieures. Le serveur peut vérifier la signature du JWT sans avoir à accéder à une base de données, ce qui en fait une solution plus efficace et évolutive.

Implémentation avec DRF

DRF ne fournit pas de support intégré pour l'authentification JWT, mais plusieurs excellentes bibliothèques facilitent son intégration. L'une des plus populaires est `djangorestframework-simplejwt`.

1. Installer `djangorestframework-simplejwt` :

            pip install djangorestframework-simplejwt
            

              
                Copy
              
            
          

2. Configurer les paramètres DRF :

Dans votre fichier `settings.py`, ajoutez ceci :

            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
              
            
          

Explication des paramètres :

• `ACCESS_TOKEN_LIFETIME` : Durée de validité du token d'accès (exemple, 5 minutes).
• `REFRESH_TOKEN_LIFETIME` : Durée de validité du token de rafraîchissement (exemple, 1 jour). Les tokens de rafraîchissement sont utilisés pour obtenir de nouveaux tokens d'accès sans obliger l'utilisateur à se reconnecter.
• `ROTATE_REFRESH_TOKENS` : Indique s'il faut faire pivoter les tokens de rafraîchissement après chaque utilisation.
• `BLACKLIST_AFTER_ROTATION` : Indique s'il faut mettre en liste noire les anciens tokens de rafraîchissement après leur rotation.
• `ALGORITHM` : L'algorithme utilisé pour signer le JWT (HS256 est un choix courant).
• `SIGNING_KEY` : La clé secrète utilisée pour signer le JWT (généralement votre `SECRET_KEY` Django).
• `AUTH_HEADER_TYPES` : Le type d'en-tête d'autorisation (généralement "Bearer").

3. Inclure les vues API de connexion et de rafraîchissement de token :

`djangorestframework-simplejwt` fournit des vues pour obtenir et rafraîchir les tokens. Incluez-les dans votre `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` fournit des tokens d'accès et de rafraîchissement après une authentification réussie. `TokenRefreshView` fournit un nouveau token d'accès lorsqu'il reçoit un token de rafraîchissement valide.

4. Implémenter vos vues API :

Voici un exemple simple de vue qui nécessite l'authentification 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': 'Bonjour, ' + request.user.username + "! Vous êtes authentifié.",
        }
        return Response(content)
            

              
                Copy
              
            
          

Similaire à l'exemple d'authentification par Token, `authentication_classes` spécifie que l'authentification JWT doit être utilisée, et `permission_classes` restreint l'accès uniquement aux utilisateurs authentifiés.

Avantages de l'authentification JWT

• Scalabilité : Aucune requête à la base de données n'est nécessaire pour la validation du token, ce qui la rend plus évolutive.
• Sans état : Le JWT contient toutes les informations nécessaires à l'authentification.
• Standardisé : JWT est une norme largement adoptée, prise en charge par de nombreuses bibliothèques et plateformes.
• Adapté aux microservices : Convient aux architectures de microservices, car les services peuvent vérifier indépendamment les JWT.

Inconvénients de l'authentification JWT

• Complexité : Plus complexe à implémenter que l'authentification par Token.
• Taille du token : Les JWT peuvent être plus volumineux que les tokens simples, augmentant potentiellement l'utilisation de la bande passante.
• Révocation de token : La révocation d'un JWT est difficile. Une fois émis, il est valide jusqu'à son expiration. Les solutions de contournement consistent à mettre en liste noire les tokens révoqués, ce qui réintroduit une dépendance à la base de données.

Stratégies de révocation de token

Les deux méthodes d'authentification par Token et JWT nécessitent des mécanismes de révocation d'accès. Voici comment vous pouvez aborder la révocation de token :

Révocation de l'authentification par Token

Avec l'authentification par Token, la révocation est simple : supprimez simplement le token de la base de données :

            from rest_framework.authtoken.models import Token

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

            

              
                Copy
              
            
          

Révocation de l'authentification JWT

La révocation des JWT est plus complexe car le token lui-même est autonome et ne repose pas sur une requête à la base de données pour sa validation (initialement). Les stratégies courantes incluent :

• Mise en liste noire des tokens : Stockez les tokens révoqués dans une liste noire (par exemple, une table de base de données ou un cache Redis). Avant de valider un JWT, vérifiez s'il figure dans la liste noire. `djangorestframework-simplejwt` fournit un support intégré pour la mise en liste noire des tokens de rafraîchissement.
• Temps d'expiration courts : Utilisez des temps d'expiration courts pour les tokens d'accès et utilisez les tokens de rafraîchissement pour obtenir fréquemment de nouveaux tokens d'accès. Cela limite la fenêtre d'opportunité pour qu'un token compromis soit utilisé.
• Rotation des tokens de rafraîchissement : Faites pivoter les tokens de rafraîchissement après chaque utilisation. Cela invalidera les anciens tokens à chaque fois et empêchera le vol de tokens.

OAuth2 et OpenID Connect

Pour des scénarios d'authentification et d'autorisation plus complexes, envisagez d'utiliser OAuth2 et OpenID Connect. Ces normes fournissent un cadre robuste pour déléguer l'accès aux ressources sans partager d'identifiants. OAuth2 est principalement un protocole d'autorisation, tandis qu'OpenID Connect s'appuie sur OAuth2 pour fournir des services d'authentification. Plusieurs packages Django, tels que `django-oauth-toolkit` et `django-allauth`, facilitent l'intégration d'OAuth2 et d'OpenID Connect dans vos API DRF.

Scénario Exemple : Un utilisateur souhaite accorder à une application tierce l'accès à ses données stockées dans votre API. Avec OAuth2, l'utilisateur peut autoriser l'application sans partager son nom d'utilisateur et son mot de passe. Au lieu de cela, l'application reçoit un token d'accès qu'elle peut utiliser pour accéder aux données de l'utilisateur dans la portée définie des autorisations.

Choisir la bonne méthode d'authentification

La meilleure méthode d'authentification dépend de vos exigences spécifiques :

• Simplicité et rapidité d'implémentation : L'authentification par Token est généralement plus facile à implémenter initialement.
• Scalabilité : L'authentification JWT est plus évolutive pour les API à fort trafic.
• Exigences de sécurité : Tenez compte de la sensibilité de vos données et du niveau de sécurité requis. OAuth2/OpenID Connect offre les fonctionnalités de sécurité les plus robustes mais nécessite une implémentation plus complexe.
• Architecture de microservices : Les JWT conviennent bien aux microservices, car chaque service peut vérifier indépendamment les tokens.

Bonnes pratiques pour l'authentification des API

• Utiliser HTTPS : Utilisez toujours HTTPS pour chiffrer la communication entre le client et le serveur, protégeant ainsi les identifiants contre l'écoute clandestine.
• Stocker les secrets en toute sécurité : Ne stockez jamais de clés secrètes ou de mots de passe en clair. Utilisez des variables d'environnement ou des outils de gestion de configuration sécurisés.
• Implémenter la limitation de débit : Protégez votre API contre les abus en implémentant la limitation de débit pour restreindre le nombre de requêtes qu'un client peut effectuer dans une période donnée.
• Valider les entrées : Validez minutieusement toutes les données d'entrée pour prévenir les attaques par injection.
• Surveiller et enregistrer : Surveillez votre API pour toute activité suspecte et enregistrez les événements d'authentification à des fins d'audit.
• Mettre à jour régulièrement les bibliothèques : Maintenez vos bibliothèques Django, DRF et d'authentification à jour pour bénéficier des correctifs de sécurité et des améliorations.
• Implémenter CORS (Cross-Origin Resource Sharing) : Configurez correctement CORS pour n'autoriser que les domaines de confiance à accéder à votre API depuis les navigateurs Web.

Conclusion

Sélectionner la méthode d'authentification appropriée est crucial pour sécuriser vos API DRF. L'authentification par Token offre la simplicité, tandis que l'authentification JWT apporte évolutivité et flexibilité. Comprendre les avantages et les inconvénients de chaque méthode, ainsi que les bonnes pratiques en matière de sécurité des API, vous permettra de construire des API robustes et sécurisées qui protègent vos données et vos utilisateurs.

N'oubliez pas de tenir compte de vos besoins spécifiques et de choisir la solution qui offre le meilleur équilibre entre sécurité, performance et facilité d'implémentation. Explorez OAuth2 et OpenID Connect pour des scénarios d'autorisation plus complexes.