Condivisione tecnica sulla deserializzazione Java

Questa condivisione riguarda i seguenti punti:

1. Basi di serializzazione e deserializzazione Java
2. Perché si verificano vulnerabilità durante la deserializzazione?
3. Riflessione Java
4. ysoserial CommonsCollections2、CommonsCollections5
5. Diversi metodi di caricamento delle classi con Java ClassLoader
6. WebLogic CVE-2020-2555 CVE-2020-2883 RCE
7. Shiro-550 rememberMe codifica fissa che porta a RCE tramite deserializzazione
8. WebLogic + Shiro deserializzazione per registrare un filter shell in memoria con un clic

Basi di serializzazione e deserializzazione Java

La serializzazione Java si riferisce al processo di conversione di un oggetto Java in una sequenza di byte per facilitare la memorizzazione in memoria, file o database. Il metodo writeObject() della classe ObjectOutputStream può realizzare la serializzazione, convertendo l'oggetto Java in una sequenza di byte.

La deserializzazione Java si riferisce al processo di ripristino di una sequenza di byte in un oggetto Java. Il metodo readObject() della classe ObjectInputStream viene utilizzato per la deserializzazione.

Facciamo un semplice esempio, vedere il codice SerializeAndDeserialize ps: qui concentrarsi sul tipo di cast forzato nel codice```java package org.chabug.demo;

import org.chabug.entity.Dog; import org.chabug.entity.Person; import org.chabug.util.Serializables;

/* 这个例子是为了证明只要实现了Serializable接口的类都可以被序列化 并且Java内置的几大数据类型也可被序列化，因为他们都继承了Object类 */

public class SerializeAndDeserialize {

public static void main(String[] args) throws Exception {
    byte[] bytes;
    String s1 = "I'm a String Object....";
    bytes = Serializables.serializeToBytes(s1);
    Object o1 = Serializables.deserializeFromBytes(bytes);
    System.out.println(o1);

    String[] s2 = new String[]{"tom", "bob", "jack"};
    bytes = Serializables.serializeToBytes(s2);
    String[] o2 = (String[])Serializables.deserializeFromBytes(bytes);
    System.out.println(o2);

    int i = 123;
    bytes = Serializables.serializeToBytes(i);
    int o3 = (Integer) Serializables.deserializeFromBytes(bytes);
    System.out.println(o3);

    // 一只名叫woody的狗
    Dog dog = new Dog();
    dog.setName("woody");

    // tom
    Person tom = new Person();
    tom.setAge(14);
    tom.setName("tom");
    tom.setSex("男");
    tom.setDog(dog);

    bytes = Serializables.serializeToBytes(tom);
    Person o = (Person) Serializables.deserializeFromBytes(bytes);
    System.out.println(o);

}

}

Tipi di dati incorporati in Java come String, Integer, array, Object ecc. possono essere serializzati. Le nostre classi Person e Dog, purché implementino l'interfaccia Serializable, possono essere serializzate e deserializzate.

## Perché ci sono vulnerabilità durante la deserializzazione?

Diamo un'occhiata a un pezzo di codice: ora c'è una classe entità maligna EvilClass```java
package org.chabug.entity;

import java.io.ObjectInputStream;
import java.io.Serializable;

public class EvilClass implements Serializable {
    String name;

    public EvilClass() {
        System.out.println(this.getClass() + "的EvilClass()构造方法被调用!!!!!!");
    }

    public EvilClass(String name) {
        System.out.println(this.getClass() + "的EvilClass(String name)构造方法被调用!!!!!!");
        this.name = name;
    }

    public String getName() {
        System.out.println(this.getClass() + "的getName被调用!!!!!!");
        return name;
    }

    public void setName(String name) {
        System.out.println(this.getClass() + "的setName被调用!!!!!!");
        this.name = name;
    }

    @Override
    public String toString() {
        System.out.println(this.getClass() + "的toString()被调用!!!!!!");
        return "EvilClass{" +
                "name='" + getName() + '\'' +
                '}';
    }

    private void readObject(ObjectInputStream in) throws Exception {
        //执行默认的readObject()方法
        in.defaultReadObject();
        System.out.println(this.getClass() + "readObject()被调用!!!!!!");
        Runtime.getRuntime().exec(new String[]{"cmd", "/c", name});
    }
}

Nel suo readObject c'è il codice per eseguire comandi Runtime.getRuntime().exec(new String[]{"cmd", "/c", name}), il parametro name è il comando da eseguire. Quindi possiamo costruire un oggetto malevolo, impostare la sua proprietà name con il comando da eseguire, e quando la deserializzazione attiva readObject, si verificherà RCE. Come segue.```java package org.chabug.demo;

import org.chabug.entity.EvilClass; import org.chabug.util.Serializables;

public class EvilSerialize { public static void main(String[] args) throws Exception { EvilClass evilObj = new EvilClass(); evilObj.setName("calc"); byte[] bytes = Serializables.serializeToBytes(evilObj); EvilClass o = (EvilClass) Serializables.deserializeFromBytes(bytes); System.out.println(o); } }

![image-20200822105256120](https://assets.kitploit.com/production/public/readmes/21799/7f07c0c8196e56e1d554bce64f73f069bdd3e589a3302936c831903e5f7e5539.png)

Ora che sappiamo come la deserializzazione può portare a RCE, ma nello sviluppo non si può scrivere direttamente così, quindi entra in gioco la ricerca delle catene di utilizzo. Una vulnerabilità di deserializzazione necessita di tre elementi:

1. Punto di ingresso della deserializzazione (source)
2. Metodo target (sink)
3. Catena di gadget (gadget chain)

Osservando attentamente l'output nell'immagine sopra, non solo è stato attivato il metodo readObject, ma anche toString(), costruttore senza parametri, set, get. Quindi nella pratica, quando si cercano catene di utilizzo, non bisogna concentrarsi solo sui metodi readObject().

A questo punto dobbiamo capire cos'è la **riflessione**. Nell'esempio precedente abbiamo menzionato il problema del **casting forzato**. Nello sviluppo reale, all'interno di readObject si effettua un'elaborazione logica; quando non si conosce il tipo specifico dell'oggetto passato, si utilizza la riflessione per determinare la chiamata. E la riflessione è il nostro strumento principale per raggiungere RCE.

## Riflessione in Java

Cos'è la riflessione? "Riflessione" contiene il prefisso "ri-", quindi per spiegare la riflessione si parte dalla "riflessione diretta" (proiezione). Guardiamo il codice. Questa è la mia classe entità.```java
package org.chabug.entity;

import java.io.IOException;

public class ReflectionClass {
    String name;

    public ReflectionClass(String name) {
        this.name = name;
    }

    public ReflectionClass() {
    }

    public String say() {
        return this.name;
    }

    private void evil(String cmd) {
        try {
            Runtime.getRuntime().exec(new String[]{"cmd","/c",cmd});
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

Scrittura normale```java package org.chabug.demo;

import org.chabug.entity.ReflectionClass;

public class ReflectionDemo { public static void main(String[] args) { ReflectionClass demo = new ReflectionClass(); demo.setName("hello"); System.out.println(demo.say()); // demo.evil("calc"); // 不能够调用private方法 } }

很简单就是通过new创建了一个ReflectionClass实例，然后通过实例去调用其所属方法，这就是"正射"。但是当你new的时候不知道类名怎么办？受private保护的方法怎么调用？反射的作用就体现出来了。看下面这一段代码```java
package org.chabug.demo;

import org.chabug.entity.ReflectionClass;

import java.lang.reflect.Method;