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
| Relay | Weißt du, wer du bist (deine IP-Adresse)? | Weißt du, wohin du gehst? |
|---|---|---|
| Guard (zuerst) | Ja | Nein, nur das mittlere Relais |
| Middle | Nein, nur der Wächter | Nein, nur der Ausgang |
| Beenden (letzte) | Nein, nur das mittlere Relais | Ja, 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 runlock 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.
Verwende die fiktiven Relais aus watched.leg7b_onion. Schreibe zwei Funktionen:
build_circuit(relays, rng): gib eine list[guard, middle, exit]zurück. Wähle den guard mitrng.choiceaus den relays, derenis_guardwahr ist; den exit aus den relays, derenis_exitwahr 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.wrap(message, destination, circuit): Sperre eine Schicht pro Relay. Der Text der Schicht des Wächters istmiddle name|..., die mittlere istexit name|...und die des Ausgangs istdestination|message. Sperre zuerst die Schicht des Ausgangs und zuletzt die des Wächters mitlock(relay.key, text)und gib den äußersten gesperrten Text zurück.
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.
Dieser Browser blockiert Cookies für learn.floati.life, daher können hier beendigte Lektionen nicht in der richtigen Reihenfolge geöffnet werden. Erlaube Cookies für diese Seite und lade sie neu.