On October 13, 2026, XBOW Labs published a technical writeup of a Chrome full-chain exploit on Windows. Google paid the first $250,000 full-chain reward under Chrome VRP rules introduced in April 2026.[1][2]
The chain used three vulnerabilities, one in V8, one in Blink's WebP decoder, and one in Crashpad. The animation below follows those three vulnerabilities and the Wasm handoff that connects them, shown as four steps.[1]
After the animation, the post walks through each step and what it gave the attacker. It then covers the background on Chrome's boundaries, defines the key terms, and ends with what the three bugs have in common. Readers new to browser security may want to start with the background.
This is a conceptual reenactment for illustrative and educational purposes.
Figure built with Claude Code and the Anatomy skill by @wheresryan22.[11]
Chrome splits work across processes. The renderer runs page code, and an operating-system sandbox limits what it can reach. Inside the renderer, V8 adds its own in-process sandbox, so memory corruption in the JavaScript engine stays inside the engine. A full exploit chain needs a way past each boundary it crosses.[6][9]
Pointer compression is a separate idea that saves memory. V8 stores most heap pointers as 32-bit offsets into one reserved 4 GiB region, often called the cage. The cage sits inside the larger V8 sandbox, so control of the cage is still control inside the sandbox.[9]
An exploit uses a bug to make software do something its authors did not intend. Browsers are built in layers, so one bug is rarely enough to achieve a full working exploit. Each layer assumes the one above it may be compromised and limits what it can reach.
This chain used three bugs to get past those two sandboxes. A V8 compiler bug gave control inside the cage. A WebP decoder bug turned that into one write outside the V8 sandbox, which the Wasm handoff turned into native code. A Crashpad bug then escaped the operating-system sandbox. Fixing any one of the three breaks the chain.[1]
All three bugs came from something changing after the code assumed it would stay fixed. Maglev treated a boxed number as a constant, but the attacker could still change it. Blink trusted image bytes it believed it owned, and Crashpad trusted the memory of a suspended renderer that still had one thread running. In each case the fix was to stop relying on that assumption.[1]