← All reports

Make Style::Calculation::ValueMap thread-safe

HighWebCore Style value system (Race

CVE: CVE-2026-112686 · Safari 27.2 · Released October 26, 2026 Impact: 악의적으로 조작된 web content를 처리하면 process가 예기치 않게 종료될 수 있습니다 Apple's description: locking을 개선하여 race condition을 해결했습니다. Credit: 익명의 연구자

Severity: High | Component: WebCore Style value system (Style::ValueHandleMap) | 669e3f1 | Bugzilla 323986

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

@@ -26,6 +26,7 @@
#pragma once
 
#include <wtf/HashMap.h>
+#include <wtf/Lock.h>
#include <wtf/NeverDestroyed.h>
 
namespace WebCore {
@@ -62,15 +63,16 @@ template<typename ValueType> class ValueHandleMap {
}
};
 
- unsigned m_nextAvailableHandle { 1 };
 
- HashMap<unsigned, Entry> m_map;
+ mutable Lock m_lock;
+ unsigned m_nextAvailableHandle WTF_GUARDED_BY_LOCK(m_lock) { 1 };
+ HashMap<unsigned, Entry> m_map WTF_GUARDED_BY_LOCK(m_lock);
};
 
template<typename ValueType> unsigned ValueHandleMap<ValueType>::insert(Ref<ValueType>&& value)
{
 
- ASSERT(m_nextAvailableHandle);
-
Entry entry(WTF::move(value));
+ Locker locker { m_lock };
+ ASSERT(m_nextAvailableHandle);
 
// FIXME: 단조 증가하는 현재 handle 생성 방식은 handle 공간을 낭비할 가능성이 있습니다.
// 비어 있는 handle의 재사용을 고려해야 합니다. https://bugs.webkit.org/show_bug.cgi?id=80489
@@ -83,14 +85,15 @@ template<typename ValueType> unsigned ValueHandleMap<ValueType>::insert(Ref<Valu
// HashMap 조회는 NoDeleteChecker가 모델링하지 않지만, 어떤 객체도 파괴하지 않습니다.
template<typename ValueType> NODELETE SUPPRESS_NODELETE ValueType& ValueHandleMap<ValueType>::get(unsigned handle) const
{
+ Locker locker { m_lock };
auto entry = m_map.find(handle);
ASSERT(entry != m_map.end());
-
return *entry->value.value;
}
 
template<typename ValueType> void ValueHandleMap<ValueType>::ref(unsigned handle)
{
+ Locker locker { m_lock };
ASSERT(m_map.contains(handle));
 
++m_map.find(handle)->value.referenceCountMinusOne;
@@ -98,6 +101,7 @@ template<typename ValueType> void ValueHandleMap<ValueType>::ref(unsigned handle
 
template<typename ValueType> void ValueHandleMap<ValueType>::deref(unsigned handle)
{
+ Locker locker { m_lock };
ASSERT(m_map.contains(handle));
 
auto it = m_map.find(handle);
@@ -106,7 +110,11 @@ template<typename ValueType> void ValueHandleMap<ValueType>::deref(unsigned hand
return;
}
 
+ RefPtr<ValueType> valueHold = WTF::move(it->value.value);
m_map.remove(it);
+ locker.unlockEarly();
+ // Calculation::Value 파괴 과정에서 임의의 `Calculation::Tree` teardown이 실행될 수 있으므로,
+ // 마지막 reference(valueHold)는 unlock 이후에 해제합니다.
}

LayoutTests/sar3/fast/canvas/offscreen-canvas-worker-calc-font-race-crash.html

@@ -0,0 +1,33 @@
+// calc() root가 유지되는 calc()를 `font`에 지정하면 — 예를 들어 `simplifyForMinMax`는
+// <length-percentage> context에서 percentage 병합을 거부합니다 — process 전역 map에
+// `Style::Calculation::Value`가 등록됩니다. 여러 worker에서 동시에 이 작업을 수행하면
+// 삽입 중 발생하는 rehash 때문에 충돌이 생길 수 있습니다.
+const workerSource = `
+const context = new OffscreenCanvas(1, 1).getContext('2d');
+for (let i = 0; i < 100; ++i)
+ context.font = 'min(' + (i % 90 + 1.5) + '%, ' + (i % 70 + 2.5) + '%) serif';
+self.postMessage('done');
+`;
+
+const workerURL = URL.createObjectURL(new Blob([workerSource], { type: 'text/javascript' }));
+const workerCount = 4;
+let finishedCount = 0;
+
+for (let i = 0; i < workerCount; ++i) {
+ const worker = new Worker(workerURL);
+ ...
+}

수정은 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를 획득하도록 변경되었습니다.

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는 통과합니다.

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가 경고를 출력합니다.

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 역할을 합니다:

  1. 페이지가 worker script용 Blob URL을 만들고 dedicated worker 4개를 생성합니다.
  2. 각 worker가 new OffscreenCanvas(1, 1).getContext('2d')를 생성합니다.
  3. 각 worker가 context.font = 'min(X%, Y%) serif'를 100번 할당합니다. X와 Y를 매번 바꾸므로 모든 값이 서로 달라 새로 등록되어야 합니다.
  4. 각 할당은 worker thread에서 font를 파싱합니다. Percentage끼리 병합될 수 없으므로 Calculation::Value가 생성되고 ValueHandleMap::insert()가 실행됩니다.
  5. 네 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해 버릴 수 있습니다.

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로 바꿔 주기 때문입니다.