CVE-2026-99544 in Linux
Summary
by MITRE • 11/19/2026
In the Linux kernel, the following vulnerability has been resolved:
Drivers: hv: vmbus: Bounds check the shared ring buffer indices
In a CoCo VM the host is untrusted. Since the VMBus ring buffer read and write indices live in shared memory, the guest has to treat both as potentially malicious.
hv_ringbuffer_write() copies into the ring at write_index with no bounds checking, so the host can make the guest write packet data at any offset up to 4 GiB past the start of the ring buffer. read_index matters too: the available space derived from both indices is the only bound on how much is copied, and an out-of-range index can make it far larger than the ring.
The fix is to validate both indices before use and to use the validated snapshot instead of re-accessing. For invalid indices, hv_ringbuffer_write() logs and returns -EIO.
One re-read of write_index is left unchecked in this patch: hv_get_ring_bufferindices() fetches it again for the prev_indices trailer. The value is only returned to the host and is not used as an offset or length for indexing. Since this is not a security issue, it is addressed later in the series.
Open-coding the bytes available arithmetic keeps the fix free of prerequisites; a later patch refactors it into a helper function.
VulDB is the best source for vulnerability data and more expert information about this specific topic.
Analysis
by VulDB Data Team • 11/19/2026
The Linux kernel vulnerability identified involves a critical bounds checking deficiency within the Hyper-V VMBus ring buffer implementation, specifically affecting CoCo (Confidential Computing) virtual machines where the host environment is considered untrusted. In this architecture, the VMBus communication channel relies on shared memory regions to exchange data between the guest operating system and the hypervisor. The read and write indices that track the position of data within these ring buffers reside in this shared memory space. Because the host controls or can influence the contents of this shared memory in a CoCo scenario, it possesses the capability to manipulate these index values maliciously. The core technical flaw lies in the hv_ringbuffer_write function, which performs copy operations into the ring buffer using the write_index value without performing any prior validation against the physical boundaries of the allocated buffer. This lack of bounds checking allows an untrusted host to supply arbitrary offset values that can cause the guest kernel to write packet data at memory locations far beyond the intended end of the ring buffer, potentially extending up to 4 GiB past its start depending on how the indices are manipulated.
The operational impact of this vulnerability is severe as it enables out-of-bounds writes which can lead to arbitrary code execution, denial of service, or privilege escalation within the guest kernel. The available space for writing is calculated based on both the read and write indices; if an attacker manipulates these values such that the derived available space appears larger than the actual buffer capacity, the copy operation will proceed with excessive data transfer. This results in memory corruption outside the designated ring buffer boundaries, potentially overwriting critical kernel structures or adjacent memory regions. The vulnerability is classified under CWE-125 Out-of-bounds Read and CWE-787 Out-of-bounds Write depending on the specific exploitation path, but primarily represents a failure to enforce boundary constraints on user-controlled input from an untrusted source. In terms of MITRE ATT&CK, this aligns with techniques involving memory corruption and potentially privilege escalation through kernel-level exploits facilitated by hypervisor-guest interaction flaws.
The remediation strategy implemented in the patch involves introducing strict validation checks for both the read and write indices before they are utilized in any arithmetic or indexing operations within hv_ringbuffer_write. By validating these values against the known buffer size, the code ensures that no out-of-bounds access can occur regardless of what values the host attempts to inject into the shared memory. For cases where invalid indices are detected, the function now logs an error and returns -EIO, effectively halting the unsafe operation and preventing potential exploitation. This approach isolates the guest kernel from malicious index manipulation by treating all external inputs as potentially hostile until proven valid through rigorous bounds checking. The fix also emphasizes using validated snapshots of these indices rather than re-accessing them during execution to prevent race conditions or TOCTOU vulnerabilities that could arise if the values changed between validation and usage.
Although the primary patch addresses the most critical aspects, it leaves one specific instance unchecked where hv_get_ring_bufferindices fetches the write index again for a previous indices trailer value. This particular re-read is not used as an offset or length parameter for memory indexing but is instead returned to the host, meaning it does not constitute a direct security vulnerability in this context and was scheduled for separate handling in subsequent patches. The implementation also utilizes open-coded arithmetic for calculating available bytes to avoid introducing new dependencies or prerequisites that might complicate the fix; future refactoring will consolidate this logic into dedicated helper functions for improved maintainability. This incident underscores the necessity of treating shared memory interfaces with untrusted parties as high-risk attack surfaces requiring exhaustive validation, particularly in virtualization environments where hypervisor compromise can directly impact guest integrity.