@suveren/gateway 0.7.4 → 0.8.0

package/node_modules/@hap/core/dist/index.js

@@ -30,9 +30,13 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  CanonicalValueError: () => CanonicalValueError,
   ContentBindingError: () => ContentBindingError,
+  MandateError: () => MandateError,
+  approvalSigningBytes: () => approvalSigningBytes,
   attestationId: () => attestationId,
   bindingAppliesTo: () => bindingAppliesTo,
+  buildMandateProjection: () => buildMandateProjection,
   canonicalBounds: () => canonicalBounds,
   canonicalContext: () => canonicalContext,
   canonicalFrame: () => canonicalFrame,
@@ -49,28 +53,38 @@ __export(index_exports, {
   computeIntentHash: () => computeIntentHash,
   contentCanonicalBytes: () => contentCanonicalBytes,
   decodeAttestationBlob: () => decodeAttestationBlob,
+  decodeDidKey: () => decodeDidKey,
   deriveIdentityLine: () => deriveIdentityLine,
   encodeAttestationBlob: () => encodeAttestationBlob,
+  encodeDidKey: () => encodeDidKey,
   frameHash: () => frameHash,
   getAllProfiles: () => getAllProfiles,
   getProfile: () => getProfile,
   intentDisclosureCanonicalBytes: () => intentDisclosureCanonicalBytes,
   isFieldBinding: () => isFieldBinding,
+  isKeyBearingDid: () => isKeyBearingDid,
   isV4Attestation: () => isV4Attestation,
   listProfiles: () => listProfiles,
+  mandateSigningBytes: () => mandateSigningBytes,
   registerProfile: () => registerProfile,
   selectBoundFields: () => selectBoundFields,
+  signApproval: () => signApproval,
+  signMandateProjection: () => signMandateProjection,
   validateBoundsParams: () => validateBoundsParams,
   validateContextParams: () => validateContextParams,
   validateFrameParams: () => validateFrameParams,
   validateSubject: () => validateSubject,
   verify: () => verify,
+  verifyApproval: () => verifyApproval,
   verifyAttestation: () => verifyAttestation,
   verifyAttestationSignature: () => verifyAttestationSignature,
   verifyAttestationV4: () => verifyAttestationV4,
   verifyBoundsHash: () => verifyBoundsHash,
   verifyContextHash: () => verifyContextHash,
-  verifyFrameHash: () => verifyFrameHash
+  verifyFrameHash: () => verifyFrameHash,
+  verifyOwnerMandate: () => verifyOwnerMandate,
+  verifyOwnerMandates: () => verifyOwnerMandates,
+  verifyReceiptSignature: () => verifyReceiptSignature
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -227,9 +241,9 @@ function computeIntentDisclosureHash(intentCiphertext, approversFrozen) {
 }
 
 // src/identity.ts
-function validateSubject(subject) {
+function validateSubject(subject, opts) {
   const errors = [];
-  const { did, assurance, method, trust_root, verifier, disclose, owner_signature } = subject;
+  const { did, assurance, method, trust_root, verifier, disclose } = subject;
   if (!did) errors.push("subject.did is required");
   if (assurance === "low") {
     if (method !== "self_declared") errors.push(`low assurance requires method "self_declared", got "${method}"`);
@@ -242,7 +256,10 @@ function validateSubject(subject) {
     } else if (method === "eudi") {
       if (trust_root !== "external") errors.push('eudi requires trust_root "external"');
       if (!verifier) errors.push("eudi requires a verifier");
-      if (!owner_signature) errors.push("eudi requires an owner_signature");
+      if (opts?.ownerMandates !== void 0) {
+        const entry = opts.ownerMandates.find((m) => m.did === did && m.binding === "eudi");
+        if (!entry) errors.push('eudi requires an owner_mandates entry with binding "eudi" for this DID');
+      }
     } else {
       errors.push(`high assurance requires method "as_vouched" or "eudi", got "${method}"`);
     }
@@ -360,15 +377,51 @@ function validateContextParams(params, profile) {
   }
   return { valid: errors.length === 0, errors };
 }
+var CanonicalValueError = class extends Error {
+  code;
+  field;
+  constructor(code, field, message) {
+    super(message);
+    this.name = "CanonicalValueError";
+    this.code = code;
+    this.field = field;
+  }
+};
+function percentEncodeCanonicalValue(raw) {
+  const bytes = new TextEncoder().encode(raw);
+  let out = "";
+  for (const b of bytes) {
+    if (b === 61 || b === 37 || b < 32 || b > 126) {
+      out += "%" + b.toString(16).toUpperCase().padStart(2, "0");
+    } else {
+      out += String.fromCharCode(b);
+    }
+  }
+  return out;
+}
+function canonicalRecords(params, keyOrder, code) {
+  const lines = [];
+  for (const key of keyOrder) {
+    const value = params[key];
+    if (value === void 0 || value === null) continue;
+    const raw = String(value);
+    if (raw.includes("\n") || raw.includes("\r")) {
+      throw new CanonicalValueError(
+        code,
+        key,
+        `Value for "${key}" contains a raw newline or carriage return. Refusing: a hash over stripped or normalized input would not represent what was authorized.`
+      );
+    }
+    lines.push(`${key}=${percentEncodeCanonicalValue(raw)}`);
+  }
+  return lines.join("\n");
+}
 function canonicalBounds(params, profile) {
   const validation = validateBoundsParams(params, profile);
   if (!validation.valid) {
     throw new Error(`Invalid bounds parameters: ${validation.errors.join("; ")}`);
   }
-  const lines = profile.boundsSchema.keyOrder.map(
-    (key) => `${key}=${String(params[key])}`
-  );
-  return lines.join("\n");
+  return canonicalRecords(params, profile.boundsSchema.keyOrder, "BOUNDS_INVALID_VALUE");
 }
 function canonicalContext(params, profile) {
   if (!profile.contextSchema || Object.keys(profile.contextSchema.fields).length === 0) {
@@ -378,10 +431,7 @@ function canonicalContext(params, profile) {
   if (!validation.valid) {
     throw new Error(`Invalid context parameters: ${validation.errors.join("; ")}`);
   }
-  const lines = profile.contextSchema.keyOrder.map(
-    (key) => `${key}=${String(params[key])}`
-  );
-  return lines.join("\n");
+  return canonicalRecords(params, profile.contextSchema.keyOrder, "CONTEXT_INVALID_VALUE");
 }
 function computeBoundsHash(params, profile) {
   const canonical = canonicalBounds(params, profile);
@@ -511,7 +561,17 @@ async function verify(request, publicKeyHex, now = Math.floor(Date.now() / 1e3),
     return verifyV3(request, profile, publicKeyHex, now, executionLog, errors);
   }
 }
+function noAttestationSupplied(request) {
+  return !Array.isArray(request.attestations) || request.attestations.length === 0;
+}
+function noAttestationResult() {
+  return {
+    approved: false,
+    errors: [{ code: "MALFORMED_ATTESTATION", message: "No attestation supplied \u2014 nothing to verify" }]
+  };
+}
 async function verifyV3(request, profile, publicKeyHex, now, executionLog, errors) {
+  if (noAttestationSupplied(request)) return noAttestationResult();
   let expectedFrameHash;
   try {
     expectedFrameHash = computeFrameHash(request.frame, profile);
@@ -572,6 +632,7 @@ async function verifyV3(request, profile, publicKeyHex, now, executionLog, error
   return { approved: true };
 }
 async function verifyV4(request, profile, publicKeyHex, now, executionLog) {
+  if (noAttestationSupplied(request)) return noAttestationResult();
   const errors = [];
   const bounds = request.frame;
   const context = request.context;
@@ -945,11 +1006,208 @@ function resolveCumulativeFields(request, profile, executionLog, now) {
   }
   return errors;
 }
+
+// src/did-key.ts
+var B58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+var B58_MAP = {};
+for (let i = 0; i < B58_ALPHABET.length; i++) B58_MAP[B58_ALPHABET[i]] = i;
+var ED25519_MULTICODEC = Uint8Array.from([237, 1]);
+var ED25519_KEY_BYTES = 32;
+function base58btcEncode(bytes) {
+  let zeros = 0;
+  while (zeros < bytes.length && bytes[zeros] === 0) zeros++;
+  const digits = [];
+  for (let i = zeros; i < bytes.length; i++) {
+    let carry = bytes[i];
+    for (let j = 0; j < digits.length; j++) {
+      carry += digits[j] * 256;
+      digits[j] = carry % 58;
+      carry = carry / 58 | 0;
+    }
+    while (carry > 0) {
+      digits.push(carry % 58);
+      carry = carry / 58 | 0;
+    }
+  }
+  let out = "1".repeat(zeros);
+  for (let i = digits.length - 1; i >= 0; i--) out += B58_ALPHABET[digits[i]];
+  return out;
+}
+function base58btcDecode(s) {
+  let zeros = 0;
+  while (zeros < s.length && s[zeros] === "1") zeros++;
+  const bytes = [];
+  for (let i = zeros; i < s.length; i++) {
+    const val = B58_MAP[s[i]];
+    if (val === void 0) throw new Error(`invalid base58 character "${s[i]}"`);
+    let carry = val;
+    for (let j = 0; j < bytes.length; j++) {
+      carry += bytes[j] * 58;
+      bytes[j] = carry & 255;
+      carry >>= 8;
+    }
+    while (carry > 0) {
+      bytes.push(carry & 255);
+      carry >>= 8;
+    }
+  }
+  const out = new Uint8Array(zeros + bytes.length);
+  for (let i = 0; i < bytes.length; i++) out[zeros + i] = bytes[bytes.length - 1 - i];
+  return out;
+}
+function encodeDidKey(publicKey) {
+  if (publicKey.length !== ED25519_KEY_BYTES) {
+    throw new Error(`INVALID_KEY: expected ${ED25519_KEY_BYTES} bytes, got ${publicKey.length}`);
+  }
+  const prefixed = new Uint8Array(ED25519_MULTICODEC.length + publicKey.length);
+  prefixed.set(ED25519_MULTICODEC, 0);
+  prefixed.set(publicKey, ED25519_MULTICODEC.length);
+  return `did:key:z${base58btcEncode(prefixed)}`;
+}
+function decodeDidKey(did) {
+  if (!did.startsWith("did:key:z")) {
+    throw new Error(`NOT_KEY_BEARING: ${JSON.stringify(did)} is not a base58btc did:key`);
+  }
+  let decoded;
+  try {
+    decoded = base58btcDecode(did.slice("did:key:z".length));
+  } catch (err) {
+    throw new Error(`NOT_KEY_BEARING: ${err.message}`);
+  }
+  if (decoded.length !== ED25519_MULTICODEC.length + ED25519_KEY_BYTES || decoded[0] !== ED25519_MULTICODEC[0] || decoded[1] !== ED25519_MULTICODEC[1]) {
+    throw new Error("NOT_KEY_BEARING: not an ed25519-pub multicodec payload");
+  }
+  return decoded.slice(ED25519_MULTICODEC.length);
+}
+function isKeyBearingDid(did) {
+  try {
+    decodeDidKey(did);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/mandate.ts
+var ed2 = __toESM(require("@noble/ed25519"));
+var MandateError = class extends Error {
+  constructor(code, message) {
+    super(`${code}: ${message}`);
+    this.code = code;
+    this.name = "MandateError";
+  }
+};
+function buildMandateProjection(payload, entry) {
+  const { profile_id, bounds_hash, context_hash, execution_context_hash, gate_content_hashes, commitment_mode, expires_at } = payload;
+  if (!bounds_hash || !context_hash || !commitment_mode) {
+    throw new MandateError("MALFORMED_ATTESTATION", "mandate projection requires bounds_hash, context_hash and commitment_mode");
+  }
+  const projection = {
+    typ: "HAP-mandate",
+    version: "0.6",
+    profile_id,
+    owner_did: entry.did,
+    bounds_hash,
+    context_hash,
+    execution_context_hash,
+    gate_content_hashes,
+    commitment_mode,
+    expires_at,
+    nonce: entry.nonce
+  };
+  if (payload.intent_disclosure_hash !== void 0) {
+    projection.intent_disclosure_hash = payload.intent_disclosure_hash;
+  }
+  return projection;
+}
+function mandateSigningBytes(projection) {
+  return new TextEncoder().encode(canonicalize(projection));
+}
+function approvalSigningBytes(approval) {
+  return new TextEncoder().encode(canonicalize(approval));
+}
+function base64urlToBytes(s) {
+  const base64 = s.replace(/-/g, "+").replace(/_/g, "/");
+  const padding = base64.length % 4 === 0 ? "" : "=".repeat(4 - base64.length % 4);
+  return new Uint8Array(Buffer.from(base64 + padding, "base64"));
+}
+function bytesToBase64url(bytes) {
+  return Buffer.from(bytes).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+async function signMandateProjection(projection, privateKey) {
+  const sig = await ed2.signAsync(mandateSigningBytes(projection), privateKey);
+  return bytesToBase64url(sig);
+}
+async function signApproval(approval, privateKey) {
+  const sig = await ed2.signAsync(approvalSigningBytes(approval), privateKey);
+  return bytesToBase64url(sig);
+}
+async function verifyOwnerMandate(attestation, entry) {
+  const owners = attestation.payload.resolved_owners ?? [];
+  if (!owners.includes(entry.did)) {
+    throw new MandateError("OWNER_NOT_RESOLVED", `signing DID ${entry.did} is not in resolved_owners`);
+  }
+  if (entry.alg !== "EdDSA") {
+    throw new MandateError("MANDATE_SIGNATURE_INVALID", `alg ${entry.alg} disagrees with the DID's key type (DID is authoritative)`);
+  }
+  let publicKey;
+  try {
+    publicKey = decodeDidKey(entry.did);
+  } catch (err) {
+    throw new MandateError("NOT_KEY_BEARING", err.message);
+  }
+  const projection = buildMandateProjection(attestation.payload, entry);
+  const ok = await ed2.verifyAsync(base64urlToBytes(entry.signature), mandateSigningBytes(projection), publicKey);
+  if (!ok) {
+    throw new MandateError("MANDATE_SIGNATURE_INVALID", `owner mandate signature by ${entry.did} does not verify`);
+  }
+}
+async function verifyOwnerMandates(attestation) {
+  const entries = attestation.payload.owner_mandates ?? [];
+  for (const entry of entries) {
+    await verifyOwnerMandate(attestation, entry);
+  }
+  return entries;
+}
+async function verifyApproval(approval, signature, signerDid) {
+  let publicKey;
+  try {
+    publicKey = decodeDidKey(signerDid);
+  } catch (err) {
+    throw new MandateError("NOT_KEY_BEARING", err.message);
+  }
+  const ok = await ed2.verifyAsync(base64urlToBytes(signature), approvalSigningBytes(approval), publicKey);
+  if (!ok) {
+    throw new MandateError("APPROVAL_SIGNATURE_INVALID", `approval signature by ${signerDid} does not verify`);
+  }
+}
+
+// src/receipt.ts
+var ed3 = __toESM(require("@noble/ed25519"));
+async function verifyReceiptSignature(receipt, publicKeyHex) {
+  const { signature, ...unsigned } = receipt;
+  if (!signature) {
+    throw new Error("INVALID_SIGNATURE: receipt carries no signature");
+  }
+  const bytes = new TextEncoder().encode(canonicalize(unsigned));
+  const base64 = signature.replace(/-/g, "+").replace(/_/g, "/");
+  const padding = base64.length % 4 === 0 ? "" : "=".repeat(4 - base64.length % 4);
+  const sigBytes = new Uint8Array(Buffer.from(base64 + padding, "base64"));
+  const publicKeyBytes = new Uint8Array(Buffer.from(publicKeyHex, "hex"));
+  const ok = await ed3.verifyAsync(sigBytes, bytes, publicKeyBytes).catch(() => false);
+  if (!ok) {
+    throw new Error("INVALID_SIGNATURE: receipt signature verification failed");
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CanonicalValueError,
   ContentBindingError,
+  MandateError,
+  approvalSigningBytes,
   attestationId,
   bindingAppliesTo,
+  buildMandateProjection,
   canonicalBounds,
   canonicalContext,
   canonicalFrame,
@@ -966,26 +1224,36 @@ function resolveCumulativeFields(request, profile, executionLog, now) {
   computeIntentHash,
   contentCanonicalBytes,
   decodeAttestationBlob,
+  decodeDidKey,
   deriveIdentityLine,
   encodeAttestationBlob,
+  encodeDidKey,
   frameHash,
   getAllProfiles,
   getProfile,
   intentDisclosureCanonicalBytes,
   isFieldBinding,
+  isKeyBearingDid,
   isV4Attestation,
   listProfiles,
+  mandateSigningBytes,
   registerProfile,
   selectBoundFields,
+  signApproval,
+  signMandateProjection,
   validateBoundsParams,
   validateContextParams,
   validateFrameParams,
   validateSubject,
   verify,
+  verifyApproval,
   verifyAttestation,
   verifyAttestationSignature,
   verifyAttestationV4,
   verifyBoundsHash,
   verifyContextHash,
-  verifyFrameHash
+  verifyFrameHash,
+  verifyOwnerMandate,
+  verifyOwnerMandates,
+  verifyReceiptSignature
 });