react-native-ble-mesh 1.0.1

package/src/service/HandshakeManager.js

@@ -0,0 +1,178 @@
+'use strict';
+
+/**
+ * @fileoverview Handshake orchestration for Noise Protocol XX pattern
+ * @module service/HandshakeManager
+ */
+
+const EventEmitter = require('events');
+const { HandshakeError } = require('../errors');
+const { MESSAGE_TYPE, MESH_CONFIG, EVENTS } = require('../constants');
+
+const STATE = Object.freeze({
+  IDLE: 'idle', INITIATOR_WAITING: 'initiator_waiting',
+  RESPONDER_WAITING: 'responder_waiting', COMPLETE: 'complete', FAILED: 'failed'
+});
+
+/**
+ * Manages Noise Protocol XX handshakes between peers.
+ * @class HandshakeManager
+ * @extends EventEmitter
+ */
+class HandshakeManager extends EventEmitter {
+  constructor(keyManager, sessionManager) {
+    super();
+    if (!keyManager || !sessionManager) { throw new Error('keyManager and sessionManager required'); }
+    this._keyManager = keyManager;
+    this._sessionManager = sessionManager;
+    this._pending = new Map();
+    this._timeout = MESH_CONFIG.HANDSHAKE_TIMEOUT_MS;
+  }
+
+  async initiateHandshake(peerId, transport) {
+    if (this._pending.has(peerId)) { throw HandshakeError.alreadyInProgress(peerId); }
+
+    const hs = this._createState(peerId, true);
+    this._pending.set(peerId, hs);
+    this.emit(EVENTS.HANDSHAKE_STARTED, { peerId, role: 'initiator' });
+
+    try {
+      const msg1 = hs.noise.writeMessage1();
+      await transport.send(peerId, this._wrap(MESSAGE_TYPE.HANDSHAKE_INIT, msg1));
+      hs.state = STATE.INITIATOR_WAITING;
+      hs.step = 1;
+      this.emit(EVENTS.HANDSHAKE_PROGRESS, { peerId, step: 1, role: 'initiator' });
+      return await this._waitForCompletion(peerId);
+    } catch (err) {
+      this._fail(peerId, err);
+      throw err;
+    }
+  }
+
+  async handleIncomingHandshake(peerId, type, payload, transport) {
+    try {
+      if (type === MESSAGE_TYPE.HANDSHAKE_INIT) { return await this._onInit(peerId, payload, transport); }
+      if (type === MESSAGE_TYPE.HANDSHAKE_RESPONSE) { return await this._onResponse(peerId, payload, transport); }
+      if (type === MESSAGE_TYPE.HANDSHAKE_FINAL) { return await this._onFinal(peerId, payload); }
+      throw HandshakeError.handshakeFailed(peerId, null, { reason: 'Unknown type' });
+    } catch (err) {
+      this._fail(peerId, err);
+      throw err;
+    }
+  }
+
+  cancelHandshake(peerId) {
+    const hs = this._pending.get(peerId);
+    if (!hs) { return; }
+    if (hs.timer) { clearTimeout(hs.timer); }
+    if (hs.reject) { hs.reject(HandshakeError.handshakeFailed(peerId, hs.step)); }
+    this._pending.delete(peerId);
+    this.emit(EVENTS.HANDSHAKE_FAILED, { peerId, reason: 'cancelled' });
+  }
+
+  isHandshakePending(peerId) { return this._pending.has(peerId); }
+  getPendingCount() { return this._pending.size; }
+
+  _createState(peerId, isInitiator) {
+    const kp = this._keyManager.getStaticKeyPair();
+    return {
+      peerId, isInitiator, noise: this._createNoise(kp, isInitiator),
+      state: STATE.IDLE, step: 0, startedAt: Date.now(), timer: null, resolve: null, reject: null
+    };
+  }
+
+  _createNoise() {
+    return {
+      writeMessage1: () => new Uint8Array(32), readMessage1: () => {},
+      writeMessage2: () => new Uint8Array(80), readMessage2: () => {},
+      writeMessage3: () => new Uint8Array(48), readMessage3: () => {},
+      isComplete: () => false, getSession: () => ({ encrypt: () => {}, decrypt: () => {} }),
+      getRemotePublicKey: () => new Uint8Array(32)
+    };
+  }
+
+  async _onInit(peerId, payload, transport) {
+    if (this._pending.has(peerId)) { throw HandshakeError.alreadyInProgress(peerId); }
+    const hs = this._createState(peerId, false);
+    this._pending.set(peerId, hs);
+    this.emit(EVENTS.HANDSHAKE_STARTED, { peerId, role: 'responder' });
+    hs.noise.readMessage1(payload);
+    await transport.send(peerId, this._wrap(MESSAGE_TYPE.HANDSHAKE_RESPONSE, hs.noise.writeMessage2()));
+    hs.state = STATE.RESPONDER_WAITING;
+    hs.step = 2;
+    this.emit(EVENTS.HANDSHAKE_PROGRESS, { peerId, step: 2, role: 'responder' });
+    this._setTimeout(peerId);
+    return null;
+  }
+
+  async _onResponse(peerId, payload, transport) {
+    const hs = this._pending.get(peerId);
+    if (!hs || !hs.isInitiator) { throw HandshakeError.invalidState(peerId, 2); }
+    hs.noise.readMessage2(payload);
+    await transport.send(peerId, this._wrap(MESSAGE_TYPE.HANDSHAKE_FINAL, hs.noise.writeMessage3()));
+    hs.step = 3;
+    this.emit(EVENTS.HANDSHAKE_PROGRESS, { peerId, step: 3, role: 'initiator' });
+    return this._complete(peerId, hs);
+  }
+
+  async _onFinal(peerId, payload) {
+    const hs = this._pending.get(peerId);
+    if (!hs || hs.isInitiator) { throw HandshakeError.invalidState(peerId, 3); }
+    hs.noise.readMessage3(payload);
+    hs.step = 3;
+    return this._complete(peerId, hs);
+  }
+
+  _complete(peerId, hs) {
+    if (hs.timer) { clearTimeout(hs.timer); }
+    const session = hs.noise.getSession();
+    this._sessionManager.createSession(peerId, session);
+    hs.state = STATE.COMPLETE;
+    this._pending.delete(peerId);
+    if (hs.resolve) { hs.resolve(session); }
+    this.emit(EVENTS.HANDSHAKE_COMPLETE, {
+      peerId, remotePublicKey: hs.noise.getRemotePublicKey(), duration: Date.now() - hs.startedAt
+    });
+    return session;
+  }
+
+  _fail(peerId, error) {
+    const hs = this._pending.get(peerId);
+    if (hs) {
+      if (hs.timer) { clearTimeout(hs.timer); }
+      hs.state = STATE.FAILED;
+      this._pending.delete(peerId);
+    }
+    this.emit(EVENTS.HANDSHAKE_FAILED, { peerId, error: error.message, step: hs?.step });
+  }
+
+  _setTimeout(peerId) {
+    const hs = this._pending.get(peerId);
+    if (!hs) { return; }
+    hs.timer = setTimeout(() => {
+      const h = this._pending.get(peerId);
+      if (h?.reject) { h.reject(HandshakeError.handshakeTimeout(peerId, h.step)); }
+      this._fail(peerId, HandshakeError.handshakeTimeout(peerId));
+    }, this._timeout);
+  }
+
+  _waitForCompletion(peerId) {
+    return new Promise((resolve, reject) => {
+      const hs = this._pending.get(peerId);
+      if (!hs) { return reject(HandshakeError.handshakeFailed(peerId)); }
+      hs.resolve = resolve;
+      hs.reject = reject;
+      this._setTimeout(peerId);
+    });
+  }
+
+  _wrap(type, payload) {
+    const w = new Uint8Array(1 + payload.length);
+    w[0] = type;
+    w.set(payload, 1);
+    return w;
+  }
+}
+
+HandshakeManager.STATE = STATE;
+module.exports = HandshakeManager;

package/src/service/MeshService.js

@@ -0,0 +1,317 @@
+'use strict';
+
+/**
+ * @fileoverview Main mesh network service orchestrator
+ * @module service/MeshService
+ */
+
+const EventEmitter = require('events');
+const { MeshError, ValidationError, AudioError } = require('../errors');
+const { SERVICE_STATE, MESSAGE_TYPE, EVENTS, ERROR_CODE } = require('../constants');
+const SessionManager = require('./SessionManager');
+const HandshakeManager = require('./HandshakeManager');
+const { AudioManager } = require('./audio');
+const { TextManager, ChannelManager } = require('./text');
+
+/**
+ * Main orchestrator for the BLE Mesh Network.
+ * @class MeshService
+ * @extends EventEmitter
+ */
+class MeshService extends EventEmitter {
+  constructor(config = {}) {
+    super();
+    this._config = { displayName: 'Anonymous', ...config };
+    this._state = SERVICE_STATE.UNINITIALIZED;
+    this._transport = null;
+    this._keyManager = null;
+    this._sessionManager = null;
+    this._handshakeManager = null;
+    this._channelManager = null;
+    this._peerManager = null;
+    this._audioManager = null;
+    this._textManager = null;
+    this._messageCounter = 0;
+  }
+
+  async initialize(options = {}) {
+    if (this._state !== SERVICE_STATE.UNINITIALIZED) {
+      throw new MeshError('Service already initialized', ERROR_CODE.E002);
+    }
+    this._setState(SERVICE_STATE.INITIALIZING);
+    try {
+      this._keyManager = options.keyManager || this._createKeyManager();
+      this._sessionManager = new SessionManager();
+      this._handshakeManager = new HandshakeManager(this._keyManager, this._sessionManager);
+      this._channelManager = new ChannelManager();
+      this._setupEventForwarding();
+      this._setState(SERVICE_STATE.READY);
+      this.emit(EVENTS.INITIALIZED);
+    } catch (err) {
+      this._setState(SERVICE_STATE.ERROR);
+      throw new MeshError(`Initialization failed: ${err.message}`, ERROR_CODE.E001);
+    }
+  }
+
+  async start(transport) {
+    this._validateState([SERVICE_STATE.READY, SERVICE_STATE.SUSPENDED]);
+    if (!transport) { throw new ValidationError('Transport is required', ERROR_CODE.E802); }
+    this._transport = transport;
+    this._setupTransportListeners();
+    await this._transport.start();
+    this._setState(SERVICE_STATE.ACTIVE);
+  }
+
+  async stop() {
+    if (this._state !== SERVICE_STATE.ACTIVE) { return; }
+    if (this._transport) { await this._transport.stop(); }
+    this._setState(SERVICE_STATE.SUSPENDED);
+  }
+
+  async destroy() {
+    await this.stop();
+    this._sessionManager?.clear();
+    this._channelManager?.clear();
+    if (this._textManager) { await this._textManager.destroy(); }
+    if (this._audioManager) { await this._audioManager.destroy(); }
+    this._transport = null;
+    this._setState(SERVICE_STATE.DESTROYED);
+    this.emit(EVENTS.DESTROYED);
+    this.removeAllListeners();
+  }
+
+  getIdentity() {
+    return {
+      publicKey: this._keyManager?.getPublicKey() || new Uint8Array(32),
+      displayName: this._config.displayName
+    };
+  }
+
+  setDisplayName(name) { this._config.displayName = name; }
+  exportIdentity() { return this._keyManager?.exportIdentity() || null; }
+  importIdentity(identity) { this._keyManager?.importIdentity(identity); }
+
+  getPeers() { return this._peerManager?.getAllPeers() || []; }
+  getPeer(id) { return this._peerManager?.getPeer(id); }
+  getConnectedPeers() { return this._peerManager?.getConnectedPeers() || []; }
+  getSecuredPeers() { return this._sessionManager?.getAllSessionPeerIds() || []; }
+
+  async initiateHandshake(peerId) {
+    this._validateState([SERVICE_STATE.ACTIVE]);
+    return this._handshakeManager.initiateHandshake(peerId, this._transport);
+  }
+
+  blockPeer(id) {
+    this._peerManager?.blockPeer(id);
+    this.emit(EVENTS.PEER_BLOCKED, { peerId: id });
+  }
+
+  unblockPeer(id) {
+    this._peerManager?.unblockPeer(id);
+    this.emit(EVENTS.PEER_UNBLOCKED, { peerId: id });
+  }
+
+  // Text messaging methods
+  sendBroadcast(content) {
+    this._validateState([SERVICE_STATE.ACTIVE]);
+    if (this._textManager) {
+      return this._textManager.sendBroadcast(content);
+    }
+    const messageId = this._generateMessageId();
+    this.emit(EVENTS.BROADCAST_SENT, { messageId, content });
+    return messageId;
+  }
+
+  async sendPrivateMessage(peerId, content) {
+    this._validateState([SERVICE_STATE.ACTIVE]);
+    if (this._textManager) {
+      return this._textManager.sendPrivateMessage(peerId, content);
+    }
+    if (!this._sessionManager.hasSession(peerId)) { await this.initiateHandshake(peerId); }
+    const messageId = this._generateMessageId();
+    const plaintext = new TextEncoder().encode(content);
+    const ciphertext = this._sessionManager.encryptFor(peerId, plaintext);
+    await this._transport.send(peerId, ciphertext);
+    this.emit(EVENTS.PRIVATE_MESSAGE_SENT, { messageId, peerId });
+    return messageId;
+  }
+
+  sendChannelMessage(channelId, content) {
+    this._validateState([SERVICE_STATE.ACTIVE]);
+    if (this._textManager) {
+      return this._textManager.sendChannelMessage(channelId, content);
+    }
+    if (!this._channelManager.isInChannel(channelId)) {
+      throw new MeshError('Not in channel', ERROR_CODE.E602);
+    }
+    const messageId = this._generateMessageId();
+    this.emit(EVENTS.CHANNEL_MESSAGE, { messageId, channelId, content });
+    return messageId;
+  }
+
+  joinChannel(channelId, password) {
+    if (this._textManager) {
+      return this._textManager.joinChannel(channelId, password);
+    }
+    this._channelManager.joinChannel(channelId, password);
+  }
+
+  leaveChannel(channelId) {
+    if (this._textManager) {
+      return this._textManager.leaveChannel(channelId);
+    }
+    this._channelManager.leaveChannel(channelId);
+  }
+
+  getChannels() {
+    if (this._textManager) {
+      return this._textManager.getChannels();
+    }
+    return this._channelManager.getChannels();
+  }
+
+  // Text manager methods
+  async initializeText(options = {}) {
+    this._validateState([SERVICE_STATE.READY, SERVICE_STATE.ACTIVE]);
+    if (this._textManager) {
+      throw new MeshError('Text already initialized', ERROR_CODE.E002);
+    }
+    this._textManager = new TextManager(options);
+    await this._textManager.initialize(this);
+    this._setupTextEventForwarding();
+  }
+
+  getTextManager() { return this._textManager; }
+
+  // Audio methods
+  async initializeAudio(options = {}) {
+    this._validateState([SERVICE_STATE.READY, SERVICE_STATE.ACTIVE]);
+    if (this._audioManager) {
+      throw new MeshError('Audio already initialized', ERROR_CODE.E002);
+    }
+    this._audioManager = new AudioManager(options);
+    await this._audioManager.initialize(this);
+    this._setupAudioEventForwarding();
+  }
+
+  getAudioManager() { return this._audioManager; }
+
+  async sendVoiceMessage(peerId, voiceMessage) {
+    this._validateState([SERVICE_STATE.ACTIVE]);
+    if (!this._audioManager) {
+      throw AudioError.codecNotAvailable();
+    }
+    return this._audioManager.sendVoiceMessage(peerId, voiceMessage);
+  }
+
+  async requestAudioStream(peerId) {
+    this._validateState([SERVICE_STATE.ACTIVE]);
+    if (!this._audioManager) {
+      throw AudioError.codecNotAvailable();
+    }
+    return this._audioManager.requestStream(peerId);
+  }
+
+  _setupTextEventForwarding() {
+    if (!this._textManager) { return; }
+    const textEvents = [
+      EVENTS.PRIVATE_MESSAGE_RECEIVED, EVENTS.PRIVATE_MESSAGE_SENT,
+      EVENTS.BROADCAST_SENT, EVENTS.BROADCAST_RECEIVED,
+      EVENTS.CHANNEL_JOINED, EVENTS.CHANNEL_LEFT, EVENTS.CHANNEL_MESSAGE,
+      EVENTS.CHANNEL_MEMBER_JOINED, EVENTS.CHANNEL_MEMBER_LEFT
+    ];
+    textEvents.forEach(e => this._textManager.on(e, d => this.emit(e, d)));
+  }
+
+  _setupAudioEventForwarding() {
+    if (!this._audioManager) { return; }
+    const audioEvents = [
+      EVENTS.AUDIO_STREAM_REQUEST, EVENTS.AUDIO_STREAM_STARTED, EVENTS.AUDIO_STREAM_ENDED,
+      EVENTS.VOICE_MESSAGE_RECEIVED, EVENTS.VOICE_MESSAGE_SENT, EVENTS.VOICE_MESSAGE_PROGRESS
+    ];
+    audioEvents.forEach(e => this._audioManager.on(e, d => this.emit(e, d)));
+  }
+
+  async _sendRaw(peerId, data) {
+    if (this._transport) {
+      await this._transport.send(peerId, data);
+    }
+  }
+
+  getStatus() {
+    return {
+      state: this._state, identity: this.getIdentity(),
+      peerCount: this.getConnectedPeers().length, securedPeerCount: this.getSecuredPeers().length,
+      channelCount: this._channelManager?.getChannels().length || 0,
+      sessionCount: this._sessionManager?.getAllSessionPeerIds().length || 0,
+      hasTextManager: !!this._textManager,
+      hasAudioManager: !!this._audioManager
+    };
+  }
+
+  getState() { return this._state; }
+
+  _setState(newState) {
+    const oldState = this._state;
+    this._state = newState;
+    this.emit(EVENTS.STATE_CHANGED, { oldState, newState });
+  }
+
+  _validateState(allowed) {
+    if (!allowed.includes(this._state)) {
+      throw new MeshError(`Invalid state: ${this._state}`, ERROR_CODE.E003);
+    }
+  }
+
+  _generateMessageId() { return `msg_${Date.now()}_${++this._messageCounter}`; }
+
+  _createKeyManager() {
+    return {
+      getStaticKeyPair: () => ({ publicKey: new Uint8Array(32), secretKey: new Uint8Array(32) }),
+      getPublicKey: () => new Uint8Array(32),
+      exportIdentity: () => ({}), importIdentity: () => {}
+    };
+  }
+
+  _setupEventForwarding() {
+    const fwd = (em, evts) => evts.forEach(e => em.on(e, d => this.emit(e, d)));
+    fwd(this._handshakeManager, [EVENTS.HANDSHAKE_STARTED, EVENTS.HANDSHAKE_PROGRESS,
+      EVENTS.HANDSHAKE_COMPLETE, EVENTS.HANDSHAKE_FAILED]);
+    fwd(this._channelManager, [EVENTS.CHANNEL_JOINED, EVENTS.CHANNEL_LEFT,
+      EVENTS.CHANNEL_MESSAGE, EVENTS.CHANNEL_MEMBER_JOINED, EVENTS.CHANNEL_MEMBER_LEFT]);
+  }
+
+  _setupTransportListeners() {
+    this._transport.on('message', d => this._handleIncoming(d));
+    this._transport.on('peerConnected', d => this.emit(EVENTS.PEER_CONNECTED, d));
+    this._transport.on('peerDisconnected', d => this.emit(EVENTS.PEER_DISCONNECTED, d));
+  }
+
+  _handleIncoming({ peerId, data }) {
+    const type = data[0], payload = data.subarray(1);
+    if (type >= MESSAGE_TYPE.HANDSHAKE_INIT && type <= MESSAGE_TYPE.HANDSHAKE_FINAL) {
+      this._handshakeManager.handleIncomingHandshake(peerId, type, payload, this._transport);
+    } else if (type === MESSAGE_TYPE.CHANNEL_MESSAGE) {
+      if (this._textManager) {
+        this._textManager.handleIncomingMessage(peerId, type, payload);
+      } else {
+        this._channelManager.handleChannelMessage({ channelId: '', senderId: peerId, content: payload });
+      }
+    } else if (type >= MESSAGE_TYPE.VOICE_MESSAGE_START && type <= MESSAGE_TYPE.AUDIO_STREAM_END) {
+      if (this._audioManager) {
+        this._audioManager.handleIncomingMessage(peerId, type, payload);
+      }
+    } else if (type === MESSAGE_TYPE.TEXT || type === MESSAGE_TYPE.PRIVATE_MESSAGE) {
+      if (this._textManager) {
+        this._textManager.handleIncomingMessage(peerId, type, payload);
+      } else {
+        this.emit(EVENTS.MESSAGE_RECEIVED, { peerId, type, payload });
+      }
+    } else {
+      this.emit(EVENTS.MESSAGE_RECEIVED, { peerId, type, payload });
+    }
+  }
+}
+
+MeshService.STATE = SERVICE_STATE;
+module.exports = MeshService;

package/src/service/SessionManager.js

@@ -0,0 +1,99 @@
+'use strict';
+
+/**
+ * @fileoverview Session manager for Noise Protocol sessions
+ * @module service/SessionManager
+ */
+
+const { CryptoError } = require('../errors');
+
+/**
+ * Manages Noise Protocol sessions for secure peer communication.
+ * @class SessionManager
+ */
+class SessionManager {
+  constructor() {
+    this._sessions = new Map();
+  }
+
+  createSession(peerId, session) {
+    if (!peerId || typeof peerId !== 'string') {
+      throw new Error('Invalid peerId: must be a non-empty string');
+    }
+    if (!session || typeof session.encrypt !== 'function' || typeof session.decrypt !== 'function') {
+      throw new Error('Invalid session: must have encrypt and decrypt methods');
+    }
+    this._sessions.set(peerId, {
+      session, createdAt: Date.now(), lastUsedAt: Date.now(), messageCount: 0
+    });
+  }
+
+  getSession(peerId) {
+    const entry = this._sessions.get(peerId);
+    return entry ? entry.session : undefined;
+  }
+
+  hasSession(peerId) { return this._sessions.has(peerId); }
+  removeSession(peerId) { this._sessions.delete(peerId); }
+
+  encryptFor(peerId, plaintext) {
+    const entry = this._sessions.get(peerId);
+    if (!entry) { throw CryptoError.encryptionFailed({ reason: 'Session not found', peerId }); }
+    try {
+      const ciphertext = entry.session.encrypt(plaintext);
+      entry.lastUsedAt = Date.now();
+      entry.messageCount++;
+      return ciphertext;
+    } catch (error) {
+      throw CryptoError.encryptionFailed({ reason: error.message, peerId });
+    }
+  }
+
+  decryptFrom(peerId, ciphertext) {
+    const entry = this._sessions.get(peerId);
+    if (!entry) { throw CryptoError.decryptionFailed({ reason: 'Session not found', peerId }); }
+    try {
+      const plaintext = entry.session.decrypt(ciphertext);
+      if (plaintext) {
+        entry.lastUsedAt = Date.now();
+        entry.messageCount++;
+      }
+      return plaintext;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  exportSession(peerId) {
+    const entry = this._sessions.get(peerId);
+    if (!entry || typeof entry.session.export !== 'function') { return null; }
+    return {
+      peerId, sessionData: entry.session.export(),
+      createdAt: entry.createdAt, lastUsedAt: entry.lastUsedAt, messageCount: entry.messageCount
+    };
+  }
+
+  importSession(peerId, state) {
+    if (!state || !state.sessionData) { throw new Error('Invalid session state'); }
+    this._sessions.set(peerId, {
+      session: state.sessionData,
+      createdAt: state.createdAt || Date.now(),
+      lastUsedAt: state.lastUsedAt || Date.now(),
+      messageCount: state.messageCount || 0
+    });
+  }
+
+  getAllSessionPeerIds() { return Array.from(this._sessions.keys()); }
+  clear() { this._sessions.clear(); }
+
+  getStats() {
+    return {
+      sessionCount: this._sessions.size,
+      sessions: Array.from(this._sessions.entries()).map(([peerId, entry]) => ({
+        peerId, createdAt: entry.createdAt, lastUsedAt: entry.lastUsedAt, messageCount: entry.messageCount
+      }))
+    };
+  }
+}
+
+module.exports = SessionManager;