Skip to main content

Linux Kernel CVE-2026-80672

| EUVDEUVD-2026-67548 HIGH
2026-08-28 Linux GHSA-f427-cm5v-83vc
8.8
CVSS 3.1 · Vendor: Linux
View

Attack ChainAIDerived

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

  1. Access
    Insert crafted NTFS image with malformed log_clients field
  2. Delivery
    Trigger kernel mount via automount or direct mount call
  3. Exploit
    u16 truncation in ntfs_check_restart_area() bypasses page-size bounds check
  4. Execution
    ntfs_check_log_client_array() walks ~64 KiB past heap buffer
  5. Persist
    Read attacker-influenced kernel heap memory
  6. Impact
    Leverage info-leak for KASLR bypass or sensitive data disclosure

Vulnerability Assessment

Exploitation Conditions

Exploitation requires that the target kernel have the classic NTFS module (ntfs, not ntfs3) loaded or loadable, and that the attacker be able to trigger a mount of a crafted NTFS image. On typical desktop Linux systems with udisks2 or systemd automount configured, low-privileged users can mount removable NTFS media without additional privileges, making exploitation straightforward if the attacker controls physical media or a shared storage path. On server systems with strict mount policies, capability restrictions (CAP_SYS_ADMIN), or module deny-listing, the attack surface is substantially reduced. Systems exclusively using the ntfs3 driver, or where the ntfs module is absent or blocked via modprobe configuration, are not exposed. The vulnerability is triggered during load_and_check_logfile() at mount time - no post-mount interaction is required.

Impact

The CVSS 3.1 score of 8.8 (AV:L/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H) reflects a credible kernel-level impact potential, but several signals materially discount the urgency. The attack vector is strictly local: exploitation requires the ability to mount a crafted NTFS image, which on hardened systems demands explicit capability grants (CAP_SYS_ADMIN) or configured automount - a meaningful constraint absent from the CVSS score alone. The EPSS score of 0.15% at the 5th percentile represents an extremely low exploitation probability and substantially undercuts the high CVSS number; there is no CISA KEV listing and no known public exploit code, so the high CVSS reflects theoretical worst-case impact rather than observed threat actor activity. One signal mismatch warrants explicit note: the CVSS scope change (S:C) implies a kernel-to-system boundary crossing, which for a read-only OOB primitive is plausible as an information-leak stepping stone (e.g., KASLR bypass) but is not independently confirmed - organizations should treat I:H as aspirational without a chained write primitive. Overall, this flaw merits scheduled patch application on affected kernel versions but does not warrant emergency out-of-band response absent evidence of exploitation.

Exploit ScenarioDerived

An attacker with local access places or inserts a crafted NTFS image - for example, a USB drive or a loop device file - containing a $LogFile restart area with log_clients set to 410 and a suitable ca_ofs value. When the kernel mounts the image via the classic NTFS driver at mount time, ntfs_check_restart_area() performs a truncated u16 bounds check that incorrectly passes, and ntfs_check_log_client_array() subsequently reads approximately 64 KiB of kernel heap memory beyond the allocated restart-page buffer, potentially disclosing sensitive kernel data. No public proof-of-concept exists at time of analysis, though the detailed technical description in the commit message provides sufficient grounding for exploit development.

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 – Aug 29, 2026

Out-of-bounds kernel heap read in the Linux kernel's classic in-tree NTFS driver (fs/ntfs/) allows a local, low-privileged user to disclose kernel memory - and potentially chain to privilege escalation - by mounting a crafted NTFS image at the filesystem layer. The flaw is a u16 integer truncation in ntfs_check_restart_area() that silently defeats a page-size bounds check, causing ntfs_check_log_client_array() to dereference up to ~64 KiB beyond an allocated heap buffer using attacker-controlled on-disk values. No public exploit code exists and no active exploitation has been confirmed; EPSS is 0.15% (5th percentile), reflecting negligible observed exploitation pressure.

RemediationAI

Apply upstream kernel patches available at https://git.kernel.org/stable/c/07a4751ef3ccc8bfd17bfbb16e5003c03161790d and https://git.kernel.org/stable/c/390936fb15053d8d8991ca3a22776e251a5a7f2f; stable releases 7.1.5 and 7.2 include these fixes per EUVD-2026-67548 and should be targeted for upgrade. For systems that cannot be patched immediately, the most effective compensating control is to block loading of the classic NTFS kernel module: add install ntfs /bin/false to /etc/modprobe.d/disable-ntfs.conf and run modprobe -r ntfs, which eliminates the attack surface entirely at the cost of classic-driver NTFS read capability - the ntfs3 driver (ntfs3 module) can substitute for read/write NTFS access on modern kernels. Where module blocking is impractical, restrict filesystem mount permissions so only privileged users can mount NTFS volumes (e.g., remove user from /etc/fstab NTFS entries, disable udisks2 NTFS automount for non-root users). Audit automount daemons that may mount removable NTFS media without privilege checks.

Affected VersionsENISA

Linux 1e9ea7e04472d4e5e12e58c881eaacfb3e49b669 <07a4751ef3ccc8bfd17bfbb16e5003c03161790d
Linux 1e9ea7e04472d4e5e12e58c881eaacfb3e49b669 <390936fb15053d8d8991ca3a22776e251a5a7f2f
Linux patch: 0
Linux patch: 7.1.5
Linux patch: 7.2
Linux 7.1

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 Linux kernel ships two distinct NTFS implementations: the classic driver (fs/ntfs/), affected here, and the newer ntfs3 driver - these are unrelated codepaths. In the classic driver, ntfs_check_restart_area() validates that a $LogFile restart area and its trailing log_client_record array fit within the system page size. The variable ra_len is declared as u16, but the right-hand arithmetic involves sizeof(struct log_client_record) which is a size_t (160 bytes). An on-disk log_clients value of 410 yields 410 × 160 = 65,600, which truncates to a small residual modulo 65,536 when stored in u16 ra_len, so the page-size bounds check passes for what is actually a wildly oversized client array. ntfs_check_log_client_array() then iterates using the raw on-disk log_clients count without re-validating, dereferencing heap memory ~64 KiB beyond the kvzalloc(system_page_size) restart-page buffer. This is structurally identical to CVE-2022-30789, which was corrected in the ntfs-3g FUSE userspace driver but was never ported back to this in-kernel classic driver. The root cause is integer truncation on width-mismatch (analogous to CWE-190 / CWE-125); no CWE was formally assigned by NVD. Affected CPE: cpe:2.3:a:linux:linux:*:*:*:*:*:*:*:*.

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 8.8 HIGH
AV:L/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H
vuln.today AI 8.7 HIGH

OOB read primitive only - I:L, not I:H; PR:L reflects low-privilege mounter; S:C for kernel-scope boundary; A:H for potential kernel panic.

3.1 AV:L/AC:L/PR:L/UI:N/S:C/C:H/I:L/A:H
4.0 AV:L/AC:L/AT:N/PR:L/UI:N/VC:H/VI:L/VA:H/SC:H/SI:L/SA:H
SUSE 6.3 MEDIUM
AV:L/AC:H/PR:L/UI:N/S:U/C:H/I:N/A:H
Red Hat 5.5 MEDIUM

Primary rating from Vendor (Linux).

CVSS VectorVendor: Linux

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

Lifecycle Timeline

4
CVSS changed
Aug 29, 2026 - 07:22 NVD
8.8 (HIGH)
Patch available
Aug 28, 2026 - 09:02 EUVD
CVE Published
Aug 28, 2026 - 06:49 cve.org
HIGH 8.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: fix u16 truncation of restart-area length check

ntfs_check_restart_area() validates that the $LogFile restart area and its trailing log client record array fit within the system page size:

u16 ra_ofs, ra_len, ca_ofs; ... ra_len = ca_ofs + le16_to_cpu(ra->log_clients) * sizeof(struct log_client_record); if (ra_ofs + ra_len > le32_to_cpu(rp->system_page_size) || ...) return false;

ra_len is u16, but the right-hand side is computed in size_t (sizeof(struct log_client_record) == 160). Both ca_ofs and log_clients come straight from the on-disk restart area. With an on-disk log_clients of 410 the product 410 * 160 = 65600; adding ca_ofs and storing into the u16 ra_len truncates modulo 65536 (e.g. ca_ofs 64 gives ra_len 128), so the "fits in the page" check passes even though the client array described by log_clients extends far beyond the page.

ntfs_check_log_client_array() then walks the array bounded only by the on-disk log_clients count:

cr = ca + idx; if (cr->prev_client != LOGFILE_NO_CLIENT) ...

For log_clients 410 it dereferences records up to ca + 409 * 160, ~64 KiB past the kvzalloc(system_page_size) restart-page buffer -- an out-of-bounds read of attacker-controlled extent, reachable when a crafted NTFS image is mounted (load_and_check_logfile() at mount time). This is the in-kernel analogue of CVE-2022-30789, fixed in the ntfs-3g userspace driver but never in this revived classic driver.

Compute the restart-area length in a u32 so the existing bounds check rejects an over-large client array instead of being defeated by the truncation. Widen ra_ofs and ca_ofs to u32 as well: both are loaded from __le16 on-disk fields and every comparison already promotes to int/size_t, so this changes no result and keeps the declaration uniform.

Executive ViewAI

Why It Matters

The Linux kernel's NTFS filesystem driver contains a memory access vulnerability (CVSS 8.8) that could allow unauthorized elevation of privileges on systems running affected kernel versions. The vulnerability is triggered through mounting specially crafted NTFS images, exposing kernel memory that can facilitate privilege escalation. Organizations must prioritize patching systems that allow untrusted users to mount filesystems or accept external storage media.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 95% exploitable
Prevalence
High
Linux kernel present on most servers, desktops, and embedded devices globally
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
Scheduled
Exploitation· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact
High

Priority Score

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