fastjson1.2.22-1.2.24反序列化流程

前言

接上一篇进行1.2.22-.1.2.24 fastjson源码漏洞的分析

反序列化流程

public class Ser {
    public static void main(String[] args) throws IOException {
        Person person = new Person();
        person.setName("harry");
        person.setAge(22);
        person.setGender("male");
        String jsonstring = JSON.toJSONString(person, SerializerFeature.WriteClassName);
        //反序列化入口parseObject
        System.out.println(JSON.parseObject(jsonstring));
    }
}

反序列化入口,断点更进．

然后来到parseObject函数内部，位于JSON.class line 201

继续更进parseObject函数的parse函数　来到了line 128

然后跟进DefaultJsonParser函数进入DefultJSONParser.class，

触发了上面这个重载，来到下图line 175,函数的作用对输入的字符串第一个字符仅那个了判断并标记为常量值以判断类型

继续放行，这里是判断刚刚传导出来的类型即{为12

继续放行来到了line 322这个if块，这里是得到我们传入类的类名

step over来到

//载入类   
public static Class<?> loadClass(String className, ClassLoader classLoader) {
    //判断传入类
        if (className == null || className.length() == 0) {
            return null;
        }

        Class<?> clazz = mappings.get(className);

        if (clazz != null) {
            return clazz;
        }

        if (className.charAt(0) == '[') {
            Class<?> componentType = loadClass(className.substring(1), classLoader);
            return Array.newInstance(componentType, 0).getClass();
        }

        if (className.startsWith("L") && className.endsWith(";")) {
            String newClassName = className.substring(1, className.length() - 1);
            return loadClass(newClassName, classLoader);
        }

        try {
            if (classLoader != null) {
                clazz = classLoader.loadClass(className);
                mappings.put(className, clazz);

                return clazz;
            }
        } catch (Throwable e) {
            e.printStackTrace();
            // skip
        }

        try {
            ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
//如果类不是内置类型，那就载入用户传入的类
            if (contextClassLoader != null) {
                clazz = contextClassLoader.loadClass(className);
          
                mappings.put(className, clazz);

                return clazz;
            }
        } catch (Throwable e) {
            // skip
        }

        try {
            clazz = Class.forName(className);
            mappings.put(className, clazz);

            return clazz;
        } catch (Throwable e) {
            // skip
        }

        return clazz;
    }