Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessVictim app connects to malicious Redis server
-
ExploitServer sends unterminated RESP line
-
ExecutionParser loops or buffers unbounded
-
ImpactJVM heap exhausted, service crashes
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 | Exploitation requires the Vert.x Redis client to process RESP responses from a server the attacker controls, has compromised, or can MITM - this is the essential precondition, since typical deployments connect to a trusted operator-owned Redis instance. Two concrete triggers are described: (1) a server that keeps streaming bytes on an EOL-terminated line (e.g. a simple string) without ever sending the terminating CRLF, causing unbounded buffer growth because there is no configurable limit on EOL-terminated lines; and (2) a server that sends a bulk string with a missing/corrupt CRLF trailer (e.g. |
| Impact | This is a moderate, availability-only denial-of-service issue (CVSS 5.9, CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H) - impact is confined to A:H, with no confidentiality or integrity exposure. The AV:N/PR:N/UI:N metrics look alarming in isolation, but the decisive limiting factor is not captured well by the vector: exploitation requires the Vert.x Redis client to receive malicious RESP bytes, i.e. the Redis server it connects to must be attacker-controlled, compromised, or the connection MITM'd. In normal deployments clients talk to a trusted, operator-owned Redis instance, which is why AC:H is justified and why real-world exploitability is narrower than a raw network-unauthenticated reading suggests. No EPSS score and no CISA KEV entry are present in the input, and there is no 'Publicly available (confirmed)' exploit flag; the GHSA advisory contains a conceptual proof-of-concept description rather than verified working exploit code. The vuln.today decision label is 'this_month', consistent with a real but non-emergency DoS that should be patched on a normal cadence rather than treated as active-exploitation firefighting. Net: a genuine bug worth remediating (unbounded heap growth can crash a service), but a measured priority - not a high-CVSS-but-illusory issue, yet also not an emergency. |
| Exploit ScenarioDerived | An attacker who controls or compromises the Redis server a Vert.x application connects to (or who can MITM that connection) returns a crafted RESP response - either a simple string whose bytes never terminate with CRLF, or a bulk string such as |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Nov 03, 2026
Denial of service in the Eclipse Vert.x Redis client (io.vertx:vertx-redis-client) 4.0.0 through 4.5.35 and 5.0.0 through 5.2.2 lets a malicious, compromised or man-in-the-middle Redis server exhaust the client's heap and crash the JVM. Two triggers are documented: a server that streams bytes on an EOL-terminated line (such as a simple string) without ever sending the terminating CRLF, which grows the read buffer without bounds because no configurable line limit exists, and a crafted RESP bulk string with a missing or corrupt CRLF trailer (for example $3\r\nfooXX) that drives the parser into an infinite loop, re-parsing the same buffer and re-emitting the same response to the consumer until memory is exhausted. The flaw is remotely reachable without authentication (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H, 5.9) and affects only availability - confidentiality and integrity are not impacted - with the significant precondition that the client must be talking to an attacker-controlled or compromised endpoint; a public proof-of-concept reference exists, but it is not verified as working exploit code, and there is no CISA KEV confirmation of active exploitation. Fixed versions are 4.5.36 on the 4.x branch and 5.2.3 on the 5.x branch.
RemediationAI
Upgrade io.vertx:vertx-redis-client to 4.5.36 on the 4.x branch or 5.2.3 on the 5.x branch; the advisory gives updating as the remediation and these are the exact fixed versions per branch. Verify the resolved dependency version in the build (for example with a dependency tree or bill-of-materials check) so transitive pulls of older vertx-redis-client releases are aligned, and consult GHSA-7f58-g87w-gx7p at https://github.com/vert-x3/vertx-redis-client/security/advisories/GHSA-7f58-g87w-gx7p and the Eclipse work item https://gitlab.eclipse.org/security/cve-assignment/-/work_items/522 for the vendor wording. Vulnerable releases expose no configuration option that bounds EOL-terminated lines or breaks the non-advancing parse loop, so there is no in-version toggle that removes the flaw. Because exploitation requires the client to process responses from a server the attacker controls or can intercept, reducing exposure before the upgrade means constraining where the client may connect: enforce TLS with server certificate validation and restrict egress to known, operator-owned Redis endpoints so a spoofed or hijacked server cannot feed the parser. The trade-off is that this narrows the attack surface rather than fixing the defect - it does not protect against a compromised legitimate Redis instance, and it leaves the unbounded allocation and infinite loop reachable once a trusted endpoint is subverted, so the patch remains the complete fix.
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
The Vert.x Redis client speaks RESP, the Redis serialization protocol, in which replies are either EOL-terminated lines (simple strings, errors and integers that end with CRLF) or length-prefixed blobs (bulk strings, where a $<len>\r\n header is followed by exactly len bytes and a trailing CRLF). The decoder in affected releases enforces no upper bound on the EOL-terminated form: as long as the peer keeps sending non-CRLF bytes, the accumulation buffer keeps growing, which is a classic uncontrolled-resource-consumption pattern rather than a memory-safety defect. The second defect is a parser state machine that does not guarantee forward progress - when a bulk string header promises N bytes but the trailer is not the expected CRLF, the same buffer window is re-parsed and the same decoded value is pushed to the application consumer on every iteration, so a consumer that queues responses grows the heap without any network amplification. No CWE identifier is recorded in the supplied data; the root cause class is resource exhaustion (unbounded allocation plus a non-advancing parse loop) inside the RESP decoder. Both behaviours occur in default configurations of vulnerable versions - no special client setting has to be enabled - but neither bypasses authentication nor crosses a trust boundary on its own; the exploitable precondition is that the attacker controls, has compromised, or can intercept the server side of the connection, which is why the assessed vector carries AC:H despite the trivially small attack payloads. Because the fix introduces a configurable limit for EOL-terminated lines, operators upgrading should review any newly exposed line-length configuration alongside the version bump.
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
AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H
Network-reachable and needing no client auth (AV:N/PR:N), but requires an attacker-controlled or compromised server response path (AC:H); only availability is impacted (C:N/I:N/A:H).
Primary rating from Vendor (eclipse).
CVSS VectorVendor: eclipse
DescriptionCVE.org
In Eclipse Vert.x versions [4.0.0, 4.5.35] or [5.0.0, 5.2.2], when a malicious server keeps sending bytes on an EOL-terminated line (not length-prefixed, for example a simple string [1]), we'll keep growing the buffer without bounds, eventually leading to an OOM. We need to have a configurable limit for EOL-terminated lines.
If a malicious server sends a specially crafted RESP response (for example a bulk string [2] with missing CRLF trailer), the parser enters an infinite loop where it keeps parsing the same buffer and pushing the same response to the caller, which may lead e.g. to an OOM if the consumer just buffers the responses. We must fix the parser to avoid this infinite looping.
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.
EUVD-2026-115881
GHSA-8x59-c7x3-46jj
NVD
CVE.org
Exploit-DB