Éviter les vulnérabilités d’affectation de masse dans Node.js

L’affectation de masse est une vulnérabilité qui permet aux attaquants d’exploiter des modèles d’enregistrements prévisibles et de déclencher des actions illégales. Elle se produit généralement lorsque les propriétés ne sont pas filtrées lors de la liaison des données fournies par le client aux modèles de données. Les vulnérabilités de ce type permettent à un attaquant d’ajouter des objets dans les charges utiles des requêtes POST, afin de modifier des propriétés qui devraient être immuables.

Node.js est un environnement serveur open source qui peut être utilisé sur différentes plateformes pour développer des applications web. Il permet aux développeurs de créer rapidement des applications puissantes et évolutives. Node.js est une plateforme éprouvée et prête pour la production, mais la sécurité des applications pose des défis liés à la sécurité de la chaîne d’approvisionnement et aux packages tiers installés pour créer les applications. La création d’une application Node.js peut faire appel à des milliers de packages npm open source issus du registre npm, ce qui l’expose à de nombreux vecteurs d’attaque.

Les vulnérabilités d’affectation de masse sont courantes dans les applications Node.js qui envoient des charges utiles à la base de données dans des requêtes POST. Un attaquant peut exploiter ces vulnérabilités pour orchestrer des attaques par injection SQL ou d’autres attaques visant les données stockées dans les bases de données. Une vulnérabilité d’affectation de masse peut permettre à un attaquant de prendre le contrôle total d’un système ou de dérober des données sensibles. Il est donc essentiel de se protéger contre ce type d’attaque.

Cet article montre comment une vulnérabilité d’affectation de masse peut se produire dans un projet Node.js, comment un attaquant peut l’exploiter et comment protéger une application web contre ce type de menace.

Éliminer les vulnérabilités d’affectation de masse dans Node.js

Cet exemple utilise Mongoose, une bibliothèque de modélisation des données objet (ODM) pour Node.js et MongoDB. Elle fait le lien entre les objets du code et ceux de MongoDB, valide les schémas et facilite la gestion des relations entre les données.

Comme indiqué ci-dessus, pour protéger une application Node.js avec MongoDB contre l’affectation de masse, vous devez intervenir dans Mongoose. Voici un exemple d’exploitation d’une vulnérabilité d’affectation de masse dans une application Node.js.

Prérequis

Pour suivre ce projet, vous aurez besoin des éléments suivants :

• Node.js installé

• Un accès à une base de données MongoDB et une chaîne de connexion valide. Ce tutoriel utilise un environnement cloud MongoDB Atlas, mais vous pouvez aussi lancer un serveur MongoDB local et mettre à jour la chaîne de connexion en conséquence.

L’affectation de masse dans Node.js

Pour commencer ce projet, ouvrez votre terminal et exécutez cette commande :

1npm init

Vous devez ensuite installer les dépendances :

1npm i mongoose
2npm i express

Pour gérer les données du formulaire ci-dessus, nous avons besoin d’un fichier newUser.js dans le dossier models pour gérer le schéma utilisateur.

1const mongoose = require('mongoose');
2
3const Schema = mongoose.Schema;
4
5const userSchema = new Schema({
6
7    first_name: String,
8    last_name: String,
9    email: String,
10    password: String,
11    isAdmin: {
12        type: Boolean,
13        protect: true,
14        default: false
15    }
16
17});
18
19const User = mongoose.model("User", userSchema);
20
21module.exports = User;
22

Ce modèle contient tous les champs du formulaire d’inscription. Le champ supplémentaire isAdmin, de type Boolean, définit le rôle de l’utilisateur. Si vous définissez ce champ sur true, vous créez un utilisateur doté de privilèges d’administrateur. Si vous le définissez sur false, l’utilisateur n’aura pas ces privilèges.

Créez un répertoire nommé routes, puis ajoutez-y le fichier routes.js pour gérer les informations des utilisateurs :

1    const express = require("express");
2    const userModel = require("../models/newUser");
3
4    const app = express();
5
6    app.post("/add_user", async (request, response) => {
7        const user = new userModel(request.body);
8
9        try {
10          await user.save();
11          response.send(user);
12        } catch (error) {
13          response.status(500).send(error);
14        }
15    });
16
17module.exports = app;

Le code ci-dessus récupère les données du formulaire, puis les structure à l’aide du modèle newUSer.

Ce code comporte deux failles qui introduisent une vulnérabilité d’affectation de masse. Premièrement, il utilise un nom et un type courants pour un champ sensible : isAdmin. Deuxièmement, le modèle utilisateur contient un champ sensible inutilisé. Pour exploiter la vulnérabilité, démarrons un serveur.

Créez un fichier nommé server.js à la racine du projet et ajoutez-y le code suivant, en remplaçant <APP_ID> par la valeur figurant dans votre chaîne de connexion :

1const express = require("express");
2const mongoose = require("mongoose");
3const Router = require("./routes/routes")
4
5const app = express();
6
7app.use(express.json());
8
9const username = "<USER>";
10const password = "<USER_PASSWORD>";
11const cluster = "<CLUSTER>";
12const dbname = "<DATABSE_NAME>";
13
14mongoose.connect(
15  `mongodb+srv://${username}:${password}@${cluster}.<APP_ID>.mongodb.net/${dbname}?retryWrites=true&w=majority`,
16  {
17    useNewUrlParser: true,
18    useUnifiedTopology: true
19  }
20);
21
22const db = mongoose.connection;
23db.on("error", console.error.bind(console, "connection error: "));
24db.once("open", function () {
25  console.log("Connected successfully");
26});
27
28app.use(Router);
29
30app.listen(3000, () => {
31  console.log("Server is running at port 3000");
32});
33

Démarrez le serveur en exécutant node server.js.

Un acteur malveillant peut exploiter cette vulnérabilité en créant une requête curl POST qui contient le champ isAdmin défini sur true, comme dans le code ci-dessous :

1curl --location --request POST 'http://localhost:3000/add_user' \
2--header 'Content-Type: application/json' \
3--data-raw '{
4    "first_name": "Mike",
5    "last_name": "Jones",
6    "email": "mikejones@hmail.com",
7    "isAdmin":"true"
8}'

La requête ci-dessus crée un utilisateur, Mike, doté de privilèges d’administrateur. Cet utilisateur peut désormais se connecter au système avec ses identifiants et effectuer toutes les actions accessibles à un administrateur.

Se protéger contre l’affectation de masse

Nous pouvons renforcer la protection de l’application contre les attaques par affectation de masse en procédant à trois ajustements.

Créer des modèles allégés

Les modèles allégés ne contiennent que les champs que l’utilisateur est censé renseigner et excluent les champs sensibles.

Dans l’exemple ci-dessus, la première mesure, et la plus importante, consiste à supprimer le champ sensible du modèle newUser, comme indiqué ci-dessous :

1const mongoose = require("mongoose");
2
3// create a schema
4var userSchema = new mongoose.Schema({
5	first_name: String,
6	last_name: String,
7	email: String,
8	password: String
9
10	//NB: there is no isAdmin field
11
12});
13
14const User = mongoose.model("User", userSchema);
15
16module.exports = User;

Ainsi, même si des attaquants accèdent au code source, ils ne pourront pas voir le champ sensible ni l’utiliser pour orchestrer une attaque. Évitez également les termes prévisibles dans la base de données pour définir le rôle d’un utilisateur, comme isAdmin, admin et role : un attaquant pourrait les deviner et lancer une attaque.

Valider le schéma des données saisies par l’utilisateur

Valider avec underscore

Vous pouvez également protéger votre application en spécifiant et en limitant les champs qu’une requête POST peut traiter. Cette méthode, appelée liste d’autorisation, utilise la bibliothèque underscore. Commencez par installer la bibliothèque :

1npm install underscore

Accédez au dossier routes et remplacez le code de route.js par celui-ci :

1const express = require("express");
2const userModel = require("../models/newUser");
3var _ = require('underscore');
4
5const app = express();
6
7app.post("/add_user", async (request, response) => {
8    const user = new userModel( _.pick(request.body, 'first_name', 'last_name', 'email', 'password'));
9
10    try {
11      await user.save();
12      response.send(user);
13    } catch (error) {
14      response.status(500).send(error);
15    }
16});
17
18module.exports = app;

Dans le code ci-dessus, nous utilisons la fonction pick pour spécifier les variables extraites d’une requête POST. Cela empêche un attaquant d’utiliser le champ sensible isAdmin.

Le problème avec underscore, c’est que l’application doit traiter les données avant de savoir si elles sont valides. Autrement dit, les erreurs ne sont pas détectées assez tôt.

Valider avec Zod

Pour valider les schémas de manière robuste, utilisez Zod. Cet outil valide le schéma et garantit que les données respectent strictement la structure, le modèle et le type de données spécifiés. Zod détecte suffisamment tôt les données incomplètes ou incorrectes pour prévenir les erreurs de l’application. Vous pouvez également créer facilement un message d’erreur indiquant à l’utilisateur quels champs ont provoqué une erreur et de quel type d’erreur il s’agit.

Cet extrait de code montre le fonctionnement de Zod. Notez qu’il est écrit en TypeScript, ce qui nécessite une configuration supplémentaire.

1import { z, AnyZodObject } from "zod";
2import express, { Request, Response, NextFunction } from 'express';
3
4const app = express();
5
6app.use(express.json());
7
8const dataSchema = z.object({
9    body: z.object({
10        first_name: z.string({
11            required_error: "First name is required",
12            invalid_type_error: "First name must be a string",
13        }),
14        last_name: z.string({
15            required_error: "Last name is required",
16            invalid_type_error: "Last name must be a string",
17        }),
18        password: z.string({
19            required_error: "Password is required",
20        }),
21        email: z
22            .string({
23                required_error: "Email is required",
24            })
25            .email("Not a valid email"),
26    }),
27});
28
29const validate =
30    (schema: AnyZodObject) =>
31    async (req: Request, res: Response, next: NextFunction) => {
32        try {
33            await schema.parseAsync({
34                body: req.body,
35                query: req.query,
36                params: req.params,
37            });
38            return next();
39        } catch (error) {
40            return res.status(400).json(error);
41        }
42    };
43
44app.post("/create",
45    validate(dataSchema),
46    (req: Request, res: Response): Response => {
47        return res.json({
48            ...req.body
49        });
50    }
51);

Si un utilisateur saisit des données qui ne correspondent pas au schéma, un message d’erreur indiquant invalid_type_error s’affiche. S’il laisse un champ vide, il reçoit une erreur required_error.

Autres exemples de vulnérabilités d’affectation de masse dans les ORM

Examinons trois autres exemples de vulnérabilités d’affectation de masse dans des solutions ORM courantes.

Vulnérabilité d’affectation de masse dans du code Sequelize

Examinons un exemple de code Sequelize vulnérable à l’affectation de masse. Ce code définit un modèle utilisateur, crée un utilisateur et enregistre ses informations dans la base de données :

1const { Sequelize } = require("sequelize");
2
3const User = sequelize.define("users", {
4    username: {
5        type: DataTypes.STRING,
6        allowNull: false
7    },
8
9    email: {
10        type: DataTypes.STRING,
11        allowNull: false
12    },
13
14    password: {
15        type: DataTypes.STRING,
16        allowNull: false
17    },
18
19    is_verified: {
20        type: DataTypes.BOOLEAN,
21        allowNull: false,
22        default: false
23    },
24
25 });

Lors de la création d’un nouvel utilisateur, le contrôleur appelle le modèle ci-dessus, comme indiqué ci-dessous :

1// Create a User
2const user = {
3    username: req.body.username,
4    email: req.body.email,
5    password: req.body.password,
6    is_verified: false
7  };
8
9//Save User in the database
10User.create(user)
11.then(data => {
12    res.send(data);
13})
14.catch(err => {
15    res.status(500).send({
16    message:
17        err.message || "Error occurred. User not created!"
18    });
19});

Le code ci-dessus est vulnérable, car il expose le champ sensible is_verified. Un attaquant peut créer une requête POST contenant le champ is_verified défini sur true, ce qui lui permet de contourner l’étape de vérification.

Pour éliminer la vulnérabilité d’affectation de masse dans ce code, supprimons le champ is_verified lors de la création de l’utilisateur. Voici à quoi ressemblerait le code sécurisé :

1// Create a User
2const user = {
3    username: req.body.username,
4    email: req.body.email,
5    password: req.body.password
6  };

Cela limite les variables acceptées dans les requêtes POST au nom d’utilisateur, à l’adresse e-mail et au mot de passe.

Vulnérabilité d’affectation de masse dans du code Prisma

Voici un exemple de code Prisma vulnérable à l’affectation de masse, qui expose le champ sensible Role.

1model User {
2    id      		Int    @id @default(autoincrement())
3    username        String
4    email       	String
5    Role    		Boolean    @default(USER)
6  }
7
8enum Role {
9    USER
10    ADMIN
11}

Pour ajouter un utilisateur, nous créons une route add_user.

1const { PrismaClient } = require("@prisma/client");
2const express = require("express");
3const prisma = new PrismaClient();
4
5const app = express();
6
7app.use(express.json());
8
9app.post('/add_user', async (req, res) => {
10    const user = await prisma.user.create({ data: req.body });
11    res.json(user);
12  });

Cette requête POST attend un corps contenant un objet utilisateur. Le code ci-dessus est vulnérable aux attaques par affectation de masse, car un pirate peut ajouter le champ role à ADMIN pour obtenir des privilèges d’administrateur.

Nous pouvons corriger cette vulnérabilité en excluant du modèle le champ sensible Role.

1model User {
2    id      		Int    @id @default(autoincrement())
3    username        String
4    email       	String
5  }

Vulnérabilité d’affectation de masse dans du code MySQL

Voici un exemple de code MySQL vulnérable à l’affectation de masse, qui expose le champ sensible isAdmin :

1// Defining the user data
2let user = {
3    username: req.body.username,
4    email: req.body.email,
5    password: req.body.password,
6    isAdmin: req.body.role
7};

Ce code ajoute l’utilisateur défini ci-dessus :

1// Saving user details
2app.post('/add_user',(req, res) => {
3
4let myQuery = "INSERT INTO users SET ?";
5
6    let query = connection.query(myQuery, user,(err, results) => {
7        if(err) throw err;
8        res.send(apiResponse(results));
9    });
10
11});

Le code ci-dessus présente une vulnérabilité d’affectation de masse, car il expose un champ sensible — isAdmin — et permet de l’inclure dans une requête POST. Un attaquant peut créer une requête POST qui définit le champ isAdmin sur true et crée ainsi un utilisateur administrateur.

Nous pouvons corriger cette vulnérabilité en excluant le champ sensible lors de la création de l’objet user. Voici le code sécurisé :

1// Defining the user data
2let user = {
3    username: req.body.username,
4    email: req.body.email,
5    password: req.body.password
6};

Vous pouvez définir la valeur par défaut du champ isAdmin sur false en modifiant la table à l’aide de la commande suivante :

1ALTER TABLE users ALTER isAdmin SET DEFAULT ‘false’;

Sécuriser votre code Node.js

Node.js est sécurisé, mais les packages nécessaires au développement d’une application web ne le sont pas toujours. Dans les applications Node.js qui envoient des requêtes à une base de données, l’affectation de masse constitue l’un des vecteurs d’attaque les plus courants. Elle permet aux utilisateurs malveillants de lancer des attaques par injection SQL, qui consistent à envoyer des requêtes malveillantes à une base de données.

Toutefois, la validation des données saisies permet d’éviter facilement l’affectation de masse dans Node.js. Pour cela, vous pouvez ne pas exposer les champs sensibles, limiter les champs acceptés ou empêcher la modification de certains champs.

L’absence de validation robuste des données saisies par l’utilisateur expose un système à des attaques telles que la pollution de prototype. Ces attaques peuvent contourner des mécanismes de validation faibles comme underscore. Veillez donc à toujours utiliser des solutions robustes telles que Zod.

Consultez l’exemple complet du code source dans notre dépôt GitHub et lancez vos propres tests de sécurité en local pour découvrir comment éviter les vulnérabilités d’affectation de masse dans Node.js.

Suivez les 10 meilleures pratiques de Snyk en matière de sécurité Node.js pour optimiser la sécurité de votre application Node.js.