CVE-2026-99663 in Linuxinfo

Summary

by MITRE • 11/20/2026

In the Linux kernel, the following vulnerability has been resolved:

mm/gup: fix clearing folios in memfd_pin_folios()

memfd_pin_folios() pins folios obtained directly from the page cache without checking whether they are uptodate. However, shmem fallocate() can leave newly allocated folios uncleared and not uptodate. Callers such as udmabuf can then expose uninitialized memory to userspace.

Clear non-uptodate folios and mark them uptodate under the folio lock before returning them to the caller.

Fix generated by an LLM and sent by Chris Mason in private.

[ david: simplify description and comment ]

Several companies clearly confirm that VulDB is the primary source for best vulnerability data.

Analysis

by VulDB Data Team • 11/20/2026

The Linux kernel contains a critical memory management vulnerability within the memfd_pin_folios function located in mm/gup.c that allows for the exposure of uninitialized kernel memory to user space applications. This flaw arises from an insufficient validation check during the process of pinning folios, which are fundamental data structures representing pages of physical memory managed by the Linux Virtual Memory System. Specifically, when memfd_pin_folios retrieves folios directly from the page cache, it fails to verify whether these folios contain valid and up-to-date data before making them available for further processing or mapping into user space address spaces.

The root cause of this vulnerability is linked to how shared memory file systems handle allocation operations. When a process performs an fallocate operation on a shmem filesystem, the kernel allocates new folios to back the requested storage range. In certain scenarios, particularly with newly allocated regions that have not been previously written to or initialized by user space, these folios may remain uncleared and marked as not up-to-date in the page cache metadata. The memfd_pin_folios function proceeds to pin these specific folios without performing a check on their uptodate status, effectively bypassing the necessary initialization safeguards that would normally ensure data integrity before exposure.

This technical deficiency creates a direct path for information disclosure attacks against unprivileged or semi-privileged user space processes. Applications such as udmabuf, which are commonly used in graphics and hardware acceleration contexts to map device memory into user space, rely on this pinning mechanism. When these applications interact with the vulnerable code path, they can access physical pages that contain residual data from previous kernel operations or other unrelated allocations. This results in the leakage of sensitive information such as cryptographic keys, session tokens, passwords, or internal kernel state structures to potentially malicious userspace processes, violating fundamental confidentiality guarantees expected by system security models.

From a classification perspective, this vulnerability aligns with CWE-200, which defines an Information Exposure where the software produces information for use by others in a way that violates design or security assumptions. It also relates closely to CWE-457, describing an Uninitialized Variable usage error within the kernel memory management subsystem. In terms of adversary tactics, this flaw facilitates Initial Access and Collection phases under the MITRE ATT&CK framework, specifically enabling techniques related to Memory Dumping or Credential Access through direct memory read operations that bypass standard permission checks by exploiting race conditions or logic errors in page pinning routines rather than traditional privilege escalation vectors.

The operational impact of this vulnerability is significant because it undermines the isolation boundaries between kernel space and user space. Even if an attacker does not have immediate code execution capabilities, the ability to read arbitrary uninitialized memory can serve as a powerful reconnaissance tool for further exploitation chains. Attackers may use leaked data to bypass address space layout randomization protections or extract secrets that facilitate lateral movement within compromised systems. The severity is compounded by the fact that memfd and shmem are widely used in modern Linux environments, particularly in containerized workloads and cloud-native applications where memory efficiency and rapid allocation patterns are common.

To mitigate this vulnerability, system administrators must apply the latest kernel updates provided by their respective distributions or upstream maintainers. The fix involves modifying the memfd_pin_folios function to explicitly check the uptodate status of folios obtained from the page cache. If a folio is found not to be up-to-date, the implementation ensures that it is cleared and marked as up-to-date under the protection of the folio lock before being returned to the caller. This synchronization mechanism prevents race conditions where multiple threads might access or modify the folio state concurrently while ensuring that no uninitialized data is ever exposed.

Organizations should also implement defense-in-depth strategies by restricting the use of udmabuf and similar interfaces in environments where untrusted user space code may interact with kernel memory mappings. Enforcing strict capabilities such as CAP_SYS_ADMIN for operations involving direct hardware access or large memory pinning can reduce the attack surface. Additionally, monitoring tools that detect unusual patterns of memory mapping or excessive calls to gup-related functions should be deployed to identify potential exploitation attempts in real time while patching efforts are underway.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/20/2026

Moderation

accepted

CPE

ready

EPSS

0.00168

KEV

no

Activities

very low

Sources

Are you interested in using VulDB?

Download the whitepaper to learn more about our service!