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. UsaAccessBrowser(world, request_fn=..., access_fn=..., blocker=..., trait_filter=...)dawatched.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.recordselenca ogni richiesta; i record di navigazione hannokind"document" o "form", tutti tranne l'ultimo sono salti di reindirizzamento, erecord.storedelenca 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
- Regole di Storage Access:
request_accessehas_access, come nel laboratorio su Storage Access, così il widget dei commenti funziona dopo un clic. - Blocker: le navigazioni (
kind"document" o "form") vengono pulite con il tuoclean_url, mai bloccate; le sottorisorse il cui sito è inTRACKER_LISTvengono bloccate; tutto il resto è permesso. Non bloccare ogni terza parte: romperebbe lo script dicdn.examplesu ogni sito. - Pulizia dei link:
clean_url(url)con l'elenco da togliere e l'elenco di eccezioni dawatched.leg6b_links, come nel laboratorio sulla pulizia dei link. - Farbling:
farble(values, top_site, session_key)come nel laboratorio sul farbling, usato da untrait_filter(traits, page)che fa farbling ditraits["canvas_pixels"]etraits["audio_samples"]conpage.top_sitee unaSESSION_KEYche scegli tu. - 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. - 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.
| Tecnica | Fermata da |
|---|---|
| cookie di terze parti | la blocklist, o il partizionamento |
| storage di un frame (host non in elenco) | il partizionamento |
| impronta (host non in elenco) | il farbling |
| decorazione dei link | pulire 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.
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.
Questo browser blocca i cookie per learn.floati.life, quindi le lezioni che hai finito qui non si possono aprire in ordine. Consenti i cookie per questo sito e ricarica.