CVE-2026-98256

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

signal: Prevent exec() race

Hyunwoo debugged the following KASAN UAF splat:

BUG: KASAN: slab-use-after-free in send signal locked+0xb27/0xba0 Write of size 8 at addr ffff888007ed80c8 by task poc/79 ... Call Trace: send signal locked+0xb27/0xba0 do send sig info+0xa7/0x160 do send specific+0x76/0xa0 x64 sys tgkill+0x193/0x270 ... Allocated by task 80: do timer create+0x1a4/0x1030 x64 sys timer create+0x145/0x190 ... Freed by task 12: kmem cache free bulk+0x1f8/0x4a0 kvfree rcu bulk+0x14f/0x1c0 kfree rcu work+0x128/0x1a0 ... Last potentially related work creation: kvfree call rcu+0x39/0x390 flush itimer signals+0x211/0x320 flush itimer signals+0x47/0x90 begin new exec+0xa6b/0x28c0

It turned out that this happens with a non-leader exec() as Hyunwoo explained:

de thread() calls exchange tids() before release task(leader), so the struct pid held by a SIGEV THREAD ID timer created against the leader's tid now points to the thread which called execve(). pid task() returns that thread and lock task sighand() on it succeeds.

If the timer signal is blocked, its sigqueue stays queued on the leader's task::pending. The next expiry of that timer can then run while release task() flushes the queue.

posixtimer send sigqueue() checks whether the sigqueue is already queued with a plain list empty(), which only reads list head::next. list del init() is not atomic and INIT LIST HEAD() stores list head::next before list head::prev, so the check can pass in between. list add tail() queues the entry on the task::pending of the live thread, and the list head::prev store from the flush then overwrites the list head::prev link that list add tail() has just set.

flush itimer signals() does not undo that either. With list head::prev pointing at the entry itself, its list del init() only stores the same values again, so the entry is not removed from the list. It is still there after the last reference is dropped and the timer is freed by RCU, and the list add tail() of a later tgkill() follows that list head::prev into the freed timer.

This problem surfaced with the recent commit which moved the sigqueue flush out of the sighand lock held region.

Hyonwoo proposed to fix this by using list del init careful(), but that just papers over the problem. After some disucssions and various attempts to solve it, Eric pointed out that there is no reason to flush task::pending late in release task() and it should be done in exit signals() already.

As nothing can collect and deliver signals which are queued in a dying task's pending queue, there is no reason to delay it further.

But it has to be ensured that no signals can be queued into it after that point. exit signals() sets PF EXITING in task::flags, which can be used as an indicator for this.

Cure it by:

Optimize that by moving the whole pending list to an on-stack list head under sighand lock and free the signals without the lock held.

There has been quite some discussion about the lockless flush and the non-leader exec case on weakly ordered systems. The problem is that a third party which tries to send a posix timer signal relies on the PID lookup to find the target task and that lookup might result in the new leader when the signal was originaly directed to the old leader. In case that the signal was queued on the old leader then the lockless flush raised a concern over the following situation:

old leader new leader third party

A: flush list() // list del in ---truncated---