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

Onion routing

Por que isso importa Quando você usa o Tor, suas mensagens passam pelos computadores de três desconhecidos. Saber exatamente o que cada um desses computadores consegue ver diz o que o Tor protege e o que deixa exposto. Neste laboratório você mesmo constrói as camadas, para que a ideia deixe de ser mágica.

Imagine uma carta dentro de três envelopes, um dentro do outro. Você entrega o pacote a um primeiro mensageiro. Ele abre o envelope de fora, encontra só o nome de um segundo mensageiro e passa o resto adiante. O segundo mensageiro abre o envelope seguinte e encontra o nome de um terceiro. Só o terceiro mensageiro abre o último envelope e vê para onde a carta realmente vai.

Nenhum mensageiro sozinho sabe ao mesmo tempo quem enviou a carta e onde ela termina. Esse é todo o truque, e ele tem um nome.

Onion routing: enviar uma mensagem embrulhada em várias camadas de criptografia por uma cadeia de computadores, em que cada um tira exatamente uma camada. Como descascar uma cebola, daí o nome.

Relay: um computador de uma rede de onion routing que repassa o tráfego. Os relays do Tor são operados por voluntários no mundo todo.

Circuito: a cadeia de relays que seu tráfego percorre, escolhida pelo seu próprio dispositivo. No Tor, um circuito normalmente tem três relays: uma guarda, um do meio e uma saída.

Quem sabe o quê

RelaySabe quem você é (seu endereço IP)?Sabe para onde você vai?
Guarda (primeiro)SimNão, só o relay do meio
MeioNão, só a guardaNão, só a saída
Saída (último)Não, só o relay do meioSim, e consegue ler o tráfego, a menos que o site use HTTPS

Seu dispositivo faz todo o embrulho antes de qualquer coisa sair. Ele compartilha uma chave secreta separada com cada relay (no Tor real, essas chaves vêm de uma troca de chaves com cada relay, um de cada vez). Como a guarda precisa descascar primeiro, a camada dela tem de ser a mais externa, então você tranca as camadas de dentro para fora: a camada da saída primeiro, depois a do meio, depois a da guarda.

Os relays do mundo de prática

O módulo watched.leg7b_onion dá a você doze relays fictícios com nomes de árvores. Cada um tem um name, uma key (um número inteiro) e flags. Um relay com is_guard marcado é confiável como primeiro salto; um com is_exit marcado aceita se conectar a sites. Alguns relays têm as duas flags, alguns nenhuma.

import random
from watched.leg7b_onion import relays, lock, unlock

rs = relays(seed=1)
print([r.name for r in rs if r.is_exit])   # the relays allowed to be exits

secret = lock(42, "hello")      # one layer, locked with key 42
print(secret)                   # unreadable hex text
print(unlock(42, secret))       # hello

rng = random.Random(7)          # a seeded random generator
print(rng.choice(["a", "b", "c"]))   # picks one item at random, the same one every run

lock é um brinquedo de ensino que não é seguro. Ele só existe para você ver as camadas sendo acrescentadas e retiradas. O Tor real usa cifras verificadas.

O texto de cada camada tem o formato next hop|the rest: o nome do próximo relay, uma barra vertical e depois as camadas internas ainda trancadas. A camada da saída guarda o host de destino em vez do nome de um relay, e depois a própria mensagem. A função auxiliar relay_views(onion, circuit, your_ip) envia sua cebola pelo circuito e informa, para cada relay, de onde o tráfego veio (came_from), para onde foi passado (passed_to) e o que ele conseguiu ler (read).

Um equívoco comum: "o Tor criptografa meu tráfego até o site." Não criptografa. A última camada sai na saída, então a saída vê o que você enviar, a menos que o próprio site use HTTPS. O Tor esconde quem está falando; o HTTPS esconde o que é dito. Você quer os dois.

Em outras linguagens

O loop de embrulho é igual em qualquer linguagem: percorra o circuito de trás para a frente, acrescentando uma camada a cada vez.

// JavaScript
function wrap(message, destination, circuit, lock) {
  const hops = circuit.slice(1).map(r => r.name).concat([destination]);
  let data = message;
  for (let i = circuit.length - 1; i >= 0; i--) {
    data = lock(circuit[i].key, hops[i] + "|" + data);
  }
  return data;
}
// Go
func wrap(message, destination string, circuit []Relay) string {
    hops := []string{}
    for _, r := range circuit[1:] { hops = append(hops, r.Name) }
    hops = append(hops, destination)
    data := message
    for i := len(circuit) - 1; i >= 0; i-- {
        data = lock(circuit[i].Key, hops[i]+"|"+data)
    }
    return data
}
// Rust
fn wrap(message: &str, destination: &str, circuit: &[Relay]) -> String {
    let mut hops: Vec<String> = circuit[1..].iter().map(|r| r.name.clone()).collect();
    hops.push(destination.to_string());
    let mut data = message.to_string();
    for i in (0..circuit.len()).rev() {
        data = lock(circuit[i].key, &format!("{}|{}", hops[i], data));
    }
    data
}

Resumo

  • O onion routing embrulha uma mensagem em uma camada por relay; cada relay descasca exatamente uma.
  • A guarda sabe quem você é, mas não seu destino; a saída sabe o destino, mas não quem você é; o do meio não sabe nenhum dos dois.
  • Tranque as camadas de dentro para fora: a da saída primeiro, a da guarda por último.
  • O Tor esconde quem está falando. Só o HTTPS esconde da saída o que é dito.
Sua vez

Use os relays fictícios de watched.leg7b_onion. Escreva duas funções:

  1. build_circuit(relays, rng): retorne uma lista [guard, middle, exit]. Escolha a guarda com rng.choice entre os relays cujo is_guard é verdadeiro; a saída entre os relays cujo is_exit é verdadeiro e que não são a guarda; o do meio entre os relays que não são nem a guarda nem a saída (quaisquer que sejam as flags deles). Alguns relays têm as duas flags, então confira que os três são diferentes.
  2. wrap(message, destination, circuit): tranque uma camada por relay. O texto da camada da guarda é middle name|..., o do meio é exit name|... e o da saída é destination|message. Tranque a camada da saída primeiro e a da guarda por último, usando lock(relay.key, text), e retorne o texto trancado mais externo.
As últimas linhas enviam sua cebola e imprimem o que cada relay viu. Os testes usam relays, seeds e mensagens novos.

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.