Lehrplan Lektion 120 von 156 · Baue die Verteidigungen
Baue die Verteidigungen

Teile die Engine auf

Warum das wichtig ist In Etappe 2 funktionierte AdCos Tracker, weil AdCos eingebetteter Frame eine Speicherschublade hatte, die er in jedem Shop öffnete. Browser stoppen das, indem sie den Speicher pro Site aufteilen, was Partitionierung heißt. Teilt eine Engine die Cookies auf, vergisst aber auch nur einen anderen Speicherbereich, verlegt der Tracker seine ID einfach dorthin. In diesem Labor bist du die Autorin der Engine: Du schreibst die Regel, die entscheidet, wo Daten aufbewahrt werden, und siehst dann zu, wie der Tracker scheitert.

Stell dir eine Fitnessstudio-Kette vor. Eine nachlässige Kette gibt jedem Mitglied einen Spindschlüssel, der in jeder Filiale denselben Spind öffnet, also folgt dir alles, was du darin lässt, durch die Stadt. Eine sorgfältige Kette gibt dir in jeder Filiale einen eigenen Spind. Und in jeder Filiale hat jedes Mitglied seinen eigenen Spind, also kann niemand den eines anderen öffnen.

Eine Browser-Engine ist die sorgfältige Kette. Die Filiale ist die Site in der Adressleiste. Das Mitglied ist, wer die Daten speichert, etwa der Shop selbst oder ein darin eingebetteter Werbe-Frame.

Top-Level-Site: die Site, die in der Adressleiste steht, zum Beispiel shopa.example. Alles auf der Seite, Frames und Skripte eingeschlossen, wird in ihrem Auftrag geladen.

Origin: wer die Daten speichert: Schema, Host und Port, zum Beispiel https://adco.example. Ein eingebetteter Frame hat seinen eigenen Origin, anders als die Seite um ihn herum.

Speicherbereich: ein Ort, an dem ein Browser Daten für eine Site aufbewahrt. Cookies sind ein Bereich; localStorage, IndexedDB (eine kleine Datenbank im Browser), der HTTP-Cache (gespeicherte Kopien von Dateien) und Service Worker (Skripte, die für eine Site im Hintergrund laufen) sind andere.

Partitionsschlüssel: das Etikett, das eine Engine an jede Schublade klebt. Zwei Lese- oder Schreibvorgänge mit demselben Schlüssel teilen sich eine Schublade; verschiedene Schlüssel nie.

Die Übungs-Engine

Das Modul watched.leg6b_engine hat eine winzige Engine namens MiniEngine mit fünf Speicherbereichen. Du gibst ihr eine Funktion, die Regel für den Partitionsschlüssel, und sie fragt diese Funktion jedes Mal, wenn etwas gelesen oder geschrieben wird:

from watched.leg6b_engine import MiniEngine, STORAGE_AREAS

def naive_key(area, origin, top_site):
    return origin                     # one drawer per origin, on every site

engine = MiniEngine(naive_key)
engine.write("cache", "https://adco.example", "shopa.example", "adco_id", "id-77")
print(engine.read("cache", "https://adco.example", "shopb.example", "adco_id"))   # id-77
print(STORAGE_AREAS)   # ('cookies', 'local_storage', 'indexeddb', 'cache', 'service_worker')

Mit der naiven Regel schreibt AdCo seine ID, während du auf ShopA bist, und liest dieselbe ID auf ShopB zurück. Diese eine Zeile ist Cross-Site-Tracking.

Ein Schlüssel aus zwei Teilen

Die Lösung ist, dass der Schlüssel sowohl die Top-Level-Site als auch den Origin enthält. Python hat eine praktische Art, Werte zusammenzukleben: ein Tupel, mit runden Klammern geschrieben.

Tupel: eine feste Gruppe von Werten, wie ("shopa.example", "https://adco.example"). Es funktioniert wie eine Liste, die du nicht ändern kannst, und anders als eine Liste kann es als Dictionary-Schlüssel benutzt werden.

key_a = ("shopa.example", "https://adco.example")
key_b = ("shopb.example", "https://adco.example")
print(key_a == key_b)    # False: different site, so a different drawer

Engines nennen das doppelte Verschlüsselung (double keying): Jedes gespeicherte Datenstück wird unter (Top-Level-Site, Origin) abgelegt. Echte Engines fügen manchen Schlüsseln mehr hinzu, aber diese zwei Teile sind das Herzstück.

Welche Bereiche vergisst eine naive Engine?

Engines haben nicht alles auf einmal partitioniert. Cookies bekamen die meiste Aufmerksamkeit, während Caches und neuere Speicher später kamen. Der HTTP-Cache ist inzwischen in allen drei großen Engines partitioniert: Safari seit 2013, Chrome seit Version 86 und Firefox seit Version 85 (geprüft im Oktober 2026). Jeder ausgelassene Bereich ist ein Versteck, darum muss deine Schlüsselregel jeden Bereich abdecken, nicht nur Cookies.

Messen, ob Tracking noch funktioniert

run_tracker(engine) besucht die drei Shops. In jedem speichert der Shop einen Warenkorb, dann sucht AdCos Frame in jedem Bereich nach seiner ID und schreibt eine neue, wenn die Schublade leer ist. Es gibt ein Dict zurück:

  • "sightings": eine Liste von Tupeln (top_site, area, id_seen), eines pro Shop und Bereich
  • "snooped": Bereiche, in denen AdCos Frame den eigenen Warenkorb des Shops lesen konnte (sollte leer sein)
  • "first_party_ok": True, wenn jeder Shop seinen eigenen Warenkorb zurücklesen konnte

Tracking funktioniert in einem Bereich, wenn dieselbe ID auf zwei oder mehr verschiedenen Sites auftaucht. Um das zu zählen, benutzt du eine Menge: eine Sammlung ohne Wiederholungen, leer als set() geschrieben. s.add(x) legt etwas hinein, und len(s) sagt, wie viele verschiedene Dinge sie enthält.

seen = {}                                   # (area, id) -> set of sites
for site, area, ident in [("shopa.example", "cache", "id-1"), ("shopb.example", "cache", "id-1")]:
    seen.setdefault((area, ident), set()).add(site)
print(seen)   # {('cache', 'id-1'): {'shopa.example', 'shopb.example'}}

d.setdefault(key, set()) heißt: Gib mir den Wert unter diesem Schlüssel, und wenn es noch keinen gibt, leg dort zuerst eine leere Menge ab.

Ein häufiger Fehler

Es ist verlockend, nur nach der Top-Level-Site zu verschlüsseln: return top_site. Das hindert AdCo tatsächlich daran, ShopA mit ShopB zu verknüpfen. Aber jetzt teilen sich AdCos Frame und der Shop auf jeder Site eine Schublade, also kann der Frame den Warenkorb des Shops lesen. Der Engine-Bericht nennt das snooped. Ein guter Schlüssel trennt Sites voneinander und Mitglieder voneinander.

Probier es aus Der Übungs-Browser hat diese Regel für Cookies und localStorage schon eingebaut. Lass nach diesem Labor deinen Cookie-Tracker aus Etappe 2 mit Browser(world, partitioned=True) noch einmal laufen und gib das Profil aus, das er baut: Du solltest ein kurzes Profil pro Shop sehen statt eines langen. Öffne in einem echten Browser DevTools (F12), geh zu Application (Storage in Firefox) und öffne Cookies. In den DevTools von Chrome zeigen Cookies, die pro Top-Level-Site gespeichert sind, einen Wert in der Spalte Partition Key.

In anderen Sprachen

Derselbe doppelte Schlüssel in anderen Sprachen:

// JavaScript: a Map keyed by a string that joins both parts
const drawers = new Map();
function partitionKey(area, origin, topSite) {
  return `${area} ${topSite} ${origin}`;
}
drawers.set(partitionKey("cache", "https://adco.example", "shopa.example"), { adco_id: "id-1" });

// Rust: a tuple of Strings is a valid HashMap key
use std::collections::HashMap;
let mut drawers: HashMap<(String, String), HashMap<String, String>> = HashMap::new();
drawers.entry(("shopa.example".into(), "https://adco.example".into()))
       .or_default().insert("adco_id".into(), "id-1".into());

// Go: a struct with comparable fields can key a map
type PartitionKey struct{ TopSite, Origin string }
drawers := map[PartitionKey]map[string]string{}
drawers[PartitionKey{"shopa.example", "https://adco.example"}] = map[string]string{"adco_id": "id-1"}

Zusammenfassung

  • Partitionierung legt jedes gespeicherte Datenstück unter einem Schlüssel ab; gleicher Schlüssel, gleiche Schublade.
  • Ein guter Schlüssel hat zwei Teile, die Top-Level-Site und den Origin, damit Sites einander nicht sehen und ein Frame die Seite um sich herum nicht sieht.
  • Jeder Speicherbereich braucht den Schlüssel, Cookies, localStorage, IndexedDB, Cache und Service Worker gleichermaßen. Ein vergessener Bereich reicht einem Tracker.
  • Tracking funktioniert überall noch, wo dieselbe ID auf zwei oder mehr Sites erscheint: Miss es, nimm es nicht an.
Du bist dran

Schreibe zwei Funktionen. partition_key(area, origin, top_site) muss den zweiteiligen Schlüssel (top_site, origin) für every Speicherbereich zurückgeben. linked_areas(sightings) nimmt eine Liste von (top_site, area, id_seen) Tupeln und gibt ein set der Bereiche zurück, in denen das gleiche id_seen auf zwei oder mehr different obersten Standorten erscheint. Baue dann engine = MiniEngine(partition_key), führe report = run_tracker(engine) aus und setze linked = linked_areas(report["sightings"]). Es sollte eine leere Menge ausgeben.

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.