@invisible-labs/sdk 0.6.0-devnet.4 → 0.6.0-devnet.5

package/dist/chunk-DIA6U2CV.js

@@ -1,1927 +0,0 @@
-import { AttestationError } from './chunk-GHBQF3A7.js';
-import * as x509 from '@peculiar/x509';
-
-var DEFAULT_AZURE_JWKS_TIMEOUT_MS = 3e4;
-var TPM_GENERATED_VALUE = 4283712327;
-var TPM_ST_ATTEST_QUOTE = 32792;
-function assertAttestResponse(value) {
-  if (typeof value !== "object" || value === null) {
-    throw err("QUOTE_DECODE", "attestation response is not a JSON object");
-  }
-  const v = value;
-  const fields = ["quote", "nonce", "pubkey", "binary_hash", "mode"];
-  for (const field of fields) {
-    if (typeof v[field] !== "string") {
-      throw err(
-        "QUOTE_DECODE",
-        `attestation response missing or non-string field: "${field}" (got ${typeof v[field]})`
-      );
-    }
-  }
-  if (v["mode"] !== "dev" && v["mode"] !== "prod") {
-    throw err("QUOTE_DECODE", `attestation response has unknown mode: "${v["mode"]}"`);
-  }
-  if (v["runtime_profile"] !== void 0 && v["runtime_profile"] !== "prod-hardened" && v["runtime_profile"] !== "prod-devnet-simplified") {
-    throw err(
-      "QUOTE_DECODE",
-      `attestation response has unknown runtime profile: "${v["runtime_profile"]}"`
-    );
-  }
-  if (v["local_attestation"] !== void 0 && typeof v["local_attestation"] !== "boolean") {
-    throw err(
-      "QUOTE_DECODE",
-      `attestation response has non-boolean local_attestation: ${typeof v["local_attestation"]}`
-    );
-  }
-}
-var INTEL_SGX_ROOT_CA_FINGERPRINT_SHA256 = "44a0196b2b99f889b8e149e95b807a350e7424964399e885a7cbb8ccfab674d3";
-var REASON_TO_CODE = {
-  // Structural / chain / quote-signature failures -> the cert-chain bucket.
-  QUOTE_DECODE: "CERT_CHAIN_INVALID",
-  QUOTE_STRUCTURE: "CERT_CHAIN_INVALID",
-  UNSUPPORTED_PLATFORM: "CERT_CHAIN_INVALID",
-  PCK_CHAIN_MISSING: "CERT_CHAIN_INVALID",
-  PCK_CHAIN_PARSE: "CERT_CHAIN_INVALID",
-  ROOT_FINGERPRINT_MISMATCH: "CERT_CHAIN_INVALID",
-  PCK_CHAIN_SIGNATURE: "CERT_CHAIN_INVALID",
-  DCAP_COLLATERAL_SIGNATURE: "CERT_CHAIN_INVALID",
-  DCAP_COLLATERAL_MISSING: "TCB_REJECTED",
-  DCAP_COLLATERAL_PARSE: "TCB_REJECTED",
-  DCAP_COLLATERAL_REVOKED: "TCB_REJECTED",
-  TCB_STATUS_REJECTED: "TCB_REJECTED",
-  QE_IDENTITY_REJECTED: "TCB_REJECTED",
-  QUOTE_SIGNATURE: "CERT_CHAIN_INVALID",
-  QE_REPORT_BINDING: "CERT_CHAIN_INVALID",
-  QE_REPORT_SIGNATURE: "CERT_CHAIN_INVALID",
-  // Freshness.
-  NONCE_MISMATCH: "FRESHNESS_NONCE_MISMATCH",
-  NONCE_FIELD_MISMATCH: "FRESHNESS_NONCE_MISMATCH",
-  TPM_NONCE_MISMATCH: "AZURE_TPM_QUALIFYING_DATA_MISMATCH",
-  // Noise channel binding (pubkey / report-data binding / bound JSON fields).
-  CHANNEL_BINDING_MISMATCH: "NOISE_BINDING_MISMATCH",
-  PUBKEY_FIELD_MISMATCH: "NOISE_BINDING_MISMATCH",
-  BINARY_HASH_FORMAT: "NOISE_BINDING_MISMATCH",
-  BINARY_HASH_MISMATCH: "NOISE_BINDING_MISMATCH",
-  // Debug bit.
-  DEBUG_BIT_SET: "DEBUG_BIT_SET",
-  MAA_DEBUG_BIT_SET: "DEBUG_BIT_SET",
-  // Mode / measurement pinning.
-  MODE_MISMATCH: "MRTD_MISMATCH",
-  MRTD_MISMATCH: "MRTD_MISMATCH",
-  RUNTIME_PROFILE_MISMATCH: "RUNTIME_PROFILE_MISMATCH",
-  // Local fallback disabled -> not attested.
-  LOCAL_ATTESTATION_DISABLED: "NOT_ATTESTED",
-  // Azure MAA token issuer / JWKS / policy / signature / compliance / binding.
-  MAA_TOKEN_MISSING: "AZURE_MAA_JWKS_INVALID",
-  MAA_TOKEN_PARSE: "AZURE_MAA_JWKS_INVALID",
-  MAA_TOKEN_EXPIRED: "AZURE_MAA_JWKS_INVALID",
-  MAA_TOKEN_SIGNATURE: "AZURE_MAA_JWKS_INVALID",
-  MAA_TRUST_POLICY_MISSING: "AZURE_MAA_ISSUER_MISMATCH",
-  MAA_ISSUER_MISMATCH: "AZURE_MAA_ISSUER_MISMATCH",
-  MAA_JWKS_MISMATCH: "AZURE_MAA_JWKS_INVALID",
-  MAA_POLICY_HASH_MISMATCH: "AZURE_MAA_POLICY_HASH_MISMATCH",
-  MAA_COMPLIANCE_MISMATCH: "AZURE_MAA_NOT_COMPLIANT",
-  MAA_REPORTDATA_MISMATCH: "AZURE_MAA_DCAP_MISMATCH",
-  // Azure HCL key blob hash binding.
-  HCL_KEYS_MISSING: "AZURE_HCL_KEYS_MISMATCH",
-  HCL_KEYS_HASH_MISMATCH: "AZURE_HCL_KEYS_MISMATCH",
-  HCL_KEYS_PARSE: "AZURE_AK_PUB_INVALID",
-  // Azure TPM AK quote.
-  TPM_QUOTE_MISSING: "AZURE_TPM_AK_QUOTE_INVALID",
-  TPM_QUOTE_SIGNATURE: "AZURE_TPM_AK_QUOTE_INVALID"
-};
-function err(reason, message) {
-  return new AttestationError(REASON_TO_CODE[reason], `[${reason}] ${message}`);
-}
-var MEASUREMENT_LEN = 48;
-var HEADER_SIZE = 48;
-var HEADER_VERSION_OFF = 0;
-var HEADER_ATT_KEY_OFF = 2;
-var HEADER_TEE_TYPE_OFF = 4;
-var TDX_TEE_TYPE = 129;
-var ECDSA_P256_KEY_TYPE = 2;
-var BODY_OFFSET = 48;
-var BODY_SIZE = 584;
-var BODY_TEE_TCB_SVN_OFF = 0;
-var BODY_MRSIGNERSEAM_OFF = 64;
-var BODY_SEAM_ATTRIBUTES_OFF = 112;
-var BODY_TD_ATTR_OFF = 120;
-var BODY_MRTD_OFF = 136;
-var BODY_RTMR0_OFF = 328;
-var BODY_RTMR1_OFF = 376;
-var BODY_RTMR2_OFF = 424;
-var BODY_RTMR3_OFF = 472;
-var BODY_REPORT_DATA_OFF = 520;
-var BODY_REPORT_DATA_LEN = 64;
-var SIG_DATA_LEN_OFFSET = BODY_OFFSET + BODY_SIZE;
-var SIG_QUOTE_SIG_OFF = 0;
-var SIG_ATT_KEY_OFF = 64;
-var SIG_QE_CERT_DATA_OFF = 128;
-var SIG_QE_CERT_DATA_HEADER_SIZE = 6;
-var SIG_QE_REPORT_SIZE = 384;
-var SIG_QE_REPORT_SIG_SIZE = 64;
-var SGX_REPORT_MISCSELECT_OFF = 16;
-var SGX_REPORT_ATTRIBUTES_OFF = 48;
-var SGX_REPORT_MRSIGNER_OFF = 128;
-var SGX_REPORT_ISV_PROD_ID_OFF = 256;
-var SGX_REPORT_ISV_SVN_OFF = 258;
-var SGX_REPORT_DATA_OFF = 320;
-var QE_CERT_TYPE_PCK_CHAIN = 5;
-var QE_CERT_TYPE_QE_REPORT_CERT_DATA = 6;
-var INTEL_PCK_SGX_EXTENSIONS_OID = "1.2.840.113741.1.13.1";
-var INTEL_PCK_EXTENSION_TCB_OID = "1.2.840.113741.1.13.1.2";
-var INTEL_PCK_EXTENSION_PCE_ID_OID = "1.2.840.113741.1.13.1.3";
-var INTEL_PCK_EXTENSION_FMSPC_OID = "1.2.840.113741.1.13.1.4";
-var INTEL_PCK_EXTENSION_PCESVN_OID = "1.2.840.113741.1.13.1.2.17";
-var INTEL_PCK_EXTENSION_CPUSVN_OID = "1.2.840.113741.1.13.1.2.18";
-var INTEL_PCK_EXTENSION_SGX_TCB_COMPONENT_OID_PREFIX = "1.2.840.113741.1.13.1.2.";
-var INTEL_TCB_SIGNING_SUBJECT = "CN=Intel SGX TCB Signing, O=Intel Corporation, L=Santa Clara, ST=CA, C=US";
-var TEST_TCB_SIGNING_SUBJECT = "CN=Test SGX and TDX TCB Signing";
-var ACCEPTED_TCB_STATUSES = /* @__PURE__ */ new Set(["UpToDate"]);
-var ACCEPTED_TDX_MODULE_STATUSES = /* @__PURE__ */ new Set(["UpToDate"]);
-var ACCEPTED_QE_IDENTITY_STATUSES = /* @__PURE__ */ new Set(["UpToDate"]);
-async function verifyAttestation(params) {
-  const { response, expectedNonce, expectedNoiseStaticPub, policy, timeoutMs } = params;
-  if (policy.expectedRuntimeProfile !== void 0 && response.runtime_profile !== policy.expectedRuntimeProfile) {
-    throw err(
-      "RUNTIME_PROFILE_MISMATCH",
-      `runtime profile ${String(response.runtime_profile)} does not match the approved release profile ${policy.expectedRuntimeProfile}`
-    );
-  }
-  if (response.local_attestation === true) {
-    return verifyLocalAttestation({
-      response,
-      expectedNonce,
-      expectedNoiseStaticPub,
-      policy
-    });
-  }
-  const raw = decodeQuoteB64(response.quote);
-  ensureStructure(raw);
-  if (response.platform === "azure-tdx-dcap") {
-    return verifyAzureTdxAttestation({
-      raw,
-      response,
-      expectedNonce,
-      expectedNoiseStaticPub,
-      policy,
-      timeoutMs
-    });
-  }
-  if (response.platform && response.platform !== "tdx-dcap") {
-    throw err(
-      "UNSUPPORTED_PLATFORM",
-      `attestation not supported for platform "${response.platform}"`
-    );
-  }
-  return verifyGcpTdxAttestation({
-    raw,
-    response,
-    expectedNonce,
-    expectedNoiseStaticPub,
-    policy
-  });
-}
-async function verifyGcpTdxAttestation(params) {
-  const { raw, response, expectedNonce, expectedNoiseStaticPub, policy } = params;
-  const body = raw.subarray(BODY_OFFSET, BODY_OFFSET + BODY_SIZE);
-  const reportData = body.subarray(
-    BODY_REPORT_DATA_OFF,
-    BODY_REPORT_DATA_OFF + BODY_REPORT_DATA_LEN
-  );
-  if (!constantTimeEq(reportData.subarray(0, 32), expectedNonce)) {
-    throw err(
-      "NONCE_MISMATCH",
-      "REPORT_DATA[0:32] does not match verifier nonce - possible replay"
-    );
-  }
-  if (response.nonce.toLowerCase() !== bytesToHex(expectedNonce)) {
-    throw err("NONCE_FIELD_MISMATCH", `JSON nonce ${response.nonce} does not match verifier nonce`);
-  }
-  if (!constantTimeEq(reportData.subarray(32, 64), expectedNoiseStaticPub)) {
-    throw err(
-      "CHANNEL_BINDING_MISMATCH",
-      "REPORT_DATA[32:64] does not match Noise static pubkey from handshake"
-    );
-  }
-  const expectedPubHex = bytesToHex(expectedNoiseStaticPub);
-  if (response.pubkey.toLowerCase() !== expectedPubHex) {
-    throw err(
-      "PUBKEY_FIELD_MISMATCH",
-      "attestation pubkey field does not match Noise static pubkey from handshake"
-    );
-  }
-  if (!/^[0-9a-f]{64}$/i.test(response.binary_hash)) {
-    throw err("BINARY_HASH_FORMAT", "binary_hash field is not a 32-byte hex digest");
-  }
-  if (policy.expectedBinaryHash !== void 0 && response.binary_hash.toLowerCase() !== policy.expectedBinaryHash.toLowerCase()) {
-    throw err(
-      "BINARY_HASH_MISMATCH",
-      `binary hash ${response.binary_hash.toLowerCase()} does not match the approved release pin`
-    );
-  }
-  await verifyDcapQuoteAndCollateral({ raw, body, response, policy });
-  assertDebugBitClear(body);
-  const measurements = parseMeasurements(body);
-  if (policy.requiredMode !== void 0 && response.mode !== policy.requiredMode) {
-    throw err(
-      "MODE_MISMATCH",
-      `attestation mode ${response.mode} does not match required ${policy.requiredMode}`
-    );
-  }
-  if (response.mode === "prod") {
-    if ((policy.expectedMrtd === void 0 || policy.expectedMrtd === null) && policy.allowUnpinnedProdMrtdForRelease !== true) {
-      throw err(
-        "MRTD_MISMATCH",
-        "production attestation requires a pinned MRTD but none was configured"
-      );
-    }
-    if (policy.expectedMrtd !== void 0 && policy.expectedMrtd !== null && measurements.mrtd !== policy.expectedMrtd.toLowerCase()) {
-      throw err(
-        "MRTD_MISMATCH",
-        `MRTD ${measurements.mrtd} does not match pinned ${policy.expectedMrtd.toLowerCase()}`
-      );
-    }
-  }
-  return {
-    mode: response.mode,
-    binaryHash: response.binary_hash,
-    runtimeProfile: response.runtime_profile,
-    mrtd: measurements.mrtd,
-    rtmr0: measurements.rtmr0,
-    rtmr1: measurements.rtmr1,
-    rtmr2: measurements.rtmr2,
-    rtmr3: measurements.rtmr3,
-    pubkeyHex: response.pubkey.toLowerCase(),
-    localAttestation: false
-  };
-}
-async function verifyDcapQuoteAndCollateral(params) {
-  const { raw, body, response, policy } = params;
-  const sigData = readSigData(raw);
-  const qeCertData = parseQeCertificationData(sigData);
-  const pckChain = extractPckChain(qeCertData.qeCertificationData);
-  const expectedRootFp = policy.intelRootFingerprint?.toLowerCase() ?? INTEL_SGX_ROOT_CA_FINGERPRINT_SHA256;
-  const rootFp = await sha256Hex(new Uint8Array(pckChain[pckChain.length - 1].rawData));
-  if (rootFp !== expectedRootFp) {
-    throw err(
-      "ROOT_FINGERPRINT_MISMATCH",
-      `PCK root fingerprint ${rootFp} does not match pinned ${expectedRootFp}`
-    );
-  }
-  await verifyChainSignatures(pckChain);
-  const quoteSig = sigData.subarray(SIG_QUOTE_SIG_OFF, SIG_QUOTE_SIG_OFF + 64);
-  const attKey = sigData.subarray(SIG_ATT_KEY_OFF, SIG_ATT_KEY_OFF + 64);
-  const headerAndBody = raw.subarray(0, BODY_OFFSET + BODY_SIZE);
-  await verifyP256Signature(
-    rawXyToSpki(attKey),
-    quoteSig,
-    headerAndBody,
-    "QUOTE_SIGNATURE",
-    "quote header||body signature"
-  );
-  const { qeReport, qeReportSig, qeAuthData } = qeCertData;
-  const expectedBinding = await sha256(concat(attKey, qeAuthData));
-  const qeReportData = qeReport.subarray(SGX_REPORT_DATA_OFF, SGX_REPORT_DATA_OFF + 32);
-  if (!constantTimeEq(qeReportData, expectedBinding)) {
-    throw err(
-      "QE_REPORT_BINDING",
-      "QE report does not bind the in-quote attestation key (REPORT_DATA mismatch)"
-    );
-  }
-  const pckLeafSpki = await leafSpki(pckChain[0]);
-  await verifyP256Signature(
-    pckLeafSpki,
-    qeReportSig,
-    qeReport,
-    "QE_REPORT_SIGNATURE",
-    "QE report signature"
-  );
-  await verifyDcapCollateral({
-    collateral: response.dcap_collateral,
-    pckChain,
-    body,
-    qeReport,
-    mode: response.mode,
-    policy
-  });
-}
-async function verifyDcapCollateral(params) {
-  const { collateral, pckChain, body, qeReport, mode, policy } = params;
-  if (!collateral) {
-    if (policy.allowMissingDcapCollateral === true && mode === "dev" && policy.requiredMode === "dev") {
-      return;
-    }
-    throw err("DCAP_COLLATERAL_MISSING", "TDX quote is missing Intel DCAP collateral");
-  }
-  const now = /* @__PURE__ */ new Date();
-  const rootCert = pckChain[pckChain.length - 1];
-  const rootCrl = parseCrl(collateral.rootCaCrlPem, "root_ca_crl");
-  await verifyCrl(rootCrl, rootCert, "root_ca_crl", now);
-  const pckCrlIssuerChain = await verifyCollateralIssuerChain(
-    parsePemCertificateChain(collateral.pckCrlIssuerChainPem, "pck_crl_issuer_chain", 2),
-    policy,
-    "pck_crl_issuer_chain"
-  );
-  await assertNotRevokedByRoot(rootCrl, pckCrlIssuerChain[0], "PCK CRL issuer");
-  await assertSameCertificate(pckCrlIssuerChain[0], pckChain[1], "PCK CRL issuer");
-  const pckCrl = parseCrl(collateral.pckCrlPem, "pck_crl");
-  await verifyCrl(pckCrl, pckCrlIssuerChain[0], "pck_crl", now);
-  if (pckCrl.findRevoked(pckChain[0])) {
-    throw err("DCAP_COLLATERAL_REVOKED", "PCK leaf certificate is revoked by PCK CRL");
-  }
-  const tcbInfo = await verifySignedDcapJson({
-    signed: collateral.tcbInfo,
-    wrapperField: "tcbInfo",
-    policy,
-    rootCrl,
-    label: "tcb_info"
-  });
-  const qeIdentity = await verifySignedDcapJson({
-    signed: collateral.qeIdentity,
-    wrapperField: "enclaveIdentity",
-    policy,
-    rootCrl,
-    label: "qe_identity"
-  });
-  assertMatchingTcbEvaluationDataNumber(tcbInfo, qeIdentity);
-  verifyTcbInfo(tcbInfo, pckChain[0], body, now);
-  verifyQeIdentity(qeIdentity, qeReport, now);
-}
-function assertDebugBitClear(body) {
-  if ((body[BODY_TD_ATTR_OFF] & 1) !== 0) {
-    throw err("DEBUG_BIT_SET", "TD_ATTRIBUTES DEBUG bit set - refusing to attest a debuggable TD");
-  }
-}
-async function verifySignedDcapJson(params) {
-  const { signed, wrapperField, policy, rootCrl, label } = params;
-  if (!signed || typeof signed.body !== "string" || typeof signed.signature !== "string" || typeof signed.issuerChainPem !== "string") {
-    throw err("DCAP_COLLATERAL_MISSING", `${label} collateral is incomplete`);
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(signed.body);
-  } catch (e) {
-    throw err("DCAP_COLLATERAL_PARSE", `${label} body is not valid JSON: ${e}`);
-  }
-  const signedBody = exactSignedDcapJsonBody(signed.body, parsed, wrapperField, label);
-  const body = signedBody.parsed;
-  if (!body || typeof body !== "object" || Array.isArray(body)) {
-    throw err("DCAP_COLLATERAL_PARSE", `${label} body is not a JSON object`);
-  }
-  const issuerChain = await verifyCollateralIssuerChain(
-    parsePemCertificateChain(signed.issuerChainPem, `${label}_issuer_chain`, 2),
-    policy,
-    `${label}_issuer_chain`
-  );
-  await assertNotRevokedByRoot(rootCrl, issuerChain[0], `${label} signing certificate`);
-  assertDcapJsonSignerIdentity(issuerChain[0], issuerChain[issuerChain.length - 1], policy, label);
-  if (!/^[0-9a-f]{128}$/i.test(signed.signature)) {
-    throw err("DCAP_COLLATERAL_PARSE", `${label} signature is not a 64-byte hex ECDSA signature`);
-  }
-  await verifyP256Signature(
-    await leafSpki(issuerChain[0]),
-    hexToBytes(signed.signature),
-    new TextEncoder().encode(signedBody.body),
-    "DCAP_COLLATERAL_SIGNATURE",
-    `${label} signature`
-  );
-  return body;
-}
-function exactSignedDcapJsonBody(raw, parsed, wrapperField, label) {
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    return { body: raw, parsed };
-  }
-  if (!(wrapperField in parsed)) {
-    return { body: raw, parsed };
-  }
-  const body = extractTopLevelJsonProperty(raw, wrapperField);
-  if (body === null) {
-    throw err(
-      "DCAP_COLLATERAL_PARSE",
-      `${label} PCS wrapper contains ${wrapperField} but exact signed body bytes could not be extracted`
-    );
-  }
-  try {
-    return { body, parsed: JSON.parse(body) };
-  } catch (e) {
-    throw err("DCAP_COLLATERAL_PARSE", `${label} exact signed body is not valid JSON: ${e}`);
-  }
-}
-function extractTopLevelJsonProperty(raw, property) {
-  let offset = skipJsonWhitespace(raw, 0);
-  if (raw[offset] !== "{") return null;
-  offset++;
-  while (offset < raw.length) {
-    offset = skipJsonWhitespace(raw, offset);
-    if (raw[offset] === "}") return null;
-    if (raw[offset] === ",") {
-      offset++;
-      continue;
-    }
-    const key = readJsonString(raw, offset);
-    if (key === null) return null;
-    offset = skipJsonWhitespace(raw, key.end);
-    if (raw[offset] !== ":") return null;
-    offset = skipJsonWhitespace(raw, offset + 1);
-    const valueStart = offset;
-    const valueEnd = findJsonValueEnd(raw, valueStart);
-    if (valueEnd === null) return null;
-    if (key.value === property) return raw.slice(valueStart, valueEnd);
-    offset = valueEnd;
-  }
-  return null;
-}
-function skipJsonWhitespace(raw, offset) {
-  while (offset < raw.length && /[\t\n\r ]/u.test(raw[offset])) offset++;
-  return offset;
-}
-function readJsonString(raw, offset) {
-  if (raw[offset] !== '"') return null;
-  let cursor = offset + 1;
-  let escaped = false;
-  while (cursor < raw.length) {
-    const char = raw[cursor];
-    if (escaped) {
-      escaped = false;
-    } else if (char === "\\") {
-      escaped = true;
-    } else if (char === '"') {
-      const token = raw.slice(offset, cursor + 1);
-      try {
-        return { value: JSON.parse(token), end: cursor + 1 };
-      } catch {
-        return null;
-      }
-    }
-    cursor++;
-  }
-  return null;
-}
-function findJsonValueEnd(raw, offset) {
-  if (offset >= raw.length) return null;
-  if (raw[offset] === '"') return readJsonString(raw, offset)?.end ?? null;
-  if (raw[offset] === "{" || raw[offset] === "[") {
-    const stack = [raw[offset]];
-    let cursor2 = offset + 1;
-    while (cursor2 < raw.length) {
-      const char = raw[cursor2];
-      if (char === '"') {
-        const stringToken = readJsonString(raw, cursor2);
-        if (stringToken === null) return null;
-        cursor2 = stringToken.end;
-        continue;
-      }
-      if (char === "{" || char === "[") {
-        stack.push(char);
-      } else if (char === "}" || char === "]") {
-        const open = stack.pop();
-        if (char === "}" && open !== "{" || char === "]" && open !== "[") return null;
-        if (stack.length === 0) return cursor2 + 1;
-      }
-      cursor2++;
-    }
-    return null;
-  }
-  let cursor = offset;
-  while (cursor < raw.length && !/[\t\n\r ,}\]]/u.test(raw[cursor])) cursor++;
-  return cursor > offset ? cursor : null;
-}
-function assertMatchingTcbEvaluationDataNumber(tcbInfo, qeIdentity) {
-  const tcbNumber = tcbInfo.tcbEvaluationDataNumber;
-  const qeNumber = qeIdentity.tcbEvaluationDataNumber;
-  if (!isTcbEvaluationDataNumber(tcbNumber) || !isTcbEvaluationDataNumber(qeNumber)) {
-    throw err(
-      "TCB_STATUS_REJECTED",
-      "TCB Info and QE Identity must include valid tcbEvaluationDataNumber values"
-    );
-  }
-  if (tcbNumber !== qeNumber) {
-    throw err(
-      "TCB_STATUS_REJECTED",
-      `TCB Info tcbEvaluationDataNumber ${tcbNumber} does not match QE Identity ${qeNumber}`
-    );
-  }
-}
-function isTcbEvaluationDataNumber(value) {
-  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
-}
-async function verifyCollateralIssuerChain(certs, policy, label) {
-  const candidates = [certs, [...certs].reverse()];
-  let lastError;
-  for (const chain of candidates) {
-    try {
-      const rootFp = await sha256Hex(new Uint8Array(chain[chain.length - 1].rawData));
-      const expectedRootFp = policy.intelRootFingerprint?.toLowerCase() ?? INTEL_SGX_ROOT_CA_FINGERPRINT_SHA256;
-      if (rootFp !== expectedRootFp) {
-        throw err(
-          "ROOT_FINGERPRINT_MISMATCH",
-          `${label} root fingerprint ${rootFp} does not match pinned ${expectedRootFp}`
-        );
-      }
-      await verifyChainSignatures(chain);
-      return chain;
-    } catch (e) {
-      lastError = e;
-    }
-  }
-  if (lastError instanceof AttestationError) throw lastError;
-  throw err("DCAP_COLLATERAL_SIGNATURE", `${label} certificate chain failed verification`);
-}
-function assertDcapJsonSignerIdentity(leaf, root, policy, label) {
-  const expectedRootFp = policy.intelRootFingerprint?.toLowerCase() ?? INTEL_SGX_ROOT_CA_FINGERPRINT_SHA256;
-  const allowsSyntheticRoot = expectedRootFp !== INTEL_SGX_ROOT_CA_FINGERPRINT_SHA256;
-  const allowedSubjects = allowsSyntheticRoot ? [INTEL_TCB_SIGNING_SUBJECT, TEST_TCB_SIGNING_SUBJECT] : [INTEL_TCB_SIGNING_SUBJECT];
-  if (!allowedSubjects.includes(leaf.subject)) {
-    throw err(
-      "DCAP_COLLATERAL_SIGNATURE",
-      `${label} signing certificate subject ${leaf.subject} is not an Intel PCS TCB signing identity`
-    );
-  }
-  if (leaf.issuer !== root.subject) {
-    throw err(
-      "DCAP_COLLATERAL_SIGNATURE",
-      `${label} signing certificate issuer ${leaf.issuer} does not match root ${root.subject}`
-    );
-  }
-  const basicConstraints = leaf.getExtension(x509.BasicConstraintsExtension);
-  if (basicConstraints?.ca) {
-    throw err("DCAP_COLLATERAL_SIGNATURE", `${label} signing certificate must not be a CA`);
-  }
-}
-function verifyTcbInfo(tcbInfo, pckLeaf, body, now) {
-  if (tcbInfo.id !== "TDX") {
-    throw err("TCB_STATUS_REJECTED", `TCB Info id ${String(tcbInfo.id)} is not TDX`);
-  }
-  if (tcbInfo.version !== 3 || tcbInfo.tcbType !== 0) {
-    throw err(
-      "TCB_STATUS_REJECTED",
-      `unsupported TCB Info version=${String(tcbInfo.version)} tcbType=${String(tcbInfo.tcbType)}`
-    );
-  }
-  assertFreshDcapJsonWindow(tcbInfo, "TCB Info", now);
-  const pckTcb = extractPckTcb(pckLeaf);
-  if (typeof tcbInfo.fmspc !== "string" || tcbInfo.fmspc.toLowerCase() !== pckTcb.fmspc) {
-    throw err(
-      "TCB_STATUS_REJECTED",
-      `TCB Info FMSPC ${String(tcbInfo.fmspc)} does not match PCK FMSPC ${pckTcb.fmspc}`
-    );
-  }
-  if (typeof tcbInfo.pceId !== "string" || tcbInfo.pceId.toLowerCase() !== pckTcb.pceId) {
-    throw err(
-      "TCB_STATUS_REJECTED",
-      `TCB Info PCE ID ${String(tcbInfo.pceId)} does not match PCK PCE ID ${pckTcb.pceId}`
-    );
-  }
-  if (!Array.isArray(tcbInfo.tcbLevels)) {
-    throw err("TCB_STATUS_REJECTED", "TCB Info has no tcbLevels array");
-  }
-  const teeTcbSvn = body.subarray(BODY_TEE_TCB_SVN_OFF, BODY_TEE_TCB_SVN_OFF + 16);
-  const matched = tcbInfo.tcbLevels.find((level) => tdxTcbLevelMatches(level, pckTcb, teeTcbSvn));
-  if (!matched || typeof matched !== "object") {
-    throw err("TCB_STATUS_REJECTED", "no TCB Info level matches PCK SGX TCB and quote TEE_TCB_SVN");
-  }
-  const status = matched["tcbStatus"];
-  if (typeof status !== "string" || !ACCEPTED_TCB_STATUSES.has(status)) {
-    throw err("TCB_STATUS_REJECTED", `TCB status ${String(status)} is not accepted`);
-  }
-  verifyTdxModuleIdentity(tcbInfo, body, teeTcbSvn);
-}
-function verifyQeIdentity(identity, qeReport, now) {
-  if (identity.id !== "TD_QE") {
-    throw err("QE_IDENTITY_REJECTED", `QE Identity id ${String(identity.id)} is not TD_QE`);
-  }
-  if (identity.version !== 2) {
-    throw err(
-      "QE_IDENTITY_REJECTED",
-      `unsupported QE Identity version ${String(identity.version)}`
-    );
-  }
-  assertFreshDcapJsonWindow(identity, "QE Identity", now);
-  assertMaskedHexMatches({
-    actual: qeReport.subarray(SGX_REPORT_MISCSELECT_OFF, SGX_REPORT_MISCSELECT_OFF + 4),
-    expectedHex: identity.miscselect,
-    maskHex: identity.miscselectMask,
-    label: "QE Identity MISCSELECT",
-    reason: "QE_IDENTITY_REJECTED"
-  });
-  assertMaskedHexMatches({
-    actual: qeReport.subarray(SGX_REPORT_ATTRIBUTES_OFF, SGX_REPORT_ATTRIBUTES_OFF + 16),
-    expectedHex: identity.attributes,
-    maskHex: identity.attributesMask,
-    label: "QE Identity ATTRIBUTES",
-    reason: "QE_IDENTITY_REJECTED"
-  });
-  const expectedMrSigner = bytesToHex(
-    qeReport.subarray(SGX_REPORT_MRSIGNER_OFF, SGX_REPORT_MRSIGNER_OFF + 32)
-  );
-  if (typeof identity.mrsigner !== "string" || identity.mrsigner.toLowerCase() !== expectedMrSigner) {
-    throw err(
-      "QE_IDENTITY_REJECTED",
-      `QE Identity MRSIGNER ${String(identity.mrsigner)} does not match QE report ${expectedMrSigner}`
-    );
-  }
-  const isvProdId = readU16LE(qeReport, SGX_REPORT_ISV_PROD_ID_OFF);
-  if (identity.isvprodid !== isvProdId) {
-    throw err(
-      "QE_IDENTITY_REJECTED",
-      `QE Identity ISVProdID ${String(identity.isvprodid)} does not match QE report ${isvProdId}`
-    );
-  }
-  if (!Array.isArray(identity.tcbLevels)) {
-    throw err("QE_IDENTITY_REJECTED", "QE Identity has no tcbLevels array");
-  }
-  const isvSvn = readU16LE(qeReport, SGX_REPORT_ISV_SVN_OFF);
-  const matched = identity.tcbLevels.find((level) => qeIdentityLevelMatches(level, isvSvn));
-  if (!matched || typeof matched !== "object") {
-    throw err("QE_IDENTITY_REJECTED", "no QE Identity level matches QE report ISVSVN");
-  }
-  const status = matched["tcbStatus"];
-  if (typeof status !== "string" || !ACCEPTED_QE_IDENTITY_STATUSES.has(status)) {
-    throw err("QE_IDENTITY_REJECTED", `QE Identity status ${String(status)} is not accepted`);
-  }
-}
-function tdxTcbLevelMatches(level, pckTcb, teeTcbSvn) {
-  if (!level || typeof level !== "object") return false;
-  const tcb = level["tcb"];
-  if (!tcb || typeof tcb !== "object") return false;
-  const record = tcb;
-  const sgxComponents = record["sgxtcbcomponents"];
-  if (!tcbComponentsMatch(sgxComponents, pckTcb.sgxTcbSvns, 0)) return false;
-  const pceSvn = record["pcesvn"];
-  if (typeof pceSvn !== "number" || pckTcb.pceSvn < pceSvn) return false;
-  const tdxComponents = record["tdxtcbcomponents"];
-  const tdxStartIndex = teeTcbSvn[1] === 0 ? 0 : 2;
-  return tcbComponentsMatch(tdxComponents, Array.from(teeTcbSvn), tdxStartIndex);
-}
-function tcbComponentsMatch(components, actualSvns, startIndex) {
-  if (!Array.isArray(components) || components.length < 16) return false;
-  for (let index = startIndex; index < 16; index++) {
-    const component = components[index];
-    if (!component || typeof component !== "object") return false;
-    const svn = component["svn"];
-    if (typeof svn !== "number" || actualSvns[index] < svn) return false;
-  }
-  return true;
-}
-function verifyTdxModuleIdentity(tcbInfo, body, teeTcbSvn) {
-  const moduleVersion = teeTcbSvn[1];
-  const identity = getTdxModuleIdentity(tcbInfo, moduleVersion);
-  const expectedMrSigner = bytesToHex(
-    body.subarray(BODY_MRSIGNERSEAM_OFF, BODY_MRSIGNERSEAM_OFF + 48)
-  );
-  if (typeof identity["mrsigner"] !== "string" || identity["mrsigner"].toLowerCase() !== expectedMrSigner) {
-    throw err(
-      "TCB_STATUS_REJECTED",
-      `TDX Module Identity MRSIGNER ${String(identity["mrsigner"])} does not match quote ${expectedMrSigner}`
-    );
-  }
-  assertMaskedHexMatches({
-    actual: body.subarray(BODY_SEAM_ATTRIBUTES_OFF, BODY_SEAM_ATTRIBUTES_OFF + 8),
-    expectedHex: identity["attributes"],
-    maskHex: identity["attributesMask"],
-    label: "TDX Module Identity ATTRIBUTES",
-    reason: "TCB_STATUS_REJECTED"
-  });
-  if (moduleVersion < 1) return;
-  const tcbLevels = identity["tcbLevels"];
-  if (!Array.isArray(tcbLevels)) {
-    throw err("TCB_STATUS_REJECTED", "TDX Module Identity has no tcbLevels array");
-  }
-  const matched = tcbLevels.find((level) => tdxModuleTcbLevelMatches(level, teeTcbSvn[0]));
-  if (!matched || typeof matched !== "object") {
-    throw err("TCB_STATUS_REJECTED", "no TDX Module Identity level matches TEE_TCB_SVN ISVSVN");
-  }
-  const status = matched["tcbStatus"];
-  if (typeof status !== "string" || !ACCEPTED_TDX_MODULE_STATUSES.has(status)) {
-    throw err("TCB_STATUS_REJECTED", `TDX Module status ${String(status)} is not accepted`);
-  }
-}
-function getTdxModuleIdentity(tcbInfo, moduleVersion) {
-  if (moduleVersion < 1) {
-    const module = tcbInfo.tdxModule;
-    if (!module || typeof module !== "object" || Array.isArray(module)) {
-      throw err("TCB_STATUS_REJECTED", "TCB Info has no tdxModule object");
-    }
-    return module;
-  }
-  const identities = tcbInfo.tdxModuleIdentities;
-  if (!Array.isArray(identities)) {
-    throw err("TCB_STATUS_REJECTED", "TCB Info has no tdxModuleIdentities array");
-  }
-  const moduleIdentity = identities.find((candidate) => {
-    if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) return false;
-    const id = candidate["id"];
-    return typeof id === "string" && tdxModuleIdMatches(id, moduleVersion);
-  });
-  if (!moduleIdentity || typeof moduleIdentity !== "object") {
-    throw err(
-      "TCB_STATUS_REJECTED",
-      `no TDX Module Identity matches TEE_TCB_SVN module version ${moduleVersion}`
-    );
-  }
-  return moduleIdentity;
-}
-function tdxModuleIdMatches(id, moduleVersion) {
-  const match = /^TDX_(\d+)$/.exec(id);
-  return match !== null && Number.parseInt(match[1], 10) === moduleVersion;
-}
-function tdxModuleTcbLevelMatches(level, isvSvn) {
-  if (!level || typeof level !== "object") return false;
-  const tcb = level["tcb"];
-  if (!tcb || typeof tcb !== "object") return false;
-  const record = tcb;
-  const required = typeof record["isvsvn"] === "number" ? record["isvsvn"] : typeof record["isvnsvn"] === "number" ? record["isvnsvn"] : void 0;
-  return typeof required === "number" && isvSvn >= required;
-}
-function qeIdentityLevelMatches(level, isvSvn) {
-  if (!level || typeof level !== "object") return false;
-  const tcb = level["tcb"];
-  if (!tcb || typeof tcb !== "object") return false;
-  const requiredIsvSvn = tcb["isvsvn"];
-  return typeof requiredIsvSvn === "number" && isvSvn >= requiredIsvSvn;
-}
-function assertMaskedHexMatches(params) {
-  const { actual, expectedHex, maskHex, label, reason } = params;
-  if (typeof expectedHex !== "string" || !isHexByteLength(expectedHex, actual.length)) {
-    throw err(reason, `${label} is missing or not ${actual.length} bytes of hex`);
-  }
-  if (typeof maskHex !== "string" || !isHexByteLength(maskHex, actual.length)) {
-    throw err(reason, `${label} mask is missing or not ${actual.length} bytes of hex`);
-  }
-  const expected = hexToBytes(expectedHex);
-  const mask = hexToBytes(maskHex);
-  for (let index = 0; index < actual.length; index++) {
-    if ((actual[index] & mask[index]) !== (expected[index] & mask[index])) {
-      throw err(reason, `${label} masked byte ${index} does not match signed collateral policy`);
-    }
-  }
-}
-function isHexByteLength(value, byteLength) {
-  return value.length === byteLength * 2 && /^[0-9a-f]+$/i.test(value);
-}
-function assertFreshDcapJsonWindow(value, label, now) {
-  if (typeof value.issueDate !== "string" || typeof value.nextUpdate !== "string") {
-    throw err("DCAP_COLLATERAL_PARSE", `${label} is missing issueDate or nextUpdate`);
-  }
-  const issueDate = new Date(value.issueDate);
-  const nextUpdate = new Date(value.nextUpdate);
-  if (Number.isNaN(issueDate.getTime()) || Number.isNaN(nextUpdate.getTime())) {
-    throw err("DCAP_COLLATERAL_PARSE", `${label} has invalid issueDate or nextUpdate`);
-  }
-  if (now < issueDate) {
-    throw err("TCB_STATUS_REJECTED", `${label} is not yet valid`);
-  }
-  if (now > nextUpdate) {
-    throw err("TCB_STATUS_REJECTED", `${label} is stale past nextUpdate`);
-  }
-}
-function parseCrl(pem, label) {
-  if (typeof pem !== "string" || pem.length === 0) {
-    throw err("DCAP_COLLATERAL_MISSING", `${label} is missing`);
-  }
-  try {
-    return new x509.X509Crl(pem);
-  } catch (e) {
-    throw err("DCAP_COLLATERAL_PARSE", `${label} is not a parseable X.509 CRL: ${e}`);
-  }
-}
-async function verifyCrl(crl, issuer, label, now) {
-  if (crl.issuer !== issuer.subject) {
-    throw err(
-      "DCAP_COLLATERAL_SIGNATURE",
-      `${label} issuer ${crl.issuer} does not match expected ${issuer.subject}`
-    );
-  }
-  if (now < crl.thisUpdate) {
-    throw err("TCB_STATUS_REJECTED", `${label} is not yet valid`);
-  }
-  if (!crl.nextUpdate || now > crl.nextUpdate) {
-    throw err("TCB_STATUS_REJECTED", `${label} is stale past nextUpdate`);
-  }
-  let ok;
-  try {
-    ok = await crl.verify({ publicKey: issuer });
-  } catch (e) {
-    throw err("DCAP_COLLATERAL_SIGNATURE", `${label} signature verification threw: ${e}`);
-  }
-  if (!ok) {
-    throw err("DCAP_COLLATERAL_SIGNATURE", `${label} signature verification failed`);
-  }
-}
-async function assertNotRevokedByRoot(rootCrl, cert, label) {
-  if (rootCrl.findRevoked(cert)) {
-    throw err("DCAP_COLLATERAL_REVOKED", `${label} is revoked by Intel root CRL`);
-  }
-}
-async function assertSameCertificate(actual, expected, label) {
-  const actualFp = await sha256Hex(new Uint8Array(actual.rawData));
-  const expectedFp = await sha256Hex(new Uint8Array(expected.rawData));
-  if (actualFp !== expectedFp) {
-    throw err(
-      "DCAP_COLLATERAL_SIGNATURE",
-      `${label} fingerprint ${actualFp} does not match quote chain issuer ${expectedFp}`
-    );
-  }
-}
-function parsePemCertificateChain(pem, label, minCerts) {
-  if (typeof pem !== "string" || pem.length === 0) {
-    throw err("DCAP_COLLATERAL_MISSING", `${label} is missing`);
-  }
-  const matches = pem.match(/-----BEGIN CERTIFICATE-----[\s\S]+?-----END CERTIFICATE-----/g) ?? [];
-  if (matches.length < minCerts) {
-    throw err(
-      "DCAP_COLLATERAL_PARSE",
-      `${label} has ${matches.length} cert(s), expected at least ${minCerts}`
-    );
-  }
-  return matches.map((certPem, index) => {
-    try {
-      return new x509.X509Certificate(certPem);
-    } catch (e) {
-      throw err("DCAP_COLLATERAL_PARSE", `${label} cert[${index}] is not parseable: ${e}`);
-    }
-  });
-}
-function extractPckTcb(cert) {
-  const sgxExtensions = cert.getExtension(INTEL_PCK_SGX_EXTENSIONS_OID);
-  if (sgxExtensions) {
-    return parsePckSgxExtensions(new Uint8Array(sgxExtensions.value));
-  }
-  return {
-    fmspc: extractPckExtensionHex(cert, INTEL_PCK_EXTENSION_FMSPC_OID, 6, "FMSPC"),
-    pceId: extractPckExtensionHex(cert, INTEL_PCK_EXTENSION_PCE_ID_OID, 2, "PCE ID"),
-    sgxTcbSvns: Array.from(
-      { length: 16 },
-      (_, index) => extractPckIntegerExtension(
-        cert,
-        `${INTEL_PCK_EXTENSION_SGX_TCB_COMPONENT_OID_PREFIX}${index + 1}`,
-        `SGX TCB component ${index + 1}`
-      )
-    ),
-    pceSvn: extractPckIntegerExtension(cert, INTEL_PCK_EXTENSION_PCESVN_OID, "PCESVN"),
-    cpuSvn: hexToBytes(extractPckExtensionHex(cert, INTEL_PCK_EXTENSION_CPUSVN_OID, 16, "CPUSVN"))
-  };
-}
-function parsePckSgxExtensions(bytes) {
-  const topLevel = unwrapDerOctetStringIfPresent(bytes);
-  const extensions = derChildren(expectDerTag(readDerTlv(topLevel, 0), 48, "SGX extensions"));
-  const parsed = {};
-  for (const extension of extensions) {
-    const contextTag = contextSpecificTagNumber(extension);
-    if (contextTag === 2) {
-      parsed.pceId = bytesToHex(readContextOctetString(extension, "PCE ID"));
-      continue;
-    }
-    if (contextTag === 3) {
-      parsed.fmspc = bytesToHex(readContextOctetString(extension, "FMSPC"));
-      continue;
-    }
-    if (contextTag === 1) {
-      const tcb = parsePckTcbExtension(extension);
-      parsed.sgxTcbSvns = tcb.sgxTcbSvns;
-      parsed.pceSvn = tcb.pceSvn;
-      parsed.cpuSvn = tcb.cpuSvn;
-      continue;
-    }
-    const children = derChildren(expectDerTag(extension, 48, "SGX extension item"));
-    if (children.length !== 2) {
-      throw err("TCB_STATUS_REJECTED", "PCK SGX extension item does not contain OID and value");
-    }
-    const oid = readDerOid(children[0]);
-    const value = children[1];
-    if (oid === INTEL_PCK_EXTENSION_PCE_ID_OID) {
-      parsed.pceId = bytesToHex(readPckChoiceOctetString(value, 2, "PCE ID"));
-    } else if (oid === INTEL_PCK_EXTENSION_FMSPC_OID) {
-      parsed.fmspc = bytesToHex(readPckChoiceOctetString(value, 3, "FMSPC"));
-    } else if (oid === INTEL_PCK_EXTENSION_TCB_OID) {
-      const tcb = parsePckTcbExtension(value);
-      parsed.sgxTcbSvns = tcb.sgxTcbSvns;
-      parsed.pceSvn = tcb.pceSvn;
-      parsed.cpuSvn = tcb.cpuSvn;
-    }
-  }
-  if (parsed.fmspc === void 0 || parsed.pceId === void 0 || parsed.sgxTcbSvns === void 0 || parsed.pceSvn === void 0 || parsed.cpuSvn === void 0) {
-    throw err("TCB_STATUS_REJECTED", "PCK SGX extension is missing FMSPC, PCE ID, or TCB fields");
-  }
-  return parsed;
-}
-function parsePckTcbExtension(value) {
-  const tcbItems = pckTcbChildren(value);
-  const sgxTcbSvns = [];
-  let pceSvn;
-  let cpuSvn;
-  for (const item of tcbItems) {
-    const contextTag = contextSpecificTagNumber(item);
-    if (contextTag !== null) {
-      if (contextTag === 16) {
-        pceSvn = readContextInteger(item, "PCESVN");
-      } else if (contextTag === 17) {
-        cpuSvn = readContextOctetString(item, "CPUSVN");
-      } else if (contextTag >= 0 && contextTag <= 15) {
-        sgxTcbSvns[contextTag] = readContextInteger(item, `SGX TCB component ${contextTag + 1}`);
-      }
-      continue;
-    }
-    const children = derChildren(expectDerTag(item, 48, "PCK TCB item"));
-    if (children.length !== 2) {
-      throw err("TCB_STATUS_REJECTED", "PCK TCB item does not contain OID and value");
-    }
-    const oid = readDerOid(children[0]);
-    const valueTlv = children[1];
-    if (oid === INTEL_PCK_EXTENSION_PCESVN_OID) {
-      pceSvn = readPckChoiceInteger(valueTlv, 16, "PCESVN");
-    } else if (oid === INTEL_PCK_EXTENSION_CPUSVN_OID) {
-      cpuSvn = readPckChoiceOctetString(valueTlv, 17, "CPUSVN");
-    } else if (oid.startsWith(INTEL_PCK_EXTENSION_SGX_TCB_COMPONENT_OID_PREFIX)) {
-      const index = Number.parseInt(
-        oid.slice(INTEL_PCK_EXTENSION_SGX_TCB_COMPONENT_OID_PREFIX.length),
-        10
-      );
-      if (!Number.isInteger(index) || index < 1 || index > 16) {
-        throw err("TCB_STATUS_REJECTED", `PCK TCB component OID ${oid} is out of range`);
-      }
-      sgxTcbSvns[index - 1] = readPckChoiceInteger(
-        valueTlv,
-        index - 1,
-        `SGX TCB component ${index}`
-      );
-    }
-  }
-  if (sgxTcbSvns.length !== 16 || Array.from({ length: 16 }, (_, index) => sgxTcbSvns[index]).some((svn) => svn === void 0)) {
-    throw err("TCB_STATUS_REJECTED", "PCK TCB extension is missing SGX TCB components");
-  }
-  if (pceSvn === void 0 || cpuSvn === void 0) {
-    throw err("TCB_STATUS_REJECTED", "PCK TCB extension is missing PCESVN or CPUSVN");
-  }
-  if (cpuSvn.length !== 16) {
-    throw err("TCB_STATUS_REJECTED", `PCK CPUSVN has ${cpuSvn.length} bytes, expected 16`);
-  }
-  return { sgxTcbSvns, pceSvn, cpuSvn };
-}
-function extractPckExtensionHex(cert, oid, expectedBytes, label) {
-  const ext = cert.getExtension(oid);
-  if (!ext) {
-    throw err("TCB_STATUS_REJECTED", `PCK leaf is missing ${label} extension ${oid}`);
-  }
-  const decoded = unwrapDerOctetStringIfPresent(new Uint8Array(ext.value));
-  if (decoded.length !== expectedBytes) {
-    throw err(
-      "TCB_STATUS_REJECTED",
-      `PCK ${label} extension has ${decoded.length} bytes, expected ${expectedBytes}`
-    );
-  }
-  return bytesToHex(decoded);
-}
-function extractPckIntegerExtension(cert, oid, label) {
-  const ext = cert.getExtension(oid);
-  if (!ext) {
-    throw err("TCB_STATUS_REJECTED", `PCK leaf is missing ${label} extension ${oid}`);
-  }
-  return readDerInteger(readDerTlv(new Uint8Array(ext.value), 0), label);
-}
-function readDerTlv(source, start) {
-  if (start + 2 > source.length) {
-    throw err("TCB_STATUS_REJECTED", "truncated DER value");
-  }
-  const tag = source[start];
-  let offset = start + 1;
-  const firstLength = source[offset++];
-  let length;
-  if ((firstLength & 128) === 0) {
-    length = firstLength;
-  } else {
-    const octets = firstLength & 127;
-    if (octets === 0 || octets > 4 || offset + octets > source.length) {
-      throw err("TCB_STATUS_REJECTED", "unsupported DER length");
-    }
-    length = 0;
-    for (let i = 0; i < octets; i++) {
-      length = length << 8 | source[offset++];
-    }
-  }
-  const valueStart = offset;
-  const valueEnd = valueStart + length;
-  if (valueEnd > source.length) {
-    throw err("TCB_STATUS_REJECTED", "DER value length exceeds buffer");
-  }
-  return { tag, start, valueStart, valueEnd, end: valueEnd, source };
-}
-function expectDerTag(tlv, tag, label) {
-  if (tlv.tag !== tag) {
-    throw err("TCB_STATUS_REJECTED", `${label} has DER tag 0x${tlv.tag.toString(16)}`);
-  }
-  return tlv;
-}
-function derChildren(tlv) {
-  const children = [];
-  let offset = tlv.valueStart;
-  while (offset < tlv.valueEnd) {
-    const child = readDerTlv(tlv.source, offset);
-    if (child.end > tlv.valueEnd) {
-      throw err("TCB_STATUS_REJECTED", "DER child exceeds parent");
-    }
-    children.push(child);
-    offset = child.end;
-  }
-  return children;
-}
-function readDerOid(tlv) {
-  expectDerTag(tlv, 6, "OID");
-  const bytes = tlv.source.subarray(tlv.valueStart, tlv.valueEnd);
-  if (bytes.length === 0) {
-    throw err("TCB_STATUS_REJECTED", "empty DER OID");
-  }
-  const parts = [Math.floor(bytes[0] / 40), bytes[0] % 40];
-  let value = 0;
-  for (const byte of bytes.subarray(1)) {
-    value = value << 7 | byte & 127;
-    if ((byte & 128) === 0) {
-      parts.push(value);
-      value = 0;
-    }
-  }
-  if (value !== 0) {
-    throw err("TCB_STATUS_REJECTED", "truncated DER OID");
-  }
-  return parts.join(".");
-}
-function readDerInteger(tlv, label) {
-  expectDerTag(tlv, 2, label);
-  const bytes = tlv.source.subarray(tlv.valueStart, tlv.valueEnd);
-  if (bytes.length === 0 || (bytes[0] & 128) !== 0) {
-    throw err("TCB_STATUS_REJECTED", `${label} is not a positive DER integer`);
-  }
-  let value = 0;
-  for (const byte of bytes) value = value << 8 | byte;
-  return value;
-}
-function readDerOctetString(tlv, label) {
-  expectDerTag(tlv, 4, label);
-  return tlv.source.subarray(tlv.valueStart, tlv.valueEnd);
-}
-function pckTcbChildren(value) {
-  if (contextSpecificTagNumber(value) === 1) {
-    if ((value.tag & 32) === 0) {
-      throw err("TCB_STATUS_REJECTED", "PCK TCB field is not constructed");
-    }
-    const children = derChildren(value);
-    if (children.length === 1 && children[0].tag === 48) {
-      return derChildren(children[0]);
-    }
-    return children;
-  }
-  return derChildren(expectDerTag(value, 48, "PCK TCB extension"));
-}
-function readPckChoiceInteger(tlv, expectedTag, label) {
-  const contextTag = contextSpecificTagNumber(tlv);
-  if (contextTag !== null) {
-    if (contextTag !== expectedTag) {
-      throw err(
-        "TCB_STATUS_REJECTED",
-        `${label} uses context tag ${contextTag}, expected ${expectedTag}`
-      );
-    }
-    return readContextInteger(tlv, label);
-  }
-  return readDerInteger(tlv, label);
-}
-function readPckChoiceOctetString(tlv, expectedTag, label) {
-  const contextTag = contextSpecificTagNumber(tlv);
-  if (contextTag !== null) {
-    if (contextTag !== expectedTag) {
-      throw err(
-        "TCB_STATUS_REJECTED",
-        `${label} uses context tag ${contextTag}, expected ${expectedTag}`
-      );
-    }
-    return readContextOctetString(tlv, label);
-  }
-  return readDerOctetString(tlv, label);
-}
-function contextSpecificTagNumber(tlv) {
-  if ((tlv.tag & 192) !== 128) return null;
-  const tagNumber = tlv.tag & 31;
-  return tagNumber === 31 ? null : tagNumber;
-}
-function readContextInner(tlv) {
-  if ((tlv.tag & 32) === 0) {
-    throw err("TCB_STATUS_REJECTED", "PCK context-specific field is not constructed");
-  }
-  const children = derChildren(tlv);
-  if (children.length !== 1) {
-    throw err("TCB_STATUS_REJECTED", "PCK context-specific field has multiple values");
-  }
-  return children[0];
-}
-function readContextInteger(tlv, label) {
-  const inner = (tlv.tag & 32) !== 0 ? readContextInner(tlv) : tlv;
-  if ((tlv.tag & 32) !== 0) return readDerInteger(inner, label);
-  return readDerIntegerValue(inner.source.subarray(inner.valueStart, inner.valueEnd), label);
-}
-function readContextOctetString(tlv, label) {
-  const inner = (tlv.tag & 32) !== 0 ? readContextInner(tlv) : tlv;
-  if ((tlv.tag & 32) !== 0) return readDerOctetString(inner, label);
-  return inner.source.subarray(inner.valueStart, inner.valueEnd);
-}
-function readDerIntegerValue(bytes, label) {
-  if (bytes.length === 0 || (bytes[0] & 128) !== 0) {
-    throw err("TCB_STATUS_REJECTED", `${label} is not a positive DER integer`);
-  }
-  let value = 0;
-  for (const byte of bytes) value = value << 8 | byte;
-  return value;
-}
-function unwrapDerOctetStringIfPresent(bytes) {
-  if (bytes.length >= 2 && bytes[0] === 4) {
-    const tlv = readDerTlv(bytes, 0);
-    if (tlv.end === bytes.length) return bytes.subarray(tlv.valueStart, tlv.valueEnd);
-  }
-  return bytes;
-}
-function hexToBytes(hex) {
-  if (hex.length % 2 !== 0 || !/^[0-9a-f]*$/i.test(hex)) {
-    throw err("DCAP_COLLATERAL_PARSE", "invalid hex string");
-  }
-  const out = new Uint8Array(hex.length / 2);
-  for (let i = 0; i < out.length; i++) {
-    out[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-  }
-  return out;
-}
-var MAA_JKU_PATTERN = /^https:\/\/[a-z0-9-]+\.[a-z0-9]+\.attest\.azure\.net\/certs$/;
-function b64urlDecodeStr(s) {
-  const padded = s.replace(/-/g, "+").replace(/_/g, "/") + "=".repeat((4 - s.length % 4) % 4);
-  return atob(padded);
-}
-function b64urlDecodeBytes(s) {
-  const decoded = b64urlDecodeStr(s);
-  const out = new Uint8Array(decoded.length);
-  for (let i = 0; i < decoded.length; i++) out[i] = decoded.charCodeAt(i);
-  return out;
-}
-async function verifyAzureMaaToken(token, policy, timeoutMs = DEFAULT_AZURE_JWKS_TIMEOUT_MS) {
-  const parts = token.split(".");
-  if (parts.length !== 3) {
-    throw err("MAA_TOKEN_PARSE", `MAA token is not a valid JWT (${parts.length} parts)`);
-  }
-  const [headerB64, payloadB64, sigB64] = parts;
-  let header;
-  let payload;
-  try {
-    header = JSON.parse(b64urlDecodeStr(headerB64));
-    payload = JSON.parse(b64urlDecodeStr(payloadB64));
-  } catch (e) {
-    throw err("MAA_TOKEN_PARSE", `failed to decode MAA JWT header/payload: ${e}`);
-  }
-  const exp = payload["exp"];
-  if (typeof exp === "number" && Math.floor(Date.now() / 1e3) > exp) {
-    throw err("MAA_TOKEN_EXPIRED", `MAA JWT expired at ${new Date(exp * 1e3).toISOString()}`);
-  }
-  const jku = header["jku"];
-  const kid = header["kid"];
-  if (!jku || !kid) {
-    throw err("MAA_TOKEN_PARSE", "MAA JWT header missing jku or kid");
-  }
-  if (payload["iss"] !== policy.expectedIssuer) {
-    throw err(
-      "MAA_ISSUER_MISMATCH",
-      `MAA JWT issuer ${String(payload["iss"])} does not match pinned ${policy.expectedIssuer}`
-    );
-  }
-  if (jku !== policy.expectedJwksUrl) {
-    throw err(
-      "MAA_JWKS_MISMATCH",
-      `MAA JWT jku ${jku} does not match pinned ${policy.expectedJwksUrl}`
-    );
-  }
-  if (!MAA_JKU_PATTERN.test(policy.expectedJwksUrl)) {
-    throw err(
-      "MAA_JWKS_MISMATCH",
-      `pinned MAA JWKS URL does not match Azure attestation domain: ${policy.expectedJwksUrl}`
-    );
-  }
-  if (payload["x-ms-policy-hash"] !== policy.expectedPolicyHash) {
-    throw err(
-      "MAA_POLICY_HASH_MISMATCH",
-      `MAA policy hash ${String(payload["x-ms-policy-hash"])} does not match pinned ${policy.expectedPolicyHash}`
-    );
-  }
-  let jwks;
-  try {
-    jwks = await fetchMaaJwks(policy.expectedJwksUrl, timeoutMs);
-  } catch (e) {
-    throw err(
-      "MAA_TOKEN_SIGNATURE",
-      `failed to fetch MAA JWKS from ${policy.expectedJwksUrl}: ${e}`
-    );
-  }
-  const jwk = jwks.keys.find((k) => k.kid === kid);
-  if (!jwk) {
-    throw err("MAA_TOKEN_SIGNATURE", `no key with kid=${kid} found in MAA JWKS`);
-  }
-  let sigPubKey;
-  try {
-    sigPubKey = await crypto.subtle.importKey(
-      "jwk",
-      { kty: "RSA", n: jwk.n, e: jwk.e, alg: "RS256", ext: true },
-      { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" },
-      false,
-      ["verify"]
-    );
-  } catch (e) {
-    throw err("MAA_TOKEN_SIGNATURE", `failed to import MAA JWK: ${e}`);
-  }
-  const msg = new TextEncoder().encode(`${headerB64}.${payloadB64}`);
-  const sig = b64urlDecodeBytes(sigB64);
-  const valid = await crypto.subtle.verify(
-    { name: "RSASSA-PKCS1-v1_5" },
-    sigPubKey,
-    sig,
-    msg
-  );
-  if (!valid) {
-    throw err("MAA_TOKEN_SIGNATURE", "MAA JWT RS256 signature verification failed");
-  }
-  if (payload["x-ms-compliance-status"] !== "azure-compliant-cvm") {
-    throw err(
-      "MAA_COMPLIANCE_MISMATCH",
-      `MAA compliance status: "${payload["x-ms-compliance-status"]}" (expected "azure-compliant-cvm")`
-    );
-  }
-  if (payload["tdx_td_attributes_debug"] !== false) {
-    throw err("MAA_DEBUG_BIT_SET", "MAA token reports TDX debug bit set");
-  }
-  const reportData = payload["tdx_report_data"];
-  if (typeof reportData !== "string" || !/^[0-9a-f]{128}$/i.test(reportData)) {
-    throw err("MAA_REPORTDATA_MISMATCH", "MAA token missing valid 64-byte tdx_report_data claim");
-  }
-  return {
-    reportData: reportData.toLowerCase(),
-    mrtd: readMaaMeasurement(payload, "tdx_mrtd"),
-    rtmr0: readMaaMeasurement(payload, "tdx_rtmr0"),
-    rtmr1: readMaaMeasurement(payload, "tdx_rtmr1"),
-    rtmr2: readMaaMeasurement(payload, "tdx_rtmr2"),
-    rtmr3: readMaaMeasurement(payload, "tdx_rtmr3")
-  };
-}
-function readMaaMeasurement(payload, claim) {
-  const value = payload[claim];
-  if (typeof value !== "string" || !/^[0-9a-f]{96}$/i.test(value)) {
-    throw err("MAA_REPORTDATA_MISMATCH", `MAA token missing valid ${claim} claim`);
-  }
-  return value.toLowerCase();
-}
-function assertMaaMeasurementsMatchDcap(maa, dcap) {
-  const fields = ["mrtd", "rtmr0", "rtmr1", "rtmr2", "rtmr3"];
-  for (const field of fields) {
-    if (maa[field] !== dcap[field]) {
-      throw err(
-        "MAA_REPORTDATA_MISMATCH",
-        `MAA ${field} ${maa[field]} does not match DCAP quote ${field.toUpperCase()} ${dcap[field]}`
-      );
-    }
-  }
-}
-async function fetchMaaJwks(url, timeoutMs) {
-  const boundedTimeoutMs = Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : DEFAULT_AZURE_JWKS_TIMEOUT_MS;
-  const controller = new AbortController();
-  let timeoutId = null;
-  const timeout = new Promise((_, reject) => {
-    timeoutId = setTimeout(() => {
-      controller.abort();
-      reject(new Error(`timed out after ${boundedTimeoutMs}ms`));
-    }, boundedTimeoutMs);
-  });
-  try {
-    return await Promise.race([
-      (async () => {
-        const resp = await fetch(url, { signal: controller.signal });
-        if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
-        return await resp.json();
-      })(),
-      timeout
-    ]);
-  } finally {
-    if (timeoutId !== null) clearTimeout(timeoutId);
-  }
-}
-async function verifyTpmQuoteNonce(tpmQuoteB64, akPubKey, expectedNonce, expectedNoiseStaticPub, expectedBinaryHash) {
-  let raw;
-  try {
-    raw = base64ToBytes(tpmQuoteB64);
-  } catch (e) {
-    throw err("TPM_QUOTE_SIGNATURE", `failed to decode tpm_quote: ${e}`);
-  }
-  if (raw.length < 8) {
-    throw err("TPM_QUOTE_SIGNATURE", "tpm_quote too short");
-  }
-  const msgLen = new DataView(raw.buffer, raw.byteOffset).getUint32(
-    0,
-    true
-    /* little-endian */
-  );
-  if (4 + msgLen > raw.length) {
-    throw err("TPM_QUOTE_SIGNATURE", `tpm_quote msg_len=${msgLen} exceeds buffer`);
-  }
-  const tpmsAttest = raw.slice(4, 4 + msgLen);
-  const sigBlob = raw.slice(4 + msgLen);
-  if (sigBlob.length < 6) {
-    throw err("TPM_QUOTE_SIGNATURE", "TPMT_SIGNATURE too short");
-  }
-  const sigSize = sigBlob[4] << 8 | sigBlob[5];
-  const sigBytes = sigBlob.slice(6, 6 + sigSize);
-  if (sigBytes.length !== sigSize) {
-    throw err(
-      "TPM_QUOTE_SIGNATURE",
-      `TPMT_SIGNATURE truncated: need ${sigSize}, have ${sigBytes.length}`
-    );
-  }
-  const valid = await crypto.subtle.verify(
-    { name: "RSASSA-PKCS1-v1_5" },
-    akPubKey,
-    sigBytes,
-    tpmsAttest
-  );
-  if (!valid) {
-    throw err("TPM_QUOTE_SIGNATURE", "TPM AK RSA signature verification failed");
-  }
-  const qdInput = new Uint8Array(
-    expectedNonce.length + expectedNoiseStaticPub.length + expectedBinaryHash.length
-  );
-  qdInput.set(expectedNonce, 0);
-  qdInput.set(expectedNoiseStaticPub, expectedNonce.length);
-  qdInput.set(expectedBinaryHash, expectedNonce.length + expectedNoiseStaticPub.length);
-  const expectedQd = new Uint8Array(await crypto.subtle.digest("SHA-256", qdInput));
-  const extraData = readTpmsAttestExtraData(tpmsAttest);
-  if (!constantTimeEq(extraData, expectedQd)) {
-    throw err(
-      "TPM_NONCE_MISMATCH",
-      "TPMS_ATTEST extraData does not equal SHA-256(nonce || noise_pubkey || binary_hash)"
-    );
-  }
-}
-function readTpmsAttestExtraData(tpmsAttest) {
-  if (tpmsAttest.length < 10) {
-    throw err("TPM_QUOTE_SIGNATURE", "TPMS_ATTEST too short");
-  }
-  const view = new DataView(tpmsAttest.buffer, tpmsAttest.byteOffset, tpmsAttest.byteLength);
-  const magic = view.getUint32(0, false);
-  if (magic !== TPM_GENERATED_VALUE) {
-    throw err(
-      "TPM_QUOTE_SIGNATURE",
-      `TPMS_ATTEST magic ${magic.toString(16)} is not TPM_GENERATED_VALUE`
-    );
-  }
-  const attestType = view.getUint16(4, false);
-  if (attestType !== TPM_ST_ATTEST_QUOTE) {
-    throw err("TPM_QUOTE_SIGNATURE", `TPMS_ATTEST type ${attestType.toString(16)} is not quote`);
-  }
-  let offset = 6;
-  offset = readTpm2b(tpmsAttest, offset, "qualifiedSigner").nextOffset;
-  return readTpm2b(tpmsAttest, offset, "extraData").data;
-}
-function readTpm2b(bytes, offset, label) {
-  if (offset + 2 > bytes.length) {
-    throw err("TPM_QUOTE_SIGNATURE", `TPMS_ATTEST truncated before ${label} size`);
-  }
-  const size = bytes[offset] << 8 | bytes[offset + 1];
-  const start = offset + 2;
-  const end = start + size;
-  if (end > bytes.length) {
-    throw err("TPM_QUOTE_SIGNATURE", `TPMS_ATTEST truncated in ${label}`);
-  }
-  return { data: bytes.slice(start, end), nextOffset: end };
-}
-function base64ToBytes(b64) {
-  const normalized = b64.replace(/-/g, "+").replace(/_/g, "/");
-  const padded = normalized + "=".repeat((4 - normalized.length % 4) % 4);
-  const binaryStr = atob(padded);
-  const out = new Uint8Array(binaryStr.length);
-  for (let i = 0; i < binaryStr.length; i++) out[i] = binaryStr.charCodeAt(i);
-  return out;
-}
-async function verifyAzureTdxAttestation(params) {
-  const { raw, response, expectedNonce, expectedNoiseStaticPub, policy, timeoutMs } = params;
-  const body = raw.subarray(BODY_OFFSET, BODY_OFFSET + BODY_SIZE);
-  const dcapMeasurements = parseMeasurements(body);
-  const reportData = body.subarray(
-    BODY_REPORT_DATA_OFF,
-    BODY_REPORT_DATA_OFF + BODY_REPORT_DATA_LEN
-  );
-  await verifyDcapQuoteAndCollateral({ raw, body, response, policy });
-  assertDebugBitClear(body);
-  if (!response.maa_token) {
-    throw err("MAA_TOKEN_MISSING", "azure-tdx-dcap response missing maa_token");
-  }
-  if (!policy.azureMaa) {
-    throw err(
-      "MAA_TRUST_POLICY_MISSING",
-      "azure-tdx-dcap attestation requires pinned MAA issuer, JWKS URL, and policy hash"
-    );
-  }
-  const measurements = await verifyAzureMaaToken(response.maa_token, policy.azureMaa, timeoutMs);
-  const reportDataHex = bytesToHex(reportData);
-  if (measurements.reportData !== reportDataHex) {
-    throw err(
-      "MAA_REPORTDATA_MISMATCH",
-      `MAA tdx_report_data ${measurements.reportData} does not match DCAP REPORTDATA ${reportDataHex}`
-    );
-  }
-  assertMaaMeasurementsMatchDcap(measurements, dcapMeasurements);
-  if (!response.hcl_keys_json) {
-    throw err("HCL_KEYS_MISSING", "azure-tdx-dcap response missing hcl_keys_json");
-  }
-  let hclKeysBytes;
-  try {
-    hclKeysBytes = base64ToBytes(response.hcl_keys_json);
-  } catch (e) {
-    throw err("HCL_KEYS_PARSE", `failed to decode hcl_keys_json base64: ${e}`);
-  }
-  const reportData0_32 = reportData.subarray(0, 32);
-  const hclKeysHash = new Uint8Array(
-    await crypto.subtle.digest("SHA-256", hclKeysBytes)
-  );
-  if (!constantTimeEq(hclKeysHash, reportData0_32)) {
-    throw err(
-      "HCL_KEYS_HASH_MISMATCH",
-      "SHA-256(hcl_keys_json) does not match DCAP quote REPORTDATA[0:32]"
-    );
-  }
-  let hclKeys;
-  try {
-    hclKeys = JSON.parse(new TextDecoder().decode(hclKeysBytes));
-  } catch (e) {
-    throw err("HCL_KEYS_PARSE", `failed to parse hcl_keys_json: ${e}`);
-  }
-  const keysArray = hclKeys["keys"];
-  const akJwk = Array.isArray(keysArray) ? keysArray.find((k) => k["kid"] === "HCLAkPub") : void 0;
-  if (!akJwk) {
-    throw err("HCL_KEYS_PARSE", 'hcl_keys_json does not contain a key with kid="HCLAkPub"');
-  }
-  let akPubKey;
-  try {
-    akPubKey = await crypto.subtle.importKey(
-      "jwk",
-      { kty: "RSA", n: akJwk["n"], e: akJwk["e"], ext: true },
-      { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" },
-      false,
-      ["verify"]
-    );
-  } catch (e) {
-    throw err("HCL_KEYS_PARSE", `failed to import HCLAkPub from hcl_keys_json: ${e}`);
-  }
-  if (!response.tpm_quote) {
-    throw err("TPM_QUOTE_MISSING", "azure-tdx-dcap response missing tpm_quote");
-  }
-  if (!/^[0-9a-f]{64}$/i.test(response.binary_hash)) {
-    throw err("BINARY_HASH_FORMAT", "binary_hash field is not a 32-byte hex digest");
-  }
-  if (response.mode === "prod" && policy.expectedBinaryHash === void 0) {
-    throw err(
-      "BINARY_HASH_MISMATCH",
-      "production Azure attestation requires a pinned coordinator binary hash"
-    );
-  }
-  if (policy.expectedBinaryHash !== void 0 && response.binary_hash.toLowerCase() !== policy.expectedBinaryHash.toLowerCase()) {
-    throw err(
-      "BINARY_HASH_MISMATCH",
-      `binary hash ${response.binary_hash.toLowerCase()} does not match the approved release pin`
-    );
-  }
-  await verifyTpmQuoteNonce(
-    response.tpm_quote,
-    akPubKey,
-    expectedNonce,
-    expectedNoiseStaticPub,
-    hexToBytes(response.binary_hash)
-  );
-  if (response.nonce.toLowerCase() !== bytesToHex(expectedNonce)) {
-    throw err("NONCE_FIELD_MISMATCH", `JSON nonce ${response.nonce} does not match verifier nonce`);
-  }
-  if (response.pubkey.toLowerCase() !== bytesToHex(expectedNoiseStaticPub)) {
-    throw err(
-      "PUBKEY_FIELD_MISMATCH",
-      "attestation pubkey field does not match Noise static pubkey from handshake"
-    );
-  }
-  if (!/^[0-9a-f]{64}$/i.test(response.binary_hash)) {
-    throw err("BINARY_HASH_FORMAT", "binary_hash field is not a 32-byte hex digest");
-  }
-  if (policy.requiredMode !== void 0 && response.mode !== policy.requiredMode) {
-    throw err(
-      "MODE_MISMATCH",
-      `attestation mode ${response.mode} does not match required ${policy.requiredMode}`
-    );
-  }
-  if (response.mode === "prod") {
-    if ((policy.expectedMrtd === void 0 || policy.expectedMrtd === null) && policy.allowUnpinnedProdMrtdForRelease !== true) {
-      throw err(
-        "MRTD_MISMATCH",
-        "production attestation requires a pinned MRTD but none was configured"
-      );
-    }
-    if (policy.expectedMrtd !== void 0 && policy.expectedMrtd !== null && dcapMeasurements.mrtd !== policy.expectedMrtd.toLowerCase()) {
-      throw err(
-        "MRTD_MISMATCH",
-        `MRTD ${dcapMeasurements.mrtd} does not match pinned ${policy.expectedMrtd.toLowerCase()}`
-      );
-    }
-  }
-  return {
-    mode: response.mode,
-    binaryHash: response.binary_hash,
-    runtimeProfile: response.runtime_profile,
-    mrtd: dcapMeasurements.mrtd,
-    rtmr0: dcapMeasurements.rtmr0,
-    rtmr1: dcapMeasurements.rtmr1,
-    rtmr2: dcapMeasurements.rtmr2,
-    rtmr3: dcapMeasurements.rtmr3,
-    pubkeyHex: response.pubkey.toLowerCase(),
-    localAttestation: false
-  };
-}
-function verifyLocalAttestation(params) {
-  const { response, expectedNonce, expectedNoiseStaticPub, policy } = params;
-  if (policy.allowLocalAttestation !== true) {
-    throw err(
-      "LOCAL_ATTESTATION_DISABLED",
-      "local attestation response received but local attestation is not enabled"
-    );
-  }
-  if (policy.requiredMode !== void 0 && response.mode !== policy.requiredMode) {
-    throw err(
-      "MODE_MISMATCH",
-      `attestation mode ${response.mode} does not match required ${policy.requiredMode}`
-    );
-  }
-  if (response.mode !== "dev") {
-    throw err(
-      "LOCAL_ATTESTATION_DISABLED",
-      "local attestation is only accepted for dev mode responses"
-    );
-  }
-  if (response.nonce.toLowerCase() !== bytesToHex(expectedNonce)) {
-    throw err("NONCE_FIELD_MISMATCH", `JSON nonce ${response.nonce} does not match verifier nonce`);
-  }
-  if (!/^[0-9a-f]{64}$/i.test(response.binary_hash)) {
-    throw err("BINARY_HASH_FORMAT", "binary_hash field is not a 32-byte hex digest");
-  }
-  const expectedPubHex = bytesToHex(expectedNoiseStaticPub);
-  if (response.pubkey.toLowerCase() !== expectedPubHex) {
-    throw err(
-      "PUBKEY_FIELD_MISMATCH",
-      "local attestation pubkey field does not match Noise static pubkey from handshake"
-    );
-  }
-  return {
-    mode: response.mode,
-    binaryHash: response.binary_hash.toLowerCase(),
-    runtimeProfile: response.runtime_profile,
-    mrtd: "local-dev-no-mrtd",
-    rtmr0: "local-dev-no-rtmr0",
-    rtmr1: "local-dev-no-rtmr1",
-    rtmr2: "local-dev-no-rtmr2",
-    rtmr3: "local-dev-no-rtmr3",
-    pubkeyHex: response.pubkey.toLowerCase(),
-    localAttestation: true
-  };
-}
-function decodeQuoteB64(b64) {
-  let bin;
-  try {
-    bin = atob(b64);
-  } catch (e) {
-    throw err("QUOTE_DECODE", `quote field is not valid base64: ${e}`);
-  }
-  const out = new Uint8Array(bin.length);
-  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
-  return out;
-}
-function ensureStructure(raw) {
-  if (raw.length < HEADER_SIZE + BODY_SIZE + 4) {
-    throw err(
-      "QUOTE_STRUCTURE",
-      `quote too short: ${raw.length} bytes (need >= ${HEADER_SIZE + BODY_SIZE + 4})`
-    );
-  }
-  const version = readU16LE(raw, HEADER_VERSION_OFF);
-  const attKey = readU16LE(raw, HEADER_ATT_KEY_OFF);
-  const teeType = readU32LE(raw, HEADER_TEE_TYPE_OFF);
-  if (version !== 4) {
-    throw err("QUOTE_STRUCTURE", `unsupported quote version ${version}`);
-  }
-  if (teeType !== TDX_TEE_TYPE) {
-    throw err("QUOTE_STRUCTURE", `not a TDX quote (TEE type 0x${teeType.toString(16)})`);
-  }
-  if (attKey !== ECDSA_P256_KEY_TYPE) {
-    throw err(
-      "QUOTE_STRUCTURE",
-      `unsupported attestation key type ${attKey} (expected ECDSA-P256)`
-    );
-  }
-}
-function readSigData(raw) {
-  const sigDataLen = readU32LE(raw, SIG_DATA_LEN_OFFSET);
-  const sigStart = SIG_DATA_LEN_OFFSET + 4;
-  if (raw.length < sigStart + sigDataLen) {
-    throw err("QUOTE_STRUCTURE", "quote truncated in signature data");
-  }
-  return raw.subarray(sigStart, sigStart + sigDataLen);
-}
-function parseMeasurements(body) {
-  const m = (off) => bytesToHex(body.subarray(off, off + MEASUREMENT_LEN));
-  return {
-    mrtd: m(BODY_MRTD_OFF),
-    rtmr0: m(BODY_RTMR0_OFF),
-    rtmr1: m(BODY_RTMR1_OFF),
-    rtmr2: m(BODY_RTMR2_OFF),
-    rtmr3: m(BODY_RTMR3_OFF),
-    tdAttr: bytesToHex(body.subarray(BODY_TD_ATTR_OFF, BODY_TD_ATTR_OFF + 8))
-  };
-}
-var PEM_BEGIN = "-----BEGIN CERTIFICATE-----";
-var PEM_END = "-----END CERTIFICATE-----";
-var PEM_BEGIN_BYTES = new TextEncoder().encode(PEM_BEGIN);
-var PEM_END_BYTES = new TextEncoder().encode(PEM_END);
-function findBytes(hay, needle, from = 0) {
-  if (needle.length === 0) return from;
-  const last = hay.length - needle.length;
-  outer: for (let i = from; i <= last; i++) {
-    for (let j = 0; j < needle.length; j++) {
-      if (hay[i + j] !== needle[j]) continue outer;
-    }
-    return i;
-  }
-  return -1;
-}
-function parseQeCertificationData(sigData) {
-  if (sigData.length < SIG_QE_CERT_DATA_OFF + SIG_QE_CERT_DATA_HEADER_SIZE) {
-    throw err("QUOTE_STRUCTURE", "signature data truncated before QE certification data header");
-  }
-  const outerCertType = readU16LE(sigData, SIG_QE_CERT_DATA_OFF);
-  const outerCertSize = readU32LE(sigData, SIG_QE_CERT_DATA_OFF + 2);
-  if (outerCertType !== QE_CERT_TYPE_QE_REPORT_CERT_DATA) {
-    throw err(
-      "QUOTE_STRUCTURE",
-      `unexpected QE certification data type ${outerCertType} (expected ${QE_CERT_TYPE_QE_REPORT_CERT_DATA})`
-    );
-  }
-  const outerDataStart = SIG_QE_CERT_DATA_OFF + SIG_QE_CERT_DATA_HEADER_SIZE;
-  const outerDataEnd = outerDataStart + outerCertSize;
-  if (sigData.length < outerDataEnd) {
-    throw err("QUOTE_STRUCTURE", "signature data truncated in outer QE certification data");
-  }
-  const outerData = sigData.subarray(outerDataStart, outerDataEnd);
-  const qeReportSigOff = SIG_QE_REPORT_SIZE;
-  const qeAuthSizeOff = qeReportSigOff + SIG_QE_REPORT_SIG_SIZE;
-  const qeAuthDataOff = qeAuthSizeOff + 2;
-  if (outerData.length < qeAuthDataOff + SIG_QE_CERT_DATA_HEADER_SIZE) {
-    throw err(
-      "QUOTE_STRUCTURE",
-      "signature data truncated before QE auth_data and nested certification data"
-    );
-  }
-  const qeReport = outerData.subarray(0, SIG_QE_REPORT_SIZE);
-  const qeReportSig = outerData.subarray(qeReportSigOff, qeReportSigOff + SIG_QE_REPORT_SIG_SIZE);
-  const authSize = readU16LE(outerData, qeAuthSizeOff);
-  const qeAuthDataEnd = qeAuthDataOff + authSize;
-  if (outerData.length < qeAuthDataEnd + SIG_QE_CERT_DATA_HEADER_SIZE) {
-    throw err("QUOTE_STRUCTURE", "signature data truncated in QE auth_data");
-  }
-  const qeAuthData = outerData.subarray(qeAuthDataOff, qeAuthDataEnd);
-  const nestedCertType = readU16LE(outerData, qeAuthDataEnd);
-  const nestedCertSize = readU32LE(outerData, qeAuthDataEnd + 2);
-  if (nestedCertType !== QE_CERT_TYPE_PCK_CHAIN) {
-    throw err(
-      "PCK_CHAIN_MISSING",
-      `cert data type ${nestedCertType} is not PCK chain (expected ${QE_CERT_TYPE_PCK_CHAIN})`
-    );
-  }
-  const nestedDataEnd = qeAuthDataEnd + SIG_QE_CERT_DATA_HEADER_SIZE + nestedCertSize;
-  if (outerData.length < nestedDataEnd) {
-    throw err("QUOTE_STRUCTURE", "signature data truncated in nested QE certification data");
-  }
-  return {
-    qeReport,
-    qeReportSig,
-    qeAuthData,
-    qeCertificationData: outerData.subarray(qeAuthDataEnd, nestedDataEnd)
-  };
-}
-function extractPckChain(qeCertificationData) {
-  if (qeCertificationData.length < SIG_QE_CERT_DATA_HEADER_SIZE) {
-    throw err("PCK_CHAIN_PARSE", "nested QE certification data header truncated");
-  }
-  const certType = readU16LE(qeCertificationData, 0);
-  const certSize = readU32LE(qeCertificationData, 2);
-  if (certType !== QE_CERT_TYPE_PCK_CHAIN) {
-    throw err(
-      "PCK_CHAIN_MISSING",
-      `cert data type ${certType} is not PCK chain (expected ${QE_CERT_TYPE_PCK_CHAIN})`
-    );
-  }
-  if (qeCertificationData.length < SIG_QE_CERT_DATA_HEADER_SIZE + certSize) {
-    throw err("PCK_CHAIN_PARSE", "nested QE certification data truncated");
-  }
-  const certBytes = qeCertificationData.subarray(
-    SIG_QE_CERT_DATA_HEADER_SIZE,
-    SIG_QE_CERT_DATA_HEADER_SIZE + certSize
-  );
-  const certs = [];
-  let cursor = 0;
-  while (cursor < certBytes.length) {
-    const begin = findBytes(certBytes, PEM_BEGIN_BYTES, cursor);
-    if (begin === -1) break;
-    const endTag = findBytes(certBytes, PEM_END_BYTES, begin);
-    if (endTag === -1) {
-      throw err("PCK_CHAIN_PARSE", "unterminated PEM block");
-    }
-    const end = endTag + PEM_END_BYTES.length;
-    const pem = new TextDecoder("utf-8").decode(certBytes.subarray(begin, end));
-    try {
-      certs.push(new x509.X509Certificate(pem));
-    } catch (e) {
-      throw err("PCK_CHAIN_PARSE", `failed to parse PEM cert: ${e}`);
-    }
-    cursor = end;
-  }
-  if (certs.length === 0) {
-    throw err("PCK_CHAIN_MISSING", "no parseable certs in PCK chain");
-  }
-  if (certs.length < 3) {
-    throw err(
-      "PCK_CHAIN_MISSING",
-      `PCK chain has only ${certs.length} cert(s); Intel DCAP requires leaf + CA + Root (min 3)`
-    );
-  }
-  return certs;
-}
-async function verifyChainSignatures(chain) {
-  const now = /* @__PURE__ */ new Date();
-  for (let i = 0; i < chain.length - 1; i++) {
-    const cert = chain[i];
-    if (now < cert.notBefore) {
-      throw err(
-        "PCK_CHAIN_SIGNATURE",
-        `cert[${i}] (${cert.subject}) is not yet valid (notBefore=${cert.notBefore.toISOString()})`
-      );
-    }
-    if (now > cert.notAfter) {
-      throw err(
-        "PCK_CHAIN_SIGNATURE",
-        `cert[${i}] (${cert.subject}) has expired (notAfter=${cert.notAfter.toISOString()})`
-      );
-    }
-    let ok;
-    try {
-      ok = await chain[i].verify({ publicKey: chain[i + 1].publicKey });
-    } catch (e) {
-      throw err(
-        "PCK_CHAIN_SIGNATURE",
-        `cert[${i}] (${chain[i].subject}) signature verification threw: ${e}`
-      );
-    }
-    if (!ok) {
-      throw err(
-        "PCK_CHAIN_SIGNATURE",
-        `cert[${i}] (${chain[i].subject}) signature does not verify against issuer cert[${i + 1}]`
-      );
-    }
-  }
-  const root = chain[chain.length - 1];
-  if (now < root.notBefore) {
-    throw err(
-      "PCK_CHAIN_SIGNATURE",
-      `root cert (${root.subject}) is not yet valid (notBefore=${root.notBefore.toISOString()})`
-    );
-  }
-  if (now > root.notAfter) {
-    throw err(
-      "PCK_CHAIN_SIGNATURE",
-      `root cert (${root.subject}) has expired (notAfter=${root.notAfter.toISOString()})`
-    );
-  }
-  let rootOk;
-  try {
-    rootOk = await root.verify({ publicKey: root.publicKey });
-  } catch (e) {
-    throw err(
-      "PCK_CHAIN_SIGNATURE",
-      `root cert (${root.subject}) self-signature verification threw: ${e}`
-    );
-  }
-  if (!rootOk) {
-    throw err("PCK_CHAIN_SIGNATURE", `root cert (${root.subject}) is not self-signed`);
-  }
-  for (let i = 1; i < chain.length; i++) {
-    const bc = chain[i].getExtension(x509.BasicConstraintsExtension);
-    if (!bc || !bc.ca) {
-      throw err(
-        "PCK_CHAIN_SIGNATURE",
-        `cert[${i}] (${chain[i].subject}) is not a CA cert (BasicConstraints.cA is not true)`
-      );
-    }
-  }
-}
-async function leafSpki(leaf) {
-  const key = await leaf.publicKey.export();
-  const spki = await crypto.subtle.exportKey("spki", key);
-  return new Uint8Array(spki);
-}
-function rawXyToSpki(xy) {
-  if (xy.length !== 64) {
-    throw err("QUOTE_STRUCTURE", `attestation pubkey must be 64 bytes (got ${xy.length})`);
-  }
-  const uncompressed = new Uint8Array(65);
-  uncompressed[0] = 4;
-  uncompressed.set(xy, 1);
-  const prefix = new Uint8Array([
-    48,
-    89,
-    48,
-    19,
-    6,
-    7,
-    42,
-    134,
-    72,
-    206,
-    61,
-    2,
-    1,
-    6,
-    8,
-    42,
-    134,
-    72,
-    206,
-    61,
-    3,
-    1,
-    7,
-    3,
-    66,
-    0
-  ]);
-  return concat(prefix, uncompressed);
-}
-async function verifyP256Signature(spki, rsSig, data, failureReason, what) {
-  if (rsSig.length !== 64) {
-    throw err(failureReason, `${what}: signature must be 64 bytes (r||s)`);
-  }
-  let key;
-  try {
-    key = await crypto.subtle.importKey(
-      "spki",
-      spki,
-      { name: "ECDSA", namedCurve: "P-256" },
-      false,
-      ["verify"]
-    );
-  } catch (e) {
-    throw err(failureReason, `${what}: failed to import key: ${e}`);
-  }
-  const ok = await crypto.subtle.verify(
-    { name: "ECDSA", hash: "SHA-256" },
-    key,
-    rsSig,
-    data
-  );
-  if (!ok) {
-    throw err(failureReason, `${what}: ECDSA verification failed`);
-  }
-}
-async function sha256(data) {
-  return new Uint8Array(await crypto.subtle.digest("SHA-256", data));
-}
-async function sha256Hex(data) {
-  return bytesToHex(await sha256(data));
-}
-function readU16LE(buf, off) {
-  return buf[off] | buf[off + 1] << 8;
-}
-function readU32LE(buf, off) {
-  return (buf[off] | buf[off + 1] << 8 | buf[off + 2] << 16 | buf[off + 3] << 24) >>> 0;
-}
-function constantTimeEq(a, b) {
-  if (a.length !== b.length) return false;
-  let diff = 0;
-  for (let i = 0; i < a.length; i++) diff |= a[i] ^ b[i];
-  return diff === 0;
-}
-function concat(a, b) {
-  const out = new Uint8Array(a.length + b.length);
-  out.set(a, 0);
-  out.set(b, a.length);
-  return out;
-}
-function bytesToHex(b) {
-  let s = "";
-  for (let i = 0; i < b.length; i++) s += b[i].toString(16).padStart(2, "0");
-  return s;
-}
-
-export { INTEL_SGX_ROOT_CA_FINGERPRINT_SHA256, assertAttestResponse, verifyAttestation };
-//# sourceMappingURL=chunk-DIA6U2CV.js.map
-//# sourceMappingURL=chunk-DIA6U2CV.js.map