@elizaos/agent 2.0.0-beta.1 → 2.0.11-beta.5

package/services/tee-policy.js

@@ -0,0 +1,233 @@
+import { normalizeTeeEvidence, teeMeasurementDigestMatches, } from "./tee-evidence.js";
+export function evaluateTeeEvidencePolicy(evidenceInput, policy) {
+    if (!policy) {
+        return { trusted: true, reason: "no-policy" };
+    }
+    if (!policy.required && evidenceInput === undefined) {
+        return { trusted: true, reason: "not-required" };
+    }
+    if (evidenceInput === undefined) {
+        return { trusted: false, reason: "missing-evidence" };
+    }
+    let evidence;
+    try {
+        evidence = normalizeTeeEvidence(evidenceInput);
+    }
+    catch (error) {
+        return {
+            trusted: false,
+            reason: "invalid-evidence",
+            detail: error instanceof Error ? error.message : String(error),
+        };
+    }
+    if (policy.rejectSimulatedEvidence) {
+        const simulated = detectSimulatedEvidence(evidence);
+        if (simulated !== undefined) {
+            return {
+                trusted: false,
+                reason: "simulated-evidence-rejected",
+                detail: simulated,
+                evidence,
+            };
+        }
+    }
+    if (policy.allowedKinds !== undefined &&
+        !policy.allowedKinds.includes(evidence.kind)) {
+        return {
+            trusted: false,
+            reason: "kind-not-allowed",
+            detail: `TEE kind "${evidence.kind}" is not allowed.`,
+            evidence,
+        };
+    }
+    if (policy.allowedProviders !== undefined &&
+        (evidence.provider === undefined ||
+            !policy.allowedProviders.includes(evidence.provider))) {
+        return {
+            trusted: false,
+            reason: "provider-not-allowed",
+            detail: `TEE provider "${evidence.provider ?? "unknown"}" is not allowed.`,
+            evidence,
+        };
+    }
+    for (const [name, expected] of Object.entries(policy.requiredMeasurements ?? {})) {
+        const actual = evidence.measurements?.[name];
+        if (!teeMeasurementDigestMatches(actual, expected)) {
+            return {
+                trusted: false,
+                reason: "measurement-mismatch",
+                detail: `TEE measurement "${name}" does not match policy.`,
+                evidence,
+            };
+        }
+    }
+    for (const [name, revokedDigests] of Object.entries(policy.revokedMeasurements ?? {})) {
+        const actual = evidence.measurements?.[name];
+        if (actual !== undefined &&
+            revokedDigests?.some((digest) => teeMeasurementDigestMatches(actual, digest))) {
+            return {
+                trusted: false,
+                reason: "measurement-revoked",
+                detail: `TEE measurement "${name}" has been revoked by policy.`,
+                evidence,
+            };
+        }
+    }
+    if (policy.minSecurityVersion !== undefined &&
+        (evidence.securityVersion === undefined ||
+            evidence.securityVersion < policy.minSecurityVersion)) {
+        return {
+            trusted: false,
+            reason: "security-version-too-low",
+            detail: `TEE security version ${evidence.securityVersion ?? "unknown"} is below ${policy.minSecurityVersion}.`,
+            evidence,
+        };
+    }
+    if (evidence.securityVersion !== undefined &&
+        policy.revokedSecurityVersions?.includes(evidence.securityVersion)) {
+        return {
+            trusted: false,
+            reason: "security-version-revoked",
+            detail: `TEE security version ${evidence.securityVersion} has been revoked by policy.`,
+            evidence,
+        };
+    }
+    const nonceDecision = evaluateNonce(evidence, policy);
+    if (!nonceDecision.trusted)
+        return nonceDecision;
+    const timestampDecision = evaluateTimestamp(evidence, policy);
+    if (!timestampDecision.trusted)
+        return timestampDecision;
+    for (const [claim, expected] of Object.entries(policy.requiredClaims ?? {})) {
+        if (evidence.claims?.[claim] !== expected) {
+            return {
+                trusted: false,
+                reason: "claim-mismatch",
+                detail: `TEE claim "${claim}" does not match policy.`,
+                evidence,
+            };
+        }
+    }
+    return { trusted: true, reason: "allowed", evidence };
+}
+/**
+ * Detect evidence that self-identifies as a developer-mode, simulated, or
+ * mock attestation. Returns a human-readable detail string when the evidence
+ * must be rejected, or `undefined` when nothing simulated was found.
+ *
+ * This is an agent-side compensating control against dstack #608 (DevMode
+ * allow-all) and #609 (KMS attestation bypass): even when an upstream KMS or
+ * provider would accept a DevMode quote, the agent refuses it under the
+ * production profile. It does NOT replace real quote-signature verification
+ * (BLOCKED on TDX/CoVE hardware) — it only rejects self-declared non-prod
+ * markers. Absence of these markers is not evidence of a genuine quote.
+ */
+function detectSimulatedEvidence(evidence) {
+    const kind = evidence.kind.toLowerCase();
+    if (kind === "none" ||
+        kind.includes("mock") ||
+        kind.includes("sim") ||
+        kind.includes("fake") ||
+        kind.includes("debug")) {
+        return `TEE kind "${evidence.kind}" indicates a non-production attestation.`;
+    }
+    const vendor = evidence.hardwareVendor?.toLowerCase();
+    if (vendor !== undefined &&
+        (vendor.startsWith("mock") || vendor.includes("sim"))) {
+        return `TEE hardwareVendor "${evidence.hardwareVendor}" indicates a non-production attestation.`;
+    }
+    const provider = evidence.provider?.toLowerCase();
+    if (provider !== undefined &&
+        (provider.includes("mock") ||
+            provider.includes("sim") ||
+            provider.includes("fake"))) {
+        return `TEE provider "${evidence.provider}" indicates a non-production attestation.`;
+    }
+    const quote = evidence.quote?.toLowerCase();
+    if (quote !== undefined &&
+        (quote.includes("simulated") ||
+            quote.includes("mock") ||
+            quote.includes("fake") ||
+            quote.includes("debug") ||
+            quote.includes("devmode"))) {
+        return "TEE quote is marked simulated/debug/devmode.";
+    }
+    const verifier = evidence.freshness?.verifier?.toLowerCase();
+    if (verifier !== undefined && isSimulatedVerifier(verifier)) {
+        return `TEE verifier "${evidence.freshness?.verifier}" indicates a non-production attestation.`;
+    }
+    return undefined;
+}
+/**
+ * Match genuinely-simulated verifier markers WITHOUT rejecting the legitimate
+ * on-device `eliza-local-verifier`. The real CoVE on-device verifier is "local"
+ * by design (self-rooted in the device RoT, no cloud QE), so a blanket
+ * `includes("local")` would block the real product path. We instead reject the
+ * specific dev/mock/smoke markers a simulated verifier carries.
+ */
+function isSimulatedVerifier(verifier) {
+    if (verifier === "eliza-local-verifier")
+        return false;
+    return (verifier.includes("local-smoke") ||
+        verifier.includes("localsim") ||
+        verifier.includes("mock") ||
+        verifier.includes("sim") ||
+        verifier.includes("fake") ||
+        verifier.includes("devmode") ||
+        verifier.includes("debug"));
+}
+function evaluateNonce(evidence, policy) {
+    if (policy.expectedNonce === undefined) {
+        return { trusted: true, reason: "allowed", evidence };
+    }
+    if (evidence.freshness?.nonce === undefined) {
+        return {
+            trusted: false,
+            reason: "missing-nonce",
+            detail: "TEE evidence does not include a freshness nonce.",
+            evidence,
+        };
+    }
+    if (evidence.freshness.nonce !== policy.expectedNonce) {
+        return {
+            trusted: false,
+            reason: "nonce-mismatch",
+            detail: "TEE evidence nonce does not match policy.",
+            evidence,
+        };
+    }
+    return { trusted: true, reason: "allowed", evidence };
+}
+function evaluateTimestamp(evidence, policy) {
+    if (policy.maxAgeMs === undefined) {
+        return { trusted: true, reason: "allowed", evidence };
+    }
+    const timestamp = evidence.freshness?.timestamp;
+    if (timestamp === undefined) {
+        return {
+            trusted: false,
+            reason: "missing-timestamp",
+            detail: "TEE evidence does not include a freshness timestamp.",
+            evidence,
+        };
+    }
+    const timestampMs = Date.parse(timestamp);
+    if (!Number.isFinite(timestampMs)) {
+        return {
+            trusted: false,
+            reason: "timestamp-invalid",
+            detail: "TEE evidence timestamp is not parseable.",
+            evidence,
+        };
+    }
+    const nowMs = policy.nowMs ?? Date.now();
+    if (timestampMs > nowMs + 60_000 || nowMs - timestampMs > policy.maxAgeMs) {
+        return {
+            trusted: false,
+            reason: "timestamp-stale",
+            detail: "TEE evidence timestamp is outside the allowed freshness window.",
+            evidence,
+        };
+    }
+    return { trusted: true, reason: "allowed", evidence };
+}

package/services/tee-production-profile.d.ts

@@ -0,0 +1,35 @@
+import type { TeeEvidencePolicy } from "./tee-policy.ts";
+/**
+ * Non-negotiable production floor for confidential-AI TEE trust.
+ *
+ * This profile exists so a caller cannot accidentally accept developer-mode,
+ * debug, or stale evidence in production by forgetting to set a claim. It is
+ * intersected with the resolved runtime policy at boot (see
+ * {@link mergeTeeProductionProfile}); the intersection only ever tightens the
+ * policy — it never relaxes a stricter caller setting.
+ *
+ * It does NOT and cannot assert hardware trust on its own: real TDX/CoVE quote
+ * signature verification is BLOCKED on hardware (plan Phase B/C). Until that
+ * lands the profile rejects self-declared non-production markers
+ * (`rejectSimulatedEvidence`) but the system must not claim hardware-verified
+ * trust.
+ */
+export declare const TEE_PRODUCTION_MAX_AGE_MS = 300000;
+export type TeeProductionProfileOptions = {
+    /**
+     * Topology of the inference path. `local` requires the NPU confidential-I/O
+     * claim; `cloud` requires the H100 confidential-GPU claim. Defaults to
+     * `local` (the device's default deployment shape).
+     */
+    inference?: "local" | "cloud";
+};
+export type TeeProductionProfile = Required<Pick<TeeEvidencePolicy, "required" | "requiredClaims" | "rejectSimulatedEvidence">> & Pick<TeeEvidencePolicy, "maxAgeMs">;
+export declare function teeProductionProfile(options?: TeeProductionProfileOptions): TeeProductionProfile;
+/**
+ * Intersect the production profile into a resolved policy. The merge only
+ * tightens: the profile's required claims are unioned in, `required` and
+ * `rejectSimulatedEvidence` are forced on, and `maxAgeMs` is clamped to the
+ * smaller (stricter) of the caller's value and the production ceiling.
+ */
+export declare function mergeTeeProductionProfile(policy: TeeEvidencePolicy | undefined, options?: TeeProductionProfileOptions): TeeEvidencePolicy;
+//# sourceMappingURL=tee-production-profile.d.ts.map

package/services/tee-production-profile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tee-production-profile.d.ts","sourceRoot":"","sources":["../../src/services/tee-production-profile.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEzD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,yBAAyB,SAAU,CAAC;AAuBjD,MAAM,MAAM,2BAA2B,GAAG;IACxC;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,QAAQ,CACzC,IAAI,CACF,iBAAiB,EACjB,UAAU,GAAG,gBAAgB,GAAG,yBAAyB,CAC1D,CACF,GACC,IAAI,CAAC,iBAAiB,EAAE,UAAU,CAAC,CAAC;AAEtC,wBAAgB,oBAAoB,CAClC,OAAO,GAAE,2BAAgC,GACxC,oBAAoB,CAatB;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,iBAAiB,GAAG,SAAS,EACrC,OAAO,GAAE,2BAAgC,GACxC,iBAAiB,CAiBnB"}

package/services/tee-production-profile.js

@@ -0,0 +1,64 @@
+/**
+ * Non-negotiable production floor for confidential-AI TEE trust.
+ *
+ * This profile exists so a caller cannot accidentally accept developer-mode,
+ * debug, or stale evidence in production by forgetting to set a claim. It is
+ * intersected with the resolved runtime policy at boot (see
+ * {@link mergeTeeProductionProfile}); the intersection only ever tightens the
+ * policy — it never relaxes a stricter caller setting.
+ *
+ * It does NOT and cannot assert hardware trust on its own: real TDX/CoVE quote
+ * signature verification is BLOCKED on hardware (plan Phase B/C). Until that
+ * lands the profile rejects self-declared non-production markers
+ * (`rejectSimulatedEvidence`) but the system must not claim hardware-verified
+ * trust.
+ */
+export const TEE_PRODUCTION_MAX_AGE_MS = 300_000;
+/**
+ * Base local-in-TEE production claims. Every claim here MUST be present and
+ * true on the evidence or `evaluateTeeEvidencePolicy` fails closed.
+ */
+const PRODUCTION_BASE_CLAIMS = {
+    debugDisabled: true,
+    secureBoot: true,
+    memoryEncrypted: true,
+    ioProtected: true,
+    productionLifecycle: true,
+};
+export function teeProductionProfile(options = {}) {
+    const inference = options.inference ?? "local";
+    return {
+        required: true,
+        rejectSimulatedEvidence: true,
+        requiredClaims: {
+            ...PRODUCTION_BASE_CLAIMS,
+            ...(inference === "local"
+                ? { npuProtected: true }
+                : { gpuProtected: true }),
+        },
+        maxAgeMs: TEE_PRODUCTION_MAX_AGE_MS,
+    };
+}
+/**
+ * Intersect the production profile into a resolved policy. The merge only
+ * tightens: the profile's required claims are unioned in, `required` and
+ * `rejectSimulatedEvidence` are forced on, and `maxAgeMs` is clamped to the
+ * smaller (stricter) of the caller's value and the production ceiling.
+ */
+export function mergeTeeProductionProfile(policy, options = {}) {
+    const profile = teeProductionProfile(options);
+    const base = policy ?? {};
+    const callerMaxAge = base.maxAgeMs;
+    return {
+        ...base,
+        required: true,
+        rejectSimulatedEvidence: true,
+        requiredClaims: {
+            ...(base.requiredClaims ?? {}),
+            ...profile.requiredClaims,
+        },
+        maxAgeMs: callerMaxAge === undefined
+            ? profile.maxAgeMs
+            : Math.min(callerMaxAge, TEE_PRODUCTION_MAX_AGE_MS),
+    };
+}

package/services/tee-release-policy.d.ts

@@ -0,0 +1,18 @@
+import type { TeeEvidencePolicy } from "./tee-policy.ts";
+export type TeeReleaseManifestLike = {
+    tee?: {
+        enabled?: boolean;
+        providers?: string[];
+        measurements?: Record<string, string>;
+        requiredClaims?: Record<string, boolean>;
+        minSecurityVersion?: number;
+    };
+};
+export type TeeReleasePolicyOptions = {
+    required?: boolean;
+    expectedNonce?: string;
+    maxAgeMs?: number;
+    nowMs?: number;
+};
+export declare function teePolicyFromReleaseManifest(manifest: TeeReleaseManifestLike, options?: TeeReleasePolicyOptions): TeeEvidencePolicy;
+//# sourceMappingURL=tee-release-policy.d.ts.map

package/services/tee-release-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tee-release-policy.d.ts","sourceRoot":"","sources":["../../src/services/tee-release-policy.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEzD,MAAM,MAAM,sBAAsB,GAAG;IACnC,GAAG,CAAC,EAAE;QACJ,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;QACrB,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACtC,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACzC,kBAAkB,CAAC,EAAE,MAAM,CAAC;KAC7B,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,sBAAsB,EAChC,OAAO,GAAE,uBAA4B,GACpC,iBAAiB,CAmBnB"}

package/services/tee-release-policy.js

@@ -0,0 +1,53 @@
+export function teePolicyFromReleaseManifest(manifest, options = {}) {
+    const tee = manifest.tee;
+    if (!tee?.enabled) {
+        return { required: options.required ?? false };
+    }
+    return {
+        required: options.required ?? true,
+        allowedKinds: normalizeProviders(tee.providers),
+        requiredMeasurements: normalizeMeasurements(tee.measurements),
+        requiredClaims: normalizeClaims(tee.requiredClaims),
+        ...(tee.minSecurityVersion === undefined
+            ? {}
+            : { minSecurityVersion: tee.minSecurityVersion }),
+        ...(options.expectedNonce === undefined
+            ? {}
+            : { expectedNonce: options.expectedNonce }),
+        ...(options.maxAgeMs === undefined ? {} : { maxAgeMs: options.maxAgeMs }),
+        ...(options.nowMs === undefined ? {} : { nowMs: options.nowMs }),
+    };
+}
+function normalizeProviders(providers) {
+    return (providers ?? [])
+        .map((provider) => provider.trim())
+        .filter((provider) => provider.length > 0);
+}
+function normalizeMeasurements(measurements) {
+    const normalized = {};
+    for (const [name, digest] of Object.entries(measurements ?? {})) {
+        if (typeof digest === "string" && digest.trim()) {
+            normalized[name] = digest.trim();
+        }
+    }
+    return normalized;
+}
+function normalizeClaims(claims) {
+    const normalized = {};
+    for (const [name, value] of Object.entries(claims ?? {})) {
+        if ([
+            "debugDisabled",
+            "productionLifecycle",
+            "secureBoot",
+            "memoryEncrypted",
+            "ioProtected",
+            "gpuProtected",
+            "npuProtected",
+            "monitorMeasured",
+        ].includes(name) &&
+            typeof value === "boolean") {
+            normalized[name] = value;
+        }
+    }
+    return normalized;
+}

package/services/tee-revocation.d.ts

@@ -0,0 +1,60 @@
+import type { TeeMeasurementName } from "./tee-evidence.ts";
+import type { TeeEvidencePolicy } from "./tee-policy.ts";
+export type TeeRevocationEntry = {
+    value: string | number;
+    reason?: string;
+    revokedAt?: string;
+    source?: string;
+};
+export type TeeRevocationManifest = {
+    schemaVersion: 1;
+    /** Identity of the signing authority; selects the trusted public key. */
+    authority?: string;
+    /**
+     * Detached Ed25519 signature (base64) over the canonical manifest body (all
+     * fields except `signature`). Verified at the load boundary against a
+     * configured trusted authority key — see {@link verifyTeeRevocationManifest}.
+     */
+    signature?: string;
+    revokedMeasurements?: Partial<Record<TeeMeasurementName, Array<string | TeeRevocationEntry>>>;
+    revokedSecurityVersions?: Array<number | TeeRevocationEntry>;
+};
+export type TeeRevocationVerificationOptions = {
+    /**
+     * Trusted authority public keys, keyed by authority id. PEM (SPKI) Ed25519
+     * keys. The manifest's `authority` selects which key must verify its
+     * signature. When this map is empty, an unsigned manifest with no `authority`
+     * is permitted (local dev); any manifest that *claims* an authority or
+     * carries a signature is rejected because there is no anchor to verify it.
+     */
+    trustedAuthorities: Record<string, string>;
+};
+export type TeeRevocationVerificationResult = {
+    verified: true;
+    authority?: string;
+} | {
+    verified: false;
+    reason: "unsigned-manifest" | "missing-authority" | "untrusted-authority" | "invalid-signature" | "malformed-key";
+    detail?: string;
+};
+/**
+ * Verify a revocation manifest's Ed25519 signature against a configured set of
+ * trusted authority keys. Fail-closed by construction:
+ *
+ * - No trusted authorities configured + manifest carries no `authority`/
+ *   `signature` ⇒ verified (local-dev unsigned path).
+ * - No trusted authorities configured but the manifest claims to be signed ⇒
+ *   rejected (cannot verify a signed manifest with no anchor).
+ * - Trusted authorities configured ⇒ the manifest MUST carry a matching
+ *   `authority` + a `signature` that verifies; otherwise rejected.
+ */
+export declare function verifyTeeRevocationManifest(manifest: TeeRevocationManifest, options: TeeRevocationVerificationOptions): TeeRevocationVerificationResult;
+/**
+ * Deterministic JSON of the manifest body excluding `signature`. Object keys
+ * are sorted recursively so the signer and verifier serialize identical bytes.
+ */
+export declare function canonicalizeRevocationBody(manifest: TeeRevocationManifest): string;
+export type NormalizedTeeRevocations = Pick<TeeEvidencePolicy, "revokedMeasurements" | "revokedSecurityVersions">;
+export declare function mergeTeeRevocationsIntoPolicy(policy: TeeEvidencePolicy, manifest: TeeRevocationManifest | undefined): TeeEvidencePolicy;
+export declare function normalizeTeeRevocationManifest(manifest: TeeRevocationManifest): NormalizedTeeRevocations;
+//# sourceMappingURL=tee-revocation.d.ts.map

package/services/tee-revocation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tee-revocation.d.ts","sourceRoot":"","sources":["../../src/services/tee-revocation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEzD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,aAAa,EAAE,CAAC,CAAC;IACjB,yEAAyE;IACzE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,mBAAmB,CAAC,EAAE,OAAO,CAC3B,MAAM,CAAC,kBAAkB,EAAE,KAAK,CAAC,MAAM,GAAG,kBAAkB,CAAC,CAAC,CAC/D,CAAC;IACF,uBAAuB,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,kBAAkB,CAAC,CAAC;CAC9D,CAAC;AAEF,MAAM,MAAM,gCAAgC,GAAG;IAC7C;;;;;;OAMG;IACH,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC5C,CAAC;AAEF,MAAM,MAAM,+BAA+B,GACvC;IAAE,QAAQ,EAAE,IAAI,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GACtC;IACE,QAAQ,EAAE,KAAK,CAAC;IAChB,MAAM,EACF,mBAAmB,GACnB,mBAAmB,GACnB,qBAAqB,GACrB,mBAAmB,GACnB,eAAe,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEN;;;;;;;;;;GAUG;AACH,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,qBAAqB,EAC/B,OAAO,EAAE,gCAAgC,GACxC,+BAA+B,CAqDjC;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,qBAAqB,GAC9B,MAAM,CAGR;AAiBD,MAAM,MAAM,wBAAwB,GAAG,IAAI,CACzC,iBAAiB,EACjB,qBAAqB,GAAG,yBAAyB,CAClD,CAAC;AAEF,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,iBAAiB,EACzB,QAAQ,EAAE,qBAAqB,GAAG,SAAS,GAC1C,iBAAiB,CAcnB;AAED,wBAAgB,8BAA8B,CAC5C,QAAQ,EAAE,qBAAqB,GAC9B,wBAAwB,CAuB1B"}

package/services/tee-revocation.js

@@ -0,0 +1,150 @@
+import { createPublicKey, verify } from "node:crypto";
+/**
+ * Verify a revocation manifest's Ed25519 signature against a configured set of
+ * trusted authority keys. Fail-closed by construction:
+ *
+ * - No trusted authorities configured + manifest carries no `authority`/
+ *   `signature` ⇒ verified (local-dev unsigned path).
+ * - No trusted authorities configured but the manifest claims to be signed ⇒
+ *   rejected (cannot verify a signed manifest with no anchor).
+ * - Trusted authorities configured ⇒ the manifest MUST carry a matching
+ *   `authority` + a `signature` that verifies; otherwise rejected.
+ */
+export function verifyTeeRevocationManifest(manifest, options) {
+    const trusted = options.trustedAuthorities;
+    const anchorsConfigured = Object.keys(trusted).length > 0;
+    if (!anchorsConfigured) {
+        if (manifest.authority !== undefined || manifest.signature !== undefined) {
+            return {
+                verified: false,
+                reason: "untrusted-authority",
+                detail: "Manifest declares an authority/signature but no trusted authority key is configured.",
+            };
+        }
+        return { verified: true };
+    }
+    if (manifest.signature === undefined || manifest.signature.trim() === "") {
+        return { verified: false, reason: "unsigned-manifest" };
+    }
+    if (manifest.authority === undefined || manifest.authority.trim() === "") {
+        return { verified: false, reason: "missing-authority" };
+    }
+    const pem = trusted[manifest.authority];
+    if (pem === undefined) {
+        return {
+            verified: false,
+            reason: "untrusted-authority",
+            detail: `No trusted key for authority "${manifest.authority}".`,
+        };
+    }
+    let publicKey;
+    try {
+        publicKey = createPublicKey(pem);
+    }
+    catch (error) {
+        return {
+            verified: false,
+            reason: "malformed-key",
+            detail: error instanceof Error ? error.message : String(error),
+        };
+    }
+    const body = Buffer.from(canonicalizeRevocationBody(manifest), "utf8");
+    let signatureBytes;
+    try {
+        signatureBytes = Buffer.from(manifest.signature, "base64");
+    }
+    catch {
+        return { verified: false, reason: "invalid-signature" };
+    }
+    const ok = verify(null, body, publicKey, signatureBytes);
+    return ok
+        ? { verified: true, authority: manifest.authority }
+        : { verified: false, reason: "invalid-signature" };
+}
+/**
+ * Deterministic JSON of the manifest body excluding `signature`. Object keys
+ * are sorted recursively so the signer and verifier serialize identical bytes.
+ */
+export function canonicalizeRevocationBody(manifest) {
+    const { signature: _signature, ...body } = manifest;
+    return stableStringify(body);
+}
+function stableStringify(value) {
+    if (value === null || typeof value !== "object") {
+        return JSON.stringify(value) ?? "null";
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map(stableStringify).join(",")}]`;
+    }
+    const entries = Object.entries(value)
+        .filter(([, v]) => v !== undefined)
+        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+    return `{${entries
+        .map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`)
+        .join(",")}}`;
+}
+export function mergeTeeRevocationsIntoPolicy(policy, manifest) {
+    if (!manifest)
+        return policy;
+    const revocations = normalizeTeeRevocationManifest(manifest);
+    return {
+        ...policy,
+        revokedMeasurements: mergeRevokedMeasurements(policy.revokedMeasurements, revocations.revokedMeasurements),
+        revokedSecurityVersions: mergeNumbers(policy.revokedSecurityVersions, revocations.revokedSecurityVersions),
+    };
+}
+export function normalizeTeeRevocationManifest(manifest) {
+    const revokedMeasurements = {};
+    for (const [name, entries] of Object.entries(manifest.revokedMeasurements ?? {})) {
+        const values = entries
+            ?.map((entry) => normalizeRevocationValue(entry))
+            .filter((value) => typeof value === "string");
+        if (values !== undefined && values.length > 0) {
+            revokedMeasurements[name] = dedupeStrings(values);
+        }
+    }
+    const revokedSecurityVersions = dedupeNumbers((manifest.revokedSecurityVersions ?? [])
+        .map((entry) => normalizeRevocationValue(entry))
+        .filter((value) => typeof value === "number"));
+    return {
+        revokedMeasurements,
+        revokedSecurityVersions,
+    };
+}
+function normalizeRevocationValue(entry) {
+    if (typeof entry === "string")
+        return entry.trim() || undefined;
+    if (typeof entry === "number" && Number.isSafeInteger(entry))
+        return entry;
+    if (entry && typeof entry === "object") {
+        if (typeof entry.value === "string")
+            return entry.value.trim() || undefined;
+        if (typeof entry.value === "number" && Number.isSafeInteger(entry.value)) {
+            return entry.value;
+        }
+    }
+    return undefined;
+}
+function mergeRevokedMeasurements(left, right) {
+    const merged = {};
+    for (const [name, values] of Object.entries(left ?? {})) {
+        merged[name] = dedupeStrings(values ?? []);
+    }
+    for (const [name, values] of Object.entries(right ?? {})) {
+        merged[name] = dedupeStrings([...(merged[name] ?? []), ...(values ?? [])]);
+    }
+    return merged;
+}
+function mergeNumbers(left, right) {
+    return dedupeNumbers([...(left ?? []), ...(right ?? [])]);
+}
+function dedupeStrings(values) {
+    return [
+        ...new Set(values.filter((value) => value.trim()).map((value) => value.trim())),
+    ];
+}
+function dedupeNumbers(values) {
+    return [
+        ...new Set(values.filter((value) => Number.isSafeInteger(value) && value >= 0)),
+    ].sort((a, b) => a - b);
+}

package/services/tee-runtime-config.d.ts

@@ -0,0 +1,9 @@
+import type { TeeEvidencePolicy } from "./tee-policy.ts";
+export type TeeRuntimeConfigEnv = Record<string, string | undefined>;
+export type ResolveTeeRuntimePolicyOptions = {
+    env?: TeeRuntimeConfigEnv;
+    readText?: (path: string) => Promise<string>;
+    nowMs?: number;
+};
+export declare function resolveTeeRuntimePolicy(options?: ResolveTeeRuntimePolicyOptions): Promise<TeeEvidencePolicy | undefined>;
+//# sourceMappingURL=tee-runtime-config.d.ts.map

package/services/tee-runtime-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tee-runtime-config.d.ts","sourceRoot":"","sources":["../../src/services/tee-runtime-config.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAWzD,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;AAErE,MAAM,MAAM,8BAA8B,GAAG;IAC3C,GAAG,CAAC,EAAE,mBAAmB,CAAC;IAC1B,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IAC7C,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,wBAAsB,uBAAuB,CAC3C,OAAO,GAAE,8BAAmC,GAC3C,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC,CA+DxC"}