ciphermesh 2.0.0 → 2.2.0

package/src/protocol/messages.js

@@ -12,8 +12,14 @@ 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',
+  ROOM_AUTH: 'room_auth',
   KICK_PEER: 'kick_peer',
   MUTE_PEER: 'mute_peer',
   BAN_PEER: 'ban_peer',
@@ -30,6 +36,8 @@ export const ERR = {
   PEER_NOT_FOUND: 'PEER_NOT_FOUND',
   RATE_LIMITED: 'RATE_LIMITED',
   PAYLOAD_TOO_LARGE: 'PAYLOAD_TOO_LARGE',
+  ROOM_AUTH_FAILED: 'ROOM_AUTH_FAILED',
+  ROOM_EXISTS: 'ROOM_EXISTS',
 };
 
 // ── Factory helpers ────────────────────────────────────────────
@@ -49,12 +57,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) {
@@ -108,12 +126,62 @@ export function createPong() {
   return base(MSG.PONG);
 }
 
-export function createChangeRoom(room) {
-  return { ...base(MSG.CHANGE_ROOM), room };
+// roomAuthPk (optional): Ed25519 verifier public key — present only when
+// CREATING a private room; the server stores it in memory as the room's
+// password verifier (see crypto/RoomKey.js).
+export function createChangeRoom(room, roomAuthPkB64 = null) {
+  const msg = { ...base(MSG.CHANGE_ROOM), room };
+  if (roomAuthPkB64) {
+    msg.roomAuthPk = roomAuthPkB64;
+  }
+  return msg;
+}
+
+export function createRoomChanged(room, peers, isPrivate = false) {
+  const msg = { ...base(MSG.ROOM_CHANGED), room, peers };
+  if (isPrivate) {
+    msg.private = true;
+  }
+  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) {
+  return { ...base(MSG.ROOM_CHALLENGE), room, nonce: nonceB64 };
 }
 
-export function createRoomChanged(room, peers) {
-  return { ...base(MSG.ROOM_CHANGED), room, peers };
+// Client → server: Ed25519 signature over (room, nonce, sessionId) with the
+// password-derived key (see crypto/RoomKey.js#signRoomChallenge).
+export function createRoomAuth(room, nonceB64, signatureB64) {
+  return { ...base(MSG.ROOM_AUTH), room, nonce: nonceB64, signature: signatureB64 };
 }
 
 export function createListRooms() {

package/src/protocol/validators.js

@@ -3,6 +3,9 @@ import {
   MAX_NICKNAME_LENGTH,
   MAX_PAYLOAD_SIZE,
   PUBLIC_KEY_SIZE,
+  ROOM_AUTH_PK_SIZE,
+  ROOM_AUTH_SIG_SIZE,
+  ROOM_CHALLENGE_NONCE_SIZE,
 } from '../shared/constants.js';
 
 // ── Helpers ────────────────────────────────────────────────────
@@ -109,6 +112,26 @@ export function validateKeyUpdate(msg) {
 }
 
 export function validateChangeRoom(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' };
+  }
+  // Optional: Ed25519 verifier public key, present only when creating a
+  // private room.
+  if (msg.roomAuthPk !== undefined && !isValidBase64(msg.roomAuthPk, ROOM_AUTH_PK_SIZE)) {
+    return { valid: false, error: 'Invalid room verifier key' };
+  }
+  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)' };
   }
@@ -118,19 +141,47 @@ export function validateChangeRoom(msg) {
   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)' };
+  }
+  if (!isValidBase64(msg.nonce, ROOM_CHALLENGE_NONCE_SIZE)) {
+    return { valid: false, error: 'Invalid challenge nonce' };
+  }
+  if (!isValidBase64(msg.signature, ROOM_AUTH_SIG_SIZE)) {
+    return { valid: false, error: 'Invalid challenge signature' };
+  }
+  return { valid: true, room: msg.room.toLowerCase(), nonce: msg.nonce, signature: msg.signature };
+}
+
 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,
   };
 }
 
@@ -142,7 +193,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) {
@@ -150,10 +205,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,13 +4,14 @@ 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>>
   #roomOwners; // Map<roomName, sessionId>
   #muteState; // Map<sessionId, { until: timestamp }>
   #banList; // Map<roomName, Set<nickname_lower>>
+  #roomMeta; // Map<roomName, { authPk: base64 }> — private-room verifiers (memory only)
 
   constructor() {
     this.#sessions = new Map();
@@ -20,6 +21,7 @@ export class SessionManager {
     this.#roomOwners = new Map();
     this.#muteState = new Map();
     this.#banList = new Map();
+    this.#roomMeta = new Map();
     // Ensure default room exists
     this.#rooms.set('general', new Set());
   }
@@ -35,7 +37,7 @@ export class SessionManager {
       nickname,
       publicKey,
       connectedAt: Date.now(),
-      room,
+      rooms: new Set(),
     };
 
     this.#sessions.set(sessionId, session);
@@ -52,7 +54,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);
@@ -91,7 +95,7 @@ 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({
@@ -104,6 +108,35 @@ export class SessionManager {
     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.
    */
@@ -145,6 +178,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)) {
@@ -153,13 +187,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);
@@ -167,9 +201,12 @@ export class SessionManager {
       if (members.size === 0 && room !== 'general') {
         // Empty non-general room — drop it and all associated moderation state
         // (otherwise a recreated room stays owner-less and unmoderatable).
+        // The private-room verifier dies here too: the room and its password
+        // exist only while someone is inside.
         this.#rooms.delete(room);
         this.#roomOwners.delete(room);
         this.#banList.delete(room);
+        this.#roomMeta.delete(room);
       } else if (this.#roomOwners.get(room) === sessionId) {
         // Owner left but room still has members — transfer ownership so the
         // room keeps a moderator instead of becoming owner-less.
@@ -180,23 +217,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) {
@@ -207,19 +289,45 @@ export class SessionManager {
     const rooms = [];
     for (const [name, members] of this.#rooms) {
       if (members.size > 0) {
-        rooms.push({ name, memberCount: members.size });
+        rooms.push({ name, memberCount: members.size, private: this.#roomMeta.has(name) });
       }
     }
     // Always include 'general' even if empty
     if (!rooms.some((r) => r.name === 'general')) {
-      rooms.unshift({ name: 'general', memberCount: 0 });
+      rooms.unshift({ name: 'general', memberCount: 0, private: false });
     }
     return rooms.sort((a, b) => a.name.localeCompare(b.name));
   }
 
+  // ── Private rooms ────────────────────────────────────────────
+
+  roomHasMembers(room) {
+    const members = this.#rooms.get(room);
+    return !!members && members.size > 0;
+  }
+
+  setRoomPrivate(room, authPkB64) {
+    this.#roomMeta.set(room, { authPk: authPkB64 });
+  }
+
+  isRoomPrivate(room) {
+    return this.#roomMeta.has(room);
+  }
+
+  getRoomAuthPk(room) {
+    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) {