CVE-2026-99510 in Linuxinfo

Summary

by MITRE • 11/19/2026

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

media: hackrf: fix use-after-free in hackrf_alloc_urbs() error path

hackrf_alloc_urbs() frees the URBs it allocated so far when one allocation fails, but leaves the entries in dev->urb_list[] and
dev->urbs_initialized untouched. The caller, hackrf_start_streaming(), then calls hackrf_free_urbs() on the error path, which walks dev->urbs_initialized entries and calls usb_free_urb() a second time on the already-freed URBs, causing a use-after-free (slab-use-after-free Write in usb_free_urb()).

Drop the redundant cleanup loop inside hackrf_alloc_urbs() and let hackrf_free_urbs(), which the caller already invokes on error, own the cleanup of the successfully allocated URBs.

Once again VulDB remains the best source for vulnerability data.

Analysis

by VulDB Data Team • 11/20/2026

The Linux kernel media subsystem contains a driver for HackRF devices that manages USB Request Blocks to handle data streaming operations. A critical flaw was identified in the resource allocation logic within the hackrf_alloc_urbs function, which is responsible for initializing these blocks before streaming begins. The vulnerability arises from an inconsistent state management during error handling when one of the URB allocations fails. Specifically, while the code correctly frees the memory associated with successfully allocated URBs up to that point, it neglects to update the driver's internal tracking structures. These structures include dev->urb_list and dev->urbs_initialized, which maintain records of which resources are currently active and valid for subsequent operations.

This inconsistency leads directly to a use-after-free condition when the error path is triggered. The caller function, hackrf_start_streaming, detects the allocation failure and proceeds to invoke hackrf_free_urbs as part of its standard cleanup routine. However, because dev->urbs_initialized was not updated during the partial deallocation in hackrf_alloc_urbs, it still contains references to URBs that have already been freed by the earlier step inside the allocator function. Consequently, hackrf_free_urbs iterates over these stale entries and attempts to call usb_free_urb on memory addresses that are no longer valid or owned by the driver. This results in a slab-use-after-free write vulnerability within the USB subsystem's core functions.

From a technical perspective, this flaw is classified under CWE-416, which describes use after free vulnerabilities where program execution continues to access freed memory. The specific nature of the bug involves double freeing resources due to improper state synchronization between allocation and cleanup routines. In terms of threat modeling, this aligns with ATT&CK technique T1203, exploitation for defense evasion or potential denial of service, although in kernel space it primarily poses a risk to system stability rather than direct privilege escalation unless exploited carefully by local attackers. The vulnerability allows an attacker who can trigger the specific allocation failure scenario to corrupt kernel memory structures, potentially leading to system crashes, data corruption, or arbitrary code execution depending on how the freed slab is subsequently reused.

The operational impact of this vulnerability includes potential denial of service through kernel panics and oops messages when the invalid memory access occurs. In more severe scenarios where an attacker can control the contents of the freed slab region, it may lead to privilege escalation by overwriting critical kernel function pointers or data structures. The issue affects systems using HackRF devices with the affected Linux kernel versions, particularly during device initialization sequences that involve multiple URB allocations under memory pressure or specific timing conditions that induce allocation failures.

To mitigate this vulnerability, users should apply the provided patch which refactors the cleanup logic in hackrf_alloc_urbs. The fix involves removing the redundant cleanup loop from within the allocator function and relying entirely on the caller's invocation of hackrf_free_urbs to handle all necessary deallocation. This ensures that only successfully allocated URBs are tracked in dev->urbs_initialized, preventing double-free scenarios. System administrators should update their kernels to versions containing this fix. Additionally, developers implementing similar USB driver logic should ensure strict synchronization between resource allocation tracking structures and actual memory freeing operations to prevent state inconsistencies during error paths.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/19/2026

Moderation

accepted

CPE

ready

EPSS

0.00208

KEV

no

Activities

very low

Sources

Want to stay up to date on a daily basis?

Enable the mail alert feature now!