@libp2p/noise 12.0.1

package/src/handshakes/xx.ts

@@ -0,0 +1,184 @@
+import { isValidPublicKey } from '../utils.js'
+import { AbstractHandshake, type DecryptedResult } from './abstract-handshake.js'
+import type { bytes32, bytes } from '../@types/basic.js'
+import type { CipherState, HandshakeState, MessageBuffer, NoiseSession } from '../@types/handshake.js'
+import type { KeyPair } from '../@types/libp2p.js'
+
+export class XX extends AbstractHandshake {
+  private initializeInitiator (prologue: bytes32, s: KeyPair, rs: bytes32, psk: bytes32): HandshakeState {
+    const name = 'Noise_XX_25519_ChaChaPoly_SHA256'
+    const ss = this.initializeSymmetric(name)
+    this.mixHash(ss, prologue)
+    const re = new Uint8Array(32)
+
+    return { ss, s, rs, psk, re }
+  }
+
+  private initializeResponder (prologue: bytes32, s: KeyPair, rs: bytes32, psk: bytes32): HandshakeState {
+    const name = 'Noise_XX_25519_ChaChaPoly_SHA256'
+    const ss = this.initializeSymmetric(name)
+    this.mixHash(ss, prologue)
+    const re = new Uint8Array(32)
+
+    return { ss, s, rs, psk, re }
+  }
+
+  private writeMessageA (hs: HandshakeState, payload: bytes, e?: KeyPair): MessageBuffer {
+    const ns = new Uint8Array(0)
+
+    if (e !== undefined) {
+      hs.e = e
+    } else {
+      hs.e = this.crypto.generateX25519KeyPair()
+    }
+
+    const ne = hs.e.publicKey
+
+    this.mixHash(hs.ss, ne)
+    const ciphertext = this.encryptAndHash(hs.ss, payload)
+
+    return { ne, ns, ciphertext }
+  }
+
+  private writeMessageB (hs: HandshakeState, payload: bytes): MessageBuffer {
+    hs.e = this.crypto.generateX25519KeyPair()
+    const ne = hs.e.publicKey
+    this.mixHash(hs.ss, ne)
+
+    this.mixKey(hs.ss, this.dh(hs.e.privateKey, hs.re))
+    const spk = hs.s.publicKey
+    const ns = this.encryptAndHash(hs.ss, spk)
+
+    this.mixKey(hs.ss, this.dh(hs.s.privateKey, hs.re))
+    const ciphertext = this.encryptAndHash(hs.ss, payload)
+
+    return { ne, ns, ciphertext }
+  }
+
+  private writeMessageC (hs: HandshakeState, payload: bytes): { messageBuffer: MessageBuffer, cs1: CipherState, cs2: CipherState, h: bytes } {
+    const spk = hs.s.publicKey
+    const ns = this.encryptAndHash(hs.ss, spk)
+    this.mixKey(hs.ss, this.dh(hs.s.privateKey, hs.re))
+    const ciphertext = this.encryptAndHash(hs.ss, payload)
+    const ne = this.createEmptyKey()
+    const messageBuffer: MessageBuffer = { ne, ns, ciphertext }
+    const { cs1, cs2 } = this.split(hs.ss)
+
+    return { h: hs.ss.h, messageBuffer, cs1, cs2 }
+  }
+
+  private readMessageA (hs: HandshakeState, message: MessageBuffer): DecryptedResult {
+    if (isValidPublicKey(message.ne)) {
+      hs.re = message.ne
+    }
+
+    this.mixHash(hs.ss, hs.re)
+    return this.decryptAndHash(hs.ss, message.ciphertext)
+  }
+
+  private readMessageB (hs: HandshakeState, message: MessageBuffer): DecryptedResult {
+    if (isValidPublicKey(message.ne)) {
+      hs.re = message.ne
+    }
+
+    this.mixHash(hs.ss, hs.re)
+    if (!hs.e) {
+      throw new Error('Handshake state `e` param is missing.')
+    }
+    this.mixKey(hs.ss, this.dh(hs.e.privateKey, hs.re))
+    const { plaintext: ns, valid: valid1 } = this.decryptAndHash(hs.ss, message.ns)
+    if (valid1 && isValidPublicKey(ns)) {
+      hs.rs = ns
+    }
+    this.mixKey(hs.ss, this.dh(hs.e.privateKey, hs.rs))
+    const { plaintext, valid: valid2 } = this.decryptAndHash(hs.ss, message.ciphertext)
+    return { plaintext, valid: (valid1 && valid2) }
+  }
+
+  private readMessageC (hs: HandshakeState, message: MessageBuffer): { h: bytes, plaintext: bytes, valid: boolean, cs1: CipherState, cs2: CipherState } {
+    const { plaintext: ns, valid: valid1 } = this.decryptAndHash(hs.ss, message.ns)
+    if (valid1 && isValidPublicKey(ns)) {
+      hs.rs = ns
+    }
+    if (!hs.e) {
+      throw new Error('Handshake state `e` param is missing.')
+    }
+    this.mixKey(hs.ss, this.dh(hs.e.privateKey, hs.rs))
+
+    const { plaintext, valid: valid2 } = this.decryptAndHash(hs.ss, message.ciphertext)
+    const { cs1, cs2 } = this.split(hs.ss)
+
+    return { h: hs.ss.h, plaintext, valid: (valid1 && valid2), cs1, cs2 }
+  }
+
+  public initSession (initiator: boolean, prologue: bytes32, s: KeyPair): NoiseSession {
+    const psk = this.createEmptyKey()
+    const rs = new Uint8Array(32) // no static key yet
+    let hs
+
+    if (initiator) {
+      hs = this.initializeInitiator(prologue, s, rs, psk)
+    } else {
+      hs = this.initializeResponder(prologue, s, rs, psk)
+    }
+
+    return {
+      hs,
+      i: initiator,
+      mc: 0
+    }
+  }
+
+  public sendMessage (session: NoiseSession, message: bytes, ephemeral?: KeyPair): MessageBuffer {
+    let messageBuffer: MessageBuffer
+    if (session.mc === 0) {
+      messageBuffer = this.writeMessageA(session.hs, message, ephemeral)
+    } else if (session.mc === 1) {
+      messageBuffer = this.writeMessageB(session.hs, message)
+    } else if (session.mc === 2) {
+      const { h, messageBuffer: resultingBuffer, cs1, cs2 } = this.writeMessageC(session.hs, message)
+      messageBuffer = resultingBuffer
+      session.h = h
+      session.cs1 = cs1
+      session.cs2 = cs2
+    } else if (session.mc > 2) {
+      if (session.i) {
+        if (!session.cs1) {
+          throw new Error('CS1 (cipher state) is not defined')
+        }
+
+        messageBuffer = this.writeMessageRegular(session.cs1, message)
+      } else {
+        if (!session.cs2) {
+          throw new Error('CS2 (cipher state) is not defined')
+        }
+
+        messageBuffer = this.writeMessageRegular(session.cs2, message)
+      }
+    } else {
+      throw new Error('Session invalid.')
+    }
+
+    session.mc++
+    return messageBuffer
+  }
+
+  public recvMessage (session: NoiseSession, message: MessageBuffer): DecryptedResult {
+    let plaintext: bytes = new Uint8Array(0)
+    let valid = false
+    if (session.mc === 0) {
+      ({ plaintext, valid } = this.readMessageA(session.hs, message))
+    } else if (session.mc === 1) {
+      ({ plaintext, valid } = this.readMessageB(session.hs, message))
+    } else if (session.mc === 2) {
+      const { h, plaintext: resultingPlaintext, valid: resultingValid, cs1, cs2 } = this.readMessageC(session.hs, message)
+      plaintext = resultingPlaintext
+      valid = resultingValid
+      session.h = h
+      session.cs1 = cs1
+      session.cs2 = cs2
+    }
+    session.mc++
+    return { plaintext, valid }
+  }
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+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'
+export { pureJsCrypto } from './crypto/js.js'
+
+export function noise (init: NoiseInit = {}): () => ConnectionEncrypter<NoiseExtensions> {
+  return () => new Noise(init)
+}

package/src/logger.ts

@@ -0,0 +1,51 @@
+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: () => {}
+  })
+}
+
+export function logLocalStaticKeys (s: KeyPair): void {
+  keyLogger(`LOCAL_STATIC_PUBLIC_KEY ${uint8ArrayToString(s.publicKey, 'hex')}`)
+  keyLogger(`LOCAL_STATIC_PRIVATE_KEY ${uint8ArrayToString(s.privateKey, 'hex')}`)
+}
+
+export function logLocalEphemeralKeys (e: KeyPair | undefined): void {
+  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): void {
+  keyLogger(`REMOTE_STATIC_PUBLIC_KEY ${uint8ArrayToString(rs, 'hex')}`)
+}
+
+export function logRemoteEphemeralKey (re: Uint8Array): void {
+  keyLogger(`REMOTE_EPHEMERAL_PUBLIC_KEY ${uint8ArrayToString(re, 'hex')}`)
+}
+
+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')}`)
+  } else {
+    keyLogger('Missing cipher state.')
+  }
+}

package/src/metrics.ts

@@ -0,0 +1,32 @@
+import type { Counter, Metrics } from '@libp2p/interface/metrics'
+
+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'
+      })
+  }
+}

package/src/noise.ts

@@ -0,0 +1,192 @@
+import { decode } from 'it-length-prefixed'
+import { lpStream, type LengthPrefixedStream } from 'it-length-prefixed-stream'
+import { duplexPair } from 'it-pair/duplex'
+import { pipe } from 'it-pipe'
+import { NOISE_MSG_MAX_LENGTH_BYTES } from './constants.js'
+import { pureJsCrypto } from './crypto/js.js'
+import { decryptStream, encryptStream } from './crypto/streaming.js'
+import { uint16BEDecode, uint16BEEncode } from './encoder.js'
+import { XXHandshake } from './handshake-xx.js'
+import { type MetricsRegistry, registerMetrics } from './metrics.js'
+import { getPayload } from './utils.js'
+import type { bytes } from './@types/basic.js'
+import type { IHandshake } from './@types/handshake-interface.js'
+import type { INoiseConnection, KeyPair } from './@types/libp2p.js'
+import type { ICryptoInterface } from './crypto.js'
+import type { NoiseExtensions } from './proto/payload.js'
+import type { SecuredConnection } from '@libp2p/interface/connection-encrypter'
+import type { Metrics } from '@libp2p/interface/metrics'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { Duplex, Source } from 'it-stream-types'
+
+interface HandshakeParams {
+  connection: LengthPrefixedStream
+  isInitiator: boolean
+  localPeer: PeerId
+  remotePeer?: PeerId
+}
+
+export interface NoiseInit {
+  /**
+   * x25519 private key, reuse for faster handshakes
+   */
+  staticNoiseKey?: bytes
+  extensions?: NoiseExtensions
+  crypto?: ICryptoInterface
+  prologueBytes?: Uint8Array
+  metrics?: Metrics
+}
+
+export class Noise implements INoiseConnection {
+  public protocol = '/noise'
+  public crypto: ICryptoInterface
+
+  private readonly prologue: Uint8Array
+  private readonly staticKeys: KeyPair
+  private readonly extensions?: NoiseExtensions
+  private readonly metrics?: MetricsRegistry
+
+  constructor (init: NoiseInit = {}) {
+    const { staticNoiseKey, extensions, crypto, prologueBytes, metrics } = init
+
+    this.crypto = crypto ?? pureJsCrypto
+    this.extensions = extensions
+    this.metrics = metrics ? registerMetrics(metrics) : undefined
+
+    if (staticNoiseKey) {
+      // accepts x25519 private key of length 32
+      this.staticKeys = this.crypto.generateX25519KeyPairFromSeed(staticNoiseKey)
+    } else {
+      this.staticKeys = this.crypto.generateX25519KeyPair()
+    }
+    this.prologue = prologueBytes ?? new Uint8Array(0)
+  }
+
+  /**
+   * Encrypt outgoing data to the remote party (handshake as initiator)
+   *
+   * @param {PeerId} localPeer - PeerId of the receiving peer
+   * @param {Duplex<AsyncGenerator<Uint8Array>, AsyncIterable<Uint8Array>, Promise<void>>} connection - streaming iterable duplex that will be encrypted
+   * @param {PeerId} remotePeer - PeerId of the remote peer. Used to validate the integrity of the remote peer.
+   * @returns {Promise<SecuredConnection>}
+   */
+  public async secureOutbound (localPeer: PeerId, connection: Duplex<AsyncGenerator<Uint8Array>, AsyncIterable<Uint8Array>, Promise<void>>, remotePeer?: PeerId): Promise<SecuredConnection<NoiseExtensions>> {
+    const wrappedConnection = lpStream(
+      connection,
+      {
+        lengthEncoder: uint16BEEncode,
+        lengthDecoder: uint16BEDecode,
+        maxDataLength: NOISE_MSG_MAX_LENGTH_BYTES
+      }
+    )
+    const handshake = await this.performHandshake({
+      connection: wrappedConnection,
+      isInitiator: true,
+      localPeer,
+      remotePeer
+    })
+    const conn = await this.createSecureConnection(wrappedConnection, handshake)
+
+    return {
+      conn,
+      remoteExtensions: handshake.remoteExtensions,
+      remotePeer: handshake.remotePeer
+    }
+  }
+
+  /**
+   * Decrypt incoming data (handshake as responder).
+   *
+   * @param {PeerId} localPeer - PeerId of the receiving peer.
+   * @param {Duplex<AsyncGenerator<Uint8Array>, AsyncIterable<Uint8Array>, Promise<void>>} connection - streaming iterable duplex that will be encryption.
+   * @param {PeerId} remotePeer - optional PeerId of the initiating peer, if known. This may only exist during transport upgrades.
+   * @returns {Promise<SecuredConnection>}
+   */
+  public async secureInbound (localPeer: PeerId, connection: Duplex<AsyncGenerator<Uint8Array>, AsyncIterable<Uint8Array>, Promise<void>>, remotePeer?: PeerId): Promise<SecuredConnection<NoiseExtensions>> {
+    const wrappedConnection = lpStream(
+      connection,
+      {
+        lengthEncoder: uint16BEEncode,
+        lengthDecoder: uint16BEDecode,
+        maxDataLength: NOISE_MSG_MAX_LENGTH_BYTES
+      }
+    )
+    const handshake = await this.performHandshake({
+      connection: wrappedConnection,
+      isInitiator: false,
+      localPeer,
+      remotePeer
+    })
+    const conn = await this.createSecureConnection(wrappedConnection, handshake)
+
+    return {
+      conn,
+      remotePeer: handshake.remotePeer,
+      remoteExtensions: handshake.remoteExtensions
+    }
+  }
+
+  /**
+   * If Noise pipes supported, tries IK handshake first with XX as fallback if it fails.
+   * If noise pipes disabled or remote peer static key is unknown, use XX.
+   *
+   * @param {HandshakeParams} params
+   */
+  private async performHandshake (params: HandshakeParams): Promise<IHandshake> {
+    const payload = await getPayload(params.localPeer, this.staticKeys.publicKey, this.extensions)
+
+    // run XX handshake
+    return this.performXXHandshake(params, payload)
+  }
+
+  private async performXXHandshake (
+    params: HandshakeParams,
+    payload: bytes
+  ): Promise<XXHandshake> {
+    const { isInitiator, remotePeer, connection } = params
+    const handshake = new XXHandshake(
+      isInitiator,
+      payload,
+      this.prologue,
+      this.crypto,
+      this.staticKeys,
+      connection,
+      remotePeer
+    )
+
+    try {
+      await handshake.propose()
+      await handshake.exchange()
+      await handshake.finish()
+      this.metrics?.xxHandshakeSuccesses.increment()
+    } catch (e: unknown) {
+      this.metrics?.xxHandshakeErrors.increment()
+      if (e instanceof Error) {
+        e.message = `Error occurred during XX handshake: ${e.message}`
+        throw e
+      }
+    }
+
+    return handshake
+  }
+
+  private async createSecureConnection (
+    connection: LengthPrefixedStream<Duplex<AsyncGenerator<Uint8Array>, AsyncIterable<Uint8Array>, Promise<void>>>,
+    handshake: IHandshake
+  ): Promise<Duplex<AsyncGenerator<Uint8Array>, Source<Uint8Array>, Promise<void>>> {
+    // Create encryption box/unbox wrapper
+    const [secure, user] = duplexPair<Uint8Array>()
+    const network = connection.unwrap()
+
+    await pipe(
+      secure, // write to wrapper
+      encryptStream(handshake, this.metrics), // encrypt data + prefix with message length
+      network, // send to the remote peer
+      (source) => decode(source, { lengthDecoder: uint16BEDecode }), // read message length prefix
+      decryptStream(handshake, this.metrics), // decrypt the incoming data
+      secure // pipe to the wrapper
+    )
+
+    return user
+  }
+}

package/src/nonce.ts

@@ -0,0 +1,49 @@
+import type { bytes, uint64 } from './@types/basic.js'
+
+export 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.
+export 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.
+ */
+export class Nonce {
+  private n: uint64
+  private readonly bytes: bytes
+  private readonly view: DataView
+
+  constructor (n = MIN_NONCE) {
+    this.n = n
+    this.bytes = new Uint8Array(12)
+    this.view = new DataView(this.bytes.buffer, this.bytes.byteOffset, this.bytes.byteLength)
+    this.view.setUint32(4, n, true)
+  }
+
+  increment (): void {
+    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 (): bytes {
+    return this.bytes
+  }
+
+  getUint64 (): uint64 {
+    return this.n
+  }
+
+  assertValue (): void {
+    if (this.n > MAX_NONCE) {
+      throw new Error(ERR_MAX_NONCE)
+    }
+  }
+}

package/src/proto/payload.proto

@@ -0,0 +1,11 @@
+syntax = "proto3";
+
+message NoiseExtensions {
+    repeated bytes webtransport_certhashes = 1;
+}
+
+message NoiseHandshakePayload {
+  bytes identity_key = 1;
+  bytes identity_sig = 2;
+  optional NoiseExtensions extensions = 4;
+}

package/src/proto/payload.ts

@@ -0,0 +1,148 @@
+/* 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 */
+
+import { encodeMessage, decodeMessage, message } from 'protons-runtime'
+import type { Codec } from 'protons-runtime'
+import type { Uint8ArrayList } from 'uint8arraylist'
+
+export interface NoiseExtensions {
+  webtransportCerthashes: Uint8Array[]
+}
+
+export namespace NoiseExtensions {
+  let _codec: Codec<NoiseExtensions>
+
+  export const codec = (): Codec<NoiseExtensions> => {
+    if (_codec == null) {
+      _codec = message<NoiseExtensions>((obj, w, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          w.fork()
+        }
+
+        if (obj.webtransportCerthashes != null) {
+          for (const value of obj.webtransportCerthashes) {
+            w.uint32(10)
+            w.bytes(value)
+          }
+        }
+
+        if (opts.lengthDelimited !== false) {
+          w.ldelim()
+        }
+      }, (reader, length) => {
+        const obj: any = {
+          webtransportCerthashes: []
+        }
+
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1:
+              obj.webtransportCerthashes.push(reader.bytes())
+              break
+            default:
+              reader.skipType(tag & 7)
+              break
+          }
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
+  }
+
+  export const encode = (obj: Partial<NoiseExtensions>): Uint8Array => {
+    return encodeMessage(obj, NoiseExtensions.codec())
+  }
+
+  export const decode = (buf: Uint8Array | Uint8ArrayList): NoiseExtensions => {
+    return decodeMessage(buf, NoiseExtensions.codec())
+  }
+}
+
+export interface NoiseHandshakePayload {
+  identityKey: Uint8Array
+  identitySig: Uint8Array
+  extensions?: NoiseExtensions
+}
+
+export namespace NoiseHandshakePayload {
+  let _codec: Codec<NoiseHandshakePayload>
+
+  export const codec = (): Codec<NoiseHandshakePayload> => {
+    if (_codec == null) {
+      _codec = message<NoiseHandshakePayload>((obj, w, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          w.fork()
+        }
+
+        if (opts.writeDefaults === true || (obj.identityKey != null && obj.identityKey.byteLength > 0)) {
+          w.uint32(10)
+          w.bytes(obj.identityKey ?? new Uint8Array(0))
+        }
+
+        if (opts.writeDefaults === true || (obj.identitySig != null && obj.identitySig.byteLength > 0)) {
+          w.uint32(18)
+          w.bytes(obj.identitySig ?? new Uint8Array(0))
+        }
+
+        if (obj.extensions != null) {
+          w.uint32(34)
+          NoiseExtensions.codec().encode(obj.extensions, w, {
+            writeDefaults: false
+          })
+        }
+
+        if (opts.lengthDelimited !== false) {
+          w.ldelim()
+        }
+      }, (reader, length) => {
+        const obj: any = {
+          identityKey: new Uint8Array(0),
+          identitySig: new Uint8Array(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 = NoiseExtensions.codec().decode(reader, reader.uint32())
+              break
+            default:
+              reader.skipType(tag & 7)
+              break
+          }
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
+  }
+
+  export const encode = (obj: Partial<NoiseHandshakePayload>): Uint8Array => {
+    return encodeMessage(obj, NoiseHandshakePayload.codec())
+  }
+
+  export const decode = (buf: Uint8Array | Uint8ArrayList): NoiseHandshakePayload => {
+    return decodeMessage(buf, NoiseHandshakePayload.codec())
+  }
+}