Compartir técnica de deserialización de Java

Los aspectos cubiertos en esta presentación son los siguientes:

1. Conceptos básicos de serialización y deserialización de Java
2. ¿Por qué se generan vulnerabilidades durante la deserialización?
3. Reflexión de Java
4. ysoserial CommonsCollections2、CommonsCollections5
5. Varios métodos para cargar clases con Java ClassLoader
6. WebLogic CVE-2020-2555 CVE-2020-2883 RCE
7. Shiro-550 rememberMe codificación rígida que conduce a deserialización RCE
8. WebLogic + Shiro deserialización registro con un clic de filter memory shell

Conceptos básicos de serialización y deserialización de Java

La serialización de Java se refiere al proceso de convertir objetos Java en una secuencia de bytes para facilitar su almacenamiento en memoria, archivos o bases de datos. El método writeObject() de la clase ObjectOutputStream puede implementar la serialización, transformando objetos Java en secuencias de bytes.

La deserialización de Java se refiere al proceso de restaurar una secuencia de bytes a un objeto Java. El método readObject() de la clase ObjectInputStream se utiliza para la deserialización.

Ponga un ejemplo simple, vea el código SerializeAndDeserialize ps: Preste especial atención a la conversión forzada de tipos en el código```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);

}

}

Los tipos de datos incorporados de Java, como String, Integer, arrays y objetos Object, pueden serializarse. Las clases que escribimos nosotros mismos, como Person y Dog, pueden serializarse y deserializarse siempre que implementen la interfaz Serializable.



## ¿Por qué se producen vulnerabilidades durante la deserialización?

Veamos un fragmento de código. Ahora tenemos una clase de entidad maliciosa llamada 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});
    }
}

En su readObject, hay código que ejecuta comandos con Runtime.getRuntime().exec(new String[]{"cmd", "/c", name}). El parámetro name es el comando a ejecutar. Entonces podemos construir un objeto malicioso, asignar su atributo name al comando que queremos ejecutar, y cuando la deserialización active readObject, se producirá RCE. Como sigue```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)

Ahora que sabemos cómo la deserialización puede ser explotada para obtener RCE, en el desarrollo real tampoco se escribe así directamente, por lo que aquí entra en juego la búsqueda de cadenas de explotación. Una vulnerabilidad de deserialización requiere tres elementos:

1. Punto de entrada de deserialización (source)
2. Método destino (sink)
3. Cadena de gadgets (gadget chain)

Si observamos con atención los resultados de la salida en la imagen anterior, no solo se activa el método `readObject`, sino también `toString()`, el constructor sin argumentos, `set` y `get`. Por lo tanto, en la búsqueda real de cadenas de explotación no solo hay que centrarse en el método `readObject()`.

Ahora necesitamos entender el concepto de **reflexión**. Anteriormente mencionamos el problema de **conversión forzada de tipos**. En el desarrollo real, dentro de `readObject` se realiza un procesamiento lógico. Cuando no se conoce el tipo de datos específico del objeto entrante, se determina la llamada mediante reflexión, y la reflexión es un medio importante para lograr RCE.

## Reflexión en Java

¿Qué es la reflexión? La palabra "reflexión" contiene el prefijo "re-", por lo que para explicar la reflexión debemos empezar por el "lado directo". Veamos el código. Esta es mi clase de entidad.```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;
    }
}

escritura normal```java package org.chabug.demo;

import org.chabug.entity.ReflectionClass;