Server-side pull RPC

src/main/java/scenario/integrita/Client.java

@@ -9,12 +9,13 @@
 import node.BaseNode;
 import scenario.integrita.events.Push;
 import scenario.integrita.historytree.HistoryTreeNode;
+import scenario.integrita.user.User;
 
 
 /**
  * Integrita client implementation.
  */
-public class Client implements BaseNode {
+public class Client extends User implements BaseNode {
   UUID id;
   MiddleLayer network;
   ArrayList<UUID> ids; // all ids inclding self

src/main/java/scenario/integrita/Server.java

@@ -1,42 +1,180 @@
 package scenario.integrita;
 
 import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.UUID;
 
+import groovy.lang.Tuple;
 import metrics.MetricsCollector;
 import network.MiddleLayer;
 import network.packets.Event;
 import node.BaseNode;
+import scenario.integrita.database.HistoryTreeStore;
 import scenario.integrita.events.PushResp;
 import scenario.integrita.historytree.HistoryTreeNode;
 import scenario.integrita.historytree.NodeAddress;
+import scenario.integrita.signature.Signature;
+import scenario.integrita.user.User;
 import scenario.integrita.utils.StatusCode;
 
 /**
  * Integrita server implementation.
  */
 public class Server implements BaseNode {
+  // Integrita related fields
+  int index; // server's index
+  int totalServers; // total number of servers
+  byte[] vk; // server's verification key
+  byte[] sk; // server's signature key
+  HistoryTreeStore db;
+  NodeAddress status; // the last node address seen by the server
+
+  // simulator related properties
   UUID id;
   MiddleLayer network;
-  ArrayList<UUID> ids; // all ids including self
-  HashMap<NodeAddress, HistoryTreeNode> db = new HashMap<>();
+  // all UUIDs including self
+  ArrayList<UUID> ids;
+
+  // Constructors -------------------------------------------------------------------------
 
+  /**
+   * Constructor.
+   */
   public Server() {
   }
 
+  /**
+   * Constructor.
+   */
   public Server(UUID selfId, MiddleLayer network) {
     this.id = selfId;
     this.network = network;
   }
 
+  /**
+   * Constructor.
+   */
+  public Server(int index, int totalServers) {
+    this.index = index;
+    this.totalServers = totalServers;
+
+    this.db = new HistoryTreeStore();
+
+    // generate signature keys
+    byte[][] keys = Signature.keyGen();
+    this.sk = keys[0];
+    this.vk = keys[1];
+  }
+
+  // getters and setters ---------------------
+
+  public NodeAddress getStatus() {
+    //    TODO add signature
+    return status;
+  }
+
+  // Integrita RPCs ---------------------------------------------------------------------
+
+  /**
+   * receives a HistoryTreeNode and updates its local db accordingly.
+   */
+  public Tuple push(HistoryTreeNode historyTreeNode) {
+    // @TODO check the user membership via signature
+
+    // check whether the node is submitted to the right server
+    int serverIndex = NodeAddress.mapServerIndex(historyTreeNode.addr, totalServers);
+    if (serverIndex != this.index) {
+      return new Tuple(new Object[]{StatusCode.Reject, null});
+    }
+
+    // the difference between the label of supplied node and the status of the server
+    // should be equal to the total number of servers
+    if (this.status != null) {
+      int diff = NodeAddress.toLabel(historyTreeNode.addr) - NodeAddress.toLabel(this.status);
+      if (diff != totalServers) {
+        return new Tuple(new Object[]{StatusCode.Reject, null});
+      }
+    }
+
+    // verify user-side signature on the leaf
+    // needed for the authorization
+    if (NodeAddress.isLeaf(historyTreeNode.addr)) {
+      //  @TODO check the hash value
+      // @TODO retrieve user vk and verify the signature
+      byte[] vk = db.getVerificationKey(historyTreeNode.userId);
+      String msg = historyTreeNode.toLeaf();
+      boolean res = Signature.verify(msg, historyTreeNode.signature, vk);
+      if (res == false) {
+        return new Tuple(new Object[]{StatusCode.Reject, null});
+      }
+    }
+
+    // verify user-side signature on the tree digest
+    if (NodeAddress.isTreeDigest(historyTreeNode.addr)) {
+      // verify signature
+      String msg = historyTreeNode.toLeaf();
+      if (!Signature.verify(msg, historyTreeNode.signature, this.db.getVerificationKey(historyTreeNode.userId))) {
+        new Tuple(new Object[]{StatusCode.Reject, null});
+      }
+    }
+
+    // update the database just for non-temporary nodes
+    if (!NodeAddress.isTemporary(historyTreeNode.addr) || NodeAddress.isTreeDigest(historyTreeNode.addr)) {
+      db.insert(historyTreeNode);
+    }
+
+    // remove tree digests of the old operations
+    // except the first operation
+    db.cleanDigests(historyTreeNode.addr);
+
+    // update the state variable
+    this.status = historyTreeNode.addr;
+
+    // server should sign tree digests
+    if (NodeAddress.isTreeDigest(historyTreeNode.addr)) {
+      String msg = historyTreeNode.toLeaf();
+      byte[] signature = Signature.sign(msg, vk);
+      return new Tuple(new Object[]{StatusCode.Accept, signature});
+    }
+
+    // if nothing goes wrong, then the push request is done successfully
+    return new Tuple(new Object[]{StatusCode.Accept, null});
+  }
+
+  /**
+   * implements the pull algorithm based on Integrita specification.
+   * by this method, a user can retrieve a specific node of history tree from the server.
+   * The method returns a tuple, where the first item is the retrieve history tree node.
+   * The second item is a server-side signature in case that the retrieved node is a tree digest.
+   * Otherwise, the second item is null.
+   */
+  public Tuple pull(User user, NodeAddress nodeAddress) {
+    // check whether user is authorized
+    if (!this.db.contains(user)) {
+      return new Tuple(new Object[]{null, null});
+    }
+
+    if (!this.db.contains(nodeAddress)) {
+      return new Tuple(new Object[]{null, null});
+    }
+
+    HistoryTreeNode res = this.db.get(nodeAddress);
+    byte[] singauture = new byte[0];
+    if (NodeAddress.isTreeDigest(nodeAddress)) {
+      singauture = Signature.sign(res.hash, this.sk);
+    }
+    return new Tuple(new Object[]{res, singauture});
+
+
+  }
+
+  // BaseNode interface implementation ---------------------------------------------------
+
   @Override
   public void onCreate(ArrayList<UUID> allId) {
     this.ids = allId;
     this.network.ready();
   }
 
-  // BaseNode interface implementation ------------
   @Override
   public void onStart() {
 

src/main/java/scenario/integrita/database/HistoryTreeStore.java

@@ -1,7 +1,6 @@
 package scenario.integrita.database;
 
-import java.util.ArrayList;
-import java.util.HashMap;
+import java.util.*;
 
 import scenario.integrita.historytree.HistoryTreeNode;
 import scenario.integrita.historytree.NodeAddress;
@@ -12,9 +11,10 @@
  */
 public class HistoryTreeStore implements Store {
 
-  public HashMap<Integer, User> users;
-  public HashMap<NodeAddress, HistoryTreeNode> historyTreeNodes;
+  private final HashMap<Integer, User> users;
+  private final HashMap<NodeAddress, HistoryTreeNode> historyTreeNodes;
 
+  // constructor ----------------------------------------------
   public HistoryTreeStore() {
     this.users = new HashMap<>();
     this.historyTreeNodes = new HashMap<>();
@@ -25,40 +25,115 @@ public HistoryTreeStore(HashMap<Integer, User> users, HashMap<NodeAddress, Histo
     this.historyTreeNodes = historyTreeNodes;
   }
 
+
+  // getters and setters ---------------------------
   public byte[] getVerificationKey(int userIndex) {
-    return users.get(userIndex).verificationKey;
+    return users.get(userIndex).vk;
+  }
+
+  // utility methods -----------------------------
+  public int totalNodes() {
+    return this.historyTreeNodes.size();
+  }
+
+  public int totalUsers() {
+    return this.users.size();
+  }
+
+  /**
+   * adds all the users supplied by `users` to the `HistoryTreeStore` object.
+   */
+  public boolean insertAllUsers(ArrayList<User> users) {
+    for (User u : users) {
+      this.insert(u);
+    }
+    return true;
+  }
+
+  /**
+   * inserts all the history nodes contained in the `historyTreeNodes` into the `HistoryTreeStore` instance.
+   */
+  public boolean insertAllNodes(ArrayList<HistoryTreeNode> historyTreeNodes) {
+    for (HistoryTreeNode node : historyTreeNodes) {
+      this.insert(node);
+    }
+    return true;
   }
 
+  /**
+   * erases all the past nodes whose `position` precede the position of the supplied `addr` exclusively.
+   */
+  public void cleanDigests(NodeAddress addr) {
+    Set<NodeAddress> keySet = historyTreeNodes.keySet();
+    Iterator<Map.Entry<NodeAddress, HistoryTreeNode>> it = historyTreeNodes.entrySet().iterator();
+    while (it.hasNext()) {
+      Map.Entry<NodeAddress, HistoryTreeNode> entry = it.next();
+      boolean isTreeDigest = NodeAddress.isTreeDigest(entry.getKey());
+      if (isTreeDigest && (entry.getKey().position < addr.position) && (entry.getKey().position != 1)) {
+        it.remove();
+      }
+    }
+  }
+
+  // ------------------- store API -----------------
+
   @Override
   public boolean insert(HistoryTreeNode historyTreeNode) {
+    if (this.contains(historyTreeNode)) {
+      return false;
+    }
     historyTreeNodes.put(historyTreeNode.addr, historyTreeNode);
     return true;
   }
 
   @Override
-  public boolean insertAll(ArrayList<HistoryTreeNode> historyTreeNodes) {
-    for (HistoryTreeNode node : historyTreeNodes) {
-      this.insert(node);
-    }
+  public boolean insert(User user) {
+    // TODO check duplicates
+    users.put(user.id, user);
     return true;
   }
 
+  @Override
+  public HistoryTreeNode get(NodeAddress nodeAddress) {
+    return historyTreeNodes.get(nodeAddress);
+  }
+
+  @Override
+  public User get(Integer id) {
+    return users.get(id);
+  }
+
   @Override
   public boolean delete(NodeAddress nodeAddress) {
     historyTreeNodes.remove(nodeAddress);
     return true;
   }
 
   @Override
-  public HistoryTreeNode get(NodeAddress nodeAddress) {
-    //    if (!historyTreeNodes.containsKey(nodeAddress)) {
-    //      return null;
-    //    }
-    return historyTreeNodes.get(nodeAddress);
+  public boolean delete(User user) {
+    users.remove(user.id);
+    return true;
   }
 
-  public Integer totalNodes() {
-    return this.historyTreeNodes.size();
+  @Override
+  public boolean contains(User user) {
+    boolean exists = this.users.containsKey(user.id);
+    return exists;
+  }
+
+  @Override
+  public boolean contains(HistoryTreeNode historyTreeNode) {
+    boolean exists = this.historyTreeNodes.containsKey(historyTreeNode.addr);
+    return exists;
+  }
+
+  /**
+   * checks if nodeAddress belongs to HistoryTreeStore object.
+   */
+  @Override
+  public boolean contains(NodeAddress nodeAddress) {
+    boolean exists = historyTreeNodes.containsKey(nodeAddress);
+    return exists;
   }
 
 }

src/main/java/scenario/integrita/database/Store.java

@@ -1,9 +1,8 @@
 package scenario.integrita.database;
 
-import java.util.ArrayList;
-
 import scenario.integrita.historytree.HistoryTreeNode;
 import scenario.integrita.historytree.NodeAddress;
+import scenario.integrita.user.User;
 
 /**
  * storage api.
@@ -12,10 +11,20 @@ public interface Store {
 
   boolean insert(HistoryTreeNode historyTreeNode);
 
-  boolean insertAll(ArrayList<HistoryTreeNode> historyTreeNodes);
+  boolean insert(User user);
+
+  HistoryTreeNode get(NodeAddress nodeAddress);
+
+  User get(Integer id);
 
   boolean delete(NodeAddress nodeAddress);
 
-  HistoryTreeNode get(NodeAddress nodeAddress);
+  boolean delete(User user);
+
+  boolean contains(User user);
+
+  boolean contains(HistoryTreeNode historyTreeNode);
+
+  boolean contains(NodeAddress nodeAddress);
 
 }

src/main/java/scenario/integrita/hash/Hash.java

@@ -0,0 +1,8 @@
+package scenario.integrita.hash;
+
+/**
+ * Hash implementation used in Merkle tree.
+ */
+public class Hash {
+
+}