Skip to main content

Linux Kernel CVE-2026-98315

| EUVDEUVD-2026-93300 HIGH
2026-10-06 Linux GHSA-32pv-963j-mqgr
7.8
CVSS 3.1 · Vendor: Linux
View

Attack ChainAIDerived

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

  1. Access
    Obtain local low-privilege access to NTFS mount
  2. Delivery
    Issue concurrent attribute shrink/map operations
  3. Exploit
    Race unlocked runlist update and failed rollback
  4. Execution
    Corrupt kernel runlist and on-disk mapping pairs
  5. Impact
    Escalate privileges or crash kernel

Vulnerability Assessment

Exploitation Conditions

Requires that the Linux NTFS driver be loaded and an NTFS volume be mounted and accessible to the attacker, who must already have local access (AV:L) and some privilege level (PR:L) sufficient to perform file/attribute operations on that volume. The specific vulnerable paths are ntfs_non_resident_attr_shrink() (cluster freeing and runlist truncation without the runlist write lock) and ntfs_attr_map_cluster() (merging a newly allocated run before a mapping-pairs update that may fail), so exploitation depends on reaching those operations - notably a failing mapping-pairs update and the resulting rollback window. LIMITING FACTORS: no remote vector (local only), the NTFS driver and a mounted NTFS volume must be present (not a default on most Linux servers), and the root cause is a locking race, so a concurrent/timing-dependent trigger is likely needed, reducing reliability. No user interaction is required (UI:N).

Impact

Signals are consistent and point to a genuine but NOT urgent local-only issue. The CVSS 3.1 vector (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, 7.8 HIGH) describes a local, already-authenticated attacker with full CIA impact and no scope change - a classic local privilege-escalation / kernel-corruption profile rather than a remotely reachable flaw. EPSS is very low (0.16%, 5th percentile) and the vulnerability is NOT in CISA KEV, with no public exploit code referenced, so there is no evidence of active or imminent exploitation. One point of tension to verify: the input Tags label this 'Information Disclosure', but the description and CVSS (I:H/A:H) describe an unsynchronized runlist/cluster-freeing race that corrupts in-memory and on-disk NTFS mapping-pairs - that is primarily a memory-corruption/integrity-and-availability bug, not pure disclosure, so treat the 'Information Disclosure' framing with caution. Separately, the upstream vector uses AC:L, but because the root cause is a missing runlist write lock (a race window during a failed mapping-pairs update/merge), real-world triggering plausibly requires concurrent operations and specific timing, which argues for higher attack complexity than AC:L suggests - verify against the actual trigger conditions. Net: a legitimate kernel hardening fix worth patching in normal cycles, not a drop-everything priority for most fleets, and only relevant where the NTFS driver is actually in use.

Exploit ScenarioDerived

A local, low-privileged user with access to a mounted NTFS volume issues concurrent file operations that drive ntfs_non_resident_attr_shrink()/ntfs_attr_map_cluster() through the unlocked runlist-update and failed-mapping-pairs-rollback paths, racing to corrupt the in-memory runlist and on-disk mapping pairs. The resulting kernel memory/filesystem-metadata corruption can be steered toward privilege escalation, or at minimum trigger a kernel crash (DoS). No public exploit code was identified, and exploitation requires winning a timing-dependent race on a system where the NTFS driver is loaded and a volume is accessible.

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

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

Alert me

AnalysisAIv1 – Oct 07, 2026

Improper runlist locking in the Linux kernel's NTFS driver allows a local attacker who can perform file and attribute operations on a mounted NTFS volume to race the cluster-freeing and runlist-truncation paths, potentially corrupting runlist and on-disk mapping-pair state and achieving high confidentiality and integrity impact inside the kernel (NVD score 7.8; our independent assessment rates it CVSS:3.1/AV:L/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H, i.e. local-only with a timing-dependent trigger). The flaw is that ntfs_non_resident_attr_shrink() calls runlist helpers that require the runlist write lock without holding it, and ntfs_attr_map_cluster() can merge a newly allocated run before a mapping-pairs update that may fail, with the rollback path itself able to fail and force the volume into an error state. EPSS is low at 0.16% (5th percentile), no public exploit code and no confirmed active exploitation have been identified at time of analysis, and the affected NTFS driver is not enabled or mounted by default on most Linux servers, which materially limits real-world exposure.

RemediationAI

Vendor-released patch: Linux 7.2.8 (stable) and Linux 7.3-rc4 (development), corresponding to upstream fix commits 91709ba5d6d709b2b663287b7e871e2c6b480502 and 742797432e8c9b0dd54ecc523c185e26b09d79a0 (see https://git.kernel.org/stable/c/91709ba5d6d709b2b663287b7e871e2c6b480502 and https://git.kernel.org/stable/c/742797432e8c9b0dd54ecc523c185e26b09d79a0); update to your distribution's kernel build that contains these commits (cherry-picks into LTS branches are likely, so verify against the distro changelog rather than relying on the upstream version number alone). Because the bug is local and requires an NTFS volume writable by the attacker, practical compensating controls are: avoid mounting untrusted or removable NTFS media on hosts where the ntfs/ntfs3 driver is loaded, and where NTFS mounts are required but not patchable, mount read-only (note the trade-off - read-only mounts prevent the attribute-shrink, cluster-free and mapping-pair update paths that trigger the race, but they also break write workloads); restrict local shell access and sudo rights so low-privileged users cannot perform attribute and file operations on NTFS mounts (this reduces the PR:L precondition but does not help if the attacker already holds such access); and, where the driver is not needed at all, blacklist or do not build the ntfs/ntfs3 module (eliminates exposure entirely at the cost of NTFS support). There is no identified public exploit and no confirmed active exploitation, so remediation can follow normal patch cadence, but note the volume-in-error behavior described by the fix means a triggered race may leave the filesystem needing a check, so back up NTFS data before and after applying the update.

Affected VersionsENISA

Linux 495e90fa334828d4119061e2726af51d0a0fb4ed <91709ba5d6d709b2b663287b7e871e2c6b480502
Linux patch: 7.3-rc4
Linux 7.1
Linux patch: 7.2.8
Linux 495e90fa334828d4119061e2726af51d0a0fb4ed <742797432e8c9b0dd54ecc523c185e26b09d79a0
Linux patch: 0

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 affected component is the NTFS filesystem driver in the Linux kernel tree (CPE cpe:2.3:a:linux:linux), which manipulates NTFS runlists - the compressed data structures describing which clusters (LCNs) belong to a non-resident attribute and how they map to virtual cluster numbers (VCNs). The runlist abstraction is protected by an explicit runlist write lock because operations such as freeing clusters, truncating a runlist, and converting an attribute between resident and non-resident form are not atomic with respect to concurrent readers and writers. Two call paths violated that contract: ntfs_non_resident_attr_shrink() invoked runlist helpers that require the write lock while free-and-truncate work was in progress, and ntfs_attr_map_cluster() could merge a freshly allocated run into the runlist before an update to the on-disk mapping pairs, so a failed mapping-pairs update left the in-memory runlist and the on-disk state divergent - the fix saves a copy of the runlist and rolls both back, marking the volume in error if either rollback step fails. No CWE identifier was supplied with the record; the root-cause class is a concurrent-execution/serialization defect (improper locking over shared mutable filesystem metadata, consistent with the family of CWE-362/CWE-667-style race conditions), which is why the exploitability depends on timing and on reaching the failing-update window rather than on a simple deterministic bug. The independent assessment and the vendor-supplied base score agree on high confidentiality/integrity impact and no privilege escalation to a different scope, but diverge on attack complexity: the 7.8 score assumes AC:L while the assessed vector uses AC:H to reflect the race/rollback-window precondition.

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 NTFS access gives AV:L/PR:L; the missing-lock race window and failed-update rollback make reliable triggering timing-dependent (AC:H); kernel/metadata corruption yields C/I/A:H.

3.1 AV:L/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H
4.0 AV:L/AC:H/AT:N/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

4
CVSS changed
Oct 07, 2026 - 07:22 NVD
7.8 (HIGH)
Patch available
Oct 06, 2026 - 10:02 EUVD
CVE Published
Oct 06, 2026 - 08:46 cve.org
HIGH 7.8
CVE Published
Oct 06, 2026 - 08:46 cve.org
UNKNOWN (no severity yet)

DescriptionCVE.org

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

ntfs: protect runlist updates with the runlist lock

ntfs_non_resident_attr_shrink() calls runlist helpers that require the runlist write lock, but did not hold it while freeing clusters and truncating the runlist. Serialize those operations and the resident conversion with the runlist lock.

ntfs_attr_map_cluster() can merge a newly allocated run before updating mapping pairs. If the update fails, free the clusters and restore both the in-memory runlist and on-disk mapping pairs from a saved runlist. Mark the volume in error if either rollback step fails.

Executive ViewAI

Why It Matters

A high-severity flaw in the Linux kernel's NTFS filesystem driver could allow a user who already has local access to a system with an NTFS volume mounted to corrupt kernel memory and gain elevated privileges or crash the host. Leadership should care because affected systems are typically shared servers and workstations where a low-privileged local account is the only foothold an attacker needs, though exploitation requires precise timing and non-default NTFS mounting, and no public exploit or active exploitation has been observed. The vendor patch is already available, making this a straightforward patch-management priority rather than an emergency incident.

Business Impact: Medium
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 95% exploitable
Prevalence
Ubiquitous
Linux kernel runs in a huge fraction of environments; NTFS driver usage is narrower
Data Quality
4 sources
Confidence: Medium

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.2%
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