CVE-2026-63952
High · 8.4CVSS
8.4
EPSS
0.1%
Published
Jul 19, 2026
CISA due date
—
Cloudanix analysis
A flaw in Linux memory handling lets certain protected files be changed even when they are supposed to be locked against modifications.
- Exploitation
- Local Privilege
- Attacker needs
- Low Privilege
- Complexity
- Low
- Impact
- Data Tampering
- Component
- OS kernel
- Class
- Authorization Bypass
- Remediation
- Upgrade
- Effort
- Medium
- Patch risk
- Low
What it actually does
The flaw allows SEAL_EXEC to imply SEAL_WRITE after the check for existing writable mappings has already passed, permitting a memfd to retain writable mappings while appearing write-sealed and enforcing W^X.
Why it matters to the business
Attackers can modify memory-backed files that should be protected from changes, increasing risk of tampering or unauthorized code execution on Linux systems handling sealed file descriptors.
How an attack unfolds
An attacker creates a memfd, obtains a writable mapping before applying SEAL_EXEC, then relies on the implied SEAL_WRITE being set after the writable-mapping check to bypass the intended seal contract and retain the ability to write.
How to fix it
Apply the kernel patch that moves implied seal application before the mapping_deny_writable call; rebuild and deploy updated kernel images across affected Linux distributions.
How to confirm the fix worked
Confirm the kernel source contains the reordered seal logic prior to mapping_deny_writable; test by attempting to add SEAL_EXEC while writable mappings exist and verify the operation is now denied.
Typical attack path
- Create memfd file descriptor
- Obtain writable mapping before seal application
- Apply SEAL_EXEC to trigger implied SEAL_WRITE
- Retain and use writable mapping to modify contents despite apparent seal
How to detect it
Review kernel logs and application code for memfd creation sequences that combine SEAL_EXEC with prior writable mappings; no widespread exploitation artifacts are known.
What your security team should do
- Prioritize kernel updates on systems using memfd seals for security boundaries
- Monitor upstream kernel changelogs for the exact commit implementing the fix
- Audit applications relying on memfd SEAL_WRITE for integrity guarantees
The record
In the Linux kernel, the following vulnerability has been resolved: memfd: deny writeable mappings when implying SEAL_WRITE When SEAL_EXEC is added, SEAL_WRITE is implied to make W^X. But the implied seal is set after the check that makes sure the memfd can not have any writable mappings. This means one can use SEAL_EXEC to apply SEAL_WRITE while having writeable mappings. This breaks the contract that SEAL_WRITE provides and can be used by an attacker to pass a memfd that appears to be write sealed but can still be modified arbitrarily. Fix this by adding the implied seals before the call for mapping_deny_writable() is done.
Affected packages
| Ecosystem | Package | Introduced | Fixed |
|---|