Temario Lección 126 de 156 · Construir las defensas
Construir las defensas

Proyecto de la etapa 6: blindar el motor

Por qué importa Aquí es donde se junta todo el módulo. Montas tu propio motor con las piezas que construiste (partición, Storage Access, limpieza de enlaces, farbling y una purga de rebotes) y lo pones a prueba contra un conjunto de rastreadores cuyos nombres de host no puedes conocer de antemano. Aprobar significa que entiendes no solo cada defensa, sino por qué un motor las necesita todas a la vez.

Piensa en ello como en asegurar una casa. Una cerradura en la puerta principal no sirve de nada si la ventana de atrás está abierta. Cada rastreador del conjunto prueba una forma distinta de entrar, y la versión oculta cambia las ventanas de sitio. Solo una casa asegurada por cómo funcionan las puertas, y no por una lista de qué puertas existen, deja fuera a todo el mundo.

Defensa en profundidad: varias defensas independientes, de forma que un rastreador que se cuela por una lo detiene otra.

Conjunto oculto: las mismas cinco técnicas de rastreo que en el laboratorio de Roturas, pero con otras semillas. Los tres rastreadores que no están en la lista reciben nombres de host distintos cada vez, y las funciones se mueven a sitios distintos.

El encargo

Escribe un motor que, en los 20 sitios de práctica, no deje ninguna técnica de rastreo relacionada y mantenga la tasa de roturas dentro de un presupuesto de 0.10 (como mucho dos sitios rotos de 20), con la semilla 0 y con dos semillas ocultas.

Tu motor son dos funciones a las que llama el conjunto de pruebas:

  • make_browser(world): devuelve un navegador. Usa AccessBrowser(world, request_fn=..., access_fn=..., blocker=..., trait_filter=...) de watched.leg6b_access. Es el navegador de práctica con la partición activada y los ganchos de Storage Access.
  • after_navigation(browser, visit, interacted): se llama después de cada carga de página. visit.records enumera cada petición; los registros de navegación tienen kind "document" o "form", todos salvo el último son saltos de redirección, y record.stored enumera las cookies que una respuesta consiguió guardar. interacted es True cuando Sam usó de verdad la página a la que llegó.

Ejecútalo con result = run_suite(make_browser, after_navigation) de watched.leg6b_harden. Devuelve linked, broken y breakage, igual que en el laboratorio de Roturas.

Lista de comprobación

  1. Reglas de Storage Access: request_access y has_access, como en el laboratorio de Storage Access, para que el widget de comentarios funcione después de un clic.
  2. Bloqueador: las navegaciones (kind "document" o "form") se limpian con tu clean_url, nunca se bloquean; los subrecursos cuyo sitio está en TRACKER_LIST se bloquean; todo lo demás se permite. No bloquees a todos los terceros: eso rompe el script de cdn.example en todos los sitios.
  3. Limpieza de enlaces: clean_url(url) con la lista de nombres a quitar y la lista de permitidos de watched.leg6b_links, como en el laboratorio de limpieza de enlaces.
  4. Farbling: farble(values, top_site, session_key) como en el laboratorio de Farbling, usado por un trait_filter(traits, page) que aplica farbling a traits["canvas_pixels"] y a traits["audio_samples"] con page.top_site y una SESSION_KEY que elijas.
  5. Purga de rebotes: en after_navigation, recuerda los sitios con los que interactuó Sam, y borra las cookies y el almacenamiento de cualquier salto de redirección que guardó una cookie y no sea uno de ellos.
  6. Mide: imprime result, y luego arregla lo que siga relacionado o roto.

Dos consejos

Guarda el estado en el navegador, no en una variable global. Las pruebas ejecutan tu motor con tres semillas, y un set global de "sitios usados" pasaría de una ejecución a la siguiente. En make_browser, escribe browser.used_sites = set() y vuelve a leerlo en after_navigation como browser.used_sites.

Cuando algo siga relacionado, pregúntate cuál de tus defensas debía detener esa técnica, y luego imprime lo que vio esa defensa. La tabla del laboratorio de Roturas es un buen mapa: cada técnica tiene una defensa que la detiene sin una lista de hosts.

TécnicaLa detiene
cookie de tercerosla lista de bloqueo, o la partición
almacenamiento de un marco (host no listado)la partición
huella digital (host no listado)el farbling
decoración de enlaceslimpiar cada navegación
rebote (host no listado)la purga de rebotes

Las pruebas prohíben watched.leg6b_presets y el reference_clean del módulo de enlaces: la idea es que el motor sea tuyo.

Una nota honesta

Superar este conjunto de pruebas no hace seguro a un motor real. Los rastreadores reales se adaptan, los sitios reales son más caóticos que veinte de práctica, y los motores reales dedican años justo a este ciclo: medir, defender, medir las roturas, ajustar. Lo que tienes ahora es el método, y es lo que usan los equipos de motores cada día.

En otros lenguajes

Un motor real toma la decisión del bloqueador en código nativo rápido. Un esbozo en Rust de la misma regla que sigue tu 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 }
}

Y la purga de rebotes en JavaScript, como la escribiría una extensión de navegador:

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

Resumen

  • Ninguna defensa por sí sola detiene todas las técnicas; un motor las necesita en capas.
  • Las defensas que funcionan por comportamiento (partición, farbling, purga) vencen a los rastreadores cuyos nombres no conoces.
  • Limpia las navegaciones en lugar de bloquearlas, y mantén listas de permitidos para lo que necesitan los sitios.
  • Publica solo lo que has medido con los dos números: el rastreo que queda y las roturas que causa.
Tu turno

Construye tu motor. Define request_access, has_access, clean_url, blocker, farble, trait_filter, make_browser(world) y after_navigation(browser, visit, interacted) como se describe en la lista de comprobación, y luego asigna result = run_suite(make_browser, after_navigation). Las pruebas ejecutan tu motor con la semilla 0 y dos semillas ocultas; cada ejecución debe dejar result["linked"] vacío con result["breakage"] como mucho en 0.10. No importes watched.leg6b_presets ni reference_clean.

¿Has visto un problema en esta lección? Avísanos · Preguntar sobre esta lección

Este ejercicio se abre pronto

Termina la lección anterior y esta se desbloquea. Todo el curso es gratis, no hace falta cuenta, y puedes leer esta lección ahora mismo.