CVE-2024-23222: Apple Safari WebKit Object Unboxing Teardown

Analyse technique détaillée du code source et mesures de durcissement pour vulnerabilidade : How JavaScriptCore's DFG JIT compiler failed to verify object type tags before unboxing, allowing targeted spyware to bypass Pointer Authentication (PAC) on iOS and macOS.

💡 Explication en Langage Simple (ELI5)

Analogie concrète : Apple devices have special hardware called Pointer Authentication (PAC) that stamps memory addresses with cryptographic signatures so hackers can't forge them. But in Safari's JavaScript engine, a math helper took an untrusted object and stripped off its label without verifying what it was. This allowed attackers to trick the processor into signing a fake pointer, letting targeted spyware take over Safari.

Concepts Clés et Termes

JavaScriptCore (JSC): Le moteur JavaScript open source qui propulse Safari et tous les navigateurs web sous iOS.
DFG (Data Flow Graph) JIT: Le compilateur d'optimisation intermédiaire dans JavaScriptCore qui optimise les types en fonction du profilage d'exécution observé.
Pointer Authentication Code (PAC): Fonctionnalité de sécurité matérielle ARM64e utilisant des signatures cryptographiques pour valider les pointeurs mémoire avant exécution.
Speculative Unboxing: Extraction d'entiers bruts ou de pointeurs à partir de valeurs JavaScript formatées en NaN-boxing en supposant que le type reste valide.

Analyse de Cause Racine

La cause fondamentale provient de paramètres de limites non validés dans les systèmes open source, permettant une désynchronisation d'état et le contournement des contrôles de sécurité.

Déroulement de l'Attaque Étape par Étape

Step 1

1. Malicious Web Page Navigation

The victim navigates to an attacker-controlled web page in Safari on iOS or macOS.

Step 2

2. DFG Speculation Generation

The script executes an object unboxing routine in a tight loop. JavaScriptCore's DFG compiler speculates that the input is always a native JS object.

Step 3

3. Type Tag Strip Without Verification

The compiled bytecode strips the NaN-box metadata tag without emitting a type assertion guard.

Step 4

4. PAC Forgery & Sandbox Escape

The attacker supplies a disguised object structure, forging a signed pointer to execute shellcode and begin the secondary kernel privilege escalation chain.

Code Source : Vulnérable vs Sécurisé

✕ IMPLÉMENTATION VULNÉRABLE

// VULNERABLE: C++ Logic from WebKit/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp
void DFGSpeculativeJIT::compileUnboxObject(Node* node) {
    Edge edge = node->child1();
    GPRReg jsValueGPR = edge.useInfo().gpr();
    GPRReg resultGPR = node->gpr();

    // CRITICAL ROOT CAUSE:
    // Speculatively stripped the TagMask from JSValue without verifying
    // that the value actually satisfied isCell() and was an Object pointer!
    m_jit.move(jsValueGPR, resultGPR);
    m_jit.and64(TrustedImm64(TagMask), resultGPR);
    
    // Resulting pointer assumed authenticated without PAC validation!
}

✓ PATCH SÉCURISÉ ET ROBUSTE

// SECURE: Open-Source C++ Patch from WebKit Repository
void DFGSpeculativeJIT::compileUnboxObject(Node* node) {
    Edge edge = node->child1();
    GPRReg jsValueGPR = edge.useInfo().gpr();
    GPRReg resultGPR = node->gpr();

    // 1. Emit explicit type tag assertion guard
    MacroAssembler::Jump notCell = m_jit.branchIfNotCell(jsValueGPR);
    speculationCheck(BadType, JSValueRegs(jsValueGPR), edge.node(), notCell);

    // 2. Verify object structure cell before unmasking pointer
    m_jit.move(jsValueGPR, resultGPR);
    m_jit.and64(TrustedImm64(TagMask), resultGPR);
    
    // 3. Ensure PAC authentication check verifies target pointer integrity
    speculationCheck(BadType, JSValueRegs(jsValueGPR), edge.node(),
                     m_jit.branchTest8(MacroAssembler::Zero, 
                                       MacroAssembler::Address(resultGPR, JSCell::typeInfoTypeOffset())));
}

Liste de Contrôle de Sécurité pour l'Ingénierie

✓Règle de sécurité recommandée : Always emit explicit type assertion guards (branchIfNotCell) prior to speculative value unboxing in JIT compilers.
✓Ne jamais bypass Pointer Authentication (PAC) by laundering pointers through untrusted intermediate JIT variables.
✓Règle de sécurité recommandée : Isolate browser WebContent rendering processes in restricted user-namespace sandboxes with zero direct kernel IPC routes.
✓Exécutez Apple's Lockdown Mode on high-risk devices, which disables JIT compilers entirely.