Lehrplan Lektion 143 von 156 · Anonymitätsnetzwerke und Verkehrsanalyse
Anonymitätsnetzwerke und Verkehrsanalyse

Website-Fingerprinting

Warum das wichtig ist Selbst wenn ein Beobachter nicht sehen kann, welche Seite du besuchst, kann die Form eines Seitenladens es verraten: wie viel du sendest, wie viel zurückkommt. Dieses Labor zeigt, wie dieser Schätzwert gemacht wird, wie Padding dagegen kämpft und warum die Laborergebnisse den Angriff stärker aussehen lassen, als er im echten Leben ist.

Denk an Pakete in braunem Papier. Du kannst das Etikett nicht lesen, aber ein langes dünnes Paket ist wahrscheinlich ein Poster und ein schweres quadratisches Paket sind wahrscheinlich Bücher. Seitenladungen sind genauso: eine Videosite lädt viele Daten herunter, ein Textforum sehr wenig. Die Verpackung verbirgt den Inhalt, nicht die Größe und Form.

Website-Fingerprinting: das Raten, welche Website jemand geladen hat, allein anhand des Musters ihres verschlüsselten Datenverkehrs, indem man es mit früher aufgezeichneten Mustern vergleicht.

Cell: eine Einheit von Verkehr mit fester Größe. In diesem Labor ist ein Seitenaufruf eine Liste von Zellen: 1 für eine Zelle, die du gesendet hast, -1 für eine Zelle, die du erhalten hast.

Ein einfacher Klassifikator: nächster Zentroid

Reduziere zuerst jede Last auf zwei Zahlen, ihre features: ausgehende Zellen und eingehende Zellen. cells.count(1) und cells.count(-1) tun das. Dann berechne für jede Stelle den Durchschnitt der features ihrer Trainingslasten. Dieser Durchschnittspunkt ist das centroid der Stelle, ihre typische Form. Um eine neue Last zu klassifizieren, finde das centroid, das ihr am nächsten liegt.

Centroid: der Durchschnitt einer Gruppe von Punkten: Durchschnitt x, Durchschnitt y. Hier, einer pro Standort.

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.

Die Verteidigung: Padding

Padding fügt Dummy-Zellen hinzu, damit die Loads weniger wie ihre Seite aussehen. Das Forschungsdesign namens FRONT fügt eine zufällige Anzahl an Dummies hinzu, meistens am Anfang eines Loads, wo eine Seite am meisten offenbart. pad_traces(traces, budget, seed) fügt bis zu budget Dummy-Zellen in jede Richtung zu jedem Load hinzu.

Um es fair zu messen, gehe davon aus, dass der Beobachter weiß, dass du Padding verwendest und auch auf gepaddeten Lasten trainierst. Padding senkt die accuracy, anstatt den Angriff zu vereiteln, und die Dummies kosten Bandbreite. Du wirst beides messen: den Abfall der accuracy und den overhead, die extra Zellen als Bruchteil des Originals:

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

Tor hat ein Framework für das Padding von Schaltkreisen, aber starkes Padding gegen Website Fingerprinting ist für normales Surfen nicht aktiviert (geprüft Oktober 2026), hauptsächlich wegen dieser Bandbreitenkosten.

Warum das Labor den Angriff übertreibt

Hier weiß der Beobachter, dass du eine von acht Seiten besuchst. Das ist eine closed world. Echte Menschen besuchen Millionen von Seiten: eine open world. Die Basisraten schlagen dann hart zu. Angenommen, ein classifier markiert eine sensible Seite korrekt zu 95% der Zeit und markiert fälschlicherweise 5% anderer loads. Wenn nur 1 load von 1.000 wirklich zu dieser Seite gehört, dann werden von 100.000 loads etwa 95 echte Besuche markiert, zusammen mit etwa 4.995 Fehlalarmen. Über 98% der Alarme sind falsch.

Ein häufiges Missverständnis: "Website fingerprinting bedeutet, dass Tor kaputt ist." Es bedeutet, dass ein spezifischer Beobachter, derjenige zwischen dir und deinem Guard, fundierte Vermutungen anstellen kann, die in einem Labor viel besser funktionieren als in der chaotischen offenen Welt. Das ist ein echtes Risiko, gegen das man sich wehren sollte, kein Grund aufzugeben.

Alle Ladevorgänge hier sind simuliert. Es wird kein echter Datenverkehr aufgezeichnet oder analysiert.

In anderen Sprachen

Der nächstgelegene Zentroid Schritt, ansonsten:

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

Zusammenfassung

  • Verschlüsselte Seitenladungen haben immer noch eine Form; durch den Vergleich von Formen kann man die Seite erraten.
  • Nächster Schwerpunkt: Merkmale jeder Stelle mitteln, dann den nächsten Durchschnitt wählen.
  • Padding verringert die Genauigkeit anstatt den Angriff zu vereiteln und kostet Bandbreite: Messe beides.
  • Closed-world lab numbers übertreiben echte Angriffe, weil Basisraten viele Fehlalarme erzeugen.
Du bist dran

Schreibe vier Funktionen:

  1. features(cells): das Tupel (outgoing, incoming), die Zählungen von 1 und -1.
  2. train(traces): ein Dictionary, das jedes trace["site"] auf die durchschnittliche ausgehende und durchschnittliche eingehende Anzahl seiner Traces abbildet.
  3. classify(model, cells): die Seite, deren Schwerpunkt am nächsten bei math.dist liegt; verwende min(sorted(model), key=...), damit Gleichstände zur alphabetisch ersten Seite gehen.
  4. accuracy(model, traces): der Anteil, der als ihre eigene Seite klassifiziert wird.
Setze dann acc_plain (traine auf data["train"], teste auf data["test"]), acc_padded (traine ein neues Modell auf padded_train, teste auf padded_test) und overhead (Gesamtanzahl der Zellen in padded_test geteilt durch Gesamtanzahl der Zellen in data["test"], minus 1). Tests nutzen auch andere Lasten.

Ein Problem in dieser Lektion entdeckt? Melde es · Frage zu dieser Lektion

Diese Übung öffnet bald

Beende die vorherige Lektion, damit diese freigeschaltet wird. Der ganze Kurs ist kostenlos, kein Konto erforderlich, und du kannst diese Lektion jetzt direkt lesen.