Skip to main content

Vert.x Redis Client CVE-2026-118488

| EUVDEUVD-2026-115881 MEDIUM
Allocation of Resources Without Limits or Throttling (CWE-770)
2026-11-03 emo@eclipse.org GHSA-8x59-c7x3-46jj
5.9
CVSS 3.1 · Vendor: eclipse
View

Attack ChainAIDerived

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

  1. Access
    Victim app connects to malicious Redis server
  2. Exploit
    Server sends unterminated RESP line
  3. Execution
    Parser loops or buffers unbounded
  4. Impact
    JVM 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. $3\r\nfooXX), forcing the parser into an infinite loop that repeatedly re-parses and re-emits the same response. Both affect default configurations of vulnerable versions (no special client setting is needed), but no authentication is bypassed and only availability is affected; the limiting factor is the need for a malicious or compromised server/connection path. Fixed in 5.2.3 (5.x) and 4.5.36 (4.x); updating is the remediation given by the advisory.

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 $3\r\nfooXX with a corrupted CRLF trailer. The client either grows its read buffer without bound or enters an infinite parse loop re-emitting the same response, exhausting the JVM heap and crashing the application. The advisory documents a conceptual proof-of-concept, but a public working exploit is not confirmed in the available data.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
No patch listed yet

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

Alert me

AnalysisAIv1 – 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

Eclipse Vert.x 4.0.0 ≤4.5.35
Eclipse Vert.x 5.0.0 ≤5.2.2

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 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

Vendor (eclipse) PRIMARY 5.9 MEDIUM
AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H
vuln.today AI 5.9 MEDIUM

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).

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
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
None
Integrity
None
Availability
High

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

Prevalence
Medium
popular JVM reactive Redis client library, moderate enterprise footprint
Social Media
1
Sightings
Data Quality
4 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 MEDIUM
CISA KEV No
Public POC No
EPSS N/A
Patch available No
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.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· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
No
Human Impact· derived
Medium

Priority Score

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

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