
Write-up und Exploit für einen Heap-Buffer-Overflow in der Windows-Suche (CVE-2026-50679), der durch Vtable-Hijacking von CVIQuery und DLL-Laden eine lokale Rechteausweitung erreicht.
Im Juni dieses Jahres habe ich diesen Heap-Overflow in der Windows-Suche gefunden, und mir wurde klar, dass er ausnutzbar ist. Ich habe ein paar Tage daran gearbeitet und es geschafft, LPE zu erreichen. Als ich ihn einreichte, wurde mir gesagt, dass es ein Duplikat sei :(. Er wurde am Juli-Patchday behoben und von Microsoft als CVE-2026-50679 geführt. Wie auch immer, der Exploit-Prozess hat viel Spaß gemacht.
CPMExternalSearchResultIn (Nachricht 245) speist ein externes Suchergebnis in eine bestehende Abfrage ein. Sein Body besteht aus drei DWORDs, gefolgt von drei UTF-16-Strings, wobei jeder String durch eine im Body eingebettete Länge beschrieben wird:
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
Alle drei Längenangaben stammen vom Client. Der Transport weiß, wie viele Bytes angekommen sind, aber nichts im Nachrichtenformat verknüpft die deklarierten Längen mit dieser Zahl.
Bevor eine Nachricht einen Handler erreicht, prüft tquery!CProxyMessage::ValidateInputHeader den Header. Er verifiziert die Nachrichten-ID, die reservierten Felder, die Prüfsumme und die Mindestnachrichtengröße für diese ID. Er prüft jedoch nicht, ob die in der Nachricht deklarierten String-Längen die Größe des Nachrichtenpuffers überschreiten.
Die Nachricht wird dann an tquery!CRequestServer::DoSetExternalRowset weitergeleitet. Der Handler reserviert einen Zielpuffer aus der äußeren Nachrichtenlänge und dekodiert den Inline-Puffer hinein:
__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 */
/* ... */
}
Der Konstruktor ist der Ort, an dem die eingebetteten Längen verwendet werden:
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));
/* ... */
}
Die erste Kopie ist die offensichtliche. dst wurde anhand der äußeren Nachrichtenlänge allokiert; die Kopierlänge stammt aus queryNameLength; nichts vergleicht die beiden. Die Kopie kann deutlich größer als die Allokation sein, und da ihre Quelle der Inline-Puffer ist, läuft sie auch über die Bytes hinaus, die tatsächlich angekommen sind. Der Rest der Quelle ist das, was der Verbindungspuffer aus früherem Datenverkehr enthielt.
Die beiden späteren Strings sind schlimmer. rowsetNameLength wird aus src + 2 * queryNameLength + 0x22 gelesen, einem Offset, der aus dem angreiferkontrollierten queryNameLength berechnet wird, und sourceNameLength wird aus einem nahegelegenen Offset gelesen. Beide liegen außerhalb des festen Teils der Nachricht, sodass der Decoder liest, was dort steht, es als Länge behandelt und erneut kopiert. Eine einzige kleine Nachricht erzeugt daher mehrere Out-of-Bounds-Reads und -Writes, und keine der Längen wird jemals mit der Ziel-Allokation verglichen.
Die Ausnutzung dieses Bugs lief auf ein paar Fragen hinaus: welches Objekt korrumpiert und der Kontrollfluss gekapert werden soll, wohin dieser Kontrollfluss umgeleitet werden soll und wie man den LFH-Heap umgeht.
Nach etwas Reverse Engineering fand ich ein geeignetes Objekt zum Hijacken: CVIQuery. CVIQuery ist das serverseitige Objekt hinter einer offenen Query. Wenn der Client eine Query-Anfrage sendet, erstellt der Server ein entsprechendes CVIQuery-Objekt, und dessen erstes Feld ist die vtable des Objekts, sodass eine Korruption dieses Objekts einen vtable-Hijack ermöglicht.
Der Heap war das nächste Hindernis. CVIQuery wird aus dem LFH-Heap allokiert, daher wollte ich die LFH-Randomisierung überwinden, indem ich eine große Anzahl dieser Objekte spraie. Das Gute daran ist, dass jede Query-Anfrage ein CVIQuery erzeugt, was ein praktisches Heap-Spray-Primitiv liefert. Allerdings begrenzt wsearch die maximale Anzahl offener Anfragen auf 4096, sodass die Spray-Anzahl begrenzt ist, aber das reichte aus; es braucht nur etwas Glück :).
Schließlich musste ich entscheiden, wohin der Kontrollfluss umgeleitet werden soll. Ich habe einige Recherchen angestellt, aber keine geeignete Technik gefunden, also beschloss ich, selbst eine zu finden. Bald fand ich eine DLL, die vom wsearch-Dienst geladen wird: dxcore.dll, und deren Funktion DXCoreDriver::LoadDriverModule sah sehr interessant aus:

Diese Funktion dereferenziert this + 0x30 als DLL-Pfad-String und ruft LoadLibraryW auf, um diese DLL zu laden. Es genügt also, den CVIQuery zu überlaufen und seine vtable zu kapern, dann weiter zu überlaufen, um den DLL-Pfad bei CVIQuery + 0x30 zu schreiben, und schon folgt das Laden einer beliebigen DLL.
Ein sehr praktischer Trick. Übrigens existierte diese Funktion, als ich den Exploit baute, nur in Insider-Builds, aber ich habe bemerkt, dass sie kürzlich auch in Release-Builds aufgetaucht ist.