CVE-2026-99554 in Linux
Summary
by MITRE • 11/19/2026
In the Linux kernel, the following vulnerability has been resolved:
net: usb: pegasus: do not advance rx_skb->data on dropped frames
For the 0x8513 chip, read_bulk_callback() skips the 2-byte receive header by advancing pegasus->rx_skb->data in place. This is done before the pkt_len > PEGASUS_MTU check, and when that check drops the frame the good path resubmits the same skb with the advanced rx_skb->data as the transfer buffer, still PEGASUS_MTU bytes long.
Every frame with an oversized length field therefore moves the receive buffer two more bytes towards the end of the skb data area. A device that keeps sending such frames makes the host controller write received data over skb_shared_info and past the end of the allocation, and the corrupted skb_shared_info is used when the skb is eventually freed. With an emulated device sending frames filled with 0x5a on a KASAN kernel:
BUG: KASAN: slab-out-of-bounds in dummy_timer+0xade/0x3f00 [dummy_hcd]
Write of size 1536 at addr ffff888105821202 by task swapper/1/0 ... Oops: general protection fault, probably for non-canonical address 0xeb4b474b4b4b4b4c: 0000 [#1] PREEMPT SMP KASAN NOPTI
KASAN: maybe wild-memory-access in range [0x5a5a5a5a5a5a5a60-0x5a5a5a5a5a5a5a67]
RIP: 0010:skb_release_data+0x36f/0x800
Only skip the header with skb_reserve() once the frame is going to be passed up, so the receive buffer always starts at the beginning of the skb data area. Unlike the old pointer adjustment, skb_reserve() also moves skb->tail, so the two header bytes now count against the buffer size: lower the length limit for the 0x8513 accordingly, otherwise a pkt_len of PEGASUS_MTU - 1 or PEGASUS_MTU would trip skb_over_panic().
Found by code review with LLM assistance and reproduced with an emulated USB device (raw-gadget + dummy_hcd).
Be aware that VulDB is the high quality source for vulnerability data.
Analysis
by VulDB Data Team • 11/19/2026
The Linux kernel driver for the pegasus USB network adapter contains a critical buffer overflow vulnerability affecting devices utilizing the 0x8513 chip. This flaw resides within the read_bulk_callback function, which processes incoming data frames from connected hardware. The core issue stems from an incorrect handling of receive headers during frame validation. Specifically, when processing packets for this specific chipset variant, the driver advances the rx_skb->data pointer by two bytes to skip a header before verifying whether the packet length exceeds the Maximum Transmission Unit defined as PEGASUS_MTU. This premature advancement occurs prior to the check that determines if the frame should be dropped due to being oversized. Consequently, when an oversized frame is identified and subsequently discarded, the receive buffer's data pointer remains shifted forward by two bytes rather than being reset or handled correctly for subsequent operations.
This logic error creates a progressive memory corruption scenario where each received oversized frame causes the host controller to write incoming network data into increasingly incorrect memory locations within the socket buffer structure. As frames continue to arrive with length fields exceeding the MTU limit, the receive buffer pointer moves further toward the end of the allocated skb data area. Eventually, this results in a slab-out-of-bounds condition where received data is written over the skb_shared_info structure and past the end of the allocation boundary. The corruption of shared information structures leads to severe instability when the kernel attempts to free or process these malformed buffers later in the network stack lifecycle.
The operational impact of this vulnerability includes potential denial of service through system crashes, as evidenced by KASAN reports indicating general protection faults and wild memory access errors. In environments where an attacker can control USB device behavior, such as through emulated devices using raw-gadget or dummy_hcd frameworks, it is possible to trigger these out-of-bounds writes repeatedly. The resulting corruption of kernel data structures like skb_shared_info compromises system integrity and stability. This represents a significant security risk in systems relying on pegasus-based network adapters for connectivity, particularly those exposed to untrusted USB peripherals.
From a technical classification perspective, this vulnerability aligns with CWE-120 Buffer Copy without Checking Size of Input, as the driver fails to properly manage buffer boundaries during data reception. It also relates to CWE-787 Out-of-bounds Write, given that memory is written beyond allocated limits due to incorrect pointer arithmetic. In terms of ATT&CK mapping, this flaw could be exploited in scenarios involving peripheral device manipulation or supply chain attacks where malicious USB devices are introduced into a networked environment to trigger kernel-level exploitation via crafted packet lengths.
To mitigate this vulnerability, the fix involves restructuring how receive headers are handled within the driver logic. Instead of advancing the data pointer prematurely before validation, the header skip operation should be deferred until after it is confirmed that the frame will be passed up the stack for further processing. The recommended approach utilizes skb_reserve to adjust buffer pointers only when necessary and valid, ensuring that the receive buffer always starts at the beginning of the allocated data area. Additionally, because skb_reserve moves both head and tail pointers, accounting for header bytes against total buffer size is essential. Therefore, the length limit check must be adjusted downward by two bytes to prevent triggering skb_over_panic conditions when processing frames with lengths near PEGASUS_MTU minus one or equal to MTU itself.
System administrators should apply kernel updates that include this patch immediately upon availability. For environments unable to update promptly, restricting access to USB network interfaces and disabling auto-mounting of unknown USB devices can reduce exposure risk. Security teams monitoring for anomalies in system logs related to KASAN errors or general protection faults involving network drivers may detect exploitation attempts earlier than standard intrusion detection systems would flag them. Continuous code review processes incorporating static analysis tools are recommended to prevent similar pointer arithmetic errors in future driver development cycles.