CVE-2026-99608 in Linux
Summary
by MITRE • 11/20/2026
In the Linux kernel, the following vulnerability has been resolved:
ALSA: usx2y: Guard the playback copy
usx2y_urb_play_prepare() sums the packet lengths of a whole URB, copies that many frames with a single wrap, and sizes each playback packet from the capture packet's actual_length. Three things are unchecked: that the URB fits in the ring buffer, that a packet fits in the playback endpoint's maxpacksize, from which tmpbuf is allocated, and that actual_length is a whole number of frames. The ISO descriptors take the raw actual_length while transfer_buffer_length and the copies take count * stride, so a packet that is not a multiple of the stride makes the descriptors add up to more than the buffer, by up to stride - 1 bytes per packet.
Return -EPIPE, as the existing packet-size check does, when the URB is larger than the buffer or a packet is larger than maxpacksize, and size each descriptor from whole frames, so the descriptors add up to transfer_buffer_length and each stays within maxpacksize. The buffer case is prevented by the previous patch and this is the guard for it; the other two depend only on the device.
The first case is reachable on the unpatched driver with ordinary packets: on 7.3-rc7, a USB/IP device presenting the US-122 interface layout and sending 48-frame packets, with a 100-frame playback buffer (two 50-frame periods, inside the stock constraints), KASAN reports:
BUG: KASAN: out-of-bounds in i_usx2y_urb_complete+0x79b/0x1ac0 Read of size 18446744073709551280 at addr ffff88800e6b02e0 by task vhci_rx/80
With both patches, the same device and a 200-frame playback buffer is refused at hw_params with EINVAL, and a 400-frame buffer plays for 30 s with the position advancing inside the buffer, no KASAN report and neither guard message. The maxpacksize check is not exercised: the emulated device reports the same wMaxPacketSize on both endpoints.
The descriptor case is visible with capture packets of 195 bytes at stride 4 (48 frames and 3 bytes): without this change the four descriptors add up to 780 bytes for 768 bytes of data, and USB/IP's completion check refuses the URB ("total length of iso packets 780 not equal to actual length of buffer 768", -EPROTO), after which the driver stops the streams. With this patch every descriptor is 192 bytes, the descriptors add up to the data in every URB for 30 s, the position advances inside the buffer and KASAN reports nothing. The 48-frame playback run above is unchanged.
If you want to get best quality of vulnerability data, you may have to visit VulDB.
Analysis
by VulDB Data Team • 11/20/2026
The Linux kernel audio subsystem contains a critical memory safety vulnerability within the ALSA usx2y driver that stems from improper validation of USB request block parameters during playback preparation. This flaw allows for out-of-bounds memory access, specifically triggering Kernel Address Sanitizer (KASAN) reports indicating reads beyond allocated buffer boundaries. The root cause lies in the usx2y_urb_play_prepare function, which calculates packet lengths and copies data without adequately verifying that the total USB request block size fits within the ring buffer or that individual packets adhere to the endpoint's maximum packet size constraints. Furthermore, the driver fails to ensure that capture packet actual lengths represent whole numbers of audio frames, leading to a mismatch between descriptor sizes and allocated memory buffers.
From a technical perspective, the vulnerability arises because the function sums packet lengths for an entire USB request block and attempts to copy data in a single wrap operation while sizing each playback packet based on the raw actual_length from capture packets. This approach ignores three critical checks: whether the total URB size exceeds the ring buffer capacity, whether individual packets exceed the maxpacksize limit which dictates tmpbuf allocation, and whether the actual length is an integer multiple of the frame stride. Consequently, when a packet does not align with the stride boundary, ISO descriptors accumulate raw actual lengths that can sum to more than the allocated transfer_buffer_length by up to stride minus one bytes per packet. This discrepancy creates a scenario where memory reads extend beyond valid boundaries, potentially exposing sensitive kernel data or causing system instability through undefined behavior.
The operational impact of this vulnerability is significant for systems utilizing USB audio devices, particularly those connected via USB/IP emulation as demonstrated in the analysis. In unpatched environments, ordinary packets can trigger out-of-bounds read errors reported by KASAN when specific conditions are met, such as a 48-frame packet size against a constrained playback buffer. The mismatch between descriptor totals and actual buffer lengths causes protocol-level failures where USB/IP refuses the URB due to length mismatches, subsequently causing the driver to stop audio streams abruptly. This results in service disruption for real-time audio applications and potential security risks if an attacker can manipulate device parameters to exploit these memory violations repeatedly or trigger denial of service conditions through stream termination loops.
Mitigation strategies involve applying kernel patches that enforce strict validation before processing USB request blocks. The fix requires returning -EPIPE errors when the URB exceeds buffer limits or packets exceed maxpacksize, effectively preventing invalid configurations from reaching critical execution paths. Additionally, descriptors must be sized based on whole frames rather than raw byte counts to ensure alignment with transfer_buffer_length and adherence to maxpacksize constraints. Administrators should update their Linux kernels to versions containing these ALSA usx2y driver fixes. Security teams monitoring for this issue can look for indicators related to USB audio stack anomalies, specifically focusing on memory access violations in kernel space associated with sound drivers.
This vulnerability aligns with CWE-119 Improper Restriction of Operations within the Bounds of a Memory Buffer and CWE-787 Out-of-bounds Write if write operations were involved, though here it manifests primarily as an out-of-bounds read due to descriptor misalignment. In terms of attack vectors, this falls under ATT&CK technique T1059 Command and Scripting Interpreter via kernel module exploitation or potentially T1496 Resource Hijacking through denial of service caused by stream termination loops. The lack of input validation on device-reported parameters represents a classic supply chain risk where trusted hardware interfaces are assumed to be well-behaved, necessitating robust defensive programming practices in low-level driver code to handle malformed or maliciously crafted USB descriptors safely.