I ran a local model (Qwen, two 3090s in my basement, DFLASH-accelerated, custom harness on qwen-code, Zed as the UI) against CVE-2026-119618 — the Apache mod_http2 assign_headers() c1/c2 header-table race — before I left for the gym.
When I came back it had hit its first checkpoint. I honestly hadn't expected much. It gave me a sliver of hope, so I sat down and watched it for the next ~3 hours.
By the end: a working RCE. I hadn't typed a line.
The part I want to point at
Everything turned on what I gave it.
Not the bug description. Not a writeup. Not a hint.
Just the fix — a one-line diff from the upstream commit:
- apr_table_setn(req->headers, "Content-Length", "0")
+ apr_table_setn(r->headers_in, "Content-Length", "0")
One identifier changed: req->headers → r->headers_in. That was the entire input.
What it did
It worked backwards from the fix — the question a senior engineer asks: why was the old line wrong?
Old line wrote into req->headers — a table shared between two threads (the h2 session/mux, "c1", and the worker that builds the real request_rec, "c2"). No lock. Data race on a hash table → heap corruption.
New line writes into r->headers_in — a per-request clone only the worker touches. No sharing, no race.
It didn't read that off a blog post. It derived it from the diff.
Then it turned the root cause into an attack chain:
Wrote a Python exploit that drives the HTTP/2 state machine directly.
Stood up the vulnerable Apache 2.4.70 in Docker (the official image).
Fired concurrent streams to force the two threads to overlap → cat /etc/passwd ran on the live container.
~4.5 hours, 9 commits, no hand-holding.
The number that doesn't add up
NVD scores it CVSS 8.1 — High. But the exploitability sub-score is 2.2 (low end, AC:H). CISA SSVC: "no known exploitation," "not automatable."
In the old mental model that's the bug you put in the "someday" pile — high impact, but you have to win a timing race on a live box.
A model in my basement didn't seem to read that part. It treated "hard to exploit" as a tuning problem — more streams, more rounds — until the race stopped being theoretical.
My take: exploitability scores are a statement about human effort, and a machine doesn't have the same cost curve. "Hard to exploit" ≠ "a machine won't brute it."
Where I'm not bragging
Root-cause half — I can follow it, it's a real inference. I'd sign it.
Exploit half — more opaque. It wrote the most plausible h2 trigger and let the Docker loop tell it when it was wrong (a 503 here, a dropped stream there). I can't point to the exact moment it "got it." Could be capability, could be a good afternoon with a fast model. That uncertainty is part of the story.
The thing I actually care about
The cage. The model could only reach a local Docker network — no host, no internet except exactly two API calls I let through (the official Apache CVE page + the httpd source on GitHub).
So my code, my patch, my exploit draft, my debug loop — none of it left the machine. The "cloud" was a fan in my basement.
But flip it: an attacker running the same setup in their basement gets the identical privacy, plus the same speed. Local AI is a double-edged tool — the edge points both ways at once.
TL;DR
Handed a local model the one-line patch for CVE-2026-119618, not the bug.
It derived the root cause (shared, unsynchronized header table) and built a working RCE against live Docker Apache 2.4.70 → cat /etc/passwd.
4.5h, 9 commits, zero lines from me.
CVSS 8.1 but exploitability 2.2 — the "someday" bug. A local model treated it as a tuning problem.
The privacy that keeps your code local is the same shield hiding an attacker's.
[Link] https://github.com/studiogangster/CVE-2026-119618