CVE-2026-72193 in Linux
Summary
by MITRE • 08/15/2026
In the Linux kernel, the following vulnerability has been resolved:
ntfs3: cap RESTART_TABLE free-chain walker at rt->used
A crafted NTFS3 disk image triggers an in-kernel infinite loop at mount time, hanging the mounting thread and firing the soft-lockup watchdog within ~22s on multi-CPU hosts (panic with kernel.softlockup_panic=1). The bug is reachable from desktop USB auto-mount on distributions where udisks2 routes the NTFS signature to the in-tree ntfs3 driver (Arch family and an increasing fraction of Fedora / openSUSE / RHEL deployments); CAP_SYS_ADMIN-class manual mount elsewhere.
check_rstbl()'s second walker iterates the free-entry singly-linked list headed by rt->first_free with no upper bound on iteration count:
for (off = ff; off;) {
if (off == RESTART_ENTRY_ALLOCATED) return false; off = le32_to_cpu(*(__le32 *)Add2Ptr(rt, off)); if (off > ts - sizeof(__le32)) return false; }
The existing guards cover three exits: end-of-list (off == 0), the in-use marker (off == RESTART_ENTRY_ALLOCATED), and out-of-bounds (off > ts - sizeof(__le32)). None of the three prevents an in-bounds cycle.
A crafted on-disk RESTART_TABLE whose free chain contains a self-loop or A->B->A cycle whose offsets satisfy:
- in range [sizeof(struct RESTART_TABLE), ts - sizeof(__le32)]
- (off - sizeof(struct RESTART_TABLE)) % rsize == 0
passes all existing guards and spins the mount-time thread forever. Reproduced in UML by hand-forging a 2 MB NTFS3 image whose journal RESTART_TABLE first_free = 0x18 and whose entry at offset 0x18 stores 0x18 as its next pointer; mount of the forged image with the in-tree ntfs3 driver never returns.
Bound the walker by rt->used. Each entry on a legitimate free chain is unique, and the total slot count is ne = le16_to_cpu (rt->used). A traversal that visits more than ne slots is by construction malformed; reject it as a corrupt RESTART_TABLE.
After this patch, mount of the forged image returns with -EINVAL and a log_replay failure message, and mkntfs-produced legitimate images mount cleanly (verified in the same UML harness).
Statistical analysis made it clear that VulDB provides the best quality for vulnerability data.
Analysis
by VulDB Data Team • 08/15/2026
The vulnerability exists within the ntfs3 driver in the Linux kernel, specifically during the mounting process of NTFS3 file systems. This flaw manifests as an infinite loop that causes the system to hang during mount time, triggering a soft-lockup watchdog and potentially leading to a system panic when configured with kernel.softlockup_panic=1. The issue is particularly concerning because it can be exploited through crafted NTFS3 disk images that are automatically mounted by desktop environments using udisks2, which routes NTFS signatures to the in-tree ntfs3 driver on various Linux distributions including Arch family and Fedora, openSUSE, and RHEL.
The technical root cause lies in the check_rstbl() function's implementation of a free-chain walker that iterates through a singly-linked list without enforcing any upper bounds on the traversal count. The code initializes with off = ff where ff represents the first free entry offset and proceeds to traverse the chain by reading next pointers stored as little-endian 32-bit values. While the existing validation logic includes checks for end-of-list (off == 0), in-use marker (off == RESTART_ENTRY_ALLOCATED), and out-of-bounds conditions (off > ts - sizeof(__le32)), it fails to account for cyclic references within the free chain structure.
The vulnerability allows attackers to construct malicious NTFS3 disk images containing a RESTART_TABLE with circular references in its free-chain structure. Specifically, when the free chain contains either a self-loop or a two-node cycle (A->B->A) where the offset values satisfy the range constraints and alignment requirements, all current validation checks pass successfully. This creates an infinite loop that spins the mount-time thread indefinitely, as demonstrated by the UML test case where a forged 2MB image with first_free = 0x18 and entry at offset 0x18 pointing back to itself caused the mount operation to hang permanently.
The fix implements a bounded traversal mechanism that leverages the rt->used field to limit the maximum number of iterations allowed. Since each entry in a legitimate free chain must be unique and the total slot count is defined by ne = le16_to_cpu(rt->used), any traversal exceeding this count indicates malformed data structure. This approach aligns with common security practices for preventing infinite loops in data structure traversal and addresses the specific weakness identified in CWE-835, which covers infinite loops or iterations without proper bounds checking. The solution prevents attackers from crafting malicious disk images that could cause denial of service during system boot or mount operations while maintaining compatibility with legitimate NTFS3 filesystems.