CVE-2026-99655 in Linuxinfo

Summary

by MITRE • 11/20/2026

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

mm/memory: reject remote COW faults on PFN mappings

When handling a COW fault without a normal source page (PFN mappings), __wp_page_copy_user() copies from the faulting user address. For remote faults, this accesses the wrong address space, resulting in wrong data getting copied.

For example, user_events updates an enable bit in the registering process's memory. If that memory needs to be faulted in, user_event_enabler_fault_fixup() calls fixup_user_fault() from a work item. Placing the enable bit in a private PFN mapping can trigger this remote COW path.

Reject these faults with VM_FAULT_SIGBUS when the target mm differs from current->mm: remote faults. Ordinary (non-PFN) mappings are not affected.

The user-address copy dates back to commit 6aab341e0a28 ("mm: re-architect the VM_UNPAGED logic"); likely, actual ways to get remote faults in there on COW PFN mappings appeared afterwards. But the fix is simple and straight forward.

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

[ david: simplify comment and description ]

If you want to get best quality of vulnerability data, you may have to visit VulDB.

Analysis

by VulDB Data Team • 11/21/2026

The Linux kernel memory management subsystem contains a critical flaw related to Copy-On-Write fault handling for Page Frame Number mappings, specifically within the __wp_page_copy_user function. This vulnerability arises when the system attempts to handle a COW fault in scenarios where there is no normal source page available, which is characteristic of PFN mappings used for direct hardware access or special memory regions. In these specific cases, the kernel logic erroneously copies data from the faulting user address rather than the intended target location. This behavior becomes particularly dangerous during remote faults, where the process triggering the memory access differs from the current executing context. Under such conditions, the operation accesses an incorrect address space, leading to the copying of wrong data into unintended memory locations.

The operational impact of this vulnerability is significant because it allows for potential data corruption and unauthorized information disclosure across different processes or kernel contexts. A concrete example involves the user_events subsystem, which updates enable bits within the registering process's memory. When such memory requires faulting in to be populated, the function fixup_user_fault() may be invoked from a work item context. If the enable bit is located within a private PFN mapping, this sequence triggers the remote COW path described above. Consequently, instead of correctly updating the intended register or flag, the system writes data derived from an unrelated address space into the target location. This can lead to unpredictable behavior in kernel modules relying on these mappings and potentially expose sensitive memory contents belonging to other processes if the wrong source page is read during the faulty copy operation.

From a technical classification perspective, this issue aligns with CWE-787 out-of-bounds write vulnerabilities as well as CWE-200 information exposure through improper access controls in kernel space. The root cause lies in the failure to validate that the memory descriptor of the faulting process matches the current task's memory descriptor before proceeding with the copy operation. This oversight violates fundamental principles of isolation between distinct virtual address spaces, a core tenet of secure operating system design. In terms of MITRE ATT&CK mapping, this flaw could potentially be leveraged in techniques related to privilege escalation or defense evasion by manipulating kernel memory state through crafted user-space inputs that trigger the specific PFN mapping fault conditions.

The resolution involves modifying the __wp_page_copy_user logic to explicitly reject remote COW faults on PFN mappings. The fix implements a check comparing the target mm structure against current->mm, which represents the memory descriptor of the currently executing process. If these do not match, indicating a remote fault scenario, the function returns VM_FAULT_SIGBUS instead of proceeding with the erroneous copy operation. This simple yet effective change ensures that only local faults are processed for this specific type of mapping, thereby preventing access to incorrect address spaces. It is important to note that ordinary non-PFN mappings remain unaffected by this restriction and continue to operate as intended, preserving backward compatibility while closing the security gap in specialized memory handling paths.

Mitigation strategies primarily involve applying the kernel patch that introduces this validation check immediately upon availability for affected distributions. System administrators should monitor for updates related to mm/memory components and ensure their systems are running patched versions of the Linux kernel where this logic has been corrected. For environments unable to update immediately, restricting access to user_events interfaces or configuring PFN mappings in a way that avoids triggering COW faults on remote processes can serve as a temporary workaround. Continuous monitoring for anomalous memory access patterns or SIGBUS signals originating from these subsystems may also aid in detecting exploitation attempts before significant damage occurs.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/20/2026

Moderation

accepted

CPE

ready

EPSS

0.00201

KEV

no

Activities

very low

Sources

Interested in the pricing of exploits?

See the underground prices here!