Skip to content
KitploitKITPLOIT
StrumentiExploitsBlog
Log in
Invia
StrumentiExploitsBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

FeedContattoPrivacy© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
Strumenti/GitHubGitHub/googlesky/cve-2026-118383
Memory ForensicsAnalisi delle VulnerabilitàExploitDebuggerPaper e RicercaSicurezza dei Database
GitHubgooglesky/cve-2026-118383

CVE-2026-118383

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.

Condividi
Vedi Repository
7 giorni faNon ancora revisionato

CVE-2026-118383 — use-after-free pre-auth in MongoDB durante il recupero del primary

CVECVE-2026-118383
ComponenteServer MongoDB, replica (ReplicationCoordinatorImpl)
Affected8.0.x precedenti alla 8.0.37 (testata la 8.0.34); build 8.2 precedenti al backport (testata la 8.2.12)
Fixed in8.0.37 (23dfc54219, 6111165c32)
CWECWE-416 — use-after-free
TriggerAvvelenamento di un waiter readConcern.afterOpTime non autenticato + interruzione del recupero del primary
ImpactCrash 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.

Avvio rapido

# 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.

Causa principale

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:

  1. Il nodo è in primary catch-up con un _waiter registrato.
  2. Il waiter è ancora non soddisfatto anche se lastApplied >= _targetOpTime.
  3. Qualsiasi abort con una ragione diversa da 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 wire
  • W2 = {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.

Superficie d'attacco

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.

Perché il controllo richiede l'autenticazione

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.

Modalità PoC

Scarica lo strumento

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Nessun dato di popolarità ancora.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →