Copy Fail is the sort of Linux bug that deserves attention because it is simple, portable, and boring in exactly the wrong way. No race. No heap feng shui. No distro-specific gymnastics. If an attacker can already run code as an unprivileged user on the box, they can often turn that foothold into root with very little friction.

Bottom Line First

This is not an initial-access vulnerability. Copy Fail does not hand an internet attacker code execution out of thin air. It turns local code execution into root. That distinction matters. If nobody can run code on the host, this bug does nothing by itself.

Patch priority depends on shared compute. If you run Kubernetes nodes, self-hosted CI runners, jump boxes, notebook platforms, shell servers, or anything else where untrusted users, containers, or jobs share a kernel, treat this as urgent. In those environments, "regular user" is close enough to "root" until patched.

Single-tenant Linux is still affected. The difference is operational, not technical. On a normal production server this is usually the second stage of a compromise: web RCE, a stolen SSH credential, or a compromised service account becomes host root. That is still serious. It is just not the same as a remote pre-auth break-in.

Temporary mitigation is available. If you just want the patching and containment steps, jump to remediation. The short version is simple: install the vendor-fixed kernel and reboot into it. If that update is not available yet, disable algif_aead, unload it if it is already present, and block AF_ALG socket creation for untrusted workloads.

Why This Bug Matters

Linux local privilege escalations are common enough. Reliable ones that survive distro changes are not. Copy Fail stands out because the attack path is straight-line logic: the same public proof-of-concept has been shown working across Ubuntu, Amazon Linux, RHEL, and SUSE without per-target tailoring, retries, or timing games.

Copy Fail proof-of-concept demo showing root access across Ubuntu 24.04, Amazon Linux 2023, RHEL 10.1, and SUSE 16
Public demo of the same Copy Fail path working across four major Linux distributions. Source: The Hacker News.

That matters most in environments that already execute attacker-controlled code by design. Think pull-request runners, hostile multi-tenant workloads, lab shells, data-science notebooks, or container platforms where the tenant boundary stops at the kernel. In those cases, the missing prerequisite is not "can code run?" but "can code run without root yet?" Copy Fail answers that last question.

It is also stealthier than many teams expect. The primitive targets page cache, not the file on disk. That means ordinary checksum comparison of the binary on disk can come back clean while the in-memory image the kernel actually executes has already been altered.

What The Bug Actually Is

The vulnerable chain sits at the intersection of three kernel features that each looked reasonable on their own. First, AF_ALG exposes parts of the kernel crypto subsystem to unprivileged user space. Second, splice() can move file-backed pages by reference instead of copying them. Third, a 2017 algif_aead optimisation made one AEAD path operate in place.

On paper, that sounds like plumbing. In practice, it means an attacker can take the page-cache pages of a readable file, feed them into an AEAD request, and end up with those same pages appearing inside a scatterlist the kernel later treats as writable destination memory.

The algorithm that turns this design mistake into an exploit is authencesn, an AEAD wrapper used for IPsec Extended Sequence Number support. Its decrypt path uses destination memory as scratch space and writes four bytes past the legitimate output boundary. Under normal assumptions that should have landed in disposable buffer space. In the in-place AF_ALG path, it can land inside the page cache of the spliced file instead.

How The Write Escapes The Buffer

The core idea is unpleasantly clean. The attacker splices a readable target file into a pipe, then from the pipe into an AF_ALG AEAD socket. Because splice() passes pages by reference, the kernel is now operating on the target file's cached pages rather than on a copied user buffer.

In the vulnerable in-place decrypt path, algif_aead builds a combined scatterlist: a normal receive buffer first, then chained tag pages that still point at page cache. authencesn later performs its scratch write at an offset of assoclen + cryptlen, which is already beyond the legitimate plaintext output region. Once that offset crosses out of the receive buffer, the next write lands in the chained page-cache pages.

The write is only four bytes, but that is enough. The public research shows that those four bytes are attacker-controlled, the target offset is attacker-controlled, and the write survives even when the crypto operation itself fails. The kernel never dirties the backing file for writeback, so the disk image remains unchanged while the in-memory cached copy is now different.

That is why the bug is so useful against setuid binaries. You do not need persistence in the file system. You need one successful execution of the modified cached image.

How It Was Discovered

Copy Fail was disclosed on April 29, 2026 by researchers from Theori and Xint. The interesting part is not just that AI was involved, but how it was involved. The starting point was a human research insight from Taeyang Lee: AF_ALG plus splice() creates an unusual path where unprivileged user space can feed page-cache-backed data directly into the kernel crypto subsystem.

From there, Xint Code was used to sweep the Linux crypto/ subsystem for reachable user-space paths that violated assumptions around scatterlists and writable buffers. According to the researchers, Copy Fail came back as the highest-severity finding in roughly an hour of scan time. That is a useful reminder for defenders too: AI is getting better at helping experienced researchers scale hunches into real bug classes. It is not replacing expertise. It is accelerating it.

Sanitised PoC Flow

The public exploit is already available, but we are not reproducing the working one-liner here. The important point for defenders is that the exploitation sequence is short, predictable, and easy to reason about:

open(readable_setuid_binary)
splice(file_pages -> pipe)
splice(pipe -> AF_ALG_aead_request)
trigger_vulnerable_in_place_decrypt()
repeat_controlled_4_byte_writes()
execve(modified_cached_setuid_binary)

The public PoC reportedly defaults to /usr/bin/su because it is widely present and setuid-root across mainstream distributions. The page-cache corruption is not persistent across reboot or cache eviction, but that is not much comfort if the attacker gets a root shell first and installs their own persistence.

Remediation

The real fix is a patched kernel, not an update that is merely installed. Apply the vendor kernel update, then reboot into it. On fleets, roll it deliberately: cordon and drain Kubernetes workers, recycle CI runners, and restart bastions or shared shell hosts. A host that downloaded the fix but is still running the old kernel is still vulnerable.

If a fixed kernel is not available yet, disable the vulnerable path. On systems where algif_aead is loadable, block it persistently with a modprobe rule and unload it if it is already present. Ubuntu's interim mitigation does exactly that through an updated kmod package, and SUSE is recommending the same manual workaround.

echo "install algif_aead /bin/false" | sudo tee /etc/modprobe.d/disable-algif.conf
sudo rmmod algif_aead 2>/dev/null || true
grep -qE '^algif_aead ' /proc/modules && echo "algif_aead still loaded" || echo "algif_aead not loaded"

Treat AF_ALG as an attack-surface control in shared-kernel environments. If you run containers, notebooks, or CI jobs from less-trusted users, block AF_ALG socket creation with seccomp or equivalent policy. That is not theory. It removes the first required step of the exploit path.

Validate the running state, not the change ticket. Check uname -r after reboot, confirm algif_aead is gone from /proc/modules if you chose the temporary workaround, and be honest about where local code execution is normal by design. That is where Copy Fail deserves urgent attention.


If you want help triaging where shared-kernel exposure actually exists in your environment, or validating whether your Linux hardening blocks this class of escalation, get in touch.