feat(rsa): always use the fastest method available for rsa keygeneration

.aegir.js

@@ -8,6 +8,9 @@ module.exports = {
       alias: {
         'node-forge': path.resolve(__dirname, 'vendor/forge.bundle.js')
       }
+    },
+    externals: {
+      ursa: '{}'
     }
   }
 }

README.md

@@ -21,7 +21,7 @@ needed for libp2p. This is based on this [go implementation](https://github.com/
 - [Usage](#usage)
   - [Example](#example)
 - [API](#api)
-  - [`generateKeyPair(type, bits)`](#generatekeypairtype-bits)
+  - [`generateKeyPair(type, bits, cb)`](#generatekeypairtype-bits-cb)
   - [`generateEphemeralKeyPair(curve)`](#generateephemeralkeypaircurve)
   - [`keyStretcher(cipherType, hashType, secret)`](#keystretcherciphertype-hashtype-secret)
   - [`marshalPublicKey(key[, type])`](#marshalpublickeykey-type)
@@ -44,15 +44,17 @@ npm install --save libp2p-crypto
 ```js
 const crypto = require('libp2p-crypto')
 
-var keyPair = crypto.generateKeyPair('RSA', 2048)
+crypto.generateKeyPair('RSA', 2048, (err, key) => {
+})
 ```
 
 ## API
 
-### `generateKeyPair(type, bits)`
+### `generateKeyPair(type, bits, cb)`
 
 - `type: String`, only `'RSA'` is currently supported
 - `bits: Number`
+- `cb: Function`
 
 Generates a keypair of the given type and bitsize.
 

package.json

@@ -2,7 +2,7 @@
   "name": "libp2p-crypto",
   "version": "0.6.1",
   "description": "Crypto primitives for libp2p",
-  "main": "lib/index.js",
+  "main": "src/index.js",
   "jsnext:main": "src/index.js",
   "scripts": {
     "lint": "aegir-lint",
@@ -55,5 +55,8 @@
     "Friedel Ziegelmayer <[email protected]>",
     "Richard Littauer <[email protected]>",
     "greenkeeperio-bot <[email protected]>"
-  ]
-}
+  ],
+  "optionalDependencies": {
+    "ursa": "^0.9.4"
+  }
+}

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) => {
+exports.generateKeyPair = (type, bits, cb) => {
   let key = keys[type.toLowerCase()]
   if (!key) {
     throw new Error('invalid or unsupported key type')
   }
 
-  return key.generateKeyPair(bits)
+  return key.generateKeyPair(bits, cb)
 }
 
 // Converts a protobuf serialized public key into its

src/keys/rsa.js

@@ -127,9 +127,39 @@ function unmarshalRsaPublicKey (bytes) {
   return new RsaPublicKey(key)
 }
 
-function generateKeyPair (bits) {
-  const p = rsa.generateKeyPair({bits})
-  return new RsaPrivateKey(p.privateKey, p.publicKey)
+function fastKeys (bits, cb) {
+  if (typeof window === 'undefined') {
+    let ursa
+    try {
+      ursa = require('ursa')
+    } catch (err) {
+    }
+
+    if (ursa && ursa.generatePrivateKey) {
+      const key = ursa.generatePrivateKey(bits, 65537)
+      cb(null, {
+        privateKey: pki.privateKeyFromPem(key.toPrivatePem().toString()),
+        publicKey: pki.publicKeyFromPem(key.toPublicPem().toString())
+      })
+      return
+    }
+  }
+
+  rsa.generateKeyPair({
+    bits,
+    workers: -1,
+    workerScript: utils.workerScript
+  }, cb)
+}
+
+function generateKeyPair (bits, cb) {
+  fastKeys(bits, (err, p) => {
+    if (err) {
+      return cb(err)
+    }
+
+    cb(null, new RsaPrivateKey(p.privateKey, p.publicKey))
+  })
 }
 
 module.exports = {

src/utils.js

@@ -1,8 +1,38 @@
 'use strict'
 
+const fs = require('fs')
+const path = require('path')
 const multihashing = require('multihashing')
 
 // 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 window.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,8 +8,12 @@ const fixtures = require('./fixtures/go-key-rsa')
 
 describe('libp2p-crypto', () => {
   let key
-  before(() => {
-    key = crypto.generateKeyPair('RSA', 2048)
+  before((done) => {
+    crypto.generateKeyPair('RSA', 2048, (err, _key) => {
+      if (err) return done(err)
+      key = _key
+      done()
+    })
   })
 
   it('marshalPublicKey and unmarshalPublicKey', () => {

test/rsa.spec.js

@@ -8,8 +8,12 @@ const rsa = crypto.keys.rsa
 
 describe('RSA', () => {
   let key
-  before(() => {
-    key = crypto.generateKeyPair('RSA', 2048)
+  before((done) => {
+    crypto.generateKeyPair('RSA', 2048, (err, _key) => {
+      if (err) return done(err)
+      key = _key
+      done()
+    })
   })
 
   it('generates a valid key', () => {
@@ -76,32 +80,35 @@ describe('RSA', () => {
       )
     })
 
-    it('not equals other key', () => {
-      const key2 = crypto.generateKeyPair('RSA', 2048)
-
-      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
-      )
+    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()
+      })
     })
   })