CVE-2026-88407

Executive Summary

CVE-2026-88407 is an out-of-bounds read (CWE-125) in the node_token_count/relation_token_count component of FalkorDB, a Redis module implementing a graph database, affecting versions 4.20.1 through 4.20.4. An unauthenticated remote attacker can trigger the flaw with crafted input, causing a Denial of Service (DoS) that renders the Redis instance hosting the module unavailable. The vulnerability carries a CVSS v3.1 base score of 7.5 (High), reflecting a network-reachable, low-complexity attack that requires no privileges or user interaction and produces a complete loss of availability.

Technical Analysis

FalkorDB is a graph database implemented as a loadable Redis module. The module registers graph-query commands with Redis and parses Cypher-like query text into an internal execution plan, which includes structures that track the number of tokens associated with nodes and relations in the query graph. The vulnerable component referenced in the NVD description — node_token_count/relation_token_count — is responsible for counting and iterating over these token sequences during query parsing or planning.

The weakness is an out-of-bounds read (CWE-125). In memory-unsafe code (FalkorDB's query engine is written in C), a counting routine that reads past the end of an allocated buffer can be induced when a crafted input causes the token count or an associated index to exceed the actual size of the backing buffer. Because the flaw is a read rather than a write, the most direct and consistently observable consequence is a crash of the Redis process (typically a segmentation fault) when the read crosses into an unmapped page or when the corrupted value is subsequently used for an allocation, index, or loop bound. The NVD description explicitly scopes the outcome to Denial of Service; no confidentiality or integrity impact is asserted, consistent with the CVSS vector (C:N/I:N/A:H).

Attack surface: the graph-query interface exposed by FalkorDB. In a standard deployment the module is accessed over the Redis protocol (default TCP/6379), and the flaw is reachable remotely without authentication if the Redis instance is network-exposed and not protected by requirepass, ACLs, TLS, or a network access-control layer. The CVSS vector confirms this posture: AV:N/AC:L/PR:N/UI:N — network exploitable, low attack complexity, no privileges, no user interaction.

Because the CNA title and NVD description do not disclose the exact malformed input form (specific command, query syntax, or parameter), the precise trigger string cannot be reproduced from the available data. No public proof-of-concept, exploit code, or Nuclei template exists for this CVE as of this writing, and no CWE identifier was supplied by the CNA (CWE-125 is assigned here by classification of the described out-of-bounds read). Operators should treat the trigger as an unspecified crafted graph query rather than assume a specific syntactic payload.

Exploitation Scenarios

No public PoC is available; the attack chain below is inferred from the vulnerability class (unauthenticated out-of-bounds read in a Redis module query parser) and must be validated against the specific deployment.

1. Reconnaissance / target identification. The attacker scans for hosts exposing Redis (default TCP/6379) and probes them for FalkorDB. Identification is performed by issuing benign Redis commands and graph-module commands that are unique to FalkorDB; a responding FalkorDB instance reveals both the presence of the module and, via module/version introspection commands available on the Redis interface, a version in the 4.20.1–4.20.4 range. Public scanning services can be used to enumerate internet-facing Redis/FalkorDB endpoints.

2. Triggering the flaw class. With a connection established, the attacker sends a crafted graph-query input through the module's query interface. The crafted input is designed so that the token counting logic for nodes and/or relations (node_token_count/relation_token_count) advances beyond the bounds of the token buffer, producing an out-of-bounds read. Because the trigger is low-complexity and requires no authentication or user interaction, the attacker can iterate candidate malformed inputs until the offending read is reached — the defining characteristic of a memory-safety DoS reached from a parser boundary.

3. Payload / execution method. At the vulnerability-class level, the payload is a single malformed query (or query fragment) delivered over the Redis protocol to the FalkorDB query processor. No memory-corruption exploitation primitive (RCE, data exfiltration) is asserted for this CVE; the objective is to force the invalid read and crash the process. The attacker needs only a single request to achieve impact, and can repeat it to maintain the denial of service.

4. Post-exploitation impact. Successful triggering terminates or hangs the Redis process hosting the FalkorDB module. All graph workloads, dependent applications, and any other keys or modules collocated on that Redis instance become unavailable. If the instance runs without a supervised restart policy, the outage persists until manual intervention; if a supervisor restarts it automatically, the attacker can sustain the DoS by re-sending the crafted query, producing a restart loop that continuously drops in-flight data served from memory and disrupts connected clients.

Impact Assessment

The impact is complete loss of availability of the affected FalkorDB/Redis service (A:H), with no direct confidentiality (C:N) or integrity (I:N) impact and no scope change (S:U) — the blast radius is confined to the vulnerable instance and its immediate dependents. The CVSS v3.1 base score is 7.5 (High).

Business impact depends on what shares the instance:

• Application downtime. Graph-backed applications (recommendation engines, knowledge graphs, identity/relationship stores, fraud-detection graphs) lose their data layer and will error or degrade for the duration of the outage.
• Collateral Redis workloads. Because FalkorDB is a Redis module, a crash brought on by the module takes down the entire Redis process, affecting all keys, other modules, pub/sub channels, and caching layers on the same instance — not just the graph data.
• Amplification via restart loops. Automated supervisors (systemd, Kubernetes, container orchestrators) may restart the process, but a persistent attacker keeps the service cycling, causing repeated connection drops and potential data loss for in-memory-only datasets.
• Availability of dependent systems. Any service with a hard dependency on the instance (session stores, rate limiter state, job queues) can cascade into broader application failure.

Exploitation is remote, unauthenticated, low-complexity, and requires no user interaction, making this a persistent, cheap-to-execute denial-of-service vector against any internet-exposed, unprotected FalkorDB instance. There is no evidence of exploitation in the wild, no CISA KEV listing, and no known ransomware or APT campaign associated with this CVE.

Detection Guidance

Sigma Rule

title: FalkorDB Out-of-Bounds Read DoS via Crafted Graph Query (CVE-2026-88407)
id: 6f2d1b8a-4c7e-4a1b-9e3d-2a5f8c0b7d41
status: experimental
description: Detects crash/restart of a Redis process hosting the FalkorDB module consistent with an out-of-bounds read triggered by a crafted graph query (CVE-2026-88407).
references:
  - https://nvd.nist.gov/vuln/detail/CVE-2026-88407
author: Threat Intelligence
date: 2026/01/01
logsource:
  product: linux
  service: syslog
detection:
  selection_proc:
    message|contains:
      - 'redis-server'
  selection_crash:
    message|contains:
      - 'segfault'
      - 'general protection fault'
      - 'core dumped'
      - 'signal 11'
      - 'signal 6'
  condition: selection_proc and selection_crash
falsepositives:
  - Legitimate Redis crashes unrelated to FalkorDB
  - Kernel or hardware memory faults
level: high
tags:
  - attack.t1499
  - cve.2026.88407

YARA Rule

rule CVE_2026_88407_FalkorDB_Token_Count_OOB_Read
{
    meta:
        description = "Identifies FalkorDB module files containing the vulnerable token-count routines referenced in CVE-2026-88407"
        author = "Threat Intelligence"
        date = "2026-01-01"
        reference = "https://nvd.nist.gov/vuln/detail/CVE-2026-88407"
        cve = "CVE-2026-88407"

    strings:
        $s1 = "node_token_count" ascii
        $s2 = "relation_token_count" ascii
        $s3 = "FalkorDB" ascii
        $s4 = "falkordb" ascii

    condition:
        (uint16(0) == 0x5A4D or uint32(0) == 0x464C457F) and
        filesize < 100MB and
        (($s1 and $s3) or ($s2 and $s3) or ($s1 and $s4) or ($s2 and $s4))
}

Suricata IDS Rule

alert tcp $EXTERNAL_NET any -> $HOME_NET 6379 (msg:"CVE-2026-88407 FalkorDB Potential Out-of-Bounds Read DoS Attempt via Crafted Graph Query"; flow:established,to_server; content:"GRAPH"; nocase; content:".QUERY"; nocase; distance:0; within:32; threshold:type limit, track by_src, count 20, seconds 10; classtype:attempted-dos; reference:cve,2026-88407; reference:url,nvd.nist.gov/vuln/detail/CVE-2026-88407; sid:202688407; rev:1;)

Elastic Detection

sequence by process.entity_id with maxspan=30s
  [process where event.type == "start" and process.name == "redis-server"]
  [process where event.type == "end" and
     (process.exit_code != 0 or
      process.name == "redis-server")]

Splunk SPL Query

index=linux sourcetype=syslog (redis-server OR falkordb)
(segfault OR "general protection fault" OR "core dumped" OR "signal 11" OR "signal 6" OR "Aborted")
| stats count, values(message) as crash_messages by host, process_name
| where count >= 2
| sort - count

Wazuh OSSEC Rule

<group name="falkordb,cve-2026-88407,">
  <rule id="2028841" level="12">
    <decoded_as>syslog</decoded_as>
    <match>redis-server</match>
    <regex>segfault|general protection fault|core dumped|signal 11|signal 6</regex>
    <description>CVE-2026-88407: Redis/FalkorDB process crashed - possible out-of-bounds read DoS from crafted graph query</description>
    <mitre>
      <id>T1499</id>
    </mitre>
    <group>dos,cve_2026_88407,</group>
  </rule>
</group>

Mitigation & Patch Guidance

Patch confidence: 0/4 (UNPATCHED — no patch evidence from any tracked source). No vendor fix, affected-version list, or workaround is published in the available data. All releases from 4.20.1 through 4.20.4 must be treated as vulnerable.

1. Immediate mitigations

• Do not expose Redis/FalkorDB to untrusted networks. Bind the instance to 127.0.0.1 or a private interface (bind directive) and restrict access with firewall rules, security groups, or a private VPC/subnet.
• Enforce authentication and ACLs. Enable Redis requirepass and Redis 6+ ACLs so unauthenticated clients cannot reach the query interface. Note this is defense-in-depth only — the CVSS vector assumes no privileges required, so authentication alone does not remediate the flaw for authorized-but-hostile clients.
• Enforce Redis protected mode and TLS. Keep protected-mode yes and require TLS between clients and the instance.
• Rate-limit and validate query input at the application layer. Where a trusted app fronts FalkorDB, cap query size/complexity and reject malformed graph queries before they reach the module.
• Deploy the instance behind an API gateway or query proxy that can throttle and terminate connections carrying malformed input.

2. Patch / upgrade steps

• Monitor the FalkorDB project (GitHub releases, security advisories) and the NVD entry for CVE-2026-88407 for a fixed release covering 4.20.1–4.20.4.
• There is currently no fixed version to upgrade to. Do not rely on a fictitious upgrade target; schedule the upgrade only when the vendor publishes a patched release, then upgrade promptly and verify the version with Redis module introspection.
• Since the module shares the Redis process, ensure the Redis server itself is at a supported version and configured for supervised restart (supervised systemd/Kubernetes restart policy) to bound outage duration.

3. Long-term hardening

• Isolate FalkorDB from general-purpose Redis workloads — run it on a dedicated Redis instance so a module-triggered crash cannot take down unrelated caching, session, or queue data.
• Adopt a memory-safe posture where feasible and track upstream memory-safety fixes; treat all parser boundaries as attack surface.
• Continuous monitoring for crashes/restarts (see Detection Guidance) to catch exploitation attempts and shorten response time.
• Network segmentation and zero-trust access to data stores; never place graph databases on the public internet.
• Inventory and configuration management to detect new internet-exposed Redis instances and drift from the hardened baseline.

References

• NVD — CVE-2026-88407: https://nvd.nist.gov/vuln/detail/CVE-2026-88407
• FalkorDB project (vendor): https://github.com/FalkorDB/FalkorDB
• FalkorDB security advisories (monitor for a fixed release): https://github.com/FalkorDB/FalkorDB/security/advisories
• CWE-125 — Out-of-bounds Read: https://cwe.mitre.org/data/definitions/125.html
• MITRE ATT&CK T1499 — Endpoint Denial of Service: https://attack.mitre.org/techniques/T1499/
• CISA KEV Catalog (listing status: NOT present): https://www.cisa.gov/known-exploited-vulnerabilities-catalog

No public proof-of-concept, exploit code, or in-the-wild exploitation is known for CVE-2026-88407. No threat-actor campaign has been attributed. EPSS has not been scored by FIRST.org.