FastJson基础

Java反序列化 Fastjson 篇 01-Fastjson 基础

0x01 前言

原本是打算尝试用一下 fastjson 开发的，但是发现教程不多，而且真正贴合进项目还是用的 jackson 多一点，就先不看具体的开发了。

0x02 Fastjson 简介

Fastjson 是 Alibaba 开发的 Java 语言编写的高性能 JSON 库，用于将数据在 JSON 和 Java Object 之间互相转换。

提供两个主要接口来分别实现序列化和反序列化操作。

JSON.toJSONString 将 Java 对象转换为 json 对象，序列化的过程。

JSON.parseObject/JSON.parse 将 json 对象重新变回 Java 对象；反序列化的过程

所以可以简单的把 json 理解成是一个字符串。

0x03 代码 demo

1. 序列化代码实现

这里通过 Demo 了解下如何使用 Fastjson 进行序列化和反序列化，以及其中的一些特性之间的区别等等。

首先，pom.xml 里面导入 Fastjson 的依赖，这里先导入 1.2.24 的。

<dependency>  
 <groupId>com.alibaba</groupId>  
 <artifactId>fastjson</artifactId>  
 <version>1.2.24</version>  
</dependency>

定义一个 Student 类，代码如下
Student.java

public class Student {  
    private String name;  
 private int age;  
  
 public Student() {  
        System.out.println("构造函数");  
 }  
  
    public String getName() {  
        System.out.println("getName");  
 return name;  
 }  
  
    public void setName(String name) {  
        System.out.println("setName");  
 this.name = name;  
 }  
  
    public int getAge() {  
        System.out.println("getAge");  
 return age;  
 }  
  
    public void setAge(int age) {  
        System.out.println("setAge");  
 this.age = age;  
 }  
}

然后写序列化的代码，调用 JSON.toJsonString() 来序列化 Student 类对象：
StudentSerialize.java

import com.alibaba.fastjson.JSON;  
import com.alibaba.fastjson.serializer.SerializerFeature;  
  
// 最开始的序列化 demopublic class StudentSerialize {  
    public static void main(String[] args) {  
        Student student = new Student();  
 student.setName("Drunkbaby");  
//        student.setAge(6);  
 String jsonString = JSON.toJSONString(student, SerializerFeature.WriteClassName);  
 System.out.println(jsonString);  
 }  
}

这个地方，序列化的逻辑我们可以稍微调试看一下。

首先会进到 JSON 这个类，然后进到它的 toJSONString() 的函数里面，new 了一个 SerializeWriter 对象。我们的序列化这一步在这里就已经是完成了。

在进到 JSON 这个类里面的时候多出了个 static 的变量，写着 “members of JSON”，这里要特别注意一个值 DEFAULT_TYPE_KEY 为 “@type”，这个挺重要的。

里面定义了一些初值，赋值给 out 变量，这个 out 变量后续作为 JSONSerializer 类构造的参数。

继续往下面走，就是显示的部分了，toString() 方法，最后的运行结果。

很明显这句语句是关键的。

1	String jsonString = JSON.toJSONString(student, SerializerFeature.WriteClassName);

我们关注于它的参数
第一个参数是 student，是一个对象，就不多说了；
第二个参数是 SerializerFeature.WriteClassName，是 JSON.toJSONString() 中的一个设置属性值，设置之后在序列化的时候会多写入一个@type，即写上被序列化的类名，type 可以指定反序列化的类，并且调用其 getter/setter/is 方法。

Fastjson 接受的 JSON 可以通过@type字段来指定该JSON应当还原成何种类型的对象，在反序列化的时候方便操作。

输出如下：

// 设置了SerializerFeature.WriteClassName
构造函数
setName
setAge
getAge
getName
{"@type":"org.example.Student","age":6,"name":"John"}
 
// 未设置SerializerFeature.WriteClassName
构造函数
setName
setAge
getAge
getName
{"age":6,"name":"John"}

2. 反序列化代码实现

调用 JSON.parseObject()，代码如下

StudentUnserialize01.java

import com.alibaba.fastjson.JSON;  
import com.alibaba.fastjson.parser.Feature;  
  
public class StudentUnserialize {  
    public static void main(String[] args) {  
        String jsonString = "{\"@type\":\"Student\",\"age\":6,\"name\":\"Drunkbaby\"}";  
 Student student = JSON.parseObject(jsonString, Student.class, Feature.SupportNonPublicField);  
 System.out.println(student);  
 System.out.println(student.getClass().getName());  
 }  
}

运行结果如图

至此，代码 demo 结束

0x04 另外一些基础知识

fastjson 这里还有一些比较重要的知识，我不知道该归到哪一堆里面，又不想起太多目录，就全部放到这里了。

感觉可以先看第三点的一句话概括，再看前面两点

1. 反序列化时的 Feature.SupportNonPublicField 参数

前文我们在反序列化代码运行的时候，发现我们并不能获取到 “age” 这个值，因为它是私有属性的。

如果要还原出 private 的属性的话，还需要在JSON.parseObject/JSON.parse中加上Feature.SupportNonPublicField参数。

这里改下Student类，将私有属性age的setAge()函数注释掉（一般没人会给私有属性加setter方法，加了就没必要声明为private了）：

整个输出如下，我直接把加了参和没有加参的直接放一起

// 未加上参数的，会看到获取不到私有变量age的值而是被设置为0
构造函数
setName
Student@4459eb14
Student
getName
getAge
Drunkbaby 0

// 加上参数的了，再输出就能成功还原出age这个私有变量的值了
构造函数
setName
Student@4459eb14
Student
getName
getAge
Drunkbaby 6

也就是说，若想让传给JSON.parseObject()进行反序列化的JSON内容指向的对象类中的私有变量成功还原出来，则需要在调用JSON.parseObject()时加上Feature.SupportNonPublicField这个属性设置才行。

2. 只进行 JSON.parseObject(jsonString)

再来看下parseObject()的指定或不指定反序列化类型之间的差异。

由于Fastjson反序列化漏洞的利用只和包含了@type的JSON数据有关，因此这里我们只对序列化时设置了SerializerFeature.WriteClassName即含有@type指定反序列化类型的JSON数据进行反序列化；对于未包含@type的情况这里不做探讨，可自行测试。

修改Student类，添加两个private成员变量，且所有的私有成员变量都不定义setter方法（既然是private也没必要定义）：

import java.util.Properties;  
  
public class Student {  
    private String name;  
 private int age;  
 private String address;  
 private Properties properties;  
  
 public Student() {  
        System.out.println("构造函数");  
 }  
  
    public String getName() {  
        System.out.println("getName");  
 return name;  
 }  
  
    public void setName(String name) {  
        System.out.println("setName");  
 this.name = name;  
 }  
  
    public int getAge() {  
        System.out.println("getAge");  
 return age;  
 }  
  
//    public void setAge(int age) {  
//        System.out.println("setAge");  
//        this.age = age;  
//    }  
  
 public String getAddress() {  
        System.out.println("getAddress");  
 return address;  
 }  
  
    public Properties getProperties() {  
        System.out.println("getProperties");  
 return properties;  
 }  
}

修改反序列化的 demo 文件，先是默认调用parseObject()不带指定类型的参数：也就是只有 JSON.parseObject(jsonstring)

代码如下
StudentUnserialize02.java

import com.alibaba.fastjson.JSON;  
  
public class StudentUnserialize02 {  
    public static void main(String[] args) {  
        String jsonString ="{\"@type\":\"Student\",\"age\":6," +  
                "\"name\":\"Drunkbaby\",\"address\":\"china\",\"properties\":{}}";  
 Object obj = JSON.parseObject(jsonString);  
 // 或以下语句，输出结果一致  
 //JSONObject obj = JSON.parseObject(jsonString);  
 System.out.println(obj);  
 System.out.println(obj.getClass().getName());  
 }  
}

输出看到，调用了Student类的构造函数、所有属性的getter方法、JSON里面非私有属性的setter方法，其中getProperties()调用了两次；无论定义的对象是Object还是JSONObject，最后反序列化得到的都是JSONObject类对象，可以看到是未反序列化成功的：

接着在StudentUnserialize02.java中修改反序列化代码语句如下，加上指定反序列化得到的类型为Object.class或Student.class，这样就是成功反序列化的回显。

3. parse与parseObject区别

前面的demo都是用parseObject()演示的，还没说到parse()。两者主要的区别就是parseObject()返回的是JSONObject而parse()返回的是实际类型的对象，当在没有对应类的定义的情况下，一般情况下都会使用JSON.parseObject()来获取数据。

FastJson中的 parse() 和 parseObject() 方法都可以用来将JSON字符串反序列化成Java对象，parseObject() 本质上也是调用 parse() 进行反序列化的。但是 parseObject() 会额外的将Java对象转为 JSONObject对象，即 JSON.toJSON()。所以进行反序列化时的细节区别在于，parse() 会识别并调用目标类的 setter 方法及某些特定条件的 getter 方法，而 parseObject() 由于多执行了 JSON.toJSON(obj)，所以在处理过程中会调用反序列化目标类的所有 setter 和 getter 方法。

也就是说，我们用parse()反序列化会直接得到特定的类，而无需像parseObject()一样返回的是JSONObject类型的对象、还可能需要去设置第二个参数指定返回特定的类。

修改反序列化语句中的parseObject()为parse()：

StudentUnserialize03.java

import com.alibaba.fastjson.JSON;  
import com.alibaba.fastjson.parser.Feature;  
  
public class StudentUnserialize03 {  
    public static void main(String[] args) {  
        String jsonString ="{\"@type\":\"Student\",\"age\":6," +  
                "\"name\":\"Drunkbaby\",\"address\":\"china\",\"properties\":{}}";  
 Object obj = JSON.parse(jsonString, Feature.SupportNonPublicField);  
 // 或以下语句，输出结果一致  
 //JSONObject obj = JSON.parseObject(jsonString);  
 System.out.println(obj);  
 System.out.println(obj.getClass().getName());  
 }  
}

4. 一句话概括

一句话概括上面两点

这里写的有点啰嗦了，我觉得就一句话就可以概括了，我们的反序列化的语句应该这么写

1
2
3

String jsonString ="{\"@type\":\"Student\",\"age\":6," +  
        "\"name\":\"Drunkbaby\",\"address\":\"china\",\"properties\":{}}";  
Object obj = JSON.parseObject(jsonString, Student.class);

要用 parseObject，里面的参数需要是 Object.class

0x05 fastjson 反序列化漏洞原理

感觉这里废话有点多，我先总结一下。

fastjson 在反序列化的时候会去找我们在 @type 中规定的类是哪个类，然后在反序列化的时候会自动调用这些 setter 与 getter 方法的调用，注意！并不是所有的 setter 和 getter 方法。

下面直接引用结论，Fastjson会对满足下列要求的setter/getter方法进行调用：

满足条件的setter：

非静态函数
返回类型为void或当前类
参数个数为1个

满足条件的getter：

非静态方法
无参数
返回值类型继承自Collection或Map或AtomicBoolean或AtomicInteger或AtomicLong

我个人理解 fastjson 的利用攻击其实是蛮简单的，因为没有那么多复杂的链子，也不需要反射修改值，直接在 json 串里面赋值就好了。

1. 漏洞原理

由前面知道，Fastjson是自己实现的一套序列化和反序列化机制，不是用的Java原生的序列化和反序列化机制。无论是哪个版本，Fastjson反序列化漏洞的原理都是一样的，只不过不同版本是针对不同的黑名单或者利用不同利用链来进行绕过利用而已。

通过Fastjson反序列化漏洞，攻击者可以传入一个恶意构造的JSON内容，程序对其进行反序列化后得到恶意类并执行了恶意类中的恶意函数，进而导致代码执行。

那么如何才能够反序列化出恶意类呢？

由前面demo知道，Fastjson使用parseObject()/parse()进行反序列化的时候可以指定类型。如果指定的类型太大，包含太多子类，就有利用空间了。例如，如果指定类型为Object或JSONObject，则可以反序列化出来任意类。例如代码写Object o = JSON.parseObject(poc,Object.class)就可以反序列化出Object类或其任意子类，而Object又是任意类的父类，所以就可以反序列化出所有类。

接着，如何才能触发反序列化得到的恶意类中的恶意函数呢？

由前面知道，在某些情况下进行反序列化时会将反序列化得到的类的构造函数、getter方法、setter方法执行一遍，如果这三种方法中存在危险操作，则可能导致反序列化漏洞的存在。换句话说，就是攻击者传入要进行反序列化的类中的构造函数、getter方法、setter方法中要存在漏洞才能触发。

我们到DefaultJSONParser.parseObject(Map object, Object fieldName)中看下，JSON中以@type形式传入的类的时候，调用deserializer.deserialize()处理该类，并去调用这个类的setter和getter方法：

public final Object parseObject(final Map object, Object fieldName) {
    ...
    // JSON.DEFAULT_TYPE_KEY即@type
    if (key == JSON.DEFAULT_TYPE_KEY && !lexer.isEnabled(Feature.DisableSpecialKeyDetect)) {
        ...
        ObjectDeserializer deserializer = config.getDeserializer(clazz);
        return deserializer.deserialze(this, clazz, fieldName);

整个解析过程相当复杂，知道结论就ok了。

小结一下

若反序列化指定类型的类如Student obj = JSON.parseObject(text, Student.class);，该类本身的构造函数、setter方法、getter方法存在危险操作，则存在Fastjson反序列化漏洞；

若反序列化未指定类型的类如Object obj = JSON.parseObject(text, Object.class);，该若该类的子类的构造方法、setter方法、getter方法存在危险操作，则存在Fastjson反序列化漏洞；

2. PoC 写法

一般的，Fastjson反序列化漏洞的PoC写法如下，@type指定了反序列化得到的类

{
"@type":"xxx.xxx.xxx",
"xxx":"xxx",
...
}

关键是要找出一个特殊的在目标环境中已存在的类，满足如下两个条件：

该类的构造函数、setter方法、getter方法中的某一个存在危险操作，比如造成命令执行；
可以控制该漏洞函数的变量（一般就是该类的属性）；

3. 漏洞Demo

由前面比较的案例知道，当反序列化指定的类型是Object.class，即代码为Object obj = JSON.parseObject(jsonstring, Object.class, Feature.SupportNonPublicField);时，反序列化得到的类的构造函数、所有属性的setter方法、properties私有属性的getter方法都会被调用，因此我们这里直接做最简单的修改，将Student类中会被调用的getter方法添加漏洞代码，这里修改getProperties()作为演示：

import java.util.Properties;  
  
public class Student {  
    private String name;  
 private int age;  
 private String address;  
 private Properties properties;  
  
 public Student() {  
        System.out.println("构造函数");  
 }  
  
    public String getName() {  
        System.out.println("getName");  
 return name;  
 }  
  
    public void setName(String name) {  
        System.out.println("setName");  
 this.name = name;  
 }  
  
    public int getAge() {  
        System.out.println("getAge");  
 return age;  
 }  
  
//    public void setAge(int age) {  
//        System.out.println("setAge");  
//        this.age = age;  
//    }  
  
 public String getAddress() {  
        System.out.println("getAddress");  
 return address;  
 }  
  
    public Properties getProperties() throws Exception{  
        System.out.println("getProperties");  
 Runtime.getRuntime().exec("calc");  
 return properties;  
 }  
}

然后在反序列化的代码当中修改如下(我这里是新建了一个文件)
FastjsonEasyPoC.java

import com.alibaba.fastjson.JSON;  
import com.alibaba.fastjson.JSONObject;  
import com.alibaba.fastjson.parser.Feature;  
  
public class FastjsonEasyPoC {  
    public static void main(String[] args){  
        String jsonString ="{\"@type\":\"Student\",\"age\":6,\"name\":\"Drunkbaby\",\"address\":\"china\",\"properties\":{}}";  
  
 Object obj = JSON.parseObject(jsonString, Object.class);  
 System.out.println(obj);  
 System.out.println(obj.getClass().getName());  
 }  
}

运行结果如图

很明显，前面的Demo中反序列化的类是一个Object类，该类是任意类的父类，其子类Student存在Fastjson反序列化漏洞，当@type指向Student类是反序列化就会触发漏洞。

对于另一种反序列化指定类的情景，是该指定类本身就存在漏洞，比如我们将上述Demo中反序列化那行代码改成直接反序列化得到Student类而非Object类，这样就是另一个触发也是最直接的触发场景：

1	Student obj = JSON.parseObject(jsonstring, Student.class, Feature.SupportNonPublicField);

4. 调试分析漏洞

就还是 debug 一下，看一下内部运行逻辑

这个地方的命令执行

其实也好理解吧，毕竟 fastjson 这里很简单，就和我们当初讲反序列化入门的时候差不多。

0x06 小结

总体来说入门确实不难，但是对于基础会有点要求。

总结一下漏洞发生在反序列化的点，也就是 Obj.parse 和 Obj.parseObject 这里。必须的是传参要带入 class 的参数，最好带上 Feature.SupportNonPublicField

PoC 是通过 String 传进去的，要以 @type 打头。

漏洞的原因是反序列化的时候去调用了 getter 和 setter 的方法。其余就没什么了，比较简单。

0x07 参考资料

Fastjson反序列化漏洞(1)——基本原理 – JohnFrod’s Blog

Fastjson系列一——反序列化漏洞基本原理 [ Mi1k7ea ]