Koffei

CVE-2026-98260

🟠 Medium

Linux kernel. The record carries no CWE from any container and no SSVC decision, and its only references are git.kernel.org stable commits, which are patches rather than advisories, so there is nothing to cite beyond the commit itself · From 5.7 onward ; fixed in 6.1.191, 6.6.158, 6.12.112, 6.18.54 and 7.2.8, with mainline fixed in 7.3. Kernels before 5.7 are explicitly unaffected

CVSS (Koffei note)
7.8
CVSS (v3.1, CVE List)
7.8
EPSS (2026-11-18)
0.222%
12.89th percentile

Exploitation

No — no exploitation reported, and the record has no SSVC container, so CISA has not triaged it. Neither CISA KEV nor its JSON feed could be reached in this run, so KEV status comes from the record's CISA-ADP container. Existing PoC (not opened), recorded from the proof-of-concept list supplied on 09/11/2026. Rated 🟠 on the public proof of concept alone, against a record that offers no exploitation signal of its own

Timeline

  1. 06/10/2026CVE record published (CVE List)

Risk

7.8 High (v3.1, Linux as CNA) — AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, EPSS 0.185% (8.12th percentile, scored 08/11/2026) — a 7.8 sitting in the bottom tenth of the population, which is what a local kernel race with no public tooling looks like in EPSS terms (no CWE in the record: a use-after-free on the exec path. A per-thread CPU timer on a non-leader thread can stay queued after de_thread() changes PID ownership ; if the exec then fails, the timer is freed while still linked, and reaping the task corrupts the rbtree. The fix moves POSIX timer cleanup to just after de_thread())

Fix

Yes — the per-branch stable release above, or 7.3 mainline

Official description

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() ]

CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H