@blamejs/blamejs-shop 0.0.44

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

@@ -0,0 +1,168 @@
+"use strict";
+/**
+ * b.tlsExporter — RFC 9266 TLS-Exporter channel binding.
+ *
+ * Live TLS handshake on a loopback socket → exporter materializes →
+ * client and server pull the same exporter bytes (RFC 9266 §4 mandate)
+ * → token-binding verify path.
+ */
+
+var helpers = require("../helpers");
+var b       = helpers.b;
+var check   = helpers.check;
+var nodeTls = require("tls");
+var nodeCrypto = require("crypto");
+
+function testSurface() {
+  check("tlsExporter namespace exposed",
+        b.tlsExporter && typeof b.tlsExporter === "object");
+  check("tlsExporter.fromSocket is a function",
+        typeof b.tlsExporter.fromSocket === "function");
+  check("tlsExporter.bindToken is a function",
+        typeof b.tlsExporter.bindToken === "function");
+  check("tlsExporter.verifyTokenBinding is a function",
+        typeof b.tlsExporter.verifyTokenBinding === "function");
+  check("EXPORTER_LABEL matches RFC 9266 §4",
+        b.tlsExporter.EXPORTER_LABEL === "EXPORTER-Channel-Binding");
+  check("EXPORTER_LENGTH is 32 bytes",
+        b.tlsExporter.EXPORTER_LENGTH === 32);
+  check("tlsExporter.TlsExporterError is fn",
+        typeof b.tlsExporter.TlsExporterError === "function");
+}
+
+function testValidationPaths() {
+  var t1 = null;
+  try { b.tlsExporter.fromSocket(null); } catch (e) { t1 = e; }
+  check("null socket throws", t1 && t1.code === "BAD_INPUT");
+
+  var t2 = null;
+  try { b.tlsExporter.fromSocket({}); } catch (e) { t2 = e; }
+  check("non-TLS socket throws", t2 && t2.code === "NOT_TLS");
+
+  var t3 = null;
+  try {
+    b.tlsExporter.fromSocket({ exportKeyingMaterial: function () {}, getProtocol: function () { return "TLSv1.2"; } });
+  } catch (e) { t3 = e; }
+  check("TLS<1.3 socket throws NOT_TLS_1_3",
+        t3 && t3.code === "NOT_TLS_1_3");
+
+  var t4 = null;
+  try {
+    b.tlsExporter.fromSocket({
+      exportKeyingMaterial: function () { return Buffer.alloc(32); },
+      getProtocol: function () { return "TLSv1.3"; },
+    }, { length: 999999 });
+  } catch (e) { t4 = e; }
+  check("out-of-range length throws", t4 && t4.code === "BAD_LENGTH");
+}
+
+function _selfSignedKeyAndCert() {
+  // Generate an ed25519 self-signed cert for the server. ed25519 is
+  // accepted by node:tls as the server identity for TLS 1.3.
+  var pair = nodeCrypto.generateKeyPairSync("ec", {
+    namedCurve: "P-256",
+    publicKeyEncoding:  { type: "spki",  format: "pem" },
+    privateKeyEncoding: { type: "pkcs8", format: "pem" },
+  });
+  // Build a minimal self-signed X.509 via X509Certificate.. Not in
+  // node stdlib; instead use a precomputed self-signed cert path.
+  // For this test we use a runtime-generated cert via the snake-case
+  // fields supported by node 22+ generateX509.
+  return pair;
+}
+
+function testLiveHandshake() {
+  return new Promise(function (resolve, reject) {
+    // Use the framework's mTLS engine to mint a CA + server leaf cert
+    // bound to "localhost" so node:tls accepts the SNI on connect.
+    (async function () {
+      try {
+        var ca = await b.mtlsEngine.generateCa({ name: "test-ca" });
+        var leaf = await b.mtlsEngine.signClientCert({
+          cn:           "localhost",
+          caCertPem:    ca.caCertPem,
+          caKeyPem:     ca.caKeyPem,
+          usage:        "server",
+          sans:         ["DNS:localhost", "IP:127.0.0.1"],
+          validityDays: 1,
+        });
+
+        // Coordinate the two halves: capture both exporters before
+        // running the assertions. Promise resolves when both sides
+        // have computed their exporter bytes + the assertions ran.
+        var serverExporter = null;
+        var clientExporter = null;
+        var ranAssertions = false;
+        function tryAssert(server, client) {
+          if (ranAssertions || !serverExporter || !clientExporter) return;
+          ranAssertions = true;
+          try {
+            check("client + server compute equal exporter bytes",
+                  Buffer.compare(serverExporter, clientExporter) === 0);
+            check("exporter is 32 bytes",
+                  clientExporter.length === 32);
+
+            var binding = b.tlsExporter.bindToken(client, "session-token-xyz");
+            check("bindToken returns hex string",
+                  typeof binding === "string" && /^[0-9a-f]+$/.test(binding));
+            var ok = b.tlsExporter.verifyTokenBinding(client, "session-token-xyz", binding);
+            check("verifyTokenBinding accepts matching token", ok === true);
+            var bad = b.tlsExporter.verifyTokenBinding(client, "DIFFERENT", binding);
+            check("verifyTokenBinding rejects mismatched token", bad === false);
+          } catch (e) {
+            client.destroy(); server.close(); reject(e); return;
+          }
+          client.end();
+          server.close();
+          resolve();
+        }
+
+        var server = nodeTls.createServer({
+          key:        leaf.key,
+          cert:       leaf.cert,
+          minVersion: "TLSv1.3",
+          maxVersion: "TLSv1.3",
+        }, function (sock) {
+          try { serverExporter = b.tlsExporter.fromSocket(sock); }
+          catch (e) { sock.destroy(e); reject(e); return; }
+          tryAssert(server, client);
+        });
+        var client;
+        server.listen(0, "127.0.0.1", function () {
+          var port = server.address().port;
+          client = nodeTls.connect({
+            host:       "127.0.0.1",
+            port:       port,
+            ca:         ca.caCertPem,
+            servername: "localhost",
+            minVersion: "TLSv1.3",
+            maxVersion: "TLSv1.3",
+          }, function () {
+            try { clientExporter = b.tlsExporter.fromSocket(client); }
+            catch (e) { client.destroy(); server.close(); reject(e); return; }
+            tryAssert(server, client);
+          });
+          client.on("error", function (e) { server.close(); reject(e); });
+        });
+      } catch (e) {
+        // Live-handshake failure should not mask the validation tests
+        // that already ran. Surface the error so an mTLS-engine
+        // regression doesn't silently disable channel-binding coverage.
+        reject(e);
+      }
+    })();
+  });
+}
+
+async function run() {
+  testSurface();
+  testValidationPaths();
+  await testLiveHandshake();
+}
+
+module.exports = { run: run };
+
+if (require.main === module) {
+  run().then(function () { console.log("OK"); })
+       .catch(function (e) { console.error(e.stack || e); process.exit(1); });
+}

package/lib/vendor/blamejs/test/layer-0-primitives/tls-ocsp-ct.test.js

@@ -0,0 +1,275 @@
+"use strict";
+/**
+ * b.network.tls.ocsp + b.network.tls.ct — surface tests.
+ *
+ * The protocol-side OCSP request/response and SCT signature
+ * verification are deferred (need ASN.1 parsing). What ships here is
+ * the operator surface — connect/requireGood wrappers + cert
+ * inspection + requireScts predicate factory. Live-network tests are
+ * gated behind operator-supplied integration runs.
+ */
+
+var helpers = require("../helpers");
+var b       = helpers.b;
+var check   = helpers.check;
+
+function testOcspSurface() {
+  check("network.tls.ocsp.connect is a function",
+        typeof b.network.tls.ocsp.connect === "function");
+  check("network.tls.ocsp.requireStapled is a function",
+        typeof b.network.tls.ocsp.requireStapled === "function");
+  check("network.tls.ocsp.inspectMustStaple is a function",
+        typeof b.network.tls.ocsp.inspectMustStaple === "function");
+  check("network.tls.ocsp.requireMustStaple is a function",
+        typeof b.network.tls.ocsp.requireMustStaple === "function");
+  check("network.tls.ocsp.buildRequest is a function",
+        typeof b.network.tls.ocsp.buildRequest === "function");
+}
+
+// Synthesize a minimal RFC 5280-shaped X.509 cert via the framework
+// ASN.1 writers — enough for buildRequest's _extractIssuerNameDerAnd-
+// KeyBitString and _extractLeafSerial walks. Not cryptographically
+// signed; verifies only that the SHAPE is read correctly.
+function _synthesizeMinimalCert(serialBytes, issuerCnBytes, pubKeyBytes) {
+  var asn1 = require("../../lib/asn1-der");
+  // Name ::= SEQUENCE OF RDN; RDN ::= SET OF AttributeTypeAndValue;
+  // Use a single CN attribute for simplicity.
+  var cnOid = asn1.writeOid("2.5.4.3");
+  var cnValue = asn1.writeNode(0x0c, issuerCnBytes);                            // UTF8String
+  var atv = asn1.writeSequence([cnOid, cnValue]);
+  var rdn = asn1.writeNode(0x31, atv);                                           // SET OF
+  var name = asn1.writeSequence([rdn]);
+  // Validity ::= SEQUENCE { notBefore, notAfter } — use UTCTime.
+  var notBefore = asn1.writeNode(0x17, Buffer.from("260101000000Z"));
+  var notAfter  = asn1.writeNode(0x17, Buffer.from("270101000000Z"));
+  var validity = asn1.writeSequence([notBefore, notAfter]);
+  // SPKI ::= SEQUENCE { algorithm AlgorithmIdentifier, subjectPublicKey BIT STRING }
+  var algId = asn1.writeSequence([asn1.writeOid("1.2.840.113549.1.1.1"), asn1.writeNull()]);
+  // BIT STRING wraps: [unusedBits=0x00, ...keyBytes]
+  var spkiBits = asn1.writeNode(0x03, Buffer.concat([Buffer.from([0]), pubKeyBytes]));
+  var spki = asn1.writeSequence([algId, spkiBits]);
+  // version [0] EXPLICIT INTEGER 2 (= v3)
+  var version = asn1.writeContextExplicit(0, asn1.writeInteger(Buffer.from([2])));
+  // tbsCertificate
+  var tbs = asn1.writeSequence([
+    version,
+    asn1.writeInteger(serialBytes),
+    algId,                                                                       // signature algorithm
+    name,                                                                        // issuer
+    validity,
+    name,                                                                        // subject (= issuer for self-signed)
+    spki,
+  ]);
+  var sigBits = asn1.writeNode(0x03, Buffer.from([0, 0, 0, 0]));                 // BIT STRING placeholder
+  var cert = asn1.writeSequence([tbs, algId, sigBits]);
+  return cert;
+}
+
+function testOcspBuildRequestDefaultIncludesNonce() {
+  // Default is nonce ON — security-defaults-on rule.
+  var cert = _synthesizeMinimalCert(Buffer.from([0x12, 0x34, 0x56, 0x78]),
+    Buffer.from("Test CA"), Buffer.from("public-key-bytes-go-here-aaaaaaaaaa"));
+  var rv = b.network.tls.ocsp.buildRequest({
+    leafCertDer:   cert,
+    issuerCertDer: cert,
+  });
+  check("buildRequest returns Buffer",  Buffer.isBuffer(rv.requestDer));
+  check("buildRequest default includes nonce (16 bytes)",
+        Buffer.isBuffer(rv.nonce) && rv.nonce.length === 16);
+  // Parse it back via the same ASN.1 walker.
+  var asn1 = require("../../lib/asn1-der");
+  var top = asn1.readNode(rv.requestDer);
+  check("buildRequest output is a SEQUENCE", top.tag === asn1.TAG.SEQUENCE);
+}
+
+function testOcspBuildRequestExplicitOptOut() {
+  // Operators talking to nonce-ignoring responders opt out via nonce: false.
+  var cert = _synthesizeMinimalCert(Buffer.from([0xab, 0xcd]),
+    Buffer.from("Test CA 2"), Buffer.from("public-key-bytes-2-aaaaaaaaaaaaaa"));
+  var rv = b.network.tls.ocsp.buildRequest({
+    leafCertDer:   cert,
+    issuerCertDer: cert,
+    nonce:         false,
+  });
+  check("buildRequest({ nonce: false }) returns null nonce", rv.nonce === null);
+}
+
+function testOcspBuildRequestNonceLenOutOfRange() {
+  var cert = _synthesizeMinimalCert(Buffer.from([0x01]),
+    Buffer.from("X"), Buffer.from("YYYYYYYYYYYYYYYYYYYYYYYYYYYYYY"));
+  var threw = null;
+  try {
+    b.network.tls.ocsp.buildRequest({
+      leafCertDer: cert, issuerCertDer: cert,
+      nonce: true, nonceLen: 64,
+    });
+  } catch (e) { threw = e; }
+  check("buildRequest refuses RFC 8954 out-of-range nonceLen",
+        threw && /ocsp-bad-nonce-len/.test(threw.code || ""));
+}
+
+function testOcspBuildRequestRejectsBadInput() {
+  var threw = null;
+  try { b.network.tls.ocsp.buildRequest({ leafCertDer: "not-a-buffer", issuerCertDer: Buffer.from("x") }); }
+  catch (e) { threw = e; }
+  check("buildRequest refuses non-Buffer leafCertDer",
+        threw && /ocsp-bad-input/.test(threw.code || ""));
+}
+
+function testMustStapleInspectMalformed() {
+  var fake = Buffer.from("not a real cert");
+  var rv = b.network.tls.ocsp.inspectMustStaple(fake);
+  check("inspectMustStaple on malformed buffer → mustStaple=false",
+        rv.mustStaple === false);
+  check("inspectMustStaple returns features array",
+        Array.isArray(rv.features));
+}
+
+function testMustStapleInspectRejectsNonBuffer() {
+  var threw = null;
+  try { b.network.tls.ocsp.inspectMustStaple("nope"); }
+  catch (e) { threw = e; }
+  check("inspectMustStaple rejects non-Buffer",
+        threw && /ocsp-bad-input/.test(threw.code || ""));
+}
+
+function testRequireMustStaplePredicateNoCert() {
+  var pred = b.network.tls.ocsp.requireMustStaple();
+  var err = pred(null, {});
+  check("requireMustStaple(null) → ocsp-no-cert",
+        err && /ocsp-no-cert/.test(err.code || ""));
+}
+
+function testRequireMustStaplePredicateNoExtensionPasses() {
+  // Cert without must-staple extension + no staple → predicate returns
+  // null (operator did not opt into enforceUnconditional).
+  var pred = b.network.tls.ocsp.requireMustStaple();
+  var err = pred({ raw: Buffer.from("not a real cert") }, {});
+  check("requireMustStaple on cert without must-staple → null (default)",
+        err === null);
+}
+
+function testRequireMustStapleEnforceUnconditional() {
+  var pred = b.network.tls.ocsp.requireMustStaple({ enforceUnconditional: true });
+  var err = pred({ raw: Buffer.from("not a real cert") }, {});
+  check("requireMustStaple({ enforceUnconditional }) refuses no-staple",
+        err && /ocsp-staple-required/.test(err.code || ""));
+}
+
+function testCtSurface() {
+  check("network.tls.ct.inspect is a function",
+        typeof b.network.tls.ct.inspect === "function");
+  check("network.tls.ct.parseScts is a function",
+        typeof b.network.tls.ct.parseScts === "function");
+  check("network.tls.ct.verifyScts is a function",
+        typeof b.network.tls.ct.verifyScts === "function");
+  check("network.tls.ct.requireScts is a function",
+        typeof b.network.tls.ct.requireScts === "function");
+}
+
+function testCtParseSctsNoExtension() {
+  // Buffer with no SCT OID — parseScts returns [].
+  var fake = Buffer.from("not a real cert");
+  var rv = b.network.tls.ct.parseScts(fake);
+  check("parseScts on cert without SCT extension → []",
+        Array.isArray(rv) && rv.length === 0);
+}
+
+function testCtVerifyNoSctExtension() {
+  var fake = Buffer.from("not a real cert");
+  var rv = b.network.tls.ct.verifyScts(fake, { logKeys: {}, minScts: 2 });
+  check("verifyScts: no SCT extension → ok=false, reason=no-sct-extension",
+        rv.ok === false && rv.reason === "no-sct-extension");
+}
+
+function testCtVerifyParseError() {
+  // Mock a "cert" that has the SCT OID byte sequence but malformed ASN.1
+  // around it — parseScts will fail to walk it.
+  var fake = Buffer.alloc(100);                                                  // not a real cert
+  var rv = b.network.tls.ct.verifyScts(fake, { logKeys: {} });
+  check("verifyScts: malformed cert → ok=false (no-sct-extension or parse-error)",
+        rv.ok === false && (rv.reason === "no-sct-extension" || rv.reason === "parse-error"));
+}
+
+function testCtInspectRejectsNonBuffer() {
+  var threw = null;
+  try { b.network.tls.ct.inspect("not a buffer"); }
+  catch (e) { threw = e; }
+  check("ct.inspect rejects non-Buffer",
+        threw && /ct-bad-input/.test(threw.code || ""));
+}
+
+function testCtInspectFakeCertNoExtension() {
+  // A buffer that doesn't contain the SCT OID bytes.
+  var fake = Buffer.from("not a real cert", "utf8");
+  var rv = b.network.tls.ct.inspect(fake);
+  check("ct.inspect on non-SCT cert → hasSctExtension = false",
+        rv.hasSctExtension === false);
+}
+
+function testCtInspectFakeCertWithOid() {
+  // Embed the SCT OID bytes inside an arbitrary buffer.
+  var oid = Buffer.from([
+    0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0xd6, 0x79, 0x02, 0x04, 0x02,
+  ]);
+  var fake = Buffer.concat([Buffer.alloc(50), oid, Buffer.alloc(50)]);
+  var rv = b.network.tls.ct.inspect(fake);
+  check("ct.inspect on cert with SCT OID → hasSctExtension = true",
+        rv.hasSctExtension === true);
+}
+
+function testRequireSctsPredicate() {
+  var pred = b.network.tls.ct.requireScts({ minScts: 2 });
+  check("requireScts returns a function",
+        typeof pred === "function");
+  // Missing cert → error.
+  var err1 = pred(null);
+  check("requireScts(null) → ct-no-cert error",
+        err1 && /ct-no-cert/.test(err1.code || ""));
+  // Cert with no SCT OID → ct-no-sct-extension error (real verifier
+  // walks ASN.1 and finds no extension, not just OID byte presence).
+  var noScts = { raw: Buffer.from("nope") };
+  var err2 = pred(noScts);
+  check("requireScts(non-SCT cert) → ct-no-sct-extension error",
+        err2 && /ct-no-sct-extension/.test(err2.code || ""));
+  // Cert with embedded OID bytes but no valid ASN.1 structure → still
+  // refused (real verifier can't extract a parseable SCT list). Old
+  // OID-presence heuristic would have passed this; the upgraded
+  // verifier correctly distinguishes "looks like the OID is in there"
+  // from "actually has a verified SCT list".
+  var oid = Buffer.from([
+    0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0xd6, 0x79, 0x02, 0x04, 0x02,
+  ]);
+  var withFakeOid = { raw: Buffer.concat([Buffer.alloc(20), oid]) };
+  var err3 = pred(withFakeOid);
+  check("requireScts(malformed cert with OID bytes) → still refused",
+        err3 !== null);
+}
+
+async function run() {
+  testOcspSurface();
+  testCtSurface();
+  testCtInspectRejectsNonBuffer();
+  testCtInspectFakeCertNoExtension();
+  testCtInspectFakeCertWithOid();
+  testCtParseSctsNoExtension();
+  testCtVerifyNoSctExtension();
+  testCtVerifyParseError();
+  testRequireSctsPredicate();
+  testMustStapleInspectMalformed();
+  testMustStapleInspectRejectsNonBuffer();
+  testRequireMustStaplePredicateNoCert();
+  testRequireMustStaplePredicateNoExtensionPasses();
+  testRequireMustStapleEnforceUnconditional();
+  testOcspBuildRequestDefaultIncludesNonce();
+  testOcspBuildRequestExplicitOptOut();
+  testOcspBuildRequestNonceLenOutOfRange();
+  testOcspBuildRequestRejectsBadInput();
+}
+
+module.exports = { run: run };
+
+if (require.main === module) {
+  run().then(function () { console.log("OK"); })
+       .catch(function (e) { console.error(e.stack || e); process.exit(1); });
+}

package/lib/vendor/blamejs/test/layer-0-primitives/tls-ocsp-verify.test.js

@@ -0,0 +1,105 @@
+"use strict";
+/**
+ * b.network.tls.ocsp.parseResponse + .evaluate + .requireGood — RFC 6960
+ * OCSP response parser + signature verifier. Live-server round-trip
+ * tests live in test/integration/; this layer-0 suite exercises the
+ * parser's malformed-input rejection + the surface contract.
+ */
+
+var helpers = require("../helpers");
+var b       = helpers.b;
+var check   = helpers.check;
+
+function testSurface() {
+  check("ocsp.parseResponse is a function",
+        typeof b.network.tls.ocsp.parseResponse === "function");
+  check("ocsp.evaluate is a function",
+        typeof b.network.tls.ocsp.evaluate === "function");
+  check("ocsp.requireGood is a function",
+        typeof b.network.tls.ocsp.requireGood === "function");
+  check("ocsp.requireStapled (presence-only) is a function",
+        typeof b.network.tls.ocsp.requireStapled === "function");
+}
+
+function testParseRejectsBadInput() {
+  var threw = null;
+  try { b.network.tls.ocsp.parseResponse("not a buffer"); }
+  catch (e) { threw = e; }
+  check("parseResponse(non-buffer) throws ocsp-bad-input",
+        threw && /ocsp-bad-input/.test(threw.code || ""));
+}
+
+function testParseRejectsNonSequence() {
+  // 0x02 = INTEGER, not a SEQUENCE.
+  var threw = null;
+  try { b.network.tls.ocsp.parseResponse(Buffer.from([0x02, 0x01, 0x05])); }
+  catch (e) { threw = e; }
+  check("parseResponse(non-SEQUENCE) throws ocsp-bad-shape",
+        threw && /ocsp-bad-shape|ocsp-bad-input|asn1\/wrong/.test(threw.code || threw.message || ""));
+}
+
+function testParseTryLater() {
+  // OCSPResponse { responseStatus 3 } — "tryLater". No responseBytes.
+  // Hand-crafted DER: 0x30 0x03 0x0a 0x01 0x03
+  //                   SEQ  len  ENUM len status=3
+  var rv = b.network.tls.ocsp.parseResponse(Buffer.from([0x30, 0x03, 0x0a, 0x01, 0x03]));
+  check("parseResponse: tryLater (status 3)",
+        rv.status === "tryLater" && rv.basic === undefined);
+}
+
+function testParseUnauthorized() {
+  // Status 6 = unauthorized.
+  var rv = b.network.tls.ocsp.parseResponse(Buffer.from([0x30, 0x03, 0x0a, 0x01, 0x06]));
+  check("parseResponse: unauthorized (status 6)",
+        rv.status === "unauthorized");
+}
+
+function testEvaluateRequiresIssuerPem() {
+  var threw = null;
+  try { b.network.tls.ocsp.evaluate(Buffer.from([0x30, 0x03, 0x0a, 0x01, 0x03])); }
+  catch (e) { threw = e; }
+  check("evaluate without issuerPem throws ocsp-missing-issuer",
+        threw && /ocsp-missing-issuer/.test(threw.code || ""));
+}
+
+function testEvaluateNonSuccessful() {
+  // Status=tryLater — evaluate returns ok:false with the status surfaced.
+  var rv = b.network.tls.ocsp.evaluate(Buffer.from([0x30, 0x03, 0x0a, 0x01, 0x03]),
+                                       { issuerPem: "-----BEGIN PUBLIC KEY-----\n-----END PUBLIC KEY-----\n" });
+  check("evaluate: non-successful response surfaces status without verify",
+        rv.ok === false && rv.status === "tryLater");
+}
+
+function testEvaluateMalformed() {
+  var rv = b.network.tls.ocsp.evaluate(Buffer.from([0x99, 0x99]),
+                                       { issuerPem: "-----BEGIN PUBLIC KEY-----\n-----END PUBLIC KEY-----\n" });
+  check("evaluate: malformed bytes → ok:false, status:'parse-error'",
+        rv.ok === false && rv.status === "parse-error");
+}
+
+async function testRequireGoodRequiresIssuerPem() {
+  var threw = null;
+  try { await b.network.tls.ocsp.requireGood({ host: "127.0.0.1", port: 1 }); }
+  catch (e) { threw = e; }
+  check("requireGood without issuerPem throws ocsp-missing-issuer",
+        threw && /ocsp-missing-issuer/.test(threw.code || ""));
+}
+
+async function run() {
+  testSurface();
+  testParseRejectsBadInput();
+  testParseRejectsNonSequence();
+  testParseTryLater();
+  testParseUnauthorized();
+  testEvaluateRequiresIssuerPem();
+  testEvaluateNonSuccessful();
+  testEvaluateMalformed();
+  await testRequireGoodRequiresIssuerPem();
+}
+
+module.exports = { run: run };
+
+if (require.main === module) {
+  run().then(function () { console.log("OK"); })
+       .catch(function (e) { console.error(e.stack || e); process.exit(1); });
+}

package/lib/vendor/blamejs/test/layer-0-primitives/tls-pinset-drift.test.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * b.network.tls.pinsetDriftMonitor — periodic check that emits
+ * audit + observability events when the trust-store fingerprint
+ * set drifts from the captured baseline.
+ */
+
+var helpers = require("../helpers");
+var b      = helpers.b;
+var check  = helpers.check;
+
+async function run() {
+  var threw;
+  try { b.network.tls.pinsetDriftMonitor({}); } catch (e) { threw = e; }
+  check("network.tls.pinsetDriftMonitor: missing intervalMs throws",
+    threw && threw.code === "tls/bad-interval");
+
+  b.network.tls.captureBaselineFingerprints();
+  var monitor = b.network.tls.pinsetDriftMonitor({
+    intervalMs: 60_000,
+    audit: false,
+  });
+  check("network.tls.pinsetDriftMonitor: returns stop handle",
+    monitor && typeof monitor.stop === "function");
+  monitor.stop();
+}
+
+module.exports = { run: run };
+
+if (require.main === module) {
+  run().then(
+    function () { console.log("[tls-pinset-drift] OK"); },
+    function (e) { console.error(e); process.exit(1); }
+  );
+}

package/lib/vendor/blamejs/test/layer-0-primitives/tls-preferred-groups.test.js

@@ -0,0 +1,81 @@
+"use strict";
+/**
+ * b.network.tls.preferredGroups + b.network.tls.pqc.* — RFC 9794
+ * named-group ordering surface tests.
+ *
+ * Validates that the framework default puts X25519MLKEM768 first
+ * (RFC 9794 default), SecP256r1MLKEM768 second (RFC 9794 optional),
+ * SecP384r1MLKEM1024 third, and X25519 fourth (classical fallback).
+ * Operator opt-out via setKeyShares / preferredGroups.set replaces
+ * the list.
+ */
+
+var helpers = require("../helpers");
+var b       = helpers.b;
+var check   = helpers.check;
+
+function testPreferredGroupsSurface() {
+  check("network.tls.preferredGroups.set is a function",
+        typeof b.network.tls.preferredGroups.set === "function");
+  check("network.tls.preferredGroups.get is a function",
+        typeof b.network.tls.preferredGroups.get === "function");
+  check("network.tls.preferredGroups.reset is a function",
+        typeof b.network.tls.preferredGroups.reset === "function");
+}
+
+function testRfc9794DefaultOrdering() {
+  b.network.tls.preferredGroups.reset();
+  var groups = b.network.tls.preferredGroups.get();
+  check("default is array with at least 4 groups",
+        Array.isArray(groups) && groups.length >= 4);
+  check("default group[0] is X25519MLKEM768 (RFC 9794 default)",
+        groups[0] === "X25519MLKEM768");
+  check("default group[1] is SecP256r1MLKEM768 (RFC 9794 optional)",
+        groups[1] === "SecP256r1MLKEM768");
+  check("default contains SecP384r1MLKEM1024",
+        groups.indexOf("SecP384r1MLKEM1024") !== -1);
+  check("default contains X25519 fallback",
+        groups.indexOf("X25519") !== -1);
+}
+
+function testOperatorOptOut() {
+  var prior = b.network.tls.preferredGroups.get();
+  try {
+    b.network.tls.preferredGroups.set(["X25519"]);
+    check("operator opt-out leaves only X25519",
+          b.network.tls.preferredGroups.get().join(",") === "X25519");
+  } finally {
+    b.network.tls.preferredGroups.reset();
+  }
+  check("reset restores default ordering with X25519MLKEM768 first",
+        b.network.tls.preferredGroups.get()[0] === "X25519MLKEM768");
+  check("reset restored default length",
+        b.network.tls.preferredGroups.get().length === prior.length);
+}
+
+function testPqcAliasMatchesPreferredGroups() {
+  b.network.tls.preferredGroups.reset();
+  var viaPqc = b.network.tls.pqc.getKeyShares();
+  var viaPref = b.network.tls.preferredGroups.get();
+  check("pqc.getKeyShares matches preferredGroups.get",
+        viaPqc.join(",") === viaPref.join(","));
+}
+
+function testApplyToContextEmitsGroups() {
+  b.network.tls.preferredGroups.reset();
+  var ctx = b.network.tls.applyToContext({ base: {} });
+  check("applyToContext emits groups string",
+        typeof ctx.groups === "string" && ctx.groups.indexOf("X25519MLKEM768") === 0);
+  check("applyToContext groups string contains SecP256r1MLKEM768",
+        ctx.groups.indexOf("SecP256r1MLKEM768") !== -1);
+}
+
+async function run() {
+  testPreferredGroupsSurface();
+  testRfc9794DefaultOrdering();
+  testOperatorOptOut();
+  testPqcAliasMatchesPreferredGroups();
+  testApplyToContextEmitsGroups();
+}
+
+module.exports = { run: run };