
CVE-2026-126912: heap buffer overflow in Skia's convex-path scan converter. Differential ASAN lab plus a Chrome 157.0.8103.50 vs .78 render check.
A web page can draw one shape and make Skia write outside a heap buffer. The
shape is a convex path that runs past the right edge of the canvas. Nothing
else is needed: no extension, no permission, no user input beyond opening the
page. Chrome shipped the fix on 11 November 2026 in 157.0.8103.78, three
days before this write-up.
The write is small, two bytes, and it lands eight bytes before the start of the
scan converter's run buffer. That is a heap-buffer-overflow in the rasteriser
that every antialiased convex fill goes through, so it sits under SVG, CSS
clip-path, and canvas 2D alike.
Class: Heap buffer overflow (out-of-bounds write) Reach: Remote, crafted web content
Skia 3715fe5ff9 (vulnerable) vs 866b61ca92 (fixed) - Skia
CVE-2026-126912 is one of the 83 fixes in Chrome stable 157.0.8103.78. Google
rates it High and keeps Chromium issue 569286603 restricted. The fix commit is
public, and it names the four defects in order, which is enough to rebuild the
trigger.
| ID | CVE-2026-126912 |
| Class | Heap buffer overflow (CWE-122) |
| Reach | Remote (crafted web content, user opens the page) |
| CVSS | 9.6 CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H (cve.org); 8.8 Red Hat |
| Product | Skia, Google Chrome |
| Affected | Chrome before 157.0.8103.78; Chromium derivatives and WebKitGTK builds that use Skia |
| Fixed | Chrome 157.0.8103.78, Skia 866b61ca92 (11 Nov 2026) |
| Chrome rating | High |
| Auth | none |
| License | GNU Affero GPL v3.0 |
| Lab | local only, macOS arm64 |
| Method | Sink | Result |
|---|---|---|
One drawPath of a convex path clipped on the right edge, antialiased | aaa_walk_convex_edges -> RunBasedAdditiveBlitter::blitAntiH -> SkAlphaRuns::Break | Lab-proven: two-byte write below the run buffer, ASAN heap-buffer-overflow |
| Same page in a browser | renderer raster path | Lab-proven: Chrome 157.0.8103.50 leaves the bottom-right pixel at #00000080 where 157.0.8103.78 gives #000000ff |
| Heap grooming around the run buffer | attacker-controlled adjacent chunk | Not attempted here. Chrome treats this as a High severity renderer bug; a control-flow chain is separate work |
| Sandbox escape | renderer to browser process | Out of scope for this pack. The 9.6 score assumes scope change; this lab stops at memory corruption |
The bug is in the renderer, so a successful chain would land inside the sandbox. That is still a full read/write primitive over the renderer heap, which is the position every browser exploitation chain wants to start from.
Four things line up, all in the rasteriser's handling of a convex path that runs past the right clip edge.
SkEdgeBuilder::combineVertical merges opposite-winding vertical edges that
share a Y range. On the right clip boundary that merge is only valid when
the builder may cull to the right. Convex paths may not, because the convex
walkers need both a left and a right edge on every scanline. When an
X-reversed curve segment separates two same-winding vertical segments, the
merge cancels the right edge and leaves a band of scanlines with no right
edge at all.aaa_walk_convex_edges then adopts the next edge without advancing y to
max(y, leftE->fUpperY, riteE->fUpperY). The new edge is evaluated at a y
far above its own fUpperY, and the fixed-point arithmetic in
SkAnalyticEdge::goY overflows 32-bit SkFixed.RunBasedAdditiveBlitter::blitAntiH clamps len to the surface width but
never rejects a non-positive length, and passes it to SkAlphaRuns::add.
SkAlphaRuns::Break writes below the start of the run buffer.The fix is those four guards, plus saturating arithmetic in goY and
Sk32_sat_add / Sk64_pin_to_s32 for the edge advance. All of it sits behind
#if !defined(SK_LEGACY_ALPHA_RUNS), so a build that defines
SK_LEGACY_ALPHA_RUNS keeps the old behaviour. The same commit adds
tests/RasterizationTests.cpp with the geometry used here.
Two stages, both differential.
Stage 1 builds the vulnerable parent of the fix and the fix itself with ASAN, then draws the path on a raster surface in both. The vulnerable build reports the overflow, the fixed build reports nothing and covers the pixel the upstream test asserts.
Stage 2 loads the same geometry in two Chrome for Testing headless builds,
157.0.8103.50 and 157.0.8103.78, and reads back the probe pixel. No crash,
no sanitizer, just a page that renders a pixel differently depending on whether
the walker lost its right edge.
./skia-convex-oob-Abraxas-Labs.py
or run the lab directly:
cd lab
./run.sh # both stages
SKIP_CHROME=1 ./run.sh # ASAN stage only, no Chrome download
WORK=/tmp/foo ./run.sh # separate build tree
First run clones Skia, fetches its third-party deps and builds two ASAN trees. That is about 12 GB of disk and 15 to 20 minutes on a 10-core machine. Later runs reuse the trees. The host must be macOS arm64, because the harness links Skia against the Apple frameworks.
run.sh prints SUCCESS or FAIL and writes poc-last-run.txt.
| File | Purpose |
|---|---|
lab/poc.cpp | Skia harness, draws the path on a raster surface, reports the corner pixel |
lab/poc.html | browser repro, canvas 2D plus SVG and CSS clip-path variants |
lab/build-skia.sh | clones Skia, builds vulnerable and fixed revisions with ASAN |
lab/run.sh | runs both stages and asserts the differential |
The path is five points on a 300x300 surface:
moveTo(161564.5, 20.75)
lineTo(41564.5, 40.75)
quadTo(20784.5, 170.625, 4.5, 300.5)
lineTo(160004.5, 40.75)
close
Vulnerable Skia with ASAN:
ERROR: AddressSanitizer: heap-buffer-overflow on address 0x618000000478
WRITE of size 2 at 0x618000000478 thread T0
#0 SkAlphaRuns::Break(short*, unsigned char*, int, int) SkAlphaRuns.h:161
#1 RunBasedAdditiveBlitter::blitAntiH(int, int, unsigned char const*, int) SkScan_AAAPath.cpp:419
#2 blit_aaa_trapezoid_row(...) SkScan_AAAPath.cpp:797
#3 blit_trapezoid_row(...) SkScan_AAAPath.cpp:872
#4 aaa_fill_path(...) SkScan_AAAPath.cpp:1684
0x618000000478 is located 8 bytes before 892-byte region [0x618000000480,0x6180000007fc)
allocated by thread T0 here:
#0 malloc
#1 sk_malloc_flags(unsigned long, unsigned int) SkMemory_malloc.cpp:109
#2 SkBlitter::allocBlitMemory(unsigned long) SkBlitter.h:138
#3 RunBasedAdditiveBlitter::RunBasedAdditiveBlitter(...) SkScan_AAAPath.cpp:395
Fixed Skia, same harness: no sanitizer output, done br=ff000000 tl=00000000.
Browser stage:
157.0.8103.50 br=#00000080 tl=#00000000 verdict=missing
157.0.8103.78 br=#000000ff tl=#00000000 verdict=covered
Lab result:
SUCCESS CVE-2026-126912 vuln=heap-buffer-overflow fixed=clean chrome=br=#00000080/br=#000000ff CVE-2026-126912-SKIA-OOB-WITNESS
Update to Chrome 157.0.8103.78 or later, or any Chromium derivative built
after Skia 866b61ca92. For WebKitGTK and other Skia consumers, check the
distribution's build. There is no configuration workaround: the defect is in
the scan converter, and the guard has to be compiled in.