Architecture du module d'authentification Django

Le framework Django intègre nativement un système robuste via le module django.contrib.auth. Ce composant gère l'authentification, les autorisations et les sessions en s'appuyant par défaut sur la table auth_user. Il permet de créer des superutilisateurs disposant de tous les droits d'daministration et facilite la gestion des identités.

Pour interagir avec ce système, les imports suivants sont nécessaires :

from django.contrib import auth
from django.contrib.auth.models import User

Gestion du cycle de vie des utilisateurs

Création de comptes

L'inscription des utilisateurs doit se faire via les méthodes dédiées du gestionnaire d'objets pour garantir que les mots de passe soient correctement hachés avant l'insertion en base de données.

# Création standard avec hachage du mot de passe (Recommandé)
User.objects.create_user(username='johndoe', password='secure_password_123')

# Création d'un superutilisateur (nécessite un email valide)
User.objects.create_superuser(username='admin', email='admin@example.com', password='admin_pass')

Note : L'utilisation de User.objects.create() est déconseillée car elle stocke le mot de passe en clair.

Authentification et établissement de session

La validation des identifiants et la création de la session se font en deux étapes distinctes. La fonction authenticate vérifie les crédits, tandis que login attache l'utilisateur à la session courante.

from django.shortcuts import render, redirect
from django.http import HttpResponseBadRequest

def process_user_login(request):
    if request.method == 'POST':
        login_identifier = request.POST.get('login_id')
        raw_password = request.POST.get('raw_password')

        # Vérification des identifiants
        authenticated_user = auth.authenticate(
            request, 
            username=login_identifier, 
            password=raw_password
        )

        if authenticated_user is not None:
            # Attachement de l'utilisateur à la session (crée le cookie de session)
            auth.login(request, authenticated_user)
            return redirect('dashboard')
        
        return HttpResponseBadRequest("Identifiants invalides.")

    return render(request, 'authentication/login_form.html')

Vérification de l'état de connexion

Une fois la session établie, l'intergiciel d'authentification injecte l'objet utliisateur dans la requête. Dans les versions modernes de Django, is_authenticated est une propriété et non une méthode.

# Vérification de l'état
if request.user.is_authenticated:
    current_user = request.user
    # Traitement des données de l'utilisateur connecté

Déconnexion

La déconnexion invalide la session courante et nettoie les données de session associées.

from django.contrib.auth.decorators import login_required

@login_required
def process_user_logout(request):
    auth.logout(request)
    return redirect('home_page')

Contrôle d'accès et sécurité

Restriction d'accès par décorateur

Le décorateur @login_required intercepte les requêtes non authentifiées et les redirige vers la page de connexion. La redirection peut être configurée localement ou globalement.

from django.contrib.auth.decorators import login_required

# Configuration locale (prioritaire)
@login_required(login_url='/accounts/login/')
def view_restricted_content(request):
    return render(request, 'secure/dashboard.html')

# Configuration globale (dans settings.py)
# LOGIN_URL = '/accounts/login/'
@login_required
def view_another_restricted_page(request):
    return render(request, 'secure/profile.html')

Modification du mot de passe

La mise à jour du mot de passe nécessite d'abord la validation de l'ancien secret, suivie de l'application du nouveau et de la persistance en base.

def update_user_credentials(current_user, legacy_pwd, fresh_pwd):
    if current_user.check_password(legacy_pwd):
        current_user.set_password(fresh_pwd)
        current_user.save()  # Persistance obligatoire pour mettre à jour le hash
        return True
    return False

Personnalisation du modèle utilisateur

Lorsque les champs par défaut de auth_user sont insuffisants, il est possible d'étendre le modèle. L'approche recommandée consiste à hériter de AbstractUser, ce qui conserve toutes les fonctionnalités natives tout en permettant l'ajout de colonnes personnalisées.

Définition du modèle étendu

from django.db import models
from django.contrib.auth.models import AbstractUser

class MemberProfile(AbstractUser):
    mobile_number = models.CharField(max_length=20, blank=True, null=True)
    profile_picture = models.ImageField(upload_to='avatars/', blank=True, null=True)
    is_premium_member = models.BooleanField(default=False)

    class Meta:
        verbose_name = "Membre"
        verbose_name_plural = "Membres"

    def __str__(self):
        return f"{self.username} - {self.mobile_number}"

Configuration de l'application

Pour que Django utilise cette nouvelle table à la place de auth_user, il est impératif de déclarer le modèle personnalisé dans le fichier de configuration principal. Cette modification doit être effectuée avant la première migration de la base de données.

# settings.py
AUTH_USER_MODEL = 'accounts.MemberProfile'

Une fois cette configuration appliquée, le module auth continuera de fonctionner de manière transparente, mais toutes les opérations de base de données et les relations de clés étrangères pointeront vers la table MemberProfile.