• Java序列化和反序列的正常使用 √
  • Java反序列化readObject是如何构成漏洞的？
  • java反序列化的服务器环境中是否需要序列化的类的定义，才能触发反序列化漏洞？
  • 为何readObject复写是需要使用private属性并且传参java.io.ObjectInputStream这个特定的格式

序列化条件

  1. 该类必须实现java.io.Serializable或Externalizable接口

同时类中不是全部内容都是可以序列化的，还有不能被序列化的情况：

  1. 如果该类有父类，则分两种情况来考虑：
    • 如果该父类已经实现了可序列化接口，则其父类的相应字段及属性的处理和该类相同；
    • 如果该类的父类没有实现可序列化接口，则该类的父类所有的字段属性将不会序列化，并且反序列化时会调用父类的默认构造函数来初始化父类的属性，而子类却不调用默认构造函数，而是直接从流中恢复属性的值。
  2. 如果该类的某个属性标识为static类型的，则该属性不能序列化。
  3. 如果该类的某个属性采用transient关键字标识，则该属性不能序列化。

若想知道一个java标准类是否是可序列化的，可以通过查看该类的文档，查看该类有没有实现java.io.serializable接口。

序列化

  • 一个小Demo ```java package com.serializable; public class Test implements java.io.Serializable{ public String name; public String identify; public void mailCheck() {
    1.   System.out.println("This is the "+this.identify+" of our company");
    } }
  2. ```java
  3. package com.serializable;
  4. import java.io.*;
  5. public class SerializableDemo {
  6.     public static void main(String [] args)
  7.     {
  8.         Test e = new Test();
  9.         e.name = "员工甲";
  10.         e.identify = "General staff";
  11.         try
  12.         {
  13.             // 打开一个文件输入流,等待反序列化后的二进制位文件的输入
  14.             FileOutputStream fileOut = new FileOutputStream("D:\\java\\serializable\\test.db");
  15.             // 建立对象输入流
  16.             ObjectOutputStream out = new ObjectOutputStream(fileOut);
  17.             //输出序列化对象,实现对象序列化
  18.             out.writeObject(e);
  19.             out.close();
  20.             fileOut.close();
  21.             System.out.printf("Serialized data is saved in D:\\Task\\employee1.db");
  22.         }catch(IOException i)
  23.         {
  24.             i.printStackTrace();
  25.         }
  26.     }
  27. }
  2. 得到二进制文件进行查看，**反序列化数据开头包含两字节的魔术数字**，这两个字节始终为十六进制的**0xACED**，接下来是0x0005的**版本号数据**，此外还包含了**类名，成员变量**的**类型**和**个数**。<br />![](https://cdn.nlark.com/yuque/0/2021/png/2870855/1621672923564-58e791c6-7c23-4315-a18f-1607e64feaec.png#height=419&id=ZVIW1&originHeight=419&originWidth=1528&originalType=binary&ratio=1&status=done&style=none&width=1528)
  5. <a name="PjIc0"></a>
  6. ## 如何序列化和反序列化 
  7. > Java反序列化和PHP反序列化的区别
  8. > - PHP反序列化攻击是在序列化、反序列化de前后才进行攻击的，序列化和反序列的过程是一个独立的过程，并不能对其进行干扰，随其实PHP反序列化并不是由反序列化导致的，只是通过反序列化可以控制对象属性进而进行操作--需要触发魔法方法来进行调用，所以使用非常局限。
  9. > - JAVA程序却可以控制序列化和反序列的输入或读取内容，
  12. 1. 序列化一个java对象，首先是构建一个ObjectOutputStream对象<br />- 调用ObjectOutputStream对象的writeObject来序列化一个对象（此对象必须满足序列化条件
  13. 1. 反序列化java对象，首先得构建一个ObjectInputStream对象
  15.          （调用readObject方法
  16. ```java
  17. import java.io.*;
  18. import java.nio.file.attribute.UserDefinedFileAttributeView;
  19. import java.util.Arrays;
  20. import java.util.Base64;
  22. public class trytry {
  23.     public static void main(String [] args) throws IOException, ClassNotFoundException {
  24.         //整一个需要序列化的对象
  25.         user u = new user();
  26.         u.setName("lala");
  27.         //序列化输出至屏幕
  28.         ObjectOutputStream out = new ObjectOutputStream(System.out);
  29.         out.writeObject(u);
  30.         System.out.println();
  31.         //序列化写入文件
  32.         FileOutputStream f = new FileOutputStream("test.bin");
  33.         ObjectOutputStream fout = new ObjectOutputStream(f);
  34.         fout.writeObject(u);
  35.         //序列化写入到变量中
  36.         ByteArrayOutputStream bOut = new ByteArrayOutputStream();
  37.         ObjectOutputStream objOut = new ObjectOutputStream(bOut);
  38.         objOut.writeObject(u);
  39.         byte[] str= bOut.toByteArray();
  40.         System.out.println(new String(str));
  41.         //从变量中反序列化
  42.         ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(str));
  43.         user u_d = (user) ois.readObject();
  44.         System.out.println(u_d.getName());
  45.     }
  46. }
  48. class user implements Serializable {
  49.     private String name;
  50.     public  String getName() {return name; }
  51.     public void  setName(String name){this.name = name;}
  52. }

输出结果如下：
image.png

Java在序列化时一个对象，将会调用这个对象中的 writeObject 方法，参数类型是 ObjectOutputStream ，开发者可以将任何内容写入这个stream中；反序列化时，会调用 readObject ，开发者也可以从中读取出前面写入的内容，并进行处理。


漏洞原理

  • 漏洞的关键在于readObject()方法： ```java package com.serializable; import java.io.*; import java.nio.file.attribute.UserDefinedFileAttributeView; import java.util.Arrays; import java.util.Base64; public class trytry { public static void main(String [] args) throws IOException, ClassNotFoundException {

    1.   //整一个需要序列化的对象
    2.   user u = new user();
    3.   u.setName("lala");
    4.   //序列化写入文件
    5.   FileOutputStream f = new FileOutputStream("test.bin");
    6.   ObjectOutputStream fout = new ObjectOutputStream(f);
    7.   fout.writeObject(u);

    class user implements Serializable { private String name;

    public String getName() {

    1.   return name;

    }

    public void setName(String name){

    1.   this.name = name;

    } private void readObject(java.io.ObjectInputStream in) throws IOException {

    1.   Runtime.getRuntime().exec("calc.exe");

    } }

public class UnSerializableDemo { public static void main(String[] args) throws Exception{ ObjectInputStream input = new ObjectInputStream(new FileInputStream(“test.bin”)); input.readObject(); } }

  1. ![image.png](https://cdn.nlark.com/yuque/0/2021/png/2870855/1621753259095-6482f221-4e7a-4a90-8152-87c7414de01b.png#height=352&id=KTkFQ&margin=%5Bobject%20Object%5D&name=image.png&originHeight=704&originWidth=1604&originalType=binary&ratio=1&size=121687&status=done&style=none&width=802)<br />在反序列化执行时调用的readObject方法是我们在trytry.java中复写的方法(序列化存储进了文件中)，进而调用calc.exe。
  2. > 反序列化原理探究：
  3. > 以上代码完成的事情：
  4. > - 创建了一个复写readObject函数的user类
  5. > - 创建了user类实例
  6. > - 对其进行序列化，并存储进文件中
  7. > - 再将文件中的数据进行反序列化恢复成user类
  8. > 
  9. > 1. 注释掉java文件中user类   >报错找不到user类
  10. > 1. 注释掉user类的所有接口，只留下user空壳 >class接口报错
  11. > 1. 注释掉user类中的readObject函数 >未报错 但未执行calc.exe
  12. > 1. 不注释user > 计算器弹框成功，成功调用user复写的readObject函数 
  15. <a name="qM94m"></a>
  16. ### 反序列化攻击条件
  18. 利用readObject方法进行攻击，待补充
  21. ---
  23. ```java
  24. package com.serializable;
  25. import java.io.*;
  26. import java.io.IOException;
  27. import java.io.ObjectOutputStream;
  28. import java.util.Arrays;
  30. public class Person implements java.io.Serializable {
  31.     public String name;
  32.     public int age;
  33.     Person(String name, int age) {
  34.     this.name = name;
  35.     this.age = age;
  36.     }
  37.     private void writeObject(java.io.ObjectOutputStream s) throws IOException {
  38.     s.defaultWriteObject();   //将当前类的字段写入此流，只能从要序列化的类的writeObject方法中调用此方法
  39.     s.writeObject("This is a object");    //在当前类已经写入的流中写入想要添加的数据段
  40.     System.out.println();
  41.     }
  42.     private void readObject(java.io.ObjectInputStream s) throws IOException, ClassNotFoundException {
  43.     s.defaultReadObject();    //从此流中读取当前类的字段，只能从要反序列化的类的readObject方法中调用此方法
  44.     String message = (String) s.readObject();   //读取输入的字符串，储存在 objectAnnotation位置
  45.     System.out.println(message);
  46.     }
  47.     public static void main(String[] args) throws IOException {
  48.         Person person = new Person("sqy",111);
  49.         ByteArrayOutputStream out = new ByteArrayOutputStream();
  50.         ObjectOutputStream objout = new ObjectOutputStream(out);
  51. //        ObjectOutputStream objout = new ObjectOutputStream(System.out);
  52.         objout.writeObject(person);
  53.         byte[] str=out.toByteArray();
  54.         System.out.println(new String(str));
  55.         ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(str));
  56.         try {    //使用try/catch语句捕获无法预知的异常报错
  57.             in.readObject();
  58.         } catch (ClassNotFoundException e) {
  59.             e.printStackTrace();
  60.         }
  61.     }
  62. }

输出：（写入的This is a Object被放在objectannotation的位置，反序列化时读取了这个字符串image.png

参考：

  1. https://lalajun.github.io/2019/08/20/java%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96-%E5%9F%BA%E7%A1%80/ 反序列化基础