Java4Shell:OpenJDK Base64 解码漏洞可致远程代码执行
我们披露 PHP2Shell 之后,发现很多人根本不了解 PHP。于是我们决定换一个大家更熟悉的目标:Java。
今天我们要披露的是 Java4Shell(CVE-2026-114938),OpenJDK Base64 解码器中的一个内存破坏漏洞。OpenJDK 是使用最广泛的 Java 运行时,按 CVSS 4.0 评分,该漏洞得分为 10 分制中的 9.2 分(严重级别)。
PHP 是一种较高级的 Web 技术,而 Java 则深入得多。Java 是全球第三大流行编程语言,支撑着90% 的财富 500 强企业,堪称现代经济跳动的心脏。银行、航空、电信,几乎所有关键行业都运行在 Java 之上,国家安全系统也不例外。
Base64 是一种非常常见的二进制数据文本表示方式,广泛用于认证协议、文件上传编码和网络消息传输。为了更快地解码 Base64,OpenJDK 使用了专门的 x86-64 CPU 指令来批量处理字节。我们在那段优化的机器级代码中发现了一个漏洞:恶意构造的输入可以覆写相邻内存。经过精心利用,这种内存破坏既能像 Heartbleed 那样泄露敏感内存,也能导致远程代码执行。触发破坏只需 64 个 A 字符加一个 =:
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=
在较旧版本的 OpenJDK 17 中,触发输入是 128 个 A 加 =。
Write once, RCE everywhere
初步测试表明,在以下广泛部署的 Java 应用的默认配置中,该漏洞可实现远程代码执行。
无需认证即可 RCE:
- Keycloak
- Atlassian Jira
- Atlassian Confluence
- JFrog Artifactory
- Jenkins
- PingFederate
需要认证后才能 RCE:
- Apache Kafka Broker
- Apache Solr
- Elasticsearch
- Gerrit
- Spinnaker
等等,Java 的 Base64 中有内存损坏漏洞?!
是的。第一次听说吗?
内存损坏是互联网上最常见的漏洞类型。但 Java 的一大卖点是内存安全。Java 代表开发者管理内存并检查内存访问,从而保护应用程序免受其他软件中常见的内存损坏 bug 的影响。
但与 PHP 和许多其他技术一样,Java 本身的大部分内容是用 C、C++ 以及本例中的汇编等低级语言编写的,在这些领域内存损坏仍是家常便饭。
为了加速 Base64 解码,OpenJDK 在支持的 x86-64 处理器上使用了专用的 AVX-512 VBMI 指令。这个 bug 位于处理最后几个字符的手工汇编代码中。对于上述 65 个字符的输入,OpenJDK 分配了一个 50 字节的结果数组。在解码前 64 个字符后,例程错误处理了多余的 = 号,并计算出负的输出长度。这个无效长度变成了一次完整的 64 字节写入操作,导致超出数组末尾 62 字节。Java 最终会拒绝该输入,但到那时,相邻的对象可能已经损坏。
半人马黑客时代
与 PHP2Shell 一样,Calif 使用 AI 发现并武器化了 Java4Shell。AI 提供了算力。我们的研究人员提供了上下文。当今最好的黑客既不是 AI 也不是人类。而是半人马黑客(centaur hacker),半人半 AI。

我们的 Quang Luong 只用了一个小时就发现了这个漏洞,又花了两个小时开发了第一个可用的利用程序。总 token 成本不到 200 美元。
值得注意的是,这个漏洞并没有通用的利用方式。具体怎么利用,取决于应用如何使用 Base64、内部逻辑是怎样的,可能需要采取不同的步骤。Calif 的团队先花时间搭建了流水线和利用策略,然后让 AI agent 据此进行初步利用,从而加速了 exploit 的开发。之后的多数利用链几乎都是 AI 自主完成的。
公地悲剧
Java 是我们都依赖的众多共享软件基础之一。多年来,它不断演进以满足各种需求。每个功能需求单独看或许都合理,但由此带来的复杂度却由所有人共同承担。需要某个功能的人得到了好处,而其他人则背上了这些代码及其风险——哪怕他们从未用过。
Java4Shell 就是一个典型例子。这次 Base64 优化对需要解码海量数据的应用有帮助,但代码同样会分发给其他所有人,包括几乎从中受益的应用。在受影响的系统上,一个少有人需要的优化变成了严重的安全隐患。
功能有用没错,大多数 bug 也能修。但为什么我们要为自己根本不需要的代码操心?
呼吁 vibe-uncoding
不需要的东西,就没必要留在你的系统里。为了处理几百字节的数据,你需要一个手写汇编的 Base64 解码器吗?大概率不需要。
今年早些时候,我们发现了 Squidbleed——Heartbleed 的“前辈”,从 1997 年起就潜伏在 Squid 代理中。漏洞出在 Squid 的 FTP 模块。可如今还有谁在用 FTP?这是个早已过时的协议,本应移除。
删代码比听起来难。一个看似无人使用的功能,背后可能藏着隐藏依赖。得有人弄清楚哪些能删、动手改掉、再测试剩余部分。
这正是 AI 能大显身手的地方——让这类工作在大规模上变得可行,而这在以前是负担不起的。
正是这位发现了 PHP2Shell 和 Java4Shell 的“半人马黑客”,可以扫描庞大的代码库,标记出死代码、臃肿的功能和多余的优化。我们称之为 vibe-uncoding:识别系统真正需要的部分,然后把其余的全部删掉,以缩小攻击面。
有了 AI,人人都在问“我们能造出什么?”但对安全而言,也许更该问的是:“我们能删掉什么?”
技术细节
- 01 Base64 的尾部陷阱
- 02 漏洞发现
- 03 漏洞原理
- 04 利用策略
- 05 堆风水(堆整理)
- 06 远程堆风水
- 07 预热、彩排与重试
- 08 局限性
- 09 概念验证
- 10 受影响产品
- 11 建议
- 12 致谢
Base64 的尾部陷阱
作者:Quang Luong
在受影响的 OpenJDK 版本中,畸形的 Base64 数据会导致堆内存被写入常量值。通过远程堆风水技术,我们将这种覆写转化为堆内存泄露,并最终实现远程代码执行(RCE)。
漏洞发现
几个月前,我曾在某手机厂商的系统上开发一个 0-click 漏洞利用。当时面临的限制很严:这是一个线性的越界写漏洞,且没有办法绕过 ASLR。我几乎以为无法利用,直到我对 Android Runtime 进行了审计。结果表明,它的内存分配模式具有一定可预测性,如果在初始内存破坏时精心对齐寄存器,就能让运行时解释攻击者的字节码。
经验教训:复杂的系统交互难以处理,而这种复杂性反而可能让难以利用的漏洞变得容易利用。
完成那条利用链后,我受此启发(且有点无聊),决定去研究完全不同的东西。于是,我拉下了官方 JVM 实现(OpenJDK HotSpot)的代码开始审计。Java 是一个成熟的平台,我知道要在这里找到一个“好”漏洞很难,但我还是想尽力一试。
回想之前“复杂系统以及跨越多个边界的代码很难做到无懈可击”的经验,我将审计重点放在 JIT 编译器、内置函数(intrinsics)、广泛可访问的 API 以及加密模块上。更准确地说,我让 Codex 像 2026 年的严肃安全研究人员那样去审计这些领域。老实说,我并不指望能找到容易直接利用的漏洞,顶多只有一些逻辑缺陷或侧信道问题。
Codex 早期给我的结果大多是垃圾,要么路径根本走不通,要么利用条件完全不现实。看起来这场赌局我要输了。但俗话说,富贵险中求,于是我只能更加卖力地 prompt……
最终,Codex 给了我一个 Base64 解码器本身的内存破坏漏洞。苦心寻找,终得真金,全靠坚持不懈。但等等,这真是金子,还是只是愚人金?
Note顺便说一句,所谓「坚持不懈」就是不停给 AI 发 prompt,无视那些垃圾结果,前后大概 20 分钟。
漏洞详情
问题出在 OpenJDK HotSpot 的 x86-64 Base64 intrinsic 上。C2 是 Java 虚拟机里最激进的 JIT 编译器——当一个函数被反复调用时,它会把该函数编译成原生代码。但即便如此,普通原生代码还是不够快。现代 CPU 提供了专门的指令,可以更高速地处理数据。HotSpot 把这些指令用在名为 intrinsic 的优化例程中。而 x86-64 的 Base64 intrinsic 在计算填充尾部的存储掩码时出了错,导致了越界写入。
x86-64 Base64 intrinsic 按 256 字节的块遍历输入;不足 256 字节时就按 64 字节的块处理。当输入小于 64 字节时,它会使用 evmovdqub,也就是 VMOVDQU8 指令对应的 intrinsic。这条指令接受一个 64 位掩码,决定哪些字节被读写。掩码先根据输入和输出长度计算出来,再根据 Base64 编码字符串中填充字符('=')的数量进行更新。伪代码如下:
// Zero High Bits Starting with Specified Bit Position
input_mask := bzhiq(-1, input_length)
output_len := (input_length / 4) * 3
// handle padding
if input[input_length - 1] == '=':
output_len -= 1
input_mask >>= 1
if input[input_length - 2] == '=':
output_len -= 1
input_mask >>= 1
output_mask := bzhiq(-1, output_len)
在上述代码中,若剩余的 input 形如 =, ==, X=, X==, XY= 或 ===,output_len 会被计算为零。但由于存在填充,output_len 会被递减,导致下溢,值为 -1 或 -2。由于当 output_len >= 64 时 bzhiq(-1, output_len) 不会改变任何位,最终结果为 output_mask == -1u64。
随后代码使用 evmovdqub 按多字节方式读写。对于写操作,如果掩码位为 1,向量寄存器中该索引处的字节将被写入内存。因此,当 output_mask == -1u64 时,在下一次操作中所有 64 个字节都会被写入:
evmovdqub(
Address(dest, dp) /* Address: destination address addr */,
k1 /* k1 == output_mask */,
tmp /* XMMRegister src register/value to write */,
true,
Assembler::AVX_512bit /* vector length */
);
生成的 stub 返回成功解码的字节数,并在检测到无效输入时提前返回。剩余字节由 Java 代码处理,如果输入无效,则会抛出 IllegalArgumentException。
在运行时,解码缓冲区长度按 (ceil(inp_len / 4) * 3) - padding 计算。当触发该漏洞时,以 65 字节([64 bytes] + '=')作为输入,该计算会分配一个 50 字节的缓冲区。在解码过程中,该漏洞使得 evmovdqub 的 output_mask == -1,因此从偏移量 48 开始写入 64 字节,造成了越过缓冲区末尾的越界写入。
在 OpenJDK 17 中,触发输入是 'A' * 128 + '=' 而不是 'A' * 64 + '=',因为到达该代码路径的长度阈值更高。
利用策略
这个 Base64 漏洞价值千金,但它不是那种躺在河床里等待淘金者捡拾的表层金矿,而是那种深埋、晦暗且难以触及的类型。虽然我们拥有内存破坏原语,但由于它仅在堆上写入固定字节,利用起来看似困难,甚至可能处于不可利用的边缘。唯一的可控点是越界写入的落点位置。
从 buffer 中原本用于写入剩余 Base64 解码字节的位置开始,我们会得到如下 64 字节的写入:
- 字节 0 完全可控(在边界内)
- 字节 1 有 4 位可控(在边界内)
- 字节 [2, 63] 不可控。其中字节
48..63的值始终为0x9a。
这个不受控的越界写入其实不算大问题。我们复用了一个常见的 JavaScript 引擎利用原语——经典的覆盖 buffer 长度技术。
我们把被覆盖长度的 buffer 称为 writer。一旦它的长度被破坏,它就会继续接受我们指定的字节,因此如果在它后面再放一个数组或对象,就能用我们想要的值破坏这个相邻对象。这就把固定写入升级成了有范围、值任选的线性写入。
接着如果我们再破坏另一个数组的长度,并且它的数据会被复制回响应中,就等于从这个越界读取构造出了堆信息泄露原语,即 reader。此时甚至还没有执行任何代码,我们就已经实现了 JavaBleed——能够泄露 Java 堆中的内容,其中可能包含 PII、私钥、其他密钥和 token。
基于 writer 和 reader,本文后续部分将构建完整的攻击链:修复被线性写入破坏的对象以保持 JVM 运行、对应用逻辑发起 data-only 攻击,并把有范围写入升级为任意写入,触及 Code Cache 和 JVM hooks 以实现代码执行。
但首先要做的是,把堆布局调整到对我们有利的状态。
替代策略从概念上讲还有其他对齐方式(例如类型混淆、通过 GC 本身控制寄存器)。由于时间有限,我们没有深入研究这些方法,而当前策略已经能很好地覆盖我们的场景。如果你发明了新方法,欢迎告诉我们。
堆风水(Heap Grooming)
G1 会把堆划分为固定大小的 region。在涉及 region 计算之前,关键数组必须先脱离其线程的私有分配范围。
HotSpot 通常为每个 Java 线程分配一个线程本地分配缓冲区(TLAB),它是 Eden 区的一块私有空间。不同请求线程创建对象时各自推进不同的游标,这意味着一个 TLAB 中的 Base64 解码器与另一个 TLAB 中的写入器之间没有有用的顺序关系。
第一层整形控制分配路径。关键数组的大小以及工作者 TLAB 中剩余的空间,决定了 HotSpot 是重新填充该 TLAB,还是采用攻击者偏好的TLAB 外部分配路径。
第二层控制布局。然而,我们无法选择 G1 如何分配内存,也不了解当前的堆状态。为了接近这一限制,Calif 采用了久经考验的“喷枪祈祷法”(Spray and Pray)。
对象大小和填充固定了 region 大小跨度内的偏移量。我们喷洒多组存活的写入器和读取器对,为解码器输出提供多个可能的邻居。当它的 region 恰好位于某个 writer region 下方时,加宽的读取器会产生更大的应用程序响应。我们丢弃未命中的尝试并重试,直到成功为止。
在漏洞利用开发早期,一个挑战是 AI 在开发堆整形原语时会陷入困境。为了节省令牌和时间,Calif 编写了一个小型堆追踪器和可视化器,为智能体提供有关堆状态的信息,并结合了我们在特定案例上的专业知识。
远程堆风水
为了执行远程整形,每个请求的数据都会发送,直到关键的堆分配发生为止。通过确保之前发送的数据获得了 TCP 确认,漏洞利用就能控制迄今的分配。一旦我们有信心目前的数据已在目标端缓冲,我们就发送剩余部分,完成 http 请求。这允许同时控制堆分配和更精确的调度,因为传输小网络数据包比传输大网络数据包更稳定。
精确的分配和释放顺序调度属于目标应用程序的配置,而我们可以控制添加、写入器、读取器和解码器部分。
当前攻击对网络状况比较敏感,比如 RTT 和抖动。更低、更稳定的往返时延能让攻击更可靠。在受控环境里,我们是直接通过公网 IP 在互联网上发起攻击的,而不是假设理想的实验室条件。为了在当前攻击路径上获得最佳的稳定性和利用成功率,Calif 没有去折腾 TCP/IP 协议栈配置,而是借助物理规律并花钱解决了问题——换句话说,Calif 在目标所在的同一区域又租了一台 VM。
预热、演练与重试
总结一下目前的利用链:先把 Base64 解码器预热到 C2 tier。在真正造成内存破坏之前,可以先对目标进行演练,校准时序和响应。拿到所需信息后,再触发漏洞。位置放错可能导致 JVM 崩溃,但多数情况下直接重试即可。
WARM持续执行合法解码,直到 JIT 选中有缺陷的快速路径,此阶段不破坏内存。REHEARSE可选的安全演练轮次,用于校准时序和响应。TRIGGER发送格式异常的尾部数据。如果对象布局恰当,固定的 spill 会撑大 writer。DISCLOSE继续驱动 writer,让选定的字节撑大 reader,然后收集由响应泄露出的堆字节。REPAIR当利用链存在修复路径时,用泄露出的原始数据恢复临时 header 和未受影响的相邻对象。FINISH完成针对具体应用的修改,并通过真实请求验证生效。局限
请求流式传输。当前的一些堆布局(grooming)手法需要部分请求体能到达应用。如果代理会等待完整请求体,就会破坏这些手法的触发时机。nginx 默认会缓冲请求体。
请求缓冲并不是通用的缓解手段。Elasticsearch 的利用链基于完整请求触发,所以这个设置挡不住它。而在配置了 WebSocket 升级之后,后续帧会走隧道直通,请求体缓冲也不再适用于它们。
应用画像。不存在通用的漏洞利用载荷。每一条攻击链都需要特定的解码器路由、存活的写入器、回传的读取器或其他反馈路径、堆内存布局以及相应的应用操作。每个目标都需要定制化的画像。该漏洞利用并非通用的“即打即用”工具。
PoC
这是一个自包含的概念验证。它先预热 Base64 解码器直至使用易受攻击的内在函数,然后将格式错误的 64 × "A" + "=" 输入解码为一个 4096 字节的数组。在受影响的 JDK 上,它会打印 REPRODUCED:解码器拒绝该输入,但解码输出之后的 62 个字节(偏移量 50 到 111)已被覆盖。由于所有写入都落在真实数组内部,因此触发器运行安全。
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.Base64;
/** 有界的独立触发器:所有写入都保持在真实的 4096 字节数组内部。 */
public final class Base64Trigger {
private static volatile int sink;
public static void main(String[] args) {
Base64.Decoder decoder = Base64.getDecoder();
byte[] valid = "A".repeat(64).getBytes(StandardCharsets.US_ASCII);
byte[] malformed = ("A".repeat(64) + "=").getBytes(StandardCharsets.US_ASCII);
byte[] target = new byte[4096];
for (int i = 0; i < 200_000; i++) {
sink += decoder.decode(valid, target);
}
Arrays.fill(target, (byte) 0x5a);
boolean rejected = false;
try {
decoder.decode(malformed, target);
} catch (IllegalArgumentException expected) {
rejected = true;
}
int changed = 0;
int first = -1;
int last = -1;
for (int i = 50; i < target.length; i++) {
if (target[i] != (byte) 0x5a) {
changed++;
if (first < 0) first = i;
last = i;
}
}
System.out.println("runtime=" + System.getProperty("java.runtime.version"));
System.out.println("vm=" + System.getProperty("java.vm.name"));
System.out.printf("rejected=%s changed=%d first=%d last=%d%n",
rejected, changed, first, last);
if (!rejected || changed != 62 || first != 50 || last != 111) {
System.err.println("NOT REPRODUCED");
System.exit(1);
}
System.out.println("REPRODUCED");
}
}
特定应用的漏洞利用细节我们暂时保留。本文介绍漏洞本身及通用的利用技术。针对各个产品的武器化攻击链将保持私有,直到大家都有机会完成升级,之后我们再公开。
受影响的产品
Java4Shell 影响 OpenJDK 17.0.6 及更新的版本。
以下 Java 发行版基于 OpenJDK 构建,同样存在漏洞:
- Amazon Corretto
- Eclipse Temurin
- Microsoft Build of OpenJDK
- Azul Zulu
- BellSoft Liberica
- SAP SapMachine
- Red Hat OpenJDK
- Oracle OpenJDK
- Oracle Java SE
- Oracle GraalVM for JDK
根据 Oracle 的说法,受影响的 Oracle Java SE 版本包括:8u511b33-perf、17.0.21.0.3、21.0.13.0.3、25.0.5.0.3、27.0.1.0.3。感谢 Oracle 在本文发布前提供了这些信息。
由于漏洞代码与硬件相关,Java4Shell 还要求处理器支持 x86-64 架构及 AVX-512 VBMI。ARM64 CPU 不受影响。
以下主流 CPU 系列满足硬件要求:
- Intel Xeon:Ice Lake、Sapphire Rapids、Emerald Rapids、Granite Rapids
- AMD EPYC 和 Ryzen:Zen 4 及更新
在 Linux 上,可以用以下命令检查你的 CPU 是否受影响:
Copygrep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$'
输出中必须包含全部四个标志。
修复建议
OpenJDK 已于太平洋时间 2026 年 11 月 17 日下午 1 点发布安全公告,Oracle 也发布了补丁。
所有 Java 用户应立即更新。
你也可以通过以下任一方式缓解 Java4Shell: