@blamejs/blamejs-shop 0.3.69 → 0.3.71

package/lib/vendor/blamejs/test/layer-0-primitives/api-encrypt.test.js

@@ -1144,6 +1144,338 @@ async function testApiEncryptObservabilityCounters() {
   check("observability emits apiEncrypt.session.created on bootstrap", hasCreated);
 }
 
+// _clusterStyleSessionStore — models a multi-replica session backend
+// where every get() deserialises a FRESH copy of the stored row (as a
+// real cluster store does — each call returns its own object, never a
+// shared reference) and get/set/delete are genuinely async (yield to the
+// microtask queue). This is the shape that exposes a non-atomic
+// read-modify-write counter guard: two concurrent requests both read the
+// same lastReqCtr from independent copies and both pass a copy-local
+// check. `gets` counts reads so the test can confirm both requests
+// actually raced through get() before either set() landed.
+function _clusterStyleSessionStore() {
+  var rows = Object.create(null);
+  var gets = 0;
+  return {
+    get: async function (sid) {
+      gets += 1;
+      await Promise.resolve();                 // force a microtask yield
+      var raw = rows[sid];
+      if (raw === undefined) return null;
+      return JSON.parse(raw);                  // fresh deserialised copy
+    },
+    set: async function (sid, row) {
+      await Promise.resolve();
+      rows[sid] = JSON.stringify(row);
+    },
+    delete: async function (sid) {
+      await Promise.resolve();
+      delete rows[sid];
+    },
+    _gets: function () { return gets; },
+  };
+}
+
+async function testApiEncryptCreateRejectsBadReplayWindow() {
+  var keypair = _serverKeypair();
+  var threw = null;
+  try {
+    b.middleware.apiEncrypt({ keypair: keypair, audit: false, replayWindowMs: "5m" });
+  } catch (e) { threw = e; }
+  check("apiEncrypt: create() rejects string replayWindowMs at boot",
+        threw && /replayWindowMs/.test(threw.message));
+  threw = null;
+  try {
+    b.middleware.apiEncrypt({ keypair: keypair, audit: false, replayWindowMs: 0 });
+  } catch (e) { threw = e; }
+  check("apiEncrypt: create() rejects replayWindowMs=0 (disables staleness defense)",
+        threw && /replayWindowMs/.test(threw.message));
+  threw = null;
+  try {
+    b.middleware.apiEncrypt({ keypair: keypair, audit: false, maxDecryptedBytes: "lots" });
+  } catch (e) { threw = e; }
+  check("apiEncrypt: create() rejects non-numeric maxDecryptedBytes",
+        threw && /maxDecryptedBytes/.test(threw.message));
+  threw = null;
+  try {
+    b.middleware.apiEncrypt({ keypair: keypair, audit: false, pruneIntervalMs: "soon" });
+  } catch (e) { threw = e; }
+  check("apiEncrypt: create() rejects non-numeric pruneIntervalMs",
+        threw && /pruneIntervalMs/.test(threw.message));
+  // Sanity: a valid numeric replayWindowMs still builds.
+  var ok = b.middleware.apiEncrypt({ keypair: keypair, audit: false, replayWindowMs: 30000 });
+  check("apiEncrypt: create() accepts numeric replayWindowMs", typeof ok === "function");
+}
+
+async function testApiEncryptClientRejectsBadMaxDecryptedBytes() {
+  var keypair = _serverKeypair();
+  var threw = null;
+  try {
+    b.middleware.apiEncrypt.client({ pubkey: keypair, maxDecryptedBytes: "5m" });
+  } catch (e) { threw = e; }
+  check("apiEncrypt.client: rejects string maxDecryptedBytes at boot",
+        threw && /maxDecryptedBytes/.test(threw.message));
+}
+
+async function testApiEncryptHttpClientRejectsBadMaxDecryptedBytes() {
+  var keypair = _serverKeypair();
+  var threw = null;
+  try {
+    b.middleware.apiEncrypt.httpClient({ pubkey: keypair, maxDecryptedBytes: "5m" });
+  } catch (e) { threw = e; }
+  check("apiEncrypt.httpClient: rejects string maxDecryptedBytes at boot",
+        threw && /maxDecryptedBytes/.test(threw.message));
+}
+
+async function testApiEncryptPerSessionConcurrentCtrExecutesOnce() {
+  var keypair = _serverKeypair();
+  var store = _clusterStyleSessionStore();
+  var mw = b.middleware.apiEncrypt({
+    keypair:      keypair,
+    audit:        false,
+    keying:       "per-session",
+    sessionStore: store,
+  });
+  var clientCtx = b.middleware.apiEncrypt.client({
+    pubkey: keypair, keying: "per-session",
+  });
+
+  // Bootstrap the session (ctr=1) so a row exists in the store.
+  var first = clientCtx.encryptRequest({ n: 1 });
+  var req1 = _bodyReq("POST", { "content-type": "application/json" }, "");
+  req1.body = first.body;
+  var res1 = _mkRes();
+  var fin1 = _newFinish(res1);
+  await mw(req1, res1, function () { res1.json({ ok: 1 }); });
+  await fin1;
+  check("concurrent-ctr: bootstrap 200", res1._endedStatus === 200);
+
+  // Build ONE subsequent request (ctr=2), then submit two byte-identical
+  // copies of it concurrently — the double-execution replay an attacker
+  // (or a buggy retry) lands on a clustered store.
+  var second = clientCtx.encryptRequest({ n: 2 });
+  var execCount = 0;
+
+  function _submit() {
+    var req = _bodyReq("POST", { "content-type": "application/json" }, "");
+    req.body = JSON.parse(JSON.stringify(second.body));   // distinct copies
+    var res = _mkRes();
+    var fin = _newFinish(res);
+    var p = mw(req, res, function () {
+      execCount += 1;
+      res.json({ ok: 2 });
+    });
+    return { done: Promise.all([p, fin]), res: res };
+  }
+
+  // Fire both BEFORE awaiting either, so they interleave at the async
+  // get()/set() yield points.
+  var a = _submit();
+  var c = _submit();
+  await a.done;
+  await c.done;
+
+  await helpers.waitUntil(function () {
+    return a.res._endedStatus !== null && c.res._endedStatus !== null;
+  }, { timeoutMs: 5000, label: "concurrent-ctr: both responses finished" });
+
+  check("concurrent-ctr: both requests read a fresh copy (raced through get)",
+        store._gets() >= 2);
+  check("concurrent-ctr: handler executed EXACTLY once", execCount === 1);
+  var statuses = [a.res._endedStatus, c.res._endedStatus].sort();
+  check("concurrent-ctr: exactly one 200 and one 400",
+        statuses[0] === 200 && statuses[1] === 400);
+  var rejected = a.res._endedStatus === 400 ? a.res : c.res;
+  check("concurrent-ctr: the loser is refused with the replay shape",
+        /encrypted-payload-rejected/.test(rejected._captured));
+}
+
+async function testApiEncryptPerSessionSequentialCounterStillWorks() {
+  // Success path: the atomic gate must NOT break normal monotonic flow.
+  var keypair = _serverKeypair();
+  var store = _clusterStyleSessionStore();
+  var mw = b.middleware.apiEncrypt({
+    keypair:      keypair,
+    audit:        false,
+    keying:       "per-session",
+    sessionStore: store,
+  });
+  var clientCtx = b.middleware.apiEncrypt.client({
+    pubkey: keypair, keying: "per-session",
+  });
+
+  var reached = [];
+  // Three sequential requests, ctr 1 → 2 → 3, each must reach next() and 200.
+  for (var i = 1; i <= 3; i++) {
+    var call = clientCtx.encryptRequest({ n: i });
+    var req = _bodyReq("POST", { "content-type": "application/json" }, "");
+    req.body = call.body;
+    var res = _mkRes();
+    var fin = _newFinish(res);
+    await mw(req, res, (function (n, rq, r) {
+      return function () {
+        reached.push(n);
+        // middleware replaced rq.body in-place with the cleartext payload.
+        check("seq-ctr: req " + n + " body decrypted", rq.body && rq.body.n === n);
+        r.json({ ok: n });
+      };
+    })(i, req, res));
+    await fin;
+    check("seq-ctr: req " + i + " returns 200", res._endedStatus === 200);
+    var resp = JSON.parse(res._captured);
+    var plain = call.decryptResponse(resp);
+    check("seq-ctr: req " + i + " response decrypts", plain.ok === i);
+  }
+  check("seq-ctr: all three sequential requests reached the handler",
+        reached.length === 3 && reached[0] === 1 && reached[1] === 2 && reached[2] === 3);
+}
+
+async function testApiEncryptCtrClaimLifetimeAndSetFailure() {
+  // The (sid, ctr) claim must live until session.expiresAt, not just
+  // replayWindowMs: the post-handler session write is best-effort, so a
+  // failed write leaves lastReqCtr stale in the store, and _ts is
+  // plaintext envelope metadata — a window-scoped claim would let the
+  // same captured body replay after the window and execute twice.
+  var keypair = _serverKeypair();
+  var store = _clusterStyleSessionStore();
+  var failSets = false;
+  var innerSet = store.set;
+  store.set = async function (sid, row, opts) {
+    if (failSets) throw new Error("store write rejected");
+    return innerSet.call(store, sid, row, opts);
+  };
+  // Wrap the memory nonce store to record every claim's expireAt.
+  var innerNonce = b.nonceStore.create({ backend: "memory" });
+  var claims = [];
+  var nonceStore = {
+    checkAndInsert: function (key, expireAt) {
+      claims.push({ key: key, expireAt: expireAt });
+      return innerNonce.checkAndInsert(key, expireAt);
+    },
+    purgeExpired: function () { return innerNonce.purgeExpired(); },
+    close: function () { return innerNonce.close(); },
+  };
+  var mw = b.middleware.apiEncrypt({
+    keypair: keypair, audit: false, keying: "per-session",
+    sessionStore: store, nonceStore: nonceStore,
+    replayWindowMs: 30000,
+  });
+  var clientCtx = b.middleware.apiEncrypt.client({
+    pubkey: keypair, keying: "per-session",
+  });
+
+  // Bootstrap (ctr=1) — session row persists (writes still succeed).
+  var first = clientCtx.encryptRequest({ n: 1 });
+  var req1 = _bodyReq("POST", { "content-type": "application/json" }, "");
+  req1.body = first.body;
+  var res1 = _mkRes();
+  var fin1 = _newFinish(res1);
+  await mw(req1, res1, function () { res1.json({ ok: 1 }); });
+  await fin1;
+  check("ctr-claim: bootstrap 200", res1._endedStatus === 200);
+
+  // Subsequent request (ctr=2) with the post-handler session write
+  // FAILING best-effort — the request still succeeds, but lastReqCtr
+  // stays stale (1) in the store.
+  failSets = true;
+  var second = clientCtx.encryptRequest({ n: 2 });
+  var execCount = 0;
+  var req2 = _bodyReq("POST", { "content-type": "application/json" }, "");
+  req2.body = JSON.parse(JSON.stringify(second.body));
+  var res2 = _mkRes();
+  var fin2 = _newFinish(res2);
+  await mw(req2, res2, function () { execCount += 1; res2.json({ ok: 2 }); });
+  await fin2;
+  check("ctr-claim: request succeeds despite failed session write",
+        res2._endedStatus === 200 && execCount === 1);
+
+  // The recorded ctr claim expires with the SESSION, not the window.
+  var ctrClaims = claims.filter(function (c) { return /^ctr:/.test(c.key); });
+  check("ctr-claim: exactly one ctr claim recorded", ctrClaims.length === 1);
+  var key = ctrClaims[0].key;
+  var sid = key.slice(4, key.lastIndexOf(":"));
+  failSets = false;
+  var row = await store.get(sid);
+  check("ctr-claim: claim lives until session.expiresAt (not the staleness window)",
+        row !== null && ctrClaims[0].expireAt === row.expiresAt &&
+        ctrClaims[0].expireAt > Date.now() + 30000);
+
+  // REPLAY the same captured body — must refuse even though the failed
+  // store write left lastReqCtr stale at 1 (the monotonic check alone
+  // would pass ctr=2 again; the atomic claim is what holds).
+  var req3 = _bodyReq("POST", { "content-type": "application/json" }, "");
+  req3.body = JSON.parse(JSON.stringify(second.body));
+  var res3 = _mkRes();
+  var fin3 = _newFinish(res3);
+  await mw(req3, res3, function () { execCount += 1; res3.json({ ok: 3 }); });
+  await fin3;
+  check("ctr-claim: replay of the captured body is refused",
+        res3._endedStatus === 400 && /encrypted-payload-rejected/.test(res3._captured));
+  check("ctr-claim: handler did not execute twice", execCount === 1);
+}
+
+async function testApiEncryptEnvelopeMetadataAadBound() {
+  // The envelope's plaintext fields are AEAD-bound: a captured request
+  // cannot be replayed with a rewritten _ts (the staleness-defeat
+  // vector), and a captured response cannot be replayed to the client
+  // under a bumped _ctr (the monotonic check reads plaintext).
+  var keypair = _serverKeypair();
+
+  // -- Request side: per-request mode, tampered _ts refused.
+  var mw = b.middleware.apiEncrypt({ keypair: keypair, audit: false });
+  var clientCtx = b.middleware.apiEncrypt.client({ pubkey: keypair });
+  var call = clientCtx.encryptRequest({ n: 1 });
+
+  var good = _bodyReq("POST", { "content-type": "application/json" }, "");
+  good.body = JSON.parse(JSON.stringify(call.body));
+  var goodRes = _mkRes();
+  var goodFin = _newFinish(goodRes);
+  var goodRan = 0;
+  await mw(good, goodRes, function () { goodRan += 1; goodRes.json({ ok: 1 }); });
+  await goodFin;
+  check("aad: untampered request succeeds", goodRes._endedStatus === 200 && goodRan === 1);
+
+  var tampered = _bodyReq("POST", { "content-type": "application/json" }, "");
+  tampered.body = JSON.parse(JSON.stringify(call.body));
+  tampered.body._ts = tampered.body._ts + 1;          // rewrite freshness field
+  tampered.body._nonce = b.crypto.generateBytes(16).toString("hex");  // fresh nonce to clear the replay claim
+  var tampRes = _mkRes();
+  var tampFin = _newFinish(tampRes);
+  var tampRan = 0;
+  await mw(tampered, tampRes, function () { tampRan += 1; tampRes.json({ ok: 1 }); });
+  await tampFin;
+  check("aad: rewritten _ts refused (AEAD tag mismatch)",
+        tampRes._endedStatus === 400 && tampRan === 0 &&
+        /encrypted-payload-rejected/.test(tampRes._captured));
+
+  // -- Response side: per-session mode, bumped response _ctr refused typed.
+  var store = _clusterStyleSessionStore();
+  var mw2 = b.middleware.apiEncrypt({
+    keypair: keypair, audit: false, keying: "per-session", sessionStore: store,
+  });
+  var ctx2 = b.middleware.apiEncrypt.client({ pubkey: keypair, keying: "per-session" });
+  var c1 = ctx2.encryptRequest({ n: 1 });
+  var r1 = _bodyReq("POST", { "content-type": "application/json" }, "");
+  r1.body = c1.body;
+  var rs1 = _mkRes();
+  var rf1 = _newFinish(rs1);
+  await mw2(r1, rs1, function () { rs1.json({ ok: 1 }); });
+  await rf1;
+  var resp1 = JSON.parse(rs1._captured);
+  // Replaying the response under a bumped counter passes the client's
+  // plaintext monotonic check; the AAD binding is what refuses it.
+  var forged = JSON.parse(JSON.stringify(resp1));
+  forged._ctr = forged._ctr + 1;
+  var threw = null;
+  try { c1.decryptResponse(forged); } catch (e) { threw = e; }
+  check("aad: response replay under a bumped _ctr refused typed",
+        threw !== null && threw.code === "CLIENT_RESPONSE_TAMPERED");
+  // The refused forgery must NOT have advanced the monotonic counter —
+  // the genuine response still decrypts after the attack attempt.
+  var plain = c1.decryptResponse(resp1);
+  check("aad: genuine response still decrypts after refused forgery", plain.ok === 1);
+}
+
 async function run() {
   await testNonceStoreSurface();
   await testNonceStoreMemoryBasics();
@@ -1155,6 +1487,9 @@ async function run() {
   await testNonceStoreUnknownBackend();
 
   await testApiEncryptKeypairValidated();
+  await testApiEncryptCreateRejectsBadReplayWindow();
+  await testApiEncryptClientRejectsBadMaxDecryptedBytes();
+  await testApiEncryptHttpClientRejectsBadMaxDecryptedBytes();
   await testApiEncryptRoundTrip();
   await testApiEncryptRejectsMissingShape();
   await testApiEncryptRejectsStaleTimestamp();
@@ -1183,6 +1518,10 @@ async function run() {
   await testApiEncryptPerSessionBootstrapAndReuse();
   await testApiEncryptPerSessionUnknownSid();
   await testApiEncryptPerSessionCounterReplay();
+  await testApiEncryptPerSessionConcurrentCtrExecutesOnce();
+  await testApiEncryptPerSessionSequentialCounterStillWorks();
+  await testApiEncryptCtrClaimLifetimeAndSetFailure();
+  await testApiEncryptEnvelopeMetadataAadBound();
   await testApiEncryptPerSessionExpiry();
   await testApiEncryptPerSessionMaxResponses();
   await testApiEncryptPerSessionResponseCounterMonotonic();

package/lib/vendor/blamejs/test/layer-0-primitives/asyncapi.test.js

@@ -516,6 +516,43 @@ function run() {
 
   check("asyncapiServe.forceRebuild is fn",      typeof serve.forceRebuild === "function");
 
+  // HEAD carries the GET response headers (incl. Content-Length) with an
+  // EMPTY body (RFC 9110 §9.3.2). GET unchanged: it still returns the
+  // body. Asserts the head-suppression against both JSON and YAML mounts.
+  var sentHeadJson = { status: null, headers: null, body: undefined, ended: false };
+  serve({ method: "HEAD", url: "/asyncapi.json", pathname: "/asyncapi.json", headers: {} },
+        { writeHead: function (s, h) { sentHeadJson.status = s; sentHeadJson.headers = h; },
+          end:       function (bdy) { sentHeadJson.body = bdy; sentHeadJson.ended = true; } },
+        function () {});
+  check("asyncapiServe HEAD JSON: 200",          sentHeadJson.status === 200);
+  check("asyncapiServe HEAD JSON: Content-Length set like GET",
+        sentHeadJson.headers["Content-Length"] === sentJson.headers["Content-Length"]);
+  check("asyncapiServe HEAD JSON: Content-Type set like GET",
+        sentHeadJson.headers["Content-Type"] === sentJson.headers["Content-Type"]);
+  check("asyncapiServe HEAD JSON: empty body",
+        sentHeadJson.ended === true && (sentHeadJson.body === undefined || sentHeadJson.body == null));
+
+  var sentHeadYaml = { status: null, headers: null, body: undefined, ended: false };
+  serve({ method: "HEAD", url: "/asyncapi.yaml", pathname: "/asyncapi.yaml", headers: {} },
+        { writeHead: function (s, h) { sentHeadYaml.status = s; sentHeadYaml.headers = h; },
+          end:       function (bdy) { sentHeadYaml.body = bdy; sentHeadYaml.ended = true; } },
+        function () {});
+  check("asyncapiServe HEAD YAML: 200",          sentHeadYaml.status === 200);
+  check("asyncapiServe HEAD YAML: Content-Length set like GET",
+        sentHeadYaml.headers["Content-Length"] === sentYaml.headers["Content-Length"]);
+  check("asyncapiServe HEAD YAML: empty body",
+        sentHeadYaml.ended === true && (sentHeadYaml.body === undefined || sentHeadYaml.body == null));
+
+  // GET still returns the body after the HEAD path was added.
+  var sentGetAfter = { status: null, headers: null, body: null };
+  serve({ method: "GET", url: "/asyncapi.json", pathname: "/asyncapi.json", headers: {} },
+        { writeHead: function (s, h) { sentGetAfter.status = s; sentGetAfter.headers = h; },
+          end:       function (bdy) { sentGetAfter.body = bdy; } },
+        function () {});
+  check("asyncapiServe GET still returns body",
+        sentGetAfter.status === 200 && typeof sentGetAfter.body === "string" &&
+        sentGetAfter.body.length > 0);
+
   // ---- operation messages with $ref form ----
   aapi.operation("publishWithRef", {
     action: "send",

package/lib/vendor/blamejs/test/layer-0-primitives/break-glass.test.js

@@ -64,6 +64,27 @@ function testSurface() {
   check("breakGlass.BreakGlassError is class",     typeof b.breakGlass.BreakGlassError === "function");
 }
 
+// ---- init opts validation ----
+
+function testInitOptsValidation() {
+  // The `now` knob was documented as a Date.now override but nothing
+  // consumed it (every time read is a direct Date.now()). It is removed
+  // from the init allowlist, so passing it is now a config-time error.
+  var threwNow = false;
+  try { b.breakGlass.init({ now: 123 }); } catch (_e) { threwNow = true; }
+  check("init: removed `now` opt throws", threwNow);
+
+  // trustProxy is still honored — default behavior unchanged.
+  var threwTrustProxy = false;
+  try { b.breakGlass.init({ trustProxy: true }); } catch (_e) { threwTrustProxy = true; }
+  check("init: trustProxy still accepted", !threwTrustProxy);
+
+  // bare init() with no opts still works.
+  var threwBare = false;
+  try { b.breakGlass.init(); } catch (_e) { threwBare = true; }
+  check("init: no-opts init still works", !threwBare);
+}
+
 // ---- Policy CRUD ----
 
 async function testPolicyCRUD() {
@@ -825,6 +846,7 @@ async function testListActiveAllAndRevokeAll() {
 
 async function run() {
   testSurface();
+  testInitOptsValidation();
   await testPolicyCRUD();
   await testPolicyValidation();
   await testGrantHappyPath();