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 FfmPointerRetention

Java 写入初始标记值

[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 = 0x7f2e5823e870

C 输出和 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 = 0x7ffff0257690

p 是 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 释放后读到:

0x1122334455667788

gdb 写入路径中,写入前同一偏移处看到:

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 留存地址的所有者。