0x01 前言

在Java中实现对象反序列化非常简单
只需要继承并实现 java.io.Serializable 或是 java.io.Externalizable 接口即可被序列化

其中 java.io.Externalizable 只是实现了 java.io.Serializable 的接口
但是两者还是有区别的,区别如下:
注意: 复制了P牛的小圈子一个大佬发的结论,比我自己总结的更好, 总的来说,有点小小修改

  1. 实现 Externalizable, 序列化过程需要开发人员自己实现。未实现 writeExternal()和 readExternal()，则序列化时不会保存和读取任何字段。属性使用和不使用 transient 修饰，无任何区别
  2. Externalizable 优先级比 Serializable 更高

  3. 如果在序列化的时候使用了构造方法的情况下,那Externalizable 必须要创建默认的无参构造方法, Serializable 方法可以没有默认的无参构造方法

    java.io.Externalizable 的例子讲解,下一篇在讲, 本文请聚焦在 java.io.Serializable

其中第三点,需要在在在注意一下,使用 Externalizable 的时候:
如果你在序列化的时候没有使用构造方法!!!!!
那么是可以不创建无参构造方法也能成功反序列化的
但是如果你使用了构造方法来进行序列化!!!!!
那么则必须创建一个无参构造方法,这样才能成功的反序列化

反序列化类对象时有如下限制:

  1. 被反序列化的类必须存在
  2. serialVersionUID 值必须一致

注意: 修改,添加,删除被序列化类的方法或是属性都会导致 serialVersionUID 值的变化

另外需要注意的一点:
反序列化时类对象是不会调用该类构造方法的!!!!!
因为反序列化时是使用的 sun.reflect.ReflectionFactory.newConstructorForSerialization 来创建了一个反序列化专用的 Constructor, 接着使用这个 Constructor 来绕过构造方法创建类实例

当然还有另外一种绕过 Constructor 构造方法创建类实例可以查看前面的章节
Java速记->第二章-Java 安全基础->3. Java sun.misc.Unsafe的妙用进行学习查看

0x02 重点的类方法

  1. java.io.ObjectOutputStream 类最核心的方法就是 writeObject()方法,即序列化类对象
  3. java.io.ObjectInputStream 类最核心的方法就是 readObject()方法,即反序列化类对象
  5. 因此只需借助 ObjectOutputStream 与 ObjectInputStream 类,即可实现类的序列化和反序列化功能
  7. 而其中:
  8. java.io.ObjectOutputStream 类,有几个常用方法分别是
  9.     writeObject() # 自定义序列化类对象,类被序列化时调用
  10.   writeReplace() # 写入替换对象时触发,类被序列化时调用
  11. 注意: writeObject() 方法是漏洞造成的重灾区之一, 因此需要认真学习并理解该方法
  13. java.io.ObjectInputStream 类,有几个常用方法分别是
  14.     readObject() # 自定义反序列化类对象,反序列化时调用
  15.   readResolve() # 读取对象时触发
  16.     readObjectNoData() # 当对象序列化的版本和反序列化时的class版本不同时触发,注意这里指的是序列化与反序列化的版本,不是java版本
  17.   readUnshared() # 此方法与readObject()相同,不同之处在于它阻止对readObject和readUnshared的后续调用返回对通过此调用获得的反序列化实例的额外引用
  18. 注意: readObject() 方法是漏洞造成的重灾区之一, 因此需要认真学习并理解该方法

0x03 java.io.Serializable 接口作用

java.io.Serializable 如果跟进去你就会发现,这是一个空接口,开发者无需实现里面的任何方法
代码如下:

  1. public interface Serializable {
  2. }

继承并实现 java.io.Serializable 这个接口的作用就是表明这个类可序列化
并且会通过这个类的方法与变量计算出来一个 serialVersionUID 常量

这个serialVersionUID是用来验证版本是否一致的
在进行反序列化时, JVM会把传进来的字节流中的 serialVersionUID 与本地相应实体类的serialVersionUID进行比较
如果有变化serialVersionUID就会不同, 导致InvalidClassException异常, 否则就进行反序列化

注意: serialVersionUID 是可以自己创建的,但是一般都不会自己去创建
创建 serialVersionUID 的例子例如:

  1. # 格式
  2. public class Person implements Serializable {
  3.     # 喜欢多长自己写
  4.     # 注意: 这个类型必须为long
  5.     private static final long  serialVersionUID = xL;
  6. }
  8. # 实例
  9. public class Person implements Serializable {
  10.    private static final long  serialVersionUID = 2239109261752820180L;
  11. }

0x04 例子

以下的例子主要是让我们知道这些方法在什么时候会被调用,心里有个大概的数,这样子方便理解后面的关于反序列化链子的文章

0x04.1 java.io.ObjectOutputStream 类

0x04.1.1 writeObject() - 重点方法

  1. // 第一步创建 SerializeTest1 类
  2. package java反序列化测试;
  4. import java.io.IOException;
  5. import java.io.ObjectOutputStream;
  6. import java.io.Serializable;
  8. public class SerializeTest1 implements Serializable {
  9.     /**
  10.      * 自定义序列化类对象
  11.      * 调用: 类被序列化时调用
  12.      * 注意: writeReplace() 与 writeObject() 同时存在时,执行 writeReplace()
  13.      *
  14.      * @param oos 序列化输出流对象
  15.      * @throws IOException IO异常
  16.      */
  17.     private void writeObject(ObjectOutputStream oos) throws IOException {
  18.         System.out.println("writeObject...");
  20.         // ObjectOutputStream 默认反序列化方法
  21.         oos.defaultWriteObject();
  22.     }
  23. }
  1. // 第二步-序列化 SerializeTest1 类
  2. package java反序列化测试;
  4. import java.io.FileOutputStream;
  5. import java.io.IOException;
  6. import java.io.ObjectOutputStream;
  8. public class SerializeDemo1 {
  9.     public static void main(String[] args) {
  10.         // SerializeTest1 序列化
  11.         SerializeTest1 e = new SerializeTest1();
  13.         try {
  14.             FileOutputStream fileOut = new FileOutputStream("./src/main/java/java反序列化测试/SerializeTest1.ser");
  15.             ObjectOutputStream out = new ObjectOutputStream(fileOut);
  16.             out.writeObject(e);
  17.             out.close();
  18.             fileOut.close();
  19.         } catch (IOException i) {
  20.             i.printStackTrace();
  21.         }
  22.     }
  23. }
  29. // 运行结果:
  30. // 输出: writeObject...
  31. // 并且会在在 /src/main/java/java反序列化测试/ 生成一个 SerializeTest1.ser 文件

0x04.1.2 writeReplace()

  1. // 第一步创建 SerializeTest2 类
  2. package java反序列化测试;
  4. import java.io.Serializable;
  5. import java.util.ArrayList;
  7. public class SerializeTest2 implements Serializable {
  8.     /**
  9.      * 写入替换对象时触发
  10.      * 调用: 类被序列化时调用
  11.      * 注意: writeReplace() 与 writeObject() 同时存在时,执行 writeReplace()
  12.      * 启动这个以后获取的内容只有 list
  13.      *
  14.      * @return 替换后的对象
  15.      */
  16.     private Object writeReplace() {
  17.         System.out.println("writeReplace....");
  19.         ArrayList<Object> list = new ArrayList<>();
  20.         list.add("test1");
  21.         list.add("test2");
  22.         return list;
  23.     }
  24. }
  1. // 第二步-序列化 SerializeTest2 类
  2. // 并且反序列化获取 writeReplace() 方法,返回的数据
  3. package java反序列化测试;
  5. import java.io.*;
  7. public class SerializeDemo2 {
  8.     public static void main(String[] args) {
  9.         // SerializeTest2 序列化
  10.         // 返回结果: writeReplace....
  11.         try {
  12.             SerializeTest2 e = new SerializeTest2();
  13.             FileOutputStream fileOut = new FileOutputStream("./src/main/java/java反序列化测试/SerializeTest2.ser");
  14.             ObjectOutputStream out = new ObjectOutputStream(fileOut);
  15.             out.writeObject(e);
  16.             out.close();
  17.             fileOut.close();
  18.         } catch (IOException i) {
  19.             i.printStackTrace();
  20.         }
  22.         // SerializeTest2 反序列化读取 writeReplace() 返回的数据
  23.         // 返回结果: [test1, test2]
  24.         try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("./src/main/java/java反序列化测试/SerializeTest2.ser"))) {
  25.             System.out.println((ois.readObject()).toString());
  26.         } catch (FileNotFoundException er) {
  27.             er.printStackTrace();
  28.         } catch (IOException er) {
  29.             er.printStackTrace();
  30.         } catch (ClassNotFoundException er) {
  31.             er.printStackTrace();
  32.         }
  33.     }
  34. }
  41. // 运行结果:
  42. // 1. SerializeTest2 序列化
  43. // 输出: writeReplace....
  44. // 并且会在在 /src/main/java/java反序列化测试/ 生成一个 SerializeTest2.ser 文件
  45. //
  46. // 2. SerializeTest2 反序列化读取 writeReplace() 返回的数据
  47. // 输出: [test1, test2]

0x04.2 java.io.ObjectOutputStream 类

0x04.2.1 readObject() - 重点方法

  1. // 第一步创建 DeserializationTest1 类
  2. package java反序列化测试;
  4. import java.io.IOException;
  5. import java.io.ObjectInputStream;
  6. import java.io.Serializable;
  8. public class DeserializationTest1 implements Serializable {
  9.     /**
  10.      * 自定义反序列化类对象
  11.      * 调用: 反序列化时调用
  12.      *
  13.      * @param ois 反序列化输入流对象
  14.      * @throws IOException            IO异常
  15.      * @throws ClassNotFoundException 类未找到异常
  16.      */
  17.     private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
  18.         System.out.println("readObject...");
  20.         // 调用ObjectInputStream默认反序列化方法
  21.         ois.defaultReadObject();
  22.     }
  23. }
  1. // 第二步-序列化 DeserializationTest1 类
  2. // 并且反序列化 DeserializationTest1 类
  3. package java反序列化测试;
  5. import java.io.*;
  7. public class DeserializationDemo1 {
  8.     public static void main(String[] args) {
  9.         // 序列化
  10.         try {
  11.             DeserializationTest1 e = new DeserializationTest1();
  12.             FileOutputStream fileOut = new FileOutputStream("./src/main/java/java反序列化测试/DeserializationTest1.ser");
  13.             ObjectOutputStream out = new ObjectOutputStream(fileOut);
  14.             out.writeObject(e);
  15.             out.close();
  16.             fileOut.close();
  17.         } catch (IOException i) {
  18.             i.printStackTrace();
  19.         }
  25.         // 反序列化 DeserializationTest1
  26.         try {
  27.             FileInputStream fileIn = new FileInputStream("./src/main/java/java反序列化测试/DeserializationTest1.ser");
  28.             ObjectInputStream in = new ObjectInputStream(fileIn);
  29.             in.readObject();
  30.             in.close();
  31.             fileIn.close();
  32.         } catch (IOException i) {
  33.             i.printStackTrace();
  34.             return;
  35.         } catch (ClassNotFoundException c) {
  36.             System.out.println("DeserializationTest1 class not found");
  37.             c.printStackTrace();
  38.             return;
  39.         }
  40.     }
  41. }
  47. // 运行结果:
  48. // 1. DeserializationTest1 序列化
  49. // 并且会在在 /src/main/java/java反序列化测试/ 生成一个 DeserializationTest1.ser 文件
  50. //
  51. // 2. 反序列化 DeserializationTest1 并且自动调用了 readObject()
  52. // 输出: readObject...

0x04.2.2 readResolve()

  1. // 第一步创建 DeserializationTest2 类
  2. package java反序列化测试;
  4. import java.io.Serializable;
  6. public class DeserializationTest2 implements Serializable {
  7.     /**
  8.      * 读取对象时触发
  9.      * 有了这个以后 getTestName() 与 getTestValue() 会访问不到
  10.      *
  11.      * @return 读取后的对象
  12.      */
  13.     protected Object readResolve() {
  14.         System.out.println("readResolve....");
  16.         return null;
  17.     }
  18. }
  1. // 第二步-序列化 DeserializationTest2 类
  2. // 并且反序列化 DeserializationTest2 类
  3. package java反序列化测试;
  5. import java.io.*;
  7. public class DeserializationDemo2 {
  8.     public static void main(String[] args) {
  9.         // 序列化
  10.         try {
  11.             DeserializationTest2 e = new DeserializationTest2();
  12.             FileOutputStream fileOut = new FileOutputStream("./src/main/java/java反序列化测试/DeserializationTest2.ser");
  13.             ObjectOutputStream out = new ObjectOutputStream(fileOut);
  14.             out.writeObject(e);
  15.             out.close();
  16.             fileOut.close();
  17.         } catch (IOException i) {
  18.             i.printStackTrace();
  19.         }
  25.         // 反序列化 DeserializationTest1
  26.         try {
  27.             FileInputStream fileIn = new FileInputStream("./src/main/java/java反序列化测试/DeserializationTest2.ser");
  28.             ObjectInputStream in = new ObjectInputStream(fileIn);
  29.             in.readObject();
  30.             in.close();
  31.             fileIn.close();
  32.         } catch (IOException i) {
  33.             i.printStackTrace();
  34.             return;
  35.         } catch (ClassNotFoundException c) {
  36.             System.out.println("DeserializationTest2 class not found");
  37.             c.printStackTrace();
  38.             return;
  39.         }
  40.     }
  41. }
  48. // 运行结果:
  49. // 1. DeserializationTest2 序列化
  50. // 并且会在在 /src/main/java/java反序列化测试/ 生成一个 DeserializationTest2.ser 文件
  51. //
  52. // 2. 反序列化 DeserializationTest2 并且自动调用了 readResolve()
  53. // 输出: readResolve....

0x04.2.3 readObjectNoData()

这个方法,说实在,我在看反序列化链子的时候就没见过有怎么使用,并且触发的方式也是奇奇怪怪,所以这个方法很值得我们写个例子,搞清楚到底要怎么样才会触发,然后知道有这么一个东西即可

注意: 它的触发方法是,当对象序列化的版本和反序列化时的class版本不同时触发,注意这里指的是序列化与反序列化的版本,不是java版本

注意2: readObjectNoData() 方法是最先执行的

  1. // 第一步创建 DeserializationTest3 类
  2. package java反序列化测试;
  4. import java.io.Serializable;
  6. public class DeserializationTest3 implements Serializable {
  8. }
  1. // 第二步创建 ReadObjectNoDataTest 类
  2. package java反序列化测试;
  4. import java.io.Serializable;
  6. public class ReadObjectNoDataTest implements Serializable {
  7.     /**
  8.      * 当对象序列化的版本和反序列化时的class版本不同时触发,注意这里指的是序列化与反序列化的版本,不是java版本
  9.      */
  10.     private void readObjectNoData() {
  11.         System.out.println("readObjectNoData...");
  12.     }
  13. }
  1. // 第三步-序列化 DeserializationTest3 类
  2. package java反序列化测试;
  4. import java.io.FileOutputStream;
  5. import java.io.IOException;
  6. import java.io.ObjectOutputStream;
  8. public class SerializeDemo3 {
  9.     public static void main(String[] args) {
  10.         // DeserializationTest3 序列化
  11.         try {
  12.             DeserializationTest3 e = new DeserializationTest3();
  13.             FileOutputStream fileOut = new FileOutputStream("./src/main/java/java反序列化测试/DeserializationTest3.ser");
  14.             ObjectOutputStream out = new ObjectOutputStream(fileOut);
  15.             out.writeObject(e);
  16.             out.close();
  17.             fileOut.close();
  18.         } catch (IOException i) {
  19.             i.printStackTrace();
  20.         }
  21.     }
  22. }
  28. // 运行结果:
  29. // DeserializationTest3 序列化
  30. // 并且会在在 /src/main/java/java反序列化测试/ 生成一个 DeserializationTest3.ser 文件
  1. // 第四步-修改 DeserializationTest3 类如下
  2. package java反序列化测试;
  4. import java.io.Serializable;
  6. public class DeserializationTest3 extends ReadObjectNoDataTest implements Serializable {
  8. }
  1. // 第五步-反序列化 DeserializationTest3 类
  2. package java反序列化测试;
  4. import java.io.FileInputStream;
  5. import java.io.IOException;
  6. import java.io.ObjectInputStream;
  8. public class DeserializationDemo3 {
  9.     public static void main(String[] args) {
  10.         // 反序列化 DeserializationTest3
  11.         try {
  12.             FileInputStream fileIn = new FileInputStream("./src/main/java/java反序列化测试/DeserializationTest3.ser");
  13.             ObjectInputStream in = new ObjectInputStream(fileIn);
  14.             in.readObject();
  15.             in.close();
  16.             fileIn.close();
  17.         } catch (IOException i) {
  18.             i.printStackTrace();
  19.             return;
  20.         } catch (ClassNotFoundException c) {
  21.             System.out.println("DeserializationTest3 class not found");
  22.             c.printStackTrace();
  23.             return;
  24.         }
  25.     }
  26. }
  32. // 运行结果:
  33. // 输出: readObjectNoData...

0x04.2.4 readUnshared()

  1. // 创建 ReadUnsharedDemo 类
  2. package java反序列化测试;
  4. import java.io.FileInputStream;
  5. import java.io.FileOutputStream;
  6. import java.io.ObjectInputStream;
  7. import java.io.ObjectOutputStream;
  9. public class ReadUnsharedDemo {
  10.     public static void main(String[] args) {
  11.         String s = "Hello World";
  13.         try {
  14.             // 序列化文件
  15.             FileOutputStream fileOut = new FileOutputStream("./src/main/java/java反序列化测试/test.txt");
  16.             ObjectOutputStream out = new ObjectOutputStream(fileOut);
  17.             out.writeUnshared(s);
  18.             out.flush();
  20.             // 反序列化文件
  21.             ObjectInputStream ois = new ObjectInputStream(new FileInputStream("./src/main/java/java反序列化测试/test.txt"));
  23.             // 读取和打印非共享对象
  24.             System.out.println("" + ois.readUnshared());
  25.         } catch (Exception ex) {
  26.             ex.printStackTrace();
  27.         }
  28.     }
  29. }
  33. // 运行结果:
  34. // 输出: Hello World