Sashiko, the AI hunting for the next big bug in Linux
Linux debuts Sashiko, AI-assisted kernel review, while XBOW exploits CVE-2026-72018. What went wrong, how root was achieved and what lessons it leaves behind.
Sashiko, the AI hunting for the next big bug in Linux
In late September 2026, two stories told that story from opposite angles, according to the XBOW investigation of September 28 and the debate on automated review on the kernel mailing list. On one hand, an autonomous system found and exploited a flaw that human reviewers had overlooked. On the other, the community was discussing Sashiko, a proposal to review kernel changes with the help of agents.
The flaw, registered as CVE-2026-72018, allowed a local user with network capabilities to escalate to root with a write of just 16 zero bytes in exactly the right place. It sounds like little, like picking a lock with a paperclip, but placed in exactly the right spot it opens the front door. XBOW demonstrated the full path to a shell with uid zero, without additional memory leaks or complex chains.
A week later, with the patch already approved in July and the CVE published in August, the interesting question is not whether to update, which too, but what this case teaches about reviewing code with AI and where expert human judgment is still needed.
Sashiko, the Linux kernel bug tracker
Sashiko is a proposal to review kernel changes with agents that read patches, look for dangerous patterns and ask for context when something does not add up. The idea was discussed on the kernel mailing list as a response to a scale problem, because each release brings thousands of changes and human reviewers cannot keep up. It does not replace a maintainer's sign-off, but it can sort the queue by risk.
The timing is no coincidence. On October 1, maintainer Greg Kroah-Hartman described an avalanche of model-assisted reports, with many false alarms among valid warnings. In that environment, a tool that reviews with judgment and explains its findings is worth more than another that generates candidates en masse. Sashiko aims at the former, with traceability of why it flags each patch.
A look at the Sashiko platform and the bugs currently under review in the Linux kernel
For a non-technical reader, imagine a proofreader that not only underlines mistakes, but asks the author why a delicate sentence was changed. That conversation leaves a trail and helps the final editor decide. In the kernel, the final editor is always human, and the agent is a tireless assistant that does not fall asleep on page one thousand.
What flaw did XBOW find in the kernel?
The flaw lives in the SMC-D stack, an IBM protocol for communicating virtual machines over shared memory that avoids copying data the way TCP does. For years it required specific mainframe hardware, so almost no one audited it on ordinary laptops. With the DIBS abstraction and the dibs_loopback driver, that code began running on any x86 over loopback, without special hardware.
The problem is conceptual and easy to explain. When establishing the connection, the peer sends fields such as token, index and size that the receiver must validate before calculating offsets. The kernel multiplied size by index to obtain the write offset without checking ranges, so a large index pushed the copy beyond the buffer. The final copy did a memcpy to the base address plus that offset without questions.
The legitimate buffer is 16384 bytes in a single memory page, and what is written outside it is a 32-byte header of which 16 are predictable zeros. Put in everyday terms, the program was writing the letter into the neighbor's envelope by trusting the house number it was given. That trust without verification is the heart of CVE-2026-72018.
Exploiting the flaw first required making it reachable locally. The normal path set the index to zero, so it seemed like a dead end for an attacker without hardware. XBOW intercepted loopback traffic with NFQUEUE, forged the handshake messages, recalculated checksums and reinjected the packets. All of this requires CAP_NET_ADMIN, a permission that containers and network daemons have, so the threat model is realistic.
Then came turning a weak write into a full escalation. The team reframed the question, instead of what to write where, it asked where the zeros hurt most. The answer was the cred structure, which stores user identifiers and which the kernel consults on every permission check. If the euid field is left at zero, the process passes as root.
The placement technique is patient and noisy at the same time. First the target buffer is pinned with the token of a warm-up connection, then many child processes are launched that force fresh credentials to stack them behind the buffer. Each child watches its own euid and alerts the parent upon reading zero, which stops the sweep before breaking neighboring structures. On Ubuntu 24.04 with mitigations disabled, the prototype achieved root in 22 of 100 boots.
Exploit phase
What the attacker does
What they need
Interception
Forge index and size on loopback
CAP_NET_ADMIN and NFQUEUE
Write
Shift 16 zeros past the buffer
Valid SMC-D connection
Placement
Stack cred behind the buffer
Many child processes
Escalation
Detect euid zero and open a shell
setresuid to zero
Human judgment will always have a place
XBOW honestly recounts the three moments where a person redirected the investigation. First, when the zero index seemed a dead end, a researcher suggested intercepting packets in transit. Second, when the agent confused the old model with free write and the new one limited to zeros, it had to be forced to measure the primitive experimentally. Third, when it insisted on turning the zeros into something more powerful, it had to be asked to exploit what it already had.
Those interventions draw the current boundary well. Models read code without tiring, test tedious hypotheses and do not give up out of boredom, but they develop very human biases when the context grows. They prefer the cheap to the costly, bury ideas they discarded with a single sentence and cling to assumptions as if they were beliefs. Someone with Linux experience knows that writing zeros in the right place can be enough, and that intuition guided the ending.
The architectural answer XBOW proposes is to split the work among several agents with bounded contexts, instead of loading a long campaign onto just one. Each agent keeps what it needs and forgets the rest, so decisions do not get diluted across thousands of lines of history. It is an organizational lesson as well as a technical one, because memory must also be managed.
The timeline helps calibrate urgency without alarmism. The flaw was reported on June 19, 2026, the patch was approved on July 7 and the CVE was published on August 17, according to XBOW's chronology with reference to the announcement on lore.kernel.org. As of October 9, when we write this, distributions have included the fix for weeks. If you updated the kernel after the summer, you are already protected.
For fleets, the routine is the familiar one. Inventory versions, prioritize hosts with SMC loaded or with containers granted CAP_NET_ADMIN, schedule reboots and verify with uname -r. In public clouds, recent images already carry the patch, so new machines boot covered. There is no sign of mass exploitation in this specific case, but the window between June and August existed.
A note for the prudent curious. Reproducing the exploit requires setting up NFQUEUE and forging handshakes on your own lab machine, never on systems that are not yours. The educational value lies in understanding validations and offsets, not in trying it where you should not. If the technique interests you, read the full report and practice with disposable machines.
Check the kernel version on each host and compare it with your distribution's advisory
Look for loaded SMC modules and consider removing them if no service uses them
Review which containers receive CAP_NET_ADMIN and trim that permission where it is unnecessary
Schedule the pending reboot, because the patch on disk does not protect until you boot
When AI reviews and also attacks
This October leaves a symmetry worth retaining. The same family of techniques that helps review patches with Sashiko is the one that found a forgotten flaw and turned it into root with XBOW. They are not two separate stories, they are two sides of the same more powerful microscope looking at the same code. The difference between defense and attack lies in who formulates the question and with what permission they act.
The kernel will come out ahead if automated reviews explain their reasoning, link evidence and accept a no for an answer. It will lose if we drown in candidates without context while real flaws wait their turn. Between those extremes, cases like CVE-2026-72018 recall a simple truth, because forgotten code that suddenly runs everywhere deserves a fresh review with an adversarial mindset.