react-native-ble-mesh 1.0.1

package/src/crypto/sha256.js

@@ -0,0 +1,240 @@
+'use strict';
+
+/**
+ * SHA-256 Hash Function (FIPS 180-4)
+ * Pure JavaScript implementation for BLE Mesh Network
+ * @module crypto/sha256
+ */
+
+/**
+ * SHA-256 round constants K[64]
+ * First 32 bits of fractional parts of cube roots of first 64 primes
+ * @type {Uint32Array}
+ */
+const K = new Uint32Array([
+  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
+  0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+  0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
+  0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
+  0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+  0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
+  0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
+  0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+  0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+]);
+
+/**
+ * Initial hash values H[8]
+ * First 32 bits of fractional parts of square roots of first 8 primes
+ * @type {Uint32Array}
+ */
+const H_INIT = new Uint32Array([
+  0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
+  0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
+]);
+
+/**
+ * Right rotate a 32-bit integer
+ * @param {number} x - Value to rotate
+ * @param {number} n - Bits to rotate
+ * @returns {number} Rotated value
+ */
+function rotr(x, n) {
+  return ((x >>> n) | (x << (32 - n))) >>> 0;
+}
+
+/**
+ * SHA-256 compression function
+ * Processes a single 512-bit block
+ * @param {Uint32Array} H - Current hash state (8 words)
+ * @param {Uint32Array} W - Message schedule (64 words)
+ */
+function compress(H, W) {
+  // Extend 16 words to 64 words
+  for (let i = 16; i < 64; i++) {
+    const s0 = rotr(W[i - 15], 7) ^ rotr(W[i - 15], 18) ^ (W[i - 15] >>> 3);
+    const s1 = rotr(W[i - 2], 17) ^ rotr(W[i - 2], 19) ^ (W[i - 2] >>> 10);
+    W[i] = (W[i - 16] + s0 + W[i - 7] + s1) >>> 0;
+  }
+
+  // Initialize working variables
+  let a = H[0], b = H[1], c = H[2], d = H[3];
+  let e = H[4], f = H[5], g = H[6], h = H[7];
+
+  // 64 rounds
+  for (let i = 0; i < 64; i++) {
+    const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+    const ch = (e & f) ^ (~e & g);
+    const temp1 = (h + S1 + ch + K[i] + W[i]) >>> 0;
+    const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+    const maj = (a & b) ^ (a & c) ^ (b & c);
+    const temp2 = (S0 + maj) >>> 0;
+
+    h = g; g = f; f = e;
+    e = (d + temp1) >>> 0;
+    d = c; c = b; b = a;
+    a = (temp1 + temp2) >>> 0;
+  }
+
+  // Add compressed chunk to hash
+  H[0] = (H[0] + a) >>> 0;
+  H[1] = (H[1] + b) >>> 0;
+  H[2] = (H[2] + c) >>> 0;
+  H[3] = (H[3] + d) >>> 0;
+  H[4] = (H[4] + e) >>> 0;
+  H[5] = (H[5] + f) >>> 0;
+  H[6] = (H[6] + g) >>> 0;
+  H[7] = (H[7] + h) >>> 0;
+}
+
+/**
+ * HashContext for streaming SHA-256 computation
+ * @class
+ */
+class HashContext {
+  constructor() {
+    this._H = new Uint32Array(H_INIT);
+    this._buffer = new Uint8Array(64);
+    this._bufferLength = 0;
+    this._totalLength = 0;
+    this._finalized = false;
+  }
+
+  /**
+   * Update hash with additional data
+   * @param {Uint8Array} data - Data to hash
+   * @returns {HashContext} This context for chaining
+   */
+  update(data) {
+    if (this._finalized) {
+      throw new Error('Cannot update finalized hash');
+    }
+
+    const W = new Uint32Array(64);
+    let offset = 0;
+
+    // Process any buffered data first
+    if (this._bufferLength > 0) {
+      const needed = 64 - this._bufferLength;
+      const toCopy = Math.min(needed, data.length);
+      this._buffer.set(data.subarray(0, toCopy), this._bufferLength);
+      this._bufferLength += toCopy;
+      offset = toCopy;
+
+      if (this._bufferLength === 64) {
+        for (let i = 0; i < 16; i++) {
+          W[i] = (this._buffer[i * 4] << 24) | (this._buffer[i * 4 + 1] << 16) |
+                 (this._buffer[i * 4 + 2] << 8) | this._buffer[i * 4 + 3];
+        }
+        compress(this._H, W);
+        this._bufferLength = 0;
+      }
+    }
+
+    // Process complete 64-byte blocks
+    while (offset + 64 <= data.length) {
+      for (let i = 0; i < 16; i++) {
+        W[i] = (data[offset + i * 4] << 24) | (data[offset + i * 4 + 1] << 16) |
+               (data[offset + i * 4 + 2] << 8) | data[offset + i * 4 + 3];
+      }
+      compress(this._H, W);
+      offset += 64;
+    }
+
+    // Buffer remaining bytes
+    if (offset < data.length) {
+      this._buffer.set(data.subarray(offset), 0);
+      this._bufferLength = data.length - offset;
+    }
+
+    this._totalLength += data.length;
+    return this;
+  }
+
+  /**
+   * Finalize hash and return digest
+   * @returns {Uint8Array} 32-byte hash digest
+   */
+  digest() {
+    if (this._finalized) {
+      throw new Error('Hash already finalized');
+    }
+    this._finalized = true;
+
+    const W = new Uint32Array(64);
+    const bitLength = this._totalLength * 8;
+
+    // Append padding bit
+    this._buffer[this._bufferLength++] = 0x80;
+
+    // If not enough room for length, process current block
+    if (this._bufferLength > 56) {
+      this._buffer.fill(0, this._bufferLength, 64);
+      for (let i = 0; i < 16; i++) {
+        W[i] = (this._buffer[i * 4] << 24) | (this._buffer[i * 4 + 1] << 16) |
+               (this._buffer[i * 4 + 2] << 8) | this._buffer[i * 4 + 3];
+      }
+      compress(this._H, W);
+      this._bufferLength = 0;
+    }
+
+    // Pad with zeros and append 64-bit length (big-endian)
+    this._buffer.fill(0, this._bufferLength, 56);
+    // Note: JavaScript bitwise ops are 32-bit, handle high bits separately
+    const highBits = Math.floor(bitLength / 0x100000000);
+    this._buffer[56] = (highBits >>> 24) & 0xff;
+    this._buffer[57] = (highBits >>> 16) & 0xff;
+    this._buffer[58] = (highBits >>> 8) & 0xff;
+    this._buffer[59] = highBits & 0xff;
+    this._buffer[60] = (bitLength >>> 24) & 0xff;
+    this._buffer[61] = (bitLength >>> 16) & 0xff;
+    this._buffer[62] = (bitLength >>> 8) & 0xff;
+    this._buffer[63] = bitLength & 0xff;
+
+    for (let i = 0; i < 16; i++) {
+      W[i] = (this._buffer[i * 4] << 24) | (this._buffer[i * 4 + 1] << 16) |
+             (this._buffer[i * 4 + 2] << 8) | this._buffer[i * 4 + 3];
+    }
+    compress(this._H, W);
+
+    // Convert hash to bytes
+    const result = new Uint8Array(32);
+    for (let i = 0; i < 8; i++) {
+      result[i * 4] = (this._H[i] >>> 24) & 0xff;
+      result[i * 4 + 1] = (this._H[i] >>> 16) & 0xff;
+      result[i * 4 + 2] = (this._H[i] >>> 8) & 0xff;
+      result[i * 4 + 3] = this._H[i] & 0xff;
+    }
+    return result;
+  }
+}
+
+/**
+ * Create a new streaming hash context
+ * @returns {HashContext} New hash context
+ */
+function createHash() {
+  return new HashContext();
+}
+
+/**
+ * Compute SHA-256 hash of data
+ * @param {Uint8Array} data - Data to hash
+ * @returns {Uint8Array} 32-byte hash digest
+ */
+function hash(data) {
+  return createHash().update(data).digest();
+}
+
+module.exports = {
+  hash,
+  createHash,
+  HashContext
+};

package/src/crypto/x25519.js

@@ -0,0 +1,154 @@
+'use strict';
+
+/**
+ * @fileoverview X25519 Elliptic Curve Diffie-Hellman (RFC 7748)
+ * Pure JavaScript implementation using BigInt for field arithmetic.
+ * @module crypto/x25519
+ */
+
+const { randomBytes } = require('../utils/bytes');
+
+/** Prime field modulus: p = 2^255 - 19 */
+const P = (1n << 255n) - 19n;
+/** a24 = (A - 2) / 4 = 121665 where A = 486662 for Curve25519 */
+const A24 = 121665n;
+/** Base point u-coordinate */
+const BASE_POINT = 9n;
+
+/** Converts Uint8Array to BigInt (little-endian). */
+function bytesToBigInt(bytes) {
+  let result = 0n;
+  for (let i = bytes.length - 1; i >= 0; i--) {
+    result = (result << 8n) | BigInt(bytes[i]);
+  }
+  return result;
+}
+
+/** Converts BigInt to Uint8Array (little-endian, 32 bytes). */
+function bigIntToBytes(n) {
+  const bytes = new Uint8Array(32);
+  let value = n;
+  for (let i = 0; i < 32; i++) {
+    bytes[i] = Number(value & 0xffn);
+    value >>= 8n;
+  }
+  return bytes;
+}
+
+/** Field operations: add, sub, mul, square */
+const fieldAdd = (a, b) => (a + b) % P;
+const fieldSub = (a, b) => ((a - b) % P + P) % P;
+const fieldMul = (a, b) => (a * b) % P;
+const fieldSquare = (a) => (a * a) % P;
+
+/** Modular exponentiation using square-and-multiply. */
+function fieldPow(base, exp) {
+  let result = 1n;
+  base = base % P;
+  while (exp > 0n) {
+    if (exp & 1n) { result = fieldMul(result, base); }
+    exp >>= 1n;
+    base = fieldSquare(base);
+  }
+  return result;
+}
+
+/** Modular inverse using Fermat's little theorem: a^(-1) = a^(p-2) mod p. */
+const fieldInvert = (a) => fieldPow(a, P - 2n);
+
+/**
+ * Conditional swap - swaps a and b if swap is 1, otherwise leaves unchanged.
+ * Implemented without branching on secret data.
+ */
+function cswap(swap, a, b) {
+  const mask = -swap;
+  const diff = (a ^ b) & mask;
+  return [a ^ diff, b ^ diff];
+}
+
+/**
+ * Clamps a scalar per RFC 7748 Section 5.
+ * @param {Uint8Array} k - 32-byte scalar
+ * @returns {Uint8Array} Clamped scalar
+ */
+function clampScalar(k) {
+  const clamped = new Uint8Array(k);
+  clamped[0] &= 248; // Clear bits 0, 1, 2
+  clamped[31] &= 127; // Clear bit 7 of last byte
+  clamped[31] |= 64; // Set bit 6 of last byte
+  return clamped;
+}
+
+/**
+ * Montgomery ladder for X25519 scalar multiplication.
+ * Computes scalar * point on Curve25519.
+ * @param {Uint8Array} scalar - 32-byte scalar (will be clamped)
+ * @param {Uint8Array} point - 32-byte u-coordinate
+ * @returns {Uint8Array} 32-byte result u-coordinate
+ */
+function scalarMult(scalar, point) {
+  const k = bytesToBigInt(clampScalar(scalar));
+  let u = bytesToBigInt(point);
+
+  // Handle edge case: all-zeros point returns all-zeros
+  if (u === 0n) { return new Uint8Array(32); }
+  u = u % P;
+
+  // Montgomery ladder state (RFC 7748 naming convention)
+  // eslint-disable-next-line camelcase, prefer-const
+  let x_1 = u, x_2 = 1n, z_2 = 0n, x_3 = u, z_3 = 1n, swap = 0n;
+
+  // Process bits from 254 down to 0
+  for (let t = 254; t >= 0; t--) {
+    // eslint-disable-next-line camelcase
+    const k_t = (k >> BigInt(t)) & 1n;
+    swap ^= k_t; // eslint-disable-line camelcase
+    [x_2, x_3] = cswap(swap, x_2, x_3); // eslint-disable-line camelcase
+    [z_2, z_3] = cswap(swap, z_2, z_3); // eslint-disable-line camelcase
+    swap = k_t; // eslint-disable-line camelcase
+
+    const A = fieldAdd(x_2, z_2); // eslint-disable-line camelcase
+    const AA = fieldSquare(A);
+    const B = fieldSub(x_2, z_2); // eslint-disable-line camelcase
+    const BB = fieldSquare(B);
+    const E = fieldSub(AA, BB);
+    const C = fieldAdd(x_3, z_3); // eslint-disable-line camelcase
+    const D = fieldSub(x_3, z_3); // eslint-disable-line camelcase
+    const DA = fieldMul(D, A);
+    const CB = fieldMul(C, B);
+    x_3 = fieldSquare(fieldAdd(DA, CB)); // eslint-disable-line camelcase
+    z_3 = fieldMul(x_1, fieldSquare(fieldSub(DA, CB))); // eslint-disable-line camelcase
+    x_2 = fieldMul(AA, BB); // eslint-disable-line camelcase
+    z_2 = fieldMul(E, fieldAdd(AA, fieldMul(A24, E))); // eslint-disable-line camelcase
+  }
+
+  [x_2, x_3] = cswap(swap, x_2, x_3); // eslint-disable-line camelcase
+  [z_2, z_3] = cswap(swap, z_2, z_3); // eslint-disable-line camelcase
+
+  return bigIntToBytes(fieldMul(x_2, fieldInvert(z_2))); // eslint-disable-line camelcase
+}
+
+/**
+ * Computes scalar multiplication with the base point (u = 9).
+ * @param {Uint8Array} scalar - 32-byte scalar (will be clamped)
+ * @returns {Uint8Array} 32-byte public key
+ */
+function scalarMultBase(scalar) {
+  return scalarMult(scalar, bigIntToBytes(BASE_POINT));
+}
+
+/**
+ * Generates a new X25519 key pair.
+ * @returns {{publicKey: Uint8Array, secretKey: Uint8Array}} Key pair
+ */
+function generateKeyPair() {
+  const secretKey = randomBytes(32);
+  const publicKey = scalarMultBase(secretKey);
+  return { publicKey, secretKey };
+}
+
+module.exports = {
+  generateKeyPair,
+  scalarMult,
+  scalarMultBase
+};

package/src/errors/AudioError.js

@@ -0,0 +1,164 @@
+'use strict';
+
+/**
+ * @fileoverview Audio-specific error class for LC3 codec and streaming
+ * @module errors/AudioError
+ */
+
+const MeshError = require('./MeshError');
+const { ERROR_MESSAGES } = require('../constants/errors');
+
+/**
+ * Error class for audio operation failures
+ * @class AudioError
+ * @extends MeshError
+ */
+class AudioError extends MeshError {
+  /**
+   * Creates a new AudioError
+   * @param {string} message - Human-readable error message
+   * @param {string} [code='EA00'] - Error code (EAxx range)
+   * @param {Object|null} [details=null] - Additional error context
+   */
+  constructor(message, code = 'EA00', details = null) {
+    super(message, code, details);
+    this.name = 'AudioError';
+  }
+
+  /**
+   * Creates an error from an error code
+   * @param {string} code - Error code
+   * @param {Object|null} [details=null] - Additional error context
+   * @returns {AudioError}
+   */
+  static fromCode(code, details = null) {
+    const message = ERROR_MESSAGES[code] || 'Audio operation failed';
+    return new AudioError(message, code, details);
+  }
+
+  /**
+   * Creates a codec initialization error
+   * @param {Object|null} [details=null] - Additional error context
+   * @returns {AudioError}
+   */
+  static codecInitFailed(details = null) {
+    return new AudioError('LC3 codec initialization failed', 'EA01', details);
+  }
+
+  /**
+   * Creates an encoding error
+   * @param {Object|null} [details=null] - Additional error context
+   * @returns {AudioError}
+   */
+  static encodingFailed(details = null) {
+    return new AudioError('Audio encoding failed', 'EA02', details);
+  }
+
+  /**
+   * Creates a decoding error
+   * @param {Object|null} [details=null] - Additional error context
+   * @returns {AudioError}
+   */
+  static decodingFailed(details = null) {
+    return new AudioError('Audio decoding failed', 'EA03', details);
+  }
+
+  /**
+   * Creates a session error
+   * @param {string} peerId - Peer ID
+   * @param {Object|null} [details=null] - Additional error context
+   * @returns {AudioError}
+   */
+  static sessionFailed(peerId, details = null) {
+    return new AudioError(
+      `Audio session failed with peer ${peerId}`,
+      'EA04',
+      { peerId, ...details }
+    );
+  }
+
+  /**
+   * Creates a buffer overflow error
+   * @param {Object|null} [details=null] - Additional error context
+   * @returns {AudioError}
+   */
+  static bufferOverflow(details = null) {
+    return new AudioError('Audio buffer overflow', 'EA05', details);
+  }
+
+  /**
+   * Creates a buffer underrun error
+   * @param {Object|null} [details=null] - Additional error context
+   * @returns {AudioError}
+   */
+  static bufferUnderrun(details = null) {
+    return new AudioError('Audio buffer underrun', 'EA06', details);
+  }
+
+  /**
+   * Creates a voice message too large error
+   * @param {number} size - Actual size in bytes
+   * @param {number} maxSize - Maximum allowed size in bytes
+   * @returns {AudioError}
+   */
+  static voiceMessageTooLarge(size, maxSize) {
+    return new AudioError(
+      `Voice message too large: ${size} bytes (max: ${maxSize})`,
+      'EA07',
+      { size, maxSize }
+    );
+  }
+
+  /**
+   * Creates a stream rejected error
+   * @param {string} peerId - Peer ID
+   * @param {string} [reason] - Rejection reason
+   * @returns {AudioError}
+   */
+  static streamRejected(peerId, reason) {
+    return new AudioError(
+      `Audio stream rejected by peer ${peerId}`,
+      'EA08',
+      { peerId, reason }
+    );
+  }
+
+  /**
+   * Creates a codec not available error
+   * @returns {AudioError}
+   */
+  static codecNotAvailable() {
+    return new AudioError(
+      'LC3 codec not available - native module not installed',
+      'EA09'
+    );
+  }
+
+  /**
+   * Creates an invalid configuration error
+   * @param {string} [reason] - Reason for invalid configuration
+   * @returns {AudioError}
+   */
+  static invalidConfig(reason) {
+    return new AudioError(
+      `Invalid audio configuration: ${reason || 'unknown'}`,
+      'EA10',
+      { reason }
+    );
+  }
+
+  /**
+   * Creates a voice message timeout error
+   * @param {string} messageId - Message ID
+   * @returns {AudioError}
+   */
+  static voiceMessageTimeout(messageId) {
+    return new AudioError(
+      `Voice message assembly timed out: ${messageId}`,
+      'EA11',
+      { messageId }
+    );
+  }
+}
+
+module.exports = AudioError;

package/src/errors/ConnectionError.js

@@ -0,0 +1,109 @@
+'use strict';
+
+/**
+ * @fileoverview Connection error class
+ * @module errors/ConnectionError
+ */
+
+const MeshError = require('./MeshError');
+const { ERROR_MESSAGES } = require('../constants/errors');
+
+/**
+ * Error class for connection-related failures
+ * @class ConnectionError
+ * @extends MeshError
+ */
+class ConnectionError extends MeshError {
+  /**
+   * Creates a new ConnectionError
+   * @param {string} message - Human-readable error message
+   * @param {string} [code='E200'] - Error code (E2xx range)
+   * @param {string|null} [peerId=null] - ID of the peer involved
+   * @param {Object|null} [details=null] - Additional error context
+   */
+  constructor(message, code = 'E200', peerId = null, details = null) {
+    super(message, code, details);
+    this.name = 'ConnectionError';
+
+    /**
+     * ID of the peer involved in the connection error
+     * @type {string|null}
+     */
+    this.peerId = peerId;
+  }
+
+  /**
+   * Creates an error from an error code
+   * @param {string} code - Error code from ERROR_CODE constants
+   * @param {string|null} [peerId=null] - ID of the peer involved
+   * @param {Object|null} [details=null] - Additional error context
+   * @returns {ConnectionError} New ConnectionError instance
+   */
+  static fromCode(code, peerId = null, details = null) {
+    const message = ERROR_MESSAGES[code] || ERROR_MESSAGES.E200;
+    return new ConnectionError(message, code, peerId, details);
+  }
+
+  /**
+   * Creates a connection failed error
+   * @param {string|null} [peerId=null] - ID of the peer
+   * @param {Object|null} [details=null] - Additional error context
+   * @returns {ConnectionError} New ConnectionError instance
+   */
+  static connectionFailed(peerId = null, details = null) {
+    return ConnectionError.fromCode('E200', peerId, details);
+  }
+
+  /**
+   * Creates a connection timeout error
+   * @param {string|null} [peerId=null] - ID of the peer
+   * @param {Object|null} [details=null] - Additional error context
+   * @returns {ConnectionError} New ConnectionError instance
+   */
+  static connectionTimeout(peerId = null, details = null) {
+    return ConnectionError.fromCode('E201', peerId, details);
+  }
+
+  /**
+   * Creates a connection lost error
+   * @param {string|null} [peerId=null] - ID of the peer
+   * @param {Object|null} [details=null] - Additional error context
+   * @returns {ConnectionError} New ConnectionError instance
+   */
+  static connectionLost(peerId = null, details = null) {
+    return ConnectionError.fromCode('E202', peerId, details);
+  }
+
+  /**
+   * Creates a peer not found error
+   * @param {string|null} [peerId=null] - ID of the peer
+   * @param {Object|null} [details=null] - Additional error context
+   * @returns {ConnectionError} New ConnectionError instance
+   */
+  static peerNotFound(peerId = null, details = null) {
+    return ConnectionError.fromCode('E204', peerId, details);
+  }
+
+  /**
+   * Creates a peer blocked error
+   * @param {string|null} [peerId=null] - ID of the peer
+   * @param {Object|null} [details=null] - Additional error context
+   * @returns {ConnectionError} New ConnectionError instance
+   */
+  static peerBlocked(peerId = null, details = null) {
+    return ConnectionError.fromCode('E205', peerId, details);
+  }
+
+  /**
+   * Converts error to a JSON-serializable object
+   * @returns {Object} JSON representation of the error
+   */
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      peerId: this.peerId
+    };
+  }
+}
+
+module.exports = ConnectionError;