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

package/lib/server/utils/assert-valid-claim-request.js

@@ -1,200 +1,354 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertValidClaimRequest = assertValidClaimRequest;
-exports.assertValidProviderTranscript = assertValidProviderTranscript;
-exports.assertTranscriptsMatch = assertTranscriptsMatch;
-exports.decryptTranscript = decryptTranscript;
-exports.getWithoutHeader = getWithoutHeader;
-const tls_1 = require("@reclaimprotocol/tls");
-const api_1 = require("../../proto/api");
-const providers_1 = require("../../providers");
-const generics_1 = require("../../server/utils/generics");
-const process_handshake_1 = require("../../server/utils/process-handshake");
-const utils_1 = require("../../utils");
-const signatures_1 = require("../../utils/signatures");
-/**
- * Asserts that the claim request is valid.
- *
- * 1. We begin by verifying the signature of the claim request.
- * 2. Next, we produce the transcript of the TLS exchange
- * from the proofs provided by the client.
- * 3. We then pull the provider the client is trying to claim
- * from
- * 4. We then use the provider's verification function to verify
- *  whether the claim is valid.
- *
- * If any of these steps fail, we throw an error.
- */
+import { areUint8ArraysEqual, concatenateUint8Arrays } from "@reclaimprotocol/tls";
+import { ClaimTunnelRequest, TranscriptMessageSenderType } from "../../proto/api.js";
+import { providers } from "../../providers/index.js";
+import { niceParseJsonObject } from "../../server/utils/generics.js";
+import { computeOPRFRaw } from "../../server/utils/oprf-raw.js";
+import { processHandshake } from "../../server/utils/process-handshake.js";
+import { assertValidateProviderParams } from "../../server/utils/validation.js";
+import {
+  AttestorError,
+  binaryHashToStr,
+  canonicalStringify,
+  decryptDirect,
+  extractApplicationDataFromTranscript,
+  hashProviderParams,
+  SIGNATURES,
+  verifyZkPacket
+} from "../../utils/index.js";
+import { getEngineString } from "../../utils/zk.js";
 async function assertValidClaimRequest(request, metadata, logger) {
-    var _a;
-    const { data, signatures: { requestSignature } = {}, zkEngine, fixedServerIV, fixedClientIV } = request;
-    if (!data) {
-        throw new utils_1.AttestorError('ERROR_INVALID_CLAIM', 'No info provided on claim request');
-    }
-    if (!(requestSignature === null || requestSignature === void 0 ? void 0 : requestSignature.length)) {
-        throw new utils_1.AttestorError('ERROR_INVALID_CLAIM', 'No signature provided on claim request');
-    }
-    // verify request signature
-    const serialisedReq = api_1.ClaimTunnelRequest
-        .encode({ ...request, signatures: undefined })
-        .finish();
-    const { verify: verifySig } = signatures_1.SIGNATURES[metadata.signatureType];
-    const verified = await verifySig(serialisedReq, requestSignature, data.owner);
-    if (!verified) {
-        throw new utils_1.AttestorError('ERROR_INVALID_CLAIM', 'Invalid signature on claim request');
-    }
-    const receipt = await decryptTranscript(request.transcript, logger, zkEngine === api_1.ZKProofEngine.ZK_ENGINE_GNARK ? 'gnark' : 'snarkjs', fixedServerIV, fixedClientIV);
-    const reqHost = (_a = request.request) === null || _a === void 0 ? void 0 : _a.host;
-    if (receipt.hostname !== reqHost) {
-        throw new Error(`Expected server name ${reqHost}, got ${receipt.hostname}`);
-    }
-    // get all application data messages
-    const applData = (0, utils_1.extractApplicationDataFromTranscript)(receipt);
-    const newData = await assertValidProviderTranscript(applData, data, logger, { version: metadata.clientVersion });
-    if (newData !== data) {
-        logger.info({ newData }, 'updated claim info');
-    }
-    return newData;
+  const {
+    data,
+    signatures: { requestSignature } = {},
+    zkEngine,
+    fixedServerIV,
+    fixedClientIV
+  } = request;
+  if (!data) {
+    throw new AttestorError(
+      "ERROR_INVALID_CLAIM",
+      "No info provided on claim request"
+    );
+  }
+  if (!requestSignature?.length) {
+    throw new AttestorError(
+      "ERROR_INVALID_CLAIM",
+      "No signature provided on claim request"
+    );
+  }
+  const serialisedReq = ClaimTunnelRequest.encode({ ...request, signatures: void 0 }).finish();
+  const { verify: verifySig } = SIGNATURES[metadata.signatureType];
+  const verified = await verifySig(serialisedReq, requestSignature, data.owner);
+  if (!verified) {
+    throw new AttestorError(
+      "ERROR_INVALID_CLAIM",
+      "Invalid signature on claim request"
+    );
+  }
+  const receipt = await decryptTranscript(
+    request.transcript,
+    logger,
+    getEngineString(zkEngine),
+    fixedServerIV,
+    fixedClientIV
+  );
+  const reqHost = request.request?.host;
+  if (receipt.hostname !== reqHost) {
+    throw new Error(
+      `Expected server name ${reqHost}, got ${receipt.hostname}`
+    );
+  }
+  const applData = extractApplicationDataFromTranscript(receipt);
+  const newData = await assertValidProviderTranscript(
+    applData,
+    data,
+    logger,
+    { version: metadata.clientVersion },
+    receipt.oprfRawReplacements
+  );
+  if (newData !== data) {
+    logger.info({ newData }, "updated claim info");
+  }
+  return newData;
 }
-/**
- * Verify that the transcript contains a valid claim
- * for the provider.
- */
-async function assertValidProviderTranscript(applData, info, logger, providerCtx) {
-    var _a;
-    const providerName = info.provider;
-    const provider = providers_1.providers[providerName];
-    if (!provider) {
-        throw new utils_1.AttestorError('ERROR_INVALID_CLAIM', `Unsupported provider: ${providerName}`);
-    }
-    const params = (0, generics_1.niceParseJsonObject)(info.parameters, 'params');
-    const ctx = (0, generics_1.niceParseJsonObject)(info.context, 'context');
-    (0, utils_1.assertValidateProviderParams)(providerName, params);
-    const rslt = await provider.assertValidProviderReceipt({
-        receipt: applData,
-        params,
-        logger,
-        ctx: providerCtx
-    });
-    ctx.providerHash = (0, utils_1.hashProviderParams)(params);
-    const extractedParameters = (rslt === null || rslt === void 0 ? void 0 : rslt.extractedParameters) || {};
-    if (Object.keys(extractedParameters).length) {
-        ctx.extractedParameters = extractedParameters;
+async function assertValidProviderTranscript(applData, info, logger, providerCtx, oprfRawReplacements) {
+  const providerName = info.provider;
+  const provider = providers[providerName];
+  if (!provider) {
+    throw new AttestorError(
+      "ERROR_INVALID_CLAIM",
+      `Unsupported provider: ${providerName}`
+    );
+  }
+  let params = niceParseJsonObject(info.parameters, "params");
+  const ctx = niceParseJsonObject(info.context, "context");
+  if (oprfRawReplacements?.length) {
+    let strParams = canonicalStringify(params) ?? "{}";
+    for (const { originalText, nullifierText } of oprfRawReplacements) {
+      strParams = strParams.replaceAll(originalText, nullifierText);
     }
-    info.context = (_a = (0, utils_1.canonicalStringify)(ctx)) !== null && _a !== void 0 ? _a : '';
-    return info;
+    params = JSON.parse(strParams);
+    info.parameters = strParams;
+    logger.debug(
+      { replacements: oprfRawReplacements.length },
+      "applied oprf-raw parameter replacements"
+    );
+  }
+  assertValidateProviderParams(providerName, params);
+  const rslt = await provider.assertValidProviderReceipt({
+    receipt: applData,
+    params,
+    logger,
+    ctx: providerCtx
+  });
+  ctx.providerHash = hashProviderParams(params);
+  const extractedParameters = rslt?.extractedParameters || {};
+  if (Object.keys(extractedParameters).length) {
+    ctx.extractedParameters = extractedParameters;
+  }
+  info.context = canonicalStringify(ctx) ?? "";
+  return info;
 }
-/**
- * Verify that the transcript provided by the client
- * matches the transcript of the tunnel, the server
- * has created.
- */
 function assertTranscriptsMatch(clientTranscript, tunnelTranscript) {
-    const clientSends = (0, tls_1.concatenateUint8Arrays)(clientTranscript
-        .filter(m => m.sender === api_1.TranscriptMessageSenderType.TRANSCRIPT_MESSAGE_SENDER_TYPE_CLIENT)
-        .map(m => m.message));
-    const tunnelSends = (0, tls_1.concatenateUint8Arrays)(tunnelTranscript
-        .filter(m => m.sender === 'client')
-        .map(m => m.message));
-    if (!(0, tls_1.areUint8ArraysEqual)(clientSends, tunnelSends)) {
-        throw utils_1.AttestorError.badRequest('Outgoing messages from client do not match the tunnel transcript');
-    }
-    const clientRecvs = (0, tls_1.concatenateUint8Arrays)(clientTranscript
-        .filter(m => m.sender === api_1.TranscriptMessageSenderType.TRANSCRIPT_MESSAGE_SENDER_TYPE_SERVER)
-        .map(m => m.message));
-    const tunnelRecvs = (0, tls_1.concatenateUint8Arrays)(tunnelTranscript
-        .filter(m => m.sender === 'server')
-        .map(m => m.message))
-        // We only need to compare the first N messages
-        // that the client claims to have received
-        // the rest are not relevant -- so even if they're
-        // not present in the tunnel transcript, it's fine
-        .slice(0, clientRecvs.length);
-    if (!(0, tls_1.areUint8ArraysEqual)(clientRecvs, tunnelRecvs)) {
-        throw utils_1.AttestorError.badRequest('Incoming messages from server do not match the tunnel transcript');
-    }
+  const clientSends = concatenateUint8Arrays(
+    clientTranscript.filter((m) => m.sender === TranscriptMessageSenderType.TRANSCRIPT_MESSAGE_SENDER_TYPE_CLIENT).map((m) => m.message)
+  );
+  const tunnelSends = concatenateUint8Arrays(
+    tunnelTranscript.filter((m) => m.sender === "client").map((m) => m.message)
+  );
+  if (!areUint8ArraysEqual(clientSends, tunnelSends)) {
+    throw AttestorError.badRequest(
+      "Outgoing messages from client do not match the tunnel transcript"
+    );
+  }
+  const clientRecvs = concatenateUint8Arrays(
+    clientTranscript.filter((m) => m.sender === TranscriptMessageSenderType.TRANSCRIPT_MESSAGE_SENDER_TYPE_SERVER).map((m) => m.message)
+  );
+  const tunnelRecvs = concatenateUint8Arrays(
+    tunnelTranscript.filter((m) => m.sender === "server").map((m) => m.message)
+  ).slice(0, clientRecvs.length);
+  if (!areUint8ArraysEqual(clientRecvs, tunnelRecvs)) {
+    throw AttestorError.badRequest(
+      "Incoming messages from server do not match the tunnel transcript"
+    );
+  }
 }
 async function decryptTranscript(transcript, logger, zkEngine, serverIV, clientIV) {
-    const { tlsVersion, cipherSuite, hostname, nextMsgIndex } = await (0, process_handshake_1.processHandshake)(transcript, logger);
-    let clientRecordNumber = tlsVersion === 'TLS1_3' ? -1 : 0; // TLS 1.3 has already one record encrypted at this point
-    let serverRecordNumber = clientRecordNumber;
-    transcript = transcript.slice(nextMsgIndex);
-    const decryptedTranscript = [];
-    for (const [i, { sender, message, reveal: { zkReveal, directReveal } = {} }] of transcript.entries()) {
-        //start with first message after last handshake message
-        await getDecryptedMessage(sender, message, directReveal, zkReveal, i);
+  const {
+    tlsVersion,
+    cipherSuite,
+    hostname,
+    nextMsgIndex
+  } = await processHandshake(transcript, logger);
+  let clientRecordNumber = tlsVersion === "TLS1_3" ? -1 : 0;
+  let serverRecordNumber = clientRecordNumber;
+  transcript = transcript.slice(nextMsgIndex);
+  const overshotMap = {};
+  const decryptedTranscript = [];
+  const oprfRawReplacements = [];
+  const pendingOprfRaw = {};
+  for (const [i, {
+    sender,
+    message,
+    reveal: { zkReveal, directReveal } = {}
+  }] of transcript.entries()) {
+    try {
+      await decryptMessage(sender, message, directReveal, zkReveal, i);
+    } catch (error) {
+      const err = new AttestorError(
+        "ERROR_INVALID_CLAIM",
+        `error in handling packet at idx ${i}: ${error}`,
+        { packetIdx: i, error }
+      );
+      if (error.stack) {
+        err.stack = error.stack;
+      }
+      throw err;
     }
-    return {
-        transcript: decryptedTranscript,
-        hostname: hostname,
-        tlsVersion: tlsVersion,
-    };
-    async function getDecryptedMessage(sender, message, directReveal, zkReveal, i) {
-        var _a, _b;
-        try {
-            const isServer = sender === api_1.TranscriptMessageSenderType
-                .TRANSCRIPT_MESSAGE_SENDER_TYPE_SERVER;
-            const recordHeader = message.slice(0, 5);
-            const content = getWithoutHeader(message);
-            if (isServer) {
-                serverRecordNumber++;
-            }
-            else {
-                clientRecordNumber++;
-            }
-            let redacted = true;
-            let plaintext = undefined;
-            let plaintextLength;
-            if ((_a = directReveal === null || directReveal === void 0 ? void 0 : directReveal.key) === null || _a === void 0 ? void 0 : _a.length) {
-                const result = await (0, utils_1.decryptDirect)(directReveal, cipherSuite, recordHeader, tlsVersion, content);
-                plaintext = result.plaintext;
-                redacted = false;
-                plaintextLength = plaintext.length;
-            }
-            else if ((_b = zkReveal === null || zkReveal === void 0 ? void 0 : zkReveal.proofs) === null || _b === void 0 ? void 0 : _b.length) {
-                const result = await (0, utils_1.verifyZkPacket)({
-                    ciphertext: content,
-                    zkReveal,
-                    logger,
-                    cipherSuite,
-                    zkEngine: zkEngine,
-                    iv: sender === api_1.TranscriptMessageSenderType
-                        .TRANSCRIPT_MESSAGE_SENDER_TYPE_SERVER
-                        ? serverIV
-                        : clientIV,
-                    recordNumber: isServer
-                        ? serverRecordNumber
-                        : clientRecordNumber
-                });
-                plaintext = result.redactedPlaintext;
-                redacted = false;
-                plaintextLength = plaintext.length;
-            }
-            else {
-                plaintext = content;
-                plaintextLength = plaintext.length;
+  }
+  const remainingPending = Object.keys(pendingOprfRaw);
+  if (remainingPending.length) {
+    throw new AttestorError(
+      "ERROR_INVALID_CLAIM",
+      `oprf-raw cross-block markers incomplete: pending for packets ${remainingPending.join(", ")}`
+    );
+  }
+  return {
+    transcript: decryptedTranscript,
+    hostname,
+    tlsVersion,
+    oprfRawReplacements: oprfRawReplacements.length ? oprfRawReplacements : void 0
+  };
+  async function decryptMessage(sender, message, directReveal, zkReveal, i) {
+    const isServer = sender === TranscriptMessageSenderType.TRANSCRIPT_MESSAGE_SENDER_TYPE_SERVER;
+    const recordHeader = message.slice(0, 5);
+    const content = getWithoutHeader(message);
+    if (isServer) {
+      serverRecordNumber++;
+    } else {
+      clientRecordNumber++;
+    }
+    let redacted = true;
+    let plaintext = void 0;
+    let plaintextLength;
+    if (directReveal?.key?.length) {
+      const result = await decryptDirect(
+        directReveal,
+        cipherSuite,
+        recordHeader,
+        tlsVersion,
+        content
+      );
+      plaintext = result.plaintext;
+      redacted = false;
+      plaintextLength = plaintext.length;
+    } else if (zkReveal?.proofs?.length) {
+      const iv = sender === TranscriptMessageSenderType.TRANSCRIPT_MESSAGE_SENDER_TYPE_SERVER ? serverIV : clientIV;
+      const recordNumber = isServer ? serverRecordNumber : clientRecordNumber;
+      const result = await verifyZkPacket(
+        {
+          ciphertext: content,
+          zkReveal,
+          iv,
+          recordNumber,
+          toprfOvershotNullifier: overshotMap[i]?.data,
+          getNextPacket(overshot) {
+            const nextIdx = transcript.findIndex((t, j) => t.sender === sender && j > i);
+            if (nextIdx < 0) {
+              return;
             }
-            decryptedTranscript.push({
-                sender: sender === api_1.TranscriptMessageSenderType
-                    .TRANSCRIPT_MESSAGE_SENDER_TYPE_CLIENT
-                    ? 'client'
-                    : 'server',
-                redacted,
-                message: plaintext,
-                recordHeader,
-                plaintextLength,
-            });
+            overshotMap[nextIdx] = { data: overshot };
+            return getWithoutHeader(transcript[nextIdx].message);
+          },
+          logger,
+          cipherSuite,
+          zkEngine
+        }
+      );
+      plaintext = result.redactedPlaintext;
+      const pendingForThis = pendingOprfRaw[i];
+      if (pendingForThis && zkReveal?.overshotOprfRawLength) {
+        const overshootLen = zkReveal.overshotOprfRawLength;
+        const overshootData = plaintext.slice(0, overshootLen);
+        const fullData = concatenateUint8Arrays([
+          pendingForThis.partialData,
+          overshootData
+        ]);
+        const expectedLen = pendingForThis.dataLocation.length;
+        if (fullData.length !== expectedLen) {
+          throw new AttestorError(
+            "ERROR_INVALID_CLAIM",
+            `oprf-raw cross-block length mismatch: got ${fullData.length}, expected ${expectedLen}`
+          );
+        }
+        const oprfResults = await computeOPRFRaw(
+          fullData,
+          [{ dataLocation: { fromIndex: 0, length: fullData.length } }],
+          logger
+        );
+        if (oprfResults.length) {
+          const { nullifier } = oprfResults[0];
+          const originalText = new TextDecoder().decode(fullData);
+          const nullifierStr = binaryHashToStr(nullifier, fullData.length);
+          oprfRawReplacements.push({ originalText, nullifierText: nullifierStr });
+          const nullifierBytes = new TextEncoder().encode(nullifierStr);
+          const overshootNullifier = nullifierBytes.slice(pendingForThis.partialData.length);
+          plaintext.set(overshootNullifier, 0);
+          const prevPkt = decryptedTranscript[pendingForThis.originPktIdx];
+          if (prevPkt) {
+            const firstPartNullifier = nullifierBytes.slice(0, pendingForThis.partialData.length);
+            prevPkt.message.set(firstPartNullifier, pendingForThis.dataLocation.fromIndex);
+          }
+        }
+        delete pendingOprfRaw[i];
+      }
+      if (result.oprfRawMarkers?.length) {
+        const { markersThisPacket, pendingMarker } = separateOprfRawMarkers(
+          result.oprfRawMarkers,
+          plaintext.length,
+          () => transcript.findIndex((t, j) => t.sender === sender && j > i),
+          decryptedTranscript.length,
+          logger
+        );
+        if (pendingMarker) {
+          pendingMarker.pending.partialData.set(
+            plaintext.slice(pendingMarker.pending.dataLocation.fromIndex)
+          );
+          pendingOprfRaw[pendingMarker.nextIdx] = pendingMarker.pending;
         }
-        catch (error) {
-            throw new utils_1.AttestorError('ERROR_INVALID_CLAIM', `error in handling packet at idx ${i}: ${error}`, {
-                packetIdx: i,
-                error: error,
-            });
+        if (markersThisPacket.length) {
+          const pt = plaintext;
+          const oprfResults = await computeOPRFRaw(pt, markersThisPacket, logger);
+          const originalTexts = oprfResults.map(({ dataLocation }) => new TextDecoder().decode(
+            pt.slice(dataLocation.fromIndex, dataLocation.fromIndex + dataLocation.length)
+          ));
+          for (const [idx, { dataLocation, nullifier }] of oprfResults.entries()) {
+            const originalText = originalTexts[idx];
+            const nullifierStr = binaryHashToStr(nullifier, dataLocation.length);
+            oprfRawReplacements.push({ originalText, nullifierText: nullifierStr });
+            const nullifierBytes = new TextEncoder().encode(nullifierStr);
+            pt.set(nullifierBytes, dataLocation.fromIndex);
+          }
         }
+      }
+      redacted = false;
+      plaintextLength = plaintext.length;
+    } else {
+      plaintext = content;
+      plaintextLength = plaintext.length;
     }
+    decryptedTranscript.push({
+      sender: sender === TranscriptMessageSenderType.TRANSCRIPT_MESSAGE_SENDER_TYPE_CLIENT ? "client" : "server",
+      redacted,
+      message: plaintext,
+      recordHeader,
+      plaintextLength
+    });
+  }
 }
 function getWithoutHeader(message) {
-    // strip the record header (xx 03 03 xx xx)
-    return message.slice(5);
+  return message.slice(5);
+}
+function separateOprfRawMarkers(markers, plaintextLength, findNextPacketIdx, currentTranscriptLength, logger) {
+  const markersThisPacket = [];
+  let pendingMarker;
+  for (const marker of markers) {
+    const dataLocation = marker.dataLocation;
+    if (!dataLocation) {
+      continue;
+    }
+    const { fromIndex, length } = dataLocation;
+    const endInPacket = fromIndex + length;
+    if (endInPacket <= plaintextLength) {
+      markersThisPacket.push({ dataLocation });
+      continue;
+    }
+    const nextIdx = findNextPacketIdx();
+    if (nextIdx < 0) {
+      throw new AttestorError(
+        "ERROR_INVALID_CLAIM",
+        "oprf-raw marker spans packets but no next packet found"
+      );
+    }
+    pendingMarker = {
+      nextIdx,
+      pending: {
+        partialData: new Uint8Array(plaintextLength - fromIndex),
+        dataLocation: { fromIndex, length },
+        originPktIdx: currentTranscriptLength
+      }
+    };
+    logger.debug(
+      { fromIndex, length, partialLen: plaintextLength - fromIndex, nextIdx },
+      "oprf-raw marker spans packets, storing partial data"
+    );
+  }
+  return { markersThisPacket, pendingMarker };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"assert-valid-claim-request.js","sourceRoot":"","sources":["../../../src/server/utils/assert-valid-claim-request.ts"],"names":[],"mappings":"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"}
+export {
+  assertTranscriptsMatch,
+  assertValidClaimRequest,
+  assertValidProviderTranscript,
+  decryptTranscript,
+  getWithoutHeader
+};

package/lib/server/utils/config-env.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const dotenv_1 = require("dotenv");
-const env_1 = require("../../utils/env");
-const nodeEnv = (0, env_1.getEnvVariable)('NODE_ENV') || 'development';
-(0, dotenv_1.config)({ path: `.env.${nodeEnv}` });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLWVudi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zZXJ2ZXIvdXRpbHMvY29uZmlnLWVudi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBLG1DQUErQjtBQUMvQix1Q0FBOEM7QUFFOUMsTUFBTSxPQUFPLEdBQUcsSUFBQSxvQkFBYyxFQUFDLFVBQVUsQ0FBQyxJQUFJLGFBQWEsQ0FBQTtBQUMzRCxJQUFBLGVBQU0sRUFBQyxFQUFFLElBQUksRUFBRSxRQUFRLE9BQU8sRUFBRSxFQUFFLENBQUMsQ0FBQSJ9
+import { config } from "dotenv";
+import { getEnvVariable } from "../../utils/env.js";
+const nodeEnv = getEnvVariable("NODE_ENV") || "development";
+config({ path: `.env.${nodeEnv}` });

package/lib/server/utils/dns.js

@@ -1,22 +1,24 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveHostnames = resolveHostnames;
-const dns_1 = require("dns");
-const config_1 = require("../../config");
+import { resolve, setServers } from "dns";
+import { DNS_SERVERS } from "../../config/index.js";
 setDnsServers();
 async function resolveHostnames(hostname) {
-    return new Promise((_resolve, reject) => {
-        (0, dns_1.resolve)(hostname, (err, addresses) => {
-            if (err) {
-                reject(new Error(`Could not resolve hostname: ${hostname}, ${err.message}`));
-            }
-            else {
-                _resolve(addresses);
-            }
-        });
+  return new Promise((_resolve, reject) => {
+    resolve(hostname, (err, addresses) => {
+      if (err) {
+        reject(
+          new Error(
+            `Could not resolve hostname: ${hostname}, ${err.message}`
+          )
+        );
+      } else {
+        _resolve(addresses);
+      }
     });
+  });
 }
 function setDnsServers() {
-    (0, dns_1.setServers)(config_1.DNS_SERVERS);
+  setServers(DNS_SERVERS);
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG5zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3NlcnZlci91dGlscy9kbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFLQSw0Q0FjQztBQW5CRCw2QkFBeUM7QUFDekMsdUNBQXdDO0FBRXhDLGFBQWEsRUFBRSxDQUFBO0FBRVIsS0FBSyxVQUFVLGdCQUFnQixDQUFDLFFBQWdCO0lBQ3RELE9BQU8sSUFBSSxPQUFPLENBQVcsQ0FBQyxRQUFRLEVBQUUsTUFBTSxFQUFFLEVBQUU7UUFDakQsSUFBQSxhQUFPLEVBQUMsUUFBUSxFQUFFLENBQUMsR0FBRyxFQUFFLFNBQVMsRUFBRSxFQUFFO1lBQ3BDLElBQUcsR0FBRyxFQUFFLENBQUM7Z0JBQ1IsTUFBTSxDQUNMLElBQUksS0FBSyxDQUNSLCtCQUErQixRQUFRLEtBQUssR0FBRyxDQUFDLE9BQU8sRUFBRSxDQUN6RCxDQUNELENBQUE7WUFDRixDQUFDO2lCQUFNLENBQUM7Z0JBQ1AsUUFBUSxDQUFDLFNBQVMsQ0FBQyxDQUFBO1lBQ3BCLENBQUM7UUFDRixDQUFDLENBQUMsQ0FBQTtJQUNILENBQUMsQ0FBQyxDQUFBO0FBQ0gsQ0FBQztBQUVELFNBQVMsYUFBYTtJQUNyQixJQUFBLGdCQUFVLEVBQUMsb0JBQVcsQ0FBQyxDQUFBO0FBQ3hCLENBQUMifQ==
+export {
+  resolveHostnames
+};

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

@@ -0,0 +1,17 @@
+/**
+ * GCP attestation validation utilities
+ * Validates JWT tokens from Google Confidential Computing
+ */
+import type { Logger } from '#src/types/general.ts';
+export interface GcpValidationResult {
+    isValid: boolean;
+    errors: string[];
+    ethAddress?: Uint8Array;
+    userDataType?: string;
+    pcr0?: string;
+    envVars?: Record<string, string>;
+}
+/**
+ * Validates GCP JWT attestation and extracts ETH address
+ */
+export declare function validateGcpAttestationAndExtractKey(attestationBytes: Uint8Array, logger?: Logger): Promise<GcpValidationResult>;