@reclaimprotocol/attestor-core 5.0.7 → 5.0.8

package/lib/proto/tdx.d.ts

@@ -0,0 +1,165 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+export declare const protobufPackage = "tdx";
+export interface QuoteV4 {
+    /** Header of quote structure */
+    header: Header | undefined;
+    /** TD report by which quote is generated */
+    tdQuoteBody: TDQuoteBody | undefined;
+    /** Size of the Quote Signature Data structure */
+    signedDataSize: number;
+    /** Quote Signature Data structure. */
+    signedData: Ecdsa256BitQuoteV4AuthData | undefined;
+    /** Extra bytes included to fill the quote buffer */
+    extraBytes: Uint8Array;
+}
+export interface Header {
+    /** Version 4 supported */
+    version: number;
+    /**
+     * Type of attestation key used by quoting enclave
+     * Values :
+     * 2 (ECDSA-256-with-P-256 curve)
+     * 3 (ECDSA-384-with-P-384 curve) (Currently not supported)
+     */
+    attestationKeyType: number;
+    /**
+     * TEE for this attestation
+     * TDX : 0x00000081
+     */
+    teeType: number;
+    /** should be 2 bytes */
+    qeSvn: Uint8Array;
+    /** should be 2 bytes */
+    pceSvn: Uint8Array;
+    /** Unique vendor id of QE vendor */
+    qeVendorId: Uint8Array;
+    /** Custom user defined data */
+    userData: Uint8Array;
+}
+export interface TDQuoteBody {
+    /** should be 16 bytes */
+    teeTcbSvn: Uint8Array;
+    /** should be 48 bytes */
+    mrSeam: Uint8Array;
+    /** should be 48 bytes */
+    mrSignerSeam: Uint8Array;
+    /** should be 8 bytes */
+    seamAttributes: Uint8Array;
+    /** should be 8 bytes */
+    tdAttributes: Uint8Array;
+    /** should be 8 bytes */
+    xfam: Uint8Array;
+    /** should be 48 bytes */
+    mrTd: Uint8Array;
+    /** should be 48 bytes */
+    mrConfigId: Uint8Array;
+    /** should be 48 bytes */
+    mrOwner: Uint8Array;
+    /** should be 48 bytes */
+    mrOwnerConfig: Uint8Array;
+    /** should be 48 * rtmrsCount */
+    rtmrs: Uint8Array[];
+    /** should be 64 bytes */
+    reportData: Uint8Array;
+}
+export interface Ecdsa256BitQuoteV4AuthData {
+    /** The ECDSA 256-bit signature. */
+    signature: Uint8Array;
+    /** The ECDSA 256-bit public key of the attestation key. */
+    ecdsaAttestationKey: Uint8Array;
+    /** The certification data. */
+    certificationData: CertificationData | undefined;
+}
+export interface CertificationData {
+    /**
+     * Supported values:
+     * - 1 (PCK identifier: PPID in plain text,  CPUSVN and PCESVN)
+     * - 2 (PCK identifier: PPID encrypted using RSA-2048-OAEP, CPUSVN and PCESVN)
+     * - 3 (PCK identifier: PPID encrypted using RSA-3072-OAEP, CPUSVN and PCESVN)
+     * - 4 (PCK Leaf Certificate in plain text,  currently not supported)
+     * - 5 (Concatenated PCK Cert Chain)
+     * - 6 (QE Report Certification Data)
+     * - 7 (PLATFORM_MANIFEST, currently  not supported)
+     */
+    certificateDataType: number;
+    /** Size of Certification Data field */
+    size: number;
+    qeReportCertificationData: QEReportCertificationData | undefined;
+}
+export interface QEReportCertificationData {
+    qeReport: EnclaveReport | undefined;
+    /** should be 64 bytes */
+    qeReportSignature: Uint8Array;
+    qeAuthData: QeAuthData | undefined;
+    pckCertificateChainData: PCKCertificateChainData | undefined;
+}
+export interface PCKCertificateChainData {
+    /**
+     * Supported values:
+     * - 1 (PCK identifier: PPID in plain text,  CPUSVN and PCESVN)
+     * - 2 (PCK identifier: PPID encrypted using RSA-2048-OAEP, CPUSVN and PCESVN)
+     * - 3 (PCK identifier: PPID encrypted using RSA-3072-OAEP, CPUSVN and PCESVN)
+     * - 4 (PCK Leaf Certificate in plain text,  currently not supported)
+     * - 5 (Concatenated PCK Cert Chain)
+     * - 6 (QE Report Certification Data)
+     * - 7 (PLATFORM_MANIFEST, currently  not supported)
+     */
+    certificateDataType: number;
+    /** Size of Certification Data field */
+    size: number;
+    pckCertChain: Uint8Array;
+}
+export interface QeAuthData {
+    /** The parsed data size. */
+    parsedDataSize: number;
+    /** The data. */
+    data: Uint8Array;
+}
+export interface EnclaveReport {
+    /** should be 16 bytes */
+    cpuSvn: Uint8Array;
+    /** should be 4 bytes */
+    miscSelect: number;
+    /** should be 28 bytes */
+    reserved1: Uint8Array;
+    /** should be 16 bytes */
+    attributes: Uint8Array;
+    /** should be 32 bytes */
+    mrEnclave: Uint8Array;
+    /** should be 32 bytes */
+    reserved2: Uint8Array;
+    /** should be 32 bytes */
+    mrSigner: Uint8Array;
+    /** should be 96 bytes */
+    reserved3: Uint8Array;
+    /** should be 2 bytes */
+    isvProdId: number;
+    /** should be 2 bytes */
+    isvSvn: number;
+    /** should be 60 bytes */
+    reserved4: Uint8Array;
+    /** should be 64 bytes */
+    reportData: Uint8Array;
+}
+export declare const QuoteV4: MessageFns<QuoteV4>;
+export declare const Header: MessageFns<Header>;
+export declare const TDQuoteBody: MessageFns<TDQuoteBody>;
+export declare const Ecdsa256BitQuoteV4AuthData: MessageFns<Ecdsa256BitQuoteV4AuthData>;
+export declare const CertificationData: MessageFns<CertificationData>;
+export declare const QEReportCertificationData: MessageFns<QEReportCertificationData>;
+export declare const PCKCertificateChainData: MessageFns<PCKCertificateChainData>;
+export declare const QeAuthData: MessageFns<QeAuthData>;
+export declare const EnclaveReport: MessageFns<EnclaveReport>;
+type Builtin = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create(base?: DeepPartial<T>): T;
+    fromPartial(object: DeepPartial<T>): T;
+}
+export {};

package/lib/proto/tpm.d.ts

@@ -0,0 +1,104 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+export declare const protobufPackage = "tpm";
+/** Enum values come from TCG Algorithm Registry - v1.27 - Table 3 */
+export declare const ObjectType: {
+    readonly OBJECT_INVALID: 0;
+    readonly RSA: 1;
+    readonly ECC: 35;
+    readonly UNRECOGNIZED: -1;
+};
+export type ObjectType = typeof ObjectType[keyof typeof ObjectType];
+export declare namespace ObjectType {
+    type OBJECT_INVALID = typeof ObjectType.OBJECT_INVALID;
+    type RSA = typeof ObjectType.RSA;
+    type ECC = typeof ObjectType.ECC;
+    type UNRECOGNIZED = typeof ObjectType.UNRECOGNIZED;
+}
+export declare function objectTypeFromJSON(object: any): ObjectType;
+export declare function objectTypeToJSON(object: ObjectType): string;
+export declare const HashAlgo: {
+    readonly HASH_INVALID: 0;
+    readonly SHA1: 4;
+    readonly SHA256: 11;
+    readonly SHA384: 12;
+    readonly SHA512: 13;
+    readonly UNRECOGNIZED: -1;
+};
+export type HashAlgo = typeof HashAlgo[keyof typeof HashAlgo];
+export declare namespace HashAlgo {
+    type HASH_INVALID = typeof HashAlgo.HASH_INVALID;
+    type SHA1 = typeof HashAlgo.SHA1;
+    type SHA256 = typeof HashAlgo.SHA256;
+    type SHA384 = typeof HashAlgo.SHA384;
+    type SHA512 = typeof HashAlgo.SHA512;
+    type UNRECOGNIZED = typeof HashAlgo.UNRECOGNIZED;
+}
+export declare function hashAlgoFromJSON(object: any): HashAlgo;
+export declare function hashAlgoToJSON(object: HashAlgo): string;
+/**
+ * SealedBytes stores the result of a TPM2_Seal. The private portion (priv) has
+ * already been encrypted and is no longer sensitive. The hash algorithm is
+ * assumed to be SHA256.
+ */
+export interface SealedBytes {
+    priv: Uint8Array;
+    pub: Uint8Array;
+    pcrs: number[];
+    hash: HashAlgo;
+    srk: ObjectType;
+    certifiedPcrs: PCRs | undefined;
+    creationData: Uint8Array;
+    ticket: Uint8Array;
+}
+export interface ImportBlob {
+    duplicate: Uint8Array;
+    encryptedSeed: Uint8Array;
+    publicArea: Uint8Array;
+    pcrs: PCRs | undefined;
+}
+export interface Quote {
+    /** TPM2 quote, encoded as a TPMS_ATTEST */
+    quote: Uint8Array;
+    /** TPM2 signature, encoded as a TPMT_SIGNATURE */
+    rawSig: Uint8Array;
+    /** PCR values of the bank being quoted */
+    pcrs: PCRs | undefined;
+}
+export interface PCRs {
+    hash: HashAlgo;
+    pcrs: {
+        [key: number]: Uint8Array;
+    };
+}
+export interface PCRs_PcrsEntry {
+    key: number;
+    value: Uint8Array;
+}
+/** Contains information corresponding an object certified with TPM2_Certify. */
+export interface CertifiedBlob {
+    /** Public area of certified object, encoded as a TPMT_PUBLIC */
+    pubArea: Uint8Array;
+    /** TPM2 certification, encoded as a TPMS_ATTEST */
+    certifyInfo: Uint8Array;
+    /** TPM2 signature, encoded as a TPMT_Signature */
+    rawSig: Uint8Array;
+}
+export declare const SealedBytes: MessageFns<SealedBytes>;
+export declare const ImportBlob: MessageFns<ImportBlob>;
+export declare const Quote: MessageFns<Quote>;
+export declare const PCRs: MessageFns<PCRs>;
+export declare const PCRs_PcrsEntry: MessageFns<PCRs_PcrsEntry>;
+export declare const CertifiedBlob: MessageFns<CertifiedBlob>;
+type Builtin = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create(base?: DeepPartial<T>): T;
+    fromPartial(object: DeepPartial<T>): T;
+}
+export {};

package/lib/providers/http/utils.d.ts

@@ -1,5 +1,4 @@
 import '../../providers/http/patch-parse5-tree.ts';
-import RE2 from 're2';
 import type { ArraySlice, CompleteTLSPacket, ProviderParams, Transcript } from '../../types/index.ts';
 import type { HttpRequest, HttpResponse } from '../../utils/index.ts';
 export type JSONIndex = {
@@ -64,7 +63,7 @@ export declare function convertResponsePosToAbsolutePos(pos: number, bodyStartId
  */
 export declare function getRedactionsForChunkHeaders(from: number, to: number, chunks?: ArraySlice[]): ArraySlice[];
 export declare function parseHttpResponse(buff: Uint8Array): HttpResponse;
-export declare function makeRegex(str: string): RE2;
+export declare function makeRegex(str: string): RegExp;
 /**
  * Try to match strings that contain templates like {{param}}
  * against redacted string that has *** instead of that param

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

@@ -0,0 +1,13 @@
+/**
+ * SEV-SNP base-image allowlist (the pin point for base UKI hashes).
+ *
+ * The attestor pins only the per-cloud base UKI (PCR 11: SHA-256 on GCP,
+ * SHA-384 on AWS) — that is its root of trust. The cross-cloud app bundle
+ * digest (PCR 8) is NOT pinned here; it is published into the claim context
+ * for the claim consumer to verify against its own policy.
+ *
+ * Rotate by editing this list or by setting SNP_BASE_ALLOWLIST (comma-separated,
+ * with or without the snp-base: prefix).
+ */
+/** Throws unless the base UKI hash is pinned. */
+export declare function assertSevSnpBaseAllowed(base: string): void;

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

@@ -0,0 +1,15 @@
+/**
+ * GCP SEV-SNP leg: go-tpm-tools Attestation. AK cert chains to the Google vTPM
+ * root; the SEV report binds sha512(akPub||bound) (anti-splice); the AK-signed
+ * TPM2 quote (SHA-256 bank) over PCRs proves PCR 8 (app) + PCR 11 (base).
+ * Ports go-tpm-tools quote.Verify + the report_data binding.
+ */
+import { type SevSnpEnvelope } from '../../../server/utils/sev-snp/verify.ts';
+/**
+ * Verifies the GCP leg: AK->Google root, SEV report bound to sha512(akPub||bound),
+ * AK-signed SHA-256 quote (nonce sha256(bound)) -> PCRs, PCR8 proves the app hash.
+ */
+export declare function verifyGcpLeg(env: SevSnpEnvelope, bound: Buffer, now: Date): {
+    app: string;
+    base: string;
+};

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

@@ -0,0 +1,19 @@
+/**
+ * AWS NitroTPM attestation document verifier (the AWS code-identity proof).
+ *
+ * Port of reclaim-tee shared/snp_combined_aws.go verifyNitroTPMDocument: the doc
+ * is a COSE_Sign1 (ES384) whose leaf cert chains to the pinned AWS Nitro root;
+ * its nitrotpm_pcrs carry PCR 8 (app) + PCR 11 (base) and user_data carries the
+ * hardware binding.
+ */
+export interface NitroTpmResult {
+    pcr8: Buffer;
+    pcr11: Buffer;
+    userData: Buffer;
+}
+/**
+ * Verifies the NitroTPM COSE_Sign1 document and returns PCR 8 / PCR 11 and
+ * user_data. Throws on any signature/chain failure. `now` defaults to the real
+ * clock (production freshness); tests may pass a time inside the leaf's window.
+ */
+export declare function verifyNitroTpmDocument(docBytes: Uint8Array, now?: Date): Promise<NitroTpmResult>;

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

@@ -0,0 +1,11 @@
+/**
+ * AMD SEV-SNP report verifier (proves genuine SEV-SNP hardware + report_data
+ * binding). Port of the go-sev-guest verification reclaim-tee invokes:
+ * reconstruct the report ABI, verify the ECDSA-P384 report signature against the
+ * VLEK/VCEK whose cert chains to the pinned AMD Milan ARK, and check report_data.
+ */
+/**
+ * Verifies the SEV-SNP report: genuine AMD hardware (report sig -> VLEK/VCEK ->
+ * Milan ARK) and report_data == expectedReportData. Throws on any failure.
+ */
+export declare function verifySevReport(sevBytes: Uint8Array, expectedReportData: Buffer, now?: Date): void;

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

@@ -0,0 +1,59 @@
+/**
+ * SEV-SNP combined attestation verifier (replaces the dead Nitro path).
+ *
+ * Faithful TS port of reclaim-tee shared/snp_combined_{aws,verify}.go:
+ * a 1-byte cloud tag (0x01 GCP / 0x02 AWS) then a CBOR envelope carrying the
+ * cross-cloud app hash, the cloud-specific hardware evidence, and the
+ * presentable nonce list (the SEV-SNP analogue of a CS JWT eat_nonce).
+ */
+export declare const SEV_TAG_GCP = 1;
+export declare const SEV_TAG_AWS = 2;
+export declare const SNP_APP_PREFIX = "snp-app:";
+export declare const SNP_BASE_PREFIX = "snp-base:";
+export declare const APP_PCR = 8;
+export declare const BASE_PCR = 11;
+export interface SevSnpEnvelope {
+    app: Uint8Array;
+    tpm?: Uint8Array;
+    nitrotpm?: Uint8Array;
+    sev?: Uint8Array;
+    nonces?: string[];
+}
+export interface SevSnpResult {
+    teeType: 'tee_k' | 'tee_t';
+    ethAddress: string;
+    app: string;
+    base: string;
+    nonces: string[];
+}
+/** Splits the 1-byte cloud tag from the CBOR envelope. */
+export declare function parseSevSnpEnvelope(att: Uint8Array): Promise<{
+    tag: number;
+    env: SevSnpEnvelope;
+}>;
+/**
+ * snpNonceCommitment: sha256 over, for each nonce, the 8-byte big-endian byte
+ * length followed by the utf-8 bytes. Binding this in report_data/user_data is
+ * what makes the carried nonces unforgeable.
+ */
+export declare function snpNonceCommitment(nonces: string[]): Buffer;
+/**
+ * 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
+ * SHA-256 bank, AWS the SHA-384 bank.
+ */
+export declare function expectedPCR8(appHash: Uint8Array, alg: 'sha256' | 'sha384'): Buffer;
+export declare function appBaseIdentity(appHash: Uint8Array, pcr11: Uint8Array): {
+    app: string;
+    base: string;
+};
+export declare function extractTeeKeyFromNonces(nonces: string[]): {
+    teeType: 'tee_k' | 'tee_t';
+    ethAddress: string;
+};
+/**
+ * Verifies a claim-path combined SEV-SNP attestation end to end and returns the
+ * tee type, eth signing key, app/base identities, and the presentable nonces.
+ * `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>;

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reclaimprotocol/attestor-core",
-  "version": "5.0.7",
+  "version": "5.0.8",
   "description": "",
   "type": "module",
   "imports": {
@@ -105,12 +105,14 @@
     "parse5": "^8.0.0",
     "parse5-htmlparser2-tree-adapter": "^8.0.0",
     "pino": "^9.14.0",
-    "re2": "^1.24.0",
     "serve-static": "^1.16.3",
     "snarkjs": "^0.7.6",
     "ws": "^8.20.0",
     "xpath": "^0.0.34"
   },
+  "optionalDependencies": {
+    "re2": "*"
+  },
   "devDependencies": {
     "@adiwajshing/eslint-config": "github:adiwajshing/eslint-config",
     "@commitlint/cli": "^17.8.1",
@@ -134,6 +136,7 @@
     "tsc-alias": "^1.8.17",
     "typechain": "^8.3.2",
     "typescript": "^5.9.3",
+    "re2": "^1.24.0",
     "whatwg-url": "^14.2.0",
     "yaml": "^2.8.3"
   },