Programma Lezione 143 di 156 · Reti di anonimato e analisi del traffico
Reti di anonimato e analisi del traffico

Fingerprinting dei siti web

Perché è importante Anche quando un osservatore non vede quale sito visiti, la forma del caricamento di una pagina può tradirti: quanto invii, quanto torna indietro. Questo laboratorio mostra come si fa quell'ipotesi, come il padding la contrasta, e perché i risultati di laboratorio fanno sembrare l'attacco più forte di quanto sia nella vita reale.

Pensa a dei pacchi avvolti in semplice carta marrone. Non puoi leggere l'etichetta, ma un pacco lungo e sottile probabilmente è un poster e uno pesante e quadrato probabilmente sono libri. Il caricamento delle pagine è uguale: un sito di video scarica tantissimi dati, un forum di solo testo pochissimi. L'involucro nasconde il contenuto, non le dimensioni e la forma.

Website fingerprinting: indovinare quale sito web ha caricato qualcuno solo dallo schema del suo traffico cifrato, confrontandolo con schemi registrati in precedenza.

Cella: un'unità di traffico di dimensione fissa. In questo laboratorio il caricamento di una pagina è una lista di celle: 1 per una cella che hai inviato, -1 per una cella che hai ricevuto.

Un classificatore semplice: il centroide più vicino

Per prima cosa riduci ogni caricamento a due numeri, le sue feature: celle in uscita e celle in entrata. Lo fanno cells.count(1) e cells.count(-1). Poi, per ogni sito, fai la media delle feature dei suoi caricamenti di addestramento. Quel punto medio è il centroide del sito, la sua forma tipica. Per classificare un nuovo caricamento, trova il centroide più vicino.

Centroide: la media di un gruppo di punti: x medio, y medio. Qui, uno per sito.

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 difesa: il padding

Il padding aggiunge celle fittizie così che i caricamenti somiglino meno al loro sito. Il progetto di ricerca chiamato FRONT aggiunge un numero casuale di celle fittizie, soprattutto vicino all'inizio di un caricamento, dove una pagina rivela di più. pad_traces(traces, budget, seed) aggiunge a ogni caricamento fino a budget celle fittizie in ciascuna direzione.

Per misurarlo in modo onesto, supponi che l'osservatore sappia che usi il padding e si addestri anche lui su caricamenti con padding. Il padding abbassa l'accuratezza invece di sconfiggere l'attacco, e le celle fittizie costano banda. Misurerai entrambe le cose: il calo di accuratezza e l'overhead, le celle in più come frazione dell'originale:

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

Tor ha un sistema per aggiungere padding ai circuiti, ma un padding pesante contro il website fingerprinting non è attivo nella navigazione normale (verificato a ottobre 2026), soprattutto per questo costo in banda.

Perché il laboratorio esagera l'attacco

Qui l'osservatore sa che visiti uno di otto siti. È un mondo chiuso. Le persone reali visitano milioni di siti: un mondo aperto. Lì contano le frequenze di base. Supponi che un classificatore segnali correttamente un sito delicato il 95% delle volte e segnali per errore il 5% degli altri caricamenti. Se solo 1 caricamento su 1.000 è davvero verso quel sito, allora su 100.000 caricamenti vengono segnalate circa 95 visite vere, insieme a circa 4.995 falsi allarmi. Oltre il 98% degli allarmi è sbagliato.

Un equivoco comune: "Il website fingerprinting significa che Tor è rotto." Significa che un osservatore specifico, quello tra te e la tua guardia, può fare ipotesi ragionate che funzionano molto meglio in laboratorio che nel disordinato mondo aperto. È un rischio reale da cui vale la pena difendersi, non un motivo per arrendersi.

Tutti i caricamenti qui sono simulati. Nessun traffico reale viene registrato o analizzato.

In altri linguaggi

Il passo del centroide più vicino, altrove:

// 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()
}

Riepilogo

  • Anche i caricamenti cifrati delle pagine hanno una forma; confrontare le forme permette di indovinare il sito.
  • Centroide più vicino: fai la media delle feature di ogni sito, poi scegli la media più vicina.
  • Il padding abbassa l'accuratezza invece di sconfiggere l'attacco, e costa banda: misura entrambe le cose.
  • I numeri di laboratorio in un mondo chiuso esagerano gli attacchi reali, perché le frequenze di base producono molti falsi allarmi.
Tocca a te

Scrivi quattro funzioni:

  1. features(cells): la tupla (outgoing, incoming), i conteggi di 1 e -1.
  2. train(traces): un dict che associa ogni trace["site"] al conteggio medio in uscita e al conteggio medio in entrata delle sue tracce.
  3. classify(model, cells): il sito il cui centroide è il più vicino secondo math.dist; usa min(sorted(model), key=...) così in caso di parità vince il primo sito in ordine alfabetico.
  4. accuracy(model, traces): la frazione classificata come il proprio sito.
Poi imposta acc_plain (addestra su data["train"], verifica su data["test"]), acc_padded (addestra un nuovo modello su padded_train, verifica su padded_test) e overhead (le celle totali in padded_test divise per le celle totali in data["test"], meno 1). I test usano anche altri caricamenti.

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.