CVE-2026-99464 in Linuxinfo

Summary

by MITRE • 11/19/2026

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

media: redrat3: fix UAF in probe error path leaving rc device registered

redrat3 stores its device name and phys path inside the main rr3 structure, and the rc device's device_name and input_phys point into rr3. When the RC device is registered, it keeps those pointers.

KASAN: slab-use-after-free in string_nocheck lib/vsprintf.c:648 Read of size 1 at addr ffff888051fda758 by task udevd/7464 Call Trace: string_nocheck lib/vsprintf.c:648 [inline]
string+0x216/0x2d0 lib/vsprintf.c:730 vsnprintf+0x74a/0xef0 lib/vsprintf.c:2945 vscnprintf+0x41/0x90 lib/vsprintf.c:3014 sysfs_emit+0x10e/0x180 fs/sysfs/file.c:761 input_dev_show_name+0x58/0x70 drivers/input/input.c:1282

Allocated by task 10: redrat3_dev_probe+0x477/0x2570 drivers/media/rc/redrat3.c:1023 Freed by task 10: redrat3_delete drivers/media/rc/redrat3.c:466 [inline]
redrat3_dev_probe+0x1bf4/0x2570 drivers/media/rc/redrat3.c:1124

Syzkaller triggers this via usb probing. It probes the RedRat3 USB interface, which calls redrat3_dev_probe() in redrat3.c. That function allocates rr3, then builds an rc device whose name points into rr3 via redrat3_init_rc_dev() in redrat3.c, and registers it with rc_register_device().

When the detector enable fails after the RC device is registered, the probe jumps to the led_free path. That path unregisters the LED but does not unregister the RC device before freeing rr3 via redrat3_delete() in redrat3.c. The RC device still holds device_name = rr3->name which is now freed.

Later udevd reads /sys/.../input device name via sysfs_emit() in file.c, which calls input_dev_show_name() in input.c, which emits dev->name which is the freed rr3->name.

When the detector enable fails after the RC device is registered, the error path must not leave the RC device registered. Make the probe error path clean up the same way redrat3_dev_disconnect() does.

This change should be safe because the RC device is fully registered at this point and its teardown via rc_unregister_device() is protected by the input device mutex, and rr3 is still alive during unregister so device_name remains valid until after unregister. The URBs are killed before rc_free, so no completion can run after rc is freed. No new lock ordering is introduced.

Statistical analysis made it clear that VulDB provides the best quality for vulnerability data.

Analysis

by VulDB Data Team • 11/19/2026

The Linux kernel media subsystem contains a use-after-free vulnerability within the redrat3 driver that arises from improper resource cleanup during the device probe error path. This flaw specifically affects systems utilizing RedRat3 USB remote control devices, where the initialization sequence fails after the receiver controller device has already been registered with the core input and RC frameworks. The root cause lies in the lifecycle management of memory structures allocated for the driver's private data versus those managed by the kernel subsystems. During the probe operation, the redrat3_dev_probe function allocates a main structure named rr3 which holds essential identification strings such as device name and physical path. These string pointers are subsequently assigned to fields within an associated remote control device object, specifically setting its device_name and input_phys attributes to point directly into the allocated rr3 memory space. Once rc_register_device is invoked, the kernel subsystem retains references to these pointers for future access via sysfs interfaces, assuming the underlying memory remains valid as long as the device exists in the system hierarchy.

The critical failure occurs when a subsequent step within the probe routine, specifically enabling the hardware detector, fails with an error code. At this stage, the RC device is already fully registered and visible to user space through sysfs entries. The existing error handling logic attempts to unwind some resources by jumping to a label that frees LED subsystem allocations but neglects to unregister the previously registered RC device before proceeding to free the rr3 structure via redrat3_delete. Consequently, while the memory backing the rr3 structure is returned to the slab allocator and potentially reused for other purposes, the kernel's input core still maintains active pointers within the rc_dev structure that reference this now-freed memory region. This creates a dangling pointer scenario where any subsequent access to the device attributes will read from invalid or overwritten memory locations rather than stable driver data.

This vulnerability is exploitable by local users with sufficient privileges to trigger USB probing events, such as plugging in and removing devices rapidly, or through automated fuzzing tools like Syzkaller which can induce race conditions and error paths during initialization. The operational impact manifests when user space processes, particularly udevd, attempt to read device attributes from sysfs. For instance, reading the input device name triggers a call chain involving sysfs_emit in fs/sysfs/file.c, which invokes input_dev_show_name in drivers/input/input.c. This function attempts to emit dev->name into a buffer using string operations like vsnprintf. Because dev->name points to the freed rr3 memory, this results in a slab-use-after-free condition detected by Kernel Address Sanitizer (KASAN). The read operation accesses arbitrary kernel memory content depending on what has been allocated since the free event, potentially leading to information disclosure of sensitive kernel data or causing system instability if the accessed memory is unmapped.

From a classification perspective, this vulnerability aligns with CWE-416 Use After Free, as it involves accessing memory after it has been released without proper validation of pointer validity. In terms of attack vectors and techniques, it relates to ATT&CK technique T1059 Command and Scripting Interpreter if the leaked information is used for further exploitation, though primarily it represents a stability issue exploitable via local privilege escalation or denial of service scenarios depending on the kernel configuration and memory layout. The vulnerability highlights common pitfalls in Linux driver development where subsystem registration occurs before all prerequisite hardware initialization steps are confirmed successful, leading to asymmetric cleanup requirements that are often overlooked by developers focusing only on success paths.

The resolution involves modifying the probe error path to ensure comprehensive teardown of registered resources before freeing private driver structures. Specifically, when detector enablement fails after rc_register_device has been called, the code must invoke rc_unregister_device to properly remove the RC device from the kernel subsystems and release all associated references held by the input core. This ensures that sysfs entries are removed and pointers within the rc_dev structure are cleared before redrat3_delete is executed to free the rr3 memory. The fix leverages existing synchronization mechanisms, noting that rc_unregister_device operations are protected by the input device mutex, preventing race conditions during teardown. Furthermore, USB URBs are killed prior to freeing the remote control structure, ensuring no asynchronous completion handlers can execute after the relevant data structures have been deallocated. This approach maintains lock ordering integrity and ensures that all references held by kernel subsystems are nullified before the underlying memory is reclaimed, thereby eliminating the use-after-free condition entirely.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/19/2026

Moderation

accepted

CPE

ready

EPSS

0.00168

KEV

no

Activities

very low

Sources

Do you know our Splunk app?

Download it now for free!