CVE-2024-20698

Informazioni su questa vulnerabilità: https://msrc.microsoft.com/update-guide/vulnerability/CVE-2024-20698

Analisi della patch

In ntoskrnl.exe abbiamo due funzioni patchate: sub_1406AE224 e WbAddLookupEntryEx. La funzione vulnerabile è WbAddLookupEntryEx. Percorsi per questa funzione:

Per chiamare questa funzione dobbiamo chiamare NtQuerySystemInformation con primo argomento 0xb9. Il primo byte nel buffer che l'utente fornisce come secondo argomento è l'opzione per questo switch:

switch ( first_byte_in_usermod_buf )
{
    case 1:
      status_1 = WbDecryptEncryptionSegment(item, copy_of_usermod_buf, NumberOfBytes_1);
      goto set_status_and_return;
    case 2:
      status_1 = WbReEncryptEncryptionSegment(item, copy_of_usermod_buf, NumberOfBytes_1);
      goto set_status_and_return;
    case 3:
      status_1 = WbHeapExecuteCall(item, copy_of_usermod_buf, usermod_buffer, NumberOfBytes_1);
      goto set_status_and_return;
    case 4:
      if ( !copy_of_usermod_buf )
      {
        status_1 = patched_case4_no_user_buffer(item, another_item);
set_status_and_return:
        status = status_1;
        goto return;
      }
      break;
    case 5:
    case 6:
      status = usermod_buffer != 0i64 ? STATUS_NOT_IMPLEMENTED : STATUS_INVALID_PARAMETER;
      goto return;
    case 7:
      status_1 = WbRemoveWarbirdProcess(item->proc_handle);
      goto set_status_and_return;
    case 8:
      status_1 = WbProcessStartup(item, copy_of_usermod_buf, NumberOfBytes_1);
      goto set_status_and_return;
    case 9:
      status_1 = WbProcessModuleUnload(item, copy_of_usermod_buf, NumberOfBytes_1);
      goto set_status_and_return;
}

Per ogni processo che utilizza NtQuerySystemInformation con argomento 0xb9, verrà creata una struttura che sarà memorizzata in memoria fino alla terminazione del processo. Ho chiamato questa struttura item_instance. Per prima cosa, la funzione sub_1406AF294 cerca di trovare la struttura del processo tra le altre strutture simili. I puntatori a queste strutture sono memorizzati in memoria in ordine di ID di processo. Se la struttura non viene trovata, verrà creata da WbCreateWarbirdProcess. Successivamente, un puntatore a questa struttura verrà aggiunto all'array utilizzando WbAddLookupEntryEx che è vulnerabile.
Il codice di WbAddLookupEntryEx prima della patch:

NTSTATUS WbAddLookupEntryEx(
        items_info *items_info,
        __int64 new_item_pointer,
        __int64 not_used,
        unsigned int new_item_index)
{
  unsigned int last_item_index;
  NTSTATUS status;
  unsigned int old_items_count;
  unsigned int size_of_item;

  last_item_index = items_info->last_item_index;
  status = 0;
  old_items_count = items_info->old_items_count;

  if ( last_item_index + 1 >= old_items_count )
  {
    status = WbReAlloc(
               items_info->vuln_buffer,
               old_items_count * items_info->size_of_item,
               items_info->size_of_item * (old_items_count + items_info->count_of_new_items),
               &items_info->vuln_buffer);

    if ( status < 0 )
      return status;

    items_info->old_items_count += items_info->count_of_new_items;
    old_items_count = items_info->old_items_count;
    last_item_index = items_info->last_item_index;
  }

  if ( new_item_index > last_item_index || !old_items_count )
    return STATUS_INVALID_PARAMETER;
  memmove(
    (char *)items_info->vuln_buffer + (new_item_index + 1) * items_info->size_of_item,
    (char *)items_info->vuln_buffer + new_item_index * items_info->size_of_item,
    items_info->size_of_item * (last_item_index - new_item_index));

  size_of_item = items_info->size_of_item;
  ++items_info->last_item_index;
  *(_QWORD *)((char *)items_info->vuln_buffer + new_item_index * size_of_item) = new_item_pointer;
  return status;
}

Rialloca l'array di puntatori e inserisce un nuovo puntatore.

La patch aggiunge questi controlli di sicurezza:

status = RtlULongMult(old_items_count, items_info->size_of_item, &size_of_old_items);
if ( status < 0 )
  return status;
status = RtlULongAdd(old_items_count, items_info->count_of_new_items, &sum_result);
if ( status < 0 )
  return status;
status = RtlULongMult(sum_result, mb_item_size, result_size_8byte);
if ( status < 0 )
  return status;

Questo rende le operazioni di addizione e moltiplicazione sicure contro gli overflow. Quindi, nella versione non patchata possiamo ottenere un overflow di interi in questi casi:

• old_items_count * size_of_item > 0xffffffff
• old_items_count + count_of_new_items > 0xffffffff
• (old_items_count + count_of_new_items) * size_of_item > 0xffffffff

Dopo l'overflow di interi l'array di puntatori verrà riallocato, ma con una dimensione inferiore. E poi, memmove cercherà di spostare gli elementi per fare spazio al nuovo elemento. Quindi, corromperà i chunk che si trovano dopo il nuovo chunk allocato. Per innescare l'overflow di interi dobbiamo creare 0xffffffff / size_of_item + 1 strutture. size_of_item è sempre 8. Quindi, dobbiamo creare 0x20000001 strutture. Ogni struttura rappresenta un processo. Quindi dobbiamo avere 0x20000001 (536870913) processi concorrenti. Sulla mia macchina virtuale sono riuscito a creare solo 12492 processi concorrenti e 39652 sulla mia macchina host.