@reclaimprotocol/attestor-core 4.0.3 → 5.0.1-beta.10

package/lib/server/utils/nitro-attestation.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Working Nitro Attestation validation utilities
+ */
+export interface AttestationDocument {
+    module_id: string;
+    digest: string;
+    timestamp: bigint;
+    pcrs: {
+        [key: number]: Buffer;
+    };
+    certificate: Buffer;
+    cabundle: Buffer[];
+    public_key?: Buffer;
+    user_data?: Buffer;
+    nonce?: Buffer;
+}
+export interface NitroValidationResult {
+    isValid: boolean;
+    errors: string[];
+    warnings: string[];
+    userDataType?: 'tee_k' | 'tee_t';
+    ethAddress?: string;
+    pcr0: string;
+}
+export interface AddressExtractionResult {
+    teeType: 'tee_k' | 'tee_t';
+    ethAddress?: string;
+    pcr0: string;
+}
+/**
+ * Working validation function copied from nitroattestor
+ */
+export declare function validateNitroAttestationAndExtractKey(attestationBytes: Uint8Array): Promise<NitroValidationResult>;

package/lib/server/utils/nitro-attestation.js

@@ -0,0 +1,249 @@
+import { AsnParser } from "@peculiar/asn1-schema";
+import { SubjectPublicKeyInfo } from "@peculiar/asn1-x509";
+import { Crypto } from "@peculiar/webcrypto";
+import { X509Certificate, X509ChainBuilder } from "@peculiar/x509";
+import { sign } from "cose-js";
+async function getCborDecode() {
+  const { decode } = await import("cbor-x");
+  return decode;
+}
+const AWS_NITRO_ROOT_CERT = `-----BEGIN CERTIFICATE-----
+MIICETCCAZagAwIBAgIRAPkxdWgbkK/hHUbMtOTn+FYwCgYIKoZIzj0EAwMwSTEL
+MAkGA1UEBhMCVVMxDzANBgNVBAoMBkFtYXpvbjEMMAoGA1UECwwDQVdTMRswGQYD
+VQQDDBJhd3Mubml0cm8tZW5jbGF2ZXMwHhcNMTkxMDI4MTMyODA1WhcNNDkxMDI4
+MTQyODA1WjBJMQswCQYDVQQGEwJVUzEPMA0GA1UECgwGQW1hem9uMQwwCgYDVQQL
+DANBV1MxGzAZBgNVBAMMEmF3cy5uaXRyby1lbmNsYXZlczB2MBAGByqGSM49AgEG
+BSuBBAAiA2IABPwCVOumCMHzaHDimtqQvkY4MpJzbolL//Zy2YlES1BR5TSksfbb
+48C8WBoyt7F2Bw7eEtaaP+ohG2bnUs990d0JX28TcPQXCEPZ3BABIeTPYwEoCWZE
+h8l5YoQwTcU/9KNCMEAwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkCW1DdkF
+R+eWw5b6cp3PmanfS5YwDgYDVR0PAQH/BAQDAgGGMAoGCCqGSM49BAMDA2kAMGYC
+MQCjfy+Rocm9Xue4YnwWmNJVA44fA0P5W2OpYow9OYCVRaEevL8uO1XYru5xtMPW
+rfMCMQCi85sWBbJwKKXdS6BptQFuZbT73o/gBh1qUxl/nNr12UO8Yfwr6wPLb+6N
+IwLz3/Y=
+-----END CERTIFICATE-----`;
+async function validateCertificateChain(targetCert, intermediateCerts, rootCert, crypto) {
+  const errors = [];
+  try {
+    const rootSubject = rootCert.subject;
+    const rootIssuer = rootCert.issuer;
+    if (rootSubject !== rootIssuer) {
+      errors.push("Root certificate is not self-signed");
+    }
+    try {
+      const isRootValid = await rootCert.verify(void 0, crypto);
+      if (!isRootValid) {
+        errors.push("Root certificate signature verification failed");
+      }
+    } catch (error) {
+      errors.push(`Root certificate verification failed: ${error.message}`);
+    }
+    const chainBuilder = new X509ChainBuilder({
+      certificates: [rootCert, ...intermediateCerts]
+    });
+    let chain;
+    try {
+      chain = await chainBuilder.build(targetCert, crypto);
+    } catch (error) {
+      errors.push(`Certificate chain building failed: ${error.message}`);
+      return { isValid: false, errors, chain: [] };
+    }
+    if (!chain || chain.length === 0) {
+      errors.push("No valid certificate chain could be built");
+      return { isValid: false, errors, chain: [] };
+    }
+    const now = /* @__PURE__ */ new Date();
+    for (let i = 0; i < chain.length; i++) {
+      const cert = chain[i];
+      if (now < cert.notBefore) {
+        errors.push(`Certificate ${i} (${cert.subject}) is not yet valid`);
+      }
+      if (now > cert.notAfter) {
+        errors.push(`Certificate ${i} (${cert.subject}) has expired`);
+      }
+      if (i < chain.length - 1) {
+        try {
+          const issuer = chain[i + 1];
+          const isValid = await cert.verify(issuer, crypto);
+          if (!isValid) {
+            errors.push(`Certificate ${i} signature verification failed`);
+          }
+        } catch (error) {
+          errors.push(`Certificate ${i} verification failed: ${error.message}`);
+        }
+      }
+    }
+    return {
+      isValid: errors.length === 0,
+      errors,
+      chain
+    };
+  } catch (error) {
+    errors.push(`Certificate chain validation error: ${error.message}`);
+    return { isValid: false, errors, chain: [] };
+  }
+}
+function extractPublicKeyFromUserData(userDataBuffer) {
+  try {
+    const userDataString = userDataBuffer.toString("utf-8");
+    const teeKMatch = userDataString.match(/^tee_k_public_key:(0x[0-9a-fA-F]{40})$/);
+    const teeTMatch = userDataString.match(/^tee_t_public_key:(0x[0-9a-fA-F]{40})$/);
+    if (teeKMatch) {
+      return {
+        teeType: "tee_k",
+        ethAddress: teeKMatch[1],
+        // Store the full ETH address with 0x prefix
+        pcr0: ""
+      };
+    }
+    if (teeTMatch) {
+      return {
+        teeType: "tee_t",
+        ethAddress: teeTMatch[1],
+        // Store the full ETH address with 0x prefix
+        pcr0: ""
+      };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function validateNitroAttestationAndExtractKey(attestationBytes) {
+  const errors = [];
+  const warnings = [];
+  try {
+    const crypto = new Crypto();
+    const decode = await getCborDecode();
+    let decoded;
+    try {
+      decoded = decode(Buffer.from(attestationBytes));
+    } catch (error) {
+      errors.push(`CBOR decoding failed: ${error.message}`);
+      return { isValid: false, errors, warnings, pcr0: "" };
+    }
+    if (!Array.isArray(decoded) || decoded.length < 4) {
+      errors.push("Invalid COSE_Sign1 structure: expected array with 4 elements");
+      return { isValid: false, errors, warnings, pcr0: "" };
+    }
+    const [, , payload] = decoded;
+    if (!payload || payload.length === 0) {
+      errors.push("Empty or missing payload in COSE_Sign1 structure");
+      return { isValid: false, errors, warnings, pcr0: "" };
+    }
+    let doc;
+    try {
+      doc = decode(payload);
+    } catch (error) {
+      errors.push(`Payload decoding failed: ${error.message}`);
+      return { isValid: false, errors, warnings, pcr0: "" };
+    }
+    if (doc.module_id.length === 0) {
+      errors.push("Missing or invalid module_id");
+    }
+    if (doc.digest.length === 0) {
+      errors.push("Missing or invalid digest");
+    }
+    if (!doc.pcrs || typeof doc.pcrs !== "object") {
+      errors.push("Missing or invalid pcrs");
+    }
+    if (!Buffer.isBuffer(doc.certificate) || doc.certificate.length === 0) {
+      errors.push("Missing or invalid certificate");
+    }
+    if (!Array.isArray(doc.cabundle) || doc.cabundle.length === 0) {
+      errors.push("Missing or invalid cabundle");
+    }
+    if (errors.length > 0) {
+      return { isValid: false, errors, warnings, pcr0: "" };
+    }
+    const pcr0 = doc.pcrs[0].toString("hex");
+    const intermediateCerts = [];
+    for (let i = 0; i < doc.cabundle.length; i++) {
+      try {
+        const cert = new X509Certificate(doc.cabundle[i].toString("base64"));
+        intermediateCerts.push(cert);
+      } catch (error) {
+        errors.push(`Failed to parse cabundle certificate ${i}: ${error.message}`);
+      }
+    }
+    let targetCert;
+    try {
+      targetCert = new X509Certificate(doc.certificate.toString("base64"));
+    } catch (error) {
+      errors.push(`Failed to parse target certificate: ${error.message}`);
+      return { isValid: false, errors, warnings, pcr0: "" };
+    }
+    let rootCert;
+    try {
+      rootCert = new X509Certificate(AWS_NITRO_ROOT_CERT);
+    } catch (error) {
+      errors.push(`Failed to parse AWS Nitro root certificate: ${error.message}`);
+      return { isValid: false, errors, warnings, pcr0: "" };
+    }
+    const chainResult = await validateCertificateChain(targetCert, intermediateCerts, rootCert, crypto);
+    if (!chainResult.isValid) {
+      errors.push(...chainResult.errors);
+      return { isValid: false, errors, warnings, pcr0: "" };
+    }
+    let publicKeyRaw;
+    try {
+      publicKeyRaw = Buffer.from(targetCert.publicKey.rawData);
+    } catch (error) {
+      errors.push(`Failed to extract public key: ${error.message}`);
+      return { isValid: false, errors, warnings, pcr0: "" };
+    }
+    if (publicKeyRaw.length !== 120 || publicKeyRaw[0] !== 48) {
+      errors.push(`Invalid public key format: expected 120-byte DER-encoded key, got ${publicKeyRaw.length} bytes`);
+      return { isValid: false, errors, warnings, pcr0: "" };
+    }
+    let spki;
+    try {
+      spki = AsnParser.parse(publicKeyRaw, SubjectPublicKeyInfo);
+    } catch (error) {
+      errors.push(`Failed to parse SubjectPublicKeyInfo: ${error.message}`);
+      return { isValid: false, errors, warnings, pcr0: "" };
+    }
+    const ecPoint = Buffer.from(spki.subjectPublicKey);
+    if (ecPoint.length !== 97 || ecPoint[0] !== 4) {
+      errors.push("Invalid EC point: expected 97-byte uncompressed P-384 key");
+      return { isValid: false, errors, warnings, pcr0: "" };
+    }
+    const x = ecPoint.subarray(1, 49);
+    const y = ecPoint.subarray(49, 97);
+    try {
+      const verifier = {
+        key: {
+          x,
+          y
+        }
+      };
+      const options = { defaultType: 18 };
+      await sign.verify(Buffer.from(attestationBytes), verifier, options);
+    } catch (error) {
+      errors.push(`COSE signature verification failed: ${error.message}`);
+      return { isValid: false, errors, warnings, pcr0: "" };
+    }
+    let userDataType;
+    let ethAddress;
+    if (doc.user_data) {
+      const keyInfo = extractPublicKeyFromUserData(doc.user_data);
+      if (keyInfo) {
+        userDataType = keyInfo.teeType;
+        ethAddress = keyInfo.ethAddress;
+      }
+    }
+    return {
+      isValid: errors.length === 0,
+      errors,
+      warnings,
+      userDataType,
+      ethAddress,
+      pcr0
+    };
+  } catch (error) {
+    errors.push(`Unexpected error during validation: ${error.message}`);
+    return { isValid: false, errors, warnings, pcr0: "" };
+  }
+}
+export {
+  validateNitroAttestationAndExtractKey
+};

package/lib/server/utils/oprf-raw.d.ts

@@ -0,0 +1,21 @@
+import type { MessageReveal_OPRFRawMarker as OPRFRawMarker } from '#src/proto/api.ts';
+import type { Logger } from '#src/types/index.ts';
+export type OPRFRawResult = {
+    /** Location of the data that was OPRF'd */
+    dataLocation: {
+        fromIndex: number;
+        length: number;
+    };
+    /** The OPRF nullifier (hash output) */
+    nullifier: Uint8Array;
+};
+/**
+ * Compute OPRF for plaintext data marked with oprf-raw.
+ * This runs server-side since the attestor has access to the revealed plaintext.
+ *
+ * @param plaintext - The revealed plaintext from the TLS transcript
+ * @param markers - Positions in the plaintext to compute OPRF for
+ * @param logger - Logger instance
+ * @returns Array of OPRF results with nullifiers
+ */
+export declare function computeOPRFRaw(plaintext: Uint8Array, markers: OPRFRawMarker[], logger: Logger): Promise<OPRFRawResult[]>;

package/lib/server/utils/oprf-raw.js

@@ -0,0 +1,61 @@
+import { getBytes } from "ethers";
+import { TOPRF_DOMAIN_SEPARATOR } from "../../config/index.js";
+import { getEnvVariable } from "../../utils/env.js";
+import { makeDefaultOPRFOperator } from "../../utils/zk.js";
+async function computeOPRFRaw(plaintext, markers, logger) {
+  if (!markers.length) {
+    return [];
+  }
+  const PRIVATE_KEY_STR = getEnvVariable("TOPRF_SHARE_PRIVATE_KEY");
+  const PUBLIC_KEY_STR = getEnvVariable("TOPRF_SHARE_PUBLIC_KEY");
+  if (!PRIVATE_KEY_STR || !PUBLIC_KEY_STR) {
+    throw new Error("TOPRF keys not configured. Cannot compute oprf-raw.");
+  }
+  const privateKey = getBytes(PRIVATE_KEY_STR);
+  const publicKey = getBytes(PUBLIC_KEY_STR);
+  const operator = makeDefaultOPRFOperator("chacha20", "gnark", logger);
+  const results = [];
+  for (const marker of markers) {
+    const { dataLocation } = marker;
+    if (!dataLocation) {
+      logger.warn("oprf-raw marker missing dataLocation, skipping");
+      continue;
+    }
+    const { fromIndex, length } = dataLocation;
+    const endIndex = fromIndex + length;
+    if (endIndex > plaintext.length) {
+      throw new Error(
+        `oprf-raw marker out of bounds: fromIndex=${fromIndex}, length=${length}, plaintextLength=${plaintext.length}`
+      );
+    }
+    const data = plaintext.slice(fromIndex, endIndex);
+    const request = await operator.generateOPRFRequestData(
+      data,
+      TOPRF_DOMAIN_SEPARATOR,
+      logger
+    );
+    const response = await operator.evaluateOPRF(
+      privateKey,
+      request.maskedData,
+      logger
+    );
+    const nullifier = await operator.finaliseOPRF(
+      publicKey,
+      request,
+      [{ ...response, publicKeyShare: publicKey }],
+      logger
+    );
+    results.push({
+      dataLocation: { fromIndex, length },
+      nullifier
+    });
+    logger.debug(
+      { fromIndex, length, nullifierHex: Buffer.from(nullifier).toString("hex").slice(0, 16) + "..." },
+      "computed oprf-raw nullifier"
+    );
+  }
+  return results;
+}
+export {
+  computeOPRFRaw
+};

package/lib/server/utils/process-handshake.d.ts

@@ -1,5 +1,5 @@
-import { ClaimTunnelRequest } from '../../proto/api';
-import { Logger } from '../../types';
+import type { ClaimTunnelRequest } from '#src/proto/api.ts';
+import type { Logger } from '#src/types/index.ts';
 /**
  * Verifies server cert chain and removes handshake messages from transcript
  * @param receipt
@@ -7,7 +7,7 @@ import { Logger } from '../../types';
  */
 export declare function processHandshake(receipt: ClaimTunnelRequest['transcript'], logger: Logger): Promise<{
     tlsVersion: "TLS1_3" | "TLS1_2";
-    cipherSuite: "TLS_CHACHA20_POLY1305_SHA256" | "TLS_AES_256_GCM_SHA384" | "TLS_AES_128_GCM_SHA256" | "TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256" | "TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256" | "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256" | "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256" | "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384" | "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384" | "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA" | "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA";
+    cipherSuite: "TLS_CHACHA20_POLY1305_SHA256" | "TLS_AES_256_GCM_SHA384" | "TLS_AES_128_GCM_SHA256" | "TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256" | "TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256" | "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256" | "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256" | "TLS_RSA_WITH_AES_128_GCM_SHA256" | "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384" | "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384" | "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA" | "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA";
     hostname: string;
     nextMsgIndex: number;
 }>;