发布于 由admin

Java反序列化漏洞防范：如何使用白名单机制限制可反序列化的类

Java反序列化漏洞防范：白名单机制的深度解析

大家好，今天我们来深入探讨Java反序列化漏洞的防范，重点聚焦于白名单机制的应用。Java反序列化漏洞长期以来都是安全领域的一大威胁，攻击者可以利用它执行任意代码，造成严重的安全风险。虽然有各种防御手段，但白名单机制因其精确性和可控性，成为一种非常有效的防御策略。

1. 反序列化漏洞的根源与危害

Java反序列化是将Java对象转换为字节流的过程，以便存储或传输。序列化后的字节流可以被反序列化回对象。问题在于，反序列化的过程如果控制不严，就可能被恶意利用。

  • 漏洞根源： 反序列化过程中，JVM会调用对象的readObject()方法，如果该方法中包含危险操作（例如，执行系统命令、加载恶意类），攻击者就可以构造恶意的序列化数据，诱使JVM执行这些危险操作。

  • 危害：

    • 远程代码执行 (RCE): 最严重的后果，攻击者可以在目标服务器上执行任意代码，完全控制服务器。
    • 拒绝服务 (DoS): 攻击者可以构造复杂的对象图，导致反序列化过程消耗大量资源，最终导致服务崩溃。
    • 信息泄露: 攻击者可以利用反序列化漏洞读取服务器上的敏感信息。

2. 白名单机制：一种精确的防御策略

白名单机制的核心思想是只允许反序列化预先定义的、安全的类，拒绝所有其他的类。这是一种非常严格的防御策略，可以有效阻止未知的反序列化攻击。

  • 工作原理： 在反序列化之前，检查即将反序列化的类的类型是否在预定义的白名单中。如果在，则允许反序列化；否则，拒绝反序列化并抛出异常。

  • 优点：

    • 精确控制： 可以精确控制哪些类可以被反序列化，有效防止未知的攻击。
    • 高安全性： 相对于黑名单，白名单更加安全，因为即使出现新的攻击利用，只要不在白名单中，就无法被利用。
    • 可预测性： 行为可预测，易于管理和维护。

  • 缺点：

    • 需要维护： 需要维护一个白名单，并随着应用程序的演进而不断更新。
    • 可能限制功能： 过于严格的白名单可能限制某些功能的实现。
    • 配置复杂性： 大型应用配置白名单可能会比较复杂。

3. 实现白名单机制的几种方法

下面介绍几种常用的实现Java反序列化白名单机制的方法：

3.1. ObjectInputStream的子类化

这是最常用，也是最直接的方法。通过自定义ObjectInputStream的子类，并重写resolveClass()方法，可以在反序列化之前检查类的类型。

import java.io.*;

public class WhitelistObjectInputStream extends ObjectInputStream {

    private final Class<?>[] whitelist;

    public WhitelistObjectInputStream(InputStream in, Class<?>... whitelist) throws IOException {
        super(in);
        this.whitelist = whitelist;
    }

    @Override
    protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException {
        String name = desc.getName();
        for (Class<?> clazz : whitelist) {
            if (clazz.getName().equals(name)) {
                return clazz;
            }
        }
        throw new InvalidClassException(
                "Unauthorized deserialization attempt",
                desc.getName());
    }

    public static void main(String[] args) throws Exception {
        // 定义白名单
        Class<?>[] whitelist = {
                String.class,
                Integer.class,
                MySafeClass.class // 假设这是一个安全的类
        };

        // 序列化一个对象
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject("Hello, world!");
        oos.writeObject(123);
        oos.writeObject(new MySafeClass("safe data"));
        oos.close();

        // 反序列化对象，使用白名单
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        WhitelistObjectInputStream ois = new WhitelistObjectInputStream(bis, whitelist);
        String str = (String) ois.readObject();
        Integer num = (Integer) ois.readObject();
        MySafeClass safeObject = (MySafeClass) ois.readObject();
        ois.close();

        System.out.println("String: " + str);
        System.out.println("Integer: " + num);
        System.out.println("MySafeClass: " + safeObject.getData());

        // 尝试反序列化一个不在白名单中的类 (例如ArrayList) - 这将会抛出异常
        try {
            ByteArrayOutputStream bos2 = new ByteArrayOutputStream();
            ObjectOutputStream oos2 = new ObjectOutputStream(bos2);
            oos2.writeObject(new java.util.ArrayList<String>());  // ArrayList 不在白名单
            oos2.close();

            ByteArrayInputStream bis2 = new ByteArrayInputStream(bos2.toByteArray());
            WhitelistObjectInputStream ois2 = new WhitelistObjectInputStream(bis2, whitelist);
            ois2.readObject(); // 抛出 InvalidClassException
            ois2.close();
        } catch (InvalidClassException e) {
            System.out.println("Exception caught: " + e.getMessage());
        }
    }
}

class MySafeClass implements Serializable {
    private String data;

    public MySafeClass(String data) {
        this.data = data;
    }

    public String getData() {
        return data;
    }
}

代码解释：

  1. WhitelistObjectInputStream 继承了 ObjectInputStream。
  2. 构造函数接收一个 InputStream 和一个 Class<?>[] whitelist 作为参数，whitelist 存储了允许反序列化的类。
  3. 重写了 resolveClass() 方法，该方法在反序列化过程中会被调用，用于加载类。
  4. 在 resolveClass() 方法中，遍历白名单，检查当前要反序列化的类的名称是否在白名单中。如果在，则返回该类；否则，抛出 InvalidClassException 异常。
  5. main 函数演示了如何使用 WhitelistObjectInputStream。首先定义一个白名单，然后序列化一些对象，并使用 WhitelistObjectInputStream 反序列化这些对象。如果尝试反序列化不在白名单中的类，将会抛出 InvalidClassException 异常。

3.2. 使用第三方库：SerialKiller

SerialKiller 是一个专门用于防御Java反序列化漏洞的开源库。它提供了更加灵活和强大的白名单/黑名单机制。

<!-- Maven 依赖 -->
<dependency>
    <groupId>com.github.stephenh</groupId>
    <artifactId>serialkiller</artifactId>
    <version>2.1.0</version>
</dependency>
import com.github.stephenh.java.security.serialkiller.SerialKiller;
import com.github.stephenh.java.security.serialkiller.SerialKillerBuilder;

import java.io.*;

public class SerialKillerExample {

    public static void main(String[] args) throws Exception {
        // 创建 SerialKiller 实例，并配置白名单
        SerialKiller serialKiller = new SerialKillerBuilder()
                .whitelist(String.class)
                .whitelist(Integer.class)
                .whitelist(MySafeClass.class)
                .build();

        // 序列化一个对象
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject("Hello, world!");
        oos.writeObject(123);
        oos.writeObject(new MySafeClass("safe data"));
        oos.close();

        // 反序列化对象，使用 SerialKiller
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis) {
            @Override
            protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException {
                serialKiller.check(desc.getName()); // 检查类是否在白名单中
                return super.resolveClass(desc);
            }
        };
        String str = (String) ois.readObject();
        Integer num = (Integer) ois.readObject();
        MySafeClass safeObject = (MySafeClass) ois.readObject();
        ois.close();

        System.out.println("String: " + str);
        System.out.println("Integer: " + num);
        System.out.println("MySafeClass: " + safeObject.getData());

        // 尝试反序列化一个不在白名单中的类 (例如ArrayList) - 这将会抛出异常
        try {
            ByteArrayOutputStream bos2 = new ByteArrayOutputStream();
            ObjectOutputStream oos2 = new ObjectOutputStream(bos2);
            oos2.writeObject(new java.util.ArrayList<String>());  // ArrayList 不在白名单
            oos2.close();

            ByteArrayInputStream bis2 = new ByteArrayInputStream(bos2.toByteArray());
            ObjectInputStream ois2 = new ObjectInputStream(bis2) {
                @Override
                protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException {
                    serialKiller.check(desc.getName()); // 检查类是否在白名单中
                    return super.resolveClass(desc);
                }
            };
            ois2.readObject(); // 抛出异常
            ois2.close();
        } catch (IOException e) {
            System.out.println("Exception caught: " + e.getMessage());
        }
    }
}

代码解释：

  1. 首先添加 SerialKiller 的 Maven 依赖。
  2. 使用 SerialKillerBuilder 创建 SerialKiller 实例，并通过 whitelist() 方法配置白名单。
  3. 创建一个匿名 ObjectInputStream 子类，并重写 resolveClass() 方法。
  4. 在 resolveClass() 方法中，调用 serialKiller.check(desc.getName()) 方法检查类是否在白名单中。如果不在，将会抛出 IOException 异常。
  5. main 函数的后续逻辑与第一个例子类似，演示了如何使用 SerialKiller 进行反序列化，并处理不在白名单中的类。

3.3. 使用 Java 9+ 的反序列化过滤器 (Serialization Filter)

Java 9 引入了反序列化过滤器，提供了一种更加官方和标准的方式来控制反序列化过程。

import java.io.*;
import java.util.function.BinaryOperator;
import java.util.function.Predicate;
import java.util.regex.Pattern;

public class SerializationFilterExample {

    public static void main(String[] args) throws Exception {

        // 定义白名单
        Predicate<Class<?>> whitelistPredicate = clazz ->
                clazz.equals(String.class) ||
                        clazz.equals(Integer.class) ||
                        clazz.equals(MySafeClass.class);

        // 创建过滤器
        ObjectInputFilter filter = ObjectInputFilter.Config.createFilter(
                info -> {
                    if (info.serialClass() != null) {
                        return whitelistPredicate.test(info.serialClass()) ?
                                ObjectInputFilter.Status.ALLOWED : ObjectInputFilter.Status.REJECTED;
                    }
                    return ObjectInputFilter.Status.UNDECIDED;
                }
        );

        // 序列化一个对象
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject("Hello, world!");
        oos.writeObject(123);
        oos.writeObject(new MySafeClass("safe data"));
        oos.close();

        // 反序列化对象，使用过滤器
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        ois.setObjectInputFilter(filter); // 设置过滤器
        String str = (String) ois.readObject();
        Integer num = (Integer) ois.readObject();
        MySafeClass safeObject = (MySafeClass) ois.readObject();
        ois.close();

        System.out.println("String: " + str);
        System.out.println("Integer: " + num);
        System.out.println("MySafeClass: " + safeObject.getData());

        // 尝试反序列化一个不在白名单中的类 (例如ArrayList) - 这将会抛出异常
        try {
            ByteArrayOutputStream bos2 = new ByteArrayOutputStream();
            ObjectOutputStream oos2 = new ObjectOutputStream(bos2);
            oos2.writeObject(new java.util.ArrayList<String>());  // ArrayList 不在白名单
            oos2.close();

            ByteArrayInputStream bis2 = new ByteArrayInputStream(bos2.toByteArray());
            ObjectInputStream ois2 = new ObjectInputStream(bis2);
            ois2.setObjectInputFilter(filter); // 设置过滤器
            ois2.readObject(); // 抛出 InvalidClassException
            ois2.close();
        } catch (Exception e) {
            System.out.println("Exception caught: " + e.getMessage());
        }
    }
}

代码解释：

  1. 首先定义一个 Predicate<Class<?>>，用于判断类是否在白名单中。
  2. 使用 ObjectInputFilter.Config.createFilter() 方法创建一个 ObjectInputFilter 实例。该方法接收一个 ObjectInputFilter.Info 对象作为参数，该对象包含了关于当前反序列化的信息，例如类名、大小等。
  3. 在 filter 中，我们检查 info.serialClass() 是否为空，如果不为空，则使用 whitelistPredicate.test() 方法判断类是否在白名单中。如果在，则返回 ObjectInputFilter.Status.ALLOWED；否则，返回 ObjectInputFilter.Status.REJECTED。
  4. 在反序列化之前，使用 ois.setObjectInputFilter(filter) 方法设置过滤器。
  5. 后续的反序列化过程会受到过滤器的限制，如果尝试反序列化不在白名单中的类，将会抛出异常。

4. 白名单策略的实践建议

在实际应用中，制定和维护白名单策略需要仔细考虑以下几个方面：

  • 最小化原则： 只将真正需要反序列化的类加入白名单。避免过度宽泛的白名单，以减少潜在的攻击面。

  • 严格审查： 对加入白名单的类进行严格的安全审查，确保这些类本身不存在安全漏洞。

  • 动态更新： 随着应用程序的演进，白名单需要动态更新，以适应新的需求。

  • 版本控制： 对白名单进行版本控制，以便在出现问题时可以回滚到之前的版本。

  • 监控与告警： 监控反序列化过程，如果出现不在白名单中的类的反序列化尝试，应及时发出告警。

  • 结合其他防御措施： 白名单机制虽然有效，但不能作为唯一的防御手段。应与其他安全措施（例如，输入验证、最小权限原则）结合使用，形成多层次的防御体系。

5. 不同方法对比

方法 优点 缺点 适用场景
ObjectInputStream子类化 简单易懂，易于实现 灵活性较低，需要修改反序列化代码 适用于简单的、类数量较少的应用
SerialKiller 功能强大，灵活性高，支持白名单/黑名单，支持自定义规则 需要引入第三方库，学习成本较高 适用于复杂的、需要灵活控制反序列化的应用
Java 9+ 反序列化过滤器 官方支持，标准API，性能较好 学习成本较高，配置较为复杂，需要Java 9+支持 适用于Java 9+环境，需要高性能和标准API的应用
使用配置文件 白名单配置和代码分离，方便管理和维护，易于修改 需要额外的配置文件解析和加载逻辑，增加了代码的复杂度 适用于需要频繁修改白名单，且对代码可维护性要求较高的应用

6. 白名单机制的局限性

白名单机制并非万能，也存在一些局限性：

  • 维护成本： 白名单的维护需要持续投入，需要随着应用程序的演进而不断更新。
  • 误判风险： 过于严格的白名单可能导致误判，阻止合法的反序列化操作。
  • 无法防御逻辑漏洞： 白名单只能防止反序列化恶意类，但无法防御白名单中的类本身存在的逻辑漏洞。

7. 案例分析：基于配置文件的白名单管理

为了提高白名单的可维护性，可以将白名单配置存储在外部文件中，例如properties文件或XML文件。

7.1. 使用Properties文件

# whitelist.properties
com.example.MySafeClass=true
java.lang.String=true
java.lang.Integer=true
import java.io.*;
import java.util.Properties;

public class PropertiesWhitelistObjectInputStream extends ObjectInputStream {

    private final Properties whitelist;

    public PropertiesWhitelistObjectInputStream(InputStream in, Properties whitelist) throws IOException {
        super(in);
        this.whitelist = whitelist;
    }

    @Override
    protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException {
        String className = desc.getName();
        if (whitelist.containsKey(className) && whitelist.getProperty(className).equals("true")) {
            return super.resolveClass(desc);
        } else {
            throw new InvalidClassException(
                    "Unauthorized deserialization attempt",
                    desc.getName());
        }
    }

    public static void main(String[] args) throws Exception {
        // 加载白名单配置文件
        Properties whitelist = new Properties();
        try (InputStream input = new FileInputStream("whitelist.properties")) {
            whitelist.load(input);
        } catch (IOException ex) {
            ex.printStackTrace();
            return;
        }

        // 序列化和反序列化过程
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject("Hello, world!");
        oos.writeObject(123);
        oos.writeObject(new MySafeClass("safe data"));
        oos.close();

        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        PropertiesWhitelistObjectInputStream ois = new PropertiesWhitelistObjectInputStream(bis, whitelist);
        String str = (String) ois.readObject();
        Integer num = (Integer) ois.readObject();
        MySafeClass safeObject = (MySafeClass) ois.readObject();
        ois.close();

        System.out.println("String: " + str);
        System.out.println("Integer: " + num);
        System.out.println("MySafeClass: " + safeObject.getData());

        // 尝试反序列化一个不在白名单中的类 (例如ArrayList) - 这将会抛出异常
        try {
            ByteArrayOutputStream bos2 = new ByteArrayOutputStream();
            ObjectOutputStream oos2 = new ObjectOutputStream(bos2);
            oos2.writeObject(new java.util.ArrayList<String>());  // ArrayList 不在白名单
            oos2.close();

            ByteArrayInputStream bis2 = new ByteArrayInputStream(bos2.toByteArray());
            PropertiesWhitelistObjectInputStream ois2 = new PropertiesWhitelistObjectInputStream(bis2, whitelist);
            ois2.readObject(); // 抛出 InvalidClassException
            ois2.close();
        } catch (InvalidClassException e) {
            System.out.println("Exception caught: " + e.getMessage());
        }
    }
}

7.2 使用 XML 文件

<!-- whitelist.xml -->
<whitelist>
    <class name="com.example.MySafeClass"/>
    <class name="java.lang.String"/>
    <class name="java.lang.Integer"/>
</whitelist>
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.*;
import java.util.HashSet;
import java.util.Set;

public class XMLWhitelistObjectInputStream extends ObjectInputStream {

    private final Set<String> whitelist;

    public XMLWhitelistObjectInputStream(InputStream in, Set<String> whitelist) throws IOException {
        super(in);
        this.whitelist = whitelist;
    }

    @Override
    protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException {
        String className = desc.getName();
        if (whitelist.contains(className)) {
            return super.resolveClass(desc);
        } else {
            throw new InvalidClassException(
                    "Unauthorized deserialization attempt",
                    desc.getName());
        }
    }

    public static void main(String[] args) throws Exception {
        // 加载白名单配置文件
        Set<String> whitelist = new HashSet<>();
        try {
            File xmlFile = new File("whitelist.xml");
            DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
            Document doc = dBuilder.parse(xmlFile);
            doc.getDocumentElement().normalize();

            NodeList nList = doc.getElementsByTagName("class");
            for (int temp = 0; temp < nList.getLength(); temp++) {
                Node nNode = nList.item(temp);
                if (nNode.getNodeType() == Node.ELEMENT_NODE) {
                    Element eElement = (Element) nNode;
                    whitelist.add(eElement.getAttribute("name"));
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            return;
        }

        // 序列化和反序列化过程
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject("Hello, world!");
        oos.writeObject(123);
        oos.writeObject(new MySafeClass("safe data"));
        oos.close();

        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        XMLWhitelistObjectInputStream ois = new XMLWhitelistObjectInputStream(bis, whitelist);
        String str = (String) ois.readObject();
        Integer num = (Integer) ois.readObject();
        MySafeClass safeObject = (MySafeClass) ois.readObject();
        ois.close();

        System.out.println("String: " + str);
        System.out.println("Integer: " + num);
        System.out.println("MySafeClass: " + safeObject.getData());

        // 尝试反序列化一个不在白名单中的类 (例如ArrayList) - 这将会抛出异常
        try {
            ByteArrayOutputStream bos2 = new ByteArrayOutputStream();
            ObjectOutputStream oos2 = new ObjectOutputStream(bos2);
            oos2.writeObject(new java.util.ArrayList<String>());  // ArrayList 不在白名单
            oos2.close();

            ByteArrayInputStream bis2 = new ByteArrayInputStream(bos2.toByteArray());
            XMLWhitelistObjectInputStream ois2 = new XMLWhitelistObjectInputStream(bis2, whitelist);
            ois2.readObject(); // 抛出 InvalidClassException
            ois2.close();
        } catch (InvalidClassException e) {
            System.out.println("Exception caught: " + e.getMessage());
        }
    }
}

这两种方法都将白名单配置从代码中分离出来，使得修改白名单更加方便。

8. 总结：多管齐下，构建坚固的反序列化防线

Java反序列化漏洞是一个复杂且持续存在的威胁。虽然白名单机制是一种有效的防御手段，但它并非万能。只有将白名单机制与其他安全措施结合使用，才能构建坚固的反序列化防线，有效地保护应用程序的安全。 在选择白名单实现方法时，需要根据实际情况进行权衡，选择最适合自己应用场景的方法。 同时，需要不断学习新的安全知识，及时发现和修复潜在的安全漏洞。

9. 记住这些关键点：防御Java反序列化漏洞

  • 白名单是防御反序列化攻击的有效手段。
  • 选择合适的白名单实现方法，并根据应用场景进行配置。
  • 持续维护和更新白名单，并与其他安全措施结合使用。

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注