一个超时的连接几乎什么都不告诉你。对端可能根本没有程序在监听;三跳之外的一台防火墙可能正在悄无声息地丢掉你的 SYN,连一行日志都不留;也可能这条路由压根不存在。从你坐的位置看,这几种情况一模一样。你等着。什么都没发生。
于是工单就写成了“445 端口在某个地方被挡了”,而正是“某个地方”让它被踢来踢去。你的服务商查了他们的边界,没问题,退回给你。你查了自己主机的防火墙,没问题,又退回去。一个星期过去了。什么都没修好。
造成损害的就是“某个地方”这几个字。它本来不必出现。你和目的地之间的每一台路由器,在它就是那一台的时候,都有义务告诉你,而这项义务从 1995 年起就写进了标准。你只需要用对的方式去问。
为什么这件事需要掰开讲
因为这个行业里有太多人连基本功都不会,这每个星期都在让他们的雇主花真金白银。
我说的不是新人。我说的是干了好些年、墙上挂着证书、职位名称里带着“高级”的人,他们对一个超时端口的诊断停在“被挡了”,再也不往下走。他们跑 ping。不通,或者通了,不管哪种,他们对被问到的那个端口一无所知。然后工单转给服务商,服务商退回来,某人两个星期的工资就花在了一个本来一条命令就能解决的邮件往来上。
这些都不难。分清丢弃(drop)和拒绝(reject),读懂回包的 TTL,知道 traceroute 里的一个星号本身说明不了任何问题:这是一个下午就能学会、用一辈子的东西。人们不会,不是因为他们笨。是因为没人教。厂商培训教你厂商的控制台。认证教你考试。底下的基本原理在第一天就被当成你已经会了,从来没有真正讲过,于是人们一路做到高级岗位都没人给他们演示过,到那时再开口问又拉不下脸。
所以与其抱怨,不如把它写下来。这就是基本功,掰开讲清楚,附上命令,还有一个你今天就能跑的脚本。
再说说我为什么费这个劲:写这篇文章时我拿它在自己的线路上跑了一遍,找到了三个我原先不知道的故障。11 跳之外的一个 SMB 丢弃。1 跳之内伪造的 SMTP 重置。一条在 IPv4 上存在、在 IPv6 上不存在的防火墙规则。一个下午,不用 root,在一条我自己维护、也留着心的线路上。你想想,在那些有人拿着工资在管的网络上,有多少东西就这么没人发现地待着。
为什么 Fisher-Price OS (Windows) 不在这里
它不在这里有两个原因。一个是技术上的,一个不是,我宁愿两个都告诉你,也不想假装全是工程问题。
技术上的原因是它做不到。tracert 只发 ICMP echo 请求,别的什么都不发。微软自己的参考文档这样描述它:“sending Internet Control Message Protocol (ICMP) echo Request or ICMPv6 messages to the destination with incrementally increasing time to live (TTL) field values”,而它的语法里没有任何端口参数。pathping 是同一个工具外加统计功能。Test-NetConnection 会告诉你一个 TCP 端口是开着还是关着,至于答案是从多远的地方来的,它一个字都不说。它们没有一个能在指定距离上探测你真正关心的那个端口,而这正是本文的全部方法。
你也没法用脚本绕过去。在 .NET 里给套接字设置 TTL 不难,但把 ICMP 错误读回来才是难的那一半,而这里没有本文所依赖的那个技巧的对应物:没有办法让内核把错误报告在引发它的那个普通套接字上。剩下的就是原始套接字(raw socket),而微软自己的文档说“only members of the Administrators group can create sockets of type SOCK_RAW”。所以无特权的路径不存在,有特权的那条要一个本地管理员令牌。你还没开始,就已经在下载第三方软件了。
另一个原因是我不在乎,我宁愿直说,也不想粉饰。这个名字也不是在挖苦,它是一个描述。它是你在从没用过别的系统时被塞到手里的那个操作系统,它把机器藏起来不让你看,这是设计目标而不是意外;当你想向网络问一个精确的问题时,你会发现那个工具从来就没造过,因为它服务的那些人从来就没被指望会问。三十年过去了,tracert 仍然没法把一个包对准一个端口。
对真正搞 IT 的人来说,它不是一个像样的操作系统;如果它是你用过的唯一一个,那你干这份活的水平就够不上本文所面向的水平。我知道这话不好听。我写东西不是为了讨人喜欢,我是在为那些动手测量的人写下我测到的东西,至于只用过它的人更希望我换个说法,我不怎么在乎。
工具清单才是论据,不是观点。下文表格里的每一个 Unix 都能让你设置跳数上限、选择协议,其中四个只用一条命令就行,而 Linux 连 sudo 都不用就能完成整个测量。这不是因为它们更难用。是因为造它们的人指望坐在键盘前的人想知道事情。一个诊断能力止步于 ping 的操作系统,已经清楚地告诉了你它怎么看待使用它的人,而三十年来人们一直接受这一点,这就是为什么我们最后有了一个找不到一个被丢掉的包的行业。
所以我不用它,我已经好多年没正经用过它了,我也不会为了显得公允,给一个真实存在的缺口专门写一节。我在上面搭建的一切、一切值得从那里去测量的东西,都是 Unix,本文就待在那里。
如果出故障的那台机器碰巧跑的是 Fisher-Price OS (Windows),方法上什么都不变。在随便别的什么东西上拿一个 shell:一台 Linux 虚拟机、一台 Mac、同一台交换机上的一块树莓派,然后朝着它把跳数上限一跳一跳往上走。测量根本不在乎对端跑的是什么。它只在乎中间有什么。
TTL 是跳数预算,每台路由器都欠你一张收据
IPv4 头部有一个 8 位的 Time to Live(生存时间)字段。这个名字是历史遗留:它当初是以秒为单位规定的,而几十年来没有任何东西把它当秒用。RFC 1812 在 1995 年了结了这场争论,把跳数的解读定为规范:
Each router (or other module) that handles a packet MUST decrement the TTL by at least one, even if the elapsed time was much less than a second. Since this is very often the case, the TTL is effectively a hop count limit on how far a datagram can propagate through the Internet.
接着是在这里真正要紧的部分,出自同一节:
If the TTL is reduced to zero (or less), the packet MUST be discarded, and if the destination is not a multicast address the router MUST send an ICMP Time Exceeded message, Code 0 (TTL Exceeded in Transit) message to the source.
这是一个 MUST。不是客气,不是建议。1981 年的 RFC 792 只说网关“may also notify the source host”;十三年后要求收紧了,RFC 1812 把原因说得明明白白:
ICMP Time Exceeded messages are required because the traceroute diagnostic tool depends on them.
IPv6 干脆不再装样子,把字段改了名。RFC 8200 把它叫作 Hop Limit(跳数上限),“8-bit unsigned integer. Decremented by 1 by each node that forwards the packet”,而过期消息变成了 ICMPv6 类型 3、代码 0,“hop limit exceeded in transit”。
把它当成一件仪器而不是一条规则来读,它就说出了有用的东西。路径上的每一台路由器都是一个你可以按距离寻址的信标。 把跳数上限设为 4,第四台路由器就会报上名来。你不需要知道拓扑,不需要任何东西的访问权限,也不需要运营方配合。每一跳你只需要一个包。
traceroute 从 1980 年代末起就在干这件事。它干得不好的,恰恰是你真正关心的那件事:默认情况下它探测的是 33434 一带的 UDP 端口,这是一个没人过滤、也没人提供服务的端口,所以它告诉你的是一条任何真实流量都不走的路径。一个到某台主机的 traceroute 干干净净,而你在 TCP/445 上连不上它,这只证明 UDP/33434 能到。可问题从来就不是这个。
所以,去探测你关心的那个端口。
读回来的是什么,而不是有没有东西回来
数跳数之前,先看看用正常的跳数上限到达对端时,对端会做什么。有五种截然不同的回答,而人们习惯性地把它们混为一谈。
| 回来的是什么 | 意味着什么 | 谁发的 |
|---|---|---|
| SYN-ACK,连接建立 | 端口是开的 | 主机,或者替它应答的某个东西 |
| TCP RST | 被主动拒绝 | 没有程序在监听的主机,或者一台配置为拒绝的设备 |
| ICMP 3/13,communication administratively prohibited | 一台设备按策略拒绝,并且明说了 | 就是那台设备,它的源地址就是你要的答案 |
| ICMP 3/1、3/2、3/3 | 主机、协议或端口不可达 | 最后一台路由器,或者主机 |
| 什么都没有 | 有人在悄无声息地丢包 | 不知道,所以去测 |
第三行值得你为它改掉习惯。当一台防火墙配置成拒绝而不是丢弃时,它会把自己的地址填进 ICMP 的源地址字段,白送你一个罪魁祸首。在 Linux 上,nft ... reject with icmpx admin-prohibited 产生的就是这个,iptables -j REJECT --reject-with icmp-admin-prohibited 一直以来产生的也是这个。大多数工具把它扔掉,只打印一个“filtered”。nmap --reason 会显示它。下面的脚本也会。
第二行和第五行才是有意思的失败。静默丢弃是一个“什么都不告诉你”的策略决定,而因为它几乎是所有商用防火墙的默认行为,你实际碰到的就是它。准备好面对沉默。
第二行也值得怀疑。一个重置并不能证明是主机发的,这一点我后面会用一个真实的例子回来讲,因为写这篇文章时我在自己的线路上就碰到了一个。
把你关心的端口走两遍
方法就是跑两次再做个对比。全部就这些。
- 用出故障的那个确切的协议和端口,把跳数上限从 1 加到 20,记下每一跳是哪台路由器在应答。
- 对一个正常工作的东西做同样的事:最好是同一台主机、一个能连上的端口。
- 第一次运行时应答停下、第二次运行时应答继续的那一跳,就是丢你包的那台设备。第二次运行给你它的地址。
为什么是应答停下而不是变了:路由器在对包做任何别的事之前,先应用它的入站访问控制列表,所以如果策略说丢弃,包在转发路径看一眼跳数上限之前就已经没了,不会生成 Time Exceeded,那台设备也就永远不会为它干的事署上自己的名字。正因如此,沉默是从出问题的那一跳开始的,而不是在它之后。
我写了一个小工具来做这个一跳一跳的走查,因为没有一个原生工具能可移植地做到。它在一个普通套接字上设置 IP_TTL(或 IPV6_UNICAST_HOPS),发起连接,然后把 ICMP 错误读回来。在 Linux 上,IP_RECVERR 会把这个错误报告在引发它的那个套接字上,这意味着整个东西以无特权方式运行:不要 root,不要原始套接字,不要 capabilities。在 macOS、各家 BSD 和 Solaris 上,内核不会这样把 ICMP 交给你,所以它退回到原始套接字,需要 root。
它一共 279 行,只用标准库,别无他物,如果你宁愿读它而不是下载它,全文印在本文末尾。
python3 hopfind.py example.net 445 # the port under suspicion
python3 hopfind.py example.net 443 # the reference run
python3 hopfind.py example.net 53 --proto udp
python3 hopfind.py 2001:db8::1 443 -6
两次运行用同一种协议。拿一条 TCP 轨迹去和一条 ICMP 轨迹比,比的是两条路径,因为负载均衡按五元组做哈希,而 ICMP 没有端口可哈希。同一台主机、同一种协议、不同的端口,才是诚实的比较。
下面的一切都是我自己线路上 2026年8月28日的真实输出,在 Fedora 上以无特权用户运行。里面的每一个地址都被改写进了文档专用地址段:IPv4 用 RFC 5737,IPv6 用 RFC 3849,那个唯一的接口标识符也改过了。所以 198.51.100.x 是我自己的路由器和我的 ISP,203.0.113.x 是中转和对等互联,192.0.2.x 是远端网络,2001:db8::/32 是整条 IPv6 路径。结构自始至终保持不变:同样的前缀边界,同样的主机部分形状,同样数量的不同网络。跳数、时延、ICMP 类型,以及哪一跳沉默了,都和测到的完全一样。
一台主机,三个端口,三种不同的故障
目的地始终不变:公网上的一台主机,14 跳远,443 开着。先看参照运行。
$ python3 hopfind.py 192.0.2.4 443 --max 15
walking to 192.0.2.4 TCP/443 hop limit 1-15
1 198.51.100.254 0.3 ms ICMP 11/0 time exceeded in-transit
2 198.51.100.133 28.8 ms ICMP 11/0 time exceeded in-transit
3 *
4 198.51.100.153 6.3 ms ICMP 11/0 time exceeded in-transit
5 *
6 203.0.113.240 16.5 ms ICMP 11/0 time exceeded in-transit
7 203.0.113.188 16.5 ms ICMP 11/0 time exceeded in-transit
8 203.0.113.185 16.5 ms ICMP 11/0 time exceeded in-transit
9 203.0.113.15 15.6 ms ICMP 11/0 time exceeded in-transit
10 203.0.113.125 16.1 ms ICMP 11/0 time exceeded in-transit
11 192.0.2.31 26.6 ms ICMP 11/0 time exceeded in-transit
12 *
13 *
14 192.0.2.4 19.5 ms connected
Verdict: TCP/443 is open. It answered at hop 14.
注意第 3、5、12 和 13 跳。在一条明显通畅的路径上,有四台路由器一声不吭,因为很多设备被配置成不为自己生成 ICMP,或者对它限速限得很狠。一个星号不是防火墙的证据。 别的啥都记不住,也要记住这一条。信号从来不是单次运行里出现了星号;而是两次运行从哪里开始不一致。
现在是同一台主机的 445 端口,从这里连会超时。
$ python3 hopfind.py 192.0.2.4 445 --max 15
walking to 192.0.2.4 TCP/445 hop limit 1-15
1 198.51.100.254 0.3 ms ICMP 11/0 time exceeded in-transit
2 198.51.100.133 8.0 ms ICMP 11/0 time exceeded in-transit
3 *
4 198.51.100.153 6.4 ms ICMP 11/0 time exceeded in-transit
5 203.0.113.76 5.6 ms ICMP 11/0 time exceeded in-transit
6 203.0.113.240 15.9 ms ICMP 11/0 time exceeded in-transit
7 203.0.113.188 15.8 ms ICMP 11/0 time exceeded in-transit
8 203.0.113.185 16.6 ms ICMP 11/0 time exceeded in-transit
9 203.0.113.15 15.9 ms ICMP 11/0 time exceeded in-transit
10 203.0.113.125 15.0 ms ICMP 11/0 time exceeded in-transit
11 *
12 *
13 *
14 *
15 *
Verdict: answers stop after hop 10 (203.0.113.125).
Whatever swallows TCP/445 is hop 11.
Walk a port that works and read off the address at hop 11.
第 11 跳在 443 运行中 26.6 ms 就应答了,而对 445 运行一个字都没说。同一台设备,同一条路径,前面是同样的十台路由器。拿正常的那次运行一对照,第 11 跳就有了名字:192.0.2.31。那就是丢弃 SMB 的设备,离目的地还差三跳,在我的服务商边界之后八跳。不是我的,也不是我的 ISP 的。
第 5 跳从另一个方向印证了关于星号的那一点。它在 443 运行里是星号,在 445 运行里却应答了:和故障的方向正好相反。这可能是 ICMP 限速,也可能是两次运行经过负载均衡器时走了不同的路径。我不知道是哪一种,你也不会知道。两次运行都重复几遍,再去相信其中任何一个。
然后是 25 端口。这个让我停了下来。
$ python3 hopfind.py 192.0.2.4 25 --max 15
walking to 192.0.2.4 TCP/25 hop limit 1-15
1 192.0.2.4 0.4 ms TCP reset
Verdict: a reset came back to a probe with a hop limit of 1.
Nothing more than one hop away can have sent it, so check the reply
TTL before you believe the host did.
跳数上限为 1,意味着包死在了我自己的路由器上。它走了一跳。它不可能走了十四跳。可是一个 TCP 重置在 0.4 ms 内回来了,上面带着目的地的地址,我的内核也老老实实地报告了 connection refused。要是没设跳数上限,我会把它读成“对端没有邮件服务器”,然后关掉工单。
一跳之内的某个东西正在为出站 SMTP 伪造重置,并且署上目的地的地址。封掉出站 25 端口,对一台家用路由器或一家 ISP 来说是再平常不过的事,用重置而不是丢弃来封,可以说还算客气的做法,但这个重置带着别人的地址,而我完全不知道我的线路在这么干。是跳数上限抓住了它,回包里的其他任何东西都抓不住。
差一:访问控制列表在流水线里的位置
上面的结论说丢包的是第 11 跳,因为应答在第 10 跳之后停了。这笔算术要小心,因为它取决于出问题的设备做两件事的先后顺序。
大多数设备先应用入站策略,再检查跳数上限。命中拒绝,包被丢掉,永远不会生成 Time Exceeded,所以这台设备从不露面,沉默就从它自己的跳数开始。上面就是这种情况。这也是常见的情况。
有些平台在评估策略之前,就在快速路径里处理跳数上限过期。在那里,设备会应答发给它自己的探测,只丢弃瞄准它之后的探测,所以它会正常出现,沉默从下一跳才开始。
所以,“应答在第 N 跳之后停了”的诚实解读是:如果丢包设备在注意到预算用完之前就把你的探测扔进了垃圾桶,那它是第 N+1 跳;如果它应答了发给它的探测、吞掉了瞄准它之后的一切,那它就是第 N 跳本身。 两台相邻的设备,而正常的那次运行把它们俩的名字都给了你。在工单里写地址,不要写跳数:跳数对读你工单的人毫无意义,他是从别的地方数起的。
回包的 TTL 告诉你到底是谁在应答
上面那个 SMTP 重置,是靠出去的跳数上限抓住的。每一个回来的回包里,还有第二个独立的检查可用,而且不花一分钱。
初始 TTL 值并没有标准化,但实际上只有三种:
| 初始值 | 典型发送方 |
|---|---|
| 64 | Linux、macOS、各家 BSD、illumos,大多数主机 |
| 255 | Cisco IOS、Junos、Solaris,大多数网络设备自己发出的流量 |
| 128 | Fisher-Price OS (Windows),读它的回包时你还是得知道这个 |
用比收到的 TTL 大的下一个值减去它,就得回了跳数。一个 TTL 为 50 的回包,起点是 64,走了 14 跳。一个 TTL 为 250 的,起点是 255,走了 5 跳。ping 不用你问就会打印出来:
ping -c1 192.0.2.4 # ttl=50 → 14 hops away
tcpdump -n -v 'icmp' # -v prints the ttl of every packet it shows
由此得出两点。两点都是免费的。
如果一个回包的反向跳数和这台主机其他回包的对不上,那它就不是这台主机发的。 如果一台服务器的 echo 回复是从 14 跳外回来的,而 25 端口上的 RST 是从 1 跳外回来的,那这个 RST 是某个中间设备写的。和上一节是同一个技巧,只是从另一头来做,而且即使你没法设置出站 TTL,它也管用。
一个起点是 255 的回包来自网络设备,而不是服务器。 当你想弄清楚拒绝你的是主机还是它前面的路由器时,这一点很有用。
要在 TCP 而不是 ICMP 上看到这个字段,你需要抓包,而这个过滤表达式值得背下来:
# every hop-limit expiry coming back to you, IPv4 and IPv6
tcpdump -n -v 'icmp[icmptype] == 11 or icmp6[icmp6type] == 3'
# who is resetting you, and from how far
tcpdump -n -v 'tcp[tcpflags] & tcp-rst != 0'
tcpdump 把过期打印成 ICMP time exceeded in-transit:和标准里的说法一样,也和某些平台上显示为“TTL expired in transit”的是同一个事件,只是那些平台换了个措辞。
用原生工具做同一件事,在五种 Unix 上
如果你不想跑脚本,原生工具能完成大部分。只是它们彼此之间的分歧比你预想的要大。尤其是 -P,取决于你手里拿的是谁家的 traceroute,它有三种不同的含义,其中一种会悄悄毁掉你的测试。
Linux(traceroute 2.1.x) | macOS / FreeBSD | OpenBSD | NetBSD | Solaris 11 | |
|---|---|---|---|---|---|
| TCP 探测 | -T | -P tcp | 不可用 | 无 | 无 |
| ICMP 探测 | -I | -I | -I | -I | -I |
| UDP 打固定端口 | -U -p N | -e -p N | 无 | 无 | 无 |
| 目的端口 | -p N(对 TCP 恒定) | -p N(不加 -e 时递增) | -p N(递增) | -p N(递增) | -p N(递增) |
-P 是什么意思 | 不使用 | 探测协议 | 数字协议号,“will not work reliably for most protocols” | 设置 DF 并探测路径 MTU | 探测之间的停顿,单位秒 |
| 需要特权 | 是,-T 和 -I 需要 | 是 | 是 | 是 | 是 |
这些全都需要原始套接字,所以全都需要特权。不过 macOS 和各家 BSD 通常把 traceroute 以 setuid root 方式发行,所以你可能不用在前面敲 sudo。Linux 不这样,Fedora 也不这样,这就是上面那个脚本存在的一半原因。
那张表里有三个坑,三个我都亲眼见过有人在上面浪费掉一个下午。
在各家 BSD 和 macOS 上,-p 是一个基准端口,每发一个探测就递增一次。 所以 traceroute -P tcp -p 445 host 测的是 445,然后 446,然后 447,到第 10 跳时你问的已经是一个从来没人听说过的端口了。你还需要加上 -e,手册页管它叫防火墙规避模式(firewall evasion mode),实际意思不过是“让端口别动”:
sudo traceroute -P tcp -e -p 445 example.net # macOS, FreeBSD
在 Linux 上,对默认的 UDP 方式,单独用 -p 也会这样,你需要 -U -p 才能得到一个恒定的 UDP 端口。对 TCP,-T -p 本来就是恒定的:手册页写得很明白,“for TCP and others specifies just the (constant) destination port to connect”。
sudo traceroute -T -p 445 example.net # Linux
sudo traceroute -U -p 53 example.net # Linux, UDP/53 specifically
在 Solaris 和 NetBSD 上,根本没有办法固定端口,而在 Solaris 上 -P 是以秒为单位的停顿,所以一条照抄来的 Linux 命令行会毫无报错地跑完,测的却完全不是你要问的东西。Solaris 也没有 TCP 探测模式。这种情况下你要用脚本。
Redox 是个异类,值得说一句,因为我料到会有人问。它的全部网络工具就是 netutils:dns、ifconfig、nc、ping、telnetd、wget。没有 traceroute,没有 tcpdump,啥抓包的东西都没有。如果问题的一端是一台 Redox 机器,那就从另一端去测,把走查对准它。
mtr 也值得一提,因为它把重复和取平均这一步做了,而上面那些表格要你手工来做:
sudo mtr -T -P 445 --report --report-cycles 20 example.net
对出故障的端口跑一次,再对一个正常的端口跑一次,并排对照。方法一样,输出更好看。
有人封掉 ICMP,这一切就都不灵了
本文里的每一次测量,都是由传回给我的 ICMP 错误构成的。把它们封掉,整套诊断就瞎了,而且瞎掉的远不止这些。
在有些地方,整个封掉 ICMP 仍然被当成一种安全姿态。从 1990 年代起它就站不住脚了。人们以为它能挡住的攻击是 ping of death 和 smurf,这两个都是在协议栈里修好的,而不是在边界上,而且修好的时候,有些至今还在重复这条建议的工程师还没出生。一刀切地封掉,如今挡住的是诊断。别的什么都没挡住。
RFC 1812 在这一点上没有留下解释的余地:Time Exceeded 是一个 MUST,而标准写明了它的理由是 traceroute 依赖它。丢掉它,你就弄坏了一个工具,而互联网自己的路由器要求文档正是把这个工具列为这条消息存在的理由。
路径 MTU 发现是代价最大的那个。它需要 ICMP 3/4(fragmentation needed,需要分片)回到发送方。把它过滤掉,你就会碰上每个网络工程师至少追过一次的那个故障:握手完成了,小的传输都正常,凡是带满尺寸包的东西都永远卡住。SSH 连上了,scp 却停住。页面加载了,图片却永远不来。日志里什么都没有。没东西可 grep。
到了 IPv6,这就不再是个人口味的问题了。RFC 4890 §4.3.1 列出了防火墙绝不能丢弃的消息:
- Destination Unreachable (Type 1) - All codes
- Packet Too Big (Type 2)
- Time Exceeded (Type 3) - Code 0 only
- Parameter Problem (Type 4) - Codes 1 and 2 only
而说到 Packet Too Big,它对后果说得毫不客气:“Effectively, parts of the Internet will become inaccessible.” IPv6 路由器不做分片。如果 Packet Too Big 到不了发送方,就没有任何恢复的路径。
该用的控制手段是限速,不是丢弃。入站放行类型 3 和类型 11,计数,把上限卡在每秒一百个左右,超出上限的记日志,这样你保住了诊断,保住了路径 MTU 发现,也保住了那条一刀切规则当初被想象成能提供的每一分保护。限制你接收某样东西的多少,是一种控制。全部拒绝还管这叫加固,那只是拒绝被测量。
给所有做 MSP 的人一句话:如果你客户的线路丢弃 ICMP 错误,你就剥夺了他们证明故障出在哪个网络上的能力,也剥夺了你自己的。下一次故障卡在两家都说自己没问题的服务商之间时,那就是这条策略的账单。
除了 Echo。把它丢掉。
上面说的全是 ICMP 错误。Echo 是另一回事,它是这个协议里我会在边界上从线上拿掉的唯一部分。
看看标准对它的要求。在 IPv4 里,RFC 792 说到 echo 请求时写道:“the data received in the echo message must be returned in the echo reply message”。IPv6 更直白:RFC 4443 把这个字段定义为“zero or more octets of arbitrary data”,然后要求它“MUST be returned entirely and unmodified in the ICMPv6 Echo Reply message”。
站在攻击者而不是运维者的角度去读。标准要求地球上的每一台主机,接收一块由你挑选的字节,再原封不动地交还给你。 这不是副作用。这是一条被强制规定的、双向的、载荷任意的通道,跑在一个大多数防火墙不检查就放行、大多数日志只记包数不记内容的协议上。
人们在它上面造隧道已经造了三十年。Loki 在 1996 年的 Phrack 49 里就干过。Ptunnel 能把一整个 TCP 会话装进 ping 里,二十年来装个软件包就有。如果你的出站策略是“全部封掉,放行 ICMP,因为网络组要用”,那你就没有出站策略。你有的是一个多绕了几步的 VPN,而流量出去时看起来就像有人在测试互联网通不通。
RFC 4890 不同意我,这一点值得明说,而不是只引用对我有利的那一半。§4.3.1 把 Echo Request 和 Echo Response 和那些错误消息放在同一张绝不能丢弃的清单里。再读读它给的理由:
For Teredo tunneling [RFC4380] to IPv6 nodes on the site to be possible, it is essential that the connectivity checking messages are allowed through the firewall.
它给出的让 echo 保持开放的理由,是有人需要用它在你的防火墙上打一条隧道。这正是我的论点,由持相反观点的人亲手写了下来。
所以策略要窄,不要一刀切:
# transit rules. permit the errors, drop the ping
ip protocol icmp icmp type { destination-unreachable, time-exceeded, parameter-problem } \
limit rate 100/second accept
ip protocol icmp icmp type { echo-request, echo-reply } drop
ip6 nexthdr ipv6-icmp icmpv6 type { destination-unreachable, packet-too-big, \
time-exceeded, parameter-problem } limit rate 100/second accept
ip6 nexthdr ipv6-icmp icmpv6 type { echo-request, echo-reply } drop
在 IPv6 上,不要把这个模式搬到链路本地或主机链上而不保留邻居发现。 类型 133 到 137,也就是 nd-router-solicit 到 nd-redirect,是 IPv6 用来干 IPv4 里 ARP 那份活的。把它们丢掉,网段几分钟内就会停止工作,而且看起来不会像防火墙故障。在边界上过滤 echo,而不是在主机和它自己的路由器之间的那段线上。
这让你付出什么?跨边界的 ping,别的什么都没有。本文里的一切都照常工作,因为这里没有一次测量发送 echo 请求。 hopfind.py 走的是 TCP 和 UDP,读的是回来的错误;traceroute -T 和 -U 也一样。路径 MTU 发现需要 Packet Too Big,那是一个错误。反向 TTL 技巧对任何回包都管用,一次 TCP 握手就能给你一个。你唯一失去的是工具箱里信息量最少的那个工具,而这整篇文章就是在论证,止步于 ping 本身就是问题所在。
我自己的线路已经正好是这么做的,不过我怀疑那不是有意的。ping 我的默认网关是 100% 丢包,而同一个网关发出的 ICMP Time Exceeded 在 0.3 ms 内就回来了:本文里每一条轨迹都显示了这一点。Echo 关着,错误开着。不管是谁发布的那个固件,他们做对了,而我是专门去找才发现的。
同一条规则,只写了一次
这是我没想到会在自己家里找到的故障。一台公共 DNS 解析器,在 TCP/443 上分别用两种地址族走查,前后相隔几分钟。
$ python3 hopfind.py 192.0.2.53 443 --max 10
walking to 192.0.2.53 TCP/443 hop limit 1-10
1 *
2 *
3 *
4 *
5 *
6 *
7 *
8 *
9 *
10 *
Verdict: nothing answered at all, not even the first hop.
什么都没有。一跳都没有。连我自己的路由器都没报告它必定生成了的那个过期,而本文里其他每一次走查,它都在 0.3 ms 内报告了同样的过期。所以丢弃发生在第 1 跳,在跳数上限检查运行之前,而第 1 跳是我的。
路径本身没问题,同一个目的地在 UDP 上就能证明:
$ python3 hopfind.py 192.0.2.53 53 --proto udp --max 10
1 198.51.100.254 0.3 ms ICMP 11/0 time exceeded in-transit
2 198.51.100.133 5.4 ms ICMP 11/0 time exceeded in-transit
3 *
4 198.51.100.167 14.5 ms ICMP 11/0 time exceeded in-transit
5 203.0.113.50 6.3 ms ICMP 11/0 time exceeded in-transit
6 203.0.113.174 5.7 ms ICMP 11/0 time exceeded in-transit
7 203.0.113.201 6.4 ms ICMP 11/0 time exceeded in-transit
8 *
到同一个地址,七跳干干净净的应答。所以不是路由,也不是目的地:我线路上的某个东西丢掉了发往那台主机的 TCP,却放行了发往它的 UDP。
接着是同一台解析器,同一个端口,走 IPv6:
$ python3 hopfind.py 2001:db8:53::53 443 -6 --max 10
walking to 2001:db8:53::53 TCP/443 hop limit 1-10
1 2001:db8:1:ee:beef:abcd:fec0:2a30 0.5 ms ICMP 3/0 hop limit exceeded in-transit
2 2001:db8:1::15c 24.6 ms ICMP 3/0 hop limit exceeded in-transit
3 *
4 2001:db8:2:200::50 5.5 ms ICMP 3/0 hop limit exceeded in-transit
5 2001:db8:2:2::4 5.7 ms ICMP 3/0 hop limit exceeded in-transit
6 2001:db8:2:991:: 16.6 ms ICMP 3/0 hop limit exceeded in-transit
7 2001:db8:53::53 5.7 ms connected
Verdict: TCP/443 is open. It answered at hop 7.
一路畅通。七跳,毫无波折。同样的服务,同样的端口,同样的意图,而这条规则只存在于一种地址族上。
写这条规则的人是为 IPv4 写的,从来没写它的孪生规则。我不知道它本来想达成什么:我猜是想让 DNS 留在本地之类的,但不管是什么,自从这条线路有了 IPv6,它就一直只在一半的流量上起作用。如果它是有理由才在那里的,那它不管用。如果没有理由,它就不该在那里。
这就是双栈问题的日常版本,比那些到底要不要部署 IPv6 的争论常见得多。两本规则手册。只维护了一本。
完整脚本
没有依赖,不用安装,只有标准库。Python 3.6 或更高版本,在 Linux 上完全不需要特权。
这两个类就是可移植性的全部故事。ErrorQueue 是 Linux 的路径:在套接字上启用 IP_RECVERR,探测失败后读取 MSG_ERRQUEUE,从内核附加的 sock_extended_err 结构里取出路由器的地址。RawIcmp 是其他所有地方的路径:打开一个原始 ICMP 套接字,读取到达的任何东西,从包上取下源地址。前者什么都不需要,后者需要 root,而程序的其余部分并不在乎它拿到的是哪一个。
有一个细节值得指出,因为它就是正确答案和看似合理的答案之间的区别。在 probe() 里,错误队列是在查询 SO_ERROR 之前被清空的。ICMP 错误到达 TCP 套接字时只是一个普通的 errno:ICMP 3/3 端口不可达会以 ECONNREFUSED 的形式到达,和一个真正的重置一模一样,所以如果先查 SO_ERROR,本文前面那个伪造的 SMTP 重置就会被报告成对端一次老老实实的拒绝。先读队列,ee_origin 就会告诉你是一台路由器说了话。
#!/usr/bin/env python3
"""hopfind - work out how many hops away the thing blocking your port is.
Walks the IPv4 TTL, or the IPv6 hop limit, up from 1 and records which router
answers at each step - using the protocol and port you actually care about
instead of traceroute's default UDP high ports.
Run it twice. Once against something that works, once against the port that
does not. The hop where the answers stop is the device dropping you, and the
run that works gives you its address.
python3 hopfind.py example.net 445 # the port under suspicion
python3 hopfind.py example.net 443 # the reference run
python3 hopfind.py example.net 53 --proto udp
python3 hopfind.py 2001:db8::1 443 -6
On Linux this needs no privileges at all: IP_RECVERR and IPV6_RECVERR hand the
ICMP errors back on the ordinary socket that caused them. On macOS, the BSDs
and Solaris the errors have to be read off a raw ICMP socket, which means root.
Written for https://blogs.damiendye.uk/networking/how-far-away-is-the-firewall/
Public domain. Do what you like with it.
"""
import argparse
import errno
import os
import select
import socket
import struct
import sys
import time
# Linux socket options. Absent from the socket module on some builds, so they
# are spelled out rather than looked up.
IP_RECVERR = 11
IPV6_RECVERR = 25
# ee_origin values from linux/errqueue.h. Anything else means the errno came
# from the local stack rather than from a router.
SO_EE_ORIGIN_ICMP = 2
SO_EE_ORIGIN_ICMP6 = 3
ICMP_V4 = {
(11, 0): "time exceeded in-transit",
(11, 1): "fragment reassembly time exceeded",
(3, 0): "net unreachable",
(3, 1): "host unreachable",
(3, 2): "protocol unreachable",
(3, 3): "port unreachable",
(3, 4): "fragmentation needed",
(3, 9): "net administratively prohibited",
(3, 10): "host administratively prohibited",
(3, 13): "communication administratively prohibited",
(5, 0): "redirect",
}
ICMP_V6 = {
(3, 0): "hop limit exceeded in-transit",
(3, 1): "fragment reassembly time exceeded",
(1, 0): "no route to destination",
(1, 1): "communication administratively prohibited",
(1, 3): "address unreachable",
(1, 4): "port unreachable",
(2, 0): "packet too big",
}
def describe(family, icmp_type, icmp_code):
table = ICMP_V4 if family == socket.AF_INET else ICMP_V6
return table.get((icmp_type, icmp_code), "unrecognised")
def is_expiry(family, icmp_type):
"""Was this the router saying 'your hop budget ran out here'?"""
return icmp_type == (11 if family == socket.AF_INET else 3)
class ErrorQueue:
"""Linux. The kernel reports the ICMP error on the socket that provoked it."""
def arm(self, sock, family):
if family == socket.AF_INET:
sock.setsockopt(socket.IPPROTO_IP, IP_RECVERR, 1)
else:
sock.setsockopt(socket.IPPROTO_IPV6, IPV6_RECVERR, 1)
def extra_readers(self):
return []
def collect(self, sock, family):
try:
_, ancillary, _, _ = sock.recvmsg(0, 1024, socket.MSG_ERRQUEUE)
except OSError:
return None
wanted = (socket.IPPROTO_IP, IP_RECVERR) if family == socket.AF_INET \
else (socket.IPPROTO_IPV6, IPV6_RECVERR)
for level, kind, data in ancillary:
if (level, kind) != wanted or len(data) < 16:
continue
# struct sock_extended_err, then the sockaddr of the router that
# sent the error - SO_EE_OFFENDER in the kernel headers.
_, origin, icmp_type, icmp_code = struct.unpack_from("=IBBB", data, 0)
if origin not in (SO_EE_ORIGIN_ICMP, SO_EE_ORIGIN_ICMP6):
return None
addr = None
if len(data) >= 24:
offender_family, = struct.unpack_from("=H", data, 16)
if offender_family == socket.AF_INET:
addr = socket.inet_ntoa(data[20:24])
elif offender_family == socket.AF_INET6 and len(data) >= 40:
addr = socket.inet_ntop(socket.AF_INET6, data[24:40])
return addr, icmp_type, icmp_code
return None
class RawIcmp:
"""macOS, the BSDs, illumos, Solaris. Read the ICMP off a raw socket, as root."""
def __init__(self, family):
proto = socket.IPPROTO_ICMP if family == socket.AF_INET else socket.IPPROTO_ICMPV6
self.sock = socket.socket(family, socket.SOCK_RAW, proto)
self.sock.setblocking(False)
def arm(self, sock, family):
pass
def extra_readers(self):
return [self.sock]
def collect(self, sock, family):
try:
packet, peer = self.sock.recvfrom(1500)
except OSError:
return None
if family == socket.AF_INET:
# BSD raw sockets hand back the IP header too.
header_len = (packet[0] & 0x0F) * 4
packet = packet[header_len:]
if len(packet) < 2:
return None
return peer[0], packet[0], packet[1]
def probe(dest, port, proto, family, hop_limit, timeout, listener):
"""One probe at one hop limit. Returns (icmp, socket_state, note)."""
kind = socket.SOCK_STREAM if proto == "tcp" else socket.SOCK_DGRAM
sock = socket.socket(family, kind)
if family == socket.AF_INET:
sock.setsockopt(socket.IPPROTO_IP, socket.IP_TTL, hop_limit)
else:
sock.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_UNICAST_HOPS, hop_limit)
listener.arm(sock, family)
sock.setblocking(False)
try:
if kind == socket.SOCK_DGRAM:
sock.connect((dest, port))
sock.send(b"\x00" * 32)
else:
try:
sock.connect((dest, port))
except BlockingIOError:
pass
except OSError as exc:
sock.close()
return None, None, "local error: %s" % exc.strerror
readers = [sock] + listener.extra_readers()
writers = [] if kind == socket.SOCK_DGRAM else [sock]
deadline = time.time() + timeout
icmp = state = None
while time.time() < deadline:
ready_r, ready_w, ready_x = select.select(
readers, writers, [sock], max(0.01, deadline - time.time()))
if not (ready_r or ready_w or ready_x):
continue
# Drain the error queue first, always. An ICMP error reaches a TCP
# socket as a plain errno, so SO_ERROR on its own cannot tell you
# whether a router spoke or the far end did.
icmp = listener.collect(sock, family)
if icmp:
break
if ready_w:
err = sock.getsockopt(socket.SOL_SOCKET, socket.SO_ERROR)
if err == 0:
state = "connected"
elif err == errno.ECONNREFUSED:
state = "TCP reset"
else:
state = os.strerror(err)
break
sock.close()
if icmp or state:
return icmp, state, None
return None, None, "no reply"
def walk(dest, port, proto, family, first, last, timeout, listener):
print("walking to %s %s/%d hop limit %d-%d" % (dest, proto.upper(), port, first, last))
answered = []
for hop in range(first, last + 1):
started = time.time()
icmp, state, _ = probe(dest, port, proto, family, hop, timeout, listener)
rtt = (time.time() - started) * 1000
if icmp:
addr, icmp_type, icmp_code = icmp
print(" %2d %-39s %7.1f ms ICMP %d/%d %s"
% (hop, addr or "?", rtt, icmp_type, icmp_code,
describe(family, icmp_type, icmp_code)))
if is_expiry(family, icmp_type):
answered.append((hop, addr))
else:
return answered, hop, "icmp-reject", addr
elif state:
print(" %2d %-39s %7.1f ms %s" % (hop, dest, rtt, state))
return answered, hop, state, dest
else:
print(" %2d *" % hop)
return answered, None, "silent", None
def main():
parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
parser.add_argument("host")
parser.add_argument("port", nargs="?", type=int, default=443)
parser.add_argument("--proto", choices=("tcp", "udp"), default="tcp")
parser.add_argument("--first", type=int, default=1, help="hop limit to start at")
parser.add_argument("--max", type=int, default=20, help="hop limit to stop at")
parser.add_argument("--wait", type=float, default=2.0, help="seconds to wait per hop")
parser.add_argument("-6", dest="v6", action="store_true", help="force IPv6")
parser.add_argument("-4", dest="v4", action="store_true", help="force IPv4")
args = parser.parse_args()
family = socket.AF_INET6 if args.v6 else socket.AF_INET
kind = socket.SOCK_STREAM if args.proto == "tcp" else socket.SOCK_DGRAM
dest = socket.getaddrinfo(args.host, args.port, family, kind)[0][4][0]
if sys.platform.startswith("linux"):
listener = ErrorQueue()
else:
try:
listener = RawIcmp(family)
except PermissionError:
sys.exit("%s cannot report ICMP errors on a normal socket, so this "
"needs a raw one. Run it as root." % sys.platform)
answered, stop, why, who = walk(dest, args.port, args.proto, family,
args.first, args.max, args.wait, listener)
what = "%s/%d" % (args.proto.upper(), args.port)
print()
if why == "connected":
print("Verdict: %s is open. It answered at hop %d." % (what, stop))
elif why == "icmp-reject":
print("Verdict: %s at hop %d is refusing %s on policy, and is honest "
"enough to say so." % (who, stop, what))
elif why == "TCP reset":
print("Verdict: a reset came back to a probe with a hop limit of %d." % stop)
print(" Nothing more than %s away can have sent it, so check the reply"
% ("one hop" if stop == 1 else "%d hops" % stop))
print(" TTL before you believe the host did.")
elif answered:
last_hop, last_addr = answered[-1]
print("Verdict: answers stop after hop %d (%s)." % (last_hop, last_addr))
print(" Whatever swallows %s is hop %d." % (what, last_hop + 1))
print(" Walk a port that works and read off the address at hop %d."
% (last_hop + 1))
else:
print("Verdict: nothing answered at all, not even the first hop. Either the")
print(" first hop is the one dropping you, or the ICMP errors are being")
print(" filtered on the way back. Walk a port that works to tell those")
print(" two apart.")
if __name__ == "__main__":
main()
它告诉不了你什么
这个方法成本低,在大多数事情上也很诚实,但它不是拓扑扫描器。在工单里老老实实说清楚你实际测到了什么。
不同的五元组可能走不同的路径。 ECMP 把源端口和目的端口哈希进下一跳的选择里,所以在两个不同端口上的两次运行根本不保证经过相同的路由器,这也是能解释上面第 5 跳在一次运行中应答、在另一次中沉默的两种可能之一。两次运行都重复几遍。一个会移动的边界是没有得到证明的。
MPLS 会把跳藏起来。 一个标签交换的核心网可能表现为一跳,也可能一跳都不显示。任何穿过别人骨干网的计数都只是一个下限。
ICMP 的生成几乎到处都被限速。 探测得比路由器愿意应答的更快,你就会自己制造出星号来。hopfind.py 每跳发一个探测,然后等待;这是有意的。
回程路径不一定和去程一样。 去程的跳数不等于回程的跳数,反向 TTL 算术测的只是回程那一段。
Anycast 意味着第 N 跳的主机两次可能不是同一台机器。 尤其是公共解析器和 CDN。
握手完成并不意味着会话能活下去。 一台有状态防火墙可以放行 SYN,再在检查后丢掉后续的包。如果连接建立了然后死掉,那这就是用错了仪器:去抓包。
你找到的是第一台丢包的设备,而不是会有人承认的那一台。 在 CGN 或运营商网络里,第 N+1 跳的地址可能是一个地址背后的好几台设备之一。它仍然是该写进工单的东西,因为它是关于这条路径的一个事实。
它到底是干什么用的
结束踢皮球。这就是这番功夫的全部回报。
“445 端口在某个地方被挡了”是在邀请别人把工单退回来。这个不是:
到 192.0.2.4 的 TCP/445 在第 11 跳被静默丢弃,地址 192.0.2.31。在同一路径上,第 11 跳对 TCP/443 在 26 ms 内应答 ICMP Time Exceeded,对 445 则什么都不应答,所以这次丢弃是那台设备上的策略决定,不是路由故障。它前面的十跳都是干净的。二十分钟内复现了四次,在无特权 shell 中运行,脚本附后。
没人会把这个退回来。它点名了一台设备,说明了它做了什么,说明了它没做什么,还给出了推导过程。他们改不改,仍然由他们决定。但一个星期的来回踢球结束了,而这只用了四条命令。
这一切都来自一个 8 位的字段,它在 1981 年被规定为一个计时器,从来没有一次被当作计时器用过,却悄悄地把“某个地方”变成了一个地址。
值得学会怎么读。