Anthropic’s Mythos AI Reveals Linux Eventpoll Race Condition (CVE‑2026‑43074)

1. Vulnerability Overview

CVE‑2026‑43074 resides in fs/eventpoll.c and is a use‑after‑free caused by improper object‑lifecycle management of the struct eventpoll object. The CVSS v3.1 score is 7.8 (High) with low attack complexity, low privileges required, and high confidentiality, integrity, and availability impact.

Attack vector: Local

Attack complexity: Low

Required privileges: Low

User interaction: None

2. What Is epoll and Why Is This Vulnerability Dangerous?

epoll is the high‑performance I/O event notification mechanism used by Nginx, MySQL, PostgreSQL, container runtimes, Node.js, Python asyncio, Android, and Chrome. The vulnerability is critical because epoll is enabled by default ( CONFIG_EPOLL) on all mainstream Linux distributions, making the flaw widely exploitable wherever Linux is deployed.

3. Technical Principle: RCU‑Delayed Free

3.1 Nature of the Race Condition

When two threads simultaneously close mutually monitored epoll instances, the following interleaving occurs:

Thread A removes file->f_ep from epoll instance A’s watch list, announcing that the file is no longer monitored, but it has not yet completed cleanup.

Thread B concurrently closes epoll instance B, sees that file->f_ep is already cleared, assumes cleanup is finished, and proceeds to free the associated struct eventpoll object.

Result: Thread A continues to operate on memory that Thread B has already freed, leading to a classic use‑after‑free.

3.2 Fix Implemented Upstream

The upstream patch titled “eventpoll: defer struct eventpoll free to RCU grace period” replaces the direct kfree(ep) with kfree_rcu(ep, rcu), deferring the free operation until after an RCU grace period so that all readers have safely exited the critical section.

The core technical insight is that object removal and object free are not atomic, creating a exploitable window in concurrent scenarios.

4. What Mythos AI Discovered

Anthropic’s AI security model Mythos audited roughly 2,500 lines of epoll code in early 2026 and identified the above race condition, demonstrating that AI‑assisted code review can locate memory‑safety bugs that require precise concurrency reasoning.

However, Mythos missed another race condition introduced in the same commit (CVE‑2026‑46242, “Bad Epoll”), highlighting that even advanced AI can overlook extremely narrow timing windows.

5. Impact and Exploitation Status

5.1 Risk Level

Exploitation requires local code execution; an attacker must already have user‑level access. While remote exploitation is not feasible directly, the vulnerability can serve as the final step in a multi‑stage attack chain such as:

Web‑app vulnerability → low‑privilege shell → local privilege escalation to root

Malware deployment → gain administrator rights

Container escape → obtain host root

High‑risk environments include CI runners, Kubernetes nodes, developer workstations with cloud credentials, and multi‑tenant bastion hosts.

5.2 Public Exploits

There is currently no publicly released exploit for CVE‑2026‑43074. The reasons are:

The fix was merged into the mainline kernel on 2026‑04‑02, reducing the value of an exploit.

The race condition is highly sensitive to kernel version, CPU model, and memory allocation state, making reliable exploitation difficult.

Security research attention has shifted to the subsequent “Bad Epoll” (CVE‑2026‑46242), which does have a public exploit (Google kernelCTF).

6. Fixes and Mitigations

6.1 Official Patch

On 2026‑04‑02 the Linux mainline incorporated the fix, changing kfree(ep) to kfree_rcu(ep, rcu). Distribution‑specific rollout dates include:

Amazon Linux 2023 (kernel 6.12/6.18): fixed on 2026‑05‑09 (ALAS2023‑2026‑1695/1693)

Debian/Ubuntu/Red Hat: delivered via regular security updates.

6.2 Verification Commands

# Show running kernel version
uname -r

# Check for security update (RPM example)
rpm -q --changelog kernel | grep -i "CVE-2026-43074\|eventpoll\|kfree_rcu"

# Debian/Ubuntu example
apt list --upgradable 2>/dev/null | grep linux-image

6.3 Defense‑in‑Depth Measures

Restrict local code execution privileges and apply whitelist policies.

Isolate CI runners and forbid execution of unreviewed PR build scripts.

Enable Pod Security Policies in Kubernetes clusters to block privileged containers.

Deploy application control on developer workstations to prevent malicious software landing.

7. Conclusion

CVE‑2026‑43074 illustrates a real‑world case where AI‑assisted security auditing successfully uncovered a subtle kernel race condition, yet also missed an even tighter bug, underscoring both the promise and current limits of AI in deep concurrency analysis. Defenders must treat kernel object lifecycle details with utmost care, ensuring removal and free operations are atomic, while the security community should view AI tools as powerful aides rather than replacements for expert manual review.