@blamejs/core 0.14.11 → 0.14.12

package/lib/vault-aad.js

@@ -147,13 +147,17 @@ function buildContextAad(parts) {
 // 32 bytes). Constant-domain prefix prevents key collision with other
 // uses of the vault root.
 
-function _deriveKey(aadBytes) {
-  var keysJson = vault().getKeysJson();
-  // The vault keys JSON includes the active keypair PEMs. We hash the
-  // whole serialized form to get a stable per-vault root secret —
-  // this is a deterministic derivation; rotating vault keys produces
-  // a different root and breaks all prior AAD-sealed values (operator
-  // intent: rotation = re-seal).
+function _deriveKey(aadBytes, rootKeysJson) {
+  // rootKeysJson lets the vault-key rotation pipeline derive the per-row
+  // key under a SPECIFIC vault root (old or new keypair) within one
+  // process; when omitted it uses the live singleton. The keys JSON
+  // includes the active keypair PEMs — hashing the whole serialized form
+  // gives a stable per-vault root secret. Rotating vault keys produces a
+  // different root, so prior AAD-sealed values must be re-sealed (the
+  // rotation pipeline walks them via sealRoot/unsealRoot/resealRoot).
+  var keysJson = (typeof rootKeysJson === "string" && rootKeysJson.length > 0)
+    ? rootKeysJson
+    : vault().getKeysJson();
   var rootHash = bCrypto().sha3Hash(keysJson);
   var prefix   = Buffer.from("vault.aad/v1/", "utf8");
   var rootBuf  = Buffer.from(rootHash, "hex");
@@ -161,7 +165,7 @@ function _deriveKey(aadBytes) {
   return bCrypto().kdf(input, C.BYTES.bytes(32));
 }
 
-function seal(plaintext, aadParts) {
+function _seal(plaintext, aadParts, rootKeysJson, suppressAudit) {
   if (plaintext == null) {
     throw new VaultAadError("vault-aad/bad-input",
       "seal: plaintext is required (use null/undefined-stripping at the call site)");
@@ -176,26 +180,32 @@ function seal(plaintext, aadParts) {
       "seal: value is already AAD-sealed (refuses to double-seal)");
   }
   var aadBytes = _canonicalize(aadParts);
-  var key = _deriveKey(aadBytes);
+  var key = _deriveKey(aadBytes, rootKeysJson);
   var ptBuf = Buffer.from(plaintext, "utf8");
   var packed = bCrypto().encryptPacked(ptBuf, key, aadBytes);
 
-  try {
-    audit().safeEmit({
-      action:   "vault.aad.sealed",
-      outcome:  "success",
-      actor:    null,
-      metadata: {
-        aadKeys: Object.keys(aadParts).sort(),    // allow:bare-canonicalize-walk — audit-emit metadata, not for signing
-        bytes:   ptBuf.length,
-      },
-    });
-  } catch (_e) { /* drop-silent */ }
+  if (!suppressAudit) {
+    try {
+      audit().safeEmit({
+        action:   "vault.aad.sealed",
+        outcome:  "success",
+        actor:    null,
+        metadata: {
+          aadKeys: Object.keys(aadParts).sort(),    // allow:bare-canonicalize-walk — audit-emit metadata, not for signing
+          bytes:   ptBuf.length,
+        },
+      });
+    } catch (_e) { /* drop-silent */ }
+  }
 
   return AAD_PREFIX + packed.toString("base64");
 }
 
-function unseal(value, aadParts) {
+function seal(plaintext, aadParts) {
+  return _seal(plaintext, aadParts, undefined, false);
+}
+
+function _unseal(value, aadParts, rootKeysJson, suppressAudit) {
   if (value == null || typeof value !== "string") {
     throw new VaultAadError("vault-aad/bad-input",
       "unseal: value must be a non-empty string");
@@ -205,7 +215,7 @@ function unseal(value, aadParts) {
       "unseal: value is not AAD-sealed (missing " + JSON.stringify(AAD_PREFIX) + " prefix)");
   }
   var aadBytes = _canonicalize(aadParts);
-  var key = _deriveKey(aadBytes);
+  var key = _deriveKey(aadBytes, rootKeysJson);
   var packed;
   try { packed = Buffer.from(value.slice(AAD_PREFIX.length), "base64"); }
   catch (e) {
@@ -215,17 +225,19 @@ function unseal(value, aadParts) {
   var pt;
   try { pt = bCrypto().decryptPacked(packed, key, aadBytes); }
   catch (e) {
-    try {
-      audit().safeEmit({
-        action:   "vault.aad.unseal_failed",
-        outcome:  "denied",
-        actor:    null,
-        metadata: {
-          aadKeys: Object.keys(aadParts).sort(),  // allow:bare-canonicalize-walk — audit-emit metadata, not for signing
-          reason:  e.message,
-        },
-      });
-    } catch (_e) { /* drop-silent */ }
+    if (!suppressAudit) {
+      try {
+        audit().safeEmit({
+          action:   "vault.aad.unseal_failed",
+          outcome:  "denied",
+          actor:    null,
+          metadata: {
+            aadKeys: Object.keys(aadParts).sort(),  // allow:bare-canonicalize-walk — audit-emit metadata, not for signing
+            reason:  e.message,
+          },
+        });
+      } catch (_e) { /* drop-silent */ }
+    }
     throw new VaultAadError("vault-aad/aead-mismatch",
       "unseal: AEAD authentication failed — value may have been tampered, " +
       "copied from a different row, or sealed under different AAD");
@@ -233,6 +245,10 @@ function unseal(value, aadParts) {
   return pt.toString("utf8");
 }
 
+function unseal(value, aadParts) {
+  return _unseal(value, aadParts, undefined, false);
+}
+
 function isAadSealed(value) {
   return typeof value === "string" && value.indexOf(AAD_PREFIX) === 0;
 }
@@ -246,10 +262,45 @@ function reseal(value, fromAad, toAad) {
   return seal(plaintext, toAad);
 }
 
+// ---- explicit-root variants (vault-key rotation pipeline) ----
+//
+// The rotation pipeline must decrypt a cell under the OLD vault root and
+// re-encrypt it under the NEW root within one process — the live-singleton
+// _deriveKey cannot straddle two keypairs. These take the serialized vault
+// keys JSON (b.vault.getKeysJson() output) for a specific root; the AAD
+// tuple is unchanged, only the root differs. Per-cell audit is suppressed
+// (the rotation pipeline has its own progress + verify reporting).
+
+function sealRoot(plaintext, aadParts, rootKeysJson) {
+  if (typeof rootKeysJson !== "string" || rootKeysJson.length === 0) {
+    throw new VaultAadError("vault-aad/bad-root", "sealRoot: rootKeysJson (vault keys JSON) is required");
+  }
+  return _seal(plaintext, aadParts, rootKeysJson, true);
+}
+
+function unsealRoot(value, aadParts, rootKeysJson) {
+  if (typeof rootKeysJson !== "string" || rootKeysJson.length === 0) {
+    throw new VaultAadError("vault-aad/bad-root", "unsealRoot: rootKeysJson (vault keys JSON) is required");
+  }
+  return _unseal(value, aadParts, rootKeysJson, true);
+}
+
+// Re-seal a value from the old root to the new root under the SAME AAD
+// tuple: authenticate under the old root (throws aead-mismatch if the
+// value was not sealed under oldRootJson + aadParts), then re-encrypt
+// under the new root. The rotation pipeline composes this per cell.
+function resealRoot(value, aadParts, oldRootJson, newRootJson) {
+  var plaintext = unsealRoot(value, aadParts, oldRootJson);
+  return sealRoot(plaintext, aadParts, newRootJson);
+}
+
 module.exports = {
   seal:               seal,
   unseal:             unseal,
   reseal:             reseal,
+  sealRoot:           sealRoot,
+  unsealRoot:         unsealRoot,
+  resealRoot:         resealRoot,
   isAadSealed:        isAadSealed,
   buildColumnAad:     buildColumnAad,
   buildContextAad:    buildContextAad,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blamejs/core",
-  "version": "0.14.11",
+  "version": "0.14.12",
   "description": "The Node framework that owns its stack.",
   "license": "Apache-2.0",
   "author": "blamejs contributors",

package/sbom.cdx.json

@@ -2,10 +2,10 @@
   "$schema": "http://cyclonedx.org/schema/bom-1.5.schema.json",
   "bomFormat": "CycloneDX",
   "specVersion": "1.5",
-  "serialNumber": "urn:uuid:51d93d1b-aac7-4b5a-b94b-b60595c0eba0",
+  "serialNumber": "urn:uuid:f81dd931-ce62-498a-ac6f-d9ac5b0be399",
   "version": 1,
   "metadata": {
-    "timestamp": "2026-05-31T14:46:52.063Z",
+    "timestamp": "2026-05-31T18:05:40.945Z",
     "lifecycles": [
       {
         "phase": "build"
@@ -19,14 +19,14 @@
       }
     ],
     "component": {
-      "bom-ref": "@blamejs/core@0.14.11",
+      "bom-ref": "@blamejs/core@0.14.12",
       "type": "application",
       "name": "blamejs",
-      "version": "0.14.11",
+      "version": "0.14.12",
       "scope": "required",
       "author": "blamejs contributors",
       "description": "The Node framework that owns its stack.",
-      "purl": "pkg:npm/%40blamejs/core@0.14.11",
+      "purl": "pkg:npm/%40blamejs/core@0.14.12",
       "properties": [],
       "externalReferences": [
         {
@@ -54,7 +54,7 @@
   "components": [],
   "dependencies": [
     {
-      "ref": "@blamejs/core@0.14.11",
+      "ref": "@blamejs/core@0.14.12",
       "dependsOn": []
     }
   ]