Skip to content
KitploitKITPLOIT
StrumentiExploitsBlog
Log in
Invia
StrumentiExploitsBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

FeedContattoPrivacy© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
CVE-2024-20698 — Analisi della vulnerabilità | Kitploit
Strumenti/GitHubGitHub/romanrybachek/cve-2024-20698
Analisi delle VulnerabilitàAnalisi del CodiceExploitReverse EngineeringAnalisi di Binari
GitHubromanrybachek/cve-2024-20698

CVE-2024-20698

Analisi della vulnerabilità

Vedi Repository
517252 anni faRevisionato da Kitploit
Condividi

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:

disegno

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.

Scarica lo strumento

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 Il toolkit OSINT definitivo: grafo di indagine, punteggio di affidabilità, famiglie di alias, mappa, timeline e report. 49 moduli, oltre 400 siti, nessuna chiave API richiesta.

    837
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # App di esecuzione con un tocco GhostLock (CVE-2026-43499)

    536
  • 3

    ARTEX

    baarai/artex

    Piattaforma di penetration testing autonoma multi-agente basata su LLM con agenti planner/worker, grafi di asset e di esplorazione, registrazione del traffico MITM e retesting delle vulnerabilità.

    424
  • 4

    redforge

    cybersecurity91/redforge

    Toolkit red team lato browser con 102 strumenti offline per ricognizione, generazione di payload, attacchi alle credenziali, crittografia, codifica e reportistica dell'engagement.

    355
  • 5

    looking-glass

    anonghosty/looking-glass

    Piattaforma CSIRT che importa i report di Shadowserver in MongoDB e li riproduce come mappe interattive, analisi, risultati, avvisi e dashboard executive.

    294
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Il sistema d'azione per la cybersecurity nativa AI—dove l'intento diventa esecuzione governata, le evidenze diventano memoria operativa, e ogni operazione migliora la successiva.

    276

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →