Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach unauthenticated FalkorDB/Redis port
-
DeliveryIssue REPLICAOF to attacker-controlled master
-
ExploitDeliver crafted RDB with oversized property count
-
ExecutionOverflow variable-length stack arrays in _RdbLoadEntity
-
ImpactCrash service or execute arbitrary code
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Stack buffer bounds checking
MITRE ATT&CK
1 technique across 1 tactic: Execution The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires the attacker to be able to issue Redis replication commands (e.g., REPLICAOF/SLAVEOF) so the FalkorDB instance loads an attacker-supplied RDB stream whose entity property count is attacker-controlled and unbounded; the decoder (_RdbLoadEntity in src/serializers/decoders/*/decode_graph_entities.c) then sizes two variable-length thread-stack arrays from that count and fills them, overflowing the stack. The concrete enabling condition named in the description is an instance with NO password configured (requirepass/ACL unset) that is network-reachable, which makes the replication commands unauthenticated. LIMITING FACTORS: if a password or ACLs are configured the attacker needs valid credentials to initiate replication; reliable arbitrary code execution (versus DoS) is non-trivial given stack overflow exploitation and corresponds to the CVSS AC:H rating; only versions before 4.18.4 are affected. |
| Impact | Signals point to a genuinely serious but not yet actively-exploited flaw whose real-world urgency is bounded by deployment context. The vendor-assigned CVSS 4.0 vector (AV:N/AC:H/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H) yields 9.2 Critical, driven by network reach, no required privileges, and high confidentiality/integrity/availability impact; AC:H appropriately reflects that an attacker must stand up a replication master and craft a malformed RDB stream, and for code execution must defeat stack layout/mitigations. PR:N is defensible ONLY for the stated no-password scenario - against a FalkorDB/Redis instance with requirepass or ACLs set, replication commands require credentials, so effective privilege rises. No EPSS score, no CISA KEV listing, and no public POC were provided in the input, so exploitation status is 'no public exploit identified at time of analysis' - there is no evidence of in-the-wild use. The root cause is firmly confirmed by the vendor source diff (variable-length stack arrays sized by an unbounded attacker-controlled count, now capped at UINT16_MAX with a 256-element stack threshold and a heap path). Net: this is a real priority for anyone exposing an unauthenticated FalkorDB instance to untrusted networks, where DoS is trivially achievable, but RCE remains the description's 'possibly' (not demonstrated) and the niche product footprint plus AC:H temper the likelihood of mass exploitation versus targeted abuse of misconfigured, internet-exposed instances. |
| Exploit ScenarioDerived | An attacker who can reach a FalkorDB instance that has no password configured issues Redis replication commands (e.g., REPLICAOF/SLAVEOF) pointing the victim at an attacker-controlled master, then serves a crafted RDB stream declaring a huge entity property count. When _RdbLoadEntity sizes two variable-length stack arrays from that unbounded count and fills them with attacker data, the thread stack is overrun, reliably crashing the service (DoS) and possibly enabling arbitrary code execution. No public exploit code was identified in the provided data, and the network vector is tempered by AC:H (crafting the RDB and achieving reliable RCE is non-trivial). |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 09, 2026
Stack-based buffer overflow in FalkorDB versions before 4.18.4 allows remote attackers who can issue Redis replication commands - for example against a network-reachable instance with no password configured - to crash the graph database and possibly achieve code execution by supplying a crafted RDB stream whose entity property count is unbounded. The decoder sizes two variable-length arrays on the thread stack from that attacker-controlled count and then fills them with attacker-supplied values, so a single malformed RDB payload overflows the stack (CWE-121). No public exploit code or confirmed active exploitation has been identified at time of analysis, and the vendor has released FalkorDB 4.18.4 moving large property sets to the heap; CVSS 4.0 rates this 9.2 with AV:N/AC:H/PR:N/UI:N, where the high attack complexity reflects the difficulty of converting the overflow into reliable arbitrary code execution rather than a denial of service.
RemediationAI
Vendor-released patch: upgrade to FalkorDB 4.18.4 (https://github.com/FalkorDB/FalkorDB/releases/tag/v4.18.4), which incorporates PR 1973 / commit 7d15431aadf37588fadc2578b90c3afb5e8daa94 and replaces the unbounded variable-length stack arrays in _RdbLoadEntity with a 256-element stack fast path plus rm_malloc heap allocation for larger property counts, adding ASSERT(n <= UINT16_MAX) as a sanity bound; this is the only complete fix and is the recommended action for all pre-4.18.4 instances, especially those exposed beyond localhost. If immediate upgrade is not possible, the highest-value compensating control is to configure requirepass and/or ACLs (or enable Redis protected-mode) so that replication commands such as REPLICAOF/SLAVEOF require authentication - this removes the unauthenticated path named in the description, but be aware it does not eliminate the overflow itself: any client holding credentials with replication privileges, or any access to the underlying RDB file, can still supply a malicious stream, so treat it as a risk reduction rather than a fix. In parallel, restrict network reachability of the Redis/FalkorDB port via bind directives, firewall rules, or a private network so untrusted hosts cannot open a replication session (trade-off: may break legitimate cross-host replication topologies), avoid loading RDB snapshots or streams from untrusted sources during recovery, and monitor logs and command traffic for unexpected REPLICAOF/SLAVEOF directives or replica connections pointing at attacker-controlled masters, which is the observable signature of an exploitation attempt; because no public exploit code has been identified, detection is primarily anomaly-based rather than signature-based.
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
FalkorDB is a Redis-module graph database that persists graphs using RDB serialization, so a replica or restarting node rebuilds its data structures by replaying an RDB stream through version-specific decoders under src/serializers/decoders/ (for example current/v19, prev/v10, prev/v11). Inside _RdbLoadEntity, the on-disk format is a property count N followed by N pairs of attribute ID and typed value; the vulnerable code read that count with RedisModule_LoadUnsigned/SerializerIO_ReadUnsigned into a uint64_t and then declared two variable-length arrays, SIValue vals[n] and AttributeID ids[n], directly on the thread stack without any upper bound and looped over N entries. Because N originates from the untrusted RDB payload, an oversized value causes a classic CWE-121 stack-based buffer overflow in which attacker-supplied IDs and values are written past the end of both arrays, corrupting adjacent stack memory (return addresses and locals), which can terminate the process or, with sufficient control, redirect execution. The fix (PR 1973, commit 7d15431aadf37588fadc2578b90c3afb5e8daa94, shipped in v4.18.4) caps the stack path at ENTITY_PROP_STACK_THRESHOLD = 256 elements, allocates the arrays via rm_malloc on the heap above that threshold, and adds ASSERT(n <= UINT16_MAX), while preserving the same decoding semantics - confirming that the root cause was purely the unvalidated variable-length stack allocation. The affected CPE is the wildcard cpe:2.3:a:falkordb:falkordb:*:*:*:*:*:*:*:*, and the flaw exists in multiple bundled decoder versions, so any pre-4.18.4 build is exposed regardless of which serializer version it uses.
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
CVSS:4.0/AV:N/AC:H/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Network-reachable with no auth on the described no-password instance (AV:N/PR:N); AC:H because the attacker must drive replication and craft an RDB stream and defeat stack layout for RCE; full C/I/A impact from possible code execution, scope unchanged.
Primary rating from Vendor (securin).
CVSS VectorVendor: securin
DescriptionCVE.org
A stack-based buffer overflow in the _RdbLoadEntity function of the RDB graph decoders (src/serializers/decoders/*/decode_graph_entities.c) in FalkorDB before 4.18.4 allows a remote attacker who can issue Redis replication commands (for example, against an instance with no password configured) to cause a denial of service and possibly execute arbitrary code by supplying a crafted RDB stream with an attacker-controlled entity property count. The count sizes two variable-length arrays on the thread stack with no upper bound, and the decoder then fills them with attacker-supplied values.
Articles & Coverage 1
Executive ViewAI
FalkorDB deployments running versions earlier than 4.18.4 are exposed to a critical remote stack overflow that any network-reachable instance can be crashed, and potentially taken over, by an unauthenticated attacker able to reach the Redis replication interface - which is the default state for instances left without a password. Because the same channel could plausibly be escalated to code execution, the exposure is not limited to availability: any graph data, connected applications, and downstream services relying on that instance sit behind a single externally reachable port. Leadership should treat this as an urgent internet-facing surface reduction and patch priority rather than a routine database update.
Apply vendor patch. Until FalkorDB 4.18.4 is deployed, restrict network access to the Redis replication port to trusted hosts only, require authentication (requirepass) on all instances, and monitor for anomalous replication or RDB synchronization activity; per the CVSS vector the flaw is remotely exploitable without authentication (PR:N) on a network-reachable instance.
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
SSVC AssessmentENISA
Priority Score
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.
A stack-based buffer overflow occurs when a program writes more data to a buffer located on the stack than it was allocated to hold.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
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.
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 is an open source, in-memory database that persists on disk. Versions 8.2.1 and below allow an authenticated user
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 remote code execution in OpenC3 COSMOS (Ruby gem 'openc3' versions 5.1.0 through 7.2.1) lets any logged-in
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
In applications using jfinal 4.9.08 and below, there is a deserialization vulnerability when using redis,may be vulnerab
An issue was found in Apache Airflow versions 1.10.10 and below. Rated critical severity (CVSS 9.8), this vulnerability
EUVD-2026-95474
GHSA-fwp9-2ghh-pw8g
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB