deniz.in

Markets

Weather

Loading weather

· via dev.to (home feed)

Chrome 157.0.8103.78 fixes ServiceWorker use-after-free that allowed sandbox escape

Google has fixed CVE-2026-126885, a use-after-free in Chrome's ServiceWorker component that a crafted HTML page could abuse to execute code outside the browser sandbox. Versions before 157.0.8103.78 are affected.

Chrome 157.0.8103.78 fixes ServiceWorker use-after-free that allowed sandbox escape

Google has closed CVE-2026-126885, a use-after-free vulnerability in Chrome's ServiceWorker component, with the release of version 157.0.8103.78. According to the CVE description quoted in a dev.to analysis, a remote attacker able to lure someone to a crafted HTML page could execute arbitrary code outside the browser sandbox. Every version before the fixed build is listed as affected, and the write-up points to a Chrome Stable Channel update dated November 11, 2026 as the shipping vehicle.

The bug and where it sits

A use-after-free is a memory-safety error in which a program keeps a reference to memory after that memory has been handed back, giving an attacker a chance to reclaim it and influence what runs. In this case the flaw lives in the ServiceWorker component, which is a particularly sensitive place for one.

As the dev.to piece explains, service workers act as a layer between a web page and the network: they intercept fetches, manage caches, persist after the page that registered them is closed, and follow a lifecycle the browser manages on its own. That longevity is exactly why their internal state is attractive. Memory corruption in ordinary renderer code tends to be bounded by the sandbox and by a crash; corruption tied to a component whose state outlives the page raises questions about how much of the process-isolation model still holds.

What the record does and does not show

Two caveats from the write-up are worth keeping straight. First, the public description establishes the mechanism — crafted page, use-after-free, code execution beyond the sandbox — but no working exploit has been published. Second, the sources the author reviewed show no evidence that this specific CVE has been exploited in the wild. Even so, the severity is treated as high enough that the update should be handled as urgent for high-risk browsing profiles.

Patch rollout is the practical problem

The dev.to analysis spends much of its length on deployment, because the gap between a patched package and a browser actually running the patched build is where exposure lives. Its recommendations:

  • Inventory the executable version, not the product name, across user endpoints, virtual desktop templates, release rings and browser-based kiosks.
  • Check extension setups and enterprise policies for anything that pins a machine to an older Chrome channel.
  • Let Chrome's updater finish and restart the browser, since a long-running session can keep an outdated process alive after the package has been updated; verify the running process version and confirm subprocesses picked up the new build.

For high-value users, the write-up suggests interim hardening — trimming unnecessary extension permissions, separating sensitive work from unrestricted browsing, and moving administrative tasks into a dedicated profile — while stressing that these only lower the odds of a crafted page meeting valuable cookies or admin access, and are not a substitute for the patch.

If you suspect a hit

A single browser crash proves little either way. The advice is to preserve the Chrome version, crash reports, renderer and service-worker logs, downloaded files, the extension inventory and recent profile changes, then look for persistence outside the browser itself: scheduled tasks, launch agents, startup folders and unusual child processes.

One service-worker-specific wrinkle: cached worker state can keep serving attacker-influenced content long after the original page is gone, so closing a tab removes nothing. Clearing site data for the suspected origin is reasonable, but only after evidence has been collected.

Why it matters

The renderer sandbox is the load-bearing wall of the modern browser: it is what makes it safe to treat any web page as hostile. A use-after-free reachable from a crafted page that can execute code outside that wall turns a routine visit into potential host compromise, which is why these fixes land as fast as they do. Service workers add a second dimension — persistence — meaning both the attack surface and any leftover attacker state can outlive the page that introduced them. The practical takeaway for any Chrome fleet is unglamorous but real: confirm what is actually running, not what is nominally installed.

  • #chrome
  • #security
  • #vulnerability
  • #browser
  • #service-workers

Related posts