@astratra/security 1.0.1 → 1.0.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -47,10 +47,26 @@ app.use('/auth', createLoginLimiter({
47
47
  app.use('/auth/login', createAccountLimiter({ onBlocked: ({ identifier }) => { /* ... */ } }));
48
48
  ```
49
49
 
50
+ `createAccountLimiter()` identifie le compte via `req.body.email` par défaut : comme
51
+ `createWafMiddleware()`, il doit être monté APRÈS `express.json()`/`express.urlencoded()`.
52
+ Avant, `req.body` vaut `undefined` et toutes les tentatives retombent sur la clé
53
+ partagée `"unknown"` — la limite par compte disparaît au profit d'une limite
54
+ globale partagée par tous les comptes. Un avertissement (`console.warn`, une
55
+ seule fois par processus) signale ce cas. Fournir son propre `keyGenerator`
56
+ contourne complètement ce point.
57
+ ```
58
+
50
59
  ## WAF
51
60
 
52
61
  ```js
53
62
  const { createWafMiddleware } = require('@astratra/security');
63
+
64
+ // IMPORTANT : à monter APRÈS express.json()/express.urlencoded(). Avant, req.body
65
+ // vaut undefined et ce middleware n'a rien à inspecter dans le corps de la requête
66
+ // — il continue de fonctionner (bloque toujours sur path/query), mais silencieusement
67
+ // sans jamais voir un payload dangereux envoyé dans le body. Un avertissement
68
+ // (`console.warn`, une seule fois par instance) signale ce cas s'il se produit.
69
+ app.use(express.json());
54
70
  app.use(createWafMiddleware({ message: { success: false, message: 'Requête bloquée.' } }));
55
71
  ```
56
72
 
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@astratra/security",
3
- "version": "1.0.1",
3
+ "version": "1.0.2",
4
4
  "description": "Generic authentication and security middleware for Astratra workspaces.",
5
5
  "main": "src/index.js",
6
6
  "types": "src/index.d.ts",
@@ -1,4 +1,7 @@
1
1
  const rateLimit = require('express-rate-limit');
2
+ const { createLogger } = require('@astratra/core');
3
+
4
+ const logger = createLogger('rate-limiters');
2
5
 
3
6
  const DEFAULT_API_MESSAGE = {
4
7
  success: false,
@@ -175,7 +178,30 @@ const createLoginLimiter = (options = {}) => rateLimit(withOptionalStore({
175
178
  )
176
179
  }, resolveStore(options)));
177
180
 
181
+ // Avertit une seule fois par processus (fonction partagée par toute instance
182
+ // de createAccountLimiter utilisant la clé par défaut) : le problème est un
183
+ // ordre de montage figé au démarrage, pas quelque chose qui varie requête par
184
+ // requête.
185
+ let warnedUnparsedBody = false;
186
+
178
187
  const defaultAccountKeyGenerator = (req) => {
188
+ // Même défaut de conception que le WAF (voir waf.js) : req.body est
189
+ // `undefined` si createAccountLimiter() est monté avant express.json().
190
+ // Sans cette détection, toute tentative de connexion retombait alors sur la
191
+ // clé partagée "unknown" — plus de limite PAR COMPTE, une seule limite
192
+ // globale pour tous les comptes confondus. Deux effets, tous deux mauvais :
193
+ // un attaquant peut essayer des mots de passe sur des comptes DIFFÉRENTS
194
+ // sans jamais être freiné par compte, et des utilisateurs légitimes sans
195
+ // rapport entre eux peuvent se faire bloquer les uns par les autres.
196
+ if (req.body === undefined && !warnedUnparsedBody) {
197
+ warnedUnparsedBody = true;
198
+ logger.warn(
199
+ 'req.body est undefined dans createAccountLimiter() — à monter APRÈS ' +
200
+ "express.json()/express.urlencoded(), sinon toutes les tentatives sont " +
201
+ 'regroupées sous la même clé "unknown" au lieu d\'être limitées par compte.'
202
+ );
203
+ }
204
+
179
205
  const body = req.body || {};
180
206
  const identifier = body.email || body.identifier || 'unknown';
181
207
  return String(identifier).toLowerCase();
package/src/waf.js CHANGED
@@ -1,3 +1,7 @@
1
+ const { createLogger } = require('@astratra/core');
2
+
3
+ const logger = createLogger('waf');
4
+
1
5
  const WAF_PATTERNS = [
2
6
  /(\b(union|select|insert|update|delete|drop|alter|create)\b.*\b(from|into|table|database)\b)/gi,
3
7
  /(\b(or|and)\b\s+\d+\s*=\s*\d+)/gi,
@@ -26,8 +30,27 @@ const safeStringify = (value) => {
26
30
  const createWafMiddleware = (options = {}) => {
27
31
  const message = options.message || DEFAULT_MESSAGE;
28
32
  const patterns = options.patterns || WAF_PATTERNS;
33
+ // Avertit une seule fois par instance de middleware, pas à chaque requête :
34
+ // le problème (mauvais ordre au montage) ne change pas d'une requête à
35
+ // l'autre, et logguer en boucle sous charge serait juste du bruit.
36
+ let warnedUnparsedBody = false;
29
37
 
30
38
  return (req, res, next) => {
39
+ // req.body est `undefined` seulement si aucun body-parser (express.json,
40
+ // express.urlencoded...) n'a tourné avant ce middleware — un body-parser
41
+ // monté en amont assigne toujours au moins `{}`, même sur une requête
42
+ // sans corps. Sans cette détection, ce middleware inspectait silencieusement
43
+ // une chaîne vide à la place du corps de la requête : aucune erreur,
44
+ // aucun log, juste une protection qui ne protégeait rien.
45
+ if (req.body === undefined && !warnedUnparsedBody) {
46
+ warnedUnparsedBody = true;
47
+ logger.warn(
48
+ 'req.body est undefined — createWafMiddleware() doit être monté APRÈS ' +
49
+ 'express.json()/express.urlencoded(), sinon le corps des requêtes ' +
50
+ "n'est jamais inspecté (SQLi/XSS dans le body passeraient sans être bloqués)."
51
+ );
52
+ }
53
+
31
54
  const targets = [
32
55
  req.path,
33
56
  safeStringify(req.query),