feat: replace lib multihashing with multihashing-async

Author: nikuda

.gitignore

@@ -31,5 +31,4 @@ build
 # https://www.npmjs.org/doc/misc/npm-faq.html#should-i-check-my-node_modules-folder-into-git
 node_modules
 
-lib
 dist

.travis.yml

@@ -1,9 +1,16 @@
 sudo: false
 language: node_js
-node_js:
-  - 4
-  - 5
-  - stable
+
+matrix:
+  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
 
 # Make sure we have new NPM.
 before_install:
@@ -22,9 +29,6 @@ before_script:
 after_success:
   - npm run coverage-publish
 
-env:
-  - CXX=g++-4.8
-
 addons:
   firefox: 'latest'
   apt:

API.md

@@ -9,6 +9,11 @@
 [![Circle CI](https://circleci.com/gh/libp2p/js-libp2p-crypto.svg?style=svg)](https://circleci.com/gh/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
 
@@ -21,6 +26,22 @@ needed for libp2p. This is based on this [go implementation](https://github.com/
 - [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)
 
@@ -43,7 +64,127 @@ crypto.generateKeyPair('RSA', 2048, (err, key) => {
 
 ## API
 
-See [API.md](API.md)
+### `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.
+
+#### `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)`
+
+- `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)`
+
+- `data: Buffer`
+- `callback: Function`
+
+##### `encrypt(data, callback)`
+
+- `data: Buffer`
+- `callback: Function`
+
+
+### `webcrypto`
+
+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`.
+
+### `keys`
+
+### `generateKeyPair(type, bits, callback)`
+
+- `type: String`, only `'RSA'` is currently supported
+- `bits: Number` Minimum of 1024
+- `callback: Function`
+
+Generates a keypair of the given type and bitsize.
+
+### `generateEphemeralKeyPair(curve, callback)`
+
+- `curve: String`, one of `'P-256'`, `'P-384'`, `'P-521'` is currently supported
+- `callback: Function`
+
+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
+
+```js
+{
+  key: Buffer,
+  genSharedKey: Function
+}
+```
+
+### `keyStretcher(cipherType, hashType, secret, callback)`
+
+- `cipherType: String`, one of `'AES-128'`, `'AES-256'`, `'Blowfish'`
+- `hashType: String`, one of `'SHA1'`, `SHA256`, `SHA512`
+- `secret: Buffer`
+- `callback: Function`
+
+Generates a set of keys for each party by stretching the shared key.
+
+Calls back with an object of the form
+```js
+{
+  k1: {
+    iv: Buffer,
+    cipherKey: Buffer,
+    macKey: Buffer
+  },
+  k2: {
+    iv: Buffer,
+    cipherKey: Buffer,
+    macKey: Buffer
+  }
+}
+```
+
+### `marshalPublicKey(key[, type], callback)`
+
+- `key: crypto.rsa.RsaPublicKey`
+- `type: String`, only `'RSA'` is currently supported
+
+Converts a public key object into a protobuf serialized public key.
+
+### `unmarshalPublicKey(buf)`
+
+- `buf: Buffer`
+
+Converts a protobuf serialized public key into its  representative object.
+
+### `marshalPrivateKey(key[, type])`
+
+- `key: crypto.rsa.RsaPrivateKey`
+- `type: String`, only `'RSA'` is currently supported
+
+Converts a private key object into a protobuf serialized private key.
+
+### `unmarshalPrivateKey(buf, callback)`
+
+- `buf: Buffer`
+- `callback: Function`
+
+Converts a protobuf serialized private key into its representative object.
+
 
 ## Contribute
 

README.md

@@ -11,9 +11,13 @@ 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
+      if (err) {
+        throw err
+      }
       res.genSharedKey(res.key, (err, secret) => {
-        if (err) throw err
+        if (err) {
+          throw err
+        }
         secrets.push(secret)
 
         d.resolve()
@@ -25,9 +29,9 @@ curves.forEach((curve) => {
 })
 
 suite
-.on('cycle', (event) => {
-  console.log(String(event.target))
-})
-.run({
-  'async': true
-})
+  .on('cycle', (event) => {
+    console.log(String(event.target))
+  })
+  .run({
+    'async': true
+  })

benchmarks/ephemeral-keys.js

@@ -11,10 +11,14 @@ const ciphers = ['AES-128', 'AES-256', 'Blowfish']
 const hashes = ['SHA1', 'SHA256', 'SHA512']
 
 crypto.generateEphemeralKeyPair('P-256', (err, res) => {
-  if (err) throw err
+  if (err) {
+    throw err
+  }
 
   res.genSharedKey(res.key, (err, secret) => {
-    if (err) throw err
+    if (err) {
+      throw err
+    }
     ciphers.forEach((cipher) => {
       hashes.forEach((hash) => {
         suite.add(`keyStretcher ${cipher} ${hash}`, (d) => {
@@ -31,13 +35,13 @@ crypto.generateEphemeralKeyPair('P-256', (err, res) => {
         })
       })
     })
-
-    suite
-      .on('cycle', (event) => {
-        console.log(String(event.target))
-      })
-      .run({
-        'async': true
-      })
   })
 })
+
+suite
+  .on('cycle', (event) => {
+    console.log(String(event.target))
+  })
+  .run({
+    'async': true
+  })