java序列化与反序列化详解_java序列化和反序列化

一：什么是反序列化

序列化：

序列化就是将 java对象 转化为字节序列的过程。
序列化是指把一个Java对象变成二进制内容，本质上就是一个byte[]数组。 为什么要把Java对象序列化呢？因为序列化后可以把byte[]保存到文件中，或者把byte[]通过网络传输到远程，这样，就相当于把Java对象存储到文件或者通过网络传输出去了。
注意：序列化是为了在传递和保存对象时，为了保证对象的完整性和可传递性。将对象转为有序的字节流，以便在网上传输或者保存在本地文件中。

反序列化：

反序列化就是将 字节序列恢复为java对象的过程。
有序列化，就有反序列化，即把一个二进制内容（也就是byte[]数组）变回Java对象。有了反序列化，保存到文件中的byte[]数组又可以“变回”Java对象，或者从网络上读取byte[]并把它“变回”Java对象。

二、序列化和反序列化的应用

两个进程在远程通信时，可以发送多种数据，包括文本、图片、音频、视频等，这些数据都是以二进制序列的形式在网络上传输。
java是面向对象的开发方式，一切都是java对象，想要在网络中传输java对象，可以使用序列化和反序列化去实现，发送发需要将java对象转换为字节序列，然后在网络上传送，接收方收到字符序列后，会通过反序列化将字节序列恢复成java对象。

三、序列化和反序列化地实现

1.JDK类库提供的序列化API:
java.io.ObjectOutputStream
表示对象输出流，其中writeObject(Object obj)方法可以将给定参数的obj对象进行序列化，将转换的一连串的字节序列写到指定的目标输出流中。
java.io.ObjectInputStream
该类表示对象输入流，该类下的readObject(Object obj)方法会从源输入流中读取字节序列，并将它反序列化为一个java对象并返回

序列化要求：

实现序列化的类对象必须实现了Serializable类或Externalizable类才能被序列化，否则会抛出异常

四、序列化和反序列化，遵循以下方法：

方法一：若student类实现了serializable接口，则可以通过objectOutputstream和objectinputstream默认的序列化和反序列化方式，对非transient的实例变量进行序列化和反序列化。

方法二：若student类实现了serializable接口，并且定义了writeObject(objectOutputStream out)和readObject(objectinputStream in)方法
则可以直接调用student类的两种方法进行序列化和反序列化

方法三：若student类实现了Externalizable接口，则必须实现readExternal(Objectinput in)和writeExternal(Objectoutput out)方法进行序列化和反序列化。

4.1 示例代码

package Serializa.Learn;

import java.io.*;

public class Person implements Serializable {

    private static String secret;
    private String name;


    private int age;

    transient private double saraly;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getSaraly() {
        return saraly;
    }

    public void setSaraly(double saraly) {
        this.saraly = saraly;
    }

    @Override
    public String toString() {
        return "Person{" +
            "name='" + name + '\'' +
            ", age='" + age + '\'' +
            ", saraly='" + saraly + '\'' +
            ", secret='" + secret + '\'' +
            '}';
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Person p1 = new Person();
        p1.setAge(18);
        p1.setName("lxl");
        p1.setSaraly(5000000);
        Person.secret = "aaa";
        System.out.println(p1);
        serizliza(p1);

        //        Person.secret="bbbb";
        Person p2 = (Person) deserizliza("person.ser");
        System.out.println("反序列化" + p2);

    }

    private static void serizliza(Object obj) throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.ser"));
        oos.writeObject(obj);
    }

    private static Object deserizliza(String file) throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
        Object obj = ois.readObject();
        return obj;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

1.被transient 修饰的变量不会被序列化，同时若自定义了readObject方法，反序列化时则会执行 自定义的方法

2.不实现Serializable接口

3.让序列化的文件的serialVersionUID 和本地class 的不一致

1.首先定义serialVersionUID 然后按住 Ctrl + Shift + A 弹出的dialog 输入serialVersionUID 然后让java计算出独一无二的值

2.序列化person类，保存到本地，用SerializationDumper 查看序列化后的文件

java -jar SerializationDumper-v1.13.jar -r person.ser
1

serialVersionUID - 0x0e 76 fa 9f 59 73 be c6 是16进制转换为二进制，就是生成的值

3.使用010editor 修改serialVersionUID值

再次解析下修改后的数据，发现确实改变了

把序列化的代码注释，再次运行代码，执行反序列化，发现报错了

报错信息如下，确实符合 java 反序列的规范，

Exception in thread "main" java.io.InvalidClassException: Serializa.Learn.Person; local class incompatible: stream classdesc serialVersionUID = 1042295926090350279, local class serialVersionUID = 1042295926090350278
    at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:699)
    at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:2001)
    at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1848)
    at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:2158)
    at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1665)
    at java.io.ObjectInputStream.readObject(ObjectInputStream.java:501)
    at java.io.ObjectInputStream.readObject(ObjectInputStream.java:459)
    at Serializa.Learn.Person.deserizliza(Person.java:77)
    at Serializa.Learn.Person.main(Person.java:61)
1
2
3
4
5
6
7
8
9
10

所以这也就是为什么我们在利用反序列化漏洞的时候，明明有这个链，但是不能成功，因为版本不一致。所以serializaUID 不一致的原因，

PS：serialVersionUID 的初衷是为了在反序列化时确保类的版本号与序列化时的版本号一致，避免出现版本不一致的问题，serialVersionUID 是根据类的成员变量自动生成的。如果没有手动指定 serialVersionUID，Java会根据类的成员变量自动生成一个版本号

4. 反序列化文件的格式

原始的16进制格式

aced 0005

base64编码的

rO0ABXNyABZTZXJpYWxpemEuTGVhcm4uUGVyc29uey5vlQ4y/oYCAAJJAANhZ2VMAARuYW1ldAAS
TGphdmEvbGFuZy9TdHJpbmc7eHAAAAASdAAGUHl0aDBu

因此在平时我们渗透过程中如果在流量中看到aced0005开头 或rO0AB 开头的流量就需要注意了，很可能这里是存在反序列化的

4.2 注意事项

1. 序列化类必须要实现Serializable接口
2. 序列化类中对象属性要求实现Serializable接口
3. serialVersionUID 序列化版本ID,保证序列化的类和反序列化的类是同一个类
4. transient(瞬间的)修饰属性,这个属性就不能序列化了
5. 静态属性也不能被序列化， 静态属性的值不会被序列化，因为它不属于任何一个对象，而是属于类
6. 如果可以序列化，就会出现下面的情况，当我们序列化某个类的一个对象到某个文件后，这个文件中的对象的那个被static修饰的属性值会固定下来,当另外一个普通的的对象修改了该static属性后,我们再去反序列化那个文件中的对象，就会得到和后面的对象不同的static属性值，
7. 用Java序列化的二进制字节数据只能由Java反序列化，不能被其他语言反序列化。如果要进行前后端或者不同语言之间的交互一般需要将对象转变成Json/Xml通用格式的数据，再恢复原来的对象。

4.3 transient真的不能被序列化么？

执行结果

在 Java 中有两种实现序列化的方式，Serializable 和 Externalizable，可能大部分人只知道 Serializable 而不知道 Externalizable。
这两种序列化方式的区别是：实现了 Serializable 接口是自动序列化的，实现 Externalizable 则需要手动序列化，通过 writeExternal 和 readExternal 方法手动进行，
因为我只手动序列化了 saraly属性，所以其他值为初始化值

4.4 transient 关键字总结

1. transient修饰的变量不能被序列化；
2. transient只作用于实现 Serializable 接口；
3. transient只能用来修饰普通成员变量字段；
4. 不管有没有 transient 修饰，静态变量都不能被序列化；

五、参考资料

• https://mp.weixin.qq.com/s/BOLwYRD-ITx7Valvt5fLWA
• https://blog.csdn.net/meser88/article/details/120003617