Java原生序列化与反序列化

序列化与反序列化

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

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

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

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

1. import java.io.Serializable;
3. public class Person implements Serializable {
4.     // 需要实现Serializable接口才可以序列化
5.     private String name;
6.     private int age;
8.     public Person(){
10.     }
12.     public Person(String name, int age) {
13.         this.name = name;
14.         this.age = age;
15.     }
17.     @Override
18.     public String toString() {
19.         return "Person{" +
20.                 "name='" + name + '\'' +
21.                 ",age=" + age +
22.                 '}';
23.     }
24. }

复制代码

序列化操作，SerializationTest.java：

1. import java.io.FileOutputStream;
2. import java.io.IOException;
3. import java.io.ObjectOutputStream;
5. public class SerializationTest {
6.     public static void serialize(Object obj) throws IOException {
7.         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
8.         oos.writeObject(obj);
9.     }
11.     public static void main(String[] args) throws Exception{
12.         Person person = new Person("a", 18);
13.         serialize(person);
14.     }
15. }

复制代码

反序列化操作，UnserializeTest.java：

1. import java.io.FileInputStream;
2. import java.io.IOException;
3. import java.io.ObjectInputStream;
5. public class UnserializeTest {
6.     public static Object unserialize(String Filename) throws IOException, ClassNotFoundException {
7.         ObjectInputStream ois = new ObjectInputStream(new FileInputStream(Filename));
8.         Object obj = ois.readObject();
9.         return obj;
10.     }
12.     public static void main(String[] args) throws Exception {
13.         Person person = (Person) unserialize("ser.bin");
14.         System.out.println(person);
15.     }
16. }

复制代码

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

1. 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方法中执行命令：
  

1. package org.example;
3. import java.io.IOException;
4. import java.io.ObjectInputStream;
5. import java.io.Serializable;
7. public class Person implements Serializable {
8.     private transient String name;
9.     private int age;
11.     public Person(){
13.     }
15.     public Person(String name, int age) {
16.         this.name = name;
17.         this.age = age;
18.     }
20.     @Override
21.     public String toString() {
22.         return "Person{" +
23.                 "name='" + name + '\'' +
24.                 ",age=" + age +
25.                 '}';
26.     }
28.     private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
29.         ois.defaultReadObject();
30.         Runtime.getRuntime().exec("calc");
31.     }
32. }

复制代码

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

• （2）入口类参数中包含可控类，该类有危险方法，readObject时调用。
  要实现反序列化攻击，入口类最好是继承Serializable，重写readObject，调用常见函数，参数类型宽泛，jdk自带，比如HashMap：
  
  
• （3）入口类中包含可控类，该类又调用其他有危险的方法的类，readObject时调用。
  
• （4）构造函数/静态代码块等类加载时隐式执行。
  

参考链接

[1] https://www.bilibili.com/video/BV16h411z7o9

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！