A use-after-free vulnerability was identified and fixed in the Linux kernel SMB client code. The issue involved premature dropping of the last session reference while a demultiplex thread was still running, leading to a race condition and potential memory corruption. The fix ensures that server information and related resources are held until the demultiplex thread exits, preventing unsafe memory access.
A use-after-free vulnerability in the Linux kernel overlay filesystem (ovl) was fixed by ensuring a reference is held on the parent directory during readdir operations. The flaw could cause kernel crashes when directory listings raced with renames in the lower layer, leading to use of freed dentries.
A use-after-free vulnerability in the Linux kernel overlay filesystem (ovl) was fixed by ensuring the OVL_WHITEOUTS flag is set before publishing the upper directory. This flaw allowed an unprivileged process listing a directory during its copy-up to trigger a use-after-free of the readdir cache, potentially causing instability or crashes. The fix involves setting OVL_WHITEOUTS before updating the inode and verifying the directory type to prevent iterating a merge directory as a real upper directory.
CVE-2026-99423 is a use-after-free vulnerability in the Linux kernel's overlay filesystem (ovl) related to directory copy-up operations. The flaw occurs when a directory is renamed concurrently with a copy-up, causing a freed dentry name to be read. This can lead to memory safety issues detected by KASAN. The vulnerability affects Linux kernel version 4.16 and has been fixed by taking a snapshot of the dentry name during copy-up to prevent use-after-free.
CVE-2026-99422 is a vulnerability in the Linux kernel overlay filesystem (ovl) where renames made directly on the upper filesystem during a lookup can crash the kernel. The issue arises because ovl_fix_origin() uses the upper directory's parent dentry without proper reference counting, leading to a use-after-free condition when multiple renames and removals occur concurrently. This has been fixed by changing the code to use the pinned upper directory dentry held by the overlay parent.
A vulnerability in the Linux kernel overlay filesystem (overlayfs) occurs when the origin file handle (fh) is not properly encoded with the index option enabled. This can cause a kernel crash (oops) during the copy-up of a directory on an overlay with index=on and nfs_export=on, if a Linux Security Module (LSM) denies CAP_DAC_READ_SEARCH capability to the mounter after mounting. The flaw arises because ovl_get_origin_fh() returns NULL when it should return a valid handle, leading to dereferencing NULL pointers in internal index operations.
CVE-2026-99420 is a Linux kernel vulnerability in the overlayfs component where an unprivileged user can cause a kernel crash by mounting overlayfs with the volatile option. The issue arises because the kernel does not properly verify that the parents of volatile/dirty dentries are directories, leading to a NULL pointer dereference during lookup operations. This flaw was fixed by ensuring that a non-directory entry is not treated as a directory during overlayfs volatile mounts.
CVE-2026-99419 is a vulnerability in the Linux kernel overlay filesystem (ovl) where a removed dentry can be improperly copied up, potentially replacing an existing file in the upper layer. This occurs when an unprivileged user opens and unlinks a lower FIFO, and root creates a file with the same name, allowing the old descriptor's operations to replace the root file. The flaw is fixed by ensuring copy up fails if the target name is already taken, preventing unintended replacement.
A vulnerability in the Linux kernel overlay filesystem (ovl) could cause uninitialized kernel memory to be copied into an extended attribute (xattr) of an upper file, potentially exposing kernel memory contents to userspace. This occurs when a FUSE lower layer returns -ERANGE for every sized GETXATTR request, leading to storing uninitialized data during copy-up. The issue has been fixed by ensuring the copy-up fails with -EIO when the size following -ERANGE fits the buffer but no data was read.
A vulnerability in the Linux kernel overlay filesystem (ovl) was fixed to address a race condition in ovl_get_redirect(). This flaw allowed an unprivileged user to create a hard link to a metacopy file while concurrently renaming its ancestor directory, causing the system to store an incorrect redirect path. After a remount, this could result in the file showing data from a root-only file. The issue was resolved by adjusting the locking and parent retrieval logic in ovl_get_redirect().
CVE-2026-99416 is a vulnerability in the Linux kernel's overlay filesystem (overlayfs) related to handling the nlink extended attribute (xattr) of indexed non-directory files. When the nfs_export option is enabled, data written through a file handle to a lower-layer file can be lost after the next mount, and lookups by name may return an I/O error (-EIO). Additionally, files copied up to the upper layer may report incorrect link counts, causing file handles to remain valid after file removal until the next mount. The issue arises from incorrect handling of link counts and index entries during copy-up and mount operations. The vulnerability has been fixed in specific Linux kernel commits.
A vulnerability in the Linux kernel overlay filesystem (overlayfs) causes a kernel warning and stat() failure with ECHILD when a file is being created concurrently on an overlay with a FUSE upper layer. The issue arises because revalidate flags are set on a negative overlay dentry before d_instantiate() is called, leading to improper revalidation and a WARN_ON() trigger. This flaw is fixed by setting the flags after d_instantiate().
A vulnerability in the Linux kernel overlay filesystem (ovl) was addressed where an empty security.capability extended attribute could block file operations such as writing, renaming, or changing the mode. This occurs because ovl_copy_xattr() fails to copy up an empty security.capability attribute, causing files in lower layers with this attribute to be effectively immutable. The fix involves skipping the copy up of empty security.capability attributes and treating certain errors as no capability present.
A buffer overrun vulnerability in the Linux kernel's xfs_ioc_attr_list ioctl was fixed. The issue arose when the al_offset array in struct xfs_attrlist was converted into a variable-length array (VLA), shrinking the object size by 4 bytes. The buffer size validation was not updated accordingly, causing an out-of-bounds write at al_offset[0]. This flaw was identified and corrected in specific Linux kernel commits.
A vulnerability in the Linux kernel's XFS filesystem code related to reaping cross-rtgroup extents has been resolved. The issue arises because extents stored in the xfs_rtblock bitmap can span multiple rtgroups, and the code did not properly handle this, potentially causing incorrect reaping behavior. The fix involves looping through rtgroups to avoid overrunning rtgroup boundaries during reaping.
A race condition vulnerability in the Linux kernel's XFS filesystem was fixed by ensuring proper locking of the metafile reservation counters during adjustments after repair. The flaw involved unlocked loads and stores to metadata reservation counters, which could lead to race conditions.
A vulnerability in the Linux kernel's XFS filesystem was fixed where the incore attribute fork buffer was not properly reset when resetting the fork. This flaw could cause post-repair verifier failures due to incorrect handling of the local format attribute fork verifier's dependency on the if_bytes field. The issue affects Linux kernel version 6.10 and has been addressed in subsequent commits.
A vulnerability in the Linux kernel's XFS filesystem handling was addressed by ensuring that the directory tree is not repaired if a live update operation fails. The issue involved not double-checking a failure flag before committing filesystem repairs, which could lead to improper fixes after runtime errors during live updates.
A vulnerability in the Linux kernel's XFS filesystem handling was addressed to prevent proceeding with extended attribute (xattr) repair if a live update fails. This fix ensures that the kernel performs a final check for failed live updates before replacing the xattr structure, improving stability and correctness during xattr repair operations.
A vulnerability in the Linux kernel's XFS filesystem repair process could cause the installation of corrupted summary counters if the filesystem scan produces garbage values. This issue was fixed by ensuring that scans producing invalid summary counters are marked incomplete, preventing the repair process from applying corrupted data.