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-2026-50679 — Write-up ed exploit per un heap buffer overflow di Windows Search (CVE-2026-50679) che consente l'escalation di privilegi locale tramite il dirottamento della vtable di CVIQuery e il caricamento di DLL. | Kitploit
Strumenti/GitHubGitHub/h4urek/cve-2026-50679
Escalation di PrivilegiMemory ForensicsAnalisi delle VulnerabilitàExploitReverse EngineeringBinary Exploitation
GitHubh4urek/cve-2026-50679

CVE-2026-50679

Write-up ed exploit per un heap buffer overflow di Windows Search (CVE-2026-50679) che consente l'escalation di privilegi locale tramite il dirottamento della vtable di CVIQuery e il caricamento di DLL.

Vedi Repository
152412 giorni faNon ancora revisionato
Condividi

CVE-2026-50679

A giugno di quest'anno ho trovato questo heap overflow in Windows Search e mi sono reso conto che era sfruttabile. Ho passato qualche giorno a lavorarci e sono riuscito a ottenere un LPE. Quando l'ho inviato, mi è stato detto che era un duplicato :(. È stato corretto nel Patch Tuesday di luglio ed è stato tracciato da Microsoft come CVE-2026-50679. In ogni caso, il processo di sfruttamento è stato molto divertente.

Causa principale

CPMExternalSearchResultIn (messaggio 245) inserisce un risultato di ricerca esterno in una query esistente. Il suo corpo è composto da tre DWORD seguiti da tre stringhe UTF-16, e ciascuna stringa è descritta da una lunghezza incorporata nel corpo:

WSP_MESSAGE_HEADER          16 bytes
queryNameLength              4 bytes
currentRowsetIndex           4 bytes
remainingRowsetCount         4 bytes
queryName                    queryNameLength UTF-16 chars, null-terminated
rowset metadata              rowsetMetadata, rowsetNameLength, sourceNameLength (12 bytes)
rowsetName                   rowsetNameLength UTF-16 chars, null-terminated
sourceName                   sourceNameLength UTF-16 chars, null-terminated

Tutte e tre le lunghezze provengono dal client. Il trasporto sa quanti byte sono arrivati, ma nulla nel formato del messaggio lega le lunghezze dichiarate a quel numero.

Prima che un messaggio raggiunga un handler, tquery!CProxyMessage::ValidateInputHeader controlla l'header. Verifica l'id del messaggio, i campi riservati, il checksum e la dimensione minima del messaggio per quell'id. Ma non controlla se le lunghezze delle stringhe dichiarate nel messaggio superano la dimensione del buffer del messaggio.

Il messaggio viene quindi inviato a tquery!CRequestServer::DoSetExternalRowset. L'handler alloca un buffer di destinazione dalla lunghezza del messaggio esterno e vi decodifica il buffer inline:

__int64 __fastcall CRequestServer::DoSetExternalRowset(CRequestServer *this, unsigned int msgSize)
{
    /* ... */
    BYTE *buffer = (BYTE *)operator new[](https://github.com/h4urek/cve-2026-50679/blob/main/msgSize);          /* outer message length */
    CPMExternalSearchResultIn *decoded =
        CPMExternalSearchResultIn::CPMExternalSearchResultIn(buffer, this + 0x270);
                                                             /* src = inline request buffer */
    /* ... */
}

Il costruttore è il punto in cui vengono utilizzate le lunghezze incorporate:

CPMExternalSearchResultIn::CPMExternalSearchResultIn(BYTE *dst, BYTE *src)
{
    /* dst: buffer sized by the outer message length */
    /* src: per-connection inline request buffer */
    /* ... */
    DWORD queryNameLength = *(DWORD *)(src + 0x10);
    *(DWORD *)(dst + 0x10) = queryNameLength;
    *(DWORD *)(dst + 0x14) = *(DWORD *)(src + 0x14);
    *(DWORD *)(dst + 0x18) = *(DWORD *)(src + 0x18);

    memcpy(dst + 0x1c, src + 0x1c, 2 * (queryNameLength + 1));

    DWORD rowsetNameLength = *(DWORD *)(src + 2 * queryNameLength + 0x22);
    memcpy(dst + 2 * queryNameLength + 0x2a,
           src + 2 * queryNameLength + 0x2a,
           2 * (rowsetNameLength + 1));

    DWORD sourceNameLength = *(DWORD *)(src + 2 * queryNameLength + 0x26);
    memcpy(dst + 2 * queryNameLength + 2 * rowsetNameLength + 0x2c,
           src + 2 * queryNameLength + 2 * rowsetNameLength + 0x2c,
           2 * (sourceNameLength + 1));
    /* ... */
}

La prima copia è quella ovvia. dst è stato allocato in base alla lunghezza del messaggio esterno; la lunghezza della copia proviene da queryNameLength; nulla confronta le due. La copia può essere molto più grande dell'allocazione e, poiché la sua origine è il buffer inline, supera anche i byte effettivamente arrivati. Il resto dell'origine è qualunque cosa il buffer di connessione contenesse da traffico precedente.

Le due stringhe successive sono peggiori. rowsetNameLength viene letto da src + 2 * queryNameLength + 0x22, un offset calcolato a partire dal queryNameLength controllato dall'attaccante, e sourceNameLength viene letto da un offset vicino. Entrambi sono al di fuori della parte fissa del messaggio, quindi il decoder legge qualunque cosa ci sia, la tratta come una lunghezza e copia di nuovo. Un singolo messaggio di piccole dimensioni produce quindi diverse letture e scritture fuori dai limiti, e nessuna delle lunghezze viene mai confrontata con l'allocazione di destinazione.

Exploit

Sfruttare questo bug si riduceva a poche domande: quale oggetto corrompere e dirottare per il flusso di controllo, dove reindirizzare quel flusso di controllo e come aggirare l'heap LFH.

Dopo un po' di reversing ho trovato un oggetto adatto da dirottare: CVIQuery. CVIQuery è l'oggetto lato server dietro una query aperta. Quando il client invia una richiesta di query, il server crea un oggetto CVIQuery corrispondente, e il suo primo campo è la vtable dell'oggetto, quindi corrompere questo oggetto consente un dirottamento della vtable.

L'heap era l'ostacolo successivo. CVIQuery viene allocato dall'heap LFH, quindi volevo superare la randomizzazione dell'LFH effettuando uno spray di un gran numero di questi oggetti. La parte buona è che ogni richiesta di query crea un CVIQuery, il che fornisce una comoda primitiva di heap spray. Tuttavia, wsearch limita il numero massimo di richieste aperte a 4096, quindi il numero di spray è limitato, ma è stato sufficiente; serve solo un po' di fortuna :).

Infine dovevo decidere dove reindirizzare il flusso di controllo. Ho fatto qualche ricerca ma non ho trovato una tecnica adatta, quindi ho deciso di trovarne una da solo. Ho presto trovato una DLL caricata dal servizio wsearch: dxcore.dll, e la sua funzione DXCoreDriver::LoadDriverModule sembrava molto interessante:

Decompilazione di DXCoreDriver::LoadDriverModule

Questa funzione dereferenzia this + 0x30 come stringa di percorso di una DLL e chiama LoadLibraryW per caricare quella DLL. Quindi è sufficiente sovraccaricare CVIQuery e dirottare la sua vtable, poi continuare a sovraccaricare per scrivere il percorso della DLL in CVIQuery + 0x30, e il caricamento arbitrario di DLL è cosa fatta.

Un trucco molto utile. A proposito, quando ho costruito l'exploit questa funzione esisteva solo nelle build Insider, ma ho notato che di recente è comparsa anche nelle build di rilascio.

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.

    831
  • 2

    ghostlock-app

    yukonga/ghostlock-app

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

    534
  • 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à.

    429
  • 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.

    284
  • 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.

    275

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →