5 exemples de code pour sécuriser Node.js que tout développeur backend devrait connaître

En tant que développeurs backend, nous avons la responsabilité essentielle de garantir la sécurité de nos applications. Node.js n’échappe pas à cette responsabilité et sa popularité croissante en fait une cible de choix pour les pirates. Il est donc impératif de suivre les bonnes pratiques de sécurité lorsqu’on travaille avec Node.js.

Dans cet article, nous allons découvrir quelques exemples de code essentiels pour sécuriser Node.js que tout développeur backend devrait connaître en 2024. Les vulnérabilités des logiciels Node.js peuvent représenter une menace importante pour toute application. Elles peuvent entraîner des accès non autorisés, des fuites de données et, dans le pire des cas, une compromission complète du système. C’est pourquoi le respect des bonnes pratiques de sécurité n’est pas simplement recommandé : il est indispensable.

Dans le contexte de Node.js, cela signifie veiller à ce que votre code ne présente aucune faille exploitable. Cela consiste notamment à assainir les entrées utilisateur pour prévenir les attaques par injection, à traiter correctement les mots de passe comme des données sensibles et à gérer les dépendances pour éviter les vulnérabilités de tiers.

Nous allons passer en revue les concepts de sécurité Node.js suivants et les exemples de code associés, sélectionnés pour leur efficacité à prévenir les vulnérabilités courantes et leur accessibilité aux développeurs, sans expertise supplémentaire en sécurité :

1. Utiliser le modèle d’autorisations de Node.js pour restreindre l’accès aux ressources lors de l’exécution

2. Valider les entrées à l’aide d’un schéma JSON Fastify

3. Sécuriser le hachage des mots de passe avec Bcrypt

4. Prévenir les attaques par injection SQL avec Knex.js

5. Mettre en place une limitation du débit avec fastify-rate-limit

1. Utiliser le modèle d’autorisations de Node.js pour restreindre l’accès aux ressources lors de l’exécution

Le modèle d’autorisations de Node.js peut jouer un rôle essentiel dans la sécurisation de vos applications. Élément clé du modèle de sécurité de base de Node.js, il contribue à protéger vos applications contre les attaques et les activités malveillantes. À l’instar des garanties de sécurité offertes par les restrictions de ressources centrées sur les processus de Deno, Node.js dispose désormais, dans une certaine mesure, d’un modèle d’autorisations similaire.

Imaginons qu’une application Node.js doive convertir des fichiers PDF en images PNG. Nous pouvons utiliser le package npm pdf-image pour effectuer cette tâche. Le package pdf-image utilise des processus enfants pour réaliser la conversion. Pour cela, nous devons utiliser l’option --allow-child-process dans l’environnement d’exécution Node.js (fournie par le modèle d’autorisations).

Voici un exemple de code qui l’illustre :

1const { PDFImage } = require('pdf-image');
2const path = require('path');
3
4const pdfPath = path.resolve(__dirname, 'sample.pdf');
5const pdfImage = new PDFImage(pdfPath, {
6  convertOptions: {
7    '-density': '300',
8    '-quality': '80'
9  },
10  combinedImage: true
11});
12pdfImage.convertFile().then(() => {
13  console.log('PDF converted to PNG successfully');
14}).catch((err) => {
15  console.error(`Failed to convert PDF to PNG: ${err}`);
16});

Dans cet exemple, nous créons une nouvelle instance de PDFImage en lui indiquant le chemin d’accès à notre fichier PDF et quelques options de conversion. Nous appelons ensuite convertFile() pour convertir le PDF en image PNG.

Si vous activez le modèle d’autorisations expérimental de Node.js, vous devrez lancer explicitement l’environnement d’exécution Node.js avec l’option de ligne de commande --allow-child-process mentionnée précédemment, car la bibliothèque pdf-image lance un processus enfant pour convertir les fichiers PDF.

Si le modèle d’autorisations de Node.js offre un excellent moyen de restreindre l’accès aux ressources système, il est également essentiel de connaître les vulnérabilités de sécurité potentielles des packages que nous utilisons. C’est là qu’intervient l’extension Snyk pour Visual Studio Code. Elle peut détecter le code non sécurisé et les dépendances vulnérables dans une application Node.js. Par exemple, le package pdf-image mentionné précédemment présente une vulnérabilité connue d’injection de commandes, liée à son utilisation de processus enfants. Cette vulnérabilité est connue depuis 2018 et, malheureusement, aucun correctif n’est disponible à ce jour.

Cela montre combien il est important d’utiliser des outils comme Snyk pour rester informé des vulnérabilités de sécurité présentes dans les packages dont nous dépendons. C’est aussi un rappel de la prudence dont nous devons faire preuve avec certaines fonctionnalités, comme les processus enfants, qui peuvent présenter des risques de sécurité si elles ne sont pas utilisées correctement.

En tant que développeurs Node.js, nous avons la responsabilité de veiller à ce que le code que nous écrivons soit non seulement fonctionnel, mais aussi sécurisé. Pour renforcer la sécurité d’une application Node.js, il est notamment essentiel d’utiliser le modèle d’autorisations intégré afin de restreindre l’accès aux ressources système lors de l’exécution. Si votre application Node.js n’a pas besoin de créer des processus enfants, n’activez pas cette ressource afin de ne pas élargir la surface d’attaque.

FAQ sur le modèle d’autorisations de Node.js

2. Valider les entrées à l’aide d’un schéma JSON Fastify

La validation des entrées est un aspect essentiel du développement backend. Si vous avez déjà créé des API avec Express, Fastify ou d’autres frameworks, vous en avez probablement déjà compris l’importance. Cette pratique de sécurité garantit que seules les données correctement formatées entrent dans votre système et permet ainsi de prévenir les risques potentiels. Dans vos applications Node.js, vous pouvez notamment valider les entrées en utilisant le schéma Fastify pour vos applications web Fastify.

L’approche de Fastify fondée sur les schémas

Fastify utilise une approche fondée sur les schémas pour valider les entrées. Bien que cela ne soit pas obligatoire, il est recommandé d’utiliser le schéma JSON pour valider vos routes et sérialiser vos sorties. Le schéma JSON définit un contrat pour vos données en précisant le format attendu, les types de données, les champs obligatoires et d’autres contraintes. Vous pouvez considérer le schéma JSON d’une route Fastify comme l’équivalent de l’utilisation de TypeScript pour garantir un typage fort dans votre code lors de la compilation.

Prenons l’exemple d’une application Fastify simple qui crée un utilisateur. Nous pouvons utiliser un schéma Fastify pour valider les données saisies.

1const fastify = require('fastify')({ logger: true });
2
3const UserSchema = {
4  body: {
5    type: 'object',
6    properties: {
7      name: { type: 'string' },
8      email: { type: 'string', format: 'email' },
9      password: { type: 'string', minLength: 8 }
10    },
11    required: ['name', 'email', 'password']
12  }
13};
14
15// User creation route
16fastify.post('/users', { schema: UserSchema }, async (request, reply) => {
17  // Example user creation logic
18  // In a real application, you would replace this with actual database logic
19  const user = request.body;
20
21  // Simulating user creation
22  console.log("Creating user:", user);
23
24  // Responding with the created user (in real applications, never send the password back)
25  return reply
26    .code(201)
27    .send({ success: true, message: "User created", user: { name: user.name, email: user.email } });
28});
29
30// Server startup
31const start = async () => {
32  try {
33    await fastify.listen({ port: 6000, host: 'localhost' });
34    console.log(`Server running at http://localhost:3000/`);
35  } catch (err) {
36    fastify.log.error(err);
37    process.exit(1);
38  }
39};
40
41start();

Dans le code ci-dessus, nous définissons un UserSchema qui exige un nom, une adresse e-mail et un mot de passe. L’adresse e-mail doit être au format valide et le mot de passe doit comporter au moins 8 caractères.

Négliger la validation des entrées peut exposer votre application à divers risques de sécurité, notamment la falsification de requêtes côté serveur (SSRF) ou les attaques par pollution des paramètres HTTP. Les attaques SSRF peuvent inciter le serveur à envoyer des requêtes non autorisées, ce qui risque d’exposer des données. La pollution des paramètres HTTP peut quant à elle manipuler ou corrompre des requêtes et entraîner un comportement inattendu.

Des outils comme Snyk peuvent vous aider à détecter ces vulnérabilités en analysant votre code à la recherche de failles de sécurité. Ils peuvent également proposer des conseils de correction pour vous aider à les résoudre et ainsi renforcer la sécurité globale de votre application.

FAQ sur la validation des entrées avec Fastify

3. Sécuriser le hachage des mots de passe avec Bcrypt

Il est essentiel de stocker les mots de passe des utilisateurs de manière sécurisée. En cas de fuite de données, vous devez vous assurer que les mots de passe des utilisateurs ne puissent pas être facilement déchiffrés. C’est là qu’intervient le hachage des mots de passe : il s’agit de convertir une clé donnée en une autre valeur. Une fonction de hachage génère cette nouvelle valeur et doit idéalement produire un résultat unique (ou code de hachage) pour chaque valeur d’entrée unique.

Si vous choisissez de mettre en œuvre vous-même l’authentification au lieu de vous appuyer sur un service ou une autre bibliothèque, il est essentiel de comprendre que la façon dont vous gérez la sécurité des mots de passe peut avoir une incidence directe sur la sécurité globale de votre application.

Présentation de Bcrypt pour le hachage des mots de passe dans Node.js

Bcrypt est un algorithme et un package npm qui fournit une fonction de hachage des mots de passe considérée comme très sûre. Il intègre un salt (données aléatoires) pour protéger contre les attaques par tables arc-en-ciel et permet de configurer un facteur de travail, qui détermine l’intensité de calcul du hachage — une fonctionnalité utile pour prévenir les attaques par force brute.

Voyons un exemple d’utilisation simple :

1const bcrypt = require('bcrypt');
2const saltRounds = 10;
3const myPlaintextPassword = 'my_password';
4
5// Define an async function
6async function hashPassword(plaintextPassword) {
7  try {
8    const hash = await bcrypt.hash(plaintextPassword, saltRounds);
9    // Store hash in your password DB.
10    console.log(hash); // Example of how to use the hash
11  } catch (err) {
12    // Handle error
13    console.error(err);
14  }
15}
16
17// Call the async function
18hashPassword(myPlaintextPassword);

Le paramètre saltRounds détermine la complexité du processus de hachage. Plus sa valeur est élevée, plus le processus est long, ce qui peut contribuer à protéger contre les attaques par force brute. La fonction hash ajoute automatiquement un salt au mot de passe en clair, puis le hache. Le hachage obtenu peut ensuite être stocké dans votre base de données.

FAQ sur le hachage des mots de passe et la gestion de l’authentification dans Node.js

4. Prévenir les attaques par injection SQL avec Knex.js

L’injection SQL est une vulnérabilité de sécurité courante qui représente un risque important pour les données des applications. Les développeurs Node.js peuvent atténuer ce risque en utilisant Knex.js, un générateur de requêtes SQL prometteur, pour créer des requêtes plus sûres. Notez toutefois que Knex.js permet également de construire et d’exécuter des requêtes SQL brutes. Dans ce cas, l’injection SQL reste un risque de sécurité : elle peut être introduite dans la requête si des entrées utilisateur y sont concaténées.

Knex.js est un puissant générateur de requêtes SQL pour Node.js. Il prend en charge les transactions, le regroupement des connexions, les migrations et les seeds, ce qui en fait un choix de prédilection pour les développeurs qui souhaitent écrire des requêtes SQL sécurisées, robustes et évolutives. Knex.js protège contre les attaques par injection SQL en utilisant des requêtes paramétrées et en échappant les valeurs insérées dans les instructions SQL.

Voici un exemple de code qui montre comment Knex.js protège contre les attaques par injection SQL :

1const knex = require('knex')({
2  client: 'pg',
3  connection: {
4    host : '127.0.0.1',
5    user : 'your_database_user',
6    password : 'your_database_password',
7    database : 'myapp_test'
8  }
9});
10
11// This value is provided by the user and could be malicious
12// such as applying an OR 1=1 SQL injection or other
13// techniques that escape the original context of the query
14// and create a new one
15let userProvidedValue = 'maliciousValue';
16
17knex('users')
18  .where('id', '=', userProvidedValue)
19  .select()
20  .then(rows => {
21    // process result
22  })
23  .catch(err => {
24    // handle error
25  });

Dans cet exemple, Knex.js échappe automatiquement la valeur userProvidedValue et prévient ainsi toute attaque potentielle par injection SQL.

Comme nous l’avons indiqué, Knex.js ne constitue pas à lui seul un environnement isolé ni une protection complète contre les injections SQL. Voici un exemple d’utilisation potentiellement non sécurisée de Knex.js, susceptible d’entraîner une attaque par injection SQL :

1knex.raw(`SELECT * FROM users WHERE id = ${userProvidedValue}`)

Dans ce cas, la valeur userProvidedValue n’est ni échappée ni paramétrée. La requête est donc vulnérable à une injection SQL si userProvidedValue contient du code SQL malveillant. Snyk peut aider les développeurs à détecter ce type de vulnérabilité dans leur base de code. Snyk analyse votre code et fournit des recommandations concrètes pour corriger les vulnérabilités de sécurité, notamment les attaques potentielles par injection SQL.

FAQ sur la prévention des injections SQL avec Knex.js

5. Mettre en place une limitation du débit avec fastify-rate-limit

La limitation du débit est un mécanisme de sécurité essentiel qui protège vos applications web contre les attaques par déni de service (DoS). En contrôlant le nombre de requêtes qu’un client peut envoyer à votre application pendant une période donnée, vous empêchez les clients malveillants de submerger votre serveur de requêtes et garantissez ainsi la disponibilité de votre application pour les autres utilisateurs légitimes.

fastify-rate-limit est un plugin pour le framework web Fastify qui facilite la mise en place d’une limitation du débit dans vos applications Node.js. Il vous permet de définir le nombre maximal de requêtes qu’un client peut envoyer pendant une période donnée, ainsi que la réponse à renvoyer lorsque cette limite est dépassée.

Voici un exemple simple de mise en place d’une limitation du débit dans votre application Node.js avec fastify-rate-limit :

1const fastify = require('fastify')()
2
3fastify.register(require('@fastify/rate-limit'), {
4  // max number of connections during windowMs milliseconds before sending a 429 response
5  max: 100,
6  timeWindow: '1 minute'
7})
8
9fastify.get('/', (req, reply) => {
10  reply.send({ hello: 'world' })
11})
12
13fastify.listen(3000, err => {
14  if (err) throw err
15  console.log('Server listening at http://localhost:3000')
16})

Dans cet exemple de code, le package de limitation du débit de Fastify est configuré pour limiter chaque client à 100 requêtes par minute. Si un client dépasse cette limite, le serveur renvoie le code d’état 429 (« Too Many Requests »).

FAQ sur la limitation du débit

Pourquoi les développeurs devraient utiliser Snyk pour sécuriser JavaScript

Dans cet article, nous avons présenté cinq exemples de code essentiels pour sécuriser Node.js que tout développeur backend devrait connaître. Nous avons souligné l’importance des pratiques de programmation sécurisée, comme la prévention des injections SQL, et leur rôle majeur dans le renforcement de la sécurité des applications. Avec l’évolution de la technologie et la complexité croissante des cybermenaces, il est impossible de trop insister sur la nécessité d’écrire du code sécurisé.

En tant que développeur, il est essentiel de tirer parti d’outils de sécurité robustes capables de détecter et d’atténuer les vulnérabilités potentielles de votre code. Snyk est l’un de ces outils : cette puissante plateforme de sécurité pour les développeurs leur permet de détecter et de corriger les vulnérabilités dans le code, les dépendances, les conteneurs et bien plus encore. Avec Snyk, vous pouvez surveiller en continu les vulnérabilités de sécurité de votre application et recevoir automatiquement des demandes de fusion proposant des correctifs dès qu’une nouvelle vulnérabilité est découverte.

1// Install Snyk CLI
2npm install -g snyk
3
4// Then run Snyk to find vulnerabilities
5snyk test

Snyk s’intègre parfaitement à vos environnements de développement intégrés et à votre pipeline CI/CD, pour vous permettre d’assurer une sécurité continue tout au long du cycle de développement de vos applications. Il prend en charge de nombreux langages de programmation, dont Node.js, et constitue ainsi un outil polyvalent pour les développeurs, quelle que soit leur plateforme.

Écrire du code sécurisé est une pratique fondamentale du développement logiciel que tout développeur backend devrait privilégier. L’utilisation d’outils de sécurité comme Snyk renforce cette pratique grâce à la détection automatisée des vulnérabilités et à leur correction. Face à l’évolution constante des cybermenaces, ces pratiques et ces outils seront essentiels pour préserver la sécurité et l’intégrité de nos applications.