@prismnetwork/agent-sdk 0.7.6 → 0.7.7

package/README.md

@@ -17,7 +17,7 @@ import { PrismAgent, DEFAULT_IMAGE } from "@prismnetwork/agent-sdk";
 
 const agent = new PrismAgent({
   privateKey: process.env.PRISM_AGENT_KEY,  // agent's wallet
-  escrow: "0xfD4228eEEfC49e4b76A0CD40af9fdd546220B2FD",
+  escrow: "0x62C042265991bEa17B07229322A01850974626dA",
 });
 
 await agent.authenticate();

package/attest.d.mts

@@ -76,6 +76,16 @@ export interface VerifyConfidentialOptions {
 
 export declare function verifyConfidential(options: VerifyConfidentialOptions): Promise<AttestationResult>;
 
+/// Everything a verifier can establish about a confidential endpoint without
+/// paying for a call: quote to Intel's root, boot-log replay, the pinned
+/// workload, and the GPU leg tied to the same TD. Spends nothing, needs no key.
+export declare function attestEndpoint(
+  options?: Pick<
+    VerifyConfidentialOptions,
+    "base" | "model" | "expectedWorkload" | "nonce" | "now" | "observedSpki" | "collateralUrl" | "fetchImpl"
+  >,
+): Promise<AttestationResult>;
+
 export declare function gateNrasClaims(input: {
   overall: Record<string, unknown>;
   gpus: Record<string, Record<string, unknown>>;

package/attest.mjs

@@ -56,7 +56,7 @@ export const EXPECTED_WORKLOAD = {
     "ghcr.io/redpill-ai/private-ai-launcher@sha256:c083ff9e6a5ddf10f6c9e9bb1f74cc618deebecfea5208b563c574399db4637c",
   repoUrl: "https://github.com/Dstack-TEE/private-ai-gateway.git",
   osImageHash: "bd369a8c2f9edb2b52dad48ac8e0b32dde5f1337c423a506b48d07403a7d8033",
-  repoCommit: "b6b5c1b82f6fc59490db5a5255bf4493805e66c6",
+  repoCommit: "d567f6b4c4d93e33037ea202db04db86a8ad881c",
 };
 
 const NRAS_ATTEST_URL = "https://nras.attestation.nvidia.com/v3/attest/gpu";
@@ -587,6 +587,111 @@ export async function verifyConfidential({
 const CUSTODY_DETAIL =
   "no verifier appraises the KMS custody chain yet; encrypt end to end rather than rely on it";
 
+/// The endpoint-only appraisal: everything a verifier can establish about a
+/// confidential endpoint without paying for a call. It spends nothing and needs
+/// no key. The receipt-family checks belong to a specific paid call and are not
+/// in this transcript; what is here is who could read a prompt sent right now —
+/// the quote to Intel's root, the boot log replay, the pinned workload, and the
+/// NVIDIA GPU leg tied to the same TD.
+export async function attestEndpoint({
+  base = DEFAULT_CONFIDENTIAL_BASE,
+  model,
+  expectedWorkload = EXPECTED_WORKLOAD,
+  nonce = randomNonce(),
+  now = Math.floor(Date.now() / 1000),
+  observedSpki = null,
+  collateralUrl = undefined,
+  fetchImpl = fetch,
+} = {}) {
+  const t = new Transcript();
+  const root = String(base).replace(/\/+$/, "");
+  const expectedSkips = new Set([CUSTODY]);
+  if (!observedSpki) expectedSkips.add(CHANNEL);
+  const settle = (extra) => verdict(t, expectedSkips, { nonce, model: model ?? null, ...extra });
+
+  const fetched = await getJson(fetchImpl, `${root}/v1/attestation?nonce=${nonce}`, "the attestation endpoint");
+  if (!fetched.ok) {
+    for (const id of ["keyset-digest", "report-data-binding", "tdx-quote", "rtmr3-replay", "compose-hash", WORKLOAD]) {
+      t.fail(id, fetched.detail);
+    }
+    t.skip("gpu-nras", "no attestation report to tie GPU evidence to");
+    t.skip("gpu-binding", "no attestation report to tie GPU evidence to");
+    channelCheck(t, null, observedSpki, root);
+    t.skip(CUSTODY, CUSTODY_DETAIL);
+    return settle({ keysetDigest: null, provenance: null });
+  }
+  const report = fetched.body;
+
+  const binding = await verifyReportBinding(report, nonce, { now });
+  const digest = binding.workloadKeysetDigest;
+  const keyset = binding.keyset;
+  const badBinding = binding.checks.find((c) => !c.ok);
+  if (badBinding) {
+    t.fail("keyset-digest", badBinding.detail ?? `${badBinding.name} failed`);
+  } else {
+    t.pass("keyset-digest", `${digest}, aci/1, valid until ${unixTime(keyset.not_after)}`);
+  }
+
+  const quote = await verifyQuote(report, { collateralUrl, now });
+  if (!quote.ok) {
+    t.fail("tdx-quote", quote.detail ?? "quote verification failed");
+  } else if (quote.status !== "UpToDate") {
+    const advisories = quote.advisoryIds?.length ? ` (${quote.advisoryIds.join(", ")})` : "";
+    t.fail("tdx-quote", `verified to Intel's root, but the platform TCB is ${quote.status}${advisories}`);
+  } else {
+    t.pass("tdx-quote", "verified to Intel's root, platform TCB up to date");
+  }
+
+  const slot = quote.ok ? quote.report.reportData : readReportData(report.attestation?.evidence?.quote);
+  const unverified = quote.ok ? "" : " (read off an unverified quote)";
+  if (!digest) {
+    t.fail("report-data-binding", "no key set was established, so nothing can be recomputed against the quote");
+  } else {
+    const expected = await computeReportData(digest, nonce);
+    const bound = slot.length === 64 ? toHex(slot.slice(0, 32)) : "nothing: the quote carries no report-data slot";
+    const padded = slot.length === 64 && slot.slice(32).every((b) => b === 0);
+    if (bound === expected && padded) {
+      t.pass("report-data-binding", `the quote's report data is sha256 of our nonce over ${digest}${unverified}`);
+    } else {
+      t.fail("report-data-binding", `the quote binds ${bound}, this nonce and key set produce ${expected}`);
+    }
+  }
+
+  let measurement = null;
+  try {
+    measurement = await verifyComposeMeasurement(report, { statedRtmr3: quote.ok ? quote.report.rtMr3 : null });
+    const rtmr3 = measurement.checks.find((c) => c.name === "rtmr3");
+    t.add("rtmr3-replay", rtmr3.ok ? "pass" : "fail", rtmr3.ok ? `${toHex(measurement.rtmr3)}${unverified}` : rtmr3.detail);
+    const composeHash = measurement.checks.find((c) => c.name === "compose_hash");
+    t.add(
+      "compose-hash",
+      composeHash.ok ? "pass" : "fail",
+      composeHash.ok
+        ? `sha256(app_compose)=${measurement.composeHash} measured before system-ready`
+        : composeHash.detail,
+    );
+    if (!measurement.ok) measurement = null;
+  } catch (err) {
+    t.fail("rtmr3-replay", `the report's boot evidence could not be replayed: ${err?.message ?? err}`);
+    t.fail("compose-hash", "no replayable boot evidence to measure the compose against");
+  }
+
+  let provenance = null;
+  if (!measurement) {
+    t.fail(WORKLOAD, "no measured compose to read the workload identity out of");
+  } else {
+    const identity = await appraiseWorkload(report, measurement, expectedWorkload);
+    provenance = identity.provenance ?? null;
+    t.add(WORKLOAD, identity.skipped ? "skip" : identity.ok ? "pass" : "fail", identity.detail);
+  }
+
+  await gpuChecks(t, { root, fetchImpl, model, digest, quote, collateralUrl, now });
+  channelCheck(t, keyset, observedSpki, root);
+  t.skip(CUSTODY, CUSTODY_DETAIL);
+
+  return settle({ keysetDigest: digest ?? null, provenance });
+}
+
 /// The verdict rule over a finished check list. `failed` means a check actually
 /// failed. `incomplete` means nothing failed but evidence the verdict would have
 /// rested on was missing, which is a different thing to say and is said with a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prismnetwork/agent-sdk",
-  "version": "0.7.6",
+  "version": "0.7.7",
   "description": "Headless GPU leasing and renter-encrypted storage on Prism Network for wallet-holding agents.",
   "type": "module",
   "main": "prism.mjs",