Insiemi di anonimato ed entropia
Perché è importante I titoli dicono cose come "il tuo browser è unico" o "questa caratteristica vale 10 bit". Questa lezione ti mostra come si misurano numeri del genere, e le due trappole che rendono molti di loro più grandi del vero. Così potrai giudicare le affermazioni sulla privacy, comprese le tue.
Nascondersi in una folla
Immagina una stazione piena di pendolari con cappotti neri identici. Se anche tu indossi un cappotto nero, ti nascondi tra centinaia di persone. Se ne indossi uno giallo acceso, la folla in cui ti nascondi sei solo tu.
Insieme di anonimato: il gruppo di persone che per un osservatore sembrano esattamente come te. Più è grande, meglio ti nascondi. Un insieme di dimensione 1 significa che sei unico.
Nella lezione 50 hai misurato quanto si notava una persona, Sam, in una folla. Qui misuri tutta la folla di 5.000 browser sintetici (inventati da synthetic_browsers, nessuna persona vera), per vedere quanto si nascondono bene tutti.
Raggruppa, poi conta
Scegli alcune caratteristiche, per esempio ["timezone", "language"]. L'impronta di ogni browser è la tupla di quei valori, per esempio ("Europe/London", "en-GB"). Una tupla funziona come chiave di un dict, quindi collections.Counter può contare quanti browser condividono ciascuna:
from collections import Counter
Counter([("A", "x"), ("A", "x"), ("B", "x")])
# Counter({('A', 'x'): 2, ('B', 'x'): 1})Ogni conteggio è un insieme di anonimato. Un conteggio di 1 è un browser unico. Con tutte e 13 le caratteristiche, la maggior parte dei 5.000 browser risulta unica.
Entropia: un numero per tutta la folla
Nella lezione 48 hai usato l'entropia di Shannon per misurare quanto sono mescolati i caratteri di un testo. La stessa formula funziona su una folla: per ogni insieme di anonimato, prendi la sua quota p sul totale, e somma -p * log2(p).
Entropia (di un'impronta): il numero medio di bit che un tracker scopre su un visitatore a caso da queste caratteristiche. 0 bit: tutti sembrano uguali. log2(N) bit: in una folla di N tutti sono unici.
Esempio: quattro browser con fusi orari A, A, B, C. Le quote sono 1/2, 1/4 e 1/4, quindi l'entropia è 0,5 × 1 + 0,25 × 2 + 0,25 × 2 = 1,5 bit.
Trappola 1: il tetto
Una folla di 5.000 non può mai mostrare più di log2(5000), circa 12,3 bit, perché a quel punto tutti sono già unici. Quindi uno studio su 5.000 browser che trova "12 bit" potrebbe star toccando il tetto, non misurando la caratteristica. E unico tra 5.000 non è unico tra miliardi. Campioni più grandi danno numeri più grandi e più onesti.
Trappola 2: sommare le caratteristiche
Fuso orario e lingua viaggiano insieme: la maggior parte dei browser con Asia/Tokyo dice ja-JP. Lo stesso vale per scheda grafica e sistema. Quindi sommare l'entropia di ogni caratteristica presa da sola conta la stessa informazione diverse volte. Il tuo sum_of_parts verrà molto sopra joint, l'entropia di tutte le caratteristiche misurate insieme, e molto sopra il tetto di 12,3 bit. Il numero congiunto è quello onesto.
Un equivoco comune
"Un'entropia alta significa che tutti sono tracciabili." L'entropia è una media. Una folla può avere un'entropia alta mentre un grande gruppo di persone con configurazioni molto comuni si nasconde comunque bene. Guarda sia la media sia quante persone stanno in insiemi piccoli.
Provalo Quando superi l'esercizio, stampa entropy_bits(crowd, [t]) per ogni caratteristica (la soluzione lo fa). Quali tre caratteristiche portano più bit? Poi confronta i valori del tuo browser per quelle caratteristiche con un sito di test delle impronte come Cover Your Tracks dell'EFF.
In altri linguaggi
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
}Riepilogo
- Un insieme di anonimato è chiunque sembri esattamente come te; dimensione 1 significa unico.
- L'entropia è la media dei bit scoperti su un visitatore: raggruppa, conta, poi somma -p log2(p).
- Nessun campione di N può mostrare più di log2(N) bit; i campioni piccoli sottostimano la folla.
- Misura le caratteristiche insieme: sommarle una per una conta due volte quelle collegate.
Scrivi fingerprint(row, traits) (una tupla dei valori), anonymity_sets(rows, traits) (un dict dall'impronta al conteggio), fraction_unique(rows, traits) (la quota di righe in un insieme di dimensione 1), entropy_bits(rows, traits) (entropia di Shannon sugli insiemi di anonimato) e max_bits(n) (log2(n)). Poi imposta joint all'entropia di crowd su tutte le TRAIT_NAMES, e sum_of_parts alla somma dell'entropia di ogni singola caratteristica.
Hai notato un problema in questa lezione? Segnalalo · Chiedi qualcosa su questa lezione
Questo esercizio si apre presto
Finisci la lezione precedente e questa si sblocca. L'intero corso è gratuito, senza account, e puoi leggere questa lezione subito.
Questo browser blocca i cookie per learn.floati.life, quindi le lezioni che hai finito qui non si possono aprire in ordine. Consenti i cookie per questo sito e ricarica.