Programme Leçon 120 sur 156 · Construire les défenses
Construire les défenses

Cloisonner le moteur

Pourquoi c'est important À l'étape 2, le traqueur d'AdCo marchait parce que la frame intégrée d'AdCo avait un seul tiroir de stockage qu'elle ouvrait dans chaque boutique. Les navigateurs l'en empêchent en séparant le stockage par site, ce qu'on appelle le cloisonnement. Si un moteur sépare les cookies mais oublie ne serait-ce qu'un autre espace de stockage, le traqueur y déplace simplement son identifiant. Dans ce labo, tu es l'auteur du moteur : tu écris la règle qui décide où les données sont gardées, puis tu regardes le traqueur échouer.

Imagine une chaîne de salles de sport. Une chaîne négligente donne à chaque membre une clé de casier qui ouvre le même casier dans chaque salle, donc tout ce qu'on y laisse te suit dans toute la ville. Une chaîne soigneuse te donne un casier séparé dans chaque salle. Et dans chaque salle, chaque membre a son propre casier, donc personne ne peut ouvrir celui d'un autre.

Un moteur de navigateur est la chaîne soigneuse. La salle, c'est le site de la barre d'adresse. Le membre, c'est celui qui stocke les données, comme la boutique elle-même ou une frame publicitaire qui y est intégrée.

Site de premier niveau : le site affiché dans la barre d'adresse, par exemple shopa.example. Tout ce qui est sur la page, frames et scripts compris, est chargé pour son compte.

Origine : celui qui stocke les données : schéma, hôte et port, par exemple https://adco.example. Une frame intégrée a sa propre origine, différente de la page autour.

Espace de stockage : un endroit où un navigateur garde des données pour un site. Les cookies en sont un ; localStorage, IndexedDB (une petite base de données dans le navigateur), le cache HTTP (des copies enregistrées de fichiers) et les service workers (des scripts qui tournent en arrière-plan pour un site) en sont d'autres.

Clé de partition : l'étiquette qu'un moteur met sur chaque tiroir. Deux lectures ou écritures avec la même clé partagent un tiroir ; des clés différentes, jamais.

Le moteur d'entraînement

Le module watched.leg6b_engine a un tout petit moteur appelé MiniEngine avec cinq espaces de stockage. Tu lui donnes une fonction, la règle de clé de partition, et il appelle cette fonction chaque fois que quelque chose est lu ou écrit :

from watched.leg6b_engine import MiniEngine, STORAGE_AREAS

def naive_key(area, origin, top_site):
    return origin                     # one drawer per origin, on every site

engine = MiniEngine(naive_key)
engine.write("cache", "https://adco.example", "shopa.example", "adco_id", "id-77")
print(engine.read("cache", "https://adco.example", "shopb.example", "adco_id"))   # id-77
print(STORAGE_AREAS)   # ('cookies', 'local_storage', 'indexeddb', 'cache', 'service_worker')

Avec la règle naïve, AdCo écrit son identifiant pendant que tu es sur ShopA et relit le même identifiant sur ShopB. Cette seule ligne, c'est du pistage intersite.

Une clé en deux parties

La correction consiste à faire inclure à la clé à la fois le site de premier niveau et l'origine. Python a une façon élégante de coller des valeurs ensemble : un tuple, écrit avec des parenthèses.

Tuple : un groupe fixe de valeurs, comme ("shopa.example", "https://adco.example"). Il marche comme une liste que tu ne peux pas modifier et, contrairement à une liste, il peut servir de clé de dictionnaire.

key_a = ("shopa.example", "https://adco.example")
key_b = ("shopb.example", "https://adco.example")
print(key_a == key_b)    # False: different site, so a different drawer

Les moteurs appellent ça la double clé : chaque donnée stockée est rangée sous (site de premier niveau, origine). Les vrais moteurs ajoutent d'autres éléments à certaines clés, mais ces deux parties en sont le cœur.

Quels espaces un moteur naïf oublie-t-il ?

Les moteurs n'ont pas tout cloisonné d'un coup. Les cookies ont reçu le plus d'attention, tandis que les caches et les stockages plus récents sont venus plus tard. Le cache HTTP est maintenant cloisonné dans les trois grands moteurs : Safari depuis 2013, Chrome depuis la version 86 et Firefox depuis la version 85 (vérifié en octobre 2026). Tout espace laissé de côté est une cachette, c'est pourquoi ta règle de clé doit couvrir chaque espace, pas seulement les cookies.

Mesurer si le pistage marche encore

run_tracker(engine) visite les trois boutiques. Sur chacune, la boutique enregistre un panier, puis la frame d'AdCo cherche son identifiant dans chaque espace et en écrit un nouveau si le tiroir est vide. Elle renvoie un dict :

  • "sightings" : une liste de tuples (top_site, area, id_seen), un par boutique et par espace
  • "snooped" : les espaces où la frame d'AdCo a pu lire le panier de la boutique elle-même (doit être vide)
  • "first_party_ok" : True quand chaque boutique a pu relire son propre panier

Le pistage marche dans un espace quand le même identifiant apparaît sur deux sites différents ou plus. Pour le compter, tu vas utiliser un set : une collection sans doublons, écrite set() quand elle est vide. s.add(x) y met quelque chose et len(s) dit combien de choses différentes il contient.

seen = {}                                   # (area, id) -> set of sites
for site, area, ident in [("shopa.example", "cache", "id-1"), ("shopb.example", "cache", "id-1")]:
    seen.setdefault((area, ident), set()).add(site)
print(seen)   # {('cache', 'id-1'): {'shopa.example', 'shopb.example'}}

d.setdefault(key, set()) veut dire : donne-moi la valeur sous cette clé, et s'il n'y en a pas encore, stocke d'abord un set vide à cet endroit.

Une erreur courante

Il est tentant d'utiliser comme clé le seul site de premier niveau : return top_site. Ça empêche bien AdCo de relier ShopA à ShopB. Mais maintenant la frame d'AdCo et la boutique partagent un tiroir sur chaque site, donc la frame peut lire le panier de la boutique. Le rapport du moteur appelle ça snooped. Une bonne clé sépare les sites les uns des autres et les membres les uns des autres.

Essaie Le Browser d'entraînement a déjà cette règle intégrée pour les cookies et localStorage. Après ce labo, relance ton traqueur par cookies de l'étape 2 avec Browser(world, partitioned=True) et affiche le profil qu'il construit : tu devrais voir un court profil par boutique au lieu d'un long. Dans un vrai navigateur, ouvre DevTools (F12), va dans Application (Stockage dans Firefox) et ouvre Cookies. Dans les DevTools de Chrome, les cookies stockés par site de premier niveau affichent une valeur dans la colonne Partition Key.

Dans d'autres langages

La même double clé dans d'autres langages :

// JavaScript: a Map keyed by a string that joins both parts
const drawers = new Map();
function partitionKey(area, origin, topSite) {
  return `${area} ${topSite} ${origin}`;
}
drawers.set(partitionKey("cache", "https://adco.example", "shopa.example"), { adco_id: "id-1" });

// Rust: a tuple of Strings is a valid HashMap key
use std::collections::HashMap;
let mut drawers: HashMap<(String, String), HashMap<String, String>> = HashMap::new();
drawers.entry(("shopa.example".into(), "https://adco.example".into()))
       .or_default().insert("adco_id".into(), "id-1".into());

// Go: a struct with comparable fields can key a map
type PartitionKey struct{ TopSite, Origin string }
drawers := map[PartitionKey]map[string]string{}
drawers[PartitionKey{"shopa.example", "https://adco.example"}] = map[string]string{"adco_id": "id-1"}

Récap

  • Le cloisonnement range chaque donnée stockée sous une clé ; même clé, même tiroir.
  • Une bonne clé a deux parties, le site de premier niveau et l'origine, pour que les sites ne puissent pas se voir et qu'une frame ne puisse pas voir la page autour d'elle.
  • Chaque espace de stockage a besoin de la clé, cookies, localStorage, IndexedDB, cache et service workers compris. Un seul espace oublié suffit à un traqueur.
  • Le pistage marche encore partout où le même identifiant apparaît sur deux sites ou plus : mesure-le, ne le suppose pas.
À ton tour

Écris deux fonctions. partition_key(area, origin, top_site) doit renvoyer la clé en deux parties (top_site, origin) pour chaque espace de stockage. linked_areas(sightings) prend une liste de tuples (top_site, area, id_seen) et renvoie un set des espaces où le même id_seen apparaît sur deux sites de premier niveau différents ou plus. Puis construis engine = MiniEngine(partition_key), lance report = run_tracker(engine), et définis linked = linked_areas(report["sightings"]). Ça doit afficher un set vide.

Tu as repéré un problème dans cette leçon ? Signale-le · Pose une question sur cette leçon

Cet exercice s'ouvre bientôt

Termine la leçon précédente pour débloquer celle-ci. Tout le cours est gratuit, aucun compte n'est requis, et tu peux lire cette leçon dès maintenant.