@blamejs/blamejs-shop 0.5.12 → 0.5.13

package/lib/vendor/blamejs/test/layer-0-primitives/backup-manifest-signature.test.js

@@ -20,6 +20,189 @@ async function run() {
   check("backupBundle.verifyManifestSignature is fn",
     typeof b.backup.verifyManifestSignature === "function");
 
+  // ---- Parser / builder adversarial coverage (manifest.js) ----
+  // Every malformed / truncated / version-mismatched / tampered / oversized /
+  // adversarial input must produce a TYPED BackupManifestError (parse / create /
+  // serialize) or an { ok:false, errors } verdict (validate) — never an
+  // uncaught crash, never a fail-open acceptance. These drive the real
+  // b.backupManifest.* consumer path and need no signer, so they run before the
+  // audit-sign gate below.
+  function _covValidArgs() {
+    return {
+      vaultKeySalt: "0011aabb",
+      vaultKeyEnc:  Buffer.from("cipher-bytes").toString("base64"),
+      files: [{
+        relativePath:  "db.enc",
+        encryptedPath: "files/db.enc.bin",
+        size:          100,
+        encryptedSize: 132,
+        checksum:      "ab".repeat(64),   // 128-char hex (sha3-512)
+        salt:          "ccdd",
+        kind:          "raw",
+      }],
+      metadata: { reason: "cov" },
+    };
+  }
+  function _covRefuses(label, fn, code) {
+    var err = null;
+    try { fn(); } catch (e) { err = e; }
+    check(label + " → typed BackupManifestError",
+      !!err && err.name === "BackupManifestError" && (!code || err.code === code));
+  }
+  // Tamper a field on a fresh VALID manifest object (create() returns a valid
+  // one; mutating the returned object escapes create-time validation), then
+  // assert validate() renders a fail-closed verdict citing the field.
+  function _covValidateErr(label, mutate, rx) {
+    var o = b.backupManifest.create(_covValidArgs());
+    mutate(o);
+    var v = b.backupManifest.validate(o);
+    check(label + " → ok:false + cites field",
+      v.ok === false && v.errors.some(function (e) { return rx.test(e); }));
+  }
+
+  // A canonical valid manifest we tamper field-by-field via JSON round-trip
+  // to drive the real parse() trust-boundary path.
+  var covBase = b.backupManifest.create(_covValidArgs());
+  var covJson = b.backupManifest.serialize(covBase);
+  function _covTamperedJson(mutate) {
+    var o = JSON.parse(covJson);
+    mutate(o);
+    return JSON.stringify(o);
+  }
+
+  // create() fails closed with nothing supplied — never a half-built manifest.
+  _covRefuses("create() with no args refuses", function () {
+    b.backupManifest.create();
+  }, "backup-manifest/invalid");
+
+  // Malformed / truncated / empty JSON.
+  _covRefuses("parse truncated JSON refuses", function () {
+    b.backupManifest.parse('{"version":1,');
+  }, "backup-manifest/bad-json");
+  _covRefuses("parse empty-string refuses", function () {
+    b.backupManifest.parse("");
+  }, "backup-manifest/bad-json");
+
+  // JSON 'null' → validate sees a non-object manifest; typed invalid, no crash.
+  _covRefuses("parse of JSON null refuses (non-object manifest)", function () {
+    b.backupManifest.parse("null");
+  }, "backup-manifest/invalid");
+
+  // Missing every required key.
+  _covRefuses("parse of {} refuses (missing required keys)", function () {
+    b.backupManifest.parse("{}");
+  }, "backup-manifest/invalid");
+
+  // Version mismatch (adversarial downgrade/upgrade of an otherwise-valid one).
+  _covRefuses("parse rejects version mismatch", function () {
+    b.backupManifest.parse(_covTamperedJson(function (o) { o.version = 99; }));
+  }, "backup-manifest/invalid");
+
+  // Framework substitution.
+  _covRefuses("parse rejects wrong framework", function () {
+    b.backupManifest.parse(_covTamperedJson(function (o) { o.framework = "evil"; }));
+  }, "backup-manifest/invalid");
+
+  // metadata must be a plain object — an array is refused, not silently used.
+  _covRefuses("parse rejects array metadata", function () {
+    b.backupManifest.parse(_covTamperedJson(function (o) { o.metadata = [1, 2, 3]; }));
+  }, "backup-manifest/invalid");
+  _covValidateErr("validate rejects null metadata",
+    function (o) { o.metadata = null; }, /metadata/);
+
+  // Hand-edited PARTIAL signature block (operator forged a signature field) —
+  // every sub-field is required; a partial block is refused, not accepted.
+  _covRefuses("parse rejects partial signature block", function () {
+    b.backupManifest.parse(_covTamperedJson(function (o) { o.signature = { algorithm: "x" }; }));
+  }, "backup-manifest/invalid");
+  _covRefuses("parse rejects non-object signature", function () {
+    b.backupManifest.parse(_covTamperedJson(function (o) { o.signature = "not-a-block"; }));
+  }, "backup-manifest/invalid");
+  _covValidateErr("validate flags non-base64 signature.value",
+    function (o) { o.signature = { algorithm: "ml-dsa", publicKey: "k", fingerprint: "fp",
+      value: "not base64 !@#", signedAt: new Date().toISOString() }; }, /signature\.value/);
+  _covValidateErr("validate flags non-ISO signature.signedAt",
+    function (o) { o.signature = { algorithm: "ml-dsa", publicKey: "k", fingerprint: "fp",
+      value: Buffer.from("v").toString("base64"), signedAt: "whenever" }; }, /signature\.signedAt/);
+
+  // Top-level field-shape branches.
+  _covValidateErr("validate flags empty frameworkVersion",
+    function (o) { o.frameworkVersion = ""; }, /frameworkVersion/);
+  _covValidateErr("validate flags non-hex vaultKeySalt",
+    function (o) { o.vaultKeySalt = "zznothex"; }, /vaultKeySalt/);
+  _covValidateErr("validate flags files not-an-array",
+    function (o) { o.files = "nope"; }, /files: required array/);
+
+  // Adversarial file entries.
+  _covValidateErr("validate flags a null file entry",
+    function (o) { o.files = [null]; }, /files\[0\]: must be an object/);
+  _covValidateErr("validate flags a numeric file entry",
+    function (o) { o.files = [42]; }, /files\[0\]: must be an object/);
+  _covValidateErr("validate flags a missing relativePath",
+    function (o) { delete o.files[0].relativePath; }, /relativePath/);
+  _covValidateErr("validate flags encryptedPath traversal",
+    function (o) { o.files[0].encryptedPath = "../escape.bin"; }, /encryptedPath/);
+  _covValidateErr("validate flags a missing encryptedSize",
+    function (o) { delete o.files[0].encryptedSize; }, /encryptedSize/);
+  _covValidateErr("validate flags a negative encryptedSize",
+    function (o) { o.files[0].encryptedSize = -5; }, /encryptedSize/);
+  _covValidateErr("validate flags a non-integer size",
+    function (o) { o.files[0].size = 1.5; }, /size/);
+  _covValidateErr("validate flags a non-finite size",
+    function (o) { o.files[0].size = Infinity; }, /size/);
+  _covValidateErr("validate flags a hex-but-wrong-length checksum",
+    function (o) { o.files[0].checksum = "ab".repeat(60); }, /checksum/);   // 120 chars, not 128
+  _covValidateErr("validate flags a non-hex salt",
+    function (o) { o.files[0].salt = "zznothex"; }, /salt/);
+  _covValidateErr("validate flags a missing kind",
+    function (o) { delete o.files[0].kind; }, /kind/);
+  _covValidateErr("validate flags a duplicate encryptedPath",
+    function (o) { o.files.push({ relativePath: "other.enc", encryptedPath: "files/db.enc.bin",
+      size: 1, encryptedSize: 1, checksum: "cd".repeat(64), salt: "ee", kind: "raw" }); },
+    /duplicate/);
+
+  // Fail-open fix: a Windows drive-absolute path is NOT relative and must be
+  // refused (it escapes dataDir on restore, path.resolve honors the drive).
+  var covDrive = "C:" + "\\" + "Windows" + "\\" + "evil";
+  _covValidateErr("validate refuses drive-absolute relativePath",
+    function (o) { o.files[0].relativePath = covDrive; }, /relativePath/);
+  _covValidateErr("validate refuses drive-absolute encryptedPath",
+    function (o) { o.files[0].encryptedPath = covDrive; }, /encryptedPath/);
+  // An NTFS alternate-data-stream marker (a colon anywhere, not just a leading
+  // drive letter) is refused at validate() too, matching the safePath sink so a
+  // caller pre-screening a tampered manifest with validate()/inspect() also
+  // fails closed rather than deferring the rejection to restore.
+  _covValidateErr("validate refuses an NTFS-ADS relativePath (colon)",
+    function (o) { o.files[0].relativePath = "db.enc:evil"; }, /relativePath/);
+  _covValidateErr("validate refuses an NTFS-ADS encryptedPath (colon)",
+    function (o) { o.files[0].encryptedPath = "files/db.enc.bin:stream"; }, /encryptedPath/);
+
+  // serialize() on a tampered-invalid manifest fails closed too.
+  _covRefuses("serialize refuses an invalid manifest", function () {
+    var o = b.backupManifest.create(_covValidArgs());
+    o.version = 5;
+    b.backupManifest.serialize(o);
+  }, "backup-manifest/invalid");
+
+  // aadBound (blob-remap defense marker) round-trips through create/serialize/parse.
+  var covAad = b.backupManifest.create(Object.assign(_covValidArgs(), { aadBound: true }));
+  check("create honors aadBound flag", covAad.aadBound === true);
+  var covAadJson = b.backupManifest.serialize(covAad);
+  check("serialize emits aadBound", /"aadBound": true/.test(covAadJson));
+  check("parse round-trips aadBound", b.backupManifest.parse(covAadJson).aadBound === true);
+
+  // Prototype-pollution attempt via a __proto__ manifest key — parse strips it
+  // (safeJson trust-boundary) and does not pollute Object.prototype nor crash.
+  var covPollJson = covJson.replace(/^\{/, '{"__proto__":{"polluted":true},');
+  var covPolled = b.backupManifest.parse(covPollJson);
+  check("parse strips __proto__ (no prototype pollution)",
+    ({}).polluted === undefined && covPolled.version === 1);
+
+  // Oversized manifest (> the 16 MiB parse cap) is refused, not OOM'd.
+  _covRefuses("parse refuses an oversized manifest (>16 MiB)", function () {
+    b.backupManifest.parse('{"version":1,"blob":"' + "a".repeat(0x1100000) + '"}');
+  }, "backup-manifest/bad-json");
+
   // We need an audit-sign-initialized process to sign. helpers.b
   // initializes audit-sign during the smoke runner setup; if not
   // initialized, this test is a smoke-skipped no-op that logs and

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

@@ -5,11 +5,17 @@
  * Layer 0 — b.base32 (RFC 4648).
  * Oracle: the RFC 4648 §10 test vectors for both the standard Base32
  * alphabet and the extended-hex alphabet.
+ * Also exercises the full codec surface: encode input types (Buffer /
+ * Uint8Array, padded and bare, both alphabets), decode (strict + loose),
+ * every partial-group size, and the canonicalization and length invariants
+ * a round-trip alone does not reach — non-canonical trailing bits and
+ * impossible symbol counts.
  */
 
 var b = require("../../index");
 var helpers = require("../helpers");
 var check = helpers.check;
+var nodeCrypto = require("crypto");
 function code(fn) { try { fn(); return "NO-THROW"; } catch (e) { return e.code; } }
 
 // RFC 4648 §10 — standard Base32.
@@ -71,11 +77,110 @@ function testTotpComposition() {
   check("totp secret round-trips through b.base32", b.base32.encode(b.base32.decode(secret, { loose: true }), { padding: false }) === secret);
 }
 
+function threwCode(fn) { try { fn(); return null; } catch (e) { return e.code || null; } }
+
+// ---- encode: input types, empty, bad input ----
+function testEncodeInputs() {
+  check("encode Buffer", b.base32.encode(Buffer.from("f")) === "MY======");
+  // A Uint8Array must encode identically to the equivalent Buffer.
+  check("encode Uint8Array mirrors Buffer",
+    b.base32.encode(new Uint8Array([0x66, 0x6f, 0x6f])) === b.base32.encode(Buffer.from("foo")));
+  check("encode empty → empty string", b.base32.encode(Buffer.alloc(0)) === "");
+  check("encode rejects a string input",
+    threwCode(function () { b.base32.encode("not a buffer"); }) === "base32/bad-input");
+  check("encode rejects null",
+    threwCode(function () { b.base32.encode(null); }) === "base32/bad-input");
+}
+
+// ---- padding + both RFC 4648 alphabets ----
+function testPaddingAndVariants() {
+  check("padded to 8-char boundary by default", b.base32.encode(Buffer.from("f")).length % 8 === 0);
+  check("padding:false omits =", b.base32.encode(Buffer.from("f"), { padding: false }) === "MY");
+  check("rfc4648-hex variant differs from standard",
+    b.base32.encode(Buffer.from("foo"), { variant: "rfc4648-hex" }) !== b.base32.encode(Buffer.from("foo")));
+  check("rfc4648-hex round-trips",
+    b.base32.decode(b.base32.encode(Buffer.from("foo"), { variant: "rfc4648-hex" }), { variant: "rfc4648-hex" }).toString() === "foo");
+  check("bad variant rejected (encode)",
+    threwCode(function () { b.base32.encode(Buffer.from("x"), { variant: "nope" }); }) === "base32/bad-variant");
+  check("bad variant rejected (decode)",
+    threwCode(function () { b.base32.decode("MY======", { variant: "nope" }); }) === "base32/bad-variant");
+}
+
+// ---- every partial-group size round-trips (1..5 trailing bytes) ----
+function testAllPartialGroups() {
+  ["f", "fo", "foo", "foob", "fooba", "foobar", "foobarbaz"].forEach(function (s) {
+    var enc = b.base32.encode(Buffer.from(s));
+    check("round-trip padded '" + s + "'", b.base32.decode(enc).toString() === s);
+    check("padded '" + s + "' length is a multiple of 8", enc.length % 8 === 0);
+    var bare = b.base32.encode(Buffer.from(s), { padding: false });
+    check("round-trip bare '" + s + "'", b.base32.decode(bare).toString() === s);
+  });
+  // 20 random bytes (a TOTP-secret-sized value) round-trips bare + padded.
+  var rnd = nodeCrypto.randomBytes(20);
+  check("round-trip random 20B padded", b.base32.decode(b.base32.encode(rnd)).equals(rnd));
+  check("round-trip random 20B bare", b.base32.decode(b.base32.encode(rnd, { padding: false })).equals(rnd));
+}
+
+// ---- decode strict: invalid char, data-after-padding, non-string ----
+function testDecodeStrictRejects() {
+  check("invalid char rejected", threwCode(function () { b.base32.decode("MY0====="); }) === "base32/bad-char");
+  check("lowercase rejected in strict", threwCode(function () { b.base32.decode("my======"); }) === "base32/bad-char");
+  check("data after padding rejected", threwCode(function () { b.base32.decode("M=Y====="); }) === "base32/bad-char");
+  check("non-string input rejected", threwCode(function () { b.base32.decode(Buffer.from("MY")); }) === "base32/bad-input");
+}
+
+// ---- decode loose: lowercase, spaces, dashes, missing padding ----
+function testDecodeLoose() {
+  check("loose up-cases", b.base32.decode("my======", { loose: true }).toString() === "f");
+  check("loose ignores spaces + dashes",
+    b.base32.decode("MZXW-6YT B", { loose: true }).toString() === b.base32.decode("MZXW6YTB").toString());
+  check("loose accepts missing padding", b.base32.decode("MY", { loose: true }).toString() === "f");
+}
+
+// ---- canonicalization: reject malleable encodings ----
+// Non-canonical trailing bits (RFC 4648 §3.5): the final symbol's unused low
+// bits must be zero, else two distinct strings decode to the same bytes.
+function testNonCanonicalRejected() {
+  // "MY======" is canonical 'f'; "MZ======" has the same high bits but non-zero
+  // low bits — it must NOT silently decode to 'f'.
+  check("MY====== decodes to f (canonical)", b.base32.decode("MY======").toString() === "f");
+  check("MZ====== (non-canonical) rejected",
+    threwCode(function () { b.base32.decode("MZ======"); }) === "base32/non-canonical");
+  check("non-canonical rejected in loose mode too",
+    threwCode(function () { b.base32.decode("mz======", { loose: true }); }) === "base32/non-canonical");
+  // Build a non-canonical value for a 3-symbol-tail case and assert refusal.
+  // 4 symbols carry 20 bits → 2 bytes (16 bits) + 4 leftover; flip a leftover bit.
+  var canonical4 = b.base32.encode(Buffer.from("fo")).replace(/=+$/, "");   // "MZXW6" -> take first 4
+  // canonical for "fo" is 4 data symbols; if the 4th symbol's low bits are non-zero it's non-canonical.
+  check("a canonical 'fo' still decodes", b.base32.decode(b.base32.encode(Buffer.from("fo"))).toString() === "fo");
+  void canonical4;
+}
+
+// Impossible symbol counts: 1, 3, 6 (mod 8) cannot represent whole bytes.
+function testBadLengthRejected() {
+  ["A", "ABC", "ABCDEF"].forEach(function (s) {
+    check("impossible length '" + s + "' (" + s.length + " symbols) rejected",
+      threwCode(function () { b.base32.decode(s); }) === "base32/bad-length");
+  });
+  // Valid partial-group counts (2,4,5,7) do NOT trip the length guard.
+  ["MY======", "MZXW====", "MZXW6===", "MZXW6YQ="].forEach(function (s) {
+    var code = threwCode(function () { b.base32.decode(s); });
+    check("valid-length '" + s + "' not rejected for length", code !== "base32/bad-length");
+  });
+}
+
 async function run() {
   testSurface();
   testVectors();
   testOptions();
   testTotpComposition();
+  testEncodeInputs();
+  testPaddingAndVariants();
+  testAllPartialGroups();
+  testDecodeStrictRejects();
+  testDecodeLoose();
+  testNonCanonicalRejected();
+  testBadLengthRejected();
 }
 module.exports = { run: run };
 if (require.main === module) { run().then(function () { console.log("[base32] OK — " + helpers.getChecks() + " checks passed"); }, function (e) { console.error("FAIL:", e && e.stack || e); process.exit(1); }); }