← All reports
16 picks from 661 commits
2026-10-31 – 11-06

This Week in WebKit — October 31 - November 06, 2026

661
Total commits
63
Security fixes
deep dives: 2 High, 4 Medium; 30 more in the appendix above
133
Contributors
Top components WebCore · WebKit · Platform · Other · JSC

Featured

Notable development

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.