Skip to main content

Linux Kernel CVE-2026-99238

| EUVDEUVD-2026-115280 HIGH
2026-11-02 Linux GHSA-x8hw-cmw2-gvx9
7.8
CVSS 3.1 · Vendor: Linux
View

Attack ChainAIDerived

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

  1. Access
    Gain local privileged access to tracefs and module loading
  2. Exploit
    Race a module load/unload against concurrent instance rmdir
  3. Execution
    Notifier walks freed trace_array (use-after-free)
  4. Impact
    Corrupt kernel memory causing crash or escalation

Vulnerability Assessment

Exploitation Conditions

Requires a kernel built with tracing enabled and actually using persistent/named trace instances (ftrace_trace_arrays), plus local access with the privileges to (a) load or unload a kernel module and (b) create/remove a trace instance directory under tracefs - operations that normally demand root or CAP_SYS_ADMIN/CAP_SYS_MODULE. The trigger per the description is a concurrent module load/unload and instance rmdir, so exploitation depends on winning that race window. Limiting factors: no remote vector (AV:L, local only), already-privileged operations are needed, the specific persistent-instance tracing feature must be in use, and the timing-sensitive race reduces reliability.

Impact

The input assigns CVSS 7.8 (HIGH) with vector AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, meaning this is a local-only, non-remote issue requiring some existing privilege - not a network-facing flaw. No KEV status is present, so there is no confirmed active exploitation; no EPSS score was supplied, and no SSVC exploitation/automatable/technical-impact triad was provided, leaving those signals unknown. The only references are three kernel.org stable git commits (the fixes themselves), i.e. no public exploit identified at time of analysis. The vuln.today decision label is 'this_week', consistent with a serious-but-not-emergency local kernel bug. The description makes clear this is a use-after-free driven by a race: trace_module_record() walks ftrace_trace_arrays from the module notifier without trace_types_lock while a concurrent instance rmdir frees a trace_array under that lock. One caveat worth flagging: the input Tags label this 'Information Disclosure', yet the CVSS vector claims full C:H/I:H/A:H, which describes kernel memory corruption with escalation/crash potential rather than mere disclosure - treat the impact as broader than the tag implies. Also note the CVSS AC:L sits uneasily with a timing-dependent race; winning that race is not guaranteed, which realistically lowers practical exploitability below what AC:L suggests. Net: a real local kernel hardening fix to deploy promptly, not a drop-everything remote emergency.

Exploit ScenarioDerived

A local actor holding the privileges needed to load/unload kernel modules and to create and remove persistent trace instances under tracefs triggers a module load or unload at the same moment another thread removes a trace instance directory. The module notifier then walks into a trace_array that the concurrent rmdir has already freed under trace_types_lock, producing a use-after-free in kernel memory that can crash the system or be groomed toward privilege escalation. No public exploit was identified; success is timing-dependent because it requires winning the race described in the fix.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available

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

Alert me

AnalysisAIv1 – Nov 02, 2026

A race condition in the Linux kernel's ftrace tracing subsystem lets a local, already-privileged user free-and-reuse a trace_array: trace_module_record() walks the ftrace_trace_arrays list from the module notifier without holding trace_types_lock, while a concurrent rmdir of a persistent/named trace instance removes that same array from the list and frees it under the lock, so a module load or unload can walk into freed memory. Affected are kernels built with tracing enabled that actually use persistent trace instances; exploitation is local-only (AV:L) and requires the ability to load or unload kernel modules and to create/remove instance directories under tracefs, which normally means root or CAP_SYS_MODULE/CAP_SYS_ADMIN. Per the independent assessment the race is timing-sensitive (AC:H rather than AC:L), no public exploit code or CISA KEV entry was identified at time of analysis, and impact is rated high for confidentiality and integrity of the kernel.

RemediationAI

Upstream fix available (PR/commit); released patched version not independently confirmed. Apply the kernel stable commits referenced in the advisory - 57408eac99b0d8a005796346d317d31f0ca4e07a, dab2bd4d67ad5eaa95019a9511f8d379401b5021 and 244c442f54601a24c86ad90572bf36fc3df41c5e (https://git.kernel.org/stable/c/57408eac99b0d8a005796346d317d31f0ca4e07a, https://git.kernel.org/stable/c/dab2bd4d67ad5eaa95019a9511f8d379401b5021, https://git.kernel.org/stable/c/244c442f54601a24c86ad90572bf36fc3df41c5e) - or the corresponding update from your distribution, and confirm the fix landed by checking that the module notifier takes trace_types_lock. Because exploitation requires both module load/unload rights and tracefs instance management rights, the practical exposure is limited to hosts where those privileges are already root-equivalent; until the kernel is updated, restricting tracefs access (keeping tracefs mounts root-only) and avoiding module load/unload concurrent with removal of trace instance directories reduces the race window, at the cost of blocking legitimate tracing administration and module hot-plug workflows on those systems.

Affected VersionsENISA

Linux 6.15
Linux patch: 7.2.14
Linux patch: 0
Linux 5f3719f697c3fdfae5cd6805f10ac7a04b0f4e43 <dab2bd4d67ad5eaa95019a9511f8d379401b5021
Linux 5f3719f697c3fdfae5cd6805f10ac7a04b0f4e43 <244c442f54601a24c86ad90572bf36fc3df41c5e
Linux patch: 6.18.60
Linux patch: 7.3.1
Linux 5f3719f697c3fdfae5cd6805f10ac7a04b0f4e43 <57408eac99b0d8a005796346d317d31f0ca4e07a

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 sits in the kernel's function tracer (ftrace) instance management. Named/persistent trace instances are represented by struct trace_array objects held on the global ftrace_trace_arrays list, and the list plus instance lifetime is protected by trace_types_lock. Removing an instance directory via tracefs takes that lock, unlinks the trace_array and frees it. The module notifier path trace_module_record() iterates the same list to update module-related records without acquiring trace_types_lock, so a module load or unload that overlaps with an instance teardown can dereference a trace_array that has already been freed - a use-after-free/race pattern (no CWE was assigned in the supplied data). Because the freed object is re-entered from kernel context while tracing bookkeeping is updated, the assessed impact is high confidentiality and integrity loss within the kernel; the fix in the referenced stable commits is to hold trace_types_lock while updating modules in persistent instances. The trigger requires tracing to be enabled with persistent instances in active use, and the window is narrow, which is why the authoritative assessment scores AC:H while the incoming NVD-style vector used AC:L.

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 7.0 HIGH

Local-only use-after-free (AV:L); the described concurrent race makes the trigger timing-dependent (AC:H); it needs privileged tracefs/module operations (PR:L); freed kernel memory yields full C/I/A impact.

3.1 AV:L/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H
4.0 AV:L/AC:L/AT:P/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

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

2
Patch available
Nov 02, 2026 - 17:18 EUVD
CVE Published
Nov 02, 2026 - 16:06 cve.org
HIGH 7.8

DescriptionCVE.org

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

tracing: Hold trace_types_lock when updating modules in persistent instances

trace_module_record() walks ftrace_trace_arrays from the module notifier without trace_types_lock. A concurrent rmdir of an instance removes it from the list and frees it under that lock, so a module load or unload can walk into a freed trace_array.

Executive ViewAI

Why It Matters

CVE-2026-99238 is a high-severity race condition in the Linux kernel's ftrace tracing subsystem that requires local, privileged access to exploit, meaning only users with root or CAP_SYS_MODULE/CAP_SYS_ADMIN can trigger it. While exploitation demands existing high privileges and is timing-sensitive with no public exploit identified, a successful attack could compromise kernel confidentiality and integrity, affecting the foundational trust of the operating system. Leadership should prioritize patching because kernel-level compromise can undermine all security controls, but the practical risk is currently contained to environments where privileged local access is common.

Business Impact: Medium
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations include restricting CAP_SYS_MODULE and CAP_SYS_ADMIN to trusted administrators, disabling persistent trace instances where not required, enforcing kernel module signing, and monitoring for anomalous module loads or tracefs modifications.

Threat Intelligence Overview

Prevalence
Ubiquitous
Linux kernel, deployed across nearly all server, cloud and embedded environments
Social Media
1
Sightings
Data Quality
2 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 N/A
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

Attack Technique

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

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