Java原生序列化与反序列化

序列化与反序列化

Java序列化是指把Java对象转换为字节序列的过程;而Java反序列化是指把字节序列恢复为Java对象的过程。

为什么需要序列化？

序列化分为两大部分:序列化和反序列化。序列化是这个过程的第一部分，将数据分解成字节流，以便存储在文件中或在网络上传输。反序列化就是打开字节流并重构对象。对象序列化不仅要将基本数据类型转换成字节表示，有时还要恢复数据。恢复数据要求有恢复数据的对象实例。

序列化为什么会产生安全问题？

只要服务端反序列化数据，客户端传递类的readObject中代码会自动执行，给予攻击者在服务器上运行代码的能力。

Java序列化基本流程

有如下三个文件，Person.java：

import java.io.Serializable;
 
public class Person implements Serializable {
    // 需要实现Serializable接口才可以序列化
    private String name;
    private int age;
 
    public Person(){
 
    }
 
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ",age=" + age +
                '}';
    }
}

序列化操作，SerializationTest.java：

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
 
public class SerializationTest {
    public static void serialize(Object obj) throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        oos.writeObject(obj);
    }
 
    public static void main(String[] args) throws Exception{
        Person person = new Person("a", 18);
        serialize(person);
    }
}

反序列化操作，UnserializeTest.java：

import java.io.FileInputStream;
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 Exception {
        Person person = (Person) unserialize("ser.bin");
        System.out.println(person);
    }
}

SerializationTest中首先生成一个person对象，然后将生成的person对象进行序列化操作，得到二进制文件ser.bin，接着在UnserializeTest中实现反序列化操作得到person对象，并打印出来：

Person{name='a',age=18}

注意：

• （1）想要序列化的对象需要实现Serializable接口才可以序列化。
• （2）使用transient标识的对象不参与序列化。
  在Person类中，name属性之前加上transient，改为private transient String name;之后再次尝试序列化和反序列化，输出结果：Person{name='null',age=18}。
• （3）静态成员变量不能被序列化，因为序列化是针对对象的，而静态成员变量属于类。

可能存在反序列化漏洞的形式

• （1）入口类的readObject直接调用危险方法。
  Person类文件中重写了readObject方法，在readObject方法中执行命令：

package org.example;
 
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.Serializable;
 
public class Person implements Serializable {
    private transient String name;
    private int age;
 
    public Person(){
 
    }
 
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ",age=" + age +
                '}';
    }
 
    private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
        ois.defaultReadObject();
        Runtime.getRuntime().exec("calc");
    }
}

再次执行SerializationTest和UnserializeTest实现序列化和反序列化，在反序列化时会调用重写的readObject，从而执行其中的命令，弹出计算器：

• （2）入口类参数中包含可控类，该类有危险方法，readObject时调用。
  要实现反序列化攻击，入口类最好是继承Serializable，重写readObject，调用常见函数，参数类型宽泛，jdk自带，比如HashMap：
  

• （3）入口类中包含可控类，该类又调用其他有危险的方法的类，readObject时调用。

• （4）构造函数/静态代码块等类加载时隐式执行。