Verdeel die engine
Waarom dit saak maak In Leg 2 het AdCo se tracker gewerk omdat AdCo se ingebedde frame een stoorlaai gehad het wat dit by elke winkel oopgemaak het. Blaaiers stop dit deur stoorplek per webwerf te verdeel, wat bording genoem word. As 'n enjin koekies verdeel maar selfs een ander stoorarea vergeet, skuif die tracker bloot sy ID daarheen. In hierdie laboratorium is jy die enjin-outeur: jy skryf die reël wat besluit waar data gehou word, en kyk dan hoe die tracker faal.
Stel jou 'n ketting van gimnasiume voor. 'n Onversorgde ketting gee vir elke lid een kluis-sleutel wat dieselfde kluis in elke tak oopmaak, so alles wat daarin losgelaat word, volg jou deur die dorp. 'n Versigtige ketting gee vir jou 'n aparte kluis in elke tak. En binne elke tak het elke lid hul eie kluis, so niemand kan iemand anders s'n oopmaak nie.
DieA-webblaaier-enjin is die versigtige ketting. Die branch is die webwerf in die adresbalk. Die member is wie ook al die data stoor, soos die winkel self of 'n advertisieraam wat daarin ingebed is.
Bopvlak-webwerkhierargi: die webwerf wat in die adresbalk wys, byvoorbeeld shopa.example. Alles op die bladsy, insluitend frames en scripts, word namens dit gelaai.
Origin: wie stoor die data: skema, gasheer en poort, byvoorbeeld https://adco.example. 'n Ingebedde raam het sy eie oorsprong, anders as die bladsy daaromheen.
Opslagarea: een plek waar 'n bl brasileiros data vir 'n webwerf hou. Cookies is een area; localStorage, IndexedDB ('n klein databasis in die bl brasileiros), die HTTP cache (bewaarde kopies van lêers) en service workers (skripte wat in die agtergrond vir 'n webwerf loop) is ander.
Partisie-sleutel: die etiket wat 'n enjin op elke laai sit. Twee lees- of skryfaksies met dieselfde sleutel deel 'n laai; verskillende sleutels doen dit nooit nie.
Die oefen-enjin
Die module watched.leg6b_engine het 'n klein enjin genaamd MiniEngine met vyf stoorareas. Jy gee dit een funksie, die partition key-reël, en dit vra daardie funksie elke keer wanneer iets gelees of geskryf word:
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')Met die naïewe reël skryf AdCo sy ID terwyl jy op ShopA is en lees dieselfde ID terug op ShopB. Daardie een reël is cross-site tracking.
'n sleutel wat uit twee dele bestaan
Die oplossing is om die sleutel beide die top-vlak webwerf en die oorsprong te laat insluit. Python het 'n neat manier om waardes aanmekaar te plak: 'n tuple, geskryf met ronde hakies.
Tuple: 'n vaste groep waardes, soos ("shopa.example", "https://adco.example"). Dit werk soos 'n lys wat jy nie kan verander nie, en anders as 'n lys kan dit as 'n dictionary key gebruik word.
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 drawerEngines noem dit double keying: elke stuk gestoorde data word onder (top-level site, origin) geklassifiseer. Ware engines voeg meer by sommige sleutels, maar hierdie twee dele is die hart daarvan.
Watter areas vergeet 'n naive engine?
Engines het nie alles gelyktydig gepartisioneer nie. Cookies het die meeste aandag gekry, terwyl caches en nuwer stores later gekom het. Die HTTP cache is nou in al drie groot engines gepartisioneer: Safari sedert 2013, Chrome sedert weergawe 86 en Firefox sedert weergawe 85 (nasien Oktober 2026). Enige area wat uitgelos is, is 'n skuilplek. Dit is waarom jou sleutelreël elke area moet dek, nie net cookies nie.
Meet of of die tracking nog werk
run_tracker(engine) besoek die drie winkels. By elke een spaar die winkel 'n cart, dan soek AdCo se frame vir sy ID in elke area en skryf 'n nuwe een as die drawer leeg is. Dit gee 'n dict terug:
"sightings": 'n lys van(top_site, area, id_seen)tuples, een per winkel en area"snooped": areas waar AdCo se frame die winkel se eie karretjie kon lees (moet leeg wees)"first_party_ok": Waar wanneer elke winkel sy eie kar kon lees terug
Tracking werk in 'n area wanneer die same ID op two of meer verskillende sites verskyn. Om dit te tel, sal jy 'n set gebruik: 'n versameling sonder herhalings, geskryf set() wanneer dit leeg is. s.add(x) sit iets in en len(s) sê hoeveel verskillende dinge dit hou.
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()) beteken: gee vir my die waarde onder hierdie sleutel, en as daar nog nie een is nie, stoor 'n leë stel daar eerste.
A algemene fout
Dit is verleidel om net volgens die topvlak-webwerf te sleutel: return top_site. Dit stop AdCo om ShopA aan ShopB te skakel. Maar nou deel AdCo se frame en die winkel een laaier op elke webwerf, so die frame kan die winkel se karretjie lees. Die engine report noem dit snooped. 'n Goeie sleutel skei webwerwe van mekaar en lede van mekaar.
Probeer dit Die oefening Browser het reeds hierdie reël ingebou vir cookies en localStorage. Na hierdie laboratorium, hardloop jou Leg 2 cookie tracker weer met Browser(world, partitioned=True) en druk die profiel wat dit bou: jy moet een kort profiel per winkel sien in plaas van een lang een. In 'n regte bl brasileiros, maak DevTools (F12) oop, gaan na Application (Storage in Firefox) en maak Cookies oop. In Chrome se DevTools wys cookies wat per top-level site gestoor word 'n waarde in die Partition Key kolom.
In ander tale
Dieselfde dubbele sleutel in ander tale:
// 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"}Opsomming
- Partisieer lêers om elke stukkie gestoorde data onder 'n sleutel te plaas; dieselfde sleutel, dieselfde laai.
- 'n goeie sleutel het twee dele, die top-level site en die origin, so webwerwe kan nie mekaar sien nie en 'n frame kan nie die bladsy daaromheen sien nie.
- Elke stoorarea het die sleutel nodig, cookies, localStorage, IndexedDB, cache en service workers ewely. Een vergeete area is genoeg vir 'n tracker.
- Tracking werk steeds oral waar dieselfde ID op twee of meer webwerwe verskyn: meet dit, moenie aanvaar nie.
Skryf twee funksies. partition_key(area, origin, top_site) moet die twee-deel sleutel (top_site, origin) vir every stoorarea teruggee. linked_areas(sightings) neem 'n lys van (top_site, area, id_seen) tuples en gee 'n set van die areas terug waar dieselfde id_seen op twee of meer different top-vlak terreine verskyn. Bou dan engine = MiniEngine(partition_key), hardloop report = run_tracker(engine), en stel linked = linked_areas(report["sightings"]). Dit moet 'n leë set druk.
Sien jy 'n probleem in hierdie les? Rapporteer dit · Vra oor hierdie les
Hierdie oefening open binnekort
Voltooi die lesie voor dit en hierdie een sal ontvanklik wees. Die hele kursus is gratis, geen rekening nodig nie, en jy kan hierdie les nou lees.
Hierdie blutser blokkeer koekies vir learn.floati.life, so lesse wat jy hier voltooi het kan nie in volgorde oopgaan nie. Laat koekies vir hierdie webwerf toe en laai nuut.