VPN 不是一个产品。它是两份活儿拼在一起,而你的机器上已经为每一份都准备好了一个程序。

第一份活儿是造出一条虚拟链路:一个看起来像网卡的接口,接收 IP 数据包,再把它们交到别处去。第二份活儿是把这条链路的字节从一端搬到另一端。买一台 VPN 设备,你买的就是这两份活儿外加一张钉在上面的许可证;自己动手的话,每份活儿都是一个已经装好的程序。在 Linux 上干第一份活儿有两种办法,本文两种都搭:pppd,它带来一整套链路协议,包括协商地址、存活检查和成帧;以及 tap 设备,它什么都不带,只是内核里的一个洞,你往里塞帧就行。它们是不同的取舍,不是竞争对手,本文后半部分会把它们并排放在一起比较。

那个协议就是 PPP,而这一切之所以行得通,写在它的第一段里:PPP 是用于点对点链路的链路协议1,它并不规定链路由什么构成。调制解调器加电话线是最初的答案,但从来不是唯一的答案。PPTP 把 PPP 放进 GRE2。L2TP 把它放进 UDP3。PPPoE 把它放进以太网帧。这些全都是同一个协议换了个信使,而且没有一个需要为此修改 PPP。

所以问题不在于你能不能把 PPP 跑在 TCP 或 UDP 套接字上,而在于选哪一个,以及代价是什么。简短的答案,推导过程附后:用 UDP。 把流协议跑在可靠的流里面,是这里唯一一个在你桌上看着没问题、一到真实链路就散架的错误。

VPN 是两份活儿,而这两样你都已经有了

把任何隧道的营销包装剥掉,都只发生三件事:某样东西提供一个虚拟接口,把数据包变成字节流;某样东西把这个流搬过一张本来就能用的网络;某样东西给它加密,或者什么都不加密。

每种隧道都是一个链路半边、一个载体,再加一些加密每次都是同样三个部分。变的只有载体和加密。隧道链路半边载体加密拨号 PPP,1994PPP调制解调器和电话线无PPPoEPPP以太网帧无PPTPPPPGREMPPE:已被攻破,别用IPsec 上的 L2TPPPPUDPIPsec本文,第一种搭法pty 上的 PPPUDP 套接字,经由 netcatDTLS本文,第二种搭法tun 或 tap 设备UDP 套接字,经由 socatDTLSWireGuard内核接口UDPNoise,而且无需协商
这张表上的每一种隧道都是同一个形状。区别只在于字节被放进哪个载体,以及有没有东西给它们加密。PPP 从 1994 年起就在干链路这一半,所以它出现在其中三种下面,却没有为任何一种重新设计过。tun 或 tap 设备干的是同一半,但完全不带协议,这就是本文的第二种搭法。

PPP 把链路这一半干得很到位:地址协商、存活检查、报头压缩、一条链路上跑多种网络层协议,你想要的话还有一个认证步骤。这么多现成的活儿,就躺在 /usr/sbin 里什么也不干。它不干的是在乎载体:给它一个能双向搬运字节的文件描述符,它就在上面跑。netcat 这个程序存在的全部意义,就是充当那个文件描述符。

加密是没人会递给你的那一部分,本文大部分篇幅都花在把它挣来上,因为 netcat 对此没有答案,而假装它有,正是人们搭出本不该搭的东西的原因。

各个阶段,以及为什么按这个顺序

下面的一切都分阶段搭建,每个阶段在前一个的基础上加一样东西。这不是教学手法。这就是你应该采用的搭法,因为当第六阶段出问题时,你需要知道第二阶段是否还能用,而只有当第二阶段曾经是你单独跑过的东西时,你才知道这一点。

六个阶段,每个只加一样你能单独测试的东西按这个顺序搭,你随时都能一级一级走回去1裸跑,走 TCPpppd 加 pty,或者一个 tap 设备,再加一个普通的 netcat 监听端。在工作台上能用。到真实路径上就崩:两个重传定时器在打架。2裸跑,走 UDP同一条链路,数据报载体。丢一个数据报就是丢一个包,别无其他。这是地基。上面的一切都是可选的;这个不是。3TLS,走 TCP用 ncat、stunnel 或 openssl 包住载体。两端都要验证证书,否则你有的是没有身份的加密,也根本没有访问控制。4DTLS,走 UDPsocat 或 openssl,这是要追求的形态:加密、认证,仍然是数据报。丢一个包仍然只是丢一个包,而不是两个协议栈为它争吵。5压缩在接口和载体之间做 zstd。载体按顺序送达时,就跨帧保留窗口;不按顺序时,就每个数据报一个自包含帧,再加一个字典。6两者都要,按这个顺序先压缩,再加密。绝不能反过来:密文压缩不了。并且要清楚代价:先压缩后加密会泄露明文长度。对你自己的流量来说没问题。
六个阶段,每个在下面那个的基础上加一样东西。裸跑 TCP 是每个人的起点,也是唯一一个死胡同:它在工作台上能用,到了真实路径上就崩。裸跑 UDP 是其余一切的地基。然后是加密,然后是压缩,然后两者一起。每个阶段都是一条你能拉起来、能 ping 通、能一直跑着的链路,所以当梯子顶端出问题时,你可以一级一级往下走回去。

链路本身也是这样搭的,后文那个一秒钟逐步升级背后的道理也在于此:隧道先裸着起来,证明它能搬运一个帧,然后才开始玩花样。一下子把所有东西都打开的搭法会整块失败,而你得花一个晚上去猜是哪一层干的。

pppd 真正要的是一个文件描述符

pppd 是为串口写的,所以最天真的理解是它需要一个串口。并不是。它需要一个终端设备,而且会自己造一个:

pty script — Specifies that the command script is 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,它们就进了套接字。

pppd、伪终端、netcat 和一个套接字一个数据包,从 ppp0 到 ppp0,以及它经过的每一双手主机 A主机 Bppp0内核接口pppdHDLC 成帧pty 对从端给 pppd主端给子进程ncat标准输入和标准输出pty 对主端给子进程从端给 pppdncat标准输入和标准输出pppdHDLC 成帧ppp0内核接口套接字:TCP 或 UDP中间这两个框是你唯一要选的部分。两侧的一切都不变,无论载体是电话线、串行控制台、TCP 流、UDP 数据报流还是 TLS 会话,所以以后换载体只需要改一个词。伪终端没有载波检测引脚,所以 pppd 会一直等一个永远不会来的载波。`local` 选项就是让它别等的那个。
pppd 把异步 HDLC 写进它自己分配的伪终端的从端。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 netcatnc -l 443-u-k
传统 netcatnc -l -p 443-u不支持
GNU netcatnc -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,正在悄悄造成破坏。这条隧道没有任何访问控制,后面有专门一节讲它。

pppd 这一行上的每个词,以及它的作用UDP 搭法的命令行,逐词解释nodetach前台运行,这样你能看到输出,也能把它交给守护管理器noauth不做对端认证:这就是漏洞,隧道没有任何访问控制local忽略 pty 没有的调制解调器控制线。没有它,什么都起不来passive等一个有效的 LCP 包,而不是退出:服务器套接字的行为nodefaultrouteIPCP 完成时不抢默认路由。你要的路由,自己加noipdefault不把本机自己的地址作为本端地址提供出去192.0.2.1:192.0.2.2local:remote,钉死:IPCP 期间 pppd 拒绝任何其他答案lcp-echo-interval / -failure存活检测:下面有专门一节mtu / mru 1400给载体包在每个帧外面的东西留出空间pty '...'这个命令的标准输入和标准输出就成为链路:这里是一个 netcat 套接字连接端是同一行,只是没有 `passive`:它主动发起,而不是等待。
这一行上的每个选项,以及它的作用。要盯住的是 noauth:它去掉了对端认证,所以监听端谁来都接受。nodefaultroute 和 noipdefault 防止链路悄悄改写你的路由,local 让它能在 pty 上起来,而钉死的 local:remote 地址对则防止 pppd 在 IPCP 期间接受一个不同的答案。连接端是同一行,只是没有 passive。

把两端都拉起来,你就在每一端都得到一个 ppp0、一条到远端地址的点对点路由,以及一个你能 ping、能走路由、能 tcpdump 的接口。这就是一个 VPN:没装任何软件包,没配置任何守护进程,没交换任何密钥。这正是问题所在,后面我还会回到这一点。

它协商了什么,以及怎么观察

加上 debug,pppd 就会记录控制协议的交换过程,哪怕你以后再也不读,也值得读一次。链路分阶段建立,每个阶段都可能单独失败。

先 LCP,再认证,然后每个地址族一个控制协议三个阶段,每个都因为自己的原因失败1LCP:链路本身最大接收单元、控制字符映射、一个用来发现环回线路的魔数,以及两端是否要求对方认证。在这里失败,说明载体没有在两个方向上干净地传递字节。去查套接字,而不是 PPP 选项。2认证:可选PAP 明文发送密码。CHAP 做一次质询和一个 MD5 响应。这里跳过了。两者都能证明对端是谁。两者都不加密后面的任何一个字节。3aIPCP每一端的IPv4 地址。3bIPV6CP64 位接口标识符。这两者彼此独立。IPv4 还在争论时,IPv6 就可以起来,一个失败也不会把另一个拖下水。某个地址族的控制协议一完成,接口就开始搬运该地址族的流量。
LCP 敲定链路本身:一帧最大能有多大,哪些控制字符需要转义,还有一个用来检测环回线路的魔数。认证是可选的,这里跳过了。然后每个网络层各有一个控制协议:IPv4 是 IPCP,IPv6 是 IPV6CP。它们彼此独立,所以 IPv4 还在争论时,链路就可以搬运 IPv6,一个失败也不会把另一个拖下水。

两个有用的调试工具早就装好了,却没人用:

# 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 本身也要转义,以及任何一端要求转义的其他字节。

帧、标志字节,以及转义的代价一个帧,以及永远不能出现在帧里的两个字节0x7E标志0xFF地址0x03控制协议1 或 2 字节载荷:你的 IP 数据包最大不超过协商好的最大接收单元FCS16 位 CRC0x7E标志转义:唯一的规则任何可能被误认为边界的字节,都被替换为 0x7D 加上原字节与 0x20 异或的结果。载荷 0x7E 发送为 0x7D 0x5E载荷 0x7D 发送为 0x7D 0x5D这两个是必须转义的。其余的由异步控制字符映射决定:32 位,每个控制字符一位。映射设为零:pppd 的默认值,在套接字上是对的256 个字节里只转义两个。开销你永远测不出来。套接字是干净的 8 位路径,别的什么都不需要。32 个全部标记:保守的调制解调器设置在压缩或加密的载荷上,大约每八个字节就有一个小于 0x20,于是翻倍。大约占链路的 12%,白白浪费。
帧的结构是:标志、地址、控制、协议、载荷、帧校验序列、标志。帧内任何可能被误认为边界的字节,都被替换为 0x7D 加上原字节与 0x20 异或的结果。ACCM 决定还有多少其他字节享受同样的待遇:在干净的 8 位路径上是零个,如果任一端要求那个假定调制解调器会吞掉控制字符的保守默认值,就是三十二个。

转义规则是精确的:“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 载体:隧道把丢包藏起来1载体丢了一个分段。2载体重传它。字节迟到了,而不是丢了:问题全在这里。3隧道里的 TCP 看不见载体。它把延迟当成拥塞,把定时器翻倍,重传下面早已在途中的数据。4现在载体欠着原件和一份副本,要走一条刚刚证明在丢包的链路。队列增长得比任何一层排空它都快。链路还没垮,吞吐量先崩了。UDP 载体:丢包到达真正负责它的那一层1载体丢掉这个包,什么都不说。2里面的 PPP 帧校验和不通过,被丢弃。下一个标志字节重新同步。3隧道里的 TCP 看到一次真实的丢包,因为它终于被告知了路径的真相。4它把窗口减半,重传一次。拥塞控制正好干它被设计来干的事。丢一个包只损失一个包。
承载用的 TCP 保证送达,所以丢掉的分段会被重传,字节是迟到而不是不到。隧道里面的 TCP 只看到延迟,认定网络拥塞,于是退避并重传同样的数据,而这些数据载体现在也得送达。每一层的定时器都在试图解决一个本属于另一层的问题,队列增长的速度比任何一层排空它的速度都快。UDP 载体则直接丢掉数据包,内层 TCP 看到的是一次真实的丢包,它的拥塞控制就去干它本来被设计来干的事。

形状是这样的。两个 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 不是:数据报要么完整到达,要么根本不到,而且可能乱序到达。可它照样能用,靠的是成帧一直都带着的两个字节。

丢一个数据报只损失一个帧,下一个标志字节就让链路恢复边界对不齐,但这无所谓pppd 写出的 PPP 帧7E帧 A + FCS7E帧 B + FCS7E帧 C + FCS7E帧 D + FCS载体实际发出的内容:netcat 读的是缓冲区,不是帧数据报 1数据报 2:丢失数据报 3数据报 4帧 B 丢了中间部分,校验和不通过,被丢弃。帧 C 丢了开头的字节,同样被丢弃。丢两个帧就是丢两个 IP 数据包。上一层会重传它们,而且是在知道路径丢了东西的情况下重传,而这恰恰是 TCP 载体会藏起来的信号:它只会让它们迟到。
netcat 读到缓冲区里有什么就把什么写进一个数据报,所以帧的边界和数据报的边界毫无关系。丢一个数据报,接收端看到的就是一个缺了字节的帧:帧校验序列不通过,帧被丢弃,跟在嘈杂的串行线路上一模一样。下一个 0x7E 让字节流重新同步。丢一个帧只损失一个数据包,由上一层来重传,而这正是内层 TCP 需要、却在 TCP 载体上永远得不到的丢包信号。

异步 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
用三十秒发现死掉的载体,并把它重建起来载体可能悄无声息地死掉。PPP 就是这样发现并恢复的。载体悄无声息地死掉远端关机 · NAT 表项过期 ·中间设备不再转发没有任何东西报告没有 FIN,没有 RST · ip link 仍显示 ppp0 UP · UDP 没有状态探测器lcp-echo-interval 10 lcp-echo-failure 3每 10 秒一次 echo,错过 3 次就断开,共 30 秒重建persist maxfail 0 holdoff 5重启,永不放弃,每次重试间隔 5 秒一个守护管理器systemd unit,Restart=always,pppd 重新运行 pty 命令,新的 netcat 和套接字随之而来两端都要设置 echo。一次 echo 只能证明回复走回来的那条路径。把 `ip route` 放进 /etc/ppp/ip-up.d/,把 IPv6 路由放进 /etc/ppp/ipv6-up.d/,这样每次链路回来,路由都会重新应用,而不是手工设一次,第一次重连就丢了。
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 让校验失败时关闭连接,而不是警告一声然后继续。这些是调试工具,表现也像调试工具,但在一台你什么都装不了的机器上,它们能把链路拉起来。

明文、TCP 上的 TLS,或 UDP 上的 DTLS两端是同一个链路半边。只有中间在变。pppd 或 tap0普通 netcat,UDPncat --udp --listen 6000pppd 或 tap0在线路上是明文,监听端接受第一个连上端口的人。没有机密性,没有访问控制。pppd 或 tap0TCP 上的 TLS:ncat、stunnel 或 opensslncat --ssl --ssl-verify --ssl-trustfile tunnel.crt host 6000pppd 或 tap0有保护,证书说明远端是谁。但载体又是 TCP 了,而且这是唯一能做流式压缩的形态。pppd 或 tap0UDP 上的 DTLS:socat 或 opensslsocat - OPENSSL-DTLS-CLIENT:host:6000,cafile=tunnel.crt,verify=1pppd 或 tap0加密、认证,仍然是数据报。丢一个包仍然只是丢一个包,而不是两个协议栈为它争吵。目标在这里。
两端自始至终都是同一个 pppd,变的只有 pty 命令。普通 netcat 给你一条毫无保护的链路。TCP 上的 TLS 保护了字节,却把载体 TCP 的问题带了回来。UDP 上的 DTLS 才是要追求的形态:加密、认证,而且仍然是数据报载体,所以丢掉的包仍然只是丢掉的包,而不会变成两个协议栈之间的重传之争。

第四阶段: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。

开销堆栈,以及剩下的内层 MTU从路径 MTU 往下算,剩下多少用多少IP 报头20(v4)/ 40(v6)UDP 报头8DTLS 记录 + 标签≈ 30PPP / 以太网成帧几个字节内层 MTU:隧道能搬运的部分,目标 1400,下限 1280DTLS 记录不能像 TLS 记录分散在 TCP 流里那样被分片,所以这一切必须一次装进路径 MTU。和 OpenVPN 自 2001 年以来的形态一样:一个数据报载体、DTLS、上面一个虚拟接口。不是怪招,只是拆散了。
从 1500 往下算:IPv4 报头 20 字节或 IPv6 报头 40 字节,UDP 8 字节,DTLS 记录及其标签大约 30 字节,成帧几个字节,剩下的就是隧道能搬运的内层 MTU。普通路径上取 1400;如果中间有什么东西本身也是隧道,1280 是安全的下限。这个形态,一个数据报载体、DTLS、上面一个虚拟接口,差不多就是 OpenVPN 从 2001 年起一直在做的事。不是什么怪招,只是拆散了而已。

调优 PPP 版本:MTU、压缩,以及真正有用的东西

四个旋钮,都是 pppd 选项。下一节的 tap 版本一个都没有,因为它根本没有这些旋钮所配置的那套机制。

四个 pppd 旋钮:一个要设,一个别动,两个关掉一个要设,一个别动,两个关掉要设MTU 和 MRU两端都设,留出余量:普通 1400,隧道下 1280。分片的帧会丢掉整个包。别动ACCM默认已经是零,在干净的套接字上是对的。只有当中间有东西吞控制字符时才去碰它。关掉novjVan Jacobson 报头压缩在快速链路上省下的只是个零头,每个包都要花 CPU,一丢包就出错。高于调制解调器速度就关掉。关掉nodeflate nobsdcomp载荷已经是 TLS/DTLS:压缩密文纯属白干,而跨越安全边界压缩,就是一种攻击。这些都不会让隧道变快。PPP 不是瓶颈:同一个守护进程跑 PPPoE 能到 2 Gbit,因为它的数据路径留在内核里。这里的代价在 pty:每个字节都要进用户空间再出来。这笔账属于伪终端,不属于 PPP。
MTU 和 MRU 才是要紧的那个:两端都设,并留出余量,因为一个需要载体去分片的帧,任何一次丢包都会损失整个数据包。在干净的套接字上,ACCM 已经是零,而且是对的。速度高于调制解调器时,用 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
tap 设备一端是接口,另一端是文件描述符没有守护进程,没有协议,没有伪终端。只有一个文件描述符。内核tap0一个普通接口,有地址,也有路由/dev/net/tunTUNSETIFF 指定你拿到的设备你的进程socat,或者五十行持有 fd 的 PythonUDP 套接字每个数据报一个帧网络以及远端读一次 = 一个帧和 PPP 搭法相比少了什么:没有协商的帧大小,没有存活检测,不交换地址,没有认证。两端都由你手工配置,它们从不讨论其中任何一样。没有东西盯着链路,所以链路死了也没人告诉你。
没有守护进程,也没有协议。内核把 tap0 呈现为一个普通接口,把它的另一侧交给打开 /dev/net/tun 的那个进程。一次读取恰好返回一个以太网帧;一次写入恰好注入一个。pppd 原来在协商的一切,地址、帧大小、存活检测,现在都由你在两端手工配置,而两端从不讨论其中任何一样。

第一条命令里有两个细节,比看上去更有分量。

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 监听端该往哪儿应答的零长度数据报,以及下一节要加的压缩,都在这个页面包里:

tapcat.py:完整的程序,大约一百行 tapcat.py · 6 kB

每个数据报上的 peer = src 是要读两遍的那部分。谁最后发来一个帧,谁就成为对端。 在源端口不断变化的 NAT 后面,这很方便;在不可信的网络上,这就是一扇敞开的门,任何能往那个端口发一个数据报的人都能接管隧道。在 DTLS 会话里面没问题,而这正是它要去的地方;单独用就不行。脚本的套接字那一半在这里通过 IPv6 环回测试过:开场数据报到达,监听端认下对端,一个帧穿过去,应答回来;tap 那一半需要 root,是我唯一没能跑的部分。

TCP 上你得自己发明成帧

现在把载体换成 TCP,看一整个问题冒出来,而这个问题 PPP 早在 1994 年就悄悄解决了。

TCP 是一个没有记录边界的字节流,也不保证字节到达时如何分组:背靠背写入的两个帧,可能在一次读取里到达,一个帧也可能分三次到达。接收端手里是一堆字节,不知道一个帧在哪儿结束,而 tap 设备只接受完整的帧。

每帧一个数据报,或者一个你得自己发明的长度前缀从 tap 设备读一次就是一个帧。保持这一点是载体的活。走 UDP:边界白送数据报 = 帧 A数据报 = 帧 B数据报 = 帧 C数据报 = 帧 D读一次,发一个数据报,远端写一次。无需定界,无需缓冲,丢包后也无需重新同步。走 TCP:边界没了,你得自己把它们放回去一条字节流:两个帧可能在一次读取里到达,一个帧也可能分三次到达len帧 Alen帧 Blen帧 Clen帧 D每个帧前面加两字节大端序长度,接收端先读长度,再恰好读那么多字节。能用,但恢复不了。HDLC 在下一个 0x7E 上重新同步,因为标志没有歧义;带长度前缀的流一旦错位,之后的每个长度都会从某个帧的中间读出来。加上标记和校验和来修它,你就重新造了一个 HDLC。
在 UDP 上,一个帧就是一个数据报,边界白白送上门。在 TCP 上边界没了,所以发送端必须给每个帧加一个长度前缀,接收端必须据此重新组装。PPP 没有这个问题,因为它自带成帧,两端各一个标志字节外加一个校验和,这也是它在受损后能重新同步的原因。带长度前缀的流做不到:错一个字节,之后的每一帧就全错了。

所以在 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。

tuntap
穿过的是什么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 字节的帧上都从头开始的压缩器,什么都看不到;一个跨帧保留窗口的压缩器,全都看得到。

先压缩后加密,载体允许的话就保留窗口顺序是固定的。模式才是要做的决定。tap0读一次,一个帧压缩zstd,1 级加密DTLS 或 TLS载体UDP 或 TCP绝不能反过来。FLUSH_BLOCK:保留窗口输出目前为止的一切,保留历史。每个帧都相对之前的所有帧编码。不增加延迟:进一个帧,出一个帧。5.0%重复性流量上 · 日志行上 7.5%需要每个帧都按顺序送达。所以:TCP,或 TCP 上的 TLS。不能是 UDP,也不能是 DTLS。FLUSH_FRAME:每个包都扔掉窗口每个数据报都是一个完整的 zstd 帧,可以单独解码,所以 1 到 N-1 丢了,数据报 N 照样能用。数据报载体唯一能用的模式。14.8%同样流量上 · 日志行上 24.2%训练好的字典能把大部分差距赢回来:5.3% 和 15.1%,而且仍然能容忍丢包。
压缩放在 tap 设备和载体之间,并且在加密之前,因为密文压缩不了。FLUSH_BLOCK 是要紧的模式:它把目前为止的一切都输出,所以进一个帧就出一个帧,不增加延迟,同时为下一个帧保留压缩历史。FLUSH_FRAME 每个包都把这段历史扔掉,这让它在有丢包的载体上是安全的,也让它在线路上的效果差了三倍。

在当前的 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%
随机字节,代替 TLS100%+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 做回显,发进去的一行字走完全程又回来了。

中继就是两个套接字加一根管道,于是端点挪了位置一个连接进,另一个连接出,中间一根管道。这就是代理。客户端打开一个 TLS 会话中继:你的边界记录下的目的地ncat -l 7000终结客户端的连接ncat farend发起新的一跳远端真正的另一端stdoutbackpipe(FIFO)把回复带回来客户端 → 中继中继 → 远端客户端的连接在中继上结束。数据包没有。你的防火墙记录了一个通往这台机器的连接。它转发到哪里,是在机器内部决定的;串起三台,真正的远端就隔着三根管道,每一跳的日志里只有一个整洁的、通往下一跳的本地连接,再往后什么都没有。
中继就是两个套接字加一根管道。监听端终结客户端的连接。第二个 netcat 往前发起一个全新的连接,FIFO 在两者之间搬运回程方向。客户端的 TLS 会话在这里,在中继上结束,新的一跳从这里开始,所以你的边界记录下的目的地是这台机器,而数据包会继续去往它转发到的任何地方。串起三台,远端就隔着三根管道,每一跳的防火墙只看到一个整洁的、通往下一跳的本地连接。

Ncat 在一个进程里就能干同样的事,为每个到来的客户端 exec 出往前的连接:

ncat -l 7000 --keep-open --sh-exec 'ncat farend.example.net 7100'

同样的形状,更少的零件:监听端的套接字与被 exec 出来的 ncat 的套接字,由 shell 在两者之间建立的管道连接起来。串起三台,隧道就跨过三张网络,在每一处终结再重新发起,每一跳的防火墙都记下一个整洁的、通往下一跳的本地连接,再往外什么都没有。

这就是全部的把戏,也是为什么边界日志不能证明目的地。在它前面那台机器所能分辨的范围内,每一台中继都是远端,而真正的另一端隔着不知多少根没人在盯的管道。

现在把这些中继放到不属于攻击者的机器上。

跨越被攻陷主机串起来的中继,把端点洗白每一跳都是别人的机器,每个主人只看到中间攻击者他们唯一拥有的机器中继 1另一家公司的网络中继 2一台被劫持的 VPS中继 3一台家用路由器目的地流量真正要去的地方看到:1←→2看到:2←→3看到:3←→目的地没有哪一跳能看到自己两个邻居之外。没有起点,没有终点,只有中间。流量在一串别人的系统里被洗白,每台都在攻击者的控制下跑着同样的两个套接字加一根管道的中继。这就是为什么被攻陷主机的出站流量常常通向另一个受害者,而不是攻击者本人:二十年的 C2 都是这样。
每一跳都是一台被攻陷的主机:另一家公司的机器、一台被劫持的 VPS、一台家用路由器,在攻击者的命令与控制下跑着同样的两个套接字加一根管道的中继。没有哪一跳能看到自己两个邻居之外的东西:中继 2 的主人看到一个来自中继 1 的连接和一个通往中继 3 的连接,别的什么都看不到。流量在一串别人的系统里被洗白,这就是为什么一台被攻陷主机的出站流量常常通向另一个受害者,而不是攻击者本人。

这条链上的每一个主人都只看到一个从上一跳到下一跳的连接:没有起点,没有终点,只有中间。这不是我递给谁的什么新点子。跳板链和 C2 网络二十年来就是这么运作的,这也是为什么一台被攻陷主机的出站流量常常通向另一个受害者,而不是攻击者。你的日志显示你跟某个数据中心里的一台机器说过话。是谁的机器,它又转发到哪里,从来都不在日志里。

防御上的分量就一句话:一个你没有提前限制的目的地,你既无法溯源,也无法信任。 等到流量往外走的时候,它去往的那个地址几乎告诉不了你什么,因为那是别人机器上的一台中继,真正的端点被洗白藏在它后面。

链路从来都不是产品

把它拆开之后,让我印象最深的是,其中新的东西少得可怜,被拿来卖的东西却多得惊人。

RFC 1661 是 1994 年的。pppd 在每个 Linux 发行版里待了三十年,内核模块是一个目录里的八个文件,而让一个 VPN 成为 VPN 的全部东西,一个虚拟接口、一条协商过的链路、一个加密的载体、一条路由,就是四个程序加一张证书。没有一样是难的或者保密的。他们把每一个字节都写成了文档,然后白白送了出来,而一个行业在你和它之间长了出来,把同样的四个零件装进盒子里卖,配上按席位计费的许可证和一份会到期的支持合同。零件并没有变得更好。只是被包装了。

这不是在主张把它跑在生产环境里。我刚刚才告诉过你别这么做。这是在主张你要知道自己买的盒子里装的是什么,因为等到厂商改了授权方式、被人收购、或者让你的型号停产的那一天,一个糟糕的季度和一个糟糕的年份之间的区别,就在于你那里有没有人知道这东西是用什么做的。

花一个晚上,用零件把隧道搭出来。看着 LCP 协商,弄断链路再看着它回来,拔掉证书看看什么会停下来。然后再读一遍你那家 VPN 厂商的产品说明书,看看其中有多少你认得出来。

同一个晚上也能换来另一半。如果一条通出你网络的可路由链路就是四个已安装的程序加一张证书,那么刚刚在你某台机器上拿到 root 的人,并不会因为隧道难搭而被拦住。它不难。拦住他们的,只有你在他们到来之前就决定好的、什么可以出去。搭一次,你就不会再把出站当作某个产品替你执行的东西,而会开始把它当作一个你要么做了、要么没做的决定。

其中没多少是魔法。大部分是刷了层漆的 1994 年,而 1994 年没什么不好。它能用,有文档,而且至今还在跑。


  1. RFC 1661 — The Point-to-Point Protocol (PPP),1994 年。定义了链路、LCP,以及位于其上的网络控制协议族。 ↩︎

  2. RFC 2637 — Point-to-Point Tunneling Protocol (PPTP),把 PPP 承载在 GRE 里。 ↩︎

  3. RFC 3931 — Layer Two Tunneling Protocol version 3,那个把 PPP 承载在 UDP 里的协议在标准轨道上的后代。 ↩︎

  4. 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。 ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎

  5. RFC 1662 — PPP in HDLC-like Framing。标志序列、字节填充规则和异步控制字符映射:“Each frame begins and ends with a Flag Sequence, which is the binary sequence 01111110 (hexadecimal 0x7e).” ↩︎ ↩︎

  6. Olaf Titz,Why TCP Over TCP Is A Bad Idea — 关于重传叠加的标准解释,开篇讲的正是这种搭法。原始 URL 已不再提供这篇文章;这是 Internet Archive 的存档。 ↩︎

  7. RFC 5072 — IP Version 6 over PPP。IPV6CP 和 64 位接口标识符,独立于 IPCP。 ↩︎

  8. RFC 1332 — The PPP Internet Protocol Control Protocol (IPCP),负责协商链路两端的 IPv4 地址。 ↩︎

  9. RFC 1994 — PPP Challenge Handshake Authentication Protocol (CHAP)。证明对端身份;什么都不加密。 ↩︎

  10. RFC 3079 — Deriving Keys for use with Microsoft Point-to-Point Encryption (MPPE)。由 MS-CHAP 交换派生密钥的 RC4 构造,也是 PPTP 不再是可选项的原因。 ↩︎

  11. Ncat Users’ Guide — connecting through a proxy — 用于 HTTP CONNECT 和 SOCKS 4/5 的 --proxy 与 --proxy-type,于是 TLS 载体终结在代理上,而不是隧道的远端。 ↩︎

  12. Ncat Users’ Guide — --ssl、--ssl-verify 和 --ssl-trustfile 选项,以及监听模式和 UDP 模式。这里测试的版本:Ncat 7.92。 ↩︎

  13. Universal TUN/TAP device driver — 内核自己关于 /dev/net/tun、TUNSETIFF 以及 tun 与 tap 区别的文档。 ↩︎

  14. PEP 784 — Adding Zstandard to the standard library,这就是为什么在 Python 3.14 上 compression.zstd 不需要任何软件包。本文实测环境为 Python 3.14.7 和 zstd 1.5.7。 ↩︎

  15. zstd(1) — --train 模式和 --maxdict,用于构建两端都必须加载的字典。 ↩︎

  16. RFC 7457 — Summarizing Known Attacks on TLS and DTLS,涵盖 CRIME,以及先压缩后加密导致长度泄露的一般形态。 ↩︎

  17. OpenVPN — the VORACLE attack — 同样的泄露,针对先压缩后加密的 VPN,也是 OpenVPN 如今建议不要使用压缩的原因。 ↩︎