ASM学习

简介

ASM 是一个通用的 Java 字节码操作和分析框架。它可直接以二进制形式用于修改现有类或动态生成类。应用场景有代码转换、优化、代码生成、动态字节码增强等。可以概括为generation、transformation 和 analysis

在学习之前先去看一下这三篇文章做一个前置知识

JAVA安全|字节码篇：字节码文件结构与解读
JAVA安全|字节码篇：常见字节码指令（JVM指令）
JAVA安全|字节码篇：字节码操作框架—ASM（原理）

在来个y4taker博客中的图总结

环境

<properties>
  <maven.compiler.source>8</maven.compiler.source>
  <maven.compiler.target>8</maven.compiler.target>
  <asm.version>9.3</asm.version>
</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>
  <dependency>
    <groupId>org.ow2.asm</groupId>
    <artifactId>asm-util</artifactId>
    <version>${asm.version}</version>
  </dependency>
  <dependency>
    <groupId>org.ow2.asm</groupId>
    <artifactId>asm-tree</artifactId>
    <version>${asm.version}</version>
  </dependency>
  <dependency>
    <groupId>org.ow2.asm</groupId>
    <artifactId>asm-analysis</artifactId>
    <version>${asm.version}</version>
  </dependency>

</dependencies>

ASM使用

在asm当中有三个最重要的类，关系如下图

• ClassReader类，负责读取.class文件里的内容，然后拆分成各个不同的部分。
• ClassVisitor类，负责对.class文件中某一部分里的信息进行修改。
• ClassWriter类，负责将各个不同的部分重新组合成一个完整的.class文件。

ClassVisitor类

用于生成和转换已编译类的 ASM API 是基于 ClassVisitor 抽象类的，将它收到的所有方法调用都委托给另一个 ClassVisitor 类，会调用该类的visitXXX方法，这个类可以看作一个事件筛选器

访问顺序

visit visitSource? visitOuterClass? ( visitAnnotation | visitAttribute )*
( visitInnerClass | visitField | visitMethod )*
visitEnd

方法解析

public abstract class ClassVisitor {
    // 构造方法
    public ClassVisitor(int api);
    public ClassVisitor(int api, ClassVisitor cv);
    // 访问类的基本信息。version参数表示类的版本号，access参数表示类的访问标志，name参数表示类的内部名称，signature参数表示类的泛型签名（如果适用），superName参数表示父类的内部名称，interfaces参数表示类实现的接口的内部名称数组
    public void visit(int version, int access, String name, String signature, String superName, String[] interfaces);
    // 访问源文件和调试信息。source参数表示源文件的名称，debug参数表示调试信息
    public void visitSource(String source, String debug);
    // 访问外部类信息。owner参数表示外部类的内部名称，name参数表示外部类的名称，desc参数表示外部类的描述符
    public void visitOuterClass(String owner, String name, String desc);
    // 访问类的注解，返回一个AnnotationVisitor实例，用于访问注解的内容。desc参数表示注解的描述符，visible参数表示注解是否在运行时可见
    AnnotationVisitor visitAnnotation(String desc, boolean visible);
    // 访问类的属性（Attribute），例如SourceFile属性。attr参数表示要访问的属性
    public void visitAttribute(Attribute attr);
    // 访问内部类信息。name参数表示内部类的内部名称，outerName参数表示内部类的外部类的内部名称，innerName参数表示内部类的名称，access参数表示内部类的访问标志
    public void visitInnerClass(String name, String outerName, String innerName, int access);
    // 访问类的字段。access参数表示字段的访问标志，name参数表示字段的名称，desc参数表示字段的描述符，signature参数表示字段的泛型签名（如果适用），value参数表示字段的初始值
    public FieldVisitor visitField(int access, String name, String desc, String signature, Object value);
    // 访问类的方法。access参数表示方法的访问标志，name参数表示方法的名称，desc参数表示方法的描述符，signature参数表示方法的泛型签名（如果适用），exceptions参数表示方法声明的异常类型的内部名称数组
    public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions);
    // 访问类的结束，表示不再访问该类的任何内容
    void visitEnd();
}

ClassReader类

该类解析 ClassFile 内容，并针对遇到的每个字段、方法和字节码指令调用给定 ClassVisitor 的相应访问方法。这个类可以看作一个事件生产者

ClassWriter类

ClassWriter 类是 ClassVisitor 抽象类的一个子类，它直接以二进制形式生成编译后的类。它会生成一个字节数组形式的输出，其中包含了已编译类，可以用 toByteArray 方法来提取。这个类可以看作一个事件消费者

MethodVisitor类

访问Java方法的访问者类，用于生成和转换已编译方法的 ASM API 是基于 MethodVisitor 抽象类的，它由 ClassVisitor 的 visitMethod 方法返回。

访问顺序

visitAnnotationDefault?
( visitAnnotation | visitParameterAnnotation | visitAttribute )*
( visitCode
( visitTryCatchBlock | visitLabel | visitFrame | visitXxxInsn | visitLocalVariable | visitLineNumber )*
visitMaxs )?
visitEnd

对非抽象方法，如果存在注解和属性，必须先访问；其次是按顺序访问字节代码，这些访问在visitCode与visitMaxs之间

方法解析

abstract class MethodVisitor { // public accessors ommited
   // 构造方法
   MethodVisitor(int api);
   MethodVisitor(int api, MethodVisitor mv);

   // 访问方法的注解默认值
   AnnotationVisitor visitAnnotationDefault();
   // 访问方法的注解
   AnnotationVisitor visitAnnotation(String desc, boolean visible);
   // 访问方法参数的注解
   AnnotationVisitor visitParameterAnnotation(int parameter,
   String desc, boolean visible);
   // 访问方法的属性
   void visitAttribute(Attribute attr);
   // 访问方法的字节码指令部分
   void visitCode();

   // 访问方法的帧（Frame）。type参数表示帧的类型，nLocal参数表示局部变量的数量，local参数表示局部变量数组，nStack参数表示操作数栈的数量，stack参数表示操作数栈数组
   void visitFrame(int type, int nLocal, Object[] local, int nStack,
   Object[] stack);
   // 访问方法的一条指令，指令没有操作数
   void visitInsn(int opcode);
   // 访问方法的一条指令，指令操作数为单个整数
   void visitIntInsn(int opcode, int operand);
   // 访问方法的一条指令，指令操作数为局部变量索引
   void visitVarInsn(int opcode, int var);
   // 访问方法的一条指令，指令操作数为类型描述符
   void visitTypeInsn(int opcode, String desc);
   // 访问方法的一条指令，指令操作数为字段的信息。opc参数表示指令的操作码，owner参数表示字段所属的类名，name参数表示字段的名称，desc参数表示字段的描述符
   void visitFieldInsn(int opc, String owner, String name, String desc);
   // 访问方法的一条指令，指令操作数为方法的信息。opc参数表示指令的操作码，owner参数表示方法所属的类名，name参数表示方法的名称，desc参数表示方法的描述符
   void visitMethodInsn(int opc, String owner, String name, String desc);
   // 访问方法的一条动态方法调用指令。name参数表示方法的名称，desc参数表示方法的描述符，bsm参数表示引导方法（bootstrap method）的句柄，bsmArgs参数表示引导方法的参数。
   void visitInvokeDynamicInsn(String name, String desc, Handle bsm, Object... bsmArgs);
   // 访问方法的一条跳转指令
   void visitJumpInsn(int opcode, Label label);
   // 访问方法的标签（Label），用于标记代码的位置
   void visitLabel(Label label);
   // 访问方法的一条指令，将常量加载到操作数栈上
   void visitLdcInsn(Object cst);
   // 访问方法的一条指令，对局部变量进行增量操作
   void visitIincInsn(int var, int increment);
   // 访问方法的一条表格跳转指令。min参数表示最小的键值，max参数表示最大的键值，dflt参数表示默认跳转目标的标签，labels参数表示每个键值对应的跳转目标的标签数组
   void visitTableSwitchInsn(int min, int max, Label dflt, Label[] labels);
   // 访问方法的一条查找跳转指令。dflt参数表示默认跳转目标的标签，keys参数表示键值数组，labels参数表示每个键值对应的跳转目标的标签数组
   void visitLookupSwitchInsn(Label dflt, int[] keys, Label[] labels);
   // 访问方法的一条多维数组创建指令。desc参数表示数组的元素类型的描述符，dims参数表示数组的维度
   void visitMultiANewArrayInsn(String desc, int dims);
   // 访问方法的一个try-catch块。start参数表示try块的起始标签，end参数表示try块的结束标签，handler参数表示catch块的处理程序标签，type参数表示捕获的异常类型的描述符
   void visitTryCatchBlock(Label start, Label end, Label handler, String type);
   // 访问方法的局部变量。name参数表示局部变量的名称，desc参数表示局部变量的描述符，signature参数表示局部变量的泛型签名（如果适用），start参数表示变量的作用域的起始标签，end参数表示变量的作用域的结束标签，index参数表示局部变量的索引
   void visitLocalVariable(String name, String desc, String signature, Label start, Label end, int index);
   // 访问方法的行号信息。line参数表示行号，start参数表示行号对应的代码位置的标签
   void visitLineNumber(int line, Label start);
   // 访问方法的最大栈大小和最大局部变量数量。maxStack参数表示最大栈大小，maxLocals参数表示最大局部变量数量
   void visitMaxs(int maxStack, int maxLocals);
   // 访问方法的结束，表示不再访问该方法的任何内容
   void visitEnd();
}

来一个例子学习一下

读取字节码

// 从文件系统中加载字节码
byte[] bytecode = Files.readAllBytes(Paths.get("path/to/MyClass.class"));

// 或者从类加载器中加载字节码
InputStream is = getClass().getClassLoader().getResourceAsStream("com/example/MyClass.class");
byte[] bytecode = is.readAllBytes();

// 创建 ClassReader 实例
ClassReader classReader = new ClassReader(bytecode);

解析字节码

要解析字节码，我们需要创建一个自定义的 ClassVisitor 实现。以下是一个简单的示例，用于打印类名和方法名：

package ocean.zbz;  
  
  
import org.objectweb.asm.ClassVisitor;  
import org.objectweb.asm.MethodVisitor;  
import org.objectweb.asm.Opcodes;  
  
public class AsmStu extends ClassVisitor {  
  
  
    // 使用 ASM5 作为 Opcodes 版本，并调用父类构造函数  
    public AsmStu() {  
        super(Opcodes.ASM5);  
    }  
  
    // 重写 visit 方法，用于在访问类时输出类名  
    public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {  
        // 打印类名  
        System.out.println("Class: " + name);  
        // 调用父类 visit 方法，以便继续处理类信息  
        super.visit(version, access, name, signature, superName, interfaces);  
    }  
  
    // 重写 visitMethod 方法，用于在访问类中的方法时输出方法名  
  
    public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {  
        // 打印方法名  
        System.out.println("Method: " + name);  
        // 调用父类 visitMethod 方法，以便继续处理方法信息  
        return super.visitMethod(access, name, descriptor, signature, exceptions);  
    }  
}

visit()方法参数说明：

1. version：类文件的版本号，表示类文件的 JDK 版本。例如，JDK1.8 对应的版本号为 52（0x34），JDK 11 对应的版本号为 55（0x37）
2. access：类访问标志，表示类的访问权限和属性。例如，ACC_PUBLIC（0x0001）表示类是公共的，ACC_FINAL（0x0010）表示类是 final 的。可以通过位运算组合多个访问标志
3. name：类的内部名称，用斜线代替点分隔包名和类名。例如com/example/MyClass
4. signature：类的泛型签名，如果类没有泛型信息，此参数为 null
5. superName：父类的内部名称。对于除java.lang.Object之外的所有类，此参数都不为 null
6. interfaces：类实现的接口的内部名称数组。如果类没有实现任何接口，此参数为空数组

visitMethod()方法参数说明：

1. access：方法访问标志，表示方法的访问权限和属性。例如，ACC_PUBLIC（0x0001）表示方法是公共的，ACC_STATIC（0x0008）表示方法是静态的。可以通过位运算组合多个访问标志
2. name：方法的名称。例如，doSomething或<init>（构造方法）
3. descriptor：方法的描述符，表示方法的参数类型和返回值类型。例如，对于方法void doSomething(int)，描述符为(I)V
4. signature：方法的泛型签名，如果方法没有泛型信息，此参数为 null
5. exceptions：方法抛出的异常的内部名称数组。如果方法没有声明抛出任何异常，此参数为空

实验类

public class Foo {
    public void execute() {
        System.out.println("test changed method name");
    }

    public void changeMethodContent() {
        System.out.println("test changed method");
    }
}

public static void main(String[] args) throws IOException {  
    String path = "/Users/ocean/Cybersecurity/Java_project/AsmStu/src/main/java/Foo.class";  
  
    ClassVisitor asmStu = new AsmStu();  
    ClassReader classReader = new ClassReader(Files.readAllBytes(Paths.get(path)));  
    classReader.accept(asmStu,0);  
  
  
}

修改字节码

字段修改

要添加、修改或删除字段，我们需要扩展 ClassVisitor 类并重写 visitField 方法，下面是一个示例，用于在类中添加一个名为newField的字段，并删除名为toBeRemovedField的字段，测试类

public class Foo {
    String toBeRemovedField;

    public void execute() {
        System.out.println("test changed method name");
    }

    public void changeMethodContent() {
        System.out.println("test changed method");
    }
}

package ocean.zbz;  
  
import org.objectweb.asm.ClassVisitor;  
import org.objectweb.asm.FieldVisitor;  
import org.objectweb.asm.Opcodes;  
  
public class UpdaateFieldClassVisitor extends ClassVisitor {  
    public UpdaateFieldClassVisitor(ClassVisitor classVisitor) {  
        super(Opcodes.ASM5, classVisitor);  
    }  
      
    public FieldVisitor visitField(int access, String name, String descriptor, String signature, Object value) {  
        // 删除名为 toBeRemovedField 的字段  
        if ("toBeRemovedField".equals(name)) {  
            return null;  
        }  
  
        return super.visitField(access, name, descriptor, signature, value);  
    }  
    public void visitEnd() {  
        // 添加名为 newField 的字段  
        FieldVisitor newFieldVisitor = super.visitField(Opcodes.ACC_PRIVATE, "newField", "Ljava/lang/String;", null, null);  
        if (newFieldVisitor != null) {  
            newFieldVisitor.visitEnd();  
        }  
        super.visitEnd();  
    }  
}

visitField()的方法参数说明：

1. access：字段访问标志，表示字段的访问权限和属性。例如，ACC_PUBLIC（0x0001）表示字段是公共的，ACC_STATIC（0x0008）表示字段是静态的。可以通过位运算组合多个访问标志
2. name：字段的名称。例如myField
3. descriptor：字段的描述符，表示字段的类型。例如，对于类型为 int 的字段，描述符为I
4. signature：字段的泛型签名，如果字段没有泛型信息，此参数为 null
5. value：字段的常量值，如果字段没有常量值，此参数为 null。需要注意的是，只有静态且已赋值的字段才会有常量值

public static void main(String[] args) throws IOException {  
    String path = "/Users/ocean/Cybersecurity/Java_project/AsmStu/src/main/java/Foo.class";  
  
    ClassVisitor asmStu = new AsmStu();  
    ClassReader classReader = new ClassReader(Files.readAllBytes(Paths.get(path)));  
    UpdaateFieldClassVisitor updaateFieldClassVisitor = new UpdaateFieldClassVisitor(asmStu);  
    classReader.accept(updaateFieldClassVisitor,0);  
}

方法修改

要添加、修改或删除方法，我们需要扩展 ClassVisitor 类并重写 visitMethod 方法。下面是一个示例，用于在类中添加一个名为newMethod的方法，并删除名为toBeRemovedMethod的方法，测试代码：

public class Foo {
    String toBeRemovedField;

    public void execute() {
        System.out.println("test changed method name");
    }

    public void changeMethodContent() {
        System.out.println("test changed method");
    }

    public void toBeRemovedMethod() {
        System.out.println("toBeRemovedMethod");
    }
}

要修改方法内的指令，我们需要扩展 MethodVisitor 类并重写相应的 visit 方法。以下是一个示例

import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;

public class MyMethodAdapter extends MethodVisitor {

    public MyMethodAdapter(MethodVisitor methodVisitor) {
        super(Opcodes.ASM5, methodVisitor);
    }

    @Override
    public void visitMethodInsn(int opcode, String owner, String name, String descriptor, boolean isInterface) {
        // 在方法调用前添加 System.out.println
        mv.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
        mv.visitLdcInsn("Entering method: " + name);
        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);

        // 原始方法调用
        super.visitMethodInsn(opcode, owner, name, descriptor, isInterface);
    }
}

public static void main(String[] args) throws Exception {  
    String path = "/Users/ocean/Cybersecurity/Java_project/AsmStu/src/main/java/Foo.class";  
  
  
    ClassWriter classWriter = new ClassWriter(0);  
    ClassVisitor updateMethodAdaptorClassVisitor = new UpdateMethodAdaptorClassVisitor(classWriter);  
    ClassReader classReader = new ClassReader(Files.readAllBytes(Paths.get(path)));  
    classReader.accept(updateMethodAdaptorClassVisitor,0);

        classReader.accept(myMethodClassVisitor, 0);
    }

可以发现已经能修改了原来class

方法的增加和删除

package ocean.zbz;  
  
import org.objectweb.asm.ClassVisitor;  
import org.objectweb.asm.MethodVisitor;  
import org.objectweb.asm.Opcodes;  
  
public class UpdateMethodClassVisitor extends ClassVisitor {  
    private String deleteMethodName;  
    private String deleteMethodDesc;  
    private int addMethodAcc;  
    private String addMethodName;  
    private String addMethodDesc;  
    private boolean flag = false;  
  
    protected UpdateMethodClassVisitor(ClassVisitor cv, String deleteMethodName, String deleteMethodDesc, int addMethodAcc,  
                                       String addMethodName, String addMethodDesc) {  
        super(Opcodes.ASM5, cv);  
        this.deleteMethodName = deleteMethodName;  
        this.deleteMethodDesc = deleteMethodDesc;  
        this.addMethodAcc = addMethodAcc;  
        this.addMethodName = addMethodName;  
        this.addMethodDesc = addMethodDesc;  
    }  
  
    @Override  
    public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {  
        // 删除名为deleteMethodName且描述为deleteMethodDesc的方法  
        // 因为有的方法可能name一致，但是参数不同  
        if (name.equals(deleteMethodName) && descriptor.equals(deleteMethodDesc)) {  
            return null;  
        }  
        if (name.equals(addMethodName) && descriptor.equals(addMethodDesc)) flag = true;  
        return super.visitMethod(access, name, descriptor, signature, exceptions);  
    }  
  
    @Override  
    public void visitEnd() {  
        // 添加名为addMethodName且描述为addMethodDesc的方法  
        if (!flag) {  
            MethodVisitor methodVisitor = super.visitMethod(addMethodAcc, addMethodName, addMethodDesc, null, null);  
            if (methodVisitor != null) {  
                // 访问方法的字节码  
                methodVisitor.visitCode();  
                // 添加return指令  
                methodVisitor.visitInsn(Opcodes.RETURN);  
                // 设置方法的最大操作数栈深度和最大局部变量表大小，空方法设置00即可  
                methodVisitor.visitMaxs(0, 0);  
                // 结束访问  
                methodVisitor.visitEnd();  
            }  
        }  
        super.visitEnd();  
    }  
}

public static void main(String[] args) throws Exception{  
    // -------------------添加与删除Method-------------------  
    FileInputStream stream = new FileInputStream("/Users/ocean/Cybersecurity/Java_project/AsmStu/src/main/java/Foo.class");  
    // 加载字节码  
    ClassReader reader = new ClassReader(stream);  
    ClassWriter writer = new ClassWriter(reader, ClassWriter.COMPUTE_FRAMES);  
    // 实例化修改Method Visitor  
    UpdateMethodClassVisitor updateMethodClassVisitor = new UpdateMethodClassVisitor(writer, "toBeRemovedMethod", "()V", Opcodes.ACC_PUBLIC, "newMethod", "()V");  
    reader.accept(updateMethodClassVisitor, ClassReader.EXPAND_FRAMES);  
    // 写入新class中  
    FileOutputStream fileOutputStream = new FileOutputStream("temp.class");  
    byte[] updateByte = writer.toByteArray();  
    fileOutputStream.write(updateByte);  
    fileOutputStream.close();  
  
  
}

可以看到已经修改成功