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

package/lib/browser/client/utils/attestor-pool.js

@@ -0,0 +1,24 @@
+import { AttestorClient } from "../../client/utils/client-socket.js";
+const POOL = {};
+function getAttestorClientFromPool(url, getCreateOpts = () => ({})) {
+  const key = url.toString();
+  let client = POOL[key];
+  let createReason;
+  if (client?.isClosed) {
+    createReason = "closed";
+  } else if (!client) {
+    createReason = "non-existent";
+  }
+  if (createReason) {
+    const createOpts = getCreateOpts();
+    createOpts?.logger?.info(
+      { key, createReason },
+      "creating new client"
+    );
+    client = POOL[key] = new AttestorClient({ ...createOpts, url });
+  }
+  return client;
+}
+export {
+  getAttestorClientFromPool
+};

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

@@ -0,0 +1,11 @@
+import type { InitResponse } from '#src/proto/api.ts';
+import type { IAttestorClient, IAttestorClientCreateOpts, RPCRequestData, RPCResponseData, RPCType } from '#src/types/index.ts';
+import { AttestorSocket } from '#src/utils/socket-base.ts';
+export declare class AttestorClient extends AttestorSocket implements IAttestorClient {
+    private waitForInitPromise;
+    initResponse?: InitResponse;
+    constructor({ url, initMessages, signatureType, logger, authRequest, makeWebSocket }: IAttestorClientCreateOpts);
+    rpc<T extends RPCType>(type: T, request: Partial<RPCRequestData<T>>, timeoutMs?: number): Promise<Exclude<import("#src/proto/api.ts").RPCMessage[`${T}Response`], undefined>>;
+    waitForResponse<T extends RPCType>(id: number, timeoutMs?: number): Promise<RPCResponseData<T>>;
+    waitForInit: () => Promise<void>;
+}

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

@@ -0,0 +1,120 @@
+import { encodeBase64 } from "ethers";
+import { DEFAULT_METADATA, DEFAULT_RPC_TIMEOUT_MS } from "../../config/index.js";
+import { RPCMessages } from "../../proto/api.js";
+import { AttestorError, generateRpcMessageId, getRpcRequestType, logger as LOGGER, packRpcMessages } from "../../utils/index.js";
+import { AttestorSocket } from "../../utils/socket-base.js";
+import { makeWebSocket as defaultMakeWebSocket } from "../../utils/ws.js";
+class AttestorClient extends AttestorSocket {
+  waitForInitPromise;
+  initResponse;
+  constructor({
+    url,
+    initMessages = [],
+    signatureType = DEFAULT_METADATA.signatureType,
+    logger = LOGGER,
+    authRequest,
+    makeWebSocket = defaultMakeWebSocket
+  }) {
+    const initRequest = {
+      ...DEFAULT_METADATA,
+      signatureType,
+      auth: authRequest
+    };
+    const msg = packRpcMessages({ initRequest }, ...initMessages);
+    const initRequestBytes = RPCMessages.encode(msg).finish();
+    const initRequestB64 = encodeBase64(initRequestBytes);
+    url = new URL(url.toString());
+    url.searchParams.set("messages", initRequestB64);
+    super(
+      makeWebSocket(url),
+      initRequest,
+      logger
+    );
+    const initReqId = msg.messages[0].id;
+    this.waitForInitPromise = this.waitForResponse(initReqId, DEFAULT_RPC_TIMEOUT_MS).then((res) => {
+      logger.info("client initialised");
+      this.isInitialised = true;
+      this.initResponse = res;
+    });
+    this.waitForInitPromise.catch(() => {
+    });
+    this.addEventListener("connection-terminated", (ev) => logger.info({ err: ev.data }, "connection terminated"));
+  }
+  async rpc(type, request, timeoutMs = DEFAULT_RPC_TIMEOUT_MS) {
+    const msgId = generateRpcMessageId();
+    this.logger.debug({ type, id: msgId }, "sending rpc request");
+    const now = Date.now();
+    try {
+      const rslt = this.waitForResponse(msgId, timeoutMs);
+      await this.sendMessage({ id: msgId, [getRpcRequestType(type)]: request });
+      return await rslt;
+    } finally {
+      const timeTakenMs = Date.now() - now;
+      this.logger.debug({ type, timeTakenMs }, "received rpc response");
+    }
+  }
+  waitForResponse(id, timeoutMs = DEFAULT_RPC_TIMEOUT_MS) {
+    if (this.isClosed) {
+      throw new AttestorError(
+        "ERROR_NETWORK_ERROR",
+        "Client connection already closed"
+      );
+    }
+    return new Promise((resolve, reject) => {
+      const handler = (event) => {
+        if (event.data.id !== id) {
+          return;
+        }
+        removeHandlers();
+        if ("error" in event.data) {
+          reject(event.data.error);
+          return;
+        }
+        resolve(event.data.data);
+      };
+      const terminateHandler = (event) => {
+        removeHandlers();
+        if (event.data.code === "ERROR_NO_ERROR") {
+          reject(
+            new AttestorError(
+              "ERROR_NETWORK_ERROR",
+              event.data.message,
+              event.data.data
+            )
+          );
+          return;
+        }
+        reject(event.data);
+      };
+      const timeout = setTimeout(() => {
+        removeHandlers();
+        reject(
+          new AttestorError(
+            "ERROR_TIMEOUT",
+            `RPC request timed out after ${timeoutMs}ms`,
+            { id }
+          )
+        );
+      }, timeoutMs);
+      const removeHandlers = () => {
+        clearTimeout(timeout);
+        this.removeEventListener("rpc-response", handler);
+        this.removeEventListener("connection-terminated", terminateHandler);
+      };
+      this.addEventListener("rpc-response", handler);
+      this.addEventListener("connection-terminated", terminateHandler);
+    });
+  }
+  waitForInit = () => {
+    if (this.isClosed) {
+      throw new AttestorError(
+        "ERROR_NETWORK_ERROR",
+        "Client connection already closed"
+      );
+    }
+    return this.waitForInitPromise;
+  };
+}
+export {
+  AttestorClient
+};

package/lib/browser/client/utils/message-handler.d.ts

@@ -0,0 +1,4 @@
+import type { RPCMessage } from '#src/proto/api.ts';
+import type { IAttestorSocket } from '#src/types/index.ts';
+export declare function wsMessageHandler(this: IAttestorSocket, data: unknown): Promise<void>;
+export declare function handleMessage(this: IAttestorSocket, msg: RPCMessage): Promise<void> | undefined;

package/lib/browser/client/utils/message-handler.js

@@ -0,0 +1,97 @@
+import { RPCMessages } from "../../proto/api.js";
+import { AttestorError, extractArrayBufferFromWsData, getRpcRequest, getRpcRequestType, getRpcResponseType } from "../../utils/index.js";
+async function wsMessageHandler(data) {
+  const buff = await extractArrayBufferFromWsData(data);
+  const { messages } = RPCMessages.decode(buff);
+  for (const msg of messages) {
+    await handleMessage.call(this, msg);
+  }
+}
+function handleMessage(msg) {
+  this.logger?.trace({ msg }, "received message");
+  if (msg.connectionTerminationAlert) {
+    const err = AttestorError.fromProto(
+      msg.connectionTerminationAlert
+    );
+    this.logger?.warn(
+      {
+        err: err.code !== "ERROR_NO_ERROR" ? err : void 0
+      },
+      "received connection termination alert"
+    );
+    this.dispatchRPCEvent("connection-terminated", err);
+    return;
+  }
+  const rpcRequest = getRpcRequest(msg);
+  if (rpcRequest) {
+    if (rpcRequest.direction === "response" && rpcRequest.type === "error") {
+      this.dispatchRPCEvent("rpc-response", {
+        id: msg.id,
+        error: AttestorError.fromProto(msg.requestError)
+      });
+      return;
+    }
+    const resType = getRpcResponseType(rpcRequest.type);
+    if (rpcRequest.direction === "response") {
+      this.dispatchRPCEvent("rpc-response", {
+        id: msg.id,
+        type: rpcRequest.type,
+        data: msg[resType]
+      });
+      return;
+    }
+    if (!this.isInitialised && rpcRequest.type !== "init") {
+      this.logger.warn(
+        { type: rpcRequest.type },
+        "RPC request received before initialisation"
+      );
+      void this.sendMessage({
+        id: msg.id,
+        requestError: AttestorError.badRequest("Initialise connection first").toProto()
+      });
+      return;
+    }
+    return new Promise((resolve, reject) => {
+      this.dispatchRPCEvent("rpc-request", {
+        requestId: msg.id,
+        type: rpcRequest.type,
+        data: msg[getRpcRequestType(rpcRequest.type)],
+        respond: (res) => {
+          if (!this.isOpen) {
+            this.logger?.debug(
+              { type: rpcRequest.type, res },
+              "connection closed before responding"
+            );
+            reject(new Error("connection closed"));
+            return;
+          }
+          if ("code" in res) {
+            reject(res);
+            return this.sendMessage({
+              id: msg.id,
+              requestError: res.toProto()
+            });
+          }
+          resolve();
+          return this.sendMessage({ id: msg.id, [resType]: res });
+        }
+      });
+    });
+  }
+  if (msg.tunnelMessage) {
+    this.dispatchRPCEvent("tunnel-message", msg.tunnelMessage);
+    return;
+  }
+  if (msg.tunnelDisconnectEvent) {
+    this.dispatchRPCEvent(
+      "tunnel-disconnect-event",
+      msg.tunnelDisconnectEvent
+    );
+    return;
+  }
+  this.logger.warn({ msg }, "unhandled message");
+}
+export {
+  handleMessage,
+  wsMessageHandler
+};

package/lib/browser/config/index.d.ts

@@ -0,0 +1,31 @@
+import type { InitRequest } from '#src/proto/api.ts';
+export declare const DEFAULT_ZK_CONCURRENCY = 10;
+export declare const RECLAIM_USER_AGENT = "reclaim/0.0.1";
+export declare const DEFAULT_HTTPS_PORT = 443;
+export declare const WS_PATHNAME = "/ws";
+export declare const BROWSER_RPC_PATHNAME = "/browser-rpc";
+export declare const ATTESTOR_ADDRESS_PATHNAME = "/address";
+export declare const DEFAULT_REMOTE_FILE_FETCH_BASE_URL = "/browser-rpc/resources";
+export declare const API_SERVER_PORT = 8001;
+export declare const CONNECTION_TIMEOUT_MS = 10000;
+export declare const DNS_SERVERS: string[];
+export declare const MAX_CLAIM_TIMESTAMP_DIFF_S: number;
+export declare const CURRENT_ATTESTOR_VERSION: 5;
+export declare const DEFAULT_METADATA: InitRequest;
+export declare const PROVIDER_CTX: {
+    version: 5;
+};
+export declare const PING_INTERVAL_MS = 10000;
+/**
+ * Maximum interval in seconds to wait for before assuming
+ * the connection is dead
+ * @default 30s
+ */
+export declare const MAX_NO_DATA_INTERVAL_MS = 30000;
+export declare const MAX_PAYLOAD_SIZE: number;
+export declare const DEFAULT_AUTH_EXPIRY_S: number;
+export declare const DEFAULT_RPC_TIMEOUT_MS = 90000;
+export declare const TOPRF_DOMAIN_SEPARATOR = "reclaim-toprf";
+export declare const MAX_CERT_SIZE_BYTES: number;
+export declare const CERT_ALLOWED_MIMETYPES: string[];
+export declare const BGP_WS_URL = "wss://ris-live.ripe.net/v1/ws/?client=reclaim-hijack-detector";

package/lib/browser/config/index.js

@@ -0,0 +1,62 @@
+import { AttestorVersion, ServiceSignatureType } from "../proto/api.js";
+const DEFAULT_ZK_CONCURRENCY = 10;
+const RECLAIM_USER_AGENT = "reclaim/0.0.1";
+const DEFAULT_HTTPS_PORT = 443;
+const WS_PATHNAME = "/ws";
+const BROWSER_RPC_PATHNAME = "/browser-rpc";
+const ATTESTOR_ADDRESS_PATHNAME = "/address";
+const DEFAULT_REMOTE_FILE_FETCH_BASE_URL = `${BROWSER_RPC_PATHNAME}/resources`;
+const API_SERVER_PORT = 8001;
+const CONNECTION_TIMEOUT_MS = 1e4;
+const DNS_SERVERS = [
+  "8.8.8.8",
+  "8.8.4.4"
+];
+const MAX_CLAIM_TIMESTAMP_DIFF_S = 10 * 60;
+const CURRENT_ATTESTOR_VERSION = AttestorVersion.ATTESTOR_VERSION_3_0_0;
+const DEFAULT_METADATA = {
+  signatureType: ServiceSignatureType.SERVICE_SIGNATURE_TYPE_ETH,
+  clientVersion: CURRENT_ATTESTOR_VERSION,
+  auth: void 0
+};
+const PROVIDER_CTX = { version: CURRENT_ATTESTOR_VERSION };
+const PING_INTERVAL_MS = 1e4;
+const MAX_NO_DATA_INTERVAL_MS = 3e4;
+const MAX_PAYLOAD_SIZE = 512 * 1024 * 1024;
+const DEFAULT_AUTH_EXPIRY_S = 15 * 60;
+const DEFAULT_RPC_TIMEOUT_MS = 9e4;
+const TOPRF_DOMAIN_SEPARATOR = "reclaim-toprf";
+const MAX_CERT_SIZE_BYTES = 10 * 1024 * 1024 * 1024;
+const CERT_ALLOWED_MIMETYPES = [
+  "application/x-x509-ca-cert",
+  "application/x-x509-user-cert",
+  "application/pkix-cert",
+  "application/pkcs7-mime",
+  "application/octet-stream"
+];
+const BGP_WS_URL = "wss://ris-live.ripe.net/v1/ws/?client=reclaim-hijack-detector";
+export {
+  API_SERVER_PORT,
+  ATTESTOR_ADDRESS_PATHNAME,
+  BGP_WS_URL,
+  BROWSER_RPC_PATHNAME,
+  CERT_ALLOWED_MIMETYPES,
+  CONNECTION_TIMEOUT_MS,
+  CURRENT_ATTESTOR_VERSION,
+  DEFAULT_AUTH_EXPIRY_S,
+  DEFAULT_HTTPS_PORT,
+  DEFAULT_METADATA,
+  DEFAULT_REMOTE_FILE_FETCH_BASE_URL,
+  DEFAULT_RPC_TIMEOUT_MS,
+  DEFAULT_ZK_CONCURRENCY,
+  DNS_SERVERS,
+  MAX_CERT_SIZE_BYTES,
+  MAX_CLAIM_TIMESTAMP_DIFF_S,
+  MAX_NO_DATA_INTERVAL_MS,
+  MAX_PAYLOAD_SIZE,
+  PING_INTERVAL_MS,
+  PROVIDER_CTX,
+  RECLAIM_USER_AGENT,
+  TOPRF_DOMAIN_SEPARATOR,
+  WS_PATHNAME
+};

package/lib/browser/external-rpc/benchmark.d.ts

@@ -0,0 +1 @@
+export declare function benchmark(): Promise<string>;

package/lib/browser/external-rpc/benchmark.js

@@ -0,0 +1,82 @@
+import {
+  crypto,
+  encryptWrappedRecord,
+  SUPPORTED_CIPHER_SUITE_MAP
+} from "../utils/tls-imports.js";
+import { strToUint8Array } from "../utils/generics.js";
+import { logger } from "../utils/logger.js";
+import { makeZkProofGenerator } from "../utils/zk.js";
+const ZK_CIPHER_SUITES = [
+  "TLS_CHACHA20_POLY1305_SHA256",
+  "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
+  "TLS_AES_128_GCM_SHA256"
+];
+async function benchmark() {
+  let benchmarkRes = "";
+  for (const cipherSuite of ZK_CIPHER_SUITES) {
+    const now = Date.now();
+    const alg = cipherSuite.includes("CHACHA20") ? "CHACHA20-POLY1305" : cipherSuite.includes("AES_256_GCM") ? "AES-256-GCM" : "AES-128-GCM";
+    const keylength = alg === "AES-128-GCM" ? 16 : 32;
+    const key = Buffer.alloc(keylength, 0);
+    const {
+      ivLength: fixedIvLength
+    } = SUPPORTED_CIPHER_SUITE_MAP[cipherSuite];
+    const fixedIv = Buffer.alloc(fixedIvLength, 0);
+    const encKey = await crypto.importKey(alg, key);
+    const vectors = [
+      {
+        plaintext: `My cool API secret is "my name jeff". Please don't reveal it`
+      }
+    ];
+    const proofGenerator = await makeZkProofGenerator({
+      logger,
+      cipherSuite
+    });
+    for (const { plaintext } of vectors) {
+      const plaintextArr = strToUint8Array(plaintext);
+      const { ciphertext, iv } = await encryptWrappedRecord(
+        plaintextArr,
+        {
+          key: encKey,
+          iv: fixedIv,
+          recordNumber: 0,
+          recordHeaderOpts: {
+            type: "WRAPPED_RECORD"
+          },
+          cipherSuite,
+          version: cipherSuite.includes("ECDHE_") ? "TLS1_2" : "TLS1_3"
+        }
+      );
+      const packet = {
+        type: "ciphertext",
+        encKey,
+        iv,
+        recordNumber: 0,
+        plaintext: plaintextArr,
+        ciphertext,
+        fixedIv: new Uint8Array(0),
+        data: ciphertext
+      };
+      await proofGenerator.addPacketToProve(
+        packet,
+        {
+          type: "zk",
+          redactedPlaintext: plaintextArr
+        },
+        () => {
+        },
+        () => {
+          throw new Error("should not be called in benchmark");
+        }
+      );
+      await proofGenerator.generateProofs();
+    }
+    benchmarkRes = benchmarkRes + `Benchmark ${alg} ok. Took ${Date.now() - now} ms 
+`;
+  }
+  logger.info(benchmarkRes);
+  return benchmarkRes;
+}
+export {
+  benchmark
+};

package/lib/browser/external-rpc/event-bus.d.ts

@@ -0,0 +1,7 @@
+type EventHandlerFn<T> = (data: T) => void;
+export declare class EventBus<T> {
+    #private;
+    addListener(fn: EventHandlerFn<T>): () => void;
+    dispatch(data: T): void;
+}
+export {};

package/lib/browser/external-rpc/event-bus.js

@@ -0,0 +1,17 @@
+class EventBus {
+  #listeners = [];
+  addListener(fn) {
+    this.#listeners.push(fn);
+    return () => {
+      this.#listeners = this.#listeners.filter((l) => l !== fn);
+    };
+  }
+  dispatch(data) {
+    for (const listener of this.#listeners) {
+      listener(data);
+    }
+  }
+}
+export {
+  EventBus
+};

package/lib/browser/external-rpc/handle-incoming-msg.d.ts

@@ -0,0 +1,2 @@
+import type { ExternalRPCIncomingMsg } from '#src/external-rpc/types.ts';
+export declare function handleIncomingMessage(data: string | ExternalRPCIncomingMsg): Promise<void>;