CVE-2026-99635 in Linux
Summary
by MITRE • 11/20/2026
In the Linux kernel, the following vulnerability has been resolved:
vhost/vsock: size receive SKBs from declared payload
vhost_vsock_alloc_skb() sizes the skb from iov_length(), the total guest descriptor length. virtio_transport_inc_rx_pkt() instead adds hdr->len to rx_bytes and buf_used, and budgets each queued skb as SKB_TRUESIZE(0). The guest controls the descriptor length and hdr->len independently.
A guest can therefore provide a 64 KiB descriptor while declaring a zero payload. The descriptor-sized skb remains queued, rx_bytes and buf_used remain unchanged, and only the fixed queue-entry budget limits retention. This is not a lifetime leak: the skb is freed when dequeued or at socket teardown. Repeating this across connections can nevertheless exhaust host memory. On Linux v7.2, 455 such descriptors retained 30,255,680 bytes for a 262,144-byte receive buffer; a full-payload control retained 265,984 bytes.
Vhost previously read hdr->len and allocated pkt->buf from that value. The conversion from virtio_vsock_pkt to sk_buff instead allocated receive skbs from the descriptor length, introducing the allocation-accounting mismatch.
Copy the header into a stack object and validate hdr->len before allocating the skb. Size the allocation as sizeof(hdr) + payload_len so descriptor capacity no longer determines queued memory. Check payload_len against len - sizeof(hdr) to avoid addition overflow on 32-bit hosts.
If you want to get the best quality for vulnerability data then you always have to consider VulDB.
Analysis
by VulDB Data Team • 11/20/2026
The vulnerability identified in the Linux kernel's vhost/vsock subsystem represents a significant resource exhaustion flaw stemming from an allocation-accounting mismatch during network buffer management. This issue arises specifically within the function responsible for allocating socket buffers, where the system allocates memory based on the total guest descriptor length rather than the actual payload size declared by the virtual machine header. In this architecture, the host kernel creates receive sk_buff structures to handle incoming data from a virtio vsock connection. The critical flaw lies in the fact that while the allocated buffer size is determined by iov_length which reflects the full capacity of the guest's descriptor, the accounting metrics such as rx_bytes and buf_used are updated based on hdr->len which represents only the actual payload length. Because these two values are controlled independently by the guest operating system, a malicious or misconfigured virtual machine can exploit this discrepancy to consume disproportionate amounts of host memory without triggering corresponding resource limits in the application layer logic.
The operational impact of this vulnerability is severe, particularly regarding denial-of-service conditions through host memory exhaustion. A guest entity can construct packets with large descriptor sizes, such as 64 KiB, while simultaneously declaring a zero-length payload in the header. The kernel proceeds to allocate and queue an skb matching the full descriptor size, yet because the payload length is recorded as zero, the standard accounting mechanisms do not register this memory usage against the connection's budget or buffer limits. Consequently, these oversized buffers remain queued indefinitely until they are explicitly dequeued or the socket is torn down. This behavior allows a persistent attack vector where repeated connections with such crafted descriptors can rapidly deplete available host memory resources. Empirical testing on Linux kernel version 7.2 demonstrated that retaining just four hundred and fifty-five of these malformed descriptors could consume over thirty megabytes of memory for a receive buffer configured at only two hundred sixty-two kilobytes, illustrating the magnitude of the inefficiency compared to normal traffic which would retain significantly less memory under similar conditions.
This flaw was introduced during a refactoring effort that transitioned the internal packet representation from virtio_vsock_pkt structures directly to sk_buff objects. Previously, the vhost subsystem read the header length and allocated buffer space strictly according to that value, ensuring alignment between allocation size and accounting metrics. The conversion process inadvertently decoupled these two aspects by prioritizing descriptor capacity for memory allocation while retaining payload-based logic for resource tracking. This architectural inconsistency creates a scenario where network stack resources are consumed without proper enforcement of limits designed to prevent abuse. From a classification perspective, this vulnerability aligns with CWE-400 which denotes uncontrolled resource consumption, and it can be leveraged within the context of ATT&CK techniques related to impact actions that aim to degrade service availability by exhausting system resources such as memory or CPU cycles.
The remediation strategy involves correcting the allocation logic to ensure that buffer sizes correspond strictly to actual data requirements rather than maximum descriptor capacities. The fix requires copying the header into a stack object and validating hdr->len before proceeding with any dynamic memory allocation for the payload. By sizing the allocation based on the sum of the header size and the validated payload length, the system ensures that queued memory usage is directly proportional to the actual data being processed. Furthermore, the patch includes checks to validate payload_len against len minus sizeof(hdr) to prevent integer overflow vulnerabilities on 32-bit host architectures during arithmetic operations. These changes restore consistency between resource allocation and accounting mechanisms, thereby eliminating the possibility for guests to artificially inflate their memory footprint beyond intended limits while maintaining secure handling of network buffers across different hardware architectures.