bitchat-node 0.1.0

package/src/protocol/types.ts

@@ -0,0 +1,182 @@
+/**
+ * Bitchat Protocol Types
+ * From: bitchat/Protocols/BitchatProtocol.swift
+ *       bitchat/Models/BitchatPacket.swift
+ */
+
+import { hash as sha256 } from '@stablelib/sha256';
+import { SENDER_ID_SIZE } from './constants.js';
+
+/**
+ * Message types from BitchatProtocol.swift
+ * Reduced from 24 types to 8 essential ones.
+ */
+export enum MessageType {
+  // Public messages (unencrypted)
+  ANNOUNCE = 0x01, // "I'm here" with nickname
+  MESSAGE = 0x02, // Public chat message
+  LEAVE = 0x03, // "I'm leaving"
+  REQUEST_SYNC = 0x21, // GCS filter-based sync request
+
+  // Noise encryption
+  NOISE_HANDSHAKE = 0x10, // Handshake (init or response)
+  NOISE_ENCRYPTED = 0x11, // All encrypted payloads
+
+  // Fragmentation
+  FRAGMENT = 0x20, // Fragment for large messages
+  FILE_TRANSFER = 0x22, // Binary file/audio/image
+}
+
+/**
+ * Noise payload types (first byte of decrypted payload)
+ */
+export enum NoisePayloadType {
+  PRIVATE_MESSAGE = 0x01,
+  READ_RECEIPT = 0x02,
+  DELIVERED = 0x03,
+  VERIFY_CHALLENGE = 0x10,
+  VERIFY_RESPONSE = 0x11,
+}
+
+/**
+ * Binary protocol flags
+ */
+export const PacketFlags = {
+  HAS_RECIPIENT: 0x01,
+  HAS_SIGNATURE: 0x02,
+  IS_COMPRESSED: 0x04,
+  HAS_ROUTE: 0x08, // v2+ only
+  IS_RSR: 0x10, // Request-Sync-Response
+} as const;
+
+/**
+ * Peer identifier (8 bytes, displayed as 16-char hex)
+ */
+export class PeerID {
+  private readonly bytes: Uint8Array;
+
+  constructor(bytes: Uint8Array | string) {
+    if (typeof bytes === 'string') {
+      // Parse hex string
+      const hex = bytes.replace(/^0x/, '').toLowerCase();
+      const padded = hex.padStart(16, '0').slice(0, 16);
+      this.bytes = new Uint8Array(SENDER_ID_SIZE);
+      for (let i = 0; i < SENDER_ID_SIZE; i++) {
+        this.bytes[i] = parseInt(padded.slice(i * 2, i * 2 + 2), 16);
+      }
+    } else {
+      this.bytes = new Uint8Array(SENDER_ID_SIZE);
+      this.bytes.set(bytes.subarray(0, SENDER_ID_SIZE));
+    }
+  }
+
+  static fromPublicKey(publicKey: Uint8Array): PeerID {
+    // SHA256 of public key, first 8 bytes
+    const hash = sha256(publicKey);
+    return new PeerID(hash.subarray(0, SENDER_ID_SIZE));
+  }
+
+  toBytes(): Uint8Array {
+    return new Uint8Array(this.bytes);
+  }
+
+  toHex(): string {
+    return Array.from(this.bytes)
+      .map((b) => b.toString(16).padStart(2, '0'))
+      .join('');
+  }
+
+  toString(): string {
+    return this.toHex();
+  }
+
+  equals(other: PeerID): boolean {
+    if (this.bytes.length !== other.bytes.length) return false;
+    for (let i = 0; i < this.bytes.length; i++) {
+      if (this.bytes[i] !== other.bytes[i]) return false;
+    }
+    return true;
+  }
+
+  get isEmpty(): boolean {
+    return this.bytes.every((b) => b === 0);
+  }
+
+  static readonly BROADCAST = new PeerID(new Uint8Array(SENDER_ID_SIZE).fill(0xff));
+}
+
+/**
+ * Core packet structure
+ * From: bitchat/Models/BitchatPacket.swift
+ */
+export interface BitchatPacket {
+  version: number; // Protocol version (1 or 2)
+  type: MessageType;
+  ttl: number; // Time-to-live for mesh routing
+  timestamp: bigint; // Milliseconds since epoch
+  senderID: PeerID;
+  recipientID?: PeerID; // Optional for directed messages
+  payload: Uint8Array;
+  signature?: Uint8Array; // Ed25519 signature
+  route?: PeerID[]; // Source routing (v2+)
+  isRSR: boolean; // Request-Sync-Response flag
+}
+
+/**
+ * Delivery status for messages
+ */
+export type DeliveryStatus =
+  | { type: 'sending' }
+  | { type: 'sent' }
+  | { type: 'delivered'; to: PeerID; at: Date }
+  | { type: 'read'; by: PeerID; at: Date }
+  | { type: 'failed'; reason: string };
+
+/**
+ * Handshake state for lazy Noise sessions
+ */
+export enum HandshakeState {
+  NONE = 'none',
+  QUEUED = 'queued',
+  HANDSHAKING = 'handshaking',
+  ESTABLISHED = 'established',
+  FAILED = 'failed',
+}
+
+/**
+ * Connected peer information
+ */
+export interface PeerInfo {
+  peerID: PeerID;
+  nickname: string;
+  isConnected: boolean;
+  noisePublicKey?: Uint8Array;
+  signingPublicKey?: Uint8Array;
+  isVerified: boolean;
+  lastSeen: Date;
+  handshakeState: HandshakeState;
+}
+
+/**
+ * Chat message (application layer)
+ */
+export interface ChatMessage {
+  id: string;
+  sender: PeerID;
+  senderNickname: string;
+  content: string;
+  timestamp: Date;
+  isPrivate: boolean;
+  recipientNickname?: string;
+  originalSender?: PeerID; // For relayed messages
+  deliveryStatus: DeliveryStatus;
+}
+
+/**
+ * Read receipt
+ */
+export interface ReadReceipt {
+  originalMessageID: string;
+  readBy: PeerID;
+  readAt: Date;
+}

package/src/session/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Session module exports
+ */
+
+export {
+  SessionManager,
+  type SessionManagerConfig,
+  type SessionManagerEvents,
+} from './manager.js';

package/src/session/manager.ts

@@ -0,0 +1,476 @@
+/**
+ * Session Manager
+ * Manages Noise sessions with peers, handling handshakes and encryption
+ */
+
+import { EventEmitter } from 'node:events';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import {
+  generateKeyPair,
+  HandshakeState as NoiseHandshake,
+  type NoiseKeyPair,
+  type NoiseRole,
+  NoiseSession,
+} from '../crypto/noise.js';
+import { fingerprint, generateSigningKeyPair, type SigningKeyPair } from '../crypto/signing.js';
+import { HandshakeState, PeerID, type PeerInfo } from '../protocol/types.js';
+
+// Key persistence path
+const KEY_DIR = join(homedir(), '.bitchat-node');
+const KEY_FILE = join(KEY_DIR, 'identity.json');
+
+interface PersistedKeys {
+  noisePublicKey: string;
+  noiseSecretKey: string;
+  signingPublicKey: string;
+  signingSecretKey: string;
+}
+
+function loadOrCreateKeys(): { static: NoiseKeyPair; signing: SigningKeyPair } {
+  try {
+    if (existsSync(KEY_FILE)) {
+      const data = JSON.parse(readFileSync(KEY_FILE, 'utf-8')) as PersistedKeys;
+      console.log('[Keys] Loaded persistent identity from', KEY_FILE);
+      return {
+        static: {
+          publicKey: Buffer.from(data.noisePublicKey, 'hex'),
+          secretKey: Buffer.from(data.noiseSecretKey, 'hex'),
+        },
+        signing: {
+          publicKey: Buffer.from(data.signingPublicKey, 'hex'),
+          secretKey: Buffer.from(data.signingSecretKey, 'hex'),
+        },
+      };
+    }
+  } catch (e) {
+    console.log('[Keys] Failed to load keys, generating new ones:', (e as Error).message);
+  }
+
+  // Generate new keys
+  const staticKP = generateKeyPair();
+  const signingKP = generateSigningKeyPair();
+
+  // Persist them
+  try {
+    mkdirSync(KEY_DIR, { recursive: true });
+    const data: PersistedKeys = {
+      noisePublicKey: Buffer.from(staticKP.publicKey).toString('hex'),
+      noiseSecretKey: Buffer.from(staticKP.secretKey).toString('hex'),
+      signingPublicKey: Buffer.from(signingKP.publicKey).toString('hex'),
+      signingSecretKey: Buffer.from(signingKP.secretKey).toString('hex'),
+    };
+    writeFileSync(KEY_FILE, JSON.stringify(data, null, 2));
+    console.log('[Keys] Generated and saved new identity to', KEY_FILE);
+  } catch (e) {
+    console.log('[Keys] Warning: Failed to persist keys:', (e as Error).message);
+  }
+
+  return { static: staticKP, signing: signingKP };
+}
+
+export interface SessionManagerConfig {
+  autoHandshake: boolean;
+  handshakeTimeoutMs: number;
+}
+
+const DEFAULT_CONFIG: SessionManagerConfig = {
+  autoHandshake: true,
+  handshakeTimeoutMs: 30000,
+};
+
+interface PendingHandshake {
+  state: NoiseHandshake;
+  role: NoiseRole;
+  startedAt: number;
+  timeoutHandle?: ReturnType<typeof setTimeout>;
+}
+
+interface EstablishedSession {
+  session: NoiseSession;
+  establishedAt: number;
+  remotePublicKey: Uint8Array;
+}
+
+export interface SessionManagerEvents {
+  'session:established': (peerID: PeerID, session: NoiseSession) => void;
+  'session:failed': (peerID: PeerID, error: Error) => void;
+  'session:closed': (peerID: PeerID) => void;
+  'handshake:message': (peerID: PeerID, message: Uint8Array) => void;
+}
+
+/**
+ * Manages Noise sessions with peers
+ */
+export class SessionManager extends EventEmitter {
+  private readonly config: SessionManagerConfig;
+
+  // Our keys
+  readonly staticKeyPair: NoiseKeyPair;
+  readonly signingKeyPair: SigningKeyPair;
+  readonly myPeerID: PeerID;
+  readonly fingerprint: string;
+
+  // Session state
+  private pendingHandshakes = new Map<string, PendingHandshake>();
+  private sessions = new Map<string, EstablishedSession>();
+
+  // Peer info
+  private peers = new Map<string, PeerInfo>();
+
+  // Messages queued for after handshake completion
+  private pendingMessages = new Map<string, Array<{ data: Uint8Array; timestamp: number }>>();
+
+  constructor(
+    config: Partial<SessionManagerConfig> = {},
+    existingKeys?: { static?: NoiseKeyPair; signing?: SigningKeyPair }
+  ) {
+    super();
+    this.config = { ...DEFAULT_CONFIG, ...config };
+
+    // Initialize with provided keys, persisted keys, or generate new ones
+    if (existingKeys?.static && existingKeys?.signing) {
+      this.staticKeyPair = existingKeys.static;
+      this.signingKeyPair = existingKeys.signing;
+    } else {
+      const loaded = loadOrCreateKeys();
+      this.staticKeyPair = loaded.static;
+      this.signingKeyPair = loaded.signing;
+    }
+
+    // Derive peer ID from static public key
+    this.myPeerID = PeerID.fromPublicKey(this.staticKeyPair.publicKey);
+    this.fingerprint = fingerprint(this.staticKeyPair.publicKey);
+
+    console.log('[SessionManager] Identity:');
+    console.log('  PeerID:', this.myPeerID.toHex());
+    console.log('  Noise pubkey:', Buffer.from(this.staticKeyPair.publicKey).toString('hex'));
+    console.log('  Signing pubkey:', Buffer.from(this.signingKeyPair.publicKey).toString('hex'));
+  }
+
+  /**
+   * Check if we have an established session with a peer
+   */
+  hasSession(peerID: PeerID): boolean {
+    return this.sessions.has(peerID.toHex());
+  }
+
+  /**
+   * Check if we're in the middle of a handshake
+   */
+  hasHandshakeInProgress(peerID: PeerID): boolean {
+    return this.pendingHandshakes.has(peerID.toHex());
+  }
+
+  /**
+   * Get handshake state for a peer
+   */
+  getHandshakeState(peerID: PeerID): HandshakeState {
+    if (this.sessions.has(peerID.toHex())) {
+      return HandshakeState.ESTABLISHED;
+    }
+    if (this.pendingHandshakes.has(peerID.toHex())) {
+      return HandshakeState.HANDSHAKING;
+    }
+    return HandshakeState.NONE;
+  }
+
+  /**
+   * Get established session
+   */
+  getSession(peerID: PeerID): NoiseSession | undefined {
+    return this.sessions.get(peerID.toHex())?.session;
+  }
+
+  /**
+   * Initiate a handshake with a peer
+   */
+  initiateHandshake(peerID: PeerID): Uint8Array {
+    const key = peerID.toHex();
+
+    // Check if already have session or handshake in progress
+    if (this.sessions.has(key)) {
+      throw new Error('Session already established');
+    }
+    if (this.pendingHandshakes.has(key)) {
+      throw new Error('Handshake already in progress');
+    }
+
+    // Create handshake state
+    const state = new NoiseHandshake('initiator', this.staticKeyPair);
+
+    // Write first message
+    const message = state.writeMessage();
+
+    // Store pending handshake
+    const pending: PendingHandshake = {
+      state,
+      role: 'initiator',
+      startedAt: Date.now(),
+    };
+
+    // Set timeout
+    pending.timeoutHandle = setTimeout(() => {
+      this.handleHandshakeTimeout(peerID);
+    }, this.config.handshakeTimeoutMs);
+
+    this.pendingHandshakes.set(key, pending);
+
+    return message;
+  }
+
+  /**
+   * Handle incoming handshake message
+   */
+  handleHandshakeMessage(peerID: PeerID, message: Uint8Array): Uint8Array | null {
+    const key = peerID.toHex();
+
+    let pending = this.pendingHandshakes.get(key);
+
+    if (!pending) {
+      // No handshake in progress - we're the responder
+      const state = new NoiseHandshake('responder', this.staticKeyPair);
+      pending = {
+        state,
+        role: 'responder',
+        startedAt: Date.now(),
+      };
+
+      // Set timeout
+      pending.timeoutHandle = setTimeout(() => {
+        this.handleHandshakeTimeout(peerID);
+      }, this.config.handshakeTimeoutMs);
+
+      this.pendingHandshakes.set(key, pending);
+    }
+
+    try {
+      // Process incoming message
+      pending.state.readMessage(message);
+
+      // Check if handshake is complete
+      if (pending.state.isComplete()) {
+        this.completeHandshake(peerID, pending);
+        return null;
+      }
+
+      // Write response
+      const response = pending.state.writeMessage();
+
+      // Check again after writing
+      if (pending.state.isComplete()) {
+        this.completeHandshake(peerID, pending);
+      }
+
+      return response;
+    } catch (error) {
+      // Handshake failed
+      this.handleHandshakeFailure(peerID, error as Error);
+      return null;
+    }
+  }
+
+  /**
+   * Complete a successful handshake
+   */
+  private completeHandshake(peerID: PeerID, pending: PendingHandshake): void {
+    const key = peerID.toHex();
+
+    // Clear timeout
+    if (pending.timeoutHandle) {
+      clearTimeout(pending.timeoutHandle);
+    }
+
+    // Get remote public key
+    const remotePublicKey = pending.state.getRemoteStaticPublicKey();
+    if (!remotePublicKey) {
+      this.handleHandshakeFailure(peerID, new Error('No remote public key'));
+      return;
+    }
+
+    // Create session
+    const { send, receive, hash } = pending.state.split();
+    const session = new NoiseSession(send, receive, hash, remotePublicKey);
+
+    // Store session
+    this.sessions.set(key, {
+      session,
+      establishedAt: Date.now(),
+      remotePublicKey,
+    });
+
+    // Clean up pending
+    this.pendingHandshakes.delete(key);
+
+    // Update peer info
+    this.updatePeerInfo(peerID, { noisePublicKey: remotePublicKey });
+
+    // Emit event
+    this.emit('session:established', peerID, session);
+
+    // Send any queued messages
+    this.flushPendingMessages(peerID);
+  }
+
+  /**
+   * Handle handshake timeout
+   */
+  private handleHandshakeTimeout(peerID: PeerID): void {
+    this.handleHandshakeFailure(peerID, new Error('Handshake timeout'));
+  }
+
+  /**
+   * Handle handshake failure
+   */
+  private handleHandshakeFailure(peerID: PeerID, error: Error): void {
+    const key = peerID.toHex();
+    const pending = this.pendingHandshakes.get(key);
+
+    if (pending?.timeoutHandle) {
+      clearTimeout(pending.timeoutHandle);
+    }
+
+    this.pendingHandshakes.delete(key);
+    this.pendingMessages.delete(key);
+
+    this.emit('session:failed', peerID, error);
+  }
+
+  /**
+   * Encrypt data for a peer
+   */
+  encrypt(peerID: PeerID, plaintext: Uint8Array): Uint8Array {
+    const session = this.sessions.get(peerID.toHex())?.session;
+    if (!session) {
+      throw new Error('No session with peer');
+    }
+    return session.encrypt(plaintext);
+  }
+
+  /**
+   * Decrypt data from a peer
+   */
+  decrypt(peerID: PeerID, ciphertext: Uint8Array): Uint8Array {
+    const session = this.sessions.get(peerID.toHex())?.session;
+    if (!session) {
+      throw new Error('No session with peer');
+    }
+    return session.decrypt(ciphertext);
+  }
+
+  /**
+   * Queue a message for after handshake completion
+   */
+  queueMessage(peerID: PeerID, data: Uint8Array): void {
+    const key = peerID.toHex();
+    const queue = this.pendingMessages.get(key) ?? [];
+    queue.push({ data, timestamp: Date.now() });
+    this.pendingMessages.set(key, queue);
+  }
+
+  /**
+   * Flush pending messages for a peer
+   */
+  private flushPendingMessages(peerID: PeerID): void {
+    const key = peerID.toHex();
+    const queue = this.pendingMessages.get(key);
+    if (!queue || queue.length === 0) return;
+
+    this.pendingMessages.delete(key);
+
+    for (const { data } of queue) {
+      try {
+        const encrypted = this.encrypt(peerID, data);
+        this.emit('handshake:message', peerID, encrypted);
+      } catch (error) {
+        console.error('Failed to encrypt queued message:', error);
+      }
+    }
+  }
+
+  /**
+   * Close session with a peer
+   */
+  closeSession(peerID: PeerID): void {
+    const key = peerID.toHex();
+
+    const established = this.sessions.get(key);
+    if (established) {
+      established.session.clear();
+      this.sessions.delete(key);
+    }
+
+    const pending = this.pendingHandshakes.get(key);
+    if (pending?.timeoutHandle) {
+      clearTimeout(pending.timeoutHandle);
+    }
+    this.pendingHandshakes.delete(key);
+
+    this.pendingMessages.delete(key);
+
+    this.emit('session:closed', peerID);
+  }
+
+  /**
+   * Update peer info
+   */
+  updatePeerInfo(peerID: PeerID, updates: Partial<PeerInfo>): void {
+    const key = peerID.toHex();
+    const existing = this.peers.get(key) ?? {
+      peerID,
+      nickname: 'anon',
+      isConnected: false,
+      isVerified: false,
+      lastSeen: new Date(),
+      handshakeState: HandshakeState.NONE,
+    };
+
+    this.peers.set(key, { ...existing, ...updates });
+  }
+
+  /**
+   * Get peer info
+   */
+  getPeerInfo(peerID: PeerID): PeerInfo | undefined {
+    return this.peers.get(peerID.toHex());
+  }
+
+  /**
+   * Get all known peers
+   */
+  getAllPeers(): PeerInfo[] {
+    return Array.from(this.peers.values());
+  }
+
+  /**
+   * Get all peers with established sessions
+   */
+  getConnectedPeers(): PeerInfo[] {
+    const connectedKeys = new Set(this.sessions.keys());
+    return Array.from(this.peers.values()).filter((p) => connectedKeys.has(p.peerID.toHex()));
+  }
+
+  /**
+   * Clean up
+   */
+  destroy(): void {
+    // Clear all sessions
+    for (const [, established] of this.sessions) {
+      established.session.clear();
+    }
+    this.sessions.clear();
+
+    // Clear pending handshakes
+    for (const [, pending] of this.pendingHandshakes) {
+      if (pending.timeoutHandle) {
+        clearTimeout(pending.timeoutHandle);
+      }
+    }
+    this.pendingHandshakes.clear();
+
+    this.pendingMessages.clear();
+    this.peers.clear();
+    this.removeAllListeners();
+  }
+}