Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCompromise Redis server or gain MITM position
-
DeliverySend RESP response with huge array length
-
ExploitClient pre-allocates unbounded heap buffer
-
ExecutionOutOfMemoryError crashes event loop thread
-
ImpactDenial 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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
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
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
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
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).
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 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
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.
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
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
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
Privilege escalation to root in the LiteSpeed User-End cPanel Plugin (versions 2.3 through before 2.4.5) lets attackers
UAF in Redis 8.2.1 via crafted Lua scripts by authenticated users. EPSS 12.4%. Patch available.
It was discovered, that redis, a persistent key-value database, due to a packaging issue, is prone to a (Debian-specific
Memory Corruption was discovered in the cmsgpack library in the Lua subsystem in Redis before 3.2.12, 4.x before 4.0.10,
Redis is an open source, in-memory database that persists on disk. Versions 8.2.1 and below allow an authenticated user
Redis before 2.8.21 and 3.x before 3.0.2 allows remote attackers to execute arbitrary Lua bytecode via the eval command.
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
Authenticated remote code execution in OpenC3 COSMOS (Ruby gem 'openc3' versions 5.1.0 through 7.2.1) lets any logged-in
Code injection in OneUptime monitoring via custom JS monitor using vm module. PoC and patch available.
RESP protocol command injection in Predis, the popular PHP client for Redis and Valkey, affects versions 3.0.0-RC1 throu
In applications using jfinal 4.9.08 and below, there is a deserialization vulnerability when using redis,may be vulnerab
An issue was found in Apache Airflow versions 1.10.10 and below. Rated critical severity (CVSS 9.8), this vulnerability
EUVD-2026-101927
GHSA-2fhm-447p-jh2m
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB