This Week in WebKit — October 31 - November 06, 2026
Featured
An earlier fix audited every call site and still missed it. The dangling pointer is one no call site can refresh, and plain page script reaches it.
The loops already kept every shadow root they visited alive. Protecting the element, it turns out, never protected the walk.
The cache is per-thread; the counter deciding when it prunes is not. What leaks is small and float-shaped, but it lands straight in TextMetrics.
Validator and backend measured one vertex in different units. The over-read is small and read-only; whether it leaks depends on what sits next door.
Private builtins guarded the record, then C++ unpacked it through a door any page can rewire. The type confusion is real; a memory-corruption ceiling is unproven.
Only one of four memory configurations did it, and it's the bounds-checking one. Script still has to win a race against a background thread, then reclaim the slot.
Notable development
-
Always render DOM and WebGL in the GPU process on Cocoa platforms
refactor WebKit GPU Process
-
Send phone number possession requests from WebContent to the UI process
feature WebKit UIProcess IPC
-
Support "message_serialization": "structured_clone" for extension messaging
feature WebKit Web Extensions
-
VideoFrames cannot be created asynchronously in WebContent process
refactor WebKit GPU Process media
-
[JSC] Implement Float16 ops in x64 via F16C
optimization JSC x64 JIT
-
XPath sorting asserts on node-sets with nodes from different trees
bug WebCore XPath
-
[Swift] Optionally decode IPC arguments into Swift types
optimization WebKit IPC (Swift)
-
Store one status byte per bucket in WTF::HashTable
feature WTF HashTable
-
[Remote Snapshotting] Serialize fonts, gradients, filters and graphics state by value
feature WebCore Display Lists
-
Add support for dual-source-blending
WebGPU WGSL
Other security-relevant changes
- [WebCore CSSFontFace] (UAF)
3230087— Blocks author-controlled then getters from running synchronously during CSSFontFace status notification, where they could rehash the glyph geometry cache and free storage that FontCascade::width() still references. Adds a ScriptDisallowedScope in font code and defers promise resolution on workers. - [WebCore CSSOM rule lists] (UAF)
53cc8be— Removes lazy CSSOM wrapper creation via item(0) from the GC opaque-root callback, which ran on parallel marker threads with non-atomic refcounts and an unguarded RefPtr slot, enabling double-free/UAF on StyleRules shared through the style sheet cache. Opaque-root lookup is now side-effect-free. - [WebKit UIProcess back/forward list] (missing ownership check)
04f64b5— Scopes back/forward item lookups to the owning page so WebContent cannot reference items it does not own; such lookups become no-ops. Adds a MESSAGE_CHECK in decidePolicyForNavigationAction rejecting navigation messages that reference an unowned item. - [WebGPU Metal pipeline layouts] (bounds-check bypass)
4f9ccbb— Fixes ArrayLength binding aliasing in Device::addPipelineLayouts: one entry's dedup key could equal another ArrayLength entry's store key when bindings were maxBindingsPerBindGroup apart. The collision zeroed arrayLength, defeating the min() clamp and allowing OOB R/W. - [WebCore FontCascade] (UAF)
1e14429— Protects the FontCascadeFonts for the whole fallback walk and passes the cascade into fallbackRangesAt, so a synchronous worker font load that prunes the cache can no longer destroy it mid-walk. Same fix applied across the CoreText, Cairo and Skia paths. - [WebKit NetworkProcess downloads] (hardening)
c66e0f5— Validates download IDs from WebContent in the Networking process: the UIProcess now registers the authorized WebContent process for each download, and StartDownload and ConvertMainResourceLoadToDownload check that registration. Previously WebContent-supplied download IDs were accepted without this check. - [JSC Wasm JSPI] (reentrancy guard bypass)
a2bc1ad— Makes WebAssembly.Suspending a non-callable marker so JS re-entry via valueOf can no longer reach the JSPI stack-evacuation path. Checks that the current VM entry frame belongs to the suspending JSPI context and zeroes the returnPC slot, which was previously read uninitialized. - [JSC FTL/DFG ArraySortCompact] (lifetime fix)
0b8e3e2— Fixes a GC write-barrier bug in the ArraySortCompact bail path, where the barrier greyed the returned sentinel instead of the sort scratch buffer. A later full GC could trace dangling slots in the stale scratch. The scratch is now cleared on bail and returned to the VM cache. - [WebKit GPUProcess USDModel] (OOB read)
0187bc1— Validates the WebContent-supplied colorSpaceName in RemoteMesh::UpdateMaterial, falling back to extendedLinearSRGB for non-RGB spaces. Previously a name like kCGColorSpaceGenericCMYK made CGColorCreate read past a four-element array, and the over-read value was stored back as alpha. - [WebCore DOM tree scope] (UAF)
dceaa3d— Fixes a double migration of a video's cue display tree when the video is adopted, which over-decremented Document::m_referencingNodeCount and could free the old Document while nodes still point to it (UAF). Skips re-scoping of shadow-owned nodes and promotes the underflow assert to a release assert. - [WebCore DOM Node] (UAF)
165954b— Fixes a UAF of the shared innerHTML/outerHTML DocumentFragment via a dangling m_shadowIncludingRoot, triggerable by DOM mutation during an img error event. insertionStep now points it at the node below the fragment. - [ANGLE libANGLE Buffer] (integer truncation)
155652d— Replaces 32-bit unsigned int casts with size_t when invalidating the index range cache in Buffer::bufferSubData, copyBufferSubData, and mapRange, so writes at offsets past 4GiB invalidate the correct cached ranges. Stale ranges could otherwise skip draw-time index validation. - [WebCore IntersectionObserver] (UAF)
9d19688— Fixes a heap-use-after-free where GC helper threads walking IntersectionObserver's target sets raced with main-thread destruction of WeakPtrImpl nodes. Adds m_observationTargetsLock around all accesses to the guarded containers and returns snapshot vectors from observationTargets(). - [WebKit GPUProcess WebGPU RemoteQueue] (UAF)
19ee007— Adds a MESSAGE_CHECK rejecting oversized writeBufferWithCopy/writeTextureWithCopy payloads. Those were aliased in a no-copy MTLBuffer whose caller-owned storage did not outlive that use, so the buffer could reference freed memory; the sender is now terminated. - [WebGPU BindGroup / RenderBundle] (OOB read)
eae6b25— Fixes a GPU OOB read where reusing an ExternalTexture bind group already recorded in a render bundle rewrote its argument buffer to point at non-resident textures. Reuse is now refused while a bundle consumes the bind group. - [WebGPU BindGroupLayout] (OOB access)
aa64efa— Fixes an OOB access in WebGPU bind group compatibility checks: auto-generated layouts from out-of-scope pipeline layouts used a decayed WeakPtr and compared equal, bypassing validation. Now uses a 64-bit identifier and makes createPipelineLayout reject auto-generated bind group layouts. - [UIProcess WebProcessPool] (validator bypass)
53765cd— Stops trusting renderer-supplied requesterOrigin in the same-site check. A compromised web process could forge a victim origin to skip the process swap and gain first-party cookie access to that site; the check now uses the opener frame URL the UIProcess already tracks. - [WebGPU Buffer] (validator bypass)
26b3c24— Stops index buffers with a recorded but not yet executed copy from skipping drawIndexed range checks, so validation no longer reuses a stale verdict. Before this, a draw recorded while the copy was pending could seed the cache and trigger a GPU OOB read. - [WebKit UIProcess ProvisionalPageProxy] (validator bypass)
ede7f74— Adds an explicit allowlist to the sync IPC dispatcher in ProvisionalPageProxy, matching the async path. Previously a WebContent process holding a provisional page during a process-swap back navigation could reach unallowlisted sync WebPageProxy handlers such as RunJavaScriptAlert on another tab. - [WebKit UIProcess WebPageProxy drag-and-drop] (validator bypass)
612064a— Removes the unused PropagateDragAndDrop IPC receiver that let a compromised WebContent process get sandbox extensions for arbitrary files via untrusted fileNames. Rejects drop target frames from another page, which could route extensions, pasteboard, and drop cross-page. - [JSC CommonSlowPaths] (UAF)
bee8011— Defers GC during the slow-put ArrayStorage allocation in operationNewArrayBuffer's bad-time path. Stops a conservative scan from blackening a fresh array that DFG barrier elision assumes is white; per the commit, this could sweep a reachable object via a barrier-free PutByVal. - [JSC GetByStatus]
d5af1b7— Fixes GetByStatus::computeFor's prototype walk, which skipped the base structure's non-reified static properties and could fold a property load to a shadowing prototype value (e.g. RegExp.input). The same check is added to PutByStatus, PropertyCondition, DFG AbstractInterpreter, and Graph::tryEnsureAbsence. - [JSC DFG IntegerRangeOptimization] (UAF)
41a3299— Fixes a use-after-free in IRO's ArithAbs transform: a raw proof pointer into a relationship Vector could dangle after executeNode() reallocated it, so pinRangeBoundProof() read freed memory. Copies the Relationship by value instead. Regression from 319726@main. - [WebCore style (ValueHandleMap / calc ValueMap)] (race condition)
669e3f1— Adds a WTF lock around ValueMap insert, get, ref, and deref so calc() values shared between the main thread and OffscreenCanvas workers are no longer accessed unsynchronized. Includes a regression test for a worker race crash. - [WebCore FontCascadeFonts] (UAF)
5b951ba— Fixes dangling references in FontCascadeFonts when a font load during fallback or glyph lookup reallocates or prunes the FontRanges vector and glyph-page cache. FontRanges are now heap-allocated, and the glyph-page cache is re-looked up after the callout. - [JSC DFG Spread elimination]
7f7e759— Fixes DFG Spread elimination watchpointing the operand's semantic origin (e.g. a Phi or GetLocal) instead of the iterable's concrete Realm, now checked via AbstractState. Cross-realm and replaced-prototype iterables are exercised by the new tests. - [JSC FTL] (register clobber)
c57b5ce— Declares the FP macro scratch register as clobbered on the FTL GetByVal and GetByValWithThis inline cache patchpoints. Float typed-array IC cases write that scratch via purifyNaN, which could overwrite a live double and produce wrong results without a crash. Adds a stress test. - [JSC Wasm tail calls] (stale register cache)
be384ac— Restores cached linear-memory base and bounds after same-instance Wasm tail calls into JS imports. Previously only cross-instance tail calls got a restore frame, so JS calling memory.grow could leave the cached values stale in BoundsChecking mode. - [JSC Wasm JS-to-Wasm IC] (type confusion)
c983da4— Fixes a stale notCellMaskRegister in the JS-to-Wasm IC entrypoint. The I64 and funcref argument arms skipped tag register materialization, so non-cell JSValues could pass the cell check and be dereferenced. Adds a stress test. - [JSC Wasm BBQ] (race condition)
7fadf12— Hardens BBQ WasmGC array and struct allocation by emitting the publication mutatorFence unconditionally. Previously only ref-typed stores were fenced, so a concurrent marker could decode a recycled cell's stale type and scan leftover bits as pointers.