node-rtc-connection 1.0.18 → 2.0.4

package/src/datachannel/RTCDataChannel.js

@@ -1,354 +0,0 @@
-/**
- * @file RTCDataChannel.js
- * @description WebRTC DataChannel implementation for peer-to-peer data transfer.
- * @module datachannel/RTCDataChannel
- * 
- * Ported from Chromium's RTCDataChannel implementation:
- * - cc/rtc_data_channel.h
- * - cc/rtc_data_channel.cc
- * - cc/rtc_data_channel.idl
- */
-
-const EventEmitter = require('events');
-
-/**
- * RTCDataChannelState - Current state of the data channel
- * @readonly
- * @enum {string}
- */
-const RTCDataChannelState = Object.freeze({
-  CONNECTING: 'connecting',
-  OPEN: 'open',
-  CLOSING: 'closing',
-  CLOSED: 'closed'
-});
-
-/**
- * RTCDataChannelInit - Configuration for creating a data channel
- * @typedef {Object} RTCDataChannelInit
- * @property {boolean} [ordered=true] - Whether messages must arrive in order
- * @property {number} [maxPacketLifeTime] - Maximum packet lifetime in milliseconds
- * @property {number} [maxRetransmits] - Maximum number of retransmissions
- * @property {string} [protocol=''] - Subprotocol name
- * @property {boolean} [negotiated=false] - Whether channel was negotiated out-of-band
- * @property {number} [id] - Channel ID (required if negotiated is true)
- */
-
-/**
- * @class RTCDataChannel
- * @extends EventEmitter
- * @description Represents a bidirectional data channel between peers.
- * Provides reliable or unreliable data transfer with configurable ordering.
- * 
- * Events:
- * - 'open': Fired when the channel opens
- * - 'message': Fired when a message is received
- * - 'bufferedamountlow': Fired when bufferedAmount drops below threshold
- * - 'error': Fired when an error occurs
- * - 'closing': Fired when the channel is closing
- * - 'close': Fired when the channel closes
- * 
- * @example
- * const dataChannel = peerConnection.createDataChannel('myChannel', {
- *   ordered: true,
- *   maxRetransmits: 3
- * });
- * 
- * dataChannel.on('open', () => {
- *   console.log('Channel opened');
- *   dataChannel.send('Hello!');
- * });
- * 
- * dataChannel.on('message', (event) => {
- *   console.log('Received:', event.data);
- * });
- */
-class RTCDataChannel extends EventEmitter {
-  /**
-   * Create an RTCDataChannel instance.
-   * @param {string} label - Channel label
-   * @param {RTCDataChannelInit} [init] - Channel configuration
-   */
-  constructor(label, init = {}) {
-    super();
-
-    if (typeof label !== 'string') {
-      throw new TypeError('label must be a string');
-    }
-
-    // Channel configuration
-    this._label = label;
-    this._ordered = init.ordered !== undefined ? init.ordered : true;
-    this._maxPacketLifeTime = init.maxPacketLifeTime || null;
-    this._maxRetransmits = init.maxRetransmits || null;
-    this._protocol = init.protocol || '';
-    this._negotiated = init.negotiated || false;
-    this._id = init.id !== undefined ? init.id : null;
-
-    // State
-    this._readyState = RTCDataChannelState.CONNECTING;
-    this._bufferedAmount = 0;
-    this._bufferedAmountLowThreshold = 0;
-    this._binaryType = 'arraybuffer'; // or 'blob'
-
-    // Message queue for when not open
-    this._messageQueue = [];
-  }
-
-  /**
-   * Get the channel label.
-   * @returns {string} Channel label
-   */
-  get label() {
-    return this._label;
-  }
-
-  /**
-   * Check if messages are delivered in order.
-   * @returns {boolean} True if ordered
-   */
-  get ordered() {
-    return this._ordered;
-  }
-
-  /**
-   * Get the maximum packet lifetime in milliseconds.
-   * @returns {number|null} Maximum lifetime or null if not set
-   */
-  get maxPacketLifeTime() {
-    return this._maxPacketLifeTime;
-  }
-
-  /**
-   * Get the maximum number of retransmissions.
-   * @returns {number|null} Maximum retransmits or null if not set
-   */
-  get maxRetransmits() {
-    return this._maxRetransmits;
-  }
-
-  /**
-   * Get the subprotocol name.
-   * @returns {string} Protocol name
-   */
-  get protocol() {
-    return this._protocol;
-  }
-
-  /**
-   * Check if the channel was negotiated out-of-band.
-   * @returns {boolean} True if negotiated
-   */
-  get negotiated() {
-    return this._negotiated;
-  }
-
-  /**
-   * Get the channel ID.
-   * @returns {number|null} Channel ID or null if not assigned
-   */
-  get id() {
-    return this._id;
-  }
-
-  /**
-   * Get the current state of the channel.
-   * @returns {string} Channel state
-   */
-  get readyState() {
-    return this._readyState;
-  }
-
-  /**
-   * Get the number of bytes queued to send.
-   * @returns {number} Buffered amount in bytes
-   */
-  get bufferedAmount() {
-    return this._bufferedAmount;
-  }
-
-  /**
-   * Get the threshold for bufferedamountlow event.
-   * @returns {number} Threshold in bytes
-   */
-  get bufferedAmountLowThreshold() {
-    return this._bufferedAmountLowThreshold;
-  }
-
-  /**
-   * Set the threshold for bufferedamountlow event.
-   * @param {number} value - Threshold in bytes
-   */
-  set bufferedAmountLowThreshold(value) {
-    this._bufferedAmountLowThreshold = value;
-  }
-
-  /**
-   * Get the binary data type.
-   * @returns {string} 'arraybuffer' or 'blob'
-   */
-  get binaryType() {
-    return this._binaryType;
-  }
-
-  /**
-   * Set the binary data type.
-   * @param {string} value - 'arraybuffer' or 'blob'
-   * @throws {TypeError} If value is invalid
-   */
-  set binaryType(value) {
-    if (value !== 'arraybuffer' && value !== 'blob') {
-      throw new TypeError('binaryType must be "arraybuffer" or "blob"');
-    }
-    this._binaryType = value;
-  }
-
-  /**
-   * Check if the channel is reliable (deprecated).
-   * @returns {boolean} True if ordered and no packet lifetime/retransmit limits
-   * @deprecated Use ordered, maxPacketLifeTime, and maxRetransmits instead
-   */
-  get reliable() {
-    return this._ordered && 
-           this._maxPacketLifeTime === null && 
-           this._maxRetransmits === null;
-  }
-
-  /**
-   * Send a message through the channel.
-   * @param {string|ArrayBuffer|ArrayBufferView|Blob} data - Data to send
-   * @throws {Error} If channel is not open or data is invalid
-   */
-  send(data) {
-    if (this._readyState !== RTCDataChannelState.OPEN) {
-      throw new Error('RTCDataChannel.readyState is not "open"');
-    }
-
-    let dataToSend;
-    let byteLength = 0;
-
-    if (typeof data === 'string') {
-      dataToSend = Buffer.from(data, 'utf8');
-      byteLength = dataToSend.length;
-    } else if (data instanceof ArrayBuffer) {
-      dataToSend = Buffer.from(data);
-      byteLength = data.byteLength;
-    } else if (ArrayBuffer.isView(data)) {
-      dataToSend = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
-      byteLength = data.byteLength;
-    } else if (data && typeof data.arrayBuffer === 'function') {
-      // Blob-like object
-      throw new Error('Blob sending not yet implemented');
-    } else {
-      throw new TypeError('Invalid data type');
-    }
-
-    // Update buffered amount
-    this._bufferedAmount += byteLength;
-
-    // Use real network transport
-    if (!this._send) {
-      throw new Error('Data channel not connected to network transport');
-    }
-    
-    this._send(data).catch(err => {
-      console.error('Send error:', err);
-      this.emit('error', err);
-    });
-  }
-
-  /**
-   * Emit bufferedamountlow if appropriate
-   * @private
-   */
-  _emitBufferedAmountLow() {
-    if (this._bufferedAmount <= this._bufferedAmountLowThreshold) {
-      this.emit('bufferedamountlow');
-    }
-  }
-
-  /**
-   * Close the data channel.
-   */
-  close() {
-    if (this._readyState === RTCDataChannelState.CLOSING || 
-        this._readyState === RTCDataChannelState.CLOSED) {
-      return;
-    }
-
-    this._setState(RTCDataChannelState.CLOSING);
-    
-    // Transition to closed asynchronously
-    setImmediate(() => {
-      if (this._readyState === RTCDataChannelState.CLOSING) {
-        this._setState(RTCDataChannelState.CLOSED);
-      }
-    });
-  }
-
-  /**
-   * Set the channel state and emit appropriate events.
-   * @param {string} newState - New state
-   * @private
-   */
-  _setState(newState) {
-    const oldState = this._readyState;
-    if (oldState === newState) {
-      return;
-    }
-
-    this._readyState = newState;
-
-    // Emit state-specific events
-    if (newState === RTCDataChannelState.OPEN) {
-      this.emit('open');
-    } else if (newState === RTCDataChannelState.CLOSING) {
-      this.emit('closing');
-    } else if (newState === RTCDataChannelState.CLOSED) {
-      this.emit('close');
-    }
-  }
-
-  /**
-   * Set channel to open state (internal use).
-   * @private
-   */
-  _setStateToOpen() {
-    this._setState(RTCDataChannelState.OPEN);
-  }
-
-  /**
-   * Handle received message (internal use).
-   * @param {Buffer|string} data - Received data
-   * @private
-   */
-  _onMessage(data) {
-    const event = {
-      data: data
-    };
-    this.emit('message', event);
-  }
-
-  /**
-   * Receive message from network transport (internal use).
-   * @param {any} data - Received data
-   * @private
-   */
-  _receiveMessage(data) {
-    this._onMessage(data);
-  }
-
-  /**
-   * Set the channel ID (internal use).
-   * @param {number} id - Channel ID
-   * @private
-   */
-  _setId(id) {
-    this._id = id;
-  }
-}
-
-module.exports = {
-  RTCDataChannel,
-  RTCDataChannelState
-};

package/src/dtls/RTCCertificate.js

@@ -1,310 +0,0 @@
-/**
- * @file RTCCertificate.js
- * @description DTLS certificate implementation for WebRTC.
- * @module dtls/RTCCertificate
- * 
- * Ported from Chromium's RTCCertificate implementation:
- * - cc/rtc_certificate.h
- * - cc/rtc_certificate.cc
- * - cc/rtc_certificate.idl
- * - cc/rtc_certificate_generator.h
- * - cc/rtc_certificate_generator.cc
- */
-
-const crypto = require('crypto');
-
-/**
- * RTCDtlsFingerprint - DTLS certificate fingerprint
- * @typedef {Object} RTCDtlsFingerprint
- * @property {string} algorithm - Hash algorithm (e.g., 'sha-256')
- * @property {string} value - Fingerprint value (colon-separated hex)
- */
-
-/**
- * Generate a self-signed certificate for DTLS.
- * @param {Object} options - Certificate generation options
- * @param {string} [options.name='webrtc'] - Common name for the certificate
- * @param {number} [options.days=30] - Days until expiration
- * @param {string} [options.hash='sha256'] - Hash algorithm
- * @returns {Object} Certificate object with key and cert
- * @private
- */
-function generateSelfSignedCertificate(options = {}) {
-  const {
-    name = 'webrtc',
-    days = 30,
-    hash = 'sha256'
-  } = options;
-
-  // Generate RSA key pair
-  const { privateKey, publicKey } = crypto.generateKeyPairSync('rsa', {
-    modulusLength: 2048,
-    publicKeyEncoding: {
-      type: 'spki',
-      format: 'pem'
-    },
-    privateKeyEncoding: {
-      type: 'pkcs8',
-      format: 'pem'
-    }
-  });
-
-  // Create certificate using Node.js crypto
-  // Note: Node.js doesn't have built-in self-signed cert generation,
-  // so we'll use a simplified approach storing the key pair
-  const expirationDate = new Date();
-  expirationDate.setDate(expirationDate.getDate() + days);
-
-  return {
-    privateKey,
-    publicKey,
-    expires: expirationDate.getTime(),
-    hash
-  };
-}
-
-/**
- * Calculate fingerprint from public key.
- * @param {string} publicKey - PEM-encoded public key
- * @param {string} algorithm - Hash algorithm (e.g., 'sha256')
- * @returns {string} Fingerprint (colon-separated hex)
- * @private
- */
-function calculateFingerprint(publicKey, algorithm = 'sha256') {
-  // Remove PEM headers and decode base64
-  const pemBody = publicKey
-    .replace(/-----BEGIN PUBLIC KEY-----/, '')
-    .replace(/-----END PUBLIC KEY-----/, '')
-    .replace(/\s/g, '');
-  
-  const keyBuffer = Buffer.from(pemBody, 'base64');
-  
-  // Calculate hash
-  const hash = crypto.createHash(algorithm);
-  hash.update(keyBuffer);
-  const digest = hash.digest('hex').toUpperCase();
-  
-  // Format as colon-separated pairs
-  return digest.match(/.{2}/g).join(':');
-}
-
-/**
- * @class RTCCertificate
- * @description Represents a certificate used for DTLS in WebRTC.
- * The certificate includes a key pair and expiration time.
- * 
- * @example
- * // Generate a certificate
- * const cert = await RTCCertificate.generateCertificate();
- * console.log('Expires:', new Date(cert.expires));
- * console.log('Fingerprints:', cert.getFingerprints());
- * 
- * @example
- * // Generate with custom expiration
- * const cert = await RTCCertificate.generateCertificate({
- *   name: 'my-peer',
- *   expires: Date.now() + (90 * 24 * 60 * 60 * 1000) // 90 days
- * });
- */
-class RTCCertificate {
-  /**
-   * Create an RTCCertificate instance.
-   * Use generateCertificate() static method instead of calling directly.
-   * @param {Object} certData - Internal certificate data
-   * @private
-   */
-  constructor(certData) {
-    // Store certificate data
-    this._privateKey = certData.privateKey;
-    this._publicKey = certData.publicKey;
-    this._expires = certData.expires;
-    this._hash = certData.hash || 'sha256';
-    
-    // Cache fingerprints
-    this._fingerprints = null;
-  }
-
-  /**
-   * Get the expiration time.
-   * @returns {number} Expiration time in milliseconds since epoch (DOMTimeStamp)
-   */
-  get expires() {
-    return this._expires;
-  }
-
-  /**
-   * Get the certificate fingerprints.
-   * Returns an array of fingerprints for the certificate chain.
-   * For self-signed certificates, this returns a single fingerprint.
-   * 
-   * @returns {Array<RTCDtlsFingerprint>} Array of fingerprint objects
-   */
-  getFingerprints() {
-    if (!this._fingerprints) {
-      // Calculate fingerprint for multiple algorithms
-      const algorithms = ['sha-256', 'sha-384', 'sha-512'];
-      this._fingerprints = algorithms.map(algorithm => {
-        const hashAlgo = algorithm.replace('-', ''); // 'sha-256' -> 'sha256'
-        return {
-          algorithm,
-          value: calculateFingerprint(this._publicKey, hashAlgo)
-        };
-      });
-    }
-    
-    return this._fingerprints.map(fp => ({ ...fp }));
-  }
-
-  /**
-   * Get the private key in PEM format.
-   * @returns {string} PEM-encoded private key
-   * @internal
-   */
-  getPrivateKey() {
-    return this._privateKey;
-  }
-
-  /**
-   * Get the public key in PEM format.
-   * @returns {string} PEM-encoded public key
-   * @internal
-   */
-  getPublicKey() {
-    return this._publicKey;
-  }
-
-  /**
-   * Convert to PEM format (for serialization/storage).
-   * @returns {Object} Object with pemPrivateKey and pemCertificate
-   */
-  toPEM() {
-    return {
-      pemPrivateKey: this._privateKey,
-      pemCertificate: this._publicKey
-    };
-  }
-
-  /**
-   * Check if the certificate has expired.
-   * @returns {boolean} True if expired, false otherwise
-   */
-  isExpired() {
-    return Date.now() > this._expires;
-  }
-
-  /**
-   * Generate a new RTCCertificate asynchronously.
-   * 
-   * @param {Object} [options] - Generation options
-   * @param {string} [options.name='webrtc'] - Common name for the certificate
-   * @param {number} [options.expires] - Expiration time in ms (default: 30 days from now)
-   * @param {string} [options.hash='sha256'] - Hash algorithm
-   * @returns {Promise<RTCCertificate>} Promise resolving to generated certificate
-   * 
-   * @example
-   * const cert = await RTCCertificate.generateCertificate({
-   *   name: 'my-app',
-   *   expires: Date.now() + (90 * 24 * 60 * 60 * 1000) // 90 days
-   * });
-   */
-  static async generateCertificate(options = {}) {
-    return new Promise((resolve, reject) => {
-      try {
-        // Calculate expiration
-        let expires;
-        if (options.expires) {
-          expires = options.expires;
-        } else {
-          const days = options.days || 30;
-          expires = Date.now() + (days * 24 * 60 * 60 * 1000);
-        }
-
-        // Generate certificate in next tick to avoid blocking
-        setImmediate(() => {
-          try {
-            const certData = generateSelfSignedCertificate({
-              name: options.name || 'webrtc',
-              days: Math.ceil((expires - Date.now()) / (24 * 60 * 60 * 1000)),
-              hash: options.hash || 'sha256'
-            });
-
-            certData.expires = expires;
-            const certificate = new RTCCertificate(certData);
-            resolve(certificate);
-          } catch (err) {
-            reject(err);
-          }
-        });
-      } catch (err) {
-        reject(err);
-      }
-    });
-  }
-
-  /**
-   * Create a certificate from PEM strings.
-   * 
-   * @param {string} pemPrivateKey - PEM-encoded private key
-   * @param {string} pemCertificate - PEM-encoded certificate (or public key)
-   * @param {number} [expires] - Expiration time in ms (default: 30 days from now)
-   * @returns {RTCCertificate} Certificate instance
-   * 
-   * @example
-   * const cert = RTCCertificate.fromPEM(
-   *   privateKeyPEM,
-   *   publicKeyPEM,
-   *   Date.now() + (30 * 24 * 60 * 60 * 1000)
-   * );
-   */
-  static fromPEM(pemPrivateKey, pemCertificate, expires) {
-    if (typeof pemPrivateKey !== 'string' || pemPrivateKey.length === 0) {
-      throw new TypeError('pemPrivateKey must be a non-empty string');
-    }
-
-    if (typeof pemCertificate !== 'string' || pemCertificate.length === 0) {
-      throw new TypeError('pemCertificate must be a non-empty string');
-    }
-
-    // Default expiration to 30 days if not provided
-    const expirationTime = expires || (Date.now() + (30 * 24 * 60 * 60 * 1000));
-
-    return new RTCCertificate({
-      privateKey: pemPrivateKey,
-      publicKey: pemCertificate,
-      expires: expirationTime,
-      hash: 'sha256'
-    });
-  }
-
-  /**
-   * Check if key parameters are supported.
-   * Currently supports RSA with 1024-4096 bits and ECDSA.
-   * 
-   * @param {Object} keyParams - Key parameters
-   * @param {string} keyParams.type - Key type ('RSA' or 'ECDSA')
-   * @param {number} [keyParams.rsaModulusLength] - RSA key size in bits
-   * @param {string} [keyParams.namedCurve] - ECDSA curve name
-   * @returns {boolean} True if supported, false otherwise
-   */
-  static isSupportedKeyParams(keyParams) {
-    if (!keyParams || typeof keyParams !== 'object') {
-      return false;
-    }
-
-    if (keyParams.type === 'RSA') {
-      const modulusLength = keyParams.rsaModulusLength || 2048;
-      // Support 1024 to 4096 bits
-      return modulusLength >= 1024 && modulusLength <= 4096;
-    }
-
-    if (keyParams.type === 'ECDSA') {
-      // Support common ECDSA curves
-      const curve = keyParams.namedCurve;
-      return ['P-256', 'P-384', 'P-521'].includes(curve);
-    }
-
-    return false;
-  }
-}
-
-module.exports = RTCCertificate;