Skip to main content

Apache bRPC EUVDEUVD-2026-107170

| CVE-2026-54426 HIGH
Uncontrolled Recursion (CWE-674)
2026-10-21 apache GHSA-m7v5-m3p2-6w26
View

Attack ChainAIDerived

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

  1. Access
    Position malicious/compromised Redis peer
  2. Delivery
    bRPC client connects and issues request
  3. Exploit
    Return deeply nested RESP array reply
  4. Execution
    Parser recurses unbounded, exhausts stack
  5. Impact
    Client 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.2% exploitation probability (EPSS)

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

Alert me

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

Apache bRPC 0 <1.18.0

Affected Packages

euvd apache_brpc fix: 1.18.0

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

Vendor (apache) PRIMARY HIGH
vuln.today AI 7.5 HIGH

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

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

Primary rating from Vendor (apache).

Lifecycle Timeline

2
Patch available
Oct 21, 2026 - 13:02 EUVD
CVE Published
Oct 21, 2026 - 11:32 cve.org
HIGH

DescriptionCVE.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:

  1. Upgrade Apache bRPC to 1.18.0.
  2. 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.

Executive ViewAI

Why It Matters

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.

Business Impact: Medium
Compensating Controls

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

EPSS Score
0.2%
Top 95% exploitable
Prevalence
Low
niche C++ RPC framework; Redis-client usage is a smaller subset
Data Quality
1 sources
Confidence: Low

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.2%
Patch available Yes
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.

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-2025-46817 HIGH POC
8.8 Oct 03

Authenticated Redis users with permission to run server-side Lua can trigger an integer overflow (CWE-190) in the bundle

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-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-2025-46819 HIGH POC
7.1 Oct 03

Authenticated Lua script execution in Redis 8.2.1 and earlier can be abused with a crafted long-string delimiter to trig

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-2025-46818 HIGH POC
7.3 Oct 03

CVE-2025-46818 is a sandbox-escape flaw in Redis's embedded Lua scripting engine (all versions up to and including 8.2.1

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

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