
CVE-2026-126919 - Chrome MimeHandlerView postMessage use-after-free. Remote, crafted HTML. Lab-proven renderer crash (BUS_ADRALN on a freed WeakPtrFactory) on Chrome for Testing 158.0.8118.0, clean on 158.0.8119.0.
One PDF embed and one child frame named chrome is enough to free a Chrome
renderer object while a function is still using it. The page needs no user
input past opening it. Chrome shipped the fix on 11 November 2026 in
157.0.8103.78, and the change is seven lines: take the WeakPtr six
statements earlier and check it.
The defect is in the MimeHandlerView postMessage bridge. The bridge finds the
target frame by name, asks Blink for that frame's window proxy, and only then
takes a weak reference to itself. Asking for the window proxy can create the
frame's V8 context. Creating that context installs chrome.loadTimes, which is
a plain JavaScript property write. If the target frame has a child frame named
chrome, the write lands on a page-controlled object and runs page-controlled
code, synchronously, in the middle of the lookup. The page uses that callback to
detach the guest. The bridge object is freed. The next statement reads the freed
WeakPtrFactory.
Class: Use after free (renderer) Reach: Remote, crafted web content
Chromium 85726bdcb2 (vulnerable) vs 1974b67c61 (fixed) - Chromium
CVE-2026-126919 is one of the fixes in Chrome stable 157.0.8103.78. Google
rates it High and keeps Chromium issue 569674220 restricted. The fix commit is
public and its message names the exact call, the exact frame shape, and the
exact setter, which is enough to rebuild the trigger.
| ID | CVE-2026-126919 |
| Also | EUVD-2026-124072 |
| Class | Use after free (CWE-416) |
| Reach | Remote (crafted HTML, user opens the page) |
| CVSS | 8.8 CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H (CISA-ADP) |
| Product | Google Chrome |
| Affected | Chrome before 157.0.8103.78 |
| Fixed | Chrome 157.0.8103.78 (11 Nov 2026), Chromium 1974b67c61 (22 Oct 2026) |
| Chrome rating | High |
| Exploited | not in CISA KEV; EPSS 0.35% (14 Nov 2026) |
| Auth | none |
| License | GNU Affero GPL v3.0 |
| Lab | Docker, loopback only, Chrome for Testing 158.0.8118.0 and 158.0.8119.0 |
| Method | Sink | Result |
|---|---|---|
Open a page that embeds a PDF, save the guest's postMessage, replace the guest with a same-named sandboxed frame, name its child chrome, install a loadTimes setter that detaches the guest, call the saved function | PostMessageSupport::PostJavaScriptMessage -> WebFrame::GlobalProxy -> LoadTimesBindings::Install -> GetOrCreateChromeObject -> Set("loadTimes") | Lab-proven: renderer aborts with BUS_ADRALN on the freed WeakPtrFactory |
Same page against 157.0.8103.78 or 158.0.8119.0 | same path, fixed order | Lab-proven: setter runs, the call returns, renderer stays alive |
Heap grooming around the freed PostMessageSupport | attacker-controlled adjacent allocation | Not attempted here. Chrome treats this as a High renderer bug; a control-flow chain is separate work |
| Sandbox escape | renderer to browser process | Out of scope for this pack. The 8.8 score assumes no scope change; this lab stops at memory corruption |
The freed object is small and lives in the renderer heap, next to everything else the page has allocated. A page that already runs script in the renderer can usually reclaim that slot. The upstream fix treats this as a use-after-free that must not happen at all, not as a hard-to-reach edge case.
The vulnerable statement order in extensions::PostMessageSupport::PostJavaScriptMessage:
v8::Context::Scope context_scope(
delegate_->GetSourceFrame()->MainWorldScriptContext());
v8::Local<v8::Object> target_window_proxy =
target_frame->GlobalProxy(isolate); // 1
gin::Dictionary window_object(isolate, target_window_proxy);
auto weak_this = weak_factory_.GetWeakPtr(); // 2 <- after the call
GlobalProxy() is MainWorldScriptContext()->Global(). For a frame that has
not created its main-world context yet, that call creates it. Context
creation ends with LocalFrameClient::DidCreateScriptContext, which runs
LoadTimesBindings::Install. That calls GetOrCreateChromeObject, which does
parent->Get(context, "chrome"). A named child frame is a property of the
parent window, so a child frame named chrome is returned as an object. The
install then does chrome->Set(context, "loadTimes", function). Set runs
the receiver's setter.MimeHandlerViewContainerManager, which owns PostMessageSupport.
~WeakReferenceOwner() invalidates the flag, and PartitionAlloc fills the
freed slot with 0xCD.GlobalProxy() returns. The next statement reads weak_factory_ out of the
freed slot, so GetWeakPtr() reads 0xcdcdcdcdcdcdcdcd as the
scoped_refptr<WeakReference::Flag> and faults on it. The abort is a
SIGBUS/BUS_ADRALN on an address ending in 0xcd, which is how this bug
shows up without a sanitizer.The frame shape matters in two ways. The replacement frame must keep its
main-world context lazy until savedPostMessage() runs, which
sandbox="allow-same-origin" on a srcdoc frame does. And the chrome name
must resolve to a child frame rather than a fresh object, which is why the
loadTimes setter is installed on the middle frame of a three-level
srcdoc nest.
Two Chrome for Testing builds, five cases, one oracle.
./CVE-2026-126919-mimehandler-postmessage-uaf-Abraxas-Labs.py
or run the lab directly:
cd lab
./run.sh
The image downloads both Chrome builds at build time and runs them under Xvfb.
Each case launches a fresh profile, serves the page over loopback, and reads two
out-of-band signals: beacons the page posts as it goes, and the browser's stderr
for the renderer's signal line. No DevTools client is attached on purpose,
because Runtime.enable makes the renderer create a main-world context for
every frame and hides the lazy-initialisation path.
| File | Purpose |
|---|---|
lab/poc.html | the trigger page, with how=call, how=descriptor, childname and noremove switches |
lab/poc.py | serves the page, launches each build, classifies the run, prints the oracle line |
lab/doc.pdf | the smallest MimeHandlerView resource that works |
lab/run.sh | docker compose up --build, then reads poc-last-run.txt |
run.sh prints SUCCESS or FAIL and writes poc-last-run.txt.