Programma Lezione 126 di 156 · Costruisci le difese
Costruisci le difese

Progetto della Tappa 6: rinforza il motore

Perché è importante È qui che il modulo si ricompone. Assembli il tuo motore con i pezzi che hai costruito, partizionamento, Storage Access, pulizia dei link, farbling e pulizia dei rimbalzi, e lo fai girare contro una serie di tracker i cui nomi di host non puoi conoscere in anticipo. Superarla significa che capisci non solo ogni difesa, ma perché un motore ne ha bisogno tutte insieme.

Pensalo come mettere in sicurezza una casa. Una serratura sulla porta d'ingresso non serve se la finestra sul retro è aperta. Ogni tracker della serie prova una strada diversa per entrare, e la versione nascosta sposta le finestre. Solo una casa protetta in base a come funzionano le porte, non da un elenco di quali porte esistono, tiene fuori tutti.

Difesa in profondità: diverse difese indipendenti, così un tracker che supera una viene fermato da un'altra.

Serie nascosta: le stesse cinque tecniche di tracciamento del laboratorio sulle rotture, ma su altri semi. I tre tracker non in elenco ricevono ogni volta nomi di host diversi, e le funzioni si spostano su siti diversi.

Il compito

Scrivi un motore che, sui 20 siti di esercitazione, non lasci nessuna tecnica di tracciamento collegata e tenga il tasso di rottura dentro un budget di 0,10 (al massimo due siti rotti su 20), con il seme 0 e con due semi nascosti.

Il tuo motore è fatto di due funzioni che la serie chiama:

  • make_browser(world): restituisce un browser. Usa AccessBrowser(world, request_fn=..., access_fn=..., blocker=..., trait_filter=...) da watched.leg6b_access. È il browser di esercitazione con il partizionamento attivo e i ganci di Storage Access.
  • after_navigation(browser, visit, interacted): chiamata dopo ogni caricamento di pagina. visit.records elenca ogni richiesta; i record di navigazione hanno kind "document" o "form", tutti tranne l'ultimo sono salti di reindirizzamento, e record.stored elenca i cookie che una risposta è riuscita a salvare. interacted è True quando Sam ha usato davvero la pagina su cui è arrivato.

Eseguilo con result = run_suite(make_browser, after_navigation) da watched.leg6b_harden. Restituisce linked, broken e breakage, proprio come il laboratorio sulle rotture.

Lista di controllo

  1. Regole di Storage Access: request_access e has_access, come nel laboratorio su Storage Access, così il widget dei commenti funziona dopo un clic.
  2. Blocker: le navigazioni (kind "document" o "form") vengono pulite con il tuo clean_url, mai bloccate; le sottorisorse il cui sito è in TRACKER_LIST vengono bloccate; tutto il resto è permesso. Non bloccare ogni terza parte: romperebbe lo script di cdn.example su ogni sito.
  3. Pulizia dei link: clean_url(url) con l'elenco da togliere e l'elenco di eccezioni da watched.leg6b_links, come nel laboratorio sulla pulizia dei link.
  4. Farbling: farble(values, top_site, session_key) come nel laboratorio sul farbling, usato da un trait_filter(traits, page) che fa farbling di traits["canvas_pixels"] e traits["audio_samples"] con page.top_site e una SESSION_KEY che scegli tu.
  5. Pulizia dei rimbalzi: in after_navigation, ricorda i siti con cui Sam ha interagito, e cancella cookie e storage di ogni salto di reindirizzamento che ha salvato un cookie e non è uno di quelli.
  6. Misura: stampa result, poi correggi tutto ciò che è ancora collegato o rotto.

Due consigli

Tieni lo stato sul browser, non in una variabile globale. I test eseguono il tuo motore su tre semi, e un set globale di "siti usati" passerebbe da un'esecuzione all'altra. In make_browser, scrivi browser.used_sites = set() e rileggilo in after_navigation come browser.used_sites.

Quando qualcosa è ancora collegato, chiediti quale delle tue difese doveva fermare quella tecnica, poi stampa ciò che quella difesa ha visto. La tabella del laboratorio sulle rotture è una buona mappa: ogni tecnica ha una difesa che la ferma senza un elenco di host.

TecnicaFermata da
cookie di terze partila blocklist, o il partizionamento
storage di un frame (host non in elenco)il partizionamento
impronta (host non in elenco)il farbling
decorazione dei linkpulire ogni navigazione
rimbalzo (host non in elenco)la pulizia dei rimbalzi

I test vietano watched.leg6b_presets e il reference_clean del modulo dei link: il punto è che il motore sia tuo.

Una nota onesta

Superare questa serie non rende sicuro un motore vero. I tracker veri si adattano, i siti veri sono più disordinati di venti siti di esercitazione, e i motori veri passano anni esattamente in questo ciclo: misurare, difendere, misurare le rotture, aggiustare. Quello che hai ora è il metodo, ed è ciò che i gruppi che costruiscono motori usano ogni giorno.

In altri linguaggi

Un motore vero prende la decisione del blocker in codice nativo veloce. Uno schizzo in Rust della stessa regola che segue il tuo 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 }
}

E la pulizia dei rimbalzi in JavaScript, come potrebbe scriverla un'estensione del browser:

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);
  }
}

Riepilogo

  • Nessuna difesa da sola ferma ogni tecnica; un motore ne ha bisogno a strati.
  • Le difese che funzionano in base al comportamento (partizionamento, farbling, pulizia) battono i tracker di cui non conosci il nome.
  • Pulisci le navigazioni invece di bloccarle, e tieni elenchi di eccezioni per ciò di cui i siti hanno bisogno.
  • Rilascia solo ciò che hai misurato su entrambi i numeri: tracciamento rimasto e rotture causate.
Tocca a te

Costruisci il tuo motore. Definisci request_access, has_access, clean_url, blocker, farble, trait_filter, make_browser(world) e after_navigation(browser, visit, interacted) come descritto nella lista di controllo, poi imposta result = run_suite(make_browser, after_navigation). I test eseguono il tuo motore con il seme 0 e con due semi nascosti; ogni esecuzione deve lasciare result["linked"] vuoto con result["breakage"] al massimo 0.10. Non importare watched.leg6b_presets o reference_clean.

Hai notato un problema in questa lezione? Segnalalo · Chiedi qualcosa su questa lezione

Questo esercizio si apre presto

Finisci la lezione precedente e questa si sblocca. L'intero corso è gratuito, senza account, e puoi leggere questa lezione subito.