CVE-2022-32932 : Escritura fuera de límites en ZinComputeProgramUpdateMutables() debida a un problema de doble fetch

Comentario del autor

CVE-2022-32932 es otra vulnerabilidad que descubrí en la interfaz del kernel de ANE; se trata de un problema de doble fetch que resultó en una interesante escritura fuera de límites (OOB).

Análisis:

H11ANEIn::patchMutableSurface() (accesible desde H11ANEIn::ANE_ProgramSendRequest_gated) se llama si el model.hwx tiene un procedimiento mutable y también una sección initInfo. Busqué un modelo así pero no pude encontrar ninguno, así que terminé parcheando uno de los modelos precompilados y usé CVE-2022-32845 para cargarlo. Tenga en cuenta que CVE-2022-32845 no es necesario para alcanzar la ruta de código vulnerable desde el sandbox de aplicaciones predeterminado; basta con compilar un mlmodel personalizado para lograr los mismos resultados. Puede encontrar más detalles sobre CVE-2022-32845 en mis diapositivas de presentación

ZinComputeProgramUpdateMutables() es otra función llamada por H11ANEIn::patchMutableSurface() y el prototipo de la función es el siguiente:

ZinComputeProgramStatus __cdecl ZinComputeProgramUpdateMutables(
        uint64_t procedureId,
        const ZinComputeProgramInitInfo *init_info,
        const ANECMutableProcedureInfo *mutable_procedure_info,
        uint64_t mut_procedure_info_size,
        void *MUTK_kernel_section,
        uint64_t MUTK_kernel_section_size);

init_info: es la sección initInfo que contiene una entrada serializada; puedes encontrar la función serializadora serialize_initinfo_section() en el código fuente del exploit weightBufs. mutable_procedure_info : es un búfer compartido de IOSurface proporcionado por el atacante; también se llama weightsBuffer en el exploit weightBufs. mut_procedure_info_size: denota el tamaño del búfer de superficie mutable_procedure_info. MUTK_kernel_section: (o MUTK) Es un búfer de mapeo de un objeto IOSurface creado por el kernel durante la fase de carga del programa. MUTK_kernel_section_size: es el tamaño de la sección mutable del kernel.

El bucle 88-92 calcula el recuento de objetos MutableWeight dentro del objeto mutable_procedure_info, luego calcula el tamaño de asignación del array de MutableWeight en 93. Después, el array de objetos ANECMutableWeight se asigna en 100, y se rellena con el par búfer/tamaño de peso apropiado en el bucle 111-127 mediante ANECGetMutableWeight().

ANECGetMutableOperationInfo() devuelve un objeto opsInfo desde nuestra memoria compartida:

opsInfo *__fastcall ANECGetMutableOperationInfo(const ANECMutableProcedureInfo *MutableProcedureInfo, unsigned int id)
{
  unsigned int weight_buffer_size; // w8
  opsInfo *opInfo; // x0

  weight_buffer_size = MutableProcedureInfo->header.weight_buffer_size;
  if ( !weight_buffer_size )
    return 0LL;
  opInfo = (opsInfo *)((char *)MutableProcedureInfo + MutableProcedureInfo->wb_offsets[id]);
  while ( opInfo->op_index != id )
  {
    if ( !--weight_buffer_size )
      return 0LL;
  }
  return opInfo;
}

El pseudo-código de ANECGetMutableWeight es el siguiente:

void __fastcall ANECGetMutableWeight(
        const ANECMutableProcedureInfo *procedure_info,
        weightInfo *a2,
        ANECMutableWeight *a3)
{
  uint64_t wi_size; // x9

  wi_size = a2->wi_size;
  a3->_weightBuf = (char *)procedure_info + a2->wi_off;
  a3->_weightBufSize = wi_size;
}

El pseudo-código de ANECGetMutableWeightInfo es el siguiente:

weightInfo *__fastcall ANECGetMutableWeightInfo(
        const ANECMutableProcedureInfo *MutableProcedureInfo,
        opsInfo *a2,
        unsigned int a3)
{
  if ( a2->op_count <= a3 )
    return 0LL;
  else
    return (weightInfo *)((char *)MutableProcedureInfo + a2->op_offsets[a3]);
}

Ya describí el formato de ANECMutableProcedureInfo en las diapositivas “Attacking Apple's Neural Engine”, así que si aún no lo has hecho, no dudes en leerlo. La definición de la estructura se puede encontrar en el exploit weightBufs en ‘ aneProgram.h’.

Vulnerabilidad:

Si te has dado cuenta, ANECGetMutableOperationInfo()->op_count se obtiene dos veces: una para calcular el tamaño con el fin de asignar el array de ANECMutableWeight, y otra para rellenar este array.

Debido a que el búfer mutable_procedure_info es una memoria compartida, un atacante podría usar un hilo separado para cambiar el valor de opsInfo->op_count entre el primer y el segundo uso, lo que resulta en una discrepancia de tamaño que conducirá a una interesante escritura fuera de límites (OOB) en una zona kalloc var, kheap defaul o el mapa del kernel.

La vulnerabilidad se puede utilizar de muchas maneras interesantes. Por ejemplo, un atacante podría establecer total_count = 0x1000; en la línea 93, y luego aumentar opsInfo->count a un valor mayor, provocando que se copien datos fuera de los límites en ANECGetMutableWeight().

El kernel entrará en pánico en la instrucción que se muestra a continuación si la escritura OOB ha alcanzado un área de memoria no mapeada:

com.apple.driver.AppleH11ANEInterface:__text:FFFFFE0008913D08                 EXPORT _ANECGetMutableWeight
com.apple.driver.AppleH11ANEInterface:__text:FFFFFE0008913D08 _ANECGetMutableWeight                   ; CODE XREF: _ZinComputeProgramUpdateMutables+270↓p
com.apple.driver.AppleH11ANEInterface:__text:FFFFFE0008913D08                 LDP             X8, X9, [X1,#8]
com.apple.driver.AppleH11ANEInterface:__text:FFFFFE0008913D0C                 ADD             X8, X0, X8
com.apple.driver.AppleH11ANEInterface:__text:FFFFFE0008913D10                 STP             X8, X9, [X2] // <---- Kernel panic 
com.apple.driver.AppleH11ANEInterface:__text:FFFFFE0008913D14                 RET

Este bug proporciona una primitiva fuerte en el sentido de que escribe dos valores de 64 bits: una dirección del kernel que apunta a nuestro búfer compartido de usuario y un valor de 64 bits (semi)arbitrario.

Prueba de concepto:

La prueba de concepto se deja como ejercicio para el lector. Sin embargo, el exploit weightBufs incluye todo lo necesario para alcanzar la ruta de código vulnerable. Buena suerte :-).