@reclaimprotocol/attestor-core 5.1.1 → 5.1.4

package/lib/external-rpc/index.js

@@ -8807,13 +8807,14 @@ function parseHttpResponse(buff) {
 var RE2;
 import("re2").then((m) => {
   RE2 = m.default;
-}).catch(() => {
+}).catch((err) => {
+  logger.warn({ err }, "Failed to load RE2; falling back to native RegExp");
 });
 function makeRegex(str) {
   if (RE2) {
     return RE2(str, "sgiu");
   }
-  return new RegExp(str, "sgiu");
+  return new RegExp(str, "sgi");
 }
 var TEMPLATE_START_CHARCODE = "{".charCodeAt(0);
 var TEMPLATE_END_CHARCODE = "}".charCodeAt(0);
@@ -9038,6 +9039,9 @@ var HTTP_PROVIDER = {
     if (res.headerIndices["date"]) {
       reveals.push(res.headerIndices["date"]);
     }
+    if (res.headerIndices["content-type"]) {
+      reveals.push(res.headerIndices["content-type"]);
+    }
     if (revealFraming && res.headerIndices["transfer-encoding"]) {
       reveals.push(res.headerIndices["transfer-encoding"]);
     }
@@ -9129,36 +9133,53 @@ var HTTP_PROVIDER = {
     const firstRealIdx = allServerBlocks.findIndex((b) => !b.every((x) => x === REDACTION_CHAR_CODE2));
     const serverBlocks = firstRealIdx === -1 ? [] : allServerBlocks.slice(firstRealIdx);
     const response = concatArrays(...serverBlocks);
-    let res;
-    res = uint8ArrayToStr(response);
+    let bodyStart;
+    if (shouldRevealCrlf(ctx)) {
+      const responseAfterStatus = response.slice(OK_HTTP_HEADER.length);
+      const separatorIdx = findIndexInUint8Array(
+        responseAfterStatus,
+        strToUint8Array("\r\n\r\n")
+      );
+      if (separatorIdx === -1) {
+        throw new Error("Response body start not found");
+      }
+      bodyStart = OK_HTTP_HEADER.length + separatorIdx + 4;
+    } else {
+      bodyStart = OK_HTTP_HEADER.length;
+    }
+    const headersText = uint8ArrayToStr(response.slice(0, bodyStart));
     const okRegex = makeRegex("^HTTP\\/1.1 2\\d{2}");
-    const matchRes = okRegex.exec(res);
+    const matchRes = okRegex.exec(headersText);
     if (!matchRes) {
       const statusRegex = makeRegex("^HTTP\\/1.1 (\\d{3})");
-      const matchRes2 = statusRegex.exec(res);
+      const matchRes2 = statusRegex.exec(headersText);
       if (matchRes2 && matchRes2.length > 1) {
         throw new Error(`Provider returned error ${matchRes2[1]}`);
       }
-      let lineEnd = res.indexOf("*");
+      let lineEnd = headersText.indexOf("*");
       if (lineEnd === -1) {
-        lineEnd = res.indexOf("\n");
+        lineEnd = headersText.indexOf("\n");
       }
       if (lineEnd === -1) {
         lineEnd = OK_HTTP_HEADER.length;
       }
       throw new Error(
-        `Response did not start with "HTTP/1.1 2XX" got "${res.slice(0, lineEnd)}"`
+        `Response did not start with "HTTP/1.1 2XX" got "${headersText.slice(0, lineEnd)}"`
       );
     }
-    let bodyStart;
-    if (shouldRevealCrlf(ctx)) {
-      bodyStart = res.indexOf("\r\n\r\n", OK_HTTP_HEADER.length) + 4;
-      if (bodyStart < 4) {
-        throw new Error("Response body start not found");
+    const paramBody = params.body instanceof Uint8Array ? params.body : strToUint8Array(params.body || "");
+    if (paramBody.length > 0 && !matchRedactedStrings(paramBody, req.body)) {
+      throw new Error("request body mismatch");
+    }
+    let body = response.slice(bodyStart);
+    if (shouldRevealChunkFraming(clientVersion)) {
+      if (/transfer-encoding:\s*chunked/i.test(headersText)) {
+        body = dechunkResponseBody(body);
       }
-    } else {
-      bodyStart = OK_HTTP_HEADER.length;
     }
+    const charset = shouldRevealCrlf(ctx) ? getResponseBodyCharset(headersText) : void 0;
+    const bodyText = decodeResponseBody(body, charset);
+    let res = headersText + bodyText;
     const dateHeader = makeRegex(dateHeaderRegex).exec(res);
     if (dateHeader && dateHeader.length > 1) {
       const serverDate = new Date(dateHeader[1]);
@@ -9166,14 +9187,7 @@ var HTTP_PROVIDER = {
         logger2.info({ dateHeader: dateHeader[0], current: Date.now() }, "date header is off");
       }
     }
-    const paramBody = params.body instanceof Uint8Array ? params.body : strToUint8Array(params.body || "");
-    if (paramBody.length > 0 && !matchRedactedStrings(paramBody, req.body)) {
-      throw new Error("request body mismatch");
-    }
-    if (shouldRevealChunkFraming(clientVersion)) {
-      const headersStr = res.slice(0, bodyStart);
-      res = /transfer-encoding:\s*chunked/i.test(headersStr) ? headersStr + dechunkResponseBody(res.slice(bodyStart)) : res;
-    } else if (!secretParams) {
+    if (!shouldRevealChunkFraming(clientVersion) && !secretParams) {
       res = res.slice(bodyStart).replace(/\*{3,}/g, "");
     }
     for (const { type, value, invert } of params.responseMatches || []) {
@@ -9264,12 +9278,35 @@ function shouldRevealCrlf({ version }) {
 function shouldRevealChunkFraming(version) {
   return version >= AttestorVersion.ATTESTOR_VERSION_3_2_0;
 }
+function getResponseBodyCharset(headers) {
+  const contentType = /(?:^|[\r\n*])content-type\s*:\s*([^*\r\n]*)/i.exec(headers)?.[1];
+  if (typeof contentType === "undefined") {
+    return void 0;
+  }
+  const charsetMatch = /(?:^|;)\s*charset\s*=\s*(?:"((?:[^"\\]|\\.)*)"|([^;\s]*))/i.exec(contentType);
+  if (!charsetMatch) {
+    return void 0;
+  }
+  const charset = charsetMatch[1]?.replace(/\\(.)/g, "$1") ?? charsetMatch[2];
+  return charset.trim() || void 0;
+}
+function decodeResponseBody(body, charset) {
+  try {
+    return new TextDecoder(charset ?? "utf-8").decode(body);
+  } catch (error) {
+    if (charset) {
+      throw new Error(`Unsupported response charset "${charset}"`, { cause: error });
+    }
+    throw error;
+  }
+}
 function dechunkResponseBody(body) {
   const parser = makeHttpResponseParser();
-  parser.onChunk(
-    strToUint8Array("HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n" + body)
-  );
-  return uint8ArrayToStr(parser.res.body ?? new Uint8Array());
+  parser.onChunk(concatenateUint8Arrays7([
+    strToUint8Array("HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n"),
+    body
+  ]));
+  return parser.res.body ?? new Uint8Array();
 }
 function getHostPort(params, secretParams) {
   const { host } = new URL(getURL(params, secretParams));
@@ -9955,6 +9992,7 @@ async function _createClaimOnAttestor({
           block,
           redactedPlaintext,
           overshotToprfFromPrevBlock,
+          overshotOprfRawFromPrevBlock,
           toprfs,
           oprfRawMarkers
         } = reveal;
@@ -9963,7 +10001,8 @@ async function _createClaimOnAttestor({
           redactedPlaintext,
           toprfs,
           oprfRawMarkers,
-          overshotToprfFromPrevBlock
+          overshotToprfFromPrevBlock,
+          overshotOprfRawFromPrevBlock
         });
         revealedPackets.push(
           { sender: "server", message: redactedPlaintext }

package/lib/index.js

@@ -7124,13 +7124,14 @@ function parseHttpResponse(buff) {
 var RE2;
 import("re2").then((m) => {
   RE2 = m.default;
-}).catch(() => {
+}).catch((err) => {
+  logger.warn({ err }, "Failed to load RE2; falling back to native RegExp");
 });
 function makeRegex(str) {
   if (RE2) {
     return RE2(str, "sgiu");
   }
-  return new RegExp(str, "sgiu");
+  return new RegExp(str, "sgi");
 }
 var TEMPLATE_START_CHARCODE = "{".charCodeAt(0);
 var TEMPLATE_END_CHARCODE = "}".charCodeAt(0);
@@ -7336,6 +7337,9 @@ var HTTP_PROVIDER = {
     if (res.headerIndices["date"]) {
       reveals.push(res.headerIndices["date"]);
     }
+    if (res.headerIndices["content-type"]) {
+      reveals.push(res.headerIndices["content-type"]);
+    }
     if (revealFraming && res.headerIndices["transfer-encoding"]) {
       reveals.push(res.headerIndices["transfer-encoding"]);
     }
@@ -7427,36 +7431,53 @@ var HTTP_PROVIDER = {
     const firstRealIdx = allServerBlocks.findIndex((b) => !b.every((x) => x === REDACTION_CHAR_CODE2));
     const serverBlocks = firstRealIdx === -1 ? [] : allServerBlocks.slice(firstRealIdx);
     const response = concatArrays(...serverBlocks);
-    let res;
-    res = uint8ArrayToStr(response);
+    let bodyStart;
+    if (shouldRevealCrlf(ctx)) {
+      const responseAfterStatus = response.slice(OK_HTTP_HEADER.length);
+      const separatorIdx = findIndexInUint8Array(
+        responseAfterStatus,
+        strToUint8Array("\r\n\r\n")
+      );
+      if (separatorIdx === -1) {
+        throw new Error("Response body start not found");
+      }
+      bodyStart = OK_HTTP_HEADER.length + separatorIdx + 4;
+    } else {
+      bodyStart = OK_HTTP_HEADER.length;
+    }
+    const headersText = uint8ArrayToStr(response.slice(0, bodyStart));
     const okRegex = makeRegex("^HTTP\\/1.1 2\\d{2}");
-    const matchRes = okRegex.exec(res);
+    const matchRes = okRegex.exec(headersText);
     if (!matchRes) {
       const statusRegex = makeRegex("^HTTP\\/1.1 (\\d{3})");
-      const matchRes2 = statusRegex.exec(res);
+      const matchRes2 = statusRegex.exec(headersText);
       if (matchRes2 && matchRes2.length > 1) {
         throw new Error(`Provider returned error ${matchRes2[1]}`);
       }
-      let lineEnd = res.indexOf("*");
+      let lineEnd = headersText.indexOf("*");
       if (lineEnd === -1) {
-        lineEnd = res.indexOf("\n");
+        lineEnd = headersText.indexOf("\n");
       }
       if (lineEnd === -1) {
         lineEnd = OK_HTTP_HEADER.length;
       }
       throw new Error(
-        `Response did not start with "HTTP/1.1 2XX" got "${res.slice(0, lineEnd)}"`
+        `Response did not start with "HTTP/1.1 2XX" got "${headersText.slice(0, lineEnd)}"`
       );
     }
-    let bodyStart;
-    if (shouldRevealCrlf(ctx)) {
-      bodyStart = res.indexOf("\r\n\r\n", OK_HTTP_HEADER.length) + 4;
-      if (bodyStart < 4) {
-        throw new Error("Response body start not found");
+    const paramBody = params.body instanceof Uint8Array ? params.body : strToUint8Array(params.body || "");
+    if (paramBody.length > 0 && !matchRedactedStrings(paramBody, req.body)) {
+      throw new Error("request body mismatch");
+    }
+    let body = response.slice(bodyStart);
+    if (shouldRevealChunkFraming(clientVersion)) {
+      if (/transfer-encoding:\s*chunked/i.test(headersText)) {
+        body = dechunkResponseBody(body);
       }
-    } else {
-      bodyStart = OK_HTTP_HEADER.length;
     }
+    const charset = shouldRevealCrlf(ctx) ? getResponseBodyCharset(headersText) : void 0;
+    const bodyText = decodeResponseBody(body, charset);
+    let res = headersText + bodyText;
     const dateHeader = makeRegex(dateHeaderRegex).exec(res);
     if (dateHeader && dateHeader.length > 1) {
       const serverDate = new Date(dateHeader[1]);
@@ -7464,14 +7485,7 @@ var HTTP_PROVIDER = {
         logger2.info({ dateHeader: dateHeader[0], current: Date.now() }, "date header is off");
       }
     }
-    const paramBody = params.body instanceof Uint8Array ? params.body : strToUint8Array(params.body || "");
-    if (paramBody.length > 0 && !matchRedactedStrings(paramBody, req.body)) {
-      throw new Error("request body mismatch");
-    }
-    if (shouldRevealChunkFraming(clientVersion)) {
-      const headersStr = res.slice(0, bodyStart);
-      res = /transfer-encoding:\s*chunked/i.test(headersStr) ? headersStr + dechunkResponseBody(res.slice(bodyStart)) : res;
-    } else if (!secretParams) {
+    if (!shouldRevealChunkFraming(clientVersion) && !secretParams) {
       res = res.slice(bodyStart).replace(/\*{3,}/g, "");
     }
     for (const { type, value, invert } of params.responseMatches || []) {
@@ -7562,12 +7576,35 @@ function shouldRevealCrlf({ version }) {
 function shouldRevealChunkFraming(version) {
   return version >= AttestorVersion.ATTESTOR_VERSION_3_2_0;
 }
+function getResponseBodyCharset(headers) {
+  const contentType = /(?:^|[\r\n*])content-type\s*:\s*([^*\r\n]*)/i.exec(headers)?.[1];
+  if (typeof contentType === "undefined") {
+    return void 0;
+  }
+  const charsetMatch = /(?:^|;)\s*charset\s*=\s*(?:"((?:[^"\\]|\\.)*)"|([^;\s]*))/i.exec(contentType);
+  if (!charsetMatch) {
+    return void 0;
+  }
+  const charset = charsetMatch[1]?.replace(/\\(.)/g, "$1") ?? charsetMatch[2];
+  return charset.trim() || void 0;
+}
+function decodeResponseBody(body, charset) {
+  try {
+    return new TextDecoder(charset ?? "utf-8").decode(body);
+  } catch (error) {
+    if (charset) {
+      throw new Error(`Unsupported response charset "${charset}"`, { cause: error });
+    }
+    throw error;
+  }
+}
 function dechunkResponseBody(body) {
   const parser = makeHttpResponseParser();
-  parser.onChunk(
-    strToUint8Array("HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n" + body)
-  );
-  return uint8ArrayToStr(parser.res.body ?? new Uint8Array());
+  parser.onChunk(concatenateUint8Arrays6([
+    strToUint8Array("HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n"),
+    body
+  ]));
+  return parser.res.body ?? new Uint8Array();
 }
 function getHostPort(params, secretParams) {
   const { host } = new URL(getURL(params, secretParams));
@@ -8454,6 +8491,7 @@ async function _createClaimOnAttestor({
           block,
           redactedPlaintext,
           overshotToprfFromPrevBlock,
+          overshotOprfRawFromPrevBlock,
           toprfs,
           oprfRawMarkers
         } = reveal;
@@ -8462,7 +8500,8 @@ async function _createClaimOnAttestor({
           redactedPlaintext,
           toprfs,
           oprfRawMarkers,
-          overshotToprfFromPrevBlock
+          overshotToprfFromPrevBlock,
+          overshotOprfRawFromPrevBlock
         });
         revealedPackets.push(
           { sender: "server", message: redactedPlaintext }

package/lib/proto/tee-bundle.d.ts

@@ -1,5 +1,20 @@
 import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
 export declare const protobufPackage = "teeproto";
+export declare const TLS12CBCRecordMode: {
+    readonly TLS12_CBC_RECORD_MODE_UNSPECIFIED: 0;
+    readonly TLS12_CBC_RECORD_MODE_MAC_THEN_ENCRYPT: 1;
+    readonly TLS12_CBC_RECORD_MODE_ENCRYPT_THEN_MAC: 2;
+    readonly UNRECOGNIZED: -1;
+};
+export type TLS12CBCRecordMode = typeof TLS12CBCRecordMode[keyof typeof TLS12CBCRecordMode];
+export declare namespace TLS12CBCRecordMode {
+    type TLS12_CBC_RECORD_MODE_UNSPECIFIED = typeof TLS12CBCRecordMode.TLS12_CBC_RECORD_MODE_UNSPECIFIED;
+    type TLS12_CBC_RECORD_MODE_MAC_THEN_ENCRYPT = typeof TLS12CBCRecordMode.TLS12_CBC_RECORD_MODE_MAC_THEN_ENCRYPT;
+    type TLS12_CBC_RECORD_MODE_ENCRYPT_THEN_MAC = typeof TLS12CBCRecordMode.TLS12_CBC_RECORD_MODE_ENCRYPT_THEN_MAC;
+    type UNRECOGNIZED = typeof TLS12CBCRecordMode.UNRECOGNIZED;
+}
+export declare function tLS12CBCRecordModeFromJSON(object: any): TLS12CBCRecordMode;
+export declare function tLS12CBCRecordModeToJSON(object: TLS12CBCRecordMode): string;
 /** Signature wrapper used everywhere */
 export declare const BodyType: {
     readonly BODY_TYPE_UNSPECIFIED: 0;
@@ -27,6 +42,13 @@ export interface ResponseRedactionRange {
     start: number;
     length: number;
 }
+export interface TLS12CBCSessionBinding {
+    contractVersion: number;
+    cipherSuite: number;
+    recordMode: TLS12CBCRecordMode;
+    extendedMasterSecret: boolean;
+    sessionBinding: Uint8Array;
+}
 export interface SignedRedactedDecryptionStream {
     redactedStream: Uint8Array;
     seqNum: number;
@@ -79,6 +101,9 @@ export interface KOutputPayload {
     sessionId: string;
     /** MPC OPRF outputs (TEE-to-TEE computation) - field 10 to match reclaim-tee */
     oprfOutputs: OPRFOutput[];
+    /** Signed TEE attestation generation */
+    attestationType: string;
+    tls12Cbc: TLS12CBCKOutput | undefined;
 }
 export interface TOutputPayload {
     /** NEW: Single consolidated ciphertext instead of individual packets */
@@ -91,6 +116,23 @@ export interface TOutputPayload {
     sessionId: string;
     /** MPC OPRF outputs (TEE-to-TEE computation) - field 10 to match reclaim-tee */
     oprfOutputs: OPRFOutput[];
+    /** Signed TEE attestation generation */
+    attestationType: string;
+    tls12Cbc: TLS12CBCTOutput | undefined;
+}
+export interface TLS12CBCKOutput {
+    binding: TLS12CBCSessionBinding | undefined;
+    authenticatedRedactedRequest: Uint8Array;
+    requestRecordsSha256: Uint8Array;
+    requestRedactionRanges: RequestRedactionRange[];
+}
+export interface TLS12CBCTOutput {
+    binding: TLS12CBCSessionBinding | undefined;
+    authenticatedRedactedResponse: Uint8Array;
+    responseRecordsSha256: Uint8Array;
+    responseRedactionRanges: ResponseRedactionRange[];
+    plaintextRecordLengths: number[];
+    closeNotify: boolean;
 }
 /** Attestation report with structured data */
 export interface AttestationReport {
@@ -130,6 +172,7 @@ export interface VerificationBundle {
 }
 export declare const RequestRedactionRange: MessageFns<RequestRedactionRange>;
 export declare const ResponseRedactionRange: MessageFns<ResponseRedactionRange>;
+export declare const TLS12CBCSessionBinding: MessageFns<TLS12CBCSessionBinding>;
 export declare const SignedRedactedDecryptionStream: MessageFns<SignedRedactedDecryptionStream>;
 export declare const CertificateInfo: MessageFns<CertificateInfo>;
 export declare const HandshakeSecrets: MessageFns<HandshakeSecrets>;
@@ -137,6 +180,8 @@ export declare const Opening: MessageFns<Opening>;
 export declare const OPRFOutput: MessageFns<OPRFOutput>;
 export declare const KOutputPayload: MessageFns<KOutputPayload>;
 export declare const TOutputPayload: MessageFns<TOutputPayload>;
+export declare const TLS12CBCKOutput: MessageFns<TLS12CBCKOutput>;
+export declare const TLS12CBCTOutput: MessageFns<TLS12CBCTOutput>;
 export declare const AttestationReport: MessageFns<AttestationReport>;
 export declare const SignedMessage: MessageFns<SignedMessage>;
 export declare const OPRFVerificationData: MessageFns<OPRFVerificationData>;

package/lib/server/tee/acme-http-server.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Ephemeral HTTP server that answers ACME HTTP-01 challenges. Started right
+ * before an order is placed and stopped as soon as the order is finalized,
+ * so the attestor does not keep port 80 bound during normal operation.
+ */
+export declare class AcmeChallengeServer {
+    private readonly tokens;
+    private server?;
+    add(token: string, keyAuthorization: string): void;
+    remove(token: string): void;
+    start(port: number): Promise<void>;
+    stop(): Promise<void>;
+}

package/lib/server/tee/attestation-generate.d.ts

@@ -0,0 +1,29 @@
+import type { AttestationReport } from '../../proto/tee-bundle.ts';
+/**
+ * Requests a custom attestation token from the Confidential Space launcher
+ * over the unix domain socket. Mirrors reclaim-tee's shared/gcp_attestation.go.
+ */
+export declare function generateAttestationJwt(nonces: string[]): Promise<Uint8Array>;
+export interface AttestationContext {
+    attestorAddress: string;
+    tlsCertSha256Hex: () => string | undefined;
+}
+/**
+ * Starts the background attestation refresh loop. The first attestation is
+ * generated synchronously so getCachedAttestationJwt() is ready by the time
+ * the server begins handling claims.
+ */
+export declare function startAttestationRefresh(ctx: AttestationContext): Promise<void>;
+export declare function stopAttestationRefresh(): void;
+/**
+ * Returns the currently-cached attestation JWT bytes, or undefined if no
+ * attestation has been generated yet or the cache has expired without a
+ * successful refresh.
+ */
+export declare function getCachedAttestationJwt(): Uint8Array | undefined;
+/**
+ * Returns an AttestationReport ready to embed in a claim response, or
+ * undefined when no attestation is available (i.e. attestor is not running
+ * inside a TEE, or the refresh loop has not produced one yet).
+ */
+export declare function makeClaimAttestation(): AttestationReport | undefined;

package/lib/server/tee/bootstrap.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Brings the attestor up in TEE mode:
+ *   1. Pull signing/OPRF secrets from GCP Secret Manager into process.env.
+ *   2. Load (or obtain via ACME) the TLS cert and start the renewal loop.
+ *   3. Start the attestation refresh loop, with the public key + cert hash
+ *      as nonces.
+ *
+ * Must run before #src/server/index.ts is imported, since modules in that
+ * tree read PRIVATE_KEY at module load.
+ */
+export declare function bootstrapTee(): Promise<void>;

package/lib/server/tee/cert-manager.d.ts

@@ -0,0 +1,24 @@
+import tls from 'tls';
+export interface CertManagerConfig {
+    projectId: string;
+    domain: string;
+    email: string;
+    directoryUrl: string;
+    httpChallengePort: number;
+}
+export interface ActiveCertificate {
+    certPem: string;
+    keyPem: string;
+    notAfter: Date;
+    sha256Hex: string;
+    secureContext: tls.SecureContext;
+}
+/**
+ * Bootstraps the TLS certificate. Tries Secret Manager first; if absent or
+ * expiring within the renewal window, runs ACME against the configured
+ * directory URL and persists the result.
+ */
+export declare function bootstrapCertificate(cfg: CertManagerConfig): Promise<ActiveCertificate>;
+export declare function startRenewalLoop(cfg: CertManagerConfig): void;
+export declare function stopRenewalLoop(): void;
+export declare function getActiveCertificate(): ActiveCertificate | undefined;

package/lib/server/tee/cloud-logging.d.ts

@@ -0,0 +1,23 @@
+import type { LogLevel } from '../../types/index.ts';
+interface CloudLoggingOptions {
+    projectId: string;
+    logName: string;
+    level?: LogLevel;
+}
+/**
+ * Replaces the default pino logger with one that forwards every log line
+ * to GCP Cloud Logging under the given log name. Idempotent.
+ *
+ * Probes the Cloud Logging client first by writing a no-op entry; if
+ * authentication or transport fails, leaves the default stdout logger in
+ * place rather than crashing the process. On Confidential Space VMs the
+ * launcher's `tee-container-log-redirect` ships stdout to Cloud Logging
+ * anyway, so the worst case is logs appear under
+ * `confidential-space-launcher` rather than the configured `logName`.
+ *
+ * We also install a process-wide `unhandledRejection` filter that
+ * swallows errors originating in `@google-cloud/logging`, since the SDK
+ * has internal lazy gRPC init that escapes our local `.catch()`.
+ */
+export declare function installCloudLogging(opts: CloudLoggingOptions): void;
+export {};

package/lib/server/tee/secret-loader.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Fetches the attestor's signing key and OPRF key material from GCP
+ * Secret Manager and writes them into process.env, so that the rest of
+ * the server (which reads these via getEnvVariable at module load) sees
+ * them as if they had been set in the environment.
+ *
+ * Must be called before any module that reads PRIVATE_KEY / TOPRF_* is
+ * imported, otherwise the reads happen before the values are populated.
+ */
+export declare function loadSecretsIntoEnv(projectId: string): Promise<void>;

package/lib/server/tee/secret-manager.d.ts

@@ -0,0 +1,3 @@
+export declare function accessLatestSecret(projectId: string, secretId: string): Promise<Uint8Array>;
+export declare function createSecretIfNotExists(projectId: string, secretId: string): Promise<void>;
+export declare function addSecretVersion(projectId: string, secretId: string, payload: Uint8Array): Promise<void>;

package/lib/server/utils/sev-snp/gcp.d.ts

@@ -12,4 +12,6 @@ import { type SevSnpEnvelope } from '../../../server/utils/sev-snp/verify.ts';
 export declare function verifyGcpLeg(env: SevSnpEnvelope, bound: Buffer, now: Date): {
     app: string;
     base: string;
+    pcrs: Map<number, Buffer>;
+    eventLog: Buffer;
 };

package/lib/server/utils/sev-snp/nitrotpm.d.ts

@@ -9,6 +9,7 @@
 export interface NitroTpmResult {
     pcr8: Buffer;
     pcr11: Buffer;
+    pcrs: Map<number, Buffer>;
     userData: Buffer;
 }
 /**

package/lib/server/utils/sev-snp/secure-boot.d.ts

@@ -0,0 +1,9 @@
+type Bank = 'sha256' | 'sha384';
+export interface SecureBootEventLogResult {
+    eventLogBytes: number;
+    verifiedEvents: number;
+    postSeparatorUses: number;
+    releasePublicKeySha256: string;
+}
+export declare function verifySecureBootEventLog(raw: Uint8Array, quotedPcrs: Map<number, Buffer>, bank: Bank): SecureBootEventLogResult;
+export {};

package/lib/server/utils/sev-snp/secure-boot.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/server/utils/sev-snp/verify.d.ts

@@ -8,6 +8,8 @@
  */
 export declare const SEV_TAG_GCP = 1;
 export declare const SEV_TAG_AWS = 2;
+export declare const SECURE_BOOT_TAG_GCP = 3;
+export declare const SECURE_BOOT_TAG_AWS = 4;
 export declare const SNP_APP_PREFIX = "snp-app:";
 export declare const SNP_BASE_PREFIX = "snp-base:";
 export declare const APP_PCR = 8;
@@ -17,6 +19,8 @@ export interface SevSnpEnvelope {
     tpm?: Uint8Array;
     nitrotpm?: Uint8Array;
     sev?: Uint8Array;
+    sev2?: Uint8Array;
+    eventlog?: Uint8Array;
     nonces?: string[];
 }
 export interface SevSnpResult {
@@ -37,6 +41,10 @@ export declare function parseSevSnpEnvelope(att: Uint8Array): Promise<{
  * what makes the carried nonces unforgeable.
  */
 export declare function snpNonceCommitment(nonces: string[]): Buffer;
+/** Commits the AMD report to the exact NitroTPM evidence from the same broker. */
+export declare function awsCombinedV2ReportData(bound: Uint8Array, appHash: Uint8Array, nitroTpm: Uint8Array): Buffer;
+/** Only an absent value or an explicit 0 keeps the AWS expansion path active. */
+export declare function requireAwsAttestationV2(value?: string | undefined): boolean;
 /**
  * expectedPCR8: the value the loader produces by extending a pristine (all-zero)
  * PCR 8 once with alg(appHash), i.e. alg(0^algSize || alg(appHash)). GCP uses the
@@ -57,3 +65,14 @@ export declare function extractTeeKeyFromNonces(nonces: string[]): {
  * `now` defaults to the real clock; tests may pass a time in the leaf window.
  */
 export declare function verifyCombinedSevSnp(att: Uint8Array, now?: Date): Promise<SevSnpResult>;
+/**
+ * Verifies the additive Secure Boot claim format. The cloud-specific leg is
+ * unchanged from SEV2; only after it succeeds do we replay PCR 4/7/11 and pin R.
+ */
+export declare function verifyCombinedSecureBoot(att: Uint8Array, now?: Date): Promise<SevSnpResult>;
+/**
+ * Restores the distinct Secure Boot tag on legacy-compatible client evidence.
+ * Call this only when an authenticated protocol value requires Secure Boot;
+ * the legacy tag alone is intentionally not a generation signal.
+ */
+export declare function secureBootAttestationFromCompatibleWire(att: Uint8Array): Buffer;

package/lib/server/utils/tee-cbc-contract.d.ts

@@ -0,0 +1,3 @@
+import type { KOutputPayload, TOutputPayload, VerificationBundle } from '../../proto/tee-bundle.ts';
+export type TeeProtocolMode = 'split-aead' | 'tls12-cbc';
+export declare function validateTeeTranscriptContract(bundle: VerificationBundle, kPayload: KOutputPayload, tPayload: TOutputPayload): TeeProtocolMode;

package/lib/server/utils/tee-oprf-mpc-verification.d.ts

@@ -9,6 +9,7 @@
 import type { KOutputPayload, TOutputPayload } from '../../proto/tee-bundle.ts';
 import type { OprfVerificationResult } from '../../server/utils/tee-oprf-verification.ts';
 import type { Logger } from '../../types/general.ts';
+export declare const MAX_TEE_OPRF_MPC_OUTPUTS = 20;
 /**
  * Verifies OPRF MPC outputs from TEE_K and TEE_T match
  * Returns verified outputs for transcript replacement (same format as ZK OPRF)

package/lib/server/utils/tee-verification.d.ts

@@ -4,6 +4,7 @@
  */
 import type { SignedMessage } from '../../proto/tee-bundle.ts';
 import { KOutputPayload, TOutputPayload } from '../../proto/tee-bundle.ts';
+import type { TeeProtocolMode } from '../../server/utils/tee-cbc-contract.ts';
 import type { Logger } from '../../types/general.ts';
 export interface TeeBundleData {
     teekSigned: SignedMessage;
@@ -13,6 +14,7 @@ export interface TeeBundleData {
     teekPcr0: string;
     teetPcr0: string;
     teeSessionId: string;
+    protocolMode: TeeProtocolMode;
 }
 export interface TeeSignatureVerificationResult {
     isValid: boolean;
@@ -26,3 +28,4 @@ export interface TeeSignatureVerificationResult {
  * @returns Validated TEE bundle data
  */
 export declare function verifyTeeBundle(bundleBytes: Uint8Array, logger: Logger): Promise<TeeBundleData>;
+export declare function resolveSignedAttestationType(signedType: string, reportType: string): string;