@libp2p/noise 12.0.1 → 16.1.4-6059227cb

package/src/crypto/index.ts

@@ -0,0 +1,219 @@
+import crypto from 'node:crypto'
+import { newInstance, ChaCha20Poly1305 } from '@chainsafe/as-chacha20poly1305'
+import { digest } from '@chainsafe/as-sha256'
+import { Uint8ArrayList } from 'uint8arraylist'
+import { isElectronMain } from 'wherearewe'
+import { pureJsCrypto } from './js.js'
+import type { ICryptoInterface } from '../crypto.js'
+import type { KeyPair } from '../types.js'
+
+const ctx = newInstance()
+const asImpl = new ChaCha20Poly1305(ctx)
+const CHACHA_POLY1305 = 'chacha20-poly1305'
+const PKCS8_PREFIX = Buffer.from([0x30, 0x2e, 0x02, 0x01, 0x00, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x6e, 0x04, 0x22, 0x04, 0x20])
+const X25519_PREFIX = Buffer.from([0x30, 0x2a, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x6e, 0x03, 0x21, 0x00])
+const nodeCrypto: Pick<ICryptoInterface, 'hashSHA256' | 'chaCha20Poly1305Encrypt' | 'chaCha20Poly1305Decrypt'> = {
+  hashSHA256 (data) {
+    const hash = crypto.createHash('sha256')
+
+    if (data instanceof Uint8Array) {
+      return hash.update(data).digest()
+    }
+
+    for (const buf of data) {
+      hash.update(buf)
+    }
+
+    return hash.digest()
+  },
+
+  chaCha20Poly1305Encrypt (plaintext, nonce, ad, k) {
+    const cipher = crypto.createCipheriv(CHACHA_POLY1305, k, nonce, {
+      authTagLength: 16
+    })
+    cipher.setAAD(ad, { plaintextLength: plaintext.byteLength })
+
+    if (plaintext instanceof Uint8Array) {
+      const updated = cipher.update(plaintext)
+      const final = cipher.final()
+      const tag = cipher.getAuthTag()
+
+      return Buffer.concat([updated, final, tag], updated.byteLength + final.byteLength + tag.byteLength)
+    }
+
+    const output = new Uint8ArrayList()
+
+    for (const buf of plaintext) {
+      output.append(cipher.update(buf))
+    }
+
+    const final = cipher.final()
+
+    if (final.byteLength > 0) {
+      output.append(final)
+    }
+
+    output.append(cipher.getAuthTag())
+
+    return output
+  },
+
+  chaCha20Poly1305Decrypt (ciphertext, nonce, ad, k, _dst) {
+    const authTag = ciphertext.subarray(ciphertext.length - 16)
+    const decipher = crypto.createDecipheriv(CHACHA_POLY1305, k, nonce, {
+      authTagLength: 16
+    })
+
+    let text: Uint8Array | Uint8ArrayList
+
+    if (ciphertext instanceof Uint8Array) {
+      text = ciphertext.subarray(0, ciphertext.length - 16)
+    } else {
+      text = ciphertext.sublist(0, ciphertext.length - 16)
+    }
+
+    decipher.setAAD(ad, {
+      plaintextLength: text.byteLength
+    })
+    decipher.setAuthTag(authTag)
+
+    if (text instanceof Uint8Array) {
+      const output = decipher.update(text)
+      const final = decipher.final()
+
+      if (final.byteLength > 0) {
+        return Buffer.concat([output, final], output.byteLength + final.byteLength)
+      }
+
+      return output
+    }
+
+    const output = new Uint8ArrayList()
+
+    for (const buf of text) {
+      output.append(decipher.update(buf))
+    }
+
+    const final = decipher.final()
+
+    if (final.byteLength > 0) {
+      output.append(final)
+    }
+
+    return output
+  }
+}
+
+const asCrypto: Pick<ICryptoInterface, 'hashSHA256' | 'chaCha20Poly1305Encrypt' | 'chaCha20Poly1305Decrypt'> = {
+  hashSHA256 (data) {
+    return digest(data.subarray())
+  },
+  chaCha20Poly1305Encrypt (plaintext, nonce, ad, k) {
+    return asImpl.seal(k, nonce, plaintext.subarray(), ad)
+  },
+  chaCha20Poly1305Decrypt (ciphertext, nonce, ad, k, dst) {
+    const plaintext = asImpl.open(k, nonce, ciphertext.subarray(), ad, dst)
+    if (!plaintext) {
+      throw new Error('Invalid chacha20poly1305 decryption')
+    }
+    return plaintext
+  }
+}
+
+// benchmarks show that for chacha20poly1305
+// the as implementation is faster for smaller payloads(<1200)
+// and the node implementation is faster for larger payloads
+export const defaultCrypto: ICryptoInterface = {
+  ...pureJsCrypto,
+  hashSHA256 (data) {
+    return nodeCrypto.hashSHA256(data)
+  },
+  chaCha20Poly1305Encrypt (plaintext, nonce, ad, k) {
+    if (plaintext.byteLength < 1200) {
+      return asCrypto.chaCha20Poly1305Encrypt(plaintext, nonce, ad, k)
+    }
+    return nodeCrypto.chaCha20Poly1305Encrypt(plaintext, nonce, ad, k)
+  },
+  chaCha20Poly1305Decrypt (ciphertext, nonce, ad, k, dst) {
+    if (ciphertext.byteLength < 1200) {
+      return asCrypto.chaCha20Poly1305Decrypt(ciphertext, nonce, ad, k, dst)
+    }
+    return nodeCrypto.chaCha20Poly1305Decrypt(ciphertext, nonce, ad, k, dst)
+  },
+  generateX25519KeyPair (): KeyPair {
+    const { publicKey, privateKey } = crypto.generateKeyPairSync('x25519', {
+      publicKeyEncoding: {
+        type: 'spki',
+        format: 'der'
+      },
+      privateKeyEncoding: {
+        type: 'pkcs8',
+        format: 'der'
+      }
+    })
+
+    return {
+      publicKey: publicKey.subarray(X25519_PREFIX.length),
+      privateKey: privateKey.subarray(PKCS8_PREFIX.length)
+    }
+  },
+  generateX25519KeyPairFromSeed (seed: Uint8Array): KeyPair {
+    const privateKey = crypto.createPrivateKey({
+      key: Buffer.concat([
+        PKCS8_PREFIX,
+        seed
+      ], PKCS8_PREFIX.byteLength + seed.byteLength),
+      type: 'pkcs8',
+      format: 'der'
+    })
+
+    const publicKey = crypto.createPublicKey(privateKey)
+      .export({
+        type: 'spki',
+        format: 'der'
+      }).subarray(X25519_PREFIX.length)
+
+    return {
+      publicKey,
+      privateKey: seed
+    }
+  },
+  generateX25519SharedKey (privateKey: Uint8Array | Uint8ArrayList, publicKey: Uint8Array | Uint8ArrayList): Uint8Array {
+    if (publicKey instanceof Uint8Array) {
+      publicKey = Buffer.concat([
+        X25519_PREFIX,
+        publicKey
+      ], X25519_PREFIX.byteLength + publicKey.byteLength)
+    } else {
+      publicKey = new Uint8ArrayList(X25519_PREFIX, publicKey).subarray()
+    }
+
+    if (privateKey instanceof Uint8Array) {
+      privateKey = Buffer.concat([
+        PKCS8_PREFIX,
+        privateKey
+      ], PKCS8_PREFIX.byteLength + privateKey.byteLength)
+    } else {
+      privateKey = new Uint8ArrayList(PKCS8_PREFIX, privateKey).subarray()
+    }
+
+    return crypto.diffieHellman({
+      publicKey: crypto.createPublicKey({
+        key: Buffer.from(publicKey.buffer, publicKey.byteOffset, publicKey.byteLength),
+        type: 'spki',
+        format: 'der'
+      }),
+      privateKey: crypto.createPrivateKey({
+        key: Buffer.from(privateKey.buffer, privateKey.byteOffset, privateKey.byteLength),
+        type: 'pkcs8',
+        format: 'der'
+      })
+    })
+  }
+}
+
+// no chacha20-poly1305 in electron https://github.com/electron/electron/issues/24024
+if (isElectronMain) {
+  defaultCrypto.chaCha20Poly1305Encrypt = asCrypto.chaCha20Poly1305Encrypt
+  defaultCrypto.chaCha20Poly1305Decrypt = asCrypto.chaCha20Poly1305Decrypt
+}

package/src/crypto/js.ts

@@ -1,19 +1,20 @@
-import { hkdf } from '@noble/hashes/hkdf'
-import { sha256 } from '@noble/hashes/sha256'
-import { ChaCha20Poly1305 } from '@stablelib/chacha20poly1305'
-import * as x25519 from '@stablelib/x25519'
-import type { bytes, bytes32 } from '../@types/basic.js'
-import type { Hkdf } from '../@types/handshake.js'
-import type { KeyPair } from '../@types/libp2p.js'
+import { chacha20poly1305 } from '@noble/ciphers/chacha'
+import { x25519 } from '@noble/curves/ed25519'
+import { extract, expand } from '@noble/hashes/hkdf'
+import { sha256 } from '@noble/hashes/sha2'
 import type { ICryptoInterface } from '../crypto.js'
+import type { KeyPair } from '../types.js'
+import type { Uint8ArrayList } from 'uint8arraylist'
 
 export const pureJsCrypto: ICryptoInterface = {
-  hashSHA256 (data: Uint8Array): Uint8Array {
-    return sha256(data)
+  hashSHA256 (data: Uint8Array | Uint8ArrayList): Uint8Array {
+    return sha256(data.subarray())
   },
 
-  getHKDF (ck: bytes32, ikm: Uint8Array): Hkdf {
-    const okm = hkdf(sha256, ikm, ck, undefined, 96)
+  getHKDF (ck: Uint8Array, ikm: Uint8Array): [Uint8Array, Uint8Array, Uint8Array] {
+    const prk = extract(sha256, ikm, ck)
+    const okmU8Array = expand(sha256, prk, undefined, 96)
+    const okm = okmU8Array
 
     const k1 = okm.subarray(0, 32)
     const k2 = okm.subarray(32, 64)
@@ -23,36 +24,33 @@ export const pureJsCrypto: ICryptoInterface = {
   },
 
   generateX25519KeyPair (): KeyPair {
-    const keypair = x25519.generateKeyPair()
+    const secretKey = x25519.utils.randomSecretKey()
+    const publicKey = x25519.getPublicKey(secretKey)
 
     return {
-      publicKey: keypair.publicKey,
-      privateKey: keypair.secretKey
+      publicKey,
+      privateKey: secretKey
     }
   },
 
   generateX25519KeyPairFromSeed (seed: Uint8Array): KeyPair {
-    const keypair = x25519.generateKeyPairFromSeed(seed)
+    const publicKey = x25519.getPublicKey(seed)
 
     return {
-      publicKey: keypair.publicKey,
-      privateKey: keypair.secretKey
+      publicKey,
+      privateKey: seed
     }
   },
 
-  generateX25519SharedKey (privateKey: Uint8Array, publicKey: Uint8Array): Uint8Array {
-    return x25519.sharedKey(privateKey, publicKey)
+  generateX25519SharedKey (privateKey: Uint8Array | Uint8ArrayList, publicKey: Uint8Array | Uint8ArrayList): Uint8Array {
+    return x25519.getSharedSecret(privateKey.subarray(), publicKey.subarray())
   },
 
-  chaCha20Poly1305Encrypt (plaintext: Uint8Array, nonce: Uint8Array, ad: Uint8Array, k: bytes32): bytes {
-    const ctx = new ChaCha20Poly1305(k)
-
-    return ctx.seal(nonce, plaintext, ad)
+  chaCha20Poly1305Encrypt (plaintext: Uint8Array | Uint8ArrayList, nonce: Uint8Array, ad: Uint8Array, k: Uint8Array): Uint8Array {
+    return chacha20poly1305(k, nonce, ad).encrypt(plaintext.subarray())
   },
 
-  chaCha20Poly1305Decrypt (ciphertext: Uint8Array, nonce: Uint8Array, ad: Uint8Array, k: bytes32, dst?: Uint8Array): bytes | null {
-    const ctx = new ChaCha20Poly1305(k)
-
-    return ctx.open(nonce, ciphertext, ad, dst)
+  chaCha20Poly1305Decrypt (ciphertext: Uint8Array | Uint8ArrayList, nonce: Uint8Array, ad: Uint8Array, k: Uint8Array, dst?: Uint8Array): Uint8Array {
+    return chacha20poly1305(k, nonce, ad).decrypt(ciphertext.subarray(), dst)
   }
 }

package/src/crypto.ts

@@ -1,16 +1,27 @@
-import type { bytes32, bytes } from './@types/basic.js'
-import type { Hkdf } from './@types/handshake.js'
-import type { KeyPair } from './@types/libp2p.js'
+import type { ICrypto, KeyPair } from './types.js'
+import type { Uint8ArrayList } from 'uint8arraylist'
 
+/** Underlying crypto implementation, meant to be overridable */
 export interface ICryptoInterface {
-  hashSHA256: (data: Uint8Array) => Uint8Array
+  hashSHA256(data: Uint8Array | Uint8ArrayList): Uint8Array
 
-  getHKDF: (ck: bytes32, ikm: Uint8Array) => Hkdf
+  getHKDF(ck: Uint8Array, ikm: Uint8Array): [Uint8Array, Uint8Array, Uint8Array]
 
-  generateX25519KeyPair: () => KeyPair
-  generateX25519KeyPairFromSeed: (seed: Uint8Array) => KeyPair
-  generateX25519SharedKey: (privateKey: Uint8Array, publicKey: Uint8Array) => Uint8Array
+  generateX25519KeyPair(): KeyPair
+  generateX25519KeyPairFromSeed(seed: Uint8Array): KeyPair
+  generateX25519SharedKey(privateKey: Uint8Array | Uint8ArrayList, publicKey: Uint8Array | Uint8ArrayList): Uint8Array
 
-  chaCha20Poly1305Encrypt: (plaintext: Uint8Array, nonce: Uint8Array, ad: Uint8Array, k: bytes32) => bytes
-  chaCha20Poly1305Decrypt: (ciphertext: Uint8Array, nonce: Uint8Array, ad: Uint8Array, k: bytes32, dst?: Uint8Array) => bytes | null
+  chaCha20Poly1305Encrypt(plaintext: Uint8Array | Uint8ArrayList, nonce: Uint8Array, ad: Uint8Array, k: Uint8Array): Uint8ArrayList | Uint8Array
+  chaCha20Poly1305Decrypt(ciphertext: Uint8Array | Uint8ArrayList, nonce: Uint8Array, ad: Uint8Array, k: Uint8Array, dst?: Uint8Array): Uint8ArrayList | Uint8Array
+}
+
+export function wrapCrypto (crypto: ICryptoInterface): ICrypto {
+  return {
+    generateKeypair: crypto.generateX25519KeyPair,
+    dh: (keypair, publicKey) => crypto.generateX25519SharedKey(keypair.privateKey, publicKey).subarray(0, 32),
+    encrypt: crypto.chaCha20Poly1305Encrypt,
+    decrypt: crypto.chaCha20Poly1305Decrypt,
+    hash: crypto.hashSHA256,
+    hkdf: crypto.getHKDF
+  }
 }

package/src/encoder.ts

@@ -1,81 +1,24 @@
-import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
-import type { bytes } from './@types/basic.js'
-import type { MessageBuffer } from './@types/handshake.js'
-import type { LengthDecoderFunction } from 'it-length-prefixed'
+import { allocUnsafe as uint8ArrayAllocUnsafe } from 'uint8arrays/alloc'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
-const allocUnsafe = (len: number): Uint8Array => {
-  if (globalThis.Buffer) {
-    return globalThis.Buffer.allocUnsafe(len)
-  }
-
-  return new Uint8Array(len)
-}
-
 export const uint16BEEncode = (value: number): Uint8Array => {
-  const target = allocUnsafe(2)
-  new DataView(target.buffer, target.byteOffset, target.byteLength).setUint16(0, value, false)
+  const target = uint8ArrayAllocUnsafe(2)
+  target[0] = value >> 8
+  target[1] = value
   return target
 }
 uint16BEEncode.bytes = 2
 
-export const uint16BEDecode: LengthDecoderFunction = (data: Uint8Array | Uint8ArrayList): number => {
-  if (data.length < 2) throw RangeError('Could not decode int16BE')
+export const uint16BEDecode = (data: Uint8Array | Uint8ArrayList): number => {
+  if (data.length < 2) { throw RangeError('Could not decode int16BE') }
 
   if (data instanceof Uint8Array) {
-    return new DataView(data.buffer, data.byteOffset, data.byteLength).getUint16(0, false)
+    let value = 0
+    value += data[0] << 8
+    value += data[1]
+    return value
   }
 
   return data.getUint16(0)
 }
 uint16BEDecode.bytes = 2
-
-// Note: IK and XX encoder usage is opposite (XX uses in stages encode0 where IK uses encode1)
-
-export function encode0 (message: MessageBuffer): bytes {
-  return uint8ArrayConcat([message.ne, message.ciphertext], message.ne.length + message.ciphertext.length)
-}
-
-export function encode1 (message: MessageBuffer): bytes {
-  return uint8ArrayConcat([message.ne, message.ns, message.ciphertext], message.ne.length + message.ns.length + message.ciphertext.length)
-}
-
-export function encode2 (message: MessageBuffer): bytes {
-  return uint8ArrayConcat([message.ns, message.ciphertext], message.ns.length + message.ciphertext.length)
-}
-
-export function decode0 (input: bytes): MessageBuffer {
-  if (input.length < 32) {
-    throw new Error('Cannot decode stage 0 MessageBuffer: length less than 32 bytes.')
-  }
-
-  return {
-    ne: input.subarray(0, 32),
-    ciphertext: input.subarray(32, input.length),
-    ns: new Uint8Array(0)
-  }
-}
-
-export function decode1 (input: bytes): MessageBuffer {
-  if (input.length < 80) {
-    throw new Error('Cannot decode stage 1 MessageBuffer: length less than 80 bytes.')
-  }
-
-  return {
-    ne: input.subarray(0, 32),
-    ns: input.subarray(32, 80),
-    ciphertext: input.subarray(80, input.length)
-  }
-}
-
-export function decode2 (input: bytes): MessageBuffer {
-  if (input.length < 48) {
-    throw new Error('Cannot decode stage 2 MessageBuffer: length less than 48 bytes.')
-  }
-
-  return {
-    ne: new Uint8Array(0),
-    ns: input.subarray(0, 48),
-    ciphertext: input.subarray(48, input.length)
-  }
-}

package/src/errors.ts

@@ -0,0 +1,10 @@
+export class InvalidCryptoExchangeError extends Error {
+  public code: string
+
+  constructor (message = 'Invalid crypto exchange') {
+    super(message)
+    this.code = InvalidCryptoExchangeError.code
+  }
+
+  static readonly code = 'ERR_INVALID_CRYPTO_EXCHANGE'
+}

package/src/index.ts

@@ -1,10 +1,58 @@
+/**
+ * @packageDocumentation
+ *
+ * This repository contains TypeScript implementation of noise protocol, an encryption protocol used in libp2p.
+ *
+ * ## Usage
+ *
+ * Install with `yarn add @libp2p/noise` or `npm i @libp2p/noise`.
+ *
+ * Example of using default noise configuration and passing it to the libp2p config:
+ *
+ * ```ts
+ * import {createLibp2p} from "libp2p"
+ * import {noise} from "@libp2p/noise"
+ *
+ * //custom noise configuration, pass it instead of `noise()`
+ * //x25519 private key
+ * const n = noise({ staticNoiseKey });
+ *
+ * const libp2p = await createLibp2p({
+ *   connectionEncrypters: [noise()],
+ *   //... other options
+ * })
+ * ```
+ *
+ * See the [NoiseInit](https://github.com/ChainSafe/js-libp2p-noise/blob/master/src/noise.ts#L22-L30) interface for noise configuration options.
+ *
+ * ## API
+ *
+ * This module exposes an implementation of the [ConnectionEncrypter](https://libp2p.github.io/js-libp2p/interfaces/_libp2p_interface.ConnectionEncrypter.html) interface.
+ *
+ * ## Bring your own crypto
+ *
+ * You can provide a custom crypto implementation (instead of the default, based on [@noble](https://paulmillr.com/noble/)) by adding a `crypto` field to the init argument passed to the `Noise` factory.
+ *
+ * The implementation must conform to the `ICryptoInterface`, defined in <https://github.com/ChainSafe/js-libp2p-noise/blob/master/src/crypto.ts>
+ */
+
 import { Noise } from './noise.js'
-import type { NoiseInit } from './noise.js'
-import type { NoiseExtensions } from './proto/payload.js'
-import type { ConnectionEncrypter } from '@libp2p/interface/connection-encrypter'
-export type { ICryptoInterface } from './crypto.js'
+import type { NoiseInit, NoiseExtensions } from './noise.js'
+import type { KeyPair } from './types.js'
+import type { ComponentLogger, ConnectionEncrypter, Metrics, PeerId, PrivateKey, Upgrader } from '@libp2p/interface'
+
 export { pureJsCrypto } from './crypto/js.js'
+export type { ICryptoInterface } from './crypto.js'
+export type { NoiseInit, NoiseExtensions, KeyPair }
+
+export interface NoiseComponents {
+  peerId: PeerId
+  privateKey: PrivateKey
+  logger: ComponentLogger
+  upgrader: Upgrader
+  metrics?: Metrics
+}
 
-export function noise (init: NoiseInit = {}): () => ConnectionEncrypter<NoiseExtensions> {
-  return () => new Noise(init)
+export function noise (init: NoiseInit = {}): (components: NoiseComponents) => ConnectionEncrypter<NoiseExtensions> {
+  return (components: NoiseComponents) => new Noise(components, init)
 }

package/src/logger.ts

@@ -1,30 +1,28 @@
-import { type Logger, logger } from '@libp2p/logger'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { DUMP_SESSION_KEYS } from './constants.js'
-import type { NoiseSession } from './@types/handshake.js'
-import type { KeyPair } from './@types/libp2p.js'
-
-const log = logger('libp2p:noise')
-
-export { log as logger }
-
-let keyLogger: Logger
-if (DUMP_SESSION_KEYS) {
-  keyLogger = log
-} else {
-  keyLogger = Object.assign(() => { /* do nothing */ }, {
-    enabled: false,
-    trace: () => {},
-    error: () => {}
-  })
-}
+import type { CipherState } from './protocol.js'
+import type { KeyPair } from './types.js'
+import type { Logger } from '@libp2p/interface'
+import type { Uint8ArrayList } from 'uint8arraylist'
+
+export function logLocalStaticKeys (s: KeyPair | undefined, keyLogger: Logger): void {
+  if (!keyLogger.enabled || !DUMP_SESSION_KEYS) {
+    return
+  }
 
-export function logLocalStaticKeys (s: KeyPair): void {
-  keyLogger(`LOCAL_STATIC_PUBLIC_KEY ${uint8ArrayToString(s.publicKey, 'hex')}`)
-  keyLogger(`LOCAL_STATIC_PRIVATE_KEY ${uint8ArrayToString(s.privateKey, 'hex')}`)
+  if (s) {
+    keyLogger(`LOCAL_STATIC_PUBLIC_KEY ${uint8ArrayToString(s.publicKey, 'hex')}`)
+    keyLogger(`LOCAL_STATIC_PRIVATE_KEY ${uint8ArrayToString(s.privateKey, 'hex')}`)
+  } else {
+    keyLogger('Missing local static keys.')
+  }
 }
 
-export function logLocalEphemeralKeys (e: KeyPair | undefined): void {
+export function logLocalEphemeralKeys (e: KeyPair | undefined, keyLogger: Logger): void {
+  if (!keyLogger.enabled || !DUMP_SESSION_KEYS) {
+    return
+  }
+
   if (e) {
     keyLogger(`LOCAL_PUBLIC_EPHEMERAL_KEY ${uint8ArrayToString(e.publicKey, 'hex')}`)
     keyLogger(`LOCAL_PRIVATE_EPHEMERAL_KEY ${uint8ArrayToString(e.privateKey, 'hex')}`)
@@ -33,19 +31,35 @@ export function logLocalEphemeralKeys (e: KeyPair | undefined): void {
   }
 }
 
-export function logRemoteStaticKey (rs: Uint8Array): void {
-  keyLogger(`REMOTE_STATIC_PUBLIC_KEY ${uint8ArrayToString(rs, 'hex')}`)
-}
+export function logRemoteStaticKey (rs: Uint8Array | Uint8ArrayList | undefined, keyLogger: Logger): void {
+  if (!keyLogger.enabled || !DUMP_SESSION_KEYS) {
+    return
+  }
 
-export function logRemoteEphemeralKey (re: Uint8Array): void {
-  keyLogger(`REMOTE_EPHEMERAL_PUBLIC_KEY ${uint8ArrayToString(re, 'hex')}`)
+  if (rs) {
+    keyLogger(`REMOTE_STATIC_PUBLIC_KEY ${uint8ArrayToString(rs.subarray(), 'hex')}`)
+  } else {
+    keyLogger('Missing remote static public key.')
+  }
 }
 
-export function logCipherState (session: NoiseSession): void {
-  if (session.cs1 && session.cs2) {
-    keyLogger(`CIPHER_STATE_1 ${session.cs1.n.getUint64()} ${uint8ArrayToString(session.cs1.k, 'hex')}`)
-    keyLogger(`CIPHER_STATE_2 ${session.cs2.n.getUint64()} ${uint8ArrayToString(session.cs2.k, 'hex')}`)
+export function logRemoteEphemeralKey (re: Uint8Array | Uint8ArrayList | undefined, keyLogger: Logger): void {
+  if (!keyLogger.enabled || !DUMP_SESSION_KEYS) {
+    return
+  }
+
+  if (re) {
+    keyLogger(`REMOTE_EPHEMERAL_PUBLIC_KEY ${uint8ArrayToString(re.subarray(), 'hex')}`)
   } else {
-    keyLogger('Missing cipher state.')
+    keyLogger('Missing remote ephemeral keys.')
   }
 }
+
+export function logCipherState (cs1: CipherState, cs2: CipherState, keyLogger: Logger): void {
+  if (!keyLogger.enabled || !DUMP_SESSION_KEYS) {
+    return
+  }
+
+  keyLogger(`CIPHER_STATE_1 ${cs1.n.getUint64()} ${cs1.k && uint8ArrayToString(cs1.k, 'hex')}`)
+  keyLogger(`CIPHER_STATE_2 ${cs2.n.getUint64()} ${cs2.k && uint8ArrayToString(cs2.k, 'hex')}`)
+}

package/src/metrics.ts

@@ -1,4 +1,4 @@
-import type { Counter, Metrics } from '@libp2p/interface/metrics'
+import type { Counter, Metrics } from '@libp2p/interface'
 
 export type MetricsRegistry = Record<string, Counter>