ciphermesh 1.0.0

package/src/p2p/PeerConnectionManager.js

@@ -0,0 +1,252 @@
+import WebSocket from 'ws';
+import { EventEmitter } from 'node:events';
+import { PROTOCOL_VERSION, RECONNECT_BASE_MS, RECONNECT_MAX_MS } from '../shared/constants.js';
+
+const HANDSHAKE_TIMEOUT_MS = 10_000;
+
+export class PeerConnectionManager extends EventEmitter {
+  #myNickname;
+  #getPublicKeyB64;
+  #peers; // Map<nickname, { ws, host, port, isOutbound }>
+  #reconnectTimers; // Map<nickname, { timer, delay, host, port }>
+  #pendingOutbound; // Set<nickname>
+  #destroyed;
+
+  constructor(nickname, getPublicKeyB64) {
+    super();
+    this.#myNickname = nickname;
+    this.#getPublicKeyB64 = getPublicKeyB64;
+    this.#peers = new Map();
+    this.#reconnectTimers = new Map();
+    this.#pendingOutbound = new Set();
+    this.#destroyed = false;
+  }
+
+  /**
+   * Deduplication rule: lexicographically smaller nickname initiates.
+   */
+  shouldInitiate(peerNickname) {
+    return this.#myNickname.toLowerCase() < peerNickname.toLowerCase();
+  }
+
+  /**
+   * Connect to a discovered peer (outbound).
+   */
+  connectTo(peerNickname, host, port) {
+    if (this.#peers.has(peerNickname) || this.#pendingOutbound.has(peerNickname)) {
+      return;
+    }
+
+    if (!this.shouldInitiate(peerNickname)) {
+      return; // Wait for inbound from the other side
+    }
+
+    this.#pendingOutbound.add(peerNickname);
+
+    const ws = new WebSocket(`ws://${host}:${port}`);
+
+    const handshakeTimer = setTimeout(() => {
+      ws.close();
+      this.#pendingOutbound.delete(peerNickname);
+    }, HANDSHAKE_TIMEOUT_MS);
+
+    ws.on('open', () => {
+      ws.send(
+        JSON.stringify({
+          type: 'p2p_handshake',
+          nickname: this.#myNickname,
+          publicKey: this.#getPublicKeyB64(),
+          version: PROTOCOL_VERSION,
+          timestamp: Date.now(),
+        }),
+      );
+    });
+
+    let handshakeComplete = false;
+
+    ws.on('message', (data) => {
+      try {
+        const msg = JSON.parse(data.toString('utf-8'));
+
+        if (!handshakeComplete && msg.type === 'p2p_handshake') {
+          clearTimeout(handshakeTimer);
+          handshakeComplete = true;
+          this.#pendingOutbound.delete(peerNickname);
+          this.#clearReconnect(peerNickname); // success resets backoff
+          this.#peers.set(peerNickname, { ws, host, port, isOutbound: true });
+          this.emit('peer-connected', {
+            nickname: msg.nickname,
+            publicKey: msg.publicKey,
+          });
+          return;
+        }
+
+        if (handshakeComplete) {
+          this.emit('message', peerNickname, msg);
+        }
+      } catch {
+        // Ignore malformed messages
+      }
+    });
+
+    ws.on('close', () => {
+      clearTimeout(handshakeTimer);
+      this.#pendingOutbound.delete(peerNickname);
+
+      if (handshakeComplete) {
+        this.#peers.delete(peerNickname);
+        this.emit('peer-disconnected', peerNickname);
+      }
+
+      // Retry with backoff whether or not the handshake ever completed — the
+      // peer may just be starting up. connectTo() no-ops if we already have
+      // the peer or shouldn't initiate to it.
+      this.#scheduleReconnect(peerNickname, host, port);
+    });
+
+    ws.on('error', () => {
+      // Error is followed by 'close'
+    });
+  }
+
+  /**
+   * Accept an inbound connection (from PeerServer).
+   */
+  acceptConnection(ws) {
+    // Send handshake immediately
+    ws.send(
+      JSON.stringify({
+        type: 'p2p_handshake',
+        nickname: this.#myNickname,
+        publicKey: this.#getPublicKeyB64(),
+        version: PROTOCOL_VERSION,
+        timestamp: Date.now(),
+      }),
+    );
+
+    const handshakeTimer = setTimeout(() => {
+      ws.close();
+    }, HANDSHAKE_TIMEOUT_MS);
+
+    let handshakeComplete = false;
+    let peerNickname = null;
+    let isDuplicate = false;
+
+    ws.on('message', (data) => {
+      try {
+        const msg = JSON.parse(data.toString('utf-8'));
+
+        if (!handshakeComplete && msg.type === 'p2p_handshake') {
+          clearTimeout(handshakeTimer);
+          handshakeComplete = true;
+          peerNickname = msg.nickname;
+
+          // Duplicate check — close the newer connection WITHOUT evicting the
+          // existing live one (isDuplicate guards the close handler below).
+          if (this.#peers.has(peerNickname)) {
+            isDuplicate = true;
+            ws.close();
+            return;
+          }
+
+          this.#peers.set(peerNickname, { ws, host: null, port: null, isOutbound: false });
+          this.emit('peer-connected', {
+            nickname: msg.nickname,
+            publicKey: msg.publicKey,
+          });
+          return;
+        }
+
+        if (handshakeComplete && peerNickname) {
+          this.emit('message', peerNickname, msg);
+        }
+      } catch {
+        // Ignore malformed messages
+      }
+    });
+
+    ws.on('close', () => {
+      clearTimeout(handshakeTimer);
+      if (handshakeComplete && peerNickname && !isDuplicate) {
+        this.#peers.delete(peerNickname);
+        this.emit('peer-disconnected', peerNickname);
+      }
+    });
+
+    ws.on('error', () => {
+      // Error triggers close
+    });
+  }
+
+  #scheduleReconnect(nickname, host, port) {
+    if (this.#destroyed) {
+      return;
+    }
+    const existing = this.#reconnectTimers.get(nickname);
+    const delay = existing ? Math.min(existing.delay * 2, RECONNECT_MAX_MS) : RECONNECT_BASE_MS;
+
+    // Keep the entry (with the grown delay) so a subsequent failed attempt
+    // doubles instead of resetting to the base. connectTo() clears it on
+    // success; destroy() clears everything.
+    const timer = setTimeout(() => {
+      this.connectTo(nickname, host, port);
+    }, delay);
+    if (typeof timer.unref === 'function') {
+      timer.unref();
+    }
+
+    this.#reconnectTimers.set(nickname, { timer, delay, host, port });
+  }
+
+  #clearReconnect(nickname) {
+    const entry = this.#reconnectTimers.get(nickname);
+    if (entry) {
+      clearTimeout(entry.timer);
+      this.#reconnectTimers.delete(nickname);
+    }
+  }
+
+  send(nickname, data) {
+    const peer = this.#peers.get(nickname);
+    if (peer && peer.ws.readyState === WebSocket.OPEN) {
+      peer.ws.send(JSON.stringify(data));
+      return true;
+    }
+    return false;
+  }
+
+  broadcast(data) {
+    const json = JSON.stringify(data);
+    for (const [, peer] of this.#peers) {
+      if (peer.ws.readyState === WebSocket.OPEN) {
+        peer.ws.send(json);
+      }
+    }
+  }
+
+  hasPeer(nickname) {
+    return this.#peers.has(nickname);
+  }
+
+  get peerCount() {
+    return this.#peers.size;
+  }
+
+  get peerNicknames() {
+    return [...this.#peers.keys()];
+  }
+
+  destroy() {
+    this.#destroyed = true;
+    for (const [, entry] of this.#reconnectTimers) {
+      clearTimeout(entry.timer);
+    }
+    this.#reconnectTimers.clear();
+    this.#pendingOutbound.clear();
+
+    for (const [, peer] of this.#peers) {
+      peer.ws.close();
+    }
+    this.#peers.clear();
+  }
+}

package/src/p2p/PeerServer.js

@@ -0,0 +1,68 @@
+import { WebSocketServer } from 'ws';
+import { EventEmitter } from 'node:events';
+import { MAX_PAYLOAD_SIZE } from '../shared/constants.js';
+import { createLogger } from '../shared/logger.js';
+
+const log = createLogger('peer-server');
+
+export class PeerServer extends EventEmitter {
+  #wss;
+  #port;
+
+  constructor() {
+    super();
+    this.#wss = null;
+    this.#port = 0;
+  }
+
+  /**
+   * Start listening on a random available port.
+   * @returns {Promise<number>} The assigned port number.
+   */
+  start() {
+    return new Promise((resolve, reject) => {
+      this.#wss = new WebSocketServer({ port: 0, maxPayload: MAX_PAYLOAD_SIZE });
+      let settled = false;
+
+      this.#wss.on('listening', () => {
+        settled = true;
+        this.#port = this.#wss.address().port;
+        resolve(this.#port);
+      });
+
+      this.#wss.on('connection', (ws) => {
+        this.emit('connection', ws);
+      });
+
+      // Persistent error handler: reject only before 'listening'; afterwards a
+      // late server error would otherwise be unhandled and crash the process.
+      this.#wss.on('error', (err) => {
+        if (!settled) {
+          settled = true;
+          reject(err);
+        } else {
+          log.error(`PeerServer error: ${err.message}`);
+          // Only emit if someone is listening — a listener-less 'error' event
+          // would itself throw and crash the process.
+          if (this.listenerCount('error') > 0) {
+            this.emit('error', err);
+          }
+        }
+      });
+    });
+  }
+
+  get port() {
+    return this.#port;
+  }
+
+  stop() {
+    if (this.#wss) {
+      for (const client of this.#wss.clients) {
+        client.close();
+      }
+      this.#wss.close();
+      this.#wss = null;
+    }
+  }
+}

package/src/p2p/index.js

@@ -0,0 +1,219 @@
+import * as readline from 'node:readline/promises';
+import { stdin, stdout } from 'node:process';
+import { readFileSync } from 'node:fs';
+import sodium from 'sodium-native';
+import boxen from 'boxen';
+import {
+  animatedBanner,
+  bootSequence,
+  promptLabel,
+  promptDim,
+  promptError,
+  chalk,
+  mint,
+} from '../shared/banner.js';
+import { KeyManager } from '../crypto/KeyManager.js';
+import { StateManager } from '../crypto/StateManager.js';
+import { questionHidden } from '../shared/prompt.js';
+import { loadConfig, startupCommands } from '../shared/config.js';
+import { setTheme } from '../shared/themes.js';
+import { importBackup } from '../crypto/IdentityBackup.js';
+import { Discovery } from './Discovery.js';
+import { PeerServer } from './PeerServer.js';
+import { PeerConnectionManager } from './PeerConnectionManager.js';
+import { UI } from '../client/UI.js';
+import { P2PChatController } from './P2PChatController.js';
+import { PluginManager } from '../shared/PluginManager.js';
+
+// ── Banner ──────────────────────────────────────────────────────
+await animatedBanner('  ░▒▓  End-to-End Encrypted P2P Chat  ▓▒░');
+
+// ── Config (optional defaults from ~/.ciphermesh/config.json) ────
+const config = loadConfig();
+if (config.theme) {
+  setTheme(config.theme);
+}
+
+// ── Prompt setup ────────────────────────────────────────────────
+const rl = readline.createInterface({ input: stdin, output: stdout });
+
+let nickname = '';
+while (!nickname) {
+  const hint = config.nickname ? `(${config.nickname})` : '(a-z, 0-9, _, -)';
+  const raw = await rl.question(promptLabel(`Nickname ${promptDim(hint)}: `));
+  const clean = (raw.trim() || config.nickname || '').replace(/[^a-zA-Z0-9_-]/g, '');
+  if (clean.length >= 1 && clean.length <= 20) {
+    nickname = clean;
+  } else {
+    console.log(promptError('Invalid nickname. Use 1-20 alphanumeric characters.'));
+  }
+}
+
+// ── State restoration ────────────────────────────────────────────
+const stateManager = new StateManager();
+let restoredState = null;
+
+if (stateManager.hasState()) {
+  const passphrase = await questionHidden(
+    rl,
+    promptLabel(`Passphrase to restore session ${promptDim('(Enter to skip)')}: `),
+  );
+  if (passphrase.trim()) {
+    restoredState = stateManager.loadState(passphrase.trim());
+    if (restoredState) {
+      restoredState.passphrase = passphrase.trim();
+      console.log(promptLabel('Previous session restored successfully!'));
+    } else {
+      console.log(promptError('Wrong passphrase or corrupted state. New session.'));
+    }
+  }
+} else {
+  const passphrase = await questionHidden(
+    rl,
+    promptLabel(`Passphrase to protect session ${promptDim('(Enter to skip)')}: `),
+  );
+  if (passphrase.trim()) {
+    const confirm = await questionHidden(rl, promptLabel('Confirm the passphrase: '));
+    if (confirm.trim() === passphrase.trim()) {
+      restoredState = { passphrase: passphrase.trim() };
+    } else {
+      console.log(
+        promptError('Passphrases do not match — the session will not be protected this time.'),
+      );
+    }
+  }
+}
+
+// Offer to restore identity + trust from an encrypted backup.
+if (!restoredState?.keyManager) {
+  const backupPath = await rl.question(
+    promptLabel(`Restore identity from a backup? ${promptDim('(path or Enter)')}: `),
+  );
+  if (backupPath.trim()) {
+    try {
+      const raw = readFileSync(backupPath.trim(), 'utf-8');
+      const pass = await questionHidden(rl, promptLabel('Backup passphrase: '));
+      const data = importBackup(raw, pass.trim());
+      if (data?.identity) {
+        restoredState = {
+          ...(restoredState || {}),
+          keyManager: data.identity,
+          trust: data.trust,
+          passphrase: pass.trim(),
+        };
+        console.log(promptLabel('Identity + trust restored from backup!'));
+      } else {
+        console.log(promptError('Invalid backup or wrong passphrase.'));
+      }
+    } catch (e) {
+      console.log(promptError(`Could not read the backup: ${e.message}`));
+    }
+  }
+}
+
+rl.close();
+
+// ── Initialize crypto ──────────────────────────────────────────
+const keyManager = restoredState?.keyManager
+  ? KeyManager.deserialize(restoredState.keyManager)
+  : new KeyManager();
+
+// ── Start P2P server ──────────────────────────────────────────
+const peerServer = new PeerServer();
+const port = await peerServer.start();
+
+// ── Info box ────────────────────────────────────────────────────
+console.log();
+const lines = [];
+lines.push(chalk.hex('#4cc9f0')('  Mode         ') + chalk.bold.white('P2P (mDNS LAN)'));
+lines.push(chalk.hex('#4cc9f0')('  Port         ') + chalk.bold.white(port));
+lines.push(chalk.hex('#4cc9f0')('  Fingerprint  ') + mint(keyManager.fingerprint));
+lines.push(chalk.hex('#4cc9f0')('  Crypto       ') + chalk.white('X25519 + XSalsa20-Poly1305'));
+lines.push(
+  chalk.hex('#4cc9f0')('  Status       ') + chalk.bold.green('● Searching for peers on the LAN...'),
+);
+
+console.log(
+  boxen(lines.join('\n'), {
+    padding: { left: 1, right: 1, top: 0, bottom: 0 },
+    borderColor: '#7b2dff',
+    borderStyle: 'round',
+    title: chalk.bold.hex('#00ff9f')(' P2P '),
+    titleAlignment: 'center',
+  }),
+);
+console.log();
+
+// ── Real boot sequence ──────────────────────────────────────────
+// The spinner gates on genuine startup work: the peer server is already
+// listening (bound above) and plugins actually load. Peer discovery starts
+// later, after the controller is wired, so no early mDNS events are missed.
+const pluginManager = new PluginManager();
+
+await bootSequence([
+  'Curve25519 key exchange',
+  'XSalsa20-Poly1305 cipher',
+  'Double Ratchet — forward secrecy',
+  'TOFU trust store',
+  {
+    label: `Peer server on :${port}`,
+    task: async () => {
+      if (!port) {
+        throw new Error('peer server is not listening');
+      }
+    },
+  },
+  { label: 'Loading plugins', task: () => pluginManager.loadAll() },
+]);
+
+// ── Initialize components ──────────────────────────────────────
+const connManager = new PeerConnectionManager(nickname, () => keyManager.publicKeyB64);
+const discovery = new Discovery();
+const ui = new UI(nickname);
+const controller = new P2PChatController(
+  nickname,
+  peerServer,
+  connManager,
+  discovery,
+  ui,
+  keyManager,
+  restoredState,
+  pluginManager,
+);
+
+ui.setFingerprint(controller.fingerprint);
+ui.addInfoMessage(`Your fingerprint: ${controller.fingerprint}`);
+ui.addInfoMessage('P2P mode — peers discovered automatically via mDNS');
+ui.addInfoMessage('Use /help to see available commands');
+
+if (restoredState?.handshake) {
+  ui.addSystemMessage('Previous session restored — ratchets preserved');
+}
+
+// Start mDNS discovery
+discovery.start(nickname, port, keyManager.publicKeyB64);
+
+// Apply config toggles by replaying their slash-commands through the controller.
+for (const cmd of startupCommands(config)) {
+  ui.emit('input', cmd);
+}
+
+// ── Graceful shutdown ───────────────────────────────────────────
+function shutdown() {
+  const passphrase = controller.passphrase;
+  if (passphrase) {
+    try {
+      const state = controller.serializeState();
+      const { kek, salt, opslimit, memlimit } = stateManager.deriveKEK(passphrase);
+      stateManager.saveState(state, kek, salt, opslimit, memlimit);
+      sodium.sodium_memzero(kek);
+    } catch {
+      // Best effort — don't block shutdown
+    }
+  }
+  controller.destroy();
+  process.exit(0);
+}
+
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);

package/src/protocol/messages.js

@@ -0,0 +1,138 @@
+import { PROTOCOL_VERSION } from '../shared/constants.js';
+
+// ── Message types ──────────────────────────────────────────────
+export const MSG = {
+  JOIN: 'join',
+  JOIN_ACK: 'join_ack',
+  PEER_JOINED: 'peer_joined',
+  PEER_LEFT: 'peer_left',
+  ENCRYPTED_MESSAGE: 'encrypted_message',
+  ERROR: 'error',
+  KEY_UPDATE: 'key_update',
+  PEER_KEY_UPDATED: 'peer_key_updated',
+  CHANGE_ROOM: 'change_room',
+  ROOM_CHANGED: 'room_changed',
+  LIST_ROOMS: 'list_rooms',
+  ROOM_LIST: 'room_list',
+  KICK_PEER: 'kick_peer',
+  MUTE_PEER: 'mute_peer',
+  BAN_PEER: 'ban_peer',
+  PEER_KICKED: 'peer_kicked',
+  PEER_MUTED: 'peer_muted',
+  PING: 'ping',
+  PONG: 'pong',
+};
+
+// ── Error codes ────────────────────────────────────────────────
+export const ERR = {
+  NICKNAME_TAKEN: 'NICKNAME_TAKEN',
+  INVALID_MESSAGE: 'INVALID_MESSAGE',
+  PEER_NOT_FOUND: 'PEER_NOT_FOUND',
+  RATE_LIMITED: 'RATE_LIMITED',
+  PAYLOAD_TOO_LARGE: 'PAYLOAD_TOO_LARGE',
+};
+
+// ── Factory helpers ────────────────────────────────────────────
+function base(type) {
+  return { type, version: PROTOCOL_VERSION, timestamp: Date.now() };
+}
+
+export function createJoin(nickname, publicKeyB64) {
+  return { ...base(MSG.JOIN), nickname, publicKey: publicKeyB64 };
+}
+
+export function createJoinAck(sessionId, peers, queuedCount = 0, room = 'general') {
+  const ack = { ...base(MSG.JOIN_ACK), sessionId, peers, room };
+  if (queuedCount > 0) {
+    ack.queuedCount = queuedCount;
+  }
+  return ack;
+}
+
+export function createPeerJoined(peer) {
+  return { ...base(MSG.PEER_JOINED), peer };
+}
+
+export function createPeerLeft(sessionId, nickname) {
+  return { ...base(MSG.PEER_LEFT), sessionId, nickname };
+}
+
+export function createEncryptedMessage(from, to, ciphertextB64, nonceB64) {
+  return {
+    ...base(MSG.ENCRYPTED_MESSAGE),
+    from,
+    to,
+    payload: { ciphertext: ciphertextB64, nonce: nonceB64 },
+  };
+}
+
+export function createRatchetedMessage(from, to, payload) {
+  return {
+    ...base(MSG.ENCRYPTED_MESSAGE),
+    from,
+    to,
+    payload: {
+      ephemeralPublicKey: payload.ephemeralPublicKey.toString('base64'),
+      counter: payload.counter,
+      previousCounter: payload.previousCounter,
+      ciphertext: payload.ciphertext.toString('base64'),
+      nonce: payload.nonce.toString('base64'),
+    },
+  };
+}
+
+export function createError(code, message) {
+  return { ...base(MSG.ERROR), code, message };
+}
+
+export function createKeyUpdate(publicKeyB64) {
+  return { ...base(MSG.KEY_UPDATE), publicKey: publicKeyB64 };
+}
+
+export function createPeerKeyUpdated(sessionId, publicKeyB64) {
+  return { ...base(MSG.PEER_KEY_UPDATED), sessionId, publicKey: publicKeyB64 };
+}
+
+export function createPing() {
+  return base(MSG.PING);
+}
+
+export function createPong() {
+  return base(MSG.PONG);
+}
+
+export function createChangeRoom(room) {
+  return { ...base(MSG.CHANGE_ROOM), room };
+}
+
+export function createRoomChanged(room, peers) {
+  return { ...base(MSG.ROOM_CHANGED), room, peers };
+}
+
+export function createListRooms() {
+  return base(MSG.LIST_ROOMS);
+}
+
+export function createRoomList(rooms) {
+  return { ...base(MSG.ROOM_LIST), rooms };
+}
+
+export function createKickPeer(targetNickname, reason = '') {
+  return { ...base(MSG.KICK_PEER), targetNickname, reason };
+}
+
+export function createMutePeer(targetNickname, durationMs) {
+  return { ...base(MSG.MUTE_PEER), targetNickname, durationMs };
+}
+
+export function createBanPeer(targetNickname, reason = '') {
+  return { ...base(MSG.BAN_PEER), targetNickname, reason };
+}
+
+export function createPeerKicked(nickname, reason = '') {
+  return { ...base(MSG.PEER_KICKED), nickname, reason };
+}
+
+export function createPeerMuted(nickname, durationMs) {
+  return { ...base(MSG.PEER_MUTED), nickname, durationMs };
+}