पाठ्यक्रम 156 में से पाठ 120 · बचाव बनाएँ
बचाव बनाएँ

Engine को partition करें

यह क्यों मायने रखता है चरण 2 में AdCo का tracker इसलिए काम करता था क्योंकि AdCo के embedded frame के पास एक storage दराज़ थी जो वह हर दुकान पर खोलता था। ब्राउज़र storage को हर साइट के हिसाब से बाँटकर इसे रोकते हैं, जिसे partitioning कहते हैं। अगर एक engine cookies बाँटता है पर एक भी दूसरी storage जगह भूल जाता है, तो tracker बस अपनी ID वहाँ ले जाता है। इस lab में आप engine लेखक हैं: आप वह नियम लिखते हैं जो तय करता है कि डेटा कहाँ रखा जाए, फिर tracker को विफल होते देखते हैं।

gyms की एक श्रृंखला की तस्वीर बनाएँ। एक लापरवाह श्रृंखला हर सदस्य को एक locker चाबी देती है जो हर शाखा में एक ही locker खोलती है, इसलिए उसमें छोड़ी कोई भी चीज़ शहर भर में आपके पीछे आती है। एक सावधान श्रृंखला आपको हर शाखा में एक अलग locker देती है। और हर शाखा के अंदर, हर सदस्य का अपना locker है, ताकि कोई किसी और का न खोल सके।

एक ब्राउज़र engine सावधान श्रृंखला है। शाखा address bar की साइट है। सदस्य वह है जो डेटा रख रहा है, जैसे दुकान ख़ुद या उसमें embed एक विज्ञापन frame।

Top-level site: address bar में दिखने वाली साइट, उदाहरण के लिए shopa.example। पन्ने पर सब कुछ, frames और scripts समेत, उसकी ओर से load होता है।

Origin: डेटा कौन रख रहा है: scheme, host और port, उदाहरण के लिए https://adco.example। एक embedded frame का अपना origin होता है, उसके चारों ओर के पन्ने से अलग।

Storage जगह: एक जगह जहाँ एक ब्राउज़र एक साइट का डेटा रखता है। Cookies एक जगह हैं; localStorage, IndexedDB (ब्राउज़र में एक छोटा database), HTTP cache (फ़ाइलों की सहेजी प्रतियाँ) और service workers (scripts जो एक साइट के लिए पृष्ठभूमि में चलती हैं) दूसरी हैं।

Partition key: वह label जो एक engine हर दराज़ पर लगाता है। एक ही key वाले दो पढ़ना या लिखना एक दराज़ साझा करते हैं; अलग keys कभी नहीं।

अभ्यास engine

module watched.leg6b_engine में पाँच storage जगहों वाला MiniEngine नाम का एक छोटा engine है। आप उसे एक function देते हैं, partition key नियम, और जब भी कुछ पढ़ा या लिखा जाता है वह उस function से पूछता है:

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')

भोले नियम के साथ, AdCo तब अपनी ID लिखता है जब आप ShopA पर हैं और ShopB पर वही ID वापस पढ़ता है। वह एक पंक्ति cross-site tracking है।

दो हिस्सों से बनी एक key

इलाज है key में top-level साइट और origin दोनों शामिल करना। Python में मानों को साथ चिपकाने का एक साफ़ तरीका है: एक tuple, गोल कोष्ठकों में लिखा।

Tuple: मानों का एक तय समूह, जैसे ("shopa.example", "https://adco.example")। यह एक ऐसी सूची की तरह काम करता है जिसे आप बदल नहीं सकते, और एक सूची के उलट इसे एक dictionary key के रूप में इस्तेमाल किया जा सकता है।

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 इसे double keying कहते हैं: रखे डेटा का हर टुकड़ा (top-level साइट, origin) के नीचे दर्ज होता है। असली engines कुछ keys में और जोड़ते हैं, पर ये दो हिस्से इसका दिल हैं।

एक भोला engine कौन-सी जगहें भूलता है?

Engines ने सब कुछ एक साथ partition नहीं किया। Cookies को ज़्यादातर ध्यान मिला, जबकि caches और नए भंडार बाद में आए। HTTP cache अब तीनों बड़े engines में partitioned है: Safari में 2013 से, Chrome में version 86 से और Firefox में version 85 से (अक्टूबर 2026 में जाँचा)। छोड़ी कोई भी जगह एक छिपने की जगह है, इसीलिए आपके key नियम को हर जगह ढकनी चाहिए, सिर्फ़ cookies नहीं।

मापना कि tracking अब भी काम करती है या नहीं

run_tracker(engine) तीनों दुकानों पर जाता है। हर एक पर दुकान एक cart सहेजती है, फिर AdCo का frame हर जगह अपनी ID खोजता है और दराज़ ख़ाली हो तो एक नई लिखता है। यह एक dict लौटाता है:

  • "sightings": (top_site, area, id_seen) tuples की एक सूची, हर दुकान और जगह का एक
  • "snooped": वे जगहें जहाँ AdCo का frame दुकान का अपना cart पढ़ सका (ख़ाली होनी चाहिए)
  • "first_party_ok": True जब हर दुकान अपना cart वापस पढ़ सकी

Tracking एक जगह में तब काम करती है जब वही ID दो या ज़्यादा अलग साइटों पर दिखे। इसे गिनने के लिए आप एक set इस्तेमाल करेंगे: बिना दोहराव का एक संग्रह, ख़ाली होने पर set() लिखा। s.add(x) कुछ अंदर डालता है और len(s) बताता है कि उसमें कितनी अलग चीज़ें हैं।

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()) का मतलब है: इस key के नीचे का मान मुझे दो, और अगर अभी कोई नहीं, तो पहले वहाँ एक ख़ाली set रखो।

एक आम ग़लती

सिर्फ़ top-level साइट से key बनाना ललचाता है: return top_site। यह AdCo को ShopA को ShopB से जोड़ने से रोकता है। पर अब AdCo का frame और दुकान हर साइट पर एक दराज़ साझा करते हैं, इसलिए frame दुकान का cart पढ़ सकता है। engine report इसे snooped कहती है। एक अच्छी key साइटों को एक-दूसरे से और सदस्यों को एक-दूसरे से अलग करती है।

आज़माएँ अभ्यास Browser में यह नियम cookies और localStorage के लिए पहले से बना है। इस lab के बाद, अपना चरण 2 cookie tracker Browser(world, partitioned=True) के साथ फिर चलाएँ और जो profile वह बनाता है उसे print करें: आपको एक लंबी के बजाय हर दुकान की एक छोटी profile दिखनी चाहिए। एक असली ब्राउज़र में DevTools (F12) खोलें, Application (Firefox में Storage) पर जाएँ और Cookies खोलें। Chrome के DevTools में, हर top-level साइट के लिए रखी cookies Partition Key column में एक मान दिखाती हैं।

दूसरी भाषाओं में

दूसरी भाषाओं में वही double key:

// 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"}

सार

  • Partitioning रखे डेटा के हर टुकड़े को एक key के नीचे दर्ज करता है; एक ही key, एक ही दराज़।
  • एक अच्छी key के दो हिस्से हैं, top-level साइट और origin, ताकि साइटें एक-दूसरे को न देख सकें और एक frame अपने चारों ओर का पन्ना न देख सके।
  • हर storage जगह को key चाहिए, cookies, localStorage, IndexedDB, cache और service workers सब। एक भूली जगह एक tracker के लिए काफ़ी है।
  • Tracking जहाँ भी वही ID दो या ज़्यादा साइटों पर दिखे वहाँ अब भी काम करती है: मापें, मान न लें।
आपकी बारी

दो functions लिखें। partition_key(area, origin, top_site) को हर storage जगह के लिए दो-हिस्सा key (top_site, origin) लौटानी चाहिए। linked_areas(sightings) (top_site, area, id_seen) tuples की एक सूची लेता है और उन जगहों का एक set लौटाता है जहाँ वही id_seen दो या ज़्यादा अलग top-level साइटों पर दिखती है। फिर engine = MiniEngine(partition_key) बनाएँ, report = run_tracker(engine) चलाएँ, और linked = linked_areas(report["sightings"]) सेट करें। इसे एक ख़ाली set print करना चाहिए।

इस पाठ में कोई समस्या दिखी? बताएँ · इस पाठ के बारे में पूछें

यह अभ्यास जल्द खुलेगा

इससे पहले वाला पाठ पूरा करें और यह खुल जाएगा। पूरा कोर्स मुफ़्त है, कोई खाता नहीं चाहिए, और आप यह पाठ अभी पढ़ सकते हैं।