Skip to main content

Linux Kernel EUVDEUVD-2026-86967

| CVE-2026-98136 HIGH
Out-of-bounds Read (CWE-125)
2026-09-25 Linux GHSA-v5r3-r9hr-q598
7.1
CVSS 3.1 · NVD
View

Attack ChainAIDerived

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

  1. Access
    Supply crafted NTFS volume
  2. Delivery
    Mount filesystem locally
  3. Exploit
    Create file triggers attrdef walk
  4. Execution
    Read ad->type past allocation
  5. Impact
    Leak kernel memory or crash

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, read limits
MITRE ATT&CK

1 technique across 1 tactic: Collection

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Requires a crafted NTFS filesystem image whose on-disk $AttrDef data size is smaller than a single struct attr_def entry (160 bytes; the write-up uses 120 bytes), which bypasses the weak load_and_init_attrdef() check (0 < i_size <= 0x7fffffff) and is reached when a file is created, driving ntfs_attr_add → ntfs_attr_can_be_non_resident → ntfs_attr_size_bounds_check → ntfs_attr_find_in_attrdef. Exploitation is LIMITED to scenarios where an attacker can get such a volume mounted: local access plus mount capability (CAP_SYS_ADMIN) or an automount service that mounts untrusted removable media. It is not reachable over a network and does not affect systems that never mount attacker-controlled NTFS volumes; the kernel must also have the NTFS driver enabled.

Impact

Signals are consistent and point to a moderate, not urgent, priority. The CVSS 3.1 base score of 7.1 is driven by AV:L (local attack vector), AC:L, PR:L, UI:N, with C:H and A:H - i.e. a local, low-privilege out-of-bounds read (CWE-125) that can leak kernel memory or crash the system, with no integrity impact. This is NOT a remotely exploitable flaw: exploitation requires the attacker to get a crafted NTFS image mounted on the target, so network-facing exposure is zero. The EPSS score of 0.14% (3rd percentile) correctly reflects very low expected exploitation volume, and the CVE is NOT in CISA KEV and has no public exploit identified at time of analysis - all low-risk signals agree. There is no SSVC decision data provided. Net assessment: a legitimate kernel memory-safety bug worth patching through normal cycles, but the local-only vector and dependence on mounting attacker-controlled NTFS media make it a low real-world priority except in multi-user, kiosk, forensic, or USB-automount environments where untrusted filesystems are mounted. The 'C:H' rating should be read as potential kernel-memory disclosure/instability from the OOB read rather than a classic data-exfiltration path.

Exploit ScenarioDerived

An attacker with local access crafts a malicious NTFS volume whose on-disk $AttrDef data size is smaller than one 160-byte attr_def entry (e.g. 120 bytes) and gets it mounted - directly, or via a desktop/USB automount service that mounts removable media. A subsequent file-creation operation drives ntfs_attr_size_bounds_check() into ntfs_attr_find_in_attrdef(), which reads ad->type past the kvzalloc allocation, leaking adjacent kernel slab memory or crashing the kernel (KASAN slab-out-of-bounds). No public exploit is identified at time of analysis; a crafted image plus trigger is required.

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 – Oct 08, 2026

Out-of-bounds read in the Linux kernel NTFS driver allows a local attacker who can mount a crafted NTFS volume to read past a heap allocation while the in-memory $AttrDef table is walked, producing a kernel crash (denial of service) and potential disclosure of adjacent kernel memory. Only systems that mount attacker-controlled NTFS images are affected - the kernel must have the NTFS driver enabled and the attacker needs either local mount capability (CAP_SYS_ADMIN) or an automount service that mounts untrusted removable media; authentication requirements are low privileges per the CVSS vector (AV:L/PR:L). No public exploit code has been identified at time of analysis and EPSS is negligible (0.14%, 3rd percentile), though a vendor patch is available and carries a moderate 7.1 severity score.

RemediationAI

Vendor-released patch: apply the upstream NTFS fix commits c8504fc1245f5322af5fa5c325ab05f9cf792b87 (https://git.kernel.org/stable/c/c8504fc1245f5322af5fa5c325ab05f9cf792b87) and 3e2ae47b8ebc632c27e7843a4632d9a7c060885e (https://git.kernel.org/stable/c/3e2ae47b8ebc632c27e7843a4632d9a7c060885e), or upgrade to Linux 7.2.7 / 7.3-rc2 or later as listed in EUVD (EUVD-2026-86967; https://nvd.nist.gov/vuln/detail/CVE-2026-98136). Until patched, the most effective compensating control is to prevent untrusted NTFS images from being mounted: disable the NTFS module on systems that do not need it (blacklist it in /etc/modprobe.d and unload with modprobe -r), which has the side effect of removing NTFS read support entirely, or, if NTFS must remain available, tighten automount policy (udev/udisks rules and disabled auto-mounting of removable media) so that only trusted volumes are mounted - this trades off convenience for reducing exposure. Restricting mount privileges (CAP_SYS_ADMIN) to trusted users limits the local attack surface but does not protect environments where an automount service mounts removable media supplied by third parties. There is no additional workaround that preserves untrusted NTFS mounting while addressing the out-of-bounds read; no public exploit code has been identified, so prioritization can follow normal kernel maintenance windows rather than emergency patching.

Affected VersionsENISA

Linux patch: 0
Linux patch: 7.3-rc2
Linux 1e9ea7e04472d4e5e12e58c881eaacfb3e49b669 <c8504fc1245f5322af5fa5c325ab05f9cf792b87
Linux 7.1
Linux 1e9ea7e04472d4e5e12e58c881eaacfb3e49b669 <3e2ae47b8ebc632c27e7843a4632d9a7c060885e
Linux patch: 7.2.7

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 classic CWE-125 out-of-bounds read in the NTFS driver's handling of the $AttrDef metadata file, which describes the attribute types a volume supports. During mount, load_and_init_attrdef() allocates the in-memory table with kvzalloc(i_size), where i_size is the on-disk $AttrDef data size, and validates it only with the weak bounds check 0 < i_size <= 0x7fffffff. ntfs_attr_find_in_attrdef() then iterates with a loop guard that bounds only the start of each entry against vol->attrdef_size, not the full entry: the condition evaluates ad->type (offset 128) and the body reads further fields, while struct attr_def is 160 bytes. If the on-disk $AttrDef is smaller than one entry (the write-up uses 120 bytes), reading ad->type already runs past the allocation, as confirmed by the KASAN report 'slab-out-of-bounds in ntfs_attr_find_in_attrdef' (Read of size 4). The path is reached when a file is created, via ntfs_attr_add → ntfs_attr_can_be_non_resident → ntfs_attr_size_bounds_check → ntfs_attr_find_in_attrdef. The fix requires the entire entry to lie within attrdef_size in the loop guard and rejects at mount any $AttrDef too small to hold one attr_def entry.

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

NVD PRIMARY 7.1 HIGH
AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:H
vuln.today AI 7.1 HIGH

Attacker must mount a crafted local NTFS image (AV:L, PR:L via mount/automount privileges); the OOB read leaks kernel memory (C:H) and can crash the kernel (A:H) with no integrity impact.

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

Primary rating from NVD.

CVSS VectorNVD

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

Lifecycle Timeline

4
CVSS changed
Oct 08, 2026 - 18:08 NVD
7.1 (HIGH)
Patch available
Sep 25, 2026 - 12:02 EUVD
CVE Published
Sep 25, 2026 - 10:36 cve.org
UNKNOWN (no severity yet)
CVE Published
Sep 25, 2026 - 10:36 nvd
HIGH 7.1

DescriptionNVD

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

ntfs: bound $AttrDef table walk to the loaded table size

ntfs_attr_find_in_attrdef() walks the in-memory $AttrDef table, but the loop condition bounds only the start of each entry, not the whole entry:

for (ad = vol->attrdef; (u8 *)ad - (u8 *)vol->attrdef < vol->attrdef_size && ad->type; ++ad)

struct attr_def is 160 bytes; the guard reads ad->type at offset 128 and the loop body reads further fields. vol->attrdef is kvzalloc(i_size), where i_size is the on-disk $AttrDef data size, checked in load_and_init_attrdef() only as 0 < i_size <= 0x7fffffff. A volume whose $AttrDef data size is smaller than one entry (e.g. 120 bytes) makes the read of ad->type run past the allocation. Creating a file reaches this through ntfs_attr_size_bounds_check() and reads out of bounds:

BUG: KASAN: slab-out-of-bounds in ntfs_attr_find_in_attrdef+0x66/0xa0 Read of size 4 at addr ffff888005833280 by task init/1 ntfs_attr_find_in_attrdef ntfs_attr_size_bounds_check ntfs_attr_can_be_non_resident ntfs_attr_add

Require the whole entry to lie within attrdef_size in the loop guard, and reject at mount a $AttrDef too small to hold one attr_def entry.

Executive ViewAI

Why It Matters

A high-severity flaw in the Linux kernel's NTFS driver can crash - and potentially leak kernel memory on - any Linux server or workstation that mounts an NTFS-formatted volume supplied by an attacker, including removable media auto-mounted by desktop or kiosk systems. Because successful abuse only requires a low-privileged local user or an automount service rather than remote access, the primary business risk is unplanned downtime and disruption of shared systems rather than mass external compromise. A vendor patch is already available, so this is a manageable patching and configuration-hygiene problem rather than an emergency, but leadership should still confirm coverage given the negligible exploitation activity observed to date.

Business Impact: Medium
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.1%
Top 97% exploitable
Prevalence
Ubiquitous
Linux kernel NTFS driver; kernel deployed across a huge fraction of environments
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.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

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

Attack Technique

A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.

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