@counterfact-labs/cli 0.1.2 → 0.2.3

package/dist/gatekeeper/connection.js

@@ -0,0 +1,140 @@
+import { isLoopbackHost } from "./loopback.js";
+import { randomBytes, X509Certificate } from "node:crypto";
+import { Agent, request as httpsRequest } from "node:https";
+import { connect } from "node:tls";
+import { PRODUCTION_EVIDENCE_VERSION, RELAY_MAX_FRAME_BYTES, RELAY_URL } from "../contract/messages.js";
+import { requestBoundedResponse } from "../transport/http-response.js";
+import { relayExportedKeyMaterial } from "../transport/tls-exporter.js";
+import { createRelayExchange, RelayConnectionError } from "./connection-exchange.js";
+export { RelayConnectionError } from "./connection-exchange.js";
+import { verifyProductionAttestation } from "./production-attestation.js";
+import { verifyAttestation } from "./attestation.js";
+import { validateProductionTrust } from "./trust/policy.js";
+export function relayOrigin(value) {
+    const origin = new URL(value);
+    if (origin.protocol !== "https:" || origin.username || origin.password || origin.pathname !== "/" || origin.search || origin.hash)
+        throw new Error();
+    return origin;
+}
+/** A self-signed leaf establishes encryption provisionally; the selected attestation policy authenticates the workload. */
+export async function connectRelay(url = RELAY_URL, policy) {
+    let socket, agent;
+    let closed = false, expiryTimer;
+    const close = () => {
+        closed = true;
+        clearTimeout(expiryTimer);
+        agent?.destroy();
+        socket?.destroy();
+    };
+    try {
+        const trust = policy.development ? undefined : validateProductionTrust(policy.trust);
+        const origin = relayOrigin(url);
+        const timeoutMs = policy.timeoutMs ?? 30_000;
+        const nowMs = policy.now ? () => policy.now() * 1000 : Date.now;
+        const now = () => Math.floor(nowMs() / 1000);
+        if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 120_000)
+            throw new Error();
+        let hostname = origin.hostname.replace(/^\[|\]$/g, "");
+        if (policy.development) {
+            if (!policy.development.allowDevelopment || policy.trust ||
+                !isLoopbackHost(hostname))
+                throw new Error();
+            // Resolve the conventional name locally so DNS cannot move development trust off the machine.
+            if (hostname === "localhost")
+                hostname = "127.0.0.1";
+        }
+        socket = await new Promise((resolve, reject) => {
+            // Attestation authenticates this exact TLS socket before any customer request is sent.
+            // nosemgrep: problem-based-packs.insecure-transport.js-node.bypass-tls-verification.bypass-tls-verification
+            const provisional = connect({ host: hostname, port: Number(origin.port || 443),
+                rejectUnauthorized: false, minVersion: "TLSv1.3", ALPNProtocols: ["http/1.1"] });
+            // Install ownership before connection establishment so even a handshake timeout destroys the socket.
+            socket = provisional;
+            const timer = setTimeout(() => { provisional.destroy(); reject(new RelayConnectionError()); }, timeoutMs);
+            provisional.once("error", () => { clearTimeout(timer); reject(new RelayConnectionError()); });
+            provisional.once("close", () => { clearTimeout(timer); reject(new RelayConnectionError()); });
+            provisional.once("secureConnect", () => { clearTimeout(timer); resolve(provisional); });
+        });
+        socket.on("error", close);
+        socket.once("close", close);
+        socket.disableRenegotiation();
+        // A new handshake must never replace exporter material on an authenticated socket.
+        socket.on("secure", close);
+        if (closed || socket.destroyed || (socket.alpnProtocol && socket.alpnProtocol !== "http/1.1"))
+            throw new Error();
+        const actualSocket = socket;
+        const exportedKeyMaterial = relayExportedKeyMaterial(actualSocket);
+        // The agent may hand out this socket once. It has no path that dials a replacement connection.
+        agent = new Agent({ keepAlive: true, maxSockets: 1, maxCachedSessions: 0 });
+        let assigned = false;
+        agent.createConnection = () => {
+            if (assigned || closed || actualSocket.destroyed)
+                throw new RelayConnectionError();
+            assigned = true;
+            return actualSocket;
+        };
+        let expires = 0;
+        const valid = () => {
+            if (closed || actualSocket.destroyed || expires <= now())
+                throw new RelayConnectionError();
+        };
+        async function exchange(path, input, maxBytes, authenticated, waitMs = timeoutMs) {
+            if (authenticated)
+                valid();
+            if (closed || actualSocket.destroyed)
+                throw new RelayConnectionError();
+            const body = JSON.stringify(input);
+            if (Buffer.byteLength(body) > RELAY_MAX_FRAME_BYTES)
+                throw new RelayConnectionError();
+            const developmentAttestation = !!policy.development && path === "/attestation";
+            try {
+                const result = await requestBoundedResponse(receive => {
+                    const req = httpsRequest({ hostname, port: origin.port || 443, method: developmentAttestation ? "GET" : "POST", path, agent,
+                        maxHeaderSize: 16 * 1024,
+                        headers: { "content-type": "application/json", "content-length": developmentAttestation ? 0 : Buffer.byteLength(body), "cache-control": "no-store" } }, receive);
+                    req.on("socket", supplied => { if (supplied !== actualSocket)
+                        req.destroy(new RelayConnectionError()); });
+                    return req;
+                }, { maxBytes, timeoutMs: waitMs, bodyTimeoutMs: timeoutMs, requestBody: developmentAttestation ? "" : body, validate: response => {
+                        const status = response.statusCode ?? 0;
+                        if (response.socket !== actualSocket || (status !== 200 && !(path === "/delivery" && status === 503)) ||
+                            !(developmentAttestation ? /^application\/jwt(?:;|$)/i : /^application\/json(?:;|$)/i).test(response.headers["content-type"] ?? ""))
+                            throw new Error();
+                    } });
+                if (authenticated)
+                    valid();
+                const text = new TextDecoder("utf-8", { fatal: true }).decode(result.body);
+                const answer = developmentAttestation ? text : JSON.parse(text);
+                return { status: result.response.statusCode ?? 0, body: answer };
+            }
+            catch {
+                close();
+                throw new RelayConnectionError();
+            }
+        }
+        const challenge = randomBytes(32).toString("hex");
+        const challengeStarted = nowMs();
+        const challengeStartedMonotonic = performance.now();
+        const result = await exchange("/attestation", { version: PRODUCTION_EVIDENCE_VERSION, challenge }, 40 * 1024, false);
+        const verified = policy.development
+            ? verifyAttestation(result.body, new X509Certificate(actualSocket.getPeerCertificate().raw).publicKey, policy.development, now())
+            : await verifyProductionAttestation(result.body, { exportedKeyMaterial, challenge }, trust, now());
+        if (nowMs() < challengeStarted || nowMs() - challengeStarted >= timeoutMs ||
+            performance.now() - challengeStartedMonotonic >= timeoutMs)
+            throw new Error();
+        expires = verified.exp;
+        valid();
+        expiryTimer = setTimeout(close, Math.max(1, (expires - now()) * 1000));
+        expiryTimer.unref();
+        return {
+            get attestedImageDigest() { return verified.imageDigest; },
+            send: createRelayExchange({ development: !!policy.development, valid, close, remainingEvidenceMs: () => Math.max(1, (expires - now()) * 1000),
+                exchange: (path, input, maxBytes, waitMs) => exchange(path, input, maxBytes, true, waitMs) }),
+            close,
+        };
+    }
+    catch {
+        close();
+        throw new RelayConnectionError();
+    }
+}

package/dist/gatekeeper/console.js

@@ -0,0 +1,168 @@
+import { consoleSchemeAllowed } from "../contract/console-url.js";
+import { request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
+import { CLI_VERSION } from "../contract/cli-version.js";
+import { cliRefusals, FINISH_FAILURE_MESSAGE, RESERVATION_EXPIRED_MESSAGE, RESULTS_TOO_LARGE_MESSAGE, START_FAILURE_MESSAGE } from "../contract/cli-refusals.js";
+import { cliRelayReservationRequestSchema, consoleCreatedSchema, consoleIntakeResultSchema, consoleReservationSchema, consoleStatusSchema, LOCAL_FINDINGS_BODY_LIMIT, localFindingsPayloadSchema, LOCAL_START_BODY_LIMIT, LOCAL_START_EXECUTION_HEADER, localStartRequestSchema, localStartResponseSchema } from "../contract/console.js";
+const RESPONSE_LIMIT = 64 * 1024;
+const RESERVATION_BODY_LIMIT = 64 * 1024;
+const messages = {
+    ...cliRefusals,
+    invalid_configuration: START_FAILURE_MESSAGE,
+    invalid_request: FINISH_FAILURE_MESSAGE,
+    unavailable: "The results couldn't be saved yet. Run the analysis on the same folder again to save them; you won't be charged again.",
+    unauthorized: "Your sign-in has expired. Run counterfact-labs login, then try again.",
+    not_allowed: "Your account can't run analyses. Ask Counterfact for access.",
+    not_found: "Counterfact couldn't find this analysis. Start a new analysis.",
+    rate_limited: "Counterfact is busy. Try again in a minute.",
+    reservation_closed: "The analysis ended before its results were saved. Start a new analysis.",
+    reservation_closing: "The results are still being saved. Run the analysis on the same folder again in a minute.",
+    delivery_incomplete: "The analysis ended before its results were saved. Start a new analysis.",
+    check_conflict: "Saved results from an earlier run don't match this analysis. Start a new analysis.",
+};
+export class ConsoleError extends Error {
+    code;
+    constructor(code = "unavailable", context) {
+        super(context === "start" && (code === "unavailable" || code === "invalid_request" || code === "not_found") ? START_FAILURE_MESSAGE
+            : context === "intake" && code === "reservation_expired" ? RESERVATION_EXPIRED_MESSAGE
+                // Only saving results can be too large; a rejected status, heartbeat or fail request just could not finish.
+                : context === "intake" && code === "invalid_request" ? RESULTS_TOO_LARGE_MESSAGE : messages[code]);
+        this.name = "ConsoleError";
+        this.code = code;
+    }
+}
+export const isConsoleToken = (token) => /^[\x21-\x7e]{1,4096}$/.test(token);
+/** Only this client may send repository metadata, content-free lifecycle or findings-only intake payloads to the console. */
+export class ConsoleClient {
+    #url;
+    #token;
+    #timeoutMs;
+    constructor(options) {
+        try {
+            const url = new URL(options.url);
+            const timeout = options.timeoutMs ?? 15_000;
+            if (!consoleSchemeAllowed(url)
+                || url.username || url.password || url.pathname !== "/" || url.search || url.hash
+                || !isConsoleToken(options.token)
+                || !Number.isSafeInteger(timeout) || timeout <= 0 || timeout > 120_000)
+                throw new ConsoleError("invalid_configuration");
+            this.#url = url;
+            this.#token = options.token;
+            this.#timeoutMs = timeout;
+        }
+        catch {
+            throw new ConsoleError("invalid_configuration");
+        }
+    }
+    start(input) {
+        return this.#send("/api/cli/checks", input, localStartRequestSchema, localStartResponseSchema, LOCAL_START_BODY_LIMIT, { statuses: [201], header: LOCAL_START_EXECUTION_HEADER, context: "start" });
+    }
+    create(input) {
+        return this.#lifecycle({ ...input, action: "create" }, consoleCreatedSchema);
+    }
+    reserve(input) {
+        return this.#lifecycle({ ...input, action: "reserve" }, consoleReservationSchema);
+    }
+    status(reservationId) {
+        return this.#lifecycle({ action: "status", reservationId }, consoleStatusSchema);
+    }
+    heartbeat(reservationId) {
+        return this.#lifecycle({ action: "heartbeat", reservationId }, consoleStatusSchema);
+    }
+    fail(reservationId) {
+        return this.#lifecycle({ action: "fail", reservationId }, consoleStatusSchema);
+    }
+    intake(input) {
+        return this.#send("/api/cli/checks/local", input, localFindingsPayloadSchema, consoleIntakeResultSchema, LOCAL_FINDINGS_BODY_LIMIT, { statuses: [200, 201], context: "intake" });
+    }
+    #lifecycle(input, response) {
+        // Starting work has no saved results to retry; recovery keeps its saving guidance.
+        const context = input.action === "create" || input.action === "reserve" ? "start" : undefined;
+        return this.#send("/api/cli/relay-reservations", input, cliRelayReservationRequestSchema, response, RESERVATION_BODY_LIMIT, { context });
+    }
+    async #send(path, input, schema, responseSchema, limit, options = {}) {
+        let body;
+        const identities = {};
+        try {
+            const parsed = schema.parse(input);
+            for (const field of ["jobId", "checkId", "projectId", "reservationId"]) {
+                const value = parsed[field];
+                if (typeof value === "string" && !(options.context === "intake" && field === "reservationId")) {
+                    identities[field] = value.toLowerCase();
+                }
+            }
+            body = Buffer.from(JSON.stringify(parsed), "utf8");
+            if (body.length > limit)
+                throw new ConsoleError("invalid_request", options.context);
+        }
+        catch {
+            throw new ConsoleError("invalid_request", options.context);
+        }
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const finish = (error, result) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                if (error)
+                    reject(error);
+                else
+                    resolve(result);
+            };
+            const destination = new URL(path, this.#url);
+            const request = (destination.protocol === "https:" ? httpsRequest : httpRequest)(destination, {
+                method: "POST", agent: false, rejectUnauthorized: true, maxHeaderSize: 16 * 1024,
+                headers: { "x-counterfact-cli-version": CLI_VERSION, authorization: `Bearer ${this.#token}`, "content-type": "application/json", accept: "application/json",
+                    "content-length": body.length, "accept-encoding": "identity",
+                    ...(options.header ? { [options.header.name]: options.header.value } : {}) },
+            }, response => {
+                const status = response.statusCode ?? 0;
+                const declared = response.headers["content-length"];
+                const contentType = response.headers["content-type"] ?? "";
+                if (status >= 300 && status < 400 || !/^application\/json(?:\s*;|$)/i.test(contentType)
+                    || response.headers["content-encoding"] && response.headers["content-encoding"] !== "identity"
+                    || declared && (!/^\d+$/.test(declared) || Number(declared) > RESPONSE_LIMIT)) {
+                    finish(new ConsoleError());
+                    response.destroy();
+                    return;
+                }
+                let size = 0;
+                const chunks = [];
+                response.on("data", (chunk) => {
+                    size += chunk.length;
+                    if (size > RESPONSE_LIMIT) {
+                        finish(new ConsoleError());
+                        response.destroy();
+                    }
+                    else
+                        chunks.push(chunk);
+                });
+                response.on("error", () => finish(new ConsoleError()));
+                response.on("aborted", () => finish(new ConsoleError()));
+                response.on("end", () => {
+                    try {
+                        const decoded = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+                        if (!(options.statuses ?? [200]).includes(status)) {
+                            const code = decoded && typeof decoded === "object" && "code" in decoded ? decoded.code : undefined;
+                            throw new ConsoleError(typeof code === "string" && Object.hasOwn(messages, code) ? code : "unavailable");
+                        }
+                        const result = responseSchema.parse(decoded);
+                        for (const [field, expected] of Object.entries(identities)) {
+                            if (result[field] !== expected)
+                                throw new ConsoleError();
+                        }
+                        finish(undefined, result);
+                    }
+                    catch (error) {
+                        finish(error instanceof ConsoleError ? error : new ConsoleError());
+                    }
+                });
+            });
+            // Use one wall-clock deadline: an idle timeout alone lets a trickling response run forever.
+            const timer = setTimeout(() => { finish(new ConsoleError()); request.destroy(); }, this.#timeoutMs);
+            request.on("error", () => finish(new ConsoleError()));
+            request.end(body);
+        }).catch(error => { throw new ConsoleError(error instanceof ConsoleError ? error.code : "unavailable", options.context); });
+    }
+}

package/dist/gatekeeper/loopback.js

@@ -0,0 +1,5 @@
+/** Whether a URL hostname names this machine, so development trust and plain HTTP never leave it. */
+export function isLoopbackHost(hostname) {
+    const host = hostname.replace(/^\[|\]$/g, "");
+    return host === "localhost" || host === "::1" || /^127\.\d+\.\d+\.\d+$/.test(host);
+}

package/dist/gatekeeper/model.js

@@ -0,0 +1,70 @@
+import { createHash, randomUUID } from "node:crypto";
+import { executionRequest } from "../analysis-core/contracts/requests.js";
+export class ModelConfigurationError extends Error {
+    name = "ModelConfigurationError";
+}
+export function relayModel(options) {
+    const { client, bundleVersion, reservationId, reservationToken, onUsage } = options;
+    if (!bundleVersion.trim() || !reservationId.trim() || !reservationToken?.trim() || reservationToken.length > 256)
+        throw new ModelConfigurationError("Invalid relay configuration");
+    const identities = new Map();
+    const originals = new WeakMap();
+    let callCount = 0;
+    function view(retry) {
+        return {
+            settleStartedOnError: true,
+            withRetry: view,
+            async execute(request, execution = {}) {
+                options.signal?.throwIfAborted();
+                execution.signal?.throwIfAborted();
+                let snapshot;
+                let inputBytes;
+                try {
+                    // Match JSON transport semantics, including omitted optional data fields.
+                    snapshot = executionRequest.parse(JSON.parse(JSON.stringify(request)));
+                    inputBytes = Buffer.byteLength(JSON.stringify(snapshot.inputs));
+                }
+                catch {
+                    throw new Error("Invalid relay request data");
+                }
+                execution.onSend?.(inputBytes);
+                const key = createHash("sha256").update(JSON.stringify(snapshot)).digest("hex");
+                const matching = identities.get(key);
+                let identity;
+                if (retry > 0) {
+                    const original = originals.get(request);
+                    const candidates = original ? [...original].filter(id => matching?.has(id)) : [...matching ?? []];
+                    if (candidates.length !== 1)
+                        throw new Error("Ambiguous relay call identity");
+                    identity = candidates[0];
+                }
+                else {
+                    if (callCount >= 4096)
+                        throw new Error("Relay call limit reached");
+                    identity = randomUUID();
+                    callCount++;
+                    identities.set(key, new Set([...matching ?? [], identity]));
+                    originals.set(request, new Set([...originals.get(request) ?? [], identity]));
+                }
+                let reply;
+                try {
+                    const signals = [options.signal, execution.signal].filter((signal) => !!signal);
+                    reply = await client.call({ ...snapshot, bundleVersion, reservationId, reservationToken, callId: identity }, { signal: signals.length ? AbortSignal.any(signals) : undefined });
+                }
+                catch {
+                    throw new Error("Relay request could not finish");
+                }
+                if (!reply.ok)
+                    throw new Error(`Relay refused the request: ${reply.code}`);
+                try {
+                    onUsage?.({ ...reply.usage, template: snapshot.template, model: snapshot.model });
+                }
+                catch {
+                    // A failed counter must not discard an answer or expose the sink's error text.
+                }
+                return reply.answer;
+            },
+        };
+    }
+    return view(0);
+}

package/dist/gatekeeper/production-attestation.js

@@ -0,0 +1,149 @@
+import { constants, verify, X509Certificate } from "node:crypto";
+import { z } from "zod";
+import { GOOGLE_ATTESTATION_ISSUER, MAX_ATTESTATION_BYTES, PRODUCTION_EVIDENCE_VERSION, RELAY_CHANNEL_AUDIENCE, attestationChallenge, evidenceBinding, googleAttestationClaims, observedAttestationClaims, productionEvidence } from "../contract/messages.js";
+import { decodeBase64url } from "../transport/base64url.js";
+import { isApprovedHardware } from "./trust/hardware.js";
+import { AttestationError } from "./attestation.js";
+import { validateCertificatePath } from "./certificate-path.js";
+import { validateProductionTrust, validateWorkloadPolicy } from "./trust/policy.js";
+/** A published client needs every trust constraint configured before it can connect to production. */
+export function assertProductionTrustConfigured(value) {
+    try {
+        validateProductionTrust(value);
+    }
+    catch {
+        throw new Error("Production trust is not configured for a CLI release.");
+    }
+}
+const ISSUER_CLOCK_SKEW_SECONDS = 60;
+const headerSchema = z.object({
+    alg: z.literal("RS256"), typ: z.literal("JWT").optional(), kid: z.string().max(256).optional(),
+    x5c: z.array(z.string().min(1).max(8192)).min(1).max(5),
+}).strict();
+/** Both peers supply bytes from their actual TLS socket; the transport owns freshness and socket reuse. */
+export function channelEvidenceBinding(binding) {
+    try {
+        attestationChallenge.parse({ version: PRODUCTION_EVIDENCE_VERSION, challenge: binding.challenge });
+        if (!(binding.exportedKeyMaterial instanceof Uint8Array) || binding.exportedKeyMaterial.byteLength !== 32)
+            throw new Error();
+        return { audience: RELAY_CHANNEL_AUDIENCE,
+            nonces: [Buffer.from(binding.exportedKeyMaterial).toString("base64url"), binding.challenge] };
+    }
+    catch {
+        throw new AttestationError("Invalid production attestation channel binding");
+    }
+}
+/** The caller's binding comes from the channel/health/action owner, never from the token being verified. */
+export async function verifyProductionEvidence(token, binding, trust, now = Math.floor(Date.now() / 1000)) {
+    let validated;
+    try {
+        validated = validateProductionTrust(trust);
+    }
+    catch {
+        throw new AttestationError("Malformed production attestation evidence");
+    }
+    const verified = await verifyEvidence(token, binding, validated, now);
+    if (!validated.imageDigests.includes(verified.imageDigest))
+        throw new AttestationError("Invalid production attestation claims or binding");
+    return verified;
+}
+export async function verifyWorkloadEvidence(token, binding, policy, now = Math.floor(Date.now() / 1000)) {
+    let validated;
+    try {
+        validated = validateWorkloadPolicy(policy);
+    }
+    catch {
+        throw new AttestationError("Malformed production attestation evidence");
+    }
+    return verifyEvidence(token, binding, validated, now);
+}
+async function authenticate(token, binding, roots, now) {
+    try {
+        productionEvidence.parse({ version: PRODUCTION_EVIDENCE_VERSION, token });
+        if (!Number.isSafeInteger(now))
+            throw new Error();
+        evidenceBinding.parse(binding);
+        const [encodedHeader, encodedPayload, signature] = token.split(".");
+        const header = headerSchema.parse(JSON.parse(decodeBase64url(encodedHeader).toString("utf8")));
+        const payload = decodeBase64url(encodedPayload);
+        const chain = header.x5c.map(encoded => {
+            const der = Buffer.from(encoded, "base64");
+            if (der.toString("base64") !== encoded)
+                throw new Error();
+            const cert = new X509Certificate(der);
+            if (!cert.raw.equals(der))
+                throw new Error();
+            return cert;
+        });
+        const key = await validateCertificatePath(chain, roots, now);
+        if (!verify("RSA-SHA256", Buffer.from(`${encodedHeader}.${encodedPayload}`), { key, padding: constants.RSA_PKCS1_PADDING }, decodeBase64url(signature))) {
+            throw new AttestationError("Invalid production attestation signature");
+        }
+        return payload;
+    }
+    catch (error) {
+        if (error instanceof AttestationError)
+            throw error;
+        throw new AttestationError("Malformed production attestation evidence");
+    }
+}
+function validateClaimsBinding(claims, binding, now) {
+    // The challenge bounds freshness; issuer clock drift gets a small allowance without extending expiry.
+    if (claims.exp <= now || claims.iat > now + ISSUER_CLOCK_SKEW_SECONDS ||
+        claims.nbf > now + ISSUER_CLOCK_SKEW_SECONDS || claims.exp <= claims.iat)
+        throw new Error();
+    const nonces = typeof claims.eat_nonce === "string" ? [claims.eat_nonce] : claims.eat_nonce;
+    if (claims.aud !== binding.audience || nonces.length !== binding.nonces.length ||
+        nonces.some((nonce, index) => nonce !== binding.nonces[index]))
+        throw new Error();
+}
+/**
+ * Reviewed roots authenticate probe facts; this result cannot substitute for workload admission.
+ * The default schema is the strict observed shape; a probe owner can supply its own shape for claims
+ * that Google omits on non-compliant workloads, but authentication and binding are always enforced here.
+ */
+export async function observeGoogleEvidence(token, binding, roots, now = Math.floor(Date.now() / 1000), claimsSchema = observedAttestationClaims) {
+    const payload = await authenticate(token, binding, roots, now);
+    try {
+        const claims = claimsSchema.parse(JSON.parse(payload.toString("utf8")));
+        validateClaimsBinding(claims, binding, now);
+        return { claims };
+    }
+    catch {
+        throw new AttestationError("Invalid production attestation claims or binding");
+    }
+}
+async function verifyEvidence(token, binding, trust, now = Math.floor(Date.now() / 1000)) {
+    const payload = await authenticate(token, binding, trust.roots, now);
+    try {
+        // Claims cannot influence trust selection or the internal identity before authentication above.
+        const claims = googleAttestationClaims.parse(JSON.parse(payload.toString("utf8")));
+        validateClaimsBinding(claims, binding, now);
+        const { container, confidential_space: space } = claims.submods;
+        if (!trust.softwareVersions.includes(claims.swversion[0]) ||
+            !isApprovedHardware(claims.hwmodel, trust.hardwareModels) || !trust.subjects.includes(claims.sub) ||
+            claims.google_service_accounts.some(account => !trust.serviceAccounts.includes(account)) ||
+            !space.support_attributes.includes("STABLE") || !space.support_attributes.includes("USABLE") ||
+            space.support_attributes.some(attribute => !["STABLE", "USABLE"].includes(attribute)))
+            throw new Error();
+        if (!container.image_signatures.some(signature => trust.imageSigningKeyIds.includes(signature.key_id)) ||
+            container.image_signatures.some(signature => Buffer.from(signature.signature, "base64").toString("base64") !== signature.signature))
+            throw new Error();
+        return { iss: GOOGLE_ATTESTATION_ISSUER, imageDigest: container.image_digest, iat: claims.iat, exp: claims.exp };
+    }
+    catch {
+        throw new AttestationError("Invalid production attestation claims or binding");
+    }
+}
+export async function verifyProductionAttestation(evidence, binding, trust, now = Math.floor(Date.now() / 1000)) {
+    return verifyProductionEvidence(evidenceToken(evidence), channelEvidenceBinding(binding), trust, now);
+}
+export async function verifyWorkloadAttestation(evidence, binding, policy, now = Math.floor(Date.now() / 1000)) {
+    return verifyWorkloadEvidence(evidenceToken(evidence), channelEvidenceBinding(binding), policy, now);
+}
+function evidenceToken(evidence) {
+    const parsed = productionEvidence.safeParse(evidence);
+    if (!parsed.success || parsed.data.token.length > MAX_ATTESTATION_BYTES)
+        throw new AttestationError("Malformed production attestation evidence");
+    return parsed.data.token;
+}

package/dist/gatekeeper/trust/hardware.js

@@ -0,0 +1,21 @@
+// Target and preserved rollback hardware are chosen only here, and callers never accept both together; rollback keeps AMD SEV on its original machine.
+const target = Object.freeze({ hwmodel: "GCP_INTEL_TDX", computeType: "TDX", machine: "c3-standard-4",
+    confidentialImage: "projects/confidential-space-images/global/images/confidential-space-260800" });
+const rollback = Object.freeze({ hwmodel: "GCP_AMD_SEV", computeType: "SEV", machine: "n2d-standard-2",
+    confidentialImage: target.confidentialImage });
+export const hardwareModels = [target.hwmodel, rollback.hwmodel];
+export function confidentialHardware(profile = "rollback") {
+    if (profile === "target")
+        return target;
+    if (profile === "rollback")
+        return rollback;
+    throw new Error("Invalid confidential hardware policy");
+}
+export function isApprovedHardware(model, approved) {
+    return approved.length === 1 && hardwareModels.some(value => value === model) && approved[0] === model;
+}
+export function requireSealedRootHardware(config, policy) {
+    if (config.hardwareProfile !== "target" || config.confidentialImage !== target.confidentialImage ||
+        policy && !isApprovedHardware(target.hwmodel, policy.hardwareModels))
+        throw new Error("Sealed root requires reviewed target hardware and host image");
+}

package/dist/gatekeeper/trust/policy.js

@@ -0,0 +1,42 @@
+import { X509Certificate } from "node:crypto";
+import { z } from "zod";
+import { hardwareModels } from "./hardware.js";
+export const workloadZones = ["us-central1-a", "us-central1-b", "us-central1-c", "us-central1-f"];
+const values = (item) => z.array(item).min(1).max(8).refine(list => new Set(list).size === list.length);
+/** The one rule for an acceptable Google root: a self-signed CA, RSA of at least 2048 bits, valid at `now`. */
+export function acceptableGoogleRoot(cert, now = Date.now()) {
+    return cert.ca && cert.checkIssued(cert) && cert.verify(cert.publicKey) &&
+        cert.publicKey.asymmetricKeyType === "rsa" && (cert.publicKey.asymmetricKeyDetails?.modulusLength ?? 0) >= 2048 &&
+        Date.parse(cert.validFrom) <= now && Date.parse(cert.validTo) > now;
+}
+const root = z.string().max(16384).refine(pem => {
+    try {
+        const cert = new X509Certificate(pem);
+        return pem.trim() === cert.toString().trim() && acceptableGoogleRoot(cert);
+    }
+    catch {
+        return false;
+    }
+});
+// Fixed security claims remain owned by the native token contract. This policy selects reviewed allow-lists.
+export const workloadPolicy = z.object({
+    version: z.literal(1), roots: values(root),
+    softwareVersions: values(z.string().regex(/^[0-9]{6,8}$/)),
+    hardwareModels: z.array(z.enum(hardwareModels)).length(1),
+    serviceAccounts: values(z.string().regex(/^[a-z][a-z0-9-]*@[a-z][a-z0-9-]*\.iam\.gserviceaccount\.com$/)),
+    subjects: values(z.string().regex(/^https:\/\/www\.googleapis\.com\/compute\/v1\/projects\/[a-z][a-z0-9-]*\/zones\/[a-z0-9-]+\/instances\/[a-z0-9][a-z0-9-]*$/)
+        .refine(subject => workloadZones.some(zone => subject.includes(`/zones/${zone}/`)))),
+    imageSigningKeyIds: values(z.string().regex(/^[0-9a-f]{64}$/)),
+}).strict();
+const productionTrust = workloadPolicy.extend({
+    imageDigests: z.array(z.string().regex(/^sha256:[0-9a-f]{64}$/)).min(1),
+});
+export function validateWorkloadPolicy(value) {
+    return workloadPolicy.parse(value);
+}
+export function workloadPolicyBytes(value) {
+    return `${JSON.stringify(validateWorkloadPolicy(value), null, 2)}\n`;
+}
+export function validateProductionTrust(value) {
+    return productionTrust.parse(value);
+}

package/dist/gatekeeper/trust/production.json

@@ -0,0 +1,25 @@
+{
+  "version": 1,
+  "roots": [
+    "-----BEGIN CERTIFICATE-----\nMIIGCDCCA/CgAwIBAgITYBvRy5g9aYYMh7tJS7pFwafL6jANBgkqhkiG9w0BAQsF\nADCBizELMAkGA1UEBhMCVVMxEzARBgNVBAgTCkNhbGlmb3JuaWExFjAUBgNVBAcT\nDU1vdW50YWluIFZpZXcxEzARBgNVBAoTCkdvb2dsZSBMTEMxFTATBgNVBAsTDEdv\nb2dsZSBDbG91ZDEjMCEGA1UEAxMaQ29uZmlkZW50aWFsIFNwYWNlIFJvb3QgQ0Ew\nHhcNMjQwMTE5MjIxMDUwWhcNMzQwMTE2MjIxMDQ5WjCBizELMAkGA1UEBhMCVVMx\nEzARBgNVBAgTCkNhbGlmb3JuaWExFjAUBgNVBAcTDU1vdW50YWluIFZpZXcxEzAR\nBgNVBAoTCkdvb2dsZSBMTEMxFTATBgNVBAsTDEdvb2dsZSBDbG91ZDEjMCEGA1UE\nAxMaQ29uZmlkZW50aWFsIFNwYWNlIFJvb3QgQ0EwggIiMA0GCSqGSIb3DQEBAQUA\nA4ICDwAwggIKAoICAQCvRuZasczAqhMZe1ODHJ6MFLX8EYVV+RN7xiO9GpuA53iz\nl9Oxgp3NXik3FbYn+7bcIkMMSQpCr6K0jbSQCZT6d5P5PJT5DpNGYjLHkW67/fl+\nBu7eSMb0qRCa1jS+3OhNK7t7SIaHm1XdmSRghjwoglKRuk3CGrF4Zia9RcE/p2MU\n69GyJZpqHYwTplNr3x4zF+2nJk86GywDP+sGwSPWfcmqY04VQD7ZPDEZZ/qgzdoL\n5ilE92eQnAsy+6m6LxBEHHVcFpfDtNVUIt2VMCWLBeOKUQcn5js756xblInqw/Qt\nQRR0An0yfRjBuGvmMjAwETDo5ETY/fc+nbQVYJzNQTc9EOpFFWPpw/ZjFcN9Amnd\ndxYUETFXPmBYerMez0LKNtGpfKYHHhMMTI3mj0m/V9fCbfh2YbBUnMS2Swd20YSI\nMi/HiGaqOpGUqXMeQVw7phGTS3QYK8ZM65sC/QhIQzXdsiLDgFBitVnlIu3lIv6C\nuiHvXeSJBRlRxQ8Vu+t6J7hBdl0etWBKAu9Vti46af5cjC03dspkHR3MAUGcrLWE\nTkQ0msQAKvIAlwyQRLuQOI5D6pF+6af1Nbl+vR7sLCbDWdMqm1E9X6KyFKd6e3rn\nE9O4dkFJp35WvR2gqIAkUoa+Vq1MXLFYG4imanZKH0igrIblbawRCr3Gr24FXQID\nAQABo2MwYTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4E\nFgQUF+fBOE6Th1snpKuvIb6S8/mtPL4wHwYDVR0jBBgwFoAUF+fBOE6Th1snpKuv\nIb6S8/mtPL4wDQYJKoZIhvcNAQELBQADggIBAGtCuV5eHxWcffylK9GPumaD6Yjd\ncs76KDBe3mky5ItBIrEOeZq3z47zM4dbKZHhFuoq4yAaO1MyApnG0w9wIQLBDndI\novtkw6j9/64aqPWpNaoB5MB0SahCUCgI83Dx9SRqGmjPI/MTMfwDLdE5EF9gFmVI\noH62YnG2aa/sc6m/8wIK8WtTJazEI16/8GPG4ZUhwT6aR3IGGnEBPMbMd5VZQ0Hw\nVbHBKWK3UykaSCxnEg8uaNx/rhNaOWuWtos4qL00dYyGV7ZXg4fpAq7244QUgkWV\nAtVcU2SPBjDd30OFHASnenDHRzQdOtHaxLp4a4WaY3jb2V6Sn3LfE8zSy6GevxmN\nCOIWW3xnPF8rwKz4ABEPqECe37zzu3W1nzZAFtdkhPBNnlWYkIusTMtU+8v6EPKp\nGIIRphpaDhtGPJQukpENOfk2728lenPycRfjxwA96UKWq0dKZC45MwBEK9Jngn8Q\ncPmpPmx7pSMkSxEX2Vos2JNaNmCKJd2VaXz8M6F2cxscRdh9TbAYAjGEEjE1nLUH\n2YHDS8Y7xYNFIDSFaJAlqGcCUbzjGhrwHGj4voTe9ZvlmngrcA/ptSuBidvsnRDw\nkNPLowCd0NqxYYSLNL7GroYCFPxoBpr+++4vsCaXalbs8iJxdU2EPqG4MB4xWKYg\nuyT5CnJulxSC5CT1\n-----END CERTIFICATE-----"
+  ],
+  "softwareVersions": [
+    "260800"
+  ],
+  "hardwareModels": [
+    "GCP_INTEL_TDX"
+  ],
+  "serviceAccounts": [
+    "relay-runtime@hosted-web-504419.iam.gserviceaccount.com"
+  ],
+  "subjects": [
+    "https://www.googleapis.com/compute/v1/projects/hosted-web-504419/zones/us-central1-a/instances/relay-vm",
+    "https://www.googleapis.com/compute/v1/projects/hosted-web-504419/zones/us-central1-a/instances/relay-staging-vm"
+  ],
+  "imageSigningKeyIds": [
+    "47caa7c1d5184e83548e604e4d74e20ffa3d4682031abfe826267a96e15f7fda"
+  ],
+  "imageDigests": [
+    "sha256:1d7a87dcb421afffba20a563e478801972b48fd9569bfb9377aac29e6b589e79"
+  ]
+}