
Prova de conceito para CVE-2026-118383, um use-after-free não autenticado no MongoDB durante a recuperação de replicação, com scripts de exploração via protocolo de rede, um oráculo de crash via gdb e controles de versões corrigidas.
| CVE | CVE-2026-118383 |
| Componente | Servidor MongoDB, replicação (ReplicationCoordinatorImpl) |
| Afetado | 8.0.x anteriores a 8.0.37 (8.0.34 testado); builds 8.2 anteriores ao backport (8.2.12 testado) |
| Corrigido em | 8.0.37 (23dfc54219, 6111165c32) |
| CWE | CWE-416 — use-after-free |
| Gatilho | Envenenamento de waiter readConcern.afterOpTime não autenticado + aborto da recuperação do primário |
| Impacto | Crash do mongod / corrupção de memória no coordenador de replicação |
Um objeto ReplicationCoordinatorImpl::CatchupState pode liberar a si mesmo enquanto um
de seus próprios métodos ainda está em execução. O callback de conclusão registrado para o
waiter de recuperação do primário captura um this bruto, ignora o status de conclusão
e chama abort_inlock(kSucceeded) de dentro de abort_inlock(). A chamada interna
redefine _repl->_catchupState e destrói o objeto; o frame externo então
continua a ler e escrever através do ponteiro liberado.
O waiter pode ser mantido não satisfeito por um cliente não autenticado. Dois
waiters readConcern.afterOpTime com termos de opTime adversariais criam um
ciclo de ordenação em std::multimap<OpTime, Waiter>, de modo que o waiter de recuperação real
nunca é alcançado por setValueIf_inlock(). O próximo heartbeat conclui
"já recuperado" e aborta a recuperação, o que destrói o waiter não satisfeito
e reentra em abort_inlock().
Duas correções do servidor foram lançadas na 8.0.37:
23dfc542199ab3b88d6a9420b6cd3f125a897620 — SERVER-138175. CatchupState
passa a ser enable_shared_from_this, _catchupState passa a ser um shared_ptr, e
o callback mantém um weak_ptr, retorna em status não-OK, e só conclui
a recuperação se ainda possuir o estado atual.6111165c32bfc74f197e2dfeb9480d0b52154d68 — SERVER-138119. Rejeita
readConcern.afterOpTime fornecido pelo cliente, a menos que o cliente possua
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> desmonta qualquer replica set anterior, inicia três membros,
executa o PoC, captura o relatório e os logs do servidor em results/ e desmonta
o conjunto novamente. Uma saída diferente de zero significa que a execução não atingiu um veredito
esperado. Use ./run.sh up e ./run.sh poc <mode> para manter um conjunto em execução para
inspeção.
Requisitos: Podman, mongosh (usado apenas dentro das imagens do MongoDB) e
Python 3.10+ se poc.py for executado diretamente. O próprio PoC não tem dependências
de terceiros; mongo_wire.py implementa BSON e OP_MSG a partir da biblioteca
padrão.
Código vulnerável em 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
}
};
Três condições tornam a reentrada fatal:
_waiter registrado.lastApplied >= _targetOpTime.kSucceeded destrói o waiter. O
callback síncrono observa que o alvo já foi aplicado e chama
abort_inlock(kSucceeded) novamente.A segunda condição é alcançável porque OpTime::operator< não é uma ordenação
estrita fraca quando qualquer um dos lados carrega o termo legado/não inicializado -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
}
Plante dois waiters nesta ordem:
W1 = {ts: applied + 1s, term: -1} — term omitido no wireW2 = {ts: Timestamp(1, 1), term: 2^40}Com W1 inserido primeiro, a ordem do multimap torna-se W2, W1, C (onde C é
o waiter de catch-up): W2 < W1 por timestamp, W1 < C por timestamp, e
C < W2 por term. A iteração em setValueIf_inlock() começa em W2, cuja chave
compara como maior que qualquer lastApplied real, então o loop para antes de C. A
ordenação envenenada sobrevive até o próximo heartbeat abortar o catch-up.
readConcern é um argumento genérico de comando, e waitForReadConcern executa
antes do despacho do comando. O campo obsoleto afterOpTime era aceito de
qualquer conexão, incluindo clientes não autenticados e comandos que não exigem
privilégios (ping, hello). O jstest corrigido
jstests/auth/after_op_time_requires_internal.js verifica exatamente esse caso.
A primitiva de envenenamento de waiter não precisa de credenciais. A reprodução também conduz a eleição que transforma o veneno em estado de catch-up; em uma implantação com auth habilitado, essa etapa exige controle do replica set. A fronteira de segurança cruzada pelo SERVER-138119 é que qualquer conexão podia registrar waiters na lista de last-applied de um secundário.
checkAuthForAfterOpTime() solicita ActionType::internal no cluster. Quando
security.authorization está desabilitado, essa ação é efetivamente concedida a
todo cliente, então até o 8.0.37 aceita afterOpTime sem um keyFile. A correção de auth
só é observável em uma implantação com auth habilitado. AUTH=1 inicia cada
membro com um keyFile compartilhado, inicializa um usuário admin através da exceção de localhost,
e deixa a conexão do atacante não autenticada.
AUTH=1 suporta apenas control. assisted e natural precisam dos
comandos de teste não autenticados usados para segurar o applier e são executados com auth
desabilitado.