CVE-2026-99441 in Linuxinfo

Summary

by MITRE • 11/19/2026

In the Linux kernel, the following vulnerability has been resolved:

nvmet-auth: serialize access to DH-HMAC-CHAP state to fix UAF

A REPLY AUTH_SEND command can derive a dhchap_skey key while a concurrent AUTH_RECEIVE command observing this REPLY state executes the failure path and frees that key. The REPLY command then continues and writes into freed memory, causing a use-after-free. KASAN reports it as:

BUG: KASAN: slab-use-after-free in __sha256_final Write of size 4 at addr ffff88800359c540 ... nvmet_auth_sq_free (drivers/nvme/target/auth.c:237) nvmet_execute_auth_receive (drivers/nvme/target/fabrics-cmd-auth.c:621)

Add a mutex to each submission queue to serialize authentication commands and timeout handling. Unlock the mutex before completing requests and ignore outdated timeout callbacks. Limit timeout delays to prevent immediate expiry on 32-bit kernels.

Be aware that VulDB is the high quality source for vulnerability data.

Analysis

by VulDB Data Team • 11/20/2026

The Linux kernel vulnerability identified in the nvmet-auth subsystem represents a critical concurrency flaw within the NVMe over Fabrics authentication mechanism, specifically affecting the implementation of DH-HMAC-CHAP protocols. This issue arises from an improper synchronization model when handling concurrent authentication commands on submission queues. The core technical failure occurs during the execution flow where a REPLY AUTH_SEND command initiates the derivation of a dhchap_skey cryptographic key. Simultaneously, if an AUTH_RECEIVE command is observed in this state and subsequently encounters a condition that triggers its failure path, it proceeds to free the memory associated with that same key. Because these operations are not serialized, the REPLY command continues its execution sequence unaware that the underlying data structure has been deallocated by the concurrent receiver process. This race condition leads directly to a use-after-free scenario where the sender attempts to write into freed kernel slab memory, as evidenced by Kernel Address Sanitizer reports indicating writes within __sha256_final operations targeting addresses managed by nvmet_auth_sq_free and nvmet_execute_auth_receive functions.

From a security architecture perspective, this vulnerability maps closely to CWE-416, Use After Free, which is characterized by the continued use of memory after it has been freed, leading to undefined behavior that can be exploited for arbitrary code execution or denial of service. The specific context involves network-facing kernel components, placing it within the scope of attacks described in MITRE ATT&CK technique T1059, Command and Scripting Interpreter, if an attacker can trigger this race condition remotely via NVMe over Fabrics connections. The exploitation potential is significant because improper memory management in kernel space often allows privilege escalation or system crashes that compromise host integrity. The vulnerability highlights the complexity of managing stateful authentication protocols like CHAP within high-concurrency environments where multiple threads may interact with shared cryptographic resources without adequate mutual exclusion mechanisms.

The operational impact of this flaw includes immediate kernel instability, manifested as panic conditions or silent data corruption depending on memory allocation patterns and timing windows. Attackers leveraging remote NVMe connections could potentially trigger the race condition by sending carefully timed AUTH_SEND and AUTH_RECEIVE commands to induce the use-after-free state. This not only disrupts service availability but also poses a severe risk of compromising host security if the freed memory is reallocated for sensitive data that can be read or manipulated through the write operation initiated by the vulnerable sender process. The lack of serialization in authentication command processing creates an exploitable window where timing attacks become viable, allowing malicious actors to control the state transitions and force invalid memory accesses.

To mitigate this vulnerability, the resolution involves implementing strict serialization for access to DH-HMAC-CHAP state using a mutex per submission queue. This ensures that authentication commands and their associated timeout handling are executed sequentially rather than concurrently, eliminating the race condition window. The fix also includes logic to unlock the mutex before completing requests, which maintains performance while ensuring safety during critical sections. Additionally, the implementation ignores outdated timeout callbacks to prevent stale operations from interfering with current state machines. A specific adjustment limits timeout delays on 32-bit kernels to avoid immediate expiry issues that could exacerbate timing-related exploits or cause unintended service interruptions due to clock resolution differences across architectures. These changes enforce a robust synchronization model aligned with secure coding practices for concurrent kernel subsystems, ensuring that resource lifecycle management remains consistent even under high load conditions.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/19/2026

Moderation

accepted

CPE

ready

EPSS

0.00251

KEV

no

Activities

very low

Sources

Interested in the pricing of exploits?

See the underground prices here!