@astratra/security 1.0.0 → 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 +16 -0
- package/package.json +1 -1
- package/src/rateLimiters.js +29 -1
- package/src/waf.js +23 -0
- package/src/webauthn.js +17 -1
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
package/src/rateLimiters.js
CHANGED
|
@@ -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,
|
|
@@ -145,10 +148,12 @@ const withOptionalStore = (limiterOptions, store) => {
|
|
|
145
148
|
return { ...limiterOptions, store };
|
|
146
149
|
};
|
|
147
150
|
|
|
151
|
+
const defaultApiSkip = () => (process.env.NODE_ENV === 'production' ? undefined : skipLocalhost);
|
|
152
|
+
|
|
148
153
|
const createApiLimiter = (options = {}) => rateLimit(withOptionalStore({
|
|
149
154
|
windowMs: options.windowMs || 15 * 60 * 1000,
|
|
150
155
|
max: options.max || 300,
|
|
151
|
-
skip: options.skip
|
|
156
|
+
skip: options.skip ?? defaultApiSkip(),
|
|
152
157
|
standardHeaders: options.standardHeaders ?? true,
|
|
153
158
|
legacyHeaders: options.legacyHeaders ?? false,
|
|
154
159
|
validate: options.validate || { ip: false },
|
|
@@ -173,7 +178,30 @@ const createLoginLimiter = (options = {}) => rateLimit(withOptionalStore({
|
|
|
173
178
|
)
|
|
174
179
|
}, resolveStore(options)));
|
|
175
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
|
+
|
|
176
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
|
+
|
|
177
205
|
const body = req.body || {};
|
|
178
206
|
const identifier = body.email || body.identifier || 'unknown';
|
|
179
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),
|
package/src/webauthn.js
CHANGED
|
@@ -93,10 +93,17 @@ const normalizeChallenge = (pending) => {
|
|
|
93
93
|
return {
|
|
94
94
|
challenge: pending.challenge,
|
|
95
95
|
origin: pending.origin || pending.metadata?.origin,
|
|
96
|
-
rpID: pending.rpID || pending.metadata?.rpID
|
|
96
|
+
rpID: pending.rpID || pending.metadata?.rpID,
|
|
97
|
+
expiresAt: pending.expiresAt || pending.metadata?.expiresAt
|
|
97
98
|
};
|
|
98
99
|
};
|
|
99
100
|
|
|
101
|
+
const isExpiredChallenge = (pending) => {
|
|
102
|
+
if (!pending?.expiresAt) return false;
|
|
103
|
+
const expiresAt = new Date(pending.expiresAt).getTime();
|
|
104
|
+
return Number.isFinite(expiresAt) && expiresAt <= Date.now();
|
|
105
|
+
};
|
|
106
|
+
|
|
100
107
|
const publicKeyToBase64Url = (publicKey) => {
|
|
101
108
|
if (Buffer.isBuffer(publicKey)) return publicKey.toString('base64url');
|
|
102
109
|
if (publicKey instanceof Uint8Array) return Buffer.from(publicKey).toString('base64url');
|
|
@@ -164,6 +171,9 @@ const createWebauthnService = (store, options = {}) => {
|
|
|
164
171
|
if (!pending) {
|
|
165
172
|
throw createError('No pending WebAuthn registration challenge.', 400);
|
|
166
173
|
}
|
|
174
|
+
if (isExpiredChallenge(pending)) {
|
|
175
|
+
throw createError('Expired WebAuthn registration challenge.', 400);
|
|
176
|
+
}
|
|
167
177
|
|
|
168
178
|
const verification = await verifyRegistrationResponse({
|
|
169
179
|
response,
|
|
@@ -222,11 +232,17 @@ const createWebauthnService = (store, options = {}) => {
|
|
|
222
232
|
if (!pending) {
|
|
223
233
|
throw createError('No pending WebAuthn authentication challenge.', 400);
|
|
224
234
|
}
|
|
235
|
+
if (isExpiredChallenge(pending)) {
|
|
236
|
+
throw createError('Expired WebAuthn authentication challenge.', 400);
|
|
237
|
+
}
|
|
225
238
|
|
|
226
239
|
const stored = await store.getCredentialById(response.id);
|
|
227
240
|
if (!stored) {
|
|
228
241
|
throw createError('Unknown WebAuthn credential.', 401);
|
|
229
242
|
}
|
|
243
|
+
if (String(stored.userId) !== String(userId)) {
|
|
244
|
+
throw createError('WebAuthn credential does not belong to this user.', 401);
|
|
245
|
+
}
|
|
230
246
|
|
|
231
247
|
const credentialID = stored.credentialID || stored.id;
|
|
232
248
|
const verification = await verifyAuthenticationResponse({
|