Skip to main content

FalkorDB CVE-2026-7826

| EUVDEUVD-2026-95475 HIGH
Out-of-bounds Read (CWE-125)
2026-10-09 securin GHSA-fmqx-854h-cfff
8.8
CVSS 4.0 · Vendor: securin
View

Attack ChainAIDerived

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

  1. Access
    Reach FalkorDB replication interface (no password)
  2. Delivery
    Initiate Redis replication as master
  3. Exploit
    Send crafted RDB with oversized sub-buffer length
  4. Execution
    Bypass ASSERT and trigger OOB memcpy read
  5. Impact
    Crash instance or leak adjacent heap memory

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, read limits
MITRE ATT&CK

1 technique across 1 tactic: Collection

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 drive a Redis replication exchange against the FalkorDB instance - for example by acting as a replication master or issuing replication commands - and supply a malicious RDB stream in which the sub-buffer length field in BufferSerializerIOv2_ReadBuffer exceeds the remaining buffer size. The primary enabling condition is an instance reachable on the network with no password (no requirepass/ACL), as the description explicitly cites; the flaw is reachable only because the bounds check is an ASSERT() stripped from release builds. Limiting factors: instances configured with authentication require valid credentials (removing the unauthenticated path), network isolation or firewalling of the replication port prevents reach, and only FalkorDB versions before 4.18.4 are affected - upgrading restores proper runtime length validation.

Impact

This is a genuine, exploitable network-facing flaw rather than an inflated high-CVSS issue, but its real-world priority hinges on exposure. The supplied CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:N/VA:H) indicates a low-complexity, remote, unauthenticated attack yielding high confidentiality (heap disclosure) and high availability (DoS) impact - consistent with the description. The PR:N rating is accurate only for the common no-password deployment the description calls out; an instance protected with requirepass/ACL effectively raises the privilege bar, so the practical attack surface is narrower than PR:N alone suggests. No EPSS score was provided, the CVE is not in CISA KEV, and no public exploit is referenced, so there is no evidence of active exploitation - this is a patch-promptly item, not a drop-everything emergency. The root cause is well-corroborated by the vendor patch (the sole bounds check was an ASSERT() compiled out of release builds, letting memcpy() over-read), which raises confidence in the technical claim. Net assessment: credible high-severity bug, moderate-to-high urgency for anyone running FalkorDB exposed to untrusted replication traffic, lower urgency where instances are authenticated and network-isolated.

Exploit ScenarioDerived

An attacker who can reach a FalkorDB instance with no password configured initiates a Redis replication exchange and feeds a crafted RDB stream whose sub-buffer length field is larger than the bytes actually remaining in the buffer. Because the only length validation was an ASSERT() stripped from release builds, memcpy() reads past the end of the heap allocation, either crashing the process (DoS) or copying adjacent heap memory into the returned buffer (information disclosure). No public proof-of-concept is referenced, but the vendor patch clearly documents the vulnerable path.

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

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

Alert me

AnalysisAIv1 – Oct 09, 2026

Heap memory disclosure and denial of service in FalkorDB before 4.18.4 stem from an out-of-bounds read in the RDB deserialization routine BufferSerializerIOv2_ReadBuffer, which trusts a sub-buffer length field taken from the incoming stream and validates it only with an ASSERT() that is compiled out of release builds. Unauthenticated remote attackers who can drive a Redis replication exchange - for example by acting as a replication master against a network-reachable instance with no requirepass/ACL configured - can supply a crafted RDB stream to read past the end of a heap allocation, crashing the server or leaking heap memory (CVSS 8.8, high confidentiality and availability impact). No public exploit code has been identified at time of analysis, and the vendor has released a fix in FalkorDB 4.18.4, so residual risk is concentrated on unauthenticated, network-exposed deployments that have not yet upgraded.

RemediationAI

The primary fix is to upgrade to FalkorDB 4.18.4 or later - this is the vendor-released patch, delivered through pull request https://github.com/FalkorDB/FalkorDB/pull/1972 and commit https://github.com/FalkorDB/FalkorDB/commit/55d986f45ecd5d80f7a9e5e138e8b0f96535b48c and tagged at https://github.com/FalkorDB/FalkorDB/releases/tag/v4.18.4; it converts the ASSERT() bounds check that was stripped from release builds into a real runtime check on the sub-buffer length, so no configuration change is needed once the updated code is deployed, though a module reload or server restart is typically required to pick it up. If upgrading cannot be done immediately, the highest-value compensating control is authentication: set requirepass (or an equivalent ACL for the replication-capable user) so that replication handshakes demand credentials, which eliminates the unauthenticated path called out in the advisory and in our independent assessment - the trade-off is that every client and replica connection string must be updated and the server reconfigured, and legacy clients that cannot send AUTH will break. Complement that with network-level restriction: firewall the replication port (default 6379/tcp, plus the cluster bus on 16379/tcp where clustered) so only trusted master and replica hosts may initiate replication traffic; this blocks a remote attacker from reaching the vulnerable decode path entirely, at the cost of flexibility for cross-network or multi-cloud replication topologies. Keeping the instance on a private management network and never exposing an unauthenticated FalkorDB to the internet addresses the main exploitation precondition, and monitoring for unexpected REPLICAOF/SLAVEOF commands or inbound replication connections from unfamiliar peers can provide early warning of probing. Because version 4.18.4 fully resolves the flaw, these measures should be treated strictly as a stopgap rather than a long-term substitute for patching.

Affected VersionsENISA

FalkorDB 0 <4.18.4

Affected Packages

euvd falkordb fix: 4.18.4

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 graph database implemented as a Redis module, and it reuses Redis's replication and RDB serialization machinery, so any peer that can act as a replication master (or otherwise drive replication commands) can push a serialized dataset into the target process. In src/serializers/serializer_io.c, BufferSerializerIOv2_ReadBuffer parses a one-byte type tag followed by either a blob marker or a char* value; in the char* case it reads an attacker-controlled size_t length field 'l' straight out of the buffer, guards it only with ASSERT((buffer->cap - buffer->count) >= l), and then advances buffer->count by 'l' and reads/allocates accordingly. Because ASSERT() is a no-op in release builds (NDEBUG), a length larger than the bytes actually remaining causes the subsequent copy to read beyond the heap allocation - a textbook CWE-125 out-of-bounds read that doubles as an availability bug (crash) and an information-disclosure bug (heap contents returned to the replication peer). The accepted fix (PR #1972, commit 55d986f4) removes every ASSERT-based check in this function and replaces it with explicit runtime validation: a warning log plus RedisModule_Assert(false) when no byte is available for the type field, when fewer than sizeof(size_t) bytes remain for the length field, when a blob marker appears anywhere other than the end of the buffer, when the type byte is unrecognized, and - the core fix - when the declared sub-buffer length exceeds the remaining bytes. The CPE cpe:2.3:a:falkordb:falkordb:*:*:*:*:*:*:*:* carries no version bounds, i.e. it covers the entire product line prior to the 4.18.4 fix.

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 (securin) PRIMARY 8.8 HIGH
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:N/VA:H/SC:N/SI:N/SA:N
vuln.today AI 9.1 CRITICAL

Remote replication path with no authentication on default no-password instances (AV:N/AC:L/PR:N/UI:N); heap over-read yields memory disclosure (C:H) and process crash (A:H) with no integrity impact (I:N).

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:H
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:N/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (securin).

CVSS VectorVendor: securin

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
None
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

DescriptionCVE.org

A heap-based out-of-bounds read in the BufferSerializerIOv2_ReadBuffer function (src/serializers/serializer_io.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 or disclose heap memory by supplying a crafted RDB stream whose sub-buffer length field exceeds the remaining buffer size. The only bounds check is an ASSERT(), which is compiled out in release builds, so memcpy() reads past the end of the heap allocation.

Executive ViewAI

Why It Matters

A memory-safety flaw in FalkorDB's replication data-loading routine exposes network-reachable graph database deployments to remote crashes and potential heap memory disclosure, threatening both availability of graph-backed applications and confidentiality of data held in memory. Because the vulnerable code path can be reached by a peer initiating a replication exchange against instances that do not enforce client authentication, exposure is greatest for internet-facing or broadly reachable FalkorDB clusters that have not yet been upgraded. Leadership should treat this as a priority remediation item for any customer-facing or sensitive-data workloads built on FalkorDB.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.4%
Top 64% exploitable
Prevalence
Low
niche graph-database Redis module, limited production deployment footprint
Social Media
1
Sightings
Data Quality
6 sources
Confidence: High

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.4%
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.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact
High

Priority Score

44
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +44
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

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.

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

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

Redis is an open source, in-memory database that persists on disk. Versions 8.2.1 and below allow an authenticated user

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

CVE-2021-31649 CRITICAL POC
9.8 Jun 24

In applications using jfinal 4.9.08 and below, there is a deserialization vulnerability when using redis,may be vulnerab

CVE-2020-11981 CRITICAL POC
9.8 Jul 17

An issue was found in Apache Airflow versions 1.10.10 and below. Rated critical severity (CVSS 9.8), this vulnerability

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