@exortek/apikey 1.0.2 → 1.1.1

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # @exortek/apikey
 
+## 1.1.1
+
+### Patch Changes
+
+- e53ae64: Fix polynomial-ReDoS (quadratic regex backtracking) surfaced by CodeQL, plus small code-quality fixes.
+  Bundled `@exortek/shared` utilities (base32, base64, duration) are inlined into the packages listed above, so each
+  ships the fix.
+
+  - Replace `/=+$/` trailing-padding strips (base32 / base64 decode, OTP provisioning URI) with linear scans —
+    `"=".repeat(n) + "x"` was O(n²).
+  - Rework the duration parser regex so surrounding whitespace can no longer cause O(n²) matching (trim first, single
+    interior `\s*`).
+  - Strip trailing spaces/dots in filename sanitisation with a linear scan — upload filenames are attacker-controlled.
+  - Cap email length before the regex in magic-link.
+  - Thread the JWT decode label into error messages (removes dead arguments and gives failures which segment broke).
+  - Drop a duplicate character in a UA browser-detection regex character class.
+
+  DoS-hardening and hygiene only — no API or behavioural change for valid input.
+
+## 1.1.0
+
+### Minor Changes
+
+- b1f5d6e: Add `customStore(impl)` — wrap your own `ApiKeyStore` implementation with validation (fails at construction
+  time if a required method is missing) and transparent sync/async wrapping, instead of hand-assembling the interface
+  yourself.
+
+### Patch Changes
+
+- 40fc707: Docs: add a "Rate limiting" section explaining why `@exortek/apikey` ships no built-in limiter and how to
+  front the mint/verify routes with `@exortek/security`'s rate-limit (with a runnable demo in both example servers);
+  document the previously-undocumented `revokeAllForUser` and `listApiKeys` functions; align README structure (badges,
+  `Why`, `Highlights`, `Links`) with the rest of the `@exortek/*` packages.
+
 ## 1.0.2
 
 ### Patch Changes

package/README.md

@@ -3,10 +3,15 @@
 > Stripe-style prefixed API keys for Node.js 22+ — 3-segment tokens (`sk_live_<id>_<secret>`), HMAC-SHA256 storage hash with optional pepper rotation, scope allowlists, memory + Redis stores, Express + Fastify middleware. Zero non-`@exortek/*` runtime dependencies.
 
 [![npm](https://img.shields.io/npm/v/@exortek/apikey.svg?color=cb3837)](https://www.npmjs.com/package/@exortek/apikey)
+[![tests](https://img.shields.io/badge/tests-passing-brightgreen)](https://github.com/ExorTek/auth/actions/workflows/ci.yml)
 [![node](https://img.shields.io/node/v/@exortek/apikey.svg?color=339933)](https://nodejs.org)
 [![install size](https://packagephobia.com/badge?p=@exortek/apikey)](https://packagephobia.com/result?p=@exortek/apikey)
+[![types](https://img.shields.io/badge/types-included-3178C6)](./dist/index.d.ts)
 [![license](https://img.shields.io/npm/l/@exortek/apikey.svg?color=blue)](./LICENSE)
-[![tests](https://img.shields.io/badge/tests-passing-brightgreen)](https://github.com/ExorTek/auth/actions/workflows/ci.yml)
+
+📖 **Docs:** [**auth.memet.dev/apikey**](https://auth.memet.dev/apikey)
+
+## Why
 
 Every API vendor rebuilds the same six things: a prefixed token format so keys are recognisable in logs, hashed storage so a leaked DB doesn't leak secrets, scope allowlists so a machine token can't accidentally admin your infrastructure, revocation, a per-user list for the "manage API keys" UI, and a middleware that turns `Authorization: Bearer <key>` into a verified caller identity. `@exortek/apikey` ships all six.
 
@@ -124,6 +129,27 @@ Never throws on a bad key. Failure reasons:
 | `missing_scope`     | `requiredScopes` not covered by the record's `scopes`.    |
 | `store_unavailable` | `store.getById` threw.                                    |
 
+### `revokeAllForUser(userId, options)`
+
+```ts
+revokeAllForUser(userId: string, {
+  store:    ApiKeyStore,
+  reason?:  string,
+}): Promise<number>  // count of records actually revoked
+```
+
+Revoke every non-revoked key belonging to `userId` in one call — password reset, account termination, etc.
+
+### `listApiKeys(userId, options)`
+
+```ts
+listApiKeys(userId: string, {
+  store: ApiKeyStore,
+}): Promise<ApiKeyRecord[]>  // most-recently-used first
+```
+
+For a "manage API keys" UI. Hide `record.hash` before rendering — only the plaintext `id` is safe to display.
+
 ### Scopes: `covers` / `hasAll` / `hasAny`
 
 ```js
@@ -221,12 +247,37 @@ app.get('/v1/whoami', async req => req.apiKey);
 
 Invalid keys respond with 401 `{ error: 'invalid_api_key', reason }`; missing scope responds 403; store failure responds 503.
 
+## Rate limiting
+
+`@exortek/apikey` doesn't ship a built-in limiter, and deliberately so: `verifyApiKey` is an O(1) store lookup plus a fast HMAC compare, and the secret half is 256-bit random — there's no brute-force cost here for a limiter to blunt (see [Token format](#token-format)). What you actually want to bound is generic request volume, which isn't specific to this package.
+
+Put [`@exortek/security`](https://www.npmjs.com/package/@exortek/security)'s rate-limit in front of the routes that matter:
+
+- **Key-minting route** (`POST /keys` or wherever `createApiKey` is called) — this one has no key-based auth yet, so limit by IP.
+- **Guarded routes** — if you want to slow down credential stuffing beyond a firehose, limit by the `id` segment (plaintext, already in your logs) instead of IP, so one leaked key can't be used to exhaust another caller's budget.
+
+```js
+import { rateLimit } from '@exortek/security';
+import { rateLimitMiddleware } from '@exortek/security/express';
+
+const mintLimiter = rateLimitMiddleware({
+  limiter: rateLimit.sliding({ requests: 5, window: '1m', store: rateLimit.stores.memory() }),
+});
+
+app.post('/keys', mintLimiter, async (req, res) => {
+  /* createApiKey(...) */
+});
+```
+
+See `@exortek/apikey/examples/express-server.js` and `fastify-server.js` for a runnable version.
+
 ## Stores
 
 `@exortek/apikey/stores` ships two implementations. Any object matching the `ApiKeyStore` interface works — bring your own if you already have a keys table in your DB.
 
 - **`memoryStore()`** — in-process Map with a reverse index by `userId`. Not cluster-safe. Fine for dev / single-node prod / tests.
 - **`redisStore(client, { keyPrefix? })`** — layout: `<keyPrefix><id>` (JSON blob) + `<keyPrefix>u:<userId>` (SADD-set of ids). Cluster-safe. Works with `ioredis`, `node-redis@4+`, `@upstash/redis`.
+- **`customStore(impl)`** — wrap your own DB-backed implementation. Validates the required methods exist at construction time (not on the first `createApiKey` call) and wraps sync return values in a Promise, so `impl` can be sync or async.
 
 ### The interface
 
@@ -258,6 +309,20 @@ import { ApiKeyError, ErrorCode } from '@exortek/apikey';
 
 Expected verify failures do NOT throw — they surface as `{ valid: false, reason }`. See the failure-reasons table above.
 
+## Highlights
+
+- Stripe-style 3-segment tokens (`prefix_id_secret`) — recognisable in logs, O(1) lookup by id.
+- HMAC-SHA256 storage hash with optional pepper rotation — never store the raw secret.
+- Scope allowlists with namespace/super wildcards (`covers` / `hasAll` / `hasAny`).
+- Revocation, per-user listing, and last-used tracking for a "manage API keys" UI.
+- Express + Fastify middleware, memory + Redis stores, zero non-`@exortek/*` runtime dependencies.
+
+## Links
+
+- **Source:** [github.com/ExorTek/auth](https://github.com/ExorTek/auth)
+- **Issues & discussions:** [github.com/ExorTek/auth/issues](https://github.com/ExorTek/auth/issues)
+- **Changelog:** [CHANGELOG.md](./CHANGELOG.md)
+
 ## License
 
-MIT
+MIT © ExorTek — see [LICENSE](./LICENSE).

package/dist/index.cjs

@@ -65,7 +65,11 @@ const UNIT_MS = Object.freeze({
   years: 31_536_000_000,
 });
 
-const DURATION_RE = /^\s*(-?\d+(?:\.\d+)?)\s*([a-z]+)?\s*$/i;
+// Note: no leading/trailing `\s*` — the caller trims first. Two `\s*` runs
+// around the optional unit (`\s*([a-z]+)?\s*`) made this O(n^2) on hostile
+// input like `"1" + " ".repeat(n) + "!"`; trimming plus a single interior
+// `\s*` keeps matching linear.
+const DURATION_RE = /^(-?\d+(?:\.\d+)?)\s*([a-z]+)?$/i;
 
 const SUPPORTED_UNITS = 'ms, s, m, h, d, w, y (and long/plural forms)';
 
@@ -95,7 +99,7 @@ function parseDuration(input) {
     throw new TypeError(`parseDuration: expected string or number; got ${typeof input}`);
   }
 
-  const match = DURATION_RE.exec(input);
+  const match = DURATION_RE.exec(input.trim());
   if (!match) {
     throw new Error(
       `parseDuration: could not parse ${JSON.stringify(input)}. Examples: 900 (ms), '15m', '2h', '7d', '500ms', '30s'.`,

package/dist/index.mjs

@@ -63,7 +63,11 @@ const UNIT_MS = Object.freeze({
   years: 31_536_000_000,
 });
 
-const DURATION_RE = /^\s*(-?\d+(?:\.\d+)?)\s*([a-z]+)?\s*$/i;
+// Note: no leading/trailing `\s*` — the caller trims first. Two `\s*` runs
+// around the optional unit (`\s*([a-z]+)?\s*`) made this O(n^2) on hostile
+// input like `"1" + " ".repeat(n) + "!"`; trimming plus a single interior
+// `\s*` keeps matching linear.
+const DURATION_RE = /^(-?\d+(?:\.\d+)?)\s*([a-z]+)?$/i;
 
 const SUPPORTED_UNITS = 'ms, s, m, h, d, w, y (and long/plural forms)';
 
@@ -93,7 +97,7 @@ function parseDuration(input) {
     throw new TypeError(`parseDuration: expected string or number; got ${typeof input}`);
   }
 
-  const match = DURATION_RE.exec(input);
+  const match = DURATION_RE.exec(input.trim());
   if (!match) {
     throw new Error(
       `parseDuration: could not parse ${JSON.stringify(input)}. Examples: 900 (ms), '15m', '2h', '7d', '500ms', '30s'.`,

package/dist/stores/custom.d.ts

@@ -0,0 +1,8 @@
+export function customStore(impl: any): {
+    put: (record: any) => Promise<any>;
+    getById: (id: any) => Promise<any>;
+    update: (id: any, patch: any) => Promise<any>;
+    revoke: (id: any, reason: any) => Promise<any>;
+    revokeAllForUser: (userId: any, reason: any) => Promise<any>;
+    listByUser: (userId: any) => Promise<any>;
+};

package/dist/stores/index.d.ts

@@ -1,2 +1,3 @@
 export { memoryStore } from "./memory.js";
 export { redisStore } from "./redis.js";
+export { customStore } from "./custom.js";

package/dist/stores.cjs

@@ -25,6 +25,27 @@
  * duplicates work the assert family already handles — don't.
  */
 
+/**
+ * `true` when `value` is a plain object *or* a class instance — anything
+ * whose property access is safe. Rejects `null`, arrays, and every
+ * primitive.
+ *
+ * The Node convention `typeof x === 'object' && x !== null` accepts
+ * arrays, which almost never matches caller intent (an array is not a
+ * "config object"). This predicate additionally rules arrays out, so
+ * `isObject(x)` really means "I can read `x.foo` without exploding on
+ * a numeric index".
+ *
+ * Class instances (Node `KeyObject`, `URL`, user-defined classes) pass
+ * because they carry `typeof === 'object'` — the check is duck-typed,
+ * not prototype-restricted.
+ *
+ * @param {unknown} value
+ * @returns {boolean}
+ */
+function isObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
 
 /**
  * `true` when `value` is a string primitive. `String` boxed objects
@@ -1090,5 +1111,40 @@ function redisStore(client, options = {}) {
   };
 }
 
+/**
+ * Wrap a user-supplied store into the `ApiKeyStore` interface.
+ * Validates that the required methods exist so a misconfiguration
+ * surfaces at construction time, not on the first `createApiKey` /
+ * `verifyApiKey` call. Sync implementations are wrapped transparently
+ * — return a plain value or a Promise, either works.
+ *
+ * Required: `put`, `getById`, `update`, `revoke`, `revokeAllForUser`, `listByUser`.
+ *
+ * @param {Partial<import('../index.js').ApiKeyStore>} impl
+ * @returns {import('../index.js').ApiKeyStore}
+ */
+
+const REQUIRED = ['put', 'getById', 'update', 'revoke', 'revokeAllForUser', 'listByUser'];
+
+function customStore(impl) {
+  if (!isObject(impl)) {
+    throw invalidArgument(`customStore(impl) requires an object with { ${REQUIRED.join(', ')} } methods`);
+  }
+  for (const name of REQUIRED) {
+    if (!isFunction(impl[name])) {
+      throw invalidArgument(`customStore: impl.${name} is required and must be a function`);
+    }
+  }
+  return {
+    put: record => Promise.resolve(impl.put(record)),
+    getById: id => Promise.resolve(impl.getById(id)),
+    update: (id, patch) => Promise.resolve(impl.update(id, patch)),
+    revoke: (id, reason) => Promise.resolve(impl.revoke(id, reason)),
+    revokeAllForUser: (userId, reason) => Promise.resolve(impl.revokeAllForUser(userId, reason)),
+    listByUser: userId => Promise.resolve(impl.listByUser(userId)),
+  };
+}
+
+exports.customStore = customStore;
 exports.memoryStore = memoryStore;
 exports.redisStore = redisStore;

package/dist/stores.mjs

@@ -23,6 +23,27 @@
  * duplicates work the assert family already handles — don't.
  */
 
+/**
+ * `true` when `value` is a plain object *or* a class instance — anything
+ * whose property access is safe. Rejects `null`, arrays, and every
+ * primitive.
+ *
+ * The Node convention `typeof x === 'object' && x !== null` accepts
+ * arrays, which almost never matches caller intent (an array is not a
+ * "config object"). This predicate additionally rules arrays out, so
+ * `isObject(x)` really means "I can read `x.foo` without exploding on
+ * a numeric index".
+ *
+ * Class instances (Node `KeyObject`, `URL`, user-defined classes) pass
+ * because they carry `typeof === 'object'` — the check is duck-typed,
+ * not prototype-restricted.
+ *
+ * @param {unknown} value
+ * @returns {boolean}
+ */
+function isObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
 
 /**
  * `true` when `value` is a string primitive. `String` boxed objects
@@ -1088,4 +1109,38 @@ function redisStore(client, options = {}) {
   };
 }
 
-export { memoryStore, redisStore };
+/**
+ * Wrap a user-supplied store into the `ApiKeyStore` interface.
+ * Validates that the required methods exist so a misconfiguration
+ * surfaces at construction time, not on the first `createApiKey` /
+ * `verifyApiKey` call. Sync implementations are wrapped transparently
+ * — return a plain value or a Promise, either works.
+ *
+ * Required: `put`, `getById`, `update`, `revoke`, `revokeAllForUser`, `listByUser`.
+ *
+ * @param {Partial<import('../index.js').ApiKeyStore>} impl
+ * @returns {import('../index.js').ApiKeyStore}
+ */
+
+const REQUIRED = ['put', 'getById', 'update', 'revoke', 'revokeAllForUser', 'listByUser'];
+
+function customStore(impl) {
+  if (!isObject(impl)) {
+    throw invalidArgument(`customStore(impl) requires an object with { ${REQUIRED.join(', ')} } methods`);
+  }
+  for (const name of REQUIRED) {
+    if (!isFunction(impl[name])) {
+      throw invalidArgument(`customStore: impl.${name} is required and must be a function`);
+    }
+  }
+  return {
+    put: record => Promise.resolve(impl.put(record)),
+    getById: id => Promise.resolve(impl.getById(id)),
+    update: (id, patch) => Promise.resolve(impl.update(id, patch)),
+    revoke: (id, reason) => Promise.resolve(impl.revoke(id, reason)),
+    revokeAllForUser: (userId, reason) => Promise.resolve(impl.revokeAllForUser(userId, reason)),
+    listByUser: userId => Promise.resolve(impl.listByUser(userId)),
+  };
+}
+
+export { customStore, memoryStore, redisStore };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exortek/apikey",
-  "version": "1.0.2",
+  "version": "1.1.1",
   "description": "Stripe-style prefixed API keys for Node.js — 3-segment tokens (prefix_id_secret), HMAC-SHA256 storage hash with pepper rotation, scope allowlists with wildcard match, opt-in lastUsedAt tracking, memory + Redis stores, Express + Fastify middleware. Server-only. Zero non-@exortek runtime dependencies.",
   "type": "module",
   "sideEffects": false,