百度云防护 11 月 18 日规则更新:Java4Shell 虚拟补丁里的五个技术判断

11 月 18 日百度云防护上线 Java4Shell 虚拟补丁,规则只有一百来字,却藏着五个判断:为什么盯长度除以 4 余 1、为什么偏偏是 64 和 128 个字符、为什么单列 Authorization: Basic、为什么必须加字符边界。逐条拆开,顺便说清这条规则挡不住什么,以及怎么自测它在你站点上到底有没有生效。

11 月 18 日,百度云防护的规则库里多了一条新条目,标题是 Java4Shell(CVE-2026-114938)。它挂在「安全更新」列表的第一条,红色圆点标记,日期 2026-11-18。点开只有一段百来字的说明:

OpenJDK x86-64 Base64 intrinsic 在非法填充长度(总长%4==1、单个’=’)下掩码下溢并越界写。检测 query/body 以及 Authorization: Basic 中 64 或 128 个 Base64 字符后仅跟 1 个 ‘=’ 的畸形串;以非 Base64 字符作边界,避免命中合法 Base64。

大多数人扫一眼就过去了——「厂商出规则了,我有防护了」。但这段话其实是五个技术判断的压缩包。它为什么盯 %4==1?为什么是 64 和 128 这两个数字?为什么专门点出 Authorization: Basic?「以非 Base64 字符作边界」又在防什么?

这几个问题答完,你就知道这条规则能挡什么、挡不住什么。

关于漏洞本身——利用条件、三步自查、17.0.21.1 这些补丁版本——我在前一天那篇里写完了。这篇只讲规则。

顺带交代个背景:这类规则下发对用户是全自动的,不用点任何按钮。今年 6 月 23 日那批一次上了 21 条,全是 XSS;这次只上一条,但分量完全不同——它挡的是能直接拿下服务器的 RCE。

一、先看这条规则在断言什么

把那段描述拆开,是五个可以独立验证的判断:

规则里的表述 它其实在说什么
总长 %4 == 1、单个 ‘=’ 攻击流量带着一个数学上「不可能存在」的指纹,据此识别,不必理解语义
掩码下溢并越界写 根因在长度计算与掩码生成,不在字符内容本身
64 或 128 个 Base64 字符 检测窗口贴着硬件加速的处理单元走,不是拍脑袋定的长度
检测 query/body 与 Authorization: Basic 预认证场景下,攻击者最省力的三个注入点
以非 Base64 字符作边界 避免把长串内部的片段误切成独立令牌

前两条回答「凭什么能识别出来」,后三条回答「在哪识别、怎么不误伤」。分开看,规则的取舍就很清楚了。

二、%4 == 1:Base64 里唯一不可能的长度

要理解这条规则,得先回忆 Base64 的编码规则。

Base64 把每 3 个字节(24 bit)切成 4 个 6 bit 的片段,每个片段映射成一个可打印字符。所以输出长度永远是 4 的倍数。原文长度不能被 3 整除时,用 = 补齐:

原文长度 mod 3 编码后长度 填充形式
0 4n 字符 无
1 4n 字符 ==(两个)
2 4n 字符 =(一个)

无论哪种情况,编码结果的长度都是 4 的倍数。也就是说,一个「长度除以 4 余 1」的 Base64 串,在任何合规编码器里都不会被生产出来。

写成代码更直观:

import base64
for n in range(1, 13):
s = base64.b64encode(b'A' * n).decode()
print(f'{n:2} 字节 -> {s!r:24} 长度 {len(s):2} 余数 {len(s) % 4}')

跑一遍你会看到,长度一直是 4、8、12、16……余数永远是 0。没有任何一行写着 余数 1。

那 %4 == 1 到底意味着什么?意味着「4n 个字符之后,还多出 1 个孤立的字符」。而 1 个 Base64 字符只携带 6 bit,凑不出任何一个完整字节——这是一个语义上无解的状态。

绝大多数解码器遇到这种输入会直接抛异常。Java4Shell 的问题在于,那条被 AVX-512 加速的解码路径没走到异常分支:它先按「长度是 4 的倍数」这个前提算好了缓冲区大小,然后才去处理那个多出来的字符。

这就是这条 WAF 规则最聪明的地方。它不需要理解 Java、不需要识别攻击载荷、不需要知道你在跑哪个中间件。它只需要问一句:这个 Base64 串的长度,除以 4 余 1 吗? 余 1 就是畸形,不用再看别的。

误报率天然为零——除非你的业务里有个编码器本身就是坏的。

三、掩码下溢:x86 上那个「移位 64 位等于没移位」的老坑

「掩码下溢」这四个字,指向一个很具体的实现细节。

SIMD 解码的常见写法是:一次读进 64 字节,用一个 64 位掩码标记「哪些车道有有效数据」,再按掩码把结果写出去。生成掩码的典型写法有两种:

// 写法 A:显式处理 n = 64 的边界
uint64_t mask = (n == 64) ? ~0ULL : ((1ULL << n) - 1);
 
// 写法 B:看起来更简洁,但埋了雷
uint64_t mask = ~0ULL >> (64 - n);

写法 B 在 n 为 0 时会出事。x86 的移位指令有个特性:移位量按 64 取模。>> 64 在硬件上实际执行的是 >> 0,结果是全 1,而不是 0。

本该「一个字节都不写」的情况,变成了「64 个字节全部写出去」。这就是掩码下溢——不是数值溢出,是「本该收缩到零的窗口,因为一次取模翻转成了满窗」。

而 %4 == 1 恰好能把 n 推到 0:那个孤立的字符在按 4 分组时被向下取整丢掉,算出来的剩余有效字节数就是 0,于是走进这条分支,于是掩码翻转,于是往缓冲区外写了 64 字节。

这条链条解释了为什么这个漏洞「看着只是个长度校验疏忽,后果却是 RCE」——它跳过的不是一个 if,它跳过的是一整块内存边界的守门人。

也解释了规则为什么要认「单个 =」。两个 = 是合法填充(原文 mod 3 == 1),一个 = 配上 4n+1 的总长,才是那个致命组合。

四、64 和 128:为什么是这两个数字

规则限定「64 或 128 个 Base64 字符后跟 1 个 =」。这两个数字不是随便挑的。

AVX-512 的寄存器是 512 位,也就是 64 字节。一次向量化处理,输出侧正好填满一个寄存器。反推输入侧:Base64 的膨胀比是 4/3,64 字节输出对应 48 字节原始数据,编码成字符正好 64 个。

Base64 字符数 对应原文字节 解码输出字节 与 AVX-512 的关系
64 48 64 正好一个 ZMM 寄存器(512 bit)
128 96 128 两个寄存器,流水线双发

所以「64 字符」是这条 intrinsic 路径最自然的处理单元,「128」是它成对处理时的长度。攻击者要触发越界写,畸形串的长度就得卡在这两个位置上——短了走标量路径,长了被分块消化掉,只有正好落在向量边界上,那个下溢的掩码才会真的写到缓冲区外面。

规则作者显然是照着 PoC 的形态写的。这不是缺点,虚拟补丁本来就该这么写:贴着已知利用形态做精确匹配,而不是追求覆盖所有理论变体。

代价是它只认这两种长度。48 或 96 个字符的畸形串会不会触发?按这个逻辑大概率不会——不足一个完整向量宽度,走不到出问题的那条分支。但这条推论的前提是 PoC 形态完整。如果后续出现新的变体长度,规则得跟着更新。

这也是为什么「等厂商出规则」替代不了「自己打补丁」:规则的覆盖面,永远滞后于漏洞的完整攻击面。

五、为什么专门点出 Authorization: Basic

规则列了三个检测位置:query、body、Authorization: Basic。前两个是常规操作,第三个值得单说。

Basic 认证的凭据格式是 Authorization: Basic base64(user:password)。这是 HTTP 协议里唯一一个「原生就是 Base64」的头部,而且它在认证之前就被解析——服务器收到请求的第一件事就是解这个头,解完才知道你是谁。

对攻击者来说,这是最理想的注入点:

  • 不需要猜参数名。 query 和 body 得先摸清业务用了什么字段,Basic 头是协议规定的,永远存在。
  • 不需要登录。 解 Base64 发生在认证判定之前,畸形数据在「你是谁」还没确定时就已经进了解码器。
  • 覆盖面极广。 Keycloak 的 client_secret_basic、Jira 的 Basic 认证、Jenkins 的 API Token、Nexus 和 Artifactory 的仓库认证,全走这条头。

对比一下三个位置的攻击成本:

检测位置 攻击者需要知道什么 预认证可达 典型场景
query 参数名、接口路径 部分可达 有公开接口的应用
body 请求格式(JSON/表单/multipart)、字段名 部分可达 登录、搜索、上传接口
Authorization: Basic 什么都不需要 完全可达 所有走 Basic 认证的中间件

这就是规则把 Authorization: Basic 单列出来的理由。Query 和 body 得靠猜,Basic 头不用——它是协议层的固定入口,也恰好是这次受影响组件(Keycloak、Jira、Jenkins、Artifactory)共同的认证方式。

顺带把上一篇里那句「预认证可利用」说透:不需要账号,是因为解码发生在认证之前。

六、边界的讲究:不误伤合法 Base64

规则最后一句是「以非 Base64 字符作边界,避免命中合法 Base64」。这句最容易被忽略,但它决定了这条规则能不能长期挂在生产环境上。

Base64 的字符集是 A-Z a-z 0-9 + / =。如果把规则写成这样:

[A-Za-z0-9+/]{64}=

它能匹配任何「64 个 Base64 字符 + 一个等号」的片段,不管这个片段是不是一个独立令牌。现实中的 Base64 很少孤立存在——JWT 用 . 分隔三段、data URI 前面挂着 data:image/png;base64,、有些系统把两段 Base64 直接拼接当缓存键。在这些长串里,{64} 可以从任意位置起算,把内部片段切出来当成一个令牌判断。

加上边界之后,规则变成:

(?:^|[^A-Za-z0-9+/])(?:[A-Za-z0-9+/]{64}|[A-Za-z0-9+/]{128})=(?:[^A-Za-z0-9+/=]|$)

含义从「某处有 64 个字符加等号」变成「这里有一个独立的、总长 65 或 129 的 Base64 令牌」。前者是字符串搜索,后者是语义匹配。

这个区别在误报上很实在。举个真实会遇到的场景:一张图片被 base64 编码塞进 JSON,长度几千字符,末尾是 ==。不加边界,正则会沿着长串反复尝试匹配 {64}=;加了边界,起始位置前面既不是串首也不是分隔符,直接不成立。

顺带提醒:规则的字符集里没有减号和下划线这两个字符,也就是 Base64URL 变体不在检测范围内。实践中问题不大——java.util.Base64 的标准解码器不接受这两个字符,走不到 intrinsic 那条路。但如果你的业务用 URL-safe 解码器处理外部输入,别以为这条规则能兜住。

判断一条 WAF 规则成熟不成熟,就看它有没有写「边界」和「排除」。只写「匹配什么」的规则,上线三天就会被业务投诉。

七、虚拟补丁的边界:它挡不住什么

规则的逻辑到这儿已经清楚了。但有几件事必须说在前面,否则容易产生「我有 WAF 了,补丁可以往后排」的错觉。

第一,规则只看得到经过它的流量。

这是所有云 WAF 的共同前提,也是最容易被忽略的一条。百度云防护的工作方式是:域名 CNAME 到防护节点,流量先到节点再回源。如果攻击者拿到了你的源站 IP,直接连 IP 发请求,整条规则链就完全失效——他连 WAF 都不会经过。

源站 IP 泄露的途径比想象中多:历史 DNS 记录、证书透明度日志、邮件头里的 Received、同 IP 上的其他站点,甚至有些扫描器专门维护「CNAME 绕过」字典。所以「隐藏源站」本身是一项独立的安全工作,不是 WAF 的附带功能。

第二,规则认的是「形态」,形态可以变形。

规则匹配的是 query、body 和 Basic 头里的明文。但 HTTP 允许同一份数据用很多种方式表达:

  • Transfer-Encoding: chunked 分块传输,把畸形串拆到多个 chunk 里
  • multipart/form-data 把参数塞进部件体
  • 对 = 做 URL 编码(%3D),或者对整个串再做一次编码
  • 用 gzip 压缩请求体,让 WAF 先看到压缩后的字节

现代 WAF 大多会做协议归一化——先解码、先解压、先拼装,再做匹配。但归一化的深度和顺序各家不同,能不能覆盖这些变形,取决于产品实现。所以准确的说法是:它挡住的是「已知形态」,不是「这个漏洞」。

第三,也是最关键的:虚拟补丁不修复漏洞。

规则拦下的是「长得像攻击」的请求。它不改变服务器上那个有问题的 JDK,也不改变那条会下溢的掩码。一旦规则被绕过、被临时关闭(比如排查误报时)、或者攻击换了个入口(内网横向、不走 HTTP 的通道),漏洞还在原地。

正确的定位是:规则给你争取时间,不给你免责。

至于多久要打完补丁,行业通行做法是「高危 7 天内、关键 72 小时内」。Java4Shell 是 9.2 分、预认证可利用,按 72 小时算并不过分。披露是 11 月 17 日,你还有两天多。

八、给你的一份落地清单

判断说了这么多,落到操作上并不复杂。按时间分三档:

什么时候做什么 判断标准
今天,10 分钟:登录控制台,确认「安全更新」里这条规则已启用,且没被全局策略排除 规则状态为「已启用」,站点绑定的策略包含该规则集
今天,30 分钟:在 WAF 日志里按规则名过滤,看有没有命中 有命中说明已有人在扫你,立刻看来源 IP 分布;无命中属正常
今天,1 小时:用无害请求自测规则是否真的生效 见下方自测方法
本周:清点公网暴露的 Java 中间件(Jira、Jenkins、Keycloak 等) 清单落到文档,逐个确认 JDK 版本
本周:非必要的管理后台收进内网,或加 IP 白名单 外网直接访问返回 403 或超时
本月:升级到 17.0.21.1 / 21.0.13.1 等修复版本 升级后关掉临时缓解参数,观察一周再删虚拟补丁

自测规则是否生效,最稳妥的方式是打一个不存在的路径,别碰真实业务接口:

# 构造 64 个 Base64 字符 + 1 个等号(总长 65,%4 == 1)
PAYLOAD="$(printf 'A%.0s' {1..64})="
 
# 打一个不存在的路径,只看返回码
curl -s -o /dev/null -w '%{http_code}\n' \
"https://你的域名/__waf_probe_$$?x=${PAYLOAD}"

返回 403 或 405,说明规则在工作;返回 404,说明请求穿过去了——要么规则没生效,要么这个位置不在检测范围里。

再测一下 Basic 头:

curl -s -o /dev/null -w '%{http_code}\n' \
-H "Authorization: Basic ${PAYLOAD}" \
"https://你的域名/__waf_probe_$$"

两个都返回 403,才算真正覆盖。只测一个就下结论,是这类验证里最常见的疏漏。

提醒一句:自测请在有权限的资产上做,别对着别人的站点发包。

九、写在最后

一条一百来字的规则,背后是五个判断:用长度余数当指纹、用掩码下溢解释根因、用 64/128 贴着硬件边界、用 Basic 头覆盖预认证入口、用字符边界兜住误报。

厂商把这条规则推下来,用了不到一天。这个速度值得肯定——从披露到虚拟补丁,中间是「看到 PoC → 抽象出形态 → 写成正则 → 压测误报 → 全网下发」的完整链路,24 小时内走完,说明规则库的工程能力是到位的。

但速度也意味着取舍。一天做出来的规则,必然贴着 PoC 形态写,覆盖不了所有变体。它能挡住今天在扫你的那批脚本,挡不住三周后专门为绕过它而写的工具。

所以这条规则的正确用法是:今天确认它生效,然后用它换来的这三天,把 JDK 升上去。

WAF 的价值从来不是「不用打补丁」,而是「打补丁的时间可以安排在白天,而不是被凌晨的告警叫起来」。

给TA打赏
共{{data.count}}人
人已打赏
在线客服
在线客服
热线电话
QQ客服
电子邮箱
suduwangluo