Skip to main content

Eclipse Vert.x EUVDEUVD-2026-101933

| CVE-2026-102461 HIGH
Inefficient Algorithmic Complexity (CWE-407)
2026-10-15 eclipse GHSA-5ww7-gp4j-grqp
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 JSON-schema-validated API endpoint
  2. Delivery
    Craft moderately-sized JSON array
  3. Exploit
    Submit array triggering uniqueItems check
  4. Execution
    O(n²) pairwise comparison pins CPU
  5. Impact
    Service degradation or denial of service

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V2 - Validation and Business Logic Algorithmic complexity limits
Exploitation Conditions

Exploitation requires the target application to perform JSON schema validation using Eclipse Vert.x's io.vertx:vertx-json-schema (directly, or transitively via vertx-web-openapi-router, vertx-web-validation, or vertx-openapi) on attacker-controllable input, AND the active schema must employ the uniqueItems keyword against an array field. When those conditions hold, no further prerequisites apply (AV:N/AC:L/AT:N/PR:N/UI:N): a remote unauthenticated attacker simply sends one moderately-sized JSON array to the validated endpoint. Limiting factors: applications that do not use uniqueItems in their schemas, that do not expose schema-validated endpoints to untrusted clients, or that enforce request/array size limits upstream (e.g., at a gateway or body-size filter) are not practically exploitable. Affected versions are [4.0.0, 4.5.34], [5.0.0, 5.0.12], [5.1.0, 5.1.9], and 5.2.0.

Impact

This is a genuine denial-of-service vulnerability whose CVSS 4.0 score of 8.7 (HIGH) is driven entirely by availability impact (VA:H) with no confidentiality or integrity consequence (VC:N/VI:N). The attack vector is favorable to an attacker: network-reachable (AV:N), low complexity (AC:L), no attack requirements (AT:N), no privileges (PR:N), and no user interaction (UI:N) - meaning a remote unauthenticated attacker can trigger it against default validation behavior. However, several escalation signals are ABSENT: there is no EPSS score provided, no CISA KEV listing, and no public exploit code referenced, so there is no evidence of active or widespread exploitation at this time. The real-world severity is also tempered by the impact ceiling - this is pure CPU exhaustion (algorithmic complexity DoS), not code execution or data compromise, and exploitation requires the application to actually expose a JSON-schema-validated endpoint using the uniqueItems keyword. Net: a real and easily reproducible availability risk for affected deployments that validate untrusted JSON arrays, but not a 'drop everything' critical in the way an RCE would be. Note the high CVSS reflects the ease of triggering a service outage, not breadth of impact; prioritize for internet-facing API gateways using vertx-openapi/vertx-web-validation.

Exploit ScenarioDerived

An attacker identifies a public API endpoint built on Vert.x that validates request bodies against a JSON schema containing a uniqueItems constraint. They submit a single moderately-sized JSON array in the request body, which forces the validator into an O(n²) pairwise comparison with no short-circuit or size limit, pinning a CPU core and degrading or halting the service. No authentication, special privileges, or user interaction is required (AV:N/AC:L/PR:N/UI:N); no public exploit code was identified at time of analysis, but the technique is trivial to reproduce from the advisory description.

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

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

Alert me

AnalysisAIv1 – Oct 15, 2026

Denial of service in Eclipse Vert.x JSON Schema validation (io.vertx:vertx-json-schema) allows a remote unauthenticated attacker to burn disproportionate CPU by sending a single moderately sized JSON array to any endpoint whose active schema uses the uniqueItems keyword. The affected ranges are 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, and the defect propagates to the dependent modules vertx-web-openapi-router, vertx-web-validation and vertx-openapi. No public exploit code was identified at time of analysis, yet the issue is rated CVSS 4.0 8.7 (HIGH) entirely on availability impact (VA:H with VC:N/VI:N), and applications that do not use uniqueItems in attacker-reachable schemas or that cap request body/array size upstream are not practically exploitable.

RemediationAI

No vendor-released patch version is identified in the available intelligence, so treat the GitHub security advisory https://github.com/eclipse-vertx/vertx-json-schema/security/advisories/GHSA-4m87-8qfr-8p8m and the Eclipse CVE assignment item https://gitlab.eclipse.org/security/cve-assignment/-/work_items/340 as the authoritative source: consult them for the patched builds published above the affected ceilings (i.e. newer than 4.5.34, 5.0.12, 5.1.9, and 5.2.0) and upgrade io.vertx:vertx-json-schema plus its transitive consumers vertx-web-openapi-router, vertx-web-validation and vertx-openapi together, since patching only the parent module leaves the vulnerable validator on the classpath. Until a fixed build is confirmed, apply compensating controls matched to the exploitation prerequisites: remove or rewrite the uniqueItems keyword in schemas reachable by untrusted clients (the trade-off is weaker input validation - replicate the check yourself with a bounded, O(n) set/hash-based comparison, ideally after truncating the array); enforce a hard maximum request body size and a small maximum array element count at the reverse proxy or gateway, or in a Vert.x BodyHandler-equivalent filter, so oversized arrays are rejected before validation runs (trade-off: legitimate large payloads to that endpoint will fail, so tune per endpoint rather than globally); and rate-limit and cap concurrency per client IP or authenticated principal so repeated quadratic requests cannot compound (trade-off: adds latency and can penalize NAT-shared or legitimate high-volume clients). Note that generic size limits only reduce the window - even moderate arrays trigger the O(n²) cost - so bounding array length on uniqueItems-validated fields is the most effective interim measure, and network segmentation or moving validation of untrusted payloads to an isolated, separately throttled service can contain CPU exhaustion if none of the above is feasible.

Affected VersionsENISA

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

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 io.vertx:vertx-json-schema validator, the JSON Schema engine that Vert.x uses to enforce schemas in vertx-web-validation, vertx-openapi and vertx-web-openapi-router. The uniqueItems keyword is meant to assert that every element of a JSON array is distinct, but the implementation performs an O(n²) pairwise comparison loop with neither short-circuiting nor an upper bound on the number of elements inspected. Because the work grows quadratically with array length, a small, unauthenticated HTTP request carrying a few thousand array elements can pin a worker event-loop/thread for seconds, and repeated or concurrent requests multiply the effect - a classic algorithmic-complexity resource exhaustion pattern (the source data assigns no CWE; the behavior is consistent with inefficient algorithmic complexity / uncontrolled resource consumption classes). The published CPE cpe:2.3:a:eclipse_foundation:eclipse_vert.x:*:*:*:*:*:*:*:* identifies the Eclipse Foundation Vert.x project generically; the authoritative version constraints come from the advisory, namely [4.0.0, 4.5.34], [5.0.0, 5.0.12], [5.1.0, 5.1.9] and 5.2.0. The CVSS 4.0 vector CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N, corroborated by the independent CVSS 3.1 assessment (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H), confirms that no authentication, user interaction, or non-default attack conditions are needed once a uniqueItems-bearing schema is reachable, and that the sole consequence is availability loss.

Know when Eclipse Vert X 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

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

Remote unauthenticated attacker sends a crafted array with no interaction (AV:N/AC:L/PR:N/UI:N); impact is pure CPU-exhaustion DoS, so C:N/I:N/A:H with no scope change.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/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
None
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

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 uniqueItems keyword validation uses an O(n²) pairwise comparison loop with no short-circuit or size limit. A remote unauthenticated attacker can submit a moderately-sized JSON array that consumes disproportionate CPU time, leading to denial of service.

The impacted component is io.vertx:vertx-json-schema.

The following Vert.x modules depend on vertx-json-schema and are also affected:

io.vertx:vertx-web-openapi-router io.vertx:vertx-web-validation io.vertx:vertx-openapi

Technical POC Analysis

Evidence note: the only artifact supplied is advisory GHSA-4m87-8qfr-8p8m.

Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.

Executive ViewAI

Why It Matters

A flaw in Eclipse Vert.x's JSON Schema validation library - used by the widely deployed vertx-web-openapi-router, vertx-web-validation, and vertx-openapi modules - allows a remote attacker to consume disproportionate CPU with a single, ordinary-looking API request, degrading or stalling applications that rely on it. Because Vert.x commonly serves customer-facing APIs and microservices, teams running affected releases face real availability risk and potential service-level or revenue impact. No vendor patch currently exists, so exposure must be reduced through configuration and network controls rather than a straightforward upgrade.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations: remove or relocate the uniqueItems keyword in any attacker-reachable schema; enforce strict request body and JSON array size limits and request depth caps at a reverse proxy, API gateway, or WAF; apply per-client rate limiting and connection/concurrency throttles; set short request-processing timeouts and circuit breakers on Vert.x endpoints; isolate or size-limit the affected services and monitor CPU saturation and latency anomalies to enable rapid detection and containment.

Threat Intelligence Overview

EPSS Score
0.4%
Top 67% exploitable
Prevalence
Medium
Popular JVM reactive toolkit, but json-schema/OpenAPI module is a subset of deployments
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.4%
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

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

CVE-2026-102469 CRITICAL
9.2 Oct 15

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 deseri

CVE-2026-102477 HIGH
8.7 Oct 15

Unauthenticated remote attackers can exhaust server memory in Eclipse Vert.x deployments that expose the io.vertx:vertx-

CVE-2026-102475 HIGH
8.7 Oct 15

Denial of service in Eclipse Vert.x HTTP proxy (io.vertx:vertx-http-proxy) affects versions 5.0.0 through 5.0.12, 5.1.0

CVE-2026-102467 HIGH
8.7 Oct 15

Denial-of-service in Eclipse Vert.x allows unauthenticated remote attackers to exhaust server memory by sending compress

CVE-2026-103224 HIGH
8.2 Oct 15

Unbounded direct-memory allocation in Eclipse Vert.x's MySQL client (io.vertx:vertx-mysql-client) versions 4.0.0 through

CVE-2026-103223 HIGH
8.2 Oct 15

An unbounded-memory denial of service in the Eclipse Vert.x PostgreSQL client (io.vertx:vertx-pg-client) allows a malici

CVE-2026-102462 HIGH
8.2 Oct 15

Unbounded direct-memory allocation in Eclipse Vert.x's MSSQL client (io.vertx:vertx-mssql-client) lets a malicious, comp

CVE-2026-102464 HIGH
8.2 Oct 15

Unbounded inbound memory retention in the Eclipse Vert.x MQTT client (io.vertx:vertx-mqtt) allows a malicious or comprom

CVE-2026-102463 HIGH
8.2 Oct 15

Denial of service in Eclipse Vert.x's vertx-pg-client component allows an attacker controlling the PostgreSQL server or

CVE-2026-102466 HIGH
8.2 Oct 15

Denial of service in the Vert.x MySQL client (io.vertx:vertx-mysql-client) lets an attacker who controls or intercepts t

CVE-2026-102465 HIGH
8.2 Oct 15

Denial of service in the Eclipse Vert.x Redis client (io.vertx:vertx-redis-client) affects versions 4.0.0 through 4.5.34

CVE-2026-15076 HIGH
8.2 Jul 14

Cross-domain cookie injection in Eclipse Vert.x Web Client (WebClientSession) lets any server a victim application conta

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