AI Agent Discovers Linux Kernel Vulnerability Allowing Root Access via Memory Write

Autonomous security research platform XBOW has disclosed CVE-2026-72018, a high-severity Linux kernel vulnerability that converts a tightly constrained out-of-bounds memory write into local root access. The flaw affects the DIBS loopback implementation used by the SMC-D shared-memory communication path, where a missing bounds check allows attacker-controlled data to be copied beyond an allocated kernel buffer. This vulnerability is notable not only for its impact but also for the weakness of the available exploit primitive.

XBOW's research demonstrated that the bug could reliably produce only 16 zero bytes at a partly controlled kernel-memory offset. Despite this limitation, the researchers developed a local privilege-escalation exploit that elevated a process to root without requiring a separate information leak. The issue exists in the dibs_loopback driver, which enables Shared Memory Communications Direct (SMC-D) on standard x86 Linux systems without IBM Z hardware. SMC-D was historically associated with IBM mainframe environments and Internal Shared Memory devices, leaving much of its code comparatively less scrutinized.

The addition of the dibs_loopback virtual device changed that exposure, making SMC-D reachable on commodity Linux systems through loopback networking. This transformed code once considered difficult to access into a local attack surface. XBOW discovered that a peer-controlled dmbe_idx value could influence offset calculations during SMC connection setup. That offset eventually reached the move_data() routine in the DIBS loopback driver, which performed a memcpy() operation without validating whether the supplied offset and write size remained within the destination buffer.

The upstream remediation adds validation for offset and size before the copy operation. Linux advisory information describes the flaw as an out-of-bounds write that could corrupt memory beyond the allocated buffer because software loopback lacks the hardware-enforced memory-region protections available in real ISM hardware. The local attack scenario requires CAP_NET_ADMIN privileges.

XBOW utilized this capability to enable SMC-D functionality and manipulate loopback CLC handshake traffic through an NFQUEUE-based man-in-the-middle setup. By modifying selected handshake fields, the exploit could force an out-of-bounds write into adjacent kernel memory. The usable effect was not an arbitrary write; it was a fixed 16-byte zero write positioned at a chosen alignment over a limited range.

Rather than attempting to build a more powerful primitive, researchers targeted the Linux kernel’s cred structure, which stores a process’s user and group identity fields. If zero bytes land on fields including euid, the effective user ID becomes zero. Since Linux permission checks treat an effective UID of zero as root, the affected process can subsequently establish a full root identity and spawn a root shell. This approach demonstrates a familiar exploitation lesson: a primitive does not need to be arbitrary to be security-critical.

The experiment, performed on Ubuntu 24.04 using Linux 7.1.0-rc6 with kernel mitigations disabled, showed a proof-of-concept succeeding on 22 out of 100 separate boots. The CVE record carries a CVSS 3.1 base score of 7.8, rated High, with a local attack vector, low privileges required, no user interaction, and high confidentiality, integrity, and availability impact. The findings highlight both the promise and current limits of autonomous vulnerability research, where AI systems can sustain exhaustive code analysis, but human judgment remains decisive.

Administrators are advised to apply Linux kernel updates containing the DIBS loopback bounds-check fix and reboot affected systems. Organizations should also review workloads and containers granted CAP_NET_ADMIN, as that capability is central to the demonstrated local attack path.