Implémentation des cookies et sessions dans Django

Gestion des cookies avec Django

Accès aux cookies

Pour lire un cookie à partir d'une requête :

valeur = request.COOKIES['clé']
valeur_signée = request.get_signed_cookie('clé', default='Erreur', sel='', age_max=None)

Les paramètres inclunet une valeur par défaut, un sel pour le chiffrement et un délai d'expiration contrôlé côté serveur.

Création de cookies

Pour définir un cookie, générez d'abord une réponse HTTP :

reponse = HttpResponse(...)
reponse = render(request, ...)
reponse = redirect()
reponse.set_cookie('clé', 'valeur', ...)
reponse.set_signed_cookie('clé', 'valeur', sel='sel_secret', ...)

Paramètres disponibles pour la méthode set_cookie :

• clé : identifiant du cookie
• valeur : contenu stocké
• age_max : durée de vie en secondes
• expirations : date d'expiration spécifique
• chemin : URL de validité (par défaut '/')
• domaine : domaine de validité pour les cookies inter-sites
• securise : transimssion uniquement via HTTPS si True
• http_seulement : inaccessible via JavaScript si True

Les cookies sont stockés côté client et manipulables avec JavaScript :

<script src="/static/js/jquery.cookie.js"></script>
$.cookie('clé', 'valeur', { chemin: '/' });

Suppression de cookies

reponse.delete_cookie('clé_cookie', chemin="/", domaine="exemple.com")

Avantages et inconvénients

Avantages : Réduction de la charge serveur, amélioration des performances.

Inconvénients : Sécurité limitée, données accessibles et modifiables par l'utilisateur.

Gestion des sessions dans Django

Opérations de base

Les sessions permettent de stocker des données utilisateur côté serveur via un identifiant unique :

request.session['utilisateur_connecte'] = 'admin'
session_data = request.session.get('utilisateur_connecte')
del request.session['utilisateur_connecte']
if 'utilisateur_connecte' in request.session:
    # Vérification d'existence
request.session.set_expiry(valeur)  # Configuration de l'expiration

Méthodes utiles : pop(), keys(), items(), flush() (pour détruire la session).

Exemple d'implémentation

Fichier views.py :

from django.shortcuts import render, redirect
from django.contrib.auth.models import User

def connexion(request):
    if request.method == "POST":
        nom_utilisateur = request.POST['identifiant']
        mot_de_passe = request.POST['mdp']
        utilisateur = User.objects.filter(username=nom_utilisateur, password=mot_de_passe)
        if utilisateur:
            request.session['est_connecte'] = True
            request.session['nom_utilisateur'] = nom_utilisateur
            return redirect('/tableau/')
    return render(request, 'connexion.html')

def tableau(request):
    est_connecte = request.session.get('est_connecte', False)
    if est_connecte:
        nom = request.session['nom_utilisateur']
        return render(request, 'tableau.html', {'nom': nom})
    return redirect('/connexion/')

def deconnexion(request):
    try:
        del request.session['est_connecte']
    except KeyError:
        pass
    return redirect('/connexion/')

Template connexion.html :

<form method="post">
    {% csrf_token %}
    <input type="text" name="identifiant">
    <input type="password" name="mdp">
    <button type="submit">Connexion</button>
</form>

Template tableau.html :

<h1>Bienvenue, {{ nom }}</h1>
<a href="/deconnexion/">Déconnexion</a>

Configuration du stockage des sessions

Django supporte plusieurs moteurs de stockage :

• Base de données (par défaut) : SESSION_ENGINE = 'django.contrib.sessions.backends.db'
• Cache : SESSION_ENGINE = 'django.contrib.sessions.backends.cache'
• Fichier : SESSION_ENGINE = 'django.contrib.sessions.backends.file'

Paramètres globaux tels que SESSION_COOKIE_AGE, SESSION_EXPIRE_AT_BROWSER_CLOSE contrôlent le comportement des cookies de session.

Module d'authentification et objets utilisateur

Utilisation du module auth

Le module django.contrib.auth fournit des fonctions essentielles :

from django.contrib import auth
from django.contrib.auth import authenticate, login, logout

Fonction authenticate()

Vérifie les identifiants et retourne un objet User si valide :

utilisateur = authenticate(username='jean', password='secret123')

Fonction login()

Attache une session à un utilisateur authentifié :

def ma_vue(request):
    if request.method == 'POST':
        user = authenticate(username=request.POST['user'], password=request.POST['pwd'])
        if user:
            login(request, user)
            return redirect('/accueil/')
    return render(request, 'login.html')

Fonction logout()

Détruit la session courante :

def deconnexion_vue(request):
    logout(request)
    return redirect('/')

Vérification d'authentification

La méthode is_authenticated() vérifie si un utilisateur est connecté. Utilisation avec le décorateur @login_required :

from django.contrib.auth.decorators import login_required

@login_required
def vue_protegee(request):
    return render(request, 'protege.html')

Objets User

Propriétés importantes : username, password, is_staff, is_active.

Création d'utilisateurs

from django.contrib.auth.models import User
nouvel_user = User.objects.create_user(username='marie', password='456abc', email='marie@exemple.com')

Gestion des mots de passe

if utilisateur.check_password('ancien_mdp'):
    utilisateur.set_password('nouveau_mdp')
    utilisateur.save()

Exemple complet d'inscription

def inscription(request):
    if request.method == 'POST':
        mdp = request.POST['mot_de_passe']
        if User.objects.filter(username=request.POST['nom']):
            return render(request, 'inscription.html', {'erreur': 'Utilisateur existant'})
        User.objects.create_user(username=request.POST['nom'], password=mdp)
        return redirect('/connexion/')
    return render(request, 'inscription.html')