chore: release version v0.17.0

fix(deps): update to ursa-optiona@0.10

.eslintignore

@@ -0,0 +1 @@
+src/keys/keys.proto.js

.gitignore

@@ -1,6 +1,11 @@
+docs
+package-lock.json
+yarn.lock
+
 **/node_modules/
 **/*.log
 test/repo-tests*
+**/bundle.js
 
 # Logs
 logs
@@ -31,4 +36,12 @@ build
 # https://www.npmjs.org/doc/misc/npm-faq.html#should-i-check-my-node_modules-folder-into-git
 node_modules
 
+lib
 dist
+test/test-data/go-ipfs-repo/LOCK
+test/test-data/go-ipfs-repo/LOG
+test/test-data/go-ipfs-repo/LOG.old
+
+# while testing npm5
+package-lock.json
+yarn.lock

.npmignore

@@ -1,34 +0,0 @@
-**/node_modules/
-**/*.log
-test/repo-tests*
-
-# Logs
-logs
-*.log
-
-coverage
-
-# Runtime data
-pids
-*.pid
-*.seed
-
-# Directory for instrumented libs generated by jscoverage/JSCover
-lib-cov
-
-# Coverage directory used by tools like istanbul
-coverage
-
-# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
-.grunt
-
-# node-waf configuration
-.lock-wscript
-
-build
-
-# Dependency directory
-# https://www.npmjs.org/doc/misc/npm-faq.html#should-i-check-my-node_modules-folder-into-git
-node_modules
-
-test

.travis.yml

@@ -1,38 +1,45 @@
-sudo: false
 language: node_js
 
-matrix:
+cache: npm
+
+stages:
+  - check
+  - test
+  - cov
+
+node_js:
+  - '10'
+  - '12'
+
+os:
+  - linux
+  - osx
+  - windows
+
+script: npx nyc -s npm run test:node -- --bail
+after_success: npx nyc report --reporter=text-lcov > coverage.lcov && npx codecov
+
+jobs:
   include:
-  - node_js: 4
-    env: CXX=g++-4.8
-  - node_js: 6
-    env:
-      - SAUCE=true
-      - CXX=g++-4.8
-  - node_js: stable
-    env: CXX=g++-4.8
+    - stage: check
+      script:
+        - npx aegir commitlint --travis
+        - npx aegir dep-check
+        - npm run lint
 
-# Make sure we have new NPM.
-before_install:
-  - npm install -g npm
+    - stage: test
+      name: chrome
+      addons:
+        chrome: stable
+      script:
+        - npx aegir test -t browser
 
-script:
-  - npm run lint
-  - npm test
-  - npm run coverage
+    - stage: test
+      name: firefox
+      addons:
+        firefox: latest
+      script:
+        - npx aegir test -t browser -- --browsers FirefoxHeadless
 
-
-before_script:
-  - export DISPLAY=:99.0
-  - sh -e /etc/init.d/xvfb start
-
-after_success:
-  - npm run coverage-publish
-
-addons:
-  firefox: 'latest'
-  apt:
-    sources:
-      - ubuntu-toolchain-r-test
-    packages:
-      - g++-4.8
+notifications:
+  email: false

CHANGELOG.md

@@ -0,0 +1,234 @@
+<a name="0.17.0"></a>
+# [0.17.0](https://github.com/libp2p/js-libp2p-crypto/compare/v0.16.1...v0.17.0) (2019-07-11)
+
+
+### Bug Fixes
+
+* **deps:** update to ursa-optiona@0.10 ([26b6217](https://github.com/libp2p/js-libp2p-crypto/commit/26b6217))
+* fix links in README ([#148](https://github.com/libp2p/js-libp2p-crypto/issues/148)) ([5cd0e8c](https://github.com/libp2p/js-libp2p-crypto/commit/5cd0e8c))
+* put optional args last for key export ([#154](https://github.com/libp2p/js-libp2p-crypto/issues/154)) ([d675670](https://github.com/libp2p/js-libp2p-crypto/commit/d675670))
+
+
+### Features
+
+* refactor to use async/await ([#131](https://github.com/libp2p/js-libp2p-crypto/issues/131)) ([ad71072](https://github.com/libp2p/js-libp2p-crypto/commit/ad71072))
+
+
+### BREAKING CHANGES
+
+* key export arguments are now swapped so that the optional format is last
+* API refactored to use async/await
+
+feat: WIP use async await
+fix: passing tests
+chore: update travis node.js versions
+fix: skip ursa optional tests on windows
+fix: benchmarks
+docs: update docs
+fix: remove broken and intested private key decrypt
+chore: update deps
+
+
+
+<a name="0.16.1"></a>
+## [0.16.1](https://github.com/libp2p/js-libp2p-crypto/compare/v0.16.0...v0.16.1) (2019-02-26)
+
+
+
+<a name="0.16.0"></a>
+# [0.16.0](https://github.com/libp2p/js-libp2p-crypto/compare/v0.15.0...v0.16.0) (2019-01-08)
+
+
+### Bug Fixes
+
+* clean up, bundle size reduction ([8d8294d](https://github.com/libp2p/js-libp2p-crypto/commit/8d8294d))
+
+
+### BREAKING CHANGES
+
+* getRandomValues method exported from src/keys/rsa-browser.js and src/keys/rsa.js signature has changed from accepting an array to a number for random byte length 
+
+
+
+<a name="0.15.0"></a>
+# [0.15.0](https://github.com/libp2p/js-libp2p-crypto/compare/v0.14.1...v0.15.0) (2019-01-03)
+
+
+### Features
+
+* nextTick instead of setImmediate, and fix sync in async ([#136](https://github.com/libp2p/js-libp2p-crypto/issues/136)) ([c54ea20](https://github.com/libp2p/js-libp2p-crypto/commit/c54ea20))
+
+
+
+<a name="0.14.1"></a>
+## [0.14.1](https://github.com/libp2p/js-libp2p-crypto/compare/v0.14.0...v0.14.1) (2018-11-05)
+
+
+### Bug Fixes
+
+* dont setimmediate when its not needed ([9e57786](https://github.com/libp2p/js-libp2p-crypto/commit/9e57786))
+
+
+
+<a name="0.14.0"></a>
+# [0.14.0](https://github.com/libp2p/js-libp2p-crypto/compare/v0.13.0...v0.14.0) (2018-09-17)
+
+
+### Bug Fixes
+
+* windows build ([c7e0409](https://github.com/libp2p/js-libp2p-crypto/commit/c7e0409))
+* **lint:** use ~ for ursa-optional version ([e8cbf13](https://github.com/libp2p/js-libp2p-crypto/commit/e8cbf13))
+
+
+### Features
+
+* use ursa-optional for lightning fast key generation ([b05e77f](https://github.com/libp2p/js-libp2p-crypto/commit/b05e77f))
+
+
+
+<a name="0.13.0"></a>
+# [0.13.0](https://github.com/libp2p/js-libp2p-crypto/compare/v0.12.1...v0.13.0) (2018-04-05)
+
+
+
+<a name="0.12.1"></a>
+## [0.12.1](https://github.com/libp2p/js-libp2p-crypto/compare/v0.12.0...v0.12.1) (2018-02-12)
+
+
+
+<a name="0.12.0"></a>
+# [0.12.0](https://github.com/libp2p/js-libp2p-crypto/compare/v0.11.0...v0.12.0) (2018-01-27)
+
+
+### Features
+
+* improve perf ([#117](https://github.com/libp2p/js-libp2p-crypto/issues/117)) ([cdcca5f](https://github.com/libp2p/js-libp2p-crypto/commit/cdcca5f))
+
+
+
+<a name="0.11.0"></a>
+# [0.11.0](https://github.com/libp2p/js-libp2p-crypto/compare/v0.10.4...v0.11.0) (2017-12-20)
+
+
+### Features
+
+* key exchange with jsrsasign ([#115](https://github.com/libp2p/js-libp2p-crypto/issues/115)) ([b342128](https://github.com/libp2p/js-libp2p-crypto/commit/b342128))
+
+
+
+<a name="0.10.4"></a>
+## [0.10.4](https://github.com/libp2p/js-libp2p-crypto/compare/v0.10.3...v0.10.4) (2017-12-01)
+
+
+### Bug Fixes
+
+* catch error when unmarshaling instead of crashing ([#113](https://github.com/libp2p/js-libp2p-crypto/issues/113)) ([7608fdd](https://github.com/libp2p/js-libp2p-crypto/commit/7608fdd))
+
+
+
+<a name="0.10.3"></a>
+## [0.10.3](https://github.com/libp2p/js-libp2p-crypto/compare/v0.10.2...v0.10.3) (2017-09-07)
+
+
+### Features
+
+* switch protocol-buffers to protons ([#110](https://github.com/libp2p/js-libp2p-crypto/issues/110)) ([3a91ae2](https://github.com/libp2p/js-libp2p-crypto/commit/3a91ae2))
+
+
+
+<a name="0.10.2"></a>
+## [0.10.2](https://github.com/libp2p/js-libp2p-crypto/compare/v0.10.1...v0.10.2) (2017-09-06)
+
+
+### Bug Fixes
+
+* use regular protocol-buffers until protobufjs is fixed ([#109](https://github.com/libp2p/js-libp2p-crypto/issues/109)) ([957fdd3](https://github.com/libp2p/js-libp2p-crypto/commit/957fdd3))
+
+
+### Features
+
+* **deps:** upgrade to aegir@12 and browserify-aes@1.0.8 ([83257bc](https://github.com/libp2p/js-libp2p-crypto/commit/83257bc))
+
+
+
+<a name="0.10.1"></a>
+## [0.10.1](https://github.com/libp2p/js-libp2p-crypto/compare/v0.10.0...v0.10.1) (2017-09-05)
+
+
+### Bug Fixes
+
+* switch to protobufjs ([#107](https://github.com/libp2p/js-libp2p-crypto/issues/107)) ([dc2793f](https://github.com/libp2p/js-libp2p-crypto/commit/dc2793f))
+
+
+
+<a name="0.10.0"></a>
+# [0.10.0](https://github.com/libp2p/js-libp2p-crypto/compare/v0.9.4...v0.10.0) (2017-09-03)
+
+
+### Features
+
+* p2p addrs situation ([#106](https://github.com/libp2p/js-libp2p-crypto/issues/106)) ([9e977c7](https://github.com/libp2p/js-libp2p-crypto/commit/9e977c7))
+* skip nextTick in nodeify ([#103](https://github.com/libp2p/js-libp2p-crypto/issues/103)) ([f20267b](https://github.com/libp2p/js-libp2p-crypto/commit/f20267b))
+
+
+
+<a name="0.9.4"></a>
+## [0.9.4](https://github.com/libp2p/js-libp2p-crypto/compare/v0.9.3...v0.9.4) (2017-07-22)
+
+
+### Bug Fixes
+
+* circular circular dep -> DI ([bc554d1](https://github.com/libp2p/js-libp2p-crypto/commit/bc554d1))
+
+
+
+<a name="0.9.3"></a>
+## [0.9.3](https://github.com/libp2p/js-libp2p-crypto/compare/v0.9.2...v0.9.3) (2017-07-22)
+
+
+
+<a name="0.9.2"></a>
+## [0.9.2](https://github.com/libp2p/js-libp2p-crypto/compare/v0.9.1...v0.9.2) (2017-07-22)
+
+
+
+<a name="0.9.1"></a>
+## [0.9.1](https://github.com/libp2p/js-libp2p-crypto/compare/v0.9.0...v0.9.1) (2017-07-22)
+
+
+
+<a name="0.9.0"></a>
+# [0.9.0](https://github.com/libp2p/js-libp2p-crypto/compare/v0.8.8...v0.9.0) (2017-07-22)
+
+
+
+<a name="0.8.8"></a>
+## [0.8.8](https://github.com/libp2p/js-libp2p-crypto/compare/v0.8.7...v0.8.8) (2017-04-11)
+
+
+### Bug Fixes
+
+* **ecdh:** allow base64 to be left-0-padded, needed for JWK format  ([be64372](https://github.com/libp2p/js-libp2p-crypto/commit/be64372)), closes [#97](https://github.com/libp2p/js-libp2p-crypto/issues/97)
+
+
+
+<a name="0.8.7"></a>
+## [0.8.7](https://github.com/libp2p/js-libp2p-crypto/compare/v0.8.6...v0.8.7) (2017-03-21)
+
+
+
+<a name="0.8.6"></a>
+## [0.8.6](https://github.com/libp2p/js-libp2p-crypto/compare/v0.8.5...v0.8.6) (2017-03-03)
+
+
+### Bug Fixes
+
+* **package:** update tweetnacl to version 1.0.0-rc.1 ([4e56e17](https://github.com/libp2p/js-libp2p-crypto/commit/4e56e17))
+
+
+### Features
+
+* **keys:** implement generateKeyPairFromSeed for ed25519  ([e5b7c1f](https://github.com/libp2p/js-libp2p-crypto/commit/e5b7c1f))
+
+
+

README.md

@@ -1,49 +1,49 @@
 # js-libp2p-crypto
 
-[![](https://img.shields.io/badge/made%20by-Protocol%20Labs-blue.svg?style=flat-square)](http://ipn.io)
-[![](https://img.shields.io/badge/project-IPFS-blue.svg?style=flat-square)](http://ipfs.io/)
-[![](https://img.shields.io/badge/freenode-%23ipfs-blue.svg?style=flat-square)](http://webchat.freenode.net/?channels=%23ipfs)
-[![standard-readme compliant](https://img.shields.io/badge/standard--readme-OK-green.svg?style=flat-square)](https://github.com/RichardLitt/standard-readme)
-[![Coverage Status](https://coveralls.io/repos/github/libp2p/js-libp2p-crypto/badge.svg?branch=master)](https://coveralls.io/github/libp2p/js-libp2p-crypto?branch=master)
-[![Travis CI](https://travis-ci.org/libp2p/js-libp2p-crypto.svg?branch=master)](https://travis-ci.org/libp2p/js-libp2p-crypto)
-[![Circle CI](https://circleci.com/gh/libp2p/js-libp2p-crypto.svg?style=svg)](https://circleci.com/gh/libp2p/js-libp2p-crypto)
+[![](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-crypto.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-crypto)
+[![](https://img.shields.io/travis/libp2p/js-libp2p-crypto.svg?style=flat-square)](https://travis-ci.com/libp2p/js-libp2p-crypto)
 [![Dependency Status](https://david-dm.org/libp2p/js-libp2p-crypto.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-crypto)
 [![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat-square)](https://github.com/feross/standard)
-![](https://img.shields.io/badge/npm-%3E%3D3.0.0-orange.svg?style=flat-square)
-![](https://img.shields.io/badge/Node.js-%3E%3D4.0.0-orange.svg?style=flat-square)
-
-[![Sauce Test Status](https://saucelabs.com/browser-matrix/ipfs-js-libp2p-crypto.svg)](https://saucelabs.com/u/ipfs-js-
-libp2p-crypto)
 
 > Crypto primitives for libp2p in JavaScript
 
-This repo contains the JavaScript implementation of the crypto primitives
-needed for libp2p. This is based on this [go implementation](https://github.com/libp2p/go-libp2p-crypto).
+This repo contains the JavaScript implementation of the crypto primitives needed for libp2p. This is based on this [go implementation](https://github.com/libp2p/go-libp2p-crypto).
+
+## Lead Maintainer
+
+[Friedel Ziegelmayer](https://github.com/dignifiedquire/)
 
 ## Table of Contents
 
-- [Install](#install)
-- [Usage](#usage)
-  - [Example](#example)
-- [API](#api)
-  - [`hmac`](#hmac)
-    - [`create(hash, secret, callback)`](#createhash-secret-callback)
-      - [`digest(data, callback)`](#digestdata-callback)
-  - [`aes`](#aes)
-    - [`create(key, iv, callback)`](#createkey-iv-callback)
-      - [`encrypt(data, callback)`](#encryptdata-callback)
-      - [`encrypt(data, callback)`](#encryptdata-callback)
-  - [`webcrypto`](#webcrypto)
-  - [`keys`](#keys)
-  - [`generateKeyPair(type, bits, callback)`](#generatekeypairtype-bits-callback)
-  - [`generateEphemeralKeyPair(curve, callback)`](#generateephemeralkeypaircurve-callback)
-  - [`keyStretcher(cipherType, hashType, secret, callback)`](#keystretcherciphertype-hashtype-secret-callback)
-  - [`marshalPublicKey(key[, type], callback)`](#marshalpublickeykey-type-callback)
-  - [`unmarshalPublicKey(buf)`](#unmarshalpublickeybuf)
-  - [`marshalPrivateKey(key[, type])`](#marshalprivatekeykey-type)
-  - [`unmarshalPrivateKey(buf, callback)`](#unmarshalprivatekeybuf-callback)
-- [Contribute](#contribute)
-- [License](#license)
+- [js-libp2p-crypto](#js-libp2p-crypto)
+  - [Lead Maintainer](#Lead-Maintainer)
+  - [Table of Contents](#Table-of-Contents)
+  - [Install](#Install)
+  - [API](#API)
+    - [`crypto.aes`](#cryptoaes)
+      - [`crypto.aes.create(key, iv)`](#cryptoaescreatekey-iv)
+        - [`decrypt(data)`](#decryptdata)
+        - [`encrypt(data)`](#encryptdata)
+    - [`crypto.hmac`](#cryptohmac)
+      - [`crypto.hmac.create(hash, secret)`](#cryptohmaccreatehash-secret)
+        - [`digest(data)`](#digestdata)
+    - [`crypto.keys`](#cryptokeys)
+    - [`crypto.keys.generateKeyPair(type, bits)`](#cryptokeysgenerateKeyPairtype-bits)
+    - [`crypto.keys.generateEphemeralKeyPair(curve)`](#cryptokeysgenerateEphemeralKeyPaircurve)
+    - [`crypto.keys.keyStretcher(cipherType, hashType, secret)`](#cryptokeyskeyStretchercipherType-hashType-secret)
+    - [`crypto.keys.marshalPublicKey(key, [type])`](#cryptokeysmarshalPublicKeykey-type)
+    - [`crypto.keys.unmarshalPublicKey(buf)`](#cryptokeysunmarshalPublicKeybuf)
+    - [`crypto.keys.marshalPrivateKey(key, [type])`](#cryptokeysmarshalPrivateKeykey-type)
+    - [`crypto.keys.unmarshalPrivateKey(buf)`](#cryptokeysunmarshalPrivateKeybuf)
+    - [`crypto.keys.import(pem, password)`](#cryptokeysimportpem-password)
+    - [`crypto.randomBytes(number)`](#cryptorandomBytesnumber)
+    - [`crypto.pbkdf2(password, salt, iterations, keySize, hash)`](#cryptopbkdf2password-salt-iterations-keySize-hash)
+  - [Contribute](#Contribute)
+  - [License](#License)
 
 ## Install
 
@@ -51,80 +51,129 @@ needed for libp2p. This is based on this [go implementation](https://github.com/
 npm install --save libp2p-crypto
 ```
 
-## Usage
-
-### Example
-
-```js
-const crypto = require('libp2p-crypto')
-
-crypto.generateKeyPair('RSA', 2048, (err, key) => {
-})
-```
-
 ## API
 
-### `hmac`
+### `crypto.aes`
 
-Exposes an interface to the Keyed-Hash Message Authentication Code (HMAC) as defined in U.S. Federal Information Processing Standards Publication 198. An HMAC is a cryptographic hash that uses a key to sign a message. The receiver verifies the hash by recomputing it using the same key.
-
-#### `create(hash, secret, callback)`
-
-- `hash: String`
-- `secret: Buffer`
-- `callback: Function`
-
-##### `digest(data, callback)`
-
-- `data: Buffer`
-- `callback: Function`
-
-### `aes`
 Expoes an interface to AES encryption (formerly Rijndael), as defined in U.S. Federal Information Processing Standards Publication 197.
 
 This uses `CTR` mode.
 
-#### `create(key, iv, callback)`
+#### `crypto.aes.create(key, iv)`
 
 - `key: Buffer` The key, if length `16` then `AES 128` is used. For length `32`, `AES 256` is used.
 - `iv: Buffer` Must have length `16`.
-- `callback: Function`
 
-##### `encrypt(data, callback)`
+Returns `Promise<{decrypt<Function>, encrypt<Function>}>`
+
+##### `decrypt(data)`
 
 - `data: Buffer`
-- `callback: Function`
 
-##### `encrypt(data, callback)`
+Returns `Promise<Buffer>`
+
+##### `encrypt(data)`
 
 - `data: Buffer`
-- `callback: Function`
 
+Returns `Promise<Buffer>`
 
-### `webcrypto`
+```js
+const crypto = require('libp2p-crypto')
 
-Depending on the environment this is either an instance of [node-webcrypto-ossl](https://github.com/PeculiarVentures/node-webcrypto-ossl) or the result of `window.crypto`.
+// Setting up Key and IV
 
-### `keys`
+// A 16 bytes array, 128 Bits, AES-128 is chosen
+const key128 = Buffer.from([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])
 
-### `generateKeyPair(type, bits, callback)`
+// A 16 bytes array, 128 Bits,
+const IV = Buffer.from([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])
 
-- `type: String`, only `'RSA'` is currently supported
+async function main () {
+  const decryptedMessage = 'Hello, world!'
+
+  // Encrypting
+  const cipher = await crypto.aes.create(key128, IV)
+  const encryptedBuffer = await cipher.encrypt(Buffer.from(decryptedMessage))
+  console.log(encryptedBuffer)
+  // prints: <Buffer 42 f1 67 d9 2e 42 d0 32 9e b1 f8 3c>
+
+  // Decrypting
+  const decipher = await crypto.aes.create(key128, IV)
+  const decryptedBuffer = await cipher.decrypt(encryptedBuffer)
+
+  console.log(decryptedBuffer)
+  // prints: <Buffer 42 f1 67 d9 2e 42 d0 32 9e b1 f8 3c>
+
+  console.log(decryptedBuffer.toString('utf-8'))
+  // prints: Hello, world!
+}
+
+main()
+```
+
+### `crypto.hmac`
+
+Exposes an interface to the Keyed-Hash Message Authentication Code (HMAC) as defined in U.S. Federal Information Processing Standards Publication 198. An HMAC is a cryptographic hash that uses a key to sign a message. The receiver verifies the hash by recomputing it using the same key.
+
+#### `crypto.hmac.create(hash, secret)`
+
+- `hash: String`
+- `secret: Buffer`
+
+Returns `Promise<{digest<Function>}>`
+
+##### `digest(data)`
+
+- `data: Buffer`
+
+Returns `Promise<Buffer>`
+
+Example:
+
+```js
+const crypto = require('libp2p-crypto')
+
+async function main () {
+  const hash = 'SHA1' // 'SHA256' || 'SHA512'
+  const hmac = await crypto.hmac.create(hash, Buffer.from('secret'))
+  const sig = await hmac.digest(Buffer.from('hello world'))
+  console.log(sig)
+}
+
+main()
+```
+
+### `crypto.keys`
+
+**Supported Key Types**
+
+The [`generateKeyPair`](#generatekeypairtype-bits), [`marshalPublicKey`](#marshalpublickeykey-type), and [`marshalPrivateKey`](#marshalprivatekeykey-type) functions accept a string `type` argument.
+
+Currently the `'RSA'` and `'ed25519'` types are supported, although ed25519 keys support only signing and verification of messages.  For encryption / decryption support, RSA keys should be used.
+
+Installing the [libp2p-crypto-secp256k1](https://github.com/libp2p/js-libp2p-crypto-secp256k1) module adds support for the `'secp256k1'` type, which supports ECDSA signatures using the secp256k1 elliptic curve popularized by Bitcoin.  This module is not installed by default, and should be explicitly depended on if your project requires secp256k1 support.
+
+### `crypto.keys.generateKeyPair(type, bits)`
+
+- `type: String`, see [Supported Key Types](#supported-key-types) above.
 - `bits: Number` Minimum of 1024
-- `callback: Function`
+
+Returns `Promise<{privateKey<Buffer>, publicKey<Buffer>}>`
 
 Generates a keypair of the given type and bitsize.
 
-### `generateEphemeralKeyPair(curve, callback)`
+### `crypto.keys.generateEphemeralKeyPair(curve)`
 
 - `curve: String`, one of `'P-256'`, `'P-384'`, `'P-521'` is currently supported
-- `callback: Function`
+
+Returns `Promise`
 
 Generates an ephemeral public key and returns a function that will compute the shared secret key.
 
 Focuses only on ECDH now, but can be made more general in the future.
 
-Calls back with an object of the form
+Resolves to an object of the form:
 
 ```js
 {
@@ -133,16 +182,18 @@ Calls back with an object of the form
 }
 ```
 
-### `keyStretcher(cipherType, hashType, secret, callback)`
+### `crypto.keys.keyStretcher(cipherType, hashType, secret)`
 
 - `cipherType: String`, one of `'AES-128'`, `'AES-256'`, `'Blowfish'`
 - `hashType: String`, one of `'SHA1'`, `SHA256`, `SHA512`
 - `secret: Buffer`
-- `callback: Function`
+
+Returns `Promise`
 
 Generates a set of keys for each party by stretching the shared key.
 
-Calls back with an object of the form
+Resolves to an object of the form:
+
 ```js
 {
   k1: {
@@ -158,39 +209,67 @@ Calls back with an object of the form
 }
 ```
 
-### `marshalPublicKey(key[, type], callback)`
+### `crypto.keys.marshalPublicKey(key, [type])`
 
-- `key: crypto.rsa.RsaPublicKey`
-- `type: String`, only `'RSA'` is currently supported
+- `key: keys.rsa.RsaPublicKey | keys.ed25519.Ed25519PublicKey | require('libp2p-crypto-secp256k1').Secp256k1PublicKey`
+- `type: String`, see [Supported Key Types](#supported-key-types) above.  Defaults to 'rsa'.
+
+Returns `Buffer`
 
 Converts a public key object into a protobuf serialized public key.
 
-### `unmarshalPublicKey(buf)`
+### `crypto.keys.unmarshalPublicKey(buf)`
 
 - `buf: Buffer`
 
-Converts a protobuf serialized public key into its  representative object.
+Returns `RsaPublicKey|Ed25519PublicKey|Secp256k1PublicKey`
 
-### `marshalPrivateKey(key[, type])`
+Converts a protobuf serialized public key into its representative object.
 
-- `key: crypto.rsa.RsaPrivateKey`
-- `type: String`, only `'RSA'` is currently supported
+### `crypto.keys.marshalPrivateKey(key, [type])`
+
+- `key: keys.rsa.RsaPrivateKey | keys.ed25519.Ed25519PrivateKey | require('libp2p-crypto-secp256k1').Secp256k1PrivateKey`
+- `type: String`, see [Supported Key Types](#supported-key-types) above.
+
+Returns `Buffer`
 
 Converts a private key object into a protobuf serialized private key.
 
-### `unmarshalPrivateKey(buf, callback)`
+### `crypto.keys.unmarshalPrivateKey(buf)`
 
 - `buf: Buffer`
-- `callback: Function`
+
+Returns `Promise<RsaPrivateKey|Ed25519PrivateKey|Secp256k1PrivateKey>`
 
 Converts a protobuf serialized private key into its representative object.
 
-### `randomBytes(number)`
+### `crypto.keys.import(pem, password)`
+
+- `pem: string`
+- `password: string`
+
+Returns `Promise<RsaPrivateKey>`
+
+Converts a PEM password protected private key into its representative object.
+
+### `crypto.randomBytes(number)`
 
 - `number: Number`
 
+Returns `Buffer`
+
 Generates a Buffer with length `number` populated by random bytes.
 
+### `crypto.pbkdf2(password, salt, iterations, keySize, hash)`
+
+- `password: String`
+- `salt: String`
+- `iterations: Number`
+- `keySize: Number` in bytes
+- `hash: String` the hashing algorithm ('sha1', 'sha2-512', ...)
+
+Computes the Password Based Key Derivation Function 2; returning a new password.
+
 ## Contribute
 
 Feel free to join in. All welcome. Open an [issue](https://github.com/libp2p/js-libp2p-crypto/issues)!
@@ -201,4 +280,4 @@ This repository falls under the IPFS [Code of Conduct](https://github.com/ipfs/c
 
 ## License
 
-[MIT](LICENSE)
+[MIT](./LICENSE)

benchmarks/ephemeral-keys.js

@@ -1,3 +1,4 @@
+/* eslint-disable no-console */
 'use strict'
 
 const Benchmark = require('benchmark')
@@ -9,29 +10,14 @@ const secrets = []
 const curves = ['P-256', 'P-384', 'P-521']
 
 curves.forEach((curve) => {
-  suite.add(`ephemeral key with secrect ${curve}`, (d) => {
-    crypto.generateEphemeralKeyPair('P-256', (err, res) => {
-      if (err) {
-        throw err
-      }
-      res.genSharedKey(res.key, (err, secret) => {
-        if (err) {
-          throw err
-        }
-        secrets.push(secret)
-
-        d.resolve()
-      })
-    })
-  }, {
-    defer: true
-  })
+  suite.add(`ephemeral key with secrect ${curve}`, async (d) => {
+    const res = await crypto.keys.generateEphemeralKeyPair('P-256')
+    const secret = await res.genSharedKey(res.key)
+    secrets.push(secret)
+    d.resolve()
+  }, { defer: true })
 })
 
 suite
-  .on('cycle', (event) => {
-    console.log(String(event.target))
-  })
-  .run({
-    async: true
-  })
+  .on('cycle', (event) => console.log(String(event.target)))
+  .run({ async: true })

benchmarks/key-stretcher.js

@@ -1,7 +1,7 @@
+/* eslint-disable no-console */
 'use strict'
 
 const Benchmark = require('benchmark')
-const async = require('async')
 
 const crypto = require('../src')
 
@@ -12,38 +12,23 @@ const keys = []
 const ciphers = ['AES-128', 'AES-256', 'Blowfish']
 const hashes = ['SHA1', 'SHA256', 'SHA512']
 
-async.waterfall([
-  (cb) => crypto.generateEphemeralKeyPair('P-256', cb),
-  (res, cb) => res.genSharedKey(res.key, cb)
-], (err, secret) => {
-  if (err) {
-    throw err
-  }
+;(async () => {
+  const res = await crypto.keys.generateEphemeralKeyPair('P-256')
+  const secret = await res.genSharedKey(res.key)
 
   ciphers.forEach((cipher) => hashes.forEach((hash) => {
     setup(cipher, hash, secret)
   }))
 
   suite
-    .on('cycle', (event) => {
-      console.log(String(event.target))
-    })
-    .run({
-      async: true
-    })
-})
+    .on('cycle', (event) => console.log(String(event.target)))
+    .run({ async: true })
+})()
 
 function setup (cipher, hash, secret) {
-  suite.add(`keyStretcher ${cipher} ${hash}`, (d) => {
-    crypto.keyStretcher(cipher, hash, secret, (err, k) => {
-      if (err) {
-        throw err
-      }
-
-      keys.push(k)
-      d.resolve()
-    })
-  }, {
-    defer: true
-  })
+  suite.add(`keyStretcher ${cipher} ${hash}`, async (d) => {
+    const k = await crypto.keys.keyStretcher(cipher, hash, secret)
+    keys.push(k)
+    d.resolve()
+  }, { defer: true })
 }

benchmarks/rsa.js

@@ -1,3 +1,4 @@
+/* eslint-disable no-console */
 'use strict'
 
 const Benchmark = require('benchmark')
@@ -9,44 +10,28 @@ const keys = []
 const bits = [1024, 2048, 4096]
 
 bits.forEach((bit) => {
-  suite.add(`generateKeyPair ${bit}bits`, (d) => {
-    crypto.generateKeyPair('RSA', bit, (err, key) => {
-      if (err) throw err
-      keys.push(key)
-      d.resolve()
-    })
+  suite.add(`generateKeyPair ${bit}bits`, async (d) => {
+    const key = await crypto.keys.generateKeyPair('RSA', bit)
+    keys.push(key)
+    d.resolve()
   }, {
     defer: true
   })
 })
 
-suite.add('sign and verify', (d) => {
+suite.add('sign and verify', async (d) => {
   const key = keys[0]
   const text = key.genSecret()
 
-  key.sign(text, (err, sig) => {
-    if (err) {
-      throw err
-    }
+  const sig = await key.sign(text)
+  const res = await key.public.verify(text, sig)
 
-    key.public.verify(text, sig, (err, res) => {
-      if (err) {
-        throw err
-      }
-      if (res !== true) {
-        throw new Error('failed to verify')
-      }
-      d.resolve()
-    })
-  })
+  if (res !== true) { throw new Error('failed to verify') }
+  d.resolve()
 }, {
   defer: true
 })
 
 suite
-  .on('cycle', (event) => {
-    console.log(String(event.target))
-  })
-  .run({
-    async: true
-  })
+  .on('cycle', (event) => console.log(String(event.target)))
+  .run({ async: true })

circle.yml

@@ -1,12 +0,0 @@
-machine:
-  node:
-    version: stable
-
-dependencies:
-  pre:
-    - google-chrome --version
-    - wget -q -O - https://dl-ssl.google.com/linux/linux_signing_key.pub | sudo apt-key add -
-    - sudo sh -c 'echo "deb [arch=amd64] http://dl.google.com/linux/chrome/deb/ stable main" >> /etc/apt/sources.list.d/google.list'
-    - sudo apt-get update
-    - sudo apt-get --only-upgrade install google-chrome-stable
-    - google-chrome --version

package.json

@@ -1,28 +1,31 @@
 {
   "name": "libp2p-crypto",
-  "version": "0.7.7",
+  "version": "0.17.0",
   "description": "Crypto primitives for libp2p",
   "main": "src/index.js",
+  "leadMaintainer": "Friedel Ziegelmayer <dignifiedquire@gmail.com>",
   "browser": {
-    "node-webcrypto-ossl": false,
-    "./src/crypto/webcrypto.js": "./src/crypto/webcrypto-browser.js",
-    "./src/crypto/hmac.js": "./src/crypto/hmac-browser.js",
-    "./src/crypto/ecdh.js": "./src/crypto/ecdh-browser.js",
-    "./src/crypto/ciphers.js": "./src/crypto/ciphers-browser.js",
-    "./src/crypto/rsa.js": "./src/crypto/rsa-browser.js"
+    "./src/hmac/index.js": "./src/hmac/index-browser.js",
+    "./src/keys/ecdh.js": "./src/keys/ecdh-browser.js",
+    "./src/aes/ciphers.js": "./src/aes/ciphers-browser.js",
+    "./src/keys/rsa.js": "./src/keys/rsa-browser.js"
   },
+  "files": [
+    "src",
+    "dist"
+  ],
   "scripts": {
-    "lint": "aegir-lint",
-    "build": "aegir-build",
-    "test": "npm run test:node && npm run test:no-webcrypto && npm run test:browser",
-    "test:node": "aegir-test --env node",
-    "test:no-webcrypto": "NO_WEBCRYPTO=true aegir-test --env node",
-    "test:browser": "aegir-test --env browser --webworker",
-    "release": "aegir-release --webworker",
-    "release-minor": "aegir-release --type minor --webworker",
-    "release-major": "aegir-release --type major --webworker",
-    "coverage": "aegir-coverage",
-    "coverage-publish": "aegir-coverage publish"
+    "lint": "aegir lint",
+    "build": "aegir build",
+    "build-proto": "pbjs --wrap commonjs --target static-module src/keys/keys.proto > src/keys/keys.proto.js",
+    "test": "aegir test",
+    "test:node": "aegir test -t node",
+    "test:browser": "aegir test -t browser -t webworker",
+    "release": "aegir release",
+    "release-minor": "aegir release --type minor",
+    "release-major": "aegir release --type major",
+    "coverage": "aegir coverage --ignore src/keys/keys.proto.js",
+    "size": "bundlesize -f dist/index.min.js -s 139kB"
   },
   "keywords": [
     "IPFS",
@@ -30,54 +33,67 @@
     "crypto",
     "rsa"
   ],
-  "author": "Friedel Ziegelmayer <dignifiedqurie@gmail.com>",
   "license": "MIT",
   "dependencies": {
-    "asn1.js": "^4.9.1",
-    "async": "^2.1.4",
-    "browserify-aes": "^1.0.6",
+    "asmcrypto.js": "^2.3.2",
+    "asn1.js": "^5.0.1",
+    "bn.js": "^5.0.0",
+    "browserify-aes": "^1.2.0",
+    "bs58": "^4.0.1",
+    "iso-random-stream": "^1.1.0",
     "keypair": "^1.0.1",
-    "multihashing-async": "^0.4.0",
-    "nodeify": "^1.0.0",
-    "pem-jwk": "^1.5.1",
-    "protocol-buffers": "^3.2.1",
+    "libp2p-crypto-secp256k1": "~0.4.0",
+    "multihashing-async": "~0.7.0",
+    "node-forge": "~0.8.5",
+    "pem-jwk": "^2.0.0",
+    "protons": "^1.0.1",
     "rsa-pem-to-jwk": "^1.1.3",
-    "safe-buffer": "^5.0.1",
-    "tweetnacl": "^0.14.5",
-    "webcrypto-shim": "github:dignifiedquire/webcrypto-shim#master"
+    "tweetnacl": "^1.0.1",
+    "ursa-optional": "~0.10.0"
   },
   "devDependencies": {
-    "aegir": "^9.4.0",
-    "benchmark": "^2.1.3",
-    "chai": "^3.5.0",
-    "pre-commit": "^1.2.2"
+    "aegir": "^19.0.5",
+    "benchmark": "^2.1.4",
+    "bundlesize": "~0.18.0",
+    "chai": "^4.2.0",
+    "chai-string": "^1.5.0",
+    "dirty-chai": "^2.0.1",
+    "sinon": "^7.3.2"
   },
-  "optionalDependencies": {
-    "node-webcrypto-ossl": "^1.0.16"
-  },
-  "pre-commit": [
-    "lint",
-    "test"
-  ],
   "engines": {
-    "node": ">=4.0.0"
+    "node": ">=10.0.0",
+    "npm": ">=6.0.0"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/ipfs/js-libp2p-crypto.git"
+    "url": "https://github.com/libp2p/js-libp2p-crypto.git"
   },
   "bugs": {
-    "url": "https://github.com/ipfs/js-libp2p-crypto/issues"
+    "url": "https://github.com/libp2p/js-libp2p-crypto/issues"
   },
-  "homepage": "https://github.com/ipfs/js-libp2p-crypto",
+  "homepage": "https://github.com/libp2p/js-libp2p-crypto",
   "contributors": [
+    "Alan Shaw <alan.shaw@protocol.ai>",
+    "Alberto Elias <hi@albertoelias.me>",
+    "Arve Knudsen <arve.knudsen@gmail.com>",
     "David Dias <daviddias.p@gmail.com>",
+    "Dmitriy Ryajov <dryajov@gmail.com>",
     "Friedel Ziegelmayer <dignifiedquire@gmail.com>",
     "Greenkeeper <support@greenkeeper.io>",
+    "Hugo Dias <hugomrdias@gmail.com>",
+    "Jack Kleeman <jackkleeman@gmail.com>",
+    "Jacob Heun <jacobheun@gmail.com>",
+    "Joao Santos <jrmsantos15@gmail.com>",
+    "Maciej Krüger <mkg20001@gmail.com>",
     "Richard Littauer <richard.littauer@gmail.com>",
+    "Richard Schneider <makaretu@gmail.com>",
     "Tom Swindell <t.swindell@rubyx.co.uk>",
+    "Vasco Santos <vasco.santos@ua.pt>",
+    "Victor Bjelkholm <victorbjelkholm@gmail.com>",
     "Yusef Napora <yusef@napora.org>",
-    "dryajov <dryajov@gmail.com>",
+    "dignifiedquire <dignifiedquire@users.noreply.github.com>",
+    "dirkmc <dirkmdev@gmail.com>",
+    "greenkeeper[bot] <greenkeeper[bot]@users.noreply.github.com>",
     "nikuda <nikuda@gmail.com>"
   ]
-}
+}

src/aes/index-browser.js

@@ -0,0 +1,34 @@
+'use strict'
+
+const asm = require('asmcrypto.js')
+
+exports.create = async function (key, iv) { // eslint-disable-line require-await
+  if (key.length !== 16 && key.length !== 32) {
+    throw new Error('Invalid key length')
+  }
+
+  const enc = new asm.AES_CTR.Encrypt({
+    key: key,
+    nonce: iv
+  })
+  const dec = new asm.AES_CTR.Decrypt({
+    key: key,
+    nonce: iv
+  })
+
+  const res = {
+    async encrypt (data) { // eslint-disable-line require-await
+      return Buffer.from(
+        enc.process(data).result
+      )
+    },
+
+    async decrypt (data) { // eslint-disable-line require-await
+      return Buffer.from(
+        dec.process(data).result
+      )
+    }
+  }
+
+  return res
+}

src/aes/index.js

@@ -0,0 +1,30 @@
+'use strict'
+
+const ciphers = require('./ciphers')
+
+const CIPHER_MODES = {
+  16: 'aes-128-ctr',
+  32: 'aes-256-ctr'
+}
+
+exports.create = async function (key, iv) { // eslint-disable-line require-await
+  const mode = CIPHER_MODES[key.length]
+  if (!mode) {
+    throw new Error('Invalid key length')
+  }
+
+  const cipher = ciphers.createCipheriv(mode, key, iv)
+  const decipher = ciphers.createDecipheriv(mode, key, iv)
+
+  const res = {
+    async encrypt (data) { // eslint-disable-line require-await
+      return cipher.update(data)
+    },
+
+    async decrypt (data) { // eslint-disable-line require-await
+      return decipher.update(data)
+    }
+  }
+
+  return res
+}

src/crypto.js

@@ -1,8 +0,0 @@
-'use strict'
-
-exports.webcrypto = require('./crypto/webcrypto')()
-exports.hmac = require('./crypto/hmac')
-exports.ecdh = require('./crypto/ecdh')
-exports.aes = require('./crypto/aes')
-exports.rsa = require('./crypto/rsa')
-exports.ed25519 = require('./crypto/ed25519')

src/crypto/aes.js

@@ -1,30 +0,0 @@
-'use strict'
-
-const ciphers = require('./ciphers')
-
-const CIPHER_MODES = {
-  16: 'aes-128-ctr',
-  32: 'aes-256-ctr'
-}
-
-exports.create = function (key, iv, callback) {
-  const mode = CIPHER_MODES[key.length]
-  if (!mode) {
-    return callback(new Error('Invalid key length'))
-  }
-
-  const cipher = ciphers.createCipheriv(mode, key, iv)
-  const decipher = ciphers.createDecipheriv(mode, key, iv)
-
-  const res = {
-    encrypt (data, cb) {
-      cb(null, cipher.update(data))
-    },
-
-    decrypt (data, cb) {
-      cb(null, decipher.update(data))
-    }
-  }
-
-  callback(null, res)
-}

src/crypto/ecdh-browser.js

@@ -1,130 +0,0 @@
-'use strict'
-
-const crypto = require('./webcrypto')()
-const nodeify = require('nodeify')
-const BN = require('asn1.js').bignum
-const Buffer = require('safe-buffer').Buffer
-
-const util = require('./util')
-const toBase64 = util.toBase64
-const toBn = util.toBn
-
-const bits = {
-  'P-256': 256,
-  'P-384': 384,
-  'P-521': 521
-}
-
-exports.generateEphmeralKeyPair = function (curve, callback) {
-  nodeify(crypto.subtle.generateKey(
-    {
-      name: 'ECDH',
-      namedCurve: curve
-    },
-    true,
-    ['deriveBits']
-  ).then((pair) => {
-    // forcePrivate is used for testing only
-    const genSharedKey = (theirPub, forcePrivate, cb) => {
-      if (typeof forcePrivate === 'function') {
-        cb = forcePrivate
-        forcePrivate = undefined
-      }
-
-      let privateKey
-
-      if (forcePrivate) {
-        privateKey = crypto.subtle.importKey(
-          'jwk',
-          unmarshalPrivateKey(curve, forcePrivate),
-          {
-            name: 'ECDH',
-            namedCurve: curve
-          },
-          false,
-          ['deriveBits']
-        )
-      } else {
-        privateKey = Promise.resolve(pair.privateKey)
-      }
-
-      const keys = Promise.all([
-        crypto.subtle.importKey(
-          'jwk',
-          unmarshalPublicKey(curve, theirPub),
-          {
-            name: 'ECDH',
-            namedCurve: curve
-          },
-          false,
-          []
-        ),
-        privateKey
-      ])
-
-      nodeify(keys.then((keys) => crypto.subtle.deriveBits(
-        {
-          name: 'ECDH',
-          namedCurve: curve,
-          public: keys[0]
-        },
-        keys[1],
-        bits[curve]
-      )).then((bits) => Buffer.from(bits)), cb)
-    }
-
-    return crypto.subtle.exportKey(
-      'jwk',
-      pair.publicKey
-    ).then((publicKey) => {
-      return {
-        key: marshalPublicKey(publicKey),
-        genSharedKey
-      }
-    })
-  }), callback)
-}
-
-const curveLengths = {
-  'P-256': 32,
-  'P-384': 48,
-  'P-521': 66
-}
-
-// Marshal converts a jwk encodec ECDH public key into the
-// form specified in section 4.3.6 of ANSI X9.62. (This is the format
-// go-ipfs uses)
-function marshalPublicKey (jwk) {
-  const byteLen = curveLengths[jwk.crv]
-
-  return Buffer.concat([
-    Buffer.from([4]), // uncompressed point
-    toBn(jwk.x).toArrayLike(Buffer, 'be', byteLen),
-    toBn(jwk.y).toArrayLike(Buffer, 'be', byteLen)
-  ], 1 + byteLen * 2)
-}
-
-// Unmarshal converts a point, serialized by Marshal, into an jwk encoded key
-function unmarshalPublicKey (curve, key) {
-  const byteLen = curveLengths[curve]
-
-  if (!key.slice(0, 1).equals(Buffer.from([4]))) {
-    throw new Error('Invalid key format')
-  }
-  const x = new BN(key.slice(1, byteLen + 1))
-  const y = new BN(key.slice(1 + byteLen))
-
-  return {
-    kty: 'EC',
-    crv: curve,
-    x: toBase64(x),
-    y: toBase64(y),
-    ext: true
-  }
-}
-
-function unmarshalPrivateKey (curve, key) {
-  const result = unmarshalPublicKey(curve, key.public)
-  result.d = toBase64(new BN(key.private))
-  return result
-}

src/crypto/ecdh.js

@@ -1,41 +0,0 @@
-'use strict'
-
-const crypto = require('crypto')
-const setImmediate = require('async/setImmediate')
-
-const curves = {
-  'P-256': 'prime256v1',
-  'P-384': 'secp384r1',
-  'P-521': 'secp521r1'
-}
-
-exports.generateEphmeralKeyPair = function (curve, callback) {
-  if (!curves[curve]) {
-    return callback(new Error(`Unkown curve: ${curve}`))
-  }
-  const ecdh = crypto.createECDH(curves[curve])
-  ecdh.generateKeys()
-
-  setImmediate(() => callback(null, {
-    key: ecdh.getPublicKey(),
-    genSharedKey (theirPub, forcePrivate, cb) {
-      if (typeof forcePrivate === 'function') {
-        cb = forcePrivate
-        forcePrivate = null
-      }
-
-      if (forcePrivate) {
-        ecdh.setPrivateKey(forcePrivate.private)
-      }
-
-      let secret
-      try {
-        secret = ecdh.computeSecret(theirPub)
-      } catch (err) {
-        return cb(err)
-      }
-
-      setImmediate(() => cb(null, secret))
-    }
-  }))
-}

src/crypto/ed25519.js

@@ -1,35 +0,0 @@
-'use strict'
-
-const nacl = require('tweetnacl')
-const setImmediate = require('async/setImmediate')
-const Buffer = require('safe-buffer').Buffer
-
-exports.publicKeyLength = nacl.sign.publicKeyLength
-exports.privateKeyLength = nacl.sign.secretKeyLength
-
-exports.generateKey = function (callback) {
-  const done = (err, res) => setImmediate(() => {
-    callback(err, res)
-  })
-
-  let keys
-  try {
-    keys = nacl.sign.keyPair()
-  } catch (err) {
-    done(err)
-    return
-  }
-  done(null, keys)
-}
-
-exports.hashAndSign = function (key, msg, callback) {
-  setImmediate(() => {
-    callback(null, Buffer.from(nacl.sign.detached(msg, key)))
-  })
-}
-
-exports.hashAndVerify = function (key, sig, msg, callback) {
-  setImmediate(() => {
-    callback(null, nacl.sign.detached.verify(msg, sig, key))
-  })
-}

src/crypto/hmac-browser.js

@@ -1,39 +0,0 @@
-'use strict'
-
-const nodeify = require('nodeify')
-const Buffer = require('safe-buffer').Buffer
-
-const crypto = require('./webcrypto')()
-const lengths = require('./hmac-lengths')
-
-const hashTypes = {
-  SHA1: 'SHA-1',
-  SHA256: 'SHA-256',
-  SHA512: 'SHA-512'
-}
-
-exports.create = function (hashType, secret, callback) {
-  const hash = hashTypes[hashType]
-
-  nodeify(crypto.subtle.importKey(
-    'raw',
-    secret,
-    {
-      name: 'HMAC',
-      hash: {name: hash}
-    },
-    false,
-    ['sign']
-  ).then((key) => {
-    return {
-      digest (data, cb) {
-        nodeify(crypto.subtle.sign(
-          {name: 'HMAC'},
-          key,
-          data
-        ).then((raw) => Buffer.from(raw)), cb)
-      },
-      length: lengths[hashType]
-    }
-  }), callback)
-}

src/crypto/hmac.js

@@ -1,24 +0,0 @@
-'use strict'
-
-const crypto = require('crypto')
-
-const lengths = require('./hmac-lengths')
-
-exports.create = function (hash, secret, callback) {
-  const res = {
-    digest (data, cb) {
-      const hmac = genFresh()
-      hmac.update(data)
-
-      setImmediate(() => {
-        cb(null, hmac.digest())
-      })
-    },
-    length: lengths[hash]
-  }
-
-  function genFresh () {
-    return crypto.createHmac(hash.toLowerCase(), secret)
-  }
-  callback(null, res)
-}

src/crypto/rsa-browser.js

@@ -1,120 +0,0 @@
-'use strict'
-
-const nodeify = require('nodeify')
-const Buffer = require('safe-buffer').Buffer
-
-const crypto = require('./webcrypto')()
-
-exports.utils = require('./rsa-utils')
-
-exports.generateKey = function (bits, callback) {
-  nodeify(crypto.subtle.generateKey(
-    {
-      name: 'RSASSA-PKCS1-v1_5',
-      modulusLength: bits,
-      publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
-      hash: {name: 'SHA-256'}
-    },
-    true,
-    ['sign', 'verify']
-  )
-  .then(exportKey)
-  .then((keys) => ({
-    privateKey: keys[0],
-    publicKey: keys[1]
-  })), callback)
-}
-
-// Takes a jwk key
-exports.unmarshalPrivateKey = function (key, callback) {
-  const privateKey = crypto.subtle.importKey(
-    'jwk',
-    key,
-    {
-      name: 'RSASSA-PKCS1-v1_5',
-      hash: {name: 'SHA-256'}
-    },
-    true,
-    ['sign']
-  )
-
-  nodeify(Promise.all([
-    privateKey,
-    derivePublicFromPrivate(key)
-  ]).then((keys) => exportKey({
-    privateKey: keys[0],
-    publicKey: keys[1]
-  })).then((keys) => ({
-    privateKey: keys[0],
-    publicKey: keys[1]
-  })), callback)
-}
-
-exports.getRandomValues = function (arr) {
-  return Buffer.from(crypto.getRandomValues(arr))
-}
-
-exports.hashAndSign = function (key, msg, callback) {
-  nodeify(crypto.subtle.importKey(
-    'jwk',
-    key,
-    {
-      name: 'RSASSA-PKCS1-v1_5',
-      hash: {name: 'SHA-256'}
-    },
-    false,
-    ['sign']
-  ).then((privateKey) => {
-    return crypto.subtle.sign(
-      {name: 'RSASSA-PKCS1-v1_5'},
-      privateKey,
-      Uint8Array.from(msg)
-    )
-  }).then((sig) => Buffer.from(sig)), callback)
-}
-
-exports.hashAndVerify = function (key, sig, msg, callback) {
-  nodeify(crypto.subtle.importKey(
-    'jwk',
-    key,
-    {
-      name: 'RSASSA-PKCS1-v1_5',
-      hash: {name: 'SHA-256'}
-    },
-    false,
-    ['verify']
-  ).then((publicKey) => {
-    return crypto.subtle.verify(
-      {name: 'RSASSA-PKCS1-v1_5'},
-      publicKey,
-      sig,
-      msg
-    )
-  }), callback)
-}
-
-function exportKey (pair) {
-  return Promise.all([
-    crypto.subtle.exportKey('jwk', pair.privateKey),
-    crypto.subtle.exportKey('jwk', pair.publicKey)
-  ])
-}
-
-function derivePublicFromPrivate (jwKey) {
-  return crypto.subtle.importKey(
-    'jwk',
-    {
-      kty: jwKey.kty,
-      n: jwKey.n,
-      e: jwKey.e,
-      alg: jwKey.alg,
-      kid: jwKey.kid
-    },
-    {
-      name: 'RSASSA-PKCS1-v1_5',
-      hash: {name: 'SHA-256'}
-    },
-    true,
-    ['verify']
-  )
-}

src/crypto/rsa.js

@@ -1,80 +0,0 @@
-'use strict'
-
-// Node.js land
-// First we look if node-webrypto-ossl is available
-// otherwise we fall back to using keypair + node core
-
-let webcrypto
-try {
-  webcrypto = require('node-webcrypto-ossl')
-} catch (err) {
-  // not available, use the code below
-}
-
-if (webcrypto && !process.env.NO_WEBCRYPTO) {
-  module.exports = require('./rsa-browser')
-} else {
-  const crypto = require('crypto')
-  const keypair = require('keypair')
-  const setImmediate = require('async/setImmediate')
-  const pemToJwk = require('pem-jwk').pem2jwk
-  const jwkToPem = require('pem-jwk').jwk2pem
-
-  exports.utils = require('./rsa-utils')
-
-  exports.generateKey = function (bits, callback) {
-    const done = (err, res) => setImmediate(() => {
-      callback(err, res)
-    })
-
-    let key
-    try {
-      key = keypair({
-        bits: bits
-      })
-    } catch (err) {
-      done(err)
-      return
-    }
-
-    done(null, {
-      privateKey: pemToJwk(key.private),
-      publicKey: pemToJwk(key.public)
-    })
-  }
-
-  // Takes a jwk key
-  exports.unmarshalPrivateKey = function (key, callback) {
-    callback(null, {
-      privateKey: key,
-      publicKey: {
-        kty: key.kty,
-        n: key.n,
-        e: key.e
-      }
-    })
-  }
-
-  exports.getRandomValues = function (arr) {
-    return crypto.randomBytes(arr.length)
-  }
-
-  exports.hashAndSign = function (key, msg, callback) {
-    const sign = crypto.createSign('RSA-SHA256')
-
-    sign.update(msg)
-    setImmediate(() => {
-      callback(null, sign.sign(jwkToPem(key)))
-    })
-  }
-
-  exports.hashAndVerify = function (key, sig, msg, callback) {
-    const verify = crypto.createVerify('RSA-SHA256')
-
-    verify.update(msg)
-
-    setImmediate(() => {
-      callback(null, verify.verify(jwkToPem(key), sig))
-    })
-  }
-}

src/crypto/webcrypto-browser.js

@@ -1,24 +0,0 @@
-/* global self */
-
-'use strict'
-
-module.exports = function getWebCrypto () {
-  if (typeof window !== 'undefined') {
-    // This is only a shim for interfaces, not for functionality
-    require('webcrypto-shim')(window)
-
-    if (window.crypto) {
-      return window.crypto
-    }
-  }
-
-  if (typeof self !== 'undefined') {
-    require('webcrypto-shim')(self)
-
-    if (self.crypto) {
-      return self.crypto
-    }
-  }
-
-  throw new Error('Please use an environment with crypto support')
-}

src/crypto/webcrypto.js

@@ -1,11 +0,0 @@
-'use strict'
-
-module.exports = function getWebCrypto () {
-  try {
-    const WebCrypto = require('node-webcrypto-ossl')
-    const webCrypto = new WebCrypto()
-    return webCrypto
-  } catch (err) {
-    // fallback to other things
-  }
-}

src/hmac/index-browser.js

@@ -0,0 +1,36 @@
+'use strict'
+
+const webcrypto = require('../webcrypto.js')
+const lengths = require('./lengths')
+
+const hashTypes = {
+  SHA1: 'SHA-1',
+  SHA256: 'SHA-256',
+  SHA512: 'SHA-512'
+}
+
+const sign = async (key, data) => {
+  return Buffer.from(await webcrypto.subtle.sign({ name: 'HMAC' }, key, data))
+}
+
+exports.create = async function (hashType, secret) {
+  const hash = hashTypes[hashType]
+
+  const key = await webcrypto.subtle.importKey(
+    'raw',
+    secret,
+    {
+      name: 'HMAC',
+      hash: { name: hash }
+    },
+    false,
+    ['sign']
+  )
+
+  return {
+    async digest (data) { // eslint-disable-line require-await
+      return sign(key, data)
+    },
+    length: lengths[hashType]
+  }
+}

src/hmac/index.js

@@ -0,0 +1,17 @@
+'use strict'
+
+const crypto = require('crypto')
+const lengths = require('./lengths')
+
+exports.create = async function (hash, secret) { // eslint-disable-line require-await
+  const res = {
+    async digest (data) { // eslint-disable-line require-await
+      const hmac = crypto.createHmac(hash.toLowerCase(), secret)
+      hmac.update(data)
+      return hmac.digest()
+    },
+    length: lengths[hash]
+  }
+
+  return res
+}

src/index.js

@@ -1,84 +1,11 @@
 'use strict'
 
-const protobuf = require('protocol-buffers')
+const hmac = require('./hmac')
+const aes = require('./aes')
+const keys = require('./keys')
 
-const pbm = protobuf(require('./crypto.proto'))
-const c = require('./crypto')
-
-exports.hmac = c.hmac
-exports.aes = c.aes
-exports.webcrypto = c.webcrypto
-
-const keys = exports.keys = require('./keys')
-const KEY_TYPES = ['rsa', 'ed25519']
-
-exports.keyStretcher = require('./key-stretcher')
-exports.generateEphemeralKeyPair = require('./ephemeral-keys')
-
-// Generates a keypair of the given type and bitsize
-exports.generateKeyPair = (type, bits, cb) => {
-  let key = keys[type.toLowerCase()]
-  if (!key) {
-    return cb(new Error('invalid or unsupported key type'))
-  }
-
-  key.generateKeyPair(bits, cb)
-}
-
-// Converts a protobuf serialized public key into its
-// representative object
-exports.unmarshalPublicKey = (buf) => {
-  const decoded = pbm.PublicKey.decode(buf)
-
-  switch (decoded.Type) {
-    case pbm.KeyType.RSA:
-      return keys.rsa.unmarshalRsaPublicKey(decoded.Data)
-    case pbm.KeyType.Ed25519:
-      return keys.ed25519.unmarshalEd25519PublicKey(decoded.Data)
-    default:
-      throw new Error('invalid or unsupported key type')
-  }
-}
-
-// Converts a public key object into a protobuf serialized public key
-exports.marshalPublicKey = (key, type) => {
-  type = (type || 'rsa').toLowerCase()
-  if (KEY_TYPES.indexOf(type) < 0) {
-    throw new Error('invalid or unsupported key type')
-  }
-
-  return key.bytes
-}
-
-// Converts a protobuf serialized private key into its
-// representative object
-exports.unmarshalPrivateKey = (buf, callback) => {
-  const decoded = pbm.PrivateKey.decode(buf)
-
-  switch (decoded.Type) {
-    case pbm.KeyType.RSA:
-      return keys.rsa.unmarshalRsaPrivateKey(decoded.Data, callback)
-    case pbm.KeyType.Ed25519:
-      return keys.ed25519.unmarshalEd25519PrivateKey(decoded.Data, callback)
-    default:
-      callback(new Error('invalid or unsupported key type'))
-  }
-}
-
-// Converts a private key object into a protobuf serialized private key
-exports.marshalPrivateKey = (key, type) => {
-  type = (type || 'rsa').toLowerCase()
-  if (KEY_TYPES.indexOf(type) < 0) {
-    throw new Error('invalid or unsupported key type')
-  }
-
-  return key.bytes
-}
-
-exports.randomBytes = (number) => {
-  if (!number || typeof number !== 'number') {
-    throw new Error('first argument must be a Number bigger than 0')
-  }
-
-  return c.rsa.getRandomValues(new Uint8Array(number))
-}
+exports.aes = aes
+exports.hmac = hmac
+exports.keys = keys
+exports.randomBytes = require('./random-bytes')
+exports.pbkdf2 = require('./pbkdf2')

src/key-stretcher.js

@@ -1,109 +0,0 @@
-'use strict'
-
-const crypto = require('./crypto')
-const whilst = require('async/whilst')
-const Buffer = require('safe-buffer').Buffer
-
-const cipherMap = {
-  'AES-128': {
-    ivSize: 16,
-    keySize: 16
-  },
-  'AES-256': {
-    ivSize: 16,
-    keySize: 32
-  },
-  Blowfish: {
-    ivSize: 8,
-    cipherKeySize: 32
-  }
-}
-
-// Generates a set of keys for each party by stretching the shared key.
-// (myIV, theirIV, myCipherKey, theirCipherKey, myMACKey, theirMACKey)
-module.exports = (cipherType, hash, secret, callback) => {
-  const cipher = cipherMap[cipherType]
-
-  if (!cipher) {
-    return callback(new Error('unkown cipherType passed'))
-  }
-
-  if (!hash) {
-    return callback(new Error('unkown hashType passed'))
-  }
-
-  const cipherKeySize = cipher.keySize
-  const ivSize = cipher.ivSize
-  const hmacKeySize = 20
-  const seed = Buffer.from('key expansion')
-  const resultLength = 2 * (ivSize + cipherKeySize + hmacKeySize)
-
-  crypto.hmac.create(hash, secret, (err, m) => {
-    if (err) {
-      return callback(err)
-    }
-
-    m.digest(seed, (err, a) => {
-      if (err) {
-        return callback(err)
-      }
-
-      let result = []
-      let j = 0
-
-      whilst(
-        () => j < resultLength,
-        stretch,
-        finish
-      )
-
-      function stretch (cb) {
-        m.digest(Buffer.concat([a, seed]), (err, b) => {
-          if (err) {
-            return cb(err)
-          }
-
-          let todo = b.length
-
-          if (j + todo > resultLength) {
-            todo = resultLength - j
-          }
-
-          result.push(b)
-
-          j += todo
-
-          m.digest(a, (err, _a) => {
-            if (err) {
-              return cb(err)
-            }
-            a = _a
-            cb()
-          })
-        })
-      }
-
-      function finish (err) {
-        if (err) {
-          return callback(err)
-        }
-
-        const half = resultLength / 2
-        const resultBuffer = Buffer.concat(result)
-        const r1 = resultBuffer.slice(0, half)
-        const r2 = resultBuffer.slice(half, resultLength)
-
-        const createKey = (res) => ({
-          iv: res.slice(0, ivSize),
-          cipherKey: res.slice(ivSize, ivSize + cipherKeySize),
-          macKey: res.slice(ivSize + cipherKeySize)
-        })
-
-        callback(null, {
-          k1: createKey(r1),
-          k2: createKey(r2)
-        })
-      }
-    })
-  })
-}

src/keys/ecdh-browser.js

@@ -0,0 +1,117 @@
+'use strict'
+
+const webcrypto = require('../webcrypto.js')
+const BN = require('asn1.js').bignum
+const { toBase64, toBn } = require('../util')
+
+const bits = {
+  'P-256': 256,
+  'P-384': 384,
+  'P-521': 521
+}
+
+exports.generateEphmeralKeyPair = async function (curve) {
+  const pair = await webcrypto.subtle.generateKey(
+    {
+      name: 'ECDH',
+      namedCurve: curve
+    },
+    true,
+    ['deriveBits']
+  )
+
+  // forcePrivate is used for testing only
+  const genSharedKey = async (theirPub, forcePrivate) => {
+    let privateKey
+
+    if (forcePrivate) {
+      privateKey = await webcrypto.subtle.importKey(
+        'jwk',
+        unmarshalPrivateKey(curve, forcePrivate),
+        {
+          name: 'ECDH',
+          namedCurve: curve
+        },
+        false,
+        ['deriveBits']
+      )
+    } else {
+      privateKey = pair.privateKey
+    }
+
+    const keys = [
+      await webcrypto.subtle.importKey(
+        'jwk',
+        unmarshalPublicKey(curve, theirPub),
+        {
+          name: 'ECDH',
+          namedCurve: curve
+        },
+        false,
+        []
+      ),
+      privateKey
+    ]
+
+    return Buffer.from(await webcrypto.subtle.deriveBits(
+      {
+        name: 'ECDH',
+        namedCurve: curve,
+        public: keys[0]
+      },
+      keys[1],
+      bits[curve]
+    ))
+  }
+
+  const publicKey = await webcrypto.subtle.exportKey('jwk', pair.publicKey)
+
+  return {
+    key: marshalPublicKey(publicKey),
+    genSharedKey
+  }
+}
+
+const curveLengths = {
+  'P-256': 32,
+  'P-384': 48,
+  'P-521': 66
+}
+
+// Marshal converts a jwk encodec ECDH public key into the
+// form specified in section 4.3.6 of ANSI X9.62. (This is the format
+// go-ipfs uses)
+function marshalPublicKey (jwk) {
+  const byteLen = curveLengths[jwk.crv]
+
+  return Buffer.concat([
+    Buffer.from([4]), // uncompressed point
+    toBn(jwk.x).toArrayLike(Buffer, 'be', byteLen),
+    toBn(jwk.y).toArrayLike(Buffer, 'be', byteLen)
+  ], 1 + byteLen * 2)
+}
+
+// Unmarshal converts a point, serialized by Marshal, into an jwk encoded key
+function unmarshalPublicKey (curve, key) {
+  const byteLen = curveLengths[curve]
+
+  if (!key.slice(0, 1).equals(Buffer.from([4]))) {
+    throw new Error('Invalid key format')
+  }
+  const x = new BN(key.slice(1, byteLen + 1))
+  const y = new BN(key.slice(1 + byteLen))
+
+  return {
+    kty: 'EC',
+    crv: curve,
+    x: toBase64(x, byteLen),
+    y: toBase64(y, byteLen),
+    ext: true
+  }
+}
+
+function unmarshalPrivateKey (curve, key) {
+  const result = unmarshalPublicKey(curve, key.public)
+  result.d = toBase64(new BN(key.private))
+  return result
+}

src/keys/ecdh.js

@@ -0,0 +1,28 @@
+'use strict'
+
+const crypto = require('crypto')
+
+const curves = {
+  'P-256': 'prime256v1',
+  'P-384': 'secp384r1',
+  'P-521': 'secp521r1'
+}
+
+exports.generateEphmeralKeyPair = async function (curve) { // eslint-disable-line require-await
+  if (!curves[curve]) {
+    throw new Error(`Unkown curve: ${curve}`)
+  }
+  const ecdh = crypto.createECDH(curves[curve])
+  ecdh.generateKeys()
+
+  return {
+    key: ecdh.getPublicKey(),
+    async genSharedKey (theirPub, forcePrivate) { // eslint-disable-line require-await
+      if (forcePrivate) {
+        ecdh.setPrivateKey(forcePrivate.private)
+      }
+
+      return ecdh.computeSecret(theirPub)
+    }
+  }
+}

src/keys/ed25519-class.js

@@ -0,0 +1,132 @@
+'use strict'
+
+const multihashing = require('multihashing-async')
+const protobuf = require('protons')
+const bs58 = require('bs58')
+
+const crypto = require('./ed25519')
+const pbm = protobuf(require('./keys.proto'))
+
+class Ed25519PublicKey {
+  constructor (key) {
+    this._key = ensureKey(key, crypto.publicKeyLength)
+  }
+
+  async verify (data, sig) { // eslint-disable-line require-await
+    return crypto.hashAndVerify(this._key, sig, data)
+  }
+
+  marshal () {
+    return Buffer.from(this._key)
+  }
+
+  get bytes () {
+    return pbm.PublicKey.encode({
+      Type: pbm.KeyType.Ed25519,
+      Data: this.marshal()
+    })
+  }
+
+  equals (key) {
+    return this.bytes.equals(key.bytes)
+  }
+
+  async hash () { // eslint-disable-line require-await
+    return multihashing(this.bytes, 'sha2-256')
+  }
+}
+
+class Ed25519PrivateKey {
+  // key       - 64 byte Uint8Array or Buffer containing private key
+  // publicKey - 32 byte Uint8Array or Buffer containing public key
+  constructor (key, publicKey) {
+    this._key = ensureKey(key, crypto.privateKeyLength)
+    this._publicKey = ensureKey(publicKey, crypto.publicKeyLength)
+  }
+
+  async sign (message) { // eslint-disable-line require-await
+    return crypto.hashAndSign(this._key, message)
+  }
+
+  get public () {
+    if (!this._publicKey) {
+      throw new Error('public key not provided')
+    }
+
+    return new Ed25519PublicKey(this._publicKey)
+  }
+
+  marshal () {
+    return Buffer.concat([Buffer.from(this._key), Buffer.from(this._publicKey)])
+  }
+
+  get bytes () {
+    return pbm.PrivateKey.encode({
+      Type: pbm.KeyType.Ed25519,
+      Data: this.marshal()
+    })
+  }
+
+  equals (key) {
+    return this.bytes.equals(key.bytes)
+  }
+
+  async hash () { // eslint-disable-line require-await
+    return multihashing(this.bytes, 'sha2-256')
+  }
+
+  /**
+   * Gets the ID of the key.
+   *
+   * The key id is the base58 encoding of the SHA-256 multihash of its public key.
+   * The public key is a protobuf encoding containing a type and the DER encoding
+   * of the PKCS SubjectPublicKeyInfo.
+   *
+   * @returns {Promise<String>}
+   */
+  async id () {
+    const hash = await this.public.hash()
+    return bs58.encode(hash)
+  }
+}
+
+function unmarshalEd25519PrivateKey (bytes) {
+  bytes = ensureKey(bytes, crypto.privateKeyLength + crypto.publicKeyLength)
+  const privateKeyBytes = bytes.slice(0, crypto.privateKeyLength)
+  const publicKeyBytes = bytes.slice(crypto.privateKeyLength, bytes.length)
+  return new Ed25519PrivateKey(privateKeyBytes, publicKeyBytes)
+}
+
+function unmarshalEd25519PublicKey (bytes) {
+  bytes = ensureKey(bytes, crypto.publicKeyLength)
+  return new Ed25519PublicKey(bytes)
+}
+
+async function generateKeyPair () {
+  const { secretKey, publicKey } = await crypto.generateKey()
+  return new Ed25519PrivateKey(secretKey, publicKey)
+}
+
+async function generateKeyPairFromSeed (seed) {
+  const { secretKey, publicKey } = await crypto.generateKeyFromSeed(seed)
+  return new Ed25519PrivateKey(secretKey, publicKey)
+}
+
+function ensureKey (key, length) {
+  if (Buffer.isBuffer(key)) {
+    key = new Uint8Array(key)
+  }
+  if (!(key instanceof Uint8Array) || key.length !== length) {
+    throw new Error('Key must be a Uint8Array or Buffer of length ' + length)
+  }
+  return key
+}
+
+module.exports = {
+  Ed25519PublicKey,
+  Ed25519PrivateKey,
+  unmarshalEd25519PrivateKey,
+  unmarshalEd25519PublicKey,
+  generateKeyPair,
+  generateKeyPairFromSeed
+}

src/keys/ed25519.js

@@ -1,142 +1,23 @@
 'use strict'
 
-const multihashing = require('multihashing-async')
-const protobuf = require('protocol-buffers')
-const Buffer = require('safe-buffer').Buffer
+const nacl = require('tweetnacl')
 
-const crypto = require('../crypto').ed25519
-const pbm = protobuf(require('../crypto.proto'))
+exports.publicKeyLength = nacl.sign.publicKeyLength
+exports.privateKeyLength = nacl.sign.secretKeyLength
 
-class Ed25519PublicKey {
-  constructor (key) {
-    this._key = ensureKey(key, crypto.publicKeyLength)
-  }
-
-  verify (data, sig, callback) {
-    ensure(callback)
-    crypto.hashAndVerify(this._key, sig, data, callback)
-  }
-
-  marshal () {
-    return Buffer.from(this._key)
-  }
-
-  get bytes () {
-    return pbm.PublicKey.encode({
-      Type: pbm.KeyType.Ed25519,
-      Data: this.marshal()
-    })
-  }
-
-  equals (key) {
-    return this.bytes.equals(key.bytes)
-  }
-
-  hash (callback) {
-    ensure(callback)
-    multihashing(this.bytes, 'sha2-256', callback)
-  }
+exports.generateKey = async function () { // eslint-disable-line require-await
+  return nacl.sign.keyPair()
 }
 
-class Ed25519PrivateKey {
-  // key       - 64 byte Uint8Array or Buffer containing private key
-  // publicKey - 32 byte Uint8Array or Buffer containing public key
-  constructor (key, publicKey) {
-    this._key = ensureKey(key, crypto.privateKeyLength)
-    this._publicKey = ensureKey(publicKey, crypto.publicKeyLength)
-  }
-
-  sign (message, callback) {
-    ensure(callback)
-    crypto.hashAndSign(this._key, message, callback)
-  }
-
-  get public () {
-    if (!this._publicKey) {
-      throw new Error('public key not provided')
-    }
-
-    return new Ed25519PublicKey(this._publicKey)
-  }
-
-  marshal () {
-    return Buffer.concat([Buffer.from(this._key), Buffer.from(this._publicKey)])
-  }
-
-  get bytes () {
-    return pbm.PrivateKey.encode({
-      Type: pbm.KeyType.Ed25519,
-      Data: this.marshal()
-    })
-  }
-
-  equals (key) {
-    return this.bytes.equals(key.bytes)
-  }
-
-  hash (callback) {
-    ensure(callback)
-    multihashing(this.bytes, 'sha2-256', callback)
-  }
+// seed should be a 32 byte uint8array
+exports.generateKeyFromSeed = async function (seed) { // eslint-disable-line require-await
+  return nacl.sign.keyPair.fromSeed(seed)
 }
 
-function unmarshalEd25519PrivateKey (bytes, callback) {
-  try {
-    bytes = ensureKey(bytes, crypto.privateKeyLength + crypto.publicKeyLength)
-  } catch (err) {
-    return callback(err)
-  }
-  const privateKeyBytes = bytes.slice(0, crypto.privateKeyLength)
-  const publicKeyBytes = bytes.slice(crypto.privateKeyLength, bytes.length)
-  callback(null, new Ed25519PrivateKey(privateKeyBytes, publicKeyBytes))
+exports.hashAndSign = async function (key, msg) { // eslint-disable-line require-await
+  return Buffer.from(nacl.sign.detached(msg, key))
 }
 
-function unmarshalEd25519PublicKey (bytes) {
-  bytes = ensureKey(bytes, crypto.publicKeyLength)
-  return new Ed25519PublicKey(bytes)
-}
-
-function generateKeyPair (_bits, cb) {
-  if (cb === undefined && typeof _bits === 'function') {
-    cb = _bits
-  }
-
-  crypto.generateKey((err, keys) => {
-    if (err) {
-      return cb(err)
-    }
-    let privkey
-    try {
-      privkey = new Ed25519PrivateKey(keys.secretKey, keys.publicKey)
-    } catch (err) {
-      cb(err)
-      return
-    }
-
-    cb(null, privkey)
-  })
-}
-
-function ensure (cb) {
-  if (typeof cb !== 'function') {
-    throw new Error('callback is required')
-  }
-}
-
-function ensureKey (key, length) {
-  if (Buffer.isBuffer(key)) {
-    key = new Uint8Array(key)
-  }
-  if (!(key instanceof Uint8Array) || key.length !== length) {
-    throw new Error('Key must be a Uint8Array or Buffer of length ' + length)
-  }
-  return key
-}
-
-module.exports = {
-  Ed25519PublicKey,
-  Ed25519PrivateKey,
-  unmarshalEd25519PrivateKey,
-  unmarshalEd25519PublicKey,
-  generateKeyPair
+exports.hashAndVerify = async function (key, sig, msg) { // eslint-disable-line require-await
+  return nacl.sign.detached.verify(msg, sig, key)
 }

src/keys/ephemeral-keys.js

@@ -1,11 +1,9 @@
 'use strict'
 
-const crypto = require('./crypto')
+const ecdh = require('./ecdh')
 
 // Generates an ephemeral public key and returns a function that will compute
 // the shared secret key.
 //
 // Focuses only on ECDH now, but can be made more general in the future.
-module.exports = (curve, callback) => {
-  crypto.ecdh.generateEphmeralKeyPair(curve, callback)
-}
+module.exports = async (curve) => ecdh.generateEphmeralKeyPair(curve) // eslint-disable-line require-await

src/keys/index.js

@@ -1,6 +1,125 @@
 'use strict'
 
-module.exports = {
-  rsa: require('./rsa'),
-  ed25519: require('./ed25519')
+const protobuf = require('protons')
+const keysPBM = protobuf(require('./keys.proto'))
+require('node-forge/lib/asn1')
+require('node-forge/lib/rsa')
+require('node-forge/lib/pbe')
+const forge = require('node-forge/lib/forge')
+
+exports = module.exports
+
+const supportedKeys = {
+  rsa: require('./rsa-class'),
+  ed25519: require('./ed25519-class'),
+  secp256k1: require('libp2p-crypto-secp256k1')(keysPBM, require('../random-bytes'))
+}
+
+exports.supportedKeys = supportedKeys
+exports.keysPBM = keysPBM
+
+function isValidKeyType (keyType) {
+  const key = supportedKeys[keyType.toLowerCase()]
+  return key !== undefined
+}
+
+exports.keyStretcher = require('./key-stretcher')
+exports.generateEphemeralKeyPair = require('./ephemeral-keys')
+
+// Generates a keypair of the given type and bitsize
+exports.generateKeyPair = async (type, bits) => { // eslint-disable-line require-await
+  let key = supportedKeys[type.toLowerCase()]
+
+  if (!key) {
+    throw new Error('invalid or unsupported key type')
+  }
+
+  return key.generateKeyPair(bits)
+}
+
+// Generates a keypair of the given type and bitsize
+// seed is a 32 byte uint8array
+exports.generateKeyPairFromSeed = async (type, seed, bits) => { // eslint-disable-line require-await
+  let key = supportedKeys[type.toLowerCase()]
+  if (!key) {
+    throw new Error('invalid or unsupported key type')
+  }
+  if (type.toLowerCase() !== 'ed25519') {
+    throw new Error('Seed key derivation is unimplemented for RSA or secp256k1')
+  }
+  return key.generateKeyPairFromSeed(seed, bits)
+}
+
+// Converts a protobuf serialized public key into its
+// representative object
+exports.unmarshalPublicKey = (buf) => {
+  const decoded = keysPBM.PublicKey.decode(buf)
+  const data = decoded.Data
+
+  switch (decoded.Type) {
+    case keysPBM.KeyType.RSA:
+      return supportedKeys.rsa.unmarshalRsaPublicKey(data)
+    case keysPBM.KeyType.Ed25519:
+      return supportedKeys.ed25519.unmarshalEd25519PublicKey(data)
+    case keysPBM.KeyType.Secp256k1:
+      if (supportedKeys.secp256k1) {
+        return supportedKeys.secp256k1.unmarshalSecp256k1PublicKey(data)
+      } else {
+        throw new Error('secp256k1 support requires libp2p-crypto-secp256k1 package')
+      }
+    default:
+      throw new Error('invalid or unsupported key type')
+  }
+}
+
+// Converts a public key object into a protobuf serialized public key
+exports.marshalPublicKey = (key, type) => {
+  type = (type || 'rsa').toLowerCase()
+  if (!isValidKeyType(type)) {
+    throw new Error('invalid or unsupported key type')
+  }
+
+  return key.bytes
+}
+
+// Converts a protobuf serialized private key into its
+// representative object
+exports.unmarshalPrivateKey = async (buf) => { // eslint-disable-line require-await
+  const decoded = keysPBM.PrivateKey.decode(buf)
+  const data = decoded.Data
+
+  switch (decoded.Type) {
+    case keysPBM.KeyType.RSA:
+      return supportedKeys.rsa.unmarshalRsaPrivateKey(data)
+    case keysPBM.KeyType.Ed25519:
+      return supportedKeys.ed25519.unmarshalEd25519PrivateKey(data)
+    case keysPBM.KeyType.Secp256k1:
+      if (supportedKeys.secp256k1) {
+        return supportedKeys.secp256k1.unmarshalSecp256k1PrivateKey(data)
+      } else {
+        throw new Error('secp256k1 support requires libp2p-crypto-secp256k1 package')
+      }
+    default:
+      throw new Error('invalid or unsupported key type')
+  }
+}
+
+// Converts a private key object into a protobuf serialized private key
+exports.marshalPrivateKey = (key, type) => {
+  type = (type || 'rsa').toLowerCase()
+  if (!isValidKeyType(type)) {
+    throw new Error('invalid or unsupported key type')
+  }
+
+  return key.bytes
+}
+
+exports.import = async (pem, password) => { // eslint-disable-line require-await
+  const key = forge.pki.decryptRsaPrivateKey(pem, password)
+  if (key === null) {
+    throw new Error('Cannot read the key, most likely the password is wrong or not a RSA key')
+  }
+  let der = forge.asn1.toDer(forge.pki.privateKeyToAsn1(key))
+  der = Buffer.from(der.getBytes(), 'binary')
+  return supportedKeys.rsa.unmarshalRsaPrivateKey(der)
 }

src/keys/key-stretcher.js

@@ -0,0 +1,73 @@
+'use strict'
+
+const hmac = require('../hmac')
+
+const cipherMap = {
+  'AES-128': {
+    ivSize: 16,
+    keySize: 16
+  },
+  'AES-256': {
+    ivSize: 16,
+    keySize: 32
+  },
+  Blowfish: {
+    ivSize: 8,
+    cipherKeySize: 32
+  }
+}
+
+// Generates a set of keys for each party by stretching the shared key.
+// (myIV, theirIV, myCipherKey, theirCipherKey, myMACKey, theirMACKey)
+module.exports = async (cipherType, hash, secret) => {
+  const cipher = cipherMap[cipherType]
+
+  if (!cipher) {
+    throw new Error('unkown cipherType passed')
+  }
+
+  if (!hash) {
+    throw new Error('unkown hashType passed')
+  }
+
+  const cipherKeySize = cipher.keySize
+  const ivSize = cipher.ivSize
+  const hmacKeySize = 20
+  const seed = Buffer.from('key expansion')
+  const resultLength = 2 * (ivSize + cipherKeySize + hmacKeySize)
+
+  const m = await hmac.create(hash, secret)
+  let a = await m.digest(seed)
+
+  let result = []
+  let j = 0
+
+  while (j < resultLength) {
+    const b = await m.digest(Buffer.concat([a, seed]))
+    let todo = b.length
+
+    if (j + todo > resultLength) {
+      todo = resultLength - j
+    }
+
+    result.push(b)
+    j += todo
+    a = await m.digest(a)
+  }
+
+  const half = resultLength / 2
+  const resultBuffer = Buffer.concat(result)
+  const r1 = resultBuffer.slice(0, half)
+  const r2 = resultBuffer.slice(half, resultLength)
+
+  const createKey = (res) => ({
+    iv: res.slice(0, ivSize),
+    cipherKey: res.slice(ivSize, ivSize + cipherKeySize),
+    macKey: res.slice(ivSize + cipherKeySize)
+  })
+
+  return {
+    k1: createKey(r1),
+    k2: createKey(r2)
+  }
+}

src/keys/keys.proto.js

@@ -3,13 +3,12 @@
 module.exports = `enum KeyType {
   RSA = 0;
   Ed25519 = 1;
+  Secp256k1 = 2;
 }
-
 message PublicKey {
   required KeyType Type = 1;
   required bytes Data = 2;
 }
-
 message PrivateKey {
   required KeyType Type = 1;
   required bytes Data = 2;

src/keys/rsa-browser.js

@@ -0,0 +1,122 @@
+'use strict'
+
+const webcrypto = require('../webcrypto.js')
+const randomBytes = require('../random-bytes')
+
+exports.utils = require('./rsa-utils')
+
+exports.generateKey = async function (bits) {
+  const pair = await webcrypto.subtle.generateKey(
+    {
+      name: 'RSASSA-PKCS1-v1_5',
+      modulusLength: bits,
+      publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
+      hash: { name: 'SHA-256' }
+    },
+    true,
+    ['sign', 'verify']
+  )
+
+  const keys = await exportKey(pair)
+
+  return {
+    privateKey: keys[0],
+    publicKey: keys[1]
+  }
+}
+
+// Takes a jwk key
+exports.unmarshalPrivateKey = async function (key) {
+  const privateKey = await webcrypto.subtle.importKey(
+    'jwk',
+    key,
+    {
+      name: 'RSASSA-PKCS1-v1_5',
+      hash: { name: 'SHA-256' }
+    },
+    true,
+    ['sign']
+  )
+
+  const pair = [
+    privateKey,
+    await derivePublicFromPrivate(key)
+  ]
+
+  const keys = await exportKey({
+    privateKey: pair[0],
+    publicKey: pair[1]
+  })
+
+  return {
+    privateKey: keys[0],
+    publicKey: keys[1]
+  }
+}
+
+exports.getRandomValues = randomBytes
+
+exports.hashAndSign = async function (key, msg) {
+  const privateKey = await webcrypto.subtle.importKey(
+    'jwk',
+    key,
+    {
+      name: 'RSASSA-PKCS1-v1_5',
+      hash: { name: 'SHA-256' }
+    },
+    false,
+    ['sign']
+  )
+
+  const sig = await webcrypto.subtle.sign(
+    { name: 'RSASSA-PKCS1-v1_5' },
+    privateKey,
+    Uint8Array.from(msg)
+  )
+
+  return Buffer.from(sig)
+}
+
+exports.hashAndVerify = async function (key, sig, msg) {
+  const publicKey = await webcrypto.subtle.importKey(
+    'jwk',
+    key,
+    {
+      name: 'RSASSA-PKCS1-v1_5',
+      hash: { name: 'SHA-256' }
+    },
+    false,
+    ['verify']
+  )
+
+  return webcrypto.subtle.verify(
+    { name: 'RSASSA-PKCS1-v1_5' },
+    publicKey,
+    sig,
+    msg
+  )
+}
+
+function exportKey (pair) {
+  return Promise.all([
+    webcrypto.subtle.exportKey('jwk', pair.privateKey),
+    webcrypto.subtle.exportKey('jwk', pair.publicKey)
+  ])
+}
+
+function derivePublicFromPrivate (jwKey) {
+  return webcrypto.subtle.importKey(
+    'jwk',
+    {
+      kty: jwKey.kty,
+      n: jwKey.n,
+      e: jwKey.e
+    },
+    {
+      name: 'RSASSA-PKCS1-v1_5',
+      hash: { name: 'SHA-256' }
+    },
+    true,
+    ['verify']
+  )
+}

src/keys/rsa-class.js

@@ -0,0 +1,161 @@
+'use strict'
+
+const multihashing = require('multihashing-async')
+const protobuf = require('protons')
+const bs58 = require('bs58')
+
+const crypto = require('./rsa')
+const pbm = protobuf(require('./keys.proto'))
+require('node-forge/lib/sha512')
+require('node-forge/lib/pbe')
+const forge = require('node-forge/lib/forge')
+
+class RsaPublicKey {
+  constructor (key) {
+    this._key = key
+  }
+
+  async verify (data, sig) { // eslint-disable-line require-await
+    return crypto.hashAndVerify(this._key, sig, data)
+  }
+
+  marshal () {
+    return crypto.utils.jwkToPkix(this._key)
+  }
+
+  get bytes () {
+    return pbm.PublicKey.encode({
+      Type: pbm.KeyType.RSA,
+      Data: this.marshal()
+    })
+  }
+
+  encrypt (bytes) {
+    return this._key.encrypt(bytes, 'RSAES-PKCS1-V1_5')
+  }
+
+  equals (key) {
+    return this.bytes.equals(key.bytes)
+  }
+
+  async hash () { // eslint-disable-line require-await
+    return multihashing(this.bytes, 'sha2-256')
+  }
+}
+
+class RsaPrivateKey {
+  // key       - Object of the jwk format
+  // publicKey - Buffer of the spki format
+  constructor (key, publicKey) {
+    this._key = key
+    this._publicKey = publicKey
+  }
+
+  genSecret () {
+    return crypto.getRandomValues(16)
+  }
+
+  async sign (message) { // eslint-disable-line require-await
+    return crypto.hashAndSign(this._key, message)
+  }
+
+  get public () {
+    if (!this._publicKey) {
+      throw new Error('public key not provided')
+    }
+
+    return new RsaPublicKey(this._publicKey)
+  }
+
+  marshal () {
+    return crypto.utils.jwkToPkcs1(this._key)
+  }
+
+  get bytes () {
+    return pbm.PrivateKey.encode({
+      Type: pbm.KeyType.RSA,
+      Data: this.marshal()
+    })
+  }
+
+  equals (key) {
+    return this.bytes.equals(key.bytes)
+  }
+
+  async hash () { // eslint-disable-line require-await
+    return multihashing(this.bytes, 'sha2-256')
+  }
+
+  /**
+   * Gets the ID of the key.
+   *
+   * The key id is the base58 encoding of the SHA-256 multihash of its public key.
+   * The public key is a protobuf encoding containing a type and the DER encoding
+   * of the PKCS SubjectPublicKeyInfo.
+   *
+   * @returns {Promise<String>}
+   */
+  async id () {
+    const hash = await this.public.hash()
+    return bs58.encode(hash)
+  }
+
+  /**
+   * Exports the key into a password protected PEM format
+   *
+   * @param {string} password - The password to read the encrypted PEM
+   * @param {string} [format] - Defaults to 'pkcs-8'.
+   * @returns {KeyInfo}
+   */
+  async export (password, format = 'pkcs-8') { // eslint-disable-line require-await
+    let pem = null
+
+    const buffer = new forge.util.ByteBuffer(this.marshal())
+    const asn1 = forge.asn1.fromDer(buffer)
+    const privateKey = forge.pki.privateKeyFromAsn1(asn1)
+
+    if (format === 'pkcs-8') {
+      const options = {
+        algorithm: 'aes256',
+        count: 10000,
+        saltSize: 128 / 8,
+        prfAlgorithm: 'sha512'
+      }
+      pem = forge.pki.encryptRsaPrivateKey(privateKey, password, options)
+    } else {
+      throw new Error(`Unknown export format '${format}'`)
+    }
+
+    return pem
+  }
+}
+
+async function unmarshalRsaPrivateKey (bytes) {
+  const jwk = crypto.utils.pkcs1ToJwk(bytes)
+  const keys = await crypto.unmarshalPrivateKey(jwk)
+  return new RsaPrivateKey(keys.privateKey, keys.publicKey)
+}
+
+function unmarshalRsaPublicKey (bytes) {
+  const jwk = crypto.utils.pkixToJwk(bytes)
+  return new RsaPublicKey(jwk)
+}
+
+async function fromJwk (jwk) {
+  const keys = await crypto.unmarshalPrivateKey(jwk)
+  return new RsaPrivateKey(keys.privateKey, keys.publicKey)
+}
+
+async function generateKeyPair (bits) {
+  const keys = await crypto.generateKey(bits)
+  return new RsaPrivateKey(keys.privateKey, keys.publicKey)
+}
+
+module.exports = {
+  RsaPublicKey,
+  RsaPrivateKey,
+  unmarshalRsaPublicKey,
+  unmarshalRsaPrivateKey,
+  generateKeyPair,
+  fromJwk
+}

src/keys/rsa-utils.js

@@ -2,7 +2,7 @@
 
 const asn1 = require('asn1.js')
 
-const util = require('./util')
+const util = require('./../util')
 const toBase64 = util.toBase64
 const toBn = util.toBn
 

src/keys/rsa.js

@@ -1,133 +1,69 @@
 'use strict'
 
-const multihashing = require('multihashing-async')
-const protobuf = require('protocol-buffers')
+const crypto = require('crypto')
+const randomBytes = require('../random-bytes')
 
-const crypto = require('../crypto').rsa
-const pbm = protobuf(require('../crypto.proto'))
-
-class RsaPublicKey {
-  constructor (key) {
-    this._key = key
+let keypair
+try {
+  if (process.env.LP2P_FORCE_CRYPTO_LIB === 'keypair') {
+    throw new Error('Force keypair usage')
   }
 
-  verify (data, sig, callback) {
-    ensure(callback)
-    crypto.hashAndVerify(this._key, sig, data, callback)
-  }
-
-  marshal () {
-    return crypto.utils.jwkToPkix(this._key)
-  }
-
-  get bytes () {
-    return pbm.PublicKey.encode({
-      Type: pbm.KeyType.RSA,
-      Data: this.marshal()
-    })
-  }
-
-  encrypt (bytes) {
-    return this._key.encrypt(bytes, 'RSAES-PKCS1-V1_5')
-  }
-
-  equals (key) {
-    return this.bytes.equals(key.bytes)
-  }
-
-  hash (callback) {
-    ensure(callback)
-    multihashing(this.bytes, 'sha2-256', callback)
-  }
-}
-
-class RsaPrivateKey {
-  // key       - Object of the jwk format
-  // publicKey - Buffer of the spki format
-  constructor (key, publicKey) {
-    this._key = key
-    this._publicKey = publicKey
-  }
-
-  genSecret () {
-    return crypto.getRandomValues(new Uint8Array(16))
-  }
-
-  sign (message, callback) {
-    ensure(callback)
-    crypto.hashAndSign(this._key, message, callback)
-  }
-
-  get public () {
-    if (!this._publicKey) {
-      throw new Error('public key not provided')
+  const ursa = require('ursa-optional') // throws if not compiled
+  keypair = ({ bits }) => {
+    const key = ursa.generatePrivateKey(bits)
+    return {
+      private: key.toPrivatePem(),
+      public: key.toPublicPem()
     }
-
-    return new RsaPublicKey(this._publicKey)
+  }
+} catch (e) {
+  if (process.env.LP2P_FORCE_CRYPTO_LIB === 'ursa') {
+    throw e
   }
 
-  decrypt (msg, callback) {
-    crypto.decrypt(this._key, msg, callback)
-  }
+  keypair = require('keypair')
+}
+const pemToJwk = require('pem-jwk').pem2jwk
+const jwkToPem = require('pem-jwk').jwk2pem
 
-  marshal () {
-    return crypto.utils.jwkToPkcs1(this._key)
-  }
+exports.utils = require('./rsa-utils')
 
-  get bytes () {
-    return pbm.PrivateKey.encode({
-      Type: pbm.KeyType.RSA,
-      Data: this.marshal()
-    })
-  }
-
-  equals (key) {
-    return this.bytes.equals(key.bytes)
-  }
-
-  hash (callback) {
-    ensure(callback)
-    multihashing(this.bytes, 'sha2-256', callback)
+exports.generateKey = async function (bits) { // eslint-disable-line require-await
+  const key = keypair({ bits })
+  return {
+    privateKey: pemToJwk(key.private),
+    publicKey: pemToJwk(key.public)
   }
 }
 
-function unmarshalRsaPrivateKey (bytes, callback) {
-  const jwk = crypto.utils.pkcs1ToJwk(bytes)
-  crypto.unmarshalPrivateKey(jwk, (err, keys) => {
-    if (err) {
-      return callback(err)
+// Takes a jwk key
+exports.unmarshalPrivateKey = async function (key) { // eslint-disable-line require-await
+  if (!key) {
+    throw new Error('Key is invalid')
+  }
+  return {
+    privateKey: key,
+    publicKey: {
+      kty: key.kty,
+      n: key.n,
+      e: key.e
     }
-
-    callback(null, new RsaPrivateKey(keys.privateKey, keys.publicKey))
-  })
-}
-
-function unmarshalRsaPublicKey (bytes) {
-  const jwk = crypto.utils.pkixToJwk(bytes)
-
-  return new RsaPublicKey(jwk)
-}
-
-function generateKeyPair (bits, cb) {
-  crypto.generateKey(bits, (err, keys) => {
-    if (err) {
-      return cb(err)
-    }
-
-    cb(null, new RsaPrivateKey(keys.privateKey, keys.publicKey))
-  })
-}
-
-function ensure (cb) {
-  if (typeof cb !== 'function') {
-    throw new Error('callback is required')
   }
 }
 
-module.exports = {
-  RsaPublicKey,
-  RsaPrivateKey,
-  unmarshalRsaPublicKey,
-  unmarshalRsaPrivateKey,
-  generateKeyPair
+exports.getRandomValues = randomBytes
+
+exports.hashAndSign = async function (key, msg) { // eslint-disable-line require-await
+  const sign = crypto.createSign('RSA-SHA256')
+  sign.update(msg)
+  const pem = jwkToPem(key)
+  return sign.sign(pem)
+}
+
+exports.hashAndVerify = async function (key, sig, msg) { // eslint-disable-line require-await
+  const verify = crypto.createVerify('RSA-SHA256')
+  verify.update(msg)
+  const pem = jwkToPem(key)
+  return verify.verify(pem, sig)
 }

src/pbkdf2.js

@@ -0,0 +1,43 @@
+'use strict'
+
+const forgePbkdf2 = require('node-forge/lib/pbkdf2')
+const forgeUtil = require('node-forge/lib/util')
+
+/**
+ * Maps an IPFS hash name to its node-forge equivalent.
+ *
+ * See https://github.com/multiformats/multihash/blob/master/hashtable.csv
+ *
+ * @private
+ */
+const hashName = {
+  sha1: 'sha1',
+  'sha2-256': 'sha256',
+  'sha2-512': 'sha512'
+}
+
+/**
+ * Computes the Password-Based Key Derivation Function 2.
+ *
+ * @param {string} password
+ * @param {string} salt
+ * @param {number} iterations
+ * @param {number} keySize (in bytes)
+ * @param {string} hash - The hash name ('sha1', 'sha2-512, ...)
+ * @returns {string} - A new password
+ */
+function pbkdf2 (password, salt, iterations, keySize, hash) {
+  const hasher = hashName[hash]
+  if (!hasher) {
+    throw new Error(`Hash '${hash}' is unknown or not supported`)
+  }
+  const dek = forgePbkdf2(
+    password,
+    salt,
+    iterations,
+    keySize,
+    hasher)
+  return forgeUtil.encode64(dek)
+}
+
+module.exports = pbkdf2

src/random-bytes.js

@@ -0,0 +1,9 @@
+'use strict'
+const randomBytes = require('iso-random-stream/src/random')
+
+module.exports = function (number) {
+  if (!number || typeof number !== 'number') {
+    throw new Error('first argument must be a Number bigger than 0')
+  }
+  return randomBytes(number)
+}

src/util.js

@@ -1,17 +1,17 @@
 'use strict'
 
 const BN = require('asn1.js').bignum
-const Buffer = require('safe-buffer').Buffer
 
 // Convert a BN.js instance to a base64 encoded string without padding
 // Adapted from https://tools.ietf.org/html/draft-ietf-jose-json-web-signature-41#appendix-C
-exports.toBase64 = function toBase64 (bn) {
-  let s = bn.toArrayLike(Buffer, 'be').toString('base64')
+exports.toBase64 = function toBase64 (bn, len) {
+  // if len is defined then the bytes are leading-0 padded to the length
+  let s = bn.toArrayLike(Buffer, 'be', len).toString('base64')
 
   return s
     .replace(/(=*)$/, '') // Remove any trailing '='s
-    .replace(/\+/g, '-')  // 62nd char of encoding
-    .replace(/\//g, '_')  // 63rd char of encoding
+    .replace(/\+/g, '-') // 62nd char of encoding
+    .replace(/\//g, '_') // 63rd char of encoding
 }
 
 // Convert a base64 encoded string to a BN.js instance

src/webcrypto.js

@@ -0,0 +1,5 @@
+/* global self */
+
+'use strict'
+
+module.exports = self.crypto || self.msCrypto

test/aes.spec.js

@@ -1,116 +0,0 @@
-/* eslint max-nested-callbacks: ["error", 8] */
-/* eslint-env mocha */
-'use strict'
-
-const expect = require('chai').expect
-const series = require('async/series')
-const Buffer = require('safe-buffer').Buffer
-
-const crypto = require('../src')
-const fixtures = require('./fixtures/aes')
-const goFixtures = require('./fixtures/go-aes')
-
-const bytes = {
-  16: 'AES-128',
-  32: 'AES-256'
-}
-
-describe('AES-CTR', () => {
-  Object.keys(bytes).forEach((byte) => {
-    it(`${bytes[byte]} - encrypt and decrypt`, (done) => {
-      const key = Buffer.alloc(parseInt(byte, 10))
-      key.fill(5)
-
-      const iv = Buffer.alloc(16)
-      iv.fill(1)
-
-      crypto.aes.create(key, iv, (err, cipher) => {
-        expect(err).to.not.exist
-
-        series([
-          encryptAndDecrypt(cipher),
-          encryptAndDecrypt(cipher),
-          encryptAndDecrypt(cipher),
-          encryptAndDecrypt(cipher),
-          encryptAndDecrypt(cipher)
-        ], done)
-      })
-    })
-  })
-  Object.keys(bytes).forEach((byte) => {
-    it(`${bytes[byte]} - fixed - encrypt and decrypt`, (done) => {
-      const key = Buffer.alloc(parseInt(byte, 10))
-      key.fill(5)
-
-      const iv = Buffer.alloc(16)
-      iv.fill(1)
-
-      crypto.aes.create(key, iv, (err, cipher) => {
-        expect(err).to.not.exist
-
-        series(fixtures[byte].inputs.map((rawIn, i) => (cb) => {
-          const input = Buffer.from(rawIn)
-          const output = Buffer.from(fixtures[byte].outputs[i])
-          cipher.encrypt(input, (err, res) => {
-            expect(err).to.not.exist
-            expect(res).to.have.length(output.length)
-            expect(res).to.be.eql(output)
-            cipher.decrypt(res, (err, res) => {
-              expect(err).to.not.exist
-              expect(res).to.be.eql(input)
-              cb()
-            })
-          })
-        }), done)
-      })
-    })
-  })
-
-  Object.keys(bytes).forEach((byte) => {
-    if (!goFixtures[byte]) {
-      return
-    }
-
-    it(`${bytes[byte]} - go interop - encrypt and decrypt`, (done) => {
-      const key = Buffer.alloc(parseInt(byte, 10))
-      key.fill(5)
-
-      const iv = Buffer.alloc(16)
-      iv.fill(1)
-
-      crypto.aes.create(key, iv, (err, cipher) => {
-        expect(err).to.not.exist
-
-        series(goFixtures[byte].inputs.map((rawIn, i) => (cb) => {
-          const input = Buffer.from(rawIn)
-          const output = Buffer.from(goFixtures[byte].outputs[i])
-          cipher.encrypt(input, (err, res) => {
-            expect(err).to.not.exist
-            expect(res).to.have.length(output.length)
-            expect(res).to.be.eql(output)
-            cipher.decrypt(res, (err, res) => {
-              expect(err).to.not.exist
-              expect(res).to.be.eql(input)
-              cb()
-            })
-          })
-        }), done)
-      })
-    })
-  })
-})
-
-function encryptAndDecrypt (cipher) {
-  const data = Buffer.alloc(100)
-  data.fill(Math.ceil(Math.random() * 100))
-  return (cb) => {
-    cipher.encrypt(data, (err, res) => {
-      expect(err).to.not.exist
-      cipher.decrypt(res, (err, res) => {
-        expect(err).to.not.exist
-        expect(res).to.be.eql(data)
-        cb()
-      })
-    })
-  }
-}

test/aes/aes.spec.js

@@ -0,0 +1,97 @@
+/* eslint max-nested-callbacks: ["error", 8] */
+/* eslint-env mocha */
+'use strict'
+
+const chai = require('chai')
+const dirtyChai = require('dirty-chai')
+const expect = chai.expect
+chai.use(dirtyChai)
+
+const crypto = require('../../src')
+const fixtures = require('./../fixtures/aes')
+const goFixtures = require('./../fixtures/go-aes')
+
+const bytes = {
+  16: 'AES-128',
+  32: 'AES-256'
+}
+
+describe('AES-CTR', () => {
+  Object.keys(bytes).forEach((byte) => {
+    it(`${bytes[byte]} - encrypt and decrypt`, async () => {
+      const key = Buffer.alloc(parseInt(byte, 10))
+      key.fill(5)
+
+      const iv = Buffer.alloc(16)
+      iv.fill(1)
+
+      const cipher = await crypto.aes.create(key, iv)
+
+      await encryptAndDecrypt(cipher)
+      await encryptAndDecrypt(cipher)
+      await encryptAndDecrypt(cipher)
+      await encryptAndDecrypt(cipher)
+      await encryptAndDecrypt(cipher)
+    })
+  })
+
+  Object.keys(bytes).forEach((byte) => {
+    it(`${bytes[byte]} - fixed - encrypt and decrypt`, async () => {
+      const key = Buffer.alloc(parseInt(byte, 10))
+      key.fill(5)
+
+      const iv = Buffer.alloc(16)
+      iv.fill(1)
+
+      const cipher = await crypto.aes.create(key, iv)
+
+      for (let i = 0; i < fixtures[byte].inputs.length; i++) {
+        const rawIn = fixtures[byte].inputs[i]
+        const input = Buffer.from(rawIn)
+        const output = Buffer.from(fixtures[byte].outputs[i])
+        const encrypted = await cipher.encrypt(input)
+        expect(encrypted).to.have.length(output.length)
+        expect(encrypted).to.eql(output)
+        const decrypted = await cipher.decrypt(encrypted)
+        expect(decrypted).to.eql(input)
+      }
+    })
+  })
+
+  Object.keys(bytes).forEach((byte) => {
+    if (!goFixtures[byte]) {
+      return
+    }
+
+    it(`${bytes[byte]} - go interop - encrypt and decrypt`, async () => {
+      const key = Buffer.alloc(parseInt(byte, 10))
+      key.fill(5)
+
+      const iv = Buffer.alloc(16)
+      iv.fill(1)
+
+      const cipher = await crypto.aes.create(key, iv)
+
+      for (let i = 0; i < goFixtures[byte].inputs.length; i++) {
+        const rawIn = goFixtures[byte].inputs[i]
+        const input = Buffer.from(rawIn)
+        const output = Buffer.from(goFixtures[byte].outputs[i])
+        const encrypted = await cipher.encrypt(input)
+        expect(encrypted).to.have.length(output.length)
+        expect(encrypted).to.eql(output)
+        const decrypted = await cipher.decrypt(encrypted)
+        expect(decrypted).to.eql(input)
+      }
+    })
+  })
+})
+
+async function encryptAndDecrypt (cipher) {
+  const data = Buffer.alloc(100)
+  data.fill(Math.ceil(Math.random() * 100))
+
+  const encrypted = await cipher.encrypt(data)
+  const decrypted = await cipher.decrypt(encrypted)
+
+  expect(decrypted).to.be.eql(data)
+}

test/crypto.spec.js

@@ -0,0 +1,114 @@
+/* eslint max-nested-callbacks: ["error", 8] */
+/* eslint-env mocha */
+'use strict'
+
+const chai = require('chai')
+const dirtyChai = require('dirty-chai')
+const expect = chai.expect
+chai.use(dirtyChai)
+const crypto = require('../src')
+const fixtures = require('./fixtures/go-key-rsa')
+
+describe('libp2p-crypto', function () {
+  this.timeout(20 * 1000)
+  let key
+  before(async () => {
+    key = await crypto.keys.generateKeyPair('RSA', 512)
+  })
+
+  it('marshalPublicKey and unmarshalPublicKey', () => {
+    const key2 = crypto.keys.unmarshalPublicKey(
+      crypto.keys.marshalPublicKey(key.public))
+
+    expect(key2.equals(key.public)).to.be.eql(true)
+
+    expect(() => {
+      crypto.keys.marshalPublicKey(key.public, 'invalid-key-type')
+    }).to.throw()
+  })
+
+  it('marshalPrivateKey and unmarshalPrivateKey', async () => {
+    expect(() => {
+      crypto.keys.marshalPrivateKey(key, 'invalid-key-type')
+    }).to.throw()
+
+    const key2 = await crypto.keys.unmarshalPrivateKey(crypto.keys.marshalPrivateKey(key))
+
+    expect(key2.equals(key)).to.be.eql(true)
+    expect(key2.public.equals(key.public)).to.be.eql(true)
+  })
+
+  // marshalled keys seem to be slightly different
+  // unsure as to if this is just a difference in encoding
+  // or a bug
+  describe('go interop', () => {
+    it('unmarshals private key', async () => {
+      const key = await crypto.keys.unmarshalPrivateKey(fixtures.private.key)
+      const hash = fixtures.private.hash
+      expect(fixtures.private.key).to.eql(key.bytes)
+      const digest = await key.hash()
+      expect(digest).to.eql(hash)
+    })
+
+    it('unmarshals public key', async () => {
+      const key = crypto.keys.unmarshalPublicKey(fixtures.public.key)
+      const hash = fixtures.public.hash
+      expect(crypto.keys.marshalPublicKey(key)).to.eql(fixtures.public.key)
+      const digest = await key.hash()
+      expect(digest).to.eql(hash)
+    })
+
+    it('unmarshal -> marshal, private key', async () => {
+      const key = await crypto.keys.unmarshalPrivateKey(fixtures.private.key)
+      const marshalled = crypto.keys.marshalPrivateKey(key)
+      expect(marshalled).to.eql(fixtures.private.key)
+    })
+
+    it('unmarshal -> marshal, public key', () => {
+      const key = crypto.keys.unmarshalPublicKey(fixtures.public.key)
+      const marshalled = crypto.keys.marshalPublicKey(key)
+      expect(fixtures.public.key.equals(marshalled)).to.eql(true)
+    })
+  })
+
+  describe('pbkdf2', () => {
+    it('generates a derived password using sha1', () => {
+      const p1 = crypto.pbkdf2('password', 'at least 16 character salt', 500, 512 / 8, 'sha1')
+      expect(p1).to.exist()
+      expect(p1).to.be.a('string')
+    })
+
+    it('generates a derived password using sha2-512', () => {
+      const p1 = crypto.pbkdf2('password', 'at least 16 character salt', 500, 512 / 8, 'sha2-512')
+      expect(p1).to.exist()
+      expect(p1).to.be.a('string')
+    })
+
+    it('generates the same derived password with the same options', () => {
+      const p1 = crypto.pbkdf2('password', 'at least 16 character salt', 10, 512 / 8, 'sha1')
+      const p2 = crypto.pbkdf2('password', 'at least 16 character salt', 10, 512 / 8, 'sha1')
+      const p3 = crypto.pbkdf2('password', 'at least 16 character salt', 11, 512 / 8, 'sha1')
+      expect(p2).to.equal(p1)
+      expect(p3).to.not.equal(p2)
+    })
+
+    it('throws on invalid hash name', () => {
+      expect(() => crypto.pbkdf2('password', 'at least 16 character salt', 500, 512 / 8, 'shaX-xxx')).to.throw()
+    })
+  })
+
+  describe('randomBytes', () => {
+    it('throws with no number passed', () => {
+      expect(() => {
+        crypto.randomBytes()
+      }).to.throw()
+    })
+
+    it('generates different random things', () => {
+      const buf1 = crypto.randomBytes(10)
+      expect(buf1.length).to.equal(10)
+      const buf2 = crypto.randomBytes(10)
+      expect(buf1).to.not.eql(buf2)
+    })
+  })
+})

test/ed25519.spec.js

@@ -1,195 +0,0 @@
-/* eslint-env mocha */
-'use strict'
-
-const expect = require('chai').expect
-const Buffer = require('safe-buffer').Buffer
-
-const crypto = require('../src')
-const ed25519 = crypto.keys.ed25519
-const fixtures = require('./fixtures/go-key-ed25519')
-
-describe('ed25519', () => {
-  let key
-  before((done) => {
-    crypto.generateKeyPair('Ed25519', 512, (err, _key) => {
-      if (err) return done(err)
-      key = _key
-      done()
-    })
-  })
-
-  it('generates a valid key', (done) => {
-    expect(
-      key
-    ).to.be.an.instanceof(
-      ed25519.Ed25519PrivateKey
-    )
-
-    key.hash((err, digest) => {
-      if (err) {
-        return done(err)
-      }
-
-      expect(digest).to.have.length(34)
-      done()
-    })
-  })
-
-  it('signs', (done) => {
-    const text = crypto.randomBytes(512)
-
-    key.sign(text, (err, sig) => {
-      if (err) {
-        return done(err)
-      }
-
-      key.public.verify(text, sig, (err, res) => {
-        if (err) {
-          return done(err)
-        }
-
-        expect(res).to.be.eql(true)
-        done()
-      })
-    })
-  })
-
-  it('encoding', (done) => {
-    const keyMarshal = key.marshal()
-    ed25519.unmarshalEd25519PrivateKey(keyMarshal, (err, key2) => {
-      if (err) {
-        return done(err)
-      }
-      const keyMarshal2 = key2.marshal()
-
-      expect(
-        keyMarshal
-      ).to.be.eql(
-        keyMarshal2
-      )
-
-      const pk = key.public
-      const pkMarshal = pk.marshal()
-      const pk2 = ed25519.unmarshalEd25519PublicKey(pkMarshal)
-      const pkMarshal2 = pk2.marshal()
-
-      expect(
-        pkMarshal
-      ).to.be.eql(
-        pkMarshal2
-      )
-      done()
-    })
-  })
-
-  describe('key equals', () => {
-    it('equals itself', () => {
-      expect(
-        key.equals(key)
-      ).to.be.eql(
-        true
-      )
-
-      expect(
-        key.public.equals(key.public)
-      ).to.be.eql(
-        true
-      )
-    })
-
-    it('not equals other key', (done) => {
-      crypto.generateKeyPair('Ed25519', 512, (err, key2) => {
-        if (err) return done(err)
-
-        expect(
-          key.equals(key2)
-        ).to.be.eql(
-          false
-        )
-
-        expect(
-          key2.equals(key)
-        ).to.be.eql(
-          false
-        )
-
-        expect(
-          key.public.equals(key2.public)
-        ).to.be.eql(
-          false
-        )
-
-        expect(
-          key2.public.equals(key.public)
-        ).to.be.eql(
-          false
-        )
-        done()
-      })
-    })
-  })
-
-  it('sign and verify', (done) => {
-    const data = Buffer.from('hello world')
-    key.sign(data, (err, sig) => {
-      if (err) {
-        return done(err)
-      }
-
-      key.public.verify(data, sig, (err, valid) => {
-        if (err) {
-          return done(err)
-        }
-        expect(valid).to.be.eql(true)
-        done()
-      })
-    })
-  })
-
-  it('fails to verify for different data', (done) => {
-    const data = Buffer.from('hello world')
-    key.sign(data, (err, sig) => {
-      if (err) {
-        return done(err)
-      }
-
-      key.public.verify(Buffer.from('hello'), sig, (err, valid) => {
-        if (err) {
-          return done(err)
-        }
-        expect(valid).to.be.eql(false)
-        done()
-      })
-    })
-  })
-
-  describe('go interop', () => {
-    let privateKey
-    before((done) => {
-      crypto.unmarshalPrivateKey(fixtures.verify.privateKey, (err, key) => {
-        expect(err).to.not.exist
-        privateKey = key
-        done()
-      })
-    })
-
-    it('verifies with data from go', (done) => {
-      const key = crypto.unmarshalPublicKey(fixtures.verify.publicKey)
-
-      key.verify(fixtures.verify.data, fixtures.verify.signature, (err, ok) => {
-        if (err) throw err
-        expect(err).to.not.exist
-        expect(ok).to.be.eql(true)
-        done()
-      })
-    })
-
-    it('generates the same signature as go', (done) => {
-      privateKey.sign(fixtures.verify.data, (err, sig) => {
-        expect(err).to.not.exist
-        expect(sig).to.deep.equal(fixtures.verify.signature)
-        done()
-      })
-    })
-  })
-})

test/ephemeral-keys.spec.js

@@ -1,75 +0,0 @@
-/* eslint max-nested-callbacks: ["error", 8] */
-/* eslint-env mocha */
-'use strict'
-
-const expect = require('chai').expect
-const parallel = require('async/parallel')
-
-const fixtures = require('./fixtures/go-elliptic-key')
-const crypto = require('../src')
-
-const curves = ['P-256', 'P-384'] // 'P-521' fails in tests :( no clue why
-const lengths = {
-  'P-256': 65,
-  'P-384': 97,
-  'P-521': 133
-}
-const secretLengths = {
-  'P-256': 32,
-  'P-384': 48,
-  'P-521': 66
-}
-
-describe('generateEphemeralKeyPair', () => {
-  curves.forEach((curve) => {
-    it(`generate and shared key ${curve}`, (done) => {
-      parallel([
-        (cb) => crypto.generateEphemeralKeyPair(curve, cb),
-        (cb) => crypto.generateEphemeralKeyPair(curve, cb)
-      ], (err, keys) => {
-        expect(err).to.not.exist
-        expect(keys[0].key).to.have.length(lengths[curve])
-        expect(keys[1].key).to.have.length(lengths[curve])
-
-        keys[0].genSharedKey(keys[1].key, (err, shared) => {
-          expect(err).to.not.exist
-          expect(shared).to.have.length(secretLengths[curve])
-          done()
-        })
-      })
-    })
-  })
-
-  describe('go interop', () => {
-    it('generates a shared secret', (done) => {
-      const curve = fixtures.curve
-
-      parallel([
-        (cb) => crypto.generateEphemeralKeyPair(curve, cb),
-        (cb) => crypto.generateEphemeralKeyPair(curve, cb)
-      ], (err, res) => {
-        expect(err).to.not.exist
-        const alice = res[0]
-        const bob = res[1]
-        bob.key = fixtures.bob.public
-
-        parallel([
-          (cb) => alice.genSharedKey(bob.key, cb),
-          (cb) => bob.genSharedKey(alice.key, fixtures.bob, cb)
-        ], (err, secrets) => {
-          expect(err).to.not.exist
-
-          expect(
-            secrets[0]
-          ).to.be.eql(
-            secrets[1]
-          )
-
-          expect(secrets[0]).to.have.length(32)
-
-          done()
-        })
-      })
-    })
-  })
-})

test/fixtures/go-elliptic-key.js

@@ -1,7 +1,5 @@
 'use strict'
 
-const Buffer = require('safe-buffer').Buffer
-
 module.exports = {
   curve: 'P-256',
   bob: {

test/fixtures/go-key-ed25519.js

@@ -1,7 +1,5 @@
 'use strict'
 
-const Buffer = require('safe-buffer').Buffer
-
 module.exports = {
   // These were generated in a gore (https://github.com/motemen/gore) repl session:
   //

test/fixtures/go-key-rsa.js

@@ -1,7 +1,5 @@
 'use strict'
 
-const Buffer = require('safe-buffer').Buffer
-
 module.exports = {
   private: {
     hash: Buffer.from([

test/fixtures/go-stretch-key.js

@@ -1,7 +1,5 @@
 'use strict'
 
-const Buffer = require('safe-buffer').Buffer
-
 module.exports = [{
   cipher: 'AES-256',
   hash: 'SHA256',

test/fixtures/secp256k1.js

@@ -0,0 +1,8 @@
+'use strict'
+
+module.exports = {
+  // protobuf marshaled key pair generated with libp2p-crypto-secp256k1
+  // and marshaled with libp2p-crypto.marshalPublicKey / marshalPrivateKey
+  pbmPrivateKey: Buffer.from('08021220e0600103010000000100000000000000be1dc82c2e000000e8d6030301000000', 'hex'),
+  pbmPublicKey: Buffer.from('0802122103a9a7272a726fa083abf31ba44037f8347fbc5e5d3113d62a7c6bc26752fd8ee1', 'hex')
+}

test/helpers/test-garbage-error-handling.js

@@ -0,0 +1,40 @@
+/* eslint-env mocha */
+'use strict'
+
+const util = require('util')
+const garbage = [Buffer.from('00010203040506070809', 'hex'), {}, null, false, undefined, true, 1, 0, Buffer.from(''), 'aGVsbG93b3JsZA==', 'helloworld', '']
+
+function doTests (fncName, fnc, num, skipBuffersAndStrings) {
+  if (!num) {
+    num = 1
+  }
+
+  garbage.forEach((garbage) => {
+    if (skipBuffersAndStrings && (Buffer.isBuffer(garbage) || (typeof garbage) === 'string')) {
+      // skip this garbage because it's a buffer or a string and we were told do do that
+      return
+    }
+    let args = []
+    for (let i = 0; i < num; i++) {
+      args.push(garbage)
+    }
+    it(fncName + '(' + args.map(garbage => util.inspect(garbage)).join(', ') + ')', async () => {
+      try {
+        await fnc.apply(null, args)
+      } catch (err) {
+        return // expected
+      }
+      throw new Error('Expected error to be thrown')
+    })
+  })
+}
+
+module.exports = (obj, fncs, num) => {
+  describe('returns error via cb instead of crashing', () => {
+    fncs.forEach(fnc => {
+      doTests(fnc, obj[fnc], num)
+    })
+  })
+}
+
+module.exports.doTests = doTests

test/hmac.spec.js

@@ -1,26 +0,0 @@
-/* eslint max-nested-callbacks: ["error", 8] */
-/* eslint-env mocha */
-'use strict'
-
-const Buffer = require('safe-buffer').Buffer
-const expect = require('chai').expect
-
-const crypto = require('../src')
-
-const hashes = ['SHA1', 'SHA256', 'SHA512']
-
-describe('HMAC', () => {
-  hashes.forEach((hash) => {
-    it(`${hash} - sign and verify`, (done) => {
-      crypto.hmac.create(hash, Buffer.from('secret'), (err, hmac) => {
-        expect(err).to.not.exist
-
-        hmac.digest(Buffer.from('hello world'), (err, sig) => {
-          expect(err).to.not.exist
-          expect(sig).to.have.length(hmac.length)
-          done()
-        })
-      })
-    })
-  })
-})

test/hmac/hmac.spec.js

@@ -0,0 +1,22 @@
+/* eslint max-nested-callbacks: ["error", 8] */
+/* eslint-env mocha */
+'use strict'
+
+const chai = require('chai')
+const dirtyChai = require('dirty-chai')
+const expect = chai.expect
+chai.use(dirtyChai)
+
+const crypto = require('../../src')
+
+const hashes = ['SHA1', 'SHA256', 'SHA512']
+
+describe('HMAC', () => {
+  hashes.forEach((hash) => {
+    it(`${hash} - sign and verify`, async () => {
+      const hmac = await crypto.hmac.create(hash, Buffer.from('secret'))
+      const sig = await hmac.digest(Buffer.from('hello world'))
+      expect(sig).to.have.length(hmac.length)
+    })
+  })
+})

test/index.spec.js

@@ -1,116 +0,0 @@
-/* eslint max-nested-callbacks: ["error", 8] */
-/* eslint-env mocha */
-'use strict'
-
-const expect = require('chai').expect
-
-const crypto = require('../src')
-const fixtures = require('./fixtures/go-key-rsa')
-
-describe('libp2p-crypto', () => {
-  let key
-  before((done) => {
-    crypto.generateKeyPair('RSA', 2048, (err, _key) => {
-      if (err) {
-        return done(err)
-      }
-      key = _key
-      done()
-    })
-  })
-
-  it('marshalPublicKey and unmarshalPublicKey', () => {
-    const key2 = crypto.unmarshalPublicKey(crypto.marshalPublicKey(key.public))
-
-    expect(key2.equals(key.public)).to.be.eql(true)
-  })
-
-  it('marshalPrivateKey and unmarshalPrivateKey', (done) => {
-    crypto.unmarshalPrivateKey(crypto.marshalPrivateKey(key), (err, key2) => {
-      if (err) {
-        return done(err)
-      }
-
-      expect(key2.equals(key)).to.be.eql(true)
-      expect(key2.public.equals(key.public)).to.be.eql(true)
-      done()
-    })
-  })
-
-  // marshalled keys seem to be slightly different
-  // unsure as to if this is just a difference in encoding
-  // or a bug
-  describe('go interop', () => {
-    it('unmarshals private key', (done) => {
-      crypto.unmarshalPrivateKey(fixtures.private.key, (err, key) => {
-        if (err) {
-          return done(err)
-        }
-        const hash = fixtures.private.hash
-        expect(fixtures.private.key).to.be.eql(key.bytes)
-
-        key.hash((err, digest) => {
-          if (err) {
-            return done(err)
-          }
-
-          expect(digest).to.be.eql(hash)
-          done()
-        })
-      })
-    })
-
-    it('unmarshals public key', (done) => {
-      const key = crypto.unmarshalPublicKey(fixtures.public.key)
-      const hash = fixtures.public.hash
-
-      expect(crypto.marshalPublicKey(key)).to.be.eql(fixtures.public.key)
-
-      key.hash((err, digest) => {
-        if (err) {
-          return done(err)
-        }
-
-        expect(digest).to.be.eql(hash)
-        done()
-      })
-    })
-
-    it('unmarshal -> marshal, private key', (done) => {
-      crypto.unmarshalPrivateKey(fixtures.private.key, (err, key) => {
-        if (err) {
-          return done(err)
-        }
-
-        const marshalled = crypto.marshalPrivateKey(key)
-        expect(marshalled).to.be.eql(fixtures.private.key)
-        done()
-      })
-    })
-
-    it('unmarshal -> marshal, public key', () => {
-      const key = crypto.unmarshalPublicKey(fixtures.public.key)
-      const marshalled = crypto.marshalPublicKey(key)
-      expect(
-        fixtures.public.key.equals(marshalled)
-      ).to.be.eql(
-        true
-      )
-    })
-  })
-
-  describe('randomBytes', () => {
-    it('throws with no number passed', () => {
-      expect(() => {
-        crypto.randomBytes()
-      }).to.throw
-    })
-
-    it('generates different random things', () => {
-      const buf1 = crypto.randomBytes(10)
-      expect(buf1.length).to.equal(10)
-      const buf2 = crypto.randomBytes(10)
-      expect(buf1).to.not.eql(buf2)
-    })
-  })
-})

test/key-stretcher.spec.js

@@ -1,74 +0,0 @@
-/* eslint max-nested-callbacks: ["error", 8] */
-/* eslint-env mocha */
-'use strict'
-
-const expect = require('chai').expect
-
-const crypto = require('../src')
-const fixtures = require('./fixtures/go-stretch-key')
-
-describe('keyStretcher', () => {
-  describe('generate', () => {
-    const ciphers = ['AES-128', 'AES-256', 'Blowfish']
-    const hashes = ['SHA1', 'SHA256', 'SHA512']
-    let res
-    let secret
-
-    before((done) => {
-      crypto.generateEphemeralKeyPair('P-256', (err, _res) => {
-        if (err) {
-          return done(err)
-        }
-        res = _res
-        res.genSharedKey(res.key, (err, _secret) => {
-          if (err) {
-            return done(err)
-          }
-
-          secret = _secret
-          done()
-        })
-      })
-    })
-
-    ciphers.forEach((cipher) => {
-      hashes.forEach((hash) => {
-        it(`${cipher} - ${hash}`, (done) => {
-          crypto.keyStretcher(cipher, hash, secret, (err, keys) => {
-            if (err) {
-              return done(err)
-            }
-
-            expect(keys.k1).to.exist
-            expect(keys.k2).to.exist
-            done()
-          })
-        })
-      })
-    })
-  })
-
-  describe('go interop', () => {
-    fixtures.forEach((test) => {
-      it(`${test.cipher} - ${test.hash}`, (done) => {
-        const cipher = test.cipher
-        const hash = test.hash
-        const secret = test.secret
-        crypto.keyStretcher(cipher, hash, secret, (err, keys) => {
-          if (err) {
-            return done(err)
-          }
-
-          expect(keys.k1.iv).to.be.eql(test.k1.iv)
-          expect(keys.k1.cipherKey).to.be.eql(test.k1.cipherKey)
-          expect(keys.k1.macKey).to.be.eql(test.k1.macKey)
-
-          expect(keys.k2.iv).to.be.eql(test.k2.iv)
-          expect(keys.k2.cipherKey).to.be.eql(test.k2.cipherKey)
-          expect(keys.k2.macKey).to.be.eql(test.k2.macKey)
-          done()
-        })
-      })
-    })
-  })
-})

test/keys/ed25519.spec.js

@@ -0,0 +1,144 @@
+/* eslint-env mocha */
+'use strict'
+
+const chai = require('chai')
+const dirtyChai = require('dirty-chai')
+const expect = chai.expect
+chai.use(dirtyChai)
+
+const crypto = require('../../src')
+const ed25519 = crypto.keys.supportedKeys.ed25519
+const fixtures = require('../fixtures/go-key-ed25519')
+
+const testGarbage = require('../helpers/test-garbage-error-handling')
+
+describe('ed25519', function () {
+  this.timeout(20 * 1000)
+  let key
+  before(async () => {
+    key = await crypto.keys.generateKeyPair('Ed25519', 512)
+  })
+
+  it('generates a valid key', async () => {
+    expect(key).to.be.an.instanceof(ed25519.Ed25519PrivateKey)
+    const digest = await key.hash()
+    expect(digest).to.have.length(34)
+  })
+
+  it('generates a valid key from seed', async () => {
+    var seed = crypto.randomBytes(32)
+    const seededkey = await crypto.keys.generateKeyPairFromSeed('Ed25519', seed, 512)
+    expect(seededkey).to.be.an.instanceof(ed25519.Ed25519PrivateKey)
+    const digest = await seededkey.hash()
+    expect(digest).to.have.length(34)
+  })
+
+  it('generates the same key from the same seed', async () => {
+    const seed = crypto.randomBytes(32)
+    const seededkey1 = await crypto.keys.generateKeyPairFromSeed('Ed25519', seed, 512)
+    const seededkey2 = await crypto.keys.generateKeyPairFromSeed('Ed25519', seed, 512)
+    expect(seededkey1.equals(seededkey2)).to.eql(true)
+    expect(seededkey1.public.equals(seededkey2.public)).to.eql(true)
+  })
+
+  it('generates different keys for different seeds', async () => {
+    const seed1 = crypto.randomBytes(32)
+    const seededkey1 = await crypto.keys.generateKeyPairFromSeed('Ed25519', seed1, 512)
+    const seed2 = crypto.randomBytes(32)
+    const seededkey2 = await crypto.keys.generateKeyPairFromSeed('Ed25519', seed2, 512)
+    expect(seededkey1.equals(seededkey2)).to.eql(false)
+    expect(seededkey1.public.equals(seededkey2.public)).to.eql(false)
+  })
+
+  it('signs', async () => {
+    const text = crypto.randomBytes(512)
+    const sig = await key.sign(text)
+    const res = await key.public.verify(text, sig)
+    expect(res).to.be.eql(true)
+  })
+
+  it('encoding', async () => {
+    const keyMarshal = key.marshal()
+    const key2 = await ed25519.unmarshalEd25519PrivateKey(keyMarshal)
+    const keyMarshal2 = key2.marshal()
+
+    expect(keyMarshal).to.eql(keyMarshal2)
+
+    const pk = key.public
+    const pkMarshal = pk.marshal()
+    const pk2 = ed25519.unmarshalEd25519PublicKey(pkMarshal)
+    const pkMarshal2 = pk2.marshal()
+
+    expect(pkMarshal).to.eql(pkMarshal2)
+  })
+
+  it('key id', async () => {
+    const id = await key.id()
+    expect(id).to.exist()
+    expect(id).to.be.a('string')
+  })
+
+  describe('key equals', () => {
+    it('equals itself', () => {
+      expect(
+        key.equals(key)
+      ).to.eql(
+        true
+      )
+
+      expect(
+        key.public.equals(key.public)
+      ).to.eql(
+        true
+      )
+    })
+
+    it('not equals other key', async () => {
+      const key2 = await crypto.keys.generateKeyPair('Ed25519', 512)
+      expect(key.equals(key2)).to.eql(false)
+      expect(key2.equals(key)).to.eql(false)
+      expect(key.public.equals(key2.public)).to.eql(false)
+      expect(key2.public.equals(key.public)).to.eql(false)
+    })
+  })
+
+  it('sign and verify', async () => {
+    const data = Buffer.from('hello world')
+    const sig = await key.sign(data)
+    const valid = await key.public.verify(data, sig)
+    expect(valid).to.eql(true)
+  })
+
+  it('fails to verify for different data', async () => {
+    const data = Buffer.from('hello world')
+    const sig = await key.sign(data)
+    const valid = await key.public.verify(Buffer.from('hello'), sig)
+    expect(valid).to.be.eql(false)
+  })
+
+  describe('returns error via cb instead of crashing', () => {
+    const key = crypto.keys.unmarshalPublicKey(fixtures.verify.publicKey)
+    testGarbage.doTests('key.verify', key.verify.bind(key), 2)
+    testGarbage.doTests('crypto.keys.unmarshalPrivateKey', crypto.keys.unmarshalPrivateKey.bind(crypto.keys))
+  })
+
+  describe('go interop', () => {
+    let privateKey
+
+    before(async () => {
+      const key = await crypto.keys.unmarshalPrivateKey(fixtures.verify.privateKey)
+      privateKey = key
+    })
+
+    it('verifies with data from go', async () => {
+      const key = crypto.keys.unmarshalPublicKey(fixtures.verify.publicKey)
+      const ok = await key.verify(fixtures.verify.data, fixtures.verify.signature)
+      expect(ok).to.eql(true)
+    })
+
+    it('generates the same signature as go', async () => {
+      const sig = await privateKey.sign(fixtures.verify.data)
+      expect(sig).to.eql(fixtures.verify.signature)
+    })
+  })
+})

test/keys/ephemeral-keys.spec.js

@@ -0,0 +1,63 @@
+/* eslint max-nested-callbacks: ["error", 8] */
+/* eslint-env mocha */
+'use strict'
+
+const chai = require('chai')
+const dirtyChai = require('dirty-chai')
+const expect = chai.expect
+chai.use(dirtyChai)
+
+const fixtures = require('../fixtures/go-elliptic-key')
+const crypto = require('../../src')
+
+const curves = ['P-256', 'P-384'] // 'P-521' fails in tests :( no clue why
+const lengths = {
+  'P-256': 65,
+  'P-384': 97,
+  'P-521': 133
+}
+const secretLengths = {
+  'P-256': 32,
+  'P-384': 48,
+  'P-521': 66
+}
+
+describe('generateEphemeralKeyPair', () => {
+  curves.forEach((curve) => {
+    it(`generate and shared key ${curve}`, async () => {
+      const keys = await Promise.all([
+        crypto.keys.generateEphemeralKeyPair(curve),
+        crypto.keys.generateEphemeralKeyPair(curve)
+      ])
+
+      expect(keys[0].key).to.have.length(lengths[curve])
+      expect(keys[1].key).to.have.length(lengths[curve])
+
+      const shared = await keys[0].genSharedKey(keys[1].key)
+      expect(shared).to.have.length(secretLengths[curve])
+    })
+  })
+
+  describe('go interop', () => {
+    it('generates a shared secret', async () => {
+      const curve = fixtures.curve
+
+      const keys = await Promise.all([
+        crypto.keys.generateEphemeralKeyPair(curve),
+        crypto.keys.generateEphemeralKeyPair(curve)
+      ])
+
+      const alice = keys[0]
+      const bob = keys[1]
+      bob.key = fixtures.bob.public
+
+      const secrets = await Promise.all([
+        alice.genSharedKey(bob.key),
+        bob.genSharedKey(alice.key, fixtures.bob)
+      ])
+
+      expect(secrets[0]).to.eql(secrets[1])
+      expect(secrets[0]).to.have.length(32)
+    })
+  })
+})

test/keys/key-stretcher.spec.js

@@ -0,0 +1,53 @@
+/* eslint max-nested-callbacks: ["error", 8] */
+/* eslint-env mocha */
+'use strict'
+
+const chai = require('chai')
+const dirtyChai = require('dirty-chai')
+const expect = chai.expect
+chai.use(dirtyChai)
+const crypto = require('../../src')
+const fixtures = require('../fixtures/go-stretch-key')
+
+describe('keyStretcher', () => {
+  describe('generate', () => {
+    const ciphers = ['AES-128', 'AES-256', 'Blowfish']
+    const hashes = ['SHA1', 'SHA256', 'SHA512']
+    let res
+    let secret
+
+    before(async () => {
+      res = await crypto.keys.generateEphemeralKeyPair('P-256')
+      secret = await res.genSharedKey(res.key)
+    })
+
+    ciphers.forEach((cipher) => {
+      hashes.forEach((hash) => {
+        it(`${cipher} - ${hash}`, async () => {
+          const keys = await crypto.keys.keyStretcher(cipher, hash, secret)
+          expect(keys.k1).to.exist()
+          expect(keys.k2).to.exist()
+        })
+      })
+    })
+  })
+
+  describe('go interop', () => {
+    fixtures.forEach((test) => {
+      it(`${test.cipher} - ${test.hash}`, async () => {
+        const cipher = test.cipher
+        const hash = test.hash
+        const secret = test.secret
+        const keys = await crypto.keys.keyStretcher(cipher, hash, secret)
+
+        expect(keys.k1.iv).to.be.eql(test.k1.iv)
+        expect(keys.k1.cipherKey).to.be.eql(test.k1.cipherKey)
+        expect(keys.k1.macKey).to.be.eql(test.k1.macKey)
+
+        expect(keys.k2.iv).to.be.eql(test.k2.iv)
+        expect(keys.k2.cipherKey).to.be.eql(test.k2.cipherKey)
+        expect(keys.k2.macKey).to.be.eql(test.k2.macKey)
+      })
+    })
+  })
+})

test/keys/rsa-crypto-libs.js

@@ -0,0 +1,53 @@
+'use strict'
+
+/* eslint-env mocha */
+/* eslint max-nested-callbacks: ["error", 8] */
+
+const chai = require('chai')
+const dirtyChai = require('dirty-chai')
+const expect = chai.expect
+chai.use(dirtyChai)
+chai.use(require('chai-string'))
+
+const LIBS = ['ursa', 'keypair']
+
+describe('RSA crypto libs', function () {
+  this.timeout(20 * 1000)
+
+  LIBS.forEach(lib => {
+    describe(lib, () => {
+      let crypto
+      let rsa
+
+      before(() => {
+        process.env.LP2P_FORCE_CRYPTO_LIB = lib
+
+        for (const path in require.cache) { // clear module cache
+          if (path.endsWith('.js')) {
+            delete require.cache[path]
+          }
+        }
+
+        crypto = require('../../src')
+        rsa = crypto.keys.supportedKeys.rsa
+      })
+
+      it('generates a valid key', async () => {
+        const key = await crypto.keys.generateKeyPair('RSA', 512)
+        expect(key).to.be.an.instanceof(rsa.RsaPrivateKey)
+        const digest = await key.hash()
+        expect(digest).to.have.length(34)
+      })
+
+      after(() => {
+        for (const path in require.cache) { // clear module cache
+          if (path.endsWith('.js')) {
+            delete require.cache[path]
+          }
+        }
+
+        delete process.env.LP2P_FORCE_CRYPTO_LIB
+      })
+    })
+  })
+})

test/keys/rsa.spec.js

@@ -0,0 +1,344 @@
+/* eslint max-nested-callbacks: ["error", 8] */
+/* eslint-env mocha */
+'use strict'
+
+const chai = require('chai')
+const dirtyChai = require('dirty-chai')
+const expect = chai.expect
+chai.use(dirtyChai)
+chai.use(require('chai-string'))
+
+const crypto = require('../../src')
+const rsa = crypto.keys.supportedKeys.rsa
+const fixtures = require('../fixtures/go-key-rsa')
+
+const testGarbage = require('../helpers/test-garbage-error-handling')
+
+describe('RSA', function () {
+  this.timeout(20 * 1000)
+  let key
+
+  before(async () => {
+    key = await crypto.keys.generateKeyPair('RSA', 512)
+  })
+
+  it('generates a valid key', async () => {
+    expect(key).to.be.an.instanceof(rsa.RsaPrivateKey)
+    const digest = await key.hash()
+    expect(digest).to.have.length(34)
+  })
+
+  it('signs', async () => {
+    const text = key.genSecret()
+    const sig = await key.sign(text)
+    const res = await key.public.verify(text, sig)
+    expect(res).to.be.eql(true)
+  })
+
+  it('encoding', async () => {
+    const keyMarshal = key.marshal()
+    const key2 = await rsa.unmarshalRsaPrivateKey(keyMarshal)
+    const keyMarshal2 = key2.marshal()
+
+    expect(keyMarshal).to.eql(keyMarshal2)
+
+    const pk = key.public
+    const pkMarshal = pk.marshal()
+    const pk2 = rsa.unmarshalRsaPublicKey(pkMarshal)
+    const pkMarshal2 = pk2.marshal()
+
+    expect(pkMarshal).to.eql(pkMarshal2)
+  })
+
+  it('key id', async () => {
+    const id = await key.id()
+    expect(id).to.exist()
+    expect(id).to.be.a('string')
+  })
+
+  describe('key equals', () => {
+    it('equals itself', () => {
+      expect(key.equals(key)).to.eql(true)
+
+      expect(key.public.equals(key.public)).to.eql(true)
+    })
+
+    it('not equals other key', async () => {
+      const key2 = await crypto.keys.generateKeyPair('RSA', 512)
+      expect(key.equals(key2)).to.eql(false)
+      expect(key2.equals(key)).to.eql(false)
+      expect(key.public.equals(key2.public)).to.eql(false)
+      expect(key2.public.equals(key.public)).to.eql(false)
+    })
+  })
+
+  it('sign and verify', async () => {
+    const data = Buffer.from('hello world')
+    const sig = await key.sign(data)
+    const valid = await key.public.verify(data, sig)
+    expect(valid).to.be.eql(true)
+  })
+
+  it('fails to verify for different data', async () => {
+    const data = Buffer.from('hello world')
+    const sig = await key.sign(data)
+    const valid = await key.public.verify(Buffer.from('hello'), sig)
+    expect(valid).to.be.eql(false)
+  })
+
+  describe('export and import', () => {
+    it('password protected PKCS #8', async () => {
+      const pem = await key.export('my secret', 'pkcs-8')
+      expect(pem).to.startsWith('-----BEGIN ENCRYPTED PRIVATE KEY-----')
+      const clone = await crypto.keys.import(pem, 'my secret')
+      expect(clone).to.exist()
+      expect(key.equals(clone)).to.eql(true)
+    })
+
+    it('defaults to PKCS #8', async () => {
+      const pem = await key.export('another secret')
+      expect(pem).to.startsWith('-----BEGIN ENCRYPTED PRIVATE KEY-----')
+      const clone = await crypto.keys.import(pem, 'another secret')
+      expect(clone).to.exist()
+      expect(key.equals(clone)).to.eql(true)
+    })
+
+    it('needs correct password', async () => {
+      const pem = await key.export('another secret')
+      try {
+        await crypto.keys.import(pem, 'not the secret')
+      } catch (err) {
+        return // expected
+      }
+      throw new Error('Expected error to be thrown')
+    })
+  })
+
+  describe('returns error via cb instead of crashing', () => {
+    const key = crypto.keys.unmarshalPublicKey(fixtures.verify.publicKey)
+    testGarbage.doTests('key.verify', key.verify.bind(key), 2, true)
+    testGarbage.doTests('crypto.keys.unmarshalPrivateKey', crypto.keys.unmarshalPrivateKey.bind(crypto.keys))
+  })
+
+  describe('go interop', () => {
+    it('verifies with data from go', async () => {
+      const key = crypto.keys.unmarshalPublicKey(fixtures.verify.publicKey)
+      const ok = await key.verify(fixtures.verify.data, fixtures.verify.signature)
+      expect(ok).to.equal(true)
+    })
+  })
+
+  describe('openssl interop', () => {
+    it('can read a private key', async () => {
+      /*
+       * Generated with
+       * openssl genpkey -algorithm RSA
+       *   -pkeyopt rsa_keygen_bits:3072
+       *   -pkeyopt rsa_keygen_pubexp:65537
+       */
+      const pem = `-----BEGIN PRIVATE KEY-----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+-----END PRIVATE KEY-----
+`
+      const key = await crypto.keys.import(pem, '')
+      expect(key).to.exist()
+      const id = await key.id()
+      expect(id).to.equal('QmfWu2Xp8DZzCkZZzoPB9rcrq4R4RZid6AWE6kmrUAzuHy')
+    })
+
+    // AssertionError: expected 'this only supports pkcs5PBES2' to not exist
+    it.skip('can read a private encrypted key (v1)', async () => {
+      /*
+       * Generated with
+       * openssl genpkey -algorithm RSA
+       *   -pkeyopt rsa_keygen_bits:1024
+       *   -pkeyopt rsa_keygen_pubexp:65537
+       *   -out foo.pem
+       * openssl pkcs8 -in foo.pem -topk8 -passout pass:mypassword
+       */
+      const pem = `-----BEGIN ENCRYPTED PRIVATE KEY-----
+MIICoTAbBgkqhkiG9w0BBQMwDgQI2563Jugj/KkCAggABIICgPxHkKtUUE8EWevq
+eX9nTjqpbsv0QoXQMhegfxDELJLU8tj6V0bWNt7QDdfQ1n6FRgnNvNGick6gyqHH
+yH9qC2oXwkDFP7OrHp2NEZd7DHQLLc+L4KJ/0dzsiZ1U9no7XzQMUay9Bc918ADE
+pN2/EqigWkaG4gNjkAeKWr6+BNRevDXlSvls7YDboNcTiACi5zJkthivB9g3vT1m
+gPdN6Gf/mmqtBTDHeqj5QsmXYqeCyo5b26JgYsziABVZDHph4ekPUsTvudRpE9Ex
+baXwdYEAZxVpSbTvQ3A5qysjSZeM9ttfRTSSwL391q7dViz4+aujpk0Vj7piH+1B
+CkfO8/XudRdRlnOe+KjMidktKCsMGCIOW92IlfMvIQ/Zn1GTYj9bRXONFNJ2WPND
+UmCKnL7cmworwg/weRorrGKBWIGspU+tDASOPSvIGKo6Hoxm4CN1TpDRY7DAGlgm
+Y3TEbMYfpXyzkPjvAhJDt03D3J9PrTO6uM5d7YUaaTmJ2TQFQVF2Lc3Uz8lDJLs0
+ZYtfQ/4H+YY2RrX7ua7t6ArUcYXZtv0J4lRYWjwV8fGPUVc0d8xLJU0Yjf4BD7K8
+rsavHo9b5YvBUX7SgUyxAEembEOe3SjQ+gPu2U5wovcjUuC9eItEEsXGrx30BQ0E
+8BtK2+hp0eMkW5/BYckJkH+Yl8ypbzRGRRIZzLgeI4JveSx/mNhewfgTr+ORPThZ
+mBdkD5r+ixWF174naw53L8U9wF8kiK7pIE1N9TR4USEeovLwX6Ni/2MMDZedOfof
+2f77eUdLsK19/5/lcgAAYaXauXWhy2d2r3SayFrC9woy0lh2VLKRMBjcx1oWb7dp
+0uxzo5Y=
+-----END ENCRYPTED PRIVATE KEY-----
+`
+      const key = await crypto.keys.import(pem, 'mypassword')
+      expect(key).to.exist()
+    })
+
+    it('can read a private encrypted key (v2 aes-128-cbc)', async () => {
+      /*
+       * Generated with
+       * openssl genpkey -algorithm RSA
+       *   -pkeyopt rsa_keygen_bits:1024
+       *   -pkeyopt rsa_keygen_pubexp:65537
+       *   -out foo.pem
+       * openssl pkcs8 -in foo.pem -topk8 -v2 aes-128-cbc -passout pass:mypassword
+       */
+      const pem = `-----BEGIN ENCRYPTED PRIVATE KEY-----
+MIICzzBJBgkqhkiG9w0BBQ0wPDAbBgkqhkiG9w0BBQwwDgQIP5QK2RfqUl4CAggA
+MB0GCWCGSAFlAwQBAgQQj3OyM9gnW2dd/eRHkxjGrgSCAoCpM5GZB0v27cxzZsGc
+O4/xqgwB0c/bSJ6QogtYU2KVoc7ZNQ5q9jtzn3I4ONvneOkpm9arzYz0FWnJi2C3
+BPiF0D1NkfvjvMLv56bwiG2A1oBECacyAb2pXYeJY7SdtYKvcbgs3jx65uCm6TF2
+BylteH+n1ewTQN9DLfASp1n81Ajq9lQGaK03SN2MUtcAPp7N9gnxJrlmDGeqlPRs
+KpQYRcot+kE6Ew8a5jAr7mAxwpqvr3SM4dMvADZmRQsM4Uc/9+YMUdI52DG87EWc
+0OUB+fnQ8jw4DZgOE9KKM5/QTWc3aEw/dzXr/YJsrv01oLazhqVHnEMG0Nfr0+DP
+q+qac1AsCsOb71VxaRlRZcVEkEfAq3gidSPD93qmlDrCnmLYTilcLanXUepda7ez
+qhjkHtpwBLN5xRZxOn3oUuLGjk8VRwfmFX+RIMYCyihjdmbEDYpNUVkQVYFGi/F/
+1hxOyl9yhGdL0hb9pKHH10GGIgoqo4jSTLlb4ennihGMHCjehAjLdx/GKJkOWShy
+V9hj8rAuYnRNb+tUW7ChXm1nLq14x9x1tX0ciVVn3ap/NoMkbFTr8M3pJ4bQlpAn
+wCT2erYqwQtgSpOJcrFeph9TjIrNRVE7Zlmr7vayJrB/8/oPssVdhf82TXkna4fB
+PcmO0YWLa117rfdeNM/Duy0ThSdTl39Qd+4FxqRZiHjbt+l0iSa/nOjTv1TZ/QqF
+wqrO6EtcM45fbFJ1Y79o2ptC2D6MB4HKJq9WCt064/8zQCVx3XPbb3X8Z5o/6koy
+ePGbz+UtSb9xczvqpRCOiFLh2MG1dUgWuHazjOtUcVWvilKnkjCMzZ9s1qG0sUDj
+nPyn
+-----END ENCRYPTED PRIVATE KEY-----
+`
+      const key = await crypto.keys.import(pem, 'mypassword')
+      expect(key).to.exist()
+    })
+
+    it('can read a private encrypted key (v2 aes-256-cbc)', async () => {
+      /*
+       * Generated with
+       * openssl genpkey -algorithm RSA
+       *   -pkeyopt rsa_keygen_bits:1024
+       *   -pkeyopt rsa_keygen_pubexp:65537
+       *   -out foo.pem
+       * openssl pkcs8 -in foo.pem -topk8 -v2 aes-256-cbc -passout pass:mypassword
+       */
+      const pem = `-----BEGIN ENCRYPTED PRIVATE KEY-----
+MIICzzBJBgkqhkiG9w0BBQ0wPDAbBgkqhkiG9w0BBQwwDgQIhuL894loRucCAggA
+MB0GCWCGSAFlAwQBKgQQEoEtsjW3iC9/u0uGvkxX7wSCAoAsX3l6JoR2OGbT8CkY
+YT3RQFqquOgItYOHw6E3tir2YrmxEAo99nxoL8pdto37KSC32eAGnfv5R1zmHHSx
+0M3/y2AWiCBTX95EEzdtGC1hK3PBa/qpp/xEmcrsjYN6NXxMAkhC0hMP/HdvqMAg
+ee7upvaYJsJcl8QLFNayAWr8b8cZA/RBhGEIRl59Eyj6nNtxDt3bCrfe06o1CPCV
+50/fRZEwFOi/C6GYvPN6MrPZO3ALBWgopLT2yQqycTKtfxYWIdOsMBkAjKf2D6Pk
+u2mqBsaP4b71jIIeT4euSJLsoJV+O39s8YHXtW8GtOqp7V5kIlnm90lZ9wzeLTZ7
+HJsD/jEdYto5J3YWm2wwEDccraffJSm7UDtJBvQdIx832kxeFCcGQjW38Zl1qqkg
+iTH1PLTypxj2ZuviS2EkXVFb/kVU6leWwOt6fqWFC58UvJKeCk/6veazz3PDnTWM
+92ClUqFd+CZn9VT4CIaJaAc6v5NLpPp+T9sRX9AtequPm7FyTeevY9bElfyk9gW9
+JDKgKxs6DGWDa16RL5vzwtU+G3o6w6IU+mEwa6/c+hN+pRFs/KBNLLSP9OHBx7BJ
+X/32Ft+VFhJaK+lQ+f+hve7od/bgKnz4c/Vtp7Dh51DgWgCpBgb8p0vqu02vTnxD
+BXtDv3h75l5PhvdWfVIzpMWRYFvPR+vJi066FjAz2sjYc0NMLSYtZWyWoIInjhoX
+Dp5CQujCtw/ZSSlwde1DKEWAW4SeDZAOQNvuz0rU3eosNUJxEmh3aSrcrRtDpw+Y
+mBUuWAZMpz7njBi7h+JDfmSW/GAaMwrVFC2gef5375R0TejAh+COAjItyoeYEvv8
+DQd8
+-----END ENCRYPTED PRIVATE KEY-----
+`
+      const key = await crypto.keys.import(pem, 'mypassword')
+      expect(key).to.exist()
+    })
+
+    it('can read a private encrypted key (v2 des)', async () => {
+      /*
+       * Generated with
+       * openssl genpkey -algorithm RSA
+       *   -pkeyopt rsa_keygen_bits:1024
+       *   -pkeyopt rsa_keygen_pubexp:65537
+       *   -out foo.pem
+       * openssl pkcs8 -in foo.pem -topk8 -v2 des -passout pass:mypassword
+       */
+      const pem = `-----BEGIN ENCRYPTED PRIVATE KEY-----
+MIICwzA9BgkqhkiG9w0BBQ0wMDAbBgkqhkiG9w0BBQwwDgQI0lXp62ozXvwCAggA
+MBEGBSsOAwIHBAiR3Id5vH0u4wSCAoDQQYOrrkPFPIa0S5fQGXnJw1F/66g92Gs1
+TkGydn4ouabWb++Vbi2chee1oyZsN2l8YNzDi0Gb2PfjsGpg2aJk0a3/efgA0u6T
+leEH1dA/7Hr9NVspgHkaXpHt3X6wdbznLYJeAelfj7sDXpOkULGWCkCst0Txb6bi
+Oxv4c0yYykiuUrp+2xvHbF9c2PrcDb58u/OBZcCg3QB1gTugQKM+ZIBRhcTEFLrm
+8gWbzBfwYiUm6aJce4zoafP0NSlEOBbpbr73A08Q1IK6pISwltOUhhTvspSZnK41
+y2CHt5Drnpl1pfOw9Q0svO3VrUP+omxP1SFP17ZfaRGw2uHd08HJZs438x5dIQoH
+QgjlZ8A5rcT3FjnytSh3fln2ZxAGuObghuzmOEL/+8fkGER9QVjmQlsL6OMfB4j4
+ZAkLf74uaTdegF3SqDQaGUwWgk7LyualmUXWTBoeP9kRIsRQLGzAEmd6duBPypED
+HhKXP/ZFA1kVp3x1fzJ2llMFB3m1JBwy4PiohqrIJoR+YvKUvzVQtbOjxtCEAj87
+JFnlQj0wjTd6lfNn+okewMNjKINZx+08ui7XANNU/l18lHIIz3ssXJSmqMW+hRZ9
+9oB2tntLrnRMhkVZDVHadq7eMFOPu0rkekuaZm9CO2vu4V7Qa2h+gOoeczYza0H7
+A+qCKbprxyL8SKI5vug2hE+mfC1leXVRtUYm1DnE+oet99bFd0fN20NwTw0rOeRg
+0Z+/ZpQNizrXxfd3sU7zaJypWCxZ6TD/U/AKBtcb2gqmUjObZhbfbWq6jU2Ye//w
+EBqQkwAUXR1tNekF8CWLOrfC/wbLRxVRkayb8bQUfdgukLpz0bgw
+-----END ENCRYPTED PRIVATE KEY-----
+`
+      const key = await crypto.keys.import(pem, 'mypassword')
+      expect(key).to.exist()
+    })
+
+    it('can read a private encrypted key (v2 des3)', async () => {
+      /*
+       * Generated with
+       * openssl genpkey -algorithm RSA
+       *   -pkeyopt rsa_keygen_bits:1024
+       *   -pkeyopt rsa_keygen_pubexp:65537
+       *   -out foo.pem
+       * openssl pkcs8 -in foo.pem -topk8 -v2 des3 -passout pass:mypassword
+       */
+      const pem = `-----BEGIN ENCRYPTED PRIVATE KEY-----
+MIICxjBABgkqhkiG9w0BBQ0wMzAbBgkqhkiG9w0BBQwwDgQISznrfHd+D58CAggA
+MBQGCCqGSIb3DQMHBAhx0DnnUvDiHASCAoCceplm+Cmwlgvn4hNsv6e4c/S1iA7w
+2hU7Jt8JgRCIMWjP2FthXOAFLa2fD4g3qncYXcDAFBXNyoh25OgOwstO14YkxhDi
+wG4TeppGUt9IlyyCol6Z4WhQs1TGm5OcD5xDta+zBXsBnlgmKLD5ZXPEYB+3v/Dg
+SvM4sQz6NgkVHN52hchERsnknwSOghiK9mIBH0RZU5LgzlDy2VoBCiEPVdZ7m4F2
+dft5e82zFS58vwDeNN/0r7fC54TyJf/8k3q94+4Hp0mseZ67LR39cvnEKuDuFROm
+kLPLekWt5R2NGdunSQlA79BkrNB1ADruO8hQOOHMO9Y3/gNPWLKk+qrfHcUni+w3
+Ofq+rdfakHRb8D6PUmsp3wQj6fSOwOyq3S50VwP4P02gKcZ1om1RvEzTbVMyL3sh
+hZcVB3vViu3DO2/56wo29lPVTpj9bSYjw/CO5jNpPBab0B/Gv7JAR0z4Q8gn6OPy
+qf+ddyW4Kcb6QUtMrYepghDthOiS3YJV/zCNdL3gTtVs5Ku9QwQ8FeM0/5oJZPlC
+TxGuOFEJnYRWqIdByCP8mp/qXS5alSR4uoYQSd7vZG4vkhkPNSAwux/qK1IWfqiW
+3XlZzrbD//9IzFVqGRs4nRIFq85ULK0zAR57HEKIwGyn2brEJzrxpV6xsHBp+m4w
+6r0+PtwuWA0NauTCUzJ1biUdH8t0TgBL6YLaMjlrfU7JstH3TpcZzhJzsjfy0+zV
+NT2TO3kSzXpQ5M2VjOoHPm2fqxD/js+ThDB3QLi4+C7HqakfiTY1lYzXl9/vayt6
+DUD29r9pYL9ErB9tYko2rat54EY7k7Ts6S5jf+8G7Zz234We1APhvqaG
+-----END ENCRYPTED PRIVATE KEY-----
+`
+      const key = await crypto.keys.import(pem, 'mypassword')
+      expect(key).to.exist()
+    })
+  })
+})

test/keys/secp256k1.spec.js

@@ -0,0 +1,80 @@
+/* eslint-env mocha */
+'use strict'
+
+const chai = require('chai')
+const dirtyChai = require('dirty-chai')
+const expect = chai.expect
+chai.use(dirtyChai)
+const sinon = require('sinon')
+
+const fixtures = require('../fixtures/secp256k1')
+const crypto = require('../../src')
+
+describe('without libp2p-crypto-secp256k1 module present', () => {
+  before(() => {
+    sinon.replace(crypto.keys.supportedKeys, 'secp256k1', null)
+  })
+
+  after(() => {
+    sinon.restore()
+  })
+
+  it('fails to generate a secp256k1 key', async () => {
+    try {
+      await crypto.keys.generateKeyPair('secp256k1', 256)
+    } catch (err) {
+      return // expected
+    }
+    throw new Error('Expected error to be thrown')
+  })
+
+  it('fails to unmarshal a secp256k1 private key', async () => {
+    try {
+      await crypto.keys.unmarshalPrivateKey(fixtures.pbmPrivateKey)
+    } catch (err) {
+      return // expected
+    }
+    throw new Error('Expected error to be thrown')
+  })
+
+  it('fails to unmarshal a secp256k1 public key', () => {
+    expect(() => {
+      crypto.keys.unmarshalPublicKey(fixtures.pbmPublicKey)
+    }).to.throw(Error)
+  })
+})
+
+describe('with libp2p-crypto-secp256k1 module present', () => {
+  it('generates a valid key', async () => {
+    const key = await crypto.keys.generateKeyPair('secp256k1', 256)
+    expect(key).to.exist()
+  })
+
+  it('protobuf encoding', async () => {
+    const key = await crypto.keys.generateKeyPair('secp256k1', 256)
+    expect(key).to.exist()
+
+    const keyMarshal = crypto.keys.marshalPrivateKey(key)
+    const key2 = await crypto.keys.unmarshalPrivateKey(keyMarshal)
+    const keyMarshal2 = crypto.keys.marshalPrivateKey(key2)
+
+    expect(keyMarshal).to.eql(keyMarshal2)
+
+    const pk = key.public
+    const pkMarshal = crypto.keys.marshalPublicKey(pk)
+    const pk2 = crypto.keys.unmarshalPublicKey(pkMarshal)
+    const pkMarshal2 = crypto.keys.marshalPublicKey(pk2)
+
+    expect(pkMarshal).to.eql(pkMarshal2)
+  })
+
+  it('unmarshals a secp256k1 private key', async () => {
+    const key = await crypto.keys.unmarshalPrivateKey(fixtures.pbmPrivateKey)
+    expect(key).to.exist()
+  })
+
+  it('unmarshals a secp256k1 public key', () => {
+    const key = crypto.keys.unmarshalPublicKey(fixtures.pbmPublicKey)
+    expect(key).to.exist()
+  })
+})

test/node.js

@@ -0,0 +1,3 @@
+'use strict'
+
+require('./keys/rsa-crypto-libs')

test/rsa.spec.js

@@ -1,178 +0,0 @@
-/* eslint-env mocha */
-'use strict'
-
-const expect = require('chai').expect
-const Buffer = require('safe-buffer').Buffer
-
-const crypto = require('../src')
-const rsa = crypto.keys.rsa
-const fixtures = require('./fixtures/go-key-rsa')
-
-describe('RSA', () => {
-  let key
-  before((done) => {
-    crypto.generateKeyPair('RSA', 2048, (err, _key) => {
-      if (err) return done(err)
-      key = _key
-      done()
-    })
-  })
-
-  it('generates a valid key', (done) => {
-    expect(
-      key
-    ).to.be.an.instanceof(
-      rsa.RsaPrivateKey
-    )
-
-    key.hash((err, digest) => {
-      if (err) {
-        return done(err)
-      }
-
-      expect(digest).to.have.length(34)
-      done()
-    })
-  })
-
-  it('signs', (done) => {
-    const text = key.genSecret()
-
-    key.sign(text, (err, sig) => {
-      if (err) {
-        return done(err)
-      }
-
-      key.public.verify(text, sig, (err, res) => {
-        if (err) {
-          return done(err)
-        }
-
-        expect(res).to.be.eql(true)
-        done()
-      })
-    })
-  })
-
-  it('encoding', (done) => {
-    const keyMarshal = key.marshal()
-    rsa.unmarshalRsaPrivateKey(keyMarshal, (err, key2) => {
-      if (err) {
-        return done(err)
-      }
-      const keyMarshal2 = key2.marshal()
-
-      expect(
-        keyMarshal
-      ).to.be.eql(
-        keyMarshal2
-      )
-
-      const pk = key.public
-      const pkMarshal = pk.marshal()
-      const pk2 = rsa.unmarshalRsaPublicKey(pkMarshal)
-      const pkMarshal2 = pk2.marshal()
-
-      expect(
-        pkMarshal
-      ).to.be.eql(
-        pkMarshal2
-      )
-      done()
-    })
-  })
-
-  describe('key equals', () => {
-    it('equals itself', () => {
-      expect(
-        key.equals(key)
-      ).to.be.eql(
-        true
-      )
-
-      expect(
-        key.public.equals(key.public)
-      ).to.be.eql(
-        true
-      )
-    })
-
-    it('not equals other key', (done) => {
-      crypto.generateKeyPair('RSA', 2048, (err, key2) => {
-        if (err) return done(err)
-
-        expect(
-          key.equals(key2)
-        ).to.be.eql(
-          false
-        )
-
-        expect(
-          key2.equals(key)
-        ).to.be.eql(
-          false
-        )
-
-        expect(
-          key.public.equals(key2.public)
-        ).to.be.eql(
-          false
-        )
-
-        expect(
-          key2.public.equals(key.public)
-        ).to.be.eql(
-          false
-        )
-        done()
-      })
-    })
-  })
-
-  it('sign and verify', (done) => {
-    const data = Buffer.from('hello world')
-    key.sign(data, (err, sig) => {
-      if (err) {
-        return done(err)
-      }
-
-      key.public.verify(data, sig, (err, valid) => {
-        if (err) {
-          return done(err)
-        }
-        expect(valid).to.be.eql(true)
-        done()
-      })
-    })
-  })
-
-  it('fails to verify for different data', (done) => {
-    const data = Buffer.from('hello world')
-    key.sign(data, (err, sig) => {
-      if (err) {
-        return done(err)
-      }
-
-      key.public.verify(Buffer.from('hello'), sig, (err, valid) => {
-        if (err) {
-          return done(err)
-        }
-        expect(valid).to.be.eql(false)
-        done()
-      })
-    })
-  })
-
-  describe('go interop', () => {
-    it('verifies with data from go', (done) => {
-      const key = crypto.unmarshalPublicKey(fixtures.verify.publicKey)
-
-      key.verify(fixtures.verify.data, fixtures.verify.signature, (err, ok) => {
-        if (err) throw err
-        expect(err).to.not.exist
-        expect(ok).to.be.eql(true)
-        done()
-      })
-    })
-  })
-})

test/util.spec.js

@@ -2,8 +2,12 @@
 /* eslint-env mocha */
 'use strict'
 
-const expect = require('chai').expect
-const util = require('../src/crypto/util')
+const chai = require('chai')
+const dirtyChai = require('dirty-chai')
+const expect = chai.expect
+chai.use(dirtyChai)
+
+const util = require('../src/util')
 const BN = require('bn.js')
 
 describe('Util', () => {
@@ -15,7 +19,13 @@ describe('Util', () => {
   })
 
   it('toBase64', (done) => {
-    expect(util.toBase64(bn)).to.be.eql('3q0')
+    expect(util.toBase64(bn)).to.eql('3q0')
+    done()
+  })
+
+  it('toBase64 zero padding', (done) => {
+    let bnpad = new BN('ff', 16)
+    expect(util.toBase64(bnpad, 2)).to.eql('AP8')
     done()
   })
 })