Ensembles d'anonymat et entropie
Pourquoi c'est important Les gros titres disent des choses comme « ton navigateur est unique » ou « ce trait donne 10 bits ». Cette leçon te montre comment on mesure ces chiffres, et les deux pièges qui en rendent beaucoup plus grands que la réalité. Tu pourras alors juger les affirmations sur la vie privée, y compris les tiennes.
Se cacher dans une foule
Imagine une gare pleine de voyageurs en manteaux noirs identiques. Si tu portes aussi un manteau noir, tu te caches parmi des centaines. Si tu en portes un jaune vif, la foule où tu te caches, c'est toi seul.
Ensemble d'anonymat : le groupe des gens qui te ressemblent exactement aux yeux d'un observateur. Plus il est grand, mieux tu te caches. Un ensemble de taille 1 veut dire que tu es unique.
À la leçon 50, tu as mesuré à quel point une personne, Sam, se distinguait dans une foule. Ici, tu mesures toute la foule de 5 000 navigateurs synthétiques (fabriqués par synthetic_browsers, aucune vraie personne), pour voir à quel point tout le monde se cache bien.
Regrouper, puis compter
Choisis quelques traits, par exemple ["timezone", "language"]. L'empreinte de chaque navigateur est le tuple de ces valeurs, par exemple ("Europe/London", "en-GB"). Un tuple marche comme clé de dict, donc collections.Counter peut compter combien de navigateurs partagent chacun :
from collections import Counter
Counter([("A", "x"), ("A", "x"), ("B", "x")])
# Counter({('A', 'x'): 2, ('B', 'x'): 1})Chaque compte est un ensemble d'anonymat. Un compte de 1 est un navigateur unique. Avec les 13 traits, la plupart des 5 000 navigateurs se révèlent uniques.
L'entropie : un seul nombre pour toute la foule
À la leçon 48, tu as utilisé l'entropie de Shannon pour mesurer à quel point les caractères d'un texte sont mélangés. La même formule marche sur une foule : pour chaque ensemble d'anonymat, prends sa part p de tout le monde, et additionne -p * log2(p).
Entropie (d'une empreinte) : le nombre moyen de bits qu'un traqueur apprend sur un visiteur pris au hasard à partir de ces traits. 0 bit : tout le monde se ressemble. log2(N) bits : tout le monde est unique dans une foule de N.
Exemple : quatre navigateurs avec les fuseaux horaires A, A, B, C. Les parts sont 1/2, 1/4 et 1/4, donc l'entropie vaut 0,5 x 1 + 0,25 x 2 + 0,25 x 2 = 1,5 bit.
Piège 1 : le plafond
Une foule de 5 000 ne peut jamais montrer plus de log2(5000), environ 12,3 bits, car à ce stade tout le monde est déjà unique. Donc une étude sur 5 000 navigateurs qui trouve « 12 bits » touche peut-être le plafond, au lieu de mesurer le trait. Et être unique parmi 5 000, ce n'est pas être unique parmi des milliards. De plus grands échantillons donnent des chiffres plus grands et plus honnêtes.
Piège 2 : additionner les traits
Le fuseau horaire et la langue vont ensemble : la plupart des navigateurs en Asia/Tokyo annoncent ja-JP. La carte graphique et le système aussi. Donc additionner l'entropie de chaque trait pris seul compte plusieurs fois la même information. Ton sum_of_parts sortira bien au-dessus de joint, l'entropie de tous les traits mesurés ensemble, et bien au-dessus du plafond de 12,3 bits. Le chiffre joint est le chiffre honnête.
Une idée reçue
« Une entropie élevée veut dire que tout le monde est pistable. » L'entropie est une moyenne. Une foule peut avoir une entropie élevée alors qu'un grand groupe de gens aux configurations très courantes se cache encore bien. Regarde à la fois la moyenne et combien de gens se trouvent dans de petits ensembles.
Essaie Une fois réussi, affiche entropy_bits(crowd, [t]) pour chaque trait (la solution le fait). Quels sont les trois traits qui portent le plus de bits ? Puis compare les valeurs de ton propre navigateur pour ces traits avec un site de test d'empreinte comme Cover Your Tracks de l'EFF.
Dans d'autres langages
JavaScript :
function entropyBits(rows, traits) {
const counts = new Map();
for (const r of rows) {
const key = JSON.stringify(traits.map(t => r[t]));
counts.set(key, (counts.get(key) || 0) + 1);
}
let bits = 0;
for (const c of counts.values()) {
const p = c / rows.length;
bits -= p * Math.log2(p);
}
return bits;
}Go :
func entropyBits(keys []string) float64 {
counts := map[string]int{}
for _, k := range keys {
counts[k]++
}
bits := 0.0
for _, c := range counts {
p := float64(c) / float64(len(keys))
bits -= p * math.Log2(p)
}
return bits
}Récap
- Un ensemble d'anonymat, c'est tous ceux qui te ressemblent exactement ; une taille de 1 veut dire unique.
- L'entropie est le nombre moyen de bits appris sur un visiteur : regroupe, compte, puis additionne -p log2(p).
- Aucun échantillon de N ne peut montrer plus de log2(N) bits ; les petits échantillons sous-estiment la foule.
- Mesure les traits ensemble : les additionner un par un compte deux fois les traits liés.
Écris fingerprint(row, traits) (un tuple des valeurs), anonymity_sets(rows, traits) (un dict de l'empreinte vers le compte), fraction_unique(rows, traits) (la part des lignes dans un ensemble de taille 1), entropy_bits(rows, traits) (l'entropie de Shannon sur les ensembles d'anonymat) et max_bits(n) (log2(n)). Puis mets dans joint l'entropie de crowd sur tous les TRAIT_NAMES, et dans sum_of_parts la somme de l'entropie de chaque trait pris seul.
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.