课程大纲 第 140 课,共 156 课 · 匿名网络与流量分析
匿名网络与流量分析

洋葱路由

为什么重要 当你使用 Tor 时,你的消息会经过三个陌生人的计算机。准确地知道每台计算机能看到什么,就能告诉你 Tor 保护了什么,又让什么暴露在外。在这个实验里,你亲手构建这些层,这样这个想法就不再神秘了。

想象一封信装在三个一层套一层的信封里。你把这一包交给第一位信使。他们拆开最外层的信封,只看到第二位信使的名字,然后把剩下的转交出去。第二位信使拆开下一个信封,看到第三位信使的名字。只有第三位信使拆开最后一个信封,看到这封信真正要去哪里。

没有任何一位信使同时知道谁寄了这封信,以及它最终到了哪里。这就是全部的诀窍,而它有一个名字。

洋葱路由:把一条消息包在好几层加密里,经过一串计算机发送,每台计算机恰好剥掉一层。就像剥洋葱一样,因此得名。

中继:洋葱路由网络中转发流量的一台计算机。Tor 的中继由世界各地的志愿者运营。

电路:你的流量所经过的那一串中继,由你自己的设备选择。在 Tor 里,一条电路通常有三个中继:一个守卫、一个中间中继和一个出口。

谁知道什么

中继知道你是谁(你的 IP 地址)吗?知道你要去哪里吗?
守卫(第一个)知道不知道,只知道中间中继
中间不知道,只知道守卫不知道,只知道出口
出口(最后一个)不知道,只知道中间中继知道,而且除非网站使用 HTTPS,它还能读到流量

你的设备在任何东西离开之前就完成了全部的包装。它和每个中继各共享一把单独的秘密密钥(在真正的 Tor 里,这些密钥来自与每个中继依次进行的密钥交换)。因为守卫必须最先剥开,它的那一层必须在最外面,所以你要由内向外地加锁:先锁出口的那一层,然后是中间的,最后是守卫的。

练习世界里的中继

模块 watched.leg7b_onion 给你十二个以树木命名的虚构中继。每个都有一个 name、一个 key(一个整数)和 flags。设置了 is_guard 的中继被信任可以作为第一跳;设置了 is_exit 的中继同意向外连接网站。有些中继两个标记都有,有些都没有。

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 是一个并不安全的教学玩具。它的存在只是为了让你能看着一层层被加上和去掉。真正的 Tor 使用经过审查的密码算法。

每一层的文本形式是 next hop|the rest:下一个中继的名字、一个竖线字符,然后是仍然锁着的内层。出口的那一层装的是目标主机,而不是中继名字,然后才是消息本身。辅助函数 relay_views(onion, circuit, your_ip) 会让你的洋葱经过这条电路,并为每个中继报告流量 came_from(从哪里来)、passed_to(传给了谁)以及它能 read(读到)什么。

一个常见的误解:“Tor 会一路加密我的流量,直到网站。”并不会。最后一层在出口处被剥掉,所以除非网站本身使用 HTTPS,出口能看到你发送的任何东西。Tor 隐藏的是谁在说话;HTTPS 隐藏的是说了什么。两者你都需要。

用其他语言实现

包装循环在任何语言里看起来都一样:倒着遍历电路,每次加上一层。

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

回顾

  • 洋葱路由为每个中继给消息包上一层;每个中继恰好剥掉一层。
  • 守卫知道你,但不知道你的目的地;出口知道目的地,但不知道你;中间中继两者都不知道。
  • 由内向外地加锁:先锁出口的,最后锁守卫的。
  • Tor 隐藏的是谁在说话。只有 HTTPS 才能对出口隐藏说了什么。
轮到你了

使用来自 watched.leg7b_onion 的虚构中继。编写两个函数:

  1. build_circuit(relays, rng):返回一个列表 [guard, middle, exit]。用 rng.choice 从 is_guard 为真的中继中挑出守卫;从 is_exit 为真、并且不是守卫的中继中挑出出口;从既不是守卫也不是出口的中继中(不管它们有什么标记)挑出中间中继。有些中继两个标记都有,所以要检查三者都不相同。
  2. wrap(message, destination, circuit):为每个中继锁上一层。守卫那一层的文本是 middle name|...,中间那一层是 exit name|...,出口那一层是 destination|message。先锁出口的那一层,最后锁守卫的,使用 lock(relay.key, text),并返回最外层加锁后的文本。
最后几行会发送你的洋葱,并打印每个中继看到了什么。测试会使用新的中继、种子和消息。

发现这节课有问题?报告它 · 就这节课提问

这个练习即将开放

完成它前面的那一课,这一课就会解锁。整门课程免费,无需账号,而且你现在就可以阅读这节课。