@reclaimprotocol/attestor-core 5.0.1-beta.2 → 5.0.1-beta.22

package/lib/server/utils/tee-verification.js

@@ -1,358 +1,421 @@
+/**
+ * TEE Bundle verification utilities
+ * Handles validation of TEE verification bundles including attestations and signatures
+ */
 import { ServiceSignatureType } from "../../proto/api.js";
 import { BodyType, KOutputPayload, TOutputPayload, VerificationBundle } from "../../proto/tee-bundle.js";
-import { validateGcpAttestationAndExtractKey } from "../../server/utils/gcp-attestation.js";
-import { validateNitroAttestationAndExtractKey } from "../../server/utils/nitro-attestation.js";
+import { validateGcpAttestationAndExtractKey } from "./gcp-attestation.js";
+import { validateNitroAttestationAndExtractKey } from "./nitro-attestation.js";
 import { AttestorError } from "../../utils/error.js";
 import { SIGNATURES } from "../../utils/signatures/index.js";
-async function verifyTeeBundle(bundleBytes, logger) {
-  const bundle = parseVerificationBundle(bundleBytes);
-  validateBundleCompleteness(bundle);
-  const { teekKeyResult, teetKeyResult } = await extractPublicKeys(bundle, logger);
-  await verifyTeeSignatures(bundle, teekKeyResult, teetKeyResult, logger);
-  if (!bundle.teekSigned || !bundle.teetSigned) {
-    throw new AttestorError("ERROR_INVALID_CLAIM", "Missing TEE signed messages");
-  }
-  const kOutputPayload = parseKOutputPayload(bundle.teekSigned);
-  const tOutputPayload = parseTOutputPayload(bundle.teetSigned);
-  validateTimestamps(kOutputPayload, tOutputPayload, logger);
-  const teeSessionId = validateSessionIds(kOutputPayload, tOutputPayload, logger);
-  logger.info("TEE bundle verification successful");
-  return {
-    teekSigned: bundle.teekSigned,
-    teetSigned: bundle.teetSigned,
-    kOutputPayload,
-    tOutputPayload,
-    teekPcr0: teekKeyResult.pcr0,
-    teetPcr0: teetKeyResult.pcr0,
-    teeSessionId
-  };
+/**
+ * Verifies a complete TEE verification bundle
+ * @param bundleBytes - Raw protobuf-encoded verification bundle
+ * @param logger - Logger instance
+ * @returns Validated TEE bundle data
+ */
+export async function verifyTeeBundle(bundleBytes, logger) {
+    // Parse the verification bundle protobuf
+    const bundle = parseVerificationBundle(bundleBytes);
+    // Validate required components are present
+    validateBundleCompleteness(bundle);
+    // Extract public keys (from attestations or embedded keys)
+    const { teekKeyResult, teetKeyResult } = await extractPublicKeys(bundle, logger);
+    // Verify TEE signatures using extracted public keys
+    await verifyTeeSignatures(bundle, teekKeyResult, teetKeyResult, logger);
+    // Ensure signed messages are present
+    if (!bundle.teekSigned || !bundle.teetSigned) {
+        throw new AttestorError('ERROR_INVALID_CLAIM', 'Missing TEE signed messages');
+    }
+    // Parse TEE payloads
+    const kOutputPayload = parseKOutputPayload(bundle.teekSigned);
+    const tOutputPayload = parseTOutputPayload(bundle.teetSigned);
+    // Validate timestamps
+    validateTimestamps(kOutputPayload, tOutputPayload, logger);
+    // Validate session IDs match (prevents cross-session component substitution)
+    const teeSessionId = validateSessionIds(kOutputPayload, tOutputPayload, logger);
+    logger.info('TEE bundle verification successful');
+    return {
+        teekSigned: bundle.teekSigned,
+        teetSigned: bundle.teetSigned,
+        kOutputPayload,
+        tOutputPayload,
+        teekPcr0: teekKeyResult.pcr0,
+        teetPcr0: teetKeyResult.pcr0,
+        teeSessionId,
+    };
 }
+/**
+ * Parses the raw verification bundle bytes into structured data
+ */
 function parseVerificationBundle(bundleBytes) {
-  try {
-    return VerificationBundle.decode(bundleBytes);
-  } catch (error) {
-    throw new Error(`Failed to parse verification bundle: ${error.message}`);
-  }
+    try {
+        // Use the actual protobuf decoder for the TEE bundle format
+        return VerificationBundle.decode(bundleBytes);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse verification bundle: ${error.message}`);
+    }
 }
+/**
+ * Validates that all required bundle components are present
+ */
 function validateBundleCompleteness(bundle) {
-  if (!bundle.teekSigned) {
-    throw new Error("SECURITY ERROR: missing TEE_K signed message - verification bundle incomplete");
-  }
-  if (!bundle.teetSigned) {
-    throw new Error("SECURITY ERROR: missing TEE_T signed message - verification bundle incomplete");
-  }
-  const hasAttestations = bundle.teekSigned.attestationReport?.report && bundle.teekSigned.attestationReport.report.length > 0 || bundle.teetSigned.attestationReport?.report && bundle.teetSigned.attestationReport.report.length > 0;
-  const hasPublicKeys = bundle.teekSigned.ethAddress && bundle.teekSigned.ethAddress.length > 0 || bundle.teetSigned.ethAddress && bundle.teetSigned.ethAddress.length > 0;
-  if (!hasAttestations && !hasPublicKeys) {
-    throw new Error("SECURITY ERROR: bundle must have either Nitro attestations (production) or embedded public keys (development)");
-  }
-  if (bundle.teekSigned.bodyType !== BodyType.BODY_TYPE_K_OUTPUT) {
-    throw new Error("Invalid TEE_K signed message: wrong body type");
-  }
-  if (bundle.teetSigned.bodyType !== BodyType.BODY_TYPE_T_OUTPUT) {
-    throw new Error("Invalid TEE_T signed message: wrong body type");
-  }
-  if (!bundle.teekSigned.body || bundle.teekSigned.body.length === 0) {
-    throw new Error("Invalid TEE_K signed message: empty body");
-  }
-  if (!bundle.teetSigned.body || bundle.teetSigned.body.length === 0) {
-    throw new Error("Invalid TEE_T signed message: empty body");
-  }
-  if (!bundle.teekSigned.signature || bundle.teekSigned.signature.length === 0) {
-    throw new Error("Invalid TEE_K signed message: missing signature");
-  }
-  if (!bundle.teetSigned.signature || bundle.teetSigned.signature.length === 0) {
-    throw new Error("Invalid TEE_T signed message: missing signature");
-  }
+    if (!bundle.teekSigned) {
+        throw new Error('SECURITY ERROR: missing TEE_K signed message - verification bundle incomplete');
+    }
+    if (!bundle.teetSigned) {
+        throw new Error('SECURITY ERROR: missing TEE_T signed message - verification bundle incomplete');
+    }
+    // Check if we're in standalone mode (development/testing) or attestation mode (production)
+    // Attestations are now embedded in SignedMessage.attestationReport
+    const hasAttestations = (bundle.teekSigned.attestationReport?.report && bundle.teekSigned.attestationReport.report.length > 0) ||
+        (bundle.teetSigned.attestationReport?.report && bundle.teetSigned.attestationReport.report.length > 0);
+    const hasPublicKeys = (bundle.teekSigned.ethAddress && bundle.teekSigned.ethAddress.length > 0) ||
+        (bundle.teetSigned.ethAddress && bundle.teetSigned.ethAddress.length > 0);
+    if (!hasAttestations && !hasPublicKeys) {
+        throw new Error('SECURITY ERROR: bundle must have either Nitro attestations (production) or embedded public keys (development)');
+    }
+    // Validate signed message structure
+    if (bundle.teekSigned.bodyType !== BodyType.BODY_TYPE_K_OUTPUT) {
+        throw new Error('Invalid TEE_K signed message: wrong body type');
+    }
+    if (bundle.teetSigned.bodyType !== BodyType.BODY_TYPE_T_OUTPUT) {
+        throw new Error('Invalid TEE_T signed message: wrong body type');
+    }
+    if (!bundle.teekSigned.body || bundle.teekSigned.body.length === 0) {
+        throw new Error('Invalid TEE_K signed message: empty body');
+    }
+    if (!bundle.teetSigned.body || bundle.teetSigned.body.length === 0) {
+        throw new Error('Invalid TEE_T signed message: empty body');
+    }
+    if (!bundle.teekSigned.signature || bundle.teekSigned.signature.length === 0) {
+        throw new Error('Invalid TEE_K signed message: missing signature');
+    }
+    if (!bundle.teetSigned.signature || bundle.teetSigned.signature.length === 0) {
+        throw new Error('Invalid TEE_T signed message: missing signature');
+    }
 }
+/**
+ * Extracts public keys from either Nitro attestations or embedded keys (standalone mode)
+ */
 async function extractPublicKeys(bundle, logger) {
-  const hasEmbeddedAttestations = bundle.teekSigned.attestationReport?.report && bundle.teekSigned.attestationReport.report.length > 0 && (bundle.teetSigned.attestationReport?.report && bundle.teetSigned.attestationReport.report.length > 0);
-  let teekKeyResult;
-  let teetKeyResult;
-  if (hasEmbeddedAttestations) {
-    logger.info("Using production mode: extracting keys from attestations");
-    if (!bundle.teekSigned?.attestationReport?.report) {
-      throw new Error("TEE_K embedded attestation report missing");
-    }
-    if (!bundle.teetSigned?.attestationReport?.report) {
-      throw new Error("TEE_T embedded attestation report missing");
-    }
-    const teekAttestationType = bundle.teekSigned.attestationReport.type || "nitro";
-    const teetAttestationType = bundle.teetSigned.attestationReport.type || "nitro";
-    logger.info(`TEE_K attestation type: ${teekAttestationType}`);
-    logger.info(`TEE_T attestation type: ${teetAttestationType}`);
-    const teekAttestationBytes = bundle.teekSigned.attestationReport.report;
-    const teetAttestationBytes = bundle.teetSigned.attestationReport.report;
-    if (teekAttestationType === "gcp") {
-      const gcpResult = await validateGcpAttestationAndExtractKey(teekAttestationBytes, logger);
-      if (!gcpResult.isValid) {
-        throw new Error(`TEE_K GCP attestation validation failed: ${gcpResult.errors.join(", ")}`);
-      }
-      if (!gcpResult.ethAddress) {
-        throw new Error("TEE_K GCP attestation validation failed: no address");
-      }
-      if (gcpResult.userDataType !== "tee_k") {
-        throw new Error(`TEE_K GCP attestation validation failed: wrong TEE type, expected tee_k, got ${gcpResult.userDataType}`);
-      }
-      teekKeyResult = {
-        teeType: gcpResult.userDataType,
-        ethAddress: "0x" + Buffer.from(gcpResult.ethAddress).toString("hex"),
-        pcr0: gcpResult.pcr0 || "gcp-no-digest"
-      };
-    } else {
-      const nitroResult = await validateNitroAttestationAndExtractKey(teekAttestationBytes);
-      if (!nitroResult.isValid) {
-        throw new Error(`TEE_K Nitro attestation validation failed: ${nitroResult.errors.join(", ")}`);
-      }
-      if (!nitroResult.ethAddress) {
-        throw new Error("TEE_K Nitro attestation validation failed: no address");
-      }
-      if (nitroResult.userDataType !== "tee_k") {
-        throw new Error(`TEE_K Nitro attestation validation failed: wrong TEE type, expected tee_k, got ${nitroResult.userDataType}`);
-      }
-      teekKeyResult = {
-        teeType: nitroResult.userDataType,
-        ethAddress: nitroResult.ethAddress,
-        pcr0: nitroResult.pcr0
-      };
-    }
-    if (teetAttestationType === "gcp") {
-      const gcpResult = await validateGcpAttestationAndExtractKey(teetAttestationBytes, logger);
-      if (!gcpResult.isValid) {
-        throw new Error(`TEE_T GCP attestation validation failed: ${gcpResult.errors.join(", ")}`);
-      }
-      if (!gcpResult.ethAddress) {
-        throw new Error("TEE_T GCP attestation validation failed: no address");
-      }
-      if (gcpResult.userDataType !== "tee_t") {
-        throw new Error(`TEE_T GCP attestation validation failed: wrong TEE type, expected tee_t, got ${gcpResult.userDataType}`);
-      }
-      teetKeyResult = {
-        teeType: gcpResult.userDataType,
-        ethAddress: "0x" + Buffer.from(gcpResult.ethAddress).toString("hex"),
-        pcr0: gcpResult.pcr0 || "gcp-no-digest"
-      };
-      if (!gcpResult.envVars?.EXPECTED_TEEK_PCR0) {
-        throw new Error("TEE_T GCP attestation missing required EXPECTED_TEEK_PCR0 environment variable");
-      }
-      const expectedPcr0 = gcpResult.envVars.EXPECTED_TEEK_PCR0;
-      const actualPcr0 = teekKeyResult.pcr0;
-      logger.info(`Cross-validating TEE_K PCR0: expected=${expectedPcr0}, actual=${actualPcr0}`);
-      if (expectedPcr0 !== actualPcr0) {
-        throw new Error(`TEE cross-validation failed: TEE_T expects TEE_K PCR0 "${expectedPcr0}" but got "${actualPcr0}"`);
-      }
-      logger.info("TEE cross-validation successful: TEE_K PCR0 matches TEE_T expectation");
-    } else {
-      const nitroResult = await validateNitroAttestationAndExtractKey(teetAttestationBytes);
-      if (!nitroResult.isValid) {
-        throw new Error(`TEE_T Nitro attestation validation failed: ${nitroResult.errors.join(", ")}`);
-      }
-      if (!nitroResult.ethAddress) {
-        throw new Error("TEE_T Nitro attestation validation failed: no address");
-      }
-      if (nitroResult.userDataType !== "tee_t") {
-        throw new Error(`TEE_T Nitro attestation validation failed: wrong TEE type, expected tee_t, got ${nitroResult.userDataType}`);
-      }
-      teetKeyResult = {
-        teeType: nitroResult.userDataType,
-        ethAddress: nitroResult.ethAddress,
-        pcr0: nitroResult.pcr0
-      };
-    }
-    logger.info("Attestations validated successfully");
-  } else {
-    const standaloneEnabled = process.env.TEE_STANDALONE === "true" || process.env.TEE_STANDALONE === "1";
-    if (!standaloneEnabled) {
-      throw new Error("Missing attestation reports and standalone mode is not enabled (set TEE_STANDALONE=true to enable)");
-    }
-    const hasEmbeddedKeys = bundle.teekSigned.ethAddress && bundle.teekSigned.ethAddress.length > 0 && (bundle.teetSigned.ethAddress && bundle.teetSigned.ethAddress.length > 0);
-    if (!hasEmbeddedKeys) {
-      throw new Error("Missing attestation and no embedded ETH addresses for standalone mode");
-    }
-    logger.warn("STANDALONE MODE ENABLED: Using embedded ETH addresses without attestation verification");
-    const teekAddress = Buffer.from(bundle.teekSigned.ethAddress).toString("utf8");
-    teekKeyResult = {
-      teeType: "tee_k",
-      ethAddress: teekAddress,
-      pcr0: "standalone-mode"
-      // No PCR0 in standalone mode
-    };
-    logger.info(`TEE_K standalone address: ${teekAddress}`);
-    const teetAddress = Buffer.from(bundle.teetSigned.ethAddress).toString("utf8");
-    teetKeyResult = {
-      teeType: "tee_t",
-      ethAddress: teetAddress,
-      pcr0: "standalone-mode"
-      // No PCR0 in standalone mode
+    // Check if we have attestations (production mode) or embedded keys (standalone mode)
+    // Attestations are now embedded in SignedMessage.attestationReport
+    const hasEmbeddedAttestations = (bundle.teekSigned.attestationReport?.report && bundle.teekSigned.attestationReport.report.length > 0) &&
+        (bundle.teetSigned.attestationReport?.report && bundle.teetSigned.attestationReport.report.length > 0);
+    let teekKeyResult;
+    let teetKeyResult;
+    if (hasEmbeddedAttestations) {
+        // Production mode: Extract from attestations (Nitro or GCP)
+        logger.info('Using production mode: extracting keys from attestations');
+        if (!bundle.teekSigned?.attestationReport?.report) {
+            throw new Error('TEE_K embedded attestation report missing');
+        }
+        if (!bundle.teetSigned?.attestationReport?.report) {
+            throw new Error('TEE_T embedded attestation report missing');
+        }
+        const teekAttestationType = bundle.teekSigned.attestationReport.type || 'nitro';
+        const teetAttestationType = bundle.teetSigned.attestationReport.type || 'nitro';
+        logger.info(`TEE_K attestation type: ${teekAttestationType}`);
+        logger.info(`TEE_T attestation type: ${teetAttestationType}`);
+        const teekAttestationBytes = bundle.teekSigned.attestationReport.report;
+        const teetAttestationBytes = bundle.teetSigned.attestationReport.report;
+        // Validate TEE_K attestation based on type
+        if (teekAttestationType === 'gcp') {
+            const gcpResult = await validateGcpAttestationAndExtractKey(teekAttestationBytes, logger);
+            if (!gcpResult.isValid) {
+                throw new Error(`TEE_K GCP attestation validation failed: ${gcpResult.errors.join(', ')}`);
+            }
+            if (!gcpResult.ethAddress) {
+                throw new Error('TEE_K GCP attestation validation failed: no address');
+            }
+            if (gcpResult.userDataType !== 'tee_k') {
+                throw new Error(`TEE_K GCP attestation validation failed: wrong TEE type, expected tee_k, got ${gcpResult.userDataType}`);
+            }
+            teekKeyResult = {
+                teeType: gcpResult.userDataType,
+                ethAddress: '0x' + Buffer.from(gcpResult.ethAddress).toString('hex'),
+                pcr0: gcpResult.pcr0 || 'gcp-no-digest'
+            };
+        }
+        else {
+            const nitroResult = await validateNitroAttestationAndExtractKey(teekAttestationBytes);
+            if (!nitroResult.isValid) {
+                throw new Error(`TEE_K Nitro attestation validation failed: ${nitroResult.errors.join(', ')}`);
+            }
+            if (!nitroResult.ethAddress) {
+                throw new Error('TEE_K Nitro attestation validation failed: no address');
+            }
+            if (nitroResult.userDataType !== 'tee_k') {
+                throw new Error(`TEE_K Nitro attestation validation failed: wrong TEE type, expected tee_k, got ${nitroResult.userDataType}`);
+            }
+            teekKeyResult = {
+                teeType: nitroResult.userDataType,
+                ethAddress: nitroResult.ethAddress,
+                pcr0: nitroResult.pcr0
+            };
+        }
+        // Validate TEE_T attestation based on type
+        if (teetAttestationType === 'gcp') {
+            const gcpResult = await validateGcpAttestationAndExtractKey(teetAttestationBytes, logger);
+            if (!gcpResult.isValid) {
+                throw new Error(`TEE_T GCP attestation validation failed: ${gcpResult.errors.join(', ')}`);
+            }
+            if (!gcpResult.ethAddress) {
+                throw new Error('TEE_T GCP attestation validation failed: no address');
+            }
+            if (gcpResult.userDataType !== 'tee_t') {
+                throw new Error(`TEE_T GCP attestation validation failed: wrong TEE type, expected tee_t, got ${gcpResult.userDataType}`);
+            }
+            teetKeyResult = {
+                teeType: gcpResult.userDataType,
+                ethAddress: '0x' + Buffer.from(gcpResult.ethAddress).toString('hex'),
+                pcr0: gcpResult.pcr0 || 'gcp-no-digest'
+            };
+            // Cross-validate: TEE_T must have EXPECTED_TEEK_PCR0 env var matching TEE_K's PCR0
+            if (!gcpResult.envVars?.EXPECTED_TEEK_PCR0) {
+                throw new Error('TEE_T GCP attestation missing required EXPECTED_TEEK_PCR0 environment variable');
+            }
+            const expectedPcr0 = gcpResult.envVars.EXPECTED_TEEK_PCR0;
+            const actualPcr0 = teekKeyResult.pcr0;
+            logger.info(`Cross-validating TEE_K PCR0: expected=${expectedPcr0}, actual=${actualPcr0}`);
+            if (expectedPcr0 !== actualPcr0) {
+                throw new Error(`TEE cross-validation failed: TEE_T expects TEE_K PCR0 "${expectedPcr0}" but got "${actualPcr0}"`);
+            }
+            logger.info('TEE cross-validation successful: TEE_K PCR0 matches TEE_T expectation');
+        }
+        else {
+            const nitroResult = await validateNitroAttestationAndExtractKey(teetAttestationBytes);
+            if (!nitroResult.isValid) {
+                throw new Error(`TEE_T Nitro attestation validation failed: ${nitroResult.errors.join(', ')}`);
+            }
+            if (!nitroResult.ethAddress) {
+                throw new Error('TEE_T Nitro attestation validation failed: no address');
+            }
+            if (nitroResult.userDataType !== 'tee_t') {
+                throw new Error(`TEE_T Nitro attestation validation failed: wrong TEE type, expected tee_t, got ${nitroResult.userDataType}`);
+            }
+            teetKeyResult = {
+                teeType: nitroResult.userDataType,
+                ethAddress: nitroResult.ethAddress,
+                pcr0: nitroResult.pcr0
+            };
+        }
+        logger.info('Attestations validated successfully');
+    }
+    else {
+        // Standalone/Development mode: Extract from embedded ETH addresses
+        // SECURITY: Only allow standalone mode when explicitly enabled via environment variable
+        const standaloneEnabled = process.env.TEE_STANDALONE === 'true' || process.env.TEE_STANDALONE === '1';
+        if (!standaloneEnabled) {
+            throw new Error('Missing attestation reports and standalone mode is not enabled (set TEE_STANDALONE=true to enable)');
+        }
+        const hasEmbeddedKeys = (bundle.teekSigned.ethAddress && bundle.teekSigned.ethAddress.length > 0) &&
+            (bundle.teetSigned.ethAddress && bundle.teetSigned.ethAddress.length > 0);
+        if (!hasEmbeddedKeys) {
+            throw new Error('Missing attestation and no embedded ETH addresses for standalone mode');
+        }
+        logger.warn('STANDALONE MODE ENABLED: Using embedded ETH addresses without attestation verification');
+        // Extract TEE_K address (stored as UTF-8 string like "0xe3c8d66...")
+        const teekAddress = Buffer.from(bundle.teekSigned.ethAddress).toString('utf8');
+        teekKeyResult = {
+            teeType: 'tee_k',
+            ethAddress: teekAddress,
+            pcr0: 'standalone-mode' // No PCR0 in standalone mode
+        };
+        logger.info(`TEE_K standalone address: ${teekAddress}`);
+        // Extract TEE_T address (stored as UTF-8 string like "0x3b8ad67...")
+        const teetAddress = Buffer.from(bundle.teetSigned.ethAddress).toString('utf8');
+        teetKeyResult = {
+            teeType: 'tee_t',
+            ethAddress: teetAddress,
+            pcr0: 'standalone-mode' // No PCR0 in standalone mode
+        };
+        logger.info(`TEE_T standalone address: ${teetAddress}`);
+        logger.info('Standalone mode key extraction successful');
+    }
+    return {
+        teekKeyResult,
+        teetKeyResult
     };
-    logger.info(`TEE_T standalone address: ${teetAddress}`);
-    logger.info("Standalone mode key extraction successful");
-  }
-  return {
-    teekKeyResult,
-    teetKeyResult
-  };
 }
+/**
+ * Verifies TEE signatures using extracted key results
+ */
 async function verifyTeeSignatures(bundle, teekKeyResult, teetKeyResult, logger) {
-  if (!bundle.teekSigned) {
-    throw new Error("TEE_K signed message is missing");
-  }
-  const teekResult = await verifyTeeSignature(
-    bundle.teekSigned,
-    teekKeyResult,
-    "TEE_K",
-    logger
-  );
-  if (!teekResult.isValid) {
-    throw new Error(`TEE_K signature verification failed: ${teekResult.errors.join(", ")}`);
-  }
-  if (!bundle.teetSigned) {
-    throw new Error("TEE_T signed message is missing");
-  }
-  const teetResult = await verifyTeeSignature(
-    bundle.teetSigned,
-    teetKeyResult,
-    "TEE_T",
-    logger
-  );
-  if (!teetResult.isValid) {
-    throw new Error(`TEE_T signature verification failed: ${teetResult.errors.join(", ")}`);
-  }
-  logger.info("TEE signatures verified successfully");
+    // Verify TEE_K signature
+    if (!bundle.teekSigned) {
+        throw new Error('TEE_K signed message is missing');
+    }
+    const teekResult = await verifyTeeSignature(bundle.teekSigned, teekKeyResult, 'TEE_K', logger);
+    if (!teekResult.isValid) {
+        throw new Error(`TEE_K signature verification failed: ${teekResult.errors.join(', ')}`);
+    }
+    // Verify TEE_T signature
+    if (!bundle.teetSigned) {
+        throw new Error('TEE_T signed message is missing');
+    }
+    const teetResult = await verifyTeeSignature(bundle.teetSigned, teetKeyResult, 'TEE_T', logger);
+    if (!teetResult.isValid) {
+        throw new Error(`TEE_T signature verification failed: ${teetResult.errors.join(', ')}`);
+    }
+    logger.info('TEE signatures verified successfully');
 }
+/**
+ * Verifies a single TEE signature using ETH address format
+ */
 async function verifyTeeSignature(signedMessage, extractedKey, teeType, logger) {
-  const errors = [];
-  if (!signedMessage) {
-    return {
-      isValid: false,
-      errors: ["Signed message is null or undefined"]
-    };
-  }
-  try {
-    let ethAddress;
-    if (extractedKey.ethAddress) {
-      ethAddress = extractedKey.ethAddress;
-      logger.debug(`${teeType} using ETH address from attestation: ${ethAddress}`);
-    } else {
-      return {
-        isValid: false,
-        errors: ["eth address is null"]
-      };
-    }
-    const { verify: verifySig } = SIGNATURES[ServiceSignatureType.SERVICE_SIGNATURE_TYPE_ETH];
-    const isValid = await verifySig(
-      signedMessage.body,
-      signedMessage.signature,
-      ethAddress
-    );
-    if (!isValid) {
-      errors.push(`${teeType} signature verification failed for address ${ethAddress}`);
-    }
-    logger.debug(`${teeType} signature verification result: ${isValid} for address ${ethAddress}`);
-    return {
-      isValid: errors.length === 0,
-      errors,
-      address: extractedKey.ethAddress
-    };
-  } catch (error) {
-    errors.push(`${teeType} signature verification error: ${error.message}`);
-    return {
-      isValid: false,
-      errors
-    };
-  }
+    const errors = [];
+    if (!signedMessage) {
+        return {
+            isValid: false,
+            errors: ['Signed message is null or undefined']
+        };
+    }
+    try {
+        let ethAddress;
+        if (extractedKey.ethAddress) {
+            ethAddress = extractedKey.ethAddress;
+            logger.debug(`${teeType} using ETH address from attestation: ${ethAddress}`);
+        }
+        else {
+            return {
+                isValid: false,
+                errors: ['eth address is null'],
+            };
+        }
+        // Use the ETH signature verification from the existing system
+        const { verify: verifySig } = SIGNATURES[ServiceSignatureType.SERVICE_SIGNATURE_TYPE_ETH];
+        // Verify signature over the body bytes
+        const isValid = await verifySig(signedMessage.body, signedMessage.signature, ethAddress);
+        if (!isValid) {
+            errors.push(`${teeType} signature verification failed for address ${ethAddress}`);
+        }
+        logger.debug(`${teeType} signature verification result: ${isValid} for address ${ethAddress}`);
+        return {
+            isValid: errors.length === 0,
+            errors,
+            address: extractedKey.ethAddress
+        };
+    }
+    catch (error) {
+        errors.push(`${teeType} signature verification error: ${error.message}`);
+        return {
+            isValid: false,
+            errors
+        };
+    }
 }
+/**
+ * Parses TEE_K output payload
+ */
 function parseKOutputPayload(signedMessage) {
-  const payload = KOutputPayload.decode(signedMessage.body);
-  if (!payload.redactedRequest) {
-    throw new Error("Missing redacted request in TEE_K payload");
-  }
-  if (!payload.consolidatedResponseKeystream || payload.consolidatedResponseKeystream.length === 0) {
-    throw new Error("Missing consolidated response keystream in TEE_K payload");
-  }
-  if (!payload.certificateInfo) {
-    throw new Error("Missing certificate info in TEE_K payload");
-  }
-  return payload;
+    // Use actual protobuf decoding
+    const payload = KOutputPayload.decode(signedMessage.body);
+    // Validate required fields
+    if (!payload.redactedRequest) {
+        throw new Error('Missing redacted request in TEE_K payload');
+    }
+    if (!payload.consolidatedResponseKeystream || payload.consolidatedResponseKeystream.length === 0) {
+        throw new Error('Missing consolidated response keystream in TEE_K payload');
+    }
+    if (!payload.certificateInfo) {
+        throw new Error('Missing certificate info in TEE_K payload');
+    }
+    return payload;
 }
+/**
+ * Parses TEE_T output payload
+ */
 function parseTOutputPayload(signedMessage) {
-  const payload = TOutputPayload.decode(signedMessage.body);
-  if (!payload.consolidatedResponseCiphertext || payload.consolidatedResponseCiphertext.length === 0) {
-    throw new Error("Missing consolidated response ciphertext in TEE_T payload");
-  }
-  return payload;
+    // Use actual protobuf decoding
+    const payload = TOutputPayload.decode(signedMessage.body);
+    // Validate required fields
+    if (!payload.consolidatedResponseCiphertext || payload.consolidatedResponseCiphertext.length === 0) {
+        throw new Error('Missing consolidated response ciphertext in TEE_T payload');
+    }
+    return payload;
 }
+/**
+ * Validates that both K and T timestamps are within acceptable range
+ * @param kPayload - K output payload with timestamp
+ * @param tPayload - T output payload with timestamp
+ * @param logger - Logger instance
+ */
 function validateTimestamps(kPayload, tPayload, logger) {
-  const now = Date.now();
-  const kTimestamp = kPayload.timestampMs;
-  const tTimestamp = tPayload.timestampMs;
-  const kTimestampS = Math.floor(kTimestamp / 1e3);
-  const tTimestampS = Math.floor(tTimestamp / 1e3);
-  const nowS = Math.floor(now / 1e3);
-  logger.info("Validating TEE timestamps", {
-    kTimestampMs: kTimestamp,
-    tTimestampMs: tTimestamp,
-    kTimestampS,
-    tTimestampS,
-    nowS
-  });
-  const maxAgeMs = 10 * 60 * 1e3;
-  const oldestAllowed = now - maxAgeMs;
-  if (kTimestamp < oldestAllowed) {
-    throw new Error(`TEE_K timestamp ${kTimestamp} is too old. Must be within 10 minutes of current time ${now}`);
-  }
-  if (tTimestamp < oldestAllowed) {
-    throw new Error(`TEE_T timestamp ${tTimestamp} is too old. Must be within 10 minutes of current time ${now}`);
-  }
-  const maxFutureMs = 60 * 1e3;
-  const maxAllowed = now + maxFutureMs;
-  if (kTimestamp > maxAllowed) {
-    throw new Error(`TEE_K timestamp ${kTimestamp} is in the future. Current time is ${now}`);
-  }
-  if (tTimestamp > maxAllowed) {
-    throw new Error(`TEE_T timestamp ${tTimestamp} is in the future. Current time is ${now}`);
-  }
-  const timestampDiffMs = Math.abs(kTimestamp - tTimestamp);
-  const maxDiffMs = 60 * 1e3;
-  if (timestampDiffMs > maxDiffMs) {
-    throw new Error(`TEE timestamps differ by ${timestampDiffMs}ms, which exceeds maximum allowed difference of ${maxDiffMs}ms (1 minute)`);
-  }
-  logger.info("TEE timestamp validation successful", {
-    timestampDiffMs,
-    ageKMs: now - kTimestamp,
-    ageTMs: now - tTimestamp
-  });
+    const now = Date.now(); // Current time in milliseconds
+    const kTimestamp = kPayload.timestampMs;
+    const tTimestamp = tPayload.timestampMs;
+    // Convert to seconds for logging consistency with existing code
+    const kTimestampS = Math.floor(kTimestamp / 1000);
+    const tTimestampS = Math.floor(tTimestamp / 1000);
+    const nowS = Math.floor(now / 1000);
+    logger.info('Validating TEE timestamps', {
+        kTimestampMs: kTimestamp,
+        tTimestampMs: tTimestamp,
+        kTimestampS,
+        tTimestampS,
+        nowS
+    });
+    // 1. Check that both timestamps are not earlier than 10 minutes in the past
+    const maxAgeMs = 10 * 60 * 1000; // 10 minutes in milliseconds
+    const oldestAllowed = now - maxAgeMs;
+    if (kTimestamp < oldestAllowed) {
+        throw new Error(`TEE_K timestamp ${kTimestamp} is too old. Must be within 10 minutes of current time ${now}`);
+    }
+    if (tTimestamp < oldestAllowed) {
+        throw new Error(`TEE_T timestamp ${tTimestamp} is too old. Must be within 10 minutes of current time ${now}`);
+    }
+    // 1b. Check that timestamps are not in the future (with small tolerance for clock skew)
+    const maxFutureMs = 60 * 1000; // 1 minute tolerance for clock skew
+    const maxAllowed = now + maxFutureMs;
+    if (kTimestamp > maxAllowed) {
+        throw new Error(`TEE_K timestamp ${kTimestamp} is in the future. Current time is ${now}`);
+    }
+    if (tTimestamp > maxAllowed) {
+        throw new Error(`TEE_T timestamp ${tTimestamp} is in the future. Current time is ${now}`);
+    }
+    // 2. Check that both timestamps are within 1 minute of each other
+    const timestampDiffMs = Math.abs(kTimestamp - tTimestamp);
+    const maxDiffMs = 60 * 1000; // 1 minute
+    if (timestampDiffMs > maxDiffMs) {
+        throw new Error(`TEE timestamps differ by ${timestampDiffMs}ms, which exceeds maximum allowed difference of ${maxDiffMs}ms (1 minute)`);
+    }
+    logger.info('TEE timestamp validation successful', {
+        timestampDiffMs,
+        ageKMs: now - kTimestamp,
+        ageTMs: now - tTimestamp
+    });
 }
+/**
+ * Validates that both K and T payloads have matching session IDs
+ * SECURITY: Prevents cross-session component substitution attacks
+ * @param kPayload - K output payload with session_id
+ * @param tPayload - T output payload with session_id
+ * @param logger - Logger instance
+ * @returns The validated session ID
+ */
 function validateSessionIds(kPayload, tPayload, logger) {
-  const kSessionId = kPayload.sessionId;
-  const tSessionId = tPayload.sessionId;
-  logger.info("Validating TEE session IDs", {
-    kSessionId,
-    tSessionId
-  });
-  if (!kSessionId || kSessionId.length === 0) {
-    throw new AttestorError(
-      "ERROR_INVALID_CLAIM",
-      "Missing session_id in TEE_K payload - required for cross-TEE binding"
-    );
-  }
-  if (!tSessionId || tSessionId.length === 0) {
-    throw new AttestorError(
-      "ERROR_INVALID_CLAIM",
-      "Missing session_id in TEE_T payload - required for cross-TEE binding"
-    );
-  }
-  if (kSessionId !== tSessionId) {
-    throw new AttestorError(
-      "ERROR_INVALID_CLAIM",
-      `Session ID mismatch: TEE_K session_id "${kSessionId}" does not match TEE_T session_id "${tSessionId}".`
-    );
-  }
-  logger.info("TEE session ID validation successful", {
-    sessionId: kSessionId
-  });
-  return kSessionId;
+    const kSessionId = kPayload.sessionId;
+    const tSessionId = tPayload.sessionId;
+    logger.info('Validating TEE session IDs', {
+        kSessionId,
+        tSessionId
+    });
+    // Both session IDs must be present
+    if (!kSessionId || kSessionId.length === 0) {
+        throw new AttestorError('ERROR_INVALID_CLAIM', 'Missing session_id in TEE_K payload - required for cross-TEE binding');
+    }
+    if (!tSessionId || tSessionId.length === 0) {
+        throw new AttestorError('ERROR_INVALID_CLAIM', 'Missing session_id in TEE_T payload - required for cross-TEE binding');
+    }
+    // Session IDs must match
+    if (kSessionId !== tSessionId) {
+        throw new AttestorError('ERROR_INVALID_CLAIM', `Session ID mismatch: TEE_K session_id "${kSessionId}" does not match TEE_T session_id "${tSessionId}".`);
+    }
+    logger.info('TEE session ID validation successful', {
+        sessionId: kSessionId
+    });
+    return kSessionId;
 }
-export {
-  verifyTeeBundle
-};