Skip to main content

Eclipse Vert.x CVE-2026-102479

| EUVDEUVD-2026-101557 HIGH
HTTP Request/Response Smuggling (CWE-444)
2026-10-14 emo@eclipse.org
8.7
CVSS 4.0 · Vendor: eclipse
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Reach Vert.x HTTP/1.x endpoint
  2. Delivery
    Craft header mimicking Content-Length
  3. Exploit
    Decoder canonicalizes to known header
  4. Execution
    Desynchronize request boundaries
  5. Persist
    Smuggle hidden request
  6. Impact
    Poison routing / bypass controls

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V4 - API and Web Service HTTP request consistency
Exploitation Conditions

Exploitation requires that the target run an affected Eclipse Vert.x version (vertx-core 5.0.0-5.0.12, 5.1.0-5.1.9, or 5.2.0) serving HTTP/1.x, since the flaw is in the HTTP/1.x decoder's canonicalization of well-known headers (e.g. 'Content-Xength' being interpreted as 'Content-Length'). The practical impact of request smuggling additionally depends on the deployment topology: a second HTTP agent must share the request path (a front-end proxy/load balancer, CDN, or back-end server) that parses the ambiguous headers differently from Vert.x - a standalone Vert.x server with no co-located HTTP intermediary limits exploitability. No authentication and no user interaction are required (PR:N/UI:N), and the attack works over the network against HTTP/1.x listeners; deployments served exclusively over HTTP/2 are not reached by this HTTP/1.x decoder path.

Impact

This is a credible, deployable HTTP request smuggling flaw rather than a high-CVSS-but-low-real-risk issue. The vendor CVSS 4.0 vector (CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N) describes a network-reachable, low-complexity, unauthenticated attack requiring no user interaction, and the impact is concentrated entirely on integrity (VI:H) with VC:N/VA:N - consistent with request smuggling, which corrupts request boundaries/routing rather than directly reading data or crashing the service. The 8.7 score is driven by trivial reachability combined with high integrity impact, which is plausible for a header-parsing desync bug. No EPSS score, CISA KEV entry, SSVC decision, or POC was supplied in the input, so exploitation-probability signals are absent - this means the score reflects latent severity, not demonstrated in-the-wild activity. Note a tagging/impact tension: the input Tags label this 'Information Disclosure', yet the CVSS vector sets VC:N (no confidentiality impact) and request smuggling is fundamentally an integrity/desync issue - treat the 'Information Disclosure' categorization as unverified. CWE is listed as N/A, so no weakness classification corroborates the mechanism beyond the description (effectively CWE-444, HTTP request smuggling). Overall: real priority for anyone running an affected Vert.x version behind or in front of other HTTP intermediaries, but without EPSS/KEV/POC data the urgency is 'patch promptly', not 'emergency active-exploitation response'.

Exploit ScenarioDerived

An attacker sends a crafted HTTP/1.x request containing a mangled header such as 'Content-Xength' that Vert.x's header canonicalization normalizes to the well-known 'Content-Length', desynchronizing how Vert.x and an upstream/downstream proxy or server delimit requests. By smuggling a second request inside the first, the attacker can poison the request queue of other users, bypass front-end access controls, or route hidden requests to back-end endpoints. No public exploit was identified in the provided data, but the technique is well understood and the unauthenticated network vector (AC:L) makes practical exploitation straightforward where a vulnerable Vert.x instance shares a connection path with another HTTP component.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
No patch listed yet 0.3% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Oct 14, 2026

HTTP request smuggling in Eclipse Vert.x (io.vertx:vertx-core) affects versions 5.0.0 through 5.0.12, 5.1.0 through 5.1.9, and 5.2.0, where the HTTP/1.x decoder canonicalizes well-known header names in a way that lets crafted names such as 'Content-Xength' be treated as 'Content-Length'. Unauthenticated remote attackers (CVSS v4.0 vector PR:N/UI:N, score 8.7; independent CVSS v3.1 assessment AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:N) can exploit this to desynchronize how HTTP messages are framed, with integrity impact only and no direct confidentiality or availability loss. Practical impact depends on deployment topology: a second HTTP agent (front-end proxy, load balancer, CDN or back-end server) must share the request path and parse the ambiguous headers differently from Vert.x, whereas a standalone Vert.x HTTP/1.x server with no co-located intermediary sharply limits exploitability; HTTP/2-only deployments are not reached by this decoder path. No public exploit identified at time of analysis, and no confirmed CISA KEV active exploitation.

RemediationAI

Upgrade io.vertx:vertx-core past the affected ranges - i.e., to a release later than 5.0.12 on the 5.0.x line, later than 5.1.9 on the 5.1.x line, or later than 5.2.0 on the 5.2.x line - and confirm the exact fixed version in the vendor advisory GHSA-ch7p-g5pm-3gqx (https://github.com/eclipse-vertx/vert.x/security/advisories/GHSA-ch7p-g5pm-3gqx), which also carries the Eclipse coordination record at https://gitlab.eclipse.org/security/cve-assignment/-/work_items/352; the provided data does not state a specific patched version, so no fixed build number should be assumed. Also update any framework or service that bundles vertx-core 5.x, since patching the library alone is insufficient if a shaded or pinned dependency is used. If immediate upgrade is not possible, the highest-value compensating control is to eliminate parser disagreement: strip or reject at the edge any request header whose name is not an exact match for a known good header (this defeats 'Content-Xength'-style canonicalization collisions), and configure the front-end proxy/load balancer and Vert.x to use identical header-normalization and transfer-encoding rules - the trade-off is a small risk of rejecting legitimate clients that send unconventional header casing or vendor-prefixed fields. Disabling the HTTP/1.x listener and serving only HTTP/2 (or HTTP/2 end-to-end with no HTTP/1 downgrade) removes the vulnerable decoder path entirely, but breaks HTTP/1-only clients and intermediaries and requires a compatible front end. Because smuggling is topology-dependent, terminating client connections at a single trusted parser and disabling connection reuse (keep-alive) between the edge and Vert.x reduces the blast radius of a desynchronized stream, at a measurable latency and throughput cost. Finally, enable request-smuggling detection and log alerting on duplicate or near-duplicate framing headers (Content-Length, Transfer-Encoding and their look-alikes) so attempted exploitation is visible even before patching; note that no public exploit code is known at time of analysis, so detection tuning should start from the advisory's header-canonicalization pattern rather than from a published payload.

Affected VersionsENISA

Eclipse Vert.x 5.1.0 ≤5.1.9
Eclipse Vert.x 5.0.0 ≤5.0.12
Eclipse Vert.x 5.2.0

Affected Packages

euvd eclipse_vert_x no fix

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

The flaw lives in the HTTP/1.x decoder inside io.vertx:vertx-core, the core component of the Eclipse Vert.x reactive toolkit. To route and frame incoming requests, Vert.x maps well-known HTTP header names to canonical forms; that canonicalization is too permissive, so a header whose name is merely similar to a well-known one (the advisory's example is 'Content-Xength') is interpreted as the well-known header ('Content-Length'). An attacker controlling the header names can therefore inject a framing header the downstream interpreter recognizes in a different position or with a different value than Vert.x does, producing an interpretation conflict - the classic request-smuggling precondition. The provided CWE field is N/A, but the weakness class corresponds to HTTP request smuggling / HTTP interpretation conflict (CWE-444 / CWE-436), and the primary consequence is integrity (VI:H) rather than disclosure: smuggled or re-framed requests can poison a shared connection, mis-associate a response with a different request, or bypass front-end access controls. Because the issue is in header-name canonicalization rather than in TLS or authentication, no credentials or user interaction are needed (PR:N/UI:N per the supplied CVSS v4.0 vector), and the exposure is network-facing wherever an HTTP/1.x listener is enabled.

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

Vendor (eclipse) PRIMARY 8.7 HIGH
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:H/VA:N/SC:N/SI:N/SA:N
vuln.today AI 7.5 HIGH

Network-reachable HTTP/1.x decoder, no auth or interaction (AV:N/AC:L/PR:N/UI:N); request smuggling corrupts request integrity (I:H) with no direct confidentiality or availability loss, and vendor rated no subsequent-system impact so S:U.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:N
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:H/VA:N/SC:N/SI:N/SA:N

Primary rating from Vendor (eclipse).

CVSS VectorVendor: eclipse

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
High
Vulnerable system: Availability
None
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

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/1.x decoder uses a canonicalization for well known HTTP headers, the canonicalization process interprets well crafted headers as headers of this list, allowing for instance Content-Xength to be interpeted as Content-Length.

This can be exploited for request smuggling purpose.

The impacted component is io.vertx:vertx-core.

Executive ViewAI

Why It Matters

Eclipse Vert.x core (io.vertx:vertx-core) versions 5.0.0 through 5.0.12, 5.1.0 through 5.1.9, and 5.2.0 contain an HTTP request smuggling flaw that can let unauthenticated remote attackers desynchronize message framing when a second HTTP intermediary shares the request path. The issue has no vendor-released patch, no public exploit identified at time of analysis, and primarily threatens integrity of HTTP traffic rather than direct confidentiality or availability. Leadership should care because affected Vert.x deployments behind proxies, load balancers, or CDNs may be exposed to security-control bypass, cache poisoning, or request-routing manipulation, requiring immediate inventory and compensating controls.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations: enforce strict HTTP header normalization at all proxies, load balancers, CDNs, and gateways to reject ambiguous, duplicate, or obfuscated Content-Length and Transfer-Encoding headers before traffic reaches Vert.x; use HTTP/2-only endpoints where feasible; isolate affected HTTP/1.x services behind trusted network boundaries; monitor for request smuggling indicators such as conflicting header names, cache anomalies, and unexplained 4xx/5xx responses; and prepare to upgrade to a vendor fix once released.

Threat Intelligence Overview

EPSS Score
0.3%
Top 82% exploitable
Prevalence
Medium
popular JVM reactive toolkit library, common but not ubiquitous
Data Quality
5 sources
Confidence: Medium

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.3%
Patch available No
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
Yes
Human Impact
High
Technical Impact
Partial

Priority Score

44
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +44
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

HTTP request smuggling exploits inconsistencies in how front-end and back-end servers parse HTTP message boundaries.

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy