
Prueba de concepto para CVE-2026-118383, un use-after-free no autenticado en MongoDB durante la puesta al día de la replicación, con scripts de explotación del protocolo de comunicación, un oráculo de fallos basado en gdb y controles con versiones corregidas.
| CVE | CVE-2026-118383 |
| Componente | Servidor MongoDB, replicación (ReplicationCoordinatorImpl) |
| Afectados | 8.0.x anteriores a 8.0.37 (8.0.34 probado); compilaciones 8.2 anteriores al backport (8.2.12 probado) |
| Corregido en | 8.0.37 (23dfc54219, 6111165c32) |
| CWE | CWE-416 — use-after-free |
| Disparador | Envenenamiento de un waiter de readConcern.afterOpTime sin autenticación + aborto de la puesta al día del primario |
| Impacto | Caída de mongod / corrupción de memoria en el coordinador de replicación |
Un objeto ReplicationCoordinatorImpl::CatchupState puede liberarse a sí mismo mientras uno
de sus propios métodos sigue en ejecución. El callback de finalización registrado para el
waiter de puesta al día del primario captura un this en bruto, ignora el estado de
finalización y llama a abort_inlock(kSucceeded) desde dentro de abort_inlock(). La llamada
interna restablece _repl->_catchupState y destruye el objeto; el marco externo entonces
continúa leyendo y escribiendo a través del puntero liberado.
El waiter puede mantenerse sin satisfacer por un cliente no autenticado. Dos
waiters de readConcern.afterOpTime con términos de opTime adversarios crean un
ciclo de ordenación en std::multimap<OpTime, Waiter>, de modo que el waiter de puesta al día real
nunca es alcanzado por setValueIf_inlock(). El siguiente heartbeat concluye
"ya puesto al día" y aborta la puesta al día, lo que destruye el waiter no satisfecho
y vuelve a entrar en abort_inlock().
Dos correcciones del servidor se publicaron en 8.0.37:
23dfc542199ab3b88d6a9420b6cd3f125a897620 — SERVER-138175. CatchupState
pasa a ser enable_shared_from_this, _catchupState pasa a ser un shared_ptr, y
el callback mantiene un weak_ptr, retorna ante un estado distinto de OK, y solo concluye
la puesta al día si aún posee el estado actual.6111165c32bfc74f197e2dfeb9480d0b52154d68 — SERVER-138119. Rechaza
el readConcern.afterOpTime proporcionado por el cliente a menos que el cliente posea
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 cualquier conjunto de réplicas previo, inicia tres miembros, ejecuta el PoC, captura el informe y los registros del servidor en results/, y vuelve a desmontar el conjunto. Una salida distinta de cero significa que la ejecución no alcanzó un veredicto esperado. Use ./run.sh up y ./run.sh poc <mode> para mantener un conjunto en ejecución para su inspección.
Requisitos: Podman, mongosh (solo se usa dentro de las imágenes de MongoDB) y Python 3.10+ si poc.py se ejecuta directamente. El PoC en sí no tiene dependencias de terceros; mongo_wire.py implementa BSON y OP_MSG a partir de la biblioteca estándar.
Código vulnerable en 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
}
};
Tres condiciones hacen fatal el reingreso:
_waiter registrado.lastApplied >= _targetOpTime.kSucceeded destruye el waiter. La
callback síncrona observa que el objetivo ya está aplicado y llama a
abort_inlock(kSucceeded) de nuevo.La segunda condición es alcanzable porque OpTime::operator< no es un orden
débil estricto cuando cualquiera de los lados lleva el término heredado/no 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
}
Coloca dos waiters en este orden:
W1 = {ts: applied + 1s, term: -1} — término omitido en el wireW2 = {ts: Timestamp(1, 1), term: 2^40}Con W1 insertado primero, el orden del multimap pasa a ser W2, W1, C (donde C es
el waiter de catch-up): W2 < W1 por timestamp, W1 < C por timestamp, y
C < W2 por término. La iteración en setValueIf_inlock() comienza en W2, cuya clave
compara como mayor que cualquier lastApplied real, por lo que el bucle se detiene antes de C. El
orden envenenado sobrevive hasta que el siguiente heartbeat aborta el catch-up.
readConcern es un argumento de comando genérico, y waitForReadConcern se ejecuta
antes del despacho del comando. El campo obsoleto afterOpTime se aceptaba desde
cualquier conexión, incluidos clientes no autenticados y comandos que no requieren
privilegios (ping, hello). El jstest corregido
jstests/auth/after_op_time_requires_internal.js verifica exactamente ese caso.
La primitiva de envenenamiento de waiters no necesita credenciales. La reproducción también provoca la elección que convierte el veneno en estado de catch-up; en un despliegue con autenticación habilitada, ese paso requiere control del replica set. La frontera de seguridad que cruza SERVER-138119 es que cualquier conexión podía registrar waiters en la lista de last-applied de un secundario.
checkAuthForAfterOpTime() solicita ActionType::internal en el clúster. Cuando
security.authorization está deshabilitado, esa acción se concede efectivamente a
todos los clientes, por lo que incluso 8.0.37 acepta afterOpTime sin un keyFile. La
corrección de autenticación solo es observable en un despliegue con autenticación habilitada. AUTH=1 inicia cada
miembro con un keyFile compartido, inicializa un usuario admin mediante la excepción de localhost,
y deja la conexión del atacante sin autenticar.
AUTH=1 solo admite control. assisted y natural necesitan los
comandos de prueba no autenticados usados para retener el applier y se ejecutan con la autenticación
deshabilitada.