@cryptforge/key-exchange 0.1.0

package/dist/electron-main.mjs

@@ -0,0 +1,768 @@
+// src/types/messages.ts
+var MESSAGES = {
+  enableBroadcast: "admin:broadcast:enable",
+  connect: "client:topic:connect",
+  onClientConnection: "admin:topic:connected",
+  requestKeystore: "client:keystore:request",
+  onKeystoreRequestInvalidPIN: "admin:pin:invalid",
+  onKeystoreRequestValidPIN: "admin:pin:valid",
+  onKeystoreRequest: "admin:request:received",
+  approveRequest: "admin:request:approve",
+  onClientApproval: "client:request:approved",
+  denyRequest: "admin:request:deny",
+  onClientDenial: "client:request:denied",
+  onCompletion: "server:link:complete",
+  disableBroadcast: "admin:broadcast:disable",
+  onBroadcastDisable: "client:broadcast:disabled",
+  getDeviceInfo: "client:request:deviceInfo",
+  getHostname: "client:request:hostname",
+  // Presence/Network messages
+  connectPresence: "network:connect",
+  broadcastClientState: "network:broadcast",
+  onClientStateRequest: "network:request",
+  onClientStateUpdate: "network:update"
+};
+
+// src/electron/main/setupExhangeHandlers.ts
+import { ipcMain } from "electron";
+
+// src/useNetworkPresenceServer.ts
+import Hyperswarm from "hyperswarm";
+import b4a from "b4a";
+function useNetworkPresence(onUpdate, onRequest) {
+  const deviceIDs = /* @__PURE__ */ new Map();
+  const swarm = new Hyperswarm();
+  swarm.on("connection", (connection) => {
+    const name = b4a.toString(connection.remotePublicKey, "hex");
+    console.log("Presence: * got a connection from:", name, "*");
+    connections.push(connection);
+    sendStateRequestMessage(connection);
+    connection.once("close", () => {
+      console.log(
+        `Presence: Connection closed.  Removing connection ${b4a.toString(
+          connection.remotePublicKey,
+          "hex"
+        )}`
+      );
+      connections.splice(connections.indexOf(connection), 1);
+      const id = deviceIDs.get(b4a.toString(connection.remotePublicKey, "hex"));
+      if (id) {
+        broadcastStatusMessage(id, "unknown");
+      }
+      deviceIDs.delete(b4a.toString(connection.remotePublicKey, "hex"));
+    });
+    connection.on("data", (data) => {
+      let parsedData;
+      try {
+        parsedData = JSON.parse(data);
+      } catch (error) {
+        console.error("Error parsing data:", error);
+        return;
+      }
+      const header = parsedData;
+      console.log(
+        "Presence: got data for ",
+        connection.publicKey.toString("hex")
+      );
+      if (header.type === "update") {
+        const payload = parsedData;
+        onUpdate({ id: payload.id, state: payload.state });
+        deviceIDs.set(
+          b4a.toString(connection.remotePublicKey, "hex"),
+          payload.id
+        );
+      } else if (header.type === "request") {
+        onRequest();
+      }
+    });
+    connection.on("error", (error) => {
+      console.error(
+        `Presence: Connection error on connection ${b4a.toString(
+          connection.remotePublicKey,
+          "hex"
+        )}: ${error}`
+      );
+    });
+  });
+  const connections = [];
+  const connect = async (topic, id) => {
+    console.log("Presence: connecting to topic: ", topic);
+    const key = b4a.from(topic, "hex");
+    console.log("key: ", key);
+    const discovery = swarm.join(key, { client: true, server: true });
+    console.log("got discovery:  ");
+    const publicKey = b4a.toString(
+      discovery.swarm.keyPair?.publicKey || discovery.swarm.publicKey || Buffer.alloc(32),
+      "hex"
+    );
+    console.log("Presence: public key is ", publicKey);
+    deviceIDs.set(publicKey, id);
+    discovery.flushed().then(() => {
+      console.log("Presence: joined topic:", b4a.toString(key, "hex"));
+    });
+  };
+  const sendStateRequestMessage = async (connection) => {
+    const message = {
+      type: "request"
+    };
+    const payload = JSON.stringify(message);
+    console.log(
+      "sending state request message to: ",
+      connection.publicKey.toString("hex")
+    );
+    connection.write(payload);
+  };
+  const receiveStatusMessage = async (id, state) => {
+    return broadcastStatusMessage(id, state);
+  };
+  const broadcastStatusMessage = (id, state) => {
+    console.log(`server got connection state message for ${id}: `, state);
+    const message = {
+      type: "update",
+      id,
+      state
+    };
+    console.log("active connections: ", connections.length);
+    const payload = JSON.stringify(message);
+    for (const connection of connections) {
+      console.log("sending message to: ", connection.publicKey.toString("hex"));
+      connection.write(payload);
+    }
+    onUpdate(message);
+  };
+  return {
+    connect,
+    receiveStatusMessage
+  };
+}
+
+// src/client/useKeyExchangeClient.ts
+import DHT from "hyperdht";
+import b4a3 from "b4a";
+
+// src/server/messages.ts
+import b4a2 from "b4a";
+var syncSetupEventRoutes = {
+  onClientConnection: MESSAGES.onClientConnection,
+  onKeystoreRequest: MESSAGES.onKeystoreRequest,
+  onClientApproval: MESSAGES.onClientApproval,
+  onClientDenial: MESSAGES.onClientDenial,
+  onCompletion: MESSAGES.onCompletion,
+  onBroadcastDisable: MESSAGES.onBroadcastDisable,
+  onKeystoreRequestInvalidPIN: MESSAGES.onKeystoreRequestInvalidPIN,
+  onKeystoreRequestValidPIN: MESSAGES.onKeystoreRequestValidPIN
+};
+var requestHeaders = [
+  {
+    code: 1e3,
+    name: "Request PIN",
+    description: "The Client is asking the Server to show UI of a PIN screen for the user to enter on the Client"
+  },
+  {
+    code: 2e3,
+    name: "Request Keystore",
+    description: "The Client is asking the Server to show UI for the user to approve or reject the request"
+  }
+];
+var sendRequest = async (options) => {
+  const index = requestHeaders.findIndex(
+    (response) => response.name === options.header
+  );
+  if (index !== -1) {
+    const header = requestHeaders[index];
+    const body = options.body();
+    const request = {
+      header,
+      body
+    };
+    const payload = JSON.stringify(request);
+    for (const socket of options.to) {
+      console.log(
+        `hyperswarm: sending ${header.name} to connection ${b4a2.toString(
+          socket.remotePublicKey,
+          "hex"
+        )}`
+      );
+      socket.write(payload);
+    }
+  } else {
+    console.log(`Request with name \`${options.header}\` not found`);
+  }
+};
+var responseHeaders = [
+  {
+    code: 1501,
+    name: "Connection Failure: Broadcast disabled",
+    type: "Failure"
+  },
+  { code: 2200, name: "Authentication Succeeded", type: "Success" },
+  { code: 2400, name: "Authentication Error: Invalid PIN", type: "Error" },
+  { code: 3200, name: "Transmition Succeeded: Approved", type: "Success" },
+  { code: 3201, name: "Transmition Succeeded: Rejected", type: "Success" },
+  { code: 4200, name: "Setup Succeeded", type: "Success" }
+];
+var sendResponse = (options) => {
+  const index = responseHeaders.findIndex(
+    (response) => response.name === options.header
+  );
+  if (index !== -1) {
+    const header = responseHeaders[index];
+    const data = options.body();
+    const response = {
+      header,
+      body: data
+    };
+    const payload = JSON.stringify(response);
+    for (const socket of options.to) {
+      console.log(
+        `hyperswarm: sending ${header.name} to connection ${b4a2.toString(
+          socket.remotePublicKey,
+          "hex"
+        )}`
+      );
+      socket.write(payload);
+    }
+  } else {
+    console.log(`Response with name \`${options.header}\` not found`);
+  }
+};
+
+// src/client/useKeyExchangeClient.ts
+function useKeyExchangeClient(onEvent) {
+  let socket;
+  let deviceName;
+  let appName;
+  const connect = async (options) => {
+    deviceName = options.name;
+    appName = options.app;
+    return new Promise((resolve) => {
+      console.log(`client: connecting to server on ${options.key}`);
+      const publicKey = b4a3.from(options.key, "hex");
+      const dht = new DHT();
+      socket = dht.connect(publicKey);
+      socket.once("open", () => {
+        const name = b4a3.toString(socket.remotePublicKey, "hex");
+        console.log(`client: got a connection on ${name}`);
+        resolve();
+      });
+      socket.on("data", (data) => {
+        parseResponse(data);
+      });
+      socket.on("error", (error) => {
+        onConnectionError(error);
+      });
+    });
+  };
+  const parseResponse = async (data) => {
+    console.log(`client: got data: ${data}`);
+    const parsedData = JSON.parse(data);
+    const payload = parsedData;
+    console.log("payload");
+    console.log(payload);
+    switch (payload.header.name) {
+      case "Connection Failure: Broadcast disabled":
+        onEvent({
+          route: syncSetupEventRoutes["onBroadcastDisable"],
+          data: {}
+        });
+        break;
+      case "Transmition Succeeded: Approved":
+        const identity = payload.body.identity;
+        const appId = payload.body.appId;
+        onEvent({
+          route: syncSetupEventRoutes["onClientApproval"],
+          data: { identity, appId }
+        });
+        break;
+      case "Transmition Succeeded: Rejected":
+        onEvent({ route: syncSetupEventRoutes["onClientDenial"], data: {} });
+        break;
+      case "Setup Succeeded":
+        onEvent({ route: syncSetupEventRoutes["onCompletion"], data: {} });
+        break;
+      case "Authentication Error: Invalid PIN":
+        onEvent({
+          route: syncSetupEventRoutes["onKeystoreRequestInvalidPIN"],
+          data: {
+            reason: "Invalid PIN Entered"
+          }
+        });
+        break;
+      case "Authentication Succeeded":
+        onEvent({
+          route: syncSetupEventRoutes["onKeystoreRequestValidPIN"],
+          data: {}
+        });
+        break;
+      default:
+        console.error(`error: response ${payload} not handled in client`);
+        break;
+    }
+  };
+  const onConnectionError = async (error) => {
+    console.log(`client: Connection error: ${error}`);
+    const route = syncSetupEventRoutes["onBroadcastDisable"];
+    switch (error.code) {
+      case "PEER_NOT_FOUND":
+        onEvent({
+          route,
+          data: {
+            title: "Peer Not Found",
+            description: "Another device with the specified broadcast key could not be located."
+          }
+        });
+        break;
+      default:
+        onEvent({
+          route,
+          data: {
+            title: "Client Disconnected",
+            description: "The connection to your other device was lost.  Please ensure you have another device that is broadcasting"
+          }
+        });
+        break;
+    }
+  };
+  const requestPIN = async () => {
+    await sendRequest({
+      to: [socket],
+      header: "Request PIN",
+      body: () => {
+        return { deviceName, appName };
+      }
+    });
+  };
+  const requestKeystore = async (pin) => {
+    await sendRequest({
+      to: [socket],
+      header: "Request Keystore",
+      body: () => {
+        return {
+          pin
+        };
+      }
+    });
+    const route = syncSetupEventRoutes["onKeystoreRequest"];
+    onEvent({ route, data: {} });
+  };
+  return {
+    connect,
+    requestPIN,
+    requestKeystore
+  };
+}
+
+// src/server/useKeyExchangeServer.ts
+import DHT2 from "hyperdht";
+import b4a4 from "b4a";
+function useKeyExchangeServer(onEvent) {
+  let client;
+  let dht;
+  const keyPair = DHT2.keyPair();
+  const getKey = () => {
+    return b4a4.toString(keyPair.publicKey, "hex");
+  };
+  const generateRandomPIN = () => {
+    return Math.floor(1e5 + Math.random() * 9e5);
+  };
+  const pin = generateRandomPIN();
+  const getPIN = () => {
+    return `${pin}`;
+  };
+  let server;
+  const createServer = async () => {
+    dht = new DHT2();
+    server = await dht.createServer((socket) => {
+      const name = b4a4.toString(socket.remotePublicKey, "hex");
+      console.log(`server: got a connection on \`${name}\``);
+      socket.on("data", (data) => {
+        parseRequest(data);
+      });
+      socket.on("error", (error) => {
+        onConnectionError(error);
+      });
+      client = socket;
+    });
+  };
+  const parseRequest = (data) => {
+    console.log(`server: got data: ${data}`);
+    const parsedData = JSON.parse(data);
+    const payload = parsedData;
+    console.log("payload");
+    console.log(payload);
+    switch (payload.header.name) {
+      case "Request PIN":
+        onRequestPin(payload.body);
+        break;
+      case "Request Keystore":
+        onRequestKeystore(payload.body);
+        break;
+    }
+  };
+  const onConnectionError = (error) => {
+    console.log(`server: Connection error: ${error}`);
+  };
+  const onRequestPin = (body) => {
+    const route = syncSetupEventRoutes["onClientConnection"];
+    onEvent({
+      route,
+      data: {
+        pin: getPIN(),
+        name: body.deviceName,
+        app: body.appName
+      }
+    });
+  };
+  const onRequestKeystore = (body) => {
+    const pin2 = body.pin;
+    if (pin2 !== getPIN()) {
+      sendResponse({
+        to: [client],
+        header: "Authentication Error: Invalid PIN",
+        body: () => {
+          return {};
+        }
+      });
+      return;
+    } else {
+      sendResponse({
+        to: [client],
+        header: "Authentication Succeeded",
+        body: () => {
+          return {};
+        }
+      });
+    }
+    const route = syncSetupEventRoutes["onKeystoreRequest"];
+    onEvent({
+      route,
+      data: {}
+    });
+  };
+  const onRequestDenied = () => {
+    const route = syncSetupEventRoutes["onClientDenial"];
+    onEvent({ route, data: {} });
+  };
+  const onSetupComplete = () => {
+    const route = syncSetupEventRoutes["onCompletion"];
+    onEvent({ route, data: {} });
+  };
+  const beginBroadcast = async () => {
+    await createServer();
+    await server.listen(keyPair);
+    await server.refresh();
+    console.log(`server: opened connection to ${getKey()}`);
+  };
+  const endBroadcast = async () => {
+    if (server) {
+      await server.close();
+      console.log(`server: closed connection to ${getKey()}`);
+    }
+    if (dht) {
+      await dht.destroy();
+      console.log(`server: destroyed dht`);
+    }
+  };
+  const approveRequest = async (identity, appId) => {
+    sendResponse({
+      to: [client],
+      header: "Transmition Succeeded: Approved",
+      body: () => {
+        return {
+          identity,
+          appId
+        };
+      }
+    });
+  };
+  const completeSetupSuccess = async () => {
+    console.log("sending compltion message to client");
+    sendResponse({
+      to: [client],
+      header: "Setup Succeeded",
+      body: () => {
+        return {};
+      }
+    });
+    onSetupComplete();
+  };
+  const rejectRequest = async () => {
+    sendResponse({
+      to: [client],
+      header: "Transmition Succeeded: Rejected",
+      body: () => {
+        return {};
+      }
+    });
+    onRequestDenied();
+  };
+  const broadcastDisabled = async () => {
+    if (client) {
+      sendResponse({
+        to: [client],
+        header: "Connection Failure: Broadcast disabled",
+        body: () => {
+          return {};
+        }
+      });
+    }
+  };
+  return {
+    getKey,
+    getPIN,
+    beginBroadcast,
+    endBroadcast,
+    approveRequest,
+    completeSetupSuccess,
+    rejectRequest,
+    broadcastDisabled
+  };
+}
+
+// src/CoreTransportLogic.ts
+import crypto from "crypto";
+import os from "os";
+import si from "systeminformation";
+var CoreTransportLogic = class {
+  syncServer;
+  syncClient;
+  presence;
+  deviceInfo = null;
+  handleEvent;
+  presenceConnected = false;
+  constructor(handleEvent = () => {
+  }) {
+    this.handleEvent = handleEvent;
+    this.syncServer = useKeyExchangeServer(this.handleEvent);
+    this.syncClient = useKeyExchangeClient(this.handleEvent);
+    this.presence = useNetworkPresence(
+      this.onStateUpdate.bind(this),
+      this.onStateRequest.bind(this)
+    );
+    this.initializeDeviceInfo();
+  }
+  async initializeDeviceInfo() {
+    this.deviceInfo = await this.getDeviceInfo();
+  }
+  onStateUpdate(response) {
+    console.log("received state message for:", response.id);
+    this.handleEvent({ route: MESSAGES.onClientStateUpdate, data: response });
+  }
+  onStateRequest() {
+    console.log("received state request");
+    this.handleEvent({ route: MESSAGES.onClientStateRequest, data: {} });
+  }
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  // Sync methods
+  async enableBroadcast() {
+    console.log(`admin: enabled broadcast`);
+    try {
+      await this.syncServer.beginBroadcast();
+      return this.syncServer.getKey();
+    } catch (error) {
+      const code = error && typeof error === "object" && "code" in error ? error.code : "UNKNOWN";
+      console.error("Error on broadcast enable during topic sync setup:", code);
+      if (code === "ALREADY_LISTENING") {
+        return this.syncServer.getKey();
+      }
+      throw error;
+    }
+  }
+  async connect(topic, name, app) {
+    console.log(`client: requested connection to ${topic}`);
+    try {
+      await this.syncClient.connect({ key: topic, name, app });
+      await this.syncClient.requestPIN();
+    } catch (error) {
+      console.error("Error on topic connect during sync setup:", error);
+      throw error;
+    }
+  }
+  async requestKeystore(pin) {
+    console.log(`client: requested keystore using pin \`${pin}\``);
+    try {
+      await this.syncClient.requestKeystore(pin);
+    } catch (error) {
+      console.error("Error on keystore request during sync setup:", error);
+      throw error;
+    }
+  }
+  async approveRequest(data) {
+    console.log(`admin: request approved`);
+    try {
+      await this.syncServer.approveRequest(data.identity, data.appId);
+      await this.delay(3e3);
+      await this.syncServer.completeSetupSuccess();
+    } catch (error) {
+      console.error("Error on request approve during sync setup:", error);
+      throw error;
+    }
+  }
+  async denyRequest() {
+    console.log(`admin: request denied`);
+    try {
+      await this.syncServer.rejectRequest();
+    } catch (error) {
+      console.error("Error on request deny during sync setup:", error);
+      throw error;
+    }
+  }
+  async disableBroadcast() {
+    try {
+      await this.syncServer.endBroadcast();
+      await this.syncServer.broadcastDisabled();
+    } catch (error) {
+      console.error("Error on broadcast disable during sync setup:", error);
+      throw error;
+    }
+  }
+  // Device methods
+  async getDeviceInfo() {
+    if (this.deviceInfo) {
+      return this.deviceInfo;
+    }
+    const hostname = os.hostname();
+    const osInfo = await si.osInfo();
+    const uuid = await si.uuid();
+    const serial = osInfo.serial;
+    const distro = osInfo.distro;
+    const arch = osInfo.arch;
+    const hardwareUUID = uuid.hardware;
+    const key = serial + distro + arch + hardwareUUID;
+    const hash = crypto.createHash("sha256").update(key).digest("hex");
+    return { id: hash, name: hostname };
+  }
+  async getHostname() {
+    return os.hostname();
+  }
+  // Network methods
+  async connectPresence(topic) {
+    if (this.presenceConnected) {
+      console.log("Presence already connected, skipping");
+      return;
+    }
+    const deviceInfo = await this.getDeviceInfo();
+    const topicHash = crypto.createHash("sha256").update(topic).digest("hex");
+    console.log(`Connecting presence network to topic: ${topicHash}`);
+    await this.presence.connect(topicHash, deviceInfo.id);
+    this.presenceConnected = true;
+  }
+  broadcastClientState(id, state) {
+    this.presence.receiveStatusMessage(id, state);
+  }
+};
+
+// src/electron/main/keyTransportMain.ts
+import { BrowserWindow } from "electron";
+var KeyTransportMain = class {
+  core;
+  peers = /* @__PURE__ */ new Map();
+  constructor() {
+    this.core = new CoreTransportLogic(this.handleEvent.bind(this));
+  }
+  /**
+   * Electron-specific event routing via IPC
+   */
+  handleEvent = (options) => {
+    console.log(
+      `received event with route: \`${options.route}\` data:`,
+      options.data
+    );
+    const allWindows = BrowserWindow.getAllWindows();
+    allWindows.forEach((window) => {
+      window.webContents.send(options.route, options.data);
+    });
+  };
+  // Sync namespace - delegate to core for logic, no-ops for callbacks
+  enableBroadcast = () => this.core.enableBroadcast();
+  connect = (topic, name, app) => this.core.connect(topic, name, app);
+  onClientConnection = async (_callback) => {
+  };
+  requestKeystore = (pin) => this.core.requestKeystore(pin);
+  onKeystoreRequestInvalidPIN = async (_callback) => {
+  };
+  onKeystoreRequestValidPIN = async (_callback) => {
+  };
+  onKeystoreRequest = async (_callback) => {
+  };
+  approveRequest = (data) => this.core.approveRequest(data);
+  onClientApproval = async (_callback) => {
+  };
+  denyRequest = () => this.core.denyRequest();
+  onClientDenial = async (_callback) => {
+  };
+  onCompletion = async (_callback) => {
+  };
+  disableBroadcast = () => this.core.disableBroadcast();
+  onBroadcastDisable = async (_callback) => {
+  };
+  getDeviceInfo = () => this.core.getDeviceInfo();
+  getHostname = () => this.core.getHostname();
+  connectPresence = async (topic) => {
+    return this.core.connectPresence(topic);
+  };
+  broadcastClientState = async (id, state) => {
+    this.peers.set(id, state);
+    this.core.broadcastClientState(id, state);
+  };
+  onClientStateRequest = async (_callback) => {
+  };
+  onClientStateUpdate = async (_callback) => {
+  };
+  getPeerState = (id) => {
+    return this.peers.get(id);
+  };
+  getAllPeers = () => {
+    return this.peers;
+  };
+};
+
+// src/electron/main/setupExhangeHandlers.ts
+var setupKeyExchangeHandlers = () => {
+  const transport = new KeyTransportMain();
+  ipcMain.handle(MESSAGES.enableBroadcast, async () => {
+    return transport.enableBroadcast();
+  });
+  ipcMain.handle(
+    MESSAGES.connect,
+    async (_event, topic, name, app) => {
+      return transport.connect(topic, name, app);
+    }
+  );
+  ipcMain.handle(MESSAGES.requestKeystore, async (_event, pin) => {
+    return transport.requestKeystore(pin);
+  });
+  ipcMain.handle(
+    MESSAGES.approveRequest,
+    async (_event, data) => {
+      return transport.approveRequest(data);
+    }
+  );
+  ipcMain.handle(MESSAGES.denyRequest, async () => {
+    return transport.denyRequest();
+  });
+  ipcMain.handle(MESSAGES.disableBroadcast, async () => {
+    return transport.disableBroadcast();
+  });
+  ipcMain.handle(MESSAGES.getDeviceInfo, async () => {
+    return transport.getDeviceInfo();
+  });
+  ipcMain.handle(MESSAGES.getHostname, async () => {
+    return transport.getHostname();
+  });
+  ipcMain.handle(MESSAGES.connectPresence, async (_event, topic) => {
+    return transport.connectPresence(topic);
+  });
+  ipcMain.handle(
+    MESSAGES.broadcastClientState,
+    async (_event, id, state) => {
+      return transport.broadcastClientState(id, state);
+    }
+  );
+};
+export {
+  CoreTransportLogic,
+  setupKeyExchangeHandlers
+};