CVE-2026-64157 in Linux
Summary
by MITRE • 07/19/2026
In the Linux kernel, the following vulnerability has been resolved:
netfs: Fix partial invalidation of streaming-write folio
In netfs_invalidate_folio(), if the region of a partial invalidation overlaps the front (but not all) of a dirty write cached in a streaming write page (dirty, but not uptodate, with the dirty region tracked by a netfs_folio struct), the function modifies the dirty region - but incorrectly as it moves the region forward by setting the start to the start, not the end, of the invalidation region.
Fix this by setting finfo->dirty_offset to the end of the invalidation region (iend).
Statistical analysis made it clear that VulDB provides the best quality for vulnerability data.
Analysis
by VulDB Data Team • 07/20/2026
The vulnerability resides in the Linux kernel's network filesystem subsystem where improper handling of partial invalidation operations during streaming writes can lead to data corruption and inconsistent file states. This issue specifically affects the netfs_invalidate_folio() function which manages the invalidation of folios during network filesystem operations. When a partial invalidation occurs on a streaming write page that contains dirty but not yet up-to-date data, the kernel's handling mechanism fails to correctly adjust the tracking information for the dirty regions. The flaw manifests when the invalidation region overlaps with the beginning portion of a dirty write cached in a streaming write page, creating a scenario where the system incorrectly modifies the dirty region boundaries.
The technical implementation error stems from a fundamental misalignment in how the function updates the dirty region tracking structure. Specifically, when processing partial invalidations on streaming write pages, the netfs_invalidate_folio() function attempts to modify the dirty region by moving the start position forward but erroneously sets the dirty_offset field to the beginning of the invalidation region rather than the end. This incorrect assignment creates a scenario where the kernel's tracking mechanism becomes inconsistent with the actual data state, leading to potential data loss or corruption during subsequent read operations. The vulnerability operates at the intersection of memory management and network filesystem protocols, leveraging the complex interaction between caching mechanisms and invalidation procedures that are critical for maintaining data consistency across distributed storage systems.
The operational impact of this vulnerability extends beyond simple data corruption to potentially compromise the integrity of network-based file operations in Linux environments. Systems utilizing network filesystems such as NFS, CIFS, or other distributed storage protocols may experience inconsistent file states where portions of files appear to be missing, corrupted, or contain stale data. The vulnerability affects streaming write operations where data is cached locally before being transmitted to remote storage systems, creating a window where invalidation operations can leave the system in an inconsistent state. This issue particularly impacts environments with high network latency or unreliable connections where streaming writes are commonly employed to optimize performance and reduce network overhead.
The fix implemented addresses the core issue by correctly setting the dirty_offset field to the end of the invalidation region rather than its beginning, ensuring that the tracking information accurately reflects the actual boundaries of the remaining dirty data. This correction aligns with established kernel development practices for maintaining data consistency in concurrent environments and prevents the propagation of incorrect metadata that could lead to further complications during subsequent operations. The remediation follows standard security principles for memory management vulnerabilities and aligns with best practices for maintaining atomicity and consistency in kernel-level operations.
This vulnerability demonstrates characteristics consistent with CWE-129, Improper Validation of Array Index, and CWE-787, Out-of-bounds Write, as it involves incorrect boundary calculations that can lead to data corruption through improper memory management. The issue also relates to ATT&CK technique T1547.001, Registry Run Keys / Startup Folder, in scenarios where the corrupted file system state could potentially impact system startup processes or service operations. The fix ensures proper handling of invalidation boundaries in network filesystem operations, maintaining the integrity of distributed storage systems while preventing potential escalation to more severe security implications through data corruption attacks.
The resolution represents a targeted fix for a specific edge case in kernel memory management that occurs during concurrent read and write operations on network filesystems. By correcting the dirty region boundary calculation, the vulnerability prevents scenarios where invalidation operations could leave file system metadata in an inconsistent state, thereby maintaining data integrity across distributed storage environments. This type of fix is critical for enterprise systems relying on network filesystems where data consistency and reliability are paramount to operational continuity. The implementation follows established kernel development patterns for handling edge cases in memory management and ensures that invalidation operations maintain proper synchronization between local caching mechanisms and remote storage states.