@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 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.0",
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,
@@ -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 || skipLocalhost,
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({