web-dc-api 0.0.62 → 0.0.64

package/dist/cjs/node_modules/@libp2p/webrtc/dist/src/private-to-public/utils/connect.js

@@ -1,162 +0,0 @@
-'use strict';
-
-var index$1 = require('../../../../../../@chainsafe/libp2p-noise/dist/src/index.js');
-var index = require('../../../../../../race-event/dist/src/index.js');
-var error = require('../../error.js');
-var maconn = require('../../maconn.js');
-var muxer = require('../../muxer.js');
-var stream = require('../../stream.js');
-var util = require('../../util.js');
-var generateNoisePrologue = require('./generate-noise-prologue.js');
-var sdp = require('./sdp.js');
-
-const CONNECTION_STATE_CHANGE_EVENT = util.isFirefox ? 'iceconnectionstatechange' : 'connectionstatechange';
-async function connect(peerConnection, ufrag, options) {
-  // create data channel for running the noise handshake. Once the data
-  // channel is opened, the listener will initiate the noise handshake. This
-  // is used to confirm the identity of the peer.
-  const handshakeDataChannel = peerConnection.createDataChannel('', {
-    negotiated: true,
-    id: 0
-  });
-  try {
-    if (options.role === 'client') {
-      // the client has to set the local offer before the remote answer
-      // Create offer and munge sdp with ufrag == pwd. This allows the remote to
-      // respond to STUN messages without performing an actual SDP exchange.
-      // This is because it can infer the passwd field by reading the USERNAME
-      // attribute of the STUN message.
-      options.log.trace('client creating local offer');
-      const offerSdp = await peerConnection.createOffer();
-      options.log.trace('client created local offer %s', offerSdp.sdp);
-      const mungedOfferSdp = sdp.munge(offerSdp, ufrag);
-      options.log.trace('client setting local offer %s', mungedOfferSdp.sdp);
-      await peerConnection.setLocalDescription(mungedOfferSdp);
-      const answerSdp = sdp.serverAnswerFromMultiaddr(options.remoteAddr, ufrag);
-      options.log.trace('client setting server description %s', answerSdp.sdp);
-      await peerConnection.setRemoteDescription(answerSdp);
-    } else {
-      // the server has to set the remote offer before the local answer
-      const offerSdp = sdp.clientOfferFromMultiAddr(options.remoteAddr, ufrag);
-      options.log.trace('server setting client %s %s', offerSdp.type, offerSdp.sdp);
-      await peerConnection.setRemoteDescription(offerSdp);
-      // Create offer and munge sdp with ufrag == pwd. This allows the remote to
-      // respond to STUN messages without performing an actual SDP exchange.
-      // This is because it can infer the passwd field by reading the USERNAME
-      // attribute of the STUN message.
-      options.log.trace('server creating local answer');
-      const answerSdp = await peerConnection.createAnswer();
-      options.log.trace('server created local answer');
-      const mungedAnswerSdp = sdp.munge(answerSdp, ufrag);
-      options.log.trace('server setting local description %s', answerSdp.sdp);
-      await peerConnection.setLocalDescription(mungedAnswerSdp);
-    }
-    if (handshakeDataChannel.readyState !== 'open') {
-      options.log.trace('%s wait for handshake channel to open, starting status %s', options.role, handshakeDataChannel.readyState);
-      await index.raceEvent(handshakeDataChannel, 'open', options.signal);
-    }
-    options.log.trace('%s handshake channel opened', options.role);
-    if (options.role === 'server') {
-      // now that the connection has been opened, add the remote's certhash to
-      // it's multiaddr so we can complete the noise handshake
-      const remoteFingerprint = peerConnection.remoteFingerprint()?.value ?? '';
-      options.remoteAddr = options.remoteAddr.encapsulate(sdp.fingerprint2Ma(remoteFingerprint));
-    }
-    // Do noise handshake.
-    // Set the Noise Prologue to libp2p-webrtc-noise:<FINGERPRINTS> before
-    // starting the actual Noise handshake.
-    // <FINGERPRINTS> is the concatenation of the of the two TLS fingerprints
-    // of A (responder) and B (initiator) in their byte representation.
-    const localFingerprint = sdp.getFingerprintFromSdp(peerConnection.localDescription?.sdp);
-    if (localFingerprint == null) {
-      throw new error.WebRTCTransportError('Could not get fingerprint from local description sdp');
-    }
-    options.log.trace('%s performing noise handshake', options.role);
-    const noisePrologue = generateNoisePrologue.generateNoisePrologue(localFingerprint, options.remoteAddr, options.role);
-    // Since we use the default crypto interface and do not use a static key
-    // or early data, we pass in undefined for these parameters.
-    const connectionEncrypter = index$1.noise({
-      prologueBytes: noisePrologue
-    })(options);
-    const handshakeStream = stream.createStream({
-      channel: handshakeDataChannel,
-      direction: 'outbound',
-      handshake: true,
-      logger: options.logger,
-      ...(options.dataChannel ?? {})
-    });
-    // Creating the connection before completion of the noise
-    // handshake ensures that the stream opening callback is set up
-    const maConn = new maconn.WebRTCMultiaddrConnection(options, {
-      peerConnection,
-      remoteAddr: options.remoteAddr,
-      timeline: {
-        open: Date.now()
-      },
-      metrics: options.events
-    });
-    peerConnection.addEventListener(CONNECTION_STATE_CHANGE_EVENT, () => {
-      switch (peerConnection.connectionState) {
-        case 'failed':
-        case 'disconnected':
-        case 'closed':
-          maConn.close().catch(err => {
-            options.log.error('error closing connection', err);
-            maConn.abort(err);
-          });
-          break;
-        default:
-          break;
-      }
-    });
-    // Track opened peer connection
-    options.events?.increment({
-      peer_connection: true
-    });
-    const muxerFactory = new muxer.DataChannelMuxerFactory(options, {
-      peerConnection,
-      metrics: options.events,
-      dataChannelOptions: options.dataChannel
-    });
-    if (options.role === 'client') {
-      // For outbound connections, the remote is expected to start the noise
-      // handshake. Therefore, we need to secure an inbound noise connection
-      // from the server.
-      options.log.trace('%s secure inbound', options.role);
-      await connectionEncrypter.secureInbound(handshakeStream, {
-        remotePeer: options.remotePeerId,
-        signal: options.signal,
-        skipStreamMuxerNegotiation: true
-      });
-      options.log.trace('%s upgrade outbound', options.role);
-      return await options.upgrader.upgradeOutbound(maConn, {
-        skipProtection: true,
-        skipEncryption: true,
-        muxerFactory,
-        signal: options.signal
-      });
-    }
-    // For inbound connections, the server is are expected to start the noise
-    // handshake. Therefore, we need to secure an outbound noise connection from
-    // the client.
-    options.log.trace('%s secure outbound', options.role);
-    const result = await connectionEncrypter.secureOutbound(handshakeStream, {
-      remotePeer: options.remotePeerId,
-      signal: options.signal,
-      skipStreamMuxerNegotiation: true
-    });
-    maConn.remoteAddr = maConn.remoteAddr.encapsulate(`/p2p/${result.remotePeer}`);
-    options.log.trace('%s upgrade inbound', options.role);
-    await options.upgrader.upgradeInbound(maConn, {
-      skipProtection: true,
-      skipEncryption: true,
-      muxerFactory,
-      signal: options.signal
-    });
-  } catch (err) {
-    handshakeDataChannel.close();
-    throw err;
-  }
-}
-
-exports.connect = connect;

package/dist/cjs/node_modules/@libp2p/webrtc/dist/src/private-to-public/utils/generate-noise-prologue.js

@@ -1,26 +0,0 @@
-'use strict';
-
-var digest = require('../../../../../../multiformats/dist/src/hashes/digest.js');
-var sha2Browser = require('../../../../../../multiformats/dist/src/hashes/sha2-browser.js');
-var concat = require('../../../../../../uint8arrays/dist/src/concat.js');
-var fromString = require('../../../../../../uint8arrays/dist/src/from-string.js');
-var sdp = require('./sdp.js');
-
-const PREFIX = fromString.fromString('libp2p-webrtc-noise:');
-/**
- * Generate a noise prologue from the peer connection's certificate.
- * noise prologue = bytes('libp2p-webrtc-noise:') + noise-server fingerprint + noise-client fingerprint
- */
-function generateNoisePrologue(localFingerprint, remoteAddr, role) {
-  const localFpString = localFingerprint.trim().toLowerCase().replaceAll(':', '');
-  const localFpArray = fromString.fromString(localFpString, 'hex');
-  const local = digest.create(sha2Browser.sha256.code, localFpArray);
-  const remote = sdp.multibaseDecoder.decode(sdp.certhash(remoteAddr));
-  const byteLength = PREFIX.byteLength + local.bytes.byteLength + remote.byteLength;
-  if (role === 'server') {
-    return concat.concat([PREFIX, remote, local.bytes], byteLength);
-  }
-  return concat.concat([PREFIX, local.bytes, remote], byteLength);
-}
-
-exports.generateNoisePrologue = generateNoisePrologue;

package/dist/cjs/node_modules/@libp2p/webrtc/dist/src/private-to-public/utils/get-rtcpeerconnection.browser.js

@@ -1,23 +0,0 @@
-'use strict';
-
-async function createDialerRTCPeerConnection(role, ufrag, rtcConfiguration, certificate) {
-  if (certificate == null) {
-    // ECDSA is preferred over RSA here. From our testing we find that P-256 elliptic
-    // curve is supported by Pion, webrtc-rs, as well as Chromium (P-228 and P-384
-    // was not supported in Chromium). We use the same hash function as found in the
-    // multiaddr if it is supported.
-    certificate = await RTCPeerConnection.generateCertificate({
-      name: 'ECDSA',
-      // @ts-expect-error missing from lib.dom.d.ts but required by chrome
-      namedCurve: 'P-256'
-      // hash: sdp.toSupportedHashFunction(hashName)
-    });
-  }
-  const rtcConfig = typeof rtcConfiguration === 'function' ? await rtcConfiguration() : rtcConfiguration;
-  return new RTCPeerConnection({
-    ...(rtcConfig ?? {}),
-    certificates: [certificate]
-  });
-}
-
-exports.createDialerRTCPeerConnection = createDialerRTCPeerConnection;

package/dist/cjs/node_modules/@libp2p/webrtc/dist/src/private-to-public/utils/pem.js

@@ -1,12 +0,0 @@
-'use strict';
-
-var index = require('../../../../../crypto/dist/src/keys/index.js');
-var toString = require('../../../../../../uint8arrays/dist/src/to-string.js');
-
-async function formatAsPem(privateKey) {
-  const keyPair = await index.privateKeyToCryptoKeyPair(privateKey);
-  const exported = await crypto.subtle.exportKey('pkcs8', keyPair.privateKey);
-  return ['-----BEGIN PRIVATE KEY-----', ...toString.toString(new Uint8Array(exported), 'base64pad').split(/(.{64})/).filter(Boolean), '-----END PRIVATE KEY-----'].join('\n');
-}
-
-exports.formatAsPem = formatAsPem;

package/dist/cjs/node_modules/@libp2p/webrtc/dist/src/private-to-public/utils/sdp.js

@@ -1,160 +0,0 @@
-'use strict';
-
-var index = require('../../../../../../@multiformats/multiaddr/dist/src/index.js');
-var base64 = require('../../../../../../multiformats/dist/src/bases/base64.js');
-var basics = require('../../../../../../multiformats/dist/src/basics.js');
-var digest = require('../../../../../../multiformats/dist/src/hashes/digest.js');
-var sha2Browser = require('../../../../../../multiformats/dist/src/hashes/sha2-browser.js');
-var constants = require('../../constants.js');
-var error = require('../../error.js');
-var errors = require('../../../../../interface/dist/src/errors.js');
-
-/**
- * Get base2 | identity decoders
- */
-// @ts-expect-error - Not easy to combine these types.
-const multibaseDecoder = Object.values(basics.bases).map(b => b.decoder).reduce((d, b) => d.or(b));
-const fingerprintRegex = /^a=fingerprint:(?:\w+-[0-9]+)\s(?<fingerprint>(:?[0-9a-fA-F]{2})+)$/m;
-function getFingerprintFromSdp(sdp) {
-  if (sdp == null) {
-    return undefined;
-  }
-  const searchResult = sdp.match(fingerprintRegex);
-  return searchResult?.groups?.fingerprint;
-}
-// Extract the certhash from a multiaddr
-function certhash(ma) {
-  const tups = ma.stringTuples();
-  const certhash = tups.filter(tup => tup[0] === constants.CODEC_CERTHASH).map(tup => tup[1])[0];
-  if (certhash === undefined || certhash === '') {
-    throw new errors.InvalidParametersError(`Couldn't find a certhash component of multiaddr: ${ma.toString()}`);
-  }
-  return certhash;
-}
-/**
- * Convert a certhash into a multihash
- */
-function decodeCerthash(certhash) {
-  return digest.decode(multibaseDecoder.decode(certhash));
-}
-/**
- * Extract the fingerprint from a multiaddr
- */
-function ma2Fingerprint(ma) {
-  const multihashDecoded = decodeCerthash(certhash(ma));
-  const prefix = toSupportedHashFunction(multihashDecoded.code);
-  const fingerprint = multihashDecoded.digest.reduce((str, byte) => str + byte.toString(16).padStart(2, '0'), '');
-  const sdp = fingerprint.match(/.{1,2}/g);
-  if (sdp == null) {
-    throw new error.InvalidFingerprintError(fingerprint, ma.toString());
-  }
-  return `${prefix} ${sdp.join(':').toUpperCase()}`;
-}
-function fingerprint2Ma(fingerprint) {
-  const output = fingerprint.split(':').map(str => parseInt(str, 16));
-  const encoded = Uint8Array.from(output);
-  const digest$1 = digest.create(sha2Browser.sha256.code, encoded);
-  return index.multiaddr(`/certhash/${base64.base64url.encode(digest$1.bytes)}`);
-}
-/**
- * Normalize the hash name from a given multihash has name
- */
-function toSupportedHashFunction(code) {
-  switch (code) {
-    case 0x11:
-      return 'sha-1';
-    case 0x12:
-      return 'sha-256';
-    case 0x13:
-      return 'sha-512';
-    default:
-      throw new error.UnsupportedHashAlgorithmError(code);
-  }
-}
-/**
- * Create an answer SDP message from a multiaddr - the server always operates in
- * ice-lite mode and DTLS active mode.
- */
-function serverAnswerFromMultiaddr(ma, ufrag) {
-  const {
-    host,
-    port,
-    family
-  } = ma.toOptions();
-  const fingerprint = ma2Fingerprint(ma);
-  const sdp = `v=0
-o=- 0 0 IN IP${family} ${host}
-s=-
-t=0 0
-a=ice-lite
-m=application ${port} UDP/DTLS/SCTP webrtc-datachannel
-c=IN IP${family} ${host}
-a=mid:0
-a=ice-options:ice2
-a=ice-ufrag:${ufrag}
-a=ice-pwd:${ufrag}
-a=fingerprint:${fingerprint}
-a=setup:passive
-a=sctp-port:5000
-a=max-message-size:${constants.MAX_MESSAGE_SIZE}
-a=candidate:1467250027 1 UDP 1467250027 ${host} ${port} typ host
-a=end-of-candidates
-`;
-  return {
-    type: 'answer',
-    sdp
-  };
-}
-/**
- * Create an offer SDP message from a multiaddr
- */
-function clientOfferFromMultiAddr(ma, ufrag) {
-  const {
-    host,
-    port,
-    family
-  } = ma.toOptions();
-  const sdp = `v=0
-o=- 0 0 IN IP${family} ${host}
-s=-
-c=IN IP${family} ${host}
-t=0 0
-a=ice-options:ice2,trickle
-m=application ${port} UDP/DTLS/SCTP webrtc-datachannel
-a=mid:0
-a=setup:active
-a=ice-ufrag:${ufrag}
-a=ice-pwd:${ufrag}
-a=fingerprint:sha-256 00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00
-a=sctp-port:5000
-a=max-message-size:${constants.MAX_MESSAGE_SIZE}
-a=candidate:1467250027 1 UDP 1467250027 ${host} ${port} typ host
-a=end-of-candidates
-`;
-  return {
-    type: 'offer',
-    sdp
-  };
-}
-/**
- * Replace (munge) the ufrag and password values in a SDP
- */
-function munge(desc, ufrag) {
-  if (desc.sdp === undefined) {
-    throw new errors.InvalidParametersError("Can't munge a missing SDP");
-  }
-  const lineBreak = desc.sdp.includes('\r\n') ? '\r\n' : '\n';
-  desc.sdp = desc.sdp.replace(/\na=ice-ufrag:[^\n]*\n/, '\na=ice-ufrag:' + ufrag + lineBreak).replace(/\na=ice-pwd:[^\n]*\n/, '\na=ice-pwd:' + ufrag + lineBreak);
-  return desc;
-}
-
-exports.certhash = certhash;
-exports.clientOfferFromMultiAddr = clientOfferFromMultiAddr;
-exports.decodeCerthash = decodeCerthash;
-exports.fingerprint2Ma = fingerprint2Ma;
-exports.getFingerprintFromSdp = getFingerprintFromSdp;
-exports.ma2Fingerprint = ma2Fingerprint;
-exports.multibaseDecoder = multibaseDecoder;
-exports.munge = munge;
-exports.serverAnswerFromMultiaddr = serverAnswerFromMultiaddr;
-exports.toSupportedHashFunction = toSupportedHashFunction;