CVE-2026-99491 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_intuos_pad

wacom_intuos_pad() accesses wacom->shared->touch_input locklessly inside the interrupt handler context. If the Touch sibling device is disconnected, wacom_remove_shared_data() clears 'touch_input' outside any lock, creating a Time-of-Check to Time-of-Use (TOCTOU) race condition where a preempted reader in interrupt context dereferences the freed pointer, leading to a Use-After-Free.

Resolve this by introducing RCU protection for the touch_input pointer:

- Annotate 'touch_input' in wacom_shared struct with __rcu - Wrap all lockless readers in wacom_wac.c with guard(rcu)() and rcu_dereference() using a unified wacom_report_touch_mute() helper - Update writers in wacom_sys.c using rcu_assign_pointer() - Call synchronize_rcu() in wacom_remove_shared_data() to ensure all active RCU readers have finished before the input device is freed

Also wrap wacom_set_shared_values() and touch/pen assignments in wacom_add_shared_data() inside the wacom_udev_list_lock to serialize concurrent probe assignments, and verify that 'shared->touch == hdev' before setting touch_input to prevent concurrent sibling probe state desynchronization.

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 HID Wacom driver contained a critical use-after-free vulnerability within the wacom_intuos_pad function, stemming from improper synchronization of shared data structures during device removal and interrupt processing. The core issue arises because the code accesses the touch_input pointer located in the wacom_shared structure without holding any locks while operating inside an interrupt handler context. This lockless access creates a dangerous window for race conditions when the Touch sibling device is disconnected, as the cleanup routine wacom_remove_shared_data() proceeds to clear and free this pointer outside of any protective locking mechanism. Consequently, if the kernel scheduler preempts the reader in the interrupt context at precisely the moment between checking the validity of the pointer and using it, a Time-of-Check to Time-of-Use race condition occurs. This allows the interrupted code path to dereference memory that has already been freed by the removal routine, leading to undefined behavior, potential kernel panics, or arbitrary code execution depending on how the freed memory is subsequently utilized.

This vulnerability aligns with CWE-416, which describes Use After Free errors where a program continues to use a pointer after it has been freed, often resulting in crashes or security exploits. Furthermore, the specific nature of this race condition between concurrent readers and writers without proper synchronization mechanisms classifies it under CWE-362, Concurrent Execution using Shared Resource with Improper Synchronization. The attack vector involves triggering device disconnection events while simultaneous input processing is occurring via interrupt handlers, allowing an attacker who can influence hardware connection states or exploit local privilege escalation paths to trigger the race condition and corrupt kernel memory state.

To resolve this issue, a comprehensive synchronization strategy was implemented using Read-Copy-Update (RCU) mechanisms to safely manage concurrent access to shared resources without introducing heavy locking overheads that could impact interrupt latency. The touch_input pointer within the wacom_shared structure is now annotated with __rcu attributes to formally declare its RCU protection status. All lockless readers in the wacom_wac.c module are wrapped using guard(rcu)() macros and utilize rcu_dereference() through a unified helper function named wacom_report_touch_mute(). This ensures that any read operation safely obtains a reference to the current pointer value before proceeding with dereferencing operations. On the writer side, located in wacom_sys.c, updates to the touch_input pointer are performed using rcu_assign_pointer(), which provides necessary memory barriers and synchronization guarantees for RCU readers.

Crucially, the fix incorporates synchronize_rcu() calls within the wacom_remove_shared_data function. This ensures that all active RCU read-side critical sections have completed their execution before the underlying input device structure is actually freed from memory. This grace period mechanism prevents premature deallocation and eliminates the window where a preempted interrupt handler could access stale pointers. Additionally, to address potential desynchronization during device initialization, wacom_set_shared_values() and touch or pen assignments within wacom_add_shared_data are now serialized under the wacom_udev_list_lock. A verification step ensures that shared->touch matches hdev before setting touch_input, preventing race conditions between concurrent probe operations from creating inconsistent driver states.

From a defensive perspective, this remediation significantly hardens the kernel against memory corruption vulnerabilities associated with USB HID device management. The adoption of RCU for read-heavy paths like interrupt handlers is consistent with modern Linux kernel best practices for maintaining high performance while ensuring data integrity in multi-threaded or preemption-prone environments. Security practitioners should verify that systems running affected versions of the Linux kernel are updated to include this patch, particularly those utilizing Wacom Intuos tablet hardware where such race conditions could be triggered by physical device manipulation or automated fuzzing tools targeting USB subsystems. The fix also mitigates risks associated with ATT&CK technique T1059, Command and Scripting Interpreter, as use-after-free bugs in kernel space can often serve as primitives for privilege escalation to root level access if exploited effectively through subsequent memory corruption stages.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/19/2026

Moderation

accepted

CPE

ready

EPSS

0.00271

KEV

no

Activities

very low

Sources

Might our Artificial Intelligence support you?

Check our Alexa App!