Microsoft's AI finds 59 Linux kernel bugs – one went unnoticed for 21 years

What it's about

On November 11, 2026, Microsoft's security research team FORGE Lab published a report titled "Lessons from 59 Linux Kernel Bug Reports" on the Microsoft Security Blog. It describes how the team used an AI-powered scanning system called MDASH (an internal codename) to hunt for security vulnerabilities in parts of the Linux kernel. The kernel is the core of the operating system. It runs on servers, cloud data centers, routers and every Android smartphone.

The tally so far: 59 public bug reports to the Linux developers, 33 assigned CVE numbers (CVE is the global identification system for known security vulnerabilities) and eight confirmed exploits that let a regular user make themselves administrator ("root"). Fixes for 38 of the reports have since landed in the kernel's official main branch, known as the mainline kernel. The work ran for three months and was led by a single full-time researcher and an intern. The actual scans ran from late May to mid-June 2026.

As the trade outlets Cybersecurity News and GBHackers report, the report focuses on one question above all: how much human work is left after the AI scan. Finding bugs is the easy part, it says. Confirming, explaining and fixing them takes much longer.

From a mountain of data to 59 reports

The team focused on core areas of the kernel: networking, file systems and security modules. It picked security-critical components that don't require special hardware. That way, every finding could be reproduced consistently in QEMU, a program that emulates an entire computer.

The process in numbers:

The scans ran on just two servers (64 cores with 256 GB RAM and 32 cores with 128 GB RAM). The code was analyzed by commercial language models, broken down by share of tokens consumed: Anthropic's Sonnet 4.6 at 71.1 percent, OpenAI's GPT-5.4 at 20.1 percent and GPT-5.5 at 7.1 percent. The team then weeded out low-confidence findings, meaning those the system itself wasn't sure about. For this, it used MDASH's confidence scores and its own fast verification agents.

In the next step, AI agents had to actually trigger each remaining candidate in QEMU. These are programs that carry out multiple steps on their own. They had to build a proof of concept, a small piece of code that shows the bug is real. The main models used here were GPT-5.5 (77.3 percent), Claude Opus 4.6 (13.2 percent) and the security variant GPT-5.5-cyber (9.4 percent).

Experts then reviewed the remaining 621 cases by hand. In the end, barely one in ten was reported. Here's why the rest didn't make the cut:

• 266 cases (42.8 %) shared a root cause with another case, so one patch covered several.
• 163 cases (26.2 %) were dropped for low security relevance.
• 133 cases (21.4 %) had already been reported or fixed.

Microsoft attributes the large overlap to timing. The first public report didn't go out until June 27, 2026, more than five weeks after scanning began. By September 1, 55 of the 59 reports were on the public mailing lists. Four more were initially reported privately and published by mid-October.

Ancient bugs in the kernel

Many of the vulnerabilities were old. On average, a reported bug had been sitting in the kernel for 8.1 years. Six were 15 to 19 years old, and three were at least 20. The oldest is a so-called shift-out-of-bounds bug in the cls_u32 network filter (CVE-2026-74544): an arithmetic operation shifts bits beyond the permitted range. According to Microsoft, it had been there for at least 21 years.

Most of the eight exploitable vulnerabilities are use-after-free bugs. In these, the kernel accesses memory it has already released, a bit like a hotel giving a room to a new guest while the old guest still has a working key. If you cleverly reallocate that memory, you can feed the kernel forged data.

Microsoft adds a caveat: the exploits were tested in controlled lab environments. Some only worked with non-default settings or with protections turned off.

A closer look: one missing line, undetected for eight years

The report goes into detail on CVE-2026-64563 in rhashtable. This is a shared, resizable hash table in the kernel, a kind of fast lookup directory. Many parts of the kernel store active objects such as network sockets in it. When a program requests a long list, the kernel can walk through the table in several passes. It keeps track of where it left off with a pointer called iter->p.

A change from 2018 (commit 5d240a8936f6) was meant to make pausing and resuming more robust. It moved the reset of this pointer to a different spot, but only in one of two possible code paths. If the table was resized during the pause and the old entry deleted, the pointer would afterwards point to freed memory. The bug only triggers when three rare events coincide: a walk is paused and resumed, the table is rebuilt during the pause, and exactly the remembered entry is deleted. That's why it went unnoticed for eight years. The fix is a single line: iter->p = NULL;.

Around two dozen files in the kernel use this function. It becomes dangerous via netlink socket diagnostics (__netlink_diag_dump()), which even unprivileged users can reach on standard kernels. An attacker can deliberately pause the query, free the socket, reallocate the memory and inject a forged pointer. According to Microsoft, this yields a limited 64-bit write into the kernel. Combined with known techniques, that's enough for root, on Linux and also on Android with SELinux enforcing, without any special kernel configuration. Yuan Tan of security firm NebuSec had independently found the vulnerability as well and contributed exploits for Linux and Android. His colleague Frank Wu developed another working exploit.

All of these vulnerabilities require local access. According to Cybersecurity News, attackers usually get that beforehand through stolen credentials or another vulnerable service.

The bottleneck is human

Microsoft itself sees a stark imbalance as the key takeaway. Two weeks of scanning produced the findings, while reporting 59 cases took more than four person-months. The Linux kernel expects a working patch with every report. AI agents wrote the first drafts, but humans had to review them and coordinate with the maintainers, the people responsible for individual parts of the kernel. Half of the 38 merged fixes were accepted on the first try; the rest needed one to four revisions. From the first public patch to the official release, a median of 41 days passed, and 108 in the longest case.

"More tokens may bring more bugs, but not a secure system."

Microsoft also warns that the sheer volume of real findings can overwhelm both bug hunters and maintainers. Teams should therefore focus on truly severe vulnerabilities. Only a small part of the kernel was scanned, and with more tuning and compute, many more findings are likely, according to the report.

Our take

The report fits a year in which AI tools have uncovered Linux vulnerabilities in large numbers. Cybersecurity News mentions, for example, OpenAI's GPT-6 Cyber model, which reportedly built hundreds of working Linux exploits. Microsoft's report still stands out because it lays out the entire chain, from 26,502 raw findings to 38 merged fixes. It's also honest about how much of it is noise and how much manual work remains.

If you run Linux or administer Linux systems, the takeaway is simple: install kernel updates promptly, since many of the fixes have already shipped. For the open-source world, there's a more serious question. If AI systems can cheaply generate thousands of suspected bugs, they'll swamp maintainers, many of whom are volunteers, and the same tool can help attackers too. It's unclear whether or when Microsoft will make MDASH available to other security teams. The report only says the findings will feed into further development. All figures come from Microsoft itself, but the CVE ratings are publicly verifiable.