chore: move keychain to libp2p

src/keychain/README.md

@@ -0,0 +1,117 @@
+# js-libp2p-keychain
+
+[![](https://img.shields.io/badge/made%20by-Protocol%20Labs-blue.svg?style=flat-square)](http://protocol.ai)
+[![](https://img.shields.io/badge/project-libp2p-yellow.svg?style=flat-square)](http://libp2p.io/)
+[![](https://img.shields.io/badge/freenode-%23libp2p-yellow.svg?style=flat-square)](http://webchat.freenode.net/?channels=%23libp2p)
+[![Discourse posts](https://img.shields.io/discourse/https/discuss.libp2p.io/posts.svg)](https://discuss.libp2p.io)
+[![](https://img.shields.io/codecov/c/github/libp2p/js-libp2p-keychain.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-keychain)
+[![](https://img.shields.io/travis/libp2p/js-libp2p-keychain.svg?style=flat-square)](https://travis-ci.com/libp2p/js-libp2p-keychain)
+[![Dependency Status](https://david-dm.org/libp2p/js-libp2p-keychain.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-keychain)
+[![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat-square)](https://github.com/feross/standard)
+
+> A secure key chain for libp2p in JavaScript
+
+## Lead Maintainer
+
+[Vasco Santos](https://github.com/vasco-santos).
+
+## 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
+
+## Table of Contents
+
+### Usage
+
+```js
+const Keychain = require('libp2p-keychain')
+const FsStore = require('datastore-fs')
+
+const datastore = new FsStore('./a-keystore')
+const opts = {
+  passPhrase: 'some long easily remembered phrase'
+}
+const keychain = new Keychain(datastore, opts)
+```
+
+## API
+
+Managing a key
+
+- `async createKey (name, type, size)`
+- `async renameKey (oldName, newName)`
+- `async removeKey (name)`
+- `async exportKey (name, password)`
+- `async importKey (name, pem, password)`
+- `async importPeer (name, peer)`
+
+A naming service for a key
+
+- `async listKeys ()`
+- `async findKeyById (id)`
+- `async findKeyByName (name)`
+
+Cryptographically protected messages
+
+- `async cms.encrypt (name, plain)`
+- `async cms.decrypt (cmsData)`
+
+### 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.
+
+## Contribute
+
+Feel free to join in. All welcome. Open an [issue](https://github.com/libp2p/js-libp2p-keychain/issues)!
+
+This repository falls under the IPFS [Code of Conduct](https://github.com/ipfs/community/blob/master/code-of-conduct.md).
+
+[![](https://cdn.rawgit.com/jbenet/contribute-ipfs-gif/master/img/contribute.gif)](https://github.com/ipfs/community/blob/master/CONTRIBUTING.md)
+
+## License
+
+[MIT](LICENSE)

src/keychain/cms.js

@@ -0,0 +1,122 @@
+'use strict'
+
+require('node-forge/lib/pkcs7')
+require('node-forge/lib/pbe')
+const forge = require('node-forge/lib/forge')
+const { certificateForKey, findAsync } = require('./util')
+const errcode = require('err-code')
+
+/**
+ * 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.
+ */
+class CMS {
+  /**
+   * Creates a new instance with a keychain
+   *
+   * @param {Keychain} keychain - the available keys
+   */
+  constructor (keychain) {
+    if (!keychain) {
+      throw errcode(new Error('keychain is required'), 'ERR_KEYCHAIN_REQUIRED')
+    }
+
+    this.keychain = keychain
+  }
+
+  /**
+   * Creates some protected data.
+   *
+   * The output Buffer contains the PKCS #7 message in DER.
+   *
+   * @param {string} name - The local key name.
+   * @param {Buffer} plain - The data to encrypt.
+   * @returns {undefined}
+   */
+  async encrypt (name, plain) {
+    if (!Buffer.isBuffer(plain)) {
+      throw errcode(new Error('Plain data must be a Buffer'), 'ERR_INVALID_PARAMS')
+    }
+
+    const key = await this.keychain.findKeyByName(name)
+    const pem = await this.keychain._getPrivateKey(name)
+    const privateKey = forge.pki.decryptRsaPrivateKey(pem, this.keychain._())
+    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 Buffer.from(der, 'binary')
+  }
+
+  /**
+   * 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.
+   *
+   * @param {Buffer} cmsData - The CMS encrypted data to decrypt.
+   * @returns {undefined}
+   */
+  async decrypt (cmsData) {
+    if (!Buffer.isBuffer(cmsData)) {
+      throw errcode(new Error('CMS data is required'), 'ERR_INVALID_PARAMS')
+    }
+
+    let cms
+    try {
+      const buf = forge.util.createBuffer(cmsData.toString('binary'))
+      const obj = forge.asn1.fromDer(buf)
+      cms = forge.pkcs7.messageFromAsn1(obj)
+    } catch (err) {
+      throw errcode(new Error('Invalid CMS: ' + err.message), 'ERR_INVALID_CMS')
+    }
+
+    // Find a recipient whose key we hold. We only deal with recipient certs
+    // issued by ipfs (O=ipfs).
+    const recipients = cms.recipients
+      .filter(r => r.issuer.find(a => a.shortName === 'O' && a.value === 'ipfs'))
+      .filter(r => r.issuer.find(a => a.shortName === 'CN'))
+      .map(r => {
+        return {
+          recipient: r,
+          keyId: r.issuer.find(a => a.shortName === 'CN').value
+        }
+      })
+
+    const r = await findAsync(recipients, async (recipient) => {
+      try {
+        const key = await this.keychain.findKeyById(recipient.keyId)
+        if (key) return true
+      } catch (err) {
+        return false
+      }
+      return false
+    })
+
+    if (!r) {
+      const missingKeys = recipients.map(r => r.keyId)
+      throw errcode(new Error('Decryption needs one of the key(s): ' + missingKeys.join(', ')), 'ERR_MISSING_KEYS', {
+        missingKeys
+      })
+    }
+
+    const key = await this.keychain.findKeyById(r.keyId)
+    const pem = await this.keychain._getPrivateKey(key.name)
+    const privateKey = forge.pki.decryptRsaPrivateKey(pem, this.keychain._())
+    cms.decrypt(r.recipient, privateKey)
+    return Buffer.from(cms.content.getBytes(), 'binary')
+  }
+}
+
+module.exports = CMS

src/keychain/doc/private-key.xml

@@ -0,0 +1 @@
+<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>

src/keychain/index.js

@@ -0,0 +1,3 @@
+'use strict'
+
+module.exports = require('./keychain')

src/keychain/keychain.js

@@ -0,0 +1,469 @@
+/* eslint max-nested-callbacks: ["error", 5] */
+'use strict'
+
+const sanitize = require('sanitize-filename')
+const mergeOptions = require('merge-options')
+const crypto = require('libp2p-crypto')
+const DS = require('interface-datastore')
+const CMS = require('./cms')
+const errcode = require('err-code')
+
+const keyPrefix = '/pkcs8/'
+const infoPrefix = '/info/'
+
+// NIST SP 800-132
+const NIST = {
+  minKeyLength: 112 / 8,
+  minSaltLength: 128 / 8,
+  minIterationCount: 1000
+}
+
+const defaultOptions = {
+  // See https://cryptosense.com/parametesr-choice-for-pbkdf2/
+  dek: {
+    keyLength: 512 / 8,
+    iterationCount: 10000,
+    salt: 'you should override this value with a crypto secure random number',
+    hash: 'sha2-512'
+  }
+}
+
+function validateKeyName (name) {
+  if (!name) return false
+  if (typeof name !== 'string') return false
+  return name === sanitize(name.trim())
+}
+
+/**
+ * Throws an error after a delay
+ *
+ * This assumes than an error indicates that the keychain is under attack. Delay returning an
+ * error to make brute force attacks harder.
+ *
+ * @param {string | Error} err - The error
+ * @private
+ */
+async function throwDelayed (err) {
+  const min = 200
+  const max = 1000
+  const delay = Math.random() * (max - min) + min
+
+  await new Promise(resolve => setTimeout(resolve, delay))
+  throw err
+}
+
+/**
+ * Converts a key name into a datastore name.
+ *
+ * @param {string} name
+ * @returns {DS.Key}
+ * @private
+ */
+function DsName (name) {
+  return new DS.Key(keyPrefix + name)
+}
+
+/**
+ * Converts a key name into a datastore info name.
+ *
+ * @param {string} name
+ * @returns {DS.Key}
+ * @private
+ */
+function DsInfoName (name) {
+  return new DS.Key(infoPrefix + name)
+}
+
+/**
+ * Information about a key.
+ *
+ * @typedef {Object} KeyInfo
+ *
+ * @property {string} id - The universally unique key id.
+ * @property {string} name - The local key name.
+ */
+
+/**
+ * Manages the lifecycle of a key. Keys are encrypted at rest using PKCS #8.
+ *
+ * A key in the store has two entries
+ * - '/info/*key-name*', contains the KeyInfo for the key
+ * - '/pkcs8/*key-name*', contains the PKCS #8 for the key
+ *
+ */
+class Keychain {
+  /**
+   * Creates a new instance of a key chain.
+   *
+   * @param {DS} store - where the key are.
+   * @param {object} options - ???
+   */
+  constructor (store, options) {
+    if (!store) {
+      throw new Error('store is required')
+    }
+    this.store = store
+
+    const opts = mergeOptions(defaultOptions, options)
+
+    // Enforce NIST SP 800-132
+    if (!opts.passPhrase || opts.passPhrase.length < 20) {
+      throw new Error('passPhrase must be least 20 characters')
+    }
+    if (opts.dek.keyLength < NIST.minKeyLength) {
+      throw new Error(`dek.keyLength must be least ${NIST.minKeyLength} bytes`)
+    }
+    if (opts.dek.salt.length < NIST.minSaltLength) {
+      throw new Error(`dek.saltLength must be least ${NIST.minSaltLength} bytes`)
+    }
+    if (opts.dek.iterationCount < NIST.minIterationCount) {
+      throw new Error(`dek.iterationCount must be least ${NIST.minIterationCount}`)
+    }
+
+    // Create the derived encrypting key
+    const dek = crypto.pbkdf2(
+      opts.passPhrase,
+      opts.dek.salt,
+      opts.dek.iterationCount,
+      opts.dek.keyLength,
+      opts.dek.hash)
+    Object.defineProperty(this, '_', { value: () => dek })
+  }
+
+  /**
+   * Gets an object that can encrypt/decrypt protected data
+   * using the Cryptographic Message Syntax (CMS).
+   *
+   * CMS describes an encapsulation syntax for data protection. It
+   * is used to digitally sign, digest, authenticate, or encrypt
+   * arbitrary message content.
+   *
+   * @returns {CMS}
+   */
+  get cms () {
+    return new CMS(this)
+  }
+
+  /**
+   * Generates the options for a keychain.  A random salt is produced.
+   *
+   * @returns {object}
+   */
+  static generateOptions () {
+    const options = Object.assign({}, defaultOptions)
+    const saltLength = Math.ceil(NIST.minSaltLength / 3) * 3 // no base64 padding
+    options.dek.salt = crypto.randomBytes(saltLength).toString('base64')
+    return options
+  }
+
+  /**
+   * Gets an object that can encrypt/decrypt protected data.
+   * The default options for a keychain.
+   *
+   * @returns {object}
+   */
+  static get options () {
+    return defaultOptions
+  }
+
+  /**
+   * Create a new key.
+   *
+   * @param {string} name - The local key name; cannot already exist.
+   * @param {string} type - One of the key types; 'rsa'.
+   * @param {int} size - The key size in bits.
+    * @returns {KeyInfo}
+   */
+  async createKey (name, type, size) {
+    const self = this
+
+    if (!validateKeyName(name) || name === 'self') {
+      return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), 'ERR_INVALID_KEY_NAME'))
+    }
+
+    if (typeof type !== 'string') {
+      return throwDelayed(errcode(new Error(`Invalid key type '${type}'`), 'ERR_INVALID_KEY_TYPE'))
+    }
+
+    if (!Number.isSafeInteger(size)) {
+      return throwDelayed(errcode(new Error(`Invalid key size '${size}'`), 'ERR_INVALID_KEY_SIZE'))
+    }
+
+    const dsname = DsName(name)
+    const exists = await self.store.has(dsname)
+    if (exists) return throwDelayed(errcode(new Error(`Key '${name}' already exists`), 'ERR_KEY_ALREADY_EXISTS'))
+
+    switch (type.toLowerCase()) {
+      case 'rsa':
+        if (size < 2048) {
+          return throwDelayed(errcode(new Error(`Invalid RSA key size ${size}`), 'ERR_INVALID_KEY_SIZE'))
+        }
+        break
+      default:
+        break
+    }
+
+    let keyInfo
+    try {
+      const keypair = await crypto.keys.generateKeyPair(type, size)
+      const kid = await keypair.id()
+      const pem = await keypair.export(this._())
+      keyInfo = {
+        name: name,
+        id: kid
+      }
+      const batch = self.store.batch()
+      batch.put(dsname, pem)
+      batch.put(DsInfoName(name), JSON.stringify(keyInfo))
+
+      await batch.commit()
+    } catch (err) {
+      return throwDelayed(err)
+    }
+
+    return keyInfo
+  }
+
+  /**
+   * List all the keys.
+   *
+    * @returns {KeyInfo[]}
+   */
+  async listKeys () {
+    const self = this
+    const query = {
+      prefix: infoPrefix
+    }
+
+    const info = []
+    for await (const value of self.store.query(query)) {
+      info.push(JSON.parse(value.value))
+    }
+
+    return info
+  }
+
+  /**
+   * Find a key by it's id.
+   *
+   * @param {string} id - The universally unique key identifier.
+    * @returns {KeyInfo}
+   */
+  async findKeyById (id) {
+    try {
+      const keys = await this.listKeys()
+      return keys.find((k) => k.id === id)
+    } catch (err) {
+      return throwDelayed(err)
+    }
+  }
+
+  /**
+   * Find a key by it's name.
+   *
+   * @param {string} name - The local key name.
+    * @returns {KeyInfo}
+   */
+  async findKeyByName (name) {
+    if (!validateKeyName(name)) {
+      return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), 'ERR_INVALID_KEY_NAME'))
+    }
+
+    const dsname = DsInfoName(name)
+    try {
+      const res = await this.store.get(dsname)
+      return JSON.parse(res.toString())
+    } catch (err) {
+      return throwDelayed(errcode(new Error(`Key '${name}' does not exist. ${err.message}`), 'ERR_KEY_NOT_FOUND'))
+    }
+  }
+
+  /**
+   * Remove an existing key.
+   *
+   * @param {string} name - The local key name; must already exist.
+    * @returns {KeyInfo}
+   */
+  async removeKey (name) {
+    const self = this
+    if (!validateKeyName(name) || name === 'self') {
+      return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), 'ERR_INVALID_KEY_NAME'))
+    }
+    const dsname = DsName(name)
+    const keyInfo = await self.findKeyByName(name)
+    const batch = self.store.batch()
+    batch.delete(dsname)
+    batch.delete(DsInfoName(name))
+    await batch.commit()
+    return keyInfo
+  }
+
+  /**
+   * Rename a key
+   *
+   * @param {string} oldName - The old local key name; must already exist.
+   * @param {string} newName - The new local key name; must not already exist.
+    * @returns {KeyInfo}
+   */
+  async renameKey (oldName, newName) {
+    const self = this
+    if (!validateKeyName(oldName) || oldName === 'self') {
+      return throwDelayed(errcode(new Error(`Invalid old key name '${oldName}'`), 'ERR_OLD_KEY_NAME_INVALID'))
+    }
+    if (!validateKeyName(newName) || newName === 'self') {
+      return throwDelayed(errcode(new Error(`Invalid new key name '${newName}'`), 'ERR_NEW_KEY_NAME_INVALID'))
+    }
+    const oldDsname = DsName(oldName)
+    const newDsname = DsName(newName)
+    const oldInfoName = DsInfoName(oldName)
+    const newInfoName = DsInfoName(newName)
+
+    const exists = await self.store.has(newDsname)
+    if (exists) return throwDelayed(errcode(new Error(`Key '${newName}' already exists`), 'ERR_KEY_ALREADY_EXISTS'))
+
+    try {
+      let res = await this.store.get(oldDsname)
+      const pem = res.toString()
+      res = await self.store.get(oldInfoName)
+
+      const keyInfo = JSON.parse(res.toString())
+      keyInfo.name = newName
+      const batch = self.store.batch()
+      batch.put(newDsname, pem)
+      batch.put(newInfoName, JSON.stringify(keyInfo))
+      batch.delete(oldDsname)
+      batch.delete(oldInfoName)
+      await batch.commit()
+      return keyInfo
+    } catch (err) {
+      return throwDelayed(err)
+    }
+  }
+
+  /**
+   * Export an existing key as a PEM encrypted PKCS #8 string
+   *
+   * @param {string} name - The local key name; must already exist.
+   * @param {string} password - The password
+    * @returns {string}
+   */
+  async exportKey (name, password) {
+    if (!validateKeyName(name)) {
+      return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), 'ERR_INVALID_KEY_NAME'))
+    }
+    if (!password) {
+      return throwDelayed(errcode(new Error('Password is required'), 'ERR_PASSWORD_REQUIRED'))
+    }
+
+    const dsname = DsName(name)
+    try {
+      const res = await this.store.get(dsname)
+      const pem = res.toString()
+      const privateKey = await crypto.keys.import(pem, this._())
+      return privateKey.export(password)
+    } catch (err) {
+      return throwDelayed(err)
+    }
+  }
+
+  /**
+   * Import a new key from a PEM encoded PKCS #8 string
+   *
+   * @param {string} name - The local key name; must not already exist.
+   * @param {string} pem - The PEM encoded PKCS #8 string
+   * @param {string} password - The password.
+    * @returns {KeyInfo}
+   */
+  async importKey (name, pem, password) {
+    const self = this
+    if (!validateKeyName(name) || name === 'self') {
+      return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), 'ERR_INVALID_KEY_NAME'))
+    }
+    if (!pem) {
+      return throwDelayed(errcode(new Error('PEM encoded key is required'), 'ERR_PEM_REQUIRED'))
+    }
+    const dsname = DsName(name)
+    const exists = await self.store.has(dsname)
+    if (exists) return throwDelayed(errcode(new Error(`Key '${name}' already exists`), 'ERR_KEY_ALREADY_EXISTS'))
+
+    let privateKey
+    try {
+      privateKey = await crypto.keys.import(pem, password)
+    } catch (err) {
+      return throwDelayed(errcode(new Error('Cannot read the key, most likely the password is wrong'), 'ERR_CANNOT_READ_KEY'))
+    }
+
+    let kid
+    try {
+      kid = await privateKey.id()
+      pem = await privateKey.export(this._())
+    } catch (err) {
+      return throwDelayed(err)
+    }
+
+    const keyInfo = {
+      name: name,
+      id: kid
+    }
+    const batch = self.store.batch()
+    batch.put(dsname, pem)
+    batch.put(DsInfoName(name), JSON.stringify(keyInfo))
+    await batch.commit()
+
+    return keyInfo
+  }
+
+  async importPeer (name, peer) {
+    const self = this
+    if (!validateKeyName(name)) {
+      return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), 'ERR_INVALID_KEY_NAME'))
+    }
+    if (!peer || !peer.privKey) {
+      return throwDelayed(errcode(new Error('Peer.privKey is required'), 'ERR_MISSING_PRIVATE_KEY'))
+    }
+
+    const privateKey = peer.privKey
+    const dsname = DsName(name)
+    const exists = await self.store.has(dsname)
+    if (exists) return throwDelayed(errcode(new Error(`Key '${name}' already exists`), 'ERR_KEY_ALREADY_EXISTS'))
+
+    try {
+      const kid = await privateKey.id()
+      const pem = await privateKey.export(this._())
+      const keyInfo = {
+        name: name,
+        id: kid
+      }
+      const batch = self.store.batch()
+      batch.put(dsname, pem)
+      batch.put(DsInfoName(name), JSON.stringify(keyInfo))
+      await batch.commit()
+      return keyInfo
+    } catch (err) {
+      return throwDelayed(err)
+    }
+  }
+
+  /**
+   * Gets the private key as PEM encoded PKCS #8 string.
+   *
+   * @param {string} name
+    * @returns {string}
+   * @private
+   */
+  async _getPrivateKey (name) {
+    if (!validateKeyName(name)) {
+      return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), 'ERR_INVALID_KEY_NAME'))
+    }
+
+    try {
+      const dsname = DsName(name)
+      const res = await this.store.get(dsname)
+      return res.toString()
+    } catch (err) {
+      return throwDelayed(errcode(new Error(`Key '${name}' does not exist. ${err.message}`), 'ERR_KEY_NOT_FOUND'))
+    }
+  }
+}
+
+module.exports = Keychain

src/keychain/util.js

@@ -0,0 +1,89 @@
+'use strict'
+
+require('node-forge/lib/x509')
+const forge = require('node-forge/lib/forge')
+const pki = forge.pki
+exports = module.exports
+
+/**
+ * Gets a self-signed X.509 certificate for the key.
+ *
+ * The output Buffer contains the PKCS #7 message in DER.
+ *
+ * TODO: move to libp2p-crypto package
+ *
+ * @param {KeyInfo} key - The id and name of the key
+ * @param {RsaPrivateKey} privateKey - The naked key
+ * @returns {undefined}
+ */
+exports.certificateForKey = (key, privateKey) => {
+  const publicKey = pki.setRsaPublicKey(privateKey.n, privateKey.e)
+  const cert = pki.createCertificate()
+  cert.publicKey = publicKey
+  cert.serialNumber = '01'
+  cert.validity.notBefore = new Date()
+  cert.validity.notAfter = new Date()
+  cert.validity.notAfter.setFullYear(cert.validity.notBefore.getFullYear() + 10)
+  const attrs = [{
+    name: 'organizationName',
+    value: 'ipfs'
+  }, {
+    shortName: 'OU',
+    value: 'keystore'
+  }, {
+    name: 'commonName',
+    value: key.id
+  }]
+  cert.setSubject(attrs)
+  cert.setIssuer(attrs)
+  cert.setExtensions([{
+    name: 'basicConstraints',
+    cA: true
+  }, {
+    name: 'keyUsage',
+    keyCertSign: true,
+    digitalSignature: true,
+    nonRepudiation: true,
+    keyEncipherment: true,
+    dataEncipherment: true
+  }, {
+    name: 'extKeyUsage',
+    serverAuth: true,
+    clientAuth: true,
+    codeSigning: true,
+    emailProtection: true,
+    timeStamping: true
+  }, {
+    name: 'nsCertType',
+    client: true,
+    server: true,
+    email: true,
+    objsign: true,
+    sslCA: true,
+    emailCA: true,
+    objCA: true
+  }])
+  // self-sign certificate
+  cert.sign(privateKey)
+
+  return cert
+}
+
+/**
+ * Finds the first item in a collection that is matched in the
+ * `asyncCompare` function.
+ *
+ * `asyncCompare` is an async function that must
+ * resolve to either `true` or `false`.
+ *
+ * @param {Array} array
+ * @param {function(*)} asyncCompare An async function that returns a boolean
+ */
+async function findAsync (array, asyncCompare) {
+  const promises = array.map(asyncCompare)
+  const results = await Promise.all(promises)
+  const index = results.findIndex(result => result)
+  return array[index]
+}
+
+module.exports.findAsync = findAsync