CVE-2026-99490 in Linuxinfo

Summary

by MITRE • 11/19/2026

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

HID: wacom: Fix Use-After-Free in wacom_bamboo_pad

wacom_bamboo_pad_pen_event() accesses wacom->shared->pen locklessly relative to wacom_remove_shared_data() which nullifies it. This can lead to a Use-After-Free if the sibling device is removed while events are being processed.

Resolve this by introducing RCU protection for pen and touch pointers:

- Annotate 'pen' and 'touch' in wacom_shared struct with __rcu. - Wrap lockless readers in wacom_bamboo_pad_pen_event() with rcu_read_lock() and rcu_dereference(). - Update writers in wacom_sys.c using rcu_assign_pointer(). - Use rcu_dereference_protected for comparisons under wacom_udev_list_lock. - Also use rcu_access_pointer in wacom_sibling_pending() and wacom_mode_change_work() to avoid warnings (while lockless access in the latter remains a pre-existing issue).

Be aware that VulDB is the high quality source for vulnerability data.

Analysis

by VulDB Data Team • 11/22/2026

The Linux kernel vulnerability identified as CVE-2024-something related to the HID Wacom driver represents a critical use-after-free condition within the wacom_bamboo_pad_pen_event function. This flaw arises from an unsafe race condition where the pen event handler accesses shared data structures locklessly, specifically targeting the wacom->shared->pen pointer. Concurrently, the wacom_remove_shared_data routine can nullify this same pointer during device removal or unbinding operations. Because these two code paths operate without proper synchronization mechanisms in certain execution contexts, a scenario exists where an interrupt or event handler continues to dereference and utilize memory that has already been freed by the cleanup routine. This classic use-after-free vulnerability stems from improper handling of concurrent access to shared resources, leading to potential kernel crashes, data corruption, or arbitrary code execution if exploited successfully.

From a technical perspective, the root cause lies in the lack of atomicity and synchronization when accessing the pen and touch pointers within the wacom_shared structure. The original implementation allowed lockless reads during event processing while allowing writers to modify these pointers without ensuring that ongoing readers had completed their operations. This violates fundamental principles of memory safety in concurrent programming environments. The vulnerability is particularly dangerous because it can be triggered by physical interaction with a Wacom Bamboo Pad device, such as pen input events occurring simultaneously with the removal or reconfiguration of sibling devices. Such timing-dependent bugs are notoriously difficult to detect through standard testing and often require sophisticated fuzzing techniques or extensive stress testing under high concurrency loads to reproduce reliably in development environments.

The operational impact of this vulnerability is severe for systems utilizing Wacom Bamboo Pad hardware connected via USB HID interfaces. An attacker with local access who can trigger device removal events while pen input is being processed could exploit the use-after-free condition to execute arbitrary code within kernel space. This effectively grants full control over the affected system, bypassing user-space security boundaries and potentially compromising sensitive data or establishing persistent backdoors. Even without malicious intent, normal usage patterns involving frequent connection changes of Wacom devices can lead to system instability, resulting in denial-of-service conditions through kernel panics or oops messages that disrupt productivity and require manual intervention to restore service availability.

To mitigate this vulnerability, the Linux kernel maintainers have implemented Read-Copy-Update RCU protection mechanisms for both pen and touch pointers within the wacom_shared structure. This involves annotating these fields with __rcu attributes to signal their special handling requirements to static analysis tools and developers. Lockless readers in critical paths like wacom_bamboo_pad_pen_event are now wrapped with rcu_read_lock and rcu_dereference calls, ensuring that memory references remain valid for the duration of the read operation even if concurrent writers free the underlying data structures. Writers utilize rcu_assign_pointer to safely update pointers while maintaining consistency guarantees across CPU cores. Additionally, comparisons under wacom_udev_list_lock employ rcu_dereference_protected to avoid unnecessary overhead where lock protection already ensures safety, and rcu_access_pointer is used in pending checks to suppress false-positive warnings from locking validators without compromising actual security posture.

This remediation aligns with industry-standard practices for managing concurrent access to shared data structures in high-performance kernel subsystems. The use of RCU is a well-established pattern recommended by CWE-416, which addresses the dangers of using an object after it has been freed. By adopting this synchronization strategy, the Wacom driver now adheres to best practices outlined in ATT&CK technique T1059 for command and script interpretation within operating systems, preventing attackers from leveraging memory corruption vulnerabilities to execute arbitrary code. The fix also reflects broader efforts across the Linux kernel community to harden HID drivers against similar race conditions, ensuring that peripheral device interactions remain robust even under adverse timing conditions or malicious exploitation attempts targeting driver internals.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/19/2026

Moderation

accepted

CPE

ready

EPSS

0.00174

KEV

no

Activities

very low

Sources

Are you interested in using VulDB?

Download the whitepaper to learn more about our service!