Skip to main content

Eclipse Vert.x CVE-2026-102465

| EUVDEUVD-2026-101927 HIGH
Allocation of Resources Without Limits or Throttling (CWE-770)
2026-10-15 eclipse GHSA-2fhm-447p-jh2m
8.2
CVSS 4.0 · Vendor: eclipse
View

Attack ChainAIDerived

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

  1. Access
    Compromise Redis server or gain MITM position
  2. Delivery
    Send RESP response with huge array length
  3. Exploit
    Client pre-allocates unbounded heap buffer
  4. Execution
    OutOfMemoryError crashes event loop thread
  5. Impact
    Denial of service across all shared verticles

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V2 - Validation and Business Logic Resource allocation limits
MITRE ATT&CK

1 technique across 1 tactic: Impact

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

The target application must use the Eclipse Vert.x Redis client (io.vertx:vertx-redis-client) in an affected version [4.0.0-4.5.34], [5.0.0-5.0.12], [5.1.0-5.1.9], or 5.2.0, and must connect to a Redis server that the attacker controls/has compromised, OR the attacker must occupy a man-in-the-middle position on the client-to-Redis network path. Exploitation is LIMITED by these prerequisites: a trusted, authenticated Redis instance on an isolated network with TLS-protected transport (preventing MITM) is not exploitable by an external unauthenticated party - this is why the vector carries AC:H despite PR:N. No end-user interaction is required.

Impact

This is a genuine but conditional denial-of-service issue, not a top-tier emergency. The CVSS 4.0 vector (AV:N/AC:H/AT:N/PR:N/UI:N) scores 8.2 largely because of VA:H (full availability loss of the event loop) combined with network reach and no authentication, but the AC:H flag is the decisive signal: exploitation requires the attacker to either control/compromise the Redis server the client connects to, or hold a man-in-the-middle position on that connection. That is a meaningful barrier against a properly segmented, TLS-protected Redis deployment. No EPSS score, no CISA KEV listing, and no public exploit were provided, so there is no evidence of active or widespread exploitation - exploitation status is 'no public exploit identified at time of analysis.' The impact is pure availability (VC:N/VI:N/VA:H - no confidentiality or integrity loss), and the OutOfMemoryError crashes the shared Vert.x event loop, amplifying blast radius to all connections and verticles on that loop. Net: a real priority for teams whose Vert.x apps connect to untrusted or externally-reachable Redis endpoints, but a low-urgency, patch-on-cadence issue for those with trusted, network-isolated Redis. One data conflict must be verified: the description and CPE concern the Vert.x Redis client, but the 'impacted component' field names io.vertx:vertx-mysql-client, which is inconsistent - confirm the affected Maven coordinate with the vendor advisory before remediation.

Exploit ScenarioDerived

A Vert.x application is configured to connect to a Redis endpoint that an attacker controls or can intercept (e.g., a compromised shared cache or an unencrypted Redis link an on-path attacker can tamper with). The attacker returns a crafted RESP response declaring an enormous array/push/attribute length; the client pre-allocates a correspondingly massive heap buffer, triggers an OutOfMemoryError, and crashes the event loop thread - taking down every connection and verticle sharing that loop. No public proof-of-concept was provided in the input.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
No patch listed yet 0.2% 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 the Eclipse Vert.x Redis client (io.vertx:vertx-redis-client) affects 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: the RESP parser trusts a server-declared array, push, or attribute length and pre-allocates that many elements without an upper bound, so a crafted response triggers a massive heap allocation that terminates the Vert.x event-loop thread with OutOfMemoryError and denies service to every connection and verticle sharing that loop. Exploitation is conditional rather than opportunistic - a remote, unauthenticated attacker qualifies only if they control or have compromised the Redis server the client talks to, or if they can occupy a man-in-the-middle position on the client-to-Redis path; neither user interaction nor prior client authentication is required, which is why the assessed vector is AV:N/PR:N but AC:H, and impact is availability-only (no confidentiality or integrity loss). No public exploit code or confirmed active exploitation was identified at time of analysis, and this is a genuine but conditional DoS issue rather than a top-tier emergency.

RemediationAI

No fixed version was included in the available intelligence, so treat the referenced advisory (https://github.com/vert-x3/vertx-redis-client/security/advisories/GHSA-4wf9-p5hg-98w5) as the authoritative source for the patched release and upgrade io.vertx:vertx-redis-client to the first version at or above the fix as soon as it is published; until then, compensating controls are the primary defense because the flaw is triggered by server-supplied data and cannot be fully fixed by client-side configuration. First, enforce TLS with strict server certificate validation (and mutual TLS where the server supports it) on every Redis connection so an on-path attacker cannot inject the crafted RESP frame; the trade-off is certificate/CA lifecycle management and possible breakage of clients pinned to self-signed or hostname-mismatched certs. Second, restrict network reachability to Redis - firewall or security-group rules limiting port 6379/6380 to known backend hosts, private subnets, or a service mesh - and never point an affected client at an untrusted, shared, or internet-exposed Redis endpoint, since a hostile server needs no MITM position at all; the trade-off is reduced flexibility for cross-zone or multi-tenant designs. Third, contain the blast radius by running availability-critical verticles in separate JVM processes or Vert.x instances with distinct event loops, so an OutOfMemoryError on one loop cannot kill shared connections, and monitor logs and JVM metrics for OutOfMemoryError and abrupt event-loop thread death to detect exploitation attempts; heap-size tuning alone is not an effective mitigation since the allocation is intentionally unbounded. As a last resort for workloads that must talk to an untrusted Redis, place a protocol-aware proxy or shim in front of the connection that rejects or truncates RESP aggregate headers declaring implausibly large lengths, accepting the added latency and operational complexity. No public exploit code has been identified, so prioritization should follow exposure: internet-reachable or third-party Redis backends first, isolated internal instances last.

Affected VersionsENISA

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

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

RESP (REdis Serialization Protocol) encodes aggregate types - arrays, RESP3 pushes, and attributes - with a leading count, after which the client is expected to read that many elements. The Vert.x Redis client's parser uses the declared count to size its internal collection up front instead of growing it incrementally or validating the count against a sane maximum, so a malicious or intercepted server response declaring an enormous length causes the JVM to attempt an allocation it cannot satisfy. The root-cause class is uncontrolled resource consumption / allocation without limits (consistent with CWE-770 and CWE-400, although no CWE was assigned in the source data). The impact is amplified by Vert.x's threading model: event-loop threads are shared across many connections and verticles, so an OutOfMemoryError on one loop cascades into an application-wide outage for everything pinned to that loop. The meta-data supplied with this CVE is internally inconsistent - the description names io.vertx:vertx-mysql-client as the impacted component while the parser described, the tags, the referenced advisory (GHSA-4wf9-p5hg-98w5), and the affected CPE (cpe:2.3:a:eclipse_foundation:eclipse_vert.x) all point to the Redis client, so the vertx-mysql-client label should be treated as suspect and inventory should be validated against the actual vertx-redis-client artifact.

Know when Redis 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.2 HIGH
CVSS:4.0/AV:N/AC:H/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
vuln.today AI 5.9 MEDIUM

Network-reachable RESP response but requires a malicious/compromised server or MITM position, so AC:H; no auth needed (PR:N); availability-only impact (A:H) with no scope change (S:U).

3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H
4.0 AV:N/AC:H/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
High
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 Vert.x Redis client RESP parser pre-allocates arrays to a length declared by the server without enforcing an upper bound. A malicious or compromised Redis server, or an attacker in a man-in-the-middle position, can send a crafted RESP response declaring an extremely large array, push, or attribute length, causing the client to attempt a massive heap allocation. The resulting OutOfMemoryError crashes the Vert.x event loop thread, denying service to all connections and verticles sharing that loop.

The impacted component is io.vertx:vertx-mysql-client.

Technical POC Analysis

Bug class is denial of service through memory exhaustion from an unbounded length field.

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

Eclipse Vert.x Redis 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 contain a denial-of-service flaw that allows a malicious or compromised Redis server, or an attacker in a man-in-the-middle position, to exhaust heap memory and terminate the event-loop thread, disrupting all applications sharing that loop. Organizations using the affected io.vertx:vertx-redis-client releases in production face potential service outages, particularly where Redis traffic crosses untrusted networks or connects to third-party Redis instances. No vendor patch is currently available, so leadership should prioritize network controls, monitoring, and migration planning until a fix is released.

Business Impact: Medium
Compensating Controls

No vendor-released patch identified at time of analysis; interim mitigations include restricting Redis client connections to trusted, hardened Redis servers, enforcing TLS with certificate validation to prevent man-in-the-middle attacks, segmenting and firewalling client-to-Redis traffic, requiring Redis authentication, monitoring for OOM and event-loop stalls, and applying JVM heap limits or isolating affected workloads to limit shared event-loop impact.

Threat Intelligence Overview

EPSS Score
0.2%
Top 90% exploitable
Prevalence
Medium
popular JVM reactive toolkit; Redis client used by a subset of Vert.x apps
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GitHub VulDB

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.2%
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
No
Human Impact
Medium
Technical Impact
Partial

Priority Score

41
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +41
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.

More in Redis

View all
CVE-2026-48172 CRITICAL POC
10.0 May 21

Privilege escalation to root in the LiteSpeed User-End cPanel Plugin (versions 2.3 through before 2.4.5) lets attackers

CVE-2025-49844 CRITICAL POC
9.9 Oct 03

UAF in Redis 8.2.1 via crafted Lua scripts by authenticated users. EPSS 12.4%. Patch available.

CVE-2022-0543 CRITICAL POC
10.0 Feb 18

It was discovered, that redis, a persistent key-value database, due to a packaging issue, is prone to a (Debian-specific

CVE-2018-11218 CRITICAL POC
9.8 Jun 17

Memory Corruption was discovered in the cmsgpack library in the Lua subsystem in Redis before 3.2.12, 4.x before 4.0.10,

CVE-2025-46817 HIGH POC
7.0 Oct 03

Redis is an open source, in-memory database that persists on disk. Versions 8.2.1 and below allow an authenticated user

CVE-2015-4335 CRITICAL POC
10.0 Jun 09

Redis before 2.8.21 and 3.x before 3.0.2 allows remote attackers to execute arbitrary Lua bytecode via the eval command.

CVE-2016-8339 CRITICAL POC
9.8 Oct 28

A buffer overflow in Redis 3.2.x prior to 3.2.4 causes arbitrary code execution when a crafted command is sent. Rated cr

CVE-2026-77602 CRITICAL POC
9.9 Sep 23

Authenticated remote code execution in OpenC3 COSMOS (Ruby gem 'openc3' versions 5.1.0 through 7.2.1) lets any logged-in

CVE-2026-27574 CRITICAL POC
9.9 Feb 21

Code injection in OneUptime monitoring via custom JS monitor using vm module. PoC and patch available.

CVE-2026-84372 CRITICAL POC
9.8 Sep 01

RESP protocol command injection in Predis, the popular PHP client for Redis and Valkey, affects versions 3.0.0-RC1 throu

CVE-2021-31649 CRITICAL POC
9.8 Jun 24

In applications using jfinal 4.9.08 and below, there is a deserialization vulnerability when using redis,may be vulnerab

CVE-2020-11981 CRITICAL POC
9.8 Jul 17

An issue was found in Apache Airflow versions 1.10.10 and below. Rated critical severity (CVSS 9.8), this vulnerability

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