Skip to main content

Linux Kernel CVE-2026-72470

| EUVDEUVD-2026-59369 HIGH
2026-08-15 Linux GHSA-mxhq-w28g-hr4q
7.8
CVSS 3.1 · Vendor: Linux
View

Attack ChainAIDerived

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

  1. Recon
    Craft dirty NTFS volume with oversized log page
  2. Delivery
    Transfer volume to target system
  3. Exploit
    Mount volume using ntfs3 driver
  4. Install
    log_replay() adopts larger on-disk page size
  5. C2
    one_page_buf not reallocated
  6. Execute
    read_log_page() overflows heap buffer
  7. Impact
    Leverage heap corruption for privilege escalation

Vulnerability Assessment

Exploitation Conditions

Exploitation requires local authenticated access (CVSS PR:L) with the ability to mount filesystems - either directly as root, via sudo, through a permissive udisks2/automount policy, or via user namespace mounts where allowed by the kernel configuration. The NTFS volume being mounted must be dirty, meaning it was not cleanly unmounted and retains a valid $LogFile restart area. Critically, the on-disk sys_page_size recorded in that restart area must be larger than the mounting host's PAGE_SIZE (e.g., a 64K log page on a host with 4K PAGE_SIZE); this condition does not arise with NTFS volumes formatted and normally used on matching-page-size hosts. The ntfs3 kernel module must be loaded and selected over the legacy ntfs driver. Factors limiting exploitation: the requirement to supply or control a specifically crafted NTFS volume, the page-size mismatch condition that must be intentionally engineered, the need for local mount capability, and the absence of this code path on systems that never mount NTFS volumes. Pure server environments without NTFS exposure are not affected in practice.

Impact

The CVSS 7.8 score (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) is technically justified - a heap overflow in kernel context carries full C/I/A impact potential - but the local attack vector and specific triggering conditions substantially constrain real-world risk. EPSS at 0.18% (7th percentile) reflects the absence of any observed exploitation and the niche nature of the trigger: the attacker must control an NTFS volume with a specific page-size mismatch condition. No CISA KEV listing and no public POC further reduce urgency. The attack complexity is genuinely low once a suitable volume is crafted (AC:L is fair), but the prerequisite of local filesystem-mount capability rules out remote exploitation entirely. Even a mid-sized municipal IT team in bytom should treat this as a routine patch-cycle item rather than an emergency response, unless their environment includes shared workstations or kiosk systems where users routinely plug in external NTFS drives. Server environments that never mount NTFS volumes are essentially unexposed. The primary realistic threat is a malicious insider or a compromised user account on a desktop Linux system using ntfs3 to mount external media.

Exploit ScenarioDerived

An attacker with a local shell on a Linux desktop or shared system crafts or obtains a dirty NTFS disk image whose $LogFile restart area records a 64K log page size - a condition achievable by formatting the volume on Windows with a large cluster size and then forcibly removing it without unmounting. The attacker mounts this image using the ntfs3 driver; during log replay, the kernel allocates a 4K scratch buffer but then adopts the 64K on-disk page size, subsequently writing 64K into the 4K heap allocation. The resulting heap overflow may be leveraged to overwrite adjacent kernel structures and escalate to root. No public POC has been identified at time of analysis.

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 17, 2026

Heap buffer overflow in the Linux kernel ntfs3 filesystem driver's log_replay() function allows a local authenticated user to corrupt kernel heap memory by mounting a dirty NTFS volume whose on-disk log page size exceeds the host PAGE_SIZE. The one_page_buf scratch buffer is allocated using the host page size but never resized when a larger on-disk page size is adopted from the restart area, causing read_log_page() to write beyond the allocation boundary. No public exploit code exists, EPSS is 0.18% (7th percentile), and this is not listed in the CISA KEV catalog, placing current exploitation probability very low despite a CVSS 7.8 base score.

RemediationAI

Update to a patched kernel version: 6.6.145, 6.12.97, 6.18.40, 7.1.5, or 7.2-rc1 as appropriate for your distribution's stable series; patch commits are available at https://git.kernel.org/stable/c/2097a2537d9d1c29c0e20ed0dbf717a0ccd8f374 and the per-branch equivalents linked in the references. Distribution-packaged kernels from major vendors should be checked for backported fixes. As a compensating control on systems that do not require NTFS support, blacklist the ntfs3 module by adding 'blacklist ntfs3' to /etc/modprobe.d/blacklist.conf and running update-initramfs (or equivalent); note this disables all ntfs3 NTFS mounts and may break workflows involving Windows-formatted storage. On multi-user or shared systems where users can connect external media, restrict automated mount policies via udisks2 or udev rules to require administrator approval before mounting NTFS volumes until the kernel is updated. The legacy ntfs driver (not ntfs3) is a separate codebase and is not affected by this specific flaw, but carries its own known limitations.

Affected VersionsENISA

Linux patch: 6.18.40
Linux b46acd6a6a627d876898e1c84d3f84902264b445 <c99444f6dfca893f6d310aae4a53c620f98f7b4f
Linux patch: 6.12.97
Linux b46acd6a6a627d876898e1c84d3f84902264b445 <5a35454179fe1041d9cd286f5d320ce0d448c12a
Linux 5.15
Linux patch: 7.2-rc1
Linux b46acd6a6a627d876898e1c84d3f84902264b445 <4f129fc6f756f8541e5bff45b1804cc11b1ec712
Linux patch: 0
Linux b46acd6a6a627d876898e1c84d3f84902264b445 <2097a2537d9d1c29c0e20ed0dbf717a0ccd8f374
Linux patch: 6.6.145
Linux b46acd6a6a627d876898e1c84d3f84902264b445 <f1422df595d69b997d23a8f11e12c528ccef7fad
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 vulnerable code resides in fs/ntfs3/log.c within the ntfs3 driver, which was merged into the Linux mainline kernel at version 5.15. During mount of a dirty NTFS volume (one whose $LogFile has a valid restart area), log_replay() first allocates log->one_page_buf using kmalloc(log->page_size, GFP_NOFS) where log->page_size is derived from the host PAGE_SIZE - typically 4096 bytes on x86_64 hosts. When norm_file_page() later resolves the on-disk sys_page_size from the restart area header, log->page_size is updated to the disk value (e.g., 65536 bytes, the DefaultLogPageSize on many NTFS volumes formatted by Windows on systems with 64K cluster sizes) but one_page_buf is left at its original allocation. A subsequent unaligned call to read_log_page() passes log->page_size as the byte count into this undersized buffer via ntfs_read_run_nb_ra(), producing a classic CWE-122 heap-based buffer overflow. The fix adds a krealloc() call at the point where the on-disk page size is adopted, leaving the original buffer intact on allocation failure so the existing error path can free it safely. 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 7.8 HIGH
AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
vuln.today AI 7.8 HIGH

Local filesystem-mount capability required (AV:L, PR:L); no external interaction beyond attacker-controlled mount (UI:N); heap overflow in kernel context yields full C/I/A impact potential.

3.1 AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
4.0 AV:L/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
SUSE 5.5 MEDIUM
AV:L/AC:L/PR:L/UI:N/S:U/C:N/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
Unchanged
Confidentiality
High
Integrity
High
Availability
High

Lifecycle Timeline

4
CVSS changed
Aug 17, 2026 - 06:22 NVD
7.8 (HIGH)
Patch available
Aug 15, 2026 - 07:20 EUVD
CVE Published
Aug 15, 2026 - 05:57 cve.org
HIGH 7.8
CVE Published
Aug 15, 2026 - 05:57 cve.org
UNKNOWN (no severity yet)

DescriptionCVE.org

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

fs/ntfs3: resize log->one_page_buf when adopting on-disk page size

log_replay() allocates log->one_page_buf using the page size that was chosen from the host PAGE_SIZE:

log->one_page_buf = kmalloc(log->page_size, GFP_NOFS);

Later, when a restart area is found, the log page size recorded on disk is adopted:

t32 = le32_to_cpu(log->rst_info.r_page->sys_page_size); if (log->page_size != t32) { log->l_size = log->orig_file_size; log->page_size = norm_file_page(t32, &log->l_size, t32 == DefaultLogPageSize); }

If the on-disk page size is larger than the size used for the initial allocation, log->page_size grows but one_page_buf is left at its original, smaller size. A subsequent unaligned read_log_page() then reads log->page_size bytes into the undersized scratch buffer:

page_buf = page_off ? log->one_page_buf : *buffer; err = ntfs_read_run_nb_ra(ni->mi.sbi, &ni->file.run, page_vbo, page_buf, log->page_size, NULL, &log->read_ahead);

overflowing the allocation. This is reachable when mounting a dirty NTFS volume whose log was formatted with a page size larger than the buffer initially allocated on the mounting host (for example a 64K-log volume mounted on a host that allocated a 4K scratch buffer).

Grow one_page_buf when the adopted on-disk page size exceeds the size used for the initial allocation. On krealloc() failure the original buffer is left intact and freed by the existing error path.

Executive ViewAI

Why It Matters

Linux kernel ntfs3 driver contains a heap buffer overflow (CVE-2026-72470) triggered by malicious NTFS volume metadata, allowing local authenticated users to corrupt kernel memory and potentially escalate privileges or crash systems. While CVSS rates this 7.8, exploitation probability is negligible (EPSS 0.2%), requires direct system access, and affects primarily organizations operating Linux with NTFS support in multi-user or external storage scenarios.

Business Impact: Medium
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 93% exploitable
Prevalence
High
Linux kernel deployed across billions of devices globally
Data Quality
5 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

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 Affected
SUSE Linux Enterprise Desktop 15 SP7 Affected
SUSE Linux Enterprise High Availability Extension 15 SP7 Affected
SUSE Linux Enterprise High Availability Extension 15 SP7 Affected
SUSE Linux Enterprise High Availability Extension 16.0 Affected

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy