Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessGain MITM or rogue-server position on unencrypted DRDA link
-
DeliverySend result set with 0x50-tagged UDT column
-
ExploitClient calls bare ObjectInputStream.readObject() on event loop
-
ExecutionGadget chain deserializes attacker object graph
-
ImpactExecute arbitrary code (or crash on DoS)
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A08:2025 - Software or Data Integrity Failures
ASVS 5.0
V1 - Encoding and Sanitization Safe deserialization, type allowlists
MITRE ATT&CK
2 techniques across 2 tactics: Execution, Initial Access The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires that the application use the io.vertx:vertx-db2-client in an affected version AND connect to a DRDA server the attacker controls or can man-in-the-middle; the trigger is a server-sent result-set column tagged with FDOCA UDT type LID 0x50, which legitimate DB2 servers never emit. Because client-side TLS is disabled by default, a network attacker on the client-to-DB2 path can inject the malicious response without first compromising credentials. Full remote code execution additionally requires a Java deserialization gadget chain on the application classpath; without one, impact is limited to denial of service. Limiting factors: attacker must hold server-side or MITM position (AC:H), and RCE depends on classpath gadget availability - deployments using TLS/mutual auth to a trusted DB2 server are not practically exploitable. |
| Impact | This is a genuine high-priority issue for the specific population that uses it, but its real-world blast radius is narrower than the 9.2 CVSS 4.0 score suggests in isolation. The vendor vector (CVSS:4.0/AV:N/AC:H/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H) correctly captures network reach with no authentication or user interaction against the client, but critically marks AC:H - exploitation is NOT trivial opportunistic hitting of a listening service. The attacker must either operate a malicious DRDA/DB2 server the client connects to, or hold a man-in-the-middle position on the client-to-DB2 path; the advisory notes TLS is disabled by default, which makes that MITM position realistically attainable on untrusted networks. Full remote code execution is further gated on a deserialization gadget chain being present on the application classpath - a real but not universal precondition; absent a gadget chain the impact degrades to denial of service via malicious object graphs, which still matters because deserialization occurs on the Vert.x event loop before application code can reject it. No EPSS score, no CISA KEV listing, and no public POC are present in the provided data, so there is no evidence of active exploitation - this is a disclosed vulnerability (reported by Eclipse via GHSA advisory), not a known exploited one. Signals are therefore consistent rather than conflicting: high theoretical impact, moderate attack complexity, no observed exploitation. Treat as a prioritized patch for teams running io.vertx:vertx-db2-client, especially those connecting over untrusted networks without TLS, rather than an emergency broad-internet threat. |
| Exploit ScenarioDerived | An attacker who controls a DB2/DRDA endpoint or can intercept an unencrypted client connection (TLS is off by default) returns a crafted result set containing a column tagged as a UDT with FDOCA type LID 0x50. The Vert.x DB2 client blindly calls ObjectInputStream.readObject() on the attacker-supplied bytes on the event loop, and if a Java deserialization gadget chain exists on the classpath this yields remote code execution; otherwise a malicious object graph causes denial of service. No public exploit was identified at time of analysis, but the deserialization sink is well-understood and gadget-chain tooling is widely available. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 15, 2026
Eclipse Vert.x DB2 Client versions 4.0.0 through 4.5.34, 5.0.0 through 5.0.12, 5.1.0 through 5.1.9, and 5.2.0 can deserialize attacker-controlled DRDA UDT column data, enabling remote code execution if a Java deserialization gadget chain is present on the classpath or denial of service otherwise. The affected component is io.vertx:vertx-db2-client, and exploitation requires an application to connect to a malicious or man-in-the-middle DRDA server that returns a result-set column tagged with FDOCA LID 0x50; legitimate DB2 servers never emit that type, and client-side TLS is disabled by default. The CVSS 4.0 score is 9.2 with PR:N, but practical exploitation requires attacker server-side/MITM position (AC:H) and, for RCE, a classpath gadget chain; no public exploit identified at time of analysis, and the real-world blast radius is narrower than the score alone suggests.
RemediationAI
Patch available per vendor advisory; apply the fixed release identified by the Eclipse Vert.x advisory GHSA-j4vf-w939-pgxf (https://github.com/eclipse-vertx/vertx-sql-client/security/advisories/GHSA-j4vf-w939-pgxf), but the supplied data does not list exact fixed version strings, so verify the patched version that supersedes the affected ranges (up to 4.5.34, 5.0.12, 5.1.9, and 5.2.0) before upgrading. Until patching is possible, enable TLS with certificate validation (and mutual TLS where feasible) for all vertx-db2-client connections so a man-in-the-middle cannot inject the malicious DRDA response; this adds configuration and certificate-management overhead and may have a small performance cost. Restrict the client to trusted DB2 endpoints on trusted network paths, because the attack requires server-side or MITM position; this is a compensating control, not a code fix, and does not protect against a compromised trusted server. Remove unnecessary Java deserialization gadget libraries from the application classpath as defense-in-depth to reduce RCE likelihood, though this does not prevent the deserialization call or the resulting denial-of-service path. Monitor and alert on unexpected DRDA result-set metadata carrying FDOCA LID 0x50, but note that such detection is after the client has already accepted the server response and should be paired with network controls.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
DRDA (Distributed Relational Database Architecture) is IBM's protocol for DB2 client-server communication. Within a result set, column metadata can include FDOCA type identifiers; LID 0x50 indicates a User Defined Type, a type that legitimate DB2 servers do not support. In the affected Vert.x DB2 client, receipt of a 0x50-tagged column causes a bare ObjectInputStream.readObject() call to deserialize attacker-controlled bytes without an ObjectInputFilter or class allowlist, and this occurs on the Vert.x event loop before application code can validate or reject the response. The root cause is unsafe Java deserialization of untrusted data (the CWE-502 class), though the supplied CWE field is N/A, and the CPE cpe:2.3:a:eclipse_foundation:eclipse_vert.x:*:*:*:*:*:*:*:* broadly identifies Eclipse Vert.x while the specific impacted artifact is io.vertx:vertx-db2-client. Because TLS is disabled by default on the client, a network attacker on the client-to-DB2 path can inject the crafted DRDA response without first compromising credentials; RCE additionally requires a compatible gadget chain on the application classpath, while without one the same primitive can produce denial of service through crafted object graphs.
Know when Java gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
CVSS:4.0/AV:N/AC:H/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Network-reachable with no client authentication (PR:N) or interaction, but requires attacker-controlled/MITM DRDA server plus a gadget chain, hence AC:H; successful RCE fully compromises the process (C/I/A:H).
Primary rating from Vendor (eclipse).
CVSS VectorVendor: eclipse
DescriptionCVE.org
In Eclipse Vert.x versions [4.0.0, 4.5.34] or [5.0.0,5.0.12] or [5.1.0,5.1.9] or [5.2.0, 5.2.0], the Vert.x DB2 client (vertx-db2-client) contains DRDA protocol handling code that deserializes User Defined Type (UDT) column data using a bare ObjectInputStream.readObject() call with no ObjectInputFilter or class allowlist.
This code path is triggered when a DRDA server sends a result set with a column tagged as UDT (FDOCA protocol LID 0x50). However, DB2 does not support this type of UDT. The FDOCA 0x50 type is never sent by a legitimate DB2 server.
Nevertheless, a malicious or man-in-the-middle DRDA server could craft a response with a 0x50-tagged column, causing the client to deserialize arbitrary attacker-controlled bytes on the Vert.x event loop before any application code can inspect or reject the data. If a Java deserialization gadget chain is present on the application's classpath, this enables remote code execution. Without a gadget chain, denial of service is possible via crafted object graphs. TLS is disabled by default, making man-in-the-middle exploitation feasible.
The impacted component is io.vertx:vertx-db2-client.
Articles & Coverage 1
Technical POC Analysis
Bug class: CWE-502, deserialization of untrusted data.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
Eclipse Vert.x DB2 Client, used by Java applications to talk to IBM DB2 databases, contains a critical deserialization flaw that lets an attacker who can position themselves as a man-in-the-middle or as a rogue DRDA server execute arbitrary code inside the connecting application, or at minimum crash it. Because client-side TLS is off by default, business services built on the affected 4.0.0-4.5.34, 5.0.0-5.0.12, 5.1.0-5.1.9 and 5.2.0 releases may be talking to database endpoints without any protection against this attack. Leadership should care because the worst case is full compromise of the application host and any data or credentials it can reach, and there is currently no vendor patch to fall back on.
No vendor-released patch identified at time of analysis. Interim mitigations: enforce client-side TLS with certificate validation (disabled by default), restrict outbound connectivity to known trusted DB2 servers via segmentation or proxy, apply JEP 290 deserialization filters to reject unexpected classes, and remove unused deserialization gadget-chain libraries from the classpath to eliminate the RCE precondition.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Insecure deserialization occurs when an application converts serialized data (a stream of bytes representing an object's state) back into a living object without proper validation.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
Oracle Java SE 7 Update 6 and earlier contains multiple sandbox bypass vulnerabilities via the ClassFinder and forName m
Remote code execution in IBM Sterling B2B Integrator, Sterling Integrator, and Tivoli Common Reporting allows unauthenti
Java Runtime Environment sandbox bypass via incorrect image channel verification in 2D component allows remote unauthent
Oracle Java SE JDK/JRE 7 and 6 Update 27 and earlier allows remote code execution with complete system compromise throug
JBoss Seam 2 in Red Hat JBoss EAP 4.3.0 fails to sanitize JBoss Expression Language inputs, allowing remote attackers to
Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle Java SE 7 update 4 and earlier, 6 up
Multiple vulnerabilities in Oracle Java 7 before Update 11 allow remote attackers to execute arbitrary code by (1) using
Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle Java SE 7 Update 2 and earlier, 6 Up
The WLS Security component in Oracle WebLogic Server 10.3.6.0, 12.1.2.0, 12.1.3.0, and 12.2.1.0 allows remote attackers
Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle Java SE 7 Update 7 and earlier allow
Remote unauthenticated attackers can execute arbitrary code on Adobe ColdFusion servers through Java deserialization fla
The ExceptionDelegator component in Apache Struts before 2.2.3.1 interprets parameter values as OGNL expressions during
EUVD-2026-101960
GHSA-mxgf-c753-mmc9
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB