@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 +29 -6
- package/package.json +5 -5
- package/src/encryption.js +7 -1
- package/src/index.d.ts +5 -2
- package/src/jwtAuth.js +1 -1
- package/src/mongoSanitize.js +19 -2
- package/src/rateLimiters.js +31 -10
- package/src/requestBody.js +20 -0
- package/src/revocation.js +4 -1
- package/src/waf.js +6 -5
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.
|
|
416
|
-
|
|
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
|
-
|
|
486
|
-
|
|
487
|
-
|
|
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.
|
|
3
|
+
"version": "1.15.0",
|
|
4
4
|
"description": "Generic authentication and security middleware for Astratra workspaces.",
|
|
5
5
|
"engines": {
|
|
6
|
-
"node": ">=
|
|
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.
|
|
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": "^
|
|
52
|
-
"redis": "^
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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);
|
package/src/mongoSanitize.js
CHANGED
|
@@ -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
|
-
|
|
56
|
-
|
|
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();
|
package/src/rateLimiters.js
CHANGED
|
@@ -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
|
-
|
|
178
|
-
|
|
179
|
-
|
|
180
|
-
|
|
181
|
-
|
|
182
|
-
|
|
183
|
-
|
|
184
|
-
|
|
185
|
-
|
|
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
|
|
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
|
|
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
|
-
//
|
|
40
|
-
// express.urlencoded...) n'a tourné avant ce middleware
|
|
41
|
-
//
|
|
42
|
-
//
|
|
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
|
|
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 ' +
|