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

Análise de tráfego

Por que isso importa A criptografia esconde o que você diz, mas não quando você diz nem quanto. Observar só o horário do tráfego pode revelar quem fala com quem, mesmo através de uma rede de anonimato. Ver isso funcionar em fluxos simulados deixa claro o que o Tor pode e não pode prometer, e por que a defesa mais forte custa tanto.

Imagine que você não pode abrir a correspondência de ninguém, mas pode ficar em duas agências dos correios. Toda vez que uma leva de cartas sai da casa da Ana, uma leva parecida chega a uma clínica pouco depois. Você nunca lê uma palavra, e mesmo assim consegue adivinhar que a Ana escreve para a clínica.

Metadados: dados sobre uma mensagem em vez do conteúdo dela: quando foi enviada, qual o tamanho, de onde veio e para onde foi.

Análise de tráfego: descobrir coisas a partir do padrão da comunicação (horário, tamanhos, volumes) sem ler o conteúdo.

O cenário

Um observador vigia dois lugares: a ligação entre os usuários e a guarda deles, e a ligação entre as saídas e os sites. A função tor_flows(seed) em watched.leg7b_onion dá a você gravações simuladas dos dois. Todo pacote é uma célula, a unidade de tráfego de tamanho fixo do Tor (514 bytes), então o tamanho não diz nada. O horário é tudo o que você tem. Os nomes dos fluxos dos dois lados estão embaralhados, e o lado das saídas está um pouco atrasado.

from watched.leg7b_onion import tor_flows
flows = tor_flows(seed=1)
print(flows["entry"][0]["flow"])          # e01
print(flows["entry"][0]["packets"][:3])   # [(time_in_seconds, size), ...]
print(flows["exit"][0]["flow"])           # x01, but which user is it?
# flows["answers"] holds the truth, so you can score your guesses.

Passo 1: transforme os pacotes em um formato

Conte quantos pacotes caem em cada segundo: o segundo 0 guarda os horários de 0 até 1 (sem incluir), e assim por diante. int(t) dá o segundo ao qual um horário pertence. Um fluxo vira uma lista como [0, 7, 9, 1, 0, 0, 6, ...]: seu formato ao longo do tempo.

Passo 2: compare dois formatos

Correlação: um número de -1 a 1 que diz o quanto duas listas sobem e descem juntas. 1 significa perfeitamente em sincronia, 0 significa nenhuma relação. O Python já a traz embutida: statistics.correlation(a, b).

Se uma lista nunca muda (todos os valores iguais), a correlação fica indefinida e o Python levanta statistics.StatisticsError. Capture o erro e use 0.0, que significa "nenhuma evidência em nenhum sentido".

import statistics
print(statistics.correlation([1, 5, 2, 8], [2, 9, 3, 15]))   # close to 1: in step
try:
    statistics.correlation([3, 3, 3], [1, 2, 3])
except statistics.StatisticsError:
    print("a flat list has no correlation")

Passo 3: associe cada fluxo de entrada ao fluxo de saída mais parecido

Para cada fluxo de entrada, teste todos os fluxos de saída e fique com o de maior correlação. Nesta simulação, só isso já emparelha quase todo mundo corretamente. Ataques reais desse tipo, estudados por pesquisadores, funcionam no mesmo espírito.

As defesas, e o preço delas

  • Tráfego de cobertura aleatório: acrescente células falsas em horários aleatórios. Isso borra um pouco o formato, mas os picos continuam aparecendo. Você vai ver que quase não ajuda.
  • Taxa constante: envie exatamente o mesmo número de células a cada segundo, preenchendo as lacunas com células falsas e fazendo as células reais esperarem a vez. Todo segundo fica idêntico, então o formato desaparece. O preço é banda (todas essas células falsas) e atraso (as células fazem fila durante os picos).

O Tor acrescenta um pouco de padding para borrar registros grosseiros de conexão, mas não esconde o formato do seu tráfego de alguém que consegue observar as duas pontas (verificado em outubro de 2026). Ele escolhe atraso baixo para que a web continue usável. A última lição deste módulo olha para as redes que escolhem o outro caminho.

Um equívoco comum: "se tudo está criptografado, ninguém consegue saber com quem eu falo." A criptografia esconde o conteúdo. O horário e o volume continuam visíveis, e muitas vezes são suficientes.

Este laboratório usa só fluxos simulados. Ele serve para entender o risco e você poder julgar defesas; não é um método para vigiar pessoas reais, e redes reais são muito mais ruidosas.

Em outras linguagens

Contar pacotes por segundo e calcular uma correlação, em outras linguagens:

// JavaScript
function countsPerSecond(packets, seconds) {
  const counts = new Array(seconds).fill(0);
  for (const [t] of packets) if (t >= 0 && t < seconds) counts[Math.floor(t)]++;
  return counts;
}
function correlation(a, b) {
  const n = a.length, ma = a.reduce((x, y) => x + y) / n, mb = b.reduce((x, y) => x + y) / n;
  let num = 0, da = 0, db = 0;
  for (let i = 0; i < n; i++) { num += (a[i]-ma)*(b[i]-mb); da += (a[i]-ma)**2; db += (b[i]-mb)**2; }
  return da && db ? num / Math.sqrt(da * db) : 0;
}
// Go
func countsPerSecond(times []float64, seconds int) []int {
    counts := make([]int, seconds)
    for _, t := range times {
        if t >= 0 && t < float64(seconds) { counts[int(t)]++ }
    }
    return counts
}

Resumo

  • A criptografia esconde o conteúdo, não o horário nem o volume (metadados).
  • Contar pacotes por segundo dá um formato a cada fluxo; a correlação encontra formatos correspondentes nas duas pontas.
  • Tráfego de cobertura aleatório quase não ajuda; o envio a taxa constante esconde o formato, mas custa banda e atraso.
  • O Tor prefere atraso baixo, então não consegue impedir alguém que observa as duas pontas.
Sua vez

Escreva quatro funções e depois use-as em tor_flows(seed=1):

  1. counts_per_second(packets, seconds): uma lista de seconds números, a contagem de pacotes cujo horário t satisfaz 0 <= t < seconds, colocada no índice int(t).
  2. similarity(a, b): statistics.correlation(a, b), ou 0.0 se isso levantar statistics.StatisticsError.
  3. match(entry, exits, seconds): um dict que associa o id "flow" de cada fluxo de entrada ao id do fluxo de saída com a maior similaridade.
  4. accuracy(guesses, answers): a fração dos ids em answers que seus palpites acertaram.
Depois defina acc_plain (sem defesa), acc_cover (lado de entrada depois de add_cover_traffic(flows["entry"], rate=20, seed=1, seconds=S)) e acc_constant (lado de entrada depois de constant_rate(flows["entry"], per_second=10, seconds=S)). Os testes também usam gravações novas.

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.