ciphermesh 2.1.0 → 2.3.0

package/src/protocol/messages.js

@@ -12,6 +12,10 @@ export const MSG = {
   PEER_KEY_UPDATED: 'peer_key_updated',
   CHANGE_ROOM: 'change_room',
   ROOM_CHANGED: 'room_changed',
+  JOIN_ROOM: 'join_room',
+  ROOM_JOINED: 'room_joined',
+  LEAVE_ROOM: 'leave_room',
+  ROOM_LEFT: 'room_left',
   LIST_ROOMS: 'list_rooms',
   ROOM_LIST: 'room_list',
   ROOM_CHALLENGE: 'room_challenge',
@@ -41,8 +45,14 @@ function base(type) {
   return { type, version: PROTOCOL_VERSION, timestamp: Date.now() };
 }
 
-export function createJoin(nickname, publicKeyB64) {
-  return { ...base(MSG.JOIN), nickname, publicKey: publicKeyB64 };
+// pqPublicKey (v3, optional): ML-KEM-768 encapsulation key for the hybrid
+// post-quantum handshake. Absent = classical-only peer (pre-2.3 client).
+export function createJoin(nickname, publicKeyB64, pqPublicKeyB64 = null) {
+  const msg = { ...base(MSG.JOIN), nickname, publicKey: publicKeyB64 };
+  if (pqPublicKeyB64) {
+    msg.pqPublicKey = pqPublicKeyB64;
+  }
+  return msg;
 }
 
 export function createJoinAck(sessionId, peers, queuedCount = 0, room = 'general') {
@@ -53,12 +63,22 @@ export function createJoinAck(sessionId, peers, queuedCount = 0, room = 'general
   return ack;
 }
 
-export function createPeerJoined(peer) {
-  return { ...base(MSG.PEER_JOINED), peer };
+// `room` (multi-room, additive): which room this event refers to. A peer can
+// leave room X while still sharing room Y with you. Old clients ignore it.
+export function createPeerJoined(peer, room = null) {
+  const msg = { ...base(MSG.PEER_JOINED), peer };
+  if (room) {
+    msg.room = room;
+  }
+  return msg;
 }
 
-export function createPeerLeft(sessionId, nickname) {
-  return { ...base(MSG.PEER_LEFT), sessionId, nickname };
+export function createPeerLeft(sessionId, nickname, room = null) {
+  const msg = { ...base(MSG.PEER_LEFT), sessionId, nickname };
+  if (room) {
+    msg.room = room;
+  }
+  return msg;
 }
 
 export function createEncryptedMessage(from, to, ciphertextB64, nonceB64) {
@@ -71,18 +91,20 @@ export function createEncryptedMessage(from, to, ciphertextB64, 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'),
-    },
+  const inner = {
+    ephemeralPublicKey: payload.ephemeralPublicKey.toString('base64'),
+    counter: payload.counter,
+    previousCounter: payload.previousCounter,
+    ciphertext: payload.ciphertext.toString('base64'),
+    nonce: payload.nonce.toString('base64'),
   };
+  // Hybrid PQ: the KEM ciphertext rides along until the peer has folded it in.
+  // It is sealed to the recipient like everything else — the relay sees only
+  // an opaque blob.
+  if (payload.pqCiphertext) {
+    inner.pqCiphertext = payload.pqCiphertext.toString('base64');
+  }
+  return { ...base(MSG.ENCRYPTED_MESSAGE), from, to, payload: inner };
 }
 
 // Sealed-sender envelope (protocol v2): the relay sees only the recipient and an
@@ -131,6 +153,33 @@ export function createRoomChanged(room, peers, isPrivate = false) {
   return msg;
 }
 
+// ── Multi-room (IRC-style buffers) ─────────────────────────────
+// join_room ADDS a membership (unlike change_room, which replaces them all).
+// Same optional roomAuthPk as change_room for creating a private room.
+export function createJoinRoom(room, roomAuthPkB64 = null) {
+  const msg = { ...base(MSG.JOIN_ROOM), room };
+  if (roomAuthPkB64) {
+    msg.roomAuthPk = roomAuthPkB64;
+  }
+  return msg;
+}
+
+export function createRoomJoined(room, peers, isPrivate = false) {
+  const msg = { ...base(MSG.ROOM_JOINED), room, peers };
+  if (isPrivate) {
+    msg.private = true;
+  }
+  return msg;
+}
+
+export function createLeaveRoom(room) {
+  return { ...base(MSG.LEAVE_ROOM), room };
+}
+
+export function createRoomLeft(room) {
+  return { ...base(MSG.ROOM_LEFT), room };
+}
+
 // Server → client: the target room is private; prove password knowledge by
 // signing this nonce. The password itself never travels.
 export function createRoomChallenge(room, nonceB64) {

package/src/protocol/validators.js

@@ -7,6 +7,7 @@ import {
   ROOM_AUTH_SIG_SIZE,
   ROOM_CHALLENGE_NONCE_SIZE,
 } from '../shared/constants.js';
+import { PQ_PUBLIC_KEY_SIZE } from '../crypto/PQHybrid.js';
 
 // ── Helpers ────────────────────────────────────────────────────
 function isString(v) {
@@ -86,7 +87,11 @@ export function validateJoin(msg) {
   if (!isValidBase64(msg.publicKey, PUBLIC_KEY_SIZE)) {
     return { valid: false, error: 'Invalid public key' };
   }
-  return { valid: true, nickname: nick };
+  // Optional ML-KEM-768 key (hybrid PQ). Absent = classical-only client.
+  if (msg.pqPublicKey !== undefined && !isValidBase64(msg.pqPublicKey, PQ_PUBLIC_KEY_SIZE)) {
+    return { valid: false, error: 'Invalid post-quantum public key' };
+  }
+  return { valid: true, nickname: nick, pqPublicKey: msg.pqPublicKey || null };
 }
 
 // Sealed sender (protocol v2): the relay only ever sees the recipient and an
@@ -126,6 +131,21 @@ export function validateChangeRoom(msg) {
   return { valid: true, room: msg.room.toLowerCase(), roomAuthPk: msg.roomAuthPk || null };
 }
 
+// join_room shares change_room's shape (room + optional verifier key).
+export function validateJoinRoom(msg) {
+  return validateChangeRoom(msg);
+}
+
+export function validateLeaveRoom(msg) {
+  if (!isString(msg.room) || msg.room.length === 0 || msg.room.length > 30) {
+    return { valid: false, error: 'Invalid room name (1-30 chars)' };
+  }
+  if (!/^[a-zA-Z0-9_-]+$/.test(msg.room)) {
+    return { valid: false, error: 'Room name must be alphanumeric, dash or underscore' };
+  }
+  return { valid: true, room: msg.room.toLowerCase() };
+}
+
 export function validateRoomAuth(msg) {
   if (!isString(msg.room) || msg.room.length === 0 || msg.room.length > 30) {
     return { valid: false, error: 'Invalid room name (1-30 chars)' };
@@ -143,15 +163,30 @@ export function validateListRooms() {
   return { valid: true };
 }
 
+// Optional multi-room context on moderation commands: which room the owner is
+// acting on. Absent → the server falls back to the session's only room.
+function optionalRoom(msg) {
+  if (msg.room === undefined) {
+    return { ok: true, room: null };
+  }
+  const v = validateLeaveRoom({ room: msg.room });
+  return v.valid ? { ok: true, room: v.room } : { ok: false, error: v.error };
+}
+
 export function validateKickPeer(msg) {
   const nick = sanitizeNickname(msg.targetNickname);
   if (!nick) {
     return { valid: false, error: 'Invalid target nickname' };
   }
+  const roomCheck = optionalRoom(msg);
+  if (!roomCheck.ok) {
+    return { valid: false, error: roomCheck.error };
+  }
   return {
     valid: true,
     targetNickname: nick,
     reason: isString(msg.reason) ? msg.reason.slice(0, 200) : '',
+    room: roomCheck.room,
   };
 }
 
@@ -163,7 +198,11 @@ export function validateMutePeer(msg) {
   if (!isNumber(msg.durationMs) || msg.durationMs <= 0) {
     return { valid: false, error: 'Invalid mute duration' };
   }
-  return { valid: true, targetNickname: nick, durationMs: msg.durationMs };
+  const roomCheck = optionalRoom(msg);
+  if (!roomCheck.ok) {
+    return { valid: false, error: roomCheck.error };
+  }
+  return { valid: true, targetNickname: nick, durationMs: msg.durationMs, room: roomCheck.room };
 }
 
 export function validateBanPeer(msg) {
@@ -171,10 +210,15 @@ export function validateBanPeer(msg) {
   if (!nick) {
     return { valid: false, error: 'Invalid target nickname' };
   }
+  const roomCheck = optionalRoom(msg);
+  if (!roomCheck.ok) {
+    return { valid: false, error: roomCheck.error };
+  }
   return {
     valid: true,
     targetNickname: nick,
     reason: isString(msg.reason) ? msg.reason.slice(0, 200) : '',
+    room: roomCheck.room,
   };
 }
 

package/src/server/SessionManager.js

@@ -4,7 +4,7 @@ import { createLogger } from '../shared/logger.js';
 const log = createLogger('session');
 
 export class SessionManager {
-  #sessions; // Map<sessionId, { ws, nickname, publicKey, connectedAt, room }>
+  #sessions; // Map<sessionId, { ws, nickname, publicKey, connectedAt, rooms: Set }>
   #nicknames; // Set<nickname> for quick dupe check
   #recentlyLeft; // Map<sessionId, { nickname, publicKey, leftAt }>
   #rooms; // Map<roomName, Set<sessionId>>
@@ -30,14 +30,15 @@ export class SessionManager {
     return this.#nicknames.has(nickname.toLowerCase());
   }
 
-  addSession(ws, nickname, publicKey, room = 'general') {
+  addSession(ws, nickname, publicKey, room = 'general', pqPublicKey = null) {
     const sessionId = randomUUID();
     const session = {
       ws,
       nickname,
       publicKey,
+      pqPublicKey, // ML-KEM-768 key, relayed verbatim (server never uses it)
       connectedAt: Date.now(),
-      room,
+      rooms: new Set(),
     };
 
     this.#sessions.set(sessionId, session);
@@ -54,7 +55,9 @@ export class SessionManager {
       return null;
     }
 
-    this.#leaveRoom(sessionId);
+    for (const room of [...session.rooms]) {
+      this.#leaveRoom(sessionId, room);
+    }
     this.#nicknames.delete(session.nickname.toLowerCase());
     this.#sessions.delete(sessionId);
     this.#muteState.delete(sessionId);
@@ -93,19 +96,49 @@ export class SessionManager {
     const peers = [];
     for (const [id, session] of this.#sessions) {
       if (id !== excludeSessionId) {
-        if (room && session.room !== room) {
+        if (room && !session.rooms.has(room)) {
           continue;
         }
         peers.push({
           sessionId: id,
           nickname: session.nickname,
           publicKey: session.publicKey,
+          ...(session.pqPublicKey ? { pqPublicKey: session.pqPublicKey } : {}),
         });
       }
     }
     return peers;
   }
 
+  /**
+   * Send a message once to every session that shares at least one room with
+   * the given session (deduplicated — a peer in two shared rooms gets one).
+   */
+  broadcastToPeersOf(sessionId, msg, excludeSessionId = sessionId) {
+    const session = this.#sessions.get(sessionId);
+    if (!session) {
+      return;
+    }
+    const data = JSON.stringify(msg);
+    const notified = new Set();
+    for (const room of session.rooms) {
+      const members = this.#rooms.get(room);
+      if (!members) {
+        continue;
+      }
+      for (const sid of members) {
+        if (sid === excludeSessionId || notified.has(sid)) {
+          continue;
+        }
+        notified.add(sid);
+        const peer = this.#sessions.get(sid);
+        if (peer && peer.ws.readyState === 1) {
+          peer.ws.send(data);
+        }
+      }
+    }
+  }
+
   /**
    * Send a JSON message to all sessions except one.
    */
@@ -147,6 +180,7 @@ export class SessionManager {
       this.#rooms.set(room, new Set());
     }
     this.#rooms.get(room).add(sessionId);
+    this.#sessions.get(sessionId)?.rooms.add(room);
 
     // First person to create/join an empty non-general room becomes owner
     if (isNew && room !== 'general' && !this.#roomOwners.has(room)) {
@@ -155,13 +189,13 @@ export class SessionManager {
     }
   }
 
-  #leaveRoom(sessionId) {
+  #leaveRoom(sessionId, room) {
     const session = this.#sessions.get(sessionId);
     if (!session) {
       return;
     }
 
-    const room = session.room;
+    session.rooms.delete(room);
     const members = this.#rooms.get(room);
     if (members) {
       members.delete(sessionId);
@@ -185,23 +219,68 @@ export class SessionManager {
     }
   }
 
+  /**
+   * Legacy single-room semantics (protocol `change_room`): leave every
+   * current room and end up only in `newRoom`.
+   */
   switchRoom(sessionId, newRoom) {
     const session = this.#sessions.get(sessionId);
     if (!session) {
       return null;
     }
 
-    const oldRoom = session.room;
-    if (oldRoom === newRoom) {
-      return null;
+    if (session.rooms.size === 1 && session.rooms.has(newRoom)) {
+      return null; // already exactly there
     }
 
-    this.#leaveRoom(sessionId);
-    session.room = newRoom;
+    const oldRooms = [...session.rooms].filter((r) => r !== newRoom);
+    for (const room of oldRooms) {
+      this.#leaveRoom(sessionId, room);
+    }
     this.#joinRoom(sessionId, newRoom);
 
-    log.info(`${session.nickname} switched room: ${oldRoom} → ${newRoom}`);
-    return { oldRoom, newRoom };
+    log.info(`${session.nickname} switched room: ${oldRooms.join(',') || '-'} → ${newRoom}`);
+    return { oldRoom: oldRooms[0] || null, oldRooms, newRoom };
+  }
+
+  /**
+   * Multi-room: join an ADDITIONAL room, keeping the current ones.
+   * Returns null when already a member.
+   */
+  joinAdditional(sessionId, room) {
+    const session = this.#sessions.get(sessionId);
+    if (!session || session.rooms.has(room)) {
+      return null;
+    }
+    this.#joinRoom(sessionId, room);
+    log.info(`${session.nickname} joined room ${room} (now in ${session.rooms.size})`);
+    return { room };
+  }
+
+  /**
+   * Multi-room: leave one room. Refuses to leave the last one (a session is
+   * always somewhere — that keeps peer visibility and moderation coherent).
+   */
+  leaveOneRoom(sessionId, room) {
+    const session = this.#sessions.get(sessionId);
+    if (!session || !session.rooms.has(room)) {
+      return null;
+    }
+    if (session.rooms.size === 1) {
+      return { lastRoom: true };
+    }
+    this.#leaveRoom(sessionId, room);
+    log.info(`${session.nickname} left room ${room} (now in ${session.rooms.size})`);
+    return { room };
+  }
+
+  getSessionRooms(sessionId) {
+    const session = this.#sessions.get(sessionId);
+    return session ? [...session.rooms] : [];
+  }
+
+  isInRoom(sessionId, room) {
+    return this.#sessions.get(sessionId)?.rooms.has(room) === true;
   }
 
   getRoomPeers(room, excludeSessionId) {
@@ -241,9 +320,16 @@ export class SessionManager {
     return this.#roomMeta.get(room)?.authPk || null;
   }
 
+  /**
+   * Legacy helper: a session's room when it has exactly one; null otherwise.
+   * Multi-room callers must pass the room explicitly instead.
+   */
   getSessionRoom(sessionId) {
     const session = this.#sessions.get(sessionId);
-    return session?.room || null;
+    if (!session) {
+      return null;
+    }
+    return session.rooms.size === 1 ? [...session.rooms][0] : null;
   }
 
   updatePublicKey(sessionId, newPublicKey) {