Bad Epoll: The Linux Root Bug That Anthropic's AI Walked Right Past
A newly disclosed Linux kernel vulnerability, CVE-2026-46242, lets any unprivileged local user gain root access. It affects mainstream Linux systems and Android, and it was found not by an AI but by a researcher named Jaeyoung Chung. That detail matters, and we will get to it.
The bug lives in epoll, a standard kernel mechanism for monitoring multiple file descriptors simultaneously. Servers, browsers, network services, basically anything that handles many connections at once relies on it. There is no realistic way to disable it.
The flaw itself is a use-after-free race condition. Two kernel code paths attempt to clean up the same internal object concurrently. One frees the memory while the other is still writing to it. That collision, brief as it is, opens a path to corrupting kernel memory and escalating from a normal user account to root.
Brief is something of an understatement. The exploitable window spans roughly six CPU instructions. A naive attempt will almost certainly miss it. Chung's exploit solves this by widening the window and retrying cleanly without triggering a crash, landing root access with around 99% reliability on tested systems.
Two details make this worse than the average privilege escalation bug. First, Chung claims it can be triggered from inside Chrome's renderer sandbox, which blocks almost everything. Second, it reaches Android, which most Linux kernel exploits cannot. A working Android proof of concept is still being developed, but the surface area is real.
Chung submitted it as a zero-day through Google's kernelCTF program. There is no evidence of exploitation in the wild, and it has not appeared on CISA's Known Exploited Vulnerabilities list. The only working code is the kernelCTF proof of concept.
Both Bad Epoll and a related flaw, CVE-2026-43074, trace back to a single 2023 change in the epoll subsystem. The related bug was found by Mythos, Anthropic's flagship AI model, and patched earlier in 2026. Anthropic has publicly claimed Mythos found Linux kernel privilege escalation bugs, though it has not specifically tied that work to this codebase.
Finding CVE-2026-43074 was a genuine result. Race conditions are notoriously difficult to spot. But Mythos found one bug in that 2023 change and missed the other one sitting right beside it.
Chung offers two reasons, with appropriate caveats that nobody can say for certain. The timing window is narrow enough that the precise sequence of events is genuinely hard to reason about, even when you are staring directly at the source. And once the first bug is patched, Bad Epoll's memory corruption tends not to trigger KASAN, the kernel's primary runtime sanitiser. Nothing rings an alarm. Nothing looks wrong.
For remediation: there is no workaround, because epoll cannot be turned off. Apply upstream commit a6dc643c6931 or wait for your distribution's backport. Kernels 6.4 and newer are affected. Older 6.1-based kernels, which includes some Android devices like the Pixel 8, are not, because the vulnerable code was introduced in 6.4.
Bad Epoll joins a running series of Android-grade kernel exploits with evocative names: Bad Binder, Bad IO_uring, Bad Spin. It has arrived during a busy stretch for Linux privilege flaws generally. Copy Fail (CVE-2026-31431) appeared in April and is already on CISA's KEV list. The Dirty Frag family followed.
Those are a different class of bug, deterministic page-cache-write vulnerabilities in the style of Dirty Pipe from 2022, where there is no race to win. They are more reliable by design. Bad Epoll is the older, harder kind, a race condition in the tradition of Dirty Cow from 2016.
Elsewhere, a public proof of concept has surfaced for CVE-2026-31694, a flaw in the kernel's FUSE filesystem layer found by AI-driven research firm Bynario. A local user with FUSE access can feed the kernel a malicious filesystem image and corrupt memory, potentially reaching root, leaking data, or crashing the system. Given how common FUSE access is in containers and user namespaces, this one lands squarely in server and container territory rather than mobile.
AI is finding real bugs. Mythos found one in this same code, and it and others have surfaced additional kernel flaws, including a 17-year-old remote code execution bug in FreeBSD's NFS server. That is not nothing.
But Bad Epoll is a useful reality check. A race condition is hard to find, hard to patch correctly (the first fix was incomplete; a correct one took around two months), and hard to exploit through a window six instructions wide. The AI found the first bug in a pair, missed the second, and a human had to finish the job.