Conteúdo do curso Lição 126 de 156 · Construa as defesas
Construa as defesas

Projeto da Etapa 6: blindar o motor

Por que isso importa É aqui que o módulo se junta. Você monta o seu próprio motor com as peças que construiu, particionamento, Storage Access, limpeza de links, farbling e limpeza de redirecionadores, e o roda contra um conjunto de rastreadores cujos nomes de host você não tem como saber de antemão. Passar significa que você entende não só cada defesa, mas por que um motor precisa de todas elas ao mesmo tempo.

Pense nisso como proteger uma casa. Uma tranca na porta da frente é inútil se a janela dos fundos está aberta. Cada rastreador do conjunto tenta entrar por um caminho diferente, e a versão oculta muda as janelas de lugar. Só uma casa protegida pelo modo como as portas funcionam, e não por uma lista de quais portas existem, mantém todo mundo do lado de fora.

Defesa em profundidade: várias defesas independentes, para que um rastreador que escapa de uma seja parado por outra.

Conjunto oculto: as mesmas cinco técnicas de rastreamento do laboratório de Quebras, mas com outras sementes. Os três rastreadores fora da lista recebem nomes de host diferentes a cada vez, e os recursos mudam para sites diferentes.

A tarefa

Escreva um motor que, nos 20 sites de prática, não deixe nenhuma técnica de rastreamento ligada e mantenha a taxa de quebra dentro de um orçamento de 0,10 (no máximo dois sites quebrados em 20), na semente 0 e em duas sementes ocultas.

O seu motor são duas funções que o conjunto chama:

  • make_browser(world): retorna um navegador. Use AccessBrowser(world, request_fn=..., access_fn=..., blocker=..., trait_filter=...) de watched.leg6b_access. É o navegador de prática com o particionamento ligado e os ganchos de Storage Access.
  • after_navigation(browser, visit, interacted): chamada depois de cada carregamento de página. visit.records lista todas as requisições; os registros de navegação têm kind "document" ou "form", todos menos o último deles são saltos de redirecionamento, e record.stored lista os cookies que uma resposta conseguiu guardar. interacted é True quando Sam realmente usou a página em que chegou.

Rode-o com result = run_suite(make_browser, after_navigation) de watched.leg6b_harden. Ele retorna linked, broken e breakage, como no laboratório de Quebras.

Lista de verificação

  1. Regras de Storage Access: request_access e has_access, como no laboratório de Storage Access, para que o widget de comentários funcione depois de um clique.
  2. Bloqueador: as navegações (kind "document" ou "form") são limpas com o seu clean_url, nunca bloqueadas; sub-recursos cujo site está em TRACKER_LIST são bloqueados; todo o resto é permitido. Não bloqueie todos os terceiros: isso quebra o script de cdn.example em todos os sites.
  3. Limpeza de links: clean_url(url) com a lista de remoção e a lista de permissões de watched.leg6b_links, como no laboratório de limpeza de links.
  4. Farbling: farble(values, top_site, session_key) como no laboratório de Farbling, usada por um trait_filter(traits, page) que aplica farbling a traits["canvas_pixels"] e traits["audio_samples"] com page.top_site e uma SESSION_KEY que você escolhe.
  5. Limpeza de redirecionadores: em after_navigation, lembre dos sites com que Sam interagiu e limpe os cookies e o armazenamento de qualquer salto de redirecionamento que guardou um cookie e não é um deles.
  6. Medir: imprima result e depois corrija o que ainda estiver ligado ou quebrado.

Duas dicas

Guarde o estado no navegador, não numa variável global. Os testes rodam o seu motor em três sementes, e um conjunto global de "sites usados" passaria de uma execução para a seguinte. Em make_browser, escreva browser.used_sites = set() e leia de volta em after_navigation como browser.used_sites.

Quando algo ainda estiver ligado, pergunte qual das suas defesas deveria parar aquela técnica e depois imprima o que aquela defesa viu. A tabela do laboratório de Quebras é um bom mapa: cada técnica tem uma defesa que a para sem uma lista de hosts.

TécnicaParada por
cookie de terceirosa lista de bloqueio, ou o particionamento
armazenamento de quadro (host fora da lista)o particionamento
fingerprint (host fora da lista)o farbling
decoração de linkslimpar toda navegação
redirecionamento (host fora da lista)a limpeza de redirecionadores

Os testes proíbem watched.leg6b_presets e o reference_clean do módulo de links: a ideia é que o motor seja seu.

Uma nota honesta

Passar neste conjunto não torna seguro um motor real. Rastreadores reais se adaptam, sites reais são mais bagunçados do que vinte sites de prática, e os motores reais passam anos exatamente neste ciclo: medir, defender, medir as quebras, ajustar. O que você tem agora é o método, e é isso que as equipes de motores usam todos os dias.

Em outras linguagens

Um motor real toma a decisão do bloqueador em código nativo rápido. Um esboço em Rust da mesma regra que o seu blocker segue:

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 a limpeza de redirecionadores em JavaScript, como uma extensão de navegador poderia escrevê-la:

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

Resumo

  • Nenhuma defesa sozinha para todas as técnicas; um motor precisa delas em camadas.
  • Defesas que funcionam pelo comportamento (particionamento, farbling, limpeza) vencem rastreadores cujos nomes você não conhece.
  • Limpe as navegações em vez de bloqueá-las, e mantenha listas de permissões para o que os sites precisam.
  • Lance só o que você mediu nos dois números: rastreamento restante e quebras causadas.
Sua vez

Construa o seu motor. Defina request_access, has_access, clean_url, blocker, farble, trait_filter, make_browser(world) e after_navigation(browser, visit, interacted) como descrito na lista de verificação, depois defina result = run_suite(make_browser, after_navigation). Os testes rodam o seu motor na semente 0 e em duas sementes ocultas; cada execução deve deixar result["linked"] vazio, com result["breakage"] no máximo 0.10. Não importe watched.leg6b_presets nem reference_clean.

Viu um problema nesta lição? Reporte-o · Pergunte sobre esta lição

Este exercício abre em breve

Termine a lição anterior para que esta seja desbloqueada. O curso inteiro é gratuito, não precisa de conta, e você pode ler esta lição agora mesmo.