Programme Leçon 143 sur 156 · Réseaux d'anonymat et analyse de trafic
Réseaux d'anonymat et analyse de trafic

L'empreinte des sites web

Pourquoi c'est important Même quand un observateur ne peut pas voir quel site tu visites, la forme d'un chargement de page peut le trahir : combien tu envoies, combien revient. Ce labo montre comment cette supposition est faite, comment le bourrage la combat, et pourquoi les résultats de labo font paraître l'attaque plus forte qu'elle ne l'est dans la vraie vie.

Pense à des colis dans du papier kraft. Tu ne peux pas lire l'étiquette, mais un colis long et fin est sans doute une affiche, et un lourd et carré, sans doute des livres. Les chargements de page sont pareils : un site vidéo télécharge beaucoup de données, un forum de texte très peu. L'emballage cache le contenu, pas la taille ni la forme.

Empreinte des sites web (website fingerprinting) : deviner quel site quelqu'un a chargé à partir du seul schéma de son trafic chiffré, en le comparant à des schémas enregistrés auparavant.

Cellule : une unité de trafic de taille fixe. Dans ce labo, un chargement de page est une liste de cellules : 1 pour une cellule que tu as envoyée, -1 pour une cellule que tu as reçue.

Un classifieur simple : le centroïde le plus proche

D'abord, réduis chaque chargement à deux nombres, ses caractéristiques : les cellules sortantes et les cellules entrantes. cells.count(1) et cells.count(-1) le font. Puis, pour chaque site, fais la moyenne des caractéristiques de ses chargements d'entraînement. Ce point moyen est le centroïde du site, sa forme typique. Pour classer un nouveau chargement, trouve le centroïde le plus proche.

Centroïde : la moyenne d'un groupe de points : x moyen, y moyen. Ici, un par site.

import math
from watched.leg7b_onion import page_loads

data = page_loads(seed=3)          # {"train": [...], "test": [...]}
load = data["train"][0]
print(load["site"], len(load["cells"]))
print(math.dist((30, 400), (33, 420)))   # straight-line distance between two points
# min(sorted(model), key=lambda s: ...) picks the site with the smallest value,
# and on a tie the one that comes first alphabetically.

La défense : le bourrage

Le bourrage (padding) ajoute des cellules leurres pour que les chargements ressemblent moins à leur site. La conception de recherche appelée FRONT ajoute un nombre aléatoire de leurres, surtout vers le début d'un chargement, là où une page en révèle le plus. pad_traces(traces, budget, seed) ajoute jusqu'à budget cellules leurres dans chaque sens à chaque chargement.

Pour le mesurer honnêtement, suppose que l'observateur sait que tu fais du bourrage et s'entraîne aussi sur des chargements bourrés. Le bourrage baisse la précision plutôt que de vaincre l'attaque, et les leurres coûtent de la bande passante. Tu vas mesurer les deux : la baisse de précision et le surcoût, les cellules en plus en proportion de l'original :

overhead = total_cells_after_padding / total_cells_before - 1   # 0.5 means 50% more traffic

Tor a un cadre pour bourrer les circuits, mais un bourrage lourd contre l'empreinte des sites web n'est pas activé pour la navigation ordinaire (vérifié en octobre 2026), en grande partie à cause de ce coût en bande passante.

Pourquoi le labo exagère l'attaque

Ici, l'observateur sait que tu visites un des huit sites. C'est un monde fermé. Les vraies personnes visitent des millions de sites : un monde ouvert. Les taux de base frappent alors. Suppose qu'un classifieur signale correctement un site sensible 95 % du temps et signale à tort 5 % des autres chargements. Si seulement 1 chargement sur 1 000 va vraiment vers ce site, alors sur 100 000 chargements, environ 95 vraies visites sont signalées, avec environ 4 995 fausses alertes. Plus de 98 % des alertes sont fausses.

Une idée reçue : « L'empreinte des sites web veut dire que Tor est cassé. » Elle veut dire qu'un observateur précis, celui qui est entre toi et ta garde, peut faire des suppositions éclairées qui marchent bien mieux en labo que dans le monde ouvert et désordonné. C'est un vrai risque contre lequel se défendre, pas une raison d'abandonner.

Tous les chargements ici sont simulés. Aucun vrai trafic n'est enregistré ni analysé.

Dans d'autres langages

L'étape du centroïde le plus proche, ailleurs :

// JavaScript
function classify(model, cells) {
  const f = [cells.filter(c => c === 1).length, cells.filter(c => c === -1).length];
  let best = null, bestD = Infinity;
  for (const site of Object.keys(model).sort()) {
    const d = Math.hypot(f[0] - model[site][0], f[1] - model[site][1]);
    if (d < bestD) { best = site; bestD = d; }
  }
  return best;
}
// Rust
fn dist(c: &(f64, f64), out: f64, inc: f64) -> f64 {
    ((c.0 - out).powi(2) + (c.1 - inc).powi(2)).sqrt()
}

fn classify(model: &BTreeMap<String, (f64, f64)>, cells: &[i8]) -> String {
    let out = cells.iter().filter(|&&c| c == 1).count() as f64;
    let inc = cells.iter().filter(|&&c| c == -1).count() as f64;
    model.iter()
        .min_by(|a, b| dist(a.1, out, inc).partial_cmp(&dist(b.1, out, inc)).unwrap())
        .map(|(s, _)| s.clone()).unwrap()
}

Récap

  • Les chargements de page chiffrés ont quand même une forme ; comparer les formes permet de deviner le site.
  • Centroïde le plus proche : fais la moyenne des caractéristiques de chaque site, puis choisis la moyenne la plus proche.
  • Le bourrage baisse la précision plutôt que de vaincre l'attaque, et coûte de la bande passante : mesure les deux.
  • Les chiffres de labo en monde fermé exagèrent les vraies attaques, car les taux de base produisent beaucoup de fausses alertes.
À ton tour

Écris quatre fonctions :

  1. features(cells) : le tuple (outgoing, incoming), les comptes de 1 et de -1.
  2. train(traces) : un dict qui associe chaque trace["site"] au compte sortant moyen et au compte entrant moyen de ses traces.
  3. classify(model, cells) : le site dont le centroïde est le plus proche selon math.dist ; utilise min(sorted(model), key=...) pour qu'en cas d'égalité le premier site par ordre alphabétique gagne.
  4. accuracy(model, traces) : la part classée comme leur propre site.
Puis définis acc_plain (entraîne sur data["train"], teste sur data["test"]), acc_padded (entraîne un nouveau modèle sur padded_train, teste sur padded_test) et overhead (le total des cellules de padded_test divisé par le total des cellules de data["test"], moins 1). Les tests utilisent aussi d'autres chargements.

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.