@reclaimprotocol/attestor-core 5.0.1-beta.1 → 5.0.1-beta.3

package/lib/browser/utils/redactions.js

@@ -0,0 +1,135 @@
+import { base64Encode } from "@bufbuild/protobuf/wire";
+import { concatenateUint8Arrays } from "@reclaimprotocol/tls";
+const REDACTION_CHAR = "*";
+const REDACTION_CHAR_CODE = REDACTION_CHAR.charCodeAt(0);
+function isRedactionCongruent(redacted, original) {
+  for (let i = 0; i < redacted.length; i++) {
+    const element = redacted[i];
+    const areSame = element === original[i] || typeof element === "string" && element === REDACTION_CHAR || typeof element === "number" && element === REDACTION_CHAR_CODE;
+    if (!areSame) {
+      return false;
+    }
+  }
+  return true;
+}
+function isFullyRedacted(redacted) {
+  for (const element of redacted) {
+    if (element !== REDACTION_CHAR && element !== REDACTION_CHAR_CODE) {
+      return false;
+    }
+  }
+  return true;
+}
+async function getBlocksToReveal(blocks, redact, performOprf) {
+  const slicesWithReveal = blocks.map((block) => ({
+    block,
+    // copy the plaintext to avoid mutating the original
+    redactedPlaintext: new Uint8Array(block.plaintext)
+  }));
+  const total = concatenateUint8Arrays(blocks.map((b) => b.plaintext));
+  const redactions = redact(total);
+  if (!redactions.length) {
+    return "all";
+  }
+  let blockIdx = 0;
+  let cursorInBlock = 0;
+  let cursor = 0;
+  for (const redaction of redactions) {
+    await redactBlocks(redaction);
+  }
+  return slicesWithReveal.filter((s) => !isFullyRedacted(s.redactedPlaintext));
+  async function redactBlocks(slice) {
+    while (cursor < slice.fromIndex) {
+      advance();
+    }
+    if (slice.hash === "oprf-raw") {
+      const startBlockIdx = blockIdx;
+      const startCursorInBlock = cursorInBlock;
+      const totalLength = slice.toIndex - slice.fromIndex;
+      const block = slicesWithReveal[blockIdx];
+      block.oprfRawMarkers ||= [];
+      block.oprfRawMarkers.push({
+        dataLocation: {
+          fromIndex: startCursorInBlock,
+          length: totalLength
+        }
+      });
+      let overshootLen = 0;
+      while (cursor < slice.toIndex) {
+        if (blockIdx !== startBlockIdx) {
+          overshootLen += 1;
+        }
+        advance();
+      }
+      if (overshootLen) {
+        slicesWithReveal[blockIdx].overshotOprfRawFromPrevBlock = { length: overshootLen };
+      }
+      return;
+    }
+    if (slice.hash) {
+      const plaintext = total.slice(slice.fromIndex, slice.toIndex);
+      const { nullifier, responses, mask } = await performOprf(plaintext);
+      const toprf = {
+        nullifier,
+        responses,
+        dataLocation: {
+          fromIndex: cursorInBlock,
+          length: slice.toIndex - slice.fromIndex
+        },
+        mask,
+        plaintext
+      };
+      const startBlockIdx = blockIdx;
+      const block = slicesWithReveal[blockIdx];
+      block.toprfs ||= [];
+      block.toprfs.push(toprf);
+      const nullifierStr = binaryHashToStr(nullifier, toprf.dataLocation.length);
+      let i = 0;
+      let overshootLen = 0;
+      while (cursor < slice.toIndex) {
+        if (blockIdx !== startBlockIdx) {
+          overshootLen += 1;
+        }
+        slicesWithReveal[blockIdx].redactedPlaintext[cursorInBlock] = nullifierStr.charCodeAt(i);
+        advance();
+        i += 1;
+      }
+      if (overshootLen) {
+        slicesWithReveal[blockIdx].overshotToprfFromPrevBlock = { length: overshootLen };
+      }
+    }
+    while (cursor < slice.toIndex) {
+      slicesWithReveal[blockIdx].redactedPlaintext[cursorInBlock] = REDACTION_CHAR_CODE;
+      advance();
+    }
+  }
+  function advance() {
+    cursor += 1;
+    cursorInBlock += 1;
+    if (cursorInBlock >= blocks[blockIdx].plaintext.length) {
+      blockIdx += 1;
+      cursorInBlock = 0;
+    }
+  }
+}
+function redactSlices(total, slices) {
+  const redacted = new Uint8Array(total);
+  for (const slice of slices) {
+    for (let i = slice.fromIndex; i < slice.toIndex; i++) {
+      redacted[i] = REDACTION_CHAR_CODE;
+    }
+  }
+  return redacted;
+}
+function binaryHashToStr(hash, expLength) {
+  return base64Encode(hash).padEnd(expLength, "0").slice(0, expLength);
+}
+export {
+  REDACTION_CHAR,
+  REDACTION_CHAR_CODE,
+  binaryHashToStr,
+  getBlocksToReveal,
+  isFullyRedacted,
+  isRedactionCongruent,
+  redactSlices
+};

package/lib/browser/utils/retries.d.ts

@@ -0,0 +1,12 @@
+import type { Logger } from '#src/types/index.ts';
+type RetryLoopOptions = {
+    maxRetries?: number;
+    logger: Logger;
+    shouldRetry: (error: Error) => boolean;
+};
+/**
+ * Execute a function, and upon failure -- retry
+ * based on specified options.
+ */
+export declare function executeWithRetries<T>(code: (attempt: number) => Promise<T>, { maxRetries, shouldRetry, logger, }: RetryLoopOptions): Promise<T>;
+export {};

package/lib/browser/utils/retries.js

@@ -0,0 +1,26 @@
+async function executeWithRetries(code, {
+  maxRetries = 3,
+  shouldRetry,
+  logger
+}) {
+  let retries = 0;
+  while (retries < maxRetries) {
+    try {
+      const result = await code(retries);
+      return result;
+    } catch (err) {
+      retries += 1;
+      if (retries >= maxRetries) {
+        throw err;
+      }
+      if (!shouldRetry(err)) {
+        throw err;
+      }
+      logger.info({ err, retries }, "retrying failed operation");
+    }
+  }
+  throw new Error("retries exhausted");
+}
+export {
+  executeWithRetries
+};

package/lib/browser/utils/signatures/eth.d.ts

@@ -0,0 +1,2 @@
+import type { ServiceSignatureProvider } from '#src/types/index.ts';
+export declare const ETH_SIGNATURE_PROVIDER: ServiceSignatureProvider;

package/lib/browser/utils/signatures/eth.js

@@ -0,0 +1,31 @@
+import { computeAddress, getBytes, hexlify, SigningKey, verifyMessage, Wallet } from "ethers";
+const ETH_SIGNATURE_PROVIDER = {
+  getPublicKey(privateKey) {
+    const pub = SigningKey.computePublicKey(privateKey, true);
+    return getBytes(pub);
+  },
+  getAddress(publicKey) {
+    const pubKeyHex = typeof publicKey === "string" ? publicKey : hexlify(publicKey);
+    return computeAddress(pubKeyHex).toLowerCase();
+  },
+  async sign(data, privateKey) {
+    const wallet = getEthWallet(privateKey);
+    const signature = await wallet.signMessage(data);
+    return getBytes(signature);
+  },
+  async verify(data, signature, addressBytes) {
+    const address = typeof addressBytes === "string" ? addressBytes : hexlify(addressBytes);
+    const signatureHex = typeof signature === "string" ? signature : hexlify(signature);
+    const signerAddress = verifyMessage(data, signatureHex);
+    return signerAddress.toLowerCase() === address.toLowerCase();
+  }
+};
+function getEthWallet(privateKey) {
+  if (!privateKey) {
+    throw new Error("Private key missing");
+  }
+  return new Wallet(privateKey);
+}
+export {
+  ETH_SIGNATURE_PROVIDER
+};

package/lib/browser/utils/signatures/index.d.ts

@@ -0,0 +1,5 @@
+import { ServiceSignatureType } from '#src/proto/api.ts';
+import type { ServiceSignatureProvider } from '#src/types/index.ts';
+export declare const SIGNATURES: { [key in ServiceSignatureType]: ServiceSignatureProvider; };
+export declare const SelectedServiceSignatureType: 1;
+export declare const SelectedServiceSignature: ServiceSignatureProvider;

package/lib/browser/utils/signatures/index.js

@@ -0,0 +1,12 @@
+import { ServiceSignatureType } from "../../../proto/api.js";
+import { ETH_SIGNATURE_PROVIDER } from "../../../utils/signatures/eth.js";
+const SIGNATURES = {
+  [ServiceSignatureType.SERVICE_SIGNATURE_TYPE_ETH]: ETH_SIGNATURE_PROVIDER
+};
+const SelectedServiceSignatureType = ServiceSignatureType.SERVICE_SIGNATURE_TYPE_ETH;
+const SelectedServiceSignature = SIGNATURES[SelectedServiceSignatureType];
+export {
+  SIGNATURES,
+  SelectedServiceSignature,
+  SelectedServiceSignatureType
+};

package/lib/browser/utils/socket-base.d.ts

@@ -0,0 +1,23 @@
+import type { WebSocket as WSWebSocket } from 'ws';
+import type { InitRequest, RPCMessage } from '#src/proto/api.ts';
+import { RPCMessages } from '#src/proto/api.ts';
+import type { IAttestorSocket, Logger, RPCEvent, RPCEventMap } from '#src/types/index.ts';
+/**
+ * Common AttestorSocket class used on the client & server side as the
+ * base for their respective socket implementations.
+ */
+export declare class AttestorSocket implements IAttestorSocket {
+    private eventTarget;
+    protected socket: WebSocket | WSWebSocket;
+    readonly logger: Logger;
+    readonly metadata: InitRequest;
+    isInitialised: boolean;
+    constructor(socket: WebSocket | WSWebSocket, metadata: InitRequest, logger: Logger);
+    get isOpen(): boolean;
+    get isClosed(): boolean;
+    sendMessage(...msgs: Partial<RPCMessage>[]): Promise<RPCMessages>;
+    dispatchRPCEvent<K extends keyof RPCEventMap>(type: K, data: RPCEventMap[K]): void;
+    addEventListener<K extends keyof RPCEventMap>(type: K, listener: (data: RPCEvent<K>) => void): void;
+    removeEventListener<K extends keyof RPCEventMap>(type: K, listener: (data: RPCEvent<K>) => void): void;
+    terminateConnection(err?: Error): Promise<void>;
+}

package/lib/browser/utils/socket-base.js

@@ -0,0 +1,96 @@
+import { wsMessageHandler } from "../../client/utils/message-handler.js";
+import { RPCMessages } from "../../proto/api.js";
+import { AttestorError, makeRpcEvent, packRpcMessages } from "../../utils/index.js";
+class AttestorSocket {
+  eventTarget = new EventTarget();
+  socket;
+  logger;
+  metadata;
+  isInitialised = false;
+  constructor(socket, metadata, logger) {
+    this.socket = socket;
+    this.metadata = metadata;
+    this.logger = logger;
+    socket.addEventListener("error", (event) => {
+      const witErr = AttestorError.fromError(
+        event.error || new Error(event.message),
+        "ERROR_NETWORK_ERROR"
+      );
+      this.dispatchRPCEvent("connection-terminated", witErr);
+    });
+    socket.addEventListener("close", () => this.dispatchRPCEvent(
+      "connection-terminated",
+      new AttestorError(
+        "ERROR_NO_ERROR",
+        "connection closed"
+      )
+    ));
+    socket.addEventListener("message", async (event) => {
+      try {
+        await wsMessageHandler.call(this, event.data);
+      } catch (err) {
+        this.logger.error({ err }, "error processing message");
+      }
+    });
+  }
+  get isOpen() {
+    return this.socket.readyState === this.socket.OPEN;
+  }
+  get isClosed() {
+    return this.socket.readyState === this.socket.CLOSED || this.socket.readyState === this.socket.CLOSING;
+  }
+  async sendMessage(...msgs) {
+    if (this.isClosed) {
+      throw new AttestorError(
+        "ERROR_NETWORK_ERROR",
+        "Connection closed, cannot send message"
+      );
+    }
+    if (!this.isOpen) {
+      throw new AttestorError(
+        "ERROR_NETWORK_ERROR",
+        "Wait for connection to open before sending message"
+      );
+    }
+    const msg = packRpcMessages(...msgs);
+    const bytes = RPCMessages.encode(msg).finish();
+    this.logger.trace({ msg }, "sending messages");
+    if ("sendPromise" in this.socket && this.socket.sendPromise) {
+      await this.socket.sendPromise(bytes);
+    } else {
+      this.socket.send(bytes);
+    }
+    return msg;
+  }
+  dispatchRPCEvent(type, data) {
+    const event = makeRpcEvent(type, data);
+    this.eventTarget.dispatchEvent(event);
+  }
+  addEventListener(type, listener) {
+    this.eventTarget.addEventListener(type, listener);
+  }
+  removeEventListener(type, listener) {
+    this.eventTarget.removeEventListener(type, listener);
+  }
+  async terminateConnection(err) {
+    if (this.isClosed) {
+      return;
+    }
+    try {
+      const witErr = err ? AttestorError.fromError(err) : new AttestorError("ERROR_NO_ERROR", "");
+      this.dispatchRPCEvent("connection-terminated", witErr);
+      if (this.isOpen) {
+        await this.sendMessage({
+          connectionTerminationAlert: witErr.toProto()
+        });
+      }
+    } catch (err2) {
+      this.logger?.error({ err: err2 }, "error terminating connection");
+    } finally {
+      this.socket.close();
+    }
+  }
+}
+export {
+  AttestorSocket
+};

package/lib/browser/utils/tls.d.ts

@@ -0,0 +1,2 @@
+import type { TLSConnectionOptions } from '@reclaimprotocol/tls';
+export declare function getDefaultTlsOptions(): TLSConnectionOptions;

package/lib/browser/utils/tls.js

@@ -0,0 +1,58 @@
+import { SUPPORTED_NAMED_CURVES } from "@reclaimprotocol/tls";
+import { detectEnvironment } from "../../utils/env.js";
+const ZK_CIPHER_SUITES = [
+  // chacha-20
+  "TLS_CHACHA20_POLY1305_SHA256",
+  "TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256",
+  "TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256",
+  // aes-256
+  "TLS_AES_256_GCM_SHA384",
+  "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
+  "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384",
+  // aes-128
+  "TLS_AES_128_GCM_SHA256",
+  "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
+  "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
+  "TLS_RSA_WITH_AES_128_GCM_SHA256"
+];
+const NAMED_CURVE_LIST = detectEnvironment() === "node" ? SUPPORTED_NAMED_CURVES : SUPPORTED_NAMED_CURVES.filter((c) => c !== "X25519");
+TLS_ADDITIONAL_ROOT_CA_LIST.push(
+  `-----BEGIN CERTIFICATE-----
+MIIEszCCA5ugAwIBAgIQCyWUIs7ZgSoVoE6ZUooO+jANBgkqhkiG9w0BAQsFADBh
+MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
+d3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBH
+MjAeFw0xNzExMDIxMjI0MzNaFw0yNzExMDIxMjI0MzNaMGAxCzAJBgNVBAYTAlVT
+MRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j
+b20xHzAdBgNVBAMTFlJhcGlkU1NMIFRMUyBSU0EgQ0EgRzEwggEiMA0GCSqGSIb3
+DQEBAQUAA4IBDwAwggEKAoIBAQC/uVklRBI1FuJdUEkFCuDL/I3aJQiaZ6aibRHj
+ap/ap9zy1aYNrphe7YcaNwMoPsZvXDR+hNJOo9gbgOYVTPq8gXc84I75YKOHiVA4
+NrJJQZ6p2sJQyqx60HkEIjzIN+1LQLfXTlpuznToOa1hyTD0yyitFyOYwURM+/CI
+8FNFMpBhw22hpeAQkOOLmsqT5QZJYeik7qlvn8gfD+XdDnk3kkuuu0eG+vuyrSGr
+5uX5LRhFWlv1zFQDch/EKmd163m6z/ycx/qLa9zyvILc7cQpb+k7TLra9WE17YPS
+n9ANjG+ECo9PDW3N9lwhKQCNvw1gGoguyCQu7HE7BnW8eSSFAgMBAAGjggFmMIIB
+YjAdBgNVHQ4EFgQUDNtsgkkPSmcKuBTuesRIUojrVjgwHwYDVR0jBBgwFoAUTiJU
+IBiV5uNu5g/6+rkS7QYXjzkwDgYDVR0PAQH/BAQDAgGGMB0GA1UdJQQWMBQGCCsG
+AQUFBwMBBggrBgEFBQcDAjASBgNVHRMBAf8ECDAGAQH/AgEAMDQGCCsGAQUFBwEB
+BCgwJjAkBggrBgEFBQcwAYYYaHR0cDovL29jc3AuZGlnaWNlcnQuY29tMEIGA1Ud
+HwQ7MDkwN6A1oDOGMWh0dHA6Ly9jcmwzLmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydEds
+b2JhbFJvb3RHMi5jcmwwYwYDVR0gBFwwWjA3BglghkgBhv1sAQEwKjAoBggrBgEF
+BQcCARYcaHR0cHM6Ly93d3cuZGlnaWNlcnQuY29tL0NQUzALBglghkgBhv1sAQIw
+CAYGZ4EMAQIBMAgGBmeBDAECAjANBgkqhkiG9w0BAQsFAAOCAQEAGUSlOb4K3Wtm
+SlbmE50UYBHXM0SKXPqHMzk6XQUpCheF/4qU8aOhajsyRQFDV1ih/uPIg7YHRtFi
+CTq4G+zb43X1T77nJgSOI9pq/TqCwtukZ7u9VLL3JAq3Wdy2moKLvvC8tVmRzkAe
+0xQCkRKIjbBG80MSyDX/R4uYgj6ZiNT/Zg6GI6RofgqgpDdssLc0XIRQEotxIZcK
+zP3pGJ9FCbMHmMLLyuBd+uCWvVcF2ogYAawufChS/PT61D9rqzPRS5I2uqa3tmIT
+44JhJgWhBnFMb7AGQkvNq9KNS9dd3GWc17H/dXa1enoxzWjE0hBdFjxPhUb0W3wi
+8o34/m8Fxw==
+-----END CERTIFICATE-----`
+  //RapidSSL TLS RSA CA G1
+);
+function getDefaultTlsOptions() {
+  return {
+    cipherSuites: ZK_CIPHER_SUITES,
+    namedCurves: NAMED_CURVE_LIST
+  };
+}
+export {
+  getDefaultTlsOptions
+};

package/lib/browser/utils/ws.d.ts

@@ -0,0 +1,7 @@
+import type { WebSocket as WSWebSocket } from 'ws';
+export declare function makeWebSocket(url: string): WebSocket;
+/**
+ * Adds the "sendPromise" fn to the given WebSocket instance,
+ * if not already present.
+ */
+export declare function promisifySend(ws: WSWebSocket): WSWebSocket;

package/lib/browser/utils/ws.js

@@ -0,0 +1,22 @@
+function makeWebSocket(url) {
+  return new WebSocket(url);
+}
+function promisifySend(ws) {
+  if (ws.sendPromise) {
+    return ws;
+  }
+  ws.sendPromise = (data) => new Promise((resolve, reject) => {
+    ws.send(data, (err) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      resolve();
+    });
+  });
+  return ws;
+}
+export {
+  makeWebSocket,
+  promisifySend
+};

package/lib/browser/utils/zk.d.ts

@@ -0,0 +1,71 @@
+import type { CipherSuite } from '@reclaimprotocol/tls';
+import type { EncryptionAlgorithm, OPRFOperator, PrivateInput, PublicInput, ZKEngine, ZKOperator } from '@reclaimprotocol/zk-symmetric-crypto';
+import type { MessageReveal_MessageRevealZk as ZKReveal, MessageReveal_TOPRFProof as TOPRFProof, MessageReveal_ZKProof as ZKProof } from '#src/proto/api.ts';
+import { ZKProofEngine } from '#src/proto/api.ts';
+import type { CompleteTLSPacket, Logger, OPRFOperators, PrepareZKProofsBaseOpts, TOPRFProofParams, ZKOperators, ZKRevealInfo } from '#src/types/index.ts';
+type PrepareZKProofsOpts = {
+    logger?: Logger;
+    cipherSuite: CipherSuite;
+} & PrepareZKProofsBaseOpts;
+type ZKVerifyOpts = {
+    cipherSuite: CipherSuite;
+    ciphertext: Uint8Array;
+    zkReveal: ZKReveal;
+    iv: Uint8Array;
+    recordNumber: number;
+    toprfOvershotNullifier?: Uint8Array;
+    /**
+     * Get the ciphertext of the next packet.
+     * @param overshotNullifier The TOPRF nullifier that overshoots into
+     * the next packet. This should be passed into the verifyZkPacket function
+     * of the next packet.
+     */
+    getNextPacket: (overshotNullifier: Uint8Array) => (Uint8Array | undefined);
+    logger?: Logger;
+    /** get ZK operator for specified algorithm */
+    zkOperators?: ZKOperators;
+    oprfOperators?: OPRFOperators;
+    zkEngine?: ZKEngine;
+};
+type ZKProofToGenerate = {
+    startIdx: number;
+    redactedPlaintext: Uint8Array;
+    privateInput: PrivateInput;
+    publicInput: PublicInput;
+};
+type TOPRFProofToGenerate = {
+    privateInput: PrivateInput;
+    publicInput: PublicInput;
+    toprf: TOPRFProofParams;
+    startIdx: number;
+};
+type ZKPacketToProve = {
+    onGeneratedProofs(proofs: ZKProof[], toprfs: TOPRFProof[]): void;
+    algorithm: EncryptionAlgorithm;
+    proofsToGenerate: ZKProofToGenerate[];
+    toprfsToGenerate: TOPRFProofToGenerate[];
+    iv: Uint8Array;
+};
+export declare function makeZkProofGenerator({ zkOperators, oprfOperators, logger, zkProofConcurrency, cipherSuite, zkEngine }: PrepareZKProofsOpts): Promise<{
+    /**
+     * Adds the given packet to the list of packets to
+     * generate ZK proofs for.
+     *
+     * Call `generateProofs()` to finally generate the proofs
+     */
+    addPacketToProve(packet: CompleteTLSPacket, { redactedPlaintext, toprfs, overshotToprfFromPrevBlock }: ZKRevealInfo, onGeneratedProofs: ZKPacketToProve["onGeneratedProofs"], getNextPacket: () => CompleteTLSPacket | undefined): Promise<void>;
+    getTotalChunksToProve(): number;
+    generateProofs(onChunkDone?: () => void): Promise<void>;
+}>;
+/**
+ * Verify the given ZK proof
+ */
+export declare function verifyZkPacket({ cipherSuite, ciphertext, zkReveal, zkOperators, oprfOperators, logger, zkEngine, iv, recordNumber, toprfOvershotNullifier, getNextPacket }: ZKVerifyOpts): Promise<{
+    redactedPlaintext: Uint8Array<ArrayBuffer>;
+    oprfRawMarkers: import("#src/proto/api.ts").MessageReveal_OPRFRawMarker[];
+}>;
+export declare function makeDefaultZkOperator(algorithm: EncryptionAlgorithm, zkEngine: ZKEngine, logger: Logger): ZKOperator;
+export declare function makeDefaultOPRFOperator(algorithm: EncryptionAlgorithm, zkEngine: ZKEngine, logger: Logger): OPRFOperator;
+export declare function getEngineString(engine: ZKProofEngine): "snarkjs" | "gnark" | "stwo";
+export declare function getEngineProto(engine: ZKEngine): 0 | 1 | 2;
+export {};