web-dc-api 0.0.57 → 0.0.59

package/dist/cjs/node_modules/@chainsafe/libp2p-noise/dist/src/noise.js

@@ -0,0 +1,206 @@
+'use strict';
+
+var index$1 = require('../../../../@libp2p/crypto/dist/src/keys/index.js');
+var _interface = require('@libp2p/interface');
+var peerId = require('@libp2p/peer-id');
+require('../../../../it-length-prefixed/dist/src/encode.js');
+var decode = require('../../../../it-length-prefixed/dist/src/decode.js');
+var index = require('../../../../it-length-prefixed-stream/dist/src/index.js');
+var duplex = require('../../../../it-pair/dist/src/duplex.js');
+var index$2 = require('../../../../it-pipe/dist/src/index.js');
+var alloc = require('../../../../uint8arrays/dist/src/alloc.js');
+var constants = require('./constants.js');
+var index_browser = require('./crypto/index.browser.js');
+var crypto = require('./crypto.js');
+var encoder = require('./encoder.js');
+var metrics = require('./metrics.js');
+var performHandshake = require('./performHandshake.js');
+var streaming = require('./streaming.js');
+
+class Noise {
+  protocol = '/noise';
+  crypto;
+  prologue;
+  staticKey;
+  extensions;
+  metrics;
+  components;
+  constructor(components) {
+    let init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    const {
+      staticNoiseKey,
+      extensions,
+      crypto: crypto$1,
+      prologueBytes
+    } = init;
+    const {
+      metrics: metrics$1
+    } = components;
+    this.components = components;
+    const _crypto = crypto$1 ?? index_browser.defaultCrypto;
+    this.crypto = crypto.wrapCrypto(_crypto);
+    this.extensions = {
+      webtransportCerthashes: [],
+      ...extensions
+    };
+    this.metrics = metrics$1 ? metrics.registerMetrics(metrics$1) : undefined;
+    if (staticNoiseKey) {
+      // accepts x25519 private key of length 32
+      this.staticKey = _crypto.generateX25519KeyPairFromSeed(staticNoiseKey);
+    } else {
+      this.staticKey = _crypto.generateX25519KeyPair();
+    }
+    this.prologue = prologueBytes ?? alloc.alloc(0);
+  }
+  [Symbol.toStringTag] = '@chainsafe/libp2p-noise';
+  [_interface.serviceCapabilities] = ['@libp2p/connection-encryption', '@chainsafe/libp2p-noise'];
+  /**
+   * Encrypt outgoing data to the remote party (handshake as initiator)
+   *
+   * @param connection - streaming iterable duplex that will be encrypted
+   * @param options
+   * @param options.remotePeer - PeerId of the remote peer. Used to validate the integrity of the remote peer
+   * @param options.signal - Used to abort the operation
+   */
+  async secureOutbound(connection, options) {
+    const wrappedConnection = index.lpStream(connection, {
+      lengthEncoder: encoder.uint16BEEncode,
+      lengthDecoder: encoder.uint16BEDecode,
+      maxDataLength: constants.NOISE_MSG_MAX_LENGTH_BYTES
+    });
+    const handshake = await this.performHandshakeInitiator(wrappedConnection, this.components.privateKey, options?.remotePeer?.publicKey, options);
+    const conn = await this.createSecureConnection(wrappedConnection, handshake);
+    connection.source = conn.source;
+    connection.sink = conn.sink;
+    const publicKey = index$1.publicKeyFromProtobuf(handshake.payload.identityKey);
+    return {
+      conn: connection,
+      remoteExtensions: handshake.payload.extensions,
+      remotePeer: peerId.peerIdFromPublicKey(publicKey),
+      streamMuxer: options?.skipStreamMuxerNegotiation === true ? undefined : this.getStreamMuxer(handshake.payload.extensions?.streamMuxers)
+    };
+  }
+  getStreamMuxer(protocols) {
+    if (protocols == null || protocols.length === 0) {
+      return;
+    }
+    const streamMuxers = this.components.upgrader.getStreamMuxers();
+    if (streamMuxers != null) {
+      for (const protocol of protocols) {
+        const streamMuxer = streamMuxers.get(protocol);
+        if (streamMuxer != null) {
+          return streamMuxer;
+        }
+      }
+    }
+    if (protocols.length) {
+      throw new _interface.InvalidCryptoExchangeError('Early muxer negotiation was requested but the initiator and responder had no common muxers');
+    }
+  }
+  /**
+   * Decrypt incoming data (handshake as responder).
+   *
+   * @param connection - streaming iterable duplex that will be encrypted
+   * @param options
+   * @param options.remotePeer - PeerId of the remote peer. Used to validate the integrity of the remote peer
+   * @param options.signal - Used to abort the operation
+   */
+  async secureInbound(connection, options) {
+    const wrappedConnection = index.lpStream(connection, {
+      lengthEncoder: encoder.uint16BEEncode,
+      lengthDecoder: encoder.uint16BEDecode,
+      maxDataLength: constants.NOISE_MSG_MAX_LENGTH_BYTES
+    });
+    const handshake = await this.performHandshakeResponder(wrappedConnection, this.components.privateKey, options?.remotePeer?.publicKey, options);
+    const conn = await this.createSecureConnection(wrappedConnection, handshake);
+    connection.source = conn.source;
+    connection.sink = conn.sink;
+    const publicKey = index$1.publicKeyFromProtobuf(handshake.payload.identityKey);
+    return {
+      conn: connection,
+      remoteExtensions: handshake.payload.extensions,
+      remotePeer: peerId.peerIdFromPublicKey(publicKey),
+      streamMuxer: options?.skipStreamMuxerNegotiation === true ? undefined : this.getStreamMuxer(handshake.payload.extensions?.streamMuxers)
+    };
+  }
+  /**
+   * Perform XX handshake as initiator.
+   */
+  async performHandshakeInitiator(connection,
+  // TODO: pass private key in noise constructor via Components
+  privateKey, remoteIdentityKey, options) {
+    let result;
+    const streamMuxers = options?.skipStreamMuxerNegotiation === true ? [] : [...this.components.upgrader.getStreamMuxers().keys()];
+    try {
+      result = await performHandshake.performHandshakeInitiator({
+        connection,
+        privateKey,
+        remoteIdentityKey,
+        log: this.components.logger.forComponent('libp2p:noise:xxhandshake'),
+        crypto: this.crypto,
+        prologue: this.prologue,
+        s: this.staticKey,
+        extensions: {
+          streamMuxers,
+          webtransportCerthashes: [],
+          ...this.extensions
+        }
+      }, options);
+      this.metrics?.xxHandshakeSuccesses.increment();
+    } catch (e) {
+      this.metrics?.xxHandshakeErrors.increment();
+      throw e;
+    }
+    return result;
+  }
+  /**
+   * Perform XX handshake as responder.
+   */
+  async performHandshakeResponder(connection, privateKey, remoteIdentityKey, options) {
+    let result;
+    const streamMuxers = options?.skipStreamMuxerNegotiation === true ? [] : [...this.components.upgrader.getStreamMuxers().keys()];
+    try {
+      result = await performHandshake.performHandshakeResponder({
+        connection,
+        privateKey,
+        remoteIdentityKey,
+        log: this.components.logger.forComponent('libp2p:noise:xxhandshake'),
+        crypto: this.crypto,
+        prologue: this.prologue,
+        s: this.staticKey,
+        extensions: {
+          streamMuxers,
+          webtransportCerthashes: [],
+          ...this.extensions
+        }
+      }, options);
+      this.metrics?.xxHandshakeSuccesses.increment();
+    } catch (e) {
+      this.metrics?.xxHandshakeErrors.increment();
+      throw e;
+    }
+    return result;
+  }
+  async createSecureConnection(connection, handshake) {
+    // Create encryption box/unbox wrapper
+    const [secure, user] = duplex.duplexPair();
+    const network = connection.unwrap();
+    await index$2.pipe(secure,
+    // write to wrapper
+    streaming.encryptStream(handshake, this.metrics),
+    // encrypt data + prefix with message length
+    network,
+    // send to the remote peer
+    source => decode.decode(source, {
+      lengthDecoder: encoder.uint16BEDecode
+    }),
+    // read message length prefix
+    streaming.decryptStream(handshake, this.metrics),
+    // decrypt the incoming data
+    secure // pipe to the wrapper
+    );
+    return user;
+  }
+}
+
+exports.Noise = Noise;

package/dist/cjs/node_modules/@chainsafe/libp2p-noise/dist/src/nonce.js

@@ -0,0 +1,49 @@
+'use strict';
+
+var alloc = require('../../../../uint8arrays/dist/src/alloc.js');
+
+const MIN_NONCE = 0;
+// For performance reasons, the nonce is represented as a JS `number`
+// Although JS `number` can safely represent integers up to 2 ** 53 - 1, we choose to only use
+// 4 bytes to store the data for performance reason.
+// This is a slight deviation from the noise spec, which describes the max nonce as 2 ** 64 - 2
+// The effect is that this implementation will need a new handshake to be performed after fewer messages are exchanged than other implementations with full uint64 nonces.
+// this MAX_NONCE is still a large number of messages, so the practical effect of this is negligible.
+const MAX_NONCE = 0xffffffff;
+const ERR_MAX_NONCE = 'Cipherstate has reached maximum n, a new handshake must be performed';
+/**
+ * The nonce is an uint that's increased over time.
+ * Maintaining different representations help improve performance.
+ */
+class Nonce {
+  n;
+  bytes;
+  view;
+  constructor() {
+    let n = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : MIN_NONCE;
+    this.n = n;
+    this.bytes = alloc.alloc(12);
+    this.view = new DataView(this.bytes.buffer, this.bytes.byteOffset, this.bytes.byteLength);
+    this.view.setUint32(4, n, true);
+  }
+  increment() {
+    this.n++;
+    // Even though we're treating the nonce as 8 bytes, RFC7539 specifies 12 bytes for a nonce.
+    this.view.setUint32(4, this.n, true);
+  }
+  getBytes() {
+    return this.bytes;
+  }
+  getUint64() {
+    return this.n;
+  }
+  assertValue() {
+    if (this.n > MAX_NONCE) {
+      throw new Error(ERR_MAX_NONCE);
+    }
+  }
+}
+
+exports.MAX_NONCE = MAX_NONCE;
+exports.MIN_NONCE = MIN_NONCE;
+exports.Nonce = Nonce;

package/dist/cjs/node_modules/@chainsafe/libp2p-noise/dist/src/performHandshake.js

@@ -0,0 +1,92 @@
+'use strict';
+
+var logger = require('./logger.js');
+var protocol = require('./protocol.js');
+var utils = require('./utils.js');
+
+async function performHandshakeInitiator(init, options) {
+  const {
+    log,
+    connection,
+    crypto,
+    privateKey,
+    prologue,
+    s,
+    remoteIdentityKey,
+    extensions
+  } = init;
+  const payload = await utils.createHandshakePayload(privateKey, s.publicKey, extensions);
+  const xx = new protocol.XXHandshakeState({
+    crypto,
+    protocolName: 'Noise_XX_25519_ChaChaPoly_SHA256',
+    initiator: true,
+    prologue,
+    s
+  });
+  logger.logLocalStaticKeys(xx.s, log);
+  log.trace('Stage 0 - Initiator starting to send first message.');
+  await connection.write(xx.writeMessageA(protocol.ZEROLEN), options);
+  log.trace('Stage 0 - Initiator finished sending first message.');
+  logger.logLocalEphemeralKeys(xx.e, log);
+  log.trace('Stage 1 - Initiator waiting to receive first message from responder...');
+  const plaintext = xx.readMessageB(await connection.read(options));
+  log.trace('Stage 1 - Initiator received the message.');
+  logger.logRemoteEphemeralKey(xx.re, log);
+  logger.logRemoteStaticKey(xx.rs, log);
+  log.trace("Initiator going to check remote's signature...");
+  const receivedPayload = await utils.decodeHandshakePayload(plaintext, xx.rs, remoteIdentityKey);
+  log.trace('All good with the signature!');
+  log.trace('Stage 2 - Initiator sending third handshake message.');
+  await connection.write(xx.writeMessageC(payload), options);
+  log.trace('Stage 2 - Initiator sent message with signed payload.');
+  const [cs1, cs2] = xx.ss.split();
+  logger.logCipherState(cs1, cs2, log);
+  return {
+    payload: receivedPayload,
+    encrypt: plaintext => cs1.encryptWithAd(protocol.ZEROLEN, plaintext),
+    decrypt: (ciphertext, dst) => cs2.decryptWithAd(protocol.ZEROLEN, ciphertext, dst)
+  };
+}
+async function performHandshakeResponder(init, options) {
+  const {
+    log,
+    connection,
+    crypto,
+    privateKey,
+    prologue,
+    s,
+    remoteIdentityKey,
+    extensions
+  } = init;
+  const payload = await utils.createHandshakePayload(privateKey, s.publicKey, extensions);
+  const xx = new protocol.XXHandshakeState({
+    crypto,
+    protocolName: 'Noise_XX_25519_ChaChaPoly_SHA256',
+    initiator: false,
+    prologue,
+    s
+  });
+  logger.logLocalStaticKeys(xx.s, log);
+  log.trace('Stage 0 - Responder waiting to receive first message.');
+  xx.readMessageA(await connection.read(options));
+  log.trace('Stage 0 - Responder received first message.');
+  logger.logRemoteEphemeralKey(xx.re, log);
+  log.trace('Stage 1 - Responder sending out first message with signed payload and static key.');
+  await connection.write(xx.writeMessageB(payload), options);
+  log.trace('Stage 1 - Responder sent the second handshake message with signed payload.');
+  logger.logLocalEphemeralKeys(xx.e, log);
+  log.trace('Stage 2 - Responder waiting for third handshake message...');
+  const plaintext = xx.readMessageC(await connection.read(options));
+  log.trace('Stage 2 - Responder received the message, finished handshake.');
+  const receivedPayload = await utils.decodeHandshakePayload(plaintext, xx.rs, remoteIdentityKey);
+  const [cs1, cs2] = xx.ss.split();
+  logger.logCipherState(cs1, cs2, log);
+  return {
+    payload: receivedPayload,
+    encrypt: plaintext => cs2.encryptWithAd(protocol.ZEROLEN, plaintext),
+    decrypt: (ciphertext, dst) => cs1.decryptWithAd(protocol.ZEROLEN, ciphertext, dst)
+  };
+}
+
+exports.performHandshakeInitiator = performHandshakeInitiator;
+exports.performHandshakeResponder = performHandshakeResponder;

package/dist/cjs/node_modules/@chainsafe/libp2p-noise/dist/src/proto/payload.js

@@ -0,0 +1,154 @@
+'use strict';
+
+var index = require('../../../../../protons-runtime/dist/src/index.js');
+var alloc = require('../../../../../uint8arrays/dist/src/alloc.js');
+var message = require('../../../../../protons-runtime/dist/src/codecs/message.js');
+var encode = require('../../../../../protons-runtime/dist/src/encode.js');
+var decode = require('../../../../../protons-runtime/dist/src/decode.js');
+
+/* eslint-disable import/export */
+/* eslint-disable complexity */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
+/* eslint-disable @typescript-eslint/no-empty-interface */
+exports.NoiseExtensions = void 0;
+(function (NoiseExtensions) {
+  let _codec;
+  NoiseExtensions.codec = () => {
+    if (_codec == null) {
+      _codec = message.message(function (obj, w) {
+        let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+        if (opts.lengthDelimited !== false) {
+          w.fork();
+        }
+        if (obj.webtransportCerthashes != null) {
+          for (const value of obj.webtransportCerthashes) {
+            w.uint32(10);
+            w.bytes(value);
+          }
+        }
+        if (obj.streamMuxers != null) {
+          for (const value of obj.streamMuxers) {
+            w.uint32(18);
+            w.string(value);
+          }
+        }
+        if (opts.lengthDelimited !== false) {
+          w.ldelim();
+        }
+      }, function (reader, length) {
+        let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+        const obj = {
+          webtransportCerthashes: [],
+          streamMuxers: []
+        };
+        const end = length == null ? reader.len : reader.pos + length;
+        while (reader.pos < end) {
+          const tag = reader.uint32();
+          switch (tag >>> 3) {
+            case 1:
+              {
+                if (opts.limits?.webtransportCerthashes != null && obj.webtransportCerthashes.length === opts.limits.webtransportCerthashes) {
+                  throw new index.MaxLengthError('Decode error - map field "webtransportCerthashes" had too many elements');
+                }
+                obj.webtransportCerthashes.push(reader.bytes());
+                break;
+              }
+            case 2:
+              {
+                if (opts.limits?.streamMuxers != null && obj.streamMuxers.length === opts.limits.streamMuxers) {
+                  throw new index.MaxLengthError('Decode error - map field "streamMuxers" had too many elements');
+                }
+                obj.streamMuxers.push(reader.string());
+                break;
+              }
+            default:
+              {
+                reader.skipType(tag & 7);
+                break;
+              }
+          }
+        }
+        return obj;
+      });
+    }
+    return _codec;
+  };
+  NoiseExtensions.encode = obj => {
+    return encode.encodeMessage(obj, NoiseExtensions.codec());
+  };
+  NoiseExtensions.decode = (buf, opts) => {
+    return decode.decodeMessage(buf, NoiseExtensions.codec(), opts);
+  };
+})(exports.NoiseExtensions || (exports.NoiseExtensions = {}));
+exports.NoiseHandshakePayload = void 0;
+(function (NoiseHandshakePayload) {
+  let _codec;
+  NoiseHandshakePayload.codec = () => {
+    if (_codec == null) {
+      _codec = message.message(function (obj, w) {
+        let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+        if (opts.lengthDelimited !== false) {
+          w.fork();
+        }
+        if (obj.identityKey != null && obj.identityKey.byteLength > 0) {
+          w.uint32(10);
+          w.bytes(obj.identityKey);
+        }
+        if (obj.identitySig != null && obj.identitySig.byteLength > 0) {
+          w.uint32(18);
+          w.bytes(obj.identitySig);
+        }
+        if (obj.extensions != null) {
+          w.uint32(34);
+          exports.NoiseExtensions.codec().encode(obj.extensions, w);
+        }
+        if (opts.lengthDelimited !== false) {
+          w.ldelim();
+        }
+      }, function (reader, length) {
+        let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+        const obj = {
+          identityKey: alloc.alloc(0),
+          identitySig: alloc.alloc(0)
+        };
+        const end = length == null ? reader.len : reader.pos + length;
+        while (reader.pos < end) {
+          const tag = reader.uint32();
+          switch (tag >>> 3) {
+            case 1:
+              {
+                obj.identityKey = reader.bytes();
+                break;
+              }
+            case 2:
+              {
+                obj.identitySig = reader.bytes();
+                break;
+              }
+            case 4:
+              {
+                obj.extensions = exports.NoiseExtensions.codec().decode(reader, reader.uint32(), {
+                  limits: opts.limits?.extensions
+                });
+                break;
+              }
+            default:
+              {
+                reader.skipType(tag & 7);
+                break;
+              }
+          }
+        }
+        return obj;
+      });
+    }
+    return _codec;
+  };
+  NoiseHandshakePayload.encode = obj => {
+    return encode.encodeMessage(obj, NoiseHandshakePayload.codec());
+  };
+  NoiseHandshakePayload.decode = (buf, opts) => {
+    return decode.decodeMessage(buf, NoiseHandshakePayload.codec(), opts);
+  };
+})(exports.NoiseHandshakePayload || (exports.NoiseHandshakePayload = {}));