These pages are published after PatchSiren validates generated defensive summaries against stored public CVE and source evidence.
A vulnerability in the Linux kernel has been resolved, related to a reference count leak in the lockd component. Specifically, the cached-file path in nlm_lookup_file() updates *result and file->f_count even when nlm_do_fopen() fails, leading to a reference count leak that can prevent the file from being reaped by nlm_traverse_files(). This issue arises because the cached-file path in nlm_lookup_file() re [truncated]
AI-assisted PatchSiren debrief based on the supplied source corpus. The CVE record was published on 2026-08-15T06:21:40.493Z and has not been modified since then. The Linux kernel vulnerability CVE-2026-72217 allows for an out-of-bounds store in the SUNRPC xdr_buf_to_bvec() function. The patched vulnerability moves the in-range check ahead of the store in the head, page-loop, and tail branches. The Linux [truncated]
A vulnerability has been resolved in the Linux kernel, specifically affecting MIPS: DEC configurations. The issue arises when calling firmware entry points from kernel threads other than the initial one in 64-bit configurations, leading to incorrect stack pointer manipulation and potential control flow issues. The fix involves switching the stack in the o32 wrapper for prom_printf() to ensure a 32-bit stack location.
A vulnerability in the Linux kernel has been resolved, related to hugetlb cgroup rsvd charge/uncharge mismatch. The issue arises from a single h_cg pointer being used for both rsvd and non-rsvd hugetlb cgroup charges in alloc_hugetlb_folio(). This leads to incorrect cgroup pointers being stored and ultimately results in a page_counter underflow when the folio is freed. The vulnerability affects Linux kern [truncated]
AI-assisted PatchSiren debrief based on the supplied source corpus. The CVE record was published on 2026-08-15T06:21:39.913Z and has not been modified since then. The Linux kernel vulnerability CVE-2026-72212 involves incorrect altmap passing in error paths during memory hotplug operations. This could lead to memory corruption if exploited. The fix ensures that the correct altmap is passed to arch_remove_ [truncated]
The Linux kernel vulnerability, CVE-2026-72211, exists in the ntfs module, specifically in the ntfs_ir_reparent function. This function moves resident index root entries into an index block, leaving a small root stub containing the child VCN. The current code publishes the larger index.index_length and index.allocated_size before resizing the resident value, which can lead to a transient corrupt index roo [truncated]
The Linux kernel has a vulnerability in the ntfs: fix off-by-one in mapping pairs decoding bounds checks. This issue has been resolved. The vulnerability is related to the ntfs_mapping_pairs_decompress() function, where attr_end points one byte past the end of the attribute record. The two bounds checks validating that mapping pair data bytes fit within the attribute use strict greater-than (>), which all [truncated]
The Linux kernel's ntfs file system has a vulnerability that could allow an attacker to read past the resident value when converting or comparing a file name. This was resolved by adding a shared attribute value validator. The vulnerability was found in the Linux kernel's ntfs file system, where a crafted image can set a small resident $FILE_NAME value_length while leaving file_name_length large, allowing [truncated]
The Linux kernel vulnerability, CVE-2026-72208, involves a resolved issue with added bounds checks before accessing EA entries in ntfs_ea_lookup and ntfs_listxattr. This change aims to prevent potential access issues with EA entries. Linux kernel users and administrators should be aware of this vulnerability and verify their kernel versions to ensure they are protected. The CVE record was published on 202 [truncated]
AI-assisted PatchSiren debrief based on the supplied source corpus. The CVE record was published on 2026-08-15T06:21:39.307Z and has not been modified since then. The Linux kernel has a vulnerability related to ntfs index block header validation. The CVE record indicates that the ntfs_index_block_inconsisent() function has been modified to perform stricter validation of INDEX_HEADER geometry in INDX block [truncated]
A vulnerability was found in the Linux kernel's ntfs_fill_super() function, which did not properly free volume-wide resources on fill_super failure. This could lead to a silent leak of resources, including vol->nls_map, vol->volume_label, and vol->lcn_empty_bits_per_page, with no chance of recovery short of unloading the module. The vulnerability was resolved by moving the per-volume frees down to err_out [truncated]
The Linux kernel's NTFS implementation has a vulnerability in $INDEX_ROOT header validation, tracked as CVE-2026-72204. This issue allows for stricter validation of $INDEX_ROOT, enhancing consistency across directory inodes and named index inodes. The vulnerability has been resolved with a dedicated helper. Linux kernel developers, administrators, and users relying on NTFS functionality should review and [truncated]
A deadlock vulnerability was found in the Linux kernel's ntfs filesystem implementation. The ABBA deadlock between extent_lock and extent mrec_lock was triggered by xfstests generic/113. The patch removes all extent_lock and extent mrec_lock acquisition from the MFT folio writeback path, eliminating the deadlock. This issue affects Linux kernel deployments using the ntfs filesystem. The vulnerability clas [truncated]
The Linux kernel has a vulnerability that has been resolved, related to ntfs: avoid heap allocation for free-cluster readahead state. get_nr_free_clusters() allocates a temporary file_ra_state before publishing the precomputed free cluster count, sets NVolFreeClusterKnown(), and wakes vol->free_waitq. If that allocation fails, the worker returns without setting the flag or waking waiters, so callers waiti [truncated]
AI-assisted PatchSiren debrief based on the supplied source corpus. The CVE record was published on 2026-08-15T06:21:38.640Z and has not been modified since then. This vulnerability affects the Linux kernel, specifically the NTFS mapping-pairs parser, which can cause a signed integer overflow when accumulating relative LCN deltas. The vulnerability can be triggered by a corrupted attribute that drives the [truncated]
AI-assisted PatchSiren debrief based on the supplied source corpus. The CVE record was published on 2026-08-15T06:21:38.533Z and has not been modified since then. The Linux kernel vulnerability (CVE-2026-72199) relates to validating resident index root values on lookup. Evidence is limited; verify Linux kernel resident index root value validation and CVE details through official channels like CVE.org and [truncated]
The Linux kernel vulnerability CVE-2026-72198 relates to the ntfs module's handling of non-resident records for resident-only attributes. This vulnerability affects Linux kernel users and administrators, Linux distribution maintainers. The shared lookup-time attribute validator currently rejects non-resident $FILE_NAME and $VOLUME_NAME records. This update extends the rejection to all resident-only attrib [truncated]
A slab-out-of-bounds write vulnerability exists in the Linux kernel's ntfs3 filesystem. The issue arises from an unbounded copy operation in the log_replay function's analysis pass, which can lead to an overflow of the dp->page_lcns[] array. This vulnerability can be triggered by a malformed LRH where target_vcn = dp->vcn + dp->lcns_follow - 1 and lrh->lcns_follow > 1.
The Linux kernel has a vulnerability in the fs/ntfs3 module. In the UpdateResidentValue case of do_action() in fslog.c, there is a potential underflow when calculating attr->res.data_size. This can lead to reading up to 4 GiB past the 1024-byte MFT record allocation. The existing mi_enum_attr() defense catches corrupted data_size on the next attribute walk but only on the path that walks all attributes. A [truncated]
A stack overflow vulnerability exists in the Linux kernel's ntfs3 filesystem implementation. The `indx_find_buffer` function recursively descends a B+ tree index without a depth limit, allowing a crafted NTFS image with circular index node references to cause a stack overflow and panic the system. This can be triggered by mounting a malicious NTFS filesystem and deleting a file whose index entry triggers [truncated]
A crafted NTFS3 disk image can trigger an in-kernel infinite loop at mount time, hanging the mounting thread and firing the soft-lockup watchdog. The bug is reachable from desktop USB auto-mount on distributions where udisks2 routes the NTFS signature to the in-tree ntfs3 driver. The issue is caused by an unbounded free-chain walker in the ntfs3 driver. A patched version of the driver bounds the walker by [truncated]
A crafted NTFS image can trigger a controlled out-of-bounds write of 120-136 bytes past a kmalloc(index_block_size) allocation with attacker-controlled content, reachable from unprivileged open(O_CREAT) on a mounted crafted NTFS image. This issue affects Linux systems that process NTFS images, particularly those with unprivileged user access. The vulnerability is a bounded adjacent-heap corruption primiti [truncated]
A crafted NTFS image can cause an out-of-bounds kernel write in the Linux kernel's ntfs3 module, leading to a kernel panic. The vulnerability is due to a lack of validation in the hdr_find_split function, which can return a split point that extends past the end of the buffer. This issue arises when the function fails to properly validate the split-point offset, allowing an attacker to create a specially c [truncated]
The Linux kernel has a vulnerability that has been resolved, which involves fixing an ABBA deadlock in the ntfs rename function. This vulnerability affects the ntfs file system in the Linux kernel, potentially leading to a denial of service or privilege escalation. The fix involves locking the existing target inode before taking any parent directory mrec_lock. Linux kernel developers and users who rely on [truncated]
The Linux kernel vulnerability CVE-2026-72189 is related to the handling of NTFS attribute list updates. When the superblock is inactive, updates to the attribute list can cause a self-deadlock in the find_inode() function. This issue arises because the eviction of cached inodes can lead to the writeback of the base inode, which in turn attempts to update the attribute list. To address this, a teardown gu [truncated]
The Linux kernel has a vulnerability in the ntfs_lookup_inode_by_name() function, which can return an error-marked MFT reference without validation. This can cause callers to consume a bogus pseudo-errno instead of treating the lookup result as corrupted on-disk metadata. The issue has been resolved by normalizing every error-marked MFT reference returned from ntfs_lookup_inode_by_name() to ERR_MREF(-EIO).
A self-deadlock issue in the Linux kernel's ntfs filesystem implementation has been addressed. An update to an attribute list during cluster allocation can drop the last reference to a temporary attribute inode, leading to a deadlock when evicting that inode. This issue arises in the Linux kernel's ntfs filesystem implementation, specifically affecting systems that utilize this filesystem. The vulnerabili [truncated]
The Linux kernel vulnerability CVE-2026-72186 allows corruption of NTFS file systems when system files are exposed and written from userspace. This issue arises because the NTFS file system driver, when handling system files such as $Bitmap, does not properly prevent writes from user space, leading to potential file system corruption. The vulnerability is resolved by marking base metadata files as immutab [truncated]
A crafted NTFS image can cause the Linux kernel to access the wrong union member, corrupting the VCN range check, due to a vulnerability in ntfs_map_runlist_nolock(). This vulnerability occurs when the function fails to properly handle resident attributes, allowing an attacker to potentially cause a mount error. Linux kernel developers and maintainers should review the patch and apply it to affected syste [truncated]
A memory leak vulnerability was found in the Linux kernel's ntfs_non_resident_attr_insert_range() function. The function allocates memory for hole_rl before mapping the whole runlist. If ntfs_attr_map_whole_runlist() fails, the error path drops ni->runlist.lock and returns without freeing hole_rl, resulting in a memory leak of sizeof(*hole_rl) * 2 bytes.