Skip to content
KitploitKITPLOIT
OutilsExploitsBlog
Log in
Soumettre
OutilsExploitsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

FluxContactConfidentialité© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
CVE-2026-118383 — 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. | Kitploit
Outils/GitHubGitHub/googlesky/cve-2026-118383
Criminalistique MémoireAnalyse des VulnérabilitésExploitationDébogueursArticles et RechercheSécurité des Bases de Données
GitHubgooglesky/cve-2026-118383

CVE-2026-118383

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.

Partager
Voir le dépôt
il y a 7 joursPas encore vérifié

CVE-2026-118383 — use-after-free pre-auth dans MongoDB lors de la reprise du primaire

CVECVE-2026-118383
ComposantServeur 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é dans8.0.37 (23dfc54219, 6111165c32)
CWECWE-416 — use-after-free
DéclencheurEmpoisonnement d'un waiter readConcern.afterOpTime non authentifié + abandon de la reprise du primaire
ImpactCrash 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.

Démarrage rapide

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

Cause racine

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 :

  1. Le nœud est en rattrapage primaire avec un _waiter enregistré.
  2. Le waiter est toujours non satisfait même si lastApplied >= _targetOpTime.
  3. Tout abandon avec une raison autre que 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 fil
  • W2 = {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.

Surface d'attaque

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.

Pourquoi le contrôle nécessite une authentification

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.

Modes du PoC

Télécharger l’outil

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 La boîte à outils OSINT ultime : graphe d'enquête, notation de confiance, familles d'alias, carte, chronologie et rapports. 49 modules, plus de 400 sites, aucune clé API requise.

    668
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Application d'exécution en un clic GhostLock (CVE-2026-43499)

    496
  • 3

    ARTEX

    baarai/artex

    Plateforme autonome de tests d'intrusion multi-agents basée sur des LLM, avec agents planificateur/ouvrier, graphes d'actifs et d'exploration, enregistrement du trafic MITM et retest des vulnérabilités.

    394
  • 4

    redforge

    cybersecurity91/redforge

    Boîte à outils red team côté navigateur avec 102 outils hors ligne pour la reconnaissance, la génération de payloads, les attaques par identifiants, la cryptographie, l'encodage et le reporting d'engagement.

    339
  • 5

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Le système d'action pour la cybersécurité native IA—où l'intention devient une exécution gouvernée, les preuves deviennent une mémoire opérationnelle, et chaque opération améliore la suivante.

    258
  • 6

    antifox

    antifox-ai/antifox

    Plateforme de test d'intrusion autonome multi-agents par IA qui exécute la reconnaissance, la découverte de la surface d'attaque, la validation de l'exploitation et la livraison de rapports étayés par des preuves.

    254

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →