
Laboratoire différentiel conteneurisé et preuve de concept au niveau du réseau pour CVE-2026-119958, une écriture hors limites dans le LDAP de Windows permettant une exécution de code à distance non authentifiée.
| CVE | CVE-2026-119958 |
| Composant | Windows LDAP — Lightweight Directory Access Protocol (étiquette de composant MSRC Windows LDAP - Lightweight Directory Access Protocol) |
| Affecté | Windows 10 1607 → Windows 11 26H2, Windows Server 2016 → 2025 (28 SKU ; voir §6) |
| Corrigé dans | Mise à jour de sécurité de novembre 2026 — KB5131291, KB5131085, KB5131096, KB5131090, KB5131087, KB5132061, KB5132043, KB5131080, KB5131077, KB5132059 |
| CWE | CWE-787 Écriture hors limites |
| Impact | Exécution de code à distance dans le contexte du service LDAP |
| Vecteur | Réseau, non authentifié, aucune interaction utilisateur — appels LDAP forgés vers un service LDAP en écoute |
| Déclencheur | Les octets de longueur d'un champ préfixé par sa longueur dans un message LDAP |
Microsoft a publié l'avis le 2026-11-10 avec la mise à jour de sécurité de novembre 2026. La faille est une écriture hors limites dans le composant Windows LDAP : un attaquant réseau non authentifié envoie des appels LDAP forgés à un service LDAP en écoute, et le service écrit au-delà de la fin d'un tampon de capacité fixe. L'avis indique qu'une exploitation réussie « pourrait obtenir une exécution de code via un ensemble d'appels LDAP spécialement forgés permettant d'exécuter du code arbitraire dans le contexte du service LDAP ». ZDI note que les conséquences sont amplifiées par l'endroit où le code s'exécute — « il exécute du code dans le contexte du service LDAP, ce qui pourrait être assez destructeur, en particulier sur les contrôleurs de domaine. »
Chaque contrôleur de domaine expose LDAP sur TCP/389 (et TCP/636 pour LDAPS) par conception, et le service ne peut pas être désactivé sans rompre le fonctionnement du domaine. Un attaquant qui atteint le port LDAP d'un contrôleur de domaine pénètre donc dans la frontière de confiance dont dépend toute autre ressource du domaine.
Ce dépôt contient un laboratoire conteneurisé qui reproduit le défaut de bout en bout, une preuve de concept différentielle, et les résultats d'un balayage sur le modèle corrigé.
Le composant Windows LDAP est du code Microsoft à code source fermé. Aucun de ses codes ou binaires n'est redistribué ici, et l'avis ne divulgue ni cause racine, ni nom de fonction, ni taille de tampon, ni charge utile. Ce qui est reproductible ici est donc :
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H), l'état d'exploitation
Exploitation Less Likely, et la matrice des versions affectées/corrigées —
tous repris mot pour mot de l'avis MSRC et du flux CVRF MSRC pour la
publication 2026-Nov.Tout ce que le laboratoire affirme au sujet du produit de l'éditeur provient de l'avis. Tout ce qu'il affirme au sujet du modèle est étiqueté comme tel. Le modèle est la seule chose qui s'exécute dans le laboratoire, et il est délibérément construit de sorte que le comportement vulnérable et le comportement corrigé ne diffèrent que dans le composant cible.
Le modèle se trouve dans lab/src/ et est sélectionné par une variable
d'environnement :
| build | le composant cible | binaires |
|---|---|---|
LDAP_BUILD=vuln | copie la longueur fournie par le pair sans la vérifier par rapport à la capacité de la destination | ldapd-vuln, ldapc-vuln, harness-vuln |
LDAP_BUILD=fixed | valide la longueur et refuse la valeur | ldapd-fixed, ldapc-fixed, harness-fixed |
Chaque build existe en deux exemplaires, une fois avec les sanitizers et une
fois sans (LDAP_SANITIZER=1 sélectionne le build AddressSanitizer +
UndefinedBehaviorSanitizer).
La différence entre les deux côtés est un hunk dans une fonction, et il est
reproduit mot pour mot dans evidence/versions.txt :
--- a/ldapmodel.c
+++ b/ldapmodel.c
@@ -43,12 +43,19 @@
const uint8_t *src, size_t len)
{
/*
- * The copy size is the length the peer asked for. Nothing checks it
- * against the capacity of the destination buffer.
+ * The patched implementation validates the peer-supplied length
+ * against the capacity of the destination before copying.
*/
+ if (len > cap) {
+ if (!g_quiet)
+ fprintf(stderr,
+ "ldap_copy_octets: refusing %zu bytes for a %zu byte buffer\n",
+ len, cap);
+ return LDAP_PROTOCOL_ERROR;
+ }
+
memcpy(dst, src, len);
(void)c;
- (void)cap;
return LDAP_SUCCESS;
}
Le correctif lui-même est lab/fixes/ldap-fix-bounds-check.patch ; la construction de l'image l'applique pour produire l'arborescence corrigée.
Le composant cible est la routine qui copie un champ décodé, préfixé par sa longueur, dans un tampon de capacité fixe. Dans le modèle, il s'agit de ldap_copy_octets() dans lab/src/ldapmodel.c :
int ldap_copy_octets(struct ldap_conn *c, uint8_t *dst, size_t cap,
const uint8_t *src, size_t len)
{
/*
* The copy size is the length the peer asked for. Nothing checks it
* against the capacity of the destination buffer.
*/
memcpy(dst, src, len);
(void)c;
(void)cap;
return LDAP_SUCCESS;
}
La longueur est prise depuis le flux — ce sont les octets de longueur BER de
l'élément que le pair a envoyé — et elle est utilisée directement comme taille de copie. La
capacité de la destination est connue de l'appelant (cap) et n'est pas consultée.
Un pair qui annonce une longueur supérieure à la capacité écrit donc au-delà
de la fin de la destination.
La destination du site de copie principal est le tampon de valeur d'un slot de décodage,
et le pointeur de dispatch du slot le suit en mémoire
(lab/src/ldapmodel.h) :
struct op_slot {
uint8_t val[LDAP_CAP];
void (*fn)(struct op *op);
};
LDAP_CAP vaut 1024, la capacité du tampon modélisé. Cette valeur est supérieure à toute longueur documentée par AD DS pour les champs que le modèle décode — la documentation des limites maximales d'AD DS plafonne le nom distinctif d'un simple bind à 255 caractères — de sorte qu'une valeur de cette taille est une valeur qu'aucun pair n'a de raison légitime d'envoyer. Une valeur de 1032 octets ne reste donc pas à l'intérieur de val[] : elle écrase fn, le pointeur que le service appelle pour distribuer la requête qu'il vient de décoder. L'écriture est une écriture d'octets choisis par l'attaquant à un décalage choisi par l'attaquant, par-dessus un pointeur que le service appelle ensuite — l'écriture hors limites et l'exécution de code sont un seul et même événement.
Les autres sites de copie — le nom distinctif d'une base de recherche, le nom d'un bind, une valeur de contrôle, une valeur de requête étendue, les valeurs d'attribut d'une réponse — copient dans des allocations dédiées à capacité fixe et sont les sites que le sanitizer signale directement.
evidence/check-vulnerable-asan-report.txt, issu de la compilation vulnérable :