Conteúdo do curso Lição 143 de 156 · Redes de anonimato e análise de tráfego
Redes de anonimato e análise de tráfego

Impressão digital de sites

Por que isso importa Mesmo quando um observador não consegue ver qual site você visita, o formato do carregamento de uma página pode entregá-lo: quanto você envia, quanto volta. Este laboratório mostra como esse palpite é feito, como o padding o combate e por que os resultados de laboratório fazem o ataque parecer mais forte do que é na vida real.

Pense em pacotes embrulhados em papel pardo. Você não consegue ler a etiqueta, mas um pacote comprido e fino provavelmente é um pôster, e um pesado e quadrado provavelmente são livros. Carregamentos de página são iguais: um site de vídeos baixa muitos dados, um fórum de texto muito poucos. O embrulho esconde o conteúdo, não o tamanho e o formato.

Impressão digital de sites: adivinhar qual site alguém carregou só pelo padrão do seu tráfego criptografado, comparando-o com padrões gravados antes.

Célula: uma unidade de tráfego de tamanho fixo. Neste laboratório, um carregamento de página é uma lista de células: 1 para uma célula que você enviou, -1 para uma célula que você recebeu.

Um classificador simples: centroide mais próximo

Primeiro reduza cada carregamento a dois números, suas features: células enviadas e células recebidas. cells.count(1) e cells.count(-1) fazem isso. Depois, para cada site, faça a média das features dos seus carregamentos de treino. Esse ponto médio é o centroide do site, seu formato típico. Para classificar um carregamento novo, encontre o centroide mais próximo dele.

Centroide: a média de um grupo de pontos: x médio, y médio. Aqui, um por site.

import math
from watched.leg7b_onion import page_loads

data = page_loads(seed=3)          # {"train": [...], "test": [...]}
load = data["train"][0]
print(load["site"], len(load["cells"]))
print(math.dist((30, 400), (33, 420)))   # straight-line distance between two points
# min(sorted(model), key=lambda s: ...) picks the site with the smallest value,
# and on a tie the one that comes first alphabetically.

A defesa: padding

O padding acrescenta células falsas para que os carregamentos se pareçam menos com o seu site. O projeto de pesquisa chamado FRONT acrescenta um número aleatório de células falsas, principalmente perto do início de um carregamento, onde uma página revela mais. pad_traces(traces, budget, seed) acrescenta até budget células falsas em cada direção a cada carregamento.

Para medir de forma justa, suponha que o observador sabe que você usa padding e também treina com carregamentos com padding. O padding diminui a precisão em vez de derrotar o ataque, e as células falsas custam banda. Você vai medir as duas coisas: a queda de precisão e o overhead, as células extras como fração das originais:

overhead = total_cells_after_padding / total_cells_before - 1   # 0.5 means 50% more traffic

O Tor tem uma estrutura para padding de circuitos, mas o padding pesado contra a impressão digital de sites não fica ligado na navegação comum (verificado em outubro de 2026), em grande parte por causa desse custo de banda.

Por que o laboratório exagera o ataque

Aqui o observador sabe que você visita um de oito sites. Isso é um mundo fechado. Pessoas reais visitam milhões de sites: um mundo aberto. Aí as taxas de base pesam. Suponha que um classificador sinalize corretamente um site sensível 95% das vezes e sinalize por engano 5% dos outros carregamentos. Se só 1 carregamento em 1.000 for realmente para esse site, então de 100.000 carregamentos cerca de 95 visitas verdadeiras são sinalizadas, junto com cerca de 4.995 alarmes falsos. Mais de 98% dos alarmes estão errados.

Um equívoco comum: "impressão digital de sites significa que o Tor está quebrado." Significa que um observador específico, o que fica entre você e sua guarda, consegue fazer palpites embasados que funcionam muito melhor em laboratório do que no mundo aberto e bagunçado. É um risco real contra o qual vale se defender, não um motivo para desistir.

Todos os carregamentos aqui são simulados. Nenhum tráfego real é gravado nem analisado.

Em outras linguagens

O passo do centroide mais próximo, em outras linguagens:

// JavaScript
function classify(model, cells) {
  const f = [cells.filter(c => c === 1).length, cells.filter(c => c === -1).length];
  let best = null, bestD = Infinity;
  for (const site of Object.keys(model).sort()) {
    const d = Math.hypot(f[0] - model[site][0], f[1] - model[site][1]);
    if (d < bestD) { best = site; bestD = d; }
  }
  return best;
}
// Rust
fn dist(c: &(f64, f64), out: f64, inc: f64) -> f64 {
    ((c.0 - out).powi(2) + (c.1 - inc).powi(2)).sqrt()
}

fn classify(model: &BTreeMap<String, (f64, f64)>, cells: &[i8]) -> String {
    let out = cells.iter().filter(|&&c| c == 1).count() as f64;
    let inc = cells.iter().filter(|&&c| c == -1).count() as f64;
    model.iter()
        .min_by(|a, b| dist(a.1, out, inc).partial_cmp(&dist(b.1, out, inc)).unwrap())
        .map(|(s, _)| s.clone()).unwrap()
}

Resumo

  • Carregamentos de página criptografados ainda têm um formato; comparar formatos permite adivinhar o site.
  • Centroide mais próximo: faça a média das features de cada site e escolha a média mais próxima.
  • O padding diminui a precisão em vez de derrotar o ataque, e custa banda: meça as duas coisas.
  • Números de laboratório em mundo fechado exageram os ataques reais, porque as taxas de base geram muitos alarmes falsos.
Sua vez

Escreva quatro funções:

  1. features(cells): a tupla (outgoing, incoming), as contagens de 1 e de -1.
  2. train(traces): um dict que associa cada trace["site"] à média de enviadas e à média de recebidas dos seus traces.
  3. classify(model, cells): o site cujo centroide é o mais próximo por math.dist; use min(sorted(model), key=...) para que os empates fiquem com o site que vem primeiro em ordem alfabética.
  4. accuracy(model, traces): a fração classificada como o próprio site.
Depois defina acc_plain (treine com data["train"], teste com data["test"]), acc_padded (treine um modelo novo com padded_train, teste com padded_test) e overhead (total de células em padded_test dividido pelo total de células em data["test"], menos 1). Os testes também usam outros carregamentos.

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.