Lehrplan Lektion 140 von 156 · Anonymitätsnetzwerke und Verkehrsanalyse
Anonymitätsnetzwerke und Verkehrsanalyse

Zwiebelrouting

Warum das wichtig ist Wenn du Tor benutzt, gehen deine Nachrichten durch die Computer von drei Fremden. Zu wissen, was jeder dieser Computer genau sehen kann, zeigt dir, was Tor schützt und was es offen lässt. In diesem Lab baust du die Schichten selbst, also ist die Idee keine Magie mehr.

Stell dir einen Brief in drei Umschlägen vor, einer in dem anderen. Du gibst das Bündel einem ersten Kurier. Er öffnet den äußeren Umschlag, findet nur den Namen eines zweiten Kuriers und gibt den Rest weiter. Der zweite Kurier öffnet den nächsten Umschlag und findet den Namen eines dritten. Nur der dritte Kurier öffnet den letzten Umschlag und sieht, wohin der Brief wirklich geht.

Keiner der Kuriere weiß sowohl, wer den Brief geschickt hat, als auch, wo er landet. Das ist der ganze Trick, und er hat einen Namen.

Onion routing: das Senden einer Nachricht, die in mehrere Schichten von Verschlüsselung gehüllt ist, durch eine Kette von Computern, wobei jeder genau eine Schicht entfernt. Wie das Schälen einer Zwiebel, daher der Name.

Relay: ein Computer in einem Onion-Routing-Netzwerk, der den Datenverkehr weiterleitet. Die Relays von Tor werden von Freiwilligen auf der ganzen Welt betrieben.

Circuit: die Kette von Relays, die dein Traffic nimmt, ausgewählt von deinem eigenen Gerät. In Tor hat ein Circuit normalerweise drei Relays: ein Guard, ein Middle und ein Exit.

Wer weiß was

RelayWeißt du, wer du bist (deine IP-Adresse)?Weißt du, wohin du gehst?
Guard (zuerst)JaNein, nur das mittlere Relais
MiddleNein, nur der WächterNein, nur der Ausgang
Beenden (letzte)Nein, nur das mittlere RelaisJa, und es kann den Datenverkehr lesen, sofern die Seite kein HTTPS nutzt

Dein Gerät führt das gesamte Wrapping durch, bevor etwas das Gerät verlässt. Es teilt einen separaten geheimen Schlüssel mit jedem Relay (bei echtem Tor kommen diese Schlüssel nacheinander aus einem Schlüsselaustausch mit jedem Relay). Da der Guard zuerst abziehen muss, muss seine Schicht die outermost sein, also sperrst du die Schichten von innen nach außen: zuerst die Schicht des Exits, dann die der Mitte, dann die des Guards.

Die Relais der Praxiswelt

Das Modul watched.leg7b_onion gibt dir zwölf fiktive Relays, die nach Bäumen benannt sind. Jedes hat ein name, ein key (eine ganze Zahl) und flags. Ein Relay mit gesetztem is_guard wird als erster Hop vertraut; eines mit gesetztem is_exit stimmt zu, Verbindungen zu Websites aufzubauen. Einige Relays haben beide Flags, einige keine.

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 ist ein lehrmittel, das nicht sicher ist. Es existiert nur, damit du sehen kannst, wie Schichten hinzugefügt und entfernt werden. Echtes Tor verwendet geprüfte Chiffren.

Der Text jeder Schicht hat die Form next hop|the rest: der Name der nächsten Relay, ein Balkenzeichen, dann die noch gesperrten inneren Schichten. Die Schicht des Ausgangs enthält den Zielhost anstelle eines Relay-Namens, und dann die Nachricht selbst. Der Helfer relay_views(onion, circuit, your_ip) sendet deine Onion durch den Schaltkreis und berichtet für jedes Relay, wo der Traffic came_from, wo er passed_to wurde, und was er read konnte.

Ein häufiges Missverständnis: "Tor verschlüsselt meinen Datenverkehr bis zur Website." Das tut es nicht. Die letzte Schicht wird am Ausgang entfernt, also sieht der Exit alles, was du sendest, sofern die Seite selbst kein HTTPS nutzt. Tor verbirgt wer spricht; HTTPS verbirgt was gesagt wird. Du willst beides.

In anderen Sprachen

Die wrapping loop sieht in jeder Sprache gleich aus: gehe den Schaltkreis rückwärts ab und füge jedes Mal eine Schicht hinzu.

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

Zusammenfassung

  • Onion routing verpackt eine Nachricht in eine Schicht pro Relay; jedes Relay schält genau eine.
  • Der Wächter kennt dich, aber nicht dein Ziel; der Ausgang kennt das Ziel, aber nicht dich; die Mitte kennt keines von beiden.
  • Schließe Schichten von innen nach außen: der Ausgang zuerst, der Wächter zuletzt.
  • Tor verbirgt, wer spricht. Nur HTTPS verbirgt, was gesagt wird, vom Exit.
Du bist dran

Verwende die fiktiven Relais aus watched.leg7b_onion. Schreibe zwei Funktionen:

  1. build_circuit(relays, rng): gib eine list [guard, middle, exit] zurück. Wähle den guard mit rng.choice aus den relays, deren is_guard wahr ist; den exit aus den relays, deren is_exit wahr ist und die nicht der guard sind; die mitte aus den relays, die weder der guard noch der exit sind (egal was ihre flags sind). Einige relays tragen beide flags, also prüfe, dass alle drei unterschiedlich sind.
  2. wrap(message, destination, circuit): Sperre eine Schicht pro Relay. Der Text der Schicht des Wächters ist middle name|..., die mittlere ist exit name|... und die des Ausgangs ist destination|message. Sperre zuerst die Schicht des Ausgangs und zuletzt die des Wächters mit lock(relay.key, text) und gib den äußersten gesperrten Text zurück.
Die letzten Zeilen senden deine Zwiebel und drucken aus, was jedes Relais gesehen hat. Tests nutzen neue Relais, Seeds und Nachrichten.

Ein Problem in dieser Lektion entdeckt? Melde es · Frage zu dieser Lektion

Diese Übung öffnet bald

Beende die vorherige Lektion, damit diese freigeschaltet wird. Der ganze Kurs ist kostenlos, kein Konto erforderlich, und du kannst diese Lektion jetzt direkt lesen.