JDK 21 FFM API 跨语言指针滞留导致的悬挂访问风险
JDK 21 的 Foreign Function & Memory API 位于 java.lang.foreign 包。它允许 Java 代码直接分配堆外内存、查找 native 符号并发起 downcall。MemorySegment 在 Java 侧带有地址、长度、访问状态和所属 Arena,关闭 Arena 后继续通过 Java 访问该段会被运行时拒绝。
JDK 21 的 Foreign Function & Memory API 位于
java.lang.foreign包。它允许 Java 代码直接分配堆外内存、查找 native 符号并发起 downcall。MemorySegment在 Java 侧带有地址、长度、访问状态和所属Arena,关闭Arena后继续通过 Java 访问该段会被运行时拒绝。
风险出现在跨语言调用点:当 MemorySegment 以 ADDRESS 参数传给 C 函数后,C 侧接收到的是 void *。如果 native 代码把这个地址保存到全局变量、结构体、异步任务或第三方库上下文中,Java 运行时无法继续追踪这个裸指针。Arena.close() 只能让 Java 侧段对象失效,不能让 C 侧已经复制的地址同步失效。
1. 实验环境
java -version
javac -version
gcc --version
uname -m
2. 创建 native 库
2.1 写入 retain.c
retain.c 保存 Java 传入的 native 地址、长度和偏移,并提供读取、写入、释放和地址查询函数。
偏移使用 64,不是直接读写起始地址。这样做是为了减少 glibc tcache 或 allocator 在释放小块内存时改写用户区前几个机器字带来的干扰。
cat > retain.c <<'EOF'
#include <stdint.h>
#include <stddef.h>
#include <stdio.h>
#include <string.h>
static uint8_t *retained;
static size_t retained_len;
static size_t retained_off;
static int readable_i64(void) {
if (retained == NULL) {
return 0;
}
if (retained_off > retained_len) {
return 0;
}
return retained_len - retained_off >= sizeof(int64_t);
}
void retain(void *p, int64_t len, int64_t off) {
retained = (uint8_t *)p;
retained_len = len > 0 ? (size_t)len : 0;
retained_off = off >= 0 ? (size_t)off : 0;
printf("[C] retain base=%p data=%p len=%zu off=%zu\n",
(void *)retained,
readable_i64() ? (void *)(retained + retained_off) : NULL,
retained_len,
retained_off);
fflush(stdout);
}
int64_t read_retained_i64(void) {
int64_t v = 0;
if (!readable_i64()) {
printf("[C] read skipped\n");
fflush(stdout);
return 0;
}
memcpy(&v, retained + retained_off, sizeof(v));
printf("[C] read data=%p value=0x%016llx\n",
(void *)(retained + retained_off),
(unsigned long long)v);
fflush(stdout);
return v;
}
void write_retained_i64(int64_t v) {
if (!readable_i64()) {
printf("[C] write skipped\n");
fflush(stdout);
return;
}
memcpy(retained + retained_off, &v, sizeof(v));
printf("[C] write data=%p value=0x%016llx\n",
(void *)(retained + retained_off),
(unsigned long long)v);
fflush(stdout);
}
void release_retained(void) {
retained = NULL;
retained_len = 0;
retained_off = 0;
printf("[C] release retained pointer\n");
fflush(stdout);
}
uintptr_t retained_address(void) {
return (uintptr_t)retained;
}
uintptr_t retained_data_address(void) {
if (!readable_i64()) {
return 0;
}
return (uintptr_t)(retained + retained_off);
}
EOF编译程序:
gcc -shared -fPIC -O0 -g -Wall -Wextra -o libretain.so retain.c
2.2 符号检查
file libretain.so
nm -D --defined-only libretain.so | awk '{print $3}' | sort
3. 创建 Java 触发程序
写入 FfmPointerRetention.java:
cat > FfmPointerRetention.java <<'EOF'
import java.lang.foreign.Arena;
import java.lang.foreign.FunctionDescriptor;
import java.lang.foreign.Linker;
import java.lang.foreign.MemorySegment;
import java.lang.foreign.SymbolLookup;
import java.lang.invoke.MethodHandle;
import java.nio.file.Path;
import java.util.Arrays;
import static java.lang.foreign.ValueLayout.ADDRESS;
import static java.lang.foreign.ValueLayout.JAVA_LONG;
public class FfmPointerRetention {
private static final long LEN = 128L;
private static final long OFF = 64L;
private static final long MARK = 0x1122334455667788L;
private static final long WRITE_MARK = 0x4141414142424242L;
private static MethodHandle downcall(
Linker linker,
SymbolLookup lookup,
String symbol,
FunctionDescriptor descriptor
) {
MemorySegment addr = lookup.find(symbol)
.orElseThrow(() -> new UnsatisfiedLinkError(symbol));
return linker.downcallHandle(addr, descriptor);
}
private static boolean hasArg(String[] args, String name) {
return Arrays.asList(args).contains(name);
}
public static void main(String[] args) throws Throwable {
boolean releaseBeforeClose = hasArg(args, "--release-before-close");
boolean doWrite = hasArg(args, "--write");
String lib = Path.of("./libretain.so").toAbsolutePath().toString();
System.load(lib);
Linker linker = Linker.nativeLinker();
SymbolLookup lookup = SymbolLookup.loaderLookup();
MethodHandle retain = downcall(
linker,
lookup,
"retain",
FunctionDescriptor.ofVoid(ADDRESS, JAVA_LONG, JAVA_LONG)
);
MethodHandle readRetained = downcall(
linker,
lookup,
"read_retained_i64",
FunctionDescriptor.of(JAVA_LONG)
);
MethodHandle writeRetained = downcall(
linker,
lookup,
"write_retained_i64",
FunctionDescriptor.ofVoid(JAVA_LONG)
);
MethodHandle releaseRetained = downcall(
linker,
lookup,
"release_retained",
FunctionDescriptor.ofVoid()
);
MethodHandle retainedAddress = downcall(
linker,
lookup,
"retained_address",
FunctionDescriptor.of(JAVA_LONG)
);
MethodHandle retainedDataAddress = downcall(
linker,
lookup,
"retained_data_address",
FunctionDescriptor.of(JAVA_LONG)
);
MemorySegment segment = null;
try (Arena arena = Arena.ofConfined()) {
segment = arena.allocate(LEN, JAVA_LONG.byteAlignment());
segment.set(JAVA_LONG, OFF, MARK);
System.out.printf("[Java] before close off=%d value=0x%016x%n",
OFF,
segment.get(JAVA_LONG, OFF));
retain.invoke(segment, LEN, OFF);
long base = (long) retainedAddress.invoke();
long data = (long) retainedDataAddress.invoke();
System.out.printf("[Java] native cached base=0x%016x data=0x%016x%n",
base,
data);
if (releaseBeforeClose) {
releaseRetained.invoke();
}
}
try {
long javaReadAfterClose = segment.get(JAVA_LONG, OFF);
System.out.printf("[Java] after close value=0x%016x%n",
javaReadAfterClose);
} catch (IllegalStateException e) {
System.out.printf("[Java] after close denied=%s%n",
e.getClass().getSimpleName());
}
long nativeReadAfterClose = (long) readRetained.invoke();
System.out.printf("[Java] native read after close=0x%016x%n",
nativeReadAfterClose);
if (doWrite) {
writeRetained.invoke(WRITE_MARK);
System.out.println("[Java] native write after close returned");
} else {
System.out.println("[Java] native write after close skipped; pass --write to enable");
}
}
}
EOF--write:在 Java 关闭 arena 后触发 C 侧写入。--release-before-close:在 Java 关闭 arena 前调用release_retained()清空 C 侧缓存指针。
编译 Java 程序:
javac --enable-preview --release 21 FfmPointerRetention.java
4. 默认读取路径实测
java --enable-preview --enable-native-access=ALL-UNNAMED FfmPointerRetentionJava 写入初始标记值
[Java] before close off=64 value=0x1122334455667788说明 Java 在 arena 未关闭时,对 MemorySegment 的偏移 64 成功写入 MARK。
对应代码:
segment.set(JAVA_LONG, OFF, MARK);
segment.get(JAVA_LONG, OFF);C 保存 Java 传入地址

地址关系:
base = 0x7f2e5823e830
off = 64 = 0x40
data = 0x7f2e5823e830 + 0x40 = 0x7f2e5823e870C 输出和 Java 查询 native 缓存地址的输出一致,说明 C 全局变量中保存的地址就是 Java 传入的 native segment 地址。
对应 C 代码:
retained = (uint8_t *)p;
retained_len = len > 0 ? (size_t)len : 0;
retained_off = off >= 0 ? (size_t)off : 0;5. 悬挂写入路径实测
java --enable-preview --enable-native-access=ALL-UNNAMED FfmPointerRetention --write地址关系:
base = 0x7f48e821e9e0
off = 64 = 0x40
data = 0x7f48e821e9e0 + 0x40 = 0x7f48e821ea20释放后读取发生在:
![]()
释放后写入发生在:
![]()
写入值 0x4141414142424242 对应 Java 常量:
private static final long WRITE_MARK = 0x4141414142424242L;该路径说明 C 在 Java arena 关闭后仍然执行了:
memcpy(retained + retained_off, &v, sizeof(v));6. 关闭前释放 native 指针
java --enable-preview --enable-native-access=ALL-UNNAMED FfmPointerRetention --release-before-close--release-before-close 使 Java 在 try (Arena arena = ...) 作用域内调用:
releaseRetained.invoke();对应 C 代码:
void release_retained(void) {
retained = NULL;
retained_len = 0;
retained_off = 0;
printf("[C] release retained pointer\n");
fflush(stdout);
}后续读取时,readable_i64() 发现 retained == NULL,因此输出:
[C] read skipped这组对照结果说明:
- Java 关闭 arena 的行为本身不是问题。
- 问题在于关闭 arena 前,C 侧是否还保存着旧地址。
- 只要在关闭 arena 前清空 C 侧指针,关闭后 C 就不会继续沿旧地址读取。
7. gdb 读取路径实测
7.1 启动 gdb
gdb -q \
-ex "set pagination off" \
-ex "set breakpoint pending on" \
-ex "handle SIGSEGV nostop noprint pass" \
-ex "break retain" \
-ex "break read_retained_i64" \
-ex "run" \
--args java --enable-preview --enable-native-access=ALL-UNNAMED FfmPointerRetention
7.2 retain() 断点
p/x p
p len
p off
continue
p = 0x7ffff0257650
len = 128
off = 64 = 0x40
data = 0x7ffff0257650 + 0x40 = 0x7ffff0257690p 是 Java 传入 retain() 的地址。执行到 retain.c:21 时,即将保存到 C 全局变量:
retained = (uint8_t *)p;continue 后 C 和 Java 输出中的 base、data 与 gdb 里看到的 p、off 一致。
7.3 read_retained_i64() 断点
p/x retained
p retained_len
p retained_off
x/gx retained + retained_off
continue
retain() 参数 p = 0x7ffff0257650
C 全局变量 retained = 0x7ffff0257650
retained_len = 128
retained_off = 64
读取地址 = 0x7ffff0257650 + 0x40 = 0x7ffff0257690
读取到的 8 字节值 = 0x1122334455667788这组 gdb 数据证明 C 全局变量保存的就是 Java 传入的地址。Java 侧已经输出 IllegalStateException 后,C 仍然通过 retained + retained_off 读取到标记值。
8. gdb 写入路径实测
8.1 启动 gdb
gdb -q \
-ex "set pagination off" \
-ex "set breakpoint pending on" \
-ex "handle SIGSEGV nostop noprint pass" \
-ex "break write_retained_i64" \
-ex "run" \
--args java --enable-preview --enable-native-access=ALL-UNNAMED FfmPointerRetention --write
write_retained_i64断点同样先 pending,原因仍是libretain.so动态加载。- 命中写入断点前,Java 已经输出
after close denied=IllegalStateException。 - 写入断点命中发生在释放后读取完成之后。
8.2 写入前变量和内存
p/x retained
p retained_off
p/x v
x/gx retained + retained_off
continue
写入前,x/gx retained + retained_off 看到:
0x7ffff02569d0: 0x110056293b656d61这个值已经不是 Java 最初写入的 0x1122334455667788。这说明释放后的内存内容不稳定,可能已经被 JVM、allocator 或其他 native 逻辑改写或复用。
继续执行后:
[C] write data=0x7ffff02569d0 value=0x4141414142424242
[Java] native write after close returned说明 C 实际对释放后的旧地址执行了写入,并且当前环境下没有崩溃。
9. 机制分析
9.1 Java 侧能检查 MemorySegment 状态
Java 代码:
segment.get(JAVA_LONG, OFF);在 arena 关闭后会触发 MemorySegment 状态检查,因此实测输出:
[Java] after close denied=IllegalStateException这说明 Java 侧的生命周期检查是生效的。
9.2 FFM ADDRESS 参数进入 C 后变成裸指针
Java downcall 描述符:
FunctionDescriptor.ofVoid(ADDRESS, JAVA_LONG, JAVA_LONG)Java 调用:
retain.invoke(segment, LEN, OFF);C 函数签名:
void retain(void *p, int64_t len, int64_t off)进入 C 后,p 只是一个地址值。C 可以复制、保存、传递或放入结构体。Java 运行时不会追踪所有 native 代码中保存过的地址副本。
9.3 Arena.close() 不会清理 C 侧全局变量
C 保存地址:
retained = (uint8_t *)p;Java 关闭 arena 后,只会让 Java 侧 MemorySegment 失效。它不会把 C 侧的:
static uint8_t *retained;自动改成 NULL。
因此 C 读取:
memcpy(&v, retained + retained_off, sizeof(v));和 C 写入:
memcpy(retained + retained_off, &v, sizeof(v));都不会经过 Java 的段状态检查。
9.4 释放后内容不稳定
默认读取路径中,C 释放后读到:
0x1122334455667788gdb 写入路径中,写入前同一偏移处看到:
0x110056293b656d61这两个结果不矛盾。释放后的内存内容本来就不稳定,可能因为运行状态、allocator 行为、JVM 内部逻辑、线程调度或后续 native 分配而变化。
因此判断风险时,不能要求每次释放后都读到原始标记值。关键证据是:Java 侧已拒绝访问后,C 侧仍然沿保存的旧地址执行了读取或写入。
10. 安全封装建议
核心原则:native 释放动作必须在 Arena.close() 之前完成。
C 侧提供清理函数:
void release_retained(void) {
retained = NULL;
retained_len = 0;
retained_off = 0;
}Java 侧把清理调用放进 try-with-resources 作用域:
try (Arena arena = Arena.ofConfined()) {
MemorySegment segment = arena.allocate(LEN, JAVA_LONG.byteAlignment());
segment.set(JAVA_LONG, OFF, MARK);
retain.invoke(segment, LEN, OFF);
try {
readRetained.invoke();
} finally {
releaseRetained.invoke(); // 必须先于 arena.close()
}
}对需要长期持有内存的 C 库,改用 native 自管所有权,Java 只持 opaque handle:
void *ctx_alloc(size_t len);
void ctx_free(void *ctx);
void ctx_use(void *ctx);11. 结论
风险定性:JDK 21 FFM API 的生命周期检查只作用于 Java 侧。MemorySegment 一旦以 ADDRESS 传出,就退化为普通 void *,Arena.close() 无法让 native 已缓存的地址同步失效。
问题归属:属于 FFM 封装层的错误使用模式,不是 JDK 缺陷,也不对应任何 CVE。判断依据不在于是否调用 Arena.close(),而在于 native API 是否会在返回后继续持有传入地址。
处置原则:
- 会保存指针的 C API:在
Arena.close()之前显式调用 native 释放函数清空缓存。 - 需要长期持有的对象:所有权交给 native 侧,Java 只持 opaque handle。
- 短生命周期
Arena不得作为会被 native 留存地址的所有者。


