libp2p 0.46.21 → 1.0.0

package/src/pnet/crypto.ts

@@ -1,67 +0,0 @@
-import { logger } from '@libp2p/logger'
-import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
-import xsalsa20 from 'xsalsa20'
-import * as Errors from './errors.js'
-import { KEY_LENGTH } from './key-generator.js'
-import type { Source } from 'it-stream-types'
-
-const log = logger('libp2p:pnet')
-
-/**
- * Creates a stream iterable to encrypt messages in a private network
- */
-export function createBoxStream (nonce: Uint8Array, psk: Uint8Array): (source: Source<Uint8Array>) => AsyncIterable<Uint8Array> {
-  const xor = xsalsa20(nonce, psk)
-
-  return (source: Source<Uint8Array>) => (async function * () {
-    for await (const chunk of source) {
-      yield Uint8Array.from(xor.update(chunk.slice()))
-    }
-  })()
-}
-
-/**
- * Creates a stream iterable to decrypt messages in a private network
- */
-export function createUnboxStream (nonce: Uint8Array, psk: Uint8Array) {
-  return (source: Source<Uint8Array>) => (async function * () {
-    const xor = xsalsa20(nonce, psk)
-    log.trace('Decryption enabled')
-
-    for await (const chunk of source) {
-      yield Uint8Array.from(xor.update(chunk.slice()))
-    }
-  })()
-}
-
-/**
- * Decode the version 1 psk from the given Uint8Array
- */
-export function decodeV1PSK (pskBuffer: Uint8Array): { tag: string | undefined, codecName: string | undefined, psk: Uint8Array } {
-  try {
-    // This should pull from multibase/multicodec to allow for
-    // more encoding flexibility. Ideally we'd consume the codecs
-    // from the buffer line by line to evaluate the next line
-    // programmatically instead of making assumptions about the
-    // encodings of each line.
-    const metadata = uint8ArrayToString(pskBuffer).split(/(?:\r\n|\r|\n)/g)
-    const pskTag = metadata.shift()
-    const codec = metadata.shift()
-    const pskString = metadata.shift()
-    const psk = uint8ArrayFromString(pskString ?? '', 'base16')
-
-    if (psk.byteLength !== KEY_LENGTH) {
-      throw new Error(Errors.INVALID_PSK)
-    }
-
-    return {
-      tag: pskTag,
-      codecName: codec,
-      psk
-    }
-  } catch (err: any) {
-    log.error(err)
-    throw new Error(Errors.INVALID_PSK)
-  }
-}

package/src/pnet/errors.ts

@@ -1,5 +0,0 @@
-export const INVALID_PEER = 'Not a valid peer connection'
-export const INVALID_PSK = 'Your private shared key is invalid'
-export const NO_LOCAL_ID = 'No local private key provided'
-export const NO_HANDSHAKE_CONNECTION = 'No connection for the handshake provided'
-export const STREAM_ENDED = 'Stream ended prematurely'

package/src/pnet/index.ts

@@ -1,126 +0,0 @@
-/**
- * @packageDocumentation
- *
- * Connection protection management for libp2p leveraging PSK encryption via XSalsa20.
- *
- * @example
- *
- * ```typescript
- * import { createLibp2p } from 'libp2p'
- * import { preSharedKey, generateKey } from 'libp2p/pnet'
- *
- * // Create a Uint8Array and write the swarm key to it
- * const swarmKey = new Uint8Array(95)
- * generateKey(swarmKey)
- *
- * const node = await createLibp2p({
- *   // ...other options
- *   connectionProtector: preSharedKey({
- *     psk: swarmKey
- *   })
- * })
- * ```
- */
-
-import { randomBytes } from '@libp2p/crypto'
-import { CodeError } from '@libp2p/interface/errors'
-import { logger } from '@libp2p/logger'
-import { handshake } from 'it-handshake'
-import map from 'it-map'
-import { duplexPair } from 'it-pair/duplex'
-import { pipe } from 'it-pipe'
-import { codes } from '../errors.js'
-import {
-  createBoxStream,
-  createUnboxStream,
-  decodeV1PSK
-} from './crypto.js'
-import * as Errors from './errors.js'
-import { NONCE_LENGTH } from './key-generator.js'
-import type { ConnectionProtector, MultiaddrConnection } from '@libp2p/interface/connection'
-
-const log = logger('libp2p:pnet')
-
-export { generateKey } from './key-generator.js'
-
-export interface ProtectorInit {
-  enabled?: boolean
-  psk: Uint8Array
-}
-
-class PreSharedKeyConnectionProtector implements ConnectionProtector {
-  public tag: string
-  private readonly psk: Uint8Array
-  private readonly enabled: boolean
-
-  /**
-   * Takes a Private Shared Key (psk) and provides a `protect` method
-   * for wrapping existing connections in a private encryption stream.
-   */
-  constructor (init: ProtectorInit) {
-    this.enabled = init.enabled !== false
-
-    if (this.enabled) {
-      const decodedPSK = decodeV1PSK(init.psk)
-      this.psk = decodedPSK.psk
-      this.tag = decodedPSK.tag ?? ''
-    } else {
-      this.psk = new Uint8Array()
-      this.tag = ''
-    }
-  }
-
-  /**
-   * Takes a given Connection and creates a private encryption stream
-   * between its two peers from the PSK the Protector instance was
-   * created with.
-   */
-  async protect (connection: MultiaddrConnection): Promise<MultiaddrConnection> {
-    if (!this.enabled) {
-      return connection
-    }
-
-    if (connection == null) {
-      throw new CodeError(Errors.NO_HANDSHAKE_CONNECTION, codes.ERR_INVALID_PARAMETERS)
-    }
-
-    // Exchange nonces
-    log('protecting the connection')
-    const localNonce = randomBytes(NONCE_LENGTH)
-
-    const shake = handshake(connection)
-    shake.write(localNonce)
-
-    const result = await shake.reader.next(NONCE_LENGTH)
-
-    if (result.value == null) {
-      throw new CodeError(Errors.STREAM_ENDED, codes.ERR_INVALID_PARAMETERS)
-    }
-
-    const remoteNonce = result.value.slice()
-    shake.rest()
-
-    // Create the boxing/unboxing pipe
-    log('exchanged nonces')
-    const [internal, external] = duplexPair<Uint8Array>()
-    pipe(
-      external,
-      // Encrypt all outbound traffic
-      createBoxStream(localNonce, this.psk),
-      shake.stream,
-      (source) => map(source, (buf) => buf.subarray()),
-      // Decrypt all inbound traffic
-      createUnboxStream(remoteNonce, this.psk),
-      external
-    ).catch(log.error)
-
-    return {
-      ...connection,
-      ...internal
-    }
-  }
-}
-
-export function preSharedKey (init: ProtectorInit): () => ConnectionProtector {
-  return () => new PreSharedKeyConnectionProtector(init)
-}

package/src/pnet/key-generator.ts

@@ -1,23 +0,0 @@
-import { randomBytes } from '@libp2p/crypto'
-import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
-
-/**
- * Generates a PSK that can be used in a libp2p-pnet private network
- *
- * @param {Uint8Array | NodeJS.WriteStream} bytes - An object to write the psk into
- * @returns {void}
- */
-export function generateKey (bytes: Uint8Array | NodeJS.WriteStream): void {
-  const psk = uint8ArrayToString(randomBytes(KEY_LENGTH), 'base16')
-  const key = uint8ArrayFromString('/key/swarm/psk/1.0.0/\n/base16/\n' + psk)
-
-  if (bytes instanceof Uint8Array) {
-    bytes.set(key)
-  } else {
-    bytes.write(key)
-  }
-}
-
-export const NONCE_LENGTH = 24
-export const KEY_LENGTH = 32

package/src/upnp-nat/index.ts

@@ -1,212 +0,0 @@
-import { upnpNat, type NatAPI } from '@achingbrain/nat-port-mapper'
-import { CodeError } from '@libp2p/interface/errors'
-import { logger } from '@libp2p/logger'
-import { isLoopback } from '@libp2p/utils/multiaddr/is-loopback'
-import { fromNodeAddress } from '@multiformats/multiaddr'
-import isPrivateIp from 'private-ip'
-import { isBrowser } from 'wherearewe'
-import { codes } from '../errors.js'
-import * as pkg from '../version.js'
-import type { PeerId } from '@libp2p/interface/peer-id'
-import type { Startable } from '@libp2p/interface/startable'
-import type { AddressManager } from '@libp2p/interface-internal/address-manager'
-import type { TransportManager } from '@libp2p/interface-internal/transport-manager'
-
-const log = logger('libp2p:upnp-nat')
-const DEFAULT_TTL = 7200
-
-function highPort (min = 1024, max = 65535): number {
-  return Math.floor(Math.random() * (max - min + 1) + min)
-}
-
-export interface PMPOptions {
-  /**
-   * Whether to enable PMP as well as UPnP
-   */
-  enabled?: boolean
-}
-
-export interface UPnPNATInit {
-  /**
-   * Pass a value to use instead of auto-detection
-   */
-  externalAddress?: string
-
-  /**
-   * Pass a value to use instead of auto-detection
-   */
-  localAddress?: string
-
-  /**
-   * A string value to use for the port mapping description on the gateway
-   */
-  description?: string
-
-  /**
-   * How long UPnP port mappings should last for in seconds (minimum 1200)
-   */
-  ttl?: number
-
-  /**
-   * Whether to automatically refresh UPnP port mappings when their TTL is reached
-   */
-  keepAlive?: boolean
-
-  /**
-   * Pass a value to use instead of auto-detection
-   */
-  gateway?: string
-}
-
-export interface UPnPNATComponents {
-  peerId: PeerId
-  transportManager: TransportManager
-  addressManager: AddressManager
-}
-
-class UPnPNAT implements Startable {
-  private readonly components: UPnPNATComponents
-  private readonly externalAddress?: string
-  private readonly localAddress?: string
-  private readonly description: string
-  private readonly ttl: number
-  private readonly keepAlive: boolean
-  private readonly gateway?: string
-  private started: boolean
-  private client?: NatAPI
-
-  constructor (components: UPnPNATComponents, init: UPnPNATInit) {
-    this.components = components
-
-    this.started = false
-    this.externalAddress = init.externalAddress
-    this.localAddress = init.localAddress
-    this.description = init.description ?? `${pkg.name}@${pkg.version} ${this.components.peerId.toString()}`
-    this.ttl = init.ttl ?? DEFAULT_TTL
-    this.keepAlive = init.keepAlive ?? true
-    this.gateway = init.gateway
-
-    if (this.ttl < DEFAULT_TTL) {
-      throw new CodeError(`NatManager ttl should be at least ${DEFAULT_TTL} seconds`, codes.ERR_INVALID_PARAMETERS)
-    }
-  }
-
-  isStarted (): boolean {
-    return this.started
-  }
-
-  start (): void {
-    // #TODO: is there a way to remove this? Seems like a hack
-  }
-
-  /**
-   * Attempt to use uPnP to configure port mapping using the current gateway.
-   *
-   * Run after start to ensure the transport manager has all addresses configured.
-   */
-  afterStart (): void {
-    if (isBrowser || this.started) {
-      return
-    }
-
-    this.started = true
-
-    // done async to not slow down startup
-    void this._start().catch((err) => {
-      // hole punching errors are non-fatal
-      log.error(err)
-    })
-  }
-
-  async _start (): Promise<void> {
-    const addrs = this.components.transportManager.getAddrs()
-
-    for (const addr of addrs) {
-      // try to open uPnP ports for each thin waist address
-      const { family, host, port, transport } = addr.toOptions()
-
-      if (!addr.isThinWaistAddress() || transport !== 'tcp') {
-        // only bare tcp addresses
-        // eslint-disable-next-line no-continue
-        continue
-      }
-
-      if (isLoopback(addr)) {
-        // eslint-disable-next-line no-continue
-        continue
-      }
-
-      if (family !== 4) {
-        // ignore ipv6
-        // eslint-disable-next-line no-continue
-        continue
-      }
-
-      const client = this._getClient()
-      const publicIp = this.externalAddress ?? await client.externalIp()
-      const isPrivate = isPrivateIp(publicIp)
-
-      if (isPrivate === true) {
-        throw new Error(`${publicIp} is private - please set config.nat.externalIp to an externally routable IP or ensure you are not behind a double NAT`)
-      }
-
-      if (isPrivate == null) {
-        throw new Error(`${publicIp} is not an IP address`)
-      }
-
-      const publicPort = highPort()
-
-      log(`opening uPnP connection from ${publicIp}:${publicPort} to ${host}:${port}`)
-
-      await client.map({
-        publicPort,
-        localPort: port,
-        localAddress: this.localAddress,
-        protocol: transport.toUpperCase() === 'TCP' ? 'TCP' : 'UDP'
-      })
-
-      this.components.addressManager.addObservedAddr(fromNodeAddress({
-        family: 4,
-        address: publicIp,
-        port: publicPort
-      }, transport))
-    }
-  }
-
-  _getClient (): NatAPI {
-    if (this.client != null) {
-      return this.client
-    }
-
-    this.client = upnpNat({
-      description: this.description,
-      ttl: this.ttl,
-      keepAlive: this.keepAlive,
-      gateway: this.gateway
-    })
-
-    return this.client
-  }
-
-  /**
-   * Stops the NAT manager
-   */
-  async stop (): Promise<void> {
-    if (isBrowser || this.client == null) {
-      return
-    }
-
-    try {
-      await this.client.close()
-      this.client = undefined
-    } catch (err: any) {
-      log.error(err)
-    }
-  }
-}
-
-export function uPnPNATService (init: UPnPNATInit = {}): (components: UPnPNATComponents) => UPnPNAT {
-  return (components: UPnPNATComponents) => {
-    return new UPnPNAT(components, init)
-  }
-}

package/src/utils/peer-job-queue.ts

@@ -1,119 +0,0 @@
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-
-import { CodeError } from '@libp2p/interface/errors'
-import PQueue from 'p-queue'
-import { codes } from '../errors.js'
-import type { PeerId } from '@libp2p/interface/peer-id'
-import type { QueueAddOptions, Options, Queue } from 'p-queue'
-
-// Port of lower_bound from https://en.cppreference.com/w/cpp/algorithm/lower_bound
-// Used to compute insertion index to keep queue sorted after insertion
-function lowerBound<T> (array: readonly T[], value: T, comparator: (a: T, b: T) => number): number {
-  let first = 0
-  let count = array.length
-
-  while (count > 0) {
-    const step = Math.trunc(count / 2)
-    let it = first + step
-
-    if (comparator(array[it]!, value) <= 0) {
-      first = ++it
-      count -= step + 1
-    } else {
-      count = step
-    }
-  }
-
-  return first
-}
-
-interface RunFunction { (): Promise<unknown> }
-
-export interface PeerPriorityQueueOptions extends QueueAddOptions {
-  peerId: PeerId
-}
-
-interface PeerJob {
-  priority: number
-  peerId: PeerId
-  run: RunFunction
-}
-
-/**
- * Port of https://github.com/sindresorhus/p-queue/blob/main/source/priority-queue.ts
- * that adds support for filtering jobs by peer id
- */
-class PeerPriorityQueue implements Queue<RunFunction, PeerPriorityQueueOptions> {
-  readonly #queue: PeerJob[] = []
-
-  enqueue (run: RunFunction, options?: Partial<PeerPriorityQueueOptions>): void {
-    const peerId = options?.peerId
-    const priority = options?.priority ?? 0
-
-    if (peerId == null) {
-      throw new CodeError('missing peer id', codes.ERR_INVALID_PARAMETERS)
-    }
-
-    const element: PeerJob = {
-      priority,
-      peerId,
-      run
-    }
-
-    if (this.size > 0 && this.#queue[this.size - 1]!.priority >= priority) {
-      this.#queue.push(element)
-      return
-    }
-
-    const index = lowerBound(
-      this.#queue, element,
-      (a: Readonly<PeerPriorityQueueOptions>, b: Readonly<PeerPriorityQueueOptions>) => b.priority! - a.priority!
-    )
-    this.#queue.splice(index, 0, element)
-  }
-
-  dequeue (): RunFunction | undefined {
-    const item = this.#queue.shift()
-    return item?.run
-  }
-
-  filter (options: Readonly<Partial<PeerPriorityQueueOptions>>): RunFunction[] {
-    if (options.peerId != null) {
-      const peerId = options.peerId
-
-      return this.#queue.filter(
-        (element: Readonly<PeerPriorityQueueOptions>) => peerId.equals(element.peerId)
-      ).map((element: Readonly<{ run: RunFunction }>) => element.run)
-    }
-
-    return this.#queue.filter(
-      (element: Readonly<PeerPriorityQueueOptions>) => element.priority === options.priority
-    ).map((element: Readonly<{ run: RunFunction }>) => element.run)
-  }
-
-  get size (): number {
-    return this.#queue.length
-  }
-}
-
-/**
- * Extends PQueue to add support for querying queued jobs by peer id
- */
-export class PeerJobQueue extends PQueue<PeerPriorityQueue, PeerPriorityQueueOptions> {
-  constructor (options: Options<PeerPriorityQueue, PeerPriorityQueueOptions> = {}) {
-    super({
-      ...options,
-      queueClass: PeerPriorityQueue
-    })
-  }
-
-  /**
-   * Returns true if this queue has a job for the passed peer id that has not yet
-   * started to run
-   */
-  hasJob (peerId: PeerId): boolean {
-    return this.sizeBy({
-      peerId
-    }) > 0
-  }
-}