
Brotli 1.2.0 的 DecodeBlockTypeAndLength() 返回 BROTLI_BOOL。这个布尔值有三种失败要表达:输入不够、块类型数量不合法、块长度读取失败。修复前,三种情况都返回 BROTLI_FALSE;调用方的 BROTLI_SAFE 宏把 false 一律翻译成 BROTLI_DECODER_NEEDS_MORE_INPUT,然后保存状态、返回调用方。于是"这个块切换根本不合法"被当成了"再给点输入就好"。
调用方按"需要更多输入"的语义继续喂数据。解码器保存的状态包括 bit reader 的 val_、bit_pos_、输入指针与 block_length 等;恢复之后,它从同一个位置重新进入 ProcessCommandsInternal。如果失败是真实的输入短缺,恢复后新字节补上,SafeReadSymbol 成功,状态前进;如果失败是 max_block_type <= 1,恢复后条件没变,仍然失败。状态保存/恢复机制本身没有错,错的是它被用在一个不可能通过重试解决的错误上。流式解码器在两次调用之间保留一个八字节的内部缓冲区;真实短缺会在下一个 chunk 被消费掉,无效块切换不会------它每次都回到同一个分支,每次都被要求再喂一点,缓冲区只进不出。越过第八个字节之后,写入落到缓冲区之外。Node.js 的公告把后果写成"corrupt process memory, which can lead to a crash, disclosure of process memory, or remote code execution"。
Brotli 是 HTTP 常用的压缩格式之一,Node、Bun 与浏览器都内置解码器;解码器是 C 实现,攻击面与浏览器解析器同级。这个缺陷以 CVE-2026-111497 记录,CWE-252(未检查返回值)与 CWE-787(越界写),影响 Brotli 1.0.3--1.2.0,修复 1.0.10 / 1.1.1 / 1.2.1;Node.js 22/24/26 受影响,修复 22.23.4 / 24.22.1 / 26.12.1;2026-10-27 进入 CISA KEV。公开研究把它命名为 Node2Shell,并在 Express 与 Koa 的默认 body parser 上取得了命令执行。
这篇文章从返回值开始,不从现在常见的"堆布局、gadget、偏移"开始。越界写只是结果;根因是两种失败共用一个布尔。
一个布尔装不下两种失败
DecodeBlockTypeAndLength() 的职责是读一次块切换:从流里读一个块类型符号(Huffman 编码,变长前缀码)、读一个块长度,更新三组 ring buffer 里对应的一组。修复前的签名是:
c
// c/dec/decode.c @ v1.2.0,第 1179--1221 行(节选)
static BROTLI_INLINE BROTLI_BOOL DecodeBlockTypeAndLength(
int safe, BrotliDecoderState* s, int tree_type) {
brotli_reg_t max_block_type = s->num_block_types[tree_type];
...
if (max_block_type <= 1) {
return BROTLI_FALSE;
}
...
if (!safe) {
block_type = ReadSymbol(type_tree, br);
s->block_length[tree_type] = ReadBlockLength(len_tree, br);
} else {
BrotliBitReaderState memento;
BrotliBitReaderSaveState(br, &memento);
if (!SafeReadSymbol(type_tree, br, &block_type)) return BROTLI_FALSE;
if (!SafeReadBlockLength(s, &s->block_length[tree_type], len_tree, br)) {
...
return BROTLI_FALSE;
}
}
...
}
三处 BROTLI_FALSE 的含义完全不同。max_block_type <= 1 是格式错误:这一类只声明了一个块类型,流里却要求切换,没有可切换的目标。SafeReadSymbol 失败是输入不够:当前缓冲区里读不出一个完整的 Huffman 符号。SafeReadBlockLength 失败也是输入不够。前一种是永久的,后两种是暂时的。
调用方看不到区别。BROTLI_SAFE 宏的定义是:
c
// 同文件,第 1943--1953 行
#define BROTLI_SAFE(METHOD) \
{ \
if (safe) { \
if (!Safe##METHOD) { \
result = BROTLI_DECODER_NEEDS_MORE_INPUT; \
goto saveStateAndReturn; \
} \
} else { \
METHOD; \
} \
}
它只有一条失败路径:Safe##METHOD 为假 → NEEDS_MORE_INPUT → 保存状态返回。格式错误没有单独的出口。safe 为假时更直接:METHOD 的返回值被忽略,因为调用方认为输入一定够。unsafe 路径是性能优化:解码器先用 CheckInputAmount 确认缓冲区里有足够多的位,再走不检查的读法。问题在于"输入够"只保证"读得到位",不保证"读到的位是合法格式"。max_block_type <= 1 与输入多少无关,它在 unsafe 路径里同样会发生,只是返回值被忽略,ringbuffer 不更新,block_length 可能保持 0,命令循环再次进入同一个分支。也就是说,同一个布尔值在 safe 路径里被解释成"暂时",在 unsafe 路径里被解释成"不可能失败"。
修复的第一件事是把返回类型换成 BrotliDecoderErrorCode,把三种结果分开:
c
// c/dec/decode.c @ v1.2.1(节选)
if (max_block_type <= 1) {
return BROTLI_DECODER_ERROR_FORMAT_BLOCK_SWITCH;
}
...
if (!SafeReadSymbol(type_tree, br, &block_type)) {
return BROTLI_DECODER_NEEDS_MORE_INPUT;
}
if (!SafeReadBlockLength(...)) {
...
return BROTLI_DECODER_NEEDS_MORE_INPUT;
}
...
return BROTLI_DECODER_SUCCESS;
第二件事是新增 BROTLI_SAFE_WITH_STATUS:状态不是 SUCCESS 就保存返回,NEEDS_MORE_INPUT 与 ERROR_* 分开传播。第三件事是在 decode.h 里新增错误码 FORMAT_BLOCK_SWITCH(-17),此前这个编号是保留的。Brotli 的错误码是负整数枚举,-17 空了很久;把它分配给 block switch,说明这个错误类别之前不存在,修复新增了一个语义,没有复用旧错误。错误码新增后,调用方可以按 BROTLI_DECODER_ERROR_FORMAT_BLOCK_SWITCH 单独处理,也可以按 BROTLI_DECODER_ERROR_FORMAT_* 统一处理。三处改动合起来,才让"无效切换"不再被当成"缺输入"。
Brotli 的块与块切换
要理解无效切换为什么能构造,需要知道 Brotli 的块结构。Brotli 把压缩数据分成块,块分三类:literal(字面量)、insert-and-copy command(插入/复制命令)、distance(距离)。每一类有自己的块类型表、自己的块类型数量 num_block_types[tree_type]、自己的块长度计数器 block_length[tree_type]。
Brotli 的比特流按位读取,位序是低位优先。解码器用一个 64 位累加器保存当前可用的位:BrotliBitReader 里有 val_(64 位值)、bit_pos_(已消费的位数)、bit_end_pos_、输入指针与长度。每次需要更多位时,BrotliFillBitWindow 从未消费的输入里再读几个字节进 val_,把 bit_pos_ 前移。解码器消费过的位从低位丢弃,未消费的位留在累加器里;只要还有未消费的位,下一次填充就不会覆盖它们。
"八字节内部缓冲区"指的就是这个 64 位累加器。它不是业务数据结构,是 bit reader 的滑动窗口:正常情况下,解码器每次读一个符号都会消费若干位,窗口向前滑动;输入不够时,解码器保存状态返回,下一次调用补字节进来,窗口继续。异常情况下,解码器读不到符号却不消费,窗口不滑动,补进来的字节只能往后堆,堆到第八个字节之后就没有位置了。
解码时,每一类维护一个"当前块还剩多少符号"的计数器。计数器归零,解码器就从流里读一次 block switch:一个块类型符号、一个块长度。块类型符号是一个相对编码,不是直接的类型编号:0 表示"沿用上一个类型",1 表示"上一个类型加一",大于等于 2 表示"减去 2 后的绝对类型"。读出来的类型再对 max_block_type 取模,落到合法范围。
块类型符号的三种取值对应三种"相对":0 表示沿用 ring buffer 里更早的那个类型,1 表示在更早类型上加一,2 及以上表示绝对类型减二。ring buffer 每一项保存两个历史值(ringbuffer[0] 是上一个、ringbuffer[1] 是上上个),新的切换把历史往前挪一格。这样编码的好处是常见的"切换回上一个类型"只需要几位;代价是解码器必须维护历史,且历史必须与 max_block_type 一致。
这套编码的合法性依赖一个前提:max_block_type >= 2。如果某一类只声明了一个块类型,就没有"另一个类型"可切;流里出现该类的 block switch,按格式定义就是无效的。修复前的代码用 if (max_block_type <= 1) return BROTLI_FALSE; 表达这个判断------判断本身是对的,错的是返回值的语义。
构造一个触发流,需要让某一类的 num_block_types 为 1,然后在流里放一个该类的 block switch。Brotli 的 meta-block(顶层数据单元)头会声明三类各自的块类型数量;格式本身允许某一类只有一种类型(这时所有块都是同一类型,正常流不会出现该类的 block switch)。攻击者可以在头里声明 1,然后在命令流里放一个该类的切换符号------这在语义上是自相矛盾的,解码器应当把它当成格式错误。
meta-block 还带 meta_block_remaining_len,表示这个 meta-block 解压后还有多少字节。修复 diff 在 BrotliDecoderDecompressStream 里加了一条 DCHECK:s->meta_block_remaining_len <= (int)BROTLI_BLOCK_SIZE_CAP。这条断言不是随手加的;它说明无效块切换还可能让剩余长度进入异常范围,后续的 ring buffer 位置计算依赖这个值。具体怎么编码、放在哪个 meta-block、需要多少位,属于格式细节;公开分析没有给出完整 payload,这里也不复述。能确认的是条件:单一块类型 + 块切换。
无效切换被当成缺输入
把调用方与解码器的交互画出来,问题更清楚。流式 API 是 BrotliDecoderDecompressStream(state, &available_in, &next_in, &available_out, &next_out, &total_out):调用方给一段输入、一段输出空间,解码器返回 SUCCESS、NEEDS_MORE_INPUT、NEEDS_MORE_OUTPUT 或 ERROR。这个 API 的设计是"状态机 + 外部驱动":解码器不阻塞、不自己读 socket,调用方负责在 NEEDS_MORE_INPUT 时补数据、在 NEEDS_MORE_OUTPUT 时扩输出。NEEDS_MORE_INPUT 的语义是"当前状态还缺字节,补了就能继续";它不是"格式不对,别再试了"。两者的区别,决定了调用方是继续循环还是报错退出。调用方看到 NEEDS_MORE_INPUT 就再喂一段;看到 ERROR 就停止。
修复前的 safe 路径还有一个细节:SafeReadSymbol 与 SafeReadBlockLength 在失败前会保存 bit reader 的 memento,失败时恢复。这个恢复是为了"这次没读成功,下次从同一个位置重试";它假设失败是"输入不够",重试时会有更多输入。对格式错误来说,恢复没有意义:同一个位置、同一段字节,再试多少次都是同一个错误。代码却把它当成可重试的暂时失败,恢复了状态,交给了调用方。
修复前的路径是:
ProcessCommandsInternal()发现block_length[1] == 0,调用BROTLI_SAFE(DecodeCommandBlockSwitch(s))。BROTLI_SAFE调SafeDecodeCommandBlockSwitch(),后者调DecodeBlockTypeAndLength(safe=1, ...)。max_block_type <= 1,返回BROTLI_FALSE。BROTLI_SAFE把假值翻译成NEEDS_MORE_INPUT,goto saveStateAndReturn。- 解码器保存 bit reader 状态、返回调用方。
- 调用方看到
NEEDS_MORE_INPUT,补一段输入,再次调用。 - 解码器恢复状态,回到同一个
block_length[1] == 0,再次走 1--5。
关键在于第 5 步保存了什么、第 6 步补了什么。bit reader 的状态包含一个 64 位的累加器:解码器把输入字节读进这个累加器,按位消费;消费过的位从低位丢弃,未消费的位留在里面。真实短缺时,下一次调用补进来的字节会被累加器接住,凑够一个符号后继续消费,累加器排空。无效切换时,解码器根本没有消费------它一进入分支就返回了;累加器里的字节一直留着,新补的字节继续往里塞。
八字节是累加器的容量。前八个字节还能放进去;超过八个字节,写入就落到累加器之外。Node.js 公告的措辞是 "the streaming decoder kept appending input bytes to an eight-byte internal buffer";ELLIO 的分析把它写成 "past the eighth byte the writes land outside it"。两句话描述的是同一个动作:缓冲区没有排空,追加没有上限。
这也解释了为什么单看 ringbuffer[1] = block_type 找不到越界。那行代码的下标是固定的(tree_type * 2 + 1,最大 5),block_type 也被 max_block_type 约束。越界不在业务数组里,在 bit reader 的缓冲区里;它不是一次下标算错,是"重复进入同一状态"的累积。
八字节缓冲区与越界写
公开分析把写原语描述得更具体:写相对于 ring buffer,使用 32 位有符号位移,向大约 ±2GB 的范围内复制 16 字节攻击者内容。这个描述对应的是解码器在状态机错位后执行的写指令;具体是哪一条指令、位移怎么由流控制,属于公开研究的堆分析,这里不复述偏移与 gadget。
把"八字节缓冲区溢出"与"相对 ring buffer 的 16 字节写"放在一起,可以理解利用的形状:
- 溢出发生在 bit reader 的累加器附近,攻击者通过持续输入控制溢出的字节内容。
- 溢出改变相邻的解码器状态(指针、长度、ring buffer 位置),让后续的写落到攻击者选定的地址附近。
- 写是 16 字节、相对 ring buffer(输出环形缓冲区)、32 位有符号位移,所以目标范围大约在 ring buffer 前后 2GB。
这不是"一次越界写直接改返回地址"的简单利用。它需要堆布局、目标二进制、可预测的地址;公开分析在官方 Node 构建上做了大量尝试,才在部分条件下拿到 shell。把这条链写成"发一个压缩包就 RCE"会高估可靠性;写成"只能崩溃"会低估影响。准确的表述是:越界写是稳定的,RCE 依赖环境。
公开分析对环境的描述需要单独看。官方 Node 构建是非 PIE(Position Independent Executable,位置无关可执行文件),代码段、GOT(全局偏移表,存放外部符号地址)与库入口都在固定地址;ASLR(地址空间布局随机化)只随机化堆、线程栈、分配器 arena。supervisor 是进程管理器,worker 退出后负责拉起新进程。攻击者需要的是"让 16 字节写落在可控的堆对象上",不是"猜代码地址";堆布局每次启动都变,所以需要多次尝试。失败通常 segfault(段错误),supervisor 重启 worker;重启后的进程是一个新的布局,攻击者再试。这个"崩溃---重启---再试"的循环,是公开分析能在几次内成功的原因,也是防守方看到的现象。
CVE 记录给了两个 CWE,配对很准确:CWE-252 是根因(未检查返回值/错误分类合并),CWE-787 是后果(越界写)。这种配对在解析器漏洞里很常见:一个返回值被吞掉,后面跟着一个内存错误。审稿时如果只盯 CWE-787,会去找"哪个数组越界";只盯 CWE-252,会去找"哪个返回值没检查"。两个一起看,才会问"这个返回值能不能表达所有失败"。CVSS 4.0 给 9.2,向量里 AT:P(攻击要求存在)反映了利用需要特定条件;AC:L 表示攻击者不需要复杂的时序竞争。这个组合说明"触发容易、利用有条件"。
Node 的暴露面
Brotli 是压缩格式,Node.js 通过 node:zlib 暴露解码器。任何把攻击者可控的字节交给 Brotli 解压的应用都受影响,但"应用有没有 import brotli"不是判断标准。常见的三个入口是:
第一,HTTP 请求体。反向代理与框架之间还有一层:nginx 可能根据 Content-Encoding 做缓冲或透传,CDN 可能自己解压再转发。攻击者要确保恶意字节原样到达 Node 的解压器;如果中间层解压了,攻击面会转移到中间层(中间层可能用别的 Brotli 实现,也可能根本不支持 br)。判断一个请求有没有到达 Node 解码器,不能只看客户端发了什么,要看代理配置。Express 5 与 body-parser 2.x 会解压 Content-Encoding: br 的请求体;任何客户端都能发一个带这个头的请求。body-parser 的流程是:读 Content-Encoding,选对应的解压器,把请求体流式喂给解压器,解压结果交给 JSON/urlencoded 解析。攻击者控制的是整个请求体,也就控制了喂给 Brotli 的字节序列;解压发生在路由处理之前,应用代码还没有机会拒绝。裸 Node HTTP server 不会自动解压,但很多框架会。
第二,HTTP 响应。fetch() 自动解压 Brotli 响应;Node 的 undici(内置 HTTP 客户端)实现会在收到 Content-Encoding: br 时解码,应用拿到的是解压后的 body。攻击者不需要直接访问应用,只要让应用去请求一个自己控制的 URL(webhook 回调、图片代理、URL 预览、RSS 抓取),就能把恶意 Brotli 数据送进解码器。这类"服务端请求用户提供的 URL"的功能,在 SSRF 讨论里常被关注网络可达性,很少被关注"响应解压";这个 CVE 把后者也变成了攻击面。如果应用调用用户提供的 URL(webhook、图片代理、URL 预览),攻击者控制或攻破的上游可以在响应里放恶意 Brotli 数据。
第三,直接使用 node:zlib。任何把不可信输入传给 brotliDecompress/brotliDecompressSync 的代码路径都受影响;这包括自己写的中间件、日志解压、缓存解压。
判断暴露面时,要沿着数据流问:这段字节从哪里来、经过哪些解压、解压结果给谁。只要中间有一次"攻击者可控的 Brotli 解压",就落在这个 CVE 的范围内。反过来,如果应用只解压自己生成的、签名校验过的数据,攻击者不能控制字节,触发条件不成立。
还有一个容易忽略的边界:一次性解压与流式解压的行为不同。流式路径的触发还依赖调用方分块的方式:如果调用方一次把整个 body 交给解码器,解码器可能在同一次调用里读完并返回错误;如果调用方按 16KB 或 64KB 分块,无效切换会在多次调用之间反复进入。不同的 body parser、不同的 highWaterMark、不同的反向代理缓冲,都会改变分块方式。这解释了为什么同一个 payload 在不同框架上表现不同:不是漏洞不同,是喂数据的节奏不同。
还有一个容易忽略的边界:一次性解压与流式解压的行为不同。brotliDecompressSync 一次给完整输入,解码器可能在一次调用里读完并报错,不一定经历"反复补数据"的循环;流式 API(createBrotliDecompress、HTTP body parser)才会进入"NEEDS_MORE_INPUT → 补数据 → 再进入"的循环。公告与公开分析针对的是流式路径;判断暴露面时,"是不是流式"与"数据可不可控"同样重要。只要中间有一次"攻击者可控的 Brotli 解压",就落在这个 CVE 的范围内。Node 的公告把受影响线写成 26.x、24.x、22.x;修复版本是 26.12.1、24.22.1、22.23.4;Bun 1.4.4。交付方式也很简单:一个 Content-Encoding: br 的 POST,body 是恶意 Brotli 流;不需要伪造 TLS、不需要认证、不需要诱导用户点击。对暴露在公网的 Express 服务,这是一个可以直接对着端口发的请求。
从崩溃到 RCE
公开研究的时间线很短。10 月 21 日 Node.js 发布修复;10 月 22 日首个 PoC 出现,只对故意削弱的测试构建成功。削弱构建通常指关掉 ASLR、换调试分配器、或让堆布局可预测;它证明"漏洞可触发、写原语可用",但不证明"官方构建可稳定 RCE"。同一天稍后,研究者才在官方镜像上拿到代码执行。这个顺序在内存破坏漏洞里很常见:先证明原语,再解决利用工程。同一天,研究者报告在官方 Node 24.22.0 Linux arm64 上取得代码执行。这个速度说明两件事:触发条件不难理解(单一块类型 + 块切换),利用工程的难点在堆布局而不是漏洞理解。防守方不能把"没有公开 exploit"当作缓冲期;从公告到可用利用只有一天。10 月 22 日,第一个 PoC 只对"故意削弱"的测试构建成功;同一天,研究者报告在官方、未修改的 Node 24.22.0 Linux arm64 镜像上取得代码执行,但不是每次尝试都成功;24.22.1 拒绝同一输入。Aikido 的公告把这条记录写成"public research has moved fast",并提醒当时还没有在野利用的报告。
ELLIO 的分析给了更多利用细节:官方 Node 构建是非 PIE,二进制加载地址固定,gadget、库入口、字符串都在链接器放好的位置;ASLR(地址空间布局随机化)只随机化堆、线程栈、分配器 arena。攻击需要匹配的正是堆布局,所以每次尝试都是一次布局猜测;失败通常 segfault,supervisor 重启 worker,重启又给了一次尝试。公开测量是:ASLR 开启时大约第 5 次成功;关闭 ASLR 时 60 次没有命中。这两个数字是单次测量,不作为稳定统计,只代表公开记录;堆布局每次启动都由分配器重新决定。(这个结果与直觉相反,作者的解释是固定布局反而要求更精确的匹配)。
公开分析在 Express.json() 与 Koa 3 + @koa/bodyparser 6 上取得了 RCE,shell 以服务账号运行,文件描述符指向攻击者连接。这个细节说明利用不是"反弹到外部 IP":攻击者已经在一条 TCP 连接上,shell 直接把这条连接的 fd 当成 stdin/stdout,省去了出站连接与防火墙的变量。对防守方来说,这意味着"没有异常出站连接"不能排除利用;shell 可能就挂在原本的 HTTP 连接上。
公开分析还提到两个目标相关值:接受的 socket 编号与堆布局。socket 编号决定 shell 的 fd 指向哪里,堆布局决定 16 字节写落在哪里。两者都对,才有 shell;错一个,通常变成 worker 崩溃、supervisor 重启。重启不是防守方的胜利,它只是给攻击者下一次尝试;公开测量在 ASLR 开启时大约第 5 次成功。这个结果说明:不需要应用显式调用 Brotli,默认的 body parser 就够了。也说明利用的终点是"服务账号的 shell",不是"容器逃逸";影响取决于服务账号的权限与容器配置。
这些结果都来自公开材料,没有在本项目复现。把它们写成"Node 默认配置就能稳定 RCE"会夸大;写成"只是崩溃"会低估。准确的说法是:触发是确定的,RCE 是条件性的,公开研究已经在常见框架上走通。
补丁、版本与检测
修复的形态是"把三态补回来",不是"加一个边界检查"。DecodeBlockTypeAndLength 的三处失败现在各自有名字:FORMAT_BLOCK_SWITCH 是永久错误,NEEDS_MORE_INPUT 是暂时状态,SUCCESS 是继续。调用方不再需要猜一个布尔的含义;它拿到的枚举直接告诉它"停"还是"补"。这也是为什么修复没有动 ringbuffer[1] = block_type 那一行:下标本来就没问题,问题在"什么情况下允许继续"。代码审阅时,如果只沿着数组下标找越界,会漏掉这类"状态机重复导致缓冲区累积"的路径;反过来,先看错误码与状态转换,再看向下标,更容易找到根因。
从工程角度看,这类修复比加检查更难写,因为它要求改调用链上的所有返回类型。DecodeBlockTypeAndLength 被三个 Decode*BlockSwitchInternal 调用,后者被 BROTLI_SAFE 调用;返回值一改,宏也要改,调用点也要改。修复 diff 里新增 BROTLI_SAFE_WITH_STATUS、把三个 BROTLI_SAFE 调用换掉,就是这条链的代价。代价高,但比"在越界写前加一个 if"更接近根因:后者只能挡住已知的那一条路径,前者让所有"格式错误 vs 缺输入"的分支都得到正确分类。DecodeBlockTypeAndLength 返回 BrotliDecoderErrorCode;max_block_type <= 1 返回 FORMAT_BLOCK_SWITCH;SafeReadSymbol/SafeReadBlockLength 返回 NEEDS_MORE_INPUT;BROTLI_SAFE_WITH_STATUS 把非 SUCCESS 的状态保存并返回。decode.h 新增错误码 -17,CHANGELOG 在 1.2.1 的 SECURITY 段标注 CVE-2026-111497。
版本边界有三层。Brotli 库:1.0.3--1.2.0 受影响,修复 1.0.10 / 1.1.1 / 1.2.1;1.0.x 与 1.1.x 是维护分支,修复同时回移到这两条线,说明旧分支仍在被使用。Node.js:22.x / 24.x / 26.x 受影响,修复 22.23.4 / 24.22.1 / 26.12.1;EOL 的 25.x、23.x、20.x 及更早没有修复,升级到受支持线是唯一路径。捆绑 Brotli 的软件:需要各自更新,例如用 native 模块、静态链接 Brotli 的压缩中间件、自己 vendored 的解码器;这些不在 Node 的版本号里。Brotli 库:1.0.3--1.2.0 受影响,修复 1.0.10 / 1.1.1 / 1.2.1。Node.js:22.x / 24.x / 26.x 受影响,修复 22.23.4 / 24.22.1 / 26.12.1;EOL 线没有修复。捆绑 Brotli 的软件:需要各自更新,不能只看 Node 版本。CISA KEV 在 2026-10-27 收录,说明已有在野利用观测。
检测的落点在"谁在解压"。日志之外,还有一层"版本清点":Node 的 process.versions.brotli 能看到内置 Brotli 版本;依赖自带的 Brotli 要看 lockfile 与 native 模块;容器镜像要重新构建,不能只改基础镜像标签。公开分析提到 Node 24.22.1 拒绝同一输入,这是最直接的验证:升级后重放同一请求,如果不再崩溃、返回解压错误,说明修复生效。除了请求/响应字段,还要看 Node 进程的生命周期:worker 是否在短时间内反复重启、是否有 core dump、dmesg 是否有同一二进制的 segfault、容器是否被编排系统反复拉起。公开分析把"崩溃---重启"描述成利用的一部分;对防守方,这是最容易观测到的信号,因为成功利用之前的失败尝试会留下重启记录。日志里可以看的字段包括:请求的 Content-Encoding、请求体长度、解压后长度、解压耗时、解压错误码;响应的 Content-Encoding、上游 URL、解压错误。异常模式是:很小的 Content-Encoding: br 请求体、解压后长度异常、解压器报格式错误但连接被复用、worker 周期性重启。Node 进程的 core dump 或 dmesg 里的 segfault 记录也是信号,尤其是同一 worker 反复在同一路径崩溃。请求侧看 Content-Encoding: br 的 POST/PUT,尤其是 body 很小但解压后很大、或解压失败的请求;响应侧看应用是否在拉取用户提供的 URL 并解压 Brotli 响应;进程侧看 Node worker 是否异常重启、是否出现段错误、是否派生 shell。公开分析提到利用失败会 segfault、supervisor 重启,这种"周期性崩溃 + 重启"本身就是信号。
补丁的测试也能说明修法。Brotli 的修复没有加一个新的边界检查,而是把返回值类型改掉,让编译器帮助调用方处理三态;BROTLI_SAFE_WITH_STATUS 的 goto saveStateAndReturn 在 ERROR_* 与 NEEDS_MORE_INPUT 上都保存状态,但返回给调用方的 result 不同:前者让调用方停止,后者让调用方补数据。这个区分是修复的核心,不是附属改动。
缓解措施按优先级排:升级到修复版本;无法升级时,在反向代理或框架层拒绝 Content-Encoding: br 的请求,或限制请求体大小与解压后大小;对服务端发起的 URL 请求,限制响应大小与 Content-Encoding,不要自动解压不可信来源的压缩数据。这些缓解的共同点是"不让攻击者控制的字节进入解码器",不是"让解码器更安全"。
补丁之后仍要注意两件事。第一,EOL 的 Node 线没有修复,升级到受支持版本是唯一路径;如果业务被钉在 EOL 线,反向代理层拒绝 Content-Encoding: br 是临时替代,不是等价修复。第二,Brotli 是库,不是服务;即使 Node 升级了,应用依赖里捆绑的旧 Brotli(例如某些 native 模块、某些压缩中间件)仍可能带着旧解码器。核对版本时要把 Node 内置的 Brotli 与依赖自带的 Brotli 分开看。
回到返回值。一个布尔值装不下"暂时"与"永久"两种失败,调用方只能选一种解释;选了"暂时",状态机就不前进;不前进就会重复;重复就会累积;累积就会越界。越界写是结果,错误分类是原因。修复没有改业务数组的下标,也没有加一个 if (offset < size);它把返回值从两态改成三态,让"永久错误"有地方可去。这个修法比补一个边界检查更接近根因,也更难被下一个类似输入绕过。它也给其他解码器一个可复用的检查项:凡是同一返回值同时表示"暂时"与"永久"的 API,都应当看一眼调用方是不是只能选一种解释;选错的那一种,往往就是状态机不前进的起点;状态机不前进,缓冲区就会替你前进。入口只是一个 Content-Encoding: br 的请求,默认 body parser 会替应用解压。