Temario Lección 140 de 156 · Redes de anonimato y análisis de tráfico
Redes de anonimato y análisis de tráfico

Enrutamiento cebolla

Por qué importa Cuando usas Tor, tus mensajes pasan por los ordenadores de tres desconocidos. Saber exactamente qué puede ver cada uno de esos ordenadores te dice qué protege Tor, y qué deja expuesto. En este laboratorio construyes tú mismo las capas, para que la idea deje de parecer magia.

Imagina una carta dentro de tres sobres, uno dentro de otro. Le das el paquete a un primer mensajero. Abre el sobre exterior, encuentra solo el nombre de un segundo mensajero y le pasa el resto. El segundo mensajero abre el siguiente sobre y encuentra el nombre de un tercero. Solo el tercer mensajero abre el último sobre y ve adónde va de verdad la carta.

Ningún mensajero sabe a la vez quién envió la carta y adónde llega. Ese es todo el truco, y tiene nombre.

Enrutamiento cebolla (onion routing): enviar un mensaje envuelto en varias capas de cifrado a través de una cadena de ordenadores, donde cada uno quita exactamente una capa. Como pelar una cebolla, de ahí el nombre.

Relé: un ordenador de una red de enrutamiento cebolla que va pasando el tráfico. Los relés de Tor los gestionan voluntarios de todo el mundo.

Circuito: la cadena de relés por la que va tu tráfico, elegida por tu propio dispositivo. En Tor un circuito tiene normalmente tres relés: un guardián, uno intermedio y uno de salida.

Quién sabe qué

Relé¿Sabe quién eres (tu dirección IP)?¿Sabe adónde vas?
Guardián (el primero)SíNo, solo el relé intermedio
IntermedioNo, solo el guardiánNo, solo el de salida
Salida (el último)No, solo el relé intermedioSí, y puede leer el tráfico salvo que el sitio use HTTPS

Tu dispositivo hace todo el envoltorio antes de que salga nada. Comparte una clave secreta distinta con cada relé (en el Tor real estas claves salen de un intercambio de claves con cada relé por turnos). Como el guardián tiene que pelar primero, su capa tiene que ser la más exterior, así que cierras las capas de dentro hacia fuera: primero la de la salida, luego la del intermedio y por último la del guardián.

Los relés del mundo de práctica

El módulo watched.leg7b_onion te da doce relés ficticios con nombres de árboles. Cada uno tiene un name, una key (un número entero) y unas flags. Un relé con is_guard activado es de confianza para ser el primer salto; uno con is_exit activado acepta conectarse a los sitios web. Algunos relés tienen las dos marcas, y otros ninguna.

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 es un juguete didáctico que no es seguro. Solo existe para que puedas ver cómo se añaden y se quitan las capas. El Tor real usa cifrados revisados.

El texto de cada capa tiene la forma next hop|the rest: el nombre del siguiente relé, una barra y luego las capas interiores todavía cerradas. La capa de la salida lleva el host de destino en lugar del nombre de un relé, y luego el propio mensaje. La función auxiliar relay_views(onion, circuit, your_ip) envía tu cebolla por el circuito e informa, para cada relé, de dónde vino el tráfico (came_from), adónde se pasó (passed_to) y qué pudo leer (read).

Una idea equivocada muy común: "Tor cifra mi tráfico hasta el sitio web." No es así. La última capa se quita en la salida, así que la salida ve todo lo que envías salvo que el propio sitio use HTTPS. Tor oculta quién habla; HTTPS oculta qué se dice. Quieres las dos cosas.

En otros lenguajes

El bucle de envoltorio se parece en cualquier lenguaje: recorre el circuito hacia atrás, añadiendo una capa 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
}

Resumen

  • El enrutamiento cebolla envuelve un mensaje con una capa por relé; cada relé pela exactamente una.
  • El guardián te conoce pero no conoce tu destino; la salida conoce el destino pero no a ti; el intermedio no conoce ninguno de los dos.
  • Cierra las capas de dentro hacia fuera: primero la de la salida, la del guardián la última.
  • Tor oculta quién habla. Solo HTTPS oculta a la salida lo que se dice.
Tu turno

Usa los relés ficticios de watched.leg7b_onion. Escribe dos funciones:

  1. build_circuit(relays, rng): devuelve una lista [guard, middle, exit]. Elige el guardián con rng.choice entre los relés cuyo is_guard es verdadero; la salida entre los relés cuyo is_exit es verdadero y que no son el guardián; el intermedio entre los relés que no son ni el guardián ni la salida (tengan las marcas que tengan). Algunos relés llevan las dos marcas, así que comprueba que los tres sean distintos.
  2. wrap(message, destination, circuit): cierra una capa por relé. El texto de la capa del guardián es middle name|..., el del intermedio es exit name|..., y el de la salida es destination|message. Cierra primero la capa de la salida y la del guardián la última, usando lock(relay.key, text), y devuelve el texto cerrado más exterior.
Las últimas líneas envían tu cebolla e imprimen lo que vio cada relé. Las pruebas usan relés, semillas y mensajes nuevos.

¿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.