Skip to main content

Linux Kernel CVE-2026-80674

| EUVDEUVD-2026-67550 CRITICAL
2026-08-28 Linux GHSA-2h39-9r89-9rx3
Critical
Disputed · 9.8 Vendor: Linux
View

Attack ChainAIDerived

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

  1. Access
    Craft malicious NTFS image with malformed resident $ATTRIBUTE_LIST
  2. Delivery
    Get volume mounted/read (removable media or automount)
  3. Exploit
    Kernel walks unvalidated attr_list entries
  4. Execution
    Out-of-bounds read of kernel buffer
  5. Impact
    Info disclosure or kernel crash

Vulnerability Assessment

Exploitation Conditions

Exploitation requires the kernel to parse an attacker-controlled NTFS volume containing a crafted resident $ATTRIBUTE_LIST - concretely, a malicious NTFS filesystem image or device must be mounted or read by the vulnerable in-kernel NTFS driver. Limiting factors: the attacker needs a way to introduce and cause mounting of that media (physical/removable-media access, an automount configuration, or a workflow that reads untrusted disk images), the NTFS module must be built and loadable, and the primitive is an out-of-bounds read (information disclosure / crash) rather than direct code execution. Despite the supplied AV:N/PR:N vector, there is no described remote or unauthenticated network path; the realistic prerequisite is local access to the mount/read path.

Impact

The signals conflict sharply and should be reconciled before prioritization. The provided CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N, score 9.8) implies remote unauthenticated network exploitation, but the vulnerability is triggered by parsing a crafted NTFS volume - an inherently local operation requiring the attacker to get a malicious filesystem mounted or read, so the network vector is almost certainly incorrect; verify with the kernel maintainers before treating this as remotely exploitable. The technical impact is an out-of-bounds READ, which most naturally yields kernel information disclosure and denial of service (crash), not the arbitrary code execution the 9.8/C:H/I:H/A:H would suggest - the high-integrity claim is not supported by the described primitive. Supporting the lower real-world urgency: EPSS is only 0.15% (5th percentile), the CVE is not on CISA KEV, and no public PoC is indicated. Net assessment: a legitimate memory-safety fix worth patching in normal cadence, but the raw 9.8 overstates real-world risk given the local attack surface, read-only primitive, and absence of exploitation evidence; environments that automount removable NTFS media (kiosks, forensic workstations, desktops) should weight it higher than servers that never touch NTFS.

Exploit ScenarioDerived

An attacker crafts an NTFS filesystem image whose base inode carries a malformed resident $ATTRIBUTE_LIST, then gets a victim to mount or open it - for example via an inserted USB drive on a system that automounts NTFS, or a disk image processed by a forensic/analysis workflow. When the kernel reads the inode, the unvalidated attribute-list walk over-reads adjacent kernel memory, leaking data or crashing the machine. No public proof-of-concept is currently identified, and exploitation requires local access to the media/mount path rather than a network position.

Act Now Prioritize within 24-48h. Why: CRITICAL severity.
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 – Aug 29, 2026

Out-of-bounds kernel memory reads in the Linux kernel's NTFS driver arise because ntfs_read_locked_inode() copies a resident $ATTRIBUTE_LIST into ni->attr_list via a plain memcpy() with no sanity checking, while only the non-resident path was ever validated by load_attribute_list(). A crafted NTFS volume with a malformed resident attribute list is then trusted by every subsequent walk (ntfs_external_attr_find(), ntfs_inode_attach_all_extents(), ntfs_attrlist_need()), which read fixed-header fields past the buffer. The fix factors per-entry validation into ntfs_attr_list_entry_is_valid()/ntfs_attr_list_is_valid() and applies it on the resident path and inside load_attribute_list() itself; no public exploit identified at time of analysis and EPSS probability is very low (0.15%).

RemediationAI

Patch available per vendor: apply the kernel fix delivered in stable commits https://git.kernel.org/stable/c/55e97648f7753c6097cb682d24d1abcfe878e812 and https://git.kernel.org/stable/c/7d19e1ffee084c4f7d321a360c14ba43404f7cc8, or upgrade to a distribution kernel that incorporates these stable commits; a single independently confirmed tagged release version cannot be reliably extracted from the provided EUVD data, so confirm the exact patched version with your distribution's advisory. As compensating controls where immediate patching is not possible: disable or blacklist the ntfs kernel module if NTFS support is not needed (side effect - NTFS volumes become unreadable); disable automatic mounting of removable/USB media via udisks/autofs policy so a crafted volume cannot be parsed without an operator action (side effect - users must mount media manually); and restrict which users may mount filesystems (avoid user_allow_other/suid mount helpers) so only trusted administrators can introduce NTFS images.

Affected VersionsENISA

Linux patch: 7.2
Linux 1e9ea7e04472d4e5e12e58c881eaacfb3e49b669 <7d19e1ffee084c4f7d321a360c14ba43404f7cc8
Linux 7.1
Linux patch: 0
Linux 1e9ea7e04472d4e5e12e58c881eaacfb3e49b669 <55e97648f7753c6097cb682d24d1abcfe878e812
Linux patch: 7.1.5

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 in-kernel NTFS filesystem driver's attribute-list handling. NTFS stores file metadata in MFT records; when a base MFT record cannot hold all attributes, an $ATTRIBUTE_LIST attribute enumerates struct attr_list_entry records (each with lowest_vcn at offset 8, mft_reference at offset 16, a name_offset at offset 7, plus a variable-length name). Attribute lists can be resident (stored inline in the MFT record) or non-resident (stored in external runs). The bug is a classic missing-input-validation / out-of-bounds read (CWE-125, consistent with the 'Buffer Overflow' tag; NVD lists CWE as N/A): the resident path bypassed validation entirely, and even load_attribute_list()'s own loop bounded only by 'al < al_start + size' could over-read the fixed header of a truncated trailing entry. Because these buffers come from untrusted on-disk data, any code that dereferences entry fields before confirming the fixed header (offsetof(attr_list_entry, name)) and 8-byte-aligned length fit within the buffer can read adjacent kernel memory.

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

Sources disagree (Medium–Critical)
Vendor (Linux) PRIMARY 9.8 CRITICAL
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
vuln.today AI 7.1 HIGH

Triggered by parsing a mounted crafted NTFS volume, so AV:L and PR:L (ability to mount/read media); out-of-bounds read yields info disclosure (C:H) and crash (A:H) but 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
SUSE 6.1 HIGH
AV:L/AC:L/PR:L/UI:N/S:U/C:L/I:N/A:H
Red Hat 5.5 MEDIUM

vuln.today treats the vendor’s rating as authoritative. A higher third-party CVSS (e.g. CISA-ADP) is shown for transparency but does not drive the headline severity.

CVSS VectorVendor: Linux

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

Lifecycle Timeline

4
CVSS changed
Aug 29, 2026 - 07:22 NVD
9.8 (CRITICAL)
Patch available
Aug 28, 2026 - 09:02 EUVD
CVE Published
Aug 28, 2026 - 06:49 cve.org
CRITICAL 9.8
CVE Published
Aug 28, 2026 - 06:49 cve.org
UNKNOWN (no severity yet)

DescriptionCVE.org

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

ntfs: validate resident attribute lists and harden the validator

A base inode's $ATTRIBUTE_LIST is sanity-checked by load_attribute_list() only on the non-resident path; ntfs_read_locked_inode() copies a *resident* attribute list into ni->attr_list with a plain memcpy() and no validation at all. Every subsequent walk of ni->attr_list -- ntfs_external_attr_find(), ntfs_inode_attach_all_extents() and ntfs_attrlist_need() -- then trusts the entries are well-formed and reads attr_list_entry fixed-header fields (lowest_vcn at offset 8, mft_reference at offset 16, and the name) with bounds that assume validation already happened. A crafted resident attribute list therefore reaches those walks unvalidated and can drive out-of-bounds reads of the attribute-list buffer.

load_attribute_list() itself reads ale->name_offset (offset 7), ale->mft_reference (offset 16) and the name length under only an "al < al_start + size" bound, so its own validation loop can over-read the fixed header of a truncated trailing entry by a few bytes.

Factor the per-entry validation into ntfs_attr_list_entry_is_valid(), which requires each entry's fixed header (offsetof(struct attr_list_entry, name)) to be in range before any field is dereferenced, that ale->length is a multiple of 8 covering the fixed header plus the name, and that the entry is in use and carries a live MFT reference. ntfs_attr_list_is_valid() walks the buffer with it and checks the entries tile it exactly. Use the list validator in load_attribute_list() (replacing the open-coded loop, closing its own over-read) and on the resident path in ntfs_read_locked_inode() (which previously skipped validation entirely); patches 2/3 reuse the per-entry helper at the other two attribute-list walks.

Executive ViewAI

Why It Matters

The Linux kernel NTFS driver contains a critical vulnerability (CVE-2026-80674) that could allow attackers to extract sensitive data from kernel memory through specially crafted storage volumes. While current exploitation risk remains low, this affects all organizations using Linux with NTFS support and requires prompt patching to prevent potential data breaches.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 95% exploitable
Prevalence
Ubiquitous
Linux kernel is ubiquitous, though the vulnerable NTFS module is not always loaded
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 CRITICAL
CISA KEV No
Public POC No
EPSS 0.2%
Patch available Yes
Active threat No
Deciding rule
CRITICAL severity
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
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact
High

Priority Score

49
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +49
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.

Vendor StatusVendor

SUSE

Severity: Important
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