chore: release version v0.6.0

Update aegir to version 8.0.0 🚀

README.md

@@ -1,8 +1,9 @@
-# JavaScript libp2p Crytpo
+# 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/ipfs/js-libp2p-crypto/badge.svg?branch=master)](https://coveralls.io/github/ipfs/js-libp2p-crypto?branch=master)
 [![Travis CI](https://travis-ci.org/ipfs/js-libp2p-crypto.svg?branch=master)](https://travis-ci.org/ipfs/js-libp2p-crypto)
 [![Circle CI](https://circleci.com/gh/ipfs/js-libp2p-crypto.svg?style=svg)](https://circleci.com/gh/ipfs/js-libp2p-crypto)
@@ -10,19 +11,47 @@
 
 > Crypto primitives for libp2p in JavaScript
 
-## Description
-
 This repo contains the JavaScript implementation of the crypto primitives
 needed for libp2p. This is based on this [go implementation](https://github.com/ipfs/go-libp2p-crypto).
 
+## Table of Contents
+
+- [Install](#install)
+- [Usage](#usage)
+  - [Example](#example)
+- [API](#api)
+  - [`generateKeyPair(type, bits)`](#generatekeypairtype-bits)
+  - [`generateEphemeralKeyPair(curve)`](#generateephemeralkeypaircurve)
+  - [`keyStretcher(cipherType, hashType, secret)`](#keystretcherciphertype-hashtype-secret)
+  - [`marshalPublicKey(key[, type])`](#marshalpublickeykey-type)
+  - [`unmarshalPublicKey(buf)`](#unmarshalpublickeybuf)
+  - [`marshalPrivateKey(key[, type])`](#marshalprivatekeykey-type)
+  - [`unmarshalPrivateKey(buf)`](#unmarshalprivatekeybuf)
+- [Contribute](#contribute)
+- [License](#license)
+
+## Install
+
+```sh
+npm install --save libp2p-crypto
+```
+
+## Usage
+
+### Example
+
+```js
+const crypto = require('libp2p-crypto')
+
+var keyPair = crypto.generateKeyPair('RSA', 2048)
+```
 
 ## API
 
-### `generateKeyPair(type, bits, cb)`
+### `generateKeyPair(type, bits)`
 
 - `type: String`, only `'RSA'` is currently supported
 - `bits: Number`
-- `cb: Function`, with the signature `function (err, privateKey)`
 
 Generates a keypair of the given type and bitsize.
 
@@ -90,3 +119,15 @@ Converts a private key object into a protobuf serialized private key.
 - `buf: Buffer`
 
 Converts a protobuf serialized private key into its  representative object.
+
+## Contribute
+
+Feel free to join in. All welcome. Open an [issue](https://github.com/ipfs/js-libp2p-crypto/issues)!
+
+This repository falls under the IPFS [Code of Conduct](https://github.com/ipfs/community/blob/master/code-of-conduct.md).
+
+[![](https://cdn.rawgit.com/jbenet/contribute-ipfs-gif/master/img/contribute.gif)](https://github.com/ipfs/community/blob/master/contributing.md)
+
+## License
+
+[MIT](LICENSE)

package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2p-crypto",
-  "version": "0.3.0",
+  "version": "0.6.0",
   "description": "Crypto primitives for libp2p",
   "main": "lib/index.js",
   "jsnext:main": "src/index.js",
@@ -31,7 +31,7 @@
     "protocol-buffers": "^3.1.6"
   },
   "devDependencies": {
-    "aegir": "^3.0.4",
+    "aegir": "^8.0.0",
     "chai": "^3.5.0",
     "pre-commit": "^1.1.3"
   },
@@ -51,6 +51,9 @@
   },
   "homepage": "https://github.com/ipfs/js-libp2p-crypto",
   "contributors": [
-    "Friedel Ziegelmayer <dignifiedquire@gmail.com>"
+    "David Dias <daviddias.p@gmail.com>",
+    "Friedel Ziegelmayer <dignifiedquire@gmail.com>",
+    "Richard Littauer <richard.littauer@gmail.com>",
+    "greenkeeperio-bot <support@greenkeeper.io>"
   ]
 }

src/ephemeral-keys.js

@@ -26,11 +26,11 @@ module.exports = (curveName) => {
   const genSharedKey = (theirPub, forcePrivate) => {
     const pub = ec.keyFromPublic(theirPub, 'hex')
     const p = forcePrivate || priv
-    return p.derive(pub.getPublic()).toBuffer('le')
+    return p.derive(pub.getPublic()).toBuffer('be')
   }
 
   return {
-    key: priv.getPublic(),
+    key: new Buffer(priv.getPublic('hex'), 'hex'),
     genSharedKey
   }
 }

src/index.js

@@ -12,13 +12,13 @@ exports.keyStretcher = require('./key-stretcher')
 exports.generateEphemeralKeyPair = require('./ephemeral-keys')
 
 // Generates a keypair of the given type and bitsize
-exports.generateKeyPair = (type, bits, cb) => {
+exports.generateKeyPair = (type, bits) => {
   let key = keys[type.toLowerCase()]
   if (!key) {
     throw new Error('invalid or unsupported key type')
   }
 
-  key.generateKeyPair(bits, cb)
+  return key.generateKeyPair(bits)
 }
 
 // Converts a protobuf serialized public key into its

src/key-stretcher.js

@@ -21,7 +21,8 @@ const cipherMap = {
 const hashMap = {
   SHA1: 'sha1',
   SHA256: 'sha256',
-  SHA512: 'sha512'
+  // workaround for https://github.com/digitalbazaar/forge/issues/401
+  SHA512: forge.md.sha512.create()
 }
 
 // Generates a set of keys for each party by stretching the shared key.

src/keys/rsa.js

@@ -19,7 +19,11 @@ class RsaPublicKey {
 
   verify (data, sig) {
     const md = forge.md.sha256.create()
-    md.update(data, 'utf8')
+    if (Buffer.isBuffer(data)) {
+      md.update(data.toString('binary'), 'binary')
+    } else {
+      md.update(data)
+    }
 
     return this._key.verify(md.digest().bytes(), sig)
   }
@@ -51,7 +55,11 @@ class RsaPublicKey {
 class RsaPrivateKey {
   constructor (privKey, pubKey) {
     this._privateKey = privKey
-    this._publicKey = pubKey
+    if (pubKey) {
+      this._publicKey = pubKey
+    } else {
+      this._publicKey = forge.pki.setRsaPublicKey(privKey.n, privKey.e)
+    }
   }
 
   genSecret () {
@@ -60,9 +68,13 @@ class RsaPrivateKey {
 
   sign (message) {
     const md = forge.md.sha256.create()
-    md.update(message, 'utf8')
-
-    return this._privateKey.sign(md)
+    if (Buffer.isBuffer(message)) {
+      md.update(message.toString('binary'), 'binary')
+    } else {
+      md.update(message)
+    }
+    const raw = this._privateKey.sign(md, 'RSASSA-PKCS1-V1_5')
+    return new Buffer(raw, 'binary')
   }
 
   get public () {
@@ -115,15 +127,9 @@ function unmarshalRsaPublicKey (bytes) {
   return new RsaPublicKey(key)
 }
 
-function generateKeyPair (bits, cb) {
-  rsa.generateKeyPair({
-    bits,
-    workerScript: utils.workerScript
-  }, (err, p) => {
-    if (err) return cb(err)
-
-    cb(null, new RsaPrivateKey(p.privateKey, p.publicKey))
-  })
+function generateKeyPair (bits) {
+  const p = rsa.generateKeyPair({bits})
+  return new RsaPrivateKey(p.privateKey, p.publicKey)
 }
 
 module.exports = {

src/utils.js

@@ -1,40 +1,8 @@
 'use strict'
 
 const multihashing = require('multihashing')
-const path = require('path')
-const fs = require('fs')
-
-const URL = global.window && (window.URL || window.webkitURL)
 
 // Hashes a key
 exports.keyHash = (bytes) => {
   return multihashing(bytes, 'sha2-256')
 }
-
-const toBlob = (content) => {
-  try {
-    let blob
-    try {
-      // BlobBuilder = Deprecated, but widely implemented
-      const BlobBuilder = global.window &&
-              (window.BlobBuilder ||
-              window.WebKitBlobBuilder ||
-              window.MozBlobBuilder ||
-              window.MSBlobBuilder)
-
-      blob = new BlobBuilder()
-      blob.append(content)
-      blob = blob.getBlob()
-    } catch (e) {
-      // The proposed API
-      blob = new window.Blob([content])
-    }
-    return URL.createObjectURL(blob)
-  } catch (e) {
-    return 'data:application/javascript,' + encodeURIComponent(content)
-  }
-}
-
-const rawScript = fs.readFileSync(path.join(__dirname, '../vendor/prime.worker.js'))
-
-exports.workerScript = toBlob(rawScript.toString())

test/index.spec.js

@@ -8,12 +8,8 @@ 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()
-    })
+  before(() => {
+    key = crypto.generateKeyPair('RSA', 2048)
   })
 
   it('marshalPublicKey and unmarshalPublicKey', () => {

test/key-stretcher.spec.js

@@ -1,3 +1,4 @@
+/* eslint max-nested-callbacks: ["error", 8] */
 /* eslint-env mocha */
 'use strict'
 
@@ -9,8 +10,7 @@ const fixtures = require('./fixtures/go-stretch-key')
 describe('keyStretcher', () => {
   describe('generate', () => {
     const ciphers = ['AES-128', 'AES-256', 'Blowfish']
-    const hashes = ['SHA1', 'SHA256']
-    // add 'SHA512' when https://github.com/digitalbazaar/forge/issues/401 is resolved
+    const hashes = ['SHA1', 'SHA256', 'SHA512']
     const res = crypto.generateEphemeralKeyPair('P-256')
     const secret = res.genSharedKey(res.key)
 

test/rsa.spec.js

@@ -8,12 +8,8 @@ const rsa = crypto.keys.rsa
 
 describe('RSA', () => {
   let key
-  before((done) => {
-    crypto.generateKeyPair('RSA', 2048, (err, _key) => {
-      if (err) return done(err)
-      key = _key
-      done()
-    })
+  before(() => {
+    key = crypto.generateKeyPair('RSA', 2048)
   })
 
   it('generates a valid key', () => {
@@ -80,36 +76,54 @@ describe('RSA', () => {
       )
     })
 
-    it('not equals other key', (done) => {
-      crypto.generateKeyPair('RSA', 2048, (err, key2) => {
-        if (err) return done(err)
+    it('not equals other key', () => {
+      const key2 = crypto.generateKeyPair('RSA', 2048)
 
-        expect(
-          key.equals(key2)
-        ).to.be.eql(
-          false
-        )
+      expect(
+        key.equals(key2)
+      ).to.be.eql(
+        false
+      )
 
-        expect(
-          key2.equals(key)
-        ).to.be.eql(
-          false
-        )
+      expect(
+        key2.equals(key)
+      ).to.be.eql(
+        false
+      )
 
-        expect(
-          key.public.equals(key2.public)
-        ).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()
-      })
+      expect(
+        key2.public.equals(key.public)
+      ).to.be.eql(
+        false
+      )
     })
   })
+
+  it('sign and verify', () => {
+    const data = new Buffer('hello world')
+    const sig = key.sign(data)
+
+    expect(
+      key.public.verify(data, sig)
+    ).to.be.eql(
+      true
+    )
+  })
+
+  it('does fails to verify for different data', () => {
+    const data = new Buffer('hello world')
+    const sig = key.sign(data)
+
+    expect(
+      key.public.verify(new Buffer('hello'), sig)
+    ).to.be.eql(
+      false
+    )
+  })
 })