@optimystic/quereus-plugin-crypto 0.13.5 → 0.16.2

package/dist/plugin.js

@@ -1,12 +1,18 @@
 import { FunctionFlags, TEXT_TYPE, BOOLEAN_TYPE, INTEGER_TYPE } from '@quereus/quereus';
+import { toString, fromString } from 'uint8arrays';
 import { sha512, sha256 } from '@noble/hashes/sha2.js';
 import { blake3 } from '@noble/hashes/blake3.js';
-import { randomBytes as randomBytes$1, utf8ToBytes } from '@noble/hashes/utils.js';
+import { randomBytes as randomBytes$1, concatBytes, utf8ToBytes } from '@noble/hashes/utils.js';
 import { secp256k1 } from '@noble/curves/secp256k1.js';
 import { p256 } from '@noble/curves/nist.js';
 import { ed25519 } from '@noble/curves/ed25519.js';
-import { hexToBytes, bytesToHex } from '@noble/curves/utils.js';
-import { fromString, toString } from 'uint8arrays';
+import { bytesToHex, hexToBytes } from '@noble/curves/utils.js';
+import { CID } from 'multiformats/cid';
+import * as Digest from 'multiformats/hashes/digest';
+import { base32 } from 'multiformats/bases/base32';
+import { base58btc } from 'multiformats/bases/base58';
+import { base64url } from 'multiformats/bases/base64';
+import { base16 } from 'multiformats/bases/base16';
 
 // src/plugin.ts
 function toBytes(input, encoding = "base64url") {
@@ -48,29 +54,133 @@ function fromBytes(bytes, encoding = "base64url") {
       return toString(bytes, "base64url");
   }
 }
-function digest(data, algorithm = "sha256", inputEncoding = "base64url", outputEncoding = "base64url") {
-  const bytes = toBytes(data, inputEncoding);
-  let hashBytes;
-  switch (algorithm) {
-    case "sha256":
-      hashBytes = sha256(bytes);
-      break;
-    case "sha512":
-      hashBytes = sha512(bytes);
-      break;
-    case "blake3":
-      hashBytes = blake3(bytes);
-      break;
+var HASHERS = {
+  sha256,
+  sha512,
+  blake3
+};
+var OUTPUT_ENCODERS = {
+  base64url: (bytes) => toString(bytes, "base64url"),
+  base64: (bytes) => toString(bytes, "base64"),
+  hex: (bytes) => bytesToHex(bytes),
+  bytes: (bytes) => bytes
+};
+function resolveHasher(algorithm) {
+  const hasher = HASHERS[algorithm];
+  if (!hasher) {
+    throw new Error(`Unsupported hash algorithm: ${algorithm}`);
+  }
+  return hasher;
+}
+function resolveOutputEncoder(encoding) {
+  const encoder = OUTPUT_ENCODERS[encoding];
+  if (!encoder) {
+    throw new Error(`Unsupported output encoding: ${encoding}`);
+  }
+  return encoder;
+}
+var DIGEST_FORMAT_V1 = 1;
+var TAG_NULL = 0;
+var TAG_INT = 1;
+var TAG_REAL = 2;
+var TAG_TEXT = 3;
+var TAG_BOOL = 4;
+var TAG_BLOB = 5;
+var TAG_JSON = 6;
+function writeVarint(out, value) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new Error(`varint expects a non-negative integer, got ${value}`);
+  }
+  let v = value;
+  while (v >= 128) {
+    out.push(v & 127 | 128);
+    v = Math.floor(v / 128);
+  }
+  out.push(v);
+}
+function framed(tag, payload) {
+  const header = [tag];
+  writeVarint(header, payload.length);
+  return concatBytes(Uint8Array.from(header), payload);
+}
+function canonicalJson(value) {
+  if (value === null) return "null";
+  const t = typeof value;
+  if (t === "string") return JSON.stringify(value);
+  if (t === "boolean") return value ? "true" : "false";
+  if (t === "number") {
+    if (!Number.isFinite(value)) {
+      throw new Error("digest: cannot encode a non-finite number inside a JSON field");
+    }
+    return JSON.stringify(value);
+  }
+  if (t === "bigint") {
+    throw new Error("digest: bigint is not representable inside a JSON field");
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((el) => {
+      if (el === void 0) {
+        throw new Error("digest: undefined / sparse element inside a JSON field");
+      }
+      return canonicalJson(el);
+    }).join(",")}]`;
+  }
+  if (t === "object") {
+    const proto = Object.getPrototypeOf(value);
+    if (proto !== Object.prototype && proto !== null) {
+      throw new Error("digest: only plain objects are allowed inside a JSON field");
+    }
+    const obj = value;
+    const keys = Object.keys(obj).sort();
+    return `{${keys.map((k) => {
+      if (obj[k] === void 0) {
+        throw new Error(`digest: undefined value for JSON key '${k}'`);
+      }
+      return `${JSON.stringify(k)}:${canonicalJson(obj[k])}`;
+    }).join(",")}}`;
+  }
+  throw new Error(`digest: unsupported value of type '${t}' inside a JSON field`);
+}
+function encodeField(field) {
+  if (field === null || field === void 0) {
+    return Uint8Array.of(TAG_NULL);
+  }
+  switch (typeof field) {
+    case "boolean":
+      return Uint8Array.of(TAG_BOOL, field ? 1 : 0);
+    case "bigint":
+      return framed(TAG_INT, utf8ToBytes(field.toString()));
+    case "number":
+      if (!Number.isFinite(field)) {
+        throw new Error("digest: cannot encode a non-finite number");
+      }
+      return Number.isInteger(field) ? framed(TAG_INT, utf8ToBytes(BigInt(field).toString())) : framed(TAG_REAL, utf8ToBytes(field.toString()));
+    case "string":
+      return framed(TAG_TEXT, utf8ToBytes(field));
+    case "object":
+      if (field instanceof Uint8Array) {
+        return framed(TAG_BLOB, field);
+      }
+      return framed(TAG_JSON, utf8ToBytes(canonicalJson(field)));
     default:
-      throw new Error(`Unsupported hash algorithm: ${algorithm}`);
+      throw new Error(`digest: unsupported field type '${typeof field}'`);
+  }
+}
+function encodeFields(fields) {
+  const chunks = [Uint8Array.of(DIGEST_FORMAT_V1)];
+  for (const field of fields) {
+    chunks.push(encodeField(field));
   }
-  return fromBytes(hashBytes, outputEncoding);
+  return concatBytes(...chunks);
+}
+function digestFields(fields, hasher, encode) {
+  return encode(hasher(encodeFields(fields)));
 }
 function hashMod(data, bits, algorithm = "sha256", inputEncoding = "base64url") {
   if (bits <= 0 || bits > 53) {
     throw new Error("Bits must be between 1 and 53 (JavaScript safe integer limit)");
   }
-  const hashBytes = toBytes(digest(data, algorithm, inputEncoding, "base64url"), "base64url");
+  const hashBytes = resolveHasher(algorithm)(toBytes(data, inputEncoding));
   const view = new DataView(hashBytes.buffer, hashBytes.byteOffset, Math.min(8, hashBytes.length));
   const fullHash = view.getBigUint64(0, false);
   const modulus = BigInt(2) ** BigInt(bits);
@@ -123,23 +233,316 @@ function randomBytes(bits = 256, encoding = "base64url") {
   const randomBytesArray = randomBytes$1(bytes);
   return fromBytes(randomBytesArray, encoding);
 }
+var MULTICODEC_CODES = {
+  "raw": 85,
+  "dag-cbor": 113
+};
+var MULTIHASH_CODES = {
+  "sha2-256": 18,
+  "sha2-512": 19,
+  "blake3": 30
+};
+var MULTIHASH_TO_ALGORITHM = {
+  "sha2-256": "sha256",
+  "sha2-512": "sha512",
+  "blake3": "blake3"
+};
+var MULTIHASH_DIGEST_LENGTHS = {
+  "sha2-256": 32,
+  "sha2-512": 64,
+  "blake3": 32
+};
+var MULTICODEC_NAMES = new Map(
+  Object.entries(MULTICODEC_CODES).map(([name, code]) => [code, name])
+);
+var MULTIHASH_NAMES = new Map(
+  Object.entries(MULTIHASH_CODES).map(([name, code]) => [code, name])
+);
+var MULTIBASE_ENCODERS = {
+  "base32": base32,
+  "base58btc": base58btc,
+  "base64url": base64url,
+  "base16": base16
+};
+var MULTIBASE_DECODER = base32.decoder.or(base58btc.decoder).or(base64url.decoder).or(base16.decoder);
+function resolveCodecCode(codec) {
+  const code = MULTICODEC_CODES[codec];
+  if (code === void 0) {
+    throw new Error(`cid: unsupported multicodec '${codec}' (expected one of ${Object.keys(MULTICODEC_CODES).join(", ")})`);
+  }
+  return code;
+}
+function resolveBaseEncoder(base) {
+  const encoder = MULTIBASE_ENCODERS[base];
+  if (!encoder) {
+    throw new Error(`cid: unsupported multibase '${base}' (expected one of ${Object.keys(MULTIBASE_ENCODERS).join(", ")})`);
+  }
+  return encoder;
+}
+function cidV1(digest, hash, codec = "raw", base = "base32") {
+  const hashCode = MULTIHASH_CODES[hash];
+  if (hashCode === void 0) {
+    throw new Error(`cid: unsupported multihash code '${hash}' (expected one of ${Object.keys(MULTIHASH_CODES).join(", ")})`);
+  }
+  const expectedLength = MULTIHASH_DIGEST_LENGTHS[hash];
+  if (digest.length !== expectedLength) {
+    throw new Error(`cid: digest length ${digest.length} does not match asserted hash '${hash}' (expected ${expectedLength} bytes)`);
+  }
+  const codecCode = resolveCodecCode(codec);
+  const encoder = resolveBaseEncoder(base);
+  const multihash = Digest.create(hashCode, digest);
+  return CID.createV1(codecCode, multihash).toString(encoder);
+}
+function cid(data, codec = "raw", hash = "sha2-256", base = "base32") {
+  const algorithm = MULTIHASH_TO_ALGORITHM[hash];
+  if (!algorithm) {
+    throw new Error(`cid: unsupported multihash code '${hash}' (expected one of ${Object.keys(MULTIHASH_CODES).join(", ")})`);
+  }
+  const digest = resolveHasher(algorithm)(data);
+  return cidV1(digest, hash, codec, base);
+}
+function cidDecode(value) {
+  const parsed = CID.parse(value, MULTIBASE_DECODER);
+  return {
+    version: parsed.version,
+    codec: MULTICODEC_NAMES.get(parsed.code) ?? parsed.code,
+    hashCode: MULTIHASH_NAMES.get(parsed.multihash.code) ?? parsed.multihash.code,
+    digest: parsed.multihash.digest
+  };
+}
+var SD_LEAF_DOMAIN_V1 = "optimystic/sd-leaf/v1";
+var SD_SET_DOMAIN_V1 = "optimystic/sd-set/v1";
+var HIDDEN_ENCODING = "base64url";
+function compareBytes(a, b) {
+  const len = Math.min(a.length, b.length);
+  for (let i = 0; i < len; i++) {
+    const d = a[i] - b[i];
+    if (d !== 0) return d;
+  }
+  return a.length - b.length;
+}
+function bytesEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+function requireSaltBytes(leaf) {
+  const { salt } = leaf;
+  if (salt == null) {
+    throw new Error(`set commitment: leaf '${leaf.name}' is missing a salt (an unsalted leaf is brute-forceable)`);
+  }
+  const bytes = salt instanceof Uint8Array ? salt : fromString(salt, HIDDEN_ENCODING);
+  if (bytes.length === 0) {
+    throw new Error(`set commitment: leaf '${leaf.name}' has an empty salt (an unsalted leaf is brute-forceable)`);
+  }
+  return bytes;
+}
+function assertUniqueNames(leaves) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const leaf of leaves) {
+    if (seen.has(leaf.name)) {
+      throw new Error(`set commitment: duplicate leaf name '${leaf.name}'`);
+    }
+    seen.add(leaf.name);
+  }
+}
+function leafDigest(leaf, hasher) {
+  const saltBytes = requireSaltBytes(leaf);
+  return hasher(encodeFields([SD_LEAF_DOMAIN_V1, leaf.name, leaf.value, saltBytes]));
+}
+function setCommit(leaves, hasher = resolveHasher("sha256"), encode = resolveOutputEncoder("base64url")) {
+  assertUniqueNames(leaves);
+  const leafDigests = leaves.map((leaf) => leafDigest(leaf, hasher));
+  leafDigests.sort(compareBytes);
+  return encode(hasher(encodeFields([SD_SET_DOMAIN_V1, ...leafDigests])));
+}
+function setVerify(root, disclosure, hasher = resolveHasher("sha256"), encode = resolveOutputEncoder("base64url")) {
+  try {
+    const { disclosed, hidden } = disclosure;
+    const digests = [];
+    for (const leaf of disclosed) {
+      digests.push(leafDigest(leaf, hasher));
+    }
+    for (const h of hidden) {
+      digests.push(fromString(h, HIDDEN_ENCODING));
+    }
+    digests.sort(compareBytes);
+    const recomputed = hasher(encodeFields([SD_SET_DOMAIN_V1, ...digests]));
+    if (root instanceof Uint8Array) {
+      return bytesEqual(recomputed, root);
+    }
+    const encoded = encode(recomputed);
+    return typeof encoded === "string" && encoded === root;
+  } catch {
+    return false;
+  }
+}
 
 // src/plugin.ts
+var DIGEST_ALGORITHMS = ["sha256", "sha512", "blake3"];
+var DIGEST_TEXT_ENCODINGS = ["base64url", "base64", "hex"];
+function configAlgorithm(config) {
+  const value = config.algorithm == null ? "sha256" : String(config.algorithm);
+  if (!DIGEST_ALGORITHMS.includes(value)) {
+    throw new Error(`crypto plugin: unsupported digest algorithm '${value}' (expected one of ${DIGEST_ALGORITHMS.join(", ")})`);
+  }
+  return value;
+}
+function configEncoding(config) {
+  const value = config.encoding == null ? "base64url" : String(config.encoding);
+  if (!DIGEST_TEXT_ENCODINGS.includes(value)) {
+    throw new Error(`crypto plugin: unsupported digest encoding '${value}' (expected one of ${DIGEST_TEXT_ENCODINGS.join(", ")})`);
+  }
+  return value;
+}
+function toContentBytes(value, fnName) {
+  if (value instanceof Uint8Array) {
+    return value;
+  }
+  if (typeof value === "string") {
+    return fromString(value, "base64url");
+  }
+  throw new Error(`${fnName}: expected a BLOB or base64url TEXT argument, got ${value == null ? "NULL" : typeof value}`);
+}
+function leafFromJson(entry, fnName) {
+  if (Array.isArray(entry)) {
+    if (entry.length < 3) {
+      throw new Error(`${fnName}: a leaf array must be [name, value, salt]`);
+    }
+    const [name, value, salt] = entry;
+    if (typeof name !== "string") {
+      throw new Error(`${fnName}: leaf name must be a string`);
+    }
+    return { name, value, salt };
+  }
+  if (entry !== null && typeof entry === "object") {
+    const o = entry;
+    if (typeof o.name !== "string") {
+      throw new Error(`${fnName}: leaf name must be a string`);
+    }
+    if (!("value" in o)) {
+      throw new Error(`${fnName}: leaf '${o.name}' is missing a value (pass value: null for a null-valued attribute)`);
+    }
+    return { name: o.name, value: o.value, salt: o.salt };
+  }
+  throw new Error(`${fnName}: each leaf must be a [name, value, salt] array or { name, value, salt } object`);
+}
+function parseLeaves(json, fnName) {
+  const parsed = JSON.parse(json);
+  if (!Array.isArray(parsed)) {
+    throw new Error(`${fnName}: expected a JSON array of leaves`);
+  }
+  return parsed.map((entry) => leafFromJson(entry, fnName));
+}
 var DETERMINISTIC_FLAGS = FunctionFlags.UTF8 | FunctionFlags.DETERMINISTIC;
 var NON_DETERMINISTIC_FLAGS = FunctionFlags.UTF8;
-function register(_db, _config = {}) {
+function register(_db, config = {}) {
+  const digestHasher = resolveHasher(configAlgorithm(config));
+  const digestEncoder = resolveOutputEncoder(configEncoding(config));
   const functions = [
     {
       schema: {
         name: "digest",
         numArgs: -1,
-        // Variable arguments: data, algorithm?, inputEncoding?, outputEncoding?
+        // Variadic over data fields: digest(f1, f2, ..., fN)
         flags: DETERMINISTIC_FLAGS,
         // digest is deterministic
+        // Bit-identical across peers/platforms — these digests are signed and persisted.
+        replicable: true,
+        returnType: { typeClass: "scalar", logicalType: TEXT_TYPE, nullable: false },
+        implementation: (...fields) => digestFields(fields, digestHasher, digestEncoder)
+      }
+    },
+    {
+      schema: {
+        name: "cid",
+        numArgs: -1,
+        // cid(data, codec?, hash?, base?) — trailing args optional
+        flags: DETERMINISTIC_FLAGS,
+        // Self-describing content address; signed/persisted, so byte-identical across peers.
+        replicable: true,
         returnType: { typeClass: "scalar", logicalType: TEXT_TYPE, nullable: false },
         implementation: (...args) => {
-          const [data, algorithm = "sha256", inputEncoding = "base64url", outputEncoding = "base64url"] = args;
-          return digest(data, algorithm, inputEncoding, outputEncoding);
+          const [data, codec = "raw", hash = "sha2-256", base = "base32"] = args;
+          return cid(toContentBytes(data, "cid"), codec, hash, base);
+        }
+      }
+    },
+    {
+      schema: {
+        name: "cid_v1",
+        numArgs: -1,
+        // cid_v1(digest, hash, codec?, base?) — hash required, trailing args optional
+        flags: DETERMINISTIC_FLAGS,
+        replicable: true,
+        returnType: { typeClass: "scalar", logicalType: TEXT_TYPE, nullable: false },
+        implementation: (...args) => {
+          const [digest, hash, codec = "raw", base = "base32"] = args;
+          if (hash == null) {
+            throw new Error("cid_v1: 'hash' argument is required (the multihash code asserting which algorithm produced the digest)");
+          }
+          return cidV1(toContentBytes(digest, "cid_v1"), hash, codec, base);
+        }
+      }
+    },
+    {
+      schema: {
+        name: "cid_decode",
+        numArgs: 1,
+        // cid_decode(cid) -> JSON text { version, codec, hashCode, digest }
+        flags: DETERMINISTIC_FLAGS,
+        replicable: true,
+        returnType: { typeClass: "scalar", logicalType: TEXT_TYPE, nullable: false },
+        implementation: (value) => {
+          const parts = cidDecode(value);
+          return JSON.stringify({
+            version: parts.version,
+            codec: parts.codec,
+            hashCode: parts.hashCode,
+            digest: toString(parts.digest, "base64url")
+          });
+        }
+      }
+    },
+    {
+      schema: {
+        name: "set_commit",
+        numArgs: 1,
+        // set_commit(leaves_json) -> root over a JSON array of [name, value, salt] leaves
+        flags: DETERMINISTIC_FLAGS,
+        // The root is signed and persisted as a commitment, same bar as `digest`.
+        replicable: true,
+        returnType: { typeClass: "scalar", logicalType: TEXT_TYPE, nullable: false },
+        implementation: (leavesJson) => {
+          if (typeof leavesJson !== "string") {
+            throw new Error("set_commit: expected a JSON TEXT array of [name, value, salt] leaves");
+          }
+          const leaves = parseLeaves(leavesJson, "set_commit");
+          return setCommit(leaves, digestHasher, digestEncoder);
+        }
+      }
+    },
+    {
+      schema: {
+        name: "set_verify",
+        numArgs: 3,
+        // set_verify(root, disclosed_json, hidden_json) -> BOOLEAN
+        flags: DETERMINISTIC_FLAGS,
+        // pure, not persisted — matches `verify` (no `replicable`)
+        returnType: { typeClass: "scalar", logicalType: BOOLEAN_TYPE, nullable: false },
+        implementation: (root, disclosedJson, hiddenJson) => {
+          try {
+            if (typeof root !== "string" && !(root instanceof Uint8Array)) return false;
+            if (typeof disclosedJson !== "string" || typeof hiddenJson !== "string") return false;
+            const disclosed = parseLeaves(disclosedJson, "set_verify");
+            const hidden = JSON.parse(hiddenJson);
+            if (!Array.isArray(hidden) || !hidden.every((h) => typeof h === "string")) return false;
+            return setVerify(root, { disclosed, hidden }, digestHasher, digestEncoder);
+          } catch {
+            return false;
+          }
         }
       }
     },
@@ -150,6 +553,15 @@ function register(_db, _config = {}) {
         // Variable arguments: data, privateKey, curve?, inputEncoding?, keyEncoding?, outputEncoding?
         flags: DETERMINISTIC_FLAGS,
         // sign is deterministic (same key + data = same signature)
+        // Security: passing a private key as the second argument (literal or bound
+        // parameter) is SAFE with respect to replication. The Quereus engine rebuilds
+        // the replicated statement from evaluated column values, not from source SQL
+        // text, so the key argument is discarded before the record is written — peers
+        // re-execute `INSERT ... VALUES (<signature>)`, never `sign(..., key)`. What
+        // to avoid: storing a raw private key AS a column value, since any persisted
+        // column value is replicated. See docs/transactions.md § "Secrets and the
+        // replicated statement record" and the regression guard in
+        // quereus-plugin-optimystic/test/statement-secret-arg-redaction.spec.ts.
         returnType: { typeClass: "scalar", logicalType: TEXT_TYPE, nullable: false },
         implementation: (...args) => {
           const [data, privateKey, curve = "secp256k1", inputEncoding = "base64url", keyEncoding = "base64url", outputEncoding = "base64url"] = args;