ciphermesh 1.0.0

package/src/crypto/TrustStore.js

@@ -0,0 +1,216 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import sodium from 'sodium-native';
+import { KeyManager } from './KeyManager.js';
+
+const TRUST_DIR = '.ciphermesh';
+const TRUST_FILE = 'trusted-peers.json';
+
+export const TrustResult = {
+  NEW_PEER: 'new_peer',
+  TRUSTED: 'trusted',
+  MISMATCH: 'mismatch',
+  VERIFIED_MISMATCH: 'verified_mismatch',
+};
+
+export class TrustStore {
+  #storePath;
+  #store; // Map<lowerNickname, record>
+
+  constructor(baseDir = process.cwd()) {
+    const dir = join(baseDir, TRUST_DIR);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    this.#storePath = join(dir, TRUST_FILE);
+    this.#store = new Map();
+    this.#load();
+  }
+
+  #load() {
+    try {
+      if (existsSync(this.#storePath)) {
+        const raw = readFileSync(this.#storePath, 'utf-8');
+        const data = JSON.parse(raw);
+        for (const [nick, record] of Object.entries(data)) {
+          this.#store.set(nick, record);
+        }
+      }
+    } catch {
+      this.#store = new Map();
+    }
+  }
+
+  #save() {
+    const obj = Object.fromEntries(this.#store);
+    writeFileSync(this.#storePath, JSON.stringify(obj, null, 2), {
+      encoding: 'utf-8',
+      mode: 0o600,
+    });
+  }
+
+  // Securely delete the trust store from disk (panic / duress).
+  wipe() {
+    this.#store = new Map();
+    try {
+      if (existsSync(this.#storePath)) {
+        writeFileSync(this.#storePath, Buffer.alloc(Math.max(256, statSync(this.#storePath).size)));
+        unlinkSync(this.#storePath);
+      }
+    } catch {
+      /* best effort */
+    }
+  }
+
+  /**
+   * Check if a peer's fingerprint matches the stored one.
+   */
+  checkPeer(nickname, publicKeyB64) {
+    const key = nickname.toLowerCase();
+    const record = this.#store.get(key);
+
+    if (!record) {
+      return TrustResult.NEW_PEER;
+    }
+
+    // Compare the FULL public key (256 bits), not the 64-bit fingerprint.
+    // Fall back to the fingerprint only for legacy records without publicKey.
+    const matches = record.publicKey
+      ? record.publicKey === publicKeyB64
+      : record.fingerprint === KeyManager.computeFingerprint(Buffer.from(publicKeyB64, 'base64'));
+
+    if (matches) {
+      record.lastSeen = Date.now();
+      this.#save();
+      return TrustResult.TRUSTED;
+    }
+
+    if (record.verified) {
+      return TrustResult.VERIFIED_MISMATCH;
+    }
+    return TrustResult.MISMATCH;
+  }
+
+  /**
+   * Record a first-time peer.
+   */
+  recordPeer(nickname, publicKeyB64) {
+    const key = nickname.toLowerCase();
+    const fingerprint = KeyManager.computeFingerprint(Buffer.from(publicKeyB64, 'base64'));
+    this.#store.set(key, {
+      fingerprint,
+      publicKey: publicKeyB64,
+      firstSeen: Date.now(),
+      lastSeen: Date.now(),
+      verified: false,
+    });
+    this.#save();
+  }
+
+  /**
+   * User explicitly accepts a new key (resets verified status).
+   */
+  updatePeer(nickname, publicKeyB64) {
+    const key = nickname.toLowerCase();
+    const fingerprint = KeyManager.computeFingerprint(Buffer.from(publicKeyB64, 'base64'));
+    const record = this.#store.get(key);
+    if (!record) {
+      this.recordPeer(nickname, publicKeyB64);
+      return;
+    }
+    record.fingerprint = fingerprint;
+    record.publicKey = publicKeyB64;
+    record.lastSeen = Date.now();
+    record.verified = false;
+    this.#save();
+  }
+
+  /**
+   * Auto-update from authenticated E2E key rotation (preserves verified status).
+   */
+  autoUpdatePeer(nickname, publicKeyB64) {
+    const key = nickname.toLowerCase();
+    const record = this.#store.get(key);
+    if (!record) {
+      this.recordPeer(nickname, publicKeyB64);
+      return;
+    }
+    const fingerprint = KeyManager.computeFingerprint(Buffer.from(publicKeyB64, 'base64'));
+    record.fingerprint = fingerprint;
+    record.publicKey = publicKeyB64;
+    record.lastSeen = Date.now();
+    this.#save();
+  }
+
+  /**
+   * Compute a Short Authentication String from both public keys.
+   * ~40 bits of entropy shown as 13 grouped decimal digits (was 6 digits / ~20
+   * bits, which is grindable offline). Both sides compute the same value; it is
+   * only ever compared by humans out-of-band, never typed back.
+   */
+  static computeSAS(myPublicKey, peerPublicKey) {
+    const myPub = Buffer.isBuffer(myPublicKey) ? myPublicKey : Buffer.from(myPublicKey, 'base64');
+    const peerPub = Buffer.isBuffer(peerPublicKey)
+      ? peerPublicKey
+      : Buffer.from(peerPublicKey, 'base64');
+
+    // Sort lexicographically for deterministic ordering
+    const [first, second] =
+      Buffer.compare(myPub, peerPub) <= 0 ? [myPub, peerPub] : [peerPub, myPub];
+
+    // BLAKE2b-256(pubA || pubB || domain separator)
+    const context = Buffer.from('CipherMesh-SAS-v1');
+    const input = Buffer.concat([first, second, context]);
+    const hash = Buffer.alloc(32);
+    sodium.crypto_generichash(hash, input);
+
+    // First 5 bytes (40 bits) → up to 13 decimal digits, grouped 4-4-5.
+    let num = 0n;
+    for (let i = 0; i < 5; i++) {
+      num = (num << 8n) | BigInt(hash[i]);
+    }
+    const digits = num.toString().padStart(13, '0');
+    return `${digits.slice(0, 4)} ${digits.slice(4, 8)} ${digits.slice(8)}`;
+  }
+
+  markVerified(nickname) {
+    const key = nickname.toLowerCase();
+    const record = this.#store.get(key);
+    if (record) {
+      record.verified = true;
+      this.#save();
+      return true;
+    }
+    return false;
+  }
+
+  isVerified(nickname) {
+    const key = nickname.toLowerCase();
+    const record = this.#store.get(key);
+    return record?.verified === true;
+  }
+
+  getPeerRecord(nickname) {
+    return this.#store.get(nickname.toLowerCase()) || null;
+  }
+
+  /** Export all trust records as a plain object (for identity backup). */
+  exportData() {
+    return Object.fromEntries(this.#store);
+  }
+
+  /** Merge trust records from a backup, preferring imported verified peers. */
+  importData(obj) {
+    if (!obj || typeof obj !== 'object') {
+      return;
+    }
+    for (const [nick, record] of Object.entries(obj)) {
+      const existing = this.#store.get(nick);
+      // Keep whichever record is verified; otherwise the imported one wins.
+      if (!existing || record.verified || !existing.verified) {
+        this.#store.set(nick, record);
+      }
+    }
+    this.#save();
+  }
+}

package/src/p2p/Discovery.js

@@ -0,0 +1,80 @@
+import { Bonjour } from 'bonjour-service';
+import { EventEmitter } from 'node:events';
+import { PROTOCOL_VERSION } from '../shared/constants.js';
+
+const SERVICE_TYPE = 'ciphermesh';
+
+export class Discovery extends EventEmitter {
+  #bonjour;
+  #service;
+  #browser;
+  #myNickname;
+
+  constructor() {
+    super();
+    this.#bonjour = new Bonjour();
+    this.#service = null;
+    this.#browser = null;
+    this.#myNickname = null;
+  }
+
+  /**
+   * Publish our service and start browsing for peers.
+   */
+  start(nickname, port, publicKeyB64) {
+    this.#myNickname = nickname;
+
+    // Publish mDNS service
+    this.#service = this.#bonjour.publish({
+      name: `ciphermesh-${nickname}`,
+      type: SERVICE_TYPE,
+      port,
+      txt: {
+        nickname,
+        publicKey: publicKeyB64,
+        version: String(PROTOCOL_VERSION),
+      },
+    });
+
+    // Browse for other CipherMesh peers
+    this.#browser = this.#bonjour.find({ type: SERVICE_TYPE });
+
+    this.#browser.on('up', (service) => {
+      const peerNick = service.txt?.nickname;
+      if (!peerNick || peerNick === this.#myNickname) {
+        return;
+      }
+
+      // Prefer referer address (actual IP), fallback to host
+      const host = service.referer?.address || service.host;
+
+      this.emit('peer-discovered', {
+        nickname: peerNick,
+        host,
+        port: service.port,
+        publicKey: service.txt.publicKey,
+      });
+    });
+
+    this.#browser.on('down', (service) => {
+      const peerNick = service.txt?.nickname;
+      if (!peerNick || peerNick === this.#myNickname) {
+        return;
+      }
+
+      this.emit('peer-lost', { nickname: peerNick });
+    });
+  }
+
+  stop() {
+    if (this.#browser) {
+      this.#browser.stop();
+      this.#browser = null;
+    }
+    if (this.#service) {
+      this.#service.stop();
+      this.#service = null;
+    }
+    this.#bonjour.destroy();
+  }
+}