CVE-2026-72209
Received Received - Intake

Buffer Overflow in Linux Kernel NTFS Filesystem

Vulnerability report for CVE-2026-72209, including description, CVSS score, EPSS score, affected products, exploitability, helpful resources, and attack-flow context.

Publication date: 2026-08-15

Last updated on: 2026-08-17

Assigner: kernel.org

Description

In the Linux kernel, the following vulnerability has been resolved: ntfs: validate attribute values on lookup ntfs_attr_find() and ntfs_external_attr_find() check that generic resident attribute values fit in their attribute records and that fixed-size resident values are large enough. For variable-length resident formats, however, the fixed part is not enough: embedded length fields can still point callers past the resident value. A crafted image can set a small resident $FILE_NAME value_length while leaving file_name_length large. Callers then trust file_name_length and read past the resident value when converting or comparing the name. This was reproduced with a crafted image under KASAN as a slab-out-of-bounds read from the kmalloc-1k MFT record copy. The stack included ntfs_lookup(), ntfs_iget(), ntfs_read_locked_inode(), ntfs_attr_name_get(), ntfs_ucstonls(), and utf16s_to_utf8s(). Add a shared attribute value validator and use it before a lookup path can return an attribute, including the AT_UNUSED enumeration case where callers inspect returned attributes directly. The helper validates resident value bounds, minimum resident value sizes, variable-length $FILE_NAME fields, and non-resident mapping-pairs metadata that was previously checked separately in both lookup paths. This also preserves the intended resident @val matching semantics in the external attribute lookup path. The old duplicated validation block overwrote the actual resident value length with the type-specific minimum length before comparing @val, so variable-length resident values could fail to match even when the bytes were identical. Keep the comparison on the actual value length, and make ntfs_attrlist_entry_add() compare resident attributes with lowest_vcn zero instead of reading the non-resident union member after a successful resident match. Reject non-resident $FILE_NAME records too: the format requires $FILE_NAME to be resident and callers treat returned records as resident.

CVSS Scores

EPSS Scores

Probability:
Percentile:

Meta Information

Published
2026-08-15
Last Modified
2026-08-17
Generated
2026-09-04
AI Q&A
2026-08-15
EPSS Evaluated
2026-09-03
NVD
EUVD

Affected Vendors & Products

Currently, no data is known.

Helpful Resources

Exploitability

CWE
CWE Icon
KEV
KEV Icon
CWE ID Description
CWE-UNKNOWN

Attack-Flow Graph

AI Quick Actions

Instant insights powered by AI
Executive Summary

This vulnerability in the Linux kernel involves improper validation of attribute values during file system lookups in the NTFS implementation. Specifically, functions like ntfs_attr_find() and ntfs_external_attr_find() fail to properly check variable-length resident attribute values, allowing crafted images to set mismatched length fields. This can lead to out-of-bounds memory reads when processing file names, potentially causing crashes or data corruption.

Detection Guidance

This vulnerability is specific to the Linux kernel's NTFS filesystem handling. Detection requires checking the kernel version and verifying if the vulnerable code paths are present. Use commands like 'uname -a' to check the kernel version and 'grep NTFS_FS /proc/filesystems' to confirm NTFS support. Inspect kernel logs for slab-out-of-bounds errors or filesystem corruption related to NTFS.

Impact Analysis

An attacker could exploit this to trigger memory corruption in the Linux kernel by providing a maliciously crafted NTFS image. This might result in system crashes, privilege escalation, or unauthorized data access. Systems processing untrusted NTFS files are at risk, including those using external storage or virtual machines with shared NTFS images.

Compliance Impact

This vulnerability involves a slab-out-of-bounds read in the Linux kernel's NTFS file system handling, which could lead to memory corruption or unauthorized data access. While not directly tied to GDPR or HIPAA, such memory corruption risks could potentially expose sensitive data if exploited, indirectly impacting compliance with data protection regulations that require secure data handling and integrity.

Mitigation Strategies

Immediately update the Linux kernel to a patched version that includes the fix for this NTFS vulnerability. Avoid mounting or using untrusted NTFS images until the system is updated. Monitor kernel logs for suspicious activity related to filesystem operations.

Chat Assistant

Ask questions about this CVE
Hi! I’m here to help you understand CVE-2026-72209. Ask me anything about the vulnerability, its impact, or mitigation strategies.
0/70

EPSS Chart