
Análisis y exploit para un desbordamiento de búfer en el heap de Windows Search (CVE-2026-50679) que logra una escalada de privilegios local mediante el secuestro de la vtable de CVIQuery y la carga de DLL.
En junio de este año encontré este desbordamiento de heap en Windows Search, y me di cuenta de que era explotable. Dediqué unos días a trabajar en ello y logré un LPE. Cuando lo envié, me dijeron que era un duplicado :(. Se corrigió en el Patch Tuesday de julio y Microsoft lo registró como CVE-2026-50679. De todos modos, el proceso de explotación fue muy divertido.
CPMExternalSearchResultIn (mensaje 245) introduce un resultado de búsqueda externo en una consulta existente. Su cuerpo consta de tres DWORD seguidos de tres cadenas UTF-16, y cada cadena se describe mediante una longitud incrustada en el cuerpo:
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
Las tres longitudes provienen del cliente. El transporte sabe cuántos bytes llegaron, pero nada en el formato del mensaje vincula las longitudes declaradas a ese número.
Antes de que un mensaje llegue a un controlador, tquery!CProxyMessage::ValidateInputHeader verifica el encabezado. Comprueba el id del mensaje, los campos reservados, la suma de verificación y el tamaño mínimo del mensaje para ese id. Pero no verifica si las longitudes de las cadenas declaradas en el mensaje exceden el tamaño del búfer del mensaje.
Luego, el mensaje se despacha a tquery!CRequestServer::DoSetExternalRowset. El controlador asigna un búfer de destino a partir de la longitud del mensaje externo y decodifica el búfer en línea en él:
__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 */
/* ... */
}
El constructor es donde se utilizan las longitudes incrustadas:
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 primera copia es la obvia. dst se asignó a partir de la longitud del mensaje externo; la longitud de la copia proviene de queryNameLength; nada compara ambas. La copia puede ser mucho mayor que la asignación y, como su origen es el búfer inline, también se extiende más allá de los bytes que realmente llegaron. El resto del origen es lo que el búfer de conexión contenía de tráfico anterior.
Las dos cadenas posteriores son peores. rowsetNameLength se lee desde src + 2 * queryNameLength + 0x22, un desplazamiento calculado a partir de queryNameLength controlado por el atacante, y sourceNameLength se lee desde un desplazamiento cercano. Ambos están fuera de la parte fija del mensaje, por lo que el decodificador lee lo que haya allí, lo trata como una longitud y vuelve a copiar. Un solo mensaje pequeño, por lo tanto, produce varias lecturas y escrituras fuera de límites, y ninguna de las longitudes se compara nunca con la asignación de destino.
Explotar este fallo se redujo a unas pocas preguntas: qué objeto corromper y secuestrar el flujo de control, a dónde redirigir ese flujo de control y cómo sortear el montículo LFH.
Tras algo de ingeniería inversa encontré un objeto adecuado para secuestrar: CVIQuery. CVIQuery es el objeto del lado del servidor que hay detrás de una consulta abierta. Cuando el cliente envía una solicitud de consulta, el servidor crea un objeto CVIQuery correspondiente, y su primer campo es la vtable del objeto, por lo que corromper este objeto permite un secuestro de vtable.
El montículo fue el siguiente obstáculo. CVIQuery se asigna desde el montículo LFH, así que quise superar la aleatorización del LFH rociando una gran cantidad de estos objetos. La parte buena es que cada solicitud de consulta crea un CVIQuery, lo que proporciona una primitiva conveniente de rociado del montículo. Sin embargo, wsearch limita el número máximo de solicitudes abiertas a 4096, por lo que el número de rociado es limitado, pero fue suficiente; solo hace falta un poco de suerte :).
Finalmente necesitaba decidir a dónde redirigir el flujo de control. Investigué un poco pero no encontré una técnica adecuada, así que decidí encontrar una yo mismo. Pronto encontré una DLL cargada por el servicio wsearch: dxcore.dll, y su función DXCoreDriver::LoadDriverModule parecía muy interesante:

Esta función desreferencia this + 0x30 como una cadena de ruta de DLL y llama a LoadLibraryW para cargar esa DLL. Por lo tanto, basta con desbordar el CVIQuery y secuestrar su vtable, luego seguir desbordando para escribir la ruta de la DLL en CVIQuery + 0x30, y la carga arbitraria de DLL es consecuencia.
Un truco muy útil. Por cierto, cuando construí el exploit esta función solo existía en compilaciones Insider, pero he notado que recientemente también ha aparecido en compilaciones de lanzamiento.