CVE-2026-43499
Description
In the Linux kernel, the following vulnerability has been resolved:
rtmutex: Use waiter::task instead of current in remove_waiter()
remove_waiter() is used by the slowlock paths, but it is also used for proxy-lock rollback in rt_mutex_start_proxy_lock() when invoked from futex_requeue().
In the latter case waiter::task is not current, but remove_waiter() operates on current for the dequeue operation. That results in several problems:
1) the rbtree dequeue happens without waiter::task::pi_lock being held
2) the waiter task's pi_blocked_on state is not cleared, which leaves a dangling pointer primed for UAF around.
3) rt_mutex_adjust_prio_chain() operates on the wrong top priority waiter task
Use waiter::task instead of current in all related operations in remove_waiter() to cure those problems.
[ tglx: Fixup rt_mutex_adjust_prio_chain(), add a comment and amend the changelog ]
AI Insight
LLM-synthesized narrative grounded in this CVE's description and references.
A use-after-free and priority inversion vulnerability in Linux kernel's rtmutex remove_waiter() when used in futex requeue proxy-lock rollback.
Vulnerability
In the Linux kernel, the remove_waiter() function in the rtmutex implementation is used by slowlock paths and also for proxy-lock rollback in rt_mutex_start_proxy_lock() when invoked from futex_requeue(). In the latter case, waiter::task is not current, but remove_waiter() incorrectly operates on current for the dequeue operation. This leads to three issues: (1) the rbtree dequeue occurs without holding waiter::task::pi_lock; (2) the waiter task's pi_blocked_on state is not cleared, leaving a dangling pointer primed for use-after-free; (3) rt_mutex_adjust_prio_chain() operates on the wrong top priority waiter task. The vulnerability affects Linux kernel versions prior to the inclusion of the fix commits [1], [2], [3], [4].
Exploitation
An attacker must be able to trigger a futex_requeue() operation that invokes proxy-lock rollback via rt_mutex_start_proxy_lock(). This requires local access to the system and the ability to manipulate futex operations in a way that causes the specific code path where remove_waiter() is called with a waiter::task different from current. The exact sequence involves setting up a futex requeue scenario that leads to the proxy-lock rollback, then exploiting the race window or the missing lock to corrupt kernel state.
Impact
Successful exploitation can lead to use-after-free (UAF) of the waiter task structure, potentially allowing an attacker to corrupt kernel memory and escalate privileges. Additionally, the incorrect priority chain manipulation can cause priority inversion, leading to denial of service or unpredictable scheduling behavior. The attacker may gain arbitrary code execution in kernel context, depending on the specific UAF exploitation technique.
Mitigation
The vulnerability is fixed in Linux kernel stable updates that include the commits referenced in [1], [2], [3], and [4]. Users should apply the latest kernel updates from their distribution. No workaround is available; the fix must be applied via kernel patching. The issue is not listed on CISA's Known Exploited Vulnerabilities (KEV) catalog as of the publication date.
AI Insight generated on May 21, 2026. Synthesized from this CVE's description and the cited reference URLs; citations are validated against the source bundle.
Affected products
2Patches
103bfdc63936dd3fb7394a83778a1fc8d698ac6d52dfcb2a5d88614876370a3bfdc63936dd8a1fc8d698ac3fb7394a837788614876370a6d52dfcb2a5dVulnerability mechanics
Root cause
"remove_waiter() unconditionally used current instead of waiter::task, causing incorrect lock operations when called from proxy-lock rollback in futex_requeue()."
Attack vector
An attacker able to trigger a futex_requeue() operation that invokes rt_mutex_start_proxy_lock() can cause the kernel to operate on the wrong task's pi_lock and pi_blocked_on state [patch_id=1215863]. The bug occurs because remove_waiter() uses current for dequeue operations even when waiter::task is a different process. This can lead to a use-after-free via a dangling pi_blocked_on pointer and incorrect priority inheritance chain adjustments.
Affected code
The vulnerability is in the remove_waiter() function within the kernel's rtmutex implementation. This function is called from slowlock paths and from rt_mutex_start_proxy_lock() during futex_requeue() proxy-lock rollback. The patch does not show specific file paths, but the code resides in the kernel/locking/rtmutex.c area of the Linux kernel.
What the fix does
The patch replaces all references to current in remove_waiter() with waiter::task, ensuring the correct task's pi_lock is acquired and its pi_blocked_on state is cleared [patch_id=1215863]. It also fixes rt_mutex_adjust_prio_chain() to operate on the correct top-priority waiter task. These changes close the UAF window caused by the dangling pi_blocked_on pointer and prevent incorrect rbtree dequeue operations.
Preconditions
- inputAttacker must be able to trigger a futex_requeue() operation that causes proxy-lock rollback via rt_mutex_start_proxy_lock()
- authAttacker needs local access to the system to invoke futex syscalls
Generated on May 21, 2026. Inputs: CWE entries + fix-commit diffs from this CVE's patches. Citations validated against bundle.
References
5- git.kernel.org/stable/c/3bfdc63936dd4773109b7b8c280c0f3b5ae7d349nvd
- git.kernel.org/stable/c/3fb7394a837740770f0d6b4b30567e60786a63f2nvd
- git.kernel.org/stable/c/6d52dfcb2a5db86e346cf51f8fcf2071b8085166nvd
- git.kernel.org/stable/c/88614876370aac8ad1050ad785a4c095ba17ac11nvd
- git.kernel.org/stable/c/8a1fc8d698ac5e5916e3082a0f74450d71f9611fnvd
News mentions
0No linked articles in our index yet.