In the Linux kernel, the following vulnerability has been resolved: userfaultfd: gate must_wait writability check on pte_present()… (CVE-2026-64514)
Source GCVE Database
No CVSS score published yet
- Exploitation
Not in CISA KEV, no exploitation reported
- EPSS
- 0.1% chance of exploitation in 30 days – higher than 6% of CVEs
What to do
AI-suggested
Since this is a Linux kernel vulnerability, monitor official Linux kernel security advisories for patches addressing CVE-2026-64514. Apply the official kernel updates once available to resolve the issue.
Description
In the Linux kernel, the following vulnerability has been resolved: userfaultfd: gate must_wait writability check on pte_present() userfaultfd_must_wait() and userfaultfd_huge_must_wait() read the PTE without taking the page table lock and then apply pte_write() / huge_pte_write() to it. Those accessors decode bits from the present encoding only; on a swap or migration entry they read the offset bits that happen to share the same position and return an undefined result. The intent of the check is "is this fault still WP-blocked?". A non-marker swap entry means the page is in transit -- the userfault context the original fault delivered against is no longer the same, and the swap-in or migration completion path will re-deliver a fresh fault if userspace still needs to handle it. Worst case under the current code the garbage write bit says "wait", and the thread stays asleep until a UFFDIO_WAKE that may never arrive. Gate the writability check on pte_present() so the lockless re-check only inspects present-PTE bits when the entry is actually present. The non-present, non-marker case returns "don't wait" and lets the fault path retry.
Summary
The Linux kernel vulnerability CVE-2026-64514 concerns the userfaultfd interface's must_wait writability check on page table entries (PTEs). The affected functions read PTEs without acquiring the page table lock and apply write checks that only decode bits valid for present entries. When encountering swap or migration entries, these functions misinterpret offset bits as write bits, resulting in undefined behavior. This can cause a thread to remain asleep indefinitely, waiting for a wake event that may never occur. The fix involves gating the writability check on the presence of the PTE, ensuring that only present entries are checked for writability, and non-present entries return a 'don't wait' result to allow fault path retries.
Impact
The vulnerability can cause threads to stall indefinitely by waiting on a write protection block that is incorrectly detected due to misinterpreted PTE bits. This may lead to denial of service conditions where userfaultfd-related threads do not progress as expected. There is no indication of code execution or privilege escalation from the provided data.
References
- nvd.nist.gov/vuln/detail/CVE-2026-64514 (opens in a new tab)
- git.kernel.org/stable/c/29e6f952c5fb7dc1d6b90fe5b7f36063d44ddae0 (opens in a new tab)
- git.kernel.org/stable/c/5f4dbdb0a87596214076b20b94f2b71b522170b3 (opens in a new tab)
- git.kernel.org/stable/c/60d696a037eeeedfb57756dfe7ec08a1587c8631 (opens in a new tab)
- git.kernel.org/stable/c/710183888174639a15fcec16cd1af766b8480bb7 (opens in a new tab)
- git.kernel.org/stable/c/8e80af52db652fbc41320eee45a4f73bc029faf2 (opens in a new tab)
- git.kernel.org/stable/c/a5700a4c1c9099ac2ac73fe8a09cf059972e0d2f (opens in a new tab)
- git.kernel.org/stable/c/a6e9a4939e359599701b1da351e84f72e021443a (opens in a new tab)
- git.kernel.org/stable/c/d4026417e8184d13850a0bad4d96ceb6ed9f7152 (opens in a new tab)
Community reviews
Crowdsource mitigation strategies, share intel context, and vote on the most helpful responses.
Want to contribute mitigation steps or threat intel context? Sign in or create an account to join the community discussion.