romanrybachek/cve-2024-20698Analisi della vulnerabilità
Informazioni su questa vulnerabilità: https://msrc.microsoft.com/update-guide/vulnerability/CVE-2024-20698
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:
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.