Loading story…
Google Project Zero published several vulnerability reports covering memory-safety and type-confusion flaws in major JavaScript engines, including Mozilla SpiderMonkey, Google V8, and Apple JavaScriptCore. The issues described unsafe conditions such as leaked JS_OPTIMIZED_OUT values, V8 map migration that failed to respect element kinds and caused type confusion, incorrect garbage-collection assumptions in JavaScriptCore's DFG pipeline, unsafe ObjectGroup handling in SpiderMonkey's IonMonkey, and a JavaScriptCore CodeBlock use-after-free tied to dangling watchpoints.
Project Zero also disclosed a macOS sandbox escape involving type confusion in coreaudiod and the CoreAudio framework, extending the set of reports beyond browser engines into operating-system security boundaries. Taken together, the disclosures highlight recurring exploitation risks from type confusion, use-after-free, and JIT/compiler logic errors that can enable unsafe code execution, memory corruption, or sandbox bypass across widely deployed platforms.
Mallory correlates global threat intelligence with your attack surface — know if you’re exposed before adversaries strike.
6 events from the most recent confirmed update back to the earliest known activity.
Google Project Zero published issue 372511888 describing a macOS sandbox escape via type confusion in coreaudiod and the CoreAudio framework.
Google Project Zero published issue 1923 describing a V8 flaw where Map migration does not respect element kind, leading to type confusion.
Google Project Zero published issue 1808 describing a SpiderMonkey IonMonkey issue where an unexpected ObjectGroup in ObjectGroupDispatch could lead to potentially unsafe code execution.
Google Project Zero published issue 1802 describing an error in JavaScriptCore DFG's doesGC() handling of HasIndexedProperty on StringObjects.
Google Project Zero published issue 1794 describing a SpiderMonkey IonMonkey flaw that leaks the JS_OPTIMIZED_OUT magic value to script.
Google Project Zero published issue 1783 describing a JavaScriptCore CodeBlock use-after-free caused by dangling watchpoints.
6 references tracked. Mallory keeps watching after this page renders.
project-zero.issues.chromium.org
Open sourcebugs.chromium.org
Open sourcebugs.chromium.org
Open sourcebugs.chromium.org
Open sourcebugs.chromium.org
Open sourcebugs.chromium.org
Open sourceMap indicators from this story to your assets and identify affected systems in minutes.
Every observed campaign, victim, and pivot linked to actors named in this story.
Malware, exploits, and IOCs connected to the activity described here.
YARA, Sigma, and Snort rules deployed to your SIEM as soon as they’re published.
Get matching new stories delivered to your team as they break — not the next morning.
Ask questions about this story and take action on the answers.
Other stories Mallory is tracking that overlap on entities, sources, or topic labels.
Researchers detailed two Safari WebKit exploitation paths that turned renderer memory corruption into reliable arbitrary read/write primitives on macOS and iOS. Google Project Zero showed how `CVE-2020-9802`, a JavaScriptCore JIT flaw, could be exploited starting from `addrof` and `fakeobj` primitives, then bypass WebKit mitigations including **StructureID randomization**, the **Gigacage**, and **PACCage**. The write-up demonstrated leaking a valid StructureID with a fake `JSArray` and then abusing `TypedArray` handling in the DFG JIT to escape the Gigacage and gain fast, stable arbitrary memory access. Theori separately analyzed a Safari **AudioWorklet** type confusion introduced in Safari 14.1, where WebKit failed to verify that a returned JavaScript object was a `JSAudioWorkletProcessor`. That missing type check allowed attacker-controlled objects to be confused and used to corrupt `JSArray` butterfly pointers, again yielding `addrof`, `fakeobj`, and arbitrary read/write capabilities. The exploit reportedly worked on iOS 14.6 and macOS 11.4 even after the source patch was public, highlighting patch-gap risk and reinforcing concerns that existing WebKit hardening measures could still be bypassed in practice.
Jul 24, 2026
Researchers detailed exploitation of **`CVE-2020-6418`**, a type confusion flaw in Google Chrome’s V8 JavaScript engine that affects versions before **`80.0.3987.122`**. The bug lies in Turbofan’s handling of `JSCreate` within `InferMapsUnsafe`, where incorrect side-effect modeling can cause modified object Maps to be treated as trustworthy, skipping required Map checks and enabling out-of-bounds memory access. The write-up shows that a `Proxy` supplied through `Reflect.construct()` can trigger the condition and produce out-of-bounds read/write primitives inside the V8 sandbox. The research further demonstrates a practical exploitation path that avoids the common WebAssembly RWX approach by redirecting a JIT-compiled function’s `code_entry_point` to attacker-controlled immediate values already embedded in executable JIT code. The authors said they recreated the vulnerability in a newer V8 version using the original patch context and completed a demo exploit in `d8`, while a later reference highlights continued public interest in using AI assistance to develop Chrome exploit chains around browser vulnerabilities.
Jun 29, 2026
Multiple **critical vulnerabilities in *SandboxJS***—a JavaScript sandboxing library used to run untrusted code—were disclosed as enabling **sandbox escape and arbitrary code execution on the host**, with several issues scored **CVSS 10.0**. Reported flaws include **CVE-2026-25520**, **CVE-2026-25586**, **CVE-2026-25587**, and **CVE-2026-25641**, described as providing multiple paths to break out of SandboxJS’s isolation guarantees and take over the underlying runtime environment. Technical details published for **CVE-2026-25520** indicate that, prior to *SandboxJS* `0.8.29`, **function return values are not wrapped**, allowing attackers to use `Object.values()`/`Object.entries()` to obtain an array containing the host’s `Function` constructor (e.g., via `Array.prototype.at`), which can then be used to execute code outside the sandbox; the issue is fixed in `0.8.29` (with a referenced upstream commit and GitHub Security Advisory). Additional reported escape vectors include manipulation of supposedly safe prototypes (e.g., overwriting `Map.prototype.has` via a bug in the library’s `let` implementation) and a **host prototype pollution** condition tied to unsafe property-checking logic, collectively undermining the library’s core containment model.
Jun 29, 2026