Java反序列化漏洞防范：如何使用白名单机制限制可反序列化的类 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

Java 反序列化漏洞防范：白名单机制实战

大家好，今天我们来深入探讨 Java 反序列化漏洞及其防范，重点讲解如何使用白名单机制来限制可反序列化的类，从而有效提升应用的安全性。

什么是 Java 反序列化漏洞？

在 Java 中，反序列化是指将字节流转换回 Java 对象的过程。这个过程本身是为了方便数据传输和持久化，但如果字节流的内容被恶意篡改，就可能导致安全问题，这就是 Java 反序列化漏洞。

攻击者可以通过构造恶意的序列化数据，诱使应用程序反序列化，从而执行恶意代码，造成远程代码执行 (RCE) 等严重后果。

漏洞产生的原因：

Java 反序列化漏洞的根本原因是应用程序没有对反序列化的数据进行充分的验证。攻击者利用这一点，在序列化数据中插入恶意指令，当应用程序反序列化时，这些指令会被执行，导致安全风险。

影响：

一旦 Java 应用存在反序列化漏洞，攻击者可能利用该漏洞：

执行任意代码 (RCE): 这是最严重的后果，攻击者可以在服务器上执行任意命令，完全控制服务器。
读取敏感数据: 攻击者可以读取服务器上的配置文件、数据库连接信息等敏感数据。
拒绝服务 (DoS): 攻击者可以构造恶意的序列化数据，导致服务器资源耗尽，无法正常提供服务。

常见的反序列化攻击手段

利用已知的 Gadget Chains: 攻击者利用存在于第三方库中的漏洞类（Gadget），组合成一条调用链（Gadget Chain），当应用程序反序列化恶意数据时，这条调用链会被触发，最终执行恶意代码。
直接构造恶意对象: 如果应用程序允许反序列化任意对象，攻击者可以直接构造包含恶意代码的对象，并将其序列化后发送给应用程序。

白名单机制：一种有效的防御策略

白名单机制是一种安全策略，它只允许明确指定的类进行反序列化，拒绝所有其他类。这种方式可以有效防止攻击者利用未知的 Gadget Chains 或直接构造恶意对象来攻击应用程序。

原理：

在反序列化过程中，首先检查要反序列化的类是否在白名单中。如果在，则允许反序列化；否则，拒绝反序列化，并抛出异常。

优点：

简单有效： 配置简单，能够有效地阻止大部分反序列化攻击。
可控性强： 可以精确控制哪些类可以被反序列化，减少了潜在的风险。
降低维护成本： 相比于黑名单机制，白名单机制只需要维护允许的类，减少了维护成本。

缺点：

需要维护： 需要根据应用程序的需求维护白名单，添加或删除类。
可能影响兼容性： 如果白名单配置不当，可能会导致应用程序无法正常反序列化某些对象。

如何实现白名单机制？

以下是几种实现 Java 反序列化白名单机制的方法：

自定义 ObjectInputStream：

这是最常见也是最灵活的一种方式。通过自定义 ObjectInputStream，并重写 resolveClass() 方法，可以在反序列化之前检查类是否在白名单中。

import java.io.*;
import java.util.HashSet;
import java.util.Set;

public class WhitelistObjectInputStream extends ObjectInputStream {

    private final Set<String> whitelist;

    public WhitelistObjectInputStream(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)) {
            throw new InvalidClassException(
                "Unauthorized deserialization attempt",
                className);
        }
        return super.resolveClass(desc);
    }

    public static void main(String[] args) throws Exception {
        // 创建一个包含序列化对象的示例
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(new User("Alice", 30));
        oos.close();
        byte[] serializedData = bos.toByteArray();

        // 配置白名单
        Set<String> whitelist = new HashSet<>();
        whitelist.add("User"); // 允许反序列化 User 类
        whitelist.add("java.lang.String"); // 允许反序列化 String 类
        whitelist.add("java.lang.Integer"); // 允许反序列化 Integer 类

        // 使用白名单反序列化
        ByteArrayInputStream bis = new ByteArrayInputStream(serializedData);
        WhitelistObjectInputStream ois = new WhitelistObjectInputStream(bis, whitelist);

        try {
            User user = (User) ois.readObject();
            System.out.println("反序列化成功: " + user);
        } catch (InvalidClassException e) {
            System.err.println("反序列化失败: " + e.getMessage());
        } finally {
            ois.close();
        }

        // 测试反序列化一个不在白名单中的类
        ByteArrayOutputStream bos2 = new ByteArrayOutputStream();
        ObjectOutputStream oos2 = new ObjectOutputStream(bos2);
        oos2.writeObject(new java.util.ArrayList<String>()); // 序列化 ArrayList
        oos2.close();
        byte[] serializedData2 = bos2.toByteArray();

        ByteArrayInputStream bis2 = new ByteArrayInputStream(serializedData2);
        WhitelistObjectInputStream ois2 = new WhitelistObjectInputStream(bis2, whitelist);

        try {
            ois2.readObject(); // 尝试反序列化 ArrayList
        } catch (InvalidClassException e) {
            System.err.println("反序列化失败: " + e.getMessage()); // 预期会抛出异常
        } finally {
            ois2.close();
        }
    }
}

class User implements Serializable {
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
            "name='" + name + ''' +
            ", age=" + age +
            '}';
    }
}

代码解释：

WhitelistObjectInputStream 类继承自 ObjectInputStream。
whitelist 字段保存允许反序列化的类名集合。
resolveClass() 方法重写了父类的方法，用于检查要反序列化的类是否在白名单中。
如果类不在白名单中，则抛出 InvalidClassException 异常。
main 方法演示了如何使用 WhitelistObjectInputStream 进行反序列化，并测试了反序列化白名单中和不在白名单中的类的情况。

使用第三方库：

有一些第三方库提供了白名单机制的实现，例如：

SerialKiller: SerialKiller 是一个专门用于防御 Java 反序列化漏洞的库，它提供了多种防御机制，包括白名单、黑名单、大小限制等。
SafeDeserialization: SafeDeserialization 是另一个用于安全反序列化的库，它提供了白名单、类型验证等功能。

使用 SerialKiller 示例：

首先，添加 SerialKiller 的依赖到你的项目中 (使用 Maven):

<dependency>
    <groupId>com.github.x-stream</groupId>
    <artifactId>serialkiller</artifactId>
    <version>0.8.1</version>
</dependency>

然后，使用 SerialKiller 配置白名单：

import com.github.xstream.serialkiller.SerialKiller;
import com.github.xstream.serialkiller.ValidationException;

import java.io.*;
import java.util.HashSet;
import java.util.Set;

public class SerialKillerExample {

    public static void main(String[] args) throws Exception {
        // 创建一个包含序列化对象的示例
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(new User("Bob", 25));
        oos.close();
        byte[] serializedData = bos.toByteArray();

        // 配置白名单
        Set<String> whitelist = new HashSet<>();
        whitelist.add("User"); // 允许反序列化 User 类
        whitelist.add("java.lang.String"); // 允许反序列化 String 类
        whitelist.add("java.lang.Integer"); // 允许反序列化 Integer 类

        SerialKiller serialKiller = new SerialKiller();
        serialKiller.setWhitelist(whitelist);

        // 使用 SerialKiller 反序列化
        ByteArrayInputStream bis = new ByteArrayInputStream(serializedData);
        ObjectInputStream ois = new ObjectInputStream(bis) {
            @Override
            protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException {
                try {
                    serialKiller.validate(desc);
                } catch (ValidationException e) {
                    throw new InvalidClassException("Unauthorized deserialization attempt", desc.getName());
                }
                return super.resolveClass(desc);
            }
        };

        try {
            User user = (User) ois.readObject();
            System.out.println("反序列化成功: " + user);
        } catch (InvalidClassException e) {
            System.err.println("反序列化失败: " + e.getMessage());
        } finally {
            ois.close();
        }

        // 测试反序列化一个不在白名单中的类
        ByteArrayOutputStream bos2 = new ByteArrayOutputStream();
        ObjectOutputStream oos2 = new ObjectOutputStream(bos2);
        oos2.writeObject(new java.util.ArrayList<String>()); // 序列化 ArrayList
        oos2.close();
        byte[] serializedData2 = bos2.toByteArray();

        ByteArrayInputStream bis2 = new ByteArrayInputStream(serializedData2);
        ObjectInputStream ois2 = new ObjectInputStream(bis2) {
            @Override
            protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException {
                try {
                    serialKiller.validate(desc);
                } catch (ValidationException e) {
                    throw new InvalidClassException("Unauthorized deserialization attempt", desc.getName());
                }
                return super.resolveClass(desc);
            }
        };

        try {
            ois2.readObject(); // 尝试反序列化 ArrayList
        } catch (InvalidClassException e) {
            System.err.println("反序列化失败: " + e.getMessage()); // 预期会抛出异常
        } finally {
            ois2.close();
        }
    }

}

class User implements Serializable {
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
            "name='" + name + ''' +
            ", age=" + age +
            '}';
    }
}

代码解释：

创建 SerialKiller 对象并配置白名单。
在自定义的 ObjectInputStream 的 resolveClass() 方法中，使用 serialKiller.validate(desc) 验证类是否在白名单中。
如果不在白名单中，抛出 InvalidClassException 异常。

使用 java.io.SerialFilter (Java 9 及以上):

Java 9 引入了 java.io.SerialFilter 接口，提供了一种官方的方式来控制反序列化。可以全局设置过滤器，也可以为每个 ObjectInputStream 实例设置过滤器。

import java.io.*;
import java.util.HashSet;
import java.util.Set;

public class SerialFilterExample {

   public static void main(String[] args) throws Exception {
       // 创建一个包含序列化对象的示例
       ByteArrayOutputStream bos = new ByteArrayOutputStream();
       ObjectOutputStream oos = new ObjectOutputStream(bos);
       oos.writeObject(new User("Charlie", 40));
       oos.close();
       byte[] serializedData = bos.toByteArray();

       // 配置白名单
       Set<String> whitelist = new HashSet<>();
       whitelist.add("User"); // 允许反序列化 User 类
       whitelist.add("java.lang.String"); // 允许反序列化 String 类
       whitelist.add("java.lang.Integer"); // 允许反序列化 Integer 类

       // 创建 SerialFilter
       SerialFilter filter = SerialFilter.newInstance(whitelist);

       // 使用 SerialFilter 反序列化
       ByteArrayInputStream bis = new ByteArrayInputStream(serializedData);
       ObjectInputStream ois = new ObjectInputStream(bis);
       ois.setObjectInputFilter(filter);

       try {
           User user = (User) ois.readObject();
           System.out.println("反序列化成功: " + user);
       } catch (InvalidClassException e) {
           System.err.println("反序列化失败: " + e.getMessage());
       } finally {
           ois.close();
       }

       // 测试反序列化一个不在白名单中的类
       ByteArrayOutputStream bos2 = new ByteArrayOutputStream();
       ObjectOutputStream oos2 = new ObjectOutputStream(bos2);
       oos2.writeObject(new java.util.ArrayList<String>()); // 序列化 ArrayList
       oos2.close();
       byte[] serializedData2 = bos2.toByteArray();

       ByteArrayInputStream bis2 = new ByteArrayInputStream(serializedData2);
       ObjectInputStream ois2 = new ObjectInputStream(bis2);
       ois2.setObjectInputFilter(filter);

       try {
           ois2.readObject(); // 尝试反序列化 ArrayList
       } catch (InvalidClassException e) {
           System.err.println("反序列化失败: " + e.getMessage()); // 预期会抛出异常
       } finally {
           ois2.close();
       }
   }

   static class SerialFilter {
       private final Set<String> whitelist;

       private SerialFilter(Set<String> whitelist) {
           this.whitelist = whitelist;
       }

       static ObjectInputFilter newInstance(Set<String> whitelist) {
           return new ObjectInputFilter() {
               @Override
               public Status checkInput(FilterInfo filterInfo) {
                   Class<?> clazz = filterInfo.serialClass();
                   if (clazz != null && whitelist.contains(clazz.getName())) {
                       return Status.ALLOWED;
                   }
                   return Status.REJECTED;
               }
           };
       }
   }

   static class User implements Serializable {
       private String name;
       private int age;

       public User(String name, int age) {
           this.name = name;
           this.age = age;
       }

       @Override
       public String toString() {
           return "User{" +
               "name='" + name + ''' +
               ", age=" + age +
               '}';
       }
   }
}

代码解释：

创建 SerialFilter 内部类，实现 ObjectInputFilter 接口。
checkInput 方法检查要反序列化的类是否在白名单中。
使用 ois.setObjectInputFilter(filter) 为 ObjectInputStream 实例设置过滤器.
如果类不在白名单中，反序列化操作会被拒绝。

不同方法的对比：

方法	优点	缺点	适用场景
自定义 `ObjectInputStream`	灵活，可以自定义验证逻辑。	需要手动实现白名单机制，代码量较大。	需要高度定制化的反序列化控制。
使用第三方库（SerialKiller）	简单易用，提供了多种防御机制。	引入额外的依赖，可能存在兼容性问题。	快速集成反序列化防御，简化开发。
使用 `java.io.SerialFilter` (Java 9+)	官方支持，性能较好。	只能在 Java 9 及以上版本使用，功能相对简单。	使用 Java 9 及以上版本，需要简单的白名单机制。

如何选择合适的白名单实现方式？

选择哪种白名单实现方式取决于应用程序的具体需求和环境。

如果需要高度定制化的反序列化控制，可以选择自定义 ObjectInputStream。
如果希望快速集成反序列化防御，可以选择使用第三方库。
如果使用的是 Java 9 及以上版本，并且只需要简单的白名单机制，可以选择使用 java.io.SerialFilter。

如何配置白名单？

配置白名单需要仔细考虑应用程序的需求，确保只允许必要的类进行反序列化。

配置原则：

最小权限原则： 只允许应用程序实际需要的类进行反序列化，不要过度开放。
显式声明： 明确声明允许反序列化的类，避免使用通配符或模糊匹配。
持续维护： 定期检查白名单，根据应用程序的变化添加或删除类。

配置建议：

分析应用程序的序列化/反序列化需求： 确定应用程序需要序列化和反序列化的类。
创建白名单文件： 创建一个文本文件，每行包含一个允许反序列化的类名。

在代码中加载白名单文件： 在代码中读取白名单文件，并将其加载到白名单集合中。

import java.io.*;
import java.util.HashSet;
import java.util.Set;

public class WhitelistLoader {

    public static Set<String> loadWhitelist(String filename) throws IOException {
        Set<String> whitelist = new HashSet<>();
        try (BufferedReader reader = new BufferedReader(new FileReader(filename))) {
            String line;
            while ((line = reader.readLine()) != null) {
                line = line.trim();
                if (!line.isEmpty() && !line.startsWith("#")) { // 忽略空行和注释行
                    whitelist.add(line);
                }
            }
        }
        return whitelist;
    }

    public static void main(String[] args) throws IOException {
        // 假设 whitelist.txt 文件包含允许反序列化的类名
        String whitelistFilename = "whitelist.txt";
        Set<String> whitelist = loadWhitelist(whitelistFilename);

        System.out.println("已加载的白名单：");
        for (String className : whitelist) {
            System.out.println(className);
        }
    }
}

whitelist.txt 示例：

# 允许反序列化的类
User
java.lang.String
java.lang.Integer

在反序列化过程中使用白名单集合进行验证： 使用自定义 ObjectInputStream 或第三方库，在反序列化之前检查类是否在白名单集合中。

白名单之外的补充防御措施

仅仅使用白名单机制是不够的，还需要结合其他防御措施，才能更有效地防止反序列化漏洞。

禁用不必要的序列化/反序列化： 如果应用程序不需要序列化/反序列化，应该禁用该功能。
使用安全的序列化/反序列化库： 避免使用存在已知漏洞的序列化/反序列化库。
对序列化数据进行签名或加密： 防止攻击者篡改序列化数据。
限制反序列化数据的大小： 防止攻击者发送大量的恶意数据，导致服务器资源耗尽。
监控反序列化过程： 监控反序列化过程，检测异常行为。
代码审计： 定期进行代码审计，检查是否存在反序列化漏洞。

白名单机制的局限性

尽管白名单机制是一种有效的防御策略，但它也存在一些局限性：

无法防御逻辑漏洞： 白名单机制只能防止反序列化未知的类，但无法防御应用程序自身的逻辑漏洞。
需要持续维护： 白名单需要根据应用程序的变化持续维护，否则可能会导致兼容性问题。
可能影响性能： 白名单验证会增加反序列化的开销，可能会影响性能。

总结

Java 反序列化漏洞是一种严重的安全威胁，白名单机制是一种有效的防御策略。通过自定义 ObjectInputStream 或使用第三方库，可以实现白名单机制，限制可反序列化的类，从而有效提升应用的安全性。同时，还需要结合其他防御措施，才能更全面地保护应用程序免受反序列化攻击。
务必记住，白名单配置应遵循最小权限原则，并持续维护，以确保其有效性。

Java 反序列化漏洞防范：白名单机制实战

什么是 Java 反序列化漏洞？

常见的反序列化攻击手段

白名单机制：一种有效的防御策略

如何实现白名单机制？

如何选择合适的白名单实现方式？

如何配置白名单？

白名单之外的补充防御措施

白名单机制的局限性

总结

发表回复 取消回复

发表回复取消回复