Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSupply crafted NTFS volume
-
DeliveryMount filesystem locally
-
ExploitCreate file triggers attrdef walk
-
ExecutionRead ad->type past allocation
-
ImpactLeak 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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
Affected Packages
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
AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:H
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.
Primary rating from NVD.
CVSS VectorNVD
Lifecycle Timeline
4DescriptionNVD
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
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.
Apply vendor patch.
Threat Intelligence Overview
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.
What every action level means
SSVC AssessmentENISA
Priority Score
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.
EUVD-2026-86967
GHSA-v5r3-r9hr-q598
NVD
CVE.org
EPSS
Exploit-DB