曹工说Spring Boot源码(25)-- Spring注解扫描的瑞士军刀,ASM + Java Instrumentation,顺便提提Jar包破解

2019/04/10 10:10
阅读数 17

写在前面的话

相关背景及资源:

曹工说Spring Boot源码(1)-- Bean Definition到底是什么,附spring思维导图分享

曹工说Spring Boot源码(2)-- Bean Definition到底是什么,咱们对着接口,逐个方法讲解

曹工说Spring Boot源码(3)-- 手动注册Bean Definition不比游戏好玩吗,我们来试一下

曹工说Spring Boot源码(4)-- 我是怎么自定义ApplicationContext,从json文件读取bean definition的?

曹工说Spring Boot源码(5)-- 怎么从properties文件读取bean

曹工说Spring Boot源码(6)-- Spring怎么从xml文件里解析bean的

曹工说Spring Boot源码(7)-- Spring解析xml文件,到底从中得到了什么(上)

曹工说Spring Boot源码(8)-- Spring解析xml文件,到底从中得到了什么(util命名空间)

曹工说Spring Boot源码(9)-- Spring解析xml文件,到底从中得到了什么(context命名空间上)

曹工说Spring Boot源码(10)-- Spring解析xml文件,到底从中得到了什么(context:annotation-config 解析)

曹工说Spring Boot源码(11)-- context:component-scan,你真的会用吗(这次来说说它的奇技淫巧)

曹工说Spring Boot源码(12)-- Spring解析xml文件,到底从中得到了什么(context:component-scan完整解析)

曹工说Spring Boot源码(13)-- AspectJ的运行时织入(Load-Time-Weaving),基本内容是讲清楚了(附源码)

曹工说Spring Boot源码(14)-- AspectJ的Load-Time-Weaving的两种实现方式细细讲解,以及怎么和Spring Instrumentation集成

曹工说Spring Boot源码(15)-- Spring从xml文件里到底得到了什么(context:load-time-weaver 完整解析)

曹工说Spring Boot源码(16)-- Spring从xml文件里到底得到了什么(aop:config完整解析【上】)

曹工说Spring Boot源码(17)-- Spring从xml文件里到底得到了什么(aop:config完整解析【中】)

曹工说Spring Boot源码(18)-- Spring AOP源码分析三部曲,终于快讲完了 (aop:config完整解析【下】)

曹工说Spring Boot源码(19)-- Spring 带给我们的工具利器,创建代理不用愁(ProxyFactory)

曹工说Spring Boot源码(20)-- 码网恢恢,疏而不漏,如何记录Spring RedisTemplate每次操作日志

曹工说Spring Boot源码(21)-- 为了让大家理解Spring Aop利器ProxyFactory,我已经拼了

曹工说Spring Boot源码(22)-- 你说我Spring Aop依赖AspectJ,我依赖它什么了

曹工说Spring Boot源码(23)-- ASM又立功了,Spring原来是这么递归获取注解的元注解的

曹工说Spring Boot源码(24)-- Spring注解扫描的瑞士军刀,asm技术实战(上)

工程代码地址 思维导图地址

工程结构图:

概要

上一篇,我们讲了ASM基本的使用方法,具体包括:复制一个class、修改class版本号、增加一个field、去掉一个field/method等等;同时,我们也知道了怎么才能生成一个全新的class。

但是,仅凭这点粗浅的知识,我们依然不太理解能干嘛,本篇会带大家实现简单的AOP功能,当然了,学完了之后,可能你像我一样,更困惑了,那说明你变强了。

本篇的核心是,在JVM加载class的时候,去修改class,修改class的时候,加入我们的aop逻辑。JVM加载class的时候,去修改class,这项技术就是load-time-weaver,实现load-time-weaver有两种方式,这两种方式,核心差别在于修改class的时机不同。

  • 第一种,定制classloader,在把字节码交给JVM去defineClass之前,去织入切面逻辑
  • 第二种,利用Java 官方提供的instrumentation机制,注册一个类转换器到 JVM。JVM在加载class的时候,就会传入class的原始字节码数组,回调我们的类转换器,我们类转换器中可以修改原始字节码,并将修改后的字节码数组返回回去,JVM就会用我们修改后的字节码去defineClass了

在直接开始前,声明本篇文章,是基于下面这篇文章中的代码demo,我自己稍做了修改,并附上源码(原文是贴了代码,但是没有直接提供代码地址,不贴心啊)。

初探 Java agent

要达成的目标

目标就是给下面的测试类,加上一点点切面功能。

package org.xunche.app;
public class HelloXunChe {
    public static void main(String[] args) throws InterruptedException {
        HelloXunChe helloXunChe = new HelloXunChe();
        helloXunChe.sayHi();
    }
    public void sayHi() throws InterruptedException {
        System.out.println("hi, xunche");
        sleep();
    }
    public void sleep() throws InterruptedException {
        Thread.sleep((long) (Math.random() * 200));
    }
}

我们希望,class在执行的时候,能够打印方法执行的耗时,也就是,最终的class,需要是下面这样的。

package org.xunche.app;
import org.xunche.agent.TimeHolder;
public class HelloXunChe {
    public HelloXunChe() {
    }
    public static void main(String[] args) throws InterruptedException {
        TimeHolder.start(args.getClass().getName() + "." + "main");
        // 业务逻辑开始
        HelloXunChe helloXunChe = new HelloXunChe();
        helloXunChe.sayHi();
        //业务逻辑结束
        HelloXunChe helloXunChe = args.getClass().getName() + "." + "main";
        System.out.println(helloXunChe + ": " + TimeHolder.cost(helloXunChe));
    }
    public void sayHi() throws InterruptedException {
        TimeHolder.start(this.getClass().getName() + "." + "sayHi");
        System.out.println("hi, xunche");
        // 业务逻辑开始
        this.sleep();
        //业务逻辑结束
        String var1 = this.getClass().getName() + "." + "sayHi";
        System.out.println(var1 + ": " + TimeHolder.cost(var1));
    }
    public void sleep() throws InterruptedException {
        TimeHolder.start(this.getClass().getName() + "." + "sleep");
        // 业务逻辑开始
        Thread.sleep((long)(Math.random() * 200.0D));
        //业务逻辑结束
        String var1 = this.getClass().getName() + "." + "sleep";
        System.out.println(var1 + ": " + TimeHolder.cost(var1));
    }
}

所以,我们大概就是,要做下面的这样一个切面:

@Override
protected void onMethodEnter() {
    //在方法入口处植入
    String className = getClass().getName();
    String s = className + "." + methodName;
    TimeHolder.start(s);
}
@Override
protected void onMethodExit(int i) {
    //在方法出口植入
    String className = getClass().getName();
    String s = className + "." + methodName;
    long cost = TimeHolder.cost(s);
    System.out.println(s + ": " + cost);
}

但是,习惯了动态代理的我们,看上面的代码可能会有点误解。上面的代码,不是在执行目标方法前,调用切面;而是:直接把切面代码嵌入了目标方法。

想必大家都明确了要达成的目标了,下面说,怎么做。

java agent/instrumentation机制

这部分,大家可以结合开头那个链接一起学习。

首先,我请大家看看java命令行的选项。直接在cmd里敲java,出现如下:

看了和没看一样,那我们再看一张图,在大家破解某些java编写的软件时,可能会涉及到jar包破解,比如:

大家可以使用jad这类反编译软件,打开jar包看下,看看里面是啥:

可以发现,里面有一个MANIFEST.MF文件,里面指定了Premain-Class这个key-value,从这个名字,大家可能知道了,我们平时运行java程序,都是运行main方法,这里来个premain,那这意思,就是在main方法前面插个队呗?

你说的没有错,确实是插队了,拿上面的破解jar包举例,里面的Premain-Class方法,对应的Agent类,反编译后的代码如下:

核心代码就是图里那一行:

java.lang.instrument.Instrumentation
public interface Instrumentation {
    /**
     * Registers the supplied transformer. All future class definitions
     * will be seen by the transformer, except definitions of classes upon which any
     * registered transformer is dependent.
     * The transformer is called when classes are loaded, when they are
     * {@linkplain #redefineClasses redefined}. and if <code>canRetransform</code> is true,
     * when they are {@linkplain #retransformClasses retransformed}.
     * See {@link java.lang.instrument.ClassFileTransformer#transform
     * ClassFileTransformer.transform} for the order
     * of transform calls.
     * If a transformer throws
     * an exception during execution, the JVM will still call the other registered
     * transformers in order. The same transformer may be added more than once,
     * but it is strongly discouraged -- avoid this by creating a new instance of
     * transformer class.
     * <P>
     * This method is intended for use in instrumentation, as described in the
     * {@linkplain Instrumentation class specification}.
     *
     * @param transformer          the transformer to register
     * @param canRetransform       can this transformer's transformations be retransformed
     * @throws java.lang.NullPointerException if passed a <code>null</code> transformer
     * @throws java.lang.UnsupportedOperationException if <code>canRetransform</code>
     * is true and the current configuration of the JVM does not allow
     * retransformation ({@link #isRetransformClassesSupported} is false)
     * @since 1.6
     */
    void
    addTransformer(ClassFileTransformer transformer, boolean canRetransform);
    
    ...
}

这个类,就是官方jdk提供的类,官方的本意呢,肯定是让大家,在加载class的时候,给大家提供一个机会,去修改class,比如,某个第三方jar包,我们需要修改,但是没有源码,就可以这么干;或者是一些要统一处理,不方便在应用中耦合的功能:比如埋点、性能监控、日志记录、安全监测等。

说回这个方法,参数为ClassFileTransformer,这个接口,就一个方法,大家看看注释:

	/**
     * ...
     *
	 * @param classfileBuffer       the input byte buffer in class file format - must not be modified
     *
     * @throws IllegalClassFormatException if the input does not represent a well-formed class file
     * @return  a well-formed class file buffer (the result of the transform),
                or <code>null</code> if no transform is performed.
     * @see Instrumentation#redefineClasses
     */
    byte[]
    transform(  ClassLoader         loader,
                String              className,
                Class<?>            classBeingRedefined,
                ProtectionDomain    protectionDomain,
                byte[]              classfileBuffer)
        throws IllegalClassFormatException;
  • classfileBuffer,就是原始class字节码数组,官方注释说:一定不能修改它
  • 返回的byte[]数组,注释:一个格式正确的class文件数组,或者null,表示没有进行转换

别的也不多说了,反正就是:jvm给你原始class,你自己修改,还jvm一个改后的class。

所以,大家估计也能猜到破解的原理了,但我还是希望大家:有能力支持正版的话,还是要支持。

接下来,我们回到我们的目标的实现上。

agent模块开发

完整代码:https://gitee.com/ckl111/all-simple-demo-in-work/tree/master/java-agent-premain-demo

增加类转换器

package org.xunche.agent;
import org.objectweb.asm.*;
import org.objectweb.asm.commons.AdviceAdapter;

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

public class TimeAgentByJava {
    public static void premain(String args, Instrumentation instrumentation) {
        instrumentation.addTransformer(new TimeClassFileTransformer());
    }
}

类转换器的详细代码如下:

private static class TimeClassFileTransformer implements ClassFileTransformer {
        @Override
        public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) {
            if (className.startsWith("java") || className.startsWith("jdk") || className.startsWith("javax") || className.startsWith("sun") || className.startsWith("com/sun")|| className.startsWith("org/xunche/agent")) {
                //return null或者执行异常会执行原来的字节码
                return null;
            }
            // 1
            System.out.println("loaded class: " + className);
            ClassReader reader = new ClassReader(classfileBuffer);
            // 2
            ClassWriter writer = new ClassWriter(reader, ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);
            // 3
            reader.accept(new TimeClassVisitor(writer), ClassReader.EXPAND_FRAMES);
            // 4
            return writer.toByteArray();
        }
    }
  • 1处,将原始的类字节码加载到classReader中

    ClassReader reader = new ClassReader(classfileBuffer);

  • 2处,将reader传给ClassWriter,这个我们没讲过,大概就是使用classreader中的东西,来构造ClassWriter;可以差不多理解为复制classreader的东西到ClassWriter中。

    大家可以看如下代码:

    public ClassWriter(final ClassReader classReader, final int flags) {
        super(Opcodes.ASM6);
        symbolTable = new SymbolTable(this, classReader);
        ...
      }
    

    这里new了一个对象,SymbolTable。

    SymbolTable(final ClassWriter classWriter, final ClassReader classReader) {
        this.classWriter = classWriter;
        this.sourceClassReader = classReader;
    
        // Copy the constant pool binary content.
        byte[] inputBytes = classReader.b;
        int constantPoolOffset = classReader.getItem(1) - 1;
        int constantPoolLength = classReader.header - constantPoolOffset;
        constantPoolCount = classReader.getItemCount();
        constantPool = new ByteVector(constantPoolLength);
        constantPool.putByteArray(inputBytes, constantPoolOffset, constantPoolLength);
        ...
    }
    

    大家直接看上面的注释吧,Copy the constant pool binary content。反正吧,基本可以理解为,classwriter拷贝了classreader中的一部分东西,应该不是全部。

    为什么不是全部,因为我试了下:

        public static void main(String[] args) throws IOException {
            ClassReader reader = new ClassReader("org.xunche.app.HelloXunChe");
            ClassWriter writer = new ClassWriter(reader, ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);
            byte[] bytes = writer.toByteArray();
    
            File file = new File(
    "F:\\gitee-ckl\\all-simple-demo-in-work\\java-agent-premain-demo\\test-agent\\src\\main\\java\\org\\xunche\\app\\HelloXunChe.class");
            FileOutputStream fos = new FileOutputStream(file);
            fos.write(bytes);
            fos.close();
        }
    

    上面这样,出来的class文件,是破损的,格式不正确的,无法反编译。

  • 3处,使用TimeClassVisitor作为writer的中间商,此时,顺序变成了:

    classreader --> TimeClassVisitor --> classWriter

  • 4处,返回writer的字节码,给jvm;jvm使用该字节码,去redefine一个class出来

类转换器的具体实现

public static class TimeClassVisitor extends ClassVisitor {
        public TimeClassVisitor(ClassVisitor classVisitor) {
            super(Opcodes.ASM6, classVisitor);
        }
    	// 1
        @Override
        public MethodVisitor visitMethod(int methodAccess, String methodName, String methodDesc, String signature, String[] exceptions) {
            MethodVisitor methodVisitor = cv.visitMethod(methodAccess, methodName, methodDesc, signature, exceptions);
            // 2 
            return new TimeAdviceAdapter(Opcodes.ASM6, methodVisitor, methodAccess, methodName, methodDesc);
        }
    }
}
  • 1处,visitMethod方法,会返回一个MethodVisitor,ASM会拿着我们返回的methodVisitor,去访问当前这个方法
  • 2处,new了一个适配器,TimeAdviceAdapter。

我们这里的TimeAdviceAdapter,主要是希望在方法执行前后做点事,类似于切面,所以继承了一个AdviceAdapter,这个AdviceAdaper,帮我们实现了MethodVisitor的全部方法,我们只需要覆写我们想要覆盖的方法即可。

比如,AdviceAdaper,因为继承了MethodVisitor,其visitCode方法,会在访问方法体时被回调:

@Override
  public void visitCode() {
    super.visitCode();
    // 1
    onMethodEnter();
  }
  //2 
  protected void onMethodEnter() {}

  • 1处,回调本来的onMethodEnter,是一个空实现,就是留给子类去重写的。
  • 2处,可以看到,空实现。

所以,我们最终的TimeAdviceAdaper,代码如下:

public static class TimeAdviceAdapter extends AdviceAdapter {
        private String methodName;
        protected TimeAdviceAdapter(int api, MethodVisitor methodVisitor, int methodAccess, String methodName, String methodDesc) {
            super(api, methodVisitor, methodAccess, methodName, methodDesc);
            this.methodName = methodName;
        }
        @Override
        protected void onMethodEnter() {
            //在方法入口处植入
            if ("<init>".equals(methodName)|| "<clinit>".equals(methodName)) {
                return;
            }
            String className = getClass().getName();
            String s = className + "." + methodName;
            TimeHolder.start(s);
        }
        @Override
        protected void onMethodExit(int i) {
            //在方法出口植入
            if ("<init>".equals(methodName) || "<clinit>".equals(methodName)) {
                return;
            }
            String className = getClass().getName();
            String s = className + "." + methodName;
            long cost = TimeHolder.cost(s);
            System.out.println(s + ": " + cost);
        }
    }

这份代码看着可还行?可惜啊,是假的,是错误的!写asm这么简单的话,那我要从梦里笑醒。

为啥是假的,因为:真正的代码,是长下面这样的:

看到这里,是不是想溜了,这都啥玩意,看不懂啊,不过不要着急,办法总比困难多。

类转换器的真正实现方法

我们先装个idea插件,叫:asm-bytecode-outline。这个插件的作用,简而言之,就是帮你把java代码翻译成ASM的写法。在线装不了的,可以离线装:

asm-bytecode-outline

装好插件后,只要在我们的TimeAdviceAdapter类,点右键:

就会生成我们需要的ASM代码,然后拷贝:

什么时候拷贝结束呢?

1585318732857

基本上,这样就可以了。

填坑指南

作为一个常年掉坑的人,我在这个坑里也摸爬了整整一天。

大家可以看到,我们的java写的方法里,是这样的:

        @Override
        protected void onMethodEnter() {
            //在方法入口处植入
            if ("<init>".equals(methodName)|| "<clinit>".equals(methodName)) {
                return;
            }
            String className = getClass().getName();
            // 1.
            String s = className + "." + methodName;
            TimeHolder.start(s);
        }
  • 1处,访问了本地field,methodName

所以,asm也帮我们贴心地生成了这样的语句:

mv.visitFieldInsn(Opcodes.GETFIELD, "org/xunche/agent/TimeAgentByJava$TimeAdviceAdapter", "methodName", "Ljava/lang/String;");

看起来就像是说,访问org/xunche/agent/TimeAgentByJava$TimeAdviceAdapter类的methodName字段。

但是,这是有问题的。因为,这段代码,最终aop切面会被插入到target:

public class HelloXunChe {
    private String methodName = "abc";
    public static void main(String[] args) throws InterruptedException {
        HelloXunChe helloXunChe = new HelloXunChe();
        helloXunChe.sayHi();
    }
    public void sayHi() throws InterruptedException {
        System.out.println("hi, xunche");
        sleep();
    }

    public void sleep() throws InterruptedException {
        Thread.sleep((long) (Math.random() * 200));
    }

}

我实话跟你说,这个target类里,压根访问不到org/xunche/agent/TimeAgentByJava$TimeAdviceAdapter类的methodName字段。

我是怎么发现这个问题的,之前一直报错,直到我在target后来加了这么一行:

public class HelloXunChe {
    private String methodName = "abc";
    ...
}

哎,没个大佬带我,真的难。

当然,我是通过这个确认了上述问题,最终解决的思路呢,就是:把你生成的class,反编译出来看看,看看是不是你想要的。

所以,我专门写了个main测试类,来测试改后的class是否符合预期。

public class SaveGeneratedClassWithOriginAgentTest {

    public static void main(String[] args) throws IOException {
        //1
        ClassReader reader = new ClassReader("org.xunche.app.HelloXunChe");
        ClassWriter writer = new ClassWriter(reader, ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);
        reader.accept(new TimeAgentByJava.TimeClassVisitor(writer), ClassReader.EXPAND_FRAMES);
        byte[] bytes = writer.toByteArray();
	    
        // 2
        File file = new File(
"F:\\ownprojects\\all-simple-demo-in-work\\java-agent-premain-demo\\test-agent\\src\\main\\java\\org\\xunche\\app\\HelloXunCheCopy2.class");
        FileOutputStream fos = new FileOutputStream(file);
        fos.write(bytes);
        fos.close();
    }
}
  • 1处这段代码,就是模拟在classTransformer中的那段。
  • 2处,将最终要返回给jvm的那段class字节码,写到一个文件里,然后我们就可以反编译,看看有问题没。

所以,上面那段asm,大家如果看:

初探 Java agent

会发现,访问methodname那句代码,是这么写的:

mv.visitLdcInsn(methodName);

这就是,相当于直接把methodName写死到最终的class里去了;最终的class就会是想要的样子:

public void sayHi() throws InterruptedException {
        //1 
        TimeHolder.start(this.getClass().getName() + "." + "sayHi");
        System.out.println("hi, xunche");
        this.sleep();
        // 2
        String var1 = this.getClass().getName() + "." + "sayHi";
        System.out.println(var1 + ": " + TimeHolder.cost(var1));
    }
  • 1/2处,直接把sayHi写死到target了,而不是此时再去访问field。

maven插件配置premain-class

插件中,配置Premain-Class

<plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <version>2.3.1</version>
                <configuration>
                    <archive>
                        <manifest>
                            <addClasspath>true</addClasspath>
                        </manifest>
                        <manifestEntries>
                            <Premain-Class>
                                org.xunche.agent.TimeAgent
                            </Premain-Class>
                        </manifestEntries>
                    </archive>
                </configuration>
            </plugin>

测试模块开发

测试模块,没啥开发的,就只有那个target那个类。

运行

最终我是这么运行的:

java -javaagent:agent.jar -classpath lib/*;java-agent-premain-demo.jar org/xunche/app/He
lloXunChe

这里指定了lib目录,主要是agent模块需要的jar包:

简单的运行效果如下:

loaded class: org/xunche/app/HelloXunChe
methodName = 0 <init>
methodName = 0 main
methodName = 0 sayHi
methodName = 0 sleep
hi, xunche
org.xunche.app.HelloXunChe.abc: 129
org.xunche.app.HelloXunChe.abc: 129

总结

ASM这个东西,想要不熟悉字节码就去像我上面这样傻瓜操作,坑还是比较多的,比较难趟。回头有空再介绍字节码吧。我也是半桶水,大家一起学习吧。 本节源码: https://gitee.com/ckl111/all-simple-demo-in-work/tree/master/java-agent-premain-demo

原文出处:https://www.cnblogs.com/grey-wolf/p/12584861.html

展开阅读全文
打赏
0
0 收藏
分享
加载中
更多评论
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部