libp2p 0.42.2 → 0.43.0

package/src/circuit/transport.ts

@@ -1,278 +0,0 @@
-import { logger } from '@libp2p/logger'
-import errCode from 'err-code'
-import * as mafmt from '@multiformats/mafmt'
-import type { Multiaddr } from '@multiformats/multiaddr'
-import { multiaddr } from '@multiformats/multiaddr'
-import { CircuitRelay as CircuitPB } from './pb/index.js'
-import { codes } from '../errors.js'
-import { streamToMaConnection } from '@libp2p/utils/stream-to-ma-conn'
-import { RELAY_CODEC } from './multicodec.js'
-import { createListener } from './listener.js'
-import { handleCanHop, handleHop, hop } from './circuit/hop.js'
-import { handleStop } from './circuit/stop.js'
-import { StreamHandler } from './circuit/stream-handler.js'
-import { symbol, Upgrader } from '@libp2p/interface-transport'
-import { peerIdFromString } from '@libp2p/peer-id'
-import type { AbortOptions } from '@libp2p/interfaces'
-import type { IncomingStreamData, Registrar } from '@libp2p/interface-registrar'
-import type { Listener, Transport, CreateListenerOptions, ConnectionHandler } from '@libp2p/interface-transport'
-import type { Connection } from '@libp2p/interface-connection'
-import type { RelayConfig } from './index.js'
-import { abortableDuplex } from 'abortable-iterator'
-import { TimeoutController } from 'timeout-abort-controller'
-import { setMaxListeners } from 'events'
-import type { Uint8ArrayList } from 'uint8arraylist'
-import type { Duplex } from 'it-stream-types'
-import type { Startable } from '@libp2p/interfaces/startable'
-import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { PeerStore } from '@libp2p/interface-peer-store'
-import type { AddressManager } from '@libp2p/interface-address-manager'
-
-const log = logger('libp2p:circuit')
-
-export interface CircuitComponents {
-  peerId: PeerId
-  peerStore: PeerStore
-  registrar: Registrar
-  connectionManager: ConnectionManager
-  upgrader: Upgrader
-  addressManager: AddressManager
-}
-
-export class Circuit implements Transport, Startable {
-  private handler?: ConnectionHandler
-  private readonly components: CircuitComponents
-  private readonly _init: RelayConfig
-  private _started: boolean
-
-  constructor (components: CircuitComponents, init: RelayConfig) {
-    this._init = init
-    this.components = components
-    this._started = false
-  }
-
-  isStarted () {
-    return this._started
-  }
-
-  async start (): Promise<void> {
-    if (this._started) {
-      return
-    }
-
-    this._started = true
-
-    await this.components.registrar.handle(RELAY_CODEC, (data) => {
-      void this._onProtocol(data).catch(err => {
-        log.error(err)
-      })
-    }, { ...this._init })
-      .catch(err => {
-        log.error(err)
-      })
-  }
-
-  async stop () {
-    await this.components.registrar.unhandle(RELAY_CODEC)
-  }
-
-  hopEnabled () {
-    return true
-  }
-
-  hopActive () {
-    return true
-  }
-
-  get [symbol] (): true {
-    return true
-  }
-
-  get [Symbol.toStringTag] () {
-    return 'libp2p/circuit-relay-v1'
-  }
-
-  async _onProtocol (data: IncomingStreamData) {
-    const { connection, stream } = data
-    const controller = new TimeoutController(this._init.hop.timeout)
-
-    try {
-      // fails on node < 15.4
-      setMaxListeners?.(Infinity, controller.signal)
-    } catch {}
-
-    try {
-      const source = abortableDuplex(stream, controller.signal)
-      const streamHandler = new StreamHandler({
-        stream: {
-          ...stream,
-          ...source
-        }
-      })
-      const request = await streamHandler.read()
-
-      if (request == null) {
-        log('request was invalid, could not read from stream')
-        streamHandler.write({
-          type: CircuitPB.Type.STATUS,
-          code: CircuitPB.Status.MALFORMED_MESSAGE
-        })
-        streamHandler.close()
-        return
-      }
-
-      let virtualConnection: Duplex<Uint8ArrayList, Uint8ArrayList | Uint8Array> | undefined
-
-      switch (request.type) {
-        case CircuitPB.Type.CAN_HOP: {
-          log('received CAN_HOP request from %p', connection.remotePeer)
-          await handleCanHop({ circuit: this, connection, streamHandler })
-          break
-        }
-        case CircuitPB.Type.HOP: {
-          log('received HOP request from %p', connection.remotePeer)
-          await handleHop({
-            connection,
-            request,
-            streamHandler,
-            circuit: this,
-            connectionManager: this.components.connectionManager
-          })
-          break
-        }
-        case CircuitPB.Type.STOP: {
-          log('received STOP request from %p', connection.remotePeer)
-          virtualConnection = await handleStop({
-            connection,
-            request,
-            streamHandler
-          })
-          break
-        }
-        default: {
-          log('Request of type %s not supported', request.type)
-          streamHandler.write({
-            type: CircuitPB.Type.STATUS,
-            code: CircuitPB.Status.MALFORMED_MESSAGE
-          })
-          streamHandler.close()
-          return
-        }
-      }
-
-      if (virtualConnection != null) {
-        const remoteAddr = connection.remoteAddr
-          .encapsulate('/p2p-circuit')
-          .encapsulate(multiaddr(request.dstPeer?.addrs[0]))
-        const localAddr = multiaddr(request.srcPeer?.addrs[0])
-        const maConn = streamToMaConnection({
-          stream: virtualConnection,
-          remoteAddr,
-          localAddr
-        })
-        const type = request.type === CircuitPB.Type.HOP ? 'relay' : 'inbound'
-        log('new %s connection %s', type, maConn.remoteAddr)
-
-        const conn = await this.components.upgrader.upgradeInbound(maConn)
-        log('%s connection %s upgraded', type, maConn.remoteAddr)
-
-        if (this.handler != null) {
-          this.handler(conn)
-        }
-      }
-    } finally {
-      controller.clear()
-    }
-  }
-
-  /**
-   * Dial a peer over a relay
-   */
-  async dial (ma: Multiaddr, options: AbortOptions = {}): Promise<Connection> {
-    // Check the multiaddr to see if it contains a relay and a destination peer
-    const addrs = ma.toString().split('/p2p-circuit')
-    const relayAddr = multiaddr(addrs[0])
-    const destinationAddr = multiaddr(addrs[addrs.length - 1])
-    const relayId = relayAddr.getPeerId()
-    const destinationId = destinationAddr.getPeerId()
-
-    if (relayId == null || destinationId == null) {
-      const errMsg = 'Circuit relay dial failed as addresses did not have peer id'
-      log.error(errMsg)
-      throw errCode(new Error(errMsg), codes.ERR_RELAYED_DIAL)
-    }
-
-    const relayPeer = peerIdFromString(relayId)
-    const destinationPeer = peerIdFromString(destinationId)
-
-    let disconnectOnFailure = false
-    const relayConnections = this.components.connectionManager.getConnections(relayPeer)
-    let relayConnection = relayConnections[0]
-
-    if (relayConnection == null) {
-      await this.components.peerStore.addressBook.add(relayPeer, [relayAddr])
-      relayConnection = await this.components.connectionManager.openConnection(relayPeer, options)
-      disconnectOnFailure = true
-    }
-
-    try {
-      const virtualConnection = await hop({
-        ...options,
-        connection: relayConnection,
-        request: {
-          type: CircuitPB.Type.HOP,
-          srcPeer: {
-            id: this.components.peerId.toBytes(),
-            addrs: this.components.addressManager.getAddresses().map(addr => addr.bytes)
-          },
-          dstPeer: {
-            id: destinationPeer.toBytes(),
-            addrs: [multiaddr(destinationAddr).bytes]
-          }
-        }
-      })
-
-      const localAddr = relayAddr.encapsulate(`/p2p-circuit/p2p/${this.components.peerId.toString()}`)
-      const maConn = streamToMaConnection({
-        stream: virtualConnection,
-        remoteAddr: ma,
-        localAddr
-      })
-      log('new outbound connection %s', maConn.remoteAddr)
-
-      return await this.components.upgrader.upgradeOutbound(maConn)
-    } catch (err: any) {
-      log.error('Circuit relay dial failed', err)
-      disconnectOnFailure && await relayConnection.close()
-      throw err
-    }
-  }
-
-  /**
-   * Create a listener
-   */
-  createListener (options: CreateListenerOptions): Listener {
-    // Called on successful HOP and STOP requests
-    this.handler = options.handler
-
-    return createListener({
-      connectionManager: this.components.connectionManager,
-      peerStore: this.components.peerStore
-    })
-  }
-
-  /**
-   * Filter check for all Multiaddrs that this transport can dial on
-   *
-   * @param {Multiaddr[]} multiaddrs
-   * @returns {Multiaddr[]}
-   */
-  filter (multiaddrs: Multiaddr[]): Multiaddr[] {
-    multiaddrs = Array.isArray(multiaddrs) ? multiaddrs : [multiaddrs]
-
-    return multiaddrs.filter((ma) => {
-      return mafmt.Circuit.matches(ma)
-    })
-  }
-}

package/src/keychain/README.md

@@ -1,55 +0,0 @@
-# js-libp2p-keychain
-
-> A secure key chain for libp2p in JavaScript
-
-## Features
-
-- Manages the lifecycle of a key
-- Keys are encrypted at rest
-- Enforces the use of safe key names
-- Uses encrypted PKCS 8 for key storage
-- Uses PBKDF2 for a "stetched" key encryption key
-- Enforces NIST SP 800-131A and NIST SP 800-132
-- Uses PKCS 7: CMS (aka RFC 5652) to provide cryptographically protected messages
-- Delays reporting errors to slow down brute force attacks
-
-### KeyInfo
-
-The key management and naming service API all return a `KeyInfo` object.  The `id` is a universally unique identifier for the key.  The `name` is local to the key chain.
-
-```js
-{
-  name: 'rsa-key',
-  id: 'QmYWYSUZ4PV6MRFYpdtEDJBiGs4UrmE6g8wmAWSePekXVW'
-}
-```
-
-The **key id** is the SHA-256 [multihash](https://github.com/multiformats/multihash) of its public key. The *public key* is a [protobuf encoding](https://github.com/libp2p/js-libp2p-crypto/blob/master/src/keys/keys.proto.js) containing a type and the [DER encoding](https://en.wikipedia.org/wiki/X.690) of the PKCS [SubjectPublicKeyInfo](https://www.ietf.org/rfc/rfc3279.txt).
-
-### Private key storage
-
-A private key is stored as an encrypted PKCS 8 structure in the PEM format. It is protected by a key generated from the key chain's *passPhrase* using **PBKDF2**.
-
-The default options for generating the derived encryption key are in the `dek` object.  This, along with the passPhrase, is the input to a `PBKDF2` function.
-
-```js
-const defaultOptions = {
-  //See https://cryptosense.com/parameter-choice-for-pbkdf2/
-  dek: {
-    keyLength: 512 / 8,
-    iterationCount: 1000,
-    salt: 'at least 16 characters long',
-    hash: 'sha2-512'
-  }
-}
-```
-
-![key storage](./doc/private-key.png?raw=true)
-
-### Physical storage
-
-The actual physical storage of an encrypted key is left to implementations of [interface-datastore](https://github.com/ipfs/interface-datastore/).  A key benifit is that now the key chain can be used in browser with the [js-datastore-level](https://github.com/ipfs/js-datastore-level) implementation.
-
-### Cryptographic Message Syntax (CMS)
-
-CMS, aka [PKCS #7](https://en.wikipedia.org/wiki/PKCS) and [RFC 5652](https://tools.ietf.org/html/rfc5652), describes an encapsulation syntax for data protection. It is used to digitally sign, digest, authenticate, or encrypt arbitrary message content. Basically, `cms.encrypt` creates a DER message that can be only be read by someone holding the private key.

package/src/keychain/cms.ts

@@ -1,150 +0,0 @@
-import 'node-forge/lib/pkcs7.js'
-import 'node-forge/lib/pbe.js'
-// @ts-expect-error types are missing
-import forge from 'node-forge/lib/forge.js'
-import { certificateForKey, findAsync } from './util.js'
-import errCode from 'err-code'
-import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
-import { codes } from '../errors.js'
-import { logger } from '@libp2p/logger'
-import type { KeyChain } from './index.js'
-
-const log = logger('libp2p:keychain:cms')
-
-const privates = new WeakMap<object, { dek: string }>()
-
-/**
- * Cryptographic Message Syntax (aka PKCS #7)
- *
- * CMS describes an encapsulation syntax for data protection. It
- * is used to digitally sign, digest, authenticate, or encrypt
- * arbitrary message content.
- *
- * See RFC 5652 for all the details.
- */
-export class CMS {
-  private readonly keychain: KeyChain
-
-  /**
-   * Creates a new instance with a keychain
-   */
-  constructor (keychain: KeyChain, dek: string) {
-    if (keychain == null) {
-      throw errCode(new Error('keychain is required'), codes.ERR_KEYCHAIN_REQUIRED)
-    }
-
-    this.keychain = keychain
-    privates.set(this, { dek })
-  }
-
-  /**
-   * Creates some protected data.
-   *
-   * The output Uint8Array contains the PKCS #7 message in DER.
-   */
-  async encrypt (name: string, plain: Uint8Array): Promise<Uint8Array> {
-    if (!(plain instanceof Uint8Array)) {
-      throw errCode(new Error('Plain data must be a Uint8Array'), codes.ERR_INVALID_PARAMETERS)
-    }
-
-    const key = await this.keychain.findKeyByName(name)
-    const pem = await this.keychain.getPrivateKey(name)
-    const cached = privates.get(this)
-
-    if (cached == null) {
-      throw errCode(new Error('dek missing'), codes.ERR_INVALID_PARAMETERS)
-    }
-
-    const dek = cached.dek
-    const privateKey = forge.pki.decryptRsaPrivateKey(pem, dek)
-    const certificate = await certificateForKey(key, privateKey)
-
-    // create a p7 enveloped message
-    const p7 = forge.pkcs7.createEnvelopedData()
-    p7.addRecipient(certificate)
-    p7.content = forge.util.createBuffer(plain)
-    p7.encrypt()
-
-    // convert message to DER
-    const der = forge.asn1.toDer(p7.toAsn1()).getBytes()
-    return uint8ArrayFromString(der, 'ascii')
-  }
-
-  /**
-   * Reads some protected data.
-   *
-   * The keychain must contain one of the keys used to encrypt the data.  If none of the keys
-   * exists, an Error is returned with the property 'missingKeys'.  It is array of key ids.
-   */
-  async decrypt (cmsData: Uint8Array): Promise<Uint8Array> {
-    if (!(cmsData instanceof Uint8Array)) {
-      throw errCode(new Error('CMS data is required'), codes.ERR_INVALID_PARAMETERS)
-    }
-
-    let cms: any
-    try {
-      const buf = forge.util.createBuffer(uint8ArrayToString(cmsData, 'ascii'))
-      const obj = forge.asn1.fromDer(buf)
-
-      cms = forge.pkcs7.messageFromAsn1(obj)
-    } catch (err: any) {
-      log.error(err)
-      throw errCode(new Error('Invalid CMS'), codes.ERR_INVALID_CMS)
-    }
-
-    // Find a recipient whose key we hold. We only deal with recipient certs
-    // issued by ipfs (O=ipfs).
-    const recipients: any = cms.recipients
-      // @ts-expect-error cms types not defined
-      .filter(r => r.issuer.find(a => a.shortName === 'O' && a.value === 'ipfs'))
-      // @ts-expect-error cms types not defined
-      .filter(r => r.issuer.find(a => a.shortName === 'CN'))
-      // @ts-expect-error cms types not defined
-      .map(r => {
-        return {
-          recipient: r,
-          // @ts-expect-error cms types not defined
-          keyId: r.issuer.find(a => a.shortName === 'CN').value
-        }
-      })
-
-    const r = await findAsync(recipients, async (recipient: any) => {
-      try {
-        const key = await this.keychain.findKeyById(recipient.keyId)
-        if (key != null) {
-          return true
-        }
-      } catch (err: any) {
-        return false
-      }
-      return false
-    })
-
-    if (r == null) {
-      // @ts-expect-error cms types not defined
-      const missingKeys: string[] = recipients.map(r => r.keyId)
-      throw errCode(new Error(`Decryption needs one of the key(s): ${missingKeys.join(', ')}`), codes.ERR_MISSING_KEYS, {
-        missingKeys
-      })
-    }
-
-    const key = await this.keychain.findKeyById(r.keyId)
-
-    if (key == null) {
-      throw errCode(new Error('No key available to decrypto'), codes.ERR_NO_KEY)
-    }
-
-    const pem = await this.keychain.getPrivateKey(key.name)
-    const cached = privates.get(this)
-
-    if (cached == null) {
-      throw errCode(new Error('dek missing'), codes.ERR_INVALID_PARAMETERS)
-    }
-
-    const dek = cached.dek
-    const privateKey = forge.pki.decryptRsaPrivateKey(pem, dek)
-    cms.decrypt(r.recipient, privateKey)
-    return uint8ArrayFromString(cms.content.getBytes(), 'ascii')
-  }
-}

package/src/keychain/doc/private-key.xml

@@ -1 +0,0 @@
-<mxfile userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.94 Safari/537.36" version="7.8.2" editor="www.draw.io"><diagram id="a8b2919f-aefc-d24c-c550-ea0bf34e92af" name="Page-1">7VlNb6MwEP01HLfCGBJ6bNJ2V9pdqVIP2x4dcMAKYGScJumvXxNsvkw+SmgSVe2hMs9mbL839swQA07j9U+G0vAv9XFkWKa/NuC9YVmua4n/ObApAOjCAggY8QsIVMAzeccSNCW6JD7OGgM5pREnaRP0aJJgjzcwxBhdNYfNadScNUUB1oBnD0U6+o/4PJTbssYV/guTIFQzg9Ft0TND3iJgdJnI+QwLzrd/RXeMlC250SxEPl3VIPhgwCmjlBeteD3FUU6toq1473FHb7luhhN+zAtSpzcULeXWU5RluYmQoQzLRfKNIobjtbA7CXkcCQCIZsYZXeApjSgTSEITMXIyJ1HUglBEgkQ8emJlWOCTN8w4EZTfyY6Y+H4+zWQVEo6fU+Tlc66EfwlsSynOF22KJ7loYQCvd24clHQKL8U0xpxtxBDlolIA6aBgJJ9Xldy2hMKa0ko3JB0sKA1XJIuG5Lmbc6hx/jT5ff9oaWQL50jzZsqoh4Uq3dTUtBiAF9AmxtaJAVYHM6MBmLE1Zny8EABNOaFJ9nW9sfQryfr4fN7oaJxrNOPEv8sv1ZyvSFwPxGuSLjbJNi85GzcmGCvgdQvAUQk8YUbE8nK6a7xhX7uKD7JWo8XpoEVhDEeIk7em+S6u5AxPlIiJq6PQEgWMraaJjC6Zh+Vb9Uu2bUiFw12GOGIB5pqhrXTlto9SczSomk5Dyw9IJsL1dku1C+9SKpYHR5Fvmj1VhE1D2ukbTkX3WlQsuGmErbqw4KLnE5oHBDlWWbt10K22i+xQVgiANrVhaT4g271g22xfKI3kTDQKi33d5rY7fB4Mmgxn5B3NtgNy/5D7EKOdieHcfyhcRmiGo0mZBauwW+XBe+KlzOblSoxSz7pjunvj6A8RgcpaY9Mw3tfZ1BA6n2f41IOt6puaRAucrz/AiSbUNaR/Fjxj+geAxk668PJqRLiPexX8QPuS/OjVmo84yjhleqV2CXac9o18Vnb06uEm3e01PvWW8XZfh4iZFdn+n9mQTLWSCQhcjanRntB5ElF6yl9cQl++zGpfbo7unp9VZgE9M2dJoFFdbRmc5cRarRMLLd0P3S5KnAEoGWuUaHwcTHPXhL/U2q/NjPdF+k6tIHV6J8AqeF9PBtzyZxu2HLVvaQPdlqHhShswaG0zmLQdVWsRbb+lPV5avf44Qdpm2Vo/67JLnfb+oo86RDeNKxLdHkr0208TXcXGz/pW0S066C+61SG6/S36x0TXC7VTRP9SH43VLahyzHZpc/xHY7DfUG85xWP1A2MxvPoRFz78Bw==</diagram></mxfile>