Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach exposed bRPC Redis endpoint
-
DeliverySend long inline input lacking CRLF
-
ExploitForce full-buffer allocation and copy
-
ExecutionAmplify memory and CPU consumption
-
ImpactDegrade or deny service
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 | Requires an Apache bRPC server with the Redis protocol handler enabled (non-default protocol selection) and that endpoint reachable by untrusted/attacker-controlled clients. The specific trigger is a long inline (non-RESP-bulk) command sent without a terminating CRLF, exploiting that the pre-fix redis_max_allocation_size limit was enforced on RESP bulk strings/arrays but NOT on the inline command path before allocation. Limiting factors: exploitation is impossible if the Redis protocol is not enabled or the service is not exposed to untrusted networks, and impact is confined to resource exhaustion (DoS) with no code execution or data disclosure; upgrading to bRPC 1.18.0 (or applying PR #3363) applies the allocation limit and CRLF scan to inline lines, rejecting oversized inputs. |
| Impact | This is a CWE-770 uncontrolled resource consumption (memory/CPU) denial-of-service flaw in Apache bRPC's Redis-protocol inline command parser. No CVSS score or vector is provided in the input, and there is no EPSS score, no CISA KEV listing, and no public exploit identified at time of analysis - so the only severity signal is the description itself, which characterizes impact as 'potentially causing denial of service' (availability-only, no confidentiality or integrity loss). Based on the description, the attack vector is network-facing against a bRPC service with the Redis protocol enabled, and no authentication or user interaction appears necessary, but note the precision caveat: no vendor CVSS vector is supplied, so authentication requirements are not confirmed from available data and are only inferred from the 'reachable by untrusted clients' language. Real-world priority should be treated as MODERATE-and-conditional rather than critical: the impact ceiling is DoS only (not RCE/data exposure), exploitation is gated on the non-default condition of exposing a Redis-protocol bRPC endpoint to untrusted networks, and there is no evidence of exploitation or weaponization. For most deployments this is a patch-in-normal-cycle issue; it rises in priority only where a bRPC Redis endpoint is directly internet- or tenant-exposed. Key missing data: no official CVSS, no EPSS, no POC/KEV status - all of which limits confidence in any quantitative risk ranking. |
| Exploit ScenarioDerived | An attacker who can reach a bRPC server running the Redis protocol opens a connection and sends a very long inline command line while deliberately omitting the terminating CRLF. The parser repeatedly allocates and copies the entire growing connection buffer before a command boundary is found, driving up memory usage and CPU copy overhead and degrading or denying service. No public exploit code has been identified at time of analysis, and the attack requires only a reachable Redis-protocol endpoint. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 21, 2026
Memory and CPU exhaustion in Apache bRPC's Redis-protocol handler lets remote unauthenticated clients inflate server resource usage by sending long inline commands that never terminate with CRLF. The parser sizes its allocation from the current connection buffer and copies the whole buffer before it has located the inline command boundary, because the redis_max_allocation_size guard was enforced only for RESP bulk strings and arrays, not for the inline path. Every bRPC release before 1.18.0 is affected when the optional Redis protocol is enabled and reachable by untrusted clients; impact is limited to denial of service (availability only), with no code execution or data disclosure reported. No public exploit code was identified at time of analysis and there is no confirmed active exploitation (CISA KEV), though the assessed vector CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L reflects a low-complexity, unauthenticated network trigger.
RemediationAI
Vendor-released patch: Apache bRPC 1.18.0. Upgrade bRPC to 1.18.0, or backport the upstream fix from https://github.com/apache/brpc/pull/3363, which extends redis_max_allocation_size to inline command lines and scans for CRLF before allocating parser arena memory so oversized inline lines are rejected; see the advisory at https://lists.apache.org/thread/2pf15ojj0vr7rtx95677kgtl1mx3gdgb. Where upgrading immediately is not possible, the most effective compensating control is to stop exposing the Redis-protocol handler to untrusted clients - disable the Redis protocol selection on public listeners or move it to an internal interface, firewalled to trusted sources (trade-off: breaks legitimate external RESP clients). As an interim mitigation, set redis_max_allocation_size to a conservative value and front the endpoint with a reverse proxy or load balancer that enforces a small maximum request-line/header length and short read timeouts (trade-off: the pre-fix limit does not fully cover the inline path, so this only shrinks the per-connection growth ceiling, and aggressive proxy limits may reject legitimate long inline commands). Also cap concurrent connections and per-connection buffer growth at the edge, and monitor memory/CPU spikes on Redis-protocol listeners as a detection signal.
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 C++ RPC framework that can multiplex several wire protocols on the same listening port, including an optional Redis protocol handler built for RESP. RESP clients may issue two command styles: length-prefixed bulk strings/arrays, or plain 'inline' commands terminated by CRLF. The vulnerable inline parser performed its arena allocation against the current input buffer size and memcpy'd the entire pending buffer before scanning for the terminating CRLF to determine the command boundary - so an unterminated line caused repeated allocate-and-copy work proportional to the growing buffer. The existing redis_max_allocation_size setting was applied to bulk strings and arrays but effectively bypassed on the inline path, making it CWE-770 uncontrolled resource consumption (memory and CPU, availability-only). The fix in bRPC 1.18.0 (PR #3363) applies redis_max_allocation_size to inline command lines, scans for CRLF before allocating parser arena memory, and rejects inline lines that exceed the configured limit.
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
Network-reachable Redis endpoint with no auth or interaction (AV:N/AC:L/PR:N/UI:N); impact is availability-only resource consumption rated A:L given 'potentially' gradual DoS, no C/I impact.
Primary rating from Vendor (apache).
Lifecycle Timeline
2DescriptionCVE.org
The Redis protocol implementation in Apache bRPC allowed inline command parsing to allocate and copy the full connection buffer before a complete CRLF-terminated command was available. A remote attacker with access to a Redis-protocol bRPC service could send long inline inputs without a terminating CRLF to increase memory usage and CPU copy overhead, potentially causing denial of service.
Root Cause: The Redis inline command parser allocated memory based on the current input buffer size and copied the entire buffer before determining the current inline command boundary. The existing redis_max_allocation_size limit was applied to RESP bulk strings and arrays, but not effectively to the inline command path before allocation.
Affected Scenarios: Use Apache bRPC server with Redis protocol enabled and reachable by untrusted clients.
How to Fix:
- Upgrade Apache bRPC to version 1.18.0, which fixes this issue.
- Apply the patch from PR https://github.com/apache/brpc/pull/3363 .
Note: The fix applies redis_max_allocation_size to Redis inline command lines and scans for CRLF before allocating parser arena memory. Inline command lines exceeding this limit are rejected.
Articles & Coverage 1
Executive ViewAI
Apache bRPC deployments that expose the optional Redis protocol to untrusted networks are exposed to CVE-2026-58064, a resource-exhaustion denial-of-service condition that can degrade or interrupt availability for dependent applications. Leadership should care because affected endpoints can be disrupted without credentials, and no vendor-released patch was identified at time of analysis; no public exploit code or confirmed active exploitation (CISA KEV) was identified, but exposure should still be reduced promptly.
Disable the optional Redis protocol on Apache bRPC unless strictly required; restrict Redis-protocol listeners to trusted networks via firewall/ACL allowlists; place size, connection, and rate limits at a proxy or load balancer; monitor for long inline commands and CPU/memory exhaustion; target bRPC 1.18.0 or later once vendor-confirmed and available.
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-107175
GHSA-m3mv-32pp-6vgx
CVE.org
EPSS
Exploit-DB