privateer-agent 0.12.19 → 0.12.21

package/src/providers/phala/aci-verifier/types.ts

@@ -1,139 +1,149 @@
 /**
  * Wire shapes for the ACI artifacts this verifier reads, plus the result types
- * it returns. These mirror spec/aci.md §4, §5, §8, §9; only the fields the
+ * it returns. These mirror spec/aci.md §3, §4, §7, §8; only the fields the
  * verifier touches are typed precisely, with an index signature left open so
- * unknown extension fields (§3.2) survive canonicalization untouched.
+ * extension fields (Appendix B) are visible to callers.
  */
 
-import type { JcsValue } from './jcs';
-
-/** A public key object: `{ algo, public_key }` (§4.1). */
-export interface PublicKey {
+/** A keyed public-key entry (§3.1) — receipt signing and E2EE keys. */
+export interface KeysetKey {
+  key_id: string;
   algo: string;
   public_key: string;
-  [key: string]: JcsValue | undefined;
+  [key: string]: unknown;
 }
 
-/** The workload identity (§4.2): the identity public key plus an optional subject. */
-export interface WorkloadIdentity {
-  public_key: PublicKey;
-  subject?: string | null;
-  [key: string]: JcsValue | undefined;
+/** A TLS pin entry (§3.1): the certificate SPKI digest, optionally domain-scoped. */
+export interface TlsKeyPin {
+  spki_sha256: string;
+  domain?: string;
+  [key: string]: unknown;
 }
 
-/** A receipt signing key entry (§4.2). */
-export interface ReceiptSigningKey {
-  key_id: string;
-  algo: string;
-  public_key: string;
-  [key: string]: JcsValue | undefined;
-}
-
-/** The workload keyset (§4.2). Digested with JCS to yield `workload_keyset_digest`. */
+/**
+ * The workload keyset (§3.1) — the unit of workload identity. It travels as
+ * `workload_keyset`; its digest is the SHA-256 of the JCS form of the
+ * parsed object (Appendix A).
+ */
 export interface WorkloadKeyset {
-  workload_identity: WorkloadIdentity;
-  keyset_epoch: { version: number; not_after: number; [key: string]: JcsValue | undefined };
-  receipt_signing_keys: ReceiptSigningKey[];
-  e2ee_public_keys?: JcsValue[];
-  tls_public_keys?: JcsValue[];
-  [key: string]: JcsValue | undefined;
+  subject?: string | null;
+  not_after: number;
+  receipt_signing_keys: KeysetKey[];
+  e2ee_public_keys: KeysetKey[];
+  tls_public_keys?: TlsKeyPin[];
+  [key: string]: unknown;
 }
 
-/** A receipt signature block (§8.2). `value` is dropped for canonical signing bytes (§8.5). */
-export interface ReceiptSignature {
-  algo: string;
-  key_id: string;
-  value: string;
-  [key: string]: JcsValue | undefined;
+/** Source provenance (§4.1); each field is `null` when unknown. */
+export interface SourceProvenance {
+  repo_url?: string | null;
+  repo_commit?: string | null;
+  image_digest?: string | null;
+  image_provenance?: unknown;
+  [key: string]: unknown;
 }
 
-/** A single receipt event (§8.3). Only `seq`/`type` are fixed; other fields are type-specific. */
-export interface ReceiptEvent {
-  seq: number;
-  type: string;
-  [key: string]: JcsValue | undefined;
+/** The `attestation` object of a report (§4.1). `evidence` is policy-defined (§4.2). */
+export interface Attestation {
+  tee_type: string;
+  workload_keyset: unknown;
+  report_data: string;
+  source_provenance?: SourceProvenance | null;
+  evidence?: unknown;
+  [key: string]: unknown;
 }
 
-/** An inference receipt (§8.2). */
-export interface Receipt {
+/** An attestation report (§4.1). */
+export interface AttestationReport {
   api_version: string;
-  receipt_id: string;
-  workload_id: string;
   workload_keyset_digest: string;
-  event_log: ReceiptEvent[];
-  signature: ReceiptSignature;
-  [key: string]: JcsValue | undefined;
+  attestation: Attestation;
+  service_capabilities?: { supported_e2ee_versions?: string[]; [key: string]: unknown };
+  [key: string]: unknown;
 }
 
-/** The keyset endorsement / revocation signature block (§4.3, §5.1). */
-export interface Endorsement {
-  algo: string;
-  value: string;
-  [key: string]: JcsValue | undefined;
+/**
+ * The receipt document served by `GET /v1/aci/receipts/{id}` (§7.2): the
+ * §7.3 payload members plus `key_id` and `signature`. The signature covers
+ * JCS(document minus `signature`).
+ */
+export interface ReceiptEnvelope {
+  key_id: string;
+  signature: string;
+  [key: string]: unknown;
 }
 
-/** The `attestation` object of a report (§5.1); only the fields Level 1 reads are typed. */
-export interface Attestation {
-  workload_keyset: WorkloadKeyset;
-  report_data: string;
-  keyset_endorsement: Endorsement;
-  freshness?: { fetched_at?: number; stale_after?: number; [key: string]: JcsValue | undefined };
-  [key: string]: JcsValue | undefined;
+/** A receipt event (§7.3): `type` plus type-specific fields; order is array order. */
+export interface ReceiptEvent {
+  type: string;
+  body_hash?: string;
+  [key: string]: unknown;
 }
 
-/** An attestation report (§5.1). */
-export interface AttestationReport {
+/** The receipt payload the envelope signs (§7.3). */
+export interface ReceiptPayload {
   api_version: string;
-  workload_id: string;
+  receipt_id: string;
+  chat_id?: string | null;
+  model?: string | null;
   workload_keyset_digest: string;
-  attestation: Attestation;
-  [key: string]: JcsValue | undefined;
+  endpoint: string;
+  method: string;
+  served_at: number;
+  event_log: ReceiptEvent[];
+  [key: string]: unknown;
 }
 
-/** A verifier-provided evidence block on a session record (§9.2). */
+/** A session evidence block (§8.2): a base64 data URI plus the digest of its decoded bytes. */
 export interface SessionEvidence {
-  digest?: string | null;
+  digest: string;
   data?: string;
-  [key: string]: JcsValue | undefined;
+  [key: string]: unknown;
 }
 
 /**
- * An attested session record (§9.2). The `session_id` is recomputed from the
- * named fields; absent optional fields (`endpoint`, `identity`, `evidence.digest`)
- * are restored as JSON `null` in the content-addressing material.
+ * An attested session record (§8.2). Its id is the SHA-256 of the JCS form
+ * of the parsed document ({@link computeSessionId}).
  */
 export interface SessionRecord {
+  api_version: string;
   upstream_name: string;
   endpoint?: string | null;
   verifier_id: string;
-  identity?: JcsValue;
-  channel_binding: JcsValue[];
-  claims: JcsValue;
-  evidence?: SessionEvidence | null;
-  [key: string]: JcsValue | undefined;
+  established_at: number;
+  expires_at: number;
+  identity?: unknown;
+  channel_binding: unknown[];
+  claims: unknown;
+  evidence: SessionEvidence;
+  [key: string]: unknown;
 }
 
 /** Outcome of one named verification check. */
 export interface Check {
-  /** Stable machine-readable id, e.g. `signature`, `workload_id`. */
+  /** Stable machine-readable id, e.g. `signature`, `report_data`. */
   name: string;
   ok: boolean;
   /** Human-readable detail, present when the check fails. */
   detail?: string;
 }
 
-/** Result of {@link verifyReceipt}: overall pass plus the individual §10.2 checks. */
+/** Result of {@link verifyReceipt}: overall pass plus the individual §9.3 checks. */
 export interface ReceiptVerification {
   ok: boolean;
   checks: Check[];
+  /** The receipt document read as its §7.3 payload members. */
+  payload?: ReceiptPayload;
 }
 
-/** Result of {@link verifyReportBinding}: overall pass, the §10.1 checks, and the derived identity. */
+/**
+ * Result of {@link verifyReportBinding}: overall pass, the checks, and the
+ * keyset established from the report — the digest is recomputed over the
+ * served keyset object's JCS form (§3.1).
+ */
 export interface ReportVerification {
   ok: boolean;
   checks: Check[];
-  /** `workload_id` recomputed from the report's keyset (§4.1). */
-  workloadId: string;
-  /** `workload_keyset_digest` recomputed from the report's keyset (§4.2). */
-  workloadKeysetDigest: string;
+  workloadKeysetDigest?: string;
+  keyset?: WorkloadKeyset;
 }

package/src/providers/phalaSeal.ts

@@ -8,13 +8,16 @@
 // (`${server}/api/sealed/phala`, treeview/server/routes/sealed.js) injects PHALA_API_KEY
 // and forwards ciphertext — it can't read prompts or responses.
 //
-// Crypto is the vendored @dstack/aci-verifier (./phala/aci-verifier), pure Web Crypto
+// Crypto is the vendored aci-verifier (./phala/aci-verifier), pure Web Crypto
 // (X25519/HKDF/AES-GCM/Ed25519). Node ≥ 22 provides all of it on globalThis.crypto —
 // no polyfills, unlike the RN app.
 //
 // Two-layer attestation, fail-secure:
-//   (1) verifyAciReportBinding — the report's crypto binding (keyset digest,
-//       report_data == statement(nonce), endorsement sig). Self-attesting alone.
+//   (1) verifyReportBinding — the report's crypto binding (§9.1 checks 2–3): the
+//       served keyset canonicalizes to the digest that the attestation statement for
+//       OUR nonce hashes into report_data, and the keyset has not expired. Every key
+//       we go on to use — the X25519 key we seal to above all — is a member of that
+//       one object, so the binding covers them without a separate signature.
 //   (2) verifyHardwareQuote — the hardware root: @phala/dcap-qvl verifies the TDX quote
 //       against Intel collateral and binds the quote's report_data to (1)'s statement
 //       digest. requireQuote defaults TRUE; PRIVATEER_PHALA_REQUIRE_QUOTE=0 drops it
@@ -23,17 +26,13 @@
 import type { Report } from "@phala/dcap-qvl";
 import {
   openE2eeChannel,
+  verifyReportBinding,
   toHex,
   fromHex,
   type AttestationReport,
   type ReportVerification,
   type E2eeChannel,
 } from "./phala/aci-verifier/index.ts";
-// Not the vendored verifyReportBinding directly: the deployed gateway signs its
-// keyset endorsement with ecdsa-secp256k1, which upstream's Web-Crypto-only verifier
-// refuses. This wrapper delegates ed25519 to it unchanged and adds the secp256k1 arm
-// the spec allows (§4.3), leaving aci-verifier/ pristine for re-pulls.
-import { verifyAciReportBinding } from "./phala/reportBinding.ts";
 import {
   parseEventLog,
   appIdentityFrom,
@@ -153,7 +152,7 @@ async function establishAttestation(): Promise<VerifiedAttestation> {
   if (!res.ok) throw new Error(`phala attestation HTTP ${res.status}`);
   const report = (await res.json()) as AttestationReport;
 
-  const verification = await verifyAciReportBinding(report, nonce);
+  const verification = await verifyReportBinding(report, nonce);
   if (!verification.ok) {
     const failed = verification.checks.filter((c) => !c.ok).map((c) => c.name).join(", ");
     throw new Error(`phala attestation binding failed: ${failed}`);

package/src/providers/phala/reportBinding.ts

@@ -1,193 +0,0 @@
-// Algorithm dispatch for the ACI report-binding checks (§10.1 checks 2–6).
-//
-// The ACI spec (§4.3) allows the keyset endorsement to be signed with EITHER
-// `ed25519` OR `ecdsa-secp256k1` — the former because "every primitive in it is
-// available in the Web Crypto API", the latter for "clients in the EVM/dstack
-// ecosystem". Upstream's reference TS verifier implements only the Web Crypto half:
-// `verifySignature` throws `UnsupportedAlgorithmError` on secp256k1
-// (aci-verifier/crypto.ts), and `verifyReportBinding` propagates that.
-//
-// The deployed gateway (inference.phala.com) signs with `ecdsa-secp256k1`, so the
-// vendored verifier can never attest it — a limit of upstream's CLIENT, not of the
-// spec or the gateway. Verified live 2026-07-31: attestation fetched, endorsement
-// rejected with UnsupportedAlgorithmError.
-//
-// This module owns the dispatch so `aci-verifier/` stays byte-for-byte upstream
-// (see its VENDORED.md — only the `.js`-extension strip diverges, and re-pulls stay
-// mechanical):
-//   ed25519         → delegate to the vendored verifyReportBinding, verbatim
-//   ecdsa-secp256k1 → the same checks 2–6, with check 5 done over @noble/curves
-//   anything else   → still throws (never a silent pass)
-//
-// The secp256k1 path deliberately mirrors report.ts check-for-check, in the same
-// order and with the same check names, so a caller cannot tell which path ran.
-
-import { secp256k1 } from "@noble/curves/secp256k1.js";
-import {
-  verifyReportBinding,
-  computeWorkloadId,
-  computeKeysetDigest,
-  computeReportData,
-  keysetEndorsementPayload,
-  sha256,
-  fromHex,
-  UnsupportedAlgorithmError,
-  type AttestationReport,
-  type Check,
-  type ReportVerification,
-  type ReportBindingOptions,
-} from "./aci-verifier/index.ts";
-
-const ED25519 = "ed25519";
-const SECP256K1 = "ecdsa-secp256k1";
-
-/**
- * Verify a report's cryptographic bindings for `nonce` (§10.1 checks 2–6),
- * dispatching on the algorithm the attested identity key declares. Drop-in
- * replacement for the vendored `verifyReportBinding`: same arguments, same result
- * shape, same "a failed check is `ok: false`, never thrown" contract.
- *
- * Like upstream, this is the crypto-binding half only — compose it with a hardware
- * quote verifier (phalaSeal.ts `verifyHardwareQuote`) for Level 2.
- */
-export async function verifyAciReportBinding(
-  report: AttestationReport,
-  nonce: string | null | undefined,
-  options: ReportBindingOptions = {},
-): Promise<ReportVerification> {
-  const algo = report.attestation.workload_keyset.workload_identity.public_key.algo;
-  if (algo === ED25519) return verifyReportBinding(report, nonce, options);
-  if (algo !== SECP256K1) {
-    // Same fail-closed posture as upstream: an algorithm we cannot check is a
-    // refusal, not a pass.
-    throw new UnsupportedAlgorithmError(algo, "keyset endorsement (§4.3)");
-  }
-  return verifySecp256k1ReportBinding(report, nonce, options);
-}
-
-async function verifySecp256k1ReportBinding(
-  report: AttestationReport,
-  nonce: string | null | undefined,
-  options: ReportBindingOptions,
-): Promise<ReportVerification> {
-  const now = options.now ?? Math.floor(Date.now() / 1000);
-  const checks: Check[] = [];
-
-  const keyset = report.attestation.workload_keyset;
-  const identityKey = keyset.workload_identity.public_key;
-
-  // Check 2: workload_id == digest of the identity public key in the report's keyset.
-  const workloadId = await computeWorkloadId(identityKey);
-  pushEqual(checks, "workload_id", report.workload_id, workloadId);
-
-  // Check 3: workload_keyset_digest == digest of the report's keyset.
-  const workloadKeysetDigest = await computeKeysetDigest(keyset);
-  pushEqual(checks, "workload_keyset_digest", report.workload_keyset_digest, workloadKeysetDigest);
-
-  // Check 4 (binding half): report_data == the §4.4 statement digest for this nonce.
-  // The hardware-evidence-binds-report_data half is verifyHardwareQuote's job.
-  const expectedReportData = await computeReportData(workloadId, workloadKeysetDigest, nonce);
-  pushEqual(checks, "report_data", report.attestation.report_data, expectedReportData);
-
-  // Check 5: keyset endorsement verifies under the identity key, algo matching.
-  const endorsement = report.attestation.keyset_endorsement;
-  if (endorsement.algo !== identityKey.algo) {
-    checks.push({
-      name: "keyset_endorsement",
-      ok: false,
-      detail: `endorsement.algo "${endorsement.algo}" != identity key algo "${identityKey.algo}"`,
-    });
-  } else {
-    const ok = await verifySecp256k1(
-      identityKey.public_key,
-      endorsement.value,
-      keysetEndorsementPayload(workloadKeysetDigest),
-    );
-    checks.push({
-      name: "keyset_endorsement",
-      ok,
-      ...(ok ? {} : { detail: "endorsement signature failed under identity key" }),
-    });
-  }
-
-  // Check 6: freshness. Nonce binding is check 4; here bound the epoch and, when
-  // the profile trusts it, the declared validity window.
-  const notAfter = keyset.keyset_epoch.not_after;
-  const epochOk = now < notAfter;
-  checks.push({
-    name: "keyset_epoch.not_after",
-    ok: epochOk,
-    ...(epochOk ? {} : { detail: `now ${now} >= not_after ${notAfter}` }),
-  });
-  if (options.trustPlatformClock) {
-    const freshness = report.attestation.freshness;
-    const fetchedAt = freshness?.fetched_at;
-    const staleAfter = freshness?.stale_after;
-    const windowOk =
-      typeof fetchedAt === "number" &&
-      typeof staleAfter === "number" &&
-      fetchedAt <= now &&
-      now < staleAfter;
-    checks.push({
-      name: "freshness_window",
-      ok: windowOk,
-      ...(windowOk ? {} : { detail: `now ${now} outside [${fetchedAt}, ${staleAfter})` }),
-    });
-  }
-
-  return { ok: checks.every((c) => c.ok), checks, workloadId, workloadKeysetDigest };
-}
-
-/**
- * §4.3 secp256k1 endorsement: a 64-byte `r || s` signature over
- * `sha256(payload bytes)`. Returns false on malformed input rather than throwing —
- * a bad signature is a failed check, not an exception.
- *
- * NOT the §8.5 *receipt* shape, which is a 65-byte recoverable `r || s || v` and
- * where the spec says 64-byte signatures MUST be rejected. Different shapes; easy
- * to conflate if this ever grows a receipt path.
- */
-async function verifySecp256k1(
-  publicKeyHex: string,
-  signatureHex: string,
-  payload: Uint8Array,
-): Promise<boolean> {
-  try {
-    const sig = fromHex(signatureHex);
-    if (sig.length !== 64) return false; // r||s only; DER / recoverable forms are not §4.3
-    const msgHash = await sha256(payload);
-    return secp256k1.verify(sig, msgHash, publicKey(publicKeyHex), {
-      prehash: false, // we hand it the sha256 digest, per §4.3
-      // Accept high-s as well as low-s. ECDSA malleability is meaningless for a
-      // signature over a FIXED payload — an attacker who can flip s already has a
-      // valid endorsement and still cannot sign a different keyset digest. Leaving
-      // the default on would reject ~half of otherwise-valid endorsements from any
-      // signer that doesn't normalize, as an intermittent attestation failure.
-      lowS: false,
-    });
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Identity key bytes. §7.1 pins secp256k1 public keys as 65-byte uncompressed SEC1
- * and requires that "the 64-byte uncompressed form without the `0x04` prefix MUST be
- * accepted and treated as the same key" — so restore the prefix when it's absent.
- * The live gateway sends the 65-byte form; do NOT prefix that one again.
- */
-function publicKey(hex: string): Uint8Array {
-  const raw = fromHex(hex);
-  if (raw.length === 64) {
-    const sec1 = new Uint8Array(65);
-    sec1[0] = 0x04;
-    sec1.set(raw, 1);
-    return sec1;
-  }
-  return raw;
-}
-
-function pushEqual(checks: Check[], name: string, actual: string, expected: string): void {
-  const ok = actual === expected;
-  checks.push({ name, ok, ...(ok ? {} : { detail: `report ${actual} != recomputed ${expected}` }) });
-}