Programme Leçon 140 sur 156 · Réseaux d'anonymat et analyse de trafic
Réseaux d'anonymat et analyse de trafic

Le routage en oignon

Pourquoi c'est important Quand tu utilises Tor, tes messages passent par les ordinateurs de trois inconnus. Savoir exactement ce que chacun de ces ordinateurs peut voir te dit ce que Tor protège, et ce qu'il laisse exposé. Dans ce labo, tu construis les couches toi-même, pour que l'idée cesse d'être magique.

Imagine une lettre dans trois enveloppes, l'une dans l'autre. Tu donnes le paquet à un premier coursier. Il ouvre l'enveloppe extérieure, n'y trouve que le nom d'un deuxième coursier, et transmet le reste. Le deuxième coursier ouvre l'enveloppe suivante et trouve le nom d'un troisième. Seul le troisième coursier ouvre la dernière enveloppe et voit où va vraiment la lettre.

Aucun coursier ne sait à la fois qui a envoyé la lettre et où elle arrive. C'est toute l'astuce, et elle a un nom.

Routage en oignon (onion routing) : envoyer un message enveloppé dans plusieurs couches de chiffrement à travers une chaîne d'ordinateurs, où chacun retire exactement une couche. Comme on épluche un oignon, d'où le nom.

Relais : un ordinateur d'un réseau de routage en oignon qui fait suivre le trafic. Les relais de Tor sont gérés par des bénévoles du monde entier.

Circuit : la chaîne de relais que prend ton trafic, choisie par ton propre appareil. Dans Tor, un circuit a normalement trois relais : une garde, un relais du milieu et une sortie.

Qui sait quoi

RelaisSait qui tu es (ton adresse IP) ?Sait où tu vas ?
Garde (premier)OuiNon, seulement le relais du milieu
MilieuNon, seulement la gardeNon, seulement la sortie
Sortie (dernier)Non, seulement le relais du milieuOui, et elle peut lire le trafic sauf si le site utilise HTTPS

Ton appareil fait tout l'emballage avant que quoi que ce soit ne parte. Il partage une clé secrète distincte avec chaque relais (dans le vrai Tor, ces clés viennent d'un échange de clés avec chaque relais à tour de rôle). Comme la garde doit éplucher en premier, sa couche doit être la plus extérieure, donc tu verrouilles les couches de l'intérieur vers l'extérieur : d'abord la couche de la sortie, puis celle du milieu, puis celle de la garde.

Les relais du monde d'entraînement

Le module watched.leg7b_onion te donne douze relais fictifs qui portent des noms d'arbres. Chacun a un name, une key (un nombre entier) et des flags. Un relais avec is_guard activé est jugé fiable comme premier saut ; un relais avec is_exit activé accepte de se connecter aux sites web. Certains relais ont les deux drapeaux, d'autres aucun.

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 est un jouet pédagogique qui n'est pas sûr. Il n'existe que pour que tu voies les couches s'ajouter et s'enlever. Le vrai Tor utilise des chiffrements éprouvés.

Le texte de chaque couche a la forme next hop|the rest : le nom du relais suivant, une barre verticale, puis les couches intérieures encore verrouillées. La couche de la sortie contient l'hôte de destination au lieu d'un nom de relais, puis le message lui-même. La fonction d'aide relay_views(onion, circuit, your_ip) envoie ton oignon à travers le circuit et indique, pour chaque relais, d'où le trafic venait (came_from), à qui il a été transmis (passed_to), et ce que le relais pouvait lire (read).

Une idée reçue : « Tor chiffre mon trafic jusqu'au site web. » Non. La dernière couche est retirée à la sortie, donc la sortie voit tout ce que tu envoies, sauf si le site lui-même utilise HTTPS. Tor cache qui parle ; HTTPS cache ce qui est dit. Tu veux les deux.

Dans d'autres langages

La boucle d'emballage est la même dans n'importe quel langage : parcourir le circuit à l'envers, en ajoutant une couche à chaque fois.

// 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
}

Récap

  • Le routage en oignon enveloppe un message dans une couche par relais ; chaque relais en épluche exactement une.
  • La garde te connaît mais pas ta destination ; la sortie connaît la destination mais pas toi ; le milieu ne connaît ni l'un ni l'autre.
  • Verrouille les couches de l'intérieur vers l'extérieur : celle de la sortie d'abord, celle de la garde en dernier.
  • Tor cache qui parle. Seul HTTPS cache à la sortie ce qui est dit.
À ton tour

Utilise les relais fictifs de watched.leg7b_onion. Écris deux fonctions :

  1. build_circuit(relays, rng) : renvoie une liste [guard, middle, exit]. Choisis la garde avec rng.choice parmi les relais dont is_guard est vrai ; la sortie parmi les relais dont is_exit est vrai et qui ne sont pas la garde ; le milieu parmi les relais qui ne sont ni la garde ni la sortie (quels que soient leurs drapeaux). Certains relais portent les deux drapeaux, donc vérifie que les trois sont différents.
  2. wrap(message, destination, circuit) : verrouille une couche par relais. Le texte de la couche de la garde est middle name|..., celui du milieu est exit name|..., et celui de la sortie est destination|message. Verrouille la couche de la sortie d'abord et celle de la garde en dernier, avec lock(relay.key, text), et renvoie le texte verrouillé le plus extérieur.
Les dernières lignes envoient ton oignon et affichent ce que chaque relais a vu. Les tests utilisent de nouveaux relais, graines et messages.

Tu as repéré un problème dans cette leçon ? Signale-le · Pose une question sur cette leçon

Cet exercice s'ouvre bientôt

Termine la leçon précédente pour débloquer celle-ci. Tout le cours est gratuit, aucun compte n'est requis, et tu peux lire cette leçon dès maintenant.