SneakPeek: One Routine Review, 256 Kilobytes, and the Dev Machine's Keys Are Gone

October 18, 2026 · SPR{K3 Research

A developer asks Claude Code to review an HTML file in a repository they're integrating against. The agent complies. The preview pane renders the file. Nothing visibly happens. The developer moves on.

In the version of Claude Code Desktop that shipped between early July and mid-August 2026, that was enough for an attacker who controlled the HTML to walk out with the developer's AWS credentials, GitHub secrets, Claude OAuth tokens, SSH private keys, and Kubernetes cluster configs. No prompt. No click. The routine review was the delivery vehicle.

That is SneakPeek, disclosed on October 14 by Noma Security's Eli Ainhorn, covered the same day by Dark Reading and CSO Online. Anthropic rated it CVSS 8.7 (High), has requested a CVE and a GitHub Security Advisory, and has patched it: first fix July 9, final architectural fix August 17.

The reason it's worth writing about now isn't that it's unfixed. It's what the shape of the mistake tells us about where the trust boundary of an AI coding agent actually lives.

The 256-kilobyte branch

Claude Code Desktop renders HTML in an Electron panel built on Chromium. Two code paths exist.

Under 256 KB: Claude Code converts the file to a base64 data: URL and renders it under a strict Content Security Policy that blocks script execution. Anything malicious doesn't get a chance to run.

At or over 256 KB: Claude Code writes the file to disk and loads it via a file:// URL. The CSP does not apply. The file:// origin gives the renderer host-filesystem access by Chromium's rules. A file:// request filter was supposed to block that during static file rendering — but, per Noma's writeup, it was inactive during the exact path developers hit when they asked Claude Code to review a local HTML artifact, including test reports and coverage output.

So a 256-KB file was sandboxed and a 257-KB file was not. The attacker's job was to pad past the threshold. A JavaScript payload rendered under file:// could then read local files and ship them to an attacker-controlled server over standard browser APIs — any of the credentials and keys above a one-step pivot off the developer's machine.

Zero-click, where the click would be

The attack is zero-click in a specific sense: the user did only what the product was built to do. The trigger is the developer asking Claude Code to review or edit a specific HTML file. The preview pane renders it automatically as part of satisfying the request. One ask, one render, one script run with host filesystem access. Classical zero-click bugs in email or messaging apps involve a device doing something passive on the user's behalf. Here, the user is actively using the AI coding agent to do its job. The agent's job surface is the attack surface.

The first patch was bypassed

Noma reported the issue to Anthropic on July 4. Anthropic shipped a first fix on July 9 — five days. On July 24, Noma re-tested and bypassed it: by moving the file-reading code into a Web Worker, the reproduction regained the ability to exfiltrate credentials. Anthropic shipped a deeper architectural fix on August 17 — the one in production today.

The pattern worth naming: on an AI coding agent, the first-pass fix to a rendering-pipeline flaw often doesn't cover every path to the same primitive, because the pipeline has more branches than the obvious one. Noma didn't need a new attack — they moved the same code into a Web Worker and the gap reopened. Ainhorn: "The protections were real, they just didn't cover every path."

Why this is architecturally interesting

Three readings travel beyond SneakPeek itself.

The rendering surface attached to an AI agent is a trust boundary. The preview pane isn't a passive viewer like a terminal that prints bytes — it's a scriptable Chromium origin that renders attacker-authored content as part of the agent's own workflow. Any AI coding agent that ships a built-in HTML, doc, notebook, or report renderer has the same problem, and the only durable control is CSP+filter correctness on every branch, not just the common one.

Documentation and reports are code-bearing artifacts in agent flows. The attacker doesn't need a poisoned npm package or model weight — they need a crafted HTML file in a repository the developer will ask the agent to look at. Coverage reports, generated docs, bundled test output, scraped READMEs: all are delivery surfaces. The set of things an AI coding agent treats as readable is wider than most threat models treat it as.

Safe path and unsafe path can live inside the same function. The 256-KB branch is the clearest illustration. Small-file branch, sandboxed; large-file branch, not. Both shipped, both ran, and the developer had no visibility into which was taken. That isn't model alignment or prompt injection — it's per-primitive branching inside the agent's host code, and the only control that catches it is inside-the-loop runtime observation.

What a defender actually sees

A SneakPeek-style breach has shape even in the patched product: a rendering process making HTTPS requests to a destination the developer didn't configure; a file read of ~/.aws/credentials, ~/.ssh/id_rsa, or ~/.kube/config from a child of the Claude Code binary during an HTML review; a data: or blob: URL emitting out-of-process JavaScript that then opens local files. Those chains are what an outside-the-agent runtime watchdog is sized to detect, independent of whether the vendor's CSP branch was correct that day.

The takeaway

A patched CVE isn't the end of the story. The 256-kilobyte branch is a reminder that an AI coding agent's trust boundary is wherever its code reads attacker-controlled content and does something with it — including every path the vendor's first-pass threat model missed. Watch what the agent's host does, not what the agent says it's doing.


SPR{K3 is a security research operation that pairs offensive vulnerability research with runtime behavioral defense. Defend is our runtime agent. To talk about a deployment, reach us at support@sprk3.com.