Security

Chrome Pwn in Motion

Michael Sandborn with Grok Bot Updated

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.

How to read the animation

  • Static. Chrome on Windows laid out as six process solids, with the V8 cage inside the renderer. Hover any part for a tooltip.
  • Dynamic. The same parts with Mojo IPC traffic moving between processes.
  • Exploit. A slow replay of the four steps. The active step is red and the boundary in play is amber. Drag or click the timeline to scrub.
Open fullscreen

Figure built with Claude Code and the Anatomy skill by @wheresryan22.[11]

The chain, step by step

  • 1. Maglev deopt. A Maglev deopt path reused a mutable HeapNumber that the compiler treated like an immutable constant. Attacker-controlled values became read and write anywhere inside V8's pointer-compression cage, the 4 GiB region that holds most JavaScript objects. The V8 sandbox still held. This is Chromium issue 547819997.[1][4] What this gives the attacker: The attacker can now read and change any memory inside JavaScript's walled-off area, but nothing outside it yet.
  • 2. Animated WebP. With in-cage control, a live Uint8Array was unlinked from its ArrayBuffer detach chain, so it survived when ImageDecoder took the buffer. Blink's animated WebP decoder kept cached frame geometry while the attacker changed the image bytes, a gap the V8 sandbox never promised to stop. The decoder wrote past its pixel buffer, and that yielded one chosen native write outside the V8 sandbox. This is Chromium issue 548509153.[1][4] What this gives the attacker: The attacker can now change one spot of memory outside that walled-off area. One spot is enough to take the next step.
  • 3. Wasm handoff. That write moved the base of the process-wide Wasm code-pointer table. The next Wasm call resolved a forged entry that pointed to a single jmp rcx instruction in chrome.dll, and that jump landed on the first of 13 Liftoff islands. Each island holds up to six bytes, and together they form a loader of about 70 bytes that copied in the Crashpad payload and ran it.[1] What this gives the attacker: The attacker's own code now runs in the tab's process. That process is still boxed in by the sandbox, so it cannot touch the rest of the computer.
  • 4. Crashpad race. The payload asked Crashpad for a snapshot, and Crashpad suspended the renderer to read its memory. On Windows, a freeze-exempt thread kept running and made a page readable between a failed read and its retry. The retry in ProcessMemoryWin::ReadUpTo copied more bytes than its buffer held and overwrote the next allocation, a live SnapshotMinidumpMemoryWriter. When Crashpad later used that writer, the attacker got code execution in the unsandboxed handler. The bug is tracked as CVE-2026-78952, GHSA-g6pq-88qr-3vgv, and Chromium issue 545820931. Chrome 152.0.7977.65 fixed it on August 25, 2026, and NVD scores it 8.3.[1][3][4][5] What this gives the attacker: The attacker's code now runs in Chrome's crash helper, which sits outside the sandbox. On Windows, that means it can act like a normal program on the computer.

Background

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]

Key terms

  • Browser process. The privileged process that owns the UI and brokers access to the network, disk, and other services. Compromising only a renderer should not give an attacker this process. In the figure: The box labeled BROWSER at the top of the diagram.
  • Renderer process. Runs the page. Chrome uses site isolation so unrelated sites stay apart, and it locks the renderer in an operating-system sandbox so bugs there cannot freely touch the rest of the machine.[6][7] In the figure: The box labeled RENDERER, LOW INTEGRITY. Its dashed outline is the sandbox.
  • V8. The JavaScript and WebAssembly engine inside the renderer. Most heap objects live in a 4 GiB region set up by pointer compression.[9] In the figure: The JS in renderer layer inside the renderer box.
  • Maglev. V8's mid-tier JIT. Speculative code can deopt when assumptions fail. The first step of this chain abused how Maglev rebuilds a HeapNumber during deopt.[1][9] In the figure: The MAGLEV block. Step 1 lights up here.
  • V8 sandbox and cage. Two different things. The V8 sandbox is an in-process boundary that keeps memory corruption in the engine from spreading to the rest of the renderer. The cage is the 4 GiB pointer-compression region inside it, where most JavaScript objects live. Read and write inside the cage is serious, but it is not yet native code. Step 2 gets the first write outside the V8 sandbox.[1][9] In the figure: The V8 cage box inside the renderer. Its edge turns amber while the chain works its way out.
  • Blink. The rendering engine that owns the DOM and many web APIs, including animated WebP decoding through ImageDecoder. The second step starts from a trust Blink placed in image bytes. In the figure: The BLINK block in the renderer, where the WebP decoder lives.
  • WebAssembly and Liftoff. After one native write, the chain redirects the Wasm code-pointer table. A forged entry jumps through one instruction in chrome.dll to short Liftoff instruction islands that together form a small loader.[1][9] In the figure: The CHROME.DLL strip, then the LIFTOFF ISLANDS x13 strip, in step 3.
  • Mojo IPC. How Chrome processes talk. The Dynamic view of the figure animates those pipes so you can see traffic across the sandbox.[8] In the figure: The lines between boxes. Switch to Dynamic to see the traffic move.
  • Crashpad. The crash helper outside the renderer sandbox. It suspends a renderer and reads its memory for a minidump. The final step races that read on Windows.[3][10] In the figure: The CRASHPAD box outside the sandbox, which is the target in step 4.

What the bugs share

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]

Sources

  1. Zero to Calc in Six Days: Inside XBOW's Chrome Full Chain, B. Dolan-Gavitt, XBOW Labs, Oct 13, 2026
  2. XBOW built a Chrome full-chain exploit, Oege de Moor, Oct 13, 2026
  3. CVE-2026-78952 advisory, fixed in Chrome 152.0.7977.65 on Aug 25, 2026
  4. Chromium issues 547819997, 548509153, 545820931
  5. GHSA-g6pq-88qr-3vgv
  6. Chromium multi-process architecture
  7. Site Isolation design document
  8. Mojo and services
  9. The V8 sandbox, pointer compression, Maglev, Liftoff
  10. Crashpad
  11. Anatomy skill, MIT, @wheresryan22