@astratra/security 1.13.0 → 1.15.0

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
@@ -407,13 +407,29 @@ app.use('/auth', createLoginLimiter({
407
407
  app.use('/auth/login', createAccountLimiter({ onBlocked: ({ identifier }) => { /* ... */ } }));
408
408
  ```
409
409
 
410
+ Un compteur par zone, pour qu'un dépassement sur une page ne bloque pas les autres. Les noms forment une liste fermée, jamais une valeur tirée librement de l'adresse demandée :
411
+
412
+ ```js
413
+ const ZONES = new Set(['notes', 'reunions']);
414
+ app.use(createApiLimiter({
415
+ max: 300,
416
+ area: (req) => {
417
+ const premier = req.path.split('/')[1];
418
+ if (req.path.endsWith('/chapitres')) return { name: 'chapitres', max: 2000 };
419
+ return { name: ZONES.has(premier) ? premier : 'autres' };
420
+ }
421
+ }));
422
+ ```
423
+
410
424
  `createAccountLimiter()` identifie le compte via `req.body.email` par défaut : comme
411
425
  `createWafMiddleware()`, il doit être monté APRÈS `express.json()`/`express.urlencoded()`.
412
426
  Avant, `req.body` vaut `undefined` et toutes les tentatives retombent sur la clé
413
427
  partagée `"unknown"` — la limite par compte disparaît au profit d'une limite
414
428
  globale partagée par tous les comptes. Un avertissement (`console.warn`, une
415
- seule fois par processus) signale ce cas. Fournir son propre `keyGenerator`
416
- contourne complètement ce point.
429
+ seule fois par processus) signale ce cas. Il ne part que si la requête annonce
430
+ un corps (`content-length` non nul ou `transfer-encoding`) : avec Express 5,
431
+ `req.body` reste `undefined` pour une requête sans corps, même bien montée.
432
+ Fournir son propre `keyGenerator` contourne complètement ce point.
417
433
  ```
418
434
 
419
435
  ### Store Redis namespacé
@@ -455,7 +471,9 @@ const { createWafMiddleware } = require('@astratra/security');
455
471
  // vaut undefined et ce middleware n'a rien à inspecter dans le corps de la requête
456
472
  // — il continue de fonctionner (bloque toujours sur path/query), mais silencieusement
457
473
  // sans jamais voir un payload dangereux envoyé dans le body. Un avertissement
458
- // (`console.warn`, une seule fois par instance) signale ce cas s'il se produit.
474
+ // (`console.warn`, une seule fois par instance) signale ce cas s'il se produit :
475
+ // seulement pour une requête qui annonce un corps (content-length non nul ou
476
+ // transfer-encoding), car Express 5 laisse req.body à undefined sans corps.
459
477
  app.use(express.json());
460
478
  app.use(createWafMiddleware({ message: { success: false, message: 'Requête bloquée.' } }));
461
479
  ```
@@ -482,9 +500,14 @@ l'appelant. Aucune requête légitime n'envoie une clé JSON littéralement
482
500
  préfixée par `$` ou contenant un point — sans risque de faux positif sur un
483
501
  usage normal.
484
502
 
485
- Mute les objets en place plutôt que de réassigner `req.query` (getter
486
- seul sur certaines configurations Express/routeur — une réassignation y
487
- échouerait silencieusement ou lèverait selon la version).
503
+ Fonctionne avec Express 4 et Express 5. Express 5 définit `req.query` par
504
+ un lecteur qui relit l'adresse à chaque accès : un nettoyage fait en place
505
+ serait perdu au prochain accès. L'objet nettoyé devient donc la valeur de
506
+ `req.query` pour la suite de la requête (sous Express 4, où `req.query` est
507
+ une simple valeur, rien ne change). Avec l'analyseur de requêtes par défaut
508
+ d'Express 5 (`simple`), `?date[$gt]=x` reste une clé plate et inoffensive
509
+ (`"date[$gt]": "x"`) ; avec `app.set('query parser', 'extended')`, il devient un
510
+ objet, que ce middleware vide comme sous Express 4.
488
511
 
489
512
  Monté par défaut, sans configuration, par `createSaasApp()` (voir
490
513
  `@astratra/saas-kit`) — pas besoin d'y penser route par route.
package/package.json CHANGED
@@ -1,9 +1,9 @@
1
1
  {
2
2
  "name": "@astratra/security",
3
- "version": "1.13.0",
3
+ "version": "1.15.0",
4
4
  "description": "Generic authentication and security middleware for Astratra workspaces.",
5
5
  "engines": {
6
- "node": ">=20"
6
+ "node": ">=22"
7
7
  },
8
8
  "main": "src/index.js",
9
9
  "types": "src/index.d.ts",
@@ -31,7 +31,7 @@
31
31
  "dependencies": {
32
32
  "@astratra/core": "^1.0.0",
33
33
  "@simplewebauthn/server": "^13.1.2",
34
- "express-rate-limit": "^7.5.1",
34
+ "express-rate-limit": "^8.7.4",
35
35
  "jsonwebtoken": "^9.0.2"
36
36
  },
37
37
  "peerDependencies": {
@@ -48,7 +48,7 @@
48
48
  },
49
49
  "devDependencies": {
50
50
  "jest": "30.4.2",
51
- "rate-limit-redis": "^4.2.0",
52
- "redis": "^4.7.0"
51
+ "rate-limit-redis": "^6.0.2",
52
+ "redis": "^6.3.1"
53
53
  }
54
54
  }
package/src/encryption.js CHANGED
@@ -3,6 +3,7 @@ const crypto = require('crypto');
3
3
  const ALGORITHM = 'aes-256-gcm';
4
4
  const KEY_LENGTH = 32;
5
5
  const IV_LENGTH = 12;
6
+ const AUTH_TAG_LENGTH = 16;
6
7
 
7
8
  const normalizeKey = (key) => {
8
9
  if (Buffer.isBuffer(key)) {
@@ -63,8 +64,13 @@ const createFieldCipher = (options = {}) => {
63
64
  const iv = Buffer.from(ivPart, 'base64url');
64
65
  const authTag = Buffer.from(authTagPart, 'base64url');
65
66
  const ciphertext = Buffer.from(ciphertextPart, 'base64url');
67
+ // Étiquette de 16 octets exactement : GCM accepte sinon une étiquette
68
+ // raccourcie (4 octets), bien plus facile à forger.
69
+ if (iv.length !== IV_LENGTH || authTag.length !== AUTH_TAG_LENGTH) {
70
+ throw new Error('createFieldCipher.decrypt received a malformed payload.');
71
+ }
66
72
 
67
- const decipher = crypto.createDecipheriv(ALGORITHM, key, iv);
73
+ const decipher = crypto.createDecipheriv(ALGORITHM, key, iv, { authTagLength: AUTH_TAG_LENGTH });
68
74
  decipher.setAuthTag(authTag);
69
75
  const plaintext = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
70
76
  return plaintext.toString('utf8');
package/src/index.d.ts CHANGED
@@ -211,7 +211,8 @@ export interface RevocationStore {
211
211
  revoke(jti: string, expiresAt: number): Awaitable<void>;
212
212
  isRevoked(jti?: string): Awaitable<boolean>;
213
213
  revokeAllForUser?(userId: string, revokedBeforeMs: number): Awaitable<void>;
214
- isRevokedForUser?(userId: string, issuedAtSeconds: number): Awaitable<boolean>;
214
+ /** issuedAtSeconds is undefined for a token without iat: after logout-all, answer true (revoked). */
215
+ isRevokedForUser?(userId: string, issuedAtSeconds: number | undefined): Awaitable<boolean>;
215
216
  }
216
217
 
217
218
  export function createMemoryRevocationStore(): RevocationStore;
@@ -304,7 +305,9 @@ export interface AccountLimiterOptions extends RateLimitOptions {
304
305
  onBlocked?: (context: AccountBlockedContext) => Awaitable<void>;
305
306
  }
306
307
 
307
- export function createApiLimiter(options?: RateLimitOptions): RequestHandler;
308
+ /** Un compteur à part pour une zone de l'application ; `max` remplace la limite générale. */
309
+ export interface RateLimitArea { name: string; max?: number }
310
+ export function createApiLimiter(options?: RateLimitOptions & { area?: (req: any) => RateLimitArea | null | undefined }): RequestHandler;
308
311
  export function createLoginLimiter(options?: LoginLimiterOptions): RequestHandler;
309
312
  export function createAccountLimiter(options?: AccountLimiterOptions): RequestHandler;
310
313
  export function skipLocalhost(req: RequestLike): boolean;
package/src/jwtAuth.js CHANGED
@@ -91,7 +91,7 @@ const createAuthMiddleware = (options = {}) => {
91
91
  if (
92
92
  decoded &&
93
93
  decoded.id !== undefined &&
94
- decoded.iat !== undefined &&
94
+ // Même sans iat : un jeton sans date ne doit pas échapper à « déconnecter partout ».
95
95
  typeof options.revocationStore.isRevokedForUser === 'function'
96
96
  ) {
97
97
  const revokedByUser = await options.revocationStore.isRevokedForUser(decoded.id, decoded.iat);
@@ -35,6 +35,21 @@ function stripDangerousKeys(value, replaceWith) {
35
35
 
36
36
  const DEFAULT_TARGETS = ['body', 'query', 'params'];
37
37
 
38
+ /* Express 5 définit req.query par un lecteur (getter) qui relit l'adresse à
39
+ chaque accès : nettoyer l'objet rendu une première fois ne servait à rien,
40
+ le suivant revenait intact (« ?date[$gt]= » atteignait la route). L'objet
41
+ nettoyé devient donc la valeur propre de req.query. Rien à faire quand la
42
+ propriété est déjà une simple valeur (Express 4, req.body, req.params). */
43
+ function keepCleaned(req, target, value) {
44
+ const own = Object.getOwnPropertyDescriptor(req, target);
45
+ if (own && 'value' in own) return;
46
+ try {
47
+ Object.defineProperty(req, target, { value, writable: true, configurable: true, enumerable: true });
48
+ } catch (_error) {
49
+ /* Propriété verrouillée : l'objet a au moins été nettoyé en place. */
50
+ }
51
+ }
52
+
38
53
  /**
39
54
  * Strips Mongo operator injection out of req.body/req.query/req.params
40
55
  * before it reaches a database call — see stripDangerousKeys() for the bug
@@ -52,8 +67,10 @@ const createMongoSanitizeMiddleware = (options = {}) => {
52
67
 
53
68
  return (req, res, next) => {
54
69
  for (const target of targets) {
55
- if (req[target] && typeof req[target] === 'object') {
56
- stripDangerousKeys(req[target], replaceWith);
70
+ const value = req[target];
71
+ if (value && typeof value === 'object') {
72
+ stripDangerousKeys(value, replaceWith);
73
+ keepCleaned(req, target, value);
57
74
  }
58
75
  }
59
76
  return next();
@@ -1,5 +1,6 @@
1
1
  const rateLimit = require('express-rate-limit');
2
2
  const { createLogger } = require('@astratra/core');
3
+ const { bodyLeftUnparsed } = require('./requestBody');
3
4
 
4
5
  const logger = createLogger('rate-limiters');
5
6
 
@@ -20,6 +21,14 @@ const DEFAULT_ACCOUNT_MESSAGE = {
20
21
 
21
22
  const getIp = (req) => req.ip || req.connection?.remoteAddress || '';
22
23
 
24
+ // Une adresse IPv6 compte pour tout son bloc /56, comme la clé par défaut
25
+ // d'express-rate-limit 8 : sinon chacun change d'adresse dans son bloc et
26
+ // repart avec un compteur neuf. IPv4 reste l'adresse exacte.
27
+ const clientKey = (req) => {
28
+ const ip = getIp(req);
29
+ return typeof rateLimit.ipKeyGenerator === 'function' && ip ? rateLimit.ipKeyGenerator(ip) : ip;
30
+ };
31
+
23
32
  const skipLocalhost = (req) => {
24
33
  const ip = getIp(req);
25
34
  return ip === '::1' || ip === '127.0.0.1' || ip.includes('localhost');
@@ -174,15 +183,27 @@ const withOptionalStore = (limiterOptions, store) => {
174
183
 
175
184
  const defaultApiSkip = () => (process.env.NODE_ENV === 'production' ? undefined : skipLocalhost);
176
185
 
177
- const createApiLimiter = (options = {}) => rateLimit(withOptionalStore({
178
- windowMs: options.windowMs || 15 * 60 * 1000,
179
- max: options.max || 300,
180
- skip: options.skip ?? defaultApiSkip(),
181
- standardHeaders: options.standardHeaders ?? true,
182
- legacyHeaders: options.legacyHeaders ?? false,
183
- validate: options.validate || { ip: false },
184
- message: options.message || DEFAULT_API_MESSAGE
185
- }, resolveStore(options)));
186
+ /**
187
+ * `area(req)` sépare les compteurs : chaque zone rendue (`{ name, max }`) a le
188
+ * sien, par adresse. Avec un seul compteur, une boucle ou un gros téléchargement
189
+ * sur une page rendait toutes les autres indisponibles. L'application donne une
190
+ * liste fermée de noms : un nom tiré librement de l'adresse demandée offrirait
191
+ * un compteur neuf à chaque requête, donc plus aucune limite.
192
+ */
193
+ const createApiLimiter = (options = {}) => {
194
+ const fallback = options.max || 300;
195
+ const { area } = options;
196
+ return rateLimit(withOptionalStore({
197
+ windowMs: options.windowMs || 15 * 60 * 1000,
198
+ max: area ? (req) => area(req)?.max || fallback : fallback,
199
+ ...(area ? { keyGenerator: (req) => `${area(req)?.name || 'default'}:${clientKey(req)}` } : {}),
200
+ skip: options.skip ?? defaultApiSkip(),
201
+ standardHeaders: options.standardHeaders ?? true,
202
+ legacyHeaders: options.legacyHeaders ?? false,
203
+ validate: options.validate || { ip: false },
204
+ message: options.message || DEFAULT_API_MESSAGE
205
+ }, resolveStore(options)));
206
+ };
186
207
 
187
208
  const createLoginLimiter = (options = {}) => rateLimit(withOptionalStore({
188
209
  windowMs: options.windowMs || 15 * 60 * 1000,
@@ -217,7 +238,7 @@ const defaultAccountKeyGenerator = (req) => {
217
238
  // un attaquant peut essayer des mots de passe sur des comptes DIFFÉRENTS
218
239
  // sans jamais être freiné par compte, et des utilisateurs légitimes sans
219
240
  // rapport entre eux peuvent se faire bloquer les uns par les autres.
220
- if (req.body === undefined && !warnedUnparsedBody) {
241
+ if (bodyLeftUnparsed(req) && !warnedUnparsedBody) {
221
242
  warnedUnparsedBody = true;
222
243
  logger.warn(
223
244
  'req.body est undefined dans createAccountLimiter() — à monter APRÈS ' +
@@ -0,0 +1,20 @@
1
+ /**
2
+ * La requête annonce-t-elle un corps ?
3
+ *
4
+ * Express 4 donnait toujours un objet à req.body dès qu'un analyseur
5
+ * (express.json…) était monté, même pour un GET. Express 5 le laisse à
6
+ * undefined quand la requête n'a pas de corps. « req.body est undefined » ne
7
+ * prouve donc un mauvais ordre de montage que si un corps a été envoyé.
8
+ */
9
+ function hasRequestBody(req) {
10
+ const headers = req && req.headers;
11
+ if (!headers) return false;
12
+ if (headers['transfer-encoding'] !== undefined) return true;
13
+ const length = Number(headers['content-length']);
14
+ return Number.isFinite(length) && length > 0;
15
+ }
16
+
17
+ /** Corps envoyé mais jamais lu par un analyseur monté plus tôt. */
18
+ const bodyLeftUnparsed = (req) => req.body === undefined && hasRequestBody(req);
19
+
20
+ module.exports = { hasRequestBody, bodyLeftUnparsed };
package/src/revocation.js CHANGED
@@ -39,8 +39,11 @@ const createMemoryRevocationStore = () => {
39
39
  const revokedBefore = revokedUsers.get(userId);
40
40
  if (revokedBefore === undefined) return false;
41
41
 
42
+ // Sans date d'émission lisible, rien ne prouve que le jeton est postérieur
43
+ // à « déconnecter partout » : il est révoqué.
44
+ if (issuedAtSeconds === undefined || issuedAtSeconds === null || issuedAtSeconds === '') return true;
42
45
  const issuedAtMs = Number(issuedAtSeconds) * 1000;
43
- if (!Number.isFinite(issuedAtMs)) return false;
46
+ if (!Number.isFinite(issuedAtMs)) return true;
44
47
 
45
48
  return issuedAtMs <= revokedBefore;
46
49
  }
package/src/waf.js CHANGED
@@ -1,4 +1,5 @@
1
1
  const { createLogger } = require('@astratra/core');
2
+ const { bodyLeftUnparsed } = require('./requestBody');
2
3
 
3
4
  const logger = createLogger('waf');
4
5
 
@@ -36,13 +37,13 @@ const createWafMiddleware = (options = {}) => {
36
37
  let warnedUnparsedBody = false;
37
38
 
38
39
  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
40
+ // Un corps envoyé mais laissé à `undefined` signifie qu'aucun body-parser
41
+ // (express.json, express.urlencoded...) n'a tourné avant ce middleware.
42
+ // Express 5 laisse aussi req.body à `undefined` quand la requête n'a pas
43
+ // de corps : seul un corps annoncé (voir requestBody.js) compte. Sans cette détection, ce middleware inspectait silencieusement
43
44
  // une chaîne vide à la place du corps de la requête : aucune erreur,
44
45
  // aucun log, juste une protection qui ne protégeait rien.
45
- if (req.body === undefined && !warnedUnparsedBody) {
46
+ if (bodyLeftUnparsed(req) && !warnedUnparsedBody) {
46
47
  warnedUnparsedBody = true;
47
48
  logger.warn(
48
49
  'req.body est undefined — createWafMiddleware() doit être monté APRÈS ' +