Merge branch 'test-derived-keys' of CoBox/kappa-drive into development

index.js

@@ -431,7 +431,11 @@ class KappaDrive extends EventEmitter {
     var self = this
     self.core._logs.ready(() => {
       self.key = self.core._logs._root.key
-      const opts = [2, 1, 0].map((n) => { return self.keyPair ? { keypair: self.keyPair(self.key, n) } : {} })
+      const opts = [2, 1, 0].map((n) => (
+        self.keyPair
+          ? { keypair: self.keyPair(n, self.key) }
+          : {}
+      ))
 
       self.core._logs.writer(STATE, opts.pop(), (err, state) => {
         if (err) return callback(err)

package.json

@@ -27,7 +27,6 @@
     "memdb": "^1.3.1",
     "minimist": "^1.2.0",
     "mountable-hypertrie": "^0.10.4",
-    "multifeed": "^4.1.5",
     "protocol-buffers": "^4.1.0",
     "random-access-memory": "^3.1.1",
     "through2": "^3.0.1",
@@ -35,6 +34,7 @@
     "unixify": "^1.0.0"
   },
   "devDependencies": {
+    "hypercore": "^8.3.0",
     "mkdirp": "^0.5.1",
     "nyc": "^14.1.1",
     "pump": "^3.0.0",
@@ -44,6 +44,9 @@
     "tape-plus": "^1.0.0",
     "tmp": "^0.1.0"
   },
+  "resolutions": {
+    "kappa-core/multifeed": "^5.1.1"
+  },
   "directories": {
     "test": "test"
   },

test/index.test.js

@@ -2,6 +2,8 @@ const { describe } = require('tape-plus')
 const ram = require('random-access-memory')
 const crypto = require('hypercore-crypto')
 const fs = require('fs')
+const sodium = require('sodium-native')
+const hypercore = require('hypercore')
 
 const KappaDrive = require('../')
 
@@ -307,8 +309,10 @@ describe('basic', (context) => {
 
 describe('multiwriter', (context) => {
   context('replicate to empty drive', (assert, next) => {
-    var drive = KappaDrive(tmp())
-    var drive2 = KappaDrive(tmp())
+    var storage1 = tmp()
+    var storage2 = tmp()
+    var drive = KappaDrive(storage1)
+    var drive2 = KappaDrive(storage2)
 
     drive.ready((err) => {
       assert.error(err, 'No error on drive.ready')
@@ -326,7 +330,7 @@ describe('multiwriter', (context) => {
           drive2.readFile('/hello.txt', 'utf-8', (err, data) => {
             assert.error(err, 'no error')
             assert.same(data, 'world', 'gets latest value')
-            next()
+            cleanup([storage1, storage2], next)
           })
         })
       })
@@ -334,8 +338,10 @@ describe('multiwriter', (context) => {
   })
 
   context('defaults to latest value', (assert, next) => {
-    var drive = KappaDrive(tmp())
-    var drive2 = KappaDrive(tmp())
+    var storage1 = tmp()
+    var storage2 = tmp()
+    var drive = KappaDrive(storage1)
+    var drive2 = KappaDrive(storage2)
 
     drive.ready((err) => {
       assert.error(err, 'No error on drive.ready')
@@ -367,7 +373,7 @@ describe('multiwriter', (context) => {
                 drive.readFile('/hello.txt', (err, data) => {
                   assert.error(err, 'no error')
                   assert.same(data, Buffer.from('verden'), 'gets latest value')
-                  next()
+                  cleanup([storage1, storage2], next)
                 })
               })
             })
@@ -378,8 +384,10 @@ describe('multiwriter', (context) => {
   })
 
   context('defalts to latest value with file descriptors', (assert, next) => {
-    var drive = KappaDrive(tmp())
-    var drive2 = KappaDrive(tmp())
+    var storage1 = tmp()
+    var storage2 = tmp()
+    var drive = KappaDrive(storage1)
+    var drive2 = KappaDrive(storage2)
 
     drive.ready((err) => {
       assert.error(err, 'No error on drive.ready')
@@ -412,7 +420,7 @@ describe('multiwriter', (context) => {
           drive2.read(fd, data, 0, 5, null, (err, bytesRead, readData) => {
             assert.error(err, 'no error')
             assert.same(readData, Buffer.from('world'), 'gets latest value')
-            next()
+            cleanup([storage1, storage2], next)
           })
         })
       })
@@ -459,14 +467,9 @@ describe('multiwriter', (context) => {
 
 // TODO: figure out why this resolves incorrectly when in memory
 describe('conflict', (context) => {
-  var storage1, storage2
-
-  context.beforeEach((c) => {
-    storage1 = tmp()
-    storage2 = tmp()
-  })
-
   context('fork', (assert, next) => {
+    var storage1 = tmp()
+    var storage2 = tmp()
     var drive = KappaDrive(storage1)
     var drive2 = KappaDrive(storage2)
 
@@ -500,7 +503,7 @@ describe('conflict', (context) => {
           drive.readFile('/hello.txt', 'utf-8', (err, data) => {
             assert.error(err, 'no error')
             assert.same(data, 'whateverr', 'forked values')
-            cleanup('./tmp', next)
+            cleanup([storage1, storage1], next)
           })
         })
       })
@@ -530,3 +533,98 @@ describe('read access', (context) => {
     })
   })
 })
+
+describe('replicate with derived keypair', (context) => {
+  context('regular hypercore using derived keypair', (assert, next) => {
+    var storage1 = tmp()
+    var storage2 = tmp()
+    var master = masterKey()
+    var keys = keyPair(master, 0)
+
+    assert.ok(keys, 'generates keys')
+
+    var core1 = hypercore(storage1, keys.publicKey, { secretKey: keys.secretKey })
+    var core2 = hypercore(storage2, keys.publicKey)
+
+    var dog = 'dog'
+    core1.append(dog, (err, seq) => {
+      assert.error(err, 'no error')
+      replicate(core1, core2, (err) => {
+        assert.error(err, 'no error')
+
+        core2.get(0, (err, msg) => {
+          assert.error(err, 'no error')
+          assert.same(msg.toString(), dog, 'gets the dog')
+          cleanup([storage1, storage2], next)
+        })
+      })
+    })
+  })
+
+  context('using a master key, defaults to latest value', (assert, next) => {
+    var storage1 = tmp()
+    var storage2 = tmp()
+
+    var master1 = masterKey()
+    var master2 = masterKey()
+
+    var keyPair1 = keyPair.bind(null, master1)
+    var keyPair2 = keyPair.bind(null, master2)
+
+    var drive = KappaDrive(storage1, { keyPair: keyPair1 })
+    var drive2 = KappaDrive(storage2, { keyPair: keyPair2 })
+
+    drive.ready((err) => {
+      assert.error(err, 'No error on drive.ready')
+      drive.writeFile('/hello.txt', 'world', (err) => {
+        assert.error(err, 'no error')
+        drive.writeFile('/hello.txt', 'mundo', (err) => {
+          assert.error(err, 'no error')
+          sync()
+        })
+      })
+    })
+
+    function writeSecond (cb) {
+      drive2.writeFile('/hello.txt', 'verden', (err) => {
+        assert.error(err, 'no error')
+        cb()
+      })
+    }
+
+    function sync () {
+      drive2.ready(() => {
+        drive2.writeFile('test.txt', 'testing', (err) => {
+          assert.error(err, 'no error')
+          replicate(drive, drive2, (err) => {
+            assert.error(err, 'no error')
+            writeSecond(() => {
+              replicate(drive, drive2, (err) => {
+                assert.error(err, 'no error')
+                drive.readFile('/hello.txt', (err, data) => {
+                  assert.error(err, 'no error')
+                  assert.same(data, Buffer.from('verden'), 'gets latest value')
+                  cleanup([storage1, storage2], next)
+                })
+              })
+            })
+          })
+        })
+      })
+    }
+  })
+})
+
+function masterKey () {
+  const key = sodium.sodium_malloc(sodium.crypto_kdf_KEYBYTES)
+  sodium.crypto_kdf_keygen(key)
+  return key
+}
+
+function keyPair (masterKey, id, ctxt = 'kappadrive') {
+  const context = sodium.sodium_malloc(sodium.crypto_hash_sha256_BYTES)
+  sodium.crypto_hash_sha256(context, Buffer.from(ctxt))
+  const seed = sodium.sodium_malloc(sodium.crypto_kdf_KEYBYTES)
+  sodium.crypto_kdf_derive_from_key(seed, id, context, masterKey)
+  return crypto.keyPair(seed)
+}

test/util.js

@@ -33,7 +33,7 @@ function cleanup (dirs, cb) {
 }
 
 function tmp () {
-  var path = tmpdir().name
+  var path = '.'+tmpdir().name
   mkdirp.sync(path)
   return path
 }