Comment implémenter la gestion des cookies et sessions avec Claude Code

L’importance de la gestion des cookies

Les cookies sont la base de l’authentification utilisateur et de la gestion de sessions, mais une mauvaise configuration de sécurité peut entraîner de graves vulnérabilités. Avec Claude Code, vous pouvez implémenter correctement un système de gestion de cookies sécurisé.

Utilitaire d’opérations Cookie sécurisées

> Crée un utilitaire d'opérations Cookie avec les paramètres de sécurité.
> Rends obligatoires les paramètres HttpOnly, Secure et SameSite.

interface CookieOptions {
  maxAge?: number;
  path?: string;
  domain?: string;
  secure?: boolean;
  httpOnly?: boolean;
  sameSite?: 'strict' | 'lax' | 'none';
}

const DEFAULT_OPTIONS: CookieOptions = {
  path: '/',
  secure: true,
  httpOnly: true,
  sameSite: 'lax',
  maxAge: 86400, // 1 jour
};

class CookieManager {
  static set(name: string, value: string, options: CookieOptions = {}) {
    const opts = { ...DEFAULT_OPTIONS, ...options };
    const parts = [`${encodeURIComponent(name)}=${encodeURIComponent(value)}`];

    if (opts.maxAge) parts.push(`Max-Age=${opts.maxAge}`);
    if (opts.path) parts.push(`Path=${opts.path}`);
    if (opts.domain) parts.push(`Domain=${opts.domain}`);
    if (opts.secure) parts.push('Secure');
    if (opts.httpOnly) parts.push('HttpOnly');
    if (opts.sameSite) parts.push(`SameSite=${opts.sameSite}`);

    return parts.join('; ');
  }

  static parse(cookieHeader: string): Record<string, string> {
    return cookieHeader.split(';').reduce((acc, pair) => {
      const [key, ...vals] = pair.trim().split('=');
      if (key) acc[decodeURIComponent(key)] = decodeURIComponent(vals.join('='));
      return acc;
    }, {} as Record<string, string>);
  }

  static delete(name: string, path = '/') {
    return this.set(name, '', { maxAge: 0, path });
  }
}

Gestion de sessions avec Express

> Implémente une gestion de sessions sécurisée avec Express.
> Utilise Redis comme store de sessions et ajoute la protection CSRF.

import session from 'express-session';
import RedisStore from 'connect-redis';
import { createClient } from 'redis';
import csrf from 'csurf';

const redisClient = createClient({ url: process.env.REDIS_URL });
redisClient.connect();

const sessionConfig: session.SessionOptions = {
  store: new RedisStore({ client: redisClient }),
  secret: process.env.SESSION_SECRET!,
  name: '__session',
  resave: false,
  saveUninitialized: false,
  cookie: {
    secure: process.env.NODE_ENV === 'production',
    httpOnly: true,
    sameSite: 'lax',
    maxAge: 24 * 60 * 60 * 1000, // 24 heures
  },
};

app.use(session(sessionConfig));
app.use(csrf({ cookie: false })); // CSRF basé sur la session

Opérations Cookie sécurisées côté client

La gestion des cookies manipulés côté navigateur (non HttpOnly) peut aussi être générée avec Claude Code.

// Utilitaire Cookie côté client (pour les informations non sensibles comme le thème ou la langue)
export const clientCookie = {
  get(name: string): string | null {
    const match = document.cookie.match(new RegExp(`(?:^|; )${name}=([^;]*)`));
    return match ? decodeURIComponent(match[1]) : null;
  },

  set(name: string, value: string, days = 365) {
    const expires = new Date(Date.now() + days * 864e5).toUTCString();
    document.cookie = `${encodeURIComponent(name)}=${encodeURIComponent(value)};expires=${expires};path=/;SameSite=Lax`;
  },

  remove(name: string) {
    document.cookie = `${name}=;expires=Thu, 01 Jan 1970 00:00:00 GMT;path=/`;
  },
};

// Exemple d'utilisation : sauvegarde du paramètre de thème
clientCookie.set('theme', 'dark');
const theme = clientCookie.get('theme'); // 'dark'

Renforcement de la sécurité des sessions

// Prévention des attaques par fixation de session
app.post('/login', async (req, res) => {
  const user = await authenticate(req.body);

  // Régénération de l'ID de session lors d'une connexion réussie
  req.session.regenerate((err) => {
    if (err) return res.status(500).json({ error: 'Erreur de session' });
    req.session.userId = user.id;
    res.json({ success: true });
  });
});

Résumé

Avec Claude Code, vous pouvez implémenter de manière cohérente la configuration sécurisée des cookies, la gestion de sessions et la protection CSRF. Pour l’authentification en général, consultez le guide d’implémentation de l’authentification, et pour la comparaison avec l’authentification JWT, consultez l’article sur l’authentification JWT. Pour les détails de sécurité, consultez aussi l’audit de sécurité.

Pour les bonnes pratiques de gestion de sessions, consultez OWASP Session Management.