
CVE-2026-126912: heap buffer overflow nel convertitore di scansione dei percorsi convessi di Skia. Laboratorio ASAN differenziale più un controllo di rendering tra Chrome 157.0.8103.50 e .78.
Una pagina web può disegnare una sola forma e far sì che Skia scriva al di fuori di un buffer heap. La forma è un percorso convesso che supera il bordo destro della tela. Non serve altro: nessuna estensione, nessun permesso, nessun input dell'utente oltre all'apertura della pagina. Chrome ha distribuito la correzione l'11 novembre 2026 in 157.0.8103.78, tre giorni prima di questo write-up.
La scrittura è piccola, due byte, e finisce otto byte prima dell'inizio del run buffer dello scan converter. Si tratta di un heap-buffer-overflow nel rasterizzatore attraverso cui passa ogni riempimento convesso antialiased, quindi si trova sotto SVG, CSS clip-path e canvas 2D allo stesso modo.
Classe: Heap buffer overflow (scrittura out-of-bounds) Raggiungibilità: Remota, contenuto web appositamente costruito
Skia 3715fe5ff9 (vulnerabile) vs 866b61ca92 (corretto) - Skia
CVE-2026-126912 è una delle 83 correzioni in Chrome stable 157.0.8103.78. Google la classifica come High e mantiene riservata la issue Chromium 569286603. Il commit di correzione è pubblico e nomina i quattro difetti in ordine, il che è sufficiente per ricostruire il trigger.
| ID | CVE-2026-126912 |
| Classe | Heap buffer overflow (CWE-122) |
| Raggiungibilità | Remota (contenuto web appositamente costruito, l'utente apre la pagina) |
| 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 |
| Prodotto | Skia, Google Chrome |
| Affetto | Chrome precedente a 157.0.8103.78; derivati Chromium e build WebKitGTK che usano Skia |
| Corretto | Chrome 157.0.8103.78, Skia 866b61ca92 (11 nov 2026) |
| Valutazione Chrome | High |
| Auth | nessuna |
| Licenza | GNU Affero GPL v3.0 |
| Lab | solo locale, macOS arm64 |
| Metodo | Sink | Risultato |
|---|---|---|
Una singola drawPath di un percorso convesso ritagliato sul bordo destro, antialiased | aaa_walk_convex_edges -> RunBasedAdditiveBlitter::blitAntiH -> SkAlphaRuns::Break | Dimostrato in laboratorio: scrittura di due byte sotto il run buffer, ASAN heap-buffer-overflow |
| La stessa pagina in un browser | percorso di rasterizzazione del renderer | Dimostrato in laboratorio: Chrome 157.0.8103.50 lascia il pixel in basso a destra a #00000080 dove 157.0.8103.78 restituisce #000000ff |
| Heap grooming attorno al run buffer | chunk adiacente controllato dall'attaccante | Non tentato qui. Chrome tratta questo come un bug del renderer di gravità High; una catena di control-flow è un lavoro separato |
| Sandbox escape | dal renderer al processo browser | Fuori ambito per questo pacchetto. Il punteggio 9.6 presuppone un cambio di scope; questo laboratorio si ferma alla corruzione di memoria |
Il bug è nel renderer, quindi una catena riuscita atterrerebbe all'interno della sandbox. Si tratta comunque di una primitiva completa di lettura/scrittura sull'heap del renderer, che è il punto di partenza da cui ogni catena di sfruttamento del browser vuole iniziare.
Quattro cose si allineano, tutte nella gestione da parte del rasterizzatore di un percorso convesso che supera il bordo destro del clip.
SkEdgeBuilder::combineVertical unisce i bordi verticali con avvolgimento opposto che
condividono un intervallo Y. Sul confine di clip destro tale unione è valida solo quando
il builder può eseguire il culling verso destra. I percorsi convessi non possono, perché i walker
convessi necessitano sia di un bordo sinistro sia di un bordo destro su ogni scanline. Quando un segmento di curva con X invertita separa due segmenti verticali con lo stesso avvolgimento,
l'unione annulla il bordo destro e lascia una banda di scanline priva di bordo
destro.aaa_walk_convex_edges adotta quindi il bordo successivo senza avanzare y a
max(y, leftE->fUpperY, riteE->fUpperY). Il nuovo bordo viene valutato a una y
molto superiore al proprio fUpperY, e l'aritmetica in virgola fissa in
SkAnalyticEdge::goY va in overflow sul SkFixed a 32 bit.RunBasedAdditiveBlitter::blitAntiH limita len alla larghezza della superficie ma
non rifiuta mai una lunghezza non positiva, e la passa a SkAlphaRuns::add.
SkAlphaRuns::Break scrive al di sotto dell'inizio del buffer dei run.La correzione consiste in queste quattro protezioni, più l'aritmetica saturante in goY e
Sk32_sat_add / Sk64_pin_to_s32 per l'avanzamento dei bordi. Tutto è racchiuso dietro
#if !defined(SK_LEGACY_ALPHA_RUNS), quindi una build che definisce
SK_LEGACY_ALPHA_RUNS mantiene il vecchio comportamento. Lo stesso commit aggiunge
tests/RasterizationTests.cpp con la geometria usata qui.
Due stadi, entrambi differenziali.
Lo stadio 1 compila il genitore vulnerabile della correzione e la correzione stessa con ASAN, quindi disegna il percorso su una superficie raster in entrambi. La build vulnerabile segnala l'overflow, la build corretta non segnala nulla e copre il pixel che il test upstream verifica.
Lo stadio 2 carica la stessa geometria in due build headless di Chrome for Testing,
157.0.8103.50 e 157.0.8103.78, e rilegge il pixel di prova. Nessun crash,
nessun sanitizer, solo una pagina che renderizza un pixel in modo diverso a seconda che
il walker abbia perso o meno il suo bordo destro.
./skia-convex-oob-Abraxas-Labs.py
oppure esegui direttamente il laboratorio:
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
La prima esecuzione clona Skia, recupera le sue dipendenze di terze parti e compila due alberi ASAN. Sono circa 12 GB di disco e da 15 a 20 minuti su una macchina a 10 core. Le esecuzioni successive riutilizzano gli alberi. L'host deve essere macOS arm64, perché l'harness collega Skia ai framework Apple.
run.sh stampa SUCCESS o FAIL e scrive poc-last-run.txt.
| File | Scopo |
|---|---|
lab/poc.cpp | Harness Skia, disegna il percorso su una superficie raster, riporta il pixel dell'angolo |
lab/poc.html | Riproduzione nel browser, canvas 2D più varianti SVG e CSS clip-path |
lab/build-skia.sh | clona Skia, compila le revisioni vulnerabile e corretta con ASAN |
lab/run.sh | esegue entrambe le fasi e verifica il differenziale |
Il percorso è composto da cinque punti su una superficie 300x300:
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
Skia vulnerabile con 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
Scopri gli strumenti più utilizzati dalla nostra community.
Nessun dato di popolarità ancora.