Skip to main content

FalkorDB CVE-2026-107908

| EUVDEUVD-2026-95485 CRITICAL
Out-of-bounds Write (CWE-787)
2026-10-09 securin GHSA-jpx9-94mp-7xhq
9.3
CVSS 4.0 · Vendor: securin
View

Attack ChainAIDerived

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

  1. Access
    Reach exposed Bolt port (BOLT_PORT enabled)
  2. Delivery
    Send Bolt RESET with oversized chunk size
  3. Exploit
    Bypassed ASSERT trusts 16-bit wire size
  4. Execution
    Backward ~64 KiB heap out-of-bounds write
  5. Impact
    Service crash (DoS) or possible code execution

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 target must have the Bolt protocol endpoint explicitly enabled via BOLT_PORT, which is disabled by default - this is the single decisive precondition and sharply limits the exposed population. When enabled and network-reachable, no authentication or user interaction is required (PR:N/UI:N): the attacker simply sends a Bolt RESET message specifying an attacker-chosen 16-bit chunk size. The flaw is exploitable only against release builds where the ASSERT() size check is compiled out (the normal production configuration). Reliable denial of service is the confirmed impact; arbitrary code execution is described as a possibility and is not demonstrated, so defenders with Bolt disabled or firewalled off face no exposure from this issue.

Impact

This is a genuinely high-severity flaw but with an important deployment caveat that tempers real-world risk. The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) describes a network-reachable, low-complexity, unauthenticated memory-corruption bug with high confidentiality, integrity, and availability impact (VC:H/VI:H/VA:H), scoring 9.3 - fully consistent with the description of a remote unauthenticated heap out-of-bounds write (CWE-787). The CWE, the diff reference, and the description all agree: an ASSERT()-only size check (compiled out in release builds) lets a wire-supplied 16-bit size drive a ~64 KiB backward copy past the read buffer. However, several signals pull the practical priority down: no EPSS score, no CISA KEV listing, and no public POC were provided, so there is no evidence of active exploitation or weaponization. Most importantly, exploitation requires the Bolt endpoint (BOLT_PORT) to be explicitly enabled - it is disabled by default - so the network-attack surface exists only in a subset of deployments. The 'possibly execute arbitrary code' qualifier is honest hedging: reliable DoS is near-certain, but RCE from a backward heap copy is not demonstrated and should be treated as plausible-but-unproven. Net assessment: patch promptly if Bolt is enabled and internet-exposed; lower urgency where Bolt is disabled. EPSS/KEV/POC data is absent rather than confirmed-negative, so monitor for emerging exploit code.

Exploit ScenarioDerived

A FalkorDB instance has the optional Bolt endpoint enabled and reachable over the network. A remote unauthenticated attacker connects to the Bolt port and sends a RESET message carrying a crafted 16-bit chunk size; the handler trusts this size (the bounds check is only an ASSERT compiled out of release builds) and copies up to ~64 KiB of buffered data backward past the start of the heap read buffer, crashing the service and potentially corrupting adjacent heap structures. No public exploit code was identified at time of analysis, so this reflects the described mechanism rather than an observed campaign.

Act Now Prioritize within 24-48h. Why: CRITICAL severity.
Patch available 0.6% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Oct 09, 2026

FalkorDB instances that explicitly enable the optional Bolt wire-protocol endpoint can be crashed, and possibly have arbitrary code executed, by an unauthenticated remote attacker who sends a single crafted Bolt RESET message with an attacker-chosen 16-bit chunk size. The vulnerability is a heap-based out-of-bounds write (CWE-787) in BoltReadHandler in src/bolt/bolt_api.c present before version 4.20.0; the size check is performed only with ASSERT(), which is compiled out of release builds, so production binaries provide no runtime guard. Exploitation requires the Bolt port (BOLT_PORT) to be enabled and network-reachable - it is disabled by default and is the decisive precondition that sharply limits the exposed population; with no CISA KEV entry and no public exploit code identified at time of analysis, reliable denial of service is the confirmed impact while remote code execution remains a theoretical possibility that has not been demonstrated.

RemediationAI

Upgrade to FalkorDB 4.20.0 or later, the vendor-released patched version that resolves CVE-2026-107908 (release notes at https://github.com/FalkorDB/FalkorDB/releases/tag/v4.20.0; fix code in https://github.com/FalkorDB/FalkorDB/pull/2170 and https://github.com/FalkorDB/FalkorDB/commit/0b11a00b34b25c4d4fdfe55f0a35c8a00593bd7d). If an immediate upgrade is not possible, disable the Bolt endpoint by leaving BOLT_PORT unset in the FalkorDB configuration and restarting the service - this is the single most effective mitigation because the vulnerable code path is unreachable when the endpoint is off, with the trade-off that any client using Neo4j Bolt drivers will lose connectivity. If Bolt must remain in service, restrict TCP access to the Bolt port with host firewall rules or network policy so that only trusted application subnets can reach it, accepting that this is perimeter control rather than a fix and provides no protection against an attacker already inside the trusted network segment. Rebuilding with assertions enabled (i.e., without NDEBUG) is not a dependable workaround: it would still allow an ASSERT failure to abort the process, converting code execution risk into a trivially reachable denial of service while degrading performance. Monitor and rotate credentials for any FalkorDB instance that had Bolt exposed to untrusted networks prior to patching, since memory corruption of this class can be leveraged unpredictably.

Affected VersionsENISA

FalkorDB 0 <4.20.0

Affected Packages

euvd falkordb fix: 4.20.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

FalkorDB is a graph database that speaks the Neo4j Bolt binary protocol over an optional TCP endpoint, toggled by the BOLT_PORT configuration setting. Bolt messages are framed with a 16-bit big-endian chunk-size field that the server reads off the wire and uses to locate the payload in its receive buffer. In BoltReadHandler (src/bolt/bolt_api.c), the wire-supplied chunk size was validated only through an ASSERT() macro; because assertions are stripped when the project is built in release mode (the normal production configuration), the check disappeared and the handler went on to compute a destination pointer directly from the attacker-controlled 16-bit value. That pointer arithmetic can walk backwards past the beginning of the heap-allocated read buffer and move approximately 64 KiB of buffered data into memory outside the allocation, producing a classic out-of-bounds write (CWE-787) that corrupts heap metadata and adjacent objects - hence both the reliable crash (denial of service) and the plausible, though undemonstrated, path to code execution. The root cause class is therefore missing input validation on a length field combined with reliance on debug-only assertions for a security boundary, a pattern that silently disappears in optimized builds. The associated product CPE is cpe:2.3:a:falkordb:falkordb:*:*:*:*:*:*:*:* (all versions before 4.20.0), and the upstream fix is delivered through PR github.com/FalkorDB/FalkorDB/pull/2170 and commit 0b11a00b34b25c4d4fdfe55f0a35c8a00593bd7d, whose diff shows the legacy Bolt serialization/read code being removed and reworked rather than simply patched in place. Per the assessed vector (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H, and the vendor-supplied CVSS 4.0 base of 9.3), no authentication or user interaction is required once the endpoint is exposed: an attacker only needs TCP reachability to the Bolt port.

Know when Falkordb 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 9.3 CRITICAL
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
vuln.today AI 9.8 CRITICAL

Remote unauthenticated RESET message with no user interaction (AV:N/AC:L/PR:N/UI:N); heap corruption yields reliable DoS and plausible RCE, so C:H/I:H/A:H, scope unchanged.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/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
High
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

DescriptionCVE.org

A heap-based out-of-bounds write in the BoltReadHandler function (src/bolt/bolt_api.c) in FalkorDB before 4.20.0 allows a remote unauthenticated attacker to cause a denial of service and possibly execute arbitrary code by sending a Bolt RESET message with an attacker-chosen chunk size to the Bolt port. The handler checks the size only with ASSERT(), which is compiled out in release builds, then computes a destination pointer from the wire-supplied 16-bit size and moves buffered data up to about 64 KiB backwards past the start of the read buffer. Only deployments that enable the Bolt endpoint (BOLT_PORT, disabled by default) are affected.

Executive ViewAI

Why It Matters

FalkorDB instances that have the optional Bolt wire-protocol endpoint enabled are exposed to a critical heap-based out-of-bounds write that can be triggered by a crafted network message, causing service crashes and a theoretical risk of remote code execution. Because the Bolt endpoint is disabled by default, only organizations that have explicitly enabled and exposed this interface face the risk, but for those, the impact could be significant operational disruption. Leadership should prioritize identifying and patching any such deployments to version 4.20.0 or later, as no public exploit has been identified at time of analysis but the vulnerability is severe.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.6%
Top 53% exploitable
Prevalence
Low
niche graph database; vulnerable Bolt endpoint disabled by default
Data Quality
5 sources
Confidence: Medium

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 CRITICAL
CISA KEV No
Public POC No
EPSS 0.6%
Patch available Yes
Active threat No
Deciding rule
CRITICAL severity
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

47
Low Medium High Critical
KEV: 0
EPSS: +1
CVSS: +46
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.

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.

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.

CVE-2026-5759 CRITICAL
9.3 Oct 09

Remote attackers who can issue Redis replication commands to a FalkorDB instance before 4.18.1 can trigger a double-free

CVE-2026-7827 CRITICAL
9.2 Oct 09

Stack-based buffer overflow in FalkorDB versions before 4.18.4 allows remote attackers who can issue Redis replication c

CVE-2026-107910 CRITICAL
9.2 Oct 09

Authentication bypass in the FalkorDB Bolt endpoint (src/bolt/bolt_api.c) affects all releases before 4.20.0 and lets a

CVE-2026-107909 HIGH
8.8 Oct 09

Heap-based out-of-bounds write in FalkorDB's Bolt/WebSocket handling (all versions before 4.20.0) allows a remote unauth

CVE-2026-7826 HIGH
8.8 Oct 09

Heap memory disclosure and denial of service in FalkorDB before 4.18.4 stem from an out-of-bounds read in the RDB deseri

CVE-2026-88409 HIGH
8.8 Sep 21

A crafted, attacker-controlled serialized graph payload processed by FalkorDB 4.20.1 through 4.20.4 overflows a buffer i

CVE-2026-107911 HIGH
7.7 Oct 09

Type confusion in FalkorDB versions before 4.20.0 allows an authenticated client that can issue GRAPH.QUERY to crash the

CVE-2026-88411 HIGH
7.5 Sep 21

Denial of service in FalkorDB v4.20.1, the Redis-module graph database, where the GRAPH.EFFECT replication handler in sr

CVE-2026-88406 HIGH
7.5 Sep 21

A stack overflow in the _ValidateUnion_Clauses routine of FalkorDB (a Redis graph module) versions 4.20.1 through 4.20.4

CVE-2026-88410 HIGH
7.1 Sep 21

Missing write-command registration for graph.UDF in the FalkorDB Redis module versions 4.20.1 through 4.20.4 allows a cl

CVE-2026-88408 MEDIUM
6.5 Sep 21

Authenticated denial of service in the FalkorDB Redis module versions 4.20.1 through 4.20.4 allows a user with query acc

CVE-2026-88412 MEDIUM
5.3 Sep 21

A crafted bulk-insert payload triggers an integer overflow in FalkorDB's _BulkInsert_ReadProperty parser (/bulk_insert.c

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