
Proof-of-concept per CVE-2026-118383, una vulnerabilità use-after-free non autenticata in MongoDB durante il recupero della replica, con script di exploit per il protocollo wire, un oracolo di crash gdb e controlli sulle versioni corrette.
| CVE | CVE-2026-118383 |
| Componente | Server MongoDB, replica (ReplicationCoordinatorImpl) |
| Affected | 8.0.x precedenti alla 8.0.37 (testata la 8.0.34); build 8.2 precedenti al backport (testata la 8.2.12) |
| Fixed in | 8.0.37 (23dfc54219, 6111165c32) |
| CWE | CWE-416 — use-after-free |
| Trigger | Avvelenamento di un waiter readConcern.afterOpTime non autenticato + interruzione del recupero del primary |
| Impact | Crash di mongod / corruzione della memoria nel coordinatore di replica |
Un oggetto ReplicationCoordinatorImpl::CatchupState può liberare se stesso mentre uno
dei suoi stessi metodi è ancora in esecuzione. Il callback di completamento registrato per il
waiter del recupero del primary cattura un this grezzo, ignora lo stato di completamento
e chiama abort_inlock(kSucceeded) dall'interno di abort_inlock(). La chiamata
interna reimposta _repl->_catchupState e distrugge l'oggetto; il frame esterno poi
continua a leggere e scrivere attraverso il puntatore liberato.
Il waiter può essere mantenuto non soddisfatto da un client non autenticato. Due
waiter readConcern.afterOpTime con termini opTime avversariali creano un
ciclo di ordinamento in std::multimap<OpTime, Waiter>, così il vero waiter di recupero
non viene mai raggiunto da setValueIf_inlock(). Il successivo heartbeat conclude
"già recuperato" e interrompe il recupero, il che distrugge il waiter non soddisfatto
e rientra in abort_inlock().
Due correzioni lato server sono state rilasciate nella 8.0.37:
23dfc542199ab3b88d6a9420b6cd3f125a897620 — SERVER-138175. CatchupState
diventa enable_shared_from_this, _catchupState diventa un shared_ptr, e
il callback mantiene un weak_ptr, ritorna su stato non-OK, e conclude
il recupero solo se possiede ancora lo stato corrente.6111165c32bfc74f197e2dfeb9480d0b52154d68 — SERVER-138119. Rifiuta
readConcern.afterOpTime fornito dal client a meno che il client non possieda
ActionType::internal.# Vulnerable 8.0.34: deterministic double abort (UAF fingerprint)
./run.sh assisted
# Fixed 8.0.37: same attack, no double abort
MONGO_IMAGE=docker.io/mongodb/mongodb-community-server:8.0.37-ubi9 \
./run.sh assisted
# Unauthenticated afterOpTime acceptance, vulnerable vs fixed
AUTH=1 ./run.sh control
AUTH=1 MONGO_IMAGE=docker.io/mongodb/mongodb-community-server:8.0.37-ubi9 \
./run.sh control
run.sh <mode> smonta qualsiasi replica set precedente, avvia tre membri,
esegue il PoC, cattura il report e i log del server sotto results/, e smonta
nuovamente il set. Un exit code diverso da zero significa che l'esecuzione non ha raggiunto un verdetto
atteso. Usa ./run.sh up e ./run.sh poc <mode> per mantenere un set in esecuzione per
l'ispezione.
Requisiti: Podman, mongosh (usato solo all'interno delle immagini MongoDB), e
Python 3.10+ se poc.py viene eseguito direttamente. Il PoC stesso non ha dipendenze
di terze parti; mongo_wire.py implementa BSON e OP_MSG dalla libreria
standard.
Codice vulnerabile in src/mongo/db/repl/replication_coordinator_impl.cpp:
void ReplicationCoordinatorImpl::CatchupState::abort_inlock(
PrimaryCatchUpConclusionReason reason) {
...
if (reason != PrimaryCatchUpConclusionReason::kSucceeded && _waiter) {
_repl->_lastAppliedOpTimeWaiterList.remove_inlock(_waiter);
_waiter.reset(); // may synchronously run targetOpTimeCB
}
_repl->_enterDrainMode_inlock();
_repl->_catchupState.reset(); // destroys `this`
}
auto targetOpTimeCB = [this](Status status) {
// status is ignored
const auto myLastApplied = _repl->_getMyLastAppliedOpTime_inlock();
if (_targetOpTime <= myLastApplied) {
...
abort_inlock(PrimaryCatchUpConclusionReason::kSucceeded); // re-enters
}
};
Tre condizioni rendono fatale il rientro:
_waiter registrato.lastApplied >= _targetOpTime.kSucceeded distrugge il waiter. Il
callback sincrono osserva che il target è già applicato e chiama
abort_inlock(kSucceeded) di nuovo.La seconda condizione è raggiungibile perché OpTime::operator< non è un ordinamento
stretto debole quando uno dei due lati porta il termine legacy/non inizializzato -1:
inline bool operator<(const OpTime& rhs) const {
if (_term == kUninitializedTerm || rhs._term == kUninitializedTerm)
return _timestamp < rhs._timestamp; // timestamp only
return std::tie(_term, _timestamp) < std::tie(rhs._term, rhs._timestamp); // term first
}
Inserisci due waiter in questo ordine:
W1 = {ts: applied + 1s, term: -1} — term omesso sul wireW2 = {ts: Timestamp(1, 1), term: 2^40}Con W1 inserito per primo, l'ordine della multimap diventa W2, W1, C (dove C è
il waiter di catch-up): W2 < W1 per timestamp, W1 < C per timestamp, e
C < W2 per term. L'iterazione in setValueIf_inlock() parte da W2, la cui chiave
risulta maggiore di qualsiasi lastApplied reale, quindi il ciclo si ferma prima di C. L'
ordinamento avvelenato sopravvive finché il successivo heartbeat non interrompe il catch-up.
readConcern è un argomento generico dei comandi, e waitForReadConcern viene eseguito
prima del dispatch del comando. Il campo deprecato afterOpTime era accettato da
qualsiasi connessione, inclusi client non autenticati e comandi che non richiedono
privilegi (ping, hello). Il jstest corretto
jstests/auth/after_op_time_requires_internal.js verifica esattamente questo caso.
La primitiva di avvelenamento dei waiter non richiede credenziali. La riproduzione guida anche l'elezione che trasforma il veleno in stato di catch-up; su un deployment con auth abilitata quel passaggio richiede il controllo del replica set. Il confine di sicurezza violato da SERVER-138119 è che qualsiasi connessione poteva registrare waiter sulla lista last-applied di un secondary.
checkAuthForAfterOpTime() richiede ActionType::internal sul cluster. Quando
security.authorization è disabilitata, quell'azione è di fatto concessa a
ogni client, quindi anche la 8.0.37 accetta afterOpTime senza keyFile. La correzione
dell'auth è osservabile solo su un deployment con auth abilitata. AUTH=1 avvia ogni
membro con un keyFile condiviso, inizializza un utente admin tramite l'eccezione localhost,
e lascia la connessione dell'attaccante non autenticata.
AUTH=1 supporta solo control. assisted e natural richiedono i
comandi di test non autenticati usati per bloccare l'applier e vengono eseguiti con auth
disabilitata.
Scopri gli strumenti più utilizzati dalla nostra community.
Nessun dato di popolarità ancora.