VYPR
Unrated severityNVD Advisory· Published May 21, 2026

CVE-2026-43499

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

2

Patches

10

Vulnerability 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

News mentions

0

No linked articles in our index yet.