Mi1k7ea

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

阅读量

0x01 基本概念

Fastjson简介

Fastjson是Alibaba开发的Java语言编写的高性能JSON库,用于将数据在JSON和Java Object之间互相转换,提供两个主要接口JSON.toJSONString和JSON.parseObject/JSON.parse来分别实现序列化和反序列化操作。

项目地址:https://github.com/alibaba/fastjson

使用Fastjson进行序列化和反序列化

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

Student.java,定义的一个学生类,其中包含两个属性及其getter/setter方法,还有类的构造函数:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
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;
}
}

FJTest.java,调用JSON.toJsonString()来序列化Student类对象 :

1
2
3
4
5
6
7
8
9
public class FJTest {
public static void main(String[] args){
Student student = new Student();
student.setName("Mi1k7ea");
student.setAge(6);
String jsonstring = JSON.toJSONString(student, SerializerFeature.WriteClassName);
System.out.println(jsonstring);
}
}

SerializerFeature.WriteClassName,是JSON.toJSONString()中的一个设置属性值,设置之后在序列化的时候会多写入一个@type,即写上被序列化的类名,type可以指定反序列化的类,并且调用其getter/setter/is方法。

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

输出如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 设置了SerializerFeature.WriteClassName
构造函数
setName
setAge
getAge
getName
{"@type":"Student","age":6,"name":"Mi1k7ea"}

// 未设置SerializerFeature.WriteClassName
构造函数
setName
setAge
getAge
getName
{"age":6,"name":"Mi1k7ea"}

FJTest2.java,调用JSON.parseObject()反序列化JSON为对象:

1
2
3
4
5
6
7
8
public class FJTest2 {
public static void main(String[] args){
String jsonstring ="{\"@type\":\"Student\",\"age\":6,\"name\":\"Mi1k7ea\"}";
Student obj = JSON.parseObject(jsonstring, Student.class, Feature.SupportNonPublicField);
System.out.println(obj);
System.out.println(obj.getClass().getName());
}
}

输出:

1
2
3
4
5
构造函数
setAge
setName
Student@75b9fd80
Student

反序列化类图

Fastjson反序列化的类方法调用关系如图:

JSON:门面类,提供入口

DefaultJSONParser:主类

ParserConfig:配置相关类

JSONLexerBase:字符分析类

JavaBeanDeserializer:JavaBean反序列化类

Feature.SupportNonPublicField

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
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;
// }
}

修改FJTest2.java,去掉Feature.SupportNonPublicField,添加输出两个属性getter方法的返回值:

1
2
3
4
5
6
7
8
9
public class FJTest2 {
public static void main(String[] args){
String jsonstring ="{\"@type\":\"Student\",\"age\":6,\"name\":\"Mi1k7ea\"}";
Student obj = JSON.parseObject(jsonstring, Student.class);
System.out.println(obj);
System.out.println(obj.getClass().getName());
System.out.println(obj.getName() + " " + obj.getAge());
}
}

重新运行,会看到获取不到私有变量age的值而是被设置为0:

1
2
3
4
5
6
7
构造函数
setName
Student@7addc524
Student
getName
getAge
Mi1k7ea 0

接着添加Feature.SupportNonPublicField:

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

再输出就能成功还原出age这个私有变量的值了:

1
2
3
4
5
6
7
构造函数
setName
Student@2c59109c
Student
getName
getAge
Mi1k7ea 6

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

反序列化时几种类型设置的比较

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
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 String getAddress() {
System.out.println("getAddress");
return address;
}

public Properties getProperties() {
System.out.println("getProperties");
return properties;
}
}

未设置Feature.SupportNonPublicField

修改FJTest2.java,先是默认调用parseObject()不带指定类型的参数:

1
2
3
4
5
6
7
8
9
10
public class FJTest2 {
public static void main(String[] args){
String jsonstring ="{\"@type\":\"Student\",\"age\":6,\"name\":\"Mi1k7ea\",\"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类对象,可以看到是未反序列化成功的:

1
2
3
4
5
6
7
8
9
构造函数
setName
getProperties
getAddress
getAge
getName
getProperties
{"name":"Mi1k7ea","age":0}
com.alibaba.fastjson.JSONObject

接着在FJTest2.java中修改反序列化代码语句如下,加上指定反序列化得到的类型为Object.class或Student.class:

1
2
3
4
5
6
7
Object obj = JSON.parseObject(jsonstring, Object.class);
// 或以下语句,输出结果一致
//Object obj = JSON.parseObject(jsonstring, Student.class);
// 或以下语句,输出结果一致
//Student obj = JSON.parseObject(jsonstring, Student.class);

// 另外,JSONObject类不支持这种写法

输出看到,调用了Student类的构造函数、JSON里面非私有属性的setter方法、properties成员变量的的getter方法,反序列化得到的是Student类对象即反序列化成功,也就是说只要添加了指定的类这个参数,通过@type的作用parseObject()都会成功将JSON反序列化为@type指定的类

1
2
3
4
5
构造函数
setName
getProperties
Student@ca140c2
Student

设置Feature.SupportNonPublicField

修改FJTest2.java中反序列化代码语句如下:

1
2
3
4
5
Object obj = JSON.parseObject(jsonstring, Object.class, Feature.SupportNonPublicField);
// 或以下语句,输出结果一致
//Object obj = JSON.parseObject(jsonstring, Student.class, Feature.SupportNonPublicField);
// 或以下语句,输出结果一致
//Student obj = JSON.parseObject(jsonstring, Student.class, Feature.SupportNonPublicField);

输出,发现和未设置Feature.SupportNonPublicField的是一致的:

1
2
3
4
5
构造函数
setName
getProperties
Student@4c00c0cf
Student

小结

根据前面的结果,有如下结论:

  • 当反序列化为JSON.parseObject(*)形式即未指定class时,会调用反序列化得到的类的构造函数、所有属性的getter方法、JSON里面的非私有属性的setter方法,其中properties属性的getter方法调用了两次;
  • 当反序列化为JSON.parseObject(*,*.class)形式即指定class时,只调用反序列化得到的类的构造函数、JSON里面的非私有属性的setter方法、properties属性的getter方法;
  • 当反序列化为JSON.parseObject(*)形式即未指定class进行反序列化时得到的都是JSONObject类对象,而只要指定了class即JSON.parseObject(*,*.class)形式得到的都是特定的Student类;

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

满足条件的setter:

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

满足条件的getter:

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

注意,除了getter方法和setter方法外,还有个is方法这里没有列举,可自行测试。

前面的properties私有属性,其类型为Properties,而Properties是继承于Hashtable,Hashtable是实现Map接口类的类,因此properties私有属性的getter方法时继承自Map,从而能够成功被Fastjson调用。

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类型的对象、还可能需要去设置第二个参数指定返回特定的类。

修改FJTest2.java中的parseObject()为parse():

1
2
3
4
5
6
7
8
9
10
public class FJTest2 {
public static void main(String[] args){
String jsonstring ="{\"@type\":\"Student\",\"age\":6,\"name\":\"Mi1k7ea\",\"address\":\"china\",\"properties\":{}}";
Object obj = JSON.parse(jsonstring);
// 或以下语句,输出结果一致
// Object obj = JSON.parse(jsonstring, Feature.SupportNonPublicField);
System.out.println(obj);
System.out.println(obj.getClass().getName());
}
}

输出:

1
2
3
4
5
构造函数
setName
getProperties
Student@398600d7
Student

0x02 Fastjson反序列化漏洞原理

漏洞原理

由前面知道,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方法:

1
2
3
4
5
6
7
8
@SuppressWarnings({ "unchecked", "rawtypes" })
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反序列化漏洞;

PoC写法

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

1
2
3
4
5
{
"@type":"xxx.xxx.xxx",
"xxx":"xxx",
...
}

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

  1. 该类的构造函数、setter方法、getter方法中的某一个存在危险操作,比如造成命令执行;
  2. 可以控制该漏洞函数的变量(一般就是该类的属性);

漏洞Demo

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
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 String getAddress() {
System.out.println("getAddress");
return address;
}

public Properties getProperties() throws Exception {
System.out.println("getProperties");
Runtime.getRuntime().exec("calc");
return properties;
}
}

FJTest2.java:

1
2
3
4
5
6
7
8
public class FJTest2 {
public static void main(String[] args){
String jsonstring ="{\"@type\":\"Student\",\"age\":6,\"name\":\"Mi1k7ea\",\"address\":\"china\",\"properties\":{}}";
Object obj = JSON.parseObject(jsonstring, Object.class, Feature.SupportNonPublicField);
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);

OK,Fastjson反序列化漏洞的一些基本概念原理就写到这了,下一篇写2017年的Fastjson 1.2.22-1.2.24 反序列化漏洞。


Copyright © Mi1k7ea | 本站总访问量