Skip to content
KitploitKITPLOIT
OutilsExploitsBlog
Log in
Soumettre
OutilsExploitsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

FluxContactConfidentialité© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
CVE-2026-50679 — Analyse et exploit pour un débordement de tampon dans le tas de Windows Search (CVE-2026-50679) permettant une élévation de privilèges locale via le détournement de la vtable CVIQuery et le chargement de DLL. | Kitploit
Outils/GitHubGitHub/h4urek/cve-2026-50679
Escalade de PrivilègesCriminalistique MémoireAnalyse des VulnérabilitésExploitationRétro-ingénierieExploitation de Binaires
GitHubh4urek/cve-2026-50679

CVE-2026-50679

Analyse et exploit pour un débordement de tampon dans le tas de Windows Search (CVE-2026-50679) permettant une élévation de privilèges locale via le détournement de la vtable CVIQuery et le chargement de DLL.

Voir le dépôt
1624il y a 13 joursPas encore vérifié
Partager

CVE-2026-50679

En juin de cette année, j'ai découvert ce débordement de tas dans Windows Search, et j'ai réalisé qu'il était exploitable. J'y ai consacré quelques jours et j'ai réussi à obtenir une LPE. Lorsque je l'ai soumis, on m'a dit qu'il s'agissait d'un doublon :(. Il a été corrigé lors du Patch Tuesday de juillet et suivi par Microsoft sous la référence CVE-2026-50679. Quoi qu'il en soit, le processus d'exploitation a été très amusant.

Cause racine

CPMExternalSearchResultIn (message 245) injecte un résultat de recherche externe dans une requête existante. Son corps est constitué de trois DWORD suivis de trois chaînes UTF-16, et chaque chaîne est décrite par une longueur intégrée dans le corps :

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

Les trois longueurs proviennent du client. Le transport sait combien d'octets sont arrivés, mais rien dans le format du message ne lie les longueurs déclarées à ce nombre.

Avant qu'un message n'atteigne un gestionnaire, tquery!CProxyMessage::ValidateInputHeader vérifie l'en-tête. Il valide l'identifiant du message, les champs réservés, la somme de contrôle et la taille minimale du message pour cet identifiant. Mais il ne vérifie pas si les longueurs de chaînes déclarées dans le message dépassent la taille du tampon du message.

Le message est ensuite transmis à tquery!CRequestServer::DoSetExternalRowset. Le gestionnaire alloue un tampon de destination à partir de la longueur du message externe et y décode le tampon en ligne :

__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 */
    /* ... */
}

Le constructeur est l'endroit où les longueurs intégrées sont utilisées :

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 première copie est la plus évidente. dst a été alloué à partir de la longueur du message externe ; la longueur de copie provient de queryNameLength ; rien ne compare les deux. La copie peut être bien plus grande que l'allocation, et comme sa source est le tampon inline, elle dépasse aussi les octets réellement arrivés. Le reste de la source est ce que le tampon de connexion contenait lors d'un trafic antérieur.

Les deux chaînes suivantes sont pires. rowsetNameLength est lu à partir de src + 2 * queryNameLength + 0x22, un décalage calculé à partir de queryNameLength contrôlé par l'attaquant, et sourceNameLength est lu à un décalage voisin. Les deux se trouvent en dehors de la partie fixe du message, donc le décodeur lit ce qui s'y trouve, le traite comme une longueur et copie à nouveau. Un petit message produit donc plusieurs lectures et écritures hors limites, et aucune des longueurs n'est jamais comparée à l'allocation de destination.

Exploit

L'exploitation de ce bug se résumait à quelques questions : quel objet corrompre et détourner pour prendre le contrôle du flux d'exécution, où rediriger ce flux d'exécution, et comment contourner le tas LFH.

Après un peu de rétro-ingénierie, j'ai trouvé un objet approprié à détourner : CVIQuery. CVIQuery est l'objet côté serveur derrière une requête ouverte. Lorsque le client envoie une requête, le serveur crée un objet CVIQuery correspondant, et son premier champ est la vtable de l'objet, donc corrompre cet objet permet de détourner la vtable.

Le tas était l'obstacle suivant. CVIQuery est alloué depuis le tas LFH, je voulais donc contourner la randomisation du LFH en pulvérisant un grand nombre de ces objets. Le bon côté, c'est que chaque requête crée un CVIQuery, ce qui fournit une primitive pratique de pulvérisation du tas. Cependant, wsearch limite le nombre maximal de requêtes ouvertes à 4096, donc le nombre de pulvérisations est limité, mais cela suffisait ; il faut juste un peu de chance :).

Enfin, je devais décider où rediriger le flux d'exécution. J'ai fait quelques recherches mais n'ai pas trouvé de technique appropriée, j'ai donc décidé d'en trouver une moi-même. J'ai rapidement trouvé une DLL chargée par le service wsearch : dxcore.dll, et sa fonction DXCoreDriver::LoadDriverModule semblait très intéressante :

DXCoreDriver::LoadDriverModule decompilation

Cette fonction déréférence this + 0x30 comme une chaîne de chemin de DLL et appelle LoadLibraryW pour charger cette DLL. Il suffit donc de déborder sur CVIQuery et de détourner sa vtable, puis de continuer à déborder pour écrire le chemin de la DLL à CVIQuery + 0x30, et le chargement arbitraire de DLL s'ensuit.

Une astuce très pratique. D'ailleurs, lorsque j'ai construit l'exploit, cette fonction n'existait que dans les builds Insider, mais j'ai remarqué qu'elle est récemment apparue aussi dans les builds de version finale.

Télécharger l’outil

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

Pas encore de données de popularité.

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →