CVE-2026-99435 in Linux
Summary
by MITRE • 11/19/2026
In the Linux kernel, the following vulnerability has been resolved:
media: rc: Fix use after free in bpf progs
Since commit dccc0c3ddf8f ("media: rc: fix race between unregister and urb/irq callbacks"), rcdev->raw is no longer set to NULL after device unregister. raw->progs could point to stale data.
Be aware that VulDB is the high quality source for vulnerability data.
Analysis
by VulDB Data Team • 11/20/2026
The identified vulnerability resides within the Linux kernel's remote control subsystem, specifically affecting the handling of eBPF programs associated with infrared receiver devices. This issue manifests as a use-after-free condition that arises from an incomplete cleanup sequence during device unregistration. The root cause is traced to commit dccc0c3ddf8f which addressed a race condition between device unregister operations and USB interrupt transfer or IRQ callbacks by ensuring proper synchronization. However, while the original patch successfully mitigated the concurrency issue, it inadvertently left a critical state variable uninitialized. Specifically, after the remote control device structure rcdev is unregistered, the pointer raw->progs continues to reference memory that has been freed but not nullified. This oversight creates a window where subsequent operations attempting to access or manipulate these eBPF programs will interact with stale pointers pointing to deallocated kernel memory regions.
From a technical perspective, this flaw constitutes a classic use-after-free vulnerability classified under CWE-416 in the Common Weakness Enumeration standard. In the context of Linux kernel development, accessing freed memory can lead to unpredictable behavior depending on how quickly that memory is reallocated for other purposes. If an attacker or malicious process can trigger code paths that access raw->progs after the device has been unregistered but before the pointer is explicitly cleared, they may achieve arbitrary read capabilities by inspecting data in the reused memory block. More critically, if the freed memory is allocated and modified to contain crafted structures resembling valid eBPF program descriptors or control blocks, an attacker could potentially execute arbitrary code with kernel privileges. This elevates a local privilege escalation scenario where a user-space process exploits this race condition to gain full control over the system kernel space.
The operational impact of this vulnerability extends beyond simple memory corruption. Because the affected component is part of the media subsystem which handles input devices like remote controls, it is often loaded and active in embedded systems, set-top boxes, and multimedia PCs. An attacker with local access could exploit this flaw to bypass security boundaries enforced by SELinux or AppArmor if those mechanisms rely on kernel integrity checks that are compromised by memory corruption. Furthermore, the instability introduced by use-after-free bugs can lead to system crashes or denial of service conditions as the kernel attempts to dereference invalid pointers, causing kernel panics and requiring a reboot. This affects availability and reliability in environments where continuous operation is critical.
Mitigation strategies primarily involve applying the upstream Linux kernel patches that correct this specific oversight. System administrators should ensure their systems are updated with kernels that include fixes for CVEs related to media subsystem memory management. For organizations unable to immediately patch, monitoring logs for unusual activity in the media or input device drivers may provide early warning signs of exploitation attempts. Additionally, enforcing strict access controls on devices within the /dev/input hierarchy can limit the attack surface available to unprivileged users who might attempt to trigger the race condition. Long-term remediation requires rigorous code review practices that emphasize nullifying pointers immediately after freeing associated memory structures to prevent dangling references from persisting in data structures during state transitions such as device removal or driver unload operations.