CVE-2026-85522

Executive Summary

CVE-2026-85522 is a remotely exploitable out-of-bounds read vulnerability in the Valkey in-memory data store (the Linux Foundation fork of Redis), affecting the slot migration subsystem. The flaw resides in the createSlotImportJob function within src/cluster_migrateslots.c, where improper handling of the job_name argument allows an attacker to trigger an out-of-bounds memory read via the cluster migration protocol. With a CVSS score of 5.3 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L), the attack requires no authentication and can be executed over the network. The exploit is publicly known, and operators running Valkey versions up to 9.5.4 and 9.1.0 should prioritize upgrading to 9.0.5 or 9.1.1, which contain the fix identified by commit hash f4dc3ca09eb650c2fe14060090a41c524eca803f.

Technical Analysis

The vulnerability exists within Valkey's cluster slot migration machinery, specifically in the createSlotImportJob function implemented in src/cluster_migrateslots.c. This function is responsible for constructing and enqueuing import jobs when slots are migrated between cluster nodes. During cluster rebalancing or manual slot redistribution, nodes communicate migration plans and execute import operations that copy slot data from a source node to a destination node.

The out-of-bounds read occurs during the handling of the job_name argument passed to createSlotImportJob. The NVD description indicates that manipulation of this argument causes the function to read memory outside the bounds of an intended buffer or array. This is classified under CWE-119 (Improper Restriction of Operations within the Bounds of a Memory Buffer).

The attack vector is remote and requires no credentials (PR:N). Since Valkey's cluster protocol traffic is typically exchanged between nodes over TCP ports (default 6379 for client connections, with cluster bus traffic on a separate port), an unauthenticated remote attacker who can reach the cluster communication endpoint could potentially inject malformed cluster messages. The lack of an authentication requirement combined with the lack of user interaction (UI:N) makes this particularly concerning in environments where cluster ports are exposed beyond trusted network segments.

The total CVSS assessment reflects a low availability impact (A:L) and no impact to confidentiality or integrity (C:N/I:N). This suggests the out-of-bounds read may cause service instability, segmentation faults, or denial-of-service conditions when the read encounters unmapped memory, but does not directly leak sensitive data or allow write operations.

The official patch, committed as f4dc3ca09eb650c2fe14060090a41c524eca803f, addresses the bounds-checking deficiency. The affected versions include 9.5.4 and 9.1.0, while the fix is available in 9.0.5 and 9.1.1. Notably, the patched versions are lower or equal to some affected versions, indicating a complex versioning situation: Valkey appears to have diverged into separate maintenance lines, with fixes applied to both 9.0.x and 9.1.x branches while 9.5.x may require a separate update path.

Exploitation Scenarios

Step 1 — Reconnaissance and Target Identification. An attacker begins by identifying Valkey cluster nodes exposed to the network. Using Shodan queries such as product:"Valkey" or port:"6379", the attacker locates instances listening on default Valkey/Redis ports. Node identity can be confirmed by sending a CLUSTER INFO or INFO command and inspecting the response banner, or by observing the cluster-enabled configuration.

Step 2 — Triggering the Flaw. The core vulnerability is exercised through the slot migration protocol. Since no public PoC details are available, the attack chain is inferred from the vulnerability class. Without authentication, the attacker sends cluster-bus messages that cause the receiving node to invoke createSlotImportJob with a specially crafted job_name argument. Given the remote, unauthenticated nature, the attacker likely crafts a malformed cluster message that causes the victim node to process a slot import request with an invalid or oversized name field.

No public PoC is available; the attack chain is inferred from the vulnerability class. The manipulation could involve a job_name string that lacks proper null termination or exceeds an internal fixed-size buffer used during job creation. The code path in createSlotImportJob may then read past the buffer boundary when copying or validating the name.

Step 3 — Payload Execution. At the vulnerability-class level, the attacker sends a crafted import request (a form of remote service exploitation classified as T1210). The absence of bounds checking means the function reads memory adjacent to the intended string buffer. The outcome ranges from benign reads into adjacent heap allocations (causing undefined behavior) to a segmentation fault if the read crosses into unmapped memory regions.

Step 4 — Post-Exploitation Impact. Post-exploitation depends entirely on how the out-of-bounds read manifests in practice. The CVSS vector with A:L suggests the likely outcome is a crash of the Valkey server process, causing denial of service for applications relying on the data store. Cluster members may mark the crashed node as failed, triggering failover and, in the worst case, repeated crashes if the attacker continuously sends malformed import requests. The low integrity and confidentiality scores indicate no direct data leakage or modification is expected from this flaw alone.

Operators should note that while the CVSS severity appears moderate (5.3), an unauthenticated, remotely triggerable crash in a data-store layer can have outsized cascading impact within a microservices architecture.

Impact Assessment

The business impact centers on availability. Valkey serves as a primary in-memory data store and cache layer for high-throughput applications. A remotely triggerable crash Denial-of-Service (DoS) can cascade through dependent services, causing request failures, session loss, and degraded user experiences. Because the vulnerability requires no authentication, any network-adjacent attacker who can reach the Valkey port can exploit it — including in cloud environments where security groups may inadvertently expose non-HTTP ports.

Affected systems:

• Valkey cluster nodes running version 9.5.4 and earlier (9.5.x line)
• Valkey cluster nodes running version 9.1.0 and earlier on the 9.1.x line
• Any deployment using cluster mode with slot migration enabled (default in cluster configurations)

Blast radius: The default Valkey port is TCP 6379, with cluster bus traffic on TCP 16379. In misconfigured environments where these ports are reachable from untrusted segments, the entire cluster is exposed. Even in properly segmented networks, any compromised host within the trusted zone becomes a viable attack vector. Multi-node clusters amplify the impact — a single crash triggers cluster failover; repeated crashes of the same node cause flapping, splitting, and cascading failover storms across all shards.

CVSS schema notes: Confidentiality Impact: None; Integrity Impact: None; Availability Impact: Low. The absence of confidentiality impact indicates the out-of-bounds read is unlikely to be exploitable for information disclosure in practice — this is primarily a reliability and DoS concern. The scope remains Unchanged, meaning the compromise does not cross a security boundary.

Detection Guidance

The following detection content targets the exploitation of CVE-2026-85522. Since the vulnerability is a memory-safety defect triggered via the cluster migration protocol, detection focuses on anomalous cluster message activity, process crashes, and abnormal Valkey client behavior.

Sigma Rule

title: Valkey Slot Migration Out-of-Bounds Read Attempt
id: 29a4d8f1-8f6e-4b2c-9e1d-3a7f5c0b8e2a
status: experimental
description: Detects Valkey server crashes or anomalous cluster import job activity potentially indicating CVE-2026-85522 exploitation
author: Valters IT Cyber Threat Intelligence
date: 2026/05/15
logsource:
  category: process_creation
  product: linux
detection:
  selection_crash:
    Image|endswith: '/valkey-server'
    # Common crash signature when OOB read hits unmapped memory
    CommandLine|contains: 'cluster'
  selection_segfault:
    Image|endswith: '/valkey-server'
    # Valkey typically writes crash log with "Segmentation fault"
  condition: selection_crash or selection_segfault
level: high
falsepositives:
  - Legitimate cluster maintenance operations may produce transient errors
  - Kernel or system-level issues causing unrelated crashes
fields:
  - Image
  - CommandLine
  - User
tags:
  - attack.t1210
  - cve.2026-85522

YARA Rule

rule CVE_2026_85522_Valkey_Exploit_Strings
{
    meta:
        author = "Valters IT Threat Intelligence"
        description = "Detects binary artifacts or crash dumps referencing Valkey createSlotImportJob or related migration strings"
        date = "2026-05-15"
        cve = "CVE-2026-85522"
        severity = "medium"
    strings:
        $s1 = "createSlotImportJob" ascii wide nocase
        $s2 = "cluster_migrateslots.c" ascii wide nocase
        $s3 = "job_name" ascii wide nocase
        $s4 = "slot migration failed" ascii wide nocase
        $s5 = "IMPORT" ascii wide nocase
    condition:
        uint16(0) == 0x5A4D and  // MZ header (PE)
        any of ($s1, $s2, $s3) and
        (1 of ($s4, $s5))
}

Suricata IDS Rule

alert tcp any any -> any 16379 (msg:"CVE-2026-85522 Valkey Cluster Malformed Import Job"; flow:to_server,established; content:"IMPORT"; nocase; content:"|0a|"; depth:100; metadata:created_at 2026_05_15, updated_at 2026_05_15; reference:cve,2026-85522; classtype:attempted-dos; sid:1008522; rev:1;)

Elastic Detection

// Detect repeated Valkey cluster process failures
sequence by host.name with maxspan=5m
  [process where event.type == "start" and process.name == "valkey-server"
   and process.args : ("*cluster*", "*migrate*", "*import*")]
  [process where event.type == "end" and process.name == "valkey-server"
   and process.exit_code != 0]

Splunk SPL Query

index=main sourcetype=valkey_logs OR sourcetype=syslog
| search "valkey-server" "migrate" OR "import job" OR "cluster" 
| rex field=_raw "Segmentation fault|Assertion failed|out of memory|slot import"
| where match(_raw, "(?i)(close call on|may be used|job_name)")
| stats count by host, source, _time, _raw
| sort - _time

Wazuh OSSEC Rule

<group name="valkey_cve-2026-85522,">
  <rule id="100522" level="10">
    <if_sid>5715</if_sid>
    <match>valkey-server.*IMPORT|valkey-server.*import job|valkey-server.*Segmentation fault</match>
    <description>CVE-2026-85522: Possible Valkey slot migration OOB read causing crash</description>
    <group>attack.t1210,</group>
    <mitre>
      <id>T1210</id>
    </mitre>
  </rule>
</group>

Mitigation & Patch Guidance

Patch confidence: 0/4 — UNPATCHED. While the NVD description identifies commit f4dc3ca09eb650c2fe14060090a41c524eca803f and fixed versions 9.0.5 and 9.1.1, the structured patch sources list reports no patch evidence from tracked sources at the time of analysis. The 0/4 confidence indicates a mismatch between the narrative and the tracked patch verification. Nevertheless, operators should regard the commit and versions cited in the NVD description as the authoritative remediation reference, given CNA attribution. The absence of tracked sources likely reflects incomplete aggregation rather than a disputed fix.

Immediate Mitigations (until patched):

1. Restrict network exposure — ensure Valkey ports (6379, 16379) are not reachable from untrusted networks. Apply strict firewall rules, security group ingress filters, and network ACLs.
2. Enable authentication — although the vulnerability appears to bypassauth via cluster-bus messages, enabling requirepass and masterauth adds a layer of defense-in-depth.
3. Disable cluster mode — if cluster slot migration is not required for the current deployment, run Valkey in standalone mode to completely remove the attack surface.
4. Monitor for crashes — proactively watch server logs for unexpected Valkey process exits; investigate any Segmentation fault messages in src/cluster_migrateslots.c context.

Patch/Upgrade Steps:

1. Upgrade Valkey to 9.0.5 or 9.1.1 (as per NVD). For deployments on the 9.5.x line, monitor vendor advisories for an equivalent or newer patched release.
2. Alternatively, apply commit f4dc3ca09eb650c2fe14060090a41c524eca803f from the Valkey repository if building from source.
3. Roll out upgrades during maintenance windows to avoid interruption. Validate cluster health post-upgrade using CLUSTER INFO and CLUSTER NODES.

Long-Term Hardening:

• Subscribe to Valkey security mailing lists and Linux Foundation security advisories.
• Run cluster nodes as non-root users with restricted system privileges.
• Implement network-level intrusion detection (as per Suricata rule above) to flag anomalous cluster protocol traffic.
• Maintain an inventory of Valkey versions across the estate with automated vulnerability scanning aligned to CVE feeds.

References

1. NVD Entry: CVE-2026-85522 — https://nvd.nist.gov/vuln/detail/CVE-2026-85522
2. Valkey Official GitHub Repository (Patch Commit): https://github.com/valkey-io/valkey/commit/f4dc3ca09eb650c2fe14060090a41c524eca803f
3. Valkey Releases and Security Advisories: https://valkey.io/downloads/
4. CWE-119 — Improper Restriction of Operations within the Bounds of a Memory Buffer: https://cwe.mitre.org/data/definitions/119.html
5. ATT&CK Technique T1210 — Exploitation of Remote Services: https://attack.mitre.org/techniques/T1210/

Known threat actor campaigns or exploit-in-the-wild evidence: The NVD description states "The exploit is now public and may be used," confirming public exploit knowledge. However, no specific threat actor campaigns or in-the-wild exploitation observations were recorded in the provided intelligence data at the time of writing. CISA KEV status is NO, indicating the vulnerability is not currently listed on the CISA Known Exploited Vulnerabilities catalog. Enterprise teams should nevertheless treat the public exploit as a catalyst for expedited remediation.