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 的价值从来不是「不用打补丁」,而是「打补丁的时间可以安排在白天,而不是被凌晨的告警叫起来」。
