@libp2p/autonat-v2 1.0.1-8484de8a2 → 1.0.1-87bc8d4fb

package/src/client.ts

@@ -1,16 +1,23 @@
-import { InvalidParametersError, ProtocolError, serviceCapabilities, serviceDependencies } from '@libp2p/interface'
+import { ProtocolError, serviceCapabilities, serviceDependencies } from '@libp2p/interface'
 import { peerSet } from '@libp2p/peer-collections'
-import { createScalableCuckooFilter, isGlobalUnicast, isPrivate, PeerQueue, repeatingTask, trackedMap, pbStream, getNetConfig } from '@libp2p/utils'
+import { createScalableCuckooFilter } from '@libp2p/utils/filters'
+import { isGlobalUnicast } from '@libp2p/utils/multiaddr/is-global-unicast'
+import { isPrivate } from '@libp2p/utils/multiaddr/is-private'
+import { PeerQueue } from '@libp2p/utils/peer-queue'
+import { repeatingTask } from '@libp2p/utils/repeating-task'
+import { trackedMap } from '@libp2p/utils/tracked-map'
 import { anySignal } from 'any-signal'
+import { pbStream } from 'it-protobuf-stream'
 import { setMaxListeners } from 'main-event'
 import { DEFAULT_CONNECTION_THRESHOLD, DIAL_DATA_CHUNK_SIZE, MAX_DIAL_DATA_BYTES, MAX_INBOUND_STREAMS, MAX_MESSAGE_SIZE, MAX_OUTBOUND_STREAMS, TIMEOUT } from './constants.ts'
 import { DialBack, DialBackResponse, DialResponse, DialStatus, Message } from './pb/index.ts'
 import { randomNumber } from './utils.ts'
 import type { AutoNATv2Components, AutoNATv2ServiceInit } from './index.ts'
-import type { Logger, Connection, Startable, AbortOptions, Stream } from '@libp2p/interface'
+import type { Logger, Connection, Startable, AbortOptions, IncomingStreamData } from '@libp2p/interface'
 import type { AddressType } from '@libp2p/interface-internal'
 import type { PeerSet } from '@libp2p/peer-collections'
-import type { Filter, RepeatingTask } from '@libp2p/utils'
+import type { Filter } from '@libp2p/utils/filters'
+import type { RepeatingTask } from '@libp2p/utils/repeating-task'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 // if more than 3 peers manage to dial us on what we believe to be our external
@@ -147,8 +154,8 @@ export class AutoNATv2Client implements Startable {
       }
     })
 
-    await this.components.registrar.handle(this.dialBackProtocol, (stream, connection) => {
-      void this.handleDialBackStream(stream, connection)
+    await this.components.registrar.handle(this.dialBackProtocol, (data) => {
+      void this.handleDialBackStream(data)
         .catch(err => {
           this.log.error('error handling incoming autonat stream - %e', err)
         })
@@ -232,11 +239,11 @@ export class AutoNATv2Client implements Startable {
   /**
    * Handle an incoming AutoNAT request
    */
-  async handleDialBackStream (stream: Stream, connection: Connection): Promise<void> {
+  async handleDialBackStream (data: IncomingStreamData): Promise<void> {
     const signal = AbortSignal.timeout(this.timeout)
     setMaxListeners(Infinity, signal)
 
-    const messages = pbStream(stream, {
+    const messages = pbStream(data.stream, {
       maxDataLength: this.maxMessageSize
     })
 
@@ -257,12 +264,12 @@ export class AutoNATv2Client implements Startable {
         status: DialBackResponse.DialBackStatus.OK
       }, DialBackResponse)
 
-      await stream.close({
+      await data.stream.close({
         signal
       })
     } catch (err: any) {
       this.log.error('error handling incoming dial back stream - %e', err)
-      stream.abort(err)
+      data.stream.abort(err)
     }
   }
 
@@ -288,9 +295,9 @@ export class AutoNATv2Client implements Startable {
           return false
         }
 
-        const options = getNetConfig(addr.multiaddr)
+        const options = addr.multiaddr.toOptions()
 
-        if (options.type === 'ip6') {
+        if (options.family === 6) {
           // do not send IPv6 addresses to peers without IPv6 addresses
           if (!supportsIPv6) {
             return false
@@ -402,7 +409,7 @@ export class AutoNATv2Client implements Startable {
     // if the remote peer has IPv6 addresses, we can probably send them an IPv6
     // address to verify, otherwise only send them IPv4 addresses
     const supportsIPv6 = peer.addresses.some(({ multiaddr }) => {
-      return getNetConfig(multiaddr).type === 'ip6'
+      return multiaddr.toOptions().family === 6
     })
 
     // get multiaddrs this peer is eligible to verify
@@ -458,7 +465,7 @@ export class AutoNATv2Client implements Startable {
       return
     }
 
-    this.log.trace('asking %a to verify multiaddrs %s', connection.remoteAddr, unverifiedAddresses)
+    this.log.trace('asking %p to verify multiaddrs %s', connection.remotePeer, unverifiedAddresses)
 
     const stream = await connection.newStream(this.dialRequestProtocol, options)
 
@@ -471,7 +478,7 @@ export class AutoNATv2Client implements Startable {
         }
       }, options)
 
-      for (let i = 0; i < unverifiedAddresses.length; i++) {
+      while (true) {
         let response = await messages.read(options)
 
         if (response.dialDataRequest != null) {
@@ -608,20 +615,14 @@ export class AutoNATv2Client implements Startable {
 
   private getNetworkSegment (ma: Multiaddr): string {
     // make sure we use different network segments
-    const options = getNetConfig(ma)
+    const options = ma.toOptions()
 
-    switch (options.type) {
-      case 'ip4': {
-        const octets = options.host.split('.')
-        return octets[0].padStart(3, '0')
-      }
-      case 'ip6': {
-        const octets = options.host.split(':')
-        return octets[0].padStart(4, '0')
-      }
-      default: {
-        throw new InvalidParametersError(`Remote address ${ma} was not an IPv4 or Ipv6 address`)
-      }
+    if (options.family === 4) {
+      const octets = options.host.split('.')
+      return octets[0].padStart(3, '0')
     }
+
+    const octets = options.host.split(':')
+    return octets[0].padStart(4, '0')
   }
 }

package/src/server.ts

@@ -1,14 +1,15 @@
 import { ProtocolError } from '@libp2p/interface'
-import { isPrivateIp, pbStream } from '@libp2p/utils'
+import { isPrivateIp } from '@libp2p/utils/private-ip'
 import { CODE_IP4, CODE_IP6, multiaddr } from '@multiformats/multiaddr'
+import { pbStream } from 'it-protobuf-stream'
 import { setMaxListeners } from 'main-event'
 import { MAX_INBOUND_STREAMS, MAX_MESSAGE_SIZE, MAX_OUTBOUND_STREAMS, TIMEOUT } from './constants.ts'
 import { DialBack, DialBackResponse, DialResponse, DialStatus, Message } from './pb/index.ts'
 import { randomNumber } from './utils.ts'
 import type { AutoNATv2Components, AutoNATv2ServiceInit } from './index.ts'
-import type { Logger, Connection, Startable, AbortOptions, Stream } from '@libp2p/interface'
-import type { ProtobufMessageStream } from '@libp2p/utils'
+import type { Logger, Connection, Startable, AbortOptions, IncomingStreamData, Stream } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
+import type { MessageStream } from 'it-protobuf-stream'
 
 export interface AutoNATv2ServerInit extends AutoNATv2ServiceInit {
   dialRequestProtocol: string
@@ -36,8 +37,6 @@ export class AutoNATv2Server implements Startable {
     this.maxInboundStreams = init.maxInboundStreams ?? MAX_INBOUND_STREAMS
     this.maxOutboundStreams = init.maxOutboundStreams ?? MAX_OUTBOUND_STREAMS
     this.maxMessageSize = init.maxMessageSize ?? MAX_MESSAGE_SIZE
-
-    this.handleDialRequestStream = this.handleDialRequestStream.bind(this)
   }
 
   async start (): Promise<void> {
@@ -46,7 +45,12 @@ export class AutoNATv2Server implements Startable {
     }
 
     // AutoNat server
-    await this.components.registrar.handle(this.dialRequestProtocol, this.handleDialRequestStream, {
+    await this.components.registrar.handle(this.dialRequestProtocol, (data) => {
+      void this.handleDialRequestStream(data)
+        .catch(err => {
+          this.log.error('error handling incoming autonat stream - %e', err)
+        })
+    }, {
       maxInboundStreams: this.maxInboundStreams,
       maxOutboundStreams: this.maxOutboundStreams
     })
@@ -63,95 +67,100 @@ export class AutoNATv2Server implements Startable {
   /**
    * Handle an incoming AutoNAT request
    */
-  async handleDialRequestStream (stream: Stream, connection: Connection): Promise<void> {
+  async handleDialRequestStream (data: IncomingStreamData): Promise<void> {
     const signal = AbortSignal.timeout(this.timeout)
     setMaxListeners(Infinity, signal)
 
-    const messages = pbStream(stream, {
+    const messages = pbStream(data.stream, {
       maxDataLength: this.maxMessageSize
     }).pb(Message)
 
-    const connectionIp = getIpAddress(connection.remoteAddr)
-
-    if (connectionIp == null) {
-      throw new ProtocolError(`Could not find IP address in connection address "${connection.remoteAddr}"`)
-    }
+    try {
+      const connectionIp = getIpAddress(data.connection.remoteAddr)
 
-    const { dialRequest } = await messages.read({
-      signal
-    })
+      if (connectionIp == null) {
+        throw new ProtocolError(`Could not find IP address in connection address "${data.connection.remoteAddr}"`)
+      }
 
-    if (dialRequest == null) {
-      throw new ProtocolError('Did not receive DialRequest message on incoming dial request stream')
-    }
+      const { dialRequest } = await messages.read({
+        signal
+      })
 
-    if (dialRequest.addrs.length === 0) {
-      throw new ProtocolError('Did not receive any addresses to dial')
-    }
+      if (dialRequest == null) {
+        throw new ProtocolError('Did not receive DialRequest message on incoming dial request stream')
+      }
 
-    for (let i = 0; i < dialRequest.addrs.length; i++) {
-      try {
-        const ma = multiaddr(dialRequest.addrs[i])
-        const isDialable = await this.components.connectionManager.isDialable(ma, {
-          signal
-        })
+      if (dialRequest.addrs.length === 0) {
+        throw new ProtocolError('Did not receive any addresses to dial')
+      }
 
-        if (!isDialable) {
-          await messages.write({
-            dialResponse: {
-              addrIdx: i,
-              status: DialResponse.ResponseStatus.E_DIAL_REFUSED,
-              dialStatus: DialStatus.UNUSED
-            }
-          }, {
+      for (let i = 0; i < dialRequest.addrs.length; i++) {
+        try {
+          const ma = multiaddr(dialRequest.addrs[i])
+          const isDialable = await this.components.connectionManager.isDialable(ma, {
             signal
           })
 
-          continue
-        }
+          if (!isDialable) {
+            await messages.write({
+              dialResponse: {
+                addrIdx: i,
+                status: DialResponse.ResponseStatus.E_DIAL_REFUSED,
+                dialStatus: DialStatus.UNUSED
+              }
+            }, {
+              signal
+            })
+
+            continue
+          }
 
-        const ip = getIpAddress(ma)
+          const ip = getIpAddress(ma)
 
-        if (ip == null) {
-          throw new ProtocolError(`Could not find IP address in requested address "${ma}"`)
-        }
+          if (ip == null) {
+            throw new ProtocolError(`Could not find IP address in requested address "${ma}"`)
+          }
 
-        if (isPrivateIp(ip)) {
-          throw new ProtocolError(`Requested address had private IP "${ma}"`)
-        }
+          if (isPrivateIp(ip)) {
+            throw new ProtocolError(`Requested address had private IP "${ma}"`)
+          }
+
+          if (ip !== connectionIp) {
+            // amplification attack protection - request the client sends us a
+            // random number of bytes before we'll dial the address
+            await this.preventAmplificationAttack(messages, i, {
+              signal
+            })
+          }
 
-        if (ip !== connectionIp) {
-          // amplification attack protection - request the client sends us a
-          // random number of bytes before we'll dial the address
-          await this.preventAmplificationAttack(messages, i, {
+          const dialStatus = await this.dialClientBack(ma, dialRequest.nonce, {
             signal
           })
-        }
 
-        const dialStatus = await this.dialClientBack(ma, dialRequest.nonce, {
-          signal
-        })
-
-        await messages.write({
-          dialResponse: {
-            addrIdx: i,
-            status: DialResponse.ResponseStatus.OK,
-            dialStatus
-          }
-        }, {
-          signal
-        })
-      } catch (err) {
-        this.log.error('error handling incoming dialback request - %e', err)
+          await messages.write({
+            dialResponse: {
+              addrIdx: i,
+              status: DialResponse.ResponseStatus.OK,
+              dialStatus
+            }
+          }, {
+            signal
+          })
+        } catch (err) {
+          this.log.error('could not parse multiaddr - %e', err)
+        }
       }
-    }
 
-    await stream.close({
-      signal
-    })
+      await data.stream.close({
+        signal
+      })
+    } catch (err: any) {
+      this.log.error('error handling incoming autonat stream - %e', err)
+      data.stream.abort(err)
+    }
   }
 
-  private async preventAmplificationAttack (messages: ProtobufMessageStream<Message, Stream>, index: number, options: AbortOptions): Promise<void> {
+  private async preventAmplificationAttack (messages: MessageStream<Message, Stream>, index: number, options: AbortOptions): Promise<void> {
     const numBytes = randomNumber(30_000, 100_000)
 
     await messages.write({
@@ -198,7 +207,7 @@ export class AutoNATv2Server implements Startable {
         nonce
       }, DialBack, options)
 
-      const response = await dialBackMessages.read(DialBackResponse, options)
+      const response = await dialBackMessages.read(DialBackResponse)
 
       if (response.status !== DialBackResponse.DialBackStatus.OK) {
         throw new ProtocolError('DialBackResponse status was not OK')