Skip to main content

Linux Kernel CVE-2026-97903

| EUVDEUVD-2026-86757 HIGH
2026-09-25 Linux GHSA-cpwj-27c2-jfgq
7.8
CVSS 3.1 · Vendor: Linux
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Local unprivileged shell access
  2. Delivery
    Spawn exiting task in own session/pgrp
  3. Exploit
    Race wait4(-1) reap against concurrent setsid()/free_pids
  4. Execution
    RCU frees thread_pid before proc_flush_pid
  5. Persist
    Use-after-free read in proc_invalidate_siblings_dcache
  6. Impact
    Kernel crash / denial of service

Vulnerability Assessment

Exploitation Conditions

Requires local, unprivileged code execution on an affected Linux kernel (6.16 through the fixed 6.18.53/7.2.7 range, plus the 0a36bad01731 regression window). Triggering requires winning a narrow scheduler/RCU race: the attacker must have wait4(-1) reap an exiting task at the same instant another task (via setsid()/free_pids) drops the final PIDTYPE link, so that delayed_put_pid's RCU callback frees struct pid before the first release_task() reaches proc_flush_pid(). The exiting task's PID must still be in use as another task's process-group or session ID (the condition that keeps it out of post.pids). Limiting factors: no remote vector (AV:L), no network exposure, requires valid local account (PR:L), success is timing-dependent, and the outcome is a crash - no controlled memory read/write or privilege gain is available.

Impact

This is a niche, crash-dominant memory-safety bug being scored far above its real-world impact. The NVD CVSS 3.1 vector (AV:L/AC:L/PR:L/UI:N/C:H/I:H/A:H = 7.8 'High') asserts full confidentiality/integrity/availability compromise, but the vulnerability description EXPLICITLY contradicts this: 'No controlled read or write, information leak, or privilege escalation is claimed.' The observed effect is a KASAN slab-use-after-free (read of freed pid->inodes in proc_invalidate_siblings_dcache) that manifests as a kernel crash - i.e. denial of service, not a controlled primitive. I therefore treat C:H/I:H as unsupported; realistic impact is A:H (crash) with at most I:L (uncontrolled corruption). The AC:L rating is also generous: this is an RCU/timing race requiring wait4(-1) to be raced against setsid() at exactly the window between __unhash_process() and proc_flush_pid(), which is timing-dependent (AC:H is more defensible, though the reproducer hit it 3/3 boots). Positive signals for exploitation are absent: no EPSS score, no CISA KEV listing, and no public exploit - a working reproducer is only 'available privately on request.' Bottom line: real priority is LOW-to-MEDIUM local DoS, not the High/privesc the tag and CVSS imply. Patch it via normal kernel update cadence; it is not an emergency.

Exploit ScenarioDerived

An unprivileged local user runs a program that repeatedly forks children and races wait4(-1) reaping against another task calling setsid() (so the exiting task's PID is still held as a process-group/session ID and is dropped by another task's free_pids/RCU callback). Won the race, proc_flush_pid() dereferences the already-freed struct pid, producing a slab-use-after-free that crashes the kernel. Only a private reproducer exists - no public PoC or evidence of exploitation, and no controlled read/write is claimed.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.1% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Sep 25, 2026

A slab use-after-free in the Linux kernel process-exit path lets a local user with an ordinary account crash or destabilize the system by winning a narrow race between wait4(-1) reaping an exiting task and a concurrent setsid() that drops the last PIDTYPE link for that task's struct pid. The bug affects kernels carrying the 0a36bad01731 regression (Linux 6.16 through the 6.18.53/7.2.7 fixes) and requires local authenticated access (CVSS PR:L), with success being timing-dependent; the outcome observed under KASAN is a kernel crash from a bad read of pid->inodes in proc_invalidate_siblings_dcache, not a controlled read/write or privilege gain. There is no confirmed active exploitation (not in CISA KEV) and no public exploit identified at time of analysis, although a tested reproducer exists privately; patch status is vendor-released, with fixes shipping in 6.18.53, 7.2.7, and 7.3-rc3.

RemediationAI

Vendor-released patch: upgrade to Linux 6.18.53, 7.2.7, or 7.3-rc3 (or a later 6.19.y+ mainline release, where the fix applies directly); v6.16.y through v6.18.y kernels need the context-adjusted stable backport linked at https://git.kernel.org/stable/c/96803a12e8ac15f0a1b4b151db59038f12304e58, https://git.kernel.org/stable/c/cdd812d0683dee14ead02c9eded568685e61b23f, and https://git.kernel.org/stable/c/bcb0936862f2b653114d9bd582ca26990ef54a64, and reference advisory https://nvd.nist.gov/vuln/detail/CVE-2026-97903. Because the defect is a timing-dependent race inside the process-exit path and can be reached by any local user who can call wait4()/setsid(), there is no meaningful configuration switch that disables the vulnerable code path; plausible compensating controls are limited to reducing local attack surface - restricting untrusted multi-user shell access to affected hosts (effective but operationally costly, and does not protect legitimate local account holders), or enabling KASAN/slab debugging on development and staging kernels to detect the proc_invalidate_siblings_dcache splat before production exposure (detection only, carries performance overhead and is unsuitable for production throughput), with kernel lockdown or module-signing controls offering no mitigation since no module or privileged interface is involved. Until patching, treat any local user as able to trigger a denial-of-service crash on unpatched 6.16-6.18 kernels, and prioritize rebooting into a patched kernel after upgrade because the fix must be loaded into a running kernel to take effect.

Affected VersionsENISA

Linux 0a36bad01731e71568bdd365764d38b6bd576ab0 <96803a12e8ac15f0a1b4b151db59038f12304e58
Linux 0a36bad01731e71568bdd365764d38b6bd576ab0 <cdd812d0683dee14ead02c9eded568685e61b23f
Linux 6.16
Linux patch: 7.2.7
Linux patch: 7.3-rc3
Linux 0a36bad01731e71568bdd365764d38b6bd576ab0 <bcb0936862f2b653114d9bd582ca26990ef54a64
Linux patch: 0
Linux patch: 6.18.53

Affected Packages

euvd linux no fix

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

The flaw is a lifetime-management error for the kernel's struct pid. Commit 0a36bad01731 removed a get/put_pid() reference around proc_flush_pid(), assuming that free_pids(post.pids) at the end of release_task() would keep thread_pid alive. That assumption fails because __change_pid() only records a detached PID in post.pids when pid_has_task() is false for every PIDTYPE: if another task still uses the exiting task's PID as its process-group or session ID, __unhash_process() drops only the PIDTYPE_PID link while leaving the PID out of post.pids, so release_task() holds no reference after dropping tasklist_lock. The other task can then remove the remaining links, its free_pids() schedules delayed_put_pid(), and the RCU callback frees the struct pid before the first release_task() reaches proc_flush_pid(), producing a slab-use-after-free read of pid->inodes inside proc_invalidate_siblings_dcache (read 80 bytes into a 144-byte pid-cache object in the reported KASAN trace). This is a use-after-free class defect in kernel process/RCU synchronization (no CWE was supplied in the source data). The fix takes a reference before __unhash_process() clears p->thread_pid and releases it only after proc_flush_pid() completes, so the concurrent RCU callback's put_pid() performs the final free afterward.

Know when the next one hits your stack

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

Vendor (Linux) PRIMARY 7.8 HIGH
AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
vuln.today AI 5.3 MEDIUM

Local unprivileged trigger (AV:L/PR:L); success depends on winning an RCU/scheduler race (AC:H); author denies any info leak or controlled write, so C:N, uncontrolled corruption I:L, and kernel crash A:H.

3.1 AV:L/AC:H/PR:L/UI:N/S:U/C:N/I:L/A:H
4.0 AV:L/AC:H/AT:N/PR:L/UI:N/VC:N/VI:L/VA:H/SC:N/SI:N/SA:N
SUSE 5.5 MEDIUM
AV:L/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H
Red Hat 7.0 MEDIUM

Primary rating from Vendor (Linux).

CVSS VectorVendor: Linux

Attack Vector
Local
Attack Complexity
Low
Privileges Required
Low
User Interaction
None
Scope
Unchanged
Confidentiality
High
Integrity
High
Availability
High

Lifecycle Timeline

4
CVSS changed
Sep 25, 2026 - 15:22 NVD
7.8 (HIGH)
Patch available
Sep 25, 2026 - 11:02 EUVD
CVE Published
Sep 25, 2026 - 10:22 cve.org
UNKNOWN (no severity yet)
CVE Published
Sep 25, 2026 - 10:22 cve.org
HIGH 7.8

DescriptionCVE.org

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

exit: hold a reference to thread_pid across proc_flush_pid

Commit 0a36bad01731 ("release_task: kill the no longer needed get/put_pid(thread_pid)") removed the reference around proc_flush_pid(). It assumed that free_pids(post.pids) at the end of release_task() would keep thread_pid alive until then.

That assumption is wrong. __change_pid() only records a detached PID in post.pids when pid_has_task() is false for every PIDTYPE. If another task still uses the exiting task's PID as its process group or session ID, __unhash_process() removes the exiting task's PIDTYPE_PID link but leaves the PID out of post.pids. release_task() therefore holds no reference to it after dropping tasklist_lock.

The other task can then remove the remaining PIDTYPE links. Its free_pids() call schedules delayed_put_pid(), and the RCU callback can free the PID before the first release_task() reaches proc_flush_pid().

An unprivileged reproducer races wait4(-1) against setsid() to trigger this ordering. Three of three fresh v7.2 KASAN boots reported:

BUG: KASAN: slab-use-after-free in proc_invalidate_siblings_dcache+0x3e2/0x3f0 Read of size 8 by task h7_pid_reaper/1921

Call Trace: proc_invalidate_siblings_dcache release_task wait_consider_task __do_wait do_wait kernel_wait4

Freed by task 0: kmem_cache_free put_pid delayed_put_pid rcu_core

Last potentially related work creation: __call_rcu_common free_pids ksys_setsid

KASAN identified a 144-byte object from the pid cache and located the bad read 80 bytes into the freed object, matching pid->inodes. With an explicit reference, three of three fresh boots completed without a KASAN report. The concurrent RCU callback dropped its reference while proc_flush_pid() was protected, and the balancing put_pid() performed the final free afterward.

Take a reference before __unhash_process() clears p->thread_pid and release it after proc_flush_pid() completes.

A tested source reproducer is available privately on request. No controlled read or write, information leak, or privilege escalation is claimed. The mainline patch applies directly to v6.19.y and newer; v6.16.y through v6.18.y need a context-adjusted backport.

Executive ViewAI

Why It Matters

The Linux kernel versions affected by CVE-2026-97903 can be crashed or destabilized by a local authenticated user, creating a denial-of-service risk for shared, multi-tenant, or high-availability systems. Because exploitation requires an existing local account and affects availability rather than data confidentiality or privilege gain, the immediate business concern is service disruption and operational cost, not data breach. Vendor patches are available, so leadership should prioritize updating affected kernels on high-value and multi-user hosts.

Business Impact: Medium
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.1%
Top 98% exploitable
Prevalence
Ubiquitous
core process-exit path in the mainline Linux kernel, present everywhere
Data Quality
3 sources
Confidence: Low

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.1%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Defer
Exploitation· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact
Medium

Priority Score

39
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +39
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Vendor StatusVendor

SUSE

Severity: Moderate
Product Status
SUSE Linux Enterprise Desktop 15 SP7 Not-Affected
SUSE Linux Enterprise Desktop 15 SP7 Not-Affected
SUSE Linux Enterprise High Availability Extension 15 SP7 Not-Affected
SUSE Linux Enterprise High Availability Extension 15 SP7 Not-Affected
SUSE Linux Enterprise High Availability Extension 16.0 Not-Affected

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy