Skip to main content

redis-parser CVE-2026-93435

| EUVDEUVD-2026-82533 HIGH
Uncontrolled Recursion (CWE-674)
2026-09-17 disclosure@vulncheck.com GHSA-gf2v-78w3-qhcv
8.7
CVSS 4.0 · Vendor: vulncheck
View

Attack ChainAIDerived

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

  1. Access
    Induce client to connect to malicious Redis endpoint
  2. Delivery
    Return RESP stream with repeated nested array headers
  3. Exploit
    Trigger unbounded recursion in parser.js
  4. Execution
    Exhaust V8 call stack
  5. Impact
    Uncaught RangeError terminates Node.js process

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Recursion depth limits
Exploitation Conditions

Exploitation requires that the vulnerable Node.js application using redis-parser (≤3.0.0, including via node_redis/ioredis) connect to a Redis endpoint the attacker controls or can impersonate, then receive a crafted RESP reply built from repeated/nested array headers. This is a client-side parser crash, not a listening-service flaw: the limiting factor is that the victim must be induced to talk to a malicious or compromised Redis server (rogue endpoint, man-in-the-middle on an unencrypted connection, multi-tenant/untrusted Redis, or SSRF-style connection redirection). No authentication or user interaction is needed on the parsing path once the connection exists, and default configurations are affected because the recursion is unbounded regardless of settings; impact is limited to availability (process crash) with no confidentiality or integrity effect.

Impact

The single quantified signal is the vendor CVSS 4.0 base score of 8.7 (AV:N/AC:L/AT:N/PR:N/UI:N with VA:H and confidentiality/integrity at none), which correctly frames this as a pure availability/denial-of-service issue - no data exposure or code execution. No EPSS score, no CISA KEV listing, and no weaponized proof-of-concept are present in the input, so by the precision rules this is 'no public exploit identified at time of analysis'; the VulnCheck advisory is a technical writeup, not exploit code. The most important nuance that the raw score obscures is directionality: the attacker must operate a MALICIOUS or compromised Redis endpoint that the victim Node.js process connects to - this is a client-side parser crash, not a flaw in a network service listening for attackers. That inverts the usual 'internet-exposed listener' threat model and materially lowers real-world reachability, because most Node apps connect to trusted, self-hosted Redis rather than attacker-chosen endpoints. Where it does matter is untrusted/multi-tenant Redis, SSRF-style redirection to a rogue endpoint, or supply-chain scenarios. Net: a legitimately impactful availability bug given redis-parser's ubiquity in the Node ecosystem, but real-world priority is gated by whether the deployment can be induced to connect to an attacker-controlled Redis server. No conflicting signals, but note EPSS/KEV/POC data is simply absent rather than negative.

Exploit ScenarioDerived

An attacker who controls or can impersonate a Redis endpoint (rogue server, MITM, or SSRF-redirected connection) returns a crafted RESP byte stream containing many repeated nested array headers. When the victim's Node.js client parses the reply, redis-parser recurses without bound, exhausts the V8 call stack, and throws an uncaught RangeError that terminates the process without firing the client's error callbacks. No authenticated proof-of-concept exploit is published; VulnCheck provides a technical advisory only.

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 – Sep 17, 2026

Crafted RESP replies from a malicious, compromised, or impersonated Redis endpoint crash Node.js processes that use redis-parser through 3.0.0, including applications built on node-redis and ioredis, because repeated nested array headers drive unbounded recursion that exhausts the V8 call stack and raises an uncaught RangeError. The flaw is a client-side parser denial of service: it is unauthenticated on the parsing path (CVSS 4.0 vector PR:N/UI:N, CVSS 3.1 assessment AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H) and affects default configurations, since recursion depth is not bounded by any setting. Impact is limited to availability - the process terminates without invoking error-handling callbacks - with no confidentiality or integrity effect; the vendor score of 8.7 reflects that high availability impact. No public exploit identified at time of analysis.

RemediationAI

No vendor-released patch identified at time of analysis for redis-parser through 3.0.0, so remediation must combine compensating controls until an upstream fix lands; track the NodeRedis/node-redis-parser repository and ioredis issue #2108 as well as the VulnCheck advisory (https://www.vulncheck.com/advisories/redis-parser-through-3.0.0-denial-of-service-via-unbounded-recursion) for a patched release. The most effective control is to eliminate the attacker-controlled endpoint scenario: allowlist the exact Redis hosts the application connects to (blocking SSRF-style redirection to rogue endpoints), and enforce TLS with certificate validation via rediss:// so an on-path attacker cannot impersonate the server - the trade-offs are added handshake latency and certificate lifecycle management. Treat any untrusted or multi-tenant Redis (including third-party or shared instances) as hostile: do not connect to it, or if that is unavoidable, isolate the connection in a separate worker process or child process so a stack-overflow RangeError kills only the isolated process rather than the main application. Where API compatibility permits, migrate to a maintained client that bounds parser recursion, such as a current @redis/client release, accepting the migration and dependency-churn cost. Additionally, wrap Redis clients with process-level 'uncaughtException' monitoring and restart supervision to reduce downtime, though this is a detection/liveness measure, not a fix, since the crash bypasses the library's error callbacks. Because the security assessment finds no confidentiality or integrity impact, these availability-focused controls are proportionate; there is no input-filtering fix available on the client side, as the recursion depth is unbounded regardless of configuration.

Affected VersionsENISA

redis-parser 0 ≤3.0.0

Affected Packages

euvd redis_parser 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 affected technology is the RESP (REdis Serialization Protocol) parser shipped as the npm package redis-parser, a client-side library that decodes byte streams received from a Redis server. The root cause is CWE-674 (uncontrolled recursion): when the parser encounters an array header (a '*' followed by a count), it recursively parses the contained elements, and the vulnerable code paths at lib/parser.js lines 204-213 and 291-306 place no ceiling on that recursion depth. An attacker-controlled endpoint can therefore reply with a stream of repeated or deeply nested array headers, each frame adding a stack frame until the V8 engine's call-stack limit is reached; the resulting RangeError is thrown synchronously inside the parser and is not routed to the library's error callbacks, so it becomes an uncaught exception that terminates the Node.js process. Because the parser is the receiving side of an outbound Redis connection, the trust boundary is inverted relative to a server-side parser: the untrusted input is the server's reply rather than client traffic. The parser is consumed by popular Node.js Redis clients such as node-redis (NodeRedis/node-redis-parser) and ioredis, so any application using those clients to reach an endpoint the attacker controls or can impersonate inherits the crash. All versions of redis-parser from 0 through 3.0.0 are affected per the EUVD listing (redis-parser 0 ≤ 3.0.0); no CPE identifiers were supplied in the provided intelligence.

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 (vulncheck) 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

Network-delivered RESP stream with no auth or interaction once connected, unbounded recursion reliably crashes the process, so A:H with C/I:N; malicious-endpoint requirement is a reachability caveat, not an AC increase.

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
SUSE 7.5 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H

Primary rating from Vendor (vulncheck).

CVSS VectorVendor: vulncheck

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

redis-parser through 3.0.0 contains a denial of service vulnerability in the RESP protocol parser that allows malicious Redis endpoints to crash the client process through unbounded recursion on nested arrays. Attackers can send crafted RESP byte streams with repeated array headers that exhaust the V8 call stack, causing an uncaught RangeError that terminates the Node.js process without triggering error handling callbacks.

Executive ViewAI

Why It Matters

A high-severity flaw in the widely used redis-parser library (versions through 3.0.0), which underpins Node.js Redis clients such as node-redis and ioredis, allows any party able to serve or impersonate a Redis endpoint to crash dependent application processes without credentials. Because the issue is unauthenticated, present in default configurations, and reachable by any Node.js service that connects to an untrusted or compromised Redis instance, the exposure is broad across engineering teams rather than confined to a single product. Leadership should care because the practical outcome is unplanned outages and service restarts in customer-facing and internal applications, with no data theft or tampering risk indicated.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations: restrict Node.js clients to trusted, internal Redis endpoints only (network segmentation, egress filtering, firewall allow-lists); require Redis authentication and TLS with certificate validation so endpoints cannot be impersonated; avoid connecting to public or third-party Redis services; run affected processes under a supervisor (systemd, PM2, Kubernetes) with automatic restart, resource limits, and crash-loop alerting; and, where feasible, front untrusted Redis connections with a proxy or parser with bounded recursion depth.

Threat Intelligence Overview

EPSS Score
0.4%
Top 62% exploitable
Prevalence
High
core RESP parser underpinning node_redis and ioredis across the Node.js ecosystem
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment Vendor GitHub

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.

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

Vendor StatusVendor

SUSE

Severity: Important
Product Status
SUSE Linux Enterprise Desktop 15 SP7 Not-Affected
SUSE Linux Enterprise High Performance Computing 12 Not-Affected
SUSE Linux Enterprise Micro 5.3 Affected
SUSE Linux Enterprise Micro 5.3 Affected
SUSE Linux Enterprise Micro 5.4 Affected

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