Make Style::Calculation::ValueMap thread-safe
CVE: CVE-2026-112686 · Safari 27.2 · Released October 26, 2026 Impact: 악의적으로 조작된 web content를 처리하면 process가 예기치 않게 종료될 수 있습니다 Apple's description: locking을 개선하여 race condition을 해결했습니다. Credit: 익명의 연구자
Severity는 High이며, 최소한 crash까지는 보장됩니다. worker 4개와 calc() 값을 가진 canvas font만 있으면, 한 thread가 process 전역 hash table을 쓰는 도중에 다른 thread가 rehash를 일으킬 수 있습니다. 다만 renderer crash를 넘어서려면 두 가지 조건이 더 필요합니다. race에서 이겨야 하고, 해제된 table이나 value 자리를 무엇이 재점유하는지도 제어할 수 있어야 합니다. 이번 분석에서는 두 조건 모두 확인되지 않았습니다.
WebKit의 CSS engine은 resolved style value를 작은 정수 handle로 저장해 크기를 줄입니다. 각 handle은 process 전역 side table을 가리키고, 실제 out-of-line 객체는 이 table이 소유합니다. calc()나 min() 표현식의 tree가 대표적인 예입니다. 문제는 이 table, 즉 Style::ValueHandleMap이 style value가 단일 thread에서만 생성·해제된다는 전제 위에 만들어졌다는 점입니다. 그런데 Web Worker 안에서 동작하는 OffscreenCanvas가 등장하면서, 이 전제는 드러나지 않게 깨져 있었습니다.
관전 포인트: 페이지가 worker 몇 개를 띄운 뒤 offscreen canvas에 calc() 계열 font를 반복해서 지정하는 상황을 생각해 볼 수 있습니다. 이 경우 여러 thread가 resize 중인 공유 handle table을 손상시킬 수 있습니다. 안정적으로 얻을 수 있는 결과는 renderer crash입니다. race와 reclaim에서 모두 이긴다면, 이 손상이 heap corruption의 발판으로 이어질 가능성도 있습니다.
Source/WebCore/style/values/primitives/StyleValueHandleMap.h
LayoutTests/sar3/fast/canvas/offscreen-canvas-worker-calc-font-race-crash.html
Patch Details
수정은 header 파일 하나에서 모두 이루어졌습니다. 변경 대상은 calc 전용 파일이 아니라 generic class template인 Style::ValueHandleMap<ValueType>입니다. commit message에는 StyleCalculationValueMap.h와 Calculation::ValueMap이 언급되어 있습니다. 반면 diff가 실제로 수정한 파일은 StyleValueHandleMap.h입니다. Calculation::ValueMap은 이 template의 instantiation 중 하나로 추정됩니다. 점검 관점에서는 이 차이가 중요한데, calc용 instantiation뿐 아니라 template의 모든 instantiation이 같은 lock을 갖게 되기 때문입니다.
구조적으로는 mutable Lock m_lock 멤버가 추가되었습니다. 변경 가능한 상태는 두 가지인데, handle counter인 m_nextAvailableHandle과 HashMap<unsigned, Entry> m_map입니다. 이제 두 멤버 모두 WTF_GUARDED_BY_LOCK(m_lock)로 annotation되어 있습니다. 그 결과 lock을 잡지 않은 채 두 멤버에 접근하는 코드가 앞으로 추가되면, Clang의 thread-safety analysis가 이를 거부합니다. 즉 이 invariant는 문서상의 약속에 그치지 않고, build 시점에 강제되도록 바뀌었습니다.
네 개의 진입점 모두 Locker를 획득하도록 변경되었습니다.
-
insert()는 lock을 획득하기 전에Entry를 생성합니다. 이 과정에서 전달받은Ref<ValueType>가Entry로 넘겨집니다. critical section 안에서는 handle 할당과m_map.add만 실행됩니다. 한편ASSERT(m_nextAvailableHandle)는Locker아래로 이동했는데, counter를 읽는 동작 자체가 이제 guarded access에 해당하기 때문입니다. -
get()은m_map.find(handle)구간을 lock으로 보호합니다. 이 메서드가const이므로 lock은mutable로 선언되었습니다. -
ref()는 entry의++referenceCountMinusOne연산을 lock으로 보호합니다. 이 증가 연산은 atomic이 아니기 때문입니다. -
deref()에서도 감소 연산을 lock으로 감쌌습니다. 마지막 reference를 처리하는 경로 역시 재구성되었는데, 이번 patch에서 가장 미묘한 부분이 바로 여기입니다.
Patch 이전에는 entry를 제거하는 동작이 map이 소유하던 RefPtr<ValueType>을 해제하는 동작이기도 했습니다. 이 과정에서 Calculation::Value가 파괴되고, 이어서 Calculation::Tree 해제 작업이 실행될 수 있습니다. 문제는 이 작업을 새로 추가된 critical section 안에서 수행하면 안전하지 않다는 점입니다. WTF::Lock이 recursive lock이 아니기 때문입니다. 그래서 patch는 entry 안의 RefPtr을 stack local인 valueHold로 옮기도록 변경되었습니다. 이어서 비어 있는 entry를 제거하고 locker.unlockEarly()를 호출합니다. 이후 닫는 중괄호에서 valueHold가 scope를 벗어나면, lock이 해제된 상태에서 teardown이 실행됩니다.
여기서 unlockEarly() 호출은 스타일상의 선택이 아니라 반드시 필요한 처리입니다. valueHold는 locker보다 뒤에 선언되어 있습니다. C++은 local 변수를 선언의 역순으로 파괴하므로, 명시적인 unlock이 없으면 locker가 아직 lock을 쥐고 있는 동안 valueHold가 파괴되는 순서가 됩니다:
Naive locked deref() As landed
─────────────────────────────── ───────────────────────────────────
decl 1: Locker locker{m_lock} decl 1: Locker locker{m_lock}
m_map.remove(it) decl 2: RefPtr valueHold = move(value)
└─ ~RefPtr → ~Value m_map.remove(it) // RefPtr empty
└─ Tree teardown locker.unlockEarly() // lock free
└─ deref() → lock ✗ scope exit (reverse order):
(non-recursive) ~valueHold → Tree teardown, unlocked
~locker → no-op
새로 추가된 layout test는 dedicated worker 4개를 시작합니다. 각 worker는 1×1 크기의 OffscreenCanvas를 생성하고 context.font에 값을 100번 할당합니다. 이때 매번 서로 다른 min(<pct>%, <pct>%) serif 값을 사용합니다. calc() root가 유지되는 할당은 매번 새로운 Calculation::Value를 공유 map에 등록합니다. 결과적으로 네 개의 thread가 동시에 insert()를 반복 호출하고, map은 계속 커지게 됩니다. Process가 종료되지 않고 살아남으면 test는 통과합니다.
Background
Worker와 OffscreenCanvas.
Dedicated Web Worker는 페이지와 같은 renderer(WebContent) process 안에서 별도의 OS thread로 JavaScript를 실행합니다. OffscreenCanvas를 사용하면 worker가 canvas 2D context를 직접 소유할 수 있습니다. 이때 해당 context의 font 속성을 설정하면, CSS font 구문의 파싱과 resolve가 main thread가 아닌 worker thread에서 수행됩니다.
CSS math 값.
calc(), min(), max() 같은 CSS math 함수는 대개 resolve 시점에 하나의 숫자로 접힙니다(fold). 접을 수 없는 경우에는 WebCore가 해당 식을 Style::Calculation::Value로 보관하는데, 이 객체는 내부 expression tree인 Calculation::Tree를 감싸고 있습니다. 접을 수 없는 대표적인 경우는 <length-percentage> context에서 percentage를 섞어 쓰는 상황입니다. 이 context에서는 percentage의 기준값이 아직 정해지지 않았기 때문입니다. Calculation::Value를 파괴하면 이 tree도 함께 해제됩니다. 평범하지만 가볍지는 않은 destructor 작업에 해당합니다.
Handle 기반 style 값.
Style PrimitiveData는 out-of-line 값을 pointer 대신 정수 handle로 저장해 크기를 작게 유지합니다. Style::ValueHandleMap<ValueType>은 이 handle들을 뒷받침하는 타입별 side table입니다. 각 handle은 Entry에 매핑됩니다. Entry는 RefPtr<ValueType>(WebKit의 intrusive refcounting smart pointer)으로 값을 소유하고, handle별 count인 referenceCountMinusOne을 별도로 관리합니다. PrimitiveData를 복사하면 ref(handle)이, 파괴하면 deref(handle)이 호출되며, 값을 읽을 때는 get(handle)이 호출됩니다. 새 handle은 단조 증가하는 m_nextAvailableHandle에서 발급됩니다. 즉 handle의 lifetime은 table의 counter가, 객체의 lifetime은 table 안의 RefPtr이 각각 추적합니다.
Process 전역 singleton.
ValueHandleMap::singleton()은 function-local static NeverDestroyed<ValueHandleMap>을 반환합니다. NeverDestroyed<T>는 처음 사용될 때 한 번 생성되고 이후 절대 파괴되지 않는 객체를 위한 WebKit의 관용 패턴입니다. 따라서 process 안에서 singleton()에 도달하는 모든 thread는 동일한 instance를 얻게 됩니다.
HashMap 확장.
WTF::HashMap은 open-addressing hash table로, 모든 entry가 하나의 연속된 bucket array에 저장됩니다. 삽입으로 load factor가 threshold를 넘으면 map은 rehash를 수행합니다. 먼저 더 큰 bucket array를 할당하고, 모든 entry를 다시 삽입한 뒤, 기존 array를 해제합니다. 마찬가지로 제거 연산에 의해 table이 축소될 수도 있습니다. 다만 HashMap에는 내부 동기화가 없으므로, 여러 thread가 공유하는 map에는 외부 lock이 필요합니다.
Lock과 annotation.
WTF::Lock은 작은 non-recursive mutex입니다. 이미 보유한 lock을 같은 thread가 다시 획득하려 하면 deadlock이 발생합니다. Locker는 이 lock의 RAII guard로, 생성자에서 lock을 획득하고 소멸자에서 해제합니다. Locker::unlockEarly()를 호출하면 guard가 scope를 벗어나기 전에 lock을 해제할 수 있습니다. 한편 WTF_GUARDED_BY_LOCK(lock)은 Clang thread-safety attribute입니다. 지정된 lock을 보유하지 않은 상태에서 annotation이 붙은 멤버에 접근하면 compiler가 경고를 출력합니다.
Analysis
Process 전역에 있는 non-thread-safe hash table과, 그 안에서 수동으로 관리되는 refcount에 대한 data race입니다. 결과적으로 heap corruption과 table backing store에 대한 use-after-free로 이어집니다.
Worker A (context.font = min(1.5%,2.5%)) Worker B (context.font = min(2.5%,3.5%))
───────────────────────────────────────── ─────────────────────────────────────────
insert(): h = m_nextAvailableHandle (=7) insert(): h = m_nextAvailableHandle (=7)
m_nextAvailableHandle = 8 m_nextAvailableHandle = 8
m_map.add(7, entryA) m_map.add(7, entryB) // duplicate handle
load factor exceeded → rehash probing bucket array T0 ...
alloc T1, move entries into T1
free(T0) ──────────────────────────────► write entryB into bucket of T0 ◄── freed
m_map now = T1 (entryB lost) returns handle 7 → points at entryA's value
위 다이어그램에서 두 thread는 lock 없이 같은 singleton에 대해 insert()를 실행합니다. 왼쪽 열의 m_map.add가 load factor threshold를 넘기면, HashMap은 T1을 할당하고 entry를 옮긴 뒤 T0를 해제합니다. 그런데 오른쪽 열은 아직 T0의 bucket을 탐색하거나 기록하는 중이므로, 그 write는 해제된 메모리에 들어가게 됩니다. Regression test 주석에서 언급한 "collide due to rehashing during insertion"이 바로 이 상황입니다. 결과는 interleaving에 따라 달라집니다. Entry가 유실되거나, bucket이 중복·손상되거나, map의 bucket array 크기로 할당되었던 freed allocation에 write가 발생할 수 있습니다. 한편 맨 윗줄에는 이와 독립적인 두 번째 race가 드러나 있습니다. m_nextAvailableHandle++는 동기화되지 않은 read-modify-write이므로, 두 thread가 같은 handle을 받거나 handle 하나를 건너뛸 수 있습니다.
근본에 있는 invariant는 ValueHandleMap에 오직 하나의 thread만 접근한다는 전제입니다. Style resolution이 main thread 작업이던 동안에는 원래 설계가 이 전제 아래에서 올바르게 동작했습니다. 이 전제를 깨뜨린 것이 worker입니다. Test 주석에 따르면, length-percentage context에서 OffscreenCanvas 2D의 font에 min(%, %)를 할당하면 calc() root가 유지됩니다. 그리고 이 root는 insert()를 거쳐 전역 Calculation::Value map에 들어갑니다. 결국 renderer 안에서 JavaScript가 구동하는 여러 thread가 같은 NeverDestroyed instance에 도달하게 되었지만, 이들을 직렬화하는 장치는 없었습니다.
유발하는 데에는 일반적인 web content 외에 아무것도 필요하지 않으며, test 자체가 사실상 PoC 역할을 합니다:
- 페이지가 worker script용 Blob URL을 만들고 dedicated worker 4개를 생성합니다.
- 각 worker가
new OffscreenCanvas(1, 1).getContext('2d')를 생성합니다. - 각 worker가
context.font = 'min(X%, Y%) serif'를 100번 할당합니다. X와 Y를 매번 바꾸므로 모든 값이 서로 달라 새로 등록되어야 합니다. - 각 할당은 worker thread에서 font를 파싱합니다. Percentage끼리 병합될 수 없으므로
Calculation::Value가 생성되고ValueHandleMap::insert()가 실행됩니다. - 네 thread가 공유 map을 반복적으로 확장시키고, 어떤 rehash든 다른 thread의 insert와 겹치는 순간 다이어그램의 race가 발생합니다.
Test가 실제로 유발하는 형태는 insert 대 insert 간의 rehash race입니다. 다만 lifetime bug 관점에서는 refcount 경로가 더 흥미롭습니다. ref()와 deref()는 table entry 안의 referenceCountMinusOne에 대해 단순한 ++/--를 수행합니다. 두 thread가 같은 handle의 count를 동시에 조정하면 update 하나가 유실될 수 있습니다. 증가 연산이 유실되면, 이후의 deref()는 자신이 마지막 reference를 처리한다고 판단하고 entry를 제거합니다. 이때 해당 entry의 RefPtr이 reference를 놓으면서 Calculation::Value가 해제될 수 있습니다. 그런데 다른 곳에 살아 있는 PrimitiveData는 여전히 그 handle을 들고 있습니다. 그 holder가 다음에 get()을 호출하면 해제되었거나 재사용된 slot에 대한 reference가 반환됩니다.
이와 별도로, 한 handle에 대한 ref/deref가 다른 handle의 insert나 remove와 겹칠 수도 있습니다. 그 연산이 table을 rehash하거나 축소하면, find() 결과가 insert race와 동일한 freed backing store window에 놓이게 됩니다. Race가 있는 counter에서 중복 handle이 발급되는 경우도 downstream 결과는 같습니다. 논리적으로 서로 다른 두 값이 하나의 handle을 공유하게 되므로, 잘못된 값이 반환되거나 해제될 수 있습니다.
Fix는 single-writer invariant를 명시적으로 만들어 이를 복원했습니다. 이제 m_map과 m_nextAvailableHandle에 대한 모든 접근은 m_lock 아래에서 이루어지며, compiler가 이를 강제합니다. 그 결과 rehash는 다른 연산에 대해 atomic하게 수행되고, handle 할당은 직렬화되며, refcount update도 더 이상 유실되지 않습니다. 다만 lock을 추가하면서 새로운 위험이 생겼고, deref() 재구성이 이를 처리합니다. WTF::Lock은 non-recursive이므로, critical section 안에서 Calculation::Value를 파괴하면 Calculation::Tree teardown이 같은 singleton의 deref()로 재진입할 가능성이 있습니다. 중첩된 handle 기반 값이 그런 예입니다. 이 경우 release build에서는 deadlock으로, debug build에서는 assert로 이어지게 됩니다. 그래서 마지막 RefPtr을 valueHold로 옮기고 scope 종료 전에 unlockEarly()를 호출합니다. 이렇게 하면 container 변경은 lock 안에서, destructor 작업은 lock 밖에서 수행됩니다.
보안 영향은 전적으로 WebContent process 내부에 머뭅니다. Main thread와 worker thread가 모두 이 process 안에서 실행되기 때문입니다. 안정적으로 얻을 수 있는 결과는 concurrent rehash 중 HashMap 내부 구조가 손상되면서 발생하는 crash입니다. Apple이 밝힌 "unexpected process termination"과도 일치합니다. 그 이상으로 고려할 수 있는 primitive는 두 가지입니다. 하나는 해제된 bucket array allocation에 대한 write이고, 다른 하나는 Calculation::Value에 대한 lifetime 위반입니다.
공격자가 rehash race를 반복적으로 이기고, 해제된 table이나 해제된 Calculation::Value 자리를 무엇이 다시 차지할지 제어할 수 있다고 가정해 볼 수 있습니다. 이 조건이 성립하면 두 primitive 모두 renderer 영역의 heap corruption이나 style value 객체에 대한 UAF로 이어질 가능성이 있습니다. 그런 제어가 없다면 상한은 공격자가 유발할 수 있는 crash 수준입니다. 이 버그만으로는 sandbox 경계를 넘지 못하며, renderer 밖으로 나가려면 별도의 escape가 여전히 필요합니다.
단일 thread를 전제로 만든 process 전역 handle table이 canvas font를 설정하는 모든 worker에서 도달 가능해졌습니다. 그 결과 동시에 실행되는 insert가 서로 사용 중인 table을 rehash해 버릴 수 있습니다.
Insight
Main thread용으로 작성된 subsystem이 worker에 노출되는 상황은 반복적으로 나타나는 위험입니다. OffscreenCanvas는 전통적으로 main thread 코드였던 CSS font 파싱과 style 값 resolve를 worker thread로 끌어옵니다. 그러면 이 경로에 있는 모든 process 전역 cache가 공유 mutable state로 바뀝니다. Interning table, value pool, NeverDestroyed handle map 등이 그 예이며, 해당 파일 자체에는 아무 변경이 없었는데도 조용히 그렇게 됩니다. 이런 버그는 cache의 regression이 아닙니다. 멀리 떨어진 곳에 새로운 호출자가 생기면서 발생하므로, cache의 diff를 review해서는 결코 잡아낼 수 없습니다. WTF_GUARDED_BY_LOCK annotation이 이번 fix에서 가장 오래 남을 부분인 이유가 여기에 있습니다. 다음번의 lock 없는 접근을 또 다른 race가 아니라 compile error로 바꿔 주기 때문입니다.
Audit directions
- Worker 코드에서 도달 가능한 process 전역 cache. Invariant: worker가 실행하는 API에서 도달 가능한
NeverDestroyed/static container는 반드시 동기화되어 있거나 thread-local이어야 합니다. - Narrow:
Source/WebCore/style과Source/WebCore/css에서static NeverDestroyed<와singleton()을 검색하고, 멤버에WTF_GUARDED_BY_LOCK이 없는 경우를 찾습니다. 그다음 worker의OffscreenCanvasfont, filter, color 파싱 경로가 그 대상에 도달할 수 있는지 추적합니다. 식별 신호: non-const 메서드가Locker도,isMainThread()assertion도 없이 변경하는HashMap/HashSet/Vector멤버. - Wider: worker에 노출된 다른 CSS 사용처를 점검합니다. canvas
filter,letterSpacing/wordSpacing, worker 내 color 파싱 등이 대상이며, 이들이 공유하는 font cache나 atom 형태의 interning table도 함께 살펴볼 필요가 있습니다. 식별 신호: 파싱된 CSS 값을 key로 하여 lazy하게 채워지는 cache. -
Widest: 기존 main thread subsystem을 다른 thread로 옮긴 엔진이라면 모두 같은 질문을 마주합니다. Blink의 worker 측 OffscreenCanvas font resolution, Gecko의 parallel style system이 그 예입니다. 옮겨진 코드가 건드리는 전역 cache 각각에 대해, 처음부터 concurrency를 고려해 만들어졌는지, 아니면 단지 이전에 경합이 없었을 뿐인지 확인해야 합니다.
-
Entry 안에 수동 refcount를 둔 handle table. Invariant: non-atomic count와 container 제거가 결합되면, 다른 holder가 아직 handle로 참조 중인 값이 해제될 수 있습니다.
- Narrow: 모든 instantiation에 걸쳐
ValueHandleMap<...>::singleton()의 호출 지점을 나열하고, 모든ref/deref/get이 lock이 걸린 API를 거치는지 확인합니다. 또한get()에서 얻어 보관한ValueType&가, 다른 thread가 마지막 handle을deref할 수 있는 지점을 지나 사용되지 않는지도 확인해야 합니다. Lock은 lookup을 보호할 뿐, 반환된 reference의 lifetime까지 보호하지는 않습니다. 식별 신호:get()결과를 local이나 멤버에 저장한 뒤,PrimitiveData를 해제할 수 있는 호출 이후에 사용하는 코드. - Wider: refcount가 객체가 아니라 table entry에 있는 정수 handle registry를 점검합니다. resource ID, IPC object identifier, GPU handle table 등이 해당됩니다. 식별 신호: lock이나 atomic 밖에서 수행되는
++entry.count또는--entry.count. -
Widest: ECS 엔진의 slab/generational-handle allocator와 JNI 방식의 global-reference table도 같은 lifetime 모델을 공유합니다. Handle 유효성과 값의 lifetime이 같은 atomic 단계에서 갱신되는지 확인할 필요가 있습니다.
-
Drop-under-guard: container의 lock을 쥔 채로 값을 파괴하는 패턴. Invariant: destructor가 container로 재진입할 수 있는 값은 container의 lock이 해제된 뒤에만 파괴되어야 합니다. Non-recursive lock은 self-deadlock을 일으키고, mutation 도중에 lock을 부주의하게 놓으면 container가 일관되지 않은 상태로 남습니다.
- Narrow:
Locker가 살아 있는 동안m_map.remove(...),m_map.take(...),m_map.clear()를 호출하는 WebCore/WTF 코드를 점검합니다. 대상은 mapped type이 non-trivial destructor를 가진 타입에 대한RefPtr/Ref인 경우입니다. Teardown이 같은 객체로 다시 호출될 수 있는지, 그리고valueHold+unlockEarly()관용 패턴이 적용되어 있는지 확인합니다. 식별 신호: 마지막RefPtrdrop이 lock이 걸린 scope 안에서 발생하는 경우이며, local 변수의 역순 파괴를 통해 암묵적으로 발생하는 경우도 포함합니다. - Wider: lock 아래에서 호출되는
HashMap::clear(),std::unique_ptr값의 destructor, 제거 시 callback을 유발하는 observer list에서도 같은 위험이 나타납니다. - Widest: 일반적인 drop-under-guard 버그 클래스에 해당합니다. WebKit 밖의 예로는 critical section 안에서
Arc가 drop되는 Rust의Mutexguard, 그리고 JavaConcurrentHashMap.computeIfAbsent의 recursive-update 실패가 있습니다. 이들 모두 container를 보호하는 lock이 해제된 뒤에만 값을 파괴해야 한다는 규칙을 공유합니다.