@blamejs/blamejs-shop 0.5.12 → 0.5.13

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

@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) blamejs contributors
+"use strict";
+/**
+ * vault.getCurrentPassphrase — returns the Buffer the vault was unsealed
+ * with on this boot (wrapped mode), or null in plaintext mode.
+ *
+ * Uses the shared vault-only fixture (wrapped, Argon2id-derived AEAD wrap
+ * with the test passphrase from BLAMEJS_VAULT_PASSPHRASE) and a direct
+ * plaintext init for the null path.
+ *
+ * Run standalone: `node test/layer-0-primitives/vault.test.js`
+ * Or via smoke:   `node test/smoke.js`
+ */
+
+var helpers = require("../helpers");
+var b                 = helpers.b;
+var fs                = helpers.fs;
+var os                = helpers.os;
+var path              = helpers.path;
+var check             = helpers.check;
+var setupVaultOnly    = helpers.setupVaultOnly;
+var teardownVaultOnly = helpers.teardownVaultOnly;
+var TEST_PASSPHRASE   = helpers.TEST_PASSPHRASE;
+
+async function testGetCurrentPassphraseWrapped() {
+  var tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "blamejs-vault-wrapped-"));
+  await setupVaultOnly(tmpDir);
+  try {
+    check("vault mode is wrapped after fixture init", b.vault.getMode() === "wrapped");
+    var pass = b.vault.getCurrentPassphrase();
+    check("vault.getCurrentPassphrase returns a Buffer in wrapped mode",
+          Buffer.isBuffer(pass));
+    check("vault.getCurrentPassphrase Buffer decodes to the unseal passphrase",
+          pass.toString("utf8") === TEST_PASSPHRASE);
+  } finally {
+    teardownVaultOnly(tmpDir);
+  }
+}
+
+async function testGetCurrentPassphrasePlaintext() {
+  var tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "blamejs-vault-plaintext-"));
+  process.env.BLAMEJS_SKIP_NTP_CHECK = "1";
+  b.vault._resetForTest();
+  try {
+    await b.vault.init({ dataDir: tmpDir, mode: "plaintext" });
+    check("vault mode is plaintext after plaintext init", b.vault.getMode() === "plaintext");
+    check("vault.getCurrentPassphrase is null in plaintext mode",
+          b.vault.getCurrentPassphrase() === null);
+  } finally {
+    b.vault._resetForTest();
+    try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch (_e) { /* best-effort */ }
+  }
+}
+
+function testGetCurrentPassphraseBeforeInit() {
+  b.vault._resetForTest();
+  check("vault.getCurrentPassphrase is null before init", b.vault.getCurrentPassphrase() === null);
+}
+
+async function run() {
+  testGetCurrentPassphraseBeforeInit();
+  await testGetCurrentPassphraseWrapped();
+  await testGetCurrentPassphrasePlaintext();
+}
+
+module.exports = { run: run };
+
+if (require.main === module) {
+  run().then(
+    function () { console.log("[vault] OK — " + helpers.getChecks() + " checks passed"); },
+    function (e) { console.error("FAIL:", e); process.exit(1); }
+  );
+}

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

@@ -106,6 +106,18 @@ async function testRefusals() {
   try { await b.vc.verify(noneTok, { algorithms: ["ES256"], publicKey: EC.publicKey }); } catch (e) { e3 = e; }
   check("verify: JOSE alg 'none' refused", e3 && e3.code === "vc/bad-alg");
 
+  // issue()/present() must not let an inherited Object.prototype member as
+  // `alg` slip the JOSE alg lookup on the sign side. `constructor` (etc.) is
+  // a truthy prototype-chain hit that a `!JOSE_ALGS[opts.alg]` guard would
+  // accept, then emit a JWS carrying that bogus `alg` header (fail-open).
+  var inhAlgs = ["constructor", "__proto__", "toString", "valueOf"];
+  for (var ia = 0; ia < inhAlgs.length; ia++) {
+    var eInh = null;
+    try { await b.vc.issue(_cred(), { securing: "jose", alg: inhAlgs[ia], privateKey: ED.privateKey }); } catch (e) { eInh = e; }
+    check("issue: inherited-member JOSE alg '" + inhAlgs[ia] + "' refused (not fail-open)",
+      eInh && eInh.code === "vc/bad-alg");
+  }
+
   // expectedIssuer mismatch
   var e4 = null;
   try { await b.vc.verify(jws, { algorithms: ["ES256"], publicKey: EC.publicKey, expectedIssuer: "did:other" }); } catch (e) { e4 = e; }
@@ -256,14 +268,217 @@ async function testAlgKeyBinding() {
   check("jose verify: matched ES256 + P-256 still verifies", okOut.securing === "jose");
 }
 
+async function testCoseTypBinding() {
+  // A COSE-secured VC MUST carry the vc+cose typ header (RFC 9596 label 16).
+  // The JOSE path already MANDATES the typ header (a JWS with the wrong /
+  // absent typ is refused); the COSE path must match. A COSE_Sign1 that
+  // OMITS the typ is not bound to the application/vc+cose media type — it
+  // must be refused, not accepted under a weaker (unbound) contract. This is
+  // the asymmetric-comparison / cross-media-type-confusion class: one
+  // securing enforced the binding, the sibling only enforced it when the
+  // field happened to be present.
+  var noTyp = await b.cose.sign(Buffer.from(JSON.stringify(_cred()), "utf8"), {
+    alg: "ES256", privateKey: EC.privateKey, contentType: "application/vc",
+    // deliberately no protectedHeaders[16] (typ) — the omission under test
+  });
+  var e1 = null;
+  try { await b.vc.verify(noTyp, { algorithms: ["ES256"], publicKey: EC.publicKey }); } catch (e) { e1 = e; }
+  check("cose verify: a COSE_Sign1 missing the vc+cose typ is refused", e1 && e1.code === "vc/bad-typ");
+
+  // A COSE_Sign1 carrying the WRONG typ (a vp+cose typ on a VC payload) is
+  // likewise refused as a VC.
+  var wrongTyp = await b.cose.sign(Buffer.from(JSON.stringify(_cred()), "utf8"), {
+    alg: "ES256", privateKey: EC.privateKey, contentType: "application/vc",
+    protectedHeaders: (function () { var h = {}; h[16] = "application/vp+cose"; return h; }()),
+  });
+  var e2 = null;
+  try { await b.vc.verify(wrongTyp, { algorithms: ["ES256"], publicKey: EC.publicKey }); } catch (e) { e2 = e; }
+  check("cose verify: a COSE_Sign1 with the wrong typ is refused", e2 && e2.code === "vc/bad-typ");
+
+  // The sibling VP consumer shares the same COSE seam: a holder-signed VP
+  // COSE_Sign1 that omits the vp+cose typ is refused by verifyPresentation.
+  var HOLDER = nodeCrypto.generateKeyPairSync("ed25519");
+  var vpPayload = { "@context": ["https://www.w3.org/ns/credentials/v2"], type: ["VerifiablePresentation"], holder: "did:example:holder" };
+  var noTypVp = await b.cose.sign(Buffer.from(JSON.stringify(vpPayload), "utf8"), {
+    alg: "EdDSA", privateKey: HOLDER.privateKey, contentType: "application/vp",
+  });
+  var e3 = null;
+  try { await b.vc.verifyPresentation(noTypVp, { algorithms: ["EdDSA"], publicKey: HOLDER.publicKey }); } catch (e) { e3 = e; }
+  check("cose verifyPresentation: a COSE_Sign1 missing the vp+cose typ is refused", e3 && e3.code === "vc/bad-typ");
+
+  // A correctly-typed COSE VC still verifies — the mandatory-typ check does
+  // not over-reject the framework's own tokens.
+  var good = await b.vc.issue(_cred(), { securing: "cose", alg: "ES256", privateKey: EC.privateKey });
+  var okOut = await b.vc.verify(good, { algorithms: ["ES256"], publicKey: EC.publicKey });
+  check("cose verify: a correctly-typed COSE VC still verifies", okOut.securing === "cose" && okOut.issuer === "did:example:issuer123");
+}
+
+async function testStrictXsdValidity() {
+  // VCDM 2.0 §4.9: validFrom / validUntil MUST be XSD dateTimes. Date.parse
+  // is lenient — a bare year, a slash-date, a date with no time all parse to
+  // *some* instant — so a non-conformant value must be refused by an
+  // explicit XSD-dateTime shape check. Otherwise a value a strict verifier
+  // would refuse is silently accepted and given a heuristic validity window
+  // (the documented "fails closed" contract broken), skewing the expiry
+  // decision the verifier relies on.
+  var nonXsd = ["2020", "2020/01/01", "2020-01-01", "01/01/2020", "March 5, 2020", "2020-13-01T00:00:00Z"];
+  for (var i = 0; i < nonXsd.length; i++) {
+    var err = null;
+    try { await b.vc.issue(_cred({ validFrom: nonXsd[i] }), { securing: "jose", alg: "ES256", privateKey: EC.privateKey }); } catch (e) { err = e; }
+    check("issue refuses non-XSD validFrom '" + nonXsd[i] + "'", err && err.code === "vc/bad-validity");
+  }
+
+  // Shape-valid but IMPOSSIBLE calendar dates: Date.parse NORMALIZES a day
+  // overflow into a different valid instant (2024-02-31 -> 2024-03-02, a
+  // non-leap 2023-02-29 -> 2023-03-01, 2024-04-31 -> 2024-05-01) rather than
+  // rejecting it, silently shifting the validity window. The calendar fields
+  // are range-checked before Date.parse, so these fail closed.
+  var impossible = ["2024-02-31T00:00:00Z", "2024-04-31T00:00:00Z",
+                    "2023-02-29T00:00:00Z", "2024-00-15T00:00:00Z", "2024-06-00T00:00:00Z"];
+  for (var k = 0; k < impossible.length; k++) {
+    var ie = null;
+    try { await b.vc.issue(_cred({ validFrom: impossible[k] }), { securing: "jose", alg: "ES256", privateKey: EC.privateKey }); } catch (e) { ie = e; }
+    check("issue refuses impossible calendar validFrom '" + impossible[k] + "'", ie && ie.code === "vc/bad-validity");
+  }
+  // A REAL leap day (2096-02-29) and 31-day months still round-trip: the
+  // calendar check must not over-reject a valid date.
+  var leapOk = null;
+  try { await b.vc.issue(_cred({ validFrom: "2096-02-29T00:00:00Z" }), { securing: "jose", alg: "ES256", privateKey: EC.privateKey }); leapOk = true; }
+  catch (e) { leapOk = e; }
+  check("issue accepts a valid leap-day 2096-02-29 (no over-rejection)", leapOk === true);
+
+  // Fail closed at VERIFY too (not only issue): a validly-signed credential
+  // whose validFrom is non-XSD is refused, not accepted under a Date.parse
+  // window.
+  var tok = _rawJose({ alg: "ES256", typ: "vc+jwt" }, _cred({ validFrom: "2020" }));
+  var ev = null;
+  try { await b.vc.verify(tok, { algorithms: ["ES256"], publicKey: EC.publicKey }); } catch (e) { ev = e; }
+  check("verify refuses non-XSD validFrom (fail closed, not a Date.parse window)", ev && ev.code === "vc/bad-validity");
+
+  // Strict XSD dateTimes — with fractional seconds + a numeric offset, and
+  // with 'Z' — still round-trip (no over-rejection).
+  var t1 = await b.vc.issue(_cred({ validUntil: "2099-06-15T12:30:00.500+02:00" }), { securing: "jose", alg: "ES256", privateKey: EC.privateKey });
+  var o1 = await b.vc.verify(t1, { algorithms: ["ES256"], publicKey: EC.publicKey });
+  check("issue+verify accept strict XSD dateTime with fraction + offset", o1.issuer === "did:example:issuer123");
+
+  // A strict XSD validUntil in the past is still enforced as expired — the
+  // shape check leaves the temporal window intact.
+  var t2 = _rawJose({ alg: "ES256", typ: "vc+jwt" }, _cred({ validUntil: "2000-01-01T00:00:00Z" }));
+  var ee = null;
+  try { await b.vc.verify(t2, { algorithms: ["ES256"], publicKey: EC.publicKey }); } catch (e) { ee = e; }
+  check("verify still enforces expiry on a strict XSD validUntil", ee && ee.code === "vc/expired");
+}
+
+async function testDefensiveRefusals() {
+  var jws = await b.vc.issue(_cred(), { securing: "jose", alg: "ES256", privateKey: EC.privateKey });
+
+  // verify: the algorithm allowlist is mandatory and non-empty.
+  var e1 = null;
+  try { await b.vc.verify(jws, { algorithms: [], publicKey: EC.publicKey }); } catch (e) { e1 = e; }
+  check("verify: empty algorithms refused", e1 && e1.code === "vc/algorithms-required");
+
+  // verify: a verification key (publicKey or keyResolver) is mandatory.
+  var e2 = null;
+  try { await b.vc.verify(jws, { algorithms: ["ES256"] }); } catch (e) { e2 = e; }
+  check("verify: missing key refused", e2 && e2.code === "vc/no-key");
+
+  // verify: input must be a compact-JWS string or COSE_Sign1 bytes.
+  var e3 = null;
+  try { await b.vc.verify(42, { algorithms: ["ES256"], publicKey: EC.publicKey }); } catch (e) { e3 = e; }
+  check("verify: non-string/non-bytes input refused", e3 && e3.code === "vc/bad-input");
+
+  // verify: a JWS with the wrong segment count is malformed.
+  var e4 = null;
+  try { await b.vc.verify("only.two", { algorithms: ["ES256"], publicKey: EC.publicKey }); } catch (e) { e4 = e; }
+  check("verify: two-segment token refused as malformed", e4 && e4.code === "vc/malformed");
+
+  // verify: a JWS header that is not base64url-JSON is malformed.
+  var badHdr = Buffer.from("not-json", "utf8").toString("base64url") + ".x.y";
+  var e5 = null;
+  try { await b.vc.verify(badHdr, { algorithms: ["ES256"], publicKey: EC.publicKey }); } catch (e) { e5 = e; }
+  check("verify: non-JSON JWS header refused as malformed", e5 && e5.code === "vc/malformed");
+
+  // verify: a COSE_Sign1 with a correct typ but a non-JSON payload is
+  // malformed (the credential payload must be JSON).
+  var coseBadPayload = await b.cose.sign(Buffer.from("{ not json", "utf8"), {
+    alg: "ES256", privateKey: EC.privateKey, contentType: "application/vc",
+    protectedHeaders: (function () { var h = {}; h[16] = "application/vc+cose"; return h; }()),
+  });
+  var e6 = null;
+  try { await b.vc.verify(coseBadPayload, { algorithms: ["ES256"], publicKey: EC.publicKey }); } catch (e) { e6 = e; }
+  check("verify: COSE non-JSON payload refused as malformed", e6 && e6.code === "vc/malformed");
+
+  // verify: a COSE credential with no COSE-capable algorithm in the
+  // allowlist is refused (a non-COSE allowlist cannot verify COSE).
+  var coseVc = await b.vc.issue(_cred(), { securing: "cose", alg: "ES256", privateKey: EC.privateKey });
+  var e7 = null;
+  try { await b.vc.verify(coseVc, { algorithms: ["RS256"], publicKey: EC.publicKey }); } catch (e) { e7 = e; }
+  check("verify: COSE with no COSE alg in allowlist refused", e7 && e7.code === "vc/no-cose-alg");
+
+  // issue: config-time refusals.
+  var e8 = null;
+  try { await b.vc.issue(_cred(), { securing: "jose", alg: "ES256" }); } catch (e) { e8 = e; }
+  check("issue: missing privateKey refused", e8 && e8.code === "vc/no-key");
+  var e9 = null;
+  try { await b.vc.issue(_cred(), { securing: "xml", alg: "ES256", privateKey: EC.privateKey }); } catch (e) { e9 = e; }
+  check("issue: unknown securing refused", e9 && e9.code === "vc/bad-securing");
+  var e10 = null;
+  try { await b.vc.issue(_cred(), { securing: "jose", alg: "RS256", privateKey: EC.privateKey }); } catch (e) { e10 = e; }
+  check("issue: unknown JOSE alg refused", e10 && e10.code === "vc/bad-alg");
+
+  // present: config-time refusals + the enveloped-VC input contract.
+  var HOLDER = nodeCrypto.generateKeyPairSync("ed25519");
+  var e11 = null;
+  try { await b.vc.present({ credentials: [jws], holder: "", securing: "jose", alg: "EdDSA", privateKey: HOLDER.privateKey }); } catch (e) { e11 = e; }
+  check("present: empty holder refused", e11 && e11.code === "vc/no-holder");
+  var e12 = null;
+  try { await b.vc.present({ credentials: [jws], holder: "did:h", securing: "jose", alg: "EdDSA" }); } catch (e) { e12 = e; }
+  check("present: missing privateKey refused", e12 && e12.code === "vc/no-key");
+  var e13 = null;
+  try { await b.vc.present({ credentials: [42], holder: "did:h", securing: "jose", alg: "EdDSA", privateKey: HOLDER.privateKey }); } catch (e) { e13 = e; }
+  check("present: a non-string/non-bytes credential is refused", e13 && e13.code === "vc/bad-credential");
+  var many = [];
+  for (var m = 0; m < 65; m++) many.push(jws);
+  var e14 = null;
+  try { await b.vc.present({ credentials: many, holder: "did:h", securing: "jose", alg: "EdDSA", privateKey: HOLDER.privateKey }); } catch (e) { e14 = e; }
+  check("present: more than the max credentials refused", e14 && e14.code === "vc/too-many-credentials");
+
+  // verifyPresentation: mandatory algorithms + key, and the enveloped
+  // entries must be EnvelopedVerifiableCredential data: URIs.
+  var vp = await b.vc.present({ credentials: [jws], holder: "did:h", securing: "jose", alg: "EdDSA", privateKey: HOLDER.privateKey });
+  var e15 = null;
+  try { await b.vc.verifyPresentation(vp, { algorithms: [], publicKey: HOLDER.publicKey }); } catch (e) { e15 = e; }
+  check("verifyPresentation: empty algorithms refused", e15 && e15.code === "vc/algorithms-required");
+  var e16 = null;
+  try { await b.vc.verifyPresentation(vp, { algorithms: ["EdDSA"] }); } catch (e) { e16 = e; }
+  check("verifyPresentation: missing key refused", e16 && e16.code === "vc/no-key");
+  var e17 = null;
+  try { await b.vc.verifyPresentation(vp, { algorithms: ["EdDSA"], publicKey: HOLDER.publicKey, verifyCredentials: true }); } catch (e) { e17 = e; }
+  check("verifyPresentation: verifyCredentials without credentialOpts refused", e17 && e17.code === "BAD_OPT");
+
+  // verifyPresentation: an entry that is not an EnvelopedVerifiableCredential
+  // is refused when the enclosed credentials are verified.
+  var badEntryVp = { "@context": ["https://www.w3.org/ns/credentials/v2"], type: ["VerifiablePresentation"], holder: "did:h", verifiableCredential: [{ type: "NotEnveloped", id: "data:application/vc+jwt,x" }] };
+  var bh = Buffer.from(JSON.stringify({ alg: "EdDSA", typ: "vp+jwt" }), "utf8").toString("base64url");
+  var bp = Buffer.from(JSON.stringify(badEntryVp), "utf8").toString("base64url");
+  var bsi = bh + "." + bp;
+  var badEntryJws = bsi + "." + nodeCrypto.sign(null, Buffer.from(bsi, "ascii"), HOLDER.privateKey).toString("base64url");
+  var e18 = null;
+  try { await b.vc.verifyPresentation(badEntryJws, { algorithms: ["EdDSA"], publicKey: HOLDER.publicKey, verifyCredentials: true, credentialOpts: { algorithms: ["ES256"], publicKey: EC.publicKey } }); } catch (e) { e18 = e; }
+  check("verifyPresentation: a non-enveloped credential entry is refused", e18 && e18.code === "vc/bad-enveloped");
+}
+
 async function run() {
   testSurface();
   await testJoseRoundTrip();
   await testAlgKeyBinding();
   await testCoseRoundTrip();
+  await testCoseTypBinding();
   await testRefusals();
+  await testStrictXsdValidity();
   await testTemporalAndStructural();
   await testPresentation();
+  await testDefensiveRefusals();
 }
 
 module.exports = { run: run };