Quelles sont les meilleures pratiques de sécurité clés pour une application Node.js ?

Question

Accepted Answer

Sécuriser une application Node signifie se défendre contre les vulnérabilités web courantes (OWASP Top 10) sur plusieurs couches — traitement des entrées, authentification, dépendances et configuration. La sécurité est en couches (défense en profondeur), pas un seul correctif.

## 1. Validez et désinfectez toutes les entrées

```js
import { z } from "zod";
// never trust client input — validate shape/type before using it
const schema = z.object({ email: z.string().email(), age: z.number().min(0) });
const data = schema.parse(req.body); // rejects malformed/malicious input
```

## 2. Prévenir l'injection (SQL, NoSQL, commande)

```js
// ❌ string concatenation → SQL injection
db.query(`SELECT * FROM users WHERE id = ${req.params.id}`);
// ✅ parameterized queries — input is data, never executable SQL
db.query("SELECT * FROM users WHERE id = $1", [req.params.id]);
```

Utilisez toujours des requêtes paramétrées / un ORM, et ne construisez jamais des commandes à partir de l'entrée utilisateur (voir l'injection de commande avec `child_process`).

## 3. Authentification et secrets

```text
✓ Hash passwords with bcrypt/argon2/scrypt (slow + salted) — never plain/SHA
✓ Store secrets in env vars, never in code/git
✓ Use httpOnly, secure, sameSite cookies for sessions (XSS-resistant)
✓ Sign/verify JWTs properly; keep tokens short-lived
```

## 4. Définir les en-têtes de sécurité et la limitation de débit

```js
import helmet from "helmet";
import rateLimit from "express-rate-limit";

app.use(helmet()); // sets secure HTTP headers (CSP, HSTS, X-Frame-Options, etc.)
app.use(rateLimit({ windowMs: 60_000, max: 100 })); // throttle abuse/brute-force
```

`helmet` ajoute des en-têtes de protection ; la limitation de débit se défend contre le brute-force et les attaques par déni de service.

## 5. Maintenir les dépendances sécurisées (chaîne d'approvisionnement)

```bash
npm audit          # check installed packages for known vulnerabilities
npm audit fix
# + keep deps updated; review postinstall scripts; pin versions via the lockfile
```

La plupart du code Node est constitué de packages tiers — les dépendances vulnérables sont un vecteur d'attaque majeur. Auditez et mettez à jour régulièrement.

## 6. Autres éléments essentiels

```text
✓ Use HTTPS (TLS) everywhere; redirect HTTP → HTTPS
✓ Don't leak error details/stack traces to clients in production
✓ Escape output to prevent XSS (frameworks usually do this)
✓ Implement proper authorization (not just authentication) — check permissions per action
✓ CORS configured to an allowlist, not "*" for credentialed APIs
✓ Limit request body size to prevent payload-based DoS
```

## Pourquoi c'est important

Les applications web sont des cibles constantes, et les applications Node sont exposées à l'ensemble des vulnérabilités web — injection, authentification compromise, XSS, dépendances vulnérables, mauvaise configuration.

Aucune mesure unique ne suffit ; la sécurité est **en couches** : validez les entrées, paramétrez les requêtes, hashlez les mots de passe correctement, gérez les secrets de manière sécurisée, définissez des en-têtes de protection, limitez le débit, auditez les dépendances et utilisez HTTPS.

Comprendre ces pratiques (et les risques OWASP derrière elles) est une responsabilité essentielle pour quiconque crée des services Node en production — une seule couche oubliée (une injection, un secret divulgué, une dépendance non corrigée) peut compromettre tout le système.