Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessPosition malicious/compromised Redis peer
-
DeliverybRPC client connects and issues request
-
ExploitReturn deeply nested RESP array reply
-
ExecutionParser recurses unbounded, exhausts stack
-
ImpactClient process crashes (DoS)
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Recursion depth limits
|
| Exploitation Conditions | Requires the target application to use Apache bRPC as a Redis client with ChannelOptions.protocol="redis" AND to receive replies from an untrusted, compromised, or faulty Redis server peer - the attacker must control or tamper with the Redis server side of the connection, not merely reach the client over the network. Exploitation is limited to this reverse trust scenario: deployments that connect only to trusted, operator-controlled Redis instances are effectively not exposed. No special client-side configuration is needed beyond use of the Redis protocol, and no authentication or user interaction on the client is required to trigger the crash once a malicious reply is delivered. |
| Impact | No CVSS vector, EPSS score, KEV listing, or POC is provided in the input, so quantitative exploitation signals are entirely absent and the assessment rests on the description and CWE-674 (uncontrolled recursion). This is a denial-of-service-only flaw: a deeply nested RESP array reply exhausts the stack via unbounded recursion, crashing the bRPC Redis client process. Critically, the threat actor is the Redis *server peer*, not an arbitrary internet attacker - exploitation requires the vulnerable bRPC client to connect to a malicious, compromised, or faulty Redis server (or an attacker positioned to tamper with server replies). This inverts the usual client-server trust model and substantially narrows real-world risk: deployments pointing bRPC only at trusted, controlled Redis instances are largely insulated. There is no confidentiality or integrity impact and no code execution - impact is limited to availability (process crash). My independent read is that this is a genuine but moderate-priority availability bug, not a high-urgency RCE; it warrants patching on normal cadence, prioritized where bRPC clients talk to untrusted or multi-tenant Redis endpoints. Authentication requirements cannot be confirmed because no CVSS vector is supplied. |
| Exploit ScenarioDerived | An application using Apache bRPC (< 1.18.0) as a Redis client with ChannelOptions.protocol="redis" connects to a Redis endpoint that an attacker controls or has compromised. The malicious server returns a RESP reply containing a deeply nested array, and the client's reply parser recurses once per nesting level with no depth limit, exhausting the stack and crashing the client process. No public exploit was identified at time of analysis. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 21, 2026
Remote denial of service in Apache bRPC (versions before 1.18.0) allows a malicious, compromised, or faulty Redis server peer to crash a bRPC Redis client process by returning a deeply nested RESP array reply, driving the reply parser into unbounded recursion until the stack is exhausted. Applications that use bRPC as a Redis client with ChannelOptions.protocol="redis" and that accept replies from an untrusted or tampered-with Redis peer are affected, while deployments that only ever connect to trusted, operator-controlled Redis instances are effectively not exposed. No authentication or user interaction on the client is required to trigger the crash once a crafted reply is delivered; no public exploit code, EPSS score, or CISA KEV listing was identified at time of analysis.
RemediationAI
Vendor-released patch: upgrade Apache bRPC to 1.18.0, which enforces the new redis_max_reply_depth limit (default 128) and rejects over-deep replies instead of recursing into them; if a source build must be pinned, apply the upstream fix from https://github.com/apache/brpc/pull/3344 and confirm the advisory at https://lists.apache.org/thread/2pf15ojj0vr7rtx95677kgtl1mx3gdgb for the released artifact. Where an immediate upgrade is not possible, the decisive compensating control is to eliminate the reverse-trust exposure: only point bRPC Redis channels at operator-controlled, network-isolated Redis instances that an attacker cannot impersonate or modify (for example via mTLS, dedicated segmented networks, or Redis ACLs plus TLS), and drop ChannelOptions.protocol="redis" entirely on channels that do not need the Redis protocol - the trade-off is that this removes functionality for any legitimate use of bRPC as a Redis client and depends on the network segmentation actually holding. Fronting the Redis peer with a proxy that caps RESP array nesting depth can also blunt the attack, at the cost of an extra hop and the risk of rejecting legitimately nested replies. Setting redis_max_reply_depth to a lower value than the 128 default narrows the window further but must be tuned against the deepest legitimate replies the application consumes, since anything deeper will be rejected after the fix is applied.
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
Apache bRPC is a multi-protocol RPC framework that can act as a Redis client by setting ChannelOptions.protocol="redis", speaking the Redis Serialization Protocol (RESP). RESP encodes aggregate types with a length prefix, and nested arrays are represented as arrays containing further arrays (for example '*1\r\n*1\r\n*1\r\n...'), so a parser implemented as a recursive-descent routine consumes one stack frame per nesting level. The bRPC reply parser recursed once for each nested array level without enforcing any depth limit, which is the classic CWE-674 (Uncontrolled Recursion) pattern: a peer on the far end of the connection can supply an arbitrarily deep reply and exhaust the client thread's stack, terminating the process (assessed CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H - availability-only impact, no confidentiality or integrity loss). The trust boundary runs in the reverse of the usual direction: the attacker is the server side of the connection, so only clients that can be induced to talk to an attacker-controlled or compromised Redis peer are in scope. The upstream fix introduces a configurable reply depth limit, redis_max_reply_depth, defaulting to 128, and rejects any reply that exceeds it.
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
Remote over the network (AV:N) with a simple crafted reply (AC:L); the malicious server peer needs no privileges on the client (PR:N); impact is availability-only crash (C:N/I:N/A:H).
Primary rating from Vendor (apache).
Lifecycle Timeline
2DescriptionCVE.org
Uncontrolled recursion in the Redis reply parser in Apache bRPC < 1.18.0 allows a remote Redis server peer to crash a bRPC Redis client process by returning a deeply nested RESP array reply. The parser recursed once for each nested array level without enforcing a depth limit. The fix adds a configurable Redis reply depth limit with default value 128 and rejects replies exceeding that limit.
Affected Scenarios: Applications using bRPC as a Redis client with ChannelOptions.protocol="redis" and receiving replies from an untrusted or faulty Redis server peer.
How to Fix:
- Upgrade Apache bRPC to 1.18.0.
- Apply the patch from PR https://github.com/apache/brpc/pull/3344 .
Note: After applying the fix, Redis replies with array nesting deeper than redis_max_reply_depth are rejected.
Articles & Coverage 1
Executive ViewAI
A defect in the Apache bRPC Redis client, present in all releases before 1.18.0, allows a malicious or compromised Redis server to crash the client process with a single crafted reply, taking down any service built on it. Exposure is concentrated in teams whose bRPC-based applications connect to Redis endpoints they do not fully control - shared, third-party, or externally reachable instances - where an attacker needs only to serve a malformed response to cause an outage. Because the failure mode is a stack-exhaustion crash inside the client library, the leadership concern is service availability and the trust boundary maintained with Redis infrastructure, not data exposure.
No vendor-released patch identified at time of analysis. Interim mitigations: restrict bRPC Redis clients to operator-controlled Redis instances only; enforce TLS with mutual authentication and Redis ACLs so replies cannot originate from an untrusted peer; front untrusted Redis connections with a protocol-aware proxy that enforces a maximum RESP array nesting depth; disable ChannelOptions.protocol="redis" wherever the peer is not fully trusted; run affected services under supervision with automatic restart and crash-loop alerting; segment network egress to an allowlist of known Redis hosts.
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
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.
Authenticated Redis users with permission to run server-side Lua can trigger an integer overflow (CWE-190) in the bundle
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 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 Lua script execution in Redis 8.2.1 and earlier can be abused with a crafted long-string delimiter to trig
Authenticated remote code execution in OpenC3 COSMOS (Ruby gem 'openc3' versions 5.1.0 through 7.2.1) lets any logged-in
CVE-2025-46818 is a sandbox-escape flaw in Redis's embedded Lua scripting engine (all versions up to and including 8.2.1
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
EUVD-2026-107170
GHSA-m7v5-m3p2-6w26
CVE.org
EPSS
Exploit-DB