第一次用抓包工具的人几乎都会遇到同样的困惑:明明只点了一次刷新,列表里却出现了一串包;一个响应在工具里被标成“重组后的第 1 段到第 4 段”;统计出来的字节数和页面大小差了好几倍;偶尔还能看到两个一模一样的请求。于是开始怀疑工具坏了,或者怀疑服务端偷偷发了两次。

这些“对不上”大多不是故障,而是视角问题。抓包工具看到的是链路上一段一段的字节,你的直觉想的是“一个请求”“一个页面”。中间隔着 TCP 的分段、HTTP 的编码、内容的压缩,还有抓包点本身的位置。任何一层没对齐,数字就会对不上。

这篇不教你怎么点界面,而是把“对不上”的几种常见来源逐个拆开:为什么一次发送会被切成多次接收,为什么响应的字节数不等于页面大小,为什么一条连接上有多个请求,为什么同一个包会出现两次,以及为什么两端抓到的包时间差得离谱。

现象:四个包不等于四件事

先说最基础的一层误解:包的数量和请求的数量没有对应关系。一个 HTTP 请求在发送时会被 TCP 按最大报文段长度切成若干段,每段一个包;响应体更大,会被切成更多段。十段响应在抓包列表里就是十行,但它们属于同一个响应,不是十个请求。

反过来也成立:一条 TCP 连接上可以连续发多个请求,抓包里这些请求各占若干段,但连接只有一条。所以“包数多”既可能意味着内容大,也可能意味着请求多,还可能只是重传。只看数量,什么结论都得不出来。

还有一层是抓包点。你在自己机器上抓,只能看到本机网卡进出的流量;在交换机镜像口抓,能看到整个网段的流量;在服务端抓,看到的是经过所有中间设备之后的样子。同一个请求,这三个位置看到的源地址、包数、甚至内容都可能不同。抓包前先问“我在哪儿看”,比看什么更重要。

抓包抓的到底是什么

抓包工具做的事情,本质是把网卡收到的帧复制一份交给上层解析。它能看到链路层头、IP 头、TCP 头,以及这些头后面的载荷。载荷是不是 HTTP,要靠端口和内容判断;如果流量经过加密,载荷就是一串看不懂的字节,只能看到握手和包长。

所以抓包能看到的东西分三类:一是头部元数据,源地址、目的地址、端口、序号、标志位、窗口;二是明文载荷,比如没加密的 HTTP;三是时序信息,每个包到达的时间。第三类最容易被忽略,但它才是排查延迟问题的关键。

还有一件事抓不到:应用内部的因果。你看到服务端回了一个 500,但不知道为什么;看到客户端发了重试,但不知道是哪段代码触发的。抓包给的是“网络上发生了什么”,不是“程序为什么这么做”。两者要配合日志才能得出结论。

时间戳也要打个折扣。抓包记录的是本机看到这个包的时刻,不是它离开发送方的时刻。排队、中断、复制到缓冲区都会带来偏差,高流量下这种偏差可以到毫秒级。把抓包的时间戳和应用日志的时间戳直接相减,得出“服务端处理花了三秒”这样的结论,往往是不成立的。

本机没有安装可用的 Wireshark 或 tcpdump 环境,所以这一篇不展示任何抓包软件的界面和过滤表达式,也不编造它们的输出。下面用的都是用户态代码:在应用层收发字节,观察“一次发送、多次接收”这类现象。它和网卡级抓包看到的东西不完全一样,但对理解“对不上”已经够用。

走查:一次请求在时间轴上的六段

从点击到内容落地
解析域名UDP 一问一答,可能命中缓存,也可能逐级递归
建立连接三次握手,三个包,耗时一个往返
安全握手HTTPS 再叠加 TLS,证书和密钥协商,多几个往返
发送请求请求头加请求体,可能被切成一段或多段
接收响应头先到,体分段到,按长度或分块规则拼起来
渲染取资源页面里的脚本和图片各自再发请求,复用同一条连接

第一段和后面几段在抓包里属于完全不同的流。域名解析走 UDP,端口 53,包很短;后面的连接走 TCP,端口通常是 80 或 443。把两类包混在一起看,就会觉得“请求怎么发了这么多”。按协议或端口分开,时间轴才清楚。

第三段的包长很有特点。握手初期客户端会发一个较大的包,里面是它能支持的加密套件和扩展;服务端回的证书可能被拆成好几段。这些包在列表里显得突兀,但它们属于握手,不是业务数据。看不懂时先按“握手阶段”整段跳过,别把证书当成响应体。

第四段的请求头往往比想象中大。Cookie、User-Agent、Accept 这些加起来几百字节很常见,如果超过最大报文段长度,就会被切成两段,第二段可能只有几十字节。于是你看到“请求被拆成两个包”,以为有两条请求,实际上只是头太长。

第五段的响应体是“对不上”的重灾区。它可能被压缩、可能用分块编码、可能一边生成一边发送,长度在开始时根本不知道。抓包工具会尽量重组,但重组显示和原始字节是两回事,统计口径不同,数字自然不同。

实测一:一次发送,五次接收

写一个极小的服务端,用 4096 字节的缓冲区循环读;客户端一次发送 20000 字节。看看对端要读几次才能读完。

import socket, threading, time

s = socket.socket()
s.bind(("127.0.0.1", 0))
s.listen(1)
addr = s.getsockname()
counts = []

def srv():
    c, _ = s.accept()
    buf = b""
    while len(buf) < 20000:
        d = c.recv(4096)
        if not d:
            break
        counts.append(len(d))
        buf += d
    c.close()

threading.Thread(target=srv, daemon=True).start()
cl = socket.create_connection(addr)
cl.sendall(b"x" * 20000)
time.sleep(0.2)
cl.close()
print("发送 20000 字节,对端 recv 次数 =", len(counts))
print("每次读到的字节 =", counts)

实际输出:

发送 20000 字节,对端 recv 次数 = 5
每次读到的字节 = [4096, 4096, 4096, 4096, 3616]

客户端只调用了一次发送,对端读了五次。中间发生了什么?发送方内核把这 20000 字节按链路能承载的大小切成了若干段,接收方每次从缓冲区里取最多 4096 字节,取不够就再等下一段。所以“一次发送”和“一次接收”本来就不是一对一的关系,TCP 保证的是字节流完整有序,不保证消息边界。

这也是很多协议要自己做“消息长度”或“分隔符”的原因。如果应用假设“一次读就是一条消息”,在本地小数据量下可能一直正常,一旦数据变大或网络变慢,就会读到半条消息,解析直接崩。这类 bug 在测试环境很难复现,因为它依赖发送和接收的时序。

抓包工具里的“重组”功能,做的就是把属于同一条流的分段按序号拼回去。但重组是工具的行为,不是网络的行为。你在工具里看到一个完整的请求,不代表它在线路上是一个包;反过来,你看到很多段,也不代表有很多请求。

实测二:压缩和分块让字节数对不上

接着量两个经常让人误判的数字:页面原文字节数、压缩后的字节数,以及一段分块编码的原始样子。

import gzip, urllib.request

html = urllib.request.urlopen("https://docs.czgrzx.cn/", timeout=10).read()
gz = gzip.compress(html, 6)
print("页面原文字节 =", len(html), " gzip 后 =", len(gz), " 压缩比 = %.1f%%" % (len(gz) / len(html) * 100))

chunked = (b"HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n"
           b"7\r\nhello, \r\n5\r\nworld\r\n0\r\n\r\n")
print("chunked 原始字节 =", len(chunked))
print(chunked.decode().replace("\r\n", "\\r\\n"))

实际输出:

页面原文字节 = 10427  gzip 后 = 3384  压缩比 = 32.5%
chunked 原始字节 = 74
HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n7\r\nhello, \r\n5\r\nworld\r\n0\r\n\r\n

10427 字节的页面,压缩后只有 3384 字节,占比 32.5%。如果抓包工具统计的是“链路上实际传输的字节”,而你拿它和页面文件大小比,就会觉得少了一大截。这还没算头部:每一段都要带 IP 和 TCP 头,包的个数越多,头的总开销越大。真正的“传输量”是头和压缩后的体加在一起,不是正文大小。

第二段输出展示了分块编码的原始样子。正文是“hello, world”共 12 个字符,但原始字节有 74 个,因为每个块前面要写块长度,块之间还有回车换行,最后要用一个零长度块收尾。抓包里看到的就是这些标记,工具会帮你解成正文,但原始字节数仍然包含它们。所以“抓到的字节数”和“解出来的内容长度”天然不等。

还有一点:分块编码下没有 Content-Length。客户端无法预先知道总长度,只能一块一块读,直到读到结束标记。这也意味着进度条无法给出准确百分比,除非服务端另外提供总长度。很多“下载进度卡在 99%”的问题,根源就在这儿。

实测三:一条连接,三个请求

再看连接复用带来的错觉。用前面 HTTP 那篇的原始套接字服务端,在同一条连接上连续发三个请求,客户端本地端口始终是 60393,三次响应都是 121 字节。抓包列表里会出现多组请求和响应,但连接只有一条,握手只发生了一次。

这意味着:按连接统计的日志会把三个请求算成一次会话;按请求统计的日志会出现三条记录但连接标识相同;如果中间有代理,代理可能把三个请求合并成一个上游连接,源站日志里只能看到一条连接。三种口径,三个数字,都能自洽,但互相之间对不上。

更麻烦的是重传。一个包丢了,发送方会重发,抓包里就会出现两个内容相同的包。工具通常会用序号判断并标记为“重传”,但如果工具没开这个功能,或者序号回绕、时间窗口截断,就可能显示成两个独立请求。看到“重复请求”先别怀疑业务代码,先看序号和到达时间。

另一个常见错觉来自分片。IP 层如果发生分片,一个逻辑包会被拆成多个物理帧,抓包工具会显示“分片的第 1 段”等标记。上层看到的是一个包,链路层看到的是好几个,统计字节数自然对不上。现代网络一般靠调小 MSS 避免分片,但隧道和某些老设备仍会触发。

抓包列表里请求和响应是混在一起的,同一条流上下行的包交错排列。如果只看其中一侧,就会觉得“请求发出去了,一直没回应”,其实回应就在几十行之后。按流过滤、按方向分开统计,是看懂时序的第一步。工具里通常用不同的源端口和目的端口区分方向,看错方向就会得出完全相反的结论,甚至把正常的应答当成迟到的请求。

现象对照表

现象真实原因第一步查什么
一个请求对应很多个包TCP 按最大段长切分,响应体又被拆成多段按流和序号看,而不是按包计数
抓到的字节数远小于页面大小响应体经过压缩,头部还有额外开销看 Content-Encoding,解压后再比较
原始字节里有一串长度标记分块编码,每块带长度,末尾零块结束找 Transfer-Encoding,按块解析
同一条连接出现多个请求连接复用,握手只发生一次看连接的源端口是否相同
看到两个一模一样的请求TCP 重传,或应用层自己重试对比序号和应用日志的时间
客户端发了,服务端抓不到抓包点不在同一条路径上,或流量走了别的网卡确认抓包接口和路由走向是否一致
两端的包时间差好几秒两台机器的时钟没同步先对齐时间源,再看时序
看不到请求内容,只有乱码流量经过 TLS 加密,只能看到握手和元数据确认端口和是否加密,必要时在服务端解密后看

边界与代价

抓包的第一个代价是权限和位置。普通的用户态程序看不到别人的流量,需要管理员权限或者网络设备的镜像口。在容器里抓包还要考虑网卡命名空间,抓错了接口就什么都看不到。位置选错,比不会用工具更浪费时间。

第二个代价是性能。全量抓包会把每个包复制到内核缓冲区再写到磁盘,流量大时 CPU 和磁盘都会被拖慢。生产环境通常只抓一小段时间、用过滤器缩小范围,或者用采样。抓得越全,对业务的影响越大,这是一笔必须提前算的账。

第三个代价是隐私。明文流量里可能有令牌、密码、个人信息,抓包文件本身就是敏感数据。加密流量虽然看不到内容,但元数据仍然能暴露访问关系和时间规律。抓包文件的保存、传输、销毁都应该有规矩,不能随手放在共享目录里。

第四个代价是解释成本。抓包给的是原始事实,不是结论。同一个现象可能有多种解释,必须结合日志、配置和拓扑才能定论。很多人抓到包就急着下判断,结果把“中间设备不回探测包”当成“链路断了”,把“重传”当成“服务端发了两次”。抓包的价值不在于抓,而在于能不能把一段字节讲成一个完整的故事。

当天能自己验证的练习

  1. 把“一次发送五次接收”的代码跑一遍,然后把接收缓冲区改成 1024,观察次数怎么变,理解缓冲区大小与读取次数的关系。
  2. 把发送量改成 100 字节再跑,确认这一次只读一次,说明小数据量下“看起来一对一”只是巧合。
  3. 用 gzip 把本地一个文本文件压一遍,记录原始大小和压缩后大小,算一次比例,再想想抓包统计该怎么解释。
  4. 手工拼一段分块编码的响应,用 repr 打出来,数一数正文之外的标记占了多少字节。
  5. 在浏览器开发者工具里看一个请求的“已传输”和“资源大小”,再和响应头里的 Content-Length 对比,找出三者不一致的原因。本机没有 Wireshark 和 tcpdump,网卡级抓包与重组显示未在本机实测。

小结与下一篇

抓包看到的是链路上一段一段的字节,直觉想的是一个个请求,两者之间隔着 TCP 分段、HTTP 分块、内容压缩、连接复用和重传。一次发送可能被读成五次,一个页面可能只传了三分之一的字节,一条连接上可能跑了很多请求。数字对不上时,先确认统计口径,再确认抓包位置,最后才怀疑故障。

下一篇讲抓包为什么看不到密码:HTTPS 与 TLS。抓包里最让人安心也最让人无力的,就是那串看不懂的加密字节。它是怎么谈成密钥的、证书在验什么、为什么同样的明文在不同连接里长得完全不一样,下一篇接着拆。