A nine-year-old Linux kernel bug lets any unprivileged process inside a container write to host memory and take root on the node. The default Kubernetes seccomp profile does not stop it. CVE-2026-31431 — nicknamed Copy Fail — has been on CISA’s Known Exploited Vulnerabilities list since May 2026. A public proof-of-concept runs on EKS, GKE, and AKS. If you haven’t patched or mitigated, the exploit is 732 bytes of Python away from your host.
What Copy Fail Actually Does
The vulnerability lives in algif_aead, the Linux kernel’s AF_ALG interface for AEAD (Authenticated Encryption with Associated Data) operations. In 2017, a commit added in-place operation support — meaning the same memory region could serve as both the input and output for a crypto request. That assumption turned out to be dangerously wrong.
Three design flaws compose into the exploit:
- In-place AEAD: The kernel chains the request’s output tag pages into a writable destination scatterlist.
- Page cache via splice():
splice(file → pipe → socket)feeds those writable slots the page-cache pages of any readable file — zero copy, no permissions check at this stage. - Scratch write: The
authencesn(hmac(sha256), cbc(aes))path performs a 4-byte write of its AAD sequence number into the destination — which is now a page inside the host’s page cache.
The page cache is host-global — shared by every process and every container on the same kernel. Corrupting it corrupts memory that belongs to the host, not the container. From there, overwriting a setuid binary’s cached copy is a reliable path to root.
Why Your Existing Defenses Probably Miss It
This is the part that keeps security teams up at night. Three of the most common container hardening measures provide no protection here:
- Default seccomp profile: The
runtime-defaultprofile does not blocksocket(AF_ALG, ...)calls. AF_ALG socket creation (address family 38) is not in the deny list. Containers with the default profile are fully exposed. - File integrity monitoring: Tools like Tripwire and auditd watch on-disk changes. Copy Fail writes to the page cache — the in-memory representation — and never touches the file on disk. Your file hash monitoring is blind to it.
- “Container isolation”: Namespace and cgroup isolation do not apply to the page cache. It is a kernel-level shared structure. There is no container-aware page cache.
Bugcrowd’s analysis put it plainly: “The seccomp profile most platform teams trust does not stop it.” If your hardening checklist stops at the runtime-default profile, you are exposed.
Fix It — Three Options in Order of Preference
Option 1: Patch the Kernel (Definitive Fix)
The upstream fix landed in April 2026 (commit a664bf3d603d) and reverts the in-place optimization entirely. Patched versions: 6.18.22+, 6.19.12+, 7.0+.
# Check your current kernel version
uname -r
# Ubuntu / Debian
sudo apt update && sudo apt upgrade -y && sudo reboot
# RHEL / AlmaLinux / Amazon Linux 2023
sudo dnf update kernel && sudo reboot
Reboot is required. A package update that skips the reboot leaves the old kernel running.
Option 2: Blacklist the Module (Interim Fix)
If you cannot patch immediately, unload and block the vulnerable module:
echo "install algif_aead /bin/false" | sudo tee /etc/modprobe.d/disable-algif-aead.conf
sudo rmmod algif_aead 2>/dev/null || true
Important caveat: This does not work if algif_aead is compiled directly into the kernel (built-in rather than a module). Check first:
grep algif_aead /boot/config-$(uname -r)
If the result is =y, the module cannot be unloaded. Use Option 3 instead.
Option 3: eBPF DaemonSet (Kubernetes-Native, Works Even on Built-In Kernels)
The copyfail-ebpf-k8s DaemonSet deploys an eBPF program to every node that blocks AF_ALG socket creation at the syscall level — no module dependency, no reboot required:
kubectl apply -f https://github.com/iwanhae/copyfail-ebpf-k8s/raw/main/deploy.yaml
This is the fastest path to cluster-wide protection while you schedule kernel upgrades.
Cloud Provider Status
All three major managed Kubernetes providers have patches or mitigations available now:
- Amazon EKS: Patched AMIs are available. Replace node groups — in-place kernel updates on managed nodes are not supported. Track progress on the amazon-eks-ami issue.
- Google GKE: Patched Container-Optimized OS node pool versions are available. Trigger a node pool upgrade from the console or
gcloud. - Azure AKS: New node pools and node image upgrades automatically include the mitigation. Existing pools need a manual node image upgrade. Track on the AKS GitHub issue.
Self-managed clusters get none of this automatically. If you run Kubernetes on bare metal or VMs with unmanaged kernels, you are the patch team.
Don’t Wait on This One
Copy Fail is six months old. The CISA deadline for federal agencies passed in May. The PoC is public, documented, and validated across all three major cloud providers. Exploits in the wild are confirmed.
The novel risk in late 2026 is the blast radius. AI agent workloads on multi-tenant Kubernetes clusters give a successful container escape immediate access to dozens of co-located workloads, their credentials, and their cloud IAM roles. That is a qualitatively different threat from a single-user Linux LPE. Patch the kernel, deploy the eBPF DaemonSet as a bridge, and check that your seccomp profiles actually block AF_ALG.

