@astratra/security 1.14.0 → 1.15.1

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
@@ -206,7 +206,32 @@ app.delete('/api/projects/:id', authorizeRoles('owner', 'admin'), handler);
206
206
  ```
207
207
 
208
208
  Par défaut, le middleware limite la vérification à `HS256`. Si ton application
209
- utilise un autre algorithme, configure explicitement `algorithms`.
209
+ utilise un autre algorithme, configure explicitement `algorithms`. Un jeton émis
210
+ plus d'une minute dans le futur (`clockTolerance` pour un autre écart) est refusé :
211
+ sinon il échapperait à « déconnecter partout ».
212
+
213
+ ### Les jetons eux-mêmes, sans dépendance
214
+
215
+ Depuis la 1.15.1, les jetons sont signés et vérifiés par le paquet (`signJwt`,
216
+ `verifyJwt`, `decodeJwt`), sans jsonwebtoken : même forme de jeton, mêmes options,
217
+ mêmes erreurs (`JsonWebTokenError`, `TokenExpiredError`, `NotBeforeError`),
218
+ comparés à jsonwebtoken 9 sur 120 signatures et 936 vérifications enregistrées.
219
+ HS256/384/512, RS256/384/512, PS256/384/512, ES256/384/512.
220
+
221
+ ```js
222
+ const { signJwt, verifyJwt } = require('@astratra/security');
223
+
224
+ const token = signJwt({ id: user.id, role: user.role }, process.env.JWT_SECRET, { expiresIn: '15m', issuer: 'mon-app' });
225
+ const claims = verifyJwt(token, process.env.JWT_SECRET, { algorithms: ['HS256'], issuer: 'mon-app' });
226
+ ```
227
+
228
+ Plus strict que jsonwebtoken, sans regret : `algorithms` est obligatoire et « none »
229
+ n'existe pas ; une clé ne sert qu'à sa famille (une clé publique n'est jamais un
230
+ secret HMAC, une clé EC doit être de la courbe de l'algorithme, une clé RSA d'au
231
+ moins 2 048 bits) ; chaque morceau doit être du base64url exact ; un en-tête `crit`
232
+ est refusé ; la charge doit être un objet ; un jeton de plus de 16 Kio est refusé ;
233
+ une entrée abîmée donne toujours une `JsonWebTokenError` (jsonwebtoken laissait
234
+ parfois passer une SyntaxError ou une TypeError).
210
235
 
211
236
  **Session par cookie sans `cookieParserMiddleware()` monté en amont** :
212
237
  `createAuthMiddleware` a besoin de `req.cookies` pour lire un cookie de
@@ -358,6 +383,30 @@ reproduire.
358
383
 
359
384
  Un identifiant ne doit jamais pouvoir être lu comme du contenu.
360
385
 
386
+ ## Double authentification (codes à six chiffres)
387
+
388
+ Les codes des applications d'authentification (TOTP, RFC 6238), sans otplib :
389
+ mêmes codes, mêmes vérifications et mêmes adresses `otpauth://` qu'otplib 13 sur
390
+ des vecteurs enregistrés, et les vecteurs des RFC 4226 et 6238.
391
+
392
+ ```js
393
+ const { generateTotpSecret, totpUri, verifyTotp } = require('@astratra/security');
394
+
395
+ const secret = generateTotpSecret(); // 32 caractères base32 (160 bits), à garder chiffré
396
+ const uri = totpUri({ issuer: 'Mon App', label: user.email, secret }); // à montrer en QR code
397
+
398
+ const result = verifyTotp({ secret, token: req.body.code, afterStep: user.dernierPas });
399
+ if (!result.valid) return refuser();
400
+ user.dernierPas = result.timeStep; // le même code ne sert pas deux fois
401
+ ```
402
+
403
+ - Un pas de décalage admis par défaut (`epochTolerance: 30`) ; `afterStep` refuse
404
+ un code déjà servi ; tous les pas de la fenêtre sont comparés en temps constant.
405
+ - Un code mal formé est simplement invalide (otplib levait une exception) ; un
406
+ émetteur ou un compte contenant « : » est refusé (l'adresse serait ambiguë).
407
+ - Six chiffres font un million de codes : limitez les essais de la route
408
+ (`createAccountLimiter`), sinon un robot finit par trouver.
409
+
361
410
  ## Codes uniques
362
411
 
363
412
  ```js
@@ -426,16 +475,34 @@ app.use(createApiLimiter({
426
475
  Avant, `req.body` vaut `undefined` et toutes les tentatives retombent sur la clé
427
476
  partagée `"unknown"` — la limite par compte disparaît au profit d'une limite
428
477
  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.
478
+ seule fois par processus) signale ce cas. Il ne part que si la requête annonce
479
+ un corps (`content-length` non nul ou `transfer-encoding`) : avec Express 5,
480
+ `req.body` reste `undefined` pour une requête sans corps, même bien montée.
481
+ Fournir son propre `keyGenerator` contourne complètement ce point.
431
482
  ```
432
483
 
433
- ### Store Redis namespacé
484
+ ### Le limiteur, sans dépendance
434
485
 
435
- Par défaut, `redisUrl` seul suffit à activer un store Redis partagé entre
436
- tous les limiteurs. Pour isoler les compteurs par domaine (connexion,
437
- réservation, avis...) sur la même instance Redis, construis le store avec
438
- un préfixe et passe-le via `options.store` :
486
+ Depuis la 1.15.1, le limiteur est écrit dans ce paquet (`createRateLimit`), sans
487
+ express-rate-limit ni rate-limit-redis. Mêmes options, mêmes réponses (429, en-têtes
488
+ `RateLimit-*` et `Retry-After`), même clé par adresse (une adresse IPv6 compte pour
489
+ tout son bloc /56, comme avant : vérifié sur 500 adresses contre l'ancienne
490
+ bibliothèque). Un magasin en panne ne laisse jamais passer sans compter :
491
+ `next(erreur)`, sauf `passOnStoreError: true`.
492
+
493
+ ```js
494
+ const { createRateLimit, createMemoryRateLimitStore, rateLimitKeyForIp } = require('@astratra/security');
495
+
496
+ app.post('/codes', createRateLimit({ windowMs: 10 * 60 * 1000, max: 5, keyGenerator: (req) => req.body.telephone }));
497
+ ```
498
+
499
+ ### Store Redis
500
+
501
+ `redisUrl` seul suffit : chaque sorte de limiteur a alors son espace de clés
502
+ (`rl:api:`, `rl:login:`, `rl:account:`), pour que les requêtes ordinaires ne
503
+ remplissent pas le compteur de la connexion. Pour isoler les compteurs par domaine
504
+ (connexion, réservation, avis...), construis le store avec un préfixe et passe-le
505
+ via `options.store` :
439
506
 
440
507
  ```js
441
508
  const { createApiLimiter, createLoginLimiter, createRedisRateLimitStore } = require('@astratra/security');
@@ -446,19 +513,22 @@ const loginStore = createRedisRateLimitStore({
446
513
  });
447
514
  app.use('/auth', createLoginLimiter({ store: loginStore }));
448
515
 
449
- const bookingStore = createRedisRateLimitStore({
450
- redisUrl: process.env.REDIS_URL,
451
- prefix: 'mon-app:rate:reservation:'
452
- });
516
+ // Ou une connexion du projet : sendCommand (node-redis : client.sendCommand ; ioredis : (args) => client.call(...args)).
517
+ const bookingStore = createRedisRateLimitStore({ client: redisClient, prefix: 'mon-app:rate:reservation:' });
453
518
  app.use('/bookings', createApiLimiter({ store: bookingStore }));
454
519
  ```
455
520
 
456
- `prefix` est entièrement libre et défini par le projet consommateur — Astratra
457
- ne connaît aucun nom de domaine métier. Si Redis n'est pas joignable au
458
- démarrage ou perd la connexion, le store bascule automatiquement sur un
459
- store en mémoire process (mêmes garanties que le store par défaut sans
460
- `prefix`), donc aucune configuration additionnelle n'est nécessaire pour
461
- gérer l'indisponibilité de Redis.
521
+ - Le compteur et son expiration s'écrivent en une seule opération (script Lua) :
522
+ une panne entre les deux ne laisse jamais un compteur sans fin.
523
+ - Les clés sont hachées (SHA-256) : ni adresse ni e-mail en clair dans Redis.
524
+ - Tant que Redis ne répond pas (au démarrage, coupé, ou figé sans répondre), le
525
+ compte se fait en mémoire de ce serveur : la limite reste appliquée. Une
526
+ commande sans réponse au-delà de `commandTimeoutMs` (1 s) compte comme une
527
+ panne ; Redis est réessayé après `retryAfterMs` (2 s). Au retour de Redis, le
528
+ compte en mémoire et celui de Redis ne s'additionnent pas : une adresse peut
529
+ obtenir jusqu'à deux fois la limite au moment de la bascule, jamais plus.
530
+ - `prefix` est entièrement libre et défini par le projet consommateur — Astratra
531
+ ne connaît aucun nom de domaine métier.
462
532
 
463
533
  ## WAF
464
534
 
@@ -469,7 +539,9 @@ const { createWafMiddleware } = require('@astratra/security');
469
539
  // vaut undefined et ce middleware n'a rien à inspecter dans le corps de la requête
470
540
  // — il continue de fonctionner (bloque toujours sur path/query), mais silencieusement
471
541
  // 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.
542
+ // (`console.warn`, une seule fois par instance) signale ce cas s'il se produit :
543
+ // seulement pour une requête qui annonce un corps (content-length non nul ou
544
+ // transfer-encoding), car Express 5 laisse req.body à undefined sans corps.
473
545
  app.use(express.json());
474
546
  app.use(createWafMiddleware({ message: { success: false, message: 'Requête bloquée.' } }));
475
547
  ```
@@ -496,9 +568,14 @@ l'appelant. Aucune requête légitime n'envoie une clé JSON littéralement
496
568
  préfixée par `$` ou contenant un point — sans risque de faux positif sur un
497
569
  usage normal.
498
570
 
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).
571
+ Fonctionne avec Express 4 et Express 5. Express 5 définit `req.query` par
572
+ un lecteur qui relit l'adresse à chaque accès : un nettoyage fait en place
573
+ serait perdu au prochain accès. L'objet nettoyé devient donc la valeur de
574
+ `req.query` pour la suite de la requête (sous Express 4, où `req.query` est
575
+ une simple valeur, rien ne change). Avec l'analyseur de requêtes par défaut
576
+ d'Express 5 (`simple`), `?date[$gt]=x` reste une clé plate et inoffensive
577
+ (`"date[$gt]": "x"`) ; avec `app.set('query parser', 'extended')`, il devient un
578
+ objet, que ce middleware vide comme sous Express 4.
502
579
 
503
580
  Monté par défaut, sans configuration, par `createSaasApp()` (voir
504
581
  `@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.1",
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",
@@ -12,7 +12,8 @@
12
12
  "src"
13
13
  ],
14
14
  "scripts": {
15
- "test": "jest"
15
+ "test": "jest",
16
+ "verify:mutations": "node scripts/verify-rate-limit-mutations.cjs && node scripts/verify-jwt-mutations.cjs && node scripts/verify-totp-mutations.cjs"
16
17
  },
17
18
  "jest": {
18
19
  "testMatch": [
@@ -30,25 +31,19 @@
30
31
  },
31
32
  "dependencies": {
32
33
  "@astratra/core": "^1.0.0",
33
- "@simplewebauthn/server": "^13.1.2",
34
- "express-rate-limit": "^7.5.1",
35
- "jsonwebtoken": "^9.0.2"
34
+ "@simplewebauthn/server": "^13.1.2"
36
35
  },
37
36
  "peerDependencies": {
38
- "rate-limit-redis": ">=4",
39
37
  "redis": ">=4"
40
38
  },
41
39
  "peerDependenciesMeta": {
42
- "rate-limit-redis": {
43
- "optional": true
44
- },
45
40
  "redis": {
46
41
  "optional": true
47
42
  }
48
43
  },
49
44
  "devDependencies": {
45
+ "@astratra/testkit": "^2.0.0",
50
46
  "jest": "30.4.2",
51
- "rate-limit-redis": "^4.2.0",
52
- "redis": "^4.7.0"
47
+ "redis": "^6.3.1"
53
48
  }
54
49
  }
package/src/csrf.js CHANGED
@@ -73,6 +73,18 @@ const headerValue = (req, name) => {
73
73
  return headers[name.toLowerCase()] || headers[name];
74
74
  };
75
75
 
76
+ /**
77
+ * Compares the submitted header with the cookie token in constant time, so
78
+ * response timing never reveals how many leading characters were right.
79
+ * Anything but a non-empty string (a missing or repeated header) is refused.
80
+ */
81
+ const tokensMatch = (received, expected) => {
82
+ if (typeof received !== 'string' || typeof expected !== 'string' || expected.length === 0) return false;
83
+ const a = Buffer.from(received, 'utf8');
84
+ const b = Buffer.from(expected, 'utf8');
85
+ return a.length === b.length && crypto.timingSafeEqual(a, b);
86
+ };
87
+
76
88
  const setCsrfCookie = (res, token, options = {}) => {
77
89
  const parts = [
78
90
  `${options.name || DEFAULT_CSRF_COOKIE_NAME}=${token}`,
@@ -108,7 +120,7 @@ const createCsrfMiddleware = (options = {}) => {
108
120
  return next();
109
121
  }
110
122
 
111
- if (headerValue(req, headerName) !== token) {
123
+ if (!tokensMatch(headerValue(req, headerName), token)) {
112
124
  return res.status(403).json({ success: false, message: 'Invalid CSRF token.' });
113
125
  }
114
126
 
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/idTokens.js CHANGED
@@ -1,7 +1,7 @@
1
1
  /**
2
2
  * Vérifier un jeton d'identité OpenID Connect (Google, Apple, tout fournisseur
3
3
  * qui publie ses clés en JWKS) sans dépendance JOSE : Node transforme chaque
4
- * JWK en KeyObject, jsonwebtoken vérifie la signature, l'émetteur, l'audience
4
+ * JWK en KeyObject, verifyJwt (./jwt) vérifie la signature, l'émetteur, l'audience
5
5
  * et l'expiration.
6
6
  *
7
7
  * Ce que le module garantit, chaque point testé :
@@ -28,7 +28,7 @@
28
28
  * contient jamais le jeton.
29
29
  */
30
30
  const crypto = require('crypto');
31
- const jwt = require('jsonwebtoken');
31
+ const { decodeJwt, verifyJwt } = require('./jwt');
32
32
 
33
33
  const DEFAULT_CACHE_MS = 60 * 60 * 1000;
34
34
  const DEFAULT_MIN_REFRESH_MS = 60 * 1000;
@@ -145,7 +145,7 @@ function createIdTokenVerifier(options = {}) {
145
145
  if (typeof idToken !== 'string' || !idToken || idToken.length > MAX_TOKEN_LENGTH) {
146
146
  throw new IdTokenError('malformed');
147
147
  }
148
- const decoded = jwt.decode(idToken, { complete: true });
148
+ const decoded = decodeJwt(idToken, { complete: true });
149
149
  const header = decoded && decoded.header;
150
150
  if (!header || header.alg !== 'RS256' || typeof header.kid !== 'string' || !header.kid) {
151
151
  throw new IdTokenError('malformed');
@@ -155,7 +155,8 @@ function createIdTokenVerifier(options = {}) {
155
155
 
156
156
  let claims;
157
157
  try {
158
- claims = jwt.verify(idToken, key, {
158
+ claims = verifyJwt(idToken, key, {
159
+ maxTokenLength: MAX_TOKEN_LENGTH,
159
160
  algorithms: ['RS256'],
160
161
  issuer: issuers,
161
162
  audience: audienceList,
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;
@@ -252,37 +253,86 @@ export function createCsrfMiddleware(options?: CsrfMiddlewareOptions): RequestHa
252
253
  export function createCsrfCookiePrimer(options?: Pick<CsrfMiddlewareOptions, 'name' | 'sameSite' | 'secure' | 'path' | 'domain' | 'skip'>): RequestHandler;
253
254
 
254
255
  export interface RateLimitStore {
255
- init?(options: unknown): unknown;
256
- increment?(...args: unknown[]): unknown;
257
- decrement?(...args: unknown[]): unknown;
258
- resetKey?(...args: unknown[]): unknown;
259
- resetAll?(...args: unknown[]): unknown;
260
- get?(...args: unknown[]): unknown;
261
- shutdown?(...args: unknown[]): unknown;
256
+ /** Reçoit la fenêtre du limiteur ({ windowMs }) à sa création. */
257
+ init?(options: { windowMs: number }): unknown;
258
+ /** Compte une requête pour la clé : le nombre dans la fenêtre et sa fin. */
259
+ increment(key: string): Awaitable<{ totalHits: number; resetTime?: Date }>;
260
+ decrement?(key: string): unknown;
261
+ resetKey?(key: string): unknown;
262
+ resetAll?(): unknown;
263
+ get?(key: string): Awaitable<{ totalHits: number; resetTime?: Date } | undefined>;
264
+ shutdown?(): unknown;
265
+ localKeys?: boolean;
266
+ prefix?: string;
262
267
  }
263
268
 
269
+ export interface RateLimitInfo { limit: number; used: number; remaining: number; resetTime: Date; key: string }
270
+
264
271
  export interface RateLimitOptions {
265
272
  windowMs?: number;
266
273
  max?: number;
267
- skip?: (req: RequestLike) => boolean | Promise<boolean>;
274
+ skip?: (req: RequestLike, res?: ResponseLike) => boolean | Promise<boolean>;
268
275
  standardHeaders?: boolean | string;
269
276
  legacyHeaders?: boolean;
277
+ /** Sans effet depuis la 1.15.1 (le limiteur n'est plus express-rate-limit) ; accepté pour ne rien casser. */
270
278
  validate?: Record<string, unknown> | boolean;
271
279
  message?: unknown;
272
280
  store?: RateLimitStore;
273
281
  redisUrl?: string;
274
282
  }
275
283
 
284
+ /** Le limiteur lui-même (sans dépendance) : fenêtre fixe par clé, magasin interchangeable, en-têtes RateLimit-*. */
285
+ export interface CreateRateLimitOptions {
286
+ windowMs?: number;
287
+ limit?: number | ((req: any, res: any) => number | Promise<number>);
288
+ max?: number | ((req: any, res: any) => number | Promise<number>);
289
+ keyGenerator?: (req: any, res: any) => string | Promise<string>;
290
+ skip?: (req: any, res: any) => boolean | Promise<boolean>;
291
+ message?: unknown | ((req: any, res: any) => unknown);
292
+ statusCode?: number;
293
+ handler?: (req: any, res: any, next: (error?: unknown) => void, options: CreateRateLimitOptions & { statusCode: number; limit: number; windowMs: number }) => unknown;
294
+ standardHeaders?: boolean;
295
+ legacyHeaders?: boolean;
296
+ store?: RateLimitStore;
297
+ /** Faux par défaut : un magasin en panne donne next(erreur), jamais un passage sans compter. */
298
+ passOnStoreError?: boolean;
299
+ requestPropertyName?: string;
300
+ skipSuccessfulRequests?: boolean;
301
+ skipFailedRequests?: boolean;
302
+ requestWasSuccessful?: (req: any, res: any) => boolean;
303
+ /** Le bloc IPv6 qui compte pour une seule adresse (56 par défaut) ; false pour l'adresse exacte. */
304
+ ipv6Subnet?: number | false;
305
+ }
306
+ export type RateLimitMiddleware = RequestHandler & {
307
+ resetKey(key: string): unknown;
308
+ getKey(key: string): unknown;
309
+ store: RateLimitStore;
310
+ };
311
+ export function createRateLimit(options?: CreateRateLimitOptions): RateLimitMiddleware;
312
+ export function createMemoryRateLimitStore(options?: { maxKeys?: number }): RateLimitStore;
313
+ /** La clé d'une adresse : IPv4 telle quelle (même écrite en IPv6), IPv6 par bloc (/56 par défaut). */
314
+ export function rateLimitKeyForIp(address: string, subnet?: number | false): string;
315
+
276
316
  export interface RedisRateLimitStoreOptions {
277
- /** URL de connexion Redis. */
317
+ /** URL de connexion Redis (le paquet `redis` doit être installé). */
278
318
  redisUrl?: string;
279
- /** Préfixe Redis librement défini par le projet consommateur. */
319
+ /** Préfixe Redis librement défini par le projet (« rl: » par défaut). */
280
320
  prefix?: string;
321
+ /** Une connexion du projet : sendCommand(['EVAL', …]) (node-redis : client.sendCommand ; ioredis : (args) => client.call(...args)). */
322
+ sendCommand?: (args: string[]) => Promise<unknown>;
323
+ /** Un client node-redis du projet. */
324
+ client?: { sendCommand(args: string[]): Promise<unknown> };
325
+ /** Clés hachées en SHA-256 (vrai par défaut) : ni adresse ni e-mail en clair dans Redis. */
326
+ hashKeys?: boolean;
327
+ /** Au-delà, une commande compte comme une panne (1 000 ms par défaut). */
328
+ commandTimeoutMs?: number;
329
+ /** Après une panne, compte en mémoire pendant ce temps avant de réessayer Redis (2 000 ms par défaut). */
330
+ retryAfterMs?: number;
281
331
  }
282
332
 
283
333
  /**
284
- * Crée un store express-rate-limit Redis avec bascule mémoire si Redis est
285
- * indisponible. Le préfixe est optionnel et entièrement défini par le projet.
334
+ * Crée un magasin Redis (compteur et expiration en une seule opération, clés hachées). Tant que Redis ne répond pas,
335
+ * le compte se fait en mémoire de ce serveur : la limite reste appliquée.
286
336
  */
287
337
  export function createRedisRateLimitStore(options?: RedisRateLimitStoreOptions): RateLimitStore | undefined;
288
338
 
@@ -993,3 +1043,63 @@ export function canonicalDeviceRequest(parts: { method: string; path: string; ti
993
1043
  /** Raw 65-byte point (base64), SPKI DER (base64) or PEM, P-256 only; returns the SPKI PEM. */
994
1044
  export function importDevicePublicKey(value: string): string;
995
1045
  export const DEVICE_SIGNATURE_HEADERS: { device: string; time: string; nonce: string; signature: string; key: string };
1046
+
1047
+ /** Les jetons JWT (JWS compact), sans jsonwebtoken. */
1048
+ export type JwtAlgorithm = 'HS256' | 'HS384' | 'HS512' | 'RS256' | 'RS384' | 'RS512' | 'PS256' | 'PS384' | 'PS512' | 'ES256' | 'ES384' | 'ES512';
1049
+ export type JwtKey = string | Buffer | import('node:crypto').KeyObject;
1050
+ export interface SignJwtOptions {
1051
+ algorithm?: JwtAlgorithm;
1052
+ /** Secondes, ou durée « 15m », « 2 days » (sans unité : millisecondes). */
1053
+ expiresIn?: number | string;
1054
+ notBefore?: number | string;
1055
+ audience?: string | string[];
1056
+ issuer?: string;
1057
+ subject?: string;
1058
+ jwtid?: string;
1059
+ keyid?: string;
1060
+ header?: Record<string, unknown>;
1061
+ noTimestamp?: boolean;
1062
+ }
1063
+ export interface VerifyJwtOptions {
1064
+ /** Obligatoire : les algorithmes acceptés. */
1065
+ algorithms: JwtAlgorithm[];
1066
+ issuer?: string | string[];
1067
+ audience?: string | RegExp | Array<string | RegExp>;
1068
+ subject?: string;
1069
+ jwtid?: string;
1070
+ clockTolerance?: number;
1071
+ clockTimestamp?: number;
1072
+ maxAge?: number | string;
1073
+ /** 16 Kio par défaut. */
1074
+ maxTokenLength?: number;
1075
+ ignoreExpiration?: boolean;
1076
+ ignoreNotBefore?: boolean;
1077
+ complete?: boolean;
1078
+ }
1079
+ export function signJwt(payload: Record<string, unknown>, key: JwtKey, options?: SignJwtOptions): string;
1080
+ export function verifyJwt<T = Record<string, unknown>>(token: string, key: JwtKey, options: VerifyJwtOptions): T;
1081
+ export function decodeJwt(token: string, options?: { complete?: boolean }): unknown;
1082
+ export class JsonWebTokenError extends Error {}
1083
+ export class TokenExpiredError extends JsonWebTokenError { expiredAt: Date }
1084
+ export class NotBeforeError extends JsonWebTokenError { date: Date }
1085
+ export const JWT_ALGORITHMS: JwtAlgorithm[];
1086
+
1087
+ /** La double authentification par code à six chiffres (TOTP, RFC 6238), sans otplib. */
1088
+ export interface TotpOptions { digits?: number; algorithm?: 'sha1' | 'sha256' | 'sha512'; period?: number }
1089
+ export function generateTotpSecret(options?: { bytes?: number }): string;
1090
+ export function hotp(secret: string | Buffer, counter: number, options?: TotpOptions): string;
1091
+ export function totp(secret: string | Buffer, options?: TotpOptions & { epoch?: number }): string;
1092
+ export function verifyTotp(options: TotpOptions & {
1093
+ secret: string | Buffer;
1094
+ token: unknown;
1095
+ /** Secondes ; maintenant par défaut. */
1096
+ epoch?: number;
1097
+ /** Secondes de décalage admises (30 par défaut : un pas avant ou après). */
1098
+ epochTolerance?: number;
1099
+ /** Le timeStep du dernier code accepté : un pas égal ou antérieur est refusé (code rejoué). */
1100
+ afterStep?: number | null;
1101
+ }): { valid: true; delta: number; timeStep: number; epoch: number } | { valid: false; reason: 'format' | 'mismatch' | 'replay'; timeStep?: number };
1102
+ export function totpUri(options: TotpOptions & { issuer: string; label: string; secret: string | Buffer }): string;
1103
+ export function base32Encode(buffer: Buffer): string;
1104
+ export function base32Decode(text: string): Buffer;
1105
+ export class TotpError extends Error {}
package/src/index.js CHANGED
@@ -2,6 +2,8 @@ module.exports = {
2
2
  ...require('./codes'),
3
3
  ...require('./cors'),
4
4
  ...require('./encryption'),
5
+ ...require('./jwt'),
6
+ ...require('./totp'),
5
7
  ...require('./jwtAuth'),
6
8
  ...require('./passwordHashing'),
7
9
  ...require('./mongoSanitize'),