@emilia-protocol/gate 0.18.2 → 0.20.0

package/src/reliance-risk-crypto.ts

@@ -0,0 +1,114 @@
+// SPDX-License-Identifier: Apache-2.0
+import crypto from 'node:crypto';
+import { canonicalize, hashCanonical } from './execution-binding.js';
+
+export type RiskRecord = Record<string, any>;
+export type TrustedRiskKeys = Record<string, { issuer_id: string; public_key: string }>;
+
+export const RISK_DIGEST = /^sha256:[0-9a-f]{64}$/;
+export const RISK_CAID = /^caid:1:[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)*\.[1-9][0-9]*:jcs-sha256:[A-Za-z0-9_-]{43}$/;
+export const RISK_ID = /^[A-Za-z0-9][A-Za-z0-9:_.@/+\-]{0,511}$/;
+const RFC3339 = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,9}))?Z$/;
+
+export function riskRecord(value: unknown): value is RiskRecord {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) return false;
+  return Reflect.ownKeys(value).every((key) => {
+    if (typeof key !== 'string') return false;
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    return descriptor?.enumerable === true && Object.hasOwn(descriptor, 'value');
+  });
+}
+
+export function riskExact(value: unknown, keys: readonly string[]): value is RiskRecord {
+  return riskRecord(value) && Reflect.ownKeys(value).length === keys.length
+    && keys.every((key) => Object.hasOwn(value, key));
+}
+
+export function riskIdentifier(value: unknown): value is string {
+  return typeof value === 'string' && RISK_ID.test(value);
+}
+
+export function riskInstant(value: unknown): number {
+  if (typeof value !== 'string') return NaN;
+  const match = value.match(RFC3339);
+  if (!match) return NaN;
+  const parsed = Date.parse(value);
+  if (!Number.isFinite(parsed)) return NaN;
+  return new Date(parsed).toISOString().slice(0, 19) === value.slice(0, 19) ? parsed : NaN;
+}
+
+export function riskDigest(value: unknown): string {
+  return `sha256:${hashCanonical(value)}`;
+}
+
+export function riskClone<T>(value: T): T {
+  return JSON.parse(canonicalize(value));
+}
+
+export function riskFreeze<T>(value: T): T {
+  if (!value || typeof value !== 'object' || Object.isFrozen(value)) return value;
+  Object.freeze(value);
+  for (const child of Object.values(value as RiskRecord)) riskFreeze(child);
+  return value;
+}
+
+function signingBytes(version: string, body: RiskRecord): Buffer {
+  return Buffer.from(`${version}\0${canonicalize(body)}`, 'utf8');
+}
+
+export function signRiskBody(
+  version: string,
+  bodyInput: RiskRecord,
+  signer: { issuer_id: string; key_id: string; private_key: crypto.KeyLike },
+): RiskRecord {
+  const key = signer.private_key instanceof crypto.KeyObject
+    ? signer.private_key : crypto.createPrivateKey(signer.private_key);
+  if (key.asymmetricKeyType !== 'ed25519') throw new TypeError('risk artifact signing key must be Ed25519');
+  if (!riskIdentifier(signer.issuer_id) || !riskIdentifier(signer.key_id)) throw new TypeError('risk artifact issuer is invalid');
+  const body = riskClone({ ...bodyInput, issuer: { id: signer.issuer_id, key_id: signer.key_id } });
+  const bodyDigest = riskDigest(body);
+  const proof = {
+    algorithm: 'Ed25519',
+    key_id: signer.key_id,
+    body_digest: bodyDigest,
+    signature_b64u: crypto.sign(null, signingBytes(version, body), key).toString('base64url'),
+  };
+  return riskFreeze({ ...body, proof });
+}
+
+export function verifyRiskBody(
+  artifact: unknown,
+  version: string,
+  trustedKeys: TrustedRiskKeys | undefined,
+): { valid: boolean; reason: string | null; body: RiskRecord | null; artifact_digest: string | null } {
+  const refuse = (reason: string) => ({ valid: false, reason, body: null, artifact_digest: null });
+  try {
+    if (!riskRecord(artifact) || !riskRecord(artifact.proof) || !riskRecord(artifact.issuer)) return refuse('artifact_shape_invalid');
+    const proof = artifact.proof;
+    const { proof: _proof, ...body } = artifact;
+    if (artifact['@version'] !== version || !riskExact(artifact.issuer, ['id', 'key_id'])
+        || !riskIdentifier(artifact.issuer.id) || !riskIdentifier(artifact.issuer.key_id)
+        || !riskExact(proof, ['algorithm', 'key_id', 'body_digest', 'signature_b64u'])
+        || proof.algorithm !== 'Ed25519' || proof.key_id !== artifact.issuer.key_id
+        || typeof proof.body_digest !== 'string' || !RISK_DIGEST.test(proof.body_digest)
+        || typeof proof.signature_b64u !== 'string' || !/^[A-Za-z0-9_-]+$/.test(proof.signature_b64u)) {
+      return refuse('artifact_signature_envelope_invalid');
+    }
+    if (riskDigest(body) !== proof.body_digest) return refuse('digest_mismatch');
+    const pin = trustedKeys?.[artifact.issuer.key_id];
+    if (!pin || pin.issuer_id !== artifact.issuer.id) return refuse('issuer_untrusted');
+    const keyBytes = Buffer.from(pin.public_key, 'base64url');
+    if (keyBytes.toString('base64url') !== pin.public_key) return refuse('pinned_key_invalid');
+    const key = crypto.createPublicKey({ key: keyBytes, type: 'spki', format: 'der' });
+    if (key.asymmetricKeyType !== 'ed25519') return refuse('pinned_key_invalid');
+    const signature = Buffer.from(proof.signature_b64u, 'base64url');
+    if (signature.length !== 64 || signature.toString('base64url') !== proof.signature_b64u
+        || !crypto.verify(null, signingBytes(version, body), key, signature)) return refuse('signature_invalid');
+    return { valid: true, reason: null, body, artifact_digest: riskDigest(artifact) };
+  } catch {
+    return refuse('artifact_invalid');
+  }
+}
+

package/src/remedy-program.ts

@@ -1035,61 +1035,70 @@ export function createRemedyProgramKernel(options: RemedyProgramKernelConfig) {
     const loaded = await load(value.tenantId, value.instanceId);
     if (!loaded.ok) return loaded;
     const state = loaded.state as DataRecord;
+    const decided = (ok: boolean, reason?: string, fields: DataRecord = {}) => pass({
+      ok,
+      ...(reason ? { reason } : {}),
+      program_digest: state.remedy_profile_digest,
+      ...fields,
+    }) as RemedyProgramResult;
     const requestDigest = digest(value);
-    if (state.status === 'original_proved_no_effect') return fail('remedy_case_terminal');
+    if (state.status === 'original_proved_no_effect') return decided(false, 'remedy_case_terminal');
     if (state.original.outcome === 'indeterminate'
         && state.original_reconciliation?.outcome !== 'executed') {
-      return fail('original_effect_indeterminate');
+      return decided(false, 'original_effect_indeterminate');
     }
     const priorOperation = allAttempts(state).find((attempt) => (
       attempt.remedy_operation_id === value.authorization.remedy_operation_id
     ));
     if (priorOperation) {
       return priorOperation.request_digest === requestDigest
-        ? pass({ ok: true, idempotent: true, state }) as RemedyProgramResult
-        : fail('remedy_operation_replayed');
+        ? decided(true, undefined, { idempotent: true, state })
+        : decided(false, 'remedy_operation_replayed');
+    }
+    if (state.remaining_units === 0) return decided(false, 'remedy_limit_exhausted');
+    if (['remedied', 'resolved_no_remedy'].includes(state.status)) {
+      return decided(false, 'remedy_case_terminal');
     }
-    if (state.remaining_units === 0) return fail('remedy_limit_exhausted');
-    if (['remedied', 'resolved_no_remedy'].includes(state.status)) return fail('remedy_case_terminal');
     if (state.active_remedy !== null) {
       return state.status === 'remedy_indeterminate'
-        ? fail('remedy_indeterminate') : fail('remedy_already_active');
+        ? decided(false, 'remedy_indeterminate')
+        : decided(false, 'remedy_already_active');
     }
     if (!['disputed', 'partially_remedied'].includes(state.status) || state.dispute === null) {
-      return fail('remedy_case_unavailable');
+      return decided(false, 'remedy_case_unavailable');
     }
     if (evidenceUsed(state, value.authorization.evidence_id, value.authorization.evidence_digest)) {
-      return fail('evidence_replayed');
+      return decided(false, 'evidence_replayed');
     }
     const at = transitionTime(state);
-    if (typeof at !== 'number') return at;
+    if (typeof at !== 'number') return decided(false, at.reason);
     if (instant(value.authorization.authorized_at) > at
         || instant(value.authorization.authorized_at) < instant(state.dispute.opened_at)) {
-      return fail('remedy_authorization_time_invalid');
+      return decided(false, 'remedy_authorization_time_invalid');
     }
     const disputeRemaining = state.dispute.requested_units - state.remedied_units;
     if (value.authorization.units > state.remaining_units || value.authorization.units > disputeRemaining) {
-      return fail('remedy_limit_exceeded');
+      return decided(false, 'remedy_limit_exceeded');
     }
     if (value.authorization.remedy_operation_id === state.original.operation_id
         || value.authorization.remedy_action_digest === state.original.action_digest) {
-      return fail('remedy_must_be_compensating');
+      return decided(false, 'remedy_must_be_compensating');
     }
     const verified = await invoke(verifyRemedyAuthorization, {
       authorization: clone(value.authorization), expected: expectedContext(state),
     });
     if (!verified || verified.ok !== true || !exactKeys(verified, VERIFIED_AUTHORIZATION_KEYS)) {
-      return fail('remedy_authorization_invalid');
+      return decided(false, 'remedy_authorization_invalid');
     }
     if (!validRemedyOwner(verified as DataRecord)) {
-      return fail('remedy_owner_invalid');
+      return decided(false, 'remedy_owner_invalid');
     }
     if ([...AUTHORIZATION_KEYS].some((key) => !same(verified[key], value.authorization[key]))
         || verified.dispute_id !== state.dispute.dispute_id
         || verified.original_operation_id !== state.original.operation_id
         || verified.destination_binding_digest !== state.destination_binding_digest
         || verified.unit !== state.unit) {
-      return fail('remedy_authorization_binding_mismatch');
+      return decided(false, 'remedy_authorization_binding_mismatch');
     }
     const next = touch(state, at);
     next.status = 'remedy_authorized';
@@ -1108,7 +1117,9 @@ export function createRemedyProgramKernel(options: RemedyProgramKernelConfig) {
     };
     consumeEvidence(next, verified.evidence_id, verified.evidence_digest);
     const committed = await commit(state, next);
-    return committed.ok ? pass({ ok: true, state: committed.state }) as RemedyProgramResult : committed;
+    return committed.ok
+      ? decided(true, undefined, { state: committed.state })
+      : decided(false, committed.reason);
   }
 
   async function claimRemedy(input: unknown): Promise<RemedyProgramResult> {