
Laboratorio differenziale containerizzato e proof of concept a livello di rete per CVE-2026-119958, una scrittura fuori limite (out-of-bounds write) in LDAP di Windows che consente l'esecuzione remota di codice non autenticata.
| CVE | CVE-2026-119958 |
| Componente | Windows LDAP — Lightweight Directory Access Protocol (tag del componente MSRC Windows LDAP - Lightweight Directory Access Protocol) |
| Interessato | Windows 10 1607 → Windows 11 26H2, Windows Server 2016 → 2025 (28 SKU; vedi §6) |
| Corretto in | Aggiornamento di sicurezza di novembre 2026 — KB5131291, KB5131085, KB5131096, KB5131090, KB5131087, KB5132061, KB5132043, KB5131080, KB5131077, KB5132059 |
| CWE | CWE-787 Out-of-bounds Write |
| Impatto | Esecuzione di codice remoto nel contesto del servizio LDAP |
| Vettore | Rete, non autenticato, nessuna interazione dell'utente — chiamate LDAP appositamente costruite verso un servizio LDAP in ascolto |
| Trigger | Gli ottetti di lunghezza di un campo con prefisso di lunghezza in un messaggio LDAP |
Microsoft ha pubblicato l'advisory il 2026-11-10 con l'aggiornamento di sicurezza di novembre 2026. La vulnerabilità è una scrittura fuori dai limiti nel componente Windows LDAP: un attaccante di rete non autenticato invia chiamate LDAP appositamente costruite a un servizio LDAP in ascolto, e il servizio scrive oltre la fine di un buffer a capacità fissa. L'advisory afferma che lo sfruttamento riuscito "could gain code execution through a specially crafted set of LDAP calls to execute arbitrary code within the context of the LDAP service". ZDI osserva che la conseguenza è amplificata da dove finisce il codice — "it runs code in the LDAP service context, it could be quite destructive, especially on Domain Controllers."
Ogni domain controller espone LDAP su TCP/389 (e TCP/636 per LDAPS) per progettazione, e il servizio non può essere disabilitato senza compromettere le operazioni del dominio. Un attaccante che raggiunge la porta LDAP di un domain controller si colloca quindi nel confine di fiducia su cui si basa ogni altra risorsa del dominio.
Questo repository contiene un laboratorio containerizzato che riproduce il difetto end to end, una proof of concept differenziale e i risultati di una scansione sul modello corretto.
Il componente Windows LDAP è codice Microsoft closed-source. Nessuno dei suoi codici o binari viene ridistribuito qui, e l'advisory non divulga alcuna causa radice, alcun nome di funzione, alcuna dimensione del buffer e alcun payload. Ciò che è riproducibile qui è quindi:
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H), lo stato di sfruttamento
Exploitation Less Likely e la matrice delle versioni interessate/corrette —
tutto ripreso testualmente dall'advisory MSRC e dal feed CVRF MSRC per la
release 2026-Nov.Tutto ciò che il laboratorio afferma sul prodotto del fornitore proviene dall'advisory. Tutto ciò che afferma sul modello è etichettato come tale. Il modello è l'unica cosa che viene eseguita nel laboratorio, ed è deliberatamente costruito in modo che il comportamento vulnerabile e quello corretto differiscano solo nel componente target.
Il modello risiede in lab/src/ ed è selezionato tramite una variabile
d'ambiente:
| build | il componente target | binari |
|---|---|---|
LDAP_BUILD=vuln | copia la lunghezza fornita dal peer senza verificarla rispetto alla capacità della destinazione | ldapd-vuln, ldapc-vuln, harness-vuln |
LDAP_BUILD=fixed | convalida la lunghezza e rifiuta il valore | ldapd-fixed, ldapc-fixed, harness-fixed |
Ogni build esiste in due versioni, una con i sanitizer e una senza
(LDAP_SANITIZER=1 seleziona la build con AddressSanitizer +
UndefinedBehaviorSanitizer).
La differenza tra i due lati è un singolo hunk in una funzione, ed è
riprodotta verbatim in 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;
}
La patch stessa è lab/fixes/ldap-fix-bounds-check.patch; la build dell'immagine
la applica per produrre l'albero corretto.
Il componente target è la routine che copia un campo decodificato, con prefisso di lunghezza, in un buffer a capacità fissa. Nel modello corrisponde a
ldap_copy_octets() in 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 lunghezza viene presa dal wire — sono gli octet di lunghezza BER dell'elemento inviato dal peer — e viene usata direttamente come dimensione della copia. La capacità della destinazione è nota al chiamante (cap) e non viene consultata. Un peer che annuncia una lunghezza maggiore della capacità scrive quindi oltre la fine della destinazione.
La destinazione del sito di copia primario è il buffer dei valori di uno slot di decodifica, e il puntatore di dispatch dello slot lo segue in memoria (lab/src/ldapmodel.h):
struct op_slot {
uint8_t val[LDAP_CAP];
void (*fn)(struct op *op);
};
LDAP_CAP è 1024, la capacità del buffer modellato. È maggiore di qualsiasi lunghezza documentata da AD DS per i campi che il modello decodifica — la documentazione dei limiti massimi di AD DS fissa a 255 caratteri il distinguished name di un simple bind — quindi un valore di quella dimensione è un valore che nessun peer ha motivo di inviare. Un valore di 1032 byte pertanto non rimane all'interno di val[]: sovrascrive fn, il puntatore che il servizio chiama per smistare la richiesta appena decodificata. La scrittura è una scrittura di byte scelti dall'attaccante a un offset scelto dall'attaccante, sopra un puntatore che il servizio chiama poi — la scrittura out-of-bounds e l'esecuzione di codice sono lo stesso evento.
Gli altri siti di copia — il distinguished name di una search base, il nome di un bind, un valore di control, un valore di extended request, i valori degli attributi di una response — copiano in allocazioni dedicate a capacità fissa e sono i siti su cui il sanitizer riporta direttamente.
evidence/check-vulnerable-asan-report.txt, dalla build vulnerabile:
==3==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x619000000488 ...
WRITE of size 2048 at 0x619000000488 thread T0
#0 ... in __interceptor_memcpy
#1 ... in ldap_copy_octets /build/src/ldapmodel.c:49
#2 ... in copy_filter_value /build/src/ldapmodel.c:204
#3 ... in parse_filter /build/src/ldapmodel.c:271
#4 ... in ldap_parse_search_request /build/src/ldapmodel.c:374
#5 ... in handle_connection /build/src/ldapd.c:216