VPN 不是一个产品。它是两份活儿拼在一起,而你的机器上已经为每一份都准备好了一个程序。
第一份活儿是造出一条虚拟链路:一个看起来像网卡的接口,接收 IP 数据包,再把它们交到别处去。第二份活儿是把这条链路的字节从一端搬到另一端。买一台 VPN 设备,你买的就是这两份活儿外加一张钉在上面的许可证;自己动手的话,每份活儿都是一个已经装好的程序。在 Linux 上干第一份活儿有两种办法,本文两种都搭:pppd,它带来一整套链路协议,包括协商地址、存活检查和成帧;以及 tap 设备,它什么都不带,只是内核里的一个洞,你往里塞帧就行。它们是不同的取舍,不是竞争对手,本文后半部分会把它们并排放在一起比较。
那个协议就是 PPP,而这一切之所以行得通,写在它的第一段里:PPP 是用于点对点链路的链路协议1,它并不规定链路由什么构成。调制解调器加电话线是最初的答案,但从来不是唯一的答案。PPTP 把 PPP 放进 GRE2。L2TP 把它放进 UDP3。PPPoE 把它放进以太网帧。这些全都是同一个协议换了个信使,而且没有一个需要为此修改 PPP。
所以问题不在于你能不能把 PPP 跑在 TCP 或 UDP 套接字上,而在于选哪一个,以及代价是什么。简短的答案,推导过程附后:用 UDP。 把流协议跑在可靠的流里面,是这里唯一一个在你桌上看着没问题、一到真实链路就散架的错误。
VPN 是两份活儿,而这两样你都已经有了
把任何隧道的营销包装剥掉,都只发生三件事:某样东西提供一个虚拟接口,把数据包变成字节流;某样东西把这个流搬过一张本来就能用的网络;某样东西给它加密,或者什么都不加密。
PPP 把链路这一半干得很到位:地址协商、存活检查、报头压缩、一条链路上跑多种网络层协议,你想要的话还有一个认证步骤。这么多现成的活儿,就躺在 /usr/sbin 里什么也不干。它不干的是在乎载体:给它一个能双向搬运字节的文件描述符,它就在上面跑。netcat 这个程序存在的全部意义,就是充当那个文件描述符。
加密是没人会递给你的那一部分,本文大部分篇幅都花在把它挣来上,因为 netcat 对此没有答案,而假装它有,正是人们搭出本不该搭的东西的原因。
各个阶段,以及为什么按这个顺序
下面的一切都分阶段搭建,每个阶段在前一个的基础上加一样东西。这不是教学手法。这就是你应该采用的搭法,因为当第六阶段出问题时,你需要知道第二阶段是否还能用,而只有当第二阶段曾经是你单独跑过的东西时,你才知道这一点。
链路本身也是这样搭的,后文那个一秒钟逐步升级背后的道理也在于此:隧道先裸着起来,证明它能搬运一个帧,然后才开始玩花样。一下子把所有东西都打开的搭法会整块失败,而你得花一个晚上去猜是哪一层干的。
pppd 真正要的是一个文件描述符
pppd 是为串口写的,所以最天真的理解是它需要一个串口。并不是。它需要一个终端设备,而且会自己造一个:
pty script — Specifies that the command
scriptis to be used to communicate rather than a specific terminal device. Pppd will allocate itself a pseudo-tty master/slave pair and use the slave as its terminal device. The script will be run in a child process with the pseudo-tty master as its standard input and output.4
再读一遍,整个搭法都在里面了。pppd 造一个伪终端,自己留着从端,把主端作为标准输入和标准输出交给一个命令。那个命令拿这些字节干什么,不关 pppd 的事。在那里跑 nc,它们就进了套接字。
pty 指定的命令继承主端作为标准输入和标准输出。netcat 把标准输入复制到套接字,把套接字复制到标准输出,于是两个 pppd 实例通过 pty 对和网络互相对话,而它们谁都不知道有套接字存在。还有第二条路,notty,它改用 pppd 自己的标准输入和标准输出。但它会派生一个字符转运进程,每个字节都要从中经过,所以它“increases the latency and CPU overhead”4。除非你有理由不用,否则就用 pty。
在第一条命令之前,有三个实际情况,都在写这篇文章的机器上核实过,Fedora 44,ppp-2.5.1-7.fc44:
$ pppd --version
pppd version 2.5.1
$ ls -l /usr/bin/pppd /dev/ppp
-rwxr-xr-x. 1 root root 393784 Jan 17 2026 /usr/bin/pppd
crw-------. 1 root root 108, 0 Sep 14 08:34 /dev/ppp
$ pppd noauth nodetach pty 'true'
pppd: using the noauth option requires root privilege
它需要 root。 绕不过去。在 Fedora 上这个二进制文件没有 setuid,/dev/ppp 是 root 所有、权限 0600,而你需要的那些选项本来就是特权选项。这是你以 root 身份或者在 unit 文件里跑的东西,不是普通用户随手就干的事。这一点后面很重要,到时候我们会谈到它对你的出站策略意味着什么。
内核那一侧是模块化的。 ppp_generic 负责接口,ppp_async 负责 pty 需要的字节填充成帧,ppp_deflate/bsd_comp/ppp_mppe 负责压缩和加密;它们按需加载。如果一个精简过的容器镜像里缺了 ppp_async,链路能起来,却什么也不搬运。你要是不知道该往哪儿看,这就是痛苦的半个小时。
pty 上不存在调制解调器控制线。 没有载波检测引脚,pppd 就会一直等一个永远不会来的载波。解决办法是一个词,local,它让 pppd 忽略调制解调器控制线4。漏掉它就什么都不会发生,也没有任何值得一读的报错。
netcat 不是一个程序
搭建之前,先说最浪费时间的那个坑:“netcat”至少是四个参数互不兼容的程序,你拿到的是哪一个取决于你的发行版。在这台机器上,/usr/bin/nc 是指向 /usr/bin/ncat 的符号链接,也就是 Nmap 的重写版。所以从一个十五年前的 wiki 页面上抄来的命令会失败,而失败的原因跟 PPP 毫无关系。
| 实现 | 在端口上监听 | UDP | 对端断开后继续运行 |
|---|---|---|---|
| Ncat (Nmap) | ncat -l 443 | -u | -k / --keep-open |
| OpenBSD netcat | nc -l 443 | -u | -k |
| 传统 netcat | nc -l -p 443 | -u | 不支持 |
| GNU netcat | nc -l -p 443 | -u | 不支持 |
所以在你怪罪 pppd 之前,先查一下你手上的是哪一个:
readlink -f "$(command -v nc)"
nc --version 2>&1 | head -1 || nc -h 2>&1 | head -1
下面我会明确使用 ncat。它是内置 TLS 的那一个,这一点后面很重要,而写明了也意味着这些命令在你的机器上不会悄悄变成别的意思。
第一阶段:TCP 版本,因为每个人都先试这个
一端监听,一端连接。这里的地址来自文档专用地址段,所以直接粘贴进实验环境,不会伤到任何可路由的东西。端口自始至终都是 443,这是故意的: 几乎每张网络默认都放行出站 443。往下几个阶段把载体包进 TLS,上面的流量就和任何一个 HTTPS 会话无法区分。在那里绑定监听需要 root,而远端,也就是攻击者自己的机器或者一台中继,是有 root 的。整个出站论点就浓缩在一个端口号里,后面我还会回到这一点。
在监听端:
pppd nodetach noauth local passive \
nodefaultroute noipdefault \
192.0.2.1:192.0.2.2 \
lcp-echo-interval 10 lcp-echo-failure 3 \
mtu 1400 mru 1400 \
pty 'ncat --listen --keep-open 443'
在连接端:
pppd nodetach noauth local \
nodefaultroute noipdefault \
192.0.2.2:192.0.2.1 \
lcp-echo-interval 10 lcp-echo-failure 3 \
mtu 1400 mru 1400 \
pty 'ncat 198.51.100.10 443'
那里的每个词都在干活,而其中一个,noauth,正在悄悄造成破坏。这条隧道没有任何访问控制,后面有专门一节讲它。
noauth:它去掉了对端认证,所以监听端谁来都接受。nodefaultroute 和 noipdefault 防止链路悄悄改写你的路由,local 让它能在 pty 上起来,而钉死的 local:remote 地址对则防止 pppd 在 IPCP 期间接受一个不同的答案。连接端是同一行,只是没有 passive。把两端都拉起来,你就在每一端都得到一个 ppp0、一条到远端地址的点对点路由,以及一个你能 ping、能走路由、能 tcpdump 的接口。这就是一个 VPN:没装任何软件包,没配置任何守护进程,没交换任何密钥。这正是问题所在,后面我还会回到这一点。
它协商了什么,以及怎么观察
加上 debug,pppd 就会记录控制协议的交换过程,哪怕你以后再也不读,也值得读一次。链路分阶段建立,每个阶段都可能单独失败。
两个有用的调试工具早就装好了,却没人用:
# log every frame in both directions to a file
pppd ... debug record /tmp/ppp-trace
# then read it back in a human-readable form
pppdump -h /tmp/ppp-trace | less
record 把每个字节写成带时间戳的抓包,pppdump 把它转成可读的形式4,再加上 tcpdump -ni ppp0,两边你都能看到:下面的成帧,和上面的数据包。
线路上的帧,以及为什么 0x7E 无处不在
串行线路上的 PPP,而在 pppd 看来 pty 就是串行线路,使用异步 HDLC 成帧。懂不懂它,决定了你是在调优还是在瞎猜。每一帧都以同一个字节开始和结束:“Each frame begins and ends with a Flag Sequence, which is the binary sequence 01111110 (hexadecimal 0x7e)”5。既然 0x7e 标记边界,它就不能出现在帧内部,所以它要被转义。转义字节 0x7d 本身也要转义,以及任何一端要求转义的其他字节。
转义规则是精确的:“Each Flag Sequence, Control Escape octet, and any octet which is flagged in the sending Async-Control-Character-Map (ACCM), is replaced by a two octet sequence consisting of the Control Escape octet followed by the original octet exclusive-or’d with hexadecimal 0x20”5。
最后那部分就是调优旋钮。ACCM 是 32 位,每位对应一个控制字符,1 表示“转义它”。要求全部转义的话,在字节实际上是随机的加密载荷上,大约每八个字节就有一个小于 0x20,白白多出约 12% 的开销。
现代的 pppd 在这里已经做对了。去读手册页,而不是读民间传说:
If no asyncmap option is given, the default is zero, so pppd will ask the peer not to escape any control characters.4
所以 asyncmap 0 是默认值,不是什么窍门,而套接字是一条干净的 8 位路径,除了那两个强制转义的字节之外什么都不用转义。别动它;只有当中间确实有东西吞掉控制字符时才去设置这些位,比如终端服务器、串口集中器、一个糟糕的控制台代理。末尾的帧校验序列是一个 16 位 CRC,正是它让 UDP 版本行得通,那是下一节的内容。
TCP 套 TCP 是错误的载体
上面的搭法能用。在实验台上,走环回或者一张安静的局域网,它用起来非常漂亮,而这正是人们把它交付出去的原因。
然后它遇上一条有真实丢包的真实路径。它倒下的方式看起来像任何东西,唯独不像它本来的样子。
问题在于两个彼此独立的重传定时器叠在一起,外层把丢包藏起来不让内层看见。Olaf Titz 写过权威的解释,开篇讲的恰恰就是这种搭法:
A frequently occurring idea for IP tunneling applications is to run a protocol like PPP, which encapsulates IP packets in a format suited for a stream transport (like a modem line), over a TCP-based connection. […] Unfortunately, it doesn’t work well. Long delays and frequent connection aborts are to be expected.6
形状是这样的。两个 TCP 都根据各自的往返时间设定重传定时器。载体丢了一个分段就重传,所以内层连接的数据迟到了。而看不见载体的内层 TCP 把迟到理解为拥塞,也开始重传。于是载体要在一条本来就在丢包的链路上,同时送达原始数据和一份副本。内层定时器翻倍,外层队列增长,吞吐量远在链路崩溃之前就先崩溃了。日志里没有任何东西告诉你为什么。
这不是什么微妙的效率问题。一条隧道是平稳降级,还是在大约 2% 丢包时就不再转发流量、而同一路径上的 ping 看起来依然正常,区别就在这里。这就是用 UDP 的理由,而 TCP 只留给那种别的什么都过不去的路径。
所以用 UDP,把它当默认值,而不是偏好。
第二阶段:UDP 版本,这才是地基
同样的 pppd,不同的载体。唯一的改动在 pty 命令里。
监听端:
pppd nodetach noauth local passive \
nodefaultroute noipdefault \
192.0.2.1:192.0.2.2 \
lcp-echo-interval 10 lcp-echo-failure 3 \
mtu 1400 mru 1400 \
pty 'ncat --udp --listen 198.51.100.10 443'
连接端:
pppd nodetach noauth local \
nodefaultroute noipdefault \
192.0.2.2:192.0.2.1 \
lcp-echo-interval 10 lcp-echo-failure 3 \
mtu 1400 mru 1400 \
pty 'ncat --udp 198.51.100.10 443'
关于 UDP 监听端,有两件事会让你栽跟头,而且都不是 PPP 的问题。
监听端在被搭话之前无法应答。 UDP 套接字没有可以接受的连接,所以在数据报到达之前,netcat 不知道该把回复发到哪里。它会锁定第一个听到的源地址和端口,然后跟它对话。这意味着连接端必须先发,而 pppd 会自己做到这一点,因为非被动的那一端会立刻开始发送 LCP 配置请求。这也意味着,如果客户端的源端口变了,载体就会悄悄地跟错误的地方对话。在 UDP 超时很短的 NAT 后面,这就是一条每隔几分钟就莫名其妙死掉的隧道。
--keep-open 在 UDP 上并不做你想要的事。 Ncat 的 -k 让 TCP 监听端在对端离开后继续接受连接。UDP 上没有什么可接受的,所以恢复就意味着重启载体,而这正是下文 persist 和 holdoff 的用途。
这两点都是改用 socat 的理由,它处理 UDP 对端更小心;也是用一个守护管理器的理由,而不是指望它自己一直活着。
为什么 PPP 能扛过一个丢失的数据报
对 UDP 载体最显而易见的反对意见是:PPP 期待的是字节流,而 UDP 不是:数据报要么完整到达,要么根本不到,而且可能乱序到达。可它照样能用,靠的是成帧一直都带着的两个字节。
异步 HDLC 上的 PPP 本来就是为一条会损坏字节的线路设计的。每一帧都带一个 16 位的帧校验序列;校验失败的帧被丢弃,下一个标志字节让接收端重新同步。乱序比丢包少见,结果也一样:FCS 错误,帧被丢弃,重新同步。
所以丢一个数据报只损失一个 PPP 帧,也就是一个 IP 数据包,这是有史以来每一张网络的常态。数据包的主人去重传,拥塞控制看到一次真实的丢包并正确应对。这就是支持 UDP 的全部论据:它让隧道里的流量能知道路径的真相。
不过,别让帧大到需要载体去分片。那样的话,丢一个分片就毁掉整个数据报,你的有效丢包率会成倍增长。让 PPP 的 MTU 远低于路径 MTU。
地址、路由,以及把 IPv6 做对
ppp0 是一个点对点接口,没有子网,没有 ARP,所以 local:remote 就是寻址的全部,你要明确地让路由走过它。一台主机要访问远端后面的一张网络:
# on the client, after the link is up
ip route add 203.0.113.0/24 via 192.0.2.1 dev ppp0
要让远端替客户端转发,照例两步:
sysctl -w net.ipv4.ip_forward=1
nft add rule inet nat postrouting oifname "eth0" ip saddr 192.0.2.2/32 masquerade
proxyarp 会让服务器在自己的网段上替客户端应答 ARP4,这挺巧妙,直到第二个客户端也想要同样的待遇。然后去做大多数人跳过的那部分。在上面跑 IPv6:一条没有 NAT、没有广播域、没有地址稀缺的点对点链路,是你网络里最容易把 IPv6 做对的地方:
pppd nodetach noauth local \
+ipv6 ipv6 ::1,::2 \
nodefaultroute noipdefault \
192.0.2.2:192.0.2.1 \
pty 'ncat --udp 198.51.100.10 443'
+ipv6 启用 IPV6CP;ipv6 <local>,<remote> 设定两个 64 位的接口标识符4,链路以链路本地地址起来,然后你在上面加一个全局 /647。IPV6CP 独立于 IPCP8,所以用 noip 就只搬运 IPv6,一个词就搭出一个在 2026 年很合理的东西。
载体悄无声息地死掉时如何保持在线
这是最浪费一个下午的故障,所以它有自己的一节。
一个死得很难看的 TCP 载体,比如远端断了电、NAT 表项过期了、某个中间设备不再转发,并不会关闭。没有 FIN,没有 RST,什么都没有。netcat 守着一个再也不会送来一个字节的套接字,pppd 守着一个再也看不到一帧的 pty,而 ip link 还兴高采烈地报告 ppp0 处于 UP 状态。UDP 载体根本没有连接状态,所以它什么都察觉不到。
PPP 内置了答案,而且默认是关着的:
lcp-echo-interval 10 lcp-echo-failure 3
这会每十秒发一次 LCP echo,连续三次没有回应就拆掉链路4。三十秒就能逮住一个死掉的载体,而适用的恰恰是手册页点名的那种情况,“no hardware modem control lines”4,也就是史上每一个 pty。然后决定之后会发生什么:
persist maxfail 0 holdoff 5
lcp-echo-interval 10 lcp-echo-failure 3 是探测器:每十秒一次 echo,错过三次就断开链路。persist maxfail 0 holdoff 5 是重建:重启,永不放弃,等五秒,免得一条时断时续的路径变成 fork 炸弹。pppd 会重新运行 pty 命令,所以一个新的 netcat 和新的套接字也随之而来。两端都要设置 echo;一个守护管理器,也就是带 Restart=always 的 systemd unit,胜过两个进程互相扯皮。把 ip route 放进 /etc/ppp/ip-up.d/,这样路由会随链路一起回来。它没有加密,也没有认证
上面的一切是一条能用的隧道。它不是一条安全的隧道,而这个差距不是细节。
没有加密。 不是加密很弱。是根本没有。你送进去的每个数据包都以明文躺在线路上,包在一个任何抓包工具一眼就能解码的 HDLC 帧里。tcpdump 给你看别人隧道里的内容,跟看你自己的一样轻松。
没有对端认证。 noauth 说得明明白白。netcat 监听端接受到达那个端口的任何东西:来自任何地方的第一个连接或数据报。谁先到,谁就拿到一条通进你网络的、可路由的链路。PPP 确实有认证(明文的 PAP,以及质询-应答式的 CHAP9),但两者都只证明对端是谁,之后的内容一个字节都不加密:在这里用 CHAP,你得到的是一条知道自己在跟谁说话、却仍然把内容公开给路径上任何人的隧道。
PPP 家族里确实有一个加密选项,MPPE10,就是躺在 ppp_mppe.ko 里的那个模块。别去碰它:它是用 MS-CHAPv2 交换派生密钥的 RC4,公开被攻破已经十多年了,也是 PPTP 已死的原因。2026 年还在它上面搭新隧道,就是放着一个零成本的可用密码不用,偏选一个已知被攻破的。
所以到目前为止,老实的总结是:一条既无机密性、也无访问控制的可路由链路。 在实验环境里没问题,在一条本来就加密的链路里面没问题,在其他任何地方都不行。解决办法是给载体加密,这是接下来两节的内容,也是用 ncat 而不是你的发行版随便带的哪个 netcat 的原因。
第三阶段:把载体包进 TLS
干净的答案是让 pppd 原封不动,把载体换成一个能做 TLS 的。pppd 永远不会知道有什么变了。
先是证书。只要客户端会校验,自签名证书就够了。一个不做校验的 TLS 会话,就是跟一个你没有识别过身份的人进行加密对话,这拦不住任何人:
openssl req -x509 -newkey rsa:4096 -days 825 -nodes \
-keyout tunnel.key -out tunnel.crt \
-subj "/CN=tunnel.example.net" \
-addext "subjectAltName=DNS:tunnel.example.net"
Ncat
Ncat 内置了 TLS。它还能通过代理串接,--proxy host:port --proxy-type http|socks4|socks511,所以载体可以终结在一台中继上,而不是隧道的远端。出站那一节的论点就落在这一点上。监听端:
pppd nodetach noauth local passive \
nodefaultroute noipdefault 192.0.2.1:192.0.2.2 \
lcp-echo-interval 10 lcp-echo-failure 3 mtu 1400 mru 1400 \
pty 'ncat --listen --keep-open --ssl --ssl-cert tunnel.crt --ssl-key tunnel.key 443'
连接端:
pppd nodetach noauth local \
nodefaultroute noipdefault 192.0.2.2:192.0.2.1 \
lcp-echo-interval 10 lcp-echo-failure 3 mtu 1400 mru 1400 \
pty 'ncat --ssl --ssl-verify --ssl-trustfile tunnel.crt tunnel.example.net 443'
--ssl-verify 才是关键的那个词。 没有它,--ssl 只能防住被动监听者,对先应答那个端口的人毫无防备;有了它,Ncat 会对照信任文件校验信任链和域名12。不过 Ncat 在服务器端不检查客户端证书,所以服务器无法识别客户端。把它和 CHAP 搭配使用,或者用接下来两个中的一个。
Stunnel
传统的包装器,也是能把双向认证做对的那一个:
[ppp]
accept = 443
connect = 127.0.0.1:6001
cert = /etc/stunnel/tunnel.crt
key = /etc/stunnel/tunnel.key
CAfile = /etc/stunnel/clients.crt
verify = 2
verify = 2 要求客户端证书由 CAfile 里的某个 CA 签发,这正是 netcat 版本从来没有的访问控制。客户端以客户端模式运行 stunnel,pppd 的 pty 命令连接本地的明文一侧。
Socat
socat 每端一个进程就能搞定整件事,而且默认开启校验:
# listening end
pppd ... pty 'socat - OPENSSL-LISTEN:443,reuseaddr,cert=tunnel.pem,cafile=clients.crt,verify=1'
# connecting end
pppd ... pty 'socat - OPENSSL:tunnel.example.net:443,cafile=tunnel.crt,verify=1'
写这篇文章的机器上没装 socat,所以那段来自它的文档,请核对你自己的参数。它是我会首选的那个,因为它是四个里唯一也会说 DTLS 的。
Openssl,在别的什么都没有的时候
只要一台机器有 TLS,就有 openssl,而 s_server/s_client 能搬运一条管道:
# listening end
pppd ... pty 'openssl s_server -quiet -accept 443 -cert tunnel.crt -key tunnel.key'
# connecting end
pppd ... pty 'openssl s_client -quiet -verify_return_error -CAfile tunnel.crt -connect tunnel.example.net:443'
-quiet 压掉那条否则会落进你 PPP 字节流里的横幅,-verify_return_error 让校验失败时关闭连接,而不是警告一声然后继续。这些是调试工具,表现也像调试工具,但在一台你什么都装不了的机器上,它们能把链路拉起来。
第四阶段:DTLS,因为载体仍然应该是 UDP
尴尬的部分来了,这也是这一节单独成节的原因。上面每一个 TLS 选项都跑在 TCP 上,所以把载体包进 TLS 就推翻了支持 UDP 的论据,又把崩溃还给了你。加密和正确的传输不应该是二选一。DTLS 就是数据报上的 TLS,它才是你想要的:它保留记录层的保护,去掉有序和重传的保证,让丢掉的包就那么丢掉,而这正是 PPP 的帧校验序列被设计来消化的东西。
Ncat 做不到。socat 和 openssl 可以:
# listening end
pppd ... pty 'socat - OPENSSL-DTLS-LISTEN:443,cert=tunnel.pem,cafile=clients.crt,verify=1'
# connecting end
pppd ... pty 'socat - OPENSSL-DTLS-CLIENT:tunnel.example.net:443,cafile=tunnel.crt,verify=1'
只用 openssl 的话,-dtls 选择任意一个 DTLS 版本:
# listening end
pppd ... pty 'openssl s_server -quiet -dtls -accept 443 -cert tunnel.crt -key tunnel.key'
# connecting end
pppd ... pty 'openssl s_client -quiet -dtls -verify_return_error -CAfile tunnel.crt -connect tunnel.example.net:443'
注意帧的大小。DTLS 记录不能像 TLS 记录分散在 TCP 流上那样被分片,所以一切都必须一次性装进路径 MTU。
调优 PPP 版本:MTU、压缩,以及真正有用的东西
四个旋钮,都是 pppd 选项。下一节的 tap 版本一个都没有,因为它根本没有这些旋钮所配置的那套机制。
novj 关掉 Van Jacobson 报头压缩。它省下的只是个零头,每个包都要花 CPU,一丢包就出错。把 deflate/bsdcomp 关掉:载荷已经加密了,跨越安全边界做压缩是一种攻击,不是一项功能。这些都不会让隧道变快,而原因很重要,因为 PPP 常为此背锅,其实不该。PPP 不是瓶颈。 PPPoE 在同一个守护进程上能跑 2 Gbit,因为它的数据路径从不离开内核:ppp_generic 和 pppoe 负责成帧和转发,pppd 只处理控制平面。在这里让你付出代价的是 pty:每个字节都要跨进用户空间,经过 netcat,进入套接字再回来,这是 PPPoE 从来不走的一趟往返。这笔账算在伪终端头上,不算在 PPP 头上。
这正好是看看另一种做法的时候,那种做法根本没有 pty。
另一种做法:tap 设备,完全不用 PPP
到目前为止,链路那一半一直用的是 PPP。造一个虚拟接口还有第二种办法,而且它根本不需要协议。
内核的 TUN/TAP 驱动给你一个接口和一个绑在一起的文件描述符:往描述符里写一个数据包,它就出现在接口上,就像从线缆上来的一样;从里面读,你就得到一个内核想要发出去的数据包。这就是全部的接口13,它从 1999 年起就在 Linux 里了。
ip tuntap add dev tap0 mode tap user damien group damien
ip link set tap0 mtu 1400 up
ip addr add 192.0.2.1/30 dev tap0
第一条命令里有两个细节,比看上去更有分量。
user damien 让设备持久化且无需特权。 这样创建的设备会比使用它的进程活得更久,指定的用户不是 root 也能打开它。root 只创建一次设备;铲运帧的那个东西完全不需要 root。在出站那一节之前,先记住这一点。
mode tun 是同一个驱动的另一半,也是大多数人真正想要的那一个。tun 搬运 IP 数据包,tap 搬运以太网帧。这个区别重要到下面专门有一节讲它。
跟 PPP 相比,你放弃的是 PPP 协商的一切:没有 LCP,所以没有商定的帧大小,也没有存活检查;没有 IPCP/IPV6CP,所以两端都要手工配置;没有认证;没有报头压缩。tap 设备是内核里的一个洞,从中穿过的协议是你放进去的任何东西。你得到的是完全没有成帧开销,没有转义,没有控制通道,以及一个可以桥接的接口。
UDP 上的 tap,一个数据报就是一个帧
这是全文最干净的映射,而且它是从设计里自然得出的。tap 设备是数据报设备,一次 read() 恰好返回一个帧;UDP 套接字是数据报套接字,一次 sendto() 对应一个数据报。所以一个帧放进一个数据报,到达时还是一个帧,没有任何东西需要分隔、缓冲或重新同步。丢一个数据报就丢一个帧,而丢包本来就是这个样子。
用 socat 的话,两端各一条命令:
# listening end
socat TUN:192.0.2.1/30,tun-type=tap,tun-name=tap0,iff-up UDP-LISTEN:443
# connecting end
socat TUN:192.0.2.2/30,tun-type=tap,tun-name=tap0,iff-up UDP:198.51.100.10:443
写这篇文章的机器上没装 socat,所以这两条来自它的文档,不是在这里跑出来的。在相信它们之前,请核对你自己那个版本的地址类型名称。它值得拥有:它是本文里唯一一个在一个进程里就能做 tun、tap、TLS 和 DTLS 的工具。
在你什么都装不了的地方,整件事大约五十行,除了标准库之外没有任何依赖。它的核心如下,其中 IFF_NO_PI 关掉驱动本来会加在前面的四字节报头:
TUNSETIFF, IFF_TAP, IFF_NO_PI = 0x400454CA, 0x0002, 0x1000 # IFF_TUN is 0x0001
def open_tap(name):
fd = os.open("/dev/net/tun", os.O_RDWR)
fcntl.ioctl(fd, TUNSETIFF, struct.pack("16sH", name.encode(), IFF_TAP | IFF_NO_PI))
return fd
# ... learn the peer from the first datagram (UDP has no accept), then shovel:
while True:
ready, _, _ = select.select([tap, sock], [], [])
if tap in ready and peer:
sock.sendto(os.read(tap, MTU), peer) # one read = one frame = one datagram
if sock in ready:
frame, src = sock.recvfrom(MTU)
peer = src # last speaker wins — see the note below
if frame:
os.write(tap, frame)
完整的文件,包括参数解析、通过 getaddrinfo 支持 IPv6、告诉 UDP 监听端该往哪儿应答的零长度数据报,以及下一节要加的压缩,都在这个页面包里:
每个数据报上的 peer = src 是要读两遍的那部分。谁最后发来一个帧,谁就成为对端。 在源端口不断变化的 NAT 后面,这很方便;在不可信的网络上,这就是一扇敞开的门,任何能往那个端口发一个数据报的人都能接管隧道。在 DTLS 会话里面没问题,而这正是它要去的地方;单独用就不行。脚本的套接字那一半在这里通过 IPv6 环回测试过:开场数据报到达,监听端认下对端,一个帧穿过去,应答回来;tap 那一半需要 root,是我唯一没能跑的部分。
TCP 上你得自己发明成帧
现在把载体换成 TCP,看一整个问题冒出来,而这个问题 PPP 早在 1994 年就悄悄解决了。
TCP 是一个没有记录边界的字节流,也不保证字节到达时如何分组:背靠背写入的两个帧,可能在一次读取里到达,一个帧也可能分三次到达。接收端手里是一堆字节,不知道一个帧在哪儿结束,而 tap 设备只接受完整的帧。
所以在 TCP 上你得自己写成帧。在每个帧前面加两个字节的大端序长度,是通常的做法:
# sending
sock.sendall(struct.pack("!H", len(frame)) + frame)
# receiving
def recv_exactly(sock, n):
buf = b""
while len(buf) < n:
chunk = sock.recv(n - len(buf))
if not chunk:
raise ConnectionError("carrier closed")
buf += chunk
return buf
length = struct.unpack("!H", recv_exactly(sock, 2))[0]
frame = recv_exactly(sock, length)
这能用,但它比 UDP 版本严格地更差。这又是 TCP 套 TCP 的问题;每个帧多出两个字节和一个重组循环;而且出错后没有退路,因为一个丢了位置的带长度前缀的流,会从某个帧的中间读出之后的每一个长度。HDLC 会在下一个 0x7E 上重新同步;这个做不到,除非你更糟糕地重新发明一遍 HDLC。支持 UDP 的第三个论据,也是最有力的一个: 在数据报载体上根本不存在成帧问题,因为载体已经具备你唯一需要的那个特性。
tun 还是 tap:除非真的需要第二层,否则用第三层
同一个驱动给你两种设备,而人们总是选错,因为某个教程说的是 tap。
| tun | tap | |
|---|---|---|
| 穿过的是什么 | IP 数据包 | 以太网帧 |
| 每包开销 | 无 | 14 字节以太网报头 |
| ARP、DHCP、广播 | 无 | 有,全都通过隧道 |
| 非 IP 协议 | 不支持 | 支持 |
| 能否加入网桥 | 不能 | 能 |
| 相当于 | 一条点对点链路,就像 ppp0 | 一根网线 |
tun 是一条路由链路,就像前半部分的 PPP 接口:两个地址,一条路由,数据包进进出出。tap 是一根虚拟的以太网线,所以网段上的每一个广播、每一次 ARP 查询、每一点组播噪声,现在都要穿过你的隧道,烧掉带宽。
改脚本里的一行就能切换:
IFF_TUN = 0x0001 # instead of IFF_TAP
当你真的需要第二层时才用 tap。确实有真正的理由:一个不是 IP 的协议,一个期待看到广播的集群心跳,一台必须穿过隧道触达客户端的 DHCP 服务器,或者把两个网段桥接成一个。
最后那个是常见情况,也是要小心的那个:
ip link add br0 type bridge
ip link set tap0 master br0
ip link set eth1 master br0
ip link set br0 up
现在远端网段成了你本地网段的一部分:它的广播、它的生成树、它的 MAC 地址变动,以及,如果有人粗心的话,它的 DHCP 服务器。把两个都在跑 192.168.1.0/24 的站点桥接起来,是一个糟糕的下午;桥出一个绕回同一网段的环路,是一个糟糕的星期。默认用 tun,当你能说出自己需要的那个第二层的东西时才去用 tap,并且只在查清楚两边都有什么在广播之后再去桥接。
同样的包装器,每端一个进程
tap 版本有和 PPP 版本一样的漏洞:载体是明文的,监听端谁先到就接受谁。解决办法也一样,而用 socat 的话它会缩成每端一条命令,因为它在一个进程里既创建设备又终结 DTLS 会话:
# listening end
socat TUN:192.0.2.1/30,tun-type=tap,tun-name=tap0,iff-up \
OPENSSL-DTLS-LISTEN:443,cert=tunnel.pem,cafile=clients.crt,verify=1
# connecting end
socat TUN:192.0.2.2/30,tun-type=tap,tun-name=tap0,iff-up \
OPENSSL-DTLS-CLIENT:tunnel.example.net:443,cafile=tunnel.crt,verify=1
这是本文里最短的正确搭法。一个虚拟接口,一个数据报载体,双向证书认证,加密。两条命令。没有守护进程,没有协议协商。
verify=1 不是可选的,道理和 --ssl-verify 一样,而且结合上面 peer = src 的行为,一个身份不明的人离占有你的隧道只差一个数据报。如果你只能用那个 Python 脚本,别往里面硬塞 TLS:让它指向一个环回端口,在前面放上包装器,或者用 socat。在手搓的隧道外面套一个手搓的 TLS 包装器,就是在最要紧的部分给自己两次犯错的机会。
第五阶段:用 zstd 压缩字节流
后端里还有一样东西值得放进去,而且跟 pppd 上的压缩选项不同,它真的能带来回报:在帧进入载体之前,用 zstd 压缩它们。
这里的关键词是帧,复数。压缩的是字节流,而不是单独压缩每一个数据包。 这是本文中测得的最大单项效果。
网络流量的重复性只在跨数据包时才显现:同样的报头、主机名和 JSON 键,一遍又一遍。一个在每个 1,400 字节的帧上都从头开始的压缩器,什么都看不到;一个跨帧保留窗口的压缩器,全都看得到。
在当前的 Fedora 上,这不需要安装任何东西:Python 3.14 把 zstd 带进了标准库14;这台机器是 3.14.7,配 zstd 1.5.7:
from compression.zstd import ZstdCompressor, ZstdDecompressor # Python 3.14+
_c, _d = ZstdCompressor(level=1), ZstdDecompressor()
# FLUSH_BLOCK: emit everything so far, keep the window for the next frame.
out = _c.compress(frame, mode=ZstdCompressor.FLUSH_BLOCK)
frame = _d.decompress(out)
每个方向一个压缩器,在链路的整个生命周期里都活着。每个帧一次 FLUSH_BLOCK,所以帧一到就立刻发出,什么都不缓冲,远端也是每个块交回一个帧。
窗口值多少,实测
数字来自这台机器。同样的 1,400 字节帧,同样的 1 级,唯一的区别是压缩器是否保留历史:
| 隧道里的流量 | 流式,FLUSH_BLOCK | 逐包,FLUSH_FRAME | 逐包,用训练过的字典 |
|---|---|---|---|
| 重复性的 API 调用和遥测 | 5.0% | 14.8% | 5.3% |
| 日志行 | 7.5% | 24.2% | 15.1% |
| 纯文本和配置文件 | 37.8% | 51.3% | 45.3% |
| 随机字节,代替 TLS | 100%+ | 100.7% | — |
1 级下的吞吐量,文本是 205 MB/s,重复性流量超过 1 GB/s。越可压缩就越快,因为要编码的东西更少。
日志流量压到原始大小的 7.5%,而逐包压缩是 24.2%:同样的数据,同样的级别,一个参数就差了三倍。而且 1 级就是该用的级别:3 级大约只多换来百分之一,9 级再多百分之一,吞吐量却从 211 MB/s 掉到 61。
代价,而且和这里的其他一切是同一个代价
共享窗口意味着每一帧都依赖它之前的帧:丢一个,解压器的历史就对不上了,之后什么都解不出来。所以流式压缩需要一个按顺序送达一切的载体:TCP,或者 TCP 上的 TLS,而不是 UDP 或 DTLS。这是全文里支持 TCP 载体的唯一一个诚实的论据。如果穿过你隧道的东西真的可压缩,比如 syslog、明文的数据库复制、遥测、一个话很多的 API,那么一个流式压缩的 TLS 会话搬运的字节只有数据报载体的三分之一,在一条像样的路径上,这可能胜过重传带来的惩罚。拿你自己的流量去测。
UDP 上,由字典来干窗口的活
当载体是 UDP 或 DTLS 时,而默认就应该如此,你无法保留窗口:每个数据报都是独立的,这意味着用 FLUSH_FRAME,以及上表中较弱的那一列。一个训练过的字典能给压缩器提供原本由窗口提供的跨包上下文,而数据报之间没有任何依赖15:
# capture a few thousand real frames off the link first, one per file
zstd --train frames/* -o tunnel.dict --maxdict=110000
from compression.zstd import ZstdCompressor, ZstdDecompressor, ZstdDict
d = ZstdDict(open("tunnel.dict", "rb").read())
_c = ZstdCompressor(level=1, zstd_dict=d) # load it ONCE, not per frame
out = _c.compress(frame, mode=ZstdCompressor.FLUSH_FRAME)
在重复性流量上,它把逐包压缩从 14.8% 降到 5.3%,在保持容忍丢包的同时,追回了与完整流式压缩之间差距的 96%;日志行上追回 55%,一般文本上追回 44%。
随之而来有三条规矩。两端必须加载同一个字典,否则什么都解不出来,这在这里验证过:没有字典,一个用字典压缩的帧会抛出 ZstdError。用真实流量的抓包来训练,因为字典是一个先验,错的先验会让你吃亏:文本字典让另一种文本略微变差了。还有,把它一次性加载进一个长期存活的压缩器;每次调用都传一遍字典,实测 5 MB/s,这不是笔误。
报头字节,以及一秒钟逐步升级
两个让它不再脆弱的小东西。
每个数据报都带一个单字节报头,它说明的是模式,而不仅仅是“已压缩”:0x00 表示原样的帧,0x01 表示一个自包含的 zstd 帧,0x02 表示来自一个持续流的块。这样接收端就能解码远端选择的任何东西,而不需要被配置成与之匹配,光凭这一点这个字节就值了。
在帧模式下,发送端只在压缩后确实更小时才发送压缩形式,因为压缩并不总是划算:随机字节压出来是 100.7%,一个 64 字节的 TCP ACK 压缩后是 73 字节,也就是一个没东西可挤的包上多了十字节的 zstd 报头。真实链路上的数据包数量以小包为主,所以没有这个检查,你就会为了缩小少数流量而把大多数流量撑大。在流模式下它总是发送压缩形式,因为跳过一次就会让两个窗口错位。
而且链路一开始是裸的: 头一秒钟里每个帧都不压缩就发出去,不管设置怎么说,两个方向各自独立地逐步升级:
RAMP = 1.0 # seconds of raw frames before compression starts
def pack(self, frame):
if self.c is None or time.monotonic() - self.started < RAMP:
return RAW + frame
out = self.c.compress(frame, mode=ZstdCompressor.FLUSH_BLOCK)
return ZSTD + out if len(out) < len(frame) else RAW + frame
这就是文章开头那个分阶段的思路,应用到了单条链路上。隧道先走它最简单的路径起来,证明它能搬运一个帧,然后才开始干任何花哨的事。它出问题时,你知道是在哪一秒出的。
第六阶段:压缩加加密,以及顺序的代价
顺序很重要,而且只有一种行得通:先压缩,再加密。密文压缩不了,100.7% 那一行就说明了这一点,这也是 TLS 1.3 去掉了它自己的压缩的原因,只剩下你这一层能做这件事。这个顺序有一个已知的问题,就是我之前用来反对 deflate 的那一个:先压缩后加密会通过密文长度泄露明文,而在攻击者能把自选数据和秘密一起注入并观察大小的地方,这种泄露不止一次成为可行的攻击:针对 TLS 的 CRIME 和 BREACH16,以及恰恰针对这种形态的 VORACLE17。
这不是永远不压缩的理由。这是要你知道自己处于哪种情况的理由:
- 一条在你自己拥有的两台机器之间搬运你自己流量的链路,比如复制、备份、日志、遥测,没有攻击者自选的明文和秘密同行。压缩它,而且压缩字节流。
- 一条搬运任意用户浏览流量的链路,别人的网页内容和你的凭据走在一起,这正是 VORACLE 所写的情况。别开压缩。
我之所以放心把它放进 tap 版本而不是 PPP 版本,原因不在原则:在这里你是有意选择一个现代算法,用于你看过的流量;而 pppd 的 deflate 默认用一个 1996 年的算法压缩一切,不管情况合不合适。
tap 版本得到了什么,又放弃了什么
把两半并排放在一起,因为它们不是在竞争。它们是不同的取舍。
| 套接字上的 pppd | 套接字上的 tap 或 tun | |
|---|---|---|
| 成帧 | 内置(HDLC,受损后能重新同步) | UDP 上没有,因为不需要;TCP 上要自己发明 |
| 地址设置 | 由 IPCP 和 IPV6CP 协商 | 两端手工配置 |
| 存活检测 | LCP echo,内置 | 没有;你自己加,否则链路悄无声息地死掉 |
| 认证 | 有 PAP 或 CHAP,都很弱 | 完全没有 |
| 层 | 只有第 3 层 | tun 是第 3 层,tap 是第 2 层 |
| 桥接 | 不能 | 能,用 tap |
| 开销 | 每帧有标志、报头和 FCS,外加转义 | 没有,tap 是 14 字节 |
| 压缩 | deflate 和 BSD,默认开启,1996 年的东西 | 没有,或者你自己加上并掌控的逐帧 zstd |
| 是否需要 root | 需要,自始至终 | 创建设备时需要;使用时不需要 |
| 活动部件 | 一个守护进程,三十岁了 | 一个文件描述符 |
PPP 给你一条经过协商、能自我监控的链路,代价是一个协议。tap 设备白送你一个裸洞,缺的部分你自己补上,或者不要。对于一条一直跑着的隧道,缺少存活检测才是会咬人的那个:pppd 三十秒内就能发现死掉的载体并重建它,tap 版本什么都发现不了,因为它里面没有任何东西在盯着。加一个保活,让它跑在会重启它的东西下面,或者用那个已经自带保活的版本。
什么时候它是合适的工具,什么时候不是
它从来都不是真正合适的工具,我不打算假装不是这样。上面的一切都能用,而其中没有一样是你该在生产环境里跑的。一份诚实的教程要包括你把工具放下的那一部分,而这就是那一部分。
它真正擅长的,是让你看清一个东西是怎么工作的。一个被拆成零件的 VPN,以及在下一节里,一旦有人带着 root 进了你的网络,出站流量实际上会怎样表现。这些才是读这篇文章的理由。下面那些狭窄的用例是真的,但它们不是这篇文章存在的原因。
以下情况用 PPP 版本:
- 载体根本不是 IP:串口控制台、USB gadget、无线电链路、命名管道、SSH 通道。
pppd不在乎字节在什么上面走,而 tap 设备在这里帮不了你。 - 你在抢救什么东西:一台有串口控制台、没有网络、今晚必须把活干完的机器。在那个控制台上跑 PPP 就是一条可路由的链路,两端都已经装好,什么都不用拷过去。
- 你想让链路自己照顾自己。LCP echo、地址协商和重启都是免费的;自己去写这些,就是 tap 版本变成一个不可靠的小产品的过程。
以下情况用 tap 版本:
- 你需要第二层:一个非 IP 协议,一个想要广播的集群心跳,穿过隧道的 DHCP,或者必须合为一体的两个网段。
- 你想要最少的活动部件:UDP 加 DTLS 就是两条命令,没有守护进程,没有协商,没有要转义的东西。
- root 很稀缺。用
user创建一次设备,搬运帧的进程就再也不需要特权。
在你学习的时候,两者都是合适的工具。 每一层都看得见,都能单独替换,要理解一个 VPN 产品在干什么,没有比用零件搭一个、看着每个零件依次起来更好的办法了。
当你想要一个 VPN 时,两者都不是合适的工具。 那种时候,用 WireGuard。它在内核里,代码量只是零头,它把密码学做得很到位,没有要协商的东西,也没有能出错的东西,而且它从设计上就是一个数据报协议。ssh -w 一条命令就能在已有的 SSH 会话上给你一个 tun 设备,而 OpenVPN 是上面那种 tap 加 DTLS 形态的成熟、经过审计的版本。这三个干这件事都比这里搭的任何东西强。
搭这些东西,是因为你想知道自己买的那个东西里面是什么。不是因为它很巧妙。
这真正揭示的是什么:从攻击者一方看出站
这就是去读一篇刚被告知别用的搭建文章的理由。把它掉过来,从你自己网络的内部看,以一个刚带着 root 落脚在那里的人的身份。每一次真正的入侵最终都会走到那一步,通过一把被盗的密钥、一次容器逃逸、一个没打补丁的服务、一个内部人员。接下来决定这一天会有多糟的问题,不是“他们能运行什么”,因为他们什么都能运行。而是**“什么能出去,以及你是否在他们到来之前就已经做出了决定。”**
如果出站默认开放,答案就是一切,而你现在能做的已经不多了。这里没有任何稀奇古怪的东西。pppd、ncat、socat 和 ip 都是已经在机器上的、经过签名的发行版软件包;tap 垫片是五十行标准库代码。一个被放行的出站端口,而且就是 443,每张网络默认都开的那个,就有了一条从你的网络通往别人网络的可路由链路:加密的、经过认证的、能扛过重启的、搬运 IPv4 和 IPv6 的,在你的边界上与你的用户每天发起上万次的任何 HTTPS 会话都无法区分。把它做成 tap 再桥接起来,那么离开大楼的就不是一条路由。是整个网段。
扫描器什么都抓不到:没有恶意软件特征,因为根本没有恶意软件;没有奇怪的协议,因为它就是一次到 443 的正常 TLS 握手;没有异常的二进制文件,因为每一个都是你自己的包管理器装的。代理记下一个连接和一个字节数,两者看起来都像是在干正事。
而且目的地甚至都不是固定的。套接字不必终结在数据包最终去往的地方,因为载体可以指向一个代理,一台中继,它不过是两个连接加一根管道,下一节用一行 shell 就把它搭出来。ncat 接受 --proxy 以及 --proxy-type http、socks4 或 socks5,所以你的边界看到的那个 TLS 会话,终结在攻击者让它经由连接的任何地方:一台内部跳板机,一个碰巧会转发 CONNECT 的被放行的 SaaS 端点,一台云中继;隧道再从那里继续通往一个你永远看不见的地方。HTTP CONNECT 和 SOCKS 在设计上就都会这么做,因为代理本来就是干这个的。所以,为一个你信任的目的地开一条放行规则,信任的永远不只是那个目的地,还有它会转发到的一切,而那些你既控制不了,也列举不出来。你防火墙日志上的那个端点是代理。它从来都不是远端。
所以那个令人不安的事实是:一旦有人带着 root 进来了,而出站又是宽松的,隧道就不是你能阻止的东西了。零件已经装好,出口是开着的,而且它甚至不通向它看起来通向的地方。你让这件事变难的唯一机会,是在攻击者到来之前,在边界上,决定什么可以出去。
这就是默认拒绝的出站策略,这也是全部的教训。出站默认封锁;一份简短的、有名有姓的放行清单,其中每个目的地和端口都由一个人说明过理由;其他一切都拒绝、记录并告警。不是因为它能把一个铁了心的攻击者当场拦住,一个被放行的目的地就是一条被放行的隧道,而是因为另一种选择是根本没有任何决定可以执行。一份写成“允许哪些端口”的出站策略,是一份关于端口号的策略。它从来不是一份关于什么能出去的策略,而一旦有人拿到了 root,它保护的就只剩端口号了。
这和 ping 那篇文章的发现一样,那篇用 ICMP echo 搭隧道;也和协议助手那篇文章一样,在那里是你的防火墙自己打开了洞。三条进路,一个结论:你以为自己掌握的控制是针对协议的,而这些协议没有一个是它自称的样子。在边界上、提前决定好的、默认拒绝的策略,是唯一一个从来都真正有效的控制。
代理就是两个连接加一根管道
值得看看一台中继有多简单,因为这解释了为什么你无法从近端推断远端。代理不是什么特殊软件。它就是一个连接通过一根管道接上另一个连接。最古老的形式用一个命名管道,也就是 FIFO,来搬运回程方向:一个 ncat 监听,另一个往前连接,FIFO 把两者之间的应答路径接起来。
mkfifo backpipe
ncat -l 7000 0<backpipe | ncat farend.example.net 7100 1>backpipe
把它当管道工程来读:监听端的输出流进第二个 ncat,再去往远端,应答则经由 FIFO 回到客户端。两个套接字,一根管道,双向,而客户端的连接终结在这里,在中继上,数据包则继续去往 farend 再回来。我在环回上原样跑过这个,远端放了第三个 ncat 做回显,发进去的一行字走完全程又回来了。
Ncat 在一个进程里就能干同样的事,为每个到来的客户端 exec 出往前的连接:
ncat -l 7000 --keep-open --sh-exec 'ncat farend.example.net 7100'
同样的形状,更少的零件:监听端的套接字与被 exec 出来的 ncat 的套接字,由 shell 在两者之间建立的管道连接起来。串起三台,隧道就跨过三张网络,在每一处终结再重新发起,每一跳的防火墙都记下一个整洁的、通往下一跳的本地连接,再往外什么都没有。
这就是全部的把戏,也是为什么边界日志不能证明目的地。在它前面那台机器所能分辨的范围内,每一台中继都是远端,而真正的另一端隔着不知多少根没人在盯的管道。
现在把这些中继放到不属于攻击者的机器上。
这条链上的每一个主人都只看到一个从上一跳到下一跳的连接:没有起点,没有终点,只有中间。这不是我递给谁的什么新点子。跳板链和 C2 网络二十年来就是这么运作的,这也是为什么一台被攻陷主机的出站流量常常通向另一个受害者,而不是攻击者。你的日志显示你跟某个数据中心里的一台机器说过话。是谁的机器,它又转发到哪里,从来都不在日志里。
防御上的分量就一句话:一个你没有提前限制的目的地,你既无法溯源,也无法信任。 等到流量往外走的时候,它去往的那个地址几乎告诉不了你什么,因为那是别人机器上的一台中继,真正的端点被洗白藏在它后面。
链路从来都不是产品
把它拆开之后,让我印象最深的是,其中新的东西少得可怜,被拿来卖的东西却多得惊人。
RFC 1661 是 1994 年的。pppd 在每个 Linux 发行版里待了三十年,内核模块是一个目录里的八个文件,而让一个 VPN 成为 VPN 的全部东西,一个虚拟接口、一条协商过的链路、一个加密的载体、一条路由,就是四个程序加一张证书。没有一样是难的或者保密的。他们把每一个字节都写成了文档,然后白白送了出来,而一个行业在你和它之间长了出来,把同样的四个零件装进盒子里卖,配上按席位计费的许可证和一份会到期的支持合同。零件并没有变得更好。只是被包装了。
这不是在主张把它跑在生产环境里。我刚刚才告诉过你别这么做。这是在主张你要知道自己买的盒子里装的是什么,因为等到厂商改了授权方式、被人收购、或者让你的型号停产的那一天,一个糟糕的季度和一个糟糕的年份之间的区别,就在于你那里有没有人知道这东西是用什么做的。
花一个晚上,用零件把隧道搭出来。看着 LCP 协商,弄断链路再看着它回来,拔掉证书看看什么会停下来。然后再读一遍你那家 VPN 厂商的产品说明书,看看其中有多少你认得出来。
同一个晚上也能换来另一半。如果一条通出你网络的可路由链路就是四个已安装的程序加一张证书,那么刚刚在你某台机器上拿到 root 的人,并不会因为隧道难搭而被拦住。它不难。拦住他们的,只有你在他们到来之前就决定好的、什么可以出去。搭一次,你就不会再把出站当作某个产品替你执行的东西,而会开始把它当作一个你要么做了、要么没做的决定。
其中没多少是魔法。大部分是刷了层漆的 1994 年,而 1994 年没什么不好。它能用,有文档,而且至今还在跑。
RFC 1661 — The Point-to-Point Protocol (PPP),1994 年。定义了链路、LCP,以及位于其上的网络控制协议族。 ↩︎
RFC 2637 — Point-to-Point Tunneling Protocol (PPTP),把 PPP 承载在 GRE 里。 ↩︎
RFC 3931 — Layer Two Tunneling Protocol version 3,那个把 PPP 承载在 UDP 里的协议在标准轨道上的后代。 ↩︎
pppd(8) — PPP 守护进程的手册页。
pty、notty、local、passive、noipdefault、proxyarp、record、receive-all、LCP echo 选项以及 asyncmap 默认值的出处:“If no asyncmap option is given, the default is zero, so pppd will ask the peer not to escape any control characters.” 文中引文读自 ppp 2.5.1 上的man pppd。 ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎RFC 1662 — PPP in HDLC-like Framing。标志序列、字节填充规则和异步控制字符映射:“Each frame begins and ends with a Flag Sequence, which is the binary sequence 01111110 (hexadecimal 0x7e).” ↩︎ ↩︎
Olaf Titz,Why TCP Over TCP Is A Bad Idea — 关于重传叠加的标准解释,开篇讲的正是这种搭法。原始 URL 已不再提供这篇文章;这是 Internet Archive 的存档。 ↩︎
RFC 5072 — IP Version 6 over PPP。IPV6CP 和 64 位接口标识符,独立于 IPCP。 ↩︎
RFC 1332 — The PPP Internet Protocol Control Protocol (IPCP),负责协商链路两端的 IPv4 地址。 ↩︎
RFC 1994 — PPP Challenge Handshake Authentication Protocol (CHAP)。证明对端身份;什么都不加密。 ↩︎
RFC 3079 — Deriving Keys for use with Microsoft Point-to-Point Encryption (MPPE)。由 MS-CHAP 交换派生密钥的 RC4 构造,也是 PPTP 不再是可选项的原因。 ↩︎
Ncat Users’ Guide — connecting through a proxy — 用于 HTTP CONNECT 和 SOCKS 4/5 的
--proxy与--proxy-type,于是 TLS 载体终结在代理上,而不是隧道的远端。 ↩︎Ncat Users’ Guide —
--ssl、--ssl-verify和--ssl-trustfile选项,以及监听模式和 UDP 模式。这里测试的版本:Ncat 7.92。 ↩︎Universal TUN/TAP device driver — 内核自己关于
/dev/net/tun、TUNSETIFF以及 tun 与 tap 区别的文档。 ↩︎PEP 784 — Adding Zstandard to the standard library,这就是为什么在 Python 3.14 上
compression.zstd不需要任何软件包。本文实测环境为 Python 3.14.7 和 zstd 1.5.7。 ↩︎RFC 7457 — Summarizing Known Attacks on TLS and DTLS,涵盖 CRIME,以及先压缩后加密导致长度泄露的一般形态。 ↩︎
OpenVPN — the VORACLE attack — 同样的泄露,针对先压缩后加密的 VPN,也是 OpenVPN 如今建议不要使用压缩的原因。 ↩︎