
Preuve de concept pour CVE-2026-118383, une utilisation après libération (use-after-free) non authentifiée dans MongoDB lors de la reprise de réplication, avec des scripts d'exploitation du protocole wire, un oracle de plantage gdb et des contrôles sur versions corrigées.
| CVE | CVE-2026-118383 |
| Composant | Serveur MongoDB, réplication (ReplicationCoordinatorImpl) |
| Affecté | 8.0.x avant 8.0.37 (8.0.34 testé) ; builds 8.2 avant le backport (8.2.12 testé) |
| Corrigé dans | 8.0.37 (23dfc54219, 6111165c32) |
| CWE | CWE-416 — use-after-free |
| Déclencheur | Empoisonnement d'un waiter readConcern.afterOpTime non authentifié + abandon de la reprise du primaire |
| Impact | Crash de mongod / corruption mémoire dans le coordinateur de réplication |
Un objet ReplicationCoordinatorImpl::CatchupState peut se libérer lui-même
alors que l'une de ses propres méthodes est encore en cours d'exécution. Le
callback de complétion enregistré pour le waiter de reprise du primaire capture
un this brut, ignore le statut de complétion et appelle abort_inlock(kSucceeded)
depuis l'intérieur de abort_inlock(). L'appel interne réinitialise
_repl->_catchupState et détruit l'objet ; la frame externe continue ensuite
à lire et écrire à travers le pointeur libéré.
Le waiter peut être maintenu non satisfait par un client non authentifié. Deux
waiters readConcern.afterOpTime avec des termes opTime adversariaux créent un
cycle d'ordonnancement dans std::multimap<OpTime, Waiter>, de sorte que le
véritable waiter de reprise n'est jamais atteint par setValueIf_inlock(). Le
heartbeat suivant conclut « déjà à jour » et abandonne la reprise, ce qui
détruit le waiter non satisfait et ré-entre dans abort_inlock().
Deux correctifs serveur ont été livrés dans 8.0.37 :
23dfc542199ab3b88d6a9420b6cd3f125a897620 — SERVER-138175. CatchupState
devient enable_shared_from_this, _catchupState devient un shared_ptr, et
le callback détient un weak_ptr, retourne sur un statut non-OK, et ne conclut
la reprise que s'il possède encore l'état courant.6111165c32bfc74f197e2dfeb9480d0b52154d68 — SERVER-138119. Rejette le
readConcern.afterOpTime fourni par le client sauf si le client détient
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> démonte tout ensemble de réplicas précédent, démarre trois membres,
exécute le PoC, capture le rapport et les journaux du serveur sous results/, puis
démonte à nouveau l'ensemble. Un code de sortie non nul signifie que l'exécution n'a pas atteint un
verdict attendu. Utilisez ./run.sh up et ./run.sh poc <mode> pour maintenir un ensemble en cours d'exécution à des fins
d'inspection.
Prérequis : Podman, mongosh (utilisé uniquement à l'intérieur des images MongoDB), et
Python 3.10+ si poc.py est exécuté directement. Le PoC lui-même n'a aucune dépendance
tierce ; mongo_wire.py implémente BSON et OP_MSG à partir de la bibliothèque
standard.
Code vulnérable dans 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
}
};
Trois conditions rendent la réentrée fatale :
_waiter enregistré.lastApplied >= _targetOpTime.kSucceeded détruit le waiter. Le
callback synchrone observe que la cible est déjà appliquée et appelle
abort_inlock(kSucceeded) à nouveau.La deuxième condition est atteignable car OpTime::operator< n'est pas un ordre
faible strict lorsque l'un des côtés porte le terme hérité/non initialisé -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
}
Placez deux waiters dans cet ordre :
W1 = {ts: applied + 1s, term: -1} — term omis sur le filW2 = {ts: Timestamp(1, 1), term: 2^40}Avec W1 inséré en premier, l'ordre du multimap devient W2, W1, C (où C est
le waiter de rattrapage) : W2 < W1 par timestamp, W1 < C par timestamp, et
C < W2 par term. L'itération dans setValueIf_inlock() commence à W2, dont la clé
se compare comme supérieure à tout lastApplied réel, donc la boucle s'arrête avant C. L'ordre
empoisonné persiste jusqu'à ce que le prochain heartbeat interrompe le rattrapage.
readConcern est un argument de commande générique, et waitForReadConcern s'exécute
avant la distribution de la commande. Le champ obsolète afterOpTime était accepté depuis
n'importe quelle connexion, y compris des clients non authentifiés et des commandes qui ne nécessitent aucun
privilège (ping, hello). Le jstest corrigé
jstests/auth/after_op_time_requires_internal.js vérifie exactement ce cas.
La primitive d'empoisonnement de waiter ne nécessite aucun identifiant. La reproduction déclenche également l'élection qui transforme le poison en état de rattrapage ; sur un déploiement avec authentification activée, cette étape nécessite le contrôle du replica-set. La frontière de sécurité franchie par SERVER-138119 est que toute connexion pouvait enregistrer des waiters sur la liste last-applied d'un secondary.
checkAuthForAfterOpTime() demande ActionType::internal sur le cluster. Lorsque
security.authorization est désactivé, cette action est effectivement accordée à
chaque client, donc même 8.0.37 accepte afterOpTime sans keyFile. Le correctif d'authentification
n'est observable que sur un déploiement avec authentification activée. AUTH=1 démarre chaque
membre avec un keyFile partagé, initialise un utilisateur admin via l'exception localhost, et laisse la connexion de l'attaquant non authentifiée.
AUTH=1 ne prend en charge que control. assisted et natural nécessitent les
commandes de test non authentifiées utilisées pour retenir l'applier et sont exécutés avec l'authentification
désactivée.