← All reports

[2] Collector thread outlives its heap during JSC VM teardown

MediumJSC Heap / CollectorUAF

JSC's collector said goodbye to its heap, then kept working on it

eaf0efa

Medium. 실제로는 crash이고, 원론적으로는 UAF에 해당합니다. 흔한 interleaving에서는 항상 동일한 RELEASE_ASSERT로 끝납니다. 더 드문 경로에서는 작은 GC 내부 timer를 건드리게 되는데, 이 timer에는 attacker가 제어하는 field가 없습니다. 그 이상으로 확장하려면 race에서 이기는 것과 해당 slot의 재점유가 모두 필요합니다.

멀티스레드 엔진에서 GC heap을 안전하게 해제하려면 한 가지 조건이 필요합니다. heap의 멤버가 파괴되기 전에, 그 heap에서 작업하던 모든 helper thread가 멈춰 있어야 합니다. JSC에서 각 Heap(VM마다 하나씩 존재하며 모든 GC 상태를 소유하는 객체)은 로컬 Collector를 가집니다. Collector는 전용 collector thread를 실행하는 helper 객체입니다. debug option이 켜져 있으면 collect-continuously thread도 하나 더 실행합니다. 기대되는 동작은 명확합니다. Heap::shutDown()이 반환된 뒤에는 어떤 collector thread도 heap 멤버를 건드리지 않아야 합니다. StopIfNecessaryTimer도 그런 멤버 중 하나로, mutator thread에게 GC를 위해 멈추라고 알리는 heap 소유 timer입니다.

관전 포인트: concurrent GC가 동작하는 상태에서 worker를 반복적으로 시작하고 종료하는 페이지를 가정할 수 있습니다. 이 경우 worker VM의 teardown과 그 VM 자신의 collector thread 사이에 race가 발생할 가능성이 있습니다. 이 race는 renderer crash로 이어집니다. 더 드문 interleaving에서는 이미 해제된 StopIfNecessaryTimer를 건드리게 됩니다.

Commit message에 따르면 Heap::shutDown()은 heap의 Leave request가 처리될 때까지만 대기합니다. 문제는 이 처리가 collector thread가 m_stopIfNecessaryTimer->scheduleSoon()에서 반환되기 전에 끝날 수 있다는 점입니다.

  1. collector thread가 collection을 진행하던 중 Heap::stopTheMutator()를 호출합니다. 이때 mutator가 heap access를 보유하고 있으므로, collector thread는 mutator를 멈추는 대신 mutatorHasConnBit를 설정해 conn을 넘깁니다.
  2. mutator thread는 waitForCollector() 안에서 자신이 conn을 가졌음을 확인합니다. 이어서 collection을 마치고 자신의 Leave request를 처리합니다.
  3. 그 시점에 collector thread는 아직 m_stopIfNecessaryTimer->scheduleSoon()에서 반환되지 않은 상태입니다. 이 함수는 Heap state를 사용합니다.
  4. Commit message에 따르면 mutator는 이후 ~VM을 진행하며, 이 과정에서 VM이 JSRunLoopTimer::Manager에서 unregister됩니다. 또한 ~Heap은 m_localCollector보다 m_stopIfNecessaryTimer를 먼저 파괴합니다. 결과적으로 ~Collector가 collector thread를 join하는 시점은 이미 늦습니다.
  5. collector thread는 해제된 m_stopIfNecessaryTimer에 접근하게 됩니다. 또는 VM이 이미 unregister되었기 때문에 JSRunLoopTimer::Manager::scheduleTimer()의 RELEASE_ASSERT에 걸립니다.

Commit message에 따르면 이전에 존재하던 join은 323479@main에서 제거되었습니다. 그 이전에는 Heap::shutDown()이 무엇이든 해제하기 전에 collector thread를 먼저 join했습니다. 이번 commit은 이 동작을 되살렸습니다. Collector::shutDown()이 collect-continuously thread와 collector thread를 멈추고, Heap::shutDown()은 로컬 Collector에 대해 leave 직후 이 함수를 호출합니다. ~Collector는 더 이상 thread를 직접 멈추지 않습니다. 대신 thread가 이미 멈춰 있다는 사실을 assert합니다. 한편 --useGlobalGC=true 경우는 여전히 수정이 필요합니다. 여러 heap의 mutator를 어떻게 멈출지가 먼저 정해져야 하기 때문입니다. 이번 commit이 수정한 범위는 로컬 Collector(--useGlobalGC=false) 경우입니다.

Source/JavaScriptCore/heap/Heap.cpp

dataLogIf(Options::logGC(), "left the collector, ");
}
 
+ if (m_localCollector) {
+ m_localCollector->shutDown();
+ dataLogIf(Options::logGC(), "stopped the collector's threads, ");
+ }
+
if (Options::dumpHeapStatisticsAtVMDestruction()) [[unlikely]]

Source/JavaScriptCore/heap/Collector.cpp

Collector::~Collector()
{
 
- ASSERT(m_heaps.isEmpty());
+ RELEASE_ASSERT(m_heaps.isEmpty());
+ RELEASE_ASSERT(!m_collectContinuouslyThread);
+ {
+ Locker locker { *m_threadLock };
+ RELEASE_ASSERT(m_threadShouldStop);
+ }
+ m_raceMarkStack->clear();
+}
+
+void Collector::shutDown()
+{
stopCollectingContinuously();
stopThread();
 
- m_raceMarkStack->clear();
}
...
void Collector::stopCollectingContinuously()
RefPtr { m_collectContinuouslyThread }->waitForCompletion();
+ m_collectContinuouslyThread = nullptr;
}

JSTests/stress/many-agents-teardown.js

+//@ runDefault("--collectContinuously=1", "--collectContinuouslyPeriodMS=0.1")
+for (let i = 0; i < rootAgents; i++)
+ $.agent.start(rootSource); // 각 root가 setTimeout을 queue하는 leaf agent를 최대 32개까지 시작

Collector.cpp에서는 기존 Collector::~Collector()의 본문이 새 public 함수 Collector::shutDown()으로 옮겨졌습니다. 옮겨진 본문은 stopCollectingContinuously()에 이어 stopThread()를 호출하는 코드이며, 새 함수는 Collector.h에 선언되었습니다. destructor는 더 이상 아무것도 멈추지 않습니다. 대신 세 개의 RELEASE_ASSERT가 추가되었습니다. debug ASSERT에서 격상된 m_heaps.isEmpty(), !m_collectContinuouslyThread, 그리고 m_threadLock 아래에서 확인하는 m_threadShouldStop입니다. m_raceMarkStack->clear()는 destructor에 그대로 남았습니다. stopCollectingContinuously()는 이제 waitForCompletion() 이후 m_collectContinuouslyThread를 null로 설정합니다. 두 번째 assertion이 성립하는 것도 이 변경 덕분입니다. stopThread()는 CollectorThread를 멈추며, tryStop(locker)가 실패한 경우에만 m_thread->join()으로 fallback합니다.

Heap.cpp에서는 Heap::shutDown()이 Leave membership change가 처리된 직후 m_localCollector->shutDown()을 호출하도록 변경되었습니다. m_localCollector가 null이면 이 호출은 건너뛰며, --useGlobalGC=true 설정이 여기에 해당합니다. 새로 추가된 stress test는 16개의 root agent를 생성합니다. 각 root agent는 최대 32개의 leaf agent를 시작하고, leaf agent는 각각 50개의 setTimeout을 queue합니다. 모든 실행은 --collectContinuously=1 --collectContinuouslyPeriodMS=0.1 조건에서 이뤄집니다.

Worker thread의 protocol 수준 acknowledgement를 thread 정지의 증거로 간주한 결과, owner의 teardown이 worker가 아직 실행 중인 state를 파괴하는 패턴.

VM, heap, agent. JSC의 각 VM은 정확히 하나의 Heap을 소유합니다. jsc shell에서는 $.agent.start()가 별도의 agent를 생성하며, 이 agent는 자신의 thread 위에서 자신의 VM을 가집니다. 브라우저에서도 마찬가지로 Web Worker마다 고유한 VM이 존재합니다. 이 VM은 worker 시작 시 생성되고 종료 시 파괴됩니다.

Local collector와 global collector. 로컬 Collector(--useGlobalGC=false) 설정에서는 각 Heap이 자신만의 m_localCollector를 가집니다. 이 Collector는 CollectorThread를 소유합니다. CollectorThread는 AutomaticThread의 일종으로, m_threadLock을 잡은 상태에서 m_threadShouldStop과 shouldCollectInCollectorThread()를 polling합니다. Options::collectContinuously()가 설정되어 있으면 m_collectContinuouslyThread도 추가로 소유합니다. 반면 --useGlobalGC=true에서는 파괴되지 않는 단일 Collector::globalCollector()가 모든 heap을 담당합니다.

Conn. JSC의 concurrent GC는 conn이라는 token으로 현재 collection phase를 어느 thread가 진행할지 결정합니다. 그 주체는 collector thread일 수도, mutator일 수도 있습니다. collector가 heap access를 보유한 mutator를 멈춰야 하는 경우, conn을 해당 mutator에게 넘길 수 있습니다. 그러면 mutator가 waitForCollector() 안에서 collection을 직접 진행합니다. 이 handoff가 존재하는 이유는 명확합니다. heap access를 보유한 채 바쁜 mutator가 block되지 않고 GC를 진척시킬 수 있게 하기 위해서입니다.

Membership change. Heap은 requestMembershipChange()에 Kind::Join 또는 Kind::Leave를 전달해 Collector에 합류하거나 이탈합니다. 이 변경은 다음 collection을 진행하는 thread가 collection 사이에 적용합니다.

JSRunLoopTimer::Manager와 StopIfNecessaryTimer. JSRunLoopTimer::Manager는 process 전역 singleton으로, 각 VM의 JSLock을 PerVMData에 mapping합니다. PerVMData는 RunLoop::Timer 하나와 Ref<JSRunLoopTimer> vector를 보관합니다. registerVM/unregisterVM이 이 entry를 추가하고 제거합니다. scheduleTimer()는 entry가 존재함을 RELEASE_ASSERT로 확인하지만, cancelTimer()는 entry가 없어도 허용합니다. StopIfNecessaryTimer는 heap이 소유하는 JSRunLoopTimer subclass입니다. 이 timer의 scheduleSoon()은 timer를 armed 상태로 만들고, 그러면 mutator thread가 곧 heap.stopIfNecessary()를 호출하게 됩니다. JSRunLoopTimer는 ThreadSafeRefCounted입니다.

C++ 멤버 파괴 순서. non-static data member는 선언의 역순으로 파괴됩니다. 즉 나중에 선언된 멤버의 destructor가 먼저 선언된 멤버의 destructor보다 먼저 실행됩니다.

teardown 순서에서 발생하는 race입니다. interleaving에 따라 결과가 갈리는데, 한쪽은 항상 동일한 RELEASE_ASSERT로, 다른 쪽은 use-after-free로 끝납니다.

  Collector thread                     Mutator thread (agent VM)
  ────────────────                     ─────────────────────────
  stopTheMutator(): mutator holds
  heap access, set mutatorHasConnBit ──► waitForCollector(): owns conn
                                         finishes collection
                                         processes own Leave
                                         Heap::shutDown() returns
  m_stopIfNecessaryTimer                 ~VM: Manager::unregisterVM()
    ->scheduleSoon()  ◄── window ──►     ~Heap: m_stopIfNecessaryTimer dropped
    ├─ timer alive: scheduleTimer()      ~Heap: m_localCollector destroyed
    │  RELEASE_ASSERT (VM gone)            └─► ~Collector stops thread (too late)
    └─ timer freed: UAF reads

메커니즘은 commit message의 설명을 따르며, conn handoff 부분은 Collector.h API와도 일치합니다. 왼쪽 열에서 collector thread는 collection 도중 mutator를 멈추기로 결정합니다. mutator가 heap access를 보유하고 있으므로 collector는 conn을 넘기고, 이어서 scheduleSoon()을 호출합니다. 오른쪽 열에서는 conn을 넘겨받은 mutator가 collection을 직접 마치고 자신의 Leave를 적용합니다. Heap::shutDown() 입장에서는 Leave가 처리되었으므로 반환합니다. 문제는 collector thread가 아직 scheduleSoon()을 빠져나오지 않았다는 점입니다. handshake는 그 thread가 어디에 있는지에 대해 아무 정보도 주지 않았습니다.

이후 mutator는 ~VM을 진행합니다. 여기서 JSRunLoopTimer::Manager::unregisterVM()이 호출되고, VM의 PerVMData가 m_mapping에서 삭제됩니다. 이 entry가 삭제되면 data.timers에 들어 있던 Ref<JSRunLoopTimer>도 함께 해제됩니다. 그 결과 ~Heap이 가진 reference가 마지막 reference가 된다고 보는 해석과 들어맞습니다. Commit message에 따르면 m_stopIfNecessaryTimer는 m_localCollector보다 먼저 파괴됩니다. 결과적으로 남아 있는 유일한 thread 정지 지점인 ~Collector는 timer가 사라진 뒤에야 실행됩니다.

Commit message에 따르면 323479@main 이전에는 Heap::shutDown()이 무엇이든 해제하기 전에 collector thread를 join했습니다. 이 early join이 제거되면서 ~Collector가 유일한 정지 지점으로 남았습니다. 그리고 멤버 선언 순서 때문에 이 정지는 timer 파괴 이후로 밀려났습니다.

아직 실행 중인 collector thread가 무엇에 부딪히는지는 window 안에서의 위치에 따라 달라집니다.

stress test는 이 상황을 압축해 재현합니다.

  1. --collectContinuously=1 --collectContinuouslyPeriodMS=0.1로 실행합니다. 그러면 모든 heap의 collector가 거의 항상 collection 도중 상태에 놓입니다.
  2. 16개의 root agent를 시작하고, 각 root는 최대 32개의 leaf agent를 시작합니다. 결과적으로 수백 개의 독립적인 VM이 생성됩니다.
  3. 각 leaf는 50개의 setTimeout을 queue합니다. 덕분에 collection이 발생할 만큼 충분히 오래 실행된 뒤 종료하며, collector thread가 바쁜 동안 VM을 teardown합니다.
  4. 수백 번의 teardown 중 일부는 conn handoff window에 걸려 assertion에 도달합니다. 수정 이후에는 Collector::shutDown()이 어떤 멤버보다도 먼저 두 thread를 멈춥니다.

발견 경위도 이 형태와 맞아떨어집니다. stress testing이나 fuzzing에서 scheduleTimer()의 RELEASE_ASSERT가 crash로 드러났다고 가정할 수 있습니다. 이어서 root cause를 추적해 323479@main regression에 도달했다면, 바로 이런 형태의 many-agents test가 나왔을 것으로 볼 수 있습니다.

Exploitability 측면에서는 먼저 하나의 조건이 필요합니다. 로컬 Collector/membership change refactor가 브라우저 빌드에 포함되어 출시되었어야 합니다. 이 조건이 성립한다면 concurrent GC 환경에서 Worker를 생성하고 종료하는 방식으로, web content에서 이 경로에 도달할 가능성이 있습니다. 다만 출시 여부는 확인되지 않았습니다. 또한 regression test는 window를 넓히기 위해 debug 전용 --collectContinuously option에 의존합니다. 가장 흔한 결과는 RELEASE_ASSERT에 의한 renderer crash로 예상됩니다.

UAF interleaving에 대해서는 몇 가지 열린 질문이 남아 있습니다. 먼저, attacker가 collector thread를 유도해 ~Heap이 timer를 해제한 뒤에 scheduleSoon()에 도달하게 만들 수 있는지입니다. 또한 해제된 JSRunLoopTimer 크기의 slot이 m_isDisabled/isScheduled()/m_apiLock 읽기 이전에 재점유될 수 있는지도 확인되지 않았습니다. 나아가 이 읽기 중 어느 것이라도 write나 indirect call로 이어질 수 있는지도 미해결입니다. 현재 형태의 primitive는 작고 layout이 고정된 GC 내부 객체에 대한 racy UAF입니다. 이 읽기로 가능한 동작은 기껏해야 재점유된 메모리 위에서 lock 연산을 일으키는 정도에 그칠 수 있습니다. timer 객체에는 attacker가 제어하는 field가 없으므로, primitive는 약한 수준에 머물 가능성이 높습니다. 버그는 WebContent process 안에 있으며 sandbox를 넘지 않습니다. 따라서 별도의 sandbox escape가 필요합니다.

이 vulnerability는 JSC VM을 호스팅하는 process의 memory safety를 약화시킵니다. VM teardown은 언제나 하나의 전제를 둡니다. heap 멤버가 파괴되기 전에 모든 helper thread가 해당 heap에 대한 접근을 멈췄다는 전제입니다. 패치 이전에는 GC conn handoff 경로에서 이 전제가 깨질 수 있었습니다. 그 결과 소유 VM이 사라진 뒤에도 collector thread가 파괴된 StopIfNecessaryTimer에 접근하는 상황이 가능했습니다. 흔한 interleaving에서는 안정적으로 재현되는 RELEASE_ASSERT crash, 즉 renderer나 worker host의 denial of service로 끝날 가능성이 높습니다. 반대로 해제된 timer에 접근하는 경우에는 GC 내부 timer 객체에 대한 use-after-free로 이어질 가능성이 있습니다. 이 window를 제어할 수 있는 attacker라도 기껏해야 같은 process 내부의 state를 손상시키는 수준입니다. 그것만으로는 sandbox를 넘을 수 없습니다.

Insight: 세 가지 지점이 눈에 띕니다. 첫째, 이 버그는 regression입니다. Commit message에 따르면 323479@main이 early stop을 제거했습니다. 그런데 그 stop은 단순한 cleanup이 아니라 lifetime을 지탱하는 역할을 하고 있었습니다. thread 소유권을 별도 객체로 옮기는 refactor는 암묵적인 순서를 잃기 쉽습니다. 이번 경우에는 Heap에서 Collector를 분리한 작업이 여기에 해당합니다. 원래는 owner가 thread를 먼저 멈췄지만, 이제 그 정지는 선언 순서에 따라 destructor가 실행되는 멤버 안에 있습니다.

둘째, conn handoff는 이 버그 유형의 미묘한 원인입니다. mutator가 collector 대신 collection을 완료할 수 있게 되는 순간 전제가 달라집니다. "collector가 내 Leave를 처리했다"는 사실이 더 이상 "collector thread가 내 heap에 대한 코드 실행을 멈췄다"를 의미하지 않습니다.

셋째, fix는 양쪽에서 이뤄졌습니다. shutDown()에서 thread를 미리 멈추고, ~Collector의 암묵적 정지를 RELEASE_ASSERT로 바꿨습니다. 덕분에 앞으로 shutDown()을 건너뛰는 경로가 생기더라도 조용히 race를 일으키는 대신 즉시 crash로 드러납니다. 한편 --useGlobalGC=true는 명시적으로 수정 대상에서 제외되었습니다. 후속 fix가 반영될 때까지는 같은 유형의 race가 그대로 남아 있습니다.