State-tester testing for removal

Author: bifurcation

src/art-state.js

@@ -76,7 +76,10 @@ class ARTState {
     return { path: path };
   }
 
-  remove(index) {/* TODO */}
+  async remove(index) {
+    /* TODO */
+    return {};
+  }
 
   get groupInitKey() {
     return {
@@ -103,7 +106,9 @@ class ARTState {
     await this.art.merge(update.path);
   }
 
-  handleRemove(remove) {/* TODO */}
+  async handleRemove(remove) {
+    /* TODO */
+  }
 }
 
 module.exports = ARTState;

src/flat-state.js

@@ -60,7 +60,10 @@ class FlatState {
     };
   }
 
-  remove(index) {/* TODO */}
+  async remove(index) {
+    /* TODO */
+    return {};
+  }
 
   get groupInitKey() {
     let publicNodes = {};
@@ -92,7 +95,9 @@ class FlatState {
     this.nodes[2 * update.from].public = update.public;
   }
 
-  handleRemove(remove) {/* TODO */}
+  async handleRemove(remove) {
+    /* TODO */
+  }
 }
 
 module.exports = FlatState;

src/state-tester.js

@@ -178,11 +178,83 @@ async function testUpdate(State, transcode) {
   console.log(`[${label}] PASS`);
 }
 
+async function testRemove(State) {
+  // Create a group via GroupAdds
+  const testGroupSize = 5;
+  let creator = await State.oneMemberGroup(base64.random(32));
+  let members = [creator];
+  for (let i = 1; i < testGroupSize; ++i) {
+    let initLeaf = base64.random(32);
+    let initKP = await iota(initLeaf);
+    let ga = await members[members.length - 1].add(initKP.publicKey)
+
+    for (let m of members) {
+      await m.handleGroupAdd(ga);
+    }
+
+    let joiner = await State.fromGroupAdd(initLeaf, ga);
+    members.push(joiner);
+  }
+
+  // Have the first member remove two members
+  let remover = members[0];
+  let removed = [2, 3];
+  for (let index of removed) {
+    let leaf = base64.random(32);
+    let removeIn = await remover.remove(leaf, index);
+    let removeEnc = JSON.stringify(removeIn);
+    let remove = JSON.parse(removeEnc);
+
+    members = members.filter(x => x.index != index);
+
+    for (let m of members) {
+      await m.handleRemove(remove);
+    }
+
+    for (let m of members) {
+      let eq = await groupEqual(m, remover);
+      if (!eq) {
+        await groupDump(remover.index, remover);
+        await groupDump(m.index, m);
+        throw 'state-remove';
+      }
+    }
+  }
+
+  // Have each remaining member update and verify that others are consistent
+  for (let m1 of members) {
+    let leaf = base64.random(32);
+    let updateIn = await m1.update(leaf);
+    let updateEnc = JSON.stringify(updateIn);
+    let update = JSON.parse(updateEnc);
+
+    await m1.handleSelfUpdate(update, leaf);
+
+    for (let m2 of members) {
+      if (m2.index == m1.index) {
+        continue
+      }
+        
+      await m2.handleUpdate(update);
+
+      let eq = await groupEqual(m1, m2);
+      if (!eq) {
+        await groupDump(m1.index, m1);
+        await groupDump(m2.index, m2);
+        throw 'state-remove';
+      }
+    }
+  }
+  
+  console.log('[state-remove] PASS');
+}
+
 module.exports = {
   test: async function(State) {
     await testUserAdd(State);
     await testGroupAdd(State);
     await testUpdate(State, false);
     await testUpdate(State, true);
+    await testRemove(State);
   },
 };

src/treekem-state.js

@@ -55,7 +55,7 @@ class TreeKEMState {
 
   static async join(leaf, groupInitKey) {
     let tkem = await TreeKEM.fromFrontier(groupInitKey.size, groupInitKey.frontier, leaf);
-    let ct = await tkem.encrypt(leaf)
+    let ct = await tkem.encrypt(leaf, tkem.index)
     return {
       ciphertexts: ct.ciphertexts,
       nodes: ct.nodes,
@@ -80,15 +80,22 @@ class TreeKEMState {
   }
 
   async update(leaf) {
-    let ct = await this.tkem.encrypt(leaf);
+    let ct = await this.tkem.encrypt(leaf, this.tkem.index);
     return {
       from: this.tkem.index,
       ciphertexts: ct.ciphertexts,
       nodes: ct.nodes,
     }
   }
 
-  remove(index) {/* TODO */}
+  async remove(leaf, index) {
+    let ct = await this.tkem.encrypt(leaf, index);
+    return {
+      index: index,
+      ciphertexts: ct.ciphertexts,
+      nodes: ct.nodes,
+    };
+  }
 
   get groupInitKey() {
     return {
@@ -122,7 +129,11 @@ class TreeKEMState {
     this.tkem.merge(pt.nodes);
   }
 
-  handleRemove(remove) {/* TODO */}
+  async handleRemove(remove) {
+    let pt = await this.tkem.decrypt(remove.index, remove.ciphertexts);
+    this.tkem.merge(pt.root);
+    this.tkem.remove(remove.index);
+  }
 }
 
 module.exports = TreeKEMState;

src/treekem.js

@@ -100,10 +100,11 @@ class TreeKEM {
 
   /*
    * Encrypt a fresh root value in a way that all participants in
-   * the group can decrypt (except for the current node).
+   * the group can decrypt, except for an excluded node.
    *
    * Arguments:
    *   * leaf - BufferSource with leaf secret
+   *   * except - index of the node to exclude
    *
    * Returns: Promise resolving to a TreeKEMCiphertext object:
    *   {
@@ -120,12 +121,12 @@ class TreeKEM {
    *     ciphertexts: [ ECKEMCiphertext ]
    *   }
    */
-  async encrypt(leaf) {
-    let dirpath = tm.dirpath(2 * this.index, this.size);
-    let copath = tm.copath(2 * this.index, this.size);
+  async encrypt(leaf, except) {
+    let dirpath = tm.dirpath(2 * except, this.size);
+    let copath = tm.copath(2 * except, this.size);
 
     // Generate hashes up the tree
-    let privateNodes = await TreeKEM.hashUp(2 * this.index, this.size, leaf);
+    let privateNodes = await TreeKEM.hashUp(2 * except, this.size, leaf);
     let nodes = {};
     for (let n in privateNodes) {
       nodes[n] = util.publicNode(privateNodes[n]);
@@ -182,21 +183,39 @@ class TreeKEM {
     let h = await ECKEM.decrypt(encryptions[decNode], this.nodes[decNode].private);
 
     // Hash up to the root (plus one if we're growing the tree)
+    let rootNode = tm.root(senderSize);
     let newDirpath = tm.dirpath(2 * this.index, senderSize);
-    newDirpath.push(tm.root(senderSize));
+    newDirpath.push(rootNode);
     let nodes = await TreeKEM.hashUp(newDirpath[dirIndex+1], senderSize, h);
 
-    let root = tm.root(senderSize);
+    let root = {}
+    root[rootNode] = nodes[root];
+
     return {
+      root: root,
       nodes: nodes,
     }
   }
 
+  /* 
+   * Remove a node from the tree, including its direct path
+   *
+   * Arguments:
+   *   index - Index of the node to remove
+   *
+   * Returns: None
+   */
+  remove(index) {
+    for (let n of tm.dirpath(2 * index, this.size)) {
+      delete this.nodes[n];
+    }
+  }
+
   /*
    * Updates nodes in the tree.
    *
    * Arguments:
-   *   nodes - Dictionary of nodes to udpate: { Int: Node }
+   *   nodes - Dictionary of nodes to update: { Int: Node }
    *
    * Returns: None
    */