Programme Leçon 126 sur 156 · Construire les défenses
Construire les défenses

Projet de l'étape 6 : renforcer le moteur

Pourquoi c'est important C'est ici que le module se rassemble. Tu assembles ton propre moteur à partir des pièces que tu as construites, cloisonnement, Storage Access, nettoyage des liens, farbling et purge des rebonds, et tu le fais tourner contre une série de traqueurs dont tu ne peux pas connaître les noms d'hôte à l'avance. Réussir veut dire que tu comprends non seulement chaque défense, mais pourquoi un moteur a besoin de toutes à la fois.

Vois ça comme sécuriser une maison. Une serrure sur la porte d'entrée ne sert à rien si la fenêtre de derrière est ouverte. Chaque traqueur de la série essaie une autre façon d'entrer, et la version cachée déplace les fenêtres. Seule une maison sécurisée par la façon dont marchent les portes, pas par une liste des portes qui existent, garde tout le monde dehors.

Défense en profondeur : plusieurs défenses indépendantes, pour qu'un traqueur qui passe à travers l'une soit arrêté par une autre.

Série cachée : les cinq mêmes techniques de pistage que dans le labo sur la casse, mais avec d'autres graines. Les trois traqueurs non listés reçoivent des noms d'hôte différents à chaque fois, et les fonctions changent de sites.

La commande

Écris un moteur qui, sur les 20 sites d'entraînement, ne laisse aucune technique de pistage reliée et garde le taux de casse dans un budget de 0,10 (au plus deux sites cassés sur 20), sur la graine 0 et sur deux graines cachées.

Ton moteur est fait de deux fonctions qu'appelle la série :

  • make_browser(world) : renvoie un navigateur. Utilise AccessBrowser(world, request_fn=..., access_fn=..., blocker=..., trait_filter=...) de watched.leg6b_access. C'est le navigateur d'entraînement avec le cloisonnement actif et les points d'accroche de Storage Access.
  • after_navigation(browser, visit, interacted) : appelée après chaque chargement de page. visit.records liste chaque requête ; les enregistrements de navigation ont un kind valant "document" ou "form", tous sauf le dernier sont des sauts de redirection, et record.stored liste les cookies qu'une réponse a réussi à enregistrer. interacted vaut True quand Sam a vraiment utilisé la page où Sam est arrivé.

Lance-le avec result = run_suite(make_browser, after_navigation) de watched.leg6b_harden. Elle renvoie linked, broken et breakage, exactement comme le labo sur la casse.

Liste de vérification

  1. Les règles de Storage Access : request_access et has_access, comme dans le labo Storage Access, pour que le widget de commentaires marche après un clic.
  2. Le bloqueur : les navigations (kind valant "document" ou "form") sont nettoyées avec ton clean_url, jamais bloquées ; les sous-ressources dont le site est sur TRACKER_LIST sont bloquées ; tout le reste est autorisé. Ne bloque pas chaque tiers : ça casse le script de cdn.example sur chaque site.
  3. Le nettoyage des liens : clean_url(url) avec la liste de retrait et la liste blanche de watched.leg6b_links, comme dans le labo sur le nettoyage des liens.
  4. Le farbling : farble(values, top_site, session_key) comme dans le labo sur le farbling, utilisée par un trait_filter(traits, page) qui applique le farbling à traits["canvas_pixels"] et traits["audio_samples"] avec page.top_site et un SESSION_KEY que tu choisis.
  5. La purge des rebonds : dans after_navigation, retiens les sites avec lesquels Sam a interagi, et efface les cookies et le stockage de tout saut de redirection qui a enregistré un cookie et n'en fait pas partie.
  6. Mesurer : affiche result, puis corrige ce qui est encore relié ou cassé.

Deux conseils

Garde l'état sur le navigateur, pas dans une variable globale. Les tests font tourner ton moteur sur trois graines, et un set global de « sites utilisés » passerait d'un passage au suivant. Dans make_browser, écris browser.used_sites = set() et relis-le dans after_navigation sous la forme browser.used_sites.

Quand quelque chose est encore relié, demande-toi laquelle de tes défenses devait arrêter cette technique, puis affiche ce que cette défense a vu. Le tableau du labo sur la casse est une bonne carte : chaque technique a une défense qui l'arrête sans liste d'hôtes.

TechniqueArrêtée par
cookie tiersla liste de blocage, ou le cloisonnement
stockage d'une frame (hôte non listé)le cloisonnement
empreinte (hôte non listé)le farbling
décoration de lienle nettoyage de chaque navigation
rebond (hôte non listé)la purge des rebonds

Les tests interdisent watched.leg6b_presets et le reference_clean du module des liens : le but est que le moteur soit le tien.

Une note honnête

Réussir cette série ne rend pas un vrai moteur sûr. Les vrais traqueurs s'adaptent, les vrais sites sont plus désordonnés que vingt sites d'entraînement, et les vrais moteurs passent des années exactement sur cette boucle : mesurer, défendre, mesurer la casse, ajuster. Ce que tu as maintenant, c'est la méthode, et c'est ce qu'utilisent les équipes de moteurs chaque jour.

Dans d'autres langages

Un vrai moteur prend la décision de blocage dans du code natif rapide. Une esquisse en Rust de la même règle que suit ton 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 }
}

Et la purge des rebonds en JavaScript, comme pourrait l'écrire une extension de navigateur :

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

Récap

  • Aucune défense seule n'arrête chaque technique ; un moteur a besoin qu'elles soient superposées.
  • Les défenses qui marchent par le comportement (cloisonnement, farbling, purge) battent les traqueurs dont tu ne connais pas les noms.
  • Nettoie les navigations au lieu de les bloquer, et garde des listes blanches pour ce dont les sites ont besoin.
  • Ne livre que ce que tu as mesuré sur les deux chiffres : le pistage restant et la casse causée.
À ton tour

Construis ton moteur. Définis request_access, has_access, clean_url, blocker, farble, trait_filter, make_browser(world) et after_navigation(browser, visit, interacted) comme décrit dans la liste de vérification, puis définis result = run_suite(make_browser, after_navigation). Les tests font tourner ton moteur sur la graine 0 et deux graines cachées ; chaque passage doit laisser result["linked"] vide avec un result["breakage"] d'au plus 0.10. N'importe pas watched.leg6b_presets ni reference_clean.

Tu as repéré un problème dans cette leçon ? Signale-le · Pose une question sur cette leçon

Cet exercice s'ouvre bientôt

Termine la leçon précédente pour débloquer celle-ci. Tout le cours est gratuit, aucun compte n'est requis, et tu peux lire cette leçon dès maintenant.