@libp2p/noise 12.0.1 → 16.1.4-8484de8a2

package/src/utils.ts

@@ -1,111 +1,221 @@
-import { unmarshalPublicKey, unmarshalPrivateKey } from '@libp2p/crypto/keys'
-import { peerIdFromKeys } from '@libp2p/peer-id'
+import { publicKeyFromProtobuf, publicKeyToProtobuf } from '@libp2p/crypto/keys'
+import { StreamMessageEvent, UnexpectedPeerError } from '@libp2p/interface'
+import { AbstractMessageStream, LengthPrefixedDecoder } from '@libp2p/utils'
+import { Uint8ArrayList } from 'uint8arraylist'
 import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { type NoiseExtensions, NoiseHandshakePayload } from './proto/payload.js'
-import type { bytes } from './@types/basic.js'
-import type { PeerId } from '@libp2p/interface/peer-id'
-
-export async function getPayload (
-  localPeer: PeerId,
-  staticPublicKey: bytes,
+import { CHACHA_TAG_LENGTH, NOISE_MSG_MAX_LENGTH_BYTES, NOISE_MSG_MAX_LENGTH_BYTES_WITHOUT_TAG } from './constants.ts'
+import { uint16BEEncode, uint16BEDecode } from './encoder.ts'
+import { NoiseHandshakePayload } from './proto/payload.js'
+import type { MetricsRegistry } from './metrics.ts'
+import type { NoiseExtensions } from './proto/payload.js'
+import type { HandshakeResult } from './types.ts'
+import type { AbortOptions, MessageStream, PrivateKey, PublicKey, StreamCloseEvent } from '@libp2p/interface'
+import type { SendResult } from '@libp2p/utils'
+
+export async function createHandshakePayload (
+  privateKey: PrivateKey,
+  staticPublicKey: Uint8Array | Uint8ArrayList,
   extensions?: NoiseExtensions
-): Promise<bytes> {
-  const signedPayload = await signPayload(localPeer, getHandshakePayload(staticPublicKey))
-
-  if (localPeer.publicKey == null) {
-    throw new Error('PublicKey was missing from local PeerId')
-  }
+): Promise<Uint8Array | Uint8ArrayList> {
+  const identitySig = await privateKey.sign(getSignaturePayload(staticPublicKey))
 
-  return createHandshakePayload(
-    localPeer.publicKey,
-    signedPayload,
+  return NoiseHandshakePayload.encode({
+    identityKey: publicKeyToProtobuf(privateKey.publicKey),
+    identitySig,
     extensions
-  )
+  })
 }
 
-export function createHandshakePayload (
-  libp2pPublicKey: Uint8Array,
-  signedPayload: Uint8Array,
-  extensions?: NoiseExtensions
-): bytes {
-  return NoiseHandshakePayload.encode({
-    identityKey: libp2pPublicKey,
-    identitySig: signedPayload,
-    extensions: extensions ?? { webtransportCerthashes: [] }
-  }).subarray()
-}
+export async function decodeHandshakePayload (
+  payloadBytes: Uint8Array | Uint8ArrayList,
+  remoteStaticKey?: Uint8Array | Uint8ArrayList,
+  remoteIdentityKey?: PublicKey
+): Promise<NoiseHandshakePayload> {
+  try {
+    const payload = NoiseHandshakePayload.decode(payloadBytes)
+    const publicKey = publicKeyFromProtobuf(payload.identityKey)
 
-export async function signPayload (peerId: PeerId, payload: bytes): Promise<bytes> {
-  if (peerId.privateKey == null) {
-    throw new Error('PrivateKey was missing from PeerId')
-  }
+    if (remoteIdentityKey?.equals(publicKey) === false) {
+      throw new Error(`Payload identity key ${publicKey} does not match expected remote identity key ${remoteIdentityKey}`)
+    }
 
-  const privateKey = await unmarshalPrivateKey(peerId.privateKey)
+    if (!remoteStaticKey) {
+      throw new Error('Remote static does not exist')
+    }
 
-  return privateKey.sign(payload)
-}
+    const signaturePayload = getSignaturePayload(remoteStaticKey)
 
-export async function getPeerIdFromPayload (payload: NoiseHandshakePayload): Promise<PeerId> {
-  return peerIdFromKeys(payload.identityKey)
-}
+    if (!(await publicKey.verify(signaturePayload, payload.identitySig))) {
+      throw new Error('Invalid payload signature')
+    }
 
-export function decodePayload (payload: bytes | Uint8Array): NoiseHandshakePayload {
-  return NoiseHandshakePayload.decode(payload)
+    return payload
+  } catch (e) {
+    throw new UnexpectedPeerError((e as Error).message)
+  }
 }
 
-export function getHandshakePayload (publicKey: bytes): bytes {
+export function getSignaturePayload (publicKey: Uint8Array | Uint8ArrayList): Uint8Array | Uint8ArrayList {
   const prefix = uint8ArrayFromString('noise-libp2p-static-key:')
-  return uint8ArrayConcat([prefix, publicKey], prefix.length + publicKey.length)
-}
 
-/**
- * Verifies signed payload, throws on any irregularities.
- *
- * @param {bytes} noiseStaticKey - owner's noise static key
- * @param {bytes} payload - decoded payload
- * @param {PeerId} remotePeer - owner's libp2p peer ID
- * @returns {Promise<PeerId>} - peer ID of payload owner
- */
-export async function verifySignedPayload (
-  noiseStaticKey: bytes,
-  payload: NoiseHandshakePayload,
-  remotePeer: PeerId
-): Promise<PeerId> {
-  // Unmarshaling from PublicKey protobuf
-  const payloadPeerId = await peerIdFromKeys(payload.identityKey)
-  if (!payloadPeerId.equals(remotePeer)) {
-    throw new Error(`Payload identity key ${payloadPeerId.toString()} does not match expected remote peer ${remotePeer.toString()}`)
+  if (publicKey instanceof Uint8Array) {
+    return uint8ArrayConcat([prefix, publicKey], prefix.length + publicKey.length)
   }
-  const generatedPayload = getHandshakePayload(noiseStaticKey)
 
-  if (payloadPeerId.publicKey == null) {
-    throw new Error('PublicKey was missing from PeerId')
+  publicKey.prepend(prefix)
+
+  return publicKey
+}
+
+class EncryptedMessageStream extends AbstractMessageStream {
+  private stream: MessageStream
+  private handshake: HandshakeResult
+  private metrics?: MetricsRegistry
+  private decoder: LengthPrefixedDecoder
+
+  constructor (stream: MessageStream, handshake: HandshakeResult, metrics?: MetricsRegistry) {
+    super({
+      log: stream.log,
+      inactivityTimeout: stream.inactivityTimeout,
+      maxReadBufferLength: stream.maxReadBufferLength,
+      direction: stream.direction
+    })
+
+    this.stream = stream
+    this.handshake = handshake
+    this.metrics = metrics
+    this.decoder = new LengthPrefixedDecoder({
+      lengthDecoder: uint16BEDecode,
+      maxBufferSize: 16 * 1024 * 1024,
+      encodingLength: () => 2
+    })
+
+    const noiseOnMessageDecrypt = (evt: StreamMessageEvent): void => {
+      try {
+        for (const buf of this.decoder.decode(evt.data)) {
+          this.onData(this.decrypt(buf))
+        }
+      } catch (err: any) {
+        this.abort(err)
+      }
+    }
+    this.stream.addEventListener('message', noiseOnMessageDecrypt)
+
+    const noiseOnClose = (evt: StreamCloseEvent): void => {
+      if (evt.error != null) {
+        if (evt.local === true) {
+          this.abort(evt.error)
+        } else {
+          this.onRemoteReset()
+        }
+      } else {
+        this.onTransportClosed()
+      }
+    }
+    this.stream.addEventListener('close', noiseOnClose)
+
+    const noiseOnDrain = (): void => {
+      this.safeDispatchEvent('drain')
+    }
+    this.stream.addEventListener('drain', noiseOnDrain)
+
+    const noiseOnRemoteCloseWrite = (): void => {
+      this.onRemoteCloseWrite()
+    }
+    this.stream.addEventListener('remoteCloseWrite', noiseOnRemoteCloseWrite)
   }
 
-  if (payload.identitySig == null) {
-    throw new Error('Signature was missing from message')
+  encrypt (chunk: Uint8Array | Uint8ArrayList): Uint8ArrayList {
+    const output = new Uint8ArrayList()
+
+    for (let i = 0; i < chunk.byteLength; i += NOISE_MSG_MAX_LENGTH_BYTES_WITHOUT_TAG) {
+      let end = i + NOISE_MSG_MAX_LENGTH_BYTES_WITHOUT_TAG
+      if (end > chunk.byteLength) {
+        end = chunk.byteLength
+      }
+
+      let data: Uint8Array | Uint8ArrayList
+
+      if (chunk instanceof Uint8Array) {
+        data = this.handshake.encrypt(chunk.subarray(i, end))
+      } else {
+        data = this.handshake.encrypt(chunk.sublist(i, end))
+      }
+
+      this.metrics?.encryptedPackets.increment()
+
+      output.append(uint16BEEncode(data.byteLength))
+      output.append(data)
+    }
+
+    return output
   }
 
-  const publicKey = unmarshalPublicKey(payloadPeerId.publicKey)
+  decrypt (chunk: Uint8Array | Uint8ArrayList): Uint8ArrayList {
+    const output = new Uint8ArrayList()
+
+    for (let i = 0; i < chunk.byteLength; i += NOISE_MSG_MAX_LENGTH_BYTES) {
+      let end = i + NOISE_MSG_MAX_LENGTH_BYTES
+      if (end > chunk.byteLength) {
+        end = chunk.byteLength
+      }
+
+      if (end - CHACHA_TAG_LENGTH < i) {
+        throw new Error('Invalid chunk')
+      }
+
+      let encrypted: Uint8Array | Uint8ArrayList
+
+      if (chunk instanceof Uint8Array) {
+        encrypted = chunk.subarray(i, end)
+      } else {
+        encrypted = chunk.sublist(i, end)
+      }
+
+      // memory allocation is not cheap so reuse the encrypted Uint8Array
+      // see https://github.com/ChainSafe/js-libp2p-noise/pull/242#issue-1422126164
+      // this is ok because chacha20 reads bytes one by one and don't reread after that
+      // it's also tested in https://github.com/ChainSafe/as-chacha20poly1305/pull/1/files#diff-25252846b58979dcaf4e41d47b3eadd7e4f335e7fb98da6c049b1f9cd011f381R48
+      const dst = chunk.subarray(i, end - CHACHA_TAG_LENGTH)
+      try {
+        const plaintext = this.handshake.decrypt(encrypted, dst)
+        this.metrics?.decryptedPackets.increment()
+
+        output.append(plaintext)
+      } catch (e) {
+        this.metrics?.decryptErrors.increment()
+        throw e
+      }
+    }
+
+    return output
+  }
 
-  const valid = await publicKey.verify(generatedPayload, payload.identitySig)
+  close (options?: AbortOptions): Promise<void> {
+    return this.stream.close(options)
+  }
 
-  if (!valid) {
-    throw new Error("Static key doesn't match to peer that signed payload!")
+  sendPause (): void {
+    this.stream.pause()
   }
 
-  return payloadPeerId
-}
+  sendResume (): void {
+    this.stream.resume()
+  }
 
-export function isValidPublicKey (pk: bytes): boolean {
-  if (!(pk instanceof Uint8Array)) {
-    return false
+  sendReset (err: Error): void {
+    this.stream.abort(err)
   }
 
-  if (pk.length !== 32) {
-    return false
+  sendData (data: Uint8ArrayList): SendResult {
+    return {
+      sentBytes: data.byteLength,
+      canSendMore: this.stream.send(this.encrypt(data))
+    }
   }
+}
 
-  return true
+export function toMessageStream (connection: MessageStream, handshake: HandshakeResult, metrics?: MetricsRegistry): MessageStream {
+  return new EncryptedMessageStream(connection, handshake, metrics)
 }

package/dist/src/@types/basic.d.ts

@@ -1,5 +0,0 @@
-export type bytes = Uint8Array;
-export type bytes32 = Uint8Array;
-export type bytes16 = Uint8Array;
-export type uint64 = number;
-//# sourceMappingURL=basic.d.ts.map

package/dist/src/@types/basic.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"basic.d.ts","sourceRoot":"","sources":["../../../src/@types/basic.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,KAAK,GAAG,UAAU,CAAA;AAC9B,MAAM,MAAM,OAAO,GAAG,UAAU,CAAA;AAChC,MAAM,MAAM,OAAO,GAAG,UAAU,CAAA;AAEhC,MAAM,MAAM,MAAM,GAAG,MAAM,CAAA"}

package/dist/src/@types/basic.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=basic.js.map

package/dist/src/@types/basic.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"basic.js","sourceRoot":"","sources":["../../../src/@types/basic.ts"],"names":[],"mappings":""}

package/dist/src/@types/handshake-interface.d.ts

@@ -1,15 +0,0 @@
-import type { bytes } from './basic.js';
-import type { NoiseSession } from './handshake.js';
-import type { NoiseExtensions } from '../proto/payload.js';
-import type { PeerId } from '@libp2p/interface/peer-id';
-export interface IHandshake {
-    session: NoiseSession;
-    remotePeer: PeerId;
-    remoteExtensions: NoiseExtensions;
-    encrypt: (plaintext: bytes, session: NoiseSession) => bytes;
-    decrypt: (ciphertext: bytes, session: NoiseSession, dst?: Uint8Array) => {
-        plaintext: bytes;
-        valid: boolean;
-    };
-}
-//# sourceMappingURL=handshake-interface.d.ts.map

package/dist/src/@types/handshake-interface.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handshake-interface.d.ts","sourceRoot":"","sources":["../../../src/@types/handshake-interface.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AACvC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAClD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAC1D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAA;AAEvD,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,YAAY,CAAA;IACrB,UAAU,EAAE,MAAM,CAAA;IAClB,gBAAgB,EAAE,eAAe,CAAA;IACjC,OAAO,EAAE,CAAC,SAAS,EAAE,KAAK,EAAE,OAAO,EAAE,YAAY,KAAK,KAAK,CAAA;IAC3D,OAAO,EAAE,CAAC,UAAU,EAAE,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,GAAG,CAAC,EAAE,UAAU,KAAK;QAAE,SAAS,EAAE,KAAK,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE,CAAA;CAC9G"}

package/dist/src/@types/handshake-interface.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=handshake-interface.js.map

package/dist/src/@types/handshake-interface.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"handshake-interface.js","sourceRoot":"","sources":["../../../src/@types/handshake-interface.ts"],"names":[],"mappings":""}

package/dist/src/@types/handshake.d.ts

@@ -1,40 +0,0 @@
-import type { bytes, bytes32, uint64 } from './basic.js';
-import type { KeyPair } from './libp2p.js';
-import type { Nonce } from '../nonce.js';
-export type Hkdf = [bytes, bytes, bytes];
-export interface MessageBuffer {
-    ne: bytes32;
-    ns: bytes;
-    ciphertext: bytes;
-}
-export interface CipherState {
-    k: bytes32;
-    n: Nonce;
-}
-export interface SymmetricState {
-    cs: CipherState;
-    ck: bytes32;
-    h: bytes32;
-}
-export interface HandshakeState {
-    ss: SymmetricState;
-    s: KeyPair;
-    e?: KeyPair;
-    rs: bytes32;
-    re: bytes32;
-    psk: bytes32;
-}
-export interface NoiseSession {
-    hs: HandshakeState;
-    h?: bytes32;
-    cs1?: CipherState;
-    cs2?: CipherState;
-    mc: uint64;
-    i: boolean;
-}
-export interface INoisePayload {
-    identityKey: bytes;
-    identitySig: bytes;
-    data: bytes;
-}
-//# sourceMappingURL=handshake.d.ts.map

package/dist/src/@types/handshake.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handshake.d.ts","sourceRoot":"","sources":["../../../src/@types/handshake.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AACxD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAC1C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAExC,MAAM,MAAM,IAAI,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,CAAA;AAExC,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,OAAO,CAAA;IACX,EAAE,EAAE,KAAK,CAAA;IACT,UAAU,EAAE,KAAK,CAAA;CAClB;AAED,MAAM,WAAW,WAAW;IAC1B,CAAC,EAAE,OAAO,CAAA;IAGV,CAAC,EAAE,KAAK,CAAA;CACT;AAED,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,WAAW,CAAA;IACf,EAAE,EAAE,OAAO,CAAA;IACX,CAAC,EAAE,OAAO,CAAA;CACX;AAED,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,cAAc,CAAA;IAClB,CAAC,EAAE,OAAO,CAAA;IACV,CAAC,CAAC,EAAE,OAAO,CAAA;IACX,EAAE,EAAE,OAAO,CAAA;IACX,EAAE,EAAE,OAAO,CAAA;IACX,GAAG,EAAE,OAAO,CAAA;CACb;AAED,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,cAAc,CAAA;IAClB,CAAC,CAAC,EAAE,OAAO,CAAA;IACX,GAAG,CAAC,EAAE,WAAW,CAAA;IACjB,GAAG,CAAC,EAAE,WAAW,CAAA;IACjB,EAAE,EAAE,MAAM,CAAA;IACV,CAAC,EAAE,OAAO,CAAA;CACX;AAED,MAAM,WAAW,aAAa;IAC5B,WAAW,EAAE,KAAK,CAAA;IAClB,WAAW,EAAE,KAAK,CAAA;IAClB,IAAI,EAAE,KAAK,CAAA;CACZ"}

package/dist/src/@types/handshake.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=handshake.js.map

package/dist/src/@types/handshake.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"handshake.js","sourceRoot":"","sources":["../../../src/@types/handshake.ts"],"names":[],"mappings":""}

package/dist/src/@types/libp2p.d.ts

@@ -1,10 +0,0 @@
-import type { bytes32 } from './basic.js';
-import type { NoiseExtensions } from '../proto/payload.js';
-import type { ConnectionEncrypter } from '@libp2p/interface/connection-encrypter';
-export interface KeyPair {
-    publicKey: bytes32;
-    privateKey: bytes32;
-}
-export interface INoiseConnection extends ConnectionEncrypter<NoiseExtensions> {
-}
-//# sourceMappingURL=libp2p.d.ts.map

package/dist/src/@types/libp2p.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"libp2p.d.ts","sourceRoot":"","sources":["../../../src/@types/libp2p.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;AACzC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAC1D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAA;AAEjF,MAAM,WAAW,OAAO;IACtB,SAAS,EAAE,OAAO,CAAA;IAClB,UAAU,EAAE,OAAO,CAAA;CACpB;AAED,MAAM,WAAW,gBAAiB,SAAQ,mBAAmB,CAAC,eAAe,CAAC;CAAG"}

package/dist/src/@types/libp2p.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=libp2p.js.map

package/dist/src/@types/libp2p.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"libp2p.js","sourceRoot":"","sources":["../../../src/@types/libp2p.ts"],"names":[],"mappings":""}

package/dist/src/crypto/streaming.d.ts

@@ -1,7 +0,0 @@
-import type { IHandshake } from '../@types/handshake-interface.js';
-import type { MetricsRegistry } from '../metrics.js';
-import type { Transform } from 'it-stream-types';
-import type { Uint8ArrayList } from 'uint8arraylist';
-export declare function encryptStream(handshake: IHandshake, metrics?: MetricsRegistry): Transform<AsyncIterable<Uint8Array>>;
-export declare function decryptStream(handshake: IHandshake, metrics?: MetricsRegistry): Transform<AsyncIterable<Uint8ArrayList>, AsyncIterable<Uint8Array>>;
-//# sourceMappingURL=streaming.d.ts.map

package/dist/src/crypto/streaming.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"streaming.d.ts","sourceRoot":"","sources":["../../../src/crypto/streaming.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAA;AAClE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAChD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAGpD,wBAAgB,aAAa,CAAE,SAAS,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,SAAS,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC,CAiBrH;AAGD,wBAAgB,aAAa,CAAE,SAAS,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,SAAS,CAAC,aAAa,CAAC,cAAc,CAAC,EAAE,aAAa,CAAC,UAAU,CAAC,CAAC,CA4BpJ"}

package/dist/src/crypto/streaming.js

@@ -1,50 +0,0 @@
-import { TAG_LENGTH } from '@stablelib/chacha20poly1305';
-import { NOISE_MSG_MAX_LENGTH_BYTES, NOISE_MSG_MAX_LENGTH_BYTES_WITHOUT_TAG } from '../constants.js';
-import { uint16BEEncode } from '../encoder.js';
-// Returns generator that encrypts payload from the user
-export function encryptStream(handshake, metrics) {
-    return async function* (source) {
-        for await (const chunk of source) {
-            for (let i = 0; i < chunk.length; i += NOISE_MSG_MAX_LENGTH_BYTES_WITHOUT_TAG) {
-                let end = i + NOISE_MSG_MAX_LENGTH_BYTES_WITHOUT_TAG;
-                if (end > chunk.length) {
-                    end = chunk.length;
-                }
-                const data = handshake.encrypt(chunk.subarray(i, end), handshake.session);
-                metrics?.encryptedPackets.increment();
-                yield uint16BEEncode(data.byteLength);
-                yield data;
-            }
-        }
-    };
-}
-// Decrypt received payload to the user
-export function decryptStream(handshake, metrics) {
-    return async function* (source) {
-        for await (const chunk of source) {
-            for (let i = 0; i < chunk.length; i += NOISE_MSG_MAX_LENGTH_BYTES) {
-                let end = i + NOISE_MSG_MAX_LENGTH_BYTES;
-                if (end > chunk.length) {
-                    end = chunk.length;
-                }
-                if (end - TAG_LENGTH < i) {
-                    throw new Error('Invalid chunk');
-                }
-                const encrypted = chunk.subarray(i, end);
-                // memory allocation is not cheap so reuse the encrypted Uint8Array
-                // see https://github.com/ChainSafe/js-libp2p-noise/pull/242#issue-1422126164
-                // this is ok because chacha20 reads bytes one by one and don't reread after that
-                // it's also tested in https://github.com/ChainSafe/as-chacha20poly1305/pull/1/files#diff-25252846b58979dcaf4e41d47b3eadd7e4f335e7fb98da6c049b1f9cd011f381R48
-                const dst = chunk.subarray(i, end - TAG_LENGTH);
-                const { plaintext: decrypted, valid } = handshake.decrypt(encrypted, handshake.session, dst);
-                if (!valid) {
-                    metrics?.decryptErrors.increment();
-                    throw new Error('Failed to validate decrypted chunk');
-                }
-                metrics?.decryptedPackets.increment();
-                yield decrypted;
-            }
-        }
-    };
-}
-//# sourceMappingURL=streaming.js.map

package/dist/src/crypto/streaming.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"streaming.js","sourceRoot":"","sources":["../../../src/crypto/streaming.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAA;AACxD,OAAO,EAAE,0BAA0B,EAAE,sCAAsC,EAAE,MAAM,iBAAiB,CAAA;AACpG,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAM9C,wDAAwD;AACxD,MAAM,UAAU,aAAa,CAAE,SAAqB,EAAE,OAAyB;IAC7E,OAAO,KAAK,SAAU,CAAC,EAAE,MAAM;QAC7B,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,MAAM,EAAE;YAChC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,IAAI,sCAAsC,EAAE;gBAC7E,IAAI,GAAG,GAAG,CAAC,GAAG,sCAAsC,CAAA;gBACpD,IAAI,GAAG,GAAG,KAAK,CAAC,MAAM,EAAE;oBACtB,GAAG,GAAG,KAAK,CAAC,MAAM,CAAA;iBACnB;gBAED,MAAM,IAAI,GAAG,SAAS,CAAC,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,SAAS,CAAC,OAAO,CAAC,CAAA;gBACzE,OAAO,EAAE,gBAAgB,CAAC,SAAS,EAAE,CAAA;gBAErC,MAAM,cAAc,CAAC,IAAI,CAAC,UAAU,CAAC,CAAA;gBACrC,MAAM,IAAI,CAAA;aACX;SACF;IACH,CAAC,CAAA;AACH,CAAC;AAED,uCAAuC;AACvC,MAAM,UAAU,aAAa,CAAE,SAAqB,EAAE,OAAyB;IAC7E,OAAO,KAAK,SAAU,CAAC,EAAE,MAAM;QAC7B,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,MAAM,EAAE;YAChC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,IAAI,0BAA0B,EAAE;gBACjE,IAAI,GAAG,GAAG,CAAC,GAAG,0BAA0B,CAAA;gBACxC,IAAI,GAAG,GAAG,KAAK,CAAC,MAAM,EAAE;oBACtB,GAAG,GAAG,KAAK,CAAC,MAAM,CAAA;iBACnB;gBAED,IAAI,GAAG,GAAG,UAAU,GAAG,CAAC,EAAE;oBACxB,MAAM,IAAI,KAAK,CAAC,eAAe,CAAC,CAAA;iBACjC;gBACD,MAAM,SAAS,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAA;gBACxC,mEAAmE;gBACnE,6EAA6E;gBAC7E,iFAAiF;gBACjF,6JAA6J;gBAC7J,MAAM,GAAG,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,GAAG,UAAU,CAAC,CAAA;gBAC/C,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,GAAG,SAAS,CAAC,OAAO,CAAC,SAAS,EAAE,SAAS,CAAC,OAAO,EAAE,GAAG,CAAC,CAAA;gBAC5F,IAAI,CAAC,KAAK,EAAE;oBACV,OAAO,EAAE,aAAa,CAAC,SAAS,EAAE,CAAA;oBAClC,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAA;iBACtD;gBACD,OAAO,EAAE,gBAAgB,CAAC,SAAS,EAAE,CAAA;gBACrC,MAAM,SAAS,CAAA;aAChB;SACF;IACH,CAAC,CAAA;AACH,CAAC"}

package/dist/src/handshake-xx.d.ts

@@ -1,33 +0,0 @@
-import { XX } from './handshakes/xx.js';
-import type { bytes, bytes32 } from './@types/basic.js';
-import type { IHandshake } from './@types/handshake-interface.js';
-import type { NoiseSession } from './@types/handshake.js';
-import type { KeyPair } from './@types/libp2p.js';
-import type { ICryptoInterface } from './crypto.js';
-import type { NoiseExtensions } from './proto/payload.js';
-import type { PeerId } from '@libp2p/interface/peer-id';
-import type { LengthPrefixedStream } from 'it-length-prefixed-stream';
-export declare class XXHandshake implements IHandshake {
-    isInitiator: boolean;
-    session: NoiseSession;
-    remotePeer: PeerId;
-    remoteExtensions: NoiseExtensions;
-    protected payload: bytes;
-    protected connection: LengthPrefixedStream;
-    protected xx: XX;
-    protected staticKeypair: KeyPair;
-    private readonly prologue;
-    constructor(isInitiator: boolean, payload: bytes, prologue: bytes32, crypto: ICryptoInterface, staticKeypair: KeyPair, connection: LengthPrefixedStream, remotePeer?: PeerId, handshake?: XX);
-    propose(): Promise<void>;
-    exchange(): Promise<void>;
-    finish(): Promise<void>;
-    encrypt(plaintext: Uint8Array, session: NoiseSession): bytes;
-    decrypt(ciphertext: Uint8Array, session: NoiseSession, dst?: Uint8Array): {
-        plaintext: bytes;
-        valid: boolean;
-    };
-    getRemoteStaticKey(): bytes;
-    private getCS;
-    protected setRemoteNoiseExtension(e: NoiseExtensions | null | undefined): void;
-}
-//# sourceMappingURL=handshake-xx.d.ts.map

package/dist/src/handshake-xx.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handshake-xx.d.ts","sourceRoot":"","sources":["../../src/handshake-xx.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,EAAE,EAAE,MAAM,oBAAoB,CAAA;AAcvC,OAAO,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAA;AACvD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AACjE,OAAO,KAAK,EAAe,YAAY,EAAE,MAAM,uBAAuB,CAAA;AACtE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAA;AACjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AACnD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AACzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAA;AACvD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AAErE,qBAAa,WAAY,YAAW,UAAU;IACrC,WAAW,EAAE,OAAO,CAAA;IACpB,OAAO,EAAE,YAAY,CAAA;IACrB,UAAU,EAAG,MAAM,CAAA;IACnB,gBAAgB,EAAE,eAAe,CAAiC;IAEzE,SAAS,CAAC,OAAO,EAAE,KAAK,CAAA;IACxB,SAAS,CAAC,UAAU,EAAE,oBAAoB,CAAA;IAC1C,SAAS,CAAC,EAAE,EAAE,EAAE,CAAA;IAChB,SAAS,CAAC,aAAa,EAAE,OAAO,CAAA;IAEhC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;gBAGhC,WAAW,EAAE,OAAO,EACpB,OAAO,EAAE,KAAK,EACd,QAAQ,EAAE,OAAO,EACjB,MAAM,EAAE,gBAAgB,EACxB,aAAa,EAAE,OAAO,EACtB,UAAU,EAAE,oBAAoB,EAChC,UAAU,CAAC,EAAE,MAAM,EACnB,SAAS,CAAC,EAAE,EAAE;IAeH,OAAO,IAAK,OAAO,CAAC,IAAI,CAAC;IAqBzB,QAAQ,IAAK,OAAO,CAAC,IAAI,CAAC;IAiC1B,MAAM,IAAK,OAAO,CAAC,IAAI,CAAC;IA4B9B,OAAO,CAAE,SAAS,EAAE,UAAU,EAAE,OAAO,EAAE,YAAY,GAAG,KAAK;IAM7D,OAAO,CAAE,UAAU,EAAE,UAAU,EAAE,OAAO,EAAE,YAAY,EAAE,GAAG,CAAC,EAAE,UAAU,GAAG;QAAE,SAAS,EAAE,KAAK,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE;IAM/G,kBAAkB,IAAK,KAAK;IAInC,OAAO,CAAC,KAAK;IAYb,SAAS,CAAC,uBAAuB,CAAE,CAAC,EAAE,eAAe,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI;CAKhF"}