@elizaos/agent 2.0.0-beta.2 → 2.0.11-beta.6

package/services/tee-confidential-inference.js

@@ -0,0 +1,254 @@
+import { createCipheriv, createDecipheriv, createHash, randomBytes, timingSafeEqual, } from "node:crypto";
+/**
+ * Confidential-inference unseal path (plan §2.2 steps 4–7).
+ *
+ * Releases the `model-key` only after the TEE key-release client's evidence
+ * satisfies the policy, then decrypts the at-rest weights blob in process
+ * memory and hands the plaintext to the in-domain model runtime. The plaintext
+ * weights and the model key never touch disk, env, or the structured logger.
+ *
+ * HARDWARE BOUNDARY (fail-closed): real TDX/CoVE quote-signature verification
+ * is BLOCKED on hardware (plan Phase B2/C1). This path verifies a normalized
+ * evidence document + nonce binding + measurement match only. It must not be
+ * presented as hardware-verified trust until B2/C1 land. If the key-release
+ * client rejects the evidence, no key is returned, the ciphertext stays sealed,
+ * and unseal throws — the negative path is enforced by data unavailability,
+ * not by a software flag that could be patched out.
+ */
+export const MODEL_KEY_ID = "model-key";
+const DEFAULT_INFERENCE_TOPOLOGY = "local";
+/**
+ * Fail-closed gate binding private inference to the confidential-I/O attestation
+ * lane (plan §2.4, Phase C item C2). For the local topology this enforces that
+ * the policy will only release the `model-key` against evidence that proves the
+ * NPU confidential-I/O lane is active:
+ *
+ *   - `requiredClaims.npuProtected === true`, and
+ *   - `requiredMeasurements.npuFirmware` is a non-empty golden digest.
+ *
+ * For the cloud topology it enforces the H100 confidential-GPU equivalent
+ * (`gpuProtected` + `gpuFirmware`). This is an explicit, reusable assertion so
+ * "no NPU/GPU confidential-I/O attestation ⇒ no private inference" is enforced
+ * at the unseal seam, not left as an implicit production-profile default a
+ * caller could forget. It checks that the *policy itself* will demand these
+ * gates; `evaluateTeeEvidencePolicy` then enforces them against the evidence at
+ * release time. It throws (fails closed) on any gap.
+ */
+export function assertNpuPrivateInferenceAllowed(policy, topology = DEFAULT_INFERENCE_TOPOLOGY) {
+    const claim = topology === "local" ? "npuProtected" : "gpuProtected";
+    const firmware = topology === "local" ? "npuFirmware" : "gpuFirmware";
+    if (policy.requiredClaims?.[claim] !== true) {
+        throw new Error(`private inference (${topology}) requires the policy to gate claim "${claim}" === true; ` +
+            "refusing to release model-key without the confidential-I/O attestation.");
+    }
+    const digest = policy.requiredMeasurements?.[firmware];
+    if (typeof digest !== "string" || digest.trim() === "") {
+        throw new Error(`private inference (${topology}) requires the policy to gate a non-empty "${firmware}" measurement; ` +
+            "refusing to release model-key without the confidential-I/O firmware golden digest.");
+    }
+}
+/**
+ * Request `model-key`, verify the policy gates the required measurements, then
+ * decrypt the sealed weights in memory. Fails closed on any gap.
+ */
+export async function unsealModelWeights(config) {
+    assertNpuPrivateInferenceAllowed(config.policy, config.topology ?? DEFAULT_INFERENCE_TOPOLOGY);
+    assertPolicyGatesRequiredMeasurements(config.policy, config.requiredMeasurements);
+    assertPolicyBindsWeightsDigest(config.policy, config.sealedWeights.weightsSha256);
+    const release = await config.keyReleaseClient.releaseKey({
+        keyId: MODEL_KEY_ID,
+        ...(config.context === undefined ? {} : { context: config.context }),
+        policy: config.policy,
+    });
+    if (!release.decision.trusted) {
+        throw new Error(`model-key release denied: ${release.decision.detail ?? release.decision.reason}`);
+    }
+    const key = Buffer.from(release.keyMaterialHex, "hex");
+    if (key.length !== 32) {
+        throw new Error("model-key material must be 32 bytes for AES-256-GCM.");
+    }
+    try {
+        const weights = decryptSealedWeights(config.sealedWeights, key);
+        const actualDigest = createHash("sha256").update(weights).digest("hex");
+        if (!digestsEqual(actualDigest, config.sealedWeights.weightsSha256)) {
+            weights.fill(0);
+            throw new Error("Decrypted model weights digest does not match the sealed manifest.");
+        }
+        return {
+            weights,
+            decision: release.decision,
+            weightsSha256: actualDigest,
+        };
+    }
+    finally {
+        key.fill(0);
+    }
+}
+/**
+ * Streaming per-shard unseal (plan §8 recommendation). Applies the same
+ * fail-closed gates as {@link unsealModelWeights}, then decrypts shards strictly
+ * in order, handing each plaintext shard to `onShard` and zeroizing it before
+ * decrypting the next — so the full plaintext is never assembled in memory. A
+ * running SHA-256 over the concatenated plaintext is verified against the
+ * manifest `weightsSha256` at the end (defense in depth). On any failure all
+ * transient buffers and the key material are zeroized and the call throws.
+ */
+export async function unsealModelWeightsStreaming(config, onShard) {
+    assertNpuPrivateInferenceAllowed(config.policy, config.topology ?? DEFAULT_INFERENCE_TOPOLOGY);
+    assertPolicyGatesRequiredMeasurements(config.policy, config.requiredMeasurements);
+    assertPolicyBindsWeightsDigest(config.policy, config.sealedWeights.weightsSha256);
+    if (config.sealedWeights.algorithm !== "aes-256-gcm") {
+        throw new Error(`Unsupported sealed-weights algorithm "${config.sealedWeights.algorithm}".`);
+    }
+    const shards = assertOrderedShards(config.sealedWeights.shards);
+    const release = await config.keyReleaseClient.releaseKey({
+        keyId: MODEL_KEY_ID,
+        ...(config.context === undefined ? {} : { context: config.context }),
+        policy: config.policy,
+    });
+    if (!release.decision.trusted) {
+        throw new Error(`model-key release denied: ${release.decision.detail ?? release.decision.reason}`);
+    }
+    const key = Buffer.from(release.keyMaterialHex, "hex");
+    if (key.length !== 32) {
+        throw new Error("model-key material must be 32 bytes for AES-256-GCM.");
+    }
+    try {
+        const running = createHash("sha256");
+        for (const shard of shards) {
+            // Only one plaintext shard exists at a time; it is zeroized below before
+            // the loop advances, so no full-plaintext buffer is ever assembled here.
+            const bytes = decryptAesGcmSegment(shard, key);
+            try {
+                const shardDigest = createHash("sha256").update(bytes).digest("hex");
+                if (!digestsEqual(shardDigest, shard.plaintextSha256)) {
+                    throw new Error(`Decrypted shard ${shard.index} digest does not match the sealed manifest.`);
+                }
+                running.update(bytes);
+                await onShard({ index: shard.index, bytes });
+            }
+            finally {
+                bytes.fill(0);
+            }
+        }
+        const actualDigest = running.digest("hex");
+        if (!digestsEqual(actualDigest, config.sealedWeights.weightsSha256)) {
+            throw new Error("Reassembled model weights digest does not match the sealed manifest.");
+        }
+        return {
+            decision: release.decision,
+            weightsSha256: actualDigest,
+            shardCount: shards.length,
+        };
+    }
+    finally {
+        key.fill(0);
+    }
+}
+/**
+ * Seal `weights` into a per-shard {@link SealedWeightsManifest} under `key`,
+ * splitting into `shardSizeBytes`-sized shards (the last may be smaller). Each
+ * shard gets a fresh 12-byte IV. Used by tests and any real packer; reuses the
+ * single-blob crypto patterns.
+ */
+export function sealModelWeightsShards(input) {
+    if (input.key.length !== 32) {
+        throw new Error("seal key must be 32 bytes for AES-256-GCM.");
+    }
+    if (!Number.isInteger(input.shardSizeBytes) || input.shardSizeBytes <= 0) {
+        throw new Error("shardSizeBytes must be a positive integer.");
+    }
+    if (input.weights.length === 0) {
+        throw new Error("cannot seal empty weights.");
+    }
+    const shards = [];
+    let index = 0;
+    for (let offset = 0; offset < input.weights.length; offset += input.shardSizeBytes) {
+        const plaintext = input.weights.subarray(offset, Math.min(offset + input.shardSizeBytes, input.weights.length));
+        const iv = randomBytes(12);
+        const cipher = createCipheriv("aes-256-gcm", input.key, iv);
+        const ciphertext = Buffer.concat([
+            cipher.update(plaintext),
+            cipher.final(),
+        ]);
+        shards.push({
+            index,
+            ivBase64: iv.toString("base64"),
+            authTagBase64: cipher.getAuthTag().toString("base64"),
+            ciphertextBase64: ciphertext.toString("base64"),
+            plaintextSha256: createHash("sha256").update(plaintext).digest("hex"),
+        });
+        index += 1;
+    }
+    return {
+        algorithm: "aes-256-gcm",
+        weightsSha256: createHash("sha256").update(input.weights).digest("hex"),
+        shards,
+    };
+}
+/**
+ * Verify shards form a contiguous 0-based sequence and return them sorted by
+ * `index` so decryption proceeds strictly in plaintext order.
+ */
+function assertOrderedShards(shards) {
+    if (shards.length === 0) {
+        throw new Error("sealed-weights manifest has no shards.");
+    }
+    const ordered = [...shards].sort((a, b) => a.index - b.index);
+    ordered.forEach((shard, position) => {
+        if (shard.index !== position) {
+            throw new Error(`sealed-weights shard indices must be contiguous from 0; got index ${shard.index} at position ${position}.`);
+        }
+    });
+    return ordered;
+}
+/** Constant-time hex-digest comparison after normalizing the `sha256:` prefix. */
+function digestsEqual(a, b) {
+    const left = Buffer.from(normalizeDigestHex(a), "hex");
+    const right = Buffer.from(normalizeDigestHex(b), "hex");
+    return left.length === right.length && timingSafeEqual(left, right);
+}
+/**
+ * Decrypt one AES-256-GCM segment (IV + auth tag + ciphertext, all base64). GCM
+ * auth-tag verification throws on tampered ciphertext or a wrong/mismatched key,
+ * so this can never silently yield garbage plaintext. Shared by the single-blob
+ * and per-shard paths.
+ */
+function decryptAesGcmSegment(segment, key) {
+    const iv = Buffer.from(segment.ivBase64, "base64");
+    if (iv.length !== 12) {
+        throw new Error("AES-256-GCM IV must be 12 bytes.");
+    }
+    const authTag = Buffer.from(segment.authTagBase64, "base64");
+    const ciphertext = Buffer.from(segment.ciphertextBase64, "base64");
+    const decipher = createDecipheriv("aes-256-gcm", key, iv);
+    decipher.setAuthTag(authTag);
+    return Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+}
+function decryptSealedWeights(blob, key) {
+    if (blob.algorithm !== "aes-256-gcm") {
+        throw new Error(`Unsupported sealed-weights algorithm "${blob.algorithm}".`);
+    }
+    return decryptAesGcmSegment(blob, key);
+}
+function assertPolicyGatesRequiredMeasurements(policy, required) {
+    const gated = policy.requiredMeasurements ?? {};
+    const missing = required.filter((name) => typeof gated[name] !== "string" || gated[name]?.trim() === "");
+    if (missing.length > 0) {
+        throw new Error(`model-key policy does not gate required measurements: ${missing.join(", ")}.`);
+    }
+}
+function assertPolicyBindsWeightsDigest(policy, weightsSha256) {
+    const expected = policy.requiredMeasurements?.modelWeights;
+    if (expected === undefined)
+        return;
+    if (normalizeDigestHex(expected) !== normalizeDigestHex(weightsSha256)) {
+        throw new Error("model-key policy modelWeights digest does not match the sealed weights blob.");
+    }
+}
+function normalizeDigestHex(value) {
+    const trimmed = value.trim().toLowerCase();
+    return trimmed.startsWith("sha256:")
+        ? trimmed.slice("sha256:".length)
+        : trimmed;
+}

package/services/tee-evidence.d.ts

@@ -0,0 +1,46 @@
+export type TeeKind = "tdx" | "sev-snp" | "nitro" | "cove" | "keystone" | "optee" | "dstack" | "eliza-vault" | "none" | (string & {});
+export type TeeMeasurementName = "boot" | "os" | "agent" | "policy" | "device" | "container" | "compose" | "monitor" | "modelWeights" | "npuFirmware" | "gpuFirmware" | (string & {});
+export type TeeMeasurements = Partial<Record<TeeMeasurementName, string>>;
+export type TeeClaims = {
+    debugDisabled?: boolean;
+    productionLifecycle?: boolean;
+    secureBoot?: boolean;
+    memoryEncrypted?: boolean;
+    ioProtected?: boolean;
+    gpuProtected?: boolean;
+    npuProtected?: boolean;
+    /**
+     * The on-device M-mode TSM/security-monitor was measured and folded into the
+     * DICE chain (CoVE path). Mirrors the `monitor` measurement; required by the
+     * confidential-channel OS release manifest so the tiny TCB cannot be swapped.
+     */
+    monitorMeasured?: boolean;
+};
+export type TeeFreshness = {
+    nonce?: string;
+    timestamp?: string;
+    verifier?: string;
+};
+export type TeeEvidence = {
+    kind: TeeKind;
+    provider?: string;
+    hardwareVendor?: string;
+    platformVersion?: string;
+    securityVersion?: number;
+    measurements?: TeeMeasurements;
+    freshness?: TeeFreshness;
+    claims?: TeeClaims;
+    quote?: string;
+    certificatePem?: string;
+    reportData?: string;
+    raw?: unknown;
+};
+export type TeeEvidenceProvider = {
+    id: string;
+    collectEvidence: () => Promise<TeeEvidence>;
+};
+export declare function isTeeEvidence(value: unknown): value is TeeEvidence;
+export declare function normalizeTeeEvidence(value: unknown): TeeEvidence;
+export declare function teeMeasurementDigestMatches(actual: string | undefined, expected: string | undefined): boolean;
+export declare function normalizeDigest(value: string): string;
+//# sourceMappingURL=tee-evidence.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tee-evidence.d.ts","sourceRoot":"","sources":["../../src/services/tee-evidence.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,OAAO,GACf,KAAK,GACL,SAAS,GACT,OAAO,GACP,MAAM,GACN,UAAU,GACV,OAAO,GACP,QAAQ,GACR,aAAa,GACb,MAAM,GACN,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;AAElB,MAAM,MAAM,kBAAkB,GAC1B,MAAM,GACN,IAAI,GACJ,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,WAAW,GACX,SAAS,GACT,SAAS,GACT,cAAc,GACd,aAAa,GACb,aAAa,GACb,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;AAElB,MAAM,MAAM,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC,kBAAkB,EAAE,MAAM,CAAC,CAAC,CAAC;AAE1E,MAAM,MAAM,SAAS,GAAG;IACtB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;;;OAIG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,eAAe,CAAC;IAC/B,SAAS,CAAC,EAAE,YAAY,CAAC;IACzB,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,GAAG,CAAC,EAAE,OAAO,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,eAAe,EAAE,MAAM,OAAO,CAAC,WAAW,CAAC,CAAC;CAC7C,CAAC;AAEF,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,WAAW,CAGlE;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,CAuChE;AAED,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,QAAQ,EAAE,MAAM,GAAG,SAAS,GAC3B,OAAO,CAIT;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAKrD"}

package/services/tee-evidence.js

@@ -0,0 +1,149 @@
+export function isTeeEvidence(value) {
+    if (!isRecord(value))
+        return false;
+    return typeof value.kind === "string" && value.kind.trim().length > 0;
+}
+export function normalizeTeeEvidence(value) {
+    if (!isRecord(value)) {
+        throw new Error("TEE evidence must be an object.");
+    }
+    const kind = readRequiredString(value, "kind");
+    return {
+        kind,
+        ...(readOptionalString(value, "provider") === undefined
+            ? {}
+            : { provider: readOptionalString(value, "provider") }),
+        ...(readOptionalString(value, "hardwareVendor") === undefined
+            ? {}
+            : { hardwareVendor: readOptionalString(value, "hardwareVendor") }),
+        ...(readOptionalString(value, "platformVersion") === undefined
+            ? {}
+            : { platformVersion: readOptionalString(value, "platformVersion") }),
+        ...(readOptionalInteger(value, "securityVersion") === undefined
+            ? {}
+            : { securityVersion: readOptionalInteger(value, "securityVersion") }),
+        ...(normalizeMeasurements(value.measurements) === undefined
+            ? {}
+            : { measurements: normalizeMeasurements(value.measurements) }),
+        ...(normalizeFreshness(value.freshness) === undefined
+            ? {}
+            : { freshness: normalizeFreshness(value.freshness) }),
+        ...(normalizeClaims(value.claims) === undefined
+            ? {}
+            : { claims: normalizeClaims(value.claims) }),
+        ...(readOptionalString(value, "quote") === undefined
+            ? {}
+            : { quote: readOptionalString(value, "quote") }),
+        ...(readOptionalString(value, "certificatePem") === undefined
+            ? {}
+            : { certificatePem: readOptionalString(value, "certificatePem") }),
+        ...(readOptionalString(value, "reportData") === undefined
+            ? {}
+            : { reportData: readOptionalString(value, "reportData") }),
+        raw: value,
+    };
+}
+export function teeMeasurementDigestMatches(actual, expected) {
+    if (expected === undefined)
+        return true;
+    if (actual === undefined)
+        return false;
+    return normalizeDigest(actual) === normalizeDigest(expected);
+}
+export function normalizeDigest(value) {
+    const trimmed = value.trim().toLowerCase();
+    return trimmed.startsWith("sha256:")
+        ? trimmed.slice("sha256:".length)
+        : trimmed;
+}
+function normalizeMeasurements(value) {
+    if (value === undefined)
+        return undefined;
+    if (!isRecord(value)) {
+        throw new Error("TEE evidence measurements must be an object.");
+    }
+    const measurements = {};
+    for (const [key, raw] of Object.entries(value)) {
+        if (typeof raw !== "string") {
+            throw new Error(`TEE measurement "${key}" must be a string.`);
+        }
+        const next = raw.trim();
+        if (next.length > 0) {
+            measurements[key] = next;
+        }
+    }
+    return Object.keys(measurements).length === 0 ? undefined : measurements;
+}
+function normalizeFreshness(value) {
+    if (value === undefined)
+        return undefined;
+    if (!isRecord(value)) {
+        throw new Error("TEE evidence freshness must be an object.");
+    }
+    const freshness = {};
+    const nonce = readOptionalString(value, "nonce");
+    const timestamp = readOptionalString(value, "timestamp");
+    const verifier = readOptionalString(value, "verifier");
+    if (nonce !== undefined)
+        freshness.nonce = nonce;
+    if (timestamp !== undefined)
+        freshness.timestamp = timestamp;
+    if (verifier !== undefined)
+        freshness.verifier = verifier;
+    return Object.keys(freshness).length === 0 ? undefined : freshness;
+}
+function normalizeClaims(value) {
+    if (value === undefined)
+        return undefined;
+    if (!isRecord(value)) {
+        throw new Error("TEE evidence claims must be an object.");
+    }
+    const claims = {};
+    for (const key of [
+        "debugDisabled",
+        "productionLifecycle",
+        "secureBoot",
+        "memoryEncrypted",
+        "ioProtected",
+        "gpuProtected",
+        "npuProtected",
+        "monitorMeasured",
+    ]) {
+        if (value[key] === undefined)
+            continue;
+        if (typeof value[key] !== "boolean") {
+            throw new Error(`TEE claim "${key}" must be boolean.`);
+        }
+        claims[key] = value[key];
+    }
+    return Object.keys(claims).length === 0 ? undefined : claims;
+}
+function readRequiredString(value, key) {
+    const result = readOptionalString(value, key);
+    if (result === undefined) {
+        throw new Error(`TEE evidence field "${key}" is required.`);
+    }
+    return result;
+}
+function readOptionalString(value, key) {
+    const raw = value[key];
+    if (raw === undefined)
+        return undefined;
+    if (typeof raw !== "string") {
+        throw new Error(`TEE evidence field "${key}" must be a string.`);
+    }
+    const trimmed = raw.trim();
+    return trimmed.length === 0 ? undefined : trimmed;
+}
+function readOptionalInteger(value, key) {
+    const raw = value[key];
+    if (raw === undefined)
+        return undefined;
+    if (typeof raw !== "number" || !Number.isInteger(raw)) {
+        throw new Error(`TEE evidence field "${key}" must be an integer.`);
+    }
+    return raw;
+}
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}

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

@@ -0,0 +1,100 @@
+import type { TeeEvidence, TeeEvidenceProvider } from "./tee-evidence.ts";
+import { type TeeEvidencePolicy, type TeeEvidencePolicyDecision } from "./tee-policy.ts";
+export type TeeKeyReleaseRequest = {
+    keyId: string;
+    context?: string;
+    policy: TeeEvidencePolicy;
+};
+export type TeeKeyReleaseResult = {
+    keyId: string;
+    keyMaterialHex: string;
+    decision: TeeEvidencePolicyDecision;
+};
+export type TeeKeyReleaseClient = {
+    releaseKey: (request: TeeKeyReleaseRequest) => Promise<TeeKeyReleaseResult>;
+};
+/**
+ * A provider that can re-collect evidence bound to a freshly issued
+ * `report_data`. Real in-domain attestation agents accept a `reportData`
+ * input and emit a quote whose `report_data` field equals it. The local
+ * stand-in simply stamps it onto the evidence so the binding can be unit
+ * tested without hardware.
+ */
+export type TeeReportDataChallenge = {
+    /** Fresh verifier nonce the agent issued for this release request. */
+    nonce: string;
+    /** report_data = SHA256(nonce || epk_pub) the quote must be bound to. */
+    reportDataHex: string;
+};
+export type TeeReportDataBoundEvidenceProvider = TeeEvidenceProvider & {
+    collectEvidenceWithReportData?: (challenge: TeeReportDataChallenge) => Promise<TeeEvidence>;
+};
+export type LocalTeeKeyReleaseClientConfig = {
+    evidenceProvider: TeeEvidenceProvider;
+    masterSecretHex?: string;
+    onDecision?: (decision: TeeEvidencePolicyDecision) => void;
+};
+export type HttpTeeKeyReleaseClientConfig = {
+    baseUrl: string;
+    evidenceProvider: TeeReportDataBoundEvidenceProvider;
+    fetch?: typeof fetch;
+    token?: string;
+    onDecision?: (decision: TeeEvidencePolicyDecision) => void;
+    env?: Record<string, string | undefined>;
+    /**
+     * Require RA-TLS-grade transport: refuse plain `http:` KMS URLs and refuse
+     * to run while `NODE_TLS_REJECT_UNAUTHORIZED=0`. Set by the production
+     * profile. Defends against dstack #609 (KMS attestation bypass via a
+     * disabled-TLS gateway).
+     */
+    requireSecureTransport?: boolean;
+};
+/**
+ * LOCAL/DEV ONLY. An HMAC KDF that models "deterministic app-key bound to
+ * measured identity". It is NOT a KMS: the master secret lives in agent
+ * memory. It must never be used under a production profile — the boot gate
+ * routes production through {@link HttpTeeKeyReleaseClient} against a real
+ * RA-TLS KMS. Kept solely as a hardware-free stand-in for unit tests and the
+ * local harness.
+ */
+export declare class LocalTeeKeyReleaseClient implements TeeKeyReleaseClient {
+    private readonly config;
+    readonly mode: "local-dev-kdf";
+    private readonly masterSecret;
+    constructor(config: LocalTeeKeyReleaseClientConfig);
+    releaseKey(request: TeeKeyReleaseRequest): Promise<TeeKeyReleaseResult>;
+}
+export declare class HttpTeeKeyReleaseClient implements TeeKeyReleaseClient {
+    private readonly config;
+    private readonly baseUrl;
+    private readonly request;
+    constructor(config: HttpTeeKeyReleaseClientConfig);
+    releaseKey(request: TeeKeyReleaseRequest): Promise<TeeKeyReleaseResult>;
+}
+/**
+ * A key wrapped to the requesting agent's ephemeral X25519 public key. The KMS
+ * performs X25519 ECDH against the agent's epk, derives an AES-256 key with
+ * HKDF-SHA256 (salted by the request nonce), and AES-256-GCM-encrypts the
+ * released key material. Only the holder of the ephemeral private key (the
+ * in-domain agent) can unwrap it.
+ */
+export type WrappedTeeKey = {
+    algorithm: "x25519-hkdf-sha256-aes-256-gcm";
+    /** KMS ephemeral X25519 public key, base64 SPKI DER. */
+    kmsEphemeralPublicKey: string;
+    ivBase64: string;
+    authTagBase64: string;
+    ciphertextBase64: string;
+};
+/**
+ * KMS-side helper: wrap `keyMaterialHex` to the agent's ephemeral public key.
+ * Exported so a real KMS adapter, the local harness, and tests produce the
+ * exact wire shape {@link HttpTeeKeyReleaseClient} unwraps. The wrap key is
+ * zeroized after use.
+ */
+export declare function wrapTeeReleaseKey(options: {
+    keyMaterialHex: string;
+    agentEphemeralPublicKeyDerBase64: string;
+    nonceHex: string;
+}): WrappedTeeKey;
+//# sourceMappingURL=tee-key-release.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tee-key-release.d.ts","sourceRoot":"","sources":["../../src/services/tee-key-release.ts"],"names":[],"mappings":"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"}