Programma Lezione 140 di 156 · Reti di anonimato e analisi del traffico
Reti di anonimato e analisi del traffico

Onion routing

Perché è importante Quando usi Tor, i tuoi messaggi passano dai computer di tre sconosciuti. Sapere esattamente che cosa può vedere ciascuno di quei computer ti dice che cosa protegge Tor, e che cosa lascia scoperto. In questo laboratorio costruisci gli strati da solo, così l'idea smette di sembrare magia.

Immagina una lettera dentro tre buste, una dentro l'altra. Consegni il pacchetto a un primo corriere. Apre la busta esterna, trova solo il nome di un secondo corriere, e passa il resto. Il secondo corriere apre la busta successiva e trova il nome di un terzo. Solo il terzo corriere apre l'ultima busta e vede dove sta andando davvero la lettera.

Nessun corriere sa sia chi ha mandato la lettera sia dove arriva. Tutto il trucco è qui, e ha un nome.

Onion routing: inviare un messaggio avvolto in diversi strati di cifratura attraverso una catena di computer, dove ciascuno toglie esattamente uno strato. Come sbucciare una cipolla (onion, in inglese), da cui il nome.

Relay: un computer in una rete di onion routing che inoltra il traffico. I relay di Tor sono gestiti da volontari in tutto il mondo.

Circuito: la catena di relay che segue il tuo traffico, scelta dal tuo stesso dispositivo. In Tor un circuito di solito ha tre relay: una guardia, un intermedio e un'uscita.

Chi sa che cosa

RelaySa chi sei (il tuo indirizzo IP)?Sa dove stai andando?
Guardia (primo)SìNo, solo il relay intermedio
IntermedioNo, solo la guardiaNo, solo l'uscita
Uscita (ultimo)No, solo il relay intermedioSì, e può leggere il traffico a meno che il sito usi HTTPS

Il tuo dispositivo fa tutto l'imballaggio prima che qualcosa parta. Condivide una chiave segreta separata con ogni relay (nel vero Tor queste chiavi nascono da uno scambio di chiavi con ciascun relay, uno dopo l'altro). Poiché la guardia deve sbucciare per prima, il suo strato deve essere quello più esterno, quindi chiudi gli strati dall'interno verso l'esterno: prima lo strato dell'uscita, poi quello dell'intermedio, poi quello della guardia.

I relay del mondo di esercitazione

Il modulo watched.leg7b_onion ti dà dodici relay immaginari con nomi di alberi. Ognuno ha un name, una key (un numero intero) e dei flags. Un relay con is_guard impostato è considerato affidabile come primo salto; uno con is_exit impostato accetta di collegarsi ai siti web. Alcuni relay hanno entrambi i flag, altri nessuno.

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 è un giocattolo didattico che non è sicuro. Esiste solo per farti vedere gli strati che si aggiungono e si tolgono. Il vero Tor usa cifrari verificati.

Il testo di ogni strato ha la forma next hop|the rest: il nome del relay successivo, una barra verticale, poi gli strati interni ancora chiusi. Lo strato dell'uscita contiene l'host di destinazione invece del nome di un relay, e poi il messaggio stesso. La funzione di aiuto relay_views(onion, circuit, your_ip) manda la tua cipolla attraverso il circuito e riporta, per ogni relay, da dove è arrivato il traffico (came_from), a chi è stato passato (passed_to) e che cosa ha potuto leggere (read).

Un equivoco comune: "Tor cifra il mio traffico fino al sito web." Non è così. L'ultimo strato si toglie all'uscita, quindi l'uscita vede tutto ciò che invii a meno che il sito stesso usi HTTPS. Tor nasconde chi sta parlando; HTTPS nasconde che cosa viene detto. Ti servono entrambi.

In altri linguaggi

Il ciclo che avvolge gli strati è uguale in qualsiasi linguaggio: percorri il circuito all'indietro, aggiungendo uno strato ogni volta.

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

Riepilogo

  • L'onion routing avvolge un messaggio in uno strato per ogni relay; ogni relay ne sbuccia esattamente uno.
  • La guardia conosce te ma non la tua destinazione; l'uscita conosce la destinazione ma non te; l'intermedio non conosce nessuna delle due.
  • Chiudi gli strati dall'interno verso l'esterno: prima quello dell'uscita, per ultimo quello della guardia.
  • Tor nasconde chi sta parlando. Solo HTTPS nasconde all'uscita che cosa viene detto.
Tocca a te

Usa i relay immaginari di watched.leg7b_onion. Scrivi due funzioni:

  1. build_circuit(relays, rng): restituisci una lista [guard, middle, exit]. Scegli la guardia con rng.choice tra i relay il cui is_guard è vero; l'uscita tra i relay il cui is_exit è vero e che non sono la guardia; l'intermedio tra i relay che non sono né la guardia né l'uscita (qualunque siano i loro flag). Alcuni relay hanno entrambi i flag, quindi controlla che tutti e tre siano diversi.
  2. wrap(message, destination, circuit): chiudi uno strato per ogni relay. Il testo dello strato della guardia è middle name|..., quello dell'intermedio è exit name|..., e quello dell'uscita è destination|message. Chiudi per primo lo strato dell'uscita e per ultimo quello della guardia, usando lock(relay.key, text), e restituisci il testo chiuso più esterno.
Le ultime righe inviano la tua cipolla e stampano che cosa ha visto ogni relay. I test usano nuovi relay, semi e messaggi.

Hai notato un problema in questa lezione? Segnalalo · Chiedi qualcosa su questa lezione

Questo esercizio si apre presto

Finisci la lezione precedente e questa si sblocca. L'intero corso è gratuito, senza account, e puoi leggere questa lezione subito.