Cloudanix VulnDB

CVE-2026-98260

High · 7.8

CVSS

7.8

EPSS

0.1%

Published

Oct 6, 2026

CISA due date

—

Cloudanix analysis

Schedule a fix SSVC: Track

A bug in the Linux kernel can let a program running on the same computer corrupt internal memory structures during certain process startup failures, which may allow that program to take over the whole machine.

Exploitation
Local Privilege
Attacker needs
Local User
Complexity
Low
Impact
Full Compromise
Component
OS kernel
Class
Use After Free
Remediation
Upgrade
Effort
Medium
Patch risk
Low

What it actually does

Use-after-free in POSIX CPU timer queue management triggered when a non-leader thread performs execve that fails after de_thread() but before posix_cpu_timers_exit(), allowing a freed k_itimer node to remain in an rbtree that is later accessed during release_task().

Why it matters to the business

Local attackers on affected Red Hat kernels can corrupt kernel memory, potentially leading to privilege escalation, system crashes, or denial of service on servers and workstations; the issue affects widely deployed enterprise kernels with many downstream dependents.

How an attack unfolds

An attacker running as a non-leader thread creates a CLOCK_THREAD_CPUTIME_ID timer, arms it, then issues an execve that triggers de_thread() followed by a failure in exec_mmap or similar before the cleanup call; this leaves a dangling node that exit_itimers frees and later timerqueue_del dereferences, resulting in a use-after-free.

How to fix it

Upgrade Red Hat Enterprise Linux kernels to the fixed versions: kernel el10 to 6.12.0-211.67.1.el10_2, kernel el9 to 5.14.0-427.156.1.el9_4, or kernel-rt el9 to 5.14.0-284.198.1.rt14.483.el9_2 via the referenced RHSA; apply the patch that moves posix_cpu_timers_exit immediately after de_thread().

How to confirm the fix worked

Verify the running kernel version matches or exceeds the fixed releases listed for each Red Hat variant; confirm the source tree contains the commit moving the POSIX timer cleanup right after de_thread(); test exec failure paths with timer-armed non-leader threads under a debug kernel to ensure no UAF reports occur.

Typical attack path

  1. Create and arm a per-thread CPU timer from a non-leader thread
  2. Invoke execve that reaches de_thread() and exchanges TIDs
  3. Force a failure path after de_thread() but before posix_cpu_timers_exit (e.g., exec_mmap returning -EINTR)
  4. Trigger exit_itimers which frees the k_itimer while its node is still queued
  5. Cause release_task to invoke cleanup_timerqueue which dereferences the freed node

How to detect it

Search kernel logs and dmesg for use-after-free or rbtree corruption messages involving timerqueue_del or posix_cpu_timers_exit; inspect crash dumps for k_itimer objects being accessed after free in the context of do_exit following a failed exec; review audit logs for sequences of timer_create, timer_settime, and execve calls from the same thread that end in SIGKILL.

What your security team should do

  • Apply the vendor kernel updates immediately on all affected Red Hat systems given the 17-day publication window
  • Restrict local unprivileged execve and timer creation via seccomp or AppArmor where feasible until patches are deployed
  • Monitor for kernel oops or slab corruption logs indicating timerqueue_del misuse
  • Prioritize production servers and multi-tenant hosts due to high local impact and broad ecosystem prevalence

The record

In the Linux kernel, the following vulnerability has been resolved: exec: Cleanup POSIX timers right after de_thread() A per-thread CPU timer holds a reference to the PID of the thread it is attached to and, while it is armed, its node is queued in that thread's posix_cputimers. The task is looked up by that PID. When a non-leader thread exec()s, de_thread() changes which task owns that PID. pid_task(timer->it.cpu.pid, PIDTYPE_PID) then returns NULL, but the node is still queued on tsk, which is alive. timer_lock_sighand() takes a failed lookup to mean that the node is already dequeued, so it has nothing to undo. begin_new_exec() calls posix_cpu_timers_exit(me) right after exec_task_namespaces() and that removes the leftover node, so the state normally stays invisible. But bprm->point_of_no_return is set before de_thread(), so if unshare_files(), set_mm_exe_file(), exec_mmap() or exec_task_namespaces() fails, the task dies before it gets there. exit_itimers() then frees the k_itimer while its node is still queued, and reaping tsk later erases that freed node from the rbtree. In short: the non-leader thread B the parent timer_create(CLOCK_THREAD_CPUTIME_ID) timer_settime() arm_timer() // the node is queued on B execve() de_thread(B) exchange_tids(B, leader) // B's PID now belongs to the leader release_task(leader) __exit_signal(leader) posix_cpu_timers_exit(leader) // cleans leader's queue, not B's __unhash_process(leader) // that PID has no task anymore exec_mmap() mmap_read_lock_killable(old_mm) kill(B, SIGKILL) // -EINTR get_signal() do_exit() exit_itimers() posix_timer_delete() posix_cpu_timer_del() posix_timer_unhash_and_free() // freed while still queued wait4() release_task(B) posix_cpu_timers_exit(B) cleanup_timerqueue() timerqueue_del() // use-after-free Move the POSIX timer cleanup right after de_thread() before any of the later failure conditions brings the task into do_exit(). [ tglx: Move the cleanup right after de_thread() ]

Affected packages

Ecosystem Package Introduced Fixed