Ping 不是诊断工具。它是一条隧道。ICMP echo(一台机器发出的请求,以及它收回的应答)会双向搬运你塞进去的任何字节,走的是一个大多数防火墙不加检查就放行、大多数日志只计数不细看的协议。一个“只放行 ping”的网络,本来就有一条完整的、可加密的 VPN 出口,任何能接入这个网络的人都能驾驶它。

这不是新东西,而且有据可查。Loki1 在 1996 年的 Phrack 49 上发表了这种技术。Ptunnel2 在 ping 里搬运完整的 TCP 会话已经二十年了,在任何一台 Linux 机器上都只差一个软件包。没有零日漏洞。只是协议完全按规范在工作。

这就是根源:问题在标准,而不在谁家产品的 bug。地球上每一台主机都有义务把 echo 请求里的数据原封不动地递回去。任意数据进,同样的数据出:一条隧道需要的就这么多,而这从 1981 年起就是强制要求。

修复只是一处很窄的改动。在边界上,在 IPv4 和 IPv6 上,丢弃 ICMP echo,请求和应答都丢,保留其他所有 ICMP 消息。错误消息(Time Exceeded、Packet Too Big、Destination Unreachable)是承重的;把它们拦了,你就平白弄坏了路径 MTU 发现和 traceroute。所以这不是“拦掉 ICMP”。而是丢掉那一条是负债的消息,留下那些说真话的消息。

你的出站策略实际放行了什么

如果你运营的网络对出站做了过滤(如果没有,那是另一个话题),那么这就是其中一行规则的账单。一条写着“拦掉所有出站,放行 ICMP,因为我们要 ping 东西”的策略,不是出站策略。它是一条完整的隧道,只不过文书归档在“诊断”名下。内部任何能发出 echo 请求并读到应答的东西,都能把数据搬到外面任何一个会应答的地方,速率是链路能承受的上限,还能绕过你买来的每一项内容管控。在日志里,它就是有人在看互联网通不通,别的啥也没有。恶意软件这么干已经好多年了,原因正在于此。安静,合规,而且通常早就被放行了。

所以,对任何已经潜入、本不该在里面的人来说,这是首选通道。这是长租,不是砸窗抢劫。想要一条长期进出通道的人,会避开那些会触发告警的端口。他们在 echo 上架起一条隧道,一跑就是几个月。一台老在 ping 的主机,是一台没人盯着的主机。进入整个网络环境的双向连接:命令进,数据出,走的是那个没人限速、没人告警、没人细看的协议。而且它是加密的,就像任何正经工具都会加密一样,所以在线路上,载荷就是 ping 本来就携带的那种看似随机的字节,内容检测没有任何东西可读。真有人在看的话,包的大小和时间间隔仍可能暴露它。往包里头瞧,是瞧不出来的。

而且驾驶它的机器,不一定属于在那里上班的任何人。它只需要某个能接入你网络、又能把一个 ping 发上互联网的东西,而接入你的网络比任何人愿意承认的都容易。WiFi 信号会穿过墙壁,进到走廊、停车场、楼上的公寓。会议室墙上、前台、窗边那张空桌旁的网口,往往是通电的,插上什么都会与之通信,没有 802.1X 来问你是谁。一个在范围内的信号,或者一个没人锁上的插座。这就是入场费。不要门禁卡,不要账号,不要邀请。

想象一下你确实邀请来的那位访客。他们在会上,和和气气,记着笔记,也在发言。他们的笔记本电脑可不是这样。它连上你网络的那一刻,不管是无线还是通过桌子底下的网口,就已经在墙里面了;如果那个网络能发出 echo 请求,它就有了一条出路。你的环境里什么都没被投放。没有账号,在你拥有的任何东西上都没有权限,你的终端代理也没什么可抓,因为你的代理不在他们的机器上。人坐在桌子对面。流量正从你的正门出去,加密着,和一台 ping 得比正常多一点的笔记本毫无区别。

访客只要在信号范围内、或插上一个开放的网口,就能穿过一台只看到 ping 的防火墙打出一条隧道在范围内、或插上一个开放网口的访客,就有一条出路墙里面 —— 你的网络WiFi 够得到走廊、停车场、楼上的公寓访客的笔记本没门禁卡,没账号一个通电的墙上网口没有 802.1X 问你是谁边界防火墙只看到 ping服务器在互联网上echo 请求 →← echo 应答任意 IP 流量,加密着,骑在 ping 里面
入场费是接入网络:一个在范围内的 WiFi 信号,或者一个没有 802.1X 的通电墙上网口;出口则是穿过边界的 echo。在防火墙看来,它是一台会 ping 的主机;那些 ping 里面装的是任意 IP 流量,加密着,发往互联网上的一台服务器。

你会想到的两样东西都帮不上忙。NAT 是一张转换表,不是过滤器:内部主机发出的 echo 请求会以 ICMP id 为键开出一条映射,NAT 对待它就和对待端口一模一样,应答像其他任何流一样从这条映射回来。我在自己家里的 NAT 后面跑了一个客户端,它压根没察觉到 NAT 的存在。单独的访客 VLAN 也好不到哪去。隔离能让访客碰不到你的服务器,却完全挡不住他们上互联网,而通过一个 ping 到达的互联网,就是全部需求。只有一项管控碰得到这个问题:那个网络放不放 echo 出去?

这东西你检测不掉,也隔离不掉。你得把门关上。之后的内容,讲的是标准为什么让这扇门开着,用三种方法搭起这条隧道,让这个论断不只靠我一句话撑着,以及关上它的那一处改动。

ICMP 中那个对你毫无益处的部分

先看标准实际怎么说,因为整个论证建立在一句话上,而人们没读过就把它挥手打发了。

echo 请求带有一个数据字段。在 IPv4 中,RFC 7923 明白地写着“the data received in the echo message must be returned in the echo reply message”。IPv6 把措辞收得更紧,而不是更松:RFC 44434 把这个字段定义为“zero or more octets of arbitrary data”,然后要求它“MUST be returned entirely and unmodified in the ICMPv6 Echo Reply message”。

作为运维人员读它,这是个保活机制。作为搬数据的人读它,这是一份大礼。**标准强制每一台可达的主机接受一块由你挑选的字节,并按需原封不动地直接送还给你。**长度任意。内容任意。没有握手,没有端口,远端也没有哪个应用需要同意什么。内核就把这事办了,任何用户态进程都还没来得及看一眼。

而且两个协议族都是这样。迁移到 IPv6 并没有把这个问题收拾掉。它把门开得更大了。RFC 792 说数据“must be returned”;RFC 4443 说它“MUST be returned entirely and unmodified”,同一扇门,用一把更结实的锁把它撑开。正因如此,这条通道在 ICMP echo 和 ICMPv6 echo 上同样存在,一条只在一个协议族上关掉它、另一个不管的规则,等于什么都没关。隧道只会搬到你留着没关的那个协议族上。不管你对此做什么,都要在 ip 和 ip6 上一起做。

协议里没有别的东西会这样。Time Exceeded 携带的是那个死掉的包的头部,仅此而已。Destination Unreachable 是关于一件已经发生之事的报告。这些消息告诉你关于网络的事实。echo 则双向携带你放进去的任何东西,还管自己叫诊断。

错误消息是承重的,echo 不是

这是“干脆把 ICMP 全拦了”那帮人从来不做的区分,而它就是全部要点,所以我认认真真地讲一次。

拦截 ICMP 错误消息,会悄无声息地弄坏网络。过滤掉 Packet Too Big,你就杀死了路径 MTU 发现:握手完成了,小的传输正常,而任何携带满尺寸包的东西都会永远挂着,日志里什么都没有。在 IPv6 上,这甚至谈不上口味问题。路由器不做分片,所以 RFC 48905 把 Packet Too Big 列为防火墙“must not drop”的消息之一,并警告说没有它,“parts of the Internet will become inaccessible”。过滤掉 Time Exceeded,你就弄坏了 traceroute,而 RFC 18126 正是把这一点列为该消息必须存在的理由。这些都不是可选的。它们是让网络能自我纠正的反馈,上一篇我已经详细讲过失去它们的代价。

现在把 echo 丢掉,再去找找坏了什么。跨越边界的 ping 不能用了。清单就这些。完整的清单。

路径 MTU 发现不在乎,因为它靠的是 Packet Too Big,那是一条错误消息。traceroute 不在乎,因为 traceroute -T 和 -U 走的是 TCP 和 UDP,读的是回来的错误消息。它们没有一个发送 echo。IPv6 上的邻居发现不在乎,因为那是类型 133 到 137,你得保留它们,否则这个网段就死了。上一篇里的反向 TTL 技巧对任何应答都管用,而一次 TCP 握手就能给你一个应答。让上一篇那些诊断能工作的一切,都照样工作,因为它里面没有一项测量发送过 echo 请求。

所以这个协议的两半,简直天差地别。一半是网络在告诉你关于它自己的真相,你弄坏它,后果自负。另一半是一个被强制要求的载荷回送服务,碰巧被叫作诊断,而为保留它所能说出的最有力的理由,不过是 ping 很顺手。它是很顺手。它也是 ICMP 里攻击者唯一能驾驶的部分,而我可以确切地给你看他们用什么来驾驶。

保留 ICMP 错误消息并限速;只丢弃 echo,双向、两个协议族一个协议的两半,只有一半是负债保留限速,绝不一拦了之Destination Unreachable说明一个包为何送不到Packet Too Big路径 MTU 发现依赖它Time Exceededtraceroute 依赖它Parameter Problem报告一个畸形的头部邻居发现 133–137IPv6:本地网段依赖它弄坏这些,网络就悄无声息地坏掉。丢弃双向,两个协议族Echo 请求type 8(IPv4)· type 128(IPv6)Echo 应答type 0(IPv4)· type 129(IPv6)除了下面这个,没东西需要它们:ping命令。攻击者驾驶的一切经 ICMP 都跑在它们上面。只在一个协议族上关掉的隧道,没算关。
ICMP 错误消息是承重的:路径 MTU 发现、traceroute 和 IPv6 邻居发现都依赖它们,拦掉它们会悄无声息地弄坏网络。echo 是唯一一个除了 ping 之外没有任何东西依赖的部分,也是攻击者唯一能驾驶的部分。丢掉它,保留其余的,两个协议族都要。

证明它:一条用 ping 搭成的 VPN

工具是 Hans7,作者 Friedrich Schöller。它自己的介绍只有一行:它“makes it possible to tunnel IPv4 through ICMP echo packets, so you could call it a ping tunnel.” 它在两端各起一个 tun 接口,给它们分配地址,然后把两者之间的每一个包都装进 ICMP echo 里搬运。在中间的网络看来,这是有人在 ping 一台服务器,服务器在应答。在我看来,这是一条路由。

一整个 IP 包装在一个 ping 的数据字段里出行一整个包骑在一个 ping 里面你的 SSH 会话发出的那个包IP 头源 / 目的TCP 头端口 22应用数据你的按键、你的文件Hans 把整个包拷进 echo 数据字段在线路上离开的那个包IP 头你到服务器ICMP echo 请求type 8 · id · seqecho 数据字段上面那整个包,原封不动在边界防火墙看来,这是一个 echo 请求,日志记下的是一次 ping。数据字段里面是一个发往远端所能到达之任何地方的包。标准要求远端把那份数据直接送回,所以应答里也是一个包。
隧道搬运的每一个包,都被拷进一个 ICMP echo 请求的数据字段。标准强制远端把那份数据原样送回,所以应答里也带着一个包。防火墙数到的是一次 ping;而载荷能去到远端路由得到的任何地方。

我在自己的线路上跑了它:一台公网地址上的服务器,一台在我家 NAT 后面的客户端,然后把真实流量推过去。不是设了标志位的合成 ping。是一次 SSH 登录和一次文件拉取,骑在 echo 里面。

在我跑服务器的那头,它只差一个软件包;在别处就从 Schöller 的源码编译。服务器必须是 Linux 并且需要 root,因为打开一个 tun 设备和一个原始 ICMP socket,两者都需要。语法故意做得很小:

# on the server (public IP), pick the tunnel network and a password
hans -s 10.8.0.0 -p '<password>'
# server takes 10.8.0.1; clients are handed 10.8.0.2 and up

# on the client, point it at the server's public address
hans -c <server-public-ip> -p '<password>'

两端都起来之后,每一侧都有一个新接口,带着隧道网络上的地址,它的表现和任何其他点对点链路一样:

那次会话里没有任何东西知道自己在 ping 里面。SSH 向 10.8.0.1 开一条 TCP 连接,内核把它路由出 tun0,Hans 把每个包包成 echo 请求的载荷,远端再拆开喂给它自己的 tun0。应答作为 echo 应答的载荷回来。在 SSH 看来,它是在一条普通链路上通信。在防火墙看来,没人打开过任何东西。只是一台主机正在被 ping。

它在线路上是什么样子

这是了结争论的部分,所以别看我这边,看防火墙眼里的那个视角。

真正在发生的事,和防火墙记下的,不是同一幅画面一条隧道,两幅画面真正在发生的事你的主机tun0 · 10.8.0.2服务器tun0 · 10.8.0.1它所能到达之处SSH、文件拉取照常路由出去任意 IP 流量,经隧道作为普通的包边界防火墙看到并记下的你的主机198.51.100.9服务器192.0.2.7echo 请求echo 应答icmp echo request 198.51.100.9 > 192.0.2.7icmp echo reply 192.0.2.7 > 198.51.100.9icmp echo request 198.51.100.9 > 192.0.2.7…… 被数作 ping,内容没人读同一条线路。防火墙永远看不到里面的那些包。
隧道在两台主机之间搬运真实流量,再出去到服务器能到达的任何地方。在边界上,它只是 echo 请求和 echo 应答——防火墙记下的是 ping,永远看不到裹在里面的那些包。

坐在外侧接口上,在 SSH 会话运行时用 tcpdump 只抓 ICMP。没有一条到 22 端口的 TCP 跨越边界。跨越边界的是 echo 请求和 echo 应答,来来回回,每一个都比真正的 ping 要胖,因为它的载荷里装着一段 TCP 报文的切片:

# on the boundary, watch only ICMP echo while traffic runs over the tunnel
tcpdump -ni <wan-iface> 'icmp[icmptype] = icmp-echo or icmp[icmptype] = icmp-echoreply'

读一读那份抓包里要紧的两样东西。第一,载荷长度:一次正常的 ping 发 56 字节,每一行都一样大,而这些长度各不相同、而且偏大,因为你搬运的东西的大小,泄进了 ping 的大小里。第二,速率:诊断用的 ping 是一秒一个,而这是洪水,因为它在搬一个文件。两样都没藏。两样都明明白白地坐在一个没人去看的协议上。

这就是全部的要点。不是说这有多巧妙,或者一看就难以发现。几乎没人去看,因为那台设备被配置成放行 ICMP,日志把它数作 ping,告警又是按某人想起来该担心的那些端口去调的。流量离开时看着像一次健康检查,而这次健康检查是一条通往服务器所能到达之处的路由。

一条亲手搭出来的完整隧道 VPN

Hans 证明了这条通道存在,但它替你把接口和地址分配都办了,递回来一条路由,所以它没完全展示出你搭成的是什么。要看清这是一条完整意义上的 VPN——整台机器的流量从 ping 里出去,而不只是两台具名主机之间的一条链路——就亲手把它拼起来。icmptunnel8,作者 Dhaval Kapil,就是干这个的,它自己的介绍也只有一行:“Transparently tunnel your IP traffic through ICMP echo and reply packets.” 同样的思路,tun 设备加 echo 载荷,只不过管道是你自己铺的,没有什么东西藏在二进制里。

在服务器上,你启动隧道,把接口拉起来,然后做那件把整盘棋都摊开的事:告诉内核别再自己应答 ping,这样它自己的 echo 应答就不会和隧道发出的那些打架。

sudo ./icmptunnel -s 10.0.1.1                 # server mode; creates tun0, then blocks
# from a second shell, bring the interface up (iproute2, not the net-tools the repo ships)
sudo ip addr add 10.0.1.1/24 dev tun0
sudo ip addr add 2001:db8:1::1/64 dev tun0
sudo ip link set tun0 mtu 1472 up             # 1500 − 20 (IP) − 8 (ICMP); see below
# stop the kernel replying to pings — echo now belongs to the tunnel
sudo sysctl -w net.ipv4.icmp_echo_ignore_all=1
sudo sysctl -w net.ipv6.icmp.echo_ignore_all=1
# let the server route the client's packets onward
sudo sysctl -w net.ipv4.ip_forward=1

把 icmp_echo_ignore_all 这一行再读一遍,因为它说的比看上去要多。那个旋钮是内核自带的,出厂就是一道防御:设上它,用内核自己的话说,它“will ignore all ICMP ECHO requests sent to it”9,于是运维人员可以把一台主机彻底从 ping 的雷达上拿掉。它现在两个协议族都有。net.ipv4.icmp_echo_ignore_all 多年前就有,net.ipv6.icmp.echo_ignore_all 是后来加上来配套的。10 隧道把那个防御开关打开,用的却是相反的理由:内核不再自己应答 echo,它的两端就能把 echo 当作纯粹的传输来用。而这正是破绽。写这套协议栈的人,早就把 echo 当成一台主机有理由拒绝的东西——本文这条规则,在边界上,为它身后的每一台主机,一次性作出同样的决定。

在客户端上,你把接口拉起来,然后把默认路由指下去。不是经隧道到达某一台主机。是一切。

sudo ./icmptunnel -c <server-public-ip>       # client mode; creates tun0
sudo ip addr add 10.0.1.2/24 dev tun0
sudo ip addr add 2001:db8:1::2/64 dev tun0
sudo ip link set tun0 mtu 1472 up
# keep the route to the server itself OUT of the tunnel...
sudo ip route add <server-public-ip> via <gateway> dev <iface>
# ...then send everything else down it
sudo ip route replace default dev tun0

这个项目自己的 client.sh 和 server.sh 仍然用的是 net-tools 的 ifconfig 和 route。上面那些 ip 命令是 iproute2 的等价物,干的是同一件事。那条到服务器的路由,是人们会忘掉的一行:把它排除在隧道之外,否则携带隧道的那些 echo 包会试图顺着隧道走,什么也出不去。其余一切现在都走 tun0,裹在 echo 里,到达服务器。它会不会再往前走,是个路由选择。服务器上一条 masquerade 规则就能把它用服务器自己的地址放上公网,而这里故意没放,因为要展示的东西是隧道,隧道不需要它。

那就是一条完整隧道 VPN,用寥寥几条命令,从 ping 里搭了出来。客户端发出的每一个包——网页、DNS、SSH,全部——都被捕进 tun0,作为 echo 请求发给服务器离开,答案作为 echo 应答回来。一台处在“只放行 ICMP”网络上的机器,刚刚把它全部的出站流量交给了外面的一台设备,而边界记下的是一台爱 ping 的主机。

用 Python 自己写一个

接下来这部分,应该让任何指望靠认出某个工具来防御的人心里发怵。Hans 和 icmptunnel,都没做任何你不能用一个下午自己写出来的事。打开一个 tun 设备,把每个包包成 echo 请求的载荷,拆开回来的那些。整个机制就这些,光是隧道本身,大约六十行标准库 Python,完全不用装任何东西。下面这个版本在上面加了一样东西:它加密载荷,而那是唯一一处引入依赖的地方。

#!/usr/bin/env python3
# pingvpn.py — a VPN tunnel over ICMP echo, in one short file.
#
# Not a product. It exists to show the channel is trivial to rebuild, so a
# defence that hunts for a known tool is chasing the wrong thing entirely.
# Linux, needs root (a tun device and a raw ICMP socket both do), and the
# `cryptography` package for the AES (pip install cryptography).
#
#   server:  sudo python3 pingvpn.py --server
#   client:  sudo python3 pingvpn.py --client <server-public-ip>
#
# The payload is encrypted with AES-128-GCM under a pre-shared key before it
# goes on the wire, so what a firewall sees in the echo data is random bytes —
# the same as a real ping's padding, and nothing for content inspection to read.

import argparse
import fcntl
import hashlib
import os
import select
import socket
import struct
import sys

from cryptography.hazmat.primitives.ciphers.aead import AESGCM

TUNSETIFF    = 0x400454CA
IFF_TUN      = 0x0001
IFF_NO_PI    = 0x1000
MAGIC        = 0x4954          # 'IT' in the id field, so we ignore real pings
ECHO_REQUEST = 8
ECHO_REPLY   = 0

PSK   = b"change-me-to-a-shared-secret"          # pre-shared secret, both ends
KEY   = hashlib.sha256(PSK).digest()[:16]        # 128-bit key -> AES-128-GCM
AEAD  = AESGCM(KEY)


def open_tun(name=b"tun0"):
    fd = os.open("/dev/net/tun", os.O_RDWR)
    fcntl.ioctl(fd, TUNSETIFF, struct.pack("16sH", name, IFF_TUN | IFF_NO_PI))
    return fd


def encrypt(data):                                # -> nonce || ciphertext+tag
    nonce = os.urandom(12)
    return nonce + AEAD.encrypt(nonce, data, None)


def decrypt(blob):                                # raises on a packet that is not ours
    return AEAD.decrypt(blob[:12], blob[12:], None)


def checksum(data):
    if len(data) % 2:
        data += b"\x00"
    total = sum(struct.unpack("!%dH" % (len(data) // 2), data))
    total = (total >> 16) + (total & 0xFFFF)
    total += total >> 16
    return ~total & 0xFFFF


def build_echo(icmp_type, payload):
    head = struct.pack("!BBHHH", icmp_type, 0, 0, MAGIC, 0)
    csum = checksum(head + payload)
    return struct.pack("!BBHHH", icmp_type, 0, csum, MAGIC, 0) + payload


def main():
    ap = argparse.ArgumentParser(description="a VPN tunnel over ICMP echo")
    group = ap.add_mutually_exclusive_group(required=True)
    group.add_argument("--server", action="store_true")
    group.add_argument("--client", metavar="SERVER_IP")
    args = ap.parse_args()

    out_type = ECHO_REQUEST if args.client else ECHO_REPLY
    in_type  = ECHO_REPLY   if args.client else ECHO_REQUEST
    peer     = args.client        # None on the server until a client is seen

    tun  = open_tun()
    sock = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_ICMP)
    print("tun0 created. bring it up with an address and route, then send traffic.",
          file=sys.stderr)

    while True:
        readable, _, _ = select.select([tun, sock], [], [])

        if tun in readable:                       # a packet wants to leave this host
            packet = os.read(tun, 65535)
            if peer:
                sock.sendto(build_echo(out_type, encrypt(packet)), (peer, 0))

        if sock in readable:                      # something arrived over ICMP
            data, _ = sock.recvfrom(65535)
            ihl  = (data[0] & 0x0F) * 4           # skip the IP header the kernel adds
            icmp = data[ihl:]
            if len(icmp) < 8 or icmp[0] != in_type or icmp[4:6] != struct.pack("!H", MAGIC):
                continue
            try:
                packet = decrypt(icmp[8:])        # wrong key or a real ping -> skip
            except Exception:
                continue
            if args.server:
                peer = socket.inet_ntoa(data[12:16])   # reply to whoever sent
            os.write(tun, packet)                 # hand the carried packet to the stack


if __name__ == "__main__":
    main()

那就是整条隧道。它打开 tun0 和一个原始 ICMP socket,在两者之间倒腾包:离开主机的东西被包成一个 echo 请求(在服务器上则是 echo 应答)发给远端;经 ICMP 到达的东西被拆开,交还给协议栈。id 字段被钉在一个值上,好让它避开真正的 ping,服务器则从它看到的第一个包的源地址,学到该往哪里应答。

值得多讲几句的是加密,因为那正是真家伙会做的事,也是为什么你往包里头看抓不到它。载荷在被包起来之前,用一个预共享密钥以 AES-128-GCM 封好,所以 echo 数据里的那些字节,和真正 ping 携带的随机填充没法区分。把那两行加密代码抽掉,隧道照样只靠标准库跑起来——它需要 pip install cryptography 的唯一理由就是 AES,而 AES 恰恰是把一条可读的隧道变成一条不可读隧道的那一部分。按和之前一样的方式把它拉起来,少掉 masquerade。证明这个要点并不需要它:

# server: start it (creates tun0, then blocks), then configure from the same shell
sudo python3 pingvpn.py --server &
sudo ip addr add 10.9.0.1/24 dev tun0
sudo ip addr add 2001:db8:9::1/64 dev tun0
sudo ip link set tun0 mtu 1400 up
sudo sysctl -w net.ipv4.icmp_echo_ignore_all=1
sudo sysctl -w net.ipv6.icmp.echo_ignore_all=1

# client
sudo python3 pingvpn.py --client <server-public-ip> &
sudo ip addr add 10.9.0.2/24 dev tun0
sudo ip addr add 2001:db8:9::2/64 dev tun0
sudo ip link set tun0 mtu 1400 up
sudo sysctl -w net.ipv4.icmp_echo_ignore_all=1
sudo sysctl -w net.ipv6.icmp.echo_ignore_all=1
sudo ip route add <server-public-ip> via <gateway> dev <iface>
sudo ip route replace default dev tun0

把它写出来的理由不在工具本身。而在于这工具是一次性的。一个短文件,加上加密之前没有依赖,而且每个人敲出来的副本,在线路上看起来都略有不同。所以一条抓得住这一个的特征规则,下周什么也抓不到。你没法靠点名软件把自己拦出这个困境,因为根本没有软件可点名。

它甚至不需要一个 shell。逻辑就是字节进、字节出,所以它能移植到任何能打开 socket 的东西上。连 WebAssembly 也行:浏览器沙箱通常会直接拒绝给一个网页原始 socket,但在那道屏障被撤掉的地方(一个被用户授了权的浏览器,在一台用户拥有足够权限来打开原始 socket 的机器上),同样这段短程序就能在一个标签页里跑起来。而这正是它让人不安的那一半。在这件事上你没法信任你的用户。驾驶隧道的那台主机就在内部,握在某个你认定安全、因为他们坐在防火墙后面的人手里,而防火墙正是那个被隧穿过去的东西。边界信任假定威胁在墙外。这一个每一次都从墙里面开始。

当心 MTU,以及 IPv6 那条 1280 的下限

隧道在线路上不是免费的。你搬运的每一个包,在离开前都会多出一个外层 IP 头和一个 ICMP 头,所以内层接口必须坐在这条路径能承载的额度之下。在 IPv4 上这几乎不花攻击者什么代价。把内层 MTU 设低(icmptunnel 的 1472 是 1500 减去外层 IP 头的 20 和 ICMP 头的 8,上面那段 Python 则降到 1400 留点余地),而在这个数仍然不对的地方,IPv4 会把超大的包分片,在远端重组,而不是丢掉。在你能挑的那条低下限,和把其余部分糊弄过去的分片之间,隧道几乎能跑过任何路径。那种灵活,正是让 IPv4 成为干这事舒服地方的原因。

IPv4 的分片和 MTU 余地让隧道哪里都能跑;IPv6 两样都没有,所以它失败关闭为什么它在 IPv4 上哪里都能跑,在 IPv6 上却失败关闭IPv4IP 头20 BICMP8 B内层包tun MTU 1472 B太大了?IPv4 分片再重组 — 隧道几乎跑过任何路径。IPv6IPv6 头40 BICMPv68 B内层包不能低于 1280 B1280 B 硬性下限(RFC 8200)太大了?IPv6 路由器丢掉它,不分片 — 隧道失败关闭。IPv4 的退路 — 一条你能挑的下限,其余靠分片 — 正是让隧道可靠的东西。IPv6 两样都没有,所以在 IPv4 上几乎哪里都跑的攻击,在 IPv6 上很脆弱。这里更安全的协议族。Packet Too Big — 一条你保留的错误消息,不是 echo — 正是让发送方找到合适尺寸的东西。非按比例绘制。
隧道给每个包砍掉一个外层 IP 头和一个 ICMP 头。IPv4 允许你削薄内层 MTU,并把仍然过大的东西分片,所以它几乎哪里都能跑;IPv6 设了一条硬性的 1280 字节下限,而它的路由器不分片,所以超大的包会被丢掉,隧道便失败关闭——这让 IPv6 在这里成了更安全的协议族。

IPv6 没那么宽容,而这一次,那是站在你这边的。下限是硬的:RFC 820011 第 5 节要求“every link in the Internet have an MTU of 1280 octets or greater”,而 IPv6 路由器在转发途中不分片。这一下子拿掉了 IPv4 的两条退路,而且它在两个方向上都咬住隧道。把隧道跑在 ICMPv6 之上,路径上每一条链路都得承载 1280,所以一条降到那以下的路径会把传输拖垮,而你没法像在 IPv4 上那样削到下限以下。把 IPv6 装进隧道里,你从另一侧撞上同一堵墙:内层接口也不能低于 1280,而外层 ICMPv6 封装——40 字节头加 8 字节 ICMPv6——已经在花额度了,所以路径得腾出 1280 加上那份开销。任一处没对上,包就被丢掉,不是被削小来将就:隧道起得来,小东西能用,任何满尺寸的都挂着。所以 IPv6 在这里是更安全的协议族,不是更危险的那个。那个在 IPv4 上几乎哪里都跑得起来的攻击,在 IPv6 上很脆弱,而且失败关闭。不过更安全不等于安全:echo 通道在 IPv6 上也是开的,所以规则仍然两个协议族都把它丢掉——只是攻击者没法像倚仗 IPv4 那样倚仗 IPv6。

从那种情况里恢复过来,靠的是你小心保留的那条 ICMP 错误消息。Packet Too Big 正是让发送方找到可用尺寸的东西,而它是一条错误消息,不是 echo,所以本文主张的规则不去碰它。丢掉隧道,保留诊断——那就是全部设计,而 MTU 是它又一次挣得自己身价的地方。

把规则收窄到只针对 echo

上一篇给出了完整的中转规则集:在限速下放行错误消息,丢弃 echo。我不打算重印它。本文主张的改动,是一对行,而正是这一对在干活:

# permit the ICMP errors — these are load-bearing, keep them
ip protocol icmp icmp type { destination-unreachable, time-exceeded, parameter-problem } \
    limit rate 100/second accept
ip6 nexthdr ipv6-icmp icmpv6 type { destination-unreachable, packet-too-big, \
    time-exceeded, parameter-problem } limit rate 100/second accept

# drop the tunnel — echo, both directions, both families
ip  protocol icmp     icmp   type { echo-request, echo-reply } drop
ip6 nexthdr ipv6-icmp icmpv6 type { echo-request, echo-reply } drop

不过这条规则不是 Linux 独有的。在任何配得上这名字的防火墙上,它都是同一个意图:放行错误消息,给它们的速率封顶,在两个协议族上双向丢弃 echo。所以这里把它写成你更可能正握在手里的那些方言。

BSD pf(pfSense、OPNsense、OpenBSD、FreeBSD):

# permit the errors; block echo both directions, both families
pass  in proto icmp  icmp-type  { unreach, timex, paramprob }
pass  in proto icmp6 icmp6-type { unreach, toobig, timex, paramprob, \
                                  routersol, routeradv, neighbrsol, neighbradv }
block in proto icmp  icmp-type  { echoreq, echorep }
block in proto icmp6 icmp6-type { echoreq, echorep }

把邻居发现的那些类型留在 icmp6 那一行上;一旦丢了它们,就是会把网段拖垮的那些。

Cisco IOS(扩展 ACL,应用在边缘):

ip access-list extended ICMP-EDGE
 permit icmp any any unreachable
 permit icmp any any time-exceeded
 permit icmp any any parameter-problem
 deny   icmp any any echo
 deny   icmp any any echo-reply
!
ipv6 access-list ICMP6-EDGE
 permit icmp any any packet-too-big
 permit icmp any any unreachable
 permit icmp any any time-exceeded
 permit icmp any any parameter-problem
 permit icmp any any nd-ns
 permit icmp any any nd-na
 deny   icmp any any echo-request
 deny   icmp any any echo-reply

在 IPv4 上 echo 类型是 echo;在 IPv6 上是 echo-request。限速放在 CoPP 里,不在 ACL 里。

Juniper Junos(防火墙过滤器;inet6 过滤器与此对应,并保留邻居发现):

firewall family inet filter icmp-edge {
    term errors {
        from { protocol icmp; icmp-type [ unreachable time-exceeded parameter-problem ]; }
        then { policer icmp-cap; accept; }
    }
    term drop-echo {
        from { protocol icmp; icmp-type [ echo-request echo-reply ]; }
        then discard;
    }
}

MikroTik RouterOS——丢弃那两个 echo 类型,然后接受 ICMP 的其余部分,这样就保留了错误消息,在 v6 上还保留了邻居发现:

/ip firewall filter
add chain=forward protocol=icmp icmp-options=8:0 action=drop comment="echo request"
add chain=forward protocol=icmp icmp-options=0:0 action=drop comment="echo reply"
add chain=forward protocol=icmp action=accept comment="keep the errors (add limit= to cap)"
/ipv6 firewall filter
add chain=forward protocol=icmpv6 icmp-options=128:0 action=drop comment="echo request"
add chain=forward protocol=icmpv6 icmp-options=129:0 action=drop comment="echo reply"
add chain=forward protocol=icmpv6 action=accept comment="keep errors and ND"

语法各异,规则只有一条。放行那些携带真相的消息,丢弃那条携带你字节的消息。

两条警告,你要是跳着看,两条都会咬你。

**在边界上丢弃 echo,而不是在一台主机和它自己的路由器之间的链路上。**在 IPv6 上,邻居发现就是 ICMP——类型 133 到 137,nd-router-solicit 到 nd-redirect——它就是网段用来干 IPv4 里 ARP 那份活的东西。把一条 echo 丢弃规则搬到链路本地或主机链上,又没保留那些类型,网段几分钟内就不工作了,而且它看起来不像是防火墙的毛病。在流量离开你网络的地方过滤 echo,内部链就别碰。

**双向都丢弃,它两头才都不再有用。**只拦请求,能让你的主机不被 ping,却仍然放应答出去,而多费点劲,一条隧道单靠应答就能搭起来。请求和应答都丢,在 IPv4 和 IPv6 上,通道两头就都关上了。

丢掉 ping 实际上要你付出什么

对损失要诚实,因为一项你夸大过头的管控,是一项别人在第一次觉得碍事时就悄悄回滚掉的管控。

你失去了跨越边界的 ping。那就是代价,全部说清楚。这是一笔实实在在的代价。ping 是本能反应,它长在每个人的指头上,你上线这个的第二天,就会有人说互联网断了,因为他们 ping 网关超时。没断。你是告诉网关别再应答一个从头到尾只是图方便的请求。

可达性测试不需要 echo。一条到某个你知道开着的端口的 TCP 连接,告诉你主机在线、路径通,而且它告诉你的比一次 ping 更多,因为它证明了有个服务在应答,而不只是一个内核:

# "is it up and reachable?" without sending a single echo
nc -zv <host> 443           # did the TCP handshake complete?
traceroute -T -p 443 <host> # walk the path on TCP, read the errors back

这两条都骑在你保留的 ICMP 错误消息,和一个真实服务本就在说的 TCP 上。两条都不发 echo。所以诚实的取舍是这样:你放弃工具箱里信息量最少的那个工具,那个只回答“某个内核愿不愿意应答”、别的什么都不说的工具,换来的是你关上了 ICMP 里攻击者唯一能变成一条离开你网络之路由的部分。你在糟糕的日子里真正会去用的那些诊断手段,全都在线那一边,分毫未动。

Fisher-Price OS (Windows) 不是逃出这件事的出路

如果你运营的是一家 Fisher-Price OS (Windows) 的铺子,你可能把这当成别人的问题在读。它不是。负债在协议里,不在操作系统里。标准强制每一台应答 ping 的主机把你的字节递回去,它可不会先停下来问问这台主机跑的是什么。

那套操作系统上的一台机器,能当一个相当好的隧道端点。Hans 带了一个 Windows 客户端,所以一台内部机器可以当客户端那头,像其他任何机器一样把它的流量装在 echo 里送出去。它不太容易当的,是服务器那头,因为那需要一个 tun 设备和一个一直开着的原始 ICMP socket,而在这套操作系统上,只有 Administrators 组的成员能创建 SOCK_RAW 类型的 socket12——微软自己的原话。所以服务器坐在一套真正的操作系统上,就像我的那台一样,而那台在防火墙后面悄悄一路 ping 出去的机器,正是别人告诉你因为在内部所以安全的那一台。

这对任何在防守它的人来说,就是要点。边界规则不在乎内部跑的是什么。在流量离开网络的地方丢弃 echo,它身后的每一台主机就都被罩住了——你管理的那些,还有那台别人向你打包票说躲在 NAT 后面的。我不跑那玩意,我也不打算假装隧道会对它客气。不管端点启动进的是什么系统,修复都是同一条规则,放在同一个地方。

如果你要加固的是那台机器本身(是机器,不是网络),PowerShell 至少能让它自己不再应答或发出 ping:

foreach ($t in 8,0)     { New-NetFirewallRule -DisplayName "Drop ICMPv4 Echo $t" -Protocol ICMPv4 -IcmpType $t -Direction Inbound -Action Block }
foreach ($t in 128,129) { New-NetFirewallRule -DisplayName "Drop ICMPv6 Echo $t" -Protocol ICMPv6 -IcmpType $t -Direction Inbound -Action Block }

再加上 -Direction Outbound 的孪生规则,好让它不能当隧道客户端往外伸,而只是坐在那当目标,并且别去碰 ICMPv6 的错误和邻居发现类型,理由和本页其他地方放它们一马是一样的。但别把它错当成那项管控。一台主机防火墙不是一台中转防火墙。它加固了那台机器,却对边界毫无改变,而边界才是这件事真正被关掉的地方。

今天就去找管你边界的那个人提这件事

读到这里,你多半心里想着的是一个轮不到你去改的网络。大多数人都是。所以有用的做法不是去伸手够防火墙,而是把这个问题摆给握着它的那个人——你自己的网络团队、你的 MSP,或者那家设备坐在边缘上的厂商——而且今天就摆,因为这扇门从 1996 年起就开着,再多开一周,是一个选择。

明白地问,并且做好对方一脸茫然的准备,因为我敢拿全英国的 GDP 打赌,那里没人对 echo 多想过一秒。它是那个人人放行、没人认领的包,而一条没人认领的规则,恰恰就是那条多年来一直摆错、没人察觉的规则。

拿这四件事问他们,就用这些话,好让他们没有空子可以点着头却什么都不改:

  • **我们在边界上,IPv4 和 IPv6 两个协议族,都丢弃 ICMP echo 请求和 echo 应答吗?**不是“我们放不放行 ICMP”——是那条具体的消息,两个方向,两个协议族。如果答案只有一个协议族,那就不算答案,因为隧道只会搬到另一个上去。
  • **我们仍然放行那些 ICMP 错误消息吗?**Destination Unreachable、Time Exceeded、Parameter Problem,以及 IPv6 上的 Packet Too Big,在限速之下而不是一拦了之。如果他们说不上来,那他们要么把一切都敞开着、要么把全部都拦了的概率一半一半,而两样都是错的。
  • **我们在内部链上保留了 IPv6 邻居发现吗?**类型 133 到 137。正是这一条,把“我们加固了 ICMP”变成一个星期后悄无声息死掉的网段,也是一次仓促改动会犯的错。
  • **把规则给我看。**不是一份策略声明,是那台真设备上那条真规则,以及它上线的日期。一项没人指得出来的管控,就是一项不存在的管控。

设备会不会从厂商那里到货时就已经关好了这个?不会。几乎所有地方的默认都是放行 echo,并把它记成一个包计数,而这正是隧道能工作的全部原因。它不是在利用一个 bug,它是在用出厂即标准的那套配置。没人会去关一扇从没人告诉过他开着的门。

坚持用这些措辞的理由是,对本文那个偷懒的修法是“行,我们把 ICMP 拦了”,而那个修法比这个窟窿更糟。它弄坏路径 MTU 发现和 traceroute,会让你对着挂死的传输到处追,日志里却什么都没有,在 IPv6 上它还会把互联网的一部分整个从桌上拿走。如果你问的那个人伸手去够那个,拦住他。这条指令故意很窄:丢弃 echo,保留错误消息,保留邻居发现。正因如此,任何靠跑防火墙吃饭的人,都应该能在一个下午做完这个改动,然后告诉你搞定了。

而如果他们是一家你付钱让他们管这个的 MSP:一个不能张口就告诉你你自己的 echo-与-错误 配置是什么样、或者把“我们拦 ICMP”当成安全选项那样回答你的供应商,刚刚就你这片环境的其余部分告诉了你一些事。下一次一个故障卡在两个网络之间、两边都说自己干净时,记住他们当中是哪一个说不清自己的防火墙拿一个 ping 怎么办。

那个从来就不是诊断工具的诊断工具

Ping 风光了很久。Mike Muuss 在 1983 年写了它,用来检查一台主机还应不应答,照着声呐给它起了名,而它这一件活干得太好,好到成了人人伸手去够的第一样东西,和没人去质疑的最后一样东西。四十年过去,它成了肌肉记忆,而肌肉记忆恰恰就是一项负债得以存活的方式。没人会去重新审视自己一向这么做的事。

可看看它到底是什么,剥掉习惯之后。一条不携带任何关于网络之事实的消息,一条每台主机都有义务用你自己的字节递回来作应答的消息,一条跑在管控不检查、日志不细读的协议之上的消息。所有让它显得人畜无害的东西——它只是个诊断、它只是个保活、人人都放行它——正是同一样东西,让它成为现存的、离开一个经过过滤之网络的最干净办法。这个行业拦掉 ICMP 错误消息,那些携带真相、丢了就把网络弄坏的消息,却对 echo 挥手放行,那条你往里装什么它就携带什么的消息。它把这个协议整个拿反了。

修复并不巧妙。保留那些告诉你真相的消息,丢掉那条只会把你字节递回来的。它让你付出一条你本就没理由信它来做诊断的命令,而它关上了一扇从 1996 年起就一直敞着的门,那门记在一本黑客杂志里,被打包了二十年,一直大开着,就因为关上它会意味着有人不能 ping。要知道一样东西的成本,而不是它的标价。Ping 标价是零(nowt)。它的成本,是那条你看不见的通道。


  1. Loki, Phrack 49 —— 一条藏在 ICMP echo 载荷里的命令通道,1996 年。 ↩︎

  2. Ptunnel —— 在 ICMP echo 里承载一次 TCP 会话。 ↩︎

  3. RFC 792 —— ICMP:“the data received in the echo message must be returned in the echo reply message”。 ↩︎

  4. RFC 4443 —— ICMPv6:echo 数据“MUST be returned entirely and unmodified in the ICMPv6 Echo Reply message”。 ↩︎

  5. RFC 4890 —— 防火墙不得丢弃的那些 ICMPv6 消息。 ↩︎

  6. RFC 1812 —— 路由器需求:Time Exceeded 是一条 MUST,因 traceroute 而得名。 ↩︎

  7. Hans —— IP over ICMP echo 隧道,作者 Friedrich Schöller。 ↩︎

  8. icmptunnel —— 把 IP 流量通过 ICMP echo 和应答包隧穿,作者 Dhaval Kapil。 ↩︎

  9. Linux kernel — IP sysctl —— icmp_echo_ignore_all:“the kernel will ignore all ICMP ECHO requests sent to it”。 ↩︎

  10. Linux commit e6f86b0f — “ipv6: Add icmp_echo_ignore_all support for ICMPv6” —— IPv6 的等价物,作者 Virgile Jarry。 ↩︎

  11. RFC 8200 §5 —— IPv6 要求每一条链路的 MTU 至少为 1280 字节。 ↩︎

  12. Microsoft — TCP/IP raw sockets —— “only members of the Administrators group can create sockets of type SOCK_RAW”。 ↩︎