L'analyse de trafic
Pourquoi c'est important Le chiffrement cache ce que tu dis, mais pas quand tu le dis ni combien. Rien qu'en surveillant le timing du trafic, on peut révéler qui parle à qui, même à travers un réseau d'anonymat. Le voir marcher sur des flux simulés montre clairement ce que Tor peut et ne peut pas promettre, et pourquoi la défense la plus forte coûte si cher.
Imagine que tu ne peux ouvrir le courrier de personne, mais que tu peux te tenir à deux bureaux de poste. Chaque fois qu'une rafale de lettres quitte la maison d'Ana, une rafale semblable arrive dans une clinique un instant plus tard. Tu n'as jamais lu un mot, et pourtant tu peux deviner qu'Ana écrit à la clinique.
Métadonnées : des données sur un message plutôt que son contenu : quand il a été envoyé, sa taille, d'où il venait et où il allait.
Analyse de trafic : apprendre des choses à partir du schéma des communications (timing, tailles, volumes) sans lire le contenu.
Le contexte
Un observateur surveille deux endroits : le lien entre les utilisateurs et leur garde, et le lien entre les sorties et les sites web. La fonction tor_flows(seed) de watched.leg7b_onion te donne des enregistrements simulés des deux. Chaque paquet est une cellule, l'unité de trafic de taille fixe de Tor (514 octets), donc la taille ne te dit rien. Le timing est tout ce que tu as. Les noms des flux des deux côtés sont mélangés, et le côté sortie est un peu retardé.
from watched.leg7b_onion import tor_flows
flows = tor_flows(seed=1)
print(flows["entry"][0]["flow"]) # e01
print(flows["entry"][0]["packets"][:3]) # [(time_in_seconds, size), ...]
print(flows["exit"][0]["flow"]) # x01, but which user is it?
# flows["answers"] holds the truth, so you can score your guesses.Étape 1 : transformer les paquets en forme
Compte combien de paquets tombent dans chaque seconde : la seconde 0 contient les temps de 0 jusqu'à 1 (non compris), et ainsi de suite. int(t) donne la seconde à laquelle appartient un temps. Un flux devient une liste comme [0, 7, 9, 1, 0, 0, 6, ...] : sa forme dans le temps.
Étape 2 : comparer deux formes
Corrélation : un nombre de -1 à 1 qui dit à quel point deux listes montent et descendent ensemble. 1 veut dire parfaitement en phase, 0 veut dire aucun lien. Python l'a intégrée : statistics.correlation(a, b).
Si une liste ne change jamais (toutes les valeurs égales), la corrélation n'est pas définie et Python lève statistics.StatisticsError. Attrape-la et utilise 0.0, qui veut dire « aucun indice dans un sens ou dans l'autre ».
import statistics
print(statistics.correlation([1, 5, 2, 8], [2, 9, 3, 15])) # close to 1: in step
try:
statistics.correlation([3, 3, 3], [1, 2, 3])
except statistics.StatisticsError:
print("a flat list has no correlation")Étape 3 : associer chaque flux d'entrée au flux de sortie le plus semblable
Pour chaque flux d'entrée, essaie chaque flux de sortie et garde celui qui a la plus forte corrélation. Dans cette simulation, ça suffit à associer correctement presque tout le monde. Les vraies attaques de ce genre, étudiées par des chercheurs, marchent dans le même esprit.
Les défenses, et leur prix
- Trafic de couverture aléatoire : ajouter de fausses cellules à des moments aléatoires. Ça brouille un peu la forme, mais les rafales ressortent quand même. Tu verras que ça aide à peine.
- Débit constant : envoyer exactement le même nombre de cellules chaque seconde, en comblant les trous avec des leurres et en faisant attendre leur tour aux vraies cellules. Chaque seconde se ressemble, donc la forme disparaît. Le prix, c'est la bande passante (tous ces leurres) et le délai (les cellules font la queue pendant les rafales).
Tor ajoute un peu de bourrage pour brouiller les relevés de connexion grossiers, mais il ne cache pas la forme de ton trafic à quelqu'un qui peut surveiller les deux bouts (vérifié en octobre 2026). Il choisit un faible délai pour que le web reste utilisable. La dernière leçon de ce module regarde les réseaux qui font l'autre choix.
Une idée reçue : « Si tout est chiffré, personne ne peut savoir à qui je parle. » Le chiffrement cache le contenu. Le timing et le volume restent visibles, et ils suffisent souvent.
Ce labo n'utilise que des flux simulés. Il sert à comprendre le risque pour que tu puisses juger les défenses ; ce n'est pas une méthode pour surveiller de vraies personnes, et les vrais réseaux sont bien plus bruités.
Dans d'autres langages
Compter les paquets par seconde et calculer une corrélation, ailleurs :
// JavaScript
function countsPerSecond(packets, seconds) {
const counts = new Array(seconds).fill(0);
for (const [t] of packets) if (t >= 0 && t < seconds) counts[Math.floor(t)]++;
return counts;
}
function correlation(a, b) {
const n = a.length, ma = a.reduce((x, y) => x + y) / n, mb = b.reduce((x, y) => x + y) / n;
let num = 0, da = 0, db = 0;
for (let i = 0; i < n; i++) { num += (a[i]-ma)*(b[i]-mb); da += (a[i]-ma)**2; db += (b[i]-mb)**2; }
return da && db ? num / Math.sqrt(da * db) : 0;
}// Go
func countsPerSecond(times []float64, seconds int) []int {
counts := make([]int, seconds)
for _, t := range times {
if t >= 0 && t < float64(seconds) { counts[int(t)]++ }
}
return counts
}Récap
- Le chiffrement cache le contenu, pas le timing ni le volume (les métadonnées).
- Compter les paquets par seconde donne une forme à chaque flux ; la corrélation trouve les formes qui correspondent aux deux bouts.
- Le trafic de couverture aléatoire aide à peine ; l'envoi à débit constant cache la forme mais coûte de la bande passante et du délai.
- Tor privilégie un faible délai, donc il ne peut pas arrêter quelqu'un qui surveille les deux bouts.
Écris quatre fonctions, puis utilise-les sur tor_flows(seed=1) :
counts_per_second(packets, seconds): une liste desecondsnombres, le compte des paquets dont le tempstvérifie0 <= t < seconds, placé à l'indiceint(t).similarity(a, b):statistics.correlation(a, b), ou0.0si ça lèvestatistics.StatisticsError.match(entry, exits, seconds): un dict qui associe l'identifiant"flow"de chaque flux d'entrée à l'identifiant du flux de sortie qui a la plus forte similarité.accuracy(guesses, answers): la part des identifiants deanswersque tes suppositions ont trouvés.
acc_plain (sans défense), acc_cover (côté entrée après add_cover_traffic(flows["entry"], rate=20, seed=1, seconds=S)) et acc_constant (côté entrée après constant_rate(flows["entry"], per_second=10, seconds=S)). Les tests utilisent aussi de nouveaux enregistrements.
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.
Ce navigateur bloque les cookies pour learn.floati.life, donc les leçons que tu as terminées ici ne peuvent pas s'ouvrir dans l'ordre. Autorise les cookies pour ce site et recharge la page.