@twin3-ai/agent-id 0.1.0

package/trust-verifier.js

@@ -0,0 +1,206 @@
+"use strict";
+
+const crypto = require("crypto");
+
+const CLAIM_SCHEMA = "agentx-trust-claim-v1";
+const EVIDENCE_SCHEMA = "agentx-evidence-attestation-v1";
+const RECEIPT_SCHEMA = "agentx-capability-runtime-receipt-v1";
+const BUNDLE_SCHEMA = "agentx-portable-trust-bundle-v1";
+const RUNTIME_RECEIPT_TTL = 24 * 60 * 60;
+
+function sorted(value) {
+  if (Array.isArray(value)) return value.map(sorted);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.keys(value).sort().map(key => [key, sorted(value[key])]));
+  }
+  return value;
+}
+
+function canonical(value) {
+  return Buffer.from(JSON.stringify(sorted(value)), "utf8");
+}
+
+function contentHash(value) {
+  return `sha256:${crypto.createHash("sha256").update(canonical(value)).digest("hex")}`;
+}
+
+function without(value, keys) {
+  return Object.fromEntries(Object.entries(value || {}).filter(([key]) => !keys.has(key)));
+}
+
+function verifySignature(publicKey, payload, proofValue) {
+  try {
+    return crypto.verify(null, canonical(payload), publicKey, Buffer.from(String(proofValue || ""), "base64url"));
+  } catch {
+    return false;
+  }
+}
+
+function evidencePayload(evidence) {
+  return without(evidence, new Set(["proof"]));
+}
+
+function evidenceIdPayload(evidence) {
+  return without(evidence, new Set(["evidence_id", "proof"]));
+}
+
+function verifyEvidenceAttestation(evidence, claimSubject, publicKeys, now) {
+  if (!["customer_signed", "independent_public", "external_approval"].includes(evidence?.origin)) return [];
+  if (evidence?.schema !== EVIDENCE_SCHEMA) return ["evidence_signature_missing"];
+  const failures = [];
+  if (JSON.stringify(sorted(evidence?.subject || {})) !== JSON.stringify(sorted(claimSubject || {}))) failures.push("evidence_subject_mismatch");
+  const verifierId = evidence?.verifier?.id || "";
+  if (!verifierId || evidence?.verifier_id !== verifierId) failures.push("evidence_verifier_mismatch");
+  const expectedId = `evd_${contentHash(evidenceIdPayload(evidence)).slice(7, 31)}`;
+  if (evidence?.evidence_id !== expectedId) failures.push("evidence_id_mismatch");
+  const publicKey = publicKeys?.[verifierId];
+  if (!publicKey) failures.push("evidence_verifier_key_missing");
+  else if (!verifySignature(publicKey, evidencePayload(evidence), evidence?.proof?.proof_value)) failures.push("evidence_signature_invalid");
+  const observedAt = Number(evidence?.observed_at || 0);
+  if (observedAt <= 0 || observedAt > now) failures.push("evidence_time_invalid");
+  return failures;
+}
+
+function evidenceLevel(evidence, verifiedEvidenceIds = []) {
+  const rows = Array.isArray(evidence) ? evidence : [];
+  const verified = new Set(verifiedEvidenceIds);
+  if (rows.some(row => row?.origin === "external_approval" && verified.has(row?.evidence_id))) return "externally_approved";
+  if (rows.some(row => row?.origin === "independent_public" && verified.has(row?.evidence_id))) return "independently_verified";
+  if (rows.some(row => row?.origin === "customer_signed" && verified.has(row?.evidence_id))) return "customer_attested";
+  if (rows.some(row => row?.origin === "issuer_verified")) return "issuer_verified";
+  return "declared";
+}
+
+function verifyClaim(claim, publicKeys, now, revocations = [], conflicts = []) {
+  const failureCodes = [];
+  if (!claim || claim.schema !== CLAIM_SCHEMA) {
+    return { status: "blocked", integrity_ok: false, failure_codes: ["invalid_claim_schema"], evidence_level: "declared" };
+  }
+  const unsigned = without(claim, new Set(["claim_hash", "proof"]));
+  if (claim.claim_hash !== contentHash(unsigned)) failureCodes.push("claim_hash_mismatch");
+  const issuerId = claim?.issuer?.id || "";
+  const publicKey = publicKeys?.[issuerId];
+  if (!publicKey) failureCodes.push("issuer_key_missing");
+  else if (!verifySignature(publicKey, { ...unsigned, claim_hash: claim.claim_hash }, claim?.proof?.proof_value)) failureCodes.push("claim_signature_invalid");
+  const issuedAt = Number(claim.issued_at || 0);
+  const expiresAt = Number(claim.expires_at || 0);
+  if (issuedAt <= 0 || expiresAt <= issuedAt || issuedAt > now) failureCodes.push("claim_lifetime_invalid");
+  if (revocations.some(row => row?.claim_id === claim.claim_id && Number(row?.revoked_at || 0) <= now)) failureCodes.push("claim_revoked");
+  if (conflicts.some(row => Array.isArray(row?.claim_ids) && row.claim_ids.includes(claim.claim_id))) failureCodes.push("claim_conflicted");
+  const verifiedEvidenceIds = [];
+  for (const evidence of claim.evidence || []) {
+    const evidenceFailures = verifyEvidenceAttestation(evidence, claim.subject, publicKeys, now);
+    if (["independent_public", "external_approval"].includes(evidence?.origin) && evidence?.verifier_id === issuerId) {
+      evidenceFailures.push("evidence_verifier_not_independent");
+    }
+    failureCodes.push(...evidenceFailures);
+    if (!evidenceFailures.length && evidence?.schema === EVIDENCE_SCHEMA) verifiedEvidenceIds.push(evidence.evidence_id);
+  }
+  const blocking = new Set([
+    "claim_hash_mismatch", "issuer_key_missing", "claim_signature_invalid", "claim_lifetime_invalid",
+    "claim_revoked", "claim_conflicted", "evidence_signature_missing", "evidence_subject_mismatch",
+    "evidence_attestation_invalid", "evidence_verifier_mismatch", "evidence_id_mismatch",
+    "evidence_verifier_key_missing", "evidence_signature_invalid", "evidence_time_invalid",
+    "evidence_verifier_not_independent"
+  ]);
+  let status;
+  if (failureCodes.some(code => blocking.has(code))) status = "blocked";
+  else if (now >= expiresAt) {
+    failureCodes.push("claim_expired");
+    status = "review";
+  } else {
+    const level = evidenceLevel(claim.evidence, verifiedEvidenceIds);
+    status = ["independently_verified", "externally_approved"].includes(level) ? "verified" : "observed";
+  }
+  return {
+    claim_id: claim.claim_id,
+    claim_type: claim.claim_type,
+    status,
+    integrity_ok: !failureCodes.some(code => blocking.has(code)),
+    evidence_level: evidenceLevel(claim.evidence, verifiedEvidenceIds),
+    failure_codes: failureCodes,
+    expires_at: expiresAt
+  };
+}
+
+function verifyRuntimeReceipt(receipt, claim, publicKeys, now) {
+  const failures = [];
+  if (!receipt || receipt.schema !== RECEIPT_SCHEMA) return ["runtime_receipt_schema_invalid"];
+  if (receipt.claim_id !== claim.claim_id) return ["runtime_claim_mismatch"];
+  if (receipt.endpoint !== claim?.statement?.endpoint) failures.push("runtime_endpoint_mismatch");
+  const unsigned = without(receipt, new Set(["receipt_hash", "proof"]));
+  if (receipt.receipt_hash !== contentHash(unsigned)) failures.push("runtime_receipt_hash_mismatch");
+  const verifierId = receipt?.verifier?.id || "";
+  if (verifierId === (claim?.issuer?.id || "")) failures.push("runtime_verifier_not_independent");
+  const publicKey = publicKeys?.[verifierId];
+  if (!publicKey) failures.push("runtime_verifier_key_missing");
+  else if (!verifySignature(publicKey, { ...unsigned, receipt_hash: receipt.receipt_hash }, receipt?.proof?.proof_value)) failures.push("runtime_receipt_signature_invalid");
+  const observedAt = Number(receipt.observed_at || 0);
+  if (observedAt <= 0 || observedAt > now) failures.push("runtime_receipt_time_invalid");
+  else if (now - observedAt > RUNTIME_RECEIPT_TTL) failures.push("runtime_receipt_stale");
+  const httpStatus = Number(receipt.http_status || 0);
+  if (httpStatus < 200 || httpStatus >= 300) failures.push("runtime_call_failed");
+  if (!/^sha256:[0-9a-f]{64}$/.test(receipt.request_hash || "") || !/^sha256:[0-9a-f]{64}$/.test(receipt.response_hash || "")) failures.push("runtime_hash_invalid");
+  return failures;
+}
+
+function verifyCapabilityRuntime(claim, receipts, publicKeys, now, revocations = [], conflicts = []) {
+  const claimResult = verifyClaim(claim, publicKeys, now, revocations, conflicts);
+  if (claimResult.status === "blocked") return claimResult;
+  const matching = (receipts || []).filter(row => row?.claim_id === claim.claim_id);
+  if (!matching.length) return { ...claimResult, status: "review", failure_codes: [...claimResult.failure_codes, "runtime_receipt_missing"] };
+  const checked = matching.map(row => ({ row, failures: verifyRuntimeReceipt(row, claim, publicKeys, now) }));
+  const valid = checked.filter(item => item.failures.length === 0).map(item => item.row);
+  if (valid.length) {
+    const latest = valid.sort((a, b) => Number(b.observed_at) - Number(a.observed_at))[0];
+    return { ...claimResult, status: "verified", evidence_level: "independently_verified", failure_codes: [], runtime_receipt_id: latest.receipt_id, runtime_observed_at: latest.observed_at };
+  }
+  const failures = [...new Set(checked.flatMap(item => item.failures))].sort();
+  const blocking = new Set(["runtime_receipt_hash_mismatch", "runtime_receipt_signature_invalid", "runtime_verifier_key_missing", "runtime_verifier_not_independent", "runtime_endpoint_mismatch", "runtime_claim_mismatch"]);
+  return { ...claimResult, status: failures.some(code => blocking.has(code)) ? "blocked" : "review", failure_codes: failures };
+}
+
+function verifyPortableBundle(bundle, { now = Math.floor(Date.now() / 1000), requiredClaimTypes = [], revocations = [], conflicts = [] } = {}) {
+  const failureCodes = [];
+  if (!bundle || bundle.schema !== BUNDLE_SCHEMA) {
+    return { verdict: "block", offline_verifiable: false, failure_codes: ["invalid_bundle_schema"], verified_claims: 0 };
+  }
+  if (!Array.isArray(bundle.claims) || bundle.claims.some(row => !row || typeof row !== "object" || Array.isArray(row))) {
+    return { verdict: "block", offline_verifiable: false, failure_codes: ["invalid_bundle_claims"], verified_claims: 0 };
+  }
+  if (!Array.isArray(bundle.runtime_receipts) || bundle.runtime_receipts.some(row => !row || typeof row !== "object" || Array.isArray(row))) {
+    return { verdict: "block", offline_verifiable: false, failure_codes: ["invalid_bundle_receipts"], verified_claims: 0 };
+  }
+  if (!bundle.public_keys || typeof bundle.public_keys !== "object" || Array.isArray(bundle.public_keys)) {
+    return { verdict: "block", offline_verifiable: false, failure_codes: ["invalid_bundle_public_keys"], verified_claims: 0 };
+  }
+  if (!Array.isArray(requiredClaimTypes) || !Array.isArray(revocations) || !Array.isArray(conflicts)) {
+    return { verdict: "block", offline_verifiable: false, failure_codes: ["invalid_verification_options"], verified_claims: 0 };
+  }
+  if (!Number.isFinite(Number(now))) {
+    return { verdict: "block", offline_verifiable: false, failure_codes: ["invalid_verification_time"], verified_claims: 0 };
+  }
+  if (bundle.bundle_hash !== contentHash(without(bundle, new Set(["bundle_hash"])))) failureCodes.push("bundle_hash_mismatch");
+  if (!(bundle.claims || []).length) failureCodes.push("trust_claim_required");
+  const publicKeys = bundle.public_keys || {};
+  const results = (bundle.claims || []).map(claim => claim.claim_type === "capability"
+    ? verifyCapabilityRuntime(claim, bundle.runtime_receipts || [], publicKeys, Number(now), revocations, conflicts)
+    : verifyClaim(claim, publicKeys, Number(now), revocations, conflicts));
+  const present = new Set(results.map(row => row.claim_type));
+  for (const type of requiredClaimTypes) if (!present.has(type)) failureCodes.push(`required_claim_missing:${type}`);
+  const required = results.filter(row => !requiredClaimTypes.length || requiredClaimTypes.includes(row.claim_type));
+  let verdict;
+  if (failureCodes.length || required.some(row => row.status === "blocked")) verdict = "block";
+  else if (required.some(row => row.status !== "verified")) verdict = "review";
+  else verdict = "pass";
+  return {
+    verdict,
+    offline_verifiable: failureCodes.length === 0 && Object.keys(publicKeys).length > 0,
+    bundle_hash: bundle.bundle_hash,
+    verified_claims: results.filter(row => row.status === "verified").length,
+    claim_results: results,
+    failure_codes: failureCodes
+  };
+}
+
+module.exports = { canonical, contentHash, verifyClaim, verifyCapabilityRuntime, verifyPortableBundle };