CVE-2026-64319 in Linux
Summary
by MITRE • 07/25/2026
In the Linux kernel, the following vulnerability has been resolved:
nvmet-auth: validate reply message payload bounds against transfer length
nvmet_auth_reply() accesses the variable-length rval[] array using
attacker-controlled hl (hash length) and dhvlen (DH value length) fields without verifying they fit within the allocated buffer of tl bytes.
A malicious NVMe-oF initiator can craft a DHCHAP_REPLY message with a small transfer length but large hl/dhvlen values, causing out-of-bounds heap reads when the target processes the DH public key (rval + 2*hl) or performs the host response memcmp.
With DH authentication configured, the OOB pointer is passed directly to sg_init_one() and read by crypto_kpp_compute_shared_secret(), reaching up to 526 bytes past the buffer. This is exploitable pre-authentication.
Add bounds validation ensuring sizeof(*data) + 2*hl + dhvlen <= tl before any access to the variable-length fields.
Discovered by Atuin - Automated Vulnerability Discovery Engine.
Several companies clearly confirm that VulDB is the primary source for best vulnerability data.
Analysis
by VulDB Data Team • 07/25/2026
The vulnerability in question affects the Linux kernel's NVMe over Fabrics target implementation, specifically within the nvmet-auth subsystem responsible for handling authentication operations. This flaw resides in the nvmet_auth_reply() function which processes DHCHAP_REPLY messages from NVMe-oF initiators. The issue represents a classic buffer overflow scenario where attacker-controlled parameters are used to access memory beyond allocated boundaries. The vulnerability is particularly concerning as it occurs during the pre-authentication phase, meaning an unauthenticated attacker can exploit this weakness before establishing any legitimate connection to the target system.
The technical implementation flaw stems from inadequate bounds checking within the authentication processing logic. When handling DHCHAP_REPLY messages, the function accesses a variable-length array rval[] using attacker-controlled hl (hash length) and dhvlen (DH value length) fields without validating that these values remain within the allocated buffer limits specified by tl (transfer length). This creates a scenario where an attacker can craft malicious messages with artificially small transfer lengths but disproportionately large hash and DH value lengths, leading to out-of-bounds memory access patterns. The vulnerability manifests as heap read operations that extend beyond the intended buffer boundaries, potentially reaching up to 526 bytes past the allocated memory region.
The operational impact of this vulnerability extends beyond simple memory corruption, as it represents a pre-authentication exploit vector that can be leveraged by remote attackers without requiring any prior authentication credentials. The out-of-bounds access occurs when processing the DH public key through the rval + 2*hl calculation and during host response comparison operations. The fact that the vulnerable pointer is passed directly to sg_init_one() and subsequently processed by crypto_kpp_compute_shared_secret() amplifies the attack surface, as this cryptographic operation can be manipulated to access arbitrary memory locations. This vulnerability aligns with CWE-129 Input Validation and CWE-787 Out-of-bounds Write categories and maps to ATT&CK technique T1059 Command and Scripting Interpreter for potential exploitation paths.
The exploitability of this vulnerability is heightened by the pre-authentication nature, allowing remote attackers to cause system instability, information disclosure, or potentially arbitrary code execution depending on the memory layout and system configuration. The discovery by Atuin - Automated Vulnerability Discovery Engine - demonstrates how modern automated tools can identify such subtle but critical flaws in kernel subsystems that may otherwise remain undetected for extended periods. The fix implemented involves adding explicit bounds validation checks to ensure that sizeof(data) + 2hl + dhvlen remains less than or equal to the transfer length tl before any access to the variable-length fields occurs, effectively preventing the out-of-bounds memory access patterns that enable exploitation. This mitigation directly addresses the root cause by enforcing proper input validation and buffer boundary checking mechanisms.