Newshot

Java4Shell:写一次,到处 RCE

Translation(model translation, not the source's own text)

Java4Shell:一次编写,处处 RCE

Base64 的尾巴

Java4Shell 海报
Java4Shell 海报

作者:Quang Luong

在受影响的 OpenJDK 构建上,畸形的 Base64 数据可能造成对已分配堆内存的常量值覆写。通过远程 Heap Feng Shui,我们将该覆写转化为堆泄漏和远程代码执行。

发现

几个月前,我正在为某家手机厂商开发一个 0-click 漏洞利用。这个漏洞限制很大:它是一个线性越界写,而我们没有办法绕过 ASLR。我几乎认为它不可利用,直到我审计了 Android Runtime。事实证明,它有一些可预测的内存分配模式,如果你把起始内存破坏处的寄存器对齐得恰到好处,就能让运行时解释攻击者的字节码。

完成那条利用链后,受启发(也感到无聊),我决定研究一些完全不同的东西。于是,我拉取了官方 JVM 实现(OpenJDK HotSpot)并开始审计。Java 是一个成熟的平台,所以我知道在这里找到一个“好”漏洞会很难,但我还是想尽最大努力试一试。

回想起早先的教训——复杂系统以及跨越多个边界的代码很难做对——我把审计重点放在 JIT 编译器、intrinsics、广泛可访问的 API 和密码学上。好吧,更准确地说,我像 2026 年任何严肃的安全研究员一样,告诉 Codex 去看那些区域。老实说,我没想到会发现任何能轻易利用的东西,也许只是一些逻辑缺陷或侧信道问题。

Codex 带给我的大多数早期结果都是垃圾,要么不可达,要么利用条件完全不现实。看起来像是我要输掉的一场赌博。但你知道吗,幸运眷顾勇者。所以我就更用力地提示……

最终,Codex 给我带来了一个发现:Base64 解码器本身存在内存破坏。我本想找铜,却靠纯粹的坚持找到了金子。但等等,它真的是金子,还是只是愚人金?

漏洞

问题出在 OpenJDK HotSpot 的 x86-64 Base64 intrinsic 中。C2 是 Java 虚拟机中最激进的 JIT 编译器。具体来说,如果你反复触发某个函数,它就会把该函数编译成本地代码。即便如此,普通的本地代码本身仍然不够快。现代 CPU 有专用指令,可以更快地处理数据。HotSpot 在称为 intrinsics 的优化例程中使用它们。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)
      

在上面的代码中,如果剩余输入的形式为 =、==、X=、X==、XY= 或 ===,那么 output_len 会被计算为零。然而,由于存在填充,output_len 会被递减,从而产生下溢值 -1 或 -2。由于当 output_len >= 64 时,bzhiq(-1, output_len) 不会改变任何位,这导致 output_mask == -1u64。

Java4Shell:一次编写,到处 RCE

随后代码使用 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 代码处理,如果输入无效,Java 代码会抛出 IllegalArgumentException。

运行时,解码后的缓冲区长度按 (ceil(inp_len / 4) * 3) - padding 计算。当漏洞被触发时,输入为 65 字节([64 字节] + '='),该计算会分配一个 50 字节的缓冲区。解码过程中,这个 bug 使 evmovdqub 的 output_mask == -1,因此从偏移 48 开始写入 64 个字节,这是一次越过缓冲区末尾的越界写。

在 OpenJDK 17 上,触发输入是 'A' 128 + '=',而不是 'A' 64 + '=',因为到达该代码路径的长度阈值更高。

利用策略

这个 Base64 bug 是金矿,但不是那种躺在河床上等着淘出来的类型。它是那种深、暗且难以触及的类型。虽然我们有了内存破坏,但利用它看起来很难,甚至接近不可利用,因为它只向堆写入固定字节。只有越界写的落点位置是可控的。

从缓冲区中原本要写入剩余各组 Base64 解码字节的位置开始,我们得到以下 64 字节写入:

  • 对字节 0 的完全受控写入(在界内)
  • 对字节 1 的 4 位受控写入(在界内)
  • 对字节 [2, 63] 的不可控写入。对于字节 48..63,值将始终是 0x9a。

不可控的越界写最终并不是大问题。我们复用了 JavaScript 引擎中常见的利用原语,即覆写缓冲区长度的经典技术。

我们把长度被覆写的缓冲区称为 writer。一旦它的长度被破坏,它就会持续接受我们选定的字节,因此如果我们在它后面放置另一个数组或对象,就能用所有选定的值破坏那个邻居。这会把固定写入升级为有界的、选定值的线性写入。

如果我们接着破坏另一个数组的长度,并且它的数据被复制回响应中,我们就利用越界读构建了一个堆泄露原语,即 reader。此时,在任何代码执行之前,我们已经有了 JavaBleed,即从 Java 堆泄露内容的能力,这些内容可能包含 PII、私钥、其他密钥和令牌。

从 writer 和 reader 出发,本文的其余部分构建完整攻击。我们修复线性写入损坏的对象以保持 JVM 运行,对应用逻辑发起纯数据攻击,并把有界写入升级为任意写入,进而到达 Code Cache 和 JVM hooks 以实现代码执行。

但首先,我们需要让堆对齐到对我们有利的位置。

堆风水(Grooming)

G1 将堆划分为固定大小的 region。在 region 算术发挥作用之前,关键数组必须离开其线程的私有分配范围。

HotSpot 通常给每个 Java 线程一个线程本地分配缓冲区(TLAB),即 Eden 的一块私有切片。不同请求线程创建的对象会推进不同的游标,这使我们在一个 TLAB 中的 Base64 解码器和另一个 TLAB 中的 writer 之间得不到有用的顺序。

第一层 grooming 控制分配路径。关键数组的大小以及 worker 的 TLAB 中剩余的空间,决定 HotSpot 是重新填充该 TLAB,还是走攻击者偏好的 TLAB 外分配路径。

第二层控制布局。然而,我们无法选择 G1 如何分配内存,也不知道当前的堆状态。为了应对这一限制,Calif 采用了久经考验的 Spray and Pray 方法。

对象大小和填充确定了区域大小的 span 内部的偏移。我们喷洒多对活跃的写入器和读取器,让解码器的输出拥有几个可能的邻居。当其区域恰好落在某个写入器区域的正下方时,被拓宽的读取器会产生更大的应用响应。我们丢弃未命中的情况并重试,直到成功。

exploit 开发早期的一个挑战是,AI 在开发堆 grooming 原语时会卡住。为了节省 token 和时间,Calif 写了一个小型堆追踪器和可视化工具,为 agent 提供堆状态信息,并结合我们在特定情况下的专业知识。

Remote Heap Feng Shui

为了执行远程 grooming,每个请求的数据会被一直发送,直到关键的堆分配发生为止。通过确保先前发送的数据已获得 TCP 确认,exploit 就能控制到目前为止的分配。一旦我们确信目前的数据已在目标上缓冲,就发送剩余部分,完成 HTTP 请求。这既实现了对堆分配的控制,也带来了更精确的时序安排,因为发送小网络包比发送大包更稳定。

精确的分配与释放顺序安排属于目标应用的 profile,而我们能够控制添加、写入器、读取器和解码器这几个部件。

当前的攻击对网络状况敏感,比如 RTT 和抖动。更低、更稳定的往返时延更有利于实现更可靠的攻击。在我们的受控环境中,我们通过公网 IP 在互联网上执行了这次攻击,而不是只假设完美的实验室条件。为了让当前攻击路径在利用中获得最佳的稳定性和可靠性,Calif 求助于物理规律,用钱来解决问题,而不是折腾 TCP/IP 协议栈配置。换句话说,Calif 在目标所在的同一区域租用了另一台 VM。

预热、排练与重试

总结一下目前的链条:我们会把 Base64 解码器预热到 C2 tier。在造成破坏发生之前,我们可以排练 exploit 的运行,以校准针对目标的时序和响应。一旦获得所需信息,我们就可以触发漏洞。位置放错可能导致 JVM 崩溃,但在许多情况下,我们直接重试即可。

限制

请求流式传输。当前一些 grooming profile 需要部分请求体到达应用。等待完整请求体的代理会消除它们的释放时序。nginx 默认会缓冲请求体。

请求缓冲并不是通用的缓解措施。Elasticsearch 从单个完整请求运行,因此该设置无法阻止那条链。在配置了 WebSocket 升级之后,后续帧通过隧道传输,请求体缓冲不再适用于它们。

应用 profile。不存在通用 payload。每条链都需要一个解码器路由、一个活跃的写入器、一个返回的读取器或其他反馈路径、一个堆布局,以及一个应用动作。每个目标都需要量身定制的 profile。这个 exploit 不是通用的 point-and-shoot。

PoC

下面是一个自包含的概念验证。它会把 Base64 解码器预热到使用存在漏洞的 intrinsic 为止,然后把格式错误的 64 个 "A" + "=" 输入解码成一个 4096 字节的数组。在受影响的 JDK 上它会打印 REPRODUCED:解码器拒绝了该输入,但解码输出之后 62 个字节(偏移 50 到 111)已经被覆盖。每次写入都落在真实数组之内,因此运行该触发器是安全的。


        import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.Base64;
      

/** Bounded standalone trigger: every write stays inside a real 4096-byte array. */ 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 或更新版本。

由于它们基于 OpenJDK 构建,以下 Java 发行版同样受影响:

- Amazon Corretto

- Eclipse Temurin

- Microsoft Build of OpenJDK

- 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 还需要支持 AVX-512 VBMI 的 x86-64 处理器。ARM64 CPU 不受影响。

以下主流 CPU 系列满足硬件要求:

- Intel Xeon:Ice Lake、Sapphire Rapids、Emerald Rapids、Granite Rapids

- AMD EPYC 和 Ryzen:Zen 4 或更新版本

在 Linux 上,你可以用以下命令检查你的 CPU 是否受影响:

      

grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$'

输出必须包含全部四个标志。

建议

OpenJDK 发布了安全公告

Oracle 于 2026 年 11 月 17 日太平洋时间下午 1:00 发布了补丁。

所有 Java 用户应立即更新。

你也可以通过以下任一方式启动 OpenJDK 来缓解 Java4Shell:

  • 使用 -XX:-UseBASE64Intrinsics 禁用硬件加速的 Base64 编码和解码,或
  • 使用 -XX:UseAVX=2 禁用 AVX-512。此标志仅适用于 x86-64 主机。ARM 上的 OpenJDK 无法识别它,会导致启动失败。

致谢

研究与撰写、漏洞利用:Quang Luong。

漏洞利用改进:Jenish Rakholiya。

插图:Michal Zalewski。

The translation is machine-generated and individual terms may be off. Nothing is rewritten or cut; the original is authoritative.

Published by Lobsters
This site only summarises and aggregates; copyright stays with the original author. Headlines and summaries follow the source — where they differ, the original wins.
Read the original ↗