Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessGain network MITM position
-
DeliveryTarget Vert.x client expecting hostname validation
-
ExploitTrigger cache key collision to weaker context
-
ExecutionPresent spoofed server certificate
-
ImpactIntercept/alter TLS traffic
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A07:2025 - Authentication Failures
ASVS 5.0
V12 - Secure Communication Certificate validation
|
| Exploitation Conditions | Exploitation requires the target application to use the Vert.x HTTP client and to create more than one SSL context whose desired properties differ in a way the cache key does not distinguish - specifically mixing a context that enables hostname (endpoint identification) validation with one that disables it - so that a request intended to validate hostnames is served the weaker cached context. It additionally requires the attacker to hold an active man-in-the-middle network position to abuse the resulting loss of certificate/hostname verification. Limiting factors: applications that use a single uniform SSL configuration, or that never disable hostname validation, are not exposed; there is no user interaction and no authentication requirement (PR:N/UI:N), but the AC:H rating reflects the dependency on this specific context-mixing configuration plus a network interception capability. |
| Impact | This is a TLS trust-decision flaw in Eclipse Vert.x's HTTP client SSL context cache (io.vertx:vertx-core), where the cache key fails to capture the full SSL semantics of requested properties, so a caller requesting a context with hostname validation can receive a cached context that ignores it. The input CVSS 4.0 vector (AV:N/AC:H/PR:N/UI:N, VC:H/VI:H) scores 9.1 and reflects high confidentiality and integrity impact reachable over the network without authentication, but AC:H correctly signals that exploitation is not trivial: it depends on an application configuring multiple SSL contexts with differing security properties that collide on the cache key, plus an attacker positioned to perform a man-in-the-middle interception once validation is silently downgraded. No EPSS score, KEV listing, or POC is provided in the input, and there is no public exploit identified at time of analysis - so despite the high CVSS this is best treated as a serious latent weakening of TLS guarantees rather than an actively-exploited priority. The headline score is driven by worst-case MITM impact; the real-world probability is gated by whether a given deployment actually mixes hostname-validating and non-validating client contexts, which the raw score does not convey. CWE is listed as N/A and no EPSS/KEV data was supplied, so the automated-exploitability dimension cannot be evaluated from the input. |
| Exploit ScenarioDerived | An application uses the Vert.x HTTP client to make outbound HTTPS calls, with some connections configured to require hostname verification; due to the cache-key collision, one of those requests is served a cached SSL context that silently skips hostname validation. An attacker holding a network man-in-the-middle position (e.g., via DNS/ARP spoofing or a rogue upstream) then presents a mismatched-but-trusted-looking certificate, intercepting and potentially altering the TLS traffic the client believed was validated. No public exploit code is identified at time of analysis, and the high attack complexity (AC:H) reflects the need for both the vulnerable multi-context configuration and the MITM position. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 14, 2026
Eclipse Vert.x's HTTP client (io.vertx:vertx-core) caches SSL contexts using a cache key that does not fully capture the SSL semantics of the requested properties, so a caller asking for a context with hostname/endpoint-identification validation can be handed a cached context that silently ignores it - a TLS trust-decision failure affecting versions 5.0.0 through 5.0.12, 5.1.0 through 5.1.9, and 5.2.0. The issue is unauthenticated (CVSS vector PR:N/UI:N) but rated high attack complexity because exploitation additionally requires the application to create multiple SSL contexts with differing security properties and an attacker to hold a man-in-the-middle network position to abuse the resulting loss of certificate verification. There is no public exploit identified at time of analysis and no CISA KEV listing; the advisory-driven CVSS 4.0 score is 9.1, while the independent v3.1 assessment rates it lower (High, ~7.4) with AC:H, reflecting the configuration-dependent and MITM-gated prerequisites.
RemediationAI
The primary fix is to upgrade io.vertx:vertx-core to a release outside the affected ranges - the advisories define the vulnerable windows as ending at 5.0.12, 5.1.9, and 5.2.0, so the patched builds are the next releases after those versions; the exact fixed version numbers should be confirmed against GitHub Security Advisory GHSA-2vhw-4xwj-r38v and the Eclipse GitLab CVE assignment work item 350 before pinning a dependency. Because the root cause is cache reuse of a context with weaker SSL semantics, effective compensating controls until the upgrade is applied are: (1) never disable hostname/endpoint-identification validation anywhere in the process - if no code path ever requests a non-validating context, the colliding cache entry cannot be produced; (2) use a single, uniform SSL configuration (same trust store, same validation settings) for all HTTP clients in the JVM, since heterogeneous configurations are what trigger the collision; and (3) where heterogeneous clients are unavoidable, isolate the non-validating client in a separate JVM/process or bypass the Vert.x SSL context cache by constructing and supplying your own SSLContext/SSLEngine rather than relying on cached contexts. Note the trade-offs: keeping validation always on may break legitimate self-signed or internal-CA test/dev flows, and process isolation increases deployment complexity and resource use. Enabling certificate pinning or an outbound proxy that enforces TLS validation adds defense against the required man-in-the-middle position, but does not remove the underlying defect, so treat the upgrade as mandatory.
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
Vert.x core maintains an SSL context cache in its HTTP client to avoid the cost of repeatedly building SSLContext/TLS engine objects, keying cached entries on a subset of the requested SSL parameters. Because the key omits part of the security semantics - most critically whether hostname validation (endpoint identification / SNI hostname verification) is enforced - two distinct security postures can collide on the same key, and whichever context is populated first may be reused for the other. A caller that explicitly requests validation can therefore receive a weaker cached context that disables hostname checking, allowing a certificate issued for a different name (for example an attacker-controlled or compromised CA-issued certificate) to be accepted for the intended endpoint. No CWE identifier was supplied; the weakness class is improper certificate/hostname validation arising from an insufficiently discriminating cache key (conceptually adjacent to CWE-295 / cache-key collision), and it is confined to the Vert.x HTTP client - the server side and code not mixing SSL configurations are unaffected. The impacted artifact is io.vertx:vertx-core.
Know when the next one hits your stack
- 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:N/SC:N/SI:N/SA:N
Network MITM with no auth or interaction (AV:N/PR:N/UI:N) but dependent on a specific multi-context configuration and interception position (AC:H); downgraded TLS validation enables read and tamper (C:H/I:H), no availability impact.
Primary rating from Vendor (eclipse).
CVSS VectorVendor: eclipse
DescriptionCVE.org
In Eclipse Vert.x versions [5.0.0,5.0.12] or [5.1.0,5.1.9] or [5.2.0, 5.2.0], the Vert.x HTTP client relies on an SSL context for efficiency purpose, the key of this cache should reflect entirely the SSL semantics of the desired SSL properties. It is possible for a client to ask for an SSL context and obtain an SSL context with weaker properties, for instance a context with hostname validation and obtain a context ignoring hostname validation.
The impacted component is io.vertx:vertx-core.
Technical POC Analysis
The advisory does not assign a CWE.
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 HTTP client (io.vertx:vertx-core) versions 5.0.0 through 5.0.12, 5.1.0 through 5.1.9, and 5.2.0 can silently lose hostname/endpoint-identification validation when applications create multiple SSL contexts with differing security properties. This is an unauthenticated TLS trust-decision failure, but exploitation requires a man-in-the-middle network position and specific application configuration; no public exploit identified at time of analysis. Organizations running affected Vert.x-based services should treat this as a high business exposure because intercepted TLS sessions could expose credentials or sensitive data, though real-world impact is conditional on those prerequisites.
No vendor-released patch identified at time of analysis. Interim mitigations include avoiding multiple SSL contexts with differing security properties in affected io.vertx:vertx-core versions; explicitly enforcing hostname/endpoint-identification and certificate verification at the application layer; restricting outbound TLS to trusted endpoints via egress filtering and network segmentation; monitoring for MITM or certificate-validation anomalies; and tracking the vendor advisory for a fixed release.
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
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
EUVD-2026-101530
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB