@astratra/security 1.14.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
@@ -426,8 +426,10 @@ app.use(createApiLimiter({
426
426
  Avant, `req.body` vaut `undefined` et toutes les tentatives retombent sur la clé
427
427
  partagée `"unknown"` — la limite par compte disparaît au profit d'une limite
428
428
  globale partagée par tous les comptes. Un avertissement (`console.warn`, une
429
- seule fois par processus) signale ce cas. Fournir son propre `keyGenerator`
430
- 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.
431
433
  ```
432
434
 
433
435
  ### Store Redis namespacé
@@ -469,7 +471,9 @@ const { createWafMiddleware } = require('@astratra/security');
469
471
  // vaut undefined et ce middleware n'a rien à inspecter dans le corps de la requête
470
472
  // — il continue de fonctionner (bloque toujours sur path/query), mais silencieusement
471
473
  // sans jamais voir un payload dangereux envoyé dans le body. Un avertissement
472
- // (`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.
473
477
  app.use(express.json());
474
478
  app.use(createWafMiddleware({ message: { success: false, message: 'Requête bloquée.' } }));
475
479
  ```
@@ -496,9 +500,14 @@ l'appelant. Aucune requête légitime n'envoie une clé JSON littéralement
496
500
  préfixée par `$` ou contenant un point — sans risque de faux positif sur un
497
501
  usage normal.
498
502
 
499
- Mute les objets en place plutôt que de réassigner `req.query` (getter
500
- seul sur certaines configurations Express/routeur — une réassignation y
501
- é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.
502
511
 
503
512
  Monté par défaut, sans configuration, par `createSaasApp()` (voir
504
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.14.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;
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');
@@ -187,7 +196,7 @@ const createApiLimiter = (options = {}) => {
187
196
  return rateLimit(withOptionalStore({
188
197
  windowMs: options.windowMs || 15 * 60 * 1000,
189
198
  max: area ? (req) => area(req)?.max || fallback : fallback,
190
- ...(area ? { keyGenerator: (req) => `${area(req)?.name || 'default'}:${getIp(req)}` } : {}),
199
+ ...(area ? { keyGenerator: (req) => `${area(req)?.name || 'default'}:${clientKey(req)}` } : {}),
191
200
  skip: options.skip ?? defaultApiSkip(),
192
201
  standardHeaders: options.standardHeaders ?? true,
193
202
  legacyHeaders: options.legacyHeaders ?? false,
@@ -229,7 +238,7 @@ const defaultAccountKeyGenerator = (req) => {
229
238
  // un attaquant peut essayer des mots de passe sur des comptes DIFFÉRENTS
230
239
  // sans jamais être freiné par compte, et des utilisateurs légitimes sans
231
240
  // rapport entre eux peuvent se faire bloquer les uns par les autres.
232
- if (req.body === undefined && !warnedUnparsedBody) {
241
+ if (bodyLeftUnparsed(req) && !warnedUnparsedBody) {
233
242
  warnedUnparsedBody = true;
234
243
  logger.warn(
235
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 ' +