Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach bRPC server with Redis service
-
DeliverySend empty RESP array header
-
ExploitFollow with bulk string
-
ExecutionTrigger out-of-bounds write on empty vector
-
ImpactCrash parser process (DoS)
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, write limits
MITRE ATT&CK
2 techniques across 2 tactics: Execution, Privilege Escalation The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | The bRPC server must have ServerOptions.redis_service enabled and must accept Redis protocol traffic from untrusted clients - this is an opt-in, non-default deployment mode. The out-of-bounds write is additionally gated by a build/runtime configuration in which fatal CHECK logs do not abort the process immediately; in default configurations the CHECK would abort before the indexed write, limiting the outcome. The vulnerable code path is reached during RESP parsing before command handling or authentication, so no credentials or user interaction are required, but the two configuration prerequisites (Redis service enabled; non-aborting fatal logs) are the primary real-world limiters on exploitation. |
| Impact | No CVSS score is provided by NVD or the vendor, so severity is self-assessed from the description (see assessed vectors). The flaw is a CWE-787 out-of-bounds write in bRPC's Redis RESP command parser reachable pre-authentication, which maps to a network-reachable, unauthenticated condition - a genuinely attractive profile. However, the practical impact described is a process crash (denial of service), not demonstrated code execution: the stray write targets _args[0] of a zero-length vector, and the vendor frames the outcome as 'crashing the process.' No EPSS score, no CISA KEV listing, and no public POC are present in the input, so there is no evidence of active or probable exploitation - this is currently a theoretical/vendor-reported issue rather than a confirmed in-the-wild priority. Crucially, exploitation is gated by a non-default server configuration (ServerOptions.redis_service enabled and accepting untrusted Redis traffic) AND by a build/log configuration where fatal CHECK logs do not abort immediately; the vendor notes that in default builds the CHECK would normally abort before the OOB write. This conditional dependency substantially narrows real-world risk despite the unauthenticated network reachability. Verify with the vendor whether any shipping configuration leaves the fatal-log abort disabled, since that determines whether the impact is a clean crash versus a potential memory-corruption primitive. |
| Exploit ScenarioDerived | An attacker who can reach a bRPC server that has the Redis service enabled opens a TCP connection and sends a RESP command header declaring an empty array (zero elements) followed by a bulk string. The parser resizes the argument vector to zero but continues parsing the bulk string, writing to _args[0] out of bounds and crashing the service. No public exploit code is identified at time of analysis, and the attack requires no authentication because parsing occurs before command handling or auth. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 21, 2026
Out-of-bounds write in Apache bRPC's Redis RESP parser allows remote unauthenticated attackers who can reach a bRPC server with ServerOptions.redis_service enabled to send an empty RESP array header followed by a bulk string, causing a parser memory corruption and process crash. The independent assessment rates it CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, with exploitation limited by the opt-in Redis service and by non-default fatal-log behavior that must fail to abort before the indexed write. No CISA KEV entry or public exploit code was identified at time of analysis, and Apache bRPC 1.18.0 contains the fix.
RemediationAI
Upgrade Apache bRPC to 1.18.0 or later, which contains the fix; the upstream change is PR #3354 at https://github.com/apache/brpc/pull/3354. If immediate upgrade is not possible, disable ServerOptions.redis_service or restrict Redis protocol traffic to trusted clients using network ACLs or firewalls, with the trade-off that Redis-compatible access is lost or limited. Retain the default fatal-log abort behavior so malformed parser states terminate the process before the indexed out-of-bounds write, with the trade-off of possible service restarts on parse anomalies. Review the vendor advisory at https://lists.apache.org/thread/2pf15ojj0vr7rtx95677kgtl1mx3gdgb for patch guidance.
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 flaw is in RedisCommandParser::ConsumeImpl, which validates RESP array counts but accepts a zero-length array. It resizes the command argument vector to zero elements and continues parsing; when a following bulk string is parsed, the only index guard is a CHECK, and if fatal logs do not abort immediately, execution can continue and write to _args[0] on an empty vector. This is a CWE-787 out-of-bounds write in the Redis protocol parsing layer, reached before Redis command handling or authentication. The supplied CPE cpe:2.3:a:apache_software_foundation:apache_brpc:*:*:*:*:*:*:*:* identifies Apache bRPC but does not encode a version bound; the fix note specifies 1.18.0 as the patched release.
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
Reachable over the network before auth (AV:N/PR:N/UI:N); parsing path is straightforward once Redis service is enabled (AC:L); impact is a process crash, so availability-only (A:H, C:N/I:N).
Primary rating from Vendor (apache).
Lifecycle Timeline
2DescriptionCVE.org
The Redis server command parser in Apache bRPC accepts an empty RESP array as a command header. A remote unauthenticated attacker who can reach a bRPC server with Redis service enabled can send an empty array header followed by a bulk string, causing an out-of-bounds write in the parser and crashing the process.
Root Cause: RedisCommandParser::ConsumeImpl rejected negative RESP array counts but accepted zero. It resized the command argument vector to zero elements and continued parsing. When a following bulk string was parsed, the only index guard was a CHECK. In configurations where fatal logs do not abort immediately, execution could continue and write to _args[0] even though the vector was empty.
Affected Scenarios: Deployments that enable ServerOptions.redis_service and accept Redis protocol traffic from untrusted clients. The issue is reached during parsing before command handling or authentication.
How to Fix:
- Upgrade bRPC to version 1.18.0, which fixes this issue.
- Apply this patch: https://github.com/apache/brpc/pull/3354
Note: The fix rejects empty RESP arrays as invalid Redis commands and replaces the internal index CHECK with an explicit parse error so malformed command streams cannot fall through to an indexed vector write.
Articles & Coverage 1
Executive ViewAI
Apache bRPC deployments that enable the optional Redis service face a remote, unauthenticated denial-of-service risk from CVE-2026-56388 that can crash the server process and interrupt dependent applications. Leadership should care because availability of business services using bRPC Redis endpoints could be disrupted, although exposure is limited to opt-in configurations and no public exploit identified at time of analysis. A vendor fix is available in Apache bRPC 1.18.0, so upgrade should be prioritized.
Apply vendor patch.
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
A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.
Memory corruption occurs when a program writes data beyond the boundaries of allocated memory regions or accesses memory in unintended ways, violating the integrity of the process's address space.
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-107174
GHSA-57w6-4hvp-7m4g
CVE.org
EPSS
Exploit-DB