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

चरण 6 प्रोजेक्ट: engine को मज़बूत करें

यह क्यों मायने रखता है यहीं मॉड्यूल एक साथ आता है। आप अपने बनाए टुकड़ों से अपना engine जोड़ते हैं, partitioning, Storage Access, link सफ़ाई, farbling और एक bounce purge, और उसे एक ऐसे tracker suite के ख़िलाफ़ चलाते हैं जिसके host नाम आप पहले से नहीं जान सकते। पास होने का मतलब है आप सिर्फ़ हर बचाव नहीं समझते, बल्कि यह भी कि एक engine को उन सबकी एक साथ ज़रूरत क्यों है।

इसे एक घर सुरक्षित करना समझें। सामने के दरवाज़े पर एक ताला बेकार है अगर पीछे की खिड़की खुली है। suite का हर tracker अंदर आने का एक अलग तरीका आज़माता है, और छिपा रूप खिड़कियाँ इधर-उधर करता है। सिर्फ़ इससे सुरक्षित घर कि दरवाज़े कैसे काम करते हैं, न कि कौन-से दरवाज़े मौजूद हैं की एक सूची से, सबको बाहर रखता है।

गहराई में बचाव: कई स्वतंत्र बचाव, ताकि एक से निकलने वाला tracker दूसरे से रुक जाए।

छिपा suite: Breakage lab वाली वही पाँच tracking तकनीकें, पर दूसरे seeds पर। तीन बिना सूची वाले trackers को हर बार अलग host नाम मिलते हैं, और features अलग साइटों पर चले जाते हैं।

काम

एक engine लिखें जो, 20 अभ्यास साइटों पर, कोई tracking तकनीक जुड़ी न छोड़े और टूट-फूट दर को 0.10 के budget (20 में ज़्यादा से ज़्यादा दो टूटी साइटें) के अंदर रखे, seed 0 पर और दो छिपे seeds पर।

आपका engine दो functions है जिन्हें suite बुलाता है:

  • make_browser(world): एक ब्राउज़र लौटाता है। watched.leg6b_access से AccessBrowser(world, request_fn=..., access_fn=..., blocker=..., trait_filter=...) इस्तेमाल करें। यह partitioning चालू और Storage Access hooks वाला अभ्यास ब्राउज़र है।
  • after_navigation(browser, visit, interacted): हर page load के बाद बुलाया जाता है। visit.records हर request सूचीबद्ध करता है; navigation records का kind "document" या "form" है, उनमें से आख़िरी के सिवा सब redirect hops हैं, और record.stored उन cookies को सूचीबद्ध करता है जो एक response सहेज पाया। interacted तब True है जब Sam ने सचमुच उस पन्ने को इस्तेमाल किया जिस पर वह पहुँचा।

इसे watched.leg6b_harden से result = run_suite(make_browser, after_navigation) से चलाएँ। यह linked, broken और breakage लौटाता है, ठीक Breakage lab की तरह।

Checklist

  1. Storage Access नियम: request_access और has_access, जैसे Storage Access lab में, ताकि comments widget एक click के बाद काम करे।
  2. Blocker: navigations (kind "document" या "form") आपके clean_url से साफ़ होते हैं, कभी रुकते नहीं; TRACKER_LIST पर साइट वाले subresources रुकते हैं; बाक़ी सब अनुमत है। हर third party न रोकें: वह हर साइट पर cdn.example script तोड़ता है।
  3. Link सफ़ाई: watched.leg6b_links की strip सूची और allowlist के साथ clean_url(url), जैसे link सफ़ाई lab में।
  4. Farbling: farble(values, top_site, session_key) जैसे Farbling lab में, एक trait_filter(traits, page) से इस्तेमाल जो traits["canvas_pixels"] और traits["audio_samples"] को page.top_site और आपके चुने एक SESSION_KEY से farble करे।
  5. Bounce purge: after_navigation में Sam ने जिन साइटों से संवाद किया उन्हें याद रखें, और किसी भी ऐसे redirect hop की cookies और storage साफ़ करें जिसने एक cookie रखी और जो उनमें से एक नहीं।
  6. मापें: result print करें, फिर जो अब भी जुड़ा या टूटा है उसे ठीक करें।

दो सुझाव

state ब्राउज़र पर रखें, एक global variable में नहीं। Tests आपका engine तीन seeds पर चलाते हैं, और "इस्तेमाल की साइटों" का एक global set एक run से अगले में चला जाता। make_browser में browser.used_sites = set() लिखें और after_navigation में उसे browser.used_sites के रूप में वापस पढ़ें।

जब कुछ अब भी जुड़ा हो, तो पूछें कि आपके किस बचाव को वह तकनीक रोकनी थी, फिर print करें कि उस बचाव ने क्या देखा। Breakage lab की table एक अच्छा नक्शा है: हर तकनीक का एक बचाव है जो उसे बिना host सूची के रोकता है।

तकनीकइससे रुकी
third-party cookieblocklist, या partitioning
frame storage (बिना सूची का host)partitioning
fingerprint (बिना सूची का host)farbling
link decorationहर navigation साफ़ करना
bounce (बिना सूची का host)bounce purge

Tests watched.leg6b_presets और link module के reference_clean को मना करते हैं: मुद्दा यह है कि engine आपका है।

एक ईमानदार नोट

इस suite को पास करना एक असली engine को सुरक्षित नहीं बनाता। असली trackers ढलते हैं, असली साइटें बीस अभ्यास वालों से ज़्यादा उलझी हैं, और असली engines ठीक इसी चक्र पर साल बिताते हैं: मापें, बचाएँ, टूट-फूट मापें, समायोजित करें। अब आपके पास जो है वह तरीका है, और वही engine टीमें हर दिन इस्तेमाल करती हैं।

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

एक असली engine blocker फ़ैसला तेज़ native code में करता है। Rust में उसी नियम का एक ख़ाका जिसका आपका blocker पालन करता है:

use std::collections::HashSet;

enum Decision { Allow, Block, Rewrite(String) }

fn decide(kind: &str, url: &str, site: &str, tracker_list: &HashSet<String>) -> Decision {
    if kind == "document" || kind == "form" {
        let cleaned = clean_url(url);          // your clean_url, in Rust; never block a navigation
        return if cleaned != url { Decision::Rewrite(cleaned) } else { Decision::Allow };
    }
    if tracker_list.contains(site) { Decision::Block } else { Decision::Allow }
}

और JavaScript में bounce purge, जैसे एक browser extension इसे लिख सकता है:

function afterNavigation(hops, landed, interacted, usedSites) {
  if (interacted) usedSites.add(landed);
  for (const hop of hops) {
    if (hop.storedCookies.length && !usedSites.has(hop.site)) clearSiteData(hop.site);
  }
}

सार

  • कोई अकेला बचाव हर तकनीक नहीं रोकता; एक engine को उनकी परतें चाहिए।
  • बर्ताव से काम करने वाले बचाव (partitioning, farbling, purging) उन trackers को हराते हैं जिनके नाम आप नहीं जानते।
  • navigations को रोकने के बजाय साफ़ करें, और साइटों की ज़रूरत के लिए allowlists रखें।
  • सिर्फ़ वही ship करें जो आपने दोनों संख्याओं पर मापा: बची tracking और पैदा हुई टूट-फूट।
आपकी बारी

अपना engine बनाएँ। checklist में बताए अनुसार request_access, has_access, clean_url, blocker, farble, trait_filter, make_browser(world) और after_navigation(browser, visit, interacted) परिभाषित करें, फिर result = run_suite(make_browser, after_navigation) सेट करें। Tests आपका engine seed 0 और दो छिपे seeds पर चलाते हैं; हर run को result["linked"] ख़ाली और result["breakage"] ज़्यादा से ज़्यादा 0.10 छोड़ना चाहिए। watched.leg6b_presets या reference_clean import न करें।

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

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

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