@libp2p/noise 1.0.0-049bfa0fa

package/package.json

@@ -0,0 +1,94 @@
+{
+  "name": "@libp2p/noise",
+  "version": "1.0.0-049bfa0fa",
+  "description": "Noise libp2p handshake for js-libp2p",
+  "author": "ChainSafe <info@chainsafe.io>",
+  "license": "Apache-2.0 OR MIT",
+  "homepage": "https://github.com/libp2p/js-libp2p/tree/main/packages/connection-encrypter-noise#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/libp2p/js-libp2p.git"
+  },
+  "bugs": {
+    "url": "https://github.com/libp2p/js-libp2p/issues"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "keywords": [
+    "crypto",
+    "libp2p",
+    "noise"
+  ],
+  "type": "module",
+  "types": "./dist/src/index.d.ts",
+  "files": [
+    "src",
+    "dist",
+    "!dist/test",
+    "!**/*.tsbuildinfo"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js"
+    }
+  },
+  "scripts": {
+    "bench": "node benchmarks/benchmark.js",
+    "clean": "aegir clean",
+    "dep-check": "aegir dep-check",
+    "build": "aegir build",
+    "lint": "aegir lint",
+    "lint:fix": "aegir lint --fix",
+    "test": "aegir test",
+    "test:node": "aegir test -t node",
+    "test:browser": "aegir test -t browser -t webworker",
+    "test:electron-main": "aegir test -t electron-main",
+    "test:interop": "aegir test -t node -f dist/test/interop.js",
+    "docs": "aegir docs",
+    "proto:gen": "protons ./src/proto/payload.proto",
+    "prepublish": "npm run build"
+  },
+  "dependencies": {
+    "@chainsafe/as-chacha20poly1305": "^0.1.0",
+    "@chainsafe/as-sha256": "^1.2.0",
+    "@libp2p/crypto": "5.1.9-049bfa0fa",
+    "@libp2p/interface": "3.0.0-049bfa0fa",
+    "@libp2p/peer-id": "6.0.0-049bfa0fa",
+    "@libp2p/utils": "7.0.0-049bfa0fa",
+    "@noble/ciphers": "^1.3.0",
+    "@noble/curves": "^1.9.7",
+    "@noble/hashes": "^1.8.0",
+    "protons-runtime": "^5.6.0",
+    "uint8arraylist": "^2.4.8",
+    "uint8arrays": "^5.1.0",
+    "wherearewe": "^2.0.1"
+  },
+  "devDependencies": {
+    "@libp2p/daemon-client": "10.0.0-049bfa0fa",
+    "@libp2p/daemon-server": "9.0.0-049bfa0fa",
+    "@libp2p/interface-compliance-tests": "7.0.0-049bfa0fa",
+    "@libp2p/interop": "14.0.0-049bfa0fa",
+    "@libp2p/logger": "6.0.0-049bfa0fa",
+    "@libp2p/tcp": "11.0.0-049bfa0fa",
+    "@libp2p/yamux": "8.0.0-049bfa0fa",
+    "@multiformats/multiaddr": "^13.0.1",
+    "@types/sinon": "^17.0.4",
+    "aegir": "^47.0.22",
+    "execa": "^9.6.0",
+    "go-libp2p": "^1.6.0",
+    "iso-random-stream": "^2.0.2",
+    "libp2p": "3.0.0-049bfa0fa",
+    "mkdirp": "^3.0.1",
+    "multiformats": "^13.4.0",
+    "p-defer": "^4.0.1",
+    "protons": "^7.7.0",
+    "sinon": "^21.0.0",
+    "sinon-ts": "^2.0.0"
+  },
+  "browser": {
+    "./dist/src/crypto/index.js": "./dist/src/crypto/index.browser.js"
+  }
+}

package/src/constants.ts

@@ -0,0 +1,5 @@
+export const NOISE_MSG_MAX_LENGTH_BYTES = 65535
+export const NOISE_MSG_MAX_LENGTH_BYTES_WITHOUT_TAG = NOISE_MSG_MAX_LENGTH_BYTES - 16
+
+export const DUMP_SESSION_KEYS = Boolean(globalThis.process?.env?.DUMP_SESSION_KEYS)
+export const CHACHA_TAG_LENGTH = 16

package/src/crypto/index.browser.ts

@@ -0,0 +1,3 @@
+import { pureJsCrypto } from './js.js'
+
+export const defaultCrypto = pureJsCrypto

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

@@ -0,0 +1,56 @@
+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 | Uint8ArrayList): Uint8Array {
+    return sha256(data.subarray())
+  },
+
+  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)
+    const k3 = okm.subarray(64, 96)
+
+    return [k1, k2, k3]
+  },
+
+  generateX25519KeyPair (): KeyPair {
+    const secretKey = x25519.utils.randomSecretKey()
+    const publicKey = x25519.getPublicKey(secretKey)
+
+    return {
+      publicKey,
+      privateKey: secretKey
+    }
+  },
+
+  generateX25519KeyPairFromSeed (seed: Uint8Array): KeyPair {
+    const publicKey = x25519.getPublicKey(seed)
+
+    return {
+      publicKey,
+      privateKey: seed
+    }
+  },
+
+  generateX25519SharedKey (privateKey: Uint8Array | Uint8ArrayList, publicKey: Uint8Array | Uint8ArrayList): Uint8Array {
+    return x25519.getSharedSecret(privateKey.subarray(), publicKey.subarray())
+  },
+
+  chaCha20Poly1305Encrypt (plaintext: Uint8Array | Uint8ArrayList, nonce: Uint8Array, ad: Uint8Array, k: Uint8Array): Uint8Array {
+    return chacha20poly1305(k, nonce, ad).encrypt(plaintext.subarray())
+  },
+
+  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

@@ -0,0 +1,27 @@
+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 | Uint8ArrayList): Uint8Array
+
+  getHKDF(ck: Uint8Array, ikm: Uint8Array): [Uint8Array, Uint8Array, Uint8Array]
+
+  generateX25519KeyPair(): KeyPair
+  generateX25519KeyPairFromSeed(seed: Uint8Array): KeyPair
+  generateX25519SharedKey(privateKey: Uint8Array | Uint8ArrayList, publicKey: Uint8Array | Uint8ArrayList): Uint8Array
+
+  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

@@ -0,0 +1,24 @@
+import { allocUnsafe as uint8ArrayAllocUnsafe } from 'uint8arrays/alloc'
+import type { Uint8ArrayList } from 'uint8arraylist'
+
+export const uint16BEEncode = (value: number): Uint8Array => {
+  const target = uint8ArrayAllocUnsafe(2)
+  target[0] = value >> 8
+  target[1] = value
+  return target
+}
+uint16BEEncode.bytes = 2
+
+export const uint16BEDecode = (data: Uint8Array | Uint8ArrayList): number => {
+  if (data.length < 2) { throw RangeError('Could not decode int16BE') }
+
+  if (data instanceof Uint8Array) {
+    let value = 0
+    value += data[0] << 8
+    value += data[1]
+    return value
+  }
+
+  return data.getUint16(0)
+}
+uint16BEDecode.bytes = 2

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

@@ -0,0 +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, 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 = {}): (components: NoiseComponents) => ConnectionEncrypter<NoiseExtensions> {
+  return (components: NoiseComponents) => new Noise(components, init)
+}

package/src/logger.ts

@@ -0,0 +1,65 @@
+import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
+import { DUMP_SESSION_KEYS } from './constants.js'
+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
+  }
+
+  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, 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')}`)
+  } else {
+    keyLogger('Missing local ephemeral keys.')
+  }
+}
+
+export function logRemoteStaticKey (rs: Uint8Array | Uint8ArrayList | undefined, keyLogger: Logger): void {
+  if (!keyLogger.enabled || !DUMP_SESSION_KEYS) {
+    return
+  }
+
+  if (rs) {
+    keyLogger(`REMOTE_STATIC_PUBLIC_KEY ${uint8ArrayToString(rs.subarray(), 'hex')}`)
+  } else {
+    keyLogger('Missing remote static public key.')
+  }
+}
+
+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 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

@@ -0,0 +1,32 @@
+import type { Counter, Metrics } from '@libp2p/interface'
+
+export type MetricsRegistry = Record<string, Counter>
+
+export function registerMetrics (metrics: Metrics): MetricsRegistry {
+  return {
+    xxHandshakeSuccesses: metrics.registerCounter(
+      'libp2p_noise_xxhandshake_successes_total', {
+        help: 'Total count of noise xxHandshakes successes_'
+      }),
+
+    xxHandshakeErrors: metrics.registerCounter(
+      'libp2p_noise_xxhandshake_error_total', {
+        help: 'Total count of noise xxHandshakes errors'
+      }),
+
+    encryptedPackets: metrics.registerCounter(
+      'libp2p_noise_encrypted_packets_total', {
+        help: 'Total count of noise encrypted packets successfully'
+      }),
+
+    decryptedPackets: metrics.registerCounter(
+      'libp2p_noise_decrypted_packets_total', {
+        help: 'Total count of noise decrypted packets'
+      }),
+
+    decryptErrors: metrics.registerCounter(
+      'libp2p_noise_decrypt_errors_total', {
+        help: 'Total count of noise decrypt errors'
+      })
+  }
+}