Skip to main content
Cybersécurité

Qu’est-ce que l’injection NoSQL ? Comment fonctionne-t-elle et comment la prévenir ?

L’injection NoSQL permet aux attaquants de manipuler les requêtes de base de données via des entrées non assainies, jusqu’à contourner l’authentification, voler des données ou exécuter du code à distance.

Par SentinelOne
Reviewer: Jackie Lehmann
Qu’est-ce que l’injection NoSQL ? Comment fonctionne-t-elle et comment la prévenir ?

Points clés

  • L’injection NoSQL permet aux attaquants de modifier les requêtes envoyées à des bases de données comme MongoDB, Redis et CouchDB en introduisant des opérateurs malveillants ou du JavaScript dans des entrées utilisateur non assainies. Elle est classée CWE-943 et relève de la catégorie Injection de l’OWASP Top 10 (A03:2021, A05:2025).
  • La technique la plus courante est l’injection d’opérateurs. Une charge utile comme {"$ne":"invalid"} peut contourner une authentification en une seule requête. Une extraction aveugle par $regex peut voler des mots de passe et des jetons de réinitialisation, caractère par caractère.
  • Les causes principales sont l’absence de contrôle des types, la coercition de types par les frameworks Express.js et PHP, le maintien de JavaScript côté serveur et les failles de la couche ORM, comme les CVE de Mongoose. Ensemble, elles peuvent entraîner des vols de données, des dénis de service et l’exécution de code à distance.
  • Des CVE réelles dans Rocket.Chat, Parse Server, AquilaCMS, Ubiquiti UniFi et @feathersjs/mongodb montrent que l’injection NoSQL continue d’apparaître dans les systèmes de production. Plusieurs nouvelles CVE ont été publiées en 2026.
  • Pour prévenir l’injection NoSQL, imposez des types scalaires avant de construire les requêtes, rejetez les clés commençant par $, désactivez JavaScript côté serveur, validez les entrées à l’aide de schémas (Joi, Ajv, Zod) et appliquez le principe du moindre privilège. Associez ces contrôles à une surveillance en cours d’exécution pour détecter les attaques qui passent au travers.

Qu’est-ce que l’injection NoSQL ?

L’injection NoSQL est une vulnérabilité qui permet aux attaquants de manipuler les requêtes envoyées aux bases de données NoSQL en introduisant des opérateurs malveillants, du code JavaScript ou une syntaxe spécialement conçue dans des entrées utilisateur non assainies. Répertoriée sous CWE-943 dans la Common Weakness Enumeration (CWE), sous l’intitulé « Neutralisation incorrecte des éléments spéciaux dans la logique des requêtes de données », elle cible des bases de données comme MongoDB, Redis, Cassandra et Elasticsearch, qui utilisent des langages de requête flexibles sans schéma plutôt que le SQL standard.

Une exploitation réussie va bien au-delà d’une seule requête malveillante. Un attaquant peut contourner entièrement l’authentification, extraire des données sensibles caractère par caractère, modifier des enregistrements, provoquer un déni de service ou exécuter du code arbitraire sur le serveur. Comme l’indique OWASP WSTG, « les conséquences potentielles sont plus importantes qu’avec l’injection SQL traditionnelle », car les charges utiles d’une injection NoSQL peuvent s’exécuter dans un langage procédural comme JavaScript, et pas seulement dans un langage de requête déclaratif.

Les bases de données NoSQL font désormais fonctionner aussi bien les systèmes d’authentification et les plateformes de chat que les catalogues e-commerce et les consoles de gestion IoT. Leur adoption croissante, associée à l’idée fausse selon laquelle « sans SQL, il n’y a pas d’injection », fait de cette catégorie de vulnérabilités un risque persistant. Ce mythe est faux, et les attaquants comptent dessus. 

Avant d’examiner le fonctionnement concret de l’injection NoSQL, situons-la dans les frameworks standard de classification des vulnérabilités.

Classification OWASP

L’OWASP classe l’injection NoSQL dans la catégorie Injection de ses Top 10 de 2021 et de 2025. Elle appartient à la même famille de risques que l’injection SQL, mais sa cause première relève d’une classification différente, ce qui change la manière de la tester et de la signaler.

La distinction essentielle tient à la correspondance avec les CWE. L’injection SQL classique relève de CWE-89 (Neutralisation incorrecte des éléments spéciaux utilisés dans une commande SQL), tandis que l’injection NoSQL correspond à CWE-943 (Neutralisation incorrecte des éléments spéciaux dans la logique des requêtes de données). CWE-943 couvre les langages de requête autres que SQL, notamment les opérateurs Binary JSON (BSON) de MongoDB, les commandes du protocole Redis et les requêtes REST de CouchDB.

Référence
Identifiant
Description

OWASP Top 10 (2021)

A03:2021

Injection

OWASP Top 10 (2025)

A05:2025

Injection

CWE

CWE-943

Neutralisation incorrecte des éléments spéciaux dans la logique des requêtes de données

Guide de test de l’OWASP

WSTG-INPV-05.6

Tester l’injection NoSQL

Si votre programme de tests de sécurité ou vos rapports de conformité ne suivent que CWE-89, les cas d’injection NoSQL risquent d’être mal classés ou de passer totalement inaperçus. Alignez vos outils et votre taxonomie sur CWE-943 pour éliminer cet angle mort. 

Une fois la classification établie, examinons les mécanismes précis utilisés par les attaquants pour exploiter les interfaces de requête NoSQL.

Comment fonctionne l’injection NoSQL ?

L’injection NoSQL exploite l’écart entre les entrées utilisateur attendues par votre application et celles qu’elle reçoit réellement. Alors que l’injection SQL cible un langage de requête universel, l’injection NoSQL varie selon la base de données. MongoDB utilise des opérateurs de requête BSON/JSON, Redis utilise le protocole de communication Redis Serialization Protocol (RESP) et CouchDB expose une API HTTP REST. Chaque base de données présente une surface d'attaque, mais le principe reste le même : des données contrôlées par l'utilisateur entrent dans une requête sans validation adéquate et en modifient la logique.

Injection d'opérateurs : le schéma le plus courant

Dans une application Node.js classique utilisant MongoDB, un endpoint de connexion peut construire une requête comme celle-ci :

Operator injection

Une requête légitime envoie {"username":"admin","password":"secret"}. Mais un attaquant peut soumettre :

JSON

L'opérateur $ne (différent de) demande à MongoDB de renvoyer tous les utilisateurs dont le nom d'utilisateur et le mot de passe ne sont pas égaux à "invalid", ce qui correspond à tous les comptes valides. L'authentification est contournée en une seule requête, sans attaque par force brute.

Injection JavaScript via $where

Lorsque les applications transmettent des données utilisateur à l'opérateur $where de MongoDB ou à des fonctions comme mapReduce, $accumulator ou $function, la base de données les exécute comme du JavaScript côté serveur. Un attaquant qui injecte une boucle occupant les ressources peut bloquer l'instance MongoDB et provoquer un déni de service. Au-delà de l'accès aux données, l'exécution de JavaScript arbitraire peut conduire à l'exécution de code à distance sur le serveur de base de données.

Extraction à l'aveugle

Lorsque l'application ne renvoie pas directement les résultats des requêtes, les attaquants utilisent des techniques fondées sur des conditions booléennes ou sur le temps de réponse pour extraire les données caractère par caractère. En soumettant des expressions régulières comme password[$regex]=^a et en observant si la réponse diffère de celle d'une condition connue comme fausse, un attaquant peut reconstituer des mots de passe, des tokens et d'autres secrets sans jamais observer directement de fuite de données.

Injection de commandes Redis via CRLF

Dans RESP, les commandes sont séparées par des séquences de retour chariot et de saut de ligne (CRLF) (\r\n). Lorsqu'une application concatène des données utilisateur dans des commandes du protocole Redis sans les assainir, un attaquant peut injecter des séquences CRLF pour terminer la commande en cours et ajouter des commandes non autorisées sur la même connexion.

Redis stocke les données sous forme de paires clé-valeur. Des commandes injectées comme SET, GET et CONFIG peuvent lire des données sensibles, écraser des clés ou reconfigurer entièrement le serveur. Cette technique est souvent combinée à une attaque de type Server-Side Request Forgery (SSRF) : l'attaquant exploite une faille SSRF pour atteindre une instance Redis interne inaccessible depuis Internet, puis injecte des commandes supplémentaires par ce canal.

Injection via l'API HTTP de CouchDB

CouchDB expose une API REST/HTTP : toutes les opérations de base de données passent par des requêtes HTTP standard avec des charges utiles JSON. Une injection survient lorsqu'une application transmet des données utilisateur non assainies aux paramètres de requête, aux définitions de vues ou aux objets sélecteurs Mango de CouchDB.

Les vues MapReduce de CouchDB étant écrites en JavaScript, elles présentent un risque d'exécution côté serveur similaire à celui de l'opérateur $where de MongoDB. Un attaquant capable d'influencer le JavaScript exécuté dans une vue MapReduce peut exécuter du code arbitraire sur le serveur de base de données. La fonction de réplication de CouchDB peut également être détournée au moyen de requêtes HTTP spécialement conçues pour déclencher une attaque SSRF contre des services internes.

Chaque base de données NoSQL présente une surface d'attaque distincte, qu'il s'agisse des opérateurs BSON de MongoDB, de l'injection CRLF au niveau du protocole Redis ou de l'API REST de CouchDB. Vos défenses contre les injections NoSQL doivent être adaptées à l'interface de requête propre à chaque base de données.

Ces mécanismes fonctionnent quels que soient le type de contenu, la couche de transport ou le framework. Leurs causes profondes se répètent, et cette répétition donne un avantage aux défenseurs.

Causes des injections NoSQL

Une injection NoSQL ne résulte pas d'une seule erreur de code. Elle découle d'hypothèses architecturales, de comportements des frameworks et de contrôles de validation manquants, dont les effets se cumulent à l'exécution.

Validation insuffisante des entrées et absence de contrôle des types

Votre application peut supposer qu'un champ comme password arrive toujours sous forme de chaîne, mais les corps de requêtes HTTP, les charges utiles JSON et les paramètres encodés dans l'URL peuvent contenir des objets et des tableaux. Quand le body-parser d'Express.js reçoit password[$ne]=x, il le désérialise automatiquement en { password: { $ne: "x" } }, un objet contenant un opérateur MongoDB, avant même que le code de l'application ne le traite.

Construction dynamique des requêtes

Si vous construisez des requêtes par concaténation ou interpolation de chaînes plutôt qu'avec des objets de requête structurés, les attaquants peuvent rompre la syntaxe et injecter une nouvelle logique. Le forum MongoDB confirme : « Dans la plupart des cas, les injections externes résultent d'une concaténation non sécurisée de chaînes lors de la création de requêtes. »

JavaScript côté serveur laissé activé

MongoDB prend en charge l'exécution de JavaScript au moyen de $where, mapReduce, $accumulator et $function. La liste de contrôle MongoDB recommande explicitement de désactiver les scripts côté serveur avec --noscripting lorsque ces opérations ne sont pas utilisées. Les laisser activés crée une surface d'attaque propice à l'exécution de code arbitraire.

Conversion des types au niveau du framework

PHP convertit automatiquement username[$ne]=toto en ['username' => ['$ne' => 'toto']]. Le body-parser d'Express.js fait de même avec les données de formulaire encodées dans l'URL et désérialise password[$ne]=x en { password: { $ne: "x" } }, un objet contenant un opérateur MongoDB, avant même que la requête n'atteigne le code de l'application. Ces comportements des frameworks transforment des paramètres HTTP d'apparence inoffensive en opérateurs de base de données, sans intervention délibérée du développeur.

Vulnérabilités de la couche ORM

Même si MongoDB est renforcé, la bibliothèque de mapping objet-relationnel (ORM) de votre application peut créer des surfaces d'injection. CVE-2024-53900 a montré que l'opérateur $where de Mongoose pouvait être exploité au moyen d'entrées contrôlées par l'utilisateur, et CVE-2025-23061, qui révèle un correctif incomplet pour la première vulnérabilité, a montré que $where pouvait encore être contourné en l'imbriquant sous $or dans la fonctionnalité populate().match de Mongoose, contournant entièrement les protections au niveau du serveur.

Validation désactivée au niveau du protocole filaire

MongoDB valide les documents entrants au niveau du protocole filaire grâce au paramètre net.wireObjectCheck. Sa désactivation supprime un garde-fou structurel qui empêche les données BSON malformées d'atteindre le moteur de requêtes.

Ces causes créent une surface d'attaque qui s'étend de l'analyse des requêtes HTTP à l'exécution en base de données, avec des risques directs pour l'entreprise.

Impact et risques

L'injection NoSQL touche toutes les dimensions de la triade confidentialité, intégrité et disponibilité (CIA), souvent simultanément.

  • Confidentialité : Les attaquants peuvent lire des documents arbitraires, énumérer les noms de champs et extraire des identifiants caractère par caractère grâce à des techniques d'injection aveugle. Dans CVE-2021-22911, des chercheurs ont divulgué des hachages de mots de passe administrateur et des jetons de réinitialisation de mot de passe provenant d'instances Rocket.Chat.
  • Intégrité : L'injection d'opérateurs et l'exploitation abusive des requêtes brutes donnent aux attaquants la possibilité de modifier, remplacer ou supprimer des documents. Des requêtes ajoutées à des requêtes légitimes peuvent insérer de nouveaux enregistrements ou écraser les valeurs de champs existants.
  • Disponibilité : Une charge utile $where exécutée en boucle peut saturer une instance MongoDB et rendre la base de données indisponible, sans inondation du réseau.
  • Le contournement de l'authentification est l'un des impacts les plus souvent documentés. L'injection NoSQL devient ainsi une voie d'accès initiale directe aux applications exposées sur Internet.
  • Les risques liés à la chaîne d'approvisionnement et aux utilisateurs en aval amplifient l'impact de l'injection NoSQL dans les plateformes. Lorsqu'une vulnérabilité compromet une plateforme comme Rocket. Chat ou Parse Server, ses effets s'étendent aux clients et aux utilisateurs en aval. Une seule faille d'injection dans un produit backend-as-a-service peut exposer de nombreuses applications construites sur cette plateforme et compromettre plusieurs environnements.
  • Les conséquences réglementaires et de conformité découlent directement des atteintes à la confidentialité. Lorsque l'injection NoSQL entraîne l'exfiltration de données personnelles, d'identifiants ou de communications avec les clients, les organisations sont soumises à des obligations de notification des violations prévues par des réglementations et normes comme le GDPR, la HIPAA, PCI DSS et les lois sur la protection de la vie privée en vigueur dans les États. La technique d'extraction caractère par caractère utilisée dans les attaques par injection aveugle peut exfiltrer discrètement des données sensibles pendant de longues périodes. Cette fuite progressive passe facilement inaperçue. Une détection précoce est donc essentielle.
  • L'exécution de code à distance est confirmée par l'évaluation de JavaScript côté serveur. L'OWASP WSTG indique que « JavaScript étant un langage complet, un attaquant peut non seulement manipuler des données, mais aussi exécuter du code arbitraire ». Un article du Symposium international 2025 sur l'investigation numérique et la sécurité (ISDFS) décrit ce risque sans détour : « JavaScript est si puissant qu'exposer une telle vulnérabilité revient à remettre une mitrailleuse à un grand criminel. »

Les défenseurs qui connaissent la méthode des attaquants peuvent les stopper à chaque étape. Voici comment ils procèdent.

Comment les attaquants exploitent l'injection NoSQL

Les attaquants suivent une méthode structurée pour trouver et exploiter les failles d'injection NoSQL, de la reconnaissance à l'exfiltration de données ou à l'exécution de code.

Phase 1 : découverte des vecteurs d'entrée

L'attaquant repère les paramètres transmis à un backend NoSQL : paramètres d'URL, corps de requêtes POST au format JSON, en-têtes HTTP et messages WebSocket. Il soumet des caractères de fuzzing (' " \ ; { }) et observe les messages d’erreur ou les changements de comportement qui révèlent une interaction avec la base de données.

Phase 2 : confirmation de l’injection d’opérateurs

Sur un endpoint de connexion, l’attaquant remplace une chaîne d’identifiants normale par un opérateur $ne :

Operator Injection Json

Si l’application connecte l’attaquant sous le compte d’un autre utilisateur, l’injection d’opérateurs est confirmée. L’attaquant peut aussi tester l’opérateur $gt (supérieur à) pour obtenir une autre confirmation :

Operator Injection Json 1

L’opérateur $gt associé à une chaîne vide correspond à tout mot de passe non vide. Si la connexion au compte administrateur réussit sans mot de passe valide, l’injection d’opérateurs est confirmée une seconde fois.

Phase 3 : contournement de l’authentification

L’attaquant passe à l’étape suivante en injectant des opérateurs dans les deux champs :

Authentication Bypass

Cette requête cible les comptes privilégiés et renvoie le premier utilisateur dont le nom figure dans la liste et dont le mot de passe est une chaîne non vide.

Phase 4 : exfiltration de données

En exploitant $where via une injection JavaScript, l’attaquant vérifie l’existence d’un champ :

Data Exfiltration

Si la réponse correspond à un schéma valide connu, le champ resetToken existe. L’attaquant extrait ensuite sa valeur caractère par caractère au moyen d’une injection aveugle fondée sur des réponses booléennes. La technique consiste à soumettre une expression régulière comme {"resetToken":{"$regex":"^A"}} et à observer la réponse HTTP. Un code de statut indiquant une réussite ou un contenu de réponse précis signifie que le caractère correspond. Une réponse différente indique le contraire. L’attaquant parcourt chaque position en testant tous les caractères possibles à chaque étape. Comme le montre CVE-2024-37405, cette extraction peut s’effectuer par des requêtes différentielles répétées. L’injection aveugle constitue donc une attaque concrète, et non un simple risque théorique.

Phase 5 : élévation des privilèges et mouvement latéral

Grâce aux identifiants ou aux jetons de réinitialisation extraits, l’attaquant obtient un accès administrateur. Il peut alors atteindre les systèmes backend, accéder à d’autres collections par injection dans le pipeline d’agrégation avec $lookup ou $unionWith (citée par PortSwigger parmi les principales techniques de piratage web), ou établir une persistance en exécutant du code côté serveur. L’injection dans le pipeline d’agrégation avec $lookup a un fort impact : elle peut lire des collections auxquelles la requête de l’application n’était pas censée accéder. Elle franchit ainsi les limites d’accès entre collections et expose des données dans toute la base.

Changement de type de contenu

Les attaquants alternent souvent entre application/x-www-form-urlencoded et application/json pour trouver des points d’injection propres à un seul type de contenu. Cette technique est particulièrement efficace contre les API REST qui gèrent plusieurs formats.

Ces techniques d’attaque s’appliquent partout où les bases de données NoSQL acceptent des données saisies par les utilisateurs. Certaines applications sont bien plus exposées que d’autres.

Qui est concerné ?

L’injection NoSQL touche toute application qui transmet des données contrôlées par l’utilisateur à une base de données NoSQL sans vérifier correctement leur type. D’après les CVE confirmées, les catégories d’applications les plus exposées sont les suivantes :

  • Systèmes d’authentification : Les endpoints de connexion constituent la surface d’attaque classique documentée par toutes les principales sources.
  • Plateformes de collaboration d’équipe : Rocket.Chat a fait l’objet de plusieurs CVE liées à l’injection NoSQL au fil des ans, dont une vulnérabilité exploitable avant l’authentification (CVE-2021-22911).
  • Applications Node.js/Express utilisant Mongoose : Mongoose, un outil de mappage objet-document (ODM), introduit des surfaces d'injection au niveau de la couche ORM, indépendamment des contrôles propres à MongoDB.
  • Backends de plateforme en tant que service : Parse Server (CVE-2022-24815, CVE-2026-30941) et Steedos Platform illustrent cette exposition dans les produits de backend en tant que service (CVE-2020-35666).
  • IoT et gestion des réseaux : l'application UniFi Network d'Ubiquiti a fait l'objet d'une CVE d'injection NoSQL confirmée par le fournisseur, permettant une élévation de privilèges.
  • Plateformes d'e-commerce : Une injection NoSQL dans la fonction de réinitialisation du mot de passe d'AquilaCMS a reçu une classification CRITICAL (CVE-2024-48573).
  • API GraphQL : Les arguments de filtre GraphQL non assainis, directement intégrés aux requêtes MongoDB, créent une surface d'injection souvent négligée.

MongoDB est largement utilisé, tout comme Node.js/Express pour le développement backend. Leur combinaison crée une vaste surface d'attaque. NIST IR 8504 reconnaît officiellement l'injection NoSQL comme une catégorie de risque pour les systèmes du gouvernement américain. Ce risque concerne donc aussi les entreprises, et pas seulement les startups ou les environnements SaaS.

Les API GraphQL constituent un vecteur de plus en plus courant : les arguments de filtre sont souvent intégrés directement aux requêtes MongoDB sans liste d'autorisation explicite. Ce schéma est mal couvert par les règles des pare-feu d'applications web traditionnels traditionnels pare-feu d'application web (WAF) axées sur les charges utiles de type SQL.

Le point commun n'est pas le secteur, mais la pile technologique. Si votre application utilise MongoDB, Redis, CouchDB ou Elasticsearch avec des données saisies par les utilisateurs, elle constitue une cible potentielle. C'est particulièrement vrai si elle repose sur des frameworks JavaScript qui effectuent une conversion automatique des types. Les incidents confirmés ci-dessous montrent comment ces failles sont exploitées en pratique.

Exemples concrets

Les CVE confirmées et les chaînes d'exploitation publiées montrent comment l'injection NoSQL touche les systèmes en production, des plateformes de collaboration et d'e-commerce aux produits de backend en tant que service et aux infrastructures réseau.

Rocket.Chat : prise de contrôle d'un compte administrateur sans authentification préalable (CVE-2021-22911)

Les recherches de SonarSource ont montré que la méthode getPasswordPolicy() de Rocket.Chat pouvait être appelée sans authentification. En injectant l'opérateur $regex de MongoDB dans le paramètre du jeton de réinitialisation du mot de passe, un attaquant pouvait extraire le jeton caractère par caractère en envoyant {"$regex":"^A"} et en observant les différences entre les réponses.

Le rapport confirmé HackerOne a détaillé la chaîne d'attaque : divulgation des noms d'utilisateur administrateur, des adresses e-mail, des empreintes de mots de passe et des jetons de réinitialisation, jusqu'à la prise de contrôle complète d'un compte administrateur.

@feathersjs/mongodb : injection d'objets via WebSocket (CVE-2026-29793)

Les clients Socket.IO pouvaient transmettre des objets JavaScript arbitraires comme argument id à n'importe quelle méthode de service Feathers. La couche de transport ne vérifiait pas le type. L'envoi de {$ne: null} comme argument id correspondait à tous les documents d'une collection. Cette vulnérabilité est référencée sous CVE-2026-29793.

Ubiquiti UniFi : élévation de privilèges après authentification (CVE-2026-22557)

Un avis d'Ubiquiti a confirmé une vulnérabilité d'injection NoSQL dans l'application UniFi Network, exploitable après authentification et permettant une élévation de privilèges. Tout utilisateur authentifié pouvait exploiter cette faille pour obtenir des droits élevés, transformant un compte à faibles privilèges en un accès administrateur complet à l'infrastructure réseau.

Rocket.Chat Livechat : injection en chaîne (CVE-2024-37405)

Deux points d’injection NoSQL distincts ont été enchaînés: extraction d’un jeton de visiteur via $regex par injection aveugle, suivie d’une seconde injection dans le paramètre rid pour extraire tous les messages Livechat. Cette attaque sans authentification préalable a exposé les données des échanges avec les clients.

AquilaCMS : injection critique dans la réinitialisation des mots de passe (CVE-2024-48573)

AquilaCMS, une plateforme e-commerce open source, a reçu une note CRITIQUE (9.8) pour une vulnérabilité d'injection NoSQL dans sa fonction de réinitialisation du mot de passe. Un attaquant non authentifié pouvait manipuler le processus de réinitialisation en injectant des opérateurs MongoDB dans le paramètre du jeton de réinitialisation, contournant ainsi entièrement la logique de validation prévue. Comme AquilaCMS est utilisé par des boutiques en ligne, une exploitation réussie mettait en danger les données des comptes clients, les informations de paiement et les historiques de commandes. La vulnérabilité ne nécessitait aucune authentification et pouvait être exploitée à distance au moyen d'une requête HTTP standard, par tout attaquant disposant d'un accès réseau à la boutique en ligne.

Parse Server : vulnérabilités d’injection récurrentes (CVE-2022-24815, CVE-2026-30941)

Parse Server, plateforme backend-as-a-service open source largement utilisée, a présenté des vulnérabilités d’injection NoSQL récurrentes au fil des années. CVE-2022-24815 associait la pollution de prototype à l’injection NoSQL. Cette vulnérabilité montre comment des failles de la couche JavaScript et de la base de données peuvent se combiner pour ouvrir des voies d’exploitation qu’aucune des deux n’offrirait seule. Des années plus tard, CVE-2026-30941 a révélé que la plateforme présentait encore des points d’injection : des valeurs de jeton étaient transmises aux requêtes de base de données sans validation de leur type. Les produits backend-as-a-service sont des cibles de choix, car une seule vulnérabilité touche toutes les applications construites sur la plateforme. Si Parse Server est compromis, les applications mobiles, les applications web et les backends IoT qui en dépendent peuvent être exposés à la même vulnérabilité.

Ces incidents couvrent plusieurs années et piles technologiques. L’injection NoSQL réapparaît sans cesse dans les systèmes en production. La chronologie montre depuis combien de temps cette tendance persiste.

Chronologie des injections NoSQL

Année
Événement marquant

2011

Bryan Sullivan (Adobe) nomme officiellement « NoSQL Injection » cette catégorie de vulnérabilités lors de Black Hat USA

2013

DEF CON 21 accueille la première présentation consacrée à l’injection NoSQL

2016

IEEE Security & Privacy publie une analyse évaluée par les pairs sur l’injection NoSQL qui contourne les défenses périmétriques

2018

CVE-2018-1784 touche un logiciel d’entreprise IBM par injection NoSQL, avec un score CVSS critique de 9,8

2021

CVE-2021-22911 permet de prendre le contrôle administrateur d’instances Rocket.Chat sans authentification préalable ; l’OWASP Top 10 A03:2021 conserve la catégorie Injection, qui englobe officiellement l’injection NoSQL

2023

NIST IR 8504 reconnaît officiellement l’injection NoSQL comme une catégorie de risque pour le gouvernement américain

2024

PortSwigger classe l’injection dans le pipeline d’agrégation MongoDB parmi les principales techniques de piratage web ; CVE-2024-48573 obtient un score CVSS de 9,8

2025

OWASP Top 10 conserve la catégorie Injection ; l’ORM Mongoose fait l’objet d’une deuxième CVE liée à une injection (CVE-2025-23061)

Mars 2026

Plusieurs CVE liées à des injections NoSQL sont publiées pour Rocket.Chat, @feathersjs/mongodb, Parse Server et Wakyma

La série de CVE publiées en 2026 indique que les chercheurs s’intéressent davantage aux piles Node.js/MongoDB. Elle suggère que l’injection NoSQL attire de nouveau l’attention, loin de disparaître. Cette évolution fait de la détection une priorité. Bonne nouvelle : les signaux sont bien connus.

Comment détecter les injections NoSQL

Pour détecter les injections NoSQL, combinez l’analyse statique du code, les tests dynamiques sur des endpoints actifs et la surveillance des comportements à l’exécution. Vous repérerez ainsi les exploitations qui échappent à vos autres contrôles.

Analyse statique et revue du code

Examinez votre base de code pour repérer les schémas à haut risque. Signalez toute utilisation de Mongoose .find(), .findOne(), ou .populate() qui transmet directement req.body, req.query, ou req.params sans vérification des types. Recherchez toute utilisation de $where avec des données contrôlées par l'utilisateur, tout pipeline d'agrégation intégrant des objets de filtrage contrôlés par l'utilisateur et tout endpoint acceptant des objets de requête JSON bruts envoyés par les clients. Signalez également toute utilisation de eval(), Function(), ou de littéraux de gabarit qui concatènent des données utilisateur dans des chaînes de requête. Examinez particulièrement les pipelines d'agrégation utilisant $lookup ou $unionWith avec des noms de collections ou des étapes de pipeline contrôlés par l'utilisateur, car ils peuvent franchir les limites d'accès entre collections.

Tests dynamiques

Appliquez la méthode OWASP WSTG-INPV-05.6 :

  1. Soumettez la chaîne de test '"\{ ;$Foo} $Foo \xYZ` pour repérer les points d'injection syntaxique.
  2. Soumettez les caractères spéciaux ' " \ ; { } pour repérer les points d'injection d'opérateurs.
  3. Utilisez la pollution des paramètres HTTP pour injecter un paramètre $where et observez les erreurs renvoyées par MongoDB.
  4. Testez les différences de réponse entre des conditions connues comme vraies et d'autres connues comme fausses pour détecter les injections à l'aveugle.

Testez aussi spécifiquement les canaux WebSocket. CVE-2026-29793 a montré que les clients Socket.IO pouvaient envoyer des objets JavaScript arbitraires comme arguments de méthodes de service, échappant ainsi à toute inspection au niveau HTTP. De nombreux scanners se concentrent exclusivement sur les endpoints HTTP et ignorent entièrement les surfaces d'injection WebSocket. Des tests WebSocket manuels ou spécialisés comblent cette faille pour les applications reposant sur des frameworks de communication en temps réel.

Surveillance des comportements à l'exécution

Surveillez votre infrastructure pour détecter les indicateurs comportementaux d'une exploitation réussie :

  • Processus de services de base de données (mongod, redis-server) lançant des processus enfants ou des shells inattendus
  • Requêtes inhabituelles contenant des opérateurs MongoDB ($where, $regex, $ne, $gt) dans les journaux applicatifs
  • Pics d'utilisation du CPU sur les serveurs MongoDB sans hausse correspondante des requêtes légitimes
  • Les endpoints de réinitialisation des mots de passe reçoivent des objets plutôt que des chaînes dans les champs de jeton
  • Écarts de temps de réponse sur les endpoints accessibles publiquement suggérant une injection aveugle basée sur le temps

Outils de test d'intrusion

Des outils dédiés vous permettent de rechercher les injections NoSQL lors de vos évaluations :

  • NoSQLMap: Outil open source conçu spécifiquement pour tester et exploiter les injections NoSQL
  • nosqli: Outil en ligne de commande pour détecter automatiquement les injections NoSQL
  • Burp Suite: Tests manuels via les modules Repeater et Intruder, avec des extensions pour tester automatiquement les charges utiles NoSQL
  • OWASP ZAP: Règles d'analyse active applicables aux endpoints NoSQL

Savoir où chercher ne représente que la moitié du défi. L'autre moitié consiste à bâtir des défenses qui empêchent l'exploitation dès le départ.

Comment prévenir les injections NoSQL

Pour bloquer les injections NoSQL, imposez des types stricts à toutes les données saisies par les utilisateurs avant qu'elles n'atteignent la couche de base de données. Les défenses ci-dessous traitent chaque cause fondamentale identifiée précédemment, de la conversion de types au niveau du framework au contournement de la couche ORM.

Vérifiez les types avant de construire les requêtes

Rejetez tout champ de saisie qui n'est pas une valeur scalaire (chaîne, nombre, booléen) avant qu'il n'atteigne votre ORM ou votre pilote de base de données. La conversion explicite des types est la défense la plus efficace :

Supprimez ou rejetez les clés d'opérateur MongoDB

Vérifiez toutes les clés de req.body, req.query, et de req.params à la recherche de $ en début de clé et rejetez-les avant qu'elles n'atteignent la couche de base de données. Utilisez la vérification key.startsWith('$') plutôt qu'une expression régulière, dont les contournements connus sont documentés dans CVE-2021-22910.

Désactivez JavaScript côté serveur

Utilisez --noscripting ou set security.javascriptEnabled: false dans votre configuration MongoDB. Vous éliminez ainsi entièrement la surface d'attaque liée à $where. Privilégiez $expr et les générateurs de requêtes typées pour la logique conditionnelle.

Utilisez des frameworks de validation de schéma

Validez le type des données dès le début du traitement des requêtes avec des bibliothèques comme Joi, Ajv ou Zod. Elles rejettent les tableaux ou les objets lorsqu'une valeur scalaire est attendue, bloquant l'injection d'opérateurs avant qu'elle n'atteigne la base de données.

Fixez les versions de Mongoose et des ORM, surveillez les avis de sécurité

Les vulnérabilités de la couche ORM peuvent contourner entièrement les contrôles de l'application et de la base de données. CVE-2024-53900 et CVE-2025-23061 ont montré que la fonctionnalité populate().match de Mongoose pouvait être exploitée même lorsque JavaScript était désactivé côté serveur dans MongoDB. CVE-2025-23061 résultait d'un correctif incomplet pour CVE-2024-53900. Cela montre que les correctifs peuvent eux-mêmes être insuffisants et nécessiter une vérification indépendante.

Abonnez-vous aux avis de sécurité de Mongoose et des autres bibliothèques ODM/ORM. Fixez explicitement les versions des dépendances et vérifiez que chaque correctif de sécurité résout entièrement la vulnérabilité documentée avant de clôturer votre ticket de remédiation.

N'acceptez jamais de requêtes JSON brutes provenant des clients

La fiche pratique de l'OWASP le dit explicitement : « N'acceptez pas de requêtes JSON brutes provenant des clients. » Une charge utile telle que { "$where": "this.balance > 0" } envoyée par un client peut entraîner l'exécution de code à distance ou l'épuisement des ressources CPU.

Configurez la base de données selon le principe du moindre privilège

Utilisez des comptes de base de données dédiés à l'application, dotés des seules autorisations nécessaires. Ne vous connectez jamais avec des identifiants root ou administrateur. N'exposez pas les ports de la base de données ni les consoles d'administration à l'Internet public.

Maintenez la vérification des objets au niveau du protocole réseau activée

Le paramètre net.wireObjectCheck de MongoDB valide tous les documents au niveau du protocole réseau. Il est activé par défaut. Ne le désactivez jamais.

Sécurisez les filtres GraphQL

Traitez les arguments de filtre GraphQL au moyen d'une liste d'autorisation explicite. N'insérez jamais directement des objets non fiables dans les filtres de requête MongoDB ou Mongoose.

Des contrôles rigoureux au niveau de l'application réduisent la surface d'attaque. Ils ne peuvent pas l'éliminer entièrement. Une détection et une réponse à plusieurs niveaux couvrent ce qui passe entre les mailles du filet.

Outils de détection et de prévention

Une défense à plusieurs niveaux contre les injections NoSQL associe contrôles au niveau de l'application, outils de test et surveillance à l'exécution.

  • Les défenses au niveau de l'application comprennent les bibliothèques de validation des entrées (Joi, Ajv, Zod), les protections au niveau de l'ORM (validation des schémas Mongoose, conversion explicite des types) et les contrôles de sécurité intégrés à MongoDB (--noscripting, wireObjectCheck, contrôle d'accès fondé sur les rôles).
  • Les outils de test comme NoSQLMap, nosqli, Burp Suite et OWASP ZAP recherchent les injections NoSQL pendant les cycles de développement et de tests d'intrusion.
  • Les WAF constituent une couche de défense périmétrique capable de bloquer les schémas d'injection connus. Toutefois, les WAF reposent sur des règles fondées sur des signatures. Ils ne peuvent pas bloquer les nouvelles charges utiles, les opérateurs obscurcis ni les injections transitant par des canaux WebSocket.
  • La surveillance comportementale à l'exécution comble la faille laissée par les WAF. Les contrôles au niveau de l'application peuvent être contournés par de nouvelles charges utiles, des vulnérabilités de la couche ORM comme celle de populate().match dans Mongoose, ou des canaux WebSocket que les WAF n'inspectent pas. La surveillance à l'exécution observe les conséquences d'une injection réussie : des processus de base de données qui lancent des shells inattendus, des schémas anormaux d'exécution de JavaScript ou des volumes de requêtes inhabituels, quel que soit le mode de transmission de la charge utile. Lorsqu'une charge utile d'injection échappe à l'inspection fondée sur les signatures et atteint la base de données, le comportement anormal qui en résulte devient l'indicateur de compromission le plus fiable.

Comment SentinelOne intervient-il ?

L'inspection des charges utiles relève du WAF. SentinelOne surveille ce qui suit. La plateforme détecte et bloque les conséquences comportementales d'une injection NoSQL réussie : anomalies des processus, déplacements latéraux et activités post-exploitation qui échappent aux contrôles au niveau de l'application.

La Singularity™ Platform de SentinelOne comprend Singularity AI SIEM, qui corrèle les données de télémétrie des endpoints, des charges de travail cloud, des systèmes d'identité et des sources tierces dans un même lac de données. Lors des évaluations MITRE ATT&CK de 2024, Singularity Platform a atteint un taux de détection de 100 % sans aucun délai, tout en générant 88 % d'alertes en moins que la médiane. Moins d'alertes inutiles, c'est plus de temps pour vous concentrer sur les menaces confirmées. Lorsqu'une attaque par injection NoSQL passe d'une application web à un serveur de base de données, puis au vol d'identifiants, AI SIEM relie ces événements entre les différentes surfaces sans corrélation manuelle.

Dans Singularity Endpoint, la technologie Storyline relie en continu les événements de création de processus, les connexions réseau, les modifications de fichiers et l'utilisation des identifiants sur chaque endpoint protégé. Elle forme ainsi des chaînes de provenance cohérentes. Dans une attaque par exécution de JavaScript côté serveur fondée sur $where, Storyline relie automatiquement le processus du serveur web qui reçoit la requête malveillante, le service de base de données au comportement anormal, le processus d'interprétation lancé et tout shell enfant sous un même identifiant Storyline. Les règles personnalisées de Storyline Active Response (STAR) se déclenchent lorsque des processus de base de données comme mongod ou redis-server lancent des processus enfants inattendus, un indicateur comportemental fiable d'une injection de commandes réussie.

Purple AI™ accélère les investigations grâce aux requêtes en langage naturel. Selon IDC, les clients de Purple AI identifient les menaces 63% plus vite et réduisent de 55% le temps moyen de remédiation (MTTR). Vous pouvez demander "montre-moi tous les processus lancés par mongod au cours des dernières 24 heures" ou citer directement des techniques MITRE ATT&CK comme T1190 (Exploitation d'une application accessible au public) et T1059 (Interpréteur de commandes et de scripts). La fonctionnalité Auto Investigation de Purple AI recueille de façon autonome des preuves sur l'ensemble de la stack, synthétise les données sur les menaces et reconstitue la chronologie complète des attaques, ramenant à quelques minutes des investigations qui prenaient auparavant des heures.

Cloud Workload Security protège les bases de données NoSQL hébergées dans le cloud pendant leur exécution. Il surveille le comportement des workloads en temps réel et utilise Verified Exploit Paths pour faire ressortir des constats étayés par des preuves. Vous voyez quand une injection NoSQL visant une instance MongoDB ou Redis hébergée dans le cloud entraîne des activités post-exploitation.

Pour les organisations qui exploitent des bases de données NoSQL à grande échelle, ces capacités comblent l'écart entre la prévention au niveau applicatif et la visibilité sur les activités post-exploitation. 

Demandez une démo SentinelOne pour découvrir ces capacités en action.

Vulnérabilités associées

L'injection NoSQL partage des causes profondes et des schémas d'attaque avec plusieurs autres catégories de vulnérabilités :

  • Injection SQL (CWE-89) : Son équivalent dans les bases de données relationnelles. Toutes deux exploitent une neutralisation incorrecte des entrées utilisateur dans les requêtes de base de données. Mais la capacité de l'injection NoSQL à exécuter un langage procédural étend son impact au-delà de la manipulation des données, jusqu'à l'exécution de code arbitraire.
  • Falsification de requête côté serveur (SSRF) : L'injection CRLF dans Redis est souvent associée à la SSRF. Un attaquant utilise la SSRF pour atteindre une instance Redis interne, puis injecte des commandes supplémentaires au moyen de séquences CRLF.
  • Injection de commandes (CWE-78) : Lorsque l'injection NoSQL permet d'exécuter du JavaScript côté serveur via $where, la capacité obtenue est très proche de l'injection de commandes du système d'exploitation.
  • Pollution de prototype : CVE-2022-24815 dans Parse Server associait pollution de prototype et injection NoSQL, montrant comment les vulnérabilités de la couche JavaScript aggravent les injections dans les bases de données.
  • Cross-Site Scripting (XSS) : Le XSS et l'injection NoSQL découlent tous deux d'une validation insuffisante des entrées. Les organisations vulnérables à l'un présentent souvent des faiblesses de validation systémiques qui les exposent à l'autre.

Comprendre ces liens vous aide à prioriser les tests et les corrections entre les catégories de vulnérabilités associées, plutôt que de traiter chacune isolément. Le tableau suivant répertorie, à titre de référence, les CVE confirmées liées à l'injection NoSQL.

FAQ

Une injection NoSQL survient lorsque les données utilisateur ne sont pas séparées de la logique des requêtes. Le signal d'alerte concret : votre application laisse-t-elle des entrées non fiables devenir des opérateurs, du JavaScript ou des objets de requête entiers, quelle que soit la base de données utilisée ?

Elle apparaît souvent dans les parcours de connexion, les fonctions de réinitialisation de mot de passe, les filtres et les méthodes reposant sur WebSocket, plutôt que dans des paramètres de recherche manifestement non sécurisés.

Oui. Lorsque l'OWASP classe l'injection NoSQL dans la catégorie Injection, cela signifie que vous devez la traiter avec la même rigueur que l'injection SQL : revues de code sécurisé, tests ciblés, surveillance des dépendances et mesures de contrôle compensatoires.

Si votre programme ne suit que les injections SQL, vous risquez de manquer des voies d'attaque propres à MongoDB, Redis ou aux ORM qui relèvent de la même famille de risques.

Généralement, oui. C'est ce qui en fait un risque concret. De nombreux cas documentés commencent par des fonctions courantes accessibles depuis Internet, comme la connexion, la réinitialisation de mot de passe ou les API de chat. Les attaquants n'ont pas besoin d'accéder d'abord à la base de données.

Il leur suffit d'un endpoint accessible qui transmet les entrées à une requête sans vérifier leur type. L'exposition avant authentification devient ainsi le cas à traiter en priorité.

La conception de l'application est le meilleur indicateur. Le secteur d'activité compte moins. Les applications sont les plus exposées lorsqu'elles acceptent des filtres flexibles côté client, désérialisent automatiquement des paramètres imbriqués ou transmettent des objets de requête à MongoDB ou Mongoose sans véritable transformation.

Les processus d'authentification exigent une attention particulière : même une faille d'injection limitée peut compromettre la frontière de confiance du reste de l'application.

Les attaquants cherchent généralement d'abord les endroits où le comportement de l'application change lorsque la structure des données saisies change. Un indice clé : un paramètre censé être une chaîne de caractères est accepté sous forme d'objet, de tableau ou de champ de formulaire imbriqué.

Ils comparent aussi les types de contenu et les couches de transport, car un endpoint peut être sûr avec JSON, mais vulnérable avec des données encodées dans une URL ou des messages WebSocket.

Les premiers signes ressemblent souvent à une utilisation abusive de l'application avant d'évoquer une compromission confirmée. Par exemple : des champs de connexion ou de réinitialisation de mot de passe reçus sous forme d'objets, l'apparition soudaine d'opérateurs dans les journaux des requêtes ou de l'application, ou de petites variations répétées des réponses, compatibles avec une extraction en aveugle.

Pour les défenseurs, ces signes peuvent précéder les shells, les mouvements latéraux ou les transferts massifs de données.

La gravité dépend de la place de la requête vulnérable dans le processus. Une faille dans un filtre peu sensible peut exposer peu de données. Mais une faille touchant la réinitialisation de mot de passe, la recherche de comptes ou l'exécution de JavaScript côté serveur peut ouvrir un accès initial aux conséquences pour l'ensemble du système.

C'est pourquoi vous devez évaluer une injection NoSQL à la fois comme une faille applicative et comme un point d'entrée potentiel pour une intrusion.

En savoir plus sur Cybersécurité

Decorative background gradient

Découvrez la plateforme de cybersécurité la plus avancée

Découvrez comment la plateforme de cybersécurité autonome la plus intelligente au monde peut protéger votre organisation aujourd’hui et à l’avenir.
Dark dashboard UI with purple-highlighted nav, summary cards showing 149, 7, 78, 56, 1.2 h, and a status table with linked purple text