初探Java安全之JavaAgent

About Java Agent

Java Agent的出现

在JDK1.5版本开始，Java增加了Instrumentation(Java Agent API)和JVMTI(JVM Tool Interface)功能，该功能可以实现JVM再加载某个class文件对其字节码进行修改，也可以对已经加载的字节码进行一个重新的加载。而在1.6版本新增了attach(附加方式)方式，可以对运行中的Java进程插入Agent。Java Agent可以去实现字节码插桩、动态跟踪分析等，比如RASP产品和Java Agent内存马。
Java Agent运行模式

有两种模式:
1、启动Java程序时添加-javaagent(Instrumentation API实现方式)或-agentpath/-agentlib(JVMTI的实现方式)参数，如java -javaagent:/data/XXX.jar LingXeTest。
2、JDK1.6新增了attach(附加方式)方式，可以对运行中的Java进程附加Agent。
这两种运行方式的最大区别在于第一种方式只能在程序启动时指定Agent文件，而attach方式可以在Java程序运行后根据进程ID动态注入Agent到JVM。
所以类似于想要注入Agent型内存马,一般会用attach的方式。
Java Agent

Javaagent是java命令的一个参数。参数 javaagent 可以用于指定一个jar包
Java Agent和普通的Java类并没有任何区别，普通的Java程序中规定了main方法为程序入口，而Java Agent则将premain（Agent模式）和agentmain（Attach模式）作为了Agent程序的入口，两者所接受的参数是完全一致的，如下：

1. public static void premain(String args, Instrumentation inst) {}
2. public static void agentmain(String args, Instrumentation inst) {}

复制代码

而在Attach模式下的premain()方法有两种写法,如下：

1. public static void premain(String agentArgs, Instrumentation inst)
2.   
3. public static void premain(String agentArgs)

复制代码

JVM会去优先加载带 Instrumentation 签名的方法，加载成功忽略第二种，如果第一种没有，则加载第二种方法。

Java Agent还限制了我们必须以jar包的形式运行或加载，我们必须将编写好的Agent程序打包成一个jar文件。除此之外，Java Agent还强制要求了所有的jar文件中必须包含/META-INF/MANIFEST.MF文件，且该文件中必须定义好Premain-Class（Agent模式）或Agent-Class:（Agent模式）配置，如：

1. Premain-Class: com.anbai.sec.agent.CrackLicenseAgent
2. Agent-Class: com.anbai.sec.agent.CrackLicenseAgent

复制代码

如果我们需要修改已经被JVM加载过的类的字节码，那么还需要设置在MANIFEST.MF中添加

1. Can-Retransform-Classes: true或Can-Redefine-Classes: true。

复制代码

javaagent参数相关:

1. -agentlib:<libname>[=<选项>] 加载本机代理库 <libname>, 例如 -agentlib:hprof
2. 另请参阅 -agentlib:jdwp=help 和 -agentlib:hprof=help
3. -agentpath:<pathname>[=<选项>]
4. 按完整路径名加载本机代理库
5. -javaagent:<jarpath>[=<选项>]
6. 加载 Java 编程语言代理, 请参阅 java.lang.instrument
8. jarpath 是指向代理程序 JAR 文件的路径。options 是代理选项。此开关可以在同一命令行上多次使用，从而创建多个代理程序。多个代理程序可以使用同一 jarpath。代理 JAR 文件必须符合 JAR 文件规范。下面的清单属性是针对代理 JAR 文件定义的：
9. Premain-Class
10. 代理类。即包含 premain 方法的类。此属性是必需的，如果它不存在，JVM 将中止。注：这是类名，而不是文件名或路径。
11. Boot-Class-Path
12. 由引导类加载器搜索的路径列表。路径表示目录或库（在许多平台上通常作为 jar 或 zip 库被引用）。查找类的特定于平台的机制出现故障之后，引导类加载器会搜索这些路径。按列出的顺序搜索路径。列表中的路径由一个或多个空格分开。路径使用分层 URI 的路径组件的语法。如果该路径以斜杠字符（“/”）开头，则为绝对路径，否则为相对路径。相对路径根据代理 JAR 文件的绝对路径解析。忽略格式不正确的路径和不存在的路径。此属性是可选的。
13. Can-Redefine-Classes
14. 布尔值（true 或 false，与大小写无关）。能够重定义此代理所需的类。值如果不是 true，则被认为是 false。此属性是可选的，默认值为 false。
15. 代理 JAR 文件附加到类路径之后。

复制代码

而关于java.lang.instrument包位于rt.jar，一共有5个文件

源码简介

其实这一部分把注释翻译过来，有些类和某些方法依旧不理解是什么意思，也有些看懂了但不知道怎么用，先鸽着。
ClassDefinition

1. public final class ClassDefinition {
2.     /**
3.      *  要重定义的类
4.      */
5.     private final Class<?> mClass;
7.     /**
8.      *  用于替换的本地 class ，为 byte 数组
9.      */
10.     private final byte[]   mClassFile;
12.     /**
13.      *  构造方法，使用提供的类和类文件字节创建一个新的 ClassDefinition 绑定
14.      */
15.     public ClassDefinition( Class<?> theClass, byte[]  theClassFile) {
16.         if (theClass == null || theClassFile == null) {
17.             throw new NullPointerException();
18.         }
19.         mClass      = theClass;
20.         mClassFile  = theClassFile;
21.     }
23.     /**
24.      * 以下为 getter 方法
25.      */
26.     public Class<?>  getDefinitionClass() {
27.         return mClass;
28.     }
30.     public byte[] getDefinitionClassFile() {
31.         return mClassFile;
32.     }
33. }

复制代码

ClassFileTransformer

ClassFileTransformer是一个转换类文件的代理接口，我们可以在获取到Instrumentation对象后通过addTransformer方法添加自定义类文件转换器。
使用addTransformer方法可以注册一个我们自定义的Transformer到Java Agent，当有新的类被JVM加载时JVM会自动回调用我们自定义的Transformer类的transform方法，传入该类的transform信息(类名、类加载器、类字节码等)，我们可以根据传入的类信息决定是否需要修改类字节码，修改完字节码后我们将新的类字节码返回给JVM，JVM会验证类和相应的修改是否合法，如果符合类加载要求JVM会加载我们修改后的类字节码。

1. package java.lang.instrument;
3. public interface ClassFileTransformer {
5.   /**
6.    * 类文件转换方法，重写transform方法可获取到待加载的类相关信息
7.    *
8.    * @param loader              定义要转换的类加载器；如果是引导加载器，则为 null
9.    * @param className           类名,如:java/lang/Runtime
10.    * @param classBeingRedefined 如果是被重定义或重转换触发，则为重定义或重转换的类；如果是类加载，则为 null
11.    * @param protectionDomain    要定义或重定义的类的保护域
12.    * @param classfileBuffer     类文件格式的输入字节缓冲区（不得修改）
13.    * @return 字节码byte数组。
14.    */
15.   byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined,
16.                           ProtectionDomain protectionDomain, byte[] classfileBuffer);
18. }

复制代码

重写transform方法需要注意以下事项：

• ClassLoader如果是被Bootstrap ClassLoader(引导类加载器)所加载那么loader参数的值是空。
  
• 修改类字节码时需要特别注意插入的代码在对应的ClassLoader中可以正确的获取到，否则会报ClassNotFoundException，比如修改java.io.FileInputStream(该类由Bootstrap ClassLoader加载)时插入了我们检测代码，那么我们将必须保证FileInputStream能够获取到我们的检测代码类。
  
• JVM类名的书写方式路径方式：java/lang/String而不是我们常用的类名方式：java.lang.String。
  
• 类字节必须符合JVM校验要求，如果无法验证类字节码会导致JVM崩溃或者VerifyError(类验证错误)。
  
• 如果修改的是retransform类(修改已被JVM加载的类)，修改后的类字节码不得新增方法、修改方法参数、类成员变量。
  
• addTransformer时如果没有传入retransform参数(默认是false)就算MANIFEST.MF中配置了Can-Redefine-Classes: true而且手动调用了retransformClasses方法也一样无法retransform。
  
• 卸载transform时需要使用创建时的Instrumentation实例。
  

Instrumentation

java.lang.instrument.Instrumentation是监测运行在JVM程序的Java API，利用Instrumentation我们可以实现如下功能：

• 动态添加或移除自定义的ClassFileTransformer（addTransformer/removeTransformer），JVM会在类加载时调用Agent中注册的ClassFileTransformer；
  
• 动态修改classpath（appendToBootstrapClassLoaderSearch、appendToSystemClassLoaderSearch），将Agent程序添加到BootstrapClassLoader和SystemClassLoaderSearch（对应的是ClassLoader类的getSystemClassLoader方法，默认是sun.misc.Launcher$AppClassLoader）中搜索；
  
• 动态获取所有JVM已加载的类(getAllLoadedClasses)；
  
• 动态获取某个类加载器已实例化的所有类(getInitiatedClasses)。
  
• 重定义某个已加载的类的字节码(redefineClasses)。
  
• 动态设置JNI前缀(setNativeMethodPrefix)，可以实现Hook native方法。
  
• 重新加载某个已经被JVM加载过的类字节码retransformClasses)。
  
  

源码如下：

1. public interface Instrumentation {
2.   
3.     //增加一个Class 文件的转换器，转换器用于改变 Class 二进制流的数据，参数 canRetransform 设置是否允许重新转换。
4.     void addTransformer(ClassFileTransformer transformer, boolean canRetransform);
6.     //在类加载之前，重新定义 Class 文件，ClassDefinition 表示对一个类新的定义，如果在类加载之后，需要使用 retransformClasses 方法重新定义。addTransformer方法配置之后，后续的类加载都会被Transformer拦截。对于已经加载过的类，可以执行retransformClasses来重新触发这个Transformer的拦截。类加载的字节码被修改后，除非再次被retransform，否则不会恢复。
7.     void addTransformer(ClassFileTransformer transformer);
9.     //删除一个类转换器
10.     boolean removeTransformer(ClassFileTransformer transformer);
12.     boolean isRetransformClassesSupported();
14.     //在类加载之后，重新定义 Class。这个很重要，该方法是1.6 之后加入的，事实上，该方法是 update 了一个类。
15.     void retransformClasses(Class<?>... classes) throws UnmodifiableClassException;
17.     boolean isRedefineClassesSupported();
19.   
20.     void redefineClasses(ClassDefinition... definitions)
21.         throws  ClassNotFoundException, UnmodifiableClassException;
23.     boolean isModifiableClass(Class<?> theClass);
25.     @SuppressWarnings("rawtypes")
26.     Class[] getAllLoadedClasses();
28.   
29.     @SuppressWarnings("rawtypes")
30.     Class[] getInitiatedClasses(ClassLoader loader);
32.     //获取一个对象的大小
33.     long getObjectSize(Object objectToSize);
36.    
37.     void appendToBootstrapClassLoaderSearch(JarFile jarfile);
39.   
40.     void appendToSystemClassLoaderSearch(JarFile jarfile);
42.   
43.     boolean isNativeMethodPrefixSupported();
45.   
46.     void setNativeMethodPrefix(ClassFileTransformer transformer, String prefix);
47. }

复制代码

Java Agent使用

前面都是理论，我们来简单写一个小Demo感受一下如何使用Java Agent技术。
Agent模式

大致分为以下流程（以-javaagent模式为例）：

• 编写一个Agent类，其中定义premain方法并调用Instrumentation#addTransformer方法添加一个自定义的Transformer
  
• 自定义一个Transformer类，实现Instrumentation接口，在transform方法中写入自己想要的AOP逻辑
  
• 创建MANIFEST.MF文件，可以手动写也可以通过Maven的插件（pom.xml）
  
• 打包Agent的jar包
  
• 在需要使用JavaAgent的项目添加JVM启动参数-javaagent并指定我们打包好的jar
  

这里需要2个项目，1个为javaagent的jar包，另1个为被javaagent代理的类。最终在被代理类的main方法执行前先执行我们Agent中的premain方法
0x01 编写javaagent相关代码
先创建一个Maven项目,其中创建一个Agent类，里面需要包含premain方法

1. package com.zh1z3ven;
3. import java.lang.instrument.Instrumentation;
5. public class Agent {
6.     public static void premain(String agentArgs, Instrumentation inst){
7.         System.out.println("agentArgs"+agentArgs);
8.         inst.addTransformer(new DefineTransformer(),true);//调用addTransformer添加一个Transformer
9.     }
11. }

复制代码

创建DefineTransformer类，实现ClassFileTransformer接口

1. package com.zh1z3ven;
3. import java.lang.instrument.ClassFileTransformer;
4. import java.lang.instrument.IllegalClassFormatException;
5. import java.security.ProtectionDomain;
7. public class DefineTransformer implements ClassFileTransformer {
8.     @Override
9.     public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
10.         System.out.println("premain load class"+className); //打印加载的类
11.         return new byte[0];
12.     }
13. }

复制代码

0x02 创建MANIFEST.MF文件
手动创建的话需要在resources/META-INF目录下创建MANIFEST.MF文件，内容如下:注意多留一行空行

1. Manifest-Version: 1.0
2. Can-Redefine-Classes: true
3. Can-Retransform-Classes: true
4. Premain-Class: com.zh1z3ven.Agent

复制代码

通过pom.xml中调用Maven的插件去创建该文件

1. <build>
2.         <plugins>
3.             <plugin>
4.                 <groupId>org.apache.maven.plugins</groupId>
5.                 <artifactId>maven-jar-plugin</artifactId>
6.                 <version>3.1.0</version>
7.                 <configuration>
8.                     <archive>
9.                         
10.                         <manifest>
11.                             <addClasspath>true</addClasspath>
12.                         </manifest>
13.                         <manifestEntries>
14.                             <Premain-Class>com.zh1z3ven.Agent</Premain-Class>
15.                             <Agent-Class>com.zh1z3ven.Agent</Agent-Class>
16.                             <Can-Redefine-Classes>true</Can-Redefine-Classes>
17.                             <Can-Retransform-Classes>true</Can-Retransform-Classes>
18.                         </manifestEntries>
19.                     </archive>
20.                 </configuration>
21.             </plugin>
22.             <plugin>
23.                 <groupId>org.apache.maven.plugins</groupId>
24.                 <artifactId>maven-compiler-plugin</artifactId>
25.                 <configuration>
26.                     <source>6</source>
27.                     <target>6</target>
28.                 </configuration>
29.             </plugin>
30.         </plugins>
31.     </build>

复制代码

打包好jar后，文件会在jar包中

一些可能会用到的参数说明：

Premain-Class ：包含 premain 方法的类（类的全路径名）
Agent-Class ：包含 agentmain 方法的类（类的全路径名）
Boot-Class-Path ：设置引导类加载器搜索的路径列表。查找类的特定于平台的机制失败后，引导类加载器会搜索这些路径。按列出的顺序搜索路径。列表中的路径由一个或多个空格分开。路径使用分层 URI 的路径组件语法。如果该路径以斜杠字符（“/”）开头，则为绝对路径，否则为相对路径。相对路径根据代理 JAR 文件的绝对路径解析。忽略格式不正确的路径和不存在的路径。如果代理是在 VM 启动之后某一时刻启动的，则忽略不表示 JAR 文件的路径。（可选）
Can-Redefine-Classes ：true表示能重定义此代理所需的类，默认值为 false（可选）
Can-Retransform-Classes ：true 表示能重转换此代理所需的类，默认值为 false （可选）
Can-Set-Native-Method-Prefix： true表示能设置此代理所需的本机方法前缀，默认值为 false（可选）

0x03 编写测试类
随意写一个

1. public class a {
2.     public static void main(String[] args) {
3.         System.out.println("main Method");
4.     }
5. }

复制代码

0x04 -javaagent模式启动
JVM启动参数添加

1. -javaagent:target/JavaAgent-1.0-SNAPSHOT.jar

复制代码

执行main方法之前会加载所有的类，包括系统类和自定义类。而在ClassFileTransformer中会去拦截系统类和自己实现的类对象，逻辑则是在ClassFileTransformer实现类的transform方法中定义。
而在这里transform给我的感觉是类似于一个filter会去拦截/遍历一些要在JVM中加载的类，而在transform方法中我们可以定义一些逻辑，比如if className== xxx时走入一个逻辑去实现AOP。而其中就可以利用如javassist技术修改字节码并作为transform方法的返回值，这样就在该类在JVM中加载前（-javaagent模式）修改了字节码
使用javassist修改字节码

这里在之前a类中新添加一个方法，并在Agent里我们自定义的Transformert中transform添加一个逻辑，使用javassist去修改我们a类中新添加的方法。
a类中新加一个call方法

1. package MemoryShell.JavaAgent;
3. public class a {
4.     public static void main(String[] args) {
5.         System.out.println("main Method");
6.         call();
7.     }
9.     public static void call(){
10.         System.out.println("say hello ...");
11.     }
12. }

复制代码

DefineTransformer

1. package com.zh1z3ven;
3. import javassist.*;
5. import java.io.IOException;
6. import java.lang.instrument.ClassFileTransformer;
7. import java.lang.instrument.IllegalClassFormatException;
8. import java.security.ProtectionDomain;
10. public class DefineTransformer implements ClassFileTransformer {
11.     @Override
12.     public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
13.         // System.out.println("premain load class"+className); //打印加载的类
14.         if ("MemoryShell/JavaAgent/a".equals(className)){
16.             try {
17.                 ClassPool classPool = ClassPool.getDefault();
18.                 CtClass ctClass = classPool.get("MemoryShell.JavaAgent.a");
19.                 CtMethod call = ctClass.getDeclaredMethod("call");
20.                 // 打印后加了一个弹计算器的操作
21.                 String MethodBody = "{System.out.println("say hello ...");" +
22.                         "java.lang.Runtime.getRuntime().exec("open -a Calculator");}";
23.                 call.setBody(MethodBody);
24.                 byte[] bytes = ctClass.toBytecode();
25.    
26.                 //detach的意思是将内存中曾经被javassist加载过的a对象移除，如果下次有需要在内存中找不到会重新走javassist加载
27.                 ctClass.detach();
28.                 return bytes;
30.             } catch (NotFoundException e) {
31.                 e.printStackTrace();
32.             } catch (CannotCompileException e) {
33.                 e.printStackTrace();
34.             } catch (IOException e) {
35.                 e.printStackTrace();
36.             }
37.         }
38.         return new byte[0];
39.     }
41. }

复制代码

打成jar包，指定JVM参数后运行a类

1. -javaagent:target/JavaAgent-1.1-SNAPSHOT.jar

复制代码

Attach api

在Java SE 6 以后在Instrumentation接口中提供了新的方法agentmain可以在 main 函数开始运行之后再运行。

1. //采用attach机制，被代理的目标程序VM有可能很早之前已经启动，当然其所有类已经被加载完成，这个时候需要借助Instrumentation#retransformClasses(Class<?>... classes)让对应的类可以重新转换，从而激活重新转换的类执行ClassFileTransformer列表中的回调
2. public static void agentmain (String agentArgs, Instrumentation inst)
4. public static void agentmain (String agentArgs)

复制代码

同样，agentmain 方法中带Instrumentation参数的方法也比不带优先级更高。开发者必须在MANIFEST.MF文件里面设置“Agent-Class”来指定包含 agentmain 函数的类。
在Java6 以后实现启动后加载的新实现是Attach api。Attach API 很简单，只有 2 个主要的类，都在 com.sun.tools.attach 包里面：

• VirtualMachine 字面意义表示一个Java 虚拟机，也就是程序需要监控的目标虚拟机，提供了获取系统信息(比如获取内存dump、线程dump，类信息统计(比如已加载的类以及实例个数等)， loadAgent，Attach 和 Detach （Attach 动作的相反行为，从 JVM 上面解除一个代理）等方法，可以实现的功能可以说非常之强大 。该类允许我们通过给attach方法传入一个jvm的pid(进程id)，远程连接到jvm上 。代理类注入操作只是它众多功能中的一个，通过loadAgent方法向jvm注册一个代理程序agent，在该agent的代理程序中会得到一个Instrumentation实例，该实例可以 在class加载前改变class的字节码，也可以在class加载后重新加载。在调用Instrumentation实例的方法时，这些方法会使用ClassFileTransformer接口中提供的方法进行处理。
  
• VirtualMachineDescriptor 则是一个描述虚拟机的容器类，配合 VirtualMachine 类完成各种功能。
  

attach实现动态注入的原理如下：
通过VirtualMachine类的attach(pid)方法，便可以attach到一个运行中的java进程上，之后便可以通过loadAgent(agentJarPath)来将agent的jar包注入到对应的进程，然后对应的进程会调用agentmain方法。

Attach模式使用

0x01 在JavaAgent项目中新编写一个AgentMain类

1. package com.zh1z3ven;
3. import java.lang.instrument.Instrumentation;
5. public class AgentMain {
6.     public static void agentmain(String agentArgs, Instrumentation instrumentation) {
7.         instrumentation.addTransformer(new AgentMainTransformer(), true);
8.     }
9. }

复制代码

0x02 新建一个自定义的Transformer
transform方法中逻辑依旧是修改a类的call方法字节码去弹calc

1. package com.zh1z3ven;
3. import javassist.*;
5. import java.lang.instrument.ClassFileTransformer;
6. import java.lang.instrument.IllegalClassFormatException;
7. import java.security.ProtectionDomain;
9. public class AgentMainTransformer implements ClassFileTransformer {
10.     @Override
11.     public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
13.         if ("MemoryShell.JavaAgent.a".equals(className)) {
14.             try {
15.                 ClassPool classPool = ClassPool.getDefault();
16.                 CtClass ctClass = classPool.get("MemoryShell.JavaAgent.a");
17.                 CtMethod call = ctClass.getDeclaredMethod("call");
18.                 // 打印后加了一个弹计算器的操作
19.                 String MethodBody = "{java.lang.Runtime.getRuntime().exec("open -a Calculator");" +
20.                         "System.out.println("say hello ...");}";
21.                 call.setBody(MethodBody);
22.                 byte[] bytes = ctClass.toBytecode();
23.                 return bytes;
24.                 //detach的意思是将内存中曾经被javassist加载过的a对象移除，如果下次有需要在内存中找不到会重新走javassist加载
25.                 //  ctClass.detach();
28.             } catch (Exception e) {
29.                 e.printStackTrace();
30.                 return classfileBuffer;
31.             }
32.         }else {
33.             return classfileBuffer;
34.         }
37.     }
40. }

复制代码

0x03 测试AgentMainTest类
将jar通过jvm pid注入进来，使其修改a类中call方法的字节码

1. package MemoryShell.JavaAgent;
3. import com.sun.tools.attach.*;
5. import java.io.IOException;
6. import java.util.List;
8. public class AgentMainTest {
9.     public static void main(String[] args) {
10.         System.out.println("running JVM start ");
11.         List<VirtualMachineDescriptor> list = VirtualMachine.list(); // 寻找当前系统中所有运行着的JVM进程
12.         for (VirtualMachineDescriptor vmd : list) {
13.             //如果虚拟机的名称为 xxx 则 该虚拟机为目标虚拟机，获取该虚拟机的 pid
14.             //然后加载 agent.jar 发送给该虚拟机
15.             System.out.println(vmd.displayName()); //vmd.displayName()看到当前系统都有哪些JVM进程在运行
16.             if (vmd.displayName().endsWith("MemoryShell.JavaAgent.AgentMainTest")) {
17.                 VirtualMachine virtualMachine = null;
18.                 try {
19.                     virtualMachine = VirtualMachine.attach(vmd.id());
20.                     virtualMachine.loadAgent("/Users/xxxx/JavaSourceCode/JavaCode/JavaAgent/target/JavaAgent-1.0-SNAPSHOT.jar");
22.                     virtualMachine.detach();
24.                 } catch (AttachNotSupportedException e) {
25.                     e.printStackTrace();
26.                 } catch (IOException e) {
27.                     e.printStackTrace();
28.                 } catch (AgentLoadException e) {
29.                     e.printStackTrace();
30.                 } catch (AgentInitializationException e) {
31.                     e.printStackTrace();
32.                 }
34.             }
35.         }
36.     }
38. }

复制代码

0x04 记得修改MANIFEST.MF或直接改pom.xml

1. <plugin>
2.     <groupId>org.apache.maven.plugins</groupId>
3.     <artifactId>maven-jar-plugin</artifactId>
4.     <version>3.1.0</version>
5.     <configuration>
6.         <archive>
7.             
8.             <manifest>
9.                 <addClasspath>true</addClasspath>
10.             </manifest>
11.             <manifestEntries>
12.                 <Agent-Class>com.zh1z3ven.AgentMain</Agent-Class>
13.                 <Can-Redefine-Classes>true</Can-Redefine-Classes>
14.                 <Can-Retransform-Classes>true</Can-Retransform-Classes>
15.             </manifestEntries>
16.         </archive>
17.     </configuration>
18. </plugin>

复制代码

0x05 打包，先运行测试AgentMainTest类将jar注入进来使其修改a类的字节码，之后运行a的main方法，调用到call方法时是我们修改过后的字节码了，所以会弹calc

Agent模式与Attach模式小结：

• 上面Attach这种情况是修改的还没被JVM加载的类，已加载的Java类是不会再被Agent处理的，这时候我们需要在Attach到目标进程后调用instrumentation.redefineClasses，让JVM重新该Java类，这样我们就可以使用Agent机制修改该类的字节码了。
  1. public static void agentmain(String agentArgs, Instrumentation inst) throws UnmodifiableClassException,
  2. ClassNotFoundException {
  3. inst.addTransformer(new Transformer(), true);
  4. inst.retransformClasses(Class.forName("com.example.xxxclass"));
  5. }

  复制代码
• premain和agentmain两种方式修改字节码的时机都是类文件加载之后，也就是说必须要带有Class类型的参数，不能通过字节码文件和自定义的类名重新定义一个本来不存在的类。
  
• 类的字节码修改称为类转换(Class Transform)，类转换其实最终都回归到类重定义Instrumentation#redefineClasses()方法，此方法有以下限制：
  
  
  
  • 新类和老类的父类必须相同；
    
  • 新类和老类实现的接口数也要相同，并且是相同的接口；
    
  • 新类和老类访问符必须一致。 新类和老类字段数和字段名要一致；
    
  • 新类和老类新增或删除的方法必须是private static/final修饰的；
    
  • 可以修改方法体。
    
  
  
• java agent 中的所有依赖，在原进程中的 classpath 中都要能找到，否则在注入时原进程会报错NoClassDefFoundError。
  
• agent 进程的 classpath 中必须有 tools.jar（提供 VirtualMachine attach api ），jdk 默认有 tools.jar，jre 默认没有。并且Linux和Windows之间是存在一个tools.jar适配问题。
  

Reference

https://www.cnblogs.com/nice0e3/p/14086165.html
https://www.cnblogs.com/rickiyang/p/11368932.html
https://su18.org/post/irP0RsYK1/
javasec.org

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！