From f2afee2aabb26f53f0b5ea4111974b6d513f6b8d Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sat, 8 Jan 2022 08:49:11 -0800 Subject: [PATCH 01/78] adds store interface --- .../integrita/database/HistoryTreeStore.java | 2 ++ .../java/scenario/integrita/database/Store.java | 14 ++++++++++++++ src/main/java/scenario/integrita/user/User.java | 2 ++ .../integrita/database/HisoryTreeStoreTest.java | 2 ++ ...Test.java => HistoryTreeStoreTreeNodeTest.java} | 0 5 files changed, 20 insertions(+) create mode 100644 src/main/java/scenario/integrita/database/HistoryTreeStore.java create mode 100644 src/main/java/scenario/integrita/database/Store.java create mode 100644 src/main/java/scenario/integrita/user/User.java create mode 100644 src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java rename src/test/java/scenario/integrita/historytree/{HistoryTreeNodeTest.java => HistoryTreeStoreTreeNodeTest.java} (100%) diff --git a/src/main/java/scenario/integrita/database/HistoryTreeStore.java b/src/main/java/scenario/integrita/database/HistoryTreeStore.java new file mode 100644 index 00000000..374deabd --- /dev/null +++ b/src/main/java/scenario/integrita/database/HistoryTreeStore.java @@ -0,0 +1,2 @@ +package scenario.integrita.database;public class HistoryTreeStore { +} diff --git a/src/main/java/scenario/integrita/database/Store.java b/src/main/java/scenario/integrita/database/Store.java new file mode 100644 index 00000000..547b3722 --- /dev/null +++ b/src/main/java/scenario/integrita/database/Store.java @@ -0,0 +1,14 @@ +package scenario.integrita.database; + +import scenario.integrita.historytree.HistoryTreeNode; +import scenario.integrita.historytree.NodeAddress; + +/** + * the storage api + */ +public interface Store { + public boolean insert(HistoryTreeNode historyTreeNode); + public boolean delete(NodeAddress nodeAddress); + public HistoryTreeNode get(NodeAddress nodeAddress); + +} diff --git a/src/main/java/scenario/integrita/user/User.java b/src/main/java/scenario/integrita/user/User.java new file mode 100644 index 00000000..b40a956c --- /dev/null +++ b/src/main/java/scenario/integrita/user/User.java @@ -0,0 +1,2 @@ +package scenario.integrita.user;public class User { +} diff --git a/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java b/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java new file mode 100644 index 00000000..41903d1e --- /dev/null +++ b/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java @@ -0,0 +1,2 @@ +package scenario.integrita.database;public class HisoryTreeStoreTest { +} diff --git a/src/test/java/scenario/integrita/historytree/HistoryTreeNodeTest.java b/src/test/java/scenario/integrita/historytree/HistoryTreeStoreTreeNodeTest.java similarity index 100% rename from src/test/java/scenario/integrita/historytree/HistoryTreeNodeTest.java rename to src/test/java/scenario/integrita/historytree/HistoryTreeStoreTreeNodeTest.java From fdce34f56bb0508279e516238fc5479689310c7f Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sat, 8 Jan 2022 08:49:24 -0800 Subject: [PATCH 02/78] adds implementation of store interface --- .../integrita/database/HistoryTreeStore.java | 49 ++++++++++++++++++- 1 file changed, 48 insertions(+), 1 deletion(-) diff --git a/src/main/java/scenario/integrita/database/HistoryTreeStore.java b/src/main/java/scenario/integrita/database/HistoryTreeStore.java index 374deabd..4a5ba703 100644 --- a/src/main/java/scenario/integrita/database/HistoryTreeStore.java +++ b/src/main/java/scenario/integrita/database/HistoryTreeStore.java @@ -1,2 +1,49 @@ -package scenario.integrita.database;public class HistoryTreeStore { +package scenario.integrita.database; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; + +import org.w3c.dom.Node; +import scenario.integrita.historytree.HistoryTreeNode; +import scenario.integrita.historytree.NodeAddress; +import scenario.integrita.user.User; + +/** + * storage unit of the history tree. It contains methods to persist and update a database of history tree nodes. + */ +public class HistoryTreeStore implements Store { + + public ArrayList users; + public HashMap historyTreeNodes; + + public HistoryTreeStore() { + } + + public HistoryTreeStore(ArrayList users, HashMap historyTreeNodes) { + this.users = users; + this.historyTreeNodes = historyTreeNodes; + } + + @Override + public boolean insert(HistoryTreeNode historyTreeNode) { + historyTreeNodes.put(historyTreeNode.addr, historyTreeNode); + return true; + } + + @Override + public boolean delete(NodeAddress nodeAddress) { + if (historyTreeNodes.containsKey(nodeAddress)){ + historyTreeNodes.remove(nodeAddress); + } + return true; + } + + @Override + public HistoryTreeNode get(NodeAddress nodeAddress) { +// if (!historyTreeNodes.containsKey(nodeAddress)) { +// return null; +// } + return historyTreeNodes.get(nodeAddress); + } } From eee5ab6c9d4c4ab7ffb2813d16dfa915fafd59f0 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sat, 8 Jan 2022 08:49:52 -0800 Subject: [PATCH 03/78] exports all the fields, adds user id --- .../historytree/HistoryTreeNode.java | 26 +++++++++++-------- .../java/scenario/integrita/user/User.java | 9 ++++++- 2 files changed, 23 insertions(+), 12 deletions(-) diff --git a/src/main/java/scenario/integrita/historytree/HistoryTreeNode.java b/src/main/java/scenario/integrita/historytree/HistoryTreeNode.java index a46f5566..84fe88c4 100644 --- a/src/main/java/scenario/integrita/historytree/HistoryTreeNode.java +++ b/src/main/java/scenario/integrita/historytree/HistoryTreeNode.java @@ -7,19 +7,23 @@ * implementation of a decentralized history tree as instructed in Integrita. */ public class HistoryTreeNode { - NodeAddress addr; - String op; - byte[] hash; - byte[] signature; + public NodeAddress addr; + public String op; + public byte[] hash; + public byte[] signature; + /* + the id of the owning user + */ + public Integer userId; @Override public String toString() { - return "HistoryTreeNode{" - + "addr=" + addr - + ", op='" + op + '\'' - + ", hash=" + Arrays.toString(hash) - + ", signature=" + Arrays.toString(signature) - + '}'; + return "HistoryTreeNode{" + + "addr=" + addr + + ", op='" + op + '\'' + + ", hash=" + Arrays.toString(hash) + + ", signature=" + Arrays.toString(signature) + + ", userId=" + userId + + '}'; } - } diff --git a/src/main/java/scenario/integrita/user/User.java b/src/main/java/scenario/integrita/user/User.java index b40a956c..90be8bbd 100644 --- a/src/main/java/scenario/integrita/user/User.java +++ b/src/main/java/scenario/integrita/user/User.java @@ -1,2 +1,9 @@ -package scenario.integrita.user;public class User { +package scenario.integrita.user; + +/** + * contains user-related information + */ +public class User { + public Integer UID; +// @TODO add signature verification key } From fbb3357775abfc45b427de648e2dc412d56a4117 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sat, 8 Jan 2022 08:50:46 -0800 Subject: [PATCH 04/78] makes client an instance of user class --- src/main/java/scenario/integrita/Client.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/main/java/scenario/integrita/Client.java b/src/main/java/scenario/integrita/Client.java index 0156b397..c3a5b7a1 100644 --- a/src/main/java/scenario/integrita/Client.java +++ b/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 ids; // all ids inclding self From 08335afa2db6089077dd56350ba6afcad169fa2d Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sat, 8 Jan 2022 09:58:09 -0800 Subject: [PATCH 05/78] adds operation type enum --- .../integrita/utils/OperationType.java | 9 ++++ .../database/HisoryTreeStoreTest.java | 41 ++++++++++++++++++- 2 files changed, 49 insertions(+), 1 deletion(-) create mode 100644 src/main/java/scenario/integrita/utils/OperationType.java diff --git a/src/main/java/scenario/integrita/utils/OperationType.java b/src/main/java/scenario/integrita/utils/OperationType.java new file mode 100644 index 00000000..d876b0dc --- /dev/null +++ b/src/main/java/scenario/integrita/utils/OperationType.java @@ -0,0 +1,9 @@ +package scenario.integrita.utils; + +/* +leaves of history tree are either Insert or Delete + */ +public enum OperationType { + Insert, + Delete +} diff --git a/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java b/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java index 41903d1e..9ba71867 100644 --- a/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java +++ b/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java @@ -1,2 +1,41 @@ -package scenario.integrita.database;public class HisoryTreeStoreTest { +package scenario.integrita.database; + +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.ArrayList; +import java.util.Arrays; + +import org.junit.jupiter.api.Test; +import scenario.integrita.historytree.HistoryTreeNode; +import scenario.integrita.historytree.NodeAddress; +import scenario.integrita.user.User; +import scenario.integrita.utils.OperationType; + +public class HisoryTreeStoreTest { + + @Test + public void TestInsertDeleteGet() { + HistoryTreeStore historyTreeStore = new HistoryTreeStore(); + + // add 3 users + historyTreeStore.users.addAll(Arrays.asList(new User(1), new User(2), new User(3))); + + // create three nodes, two of which have the same address + HistoryTreeNode historyTreeNode1 = new HistoryTreeNode(new NodeAddress(0, 1), OperationType.Insert, 1); + // historyTreeNode2 points to the same address as historyTreeNode1 + HistoryTreeNode historyTreeNode2 = new HistoryTreeNode(new NodeAddress(0, 1), OperationType.Insert, 2); + + HistoryTreeNode historyTreeNode3 = new HistoryTreeNode(new NodeAddress(2, 1), OperationType.Insert, 2); + + historyTreeStore.insertAll(new ArrayList(Arrays.asList(historyTreeNode1, historyTreeNode2, historyTreeNode3))); + + // duplicates are not allowed + assertTrue((historyTreeStore.totalNodes() == 2)); + + historyTreeStore.delete(historyTreeNode1.addr); + // check the correct deletion + assertTrue((historyTreeStore.totalNodes() == 1)); + // only historyTreeNode3 is left + assertTrue((historyTreeStore.get(historyTreeNode3.addr) == historyTreeNode3)); + } } From de5ef58b5d0884303746d47442066c2e840beb22 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sat, 8 Jan 2022 09:58:23 -0800 Subject: [PATCH 06/78] adds constructors --- src/main/java/scenario/integrita/user/User.java | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/main/java/scenario/integrita/user/User.java b/src/main/java/scenario/integrita/user/User.java index 90be8bbd..317d9db9 100644 --- a/src/main/java/scenario/integrita/user/User.java +++ b/src/main/java/scenario/integrita/user/User.java @@ -6,4 +6,12 @@ public class User { public Integer UID; // @TODO add signature verification key + + + public User(Integer UID) { + this.UID = UID; + } + + public User() { + } } From b264fbb25fc41d1e3b3d8f74c0227477abea3e36 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sat, 8 Jan 2022 09:59:01 -0800 Subject: [PATCH 07/78] implements util methods of totalNode and insertAll --- .../integrita/database/HistoryTreeStore.java | 20 ++++++++++++++----- .../scenario/integrita/database/Store.java | 3 +++ 2 files changed, 18 insertions(+), 5 deletions(-) diff --git a/src/main/java/scenario/integrita/database/HistoryTreeStore.java b/src/main/java/scenario/integrita/database/HistoryTreeStore.java index 4a5ba703..c3d8b21b 100644 --- a/src/main/java/scenario/integrita/database/HistoryTreeStore.java +++ b/src/main/java/scenario/integrita/database/HistoryTreeStore.java @@ -2,9 +2,7 @@ import java.util.ArrayList; import java.util.HashMap; -import java.util.HashSet; -import org.w3c.dom.Node; import scenario.integrita.historytree.HistoryTreeNode; import scenario.integrita.historytree.NodeAddress; import scenario.integrita.user.User; @@ -18,6 +16,8 @@ public class HistoryTreeStore implements Store { public HashMap historyTreeNodes; public HistoryTreeStore() { + this.users = new ArrayList<>(); + this.historyTreeNodes = new HashMap<>(); } public HistoryTreeStore(ArrayList users, HashMap historyTreeNodes) { @@ -32,13 +32,19 @@ public boolean insert(HistoryTreeNode historyTreeNode) { } @Override - public boolean delete(NodeAddress nodeAddress) { - if (historyTreeNodes.containsKey(nodeAddress)){ - historyTreeNodes.remove(nodeAddress); + public boolean insertAll(ArrayList historyTreeNodes) { + for (HistoryTreeNode node : historyTreeNodes) { + this.insert(node); } return true; } + @Override + public boolean delete(NodeAddress nodeAddress) { + historyTreeNodes.remove(nodeAddress); + return true; + } + @Override public HistoryTreeNode get(NodeAddress nodeAddress) { // if (!historyTreeNodes.containsKey(nodeAddress)) { @@ -46,4 +52,8 @@ public HistoryTreeNode get(NodeAddress nodeAddress) { // } return historyTreeNodes.get(nodeAddress); } + + public Integer totalNodes() { + return this.historyTreeNodes.size(); + } } diff --git a/src/main/java/scenario/integrita/database/Store.java b/src/main/java/scenario/integrita/database/Store.java index 547b3722..0d043b2a 100644 --- a/src/main/java/scenario/integrita/database/Store.java +++ b/src/main/java/scenario/integrita/database/Store.java @@ -1,5 +1,7 @@ package scenario.integrita.database; +import java.util.ArrayList; + import scenario.integrita.historytree.HistoryTreeNode; import scenario.integrita.historytree.NodeAddress; @@ -8,6 +10,7 @@ */ public interface Store { public boolean insert(HistoryTreeNode historyTreeNode); + public boolean insertAll(ArrayList historyTreeNodes); public boolean delete(NodeAddress nodeAddress); public HistoryTreeNode get(NodeAddress nodeAddress); From a5df03677782e9bbd2be1b5b25c4b379af0f692d Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sat, 8 Jan 2022 09:59:50 -0800 Subject: [PATCH 08/78] defines equal and hashcode there are required since NodeAddress is a HashMap key --- .../integrita/historytree/NodeAddress.java | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/src/main/java/scenario/integrita/historytree/NodeAddress.java b/src/main/java/scenario/integrita/historytree/NodeAddress.java index 984353e0..536d9f6f 100644 --- a/src/main/java/scenario/integrita/historytree/NodeAddress.java +++ b/src/main/java/scenario/integrita/historytree/NodeAddress.java @@ -19,6 +19,26 @@ public NodeAddress(int position, int level) { this.level = level; } + //Compare only account numbers + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + NodeAddress other = (NodeAddress) obj; + if ((position != other.position) || (level != other.level)) + return false; + return true; + } + + @Override + public int hashCode() { + return toLabel(this); + } + /** * checks whether the address fields are valid. */ From ba6f818237c36bbe72aba2bb9d83026c1d362870 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sat, 8 Jan 2022 10:00:12 -0800 Subject: [PATCH 09/78] replaces string with operation type enum --- .../integrita/historytree/HistoryTreeNode.java | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/src/main/java/scenario/integrita/historytree/HistoryTreeNode.java b/src/main/java/scenario/integrita/historytree/HistoryTreeNode.java index 84fe88c4..1966423d 100644 --- a/src/main/java/scenario/integrita/historytree/HistoryTreeNode.java +++ b/src/main/java/scenario/integrita/historytree/HistoryTreeNode.java @@ -3,12 +3,14 @@ import java.util.Arrays; +import scenario.integrita.utils.OperationType; + /** * implementation of a decentralized history tree as instructed in Integrita. */ public class HistoryTreeNode { public NodeAddress addr; - public String op; + public OperationType op; public byte[] hash; public byte[] signature; /* @@ -16,6 +18,15 @@ public class HistoryTreeNode { */ public Integer userId; + public HistoryTreeNode(NodeAddress addr, OperationType op, Integer userId) { + this.addr = addr; + this.op = op; + this.userId = userId; + } + + public HistoryTreeNode() { + } + @Override public String toString() { return "HistoryTreeNode{" + From 81926fb07cd62b0b2e0bbd1a11084fc590282e6e Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sat, 8 Jan 2022 10:00:26 -0800 Subject: [PATCH 10/78] renames the test class --- .../integrita/historytree/HistoryTreeStoreTreeNodeTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/java/scenario/integrita/historytree/HistoryTreeStoreTreeNodeTest.java b/src/test/java/scenario/integrita/historytree/HistoryTreeStoreTreeNodeTest.java index 9ef5a921..4b7c832c 100644 --- a/src/test/java/scenario/integrita/historytree/HistoryTreeStoreTreeNodeTest.java +++ b/src/test/java/scenario/integrita/historytree/HistoryTreeStoreTreeNodeTest.java @@ -5,7 +5,7 @@ import org.junit.jupiter.api.Test; -public class HistoryTreeNodeTest { +public class HistoryTreeStoreTreeNodeTest { @Test void testIsValid() { From 909d1a454e70473f33df39c16788278e4eb3cdf5 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 9 Jan 2022 09:07:43 -0800 Subject: [PATCH 11/78] adds signature package and class --- src/main/java/scenario/integrita/signature/Signature.java | 4 ++++ 1 file changed, 4 insertions(+) create mode 100644 src/main/java/scenario/integrita/signature/Signature.java diff --git a/src/main/java/scenario/integrita/signature/Signature.java b/src/main/java/scenario/integrita/signature/Signature.java new file mode 100644 index 00000000..7fd95ed1 --- /dev/null +++ b/src/main/java/scenario/integrita/signature/Signature.java @@ -0,0 +1,4 @@ +package scenario.integrita.signature; + +public class Signature { +} From c5163a586c0794ace4db1d767dc2139dfa0ee8ee Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 9 Jan 2022 09:12:18 -0800 Subject: [PATCH 12/78] implements the mocked signature unit --- .../scenario/integrita/signature/Signature.java | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/src/main/java/scenario/integrita/signature/Signature.java b/src/main/java/scenario/integrita/signature/Signature.java index 7fd95ed1..b08d04eb 100644 --- a/src/main/java/scenario/integrita/signature/Signature.java +++ b/src/main/java/scenario/integrita/signature/Signature.java @@ -1,4 +1,17 @@ package scenario.integrita.signature; public class Signature { + + public void init(){ + // @TODO generate keys + } + public byte[] sing(byte[] msg) { + // @TODO sign using the generated keys + byte[] result = new byte[0]; + return result; + } + public boolean verify(){ + // @TODO verify using the generated keys + return true; + } } From 12fd60c51d4c92048fbc816fbd8c38b430d22a47 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 9 Jan 2022 10:10:34 -0800 Subject: [PATCH 13/78] updates users data type, introduces getverificationkey --- .../scenario/integrita/database/HistoryTreeStore.java | 11 ++++++++--- src/main/java/scenario/integrita/hash/Hash.java | 2 ++ 2 files changed, 10 insertions(+), 3 deletions(-) create mode 100644 src/main/java/scenario/integrita/hash/Hash.java diff --git a/src/main/java/scenario/integrita/database/HistoryTreeStore.java b/src/main/java/scenario/integrita/database/HistoryTreeStore.java index c3d8b21b..8f3b3501 100644 --- a/src/main/java/scenario/integrita/database/HistoryTreeStore.java +++ b/src/main/java/scenario/integrita/database/HistoryTreeStore.java @@ -12,19 +12,23 @@ */ public class HistoryTreeStore implements Store { - public ArrayList users; + public HashMap users; public HashMap historyTreeNodes; public HistoryTreeStore() { - this.users = new ArrayList<>(); + this.users = new HashMap<>(); this.historyTreeNodes = new HashMap<>(); } - public HistoryTreeStore(ArrayList users, HashMap historyTreeNodes) { + public HistoryTreeStore(HashMap users, HashMap historyTreeNodes) { this.users = users; this.historyTreeNodes = historyTreeNodes; } + public byte[] getVerificationKey(int user_index) { + return users.get(user_index).verification_key; + } + @Override public boolean insert(HistoryTreeNode historyTreeNode) { historyTreeNodes.put(historyTreeNode.addr, historyTreeNode); @@ -56,4 +60,5 @@ public HistoryTreeNode get(NodeAddress nodeAddress) { public Integer totalNodes() { return this.historyTreeNodes.size(); } + } diff --git a/src/main/java/scenario/integrita/hash/Hash.java b/src/main/java/scenario/integrita/hash/Hash.java new file mode 100644 index 00000000..f860aa22 --- /dev/null +++ b/src/main/java/scenario/integrita/hash/Hash.java @@ -0,0 +1,2 @@ +package scenario.integrita.hash;public class Hash { +} From 12d2f98e74bde4776e31d970d30dabda2110237a Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 9 Jan 2022 10:10:54 -0800 Subject: [PATCH 14/78] updates hash data type and its toString method --- .../integrita/historytree/HistoryTreeNode.java | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/src/main/java/scenario/integrita/historytree/HistoryTreeNode.java b/src/main/java/scenario/integrita/historytree/HistoryTreeNode.java index 1966423d..4345e5e4 100644 --- a/src/main/java/scenario/integrita/historytree/HistoryTreeNode.java +++ b/src/main/java/scenario/integrita/historytree/HistoryTreeNode.java @@ -11,7 +11,7 @@ public class HistoryTreeNode { public NodeAddress addr; public OperationType op; - public byte[] hash; + public String hash; public byte[] signature; /* the id of the owning user @@ -29,12 +29,12 @@ public HistoryTreeNode() { @Override public String toString() { - return "HistoryTreeNode{" + - "addr=" + addr + - ", op='" + op + '\'' + - ", hash=" + Arrays.toString(hash) + - ", signature=" + Arrays.toString(signature) + - ", userId=" + userId + - '}'; + return "HistoryTreeNode{" + + "addr=" + addr + + ", op='" + op + '\'' + + ", hash=" + hash + + ", signature=" + Arrays.toString(signature) + + ", userId=" + userId + + '}'; } } From 8127770ab0467a804991f41c838d7e9e1839b950 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 9 Jan 2022 10:11:17 -0800 Subject: [PATCH 15/78] an empty implementation of hash algorithm --- src/main/java/scenario/integrita/hash/Hash.java | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/src/main/java/scenario/integrita/hash/Hash.java b/src/main/java/scenario/integrita/hash/Hash.java index f860aa22..74cdbc89 100644 --- a/src/main/java/scenario/integrita/hash/Hash.java +++ b/src/main/java/scenario/integrita/hash/Hash.java @@ -1,2 +1,16 @@ -package scenario.integrita.hash;public class Hash { +package scenario.integrita.hash; + +import java.nio.charset.StandardCharsets; + +//import org.bouncycastle.jcajce.provider.digest.Keccak; +//import org.bouncycastle.util.encoders.Hex; + +public class Hash { + public static String generateHash(String originalString) { +// Keccak.Digest256 digest256 = new Keccak.Digest256(); +// byte[] hashedByteArray = digest256.digest( +// originalString.getBytes(StandardCharsets.UTF_8)); +// return new String(Hex.encode(hashedByteArray)); + return ""; + } } From a30213c39599844c498e27d2f755c3337d8fa04c Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 9 Jan 2022 10:11:51 -0800 Subject: [PATCH 16/78] exposes member fields, adds isLeaf utility function --- .../integrita/historytree/NodeAddress.java | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/src/main/java/scenario/integrita/historytree/NodeAddress.java b/src/main/java/scenario/integrita/historytree/NodeAddress.java index 536d9f6f..e23c12ec 100644 --- a/src/main/java/scenario/integrita/historytree/NodeAddress.java +++ b/src/main/java/scenario/integrita/historytree/NodeAddress.java @@ -7,8 +7,8 @@ * level ranges from 0 to log2(position)+1. */ public class NodeAddress { - int position; - int level; + public int position; + public int level; public NodeAddress() { @@ -87,6 +87,17 @@ public static boolean isTreeDigest(NodeAddress addr) { return (addr.level == denom); } + /** + * checks if the supplied address `addr` belongs to a history tree root. + */ + public static boolean isLeaf(NodeAddress addr) { + if (!isValid(addr)) { + return false; + } + return (addr.level == 0); + } + + /** * implements the L function of Integrita. * @@ -110,6 +121,7 @@ public static int toLabel(NodeAddress addr) { * @return the index of the server */ public static int mapServerIndex(NodeAddress addr, int totalNumberServer) { + // TODO totalNumberServer should be non zero int index = Math.floorMod(toLabel(addr), totalNumberServer); if (index == 0) { index = totalNumberServer; From 97490c575c906e2859f80c54f1a3e6435acd6791 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 9 Jan 2022 10:12:13 -0800 Subject: [PATCH 17/78] implements mocked signature class --- src/main/java/scenario/integrita/signature/Signature.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/scenario/integrita/signature/Signature.java b/src/main/java/scenario/integrita/signature/Signature.java index b08d04eb..d12a055e 100644 --- a/src/main/java/scenario/integrita/signature/Signature.java +++ b/src/main/java/scenario/integrita/signature/Signature.java @@ -5,12 +5,12 @@ public class Signature { public void init(){ // @TODO generate keys } - public byte[] sing(byte[] msg) { + public static byte[] sing(String msg, byte[] signature_key) { // @TODO sign using the generated keys byte[] result = new byte[0]; return result; } - public boolean verify(){ + public static boolean verify(String msg, byte[] signature, byte[] verification_key){ // @TODO verify using the generated keys return true; } From 362b13f63a99af841ab8b1a7d8ce175bb04c510e Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 9 Jan 2022 10:12:32 -0800 Subject: [PATCH 18/78] exposes user member fields, adds verification key field --- src/main/java/scenario/integrita/user/User.java | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/main/java/scenario/integrita/user/User.java b/src/main/java/scenario/integrita/user/User.java index 317d9db9..9c0a129d 100644 --- a/src/main/java/scenario/integrita/user/User.java +++ b/src/main/java/scenario/integrita/user/User.java @@ -4,12 +4,13 @@ * contains user-related information */ public class User { - public Integer UID; + public Integer id; + public byte[] verification_key; // @TODO add signature verification key - public User(Integer UID) { - this.UID = UID; + public User(Integer id) { + this.id = id; } public User() { From bec8831c668d7c1ae75f3a18b63e918d97c9994d Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 9 Jan 2022 10:12:47 -0800 Subject: [PATCH 19/78] initial implementation of push --- src/main/java/scenario/integrita/Server.java | 59 +++++++++++++++++++- 1 file changed, 57 insertions(+), 2 deletions(-) diff --git a/src/main/java/scenario/integrita/Server.java b/src/main/java/scenario/integrita/Server.java index b33aa025..7a83230f 100644 --- a/src/main/java/scenario/integrita/Server.java +++ b/src/main/java/scenario/integrita/Server.java @@ -1,16 +1,19 @@ 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 org.apache.commons.lang3.tuple.Pair; +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.utils.StatusCode; /** @@ -20,7 +23,11 @@ public class Server implements BaseNode { UUID id; MiddleLayer network; ArrayList ids; // all ids including self - HashMap db = new HashMap<>(); + HistoryTreeStore db; + int totalServers; + int index; + NodeAddress status; + byte[] signVerificationKey; public Server() { } @@ -36,6 +43,54 @@ public void onCreate(ArrayList allId) { this.network.ready(); } + 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 different between the label of supplied node and the status of the server + // should be equal to the total number of servers + int diff = NodeAddress.toLabel(historyTreeNode.addr) - NodeAddress.toLabel(this.status); + if (diff != totalServers) { + return new Tuple(new Object[]{StatusCode.Reject, null}); + } + + if (NodeAddress.isLeaf(historyTreeNode.addr)) { + // @TODO check the hash value + // @TODO retrieve user vk and verify the signature + + } + + if (NodeAddress.isTreeDigest(historyTreeNode.addr)) { + // verify signature + String msg = historyTreeNode.hash + historyTreeNode.addr.position; + if (!Signature.verify(msg, historyTreeNode.signature, this.db.getVerificationKey(historyTreeNode.userId))) { + new Tuple(new Object[]{StatusCode.Reject, null}); + } + } + + // update the database + db.historyTreeNodes.put(historyTreeNode.addr, historyTreeNode); + + // TODO clean up the database + // remove tree digests of the old operations + // except the first operation + + // update the state variable + this.status = historyTreeNode.addr; + + if (NodeAddress.isTreeDigest(historyTreeNode.addr)) { + String msg = historyTreeNode.hash + historyTreeNode.addr.position; + byte[] signature= Signature.sing(msg, signVerificationKey); + return new Tuple(new Object[]{StatusCode.Accept, signature}); + } + return new Tuple(new Object[]{StatusCode.Accept, null}); + } + // BaseNode interface implementation ------------ @Override public void onStart() { From 5b4df3fc94dae41f683ace86b83a5e2c83679805 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 9 Jan 2022 10:13:00 -0800 Subject: [PATCH 20/78] revises test to match the new type of users --- .../scenario/integrita/database/HisoryTreeStoreTest.java | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java b/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java index 9ba71867..a59591d2 100644 --- a/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java +++ b/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java @@ -1,9 +1,12 @@ package scenario.integrita.database; +import static java.util.Map.entry; import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.ArrayList; import java.util.Arrays; +import java.util.HashMap; +import java.util.Map; import org.junit.jupiter.api.Test; import scenario.integrita.historytree.HistoryTreeNode; @@ -18,7 +21,9 @@ public void TestInsertDeleteGet() { HistoryTreeStore historyTreeStore = new HistoryTreeStore(); // add 3 users - historyTreeStore.users.addAll(Arrays.asList(new User(1), new User(2), new User(3))); + historyTreeStore.users.put( 1, new User(1)); + historyTreeStore.users.put( 2, new User(2)); + historyTreeStore.users.put( 2, new User(2)); // create three nodes, two of which have the same address HistoryTreeNode historyTreeNode1 = new HistoryTreeNode(new NodeAddress(0, 1), OperationType.Insert, 1); From 2c306fb2259f1cdcfaef7025b61b5320a504eba6 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sat, 15 Jan 2022 09:41:03 -0800 Subject: [PATCH 21/78] adds documentation and signature verification --- src/main/java/scenario/integrita/Server.java | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/src/main/java/scenario/integrita/Server.java b/src/main/java/scenario/integrita/Server.java index 7a83230f..5423b0a1 100644 --- a/src/main/java/scenario/integrita/Server.java +++ b/src/main/java/scenario/integrita/Server.java @@ -8,7 +8,6 @@ import network.MiddleLayer; import network.packets.Event; import node.BaseNode; -import org.apache.commons.lang3.tuple.Pair; import scenario.integrita.database.HistoryTreeStore; import scenario.integrita.events.PushResp; import scenario.integrita.historytree.HistoryTreeNode; @@ -27,7 +26,7 @@ public class Server implements BaseNode { int totalServers; int index; NodeAddress status; - byte[] signVerificationKey; + byte[] signVerificationKey; // server's vk public Server() { } @@ -52,7 +51,7 @@ public Tuple push(HistoryTreeNode historyTreeNode) { return new Tuple(new Object[]{StatusCode.Reject, null}); } - // the different between the label of supplied node and the status of the server + // the difference between the label of supplied node and the status of the server // should be equal to the total number of servers int diff = NodeAddress.toLabel(historyTreeNode.addr) - NodeAddress.toLabel(this.status); if (diff != totalServers) { @@ -62,12 +61,17 @@ public Tuple push(HistoryTreeNode historyTreeNode) { 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}); + } } if (NodeAddress.isTreeDigest(historyTreeNode.addr)) { // verify signature - String msg = historyTreeNode.hash + historyTreeNode.addr.position; + String msg = historyTreeNode.toLeaf(); if (!Signature.verify(msg, historyTreeNode.signature, this.db.getVerificationKey(historyTreeNode.userId))) { new Tuple(new Object[]{StatusCode.Reject, null}); } @@ -85,7 +89,7 @@ public Tuple push(HistoryTreeNode historyTreeNode) { if (NodeAddress.isTreeDigest(historyTreeNode.addr)) { String msg = historyTreeNode.hash + historyTreeNode.addr.position; - byte[] signature= Signature.sing(msg, signVerificationKey); + byte[] signature = Signature.sign(msg, signVerificationKey); return new Tuple(new Object[]{StatusCode.Accept, signature}); } return new Tuple(new Object[]{StatusCode.Accept, null}); From d9985d6825b7560eb7bf9600dcafd9d66d85f3bd Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sat, 15 Jan 2022 09:41:16 -0800 Subject: [PATCH 22/78] renames sign --- src/main/java/scenario/integrita/signature/Signature.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/scenario/integrita/signature/Signature.java b/src/main/java/scenario/integrita/signature/Signature.java index d12a055e..7d863d38 100644 --- a/src/main/java/scenario/integrita/signature/Signature.java +++ b/src/main/java/scenario/integrita/signature/Signature.java @@ -5,7 +5,7 @@ public class Signature { public void init(){ // @TODO generate keys } - public static byte[] sing(String msg, byte[] signature_key) { + public static byte[] sign(String msg, byte[] signature_key) { // @TODO sign using the generated keys byte[] result = new byte[0]; return result; From 1b7c53142098ec135e3ea919fe5d46cb76a24f9d Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sat, 15 Jan 2022 09:41:27 -0800 Subject: [PATCH 23/78] adds toLeaf --- .../integrita/historytree/HistoryTreeNode.java | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/src/main/java/scenario/integrita/historytree/HistoryTreeNode.java b/src/main/java/scenario/integrita/historytree/HistoryTreeNode.java index e22c789b..5e49a90a 100644 --- a/src/main/java/scenario/integrita/historytree/HistoryTreeNode.java +++ b/src/main/java/scenario/integrita/historytree/HistoryTreeNode.java @@ -21,10 +21,8 @@ public class HistoryTreeNode { /** * constructor. * - * @param addr node address - * - * @param op type of operation - * + * @param addr node address + * @param op type of operation * @param userId the id of the author */ public HistoryTreeNode(NodeAddress addr, OperationType op, Integer userId) { @@ -46,4 +44,11 @@ public String toString() { + ", userId=" + userId + '}'; } + + /** + * returns node's hash value concatenated with its position in the tree. + */ + public String toLeaf() { + return hash + addr.position; + } } From 61268826bf23b4a1a94234369d4b1414d967d036 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sat, 15 Jan 2022 09:41:48 -0800 Subject: [PATCH 24/78] removes redundant equals --- .../integrita/historytree/NodeAddress.java | 19 ------------------- 1 file changed, 19 deletions(-) diff --git a/src/main/java/scenario/integrita/historytree/NodeAddress.java b/src/main/java/scenario/integrita/historytree/NodeAddress.java index 98983da2..0bb7384d 100644 --- a/src/main/java/scenario/integrita/historytree/NodeAddress.java +++ b/src/main/java/scenario/integrita/historytree/NodeAddress.java @@ -129,23 +129,4 @@ public static int mapServerIndex(NodeAddress addr, int totalNumberServer) { return index; } - @Override - public boolean equals(Object obj) { - if (this == obj) { - return true; - } - if (obj == null) { - return false; - } - if (getClass() != obj.getClass()) { - return false; - } - NodeAddress other = (NodeAddress) obj; - return (position == other.position) && (level == other.level); - } - - @Override - public int hashCode() { - return toLabel(this); - } } From 0ccec830bced51bb642df24aaf7adbb007d993c8 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sat, 15 Jan 2022 09:42:01 -0800 Subject: [PATCH 25/78] removes snake case names --- .../java/scenario/integrita/database/HistoryTreeStore.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/main/java/scenario/integrita/database/HistoryTreeStore.java b/src/main/java/scenario/integrita/database/HistoryTreeStore.java index 8f3b3501..e8afe4e5 100644 --- a/src/main/java/scenario/integrita/database/HistoryTreeStore.java +++ b/src/main/java/scenario/integrita/database/HistoryTreeStore.java @@ -26,7 +26,7 @@ public HistoryTreeStore(HashMap users, HashMap Date: Sat, 15 Jan 2022 09:42:22 -0800 Subject: [PATCH 26/78] fixes the name of HistoryTreeNodeTest --- ...storyTreeStoreTreeNodeTest.java => HistoryTreeNodeTest.java} | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) rename src/test/java/scenario/integrita/historytree/{HistoryTreeStoreTreeNodeTest.java => HistoryTreeNodeTest.java} (97%) diff --git a/src/test/java/scenario/integrita/historytree/HistoryTreeStoreTreeNodeTest.java b/src/test/java/scenario/integrita/historytree/HistoryTreeNodeTest.java similarity index 97% rename from src/test/java/scenario/integrita/historytree/HistoryTreeStoreTreeNodeTest.java rename to src/test/java/scenario/integrita/historytree/HistoryTreeNodeTest.java index e69f5eaa..cee406b6 100644 --- a/src/test/java/scenario/integrita/historytree/HistoryTreeStoreTreeNodeTest.java +++ b/src/test/java/scenario/integrita/historytree/HistoryTreeNodeTest.java @@ -6,7 +6,7 @@ import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; -public class HistoryTreeStoreTreeNodeTest { +public class HistoryTreeNodeTest { @Test void testIsValid() { From 8b219ed2e755f8cb2663529f83b005283c917e24 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sat, 15 Jan 2022 09:44:33 -0800 Subject: [PATCH 27/78] invokes toLeaf --- src/main/java/scenario/integrita/Server.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/scenario/integrita/Server.java b/src/main/java/scenario/integrita/Server.java index 5423b0a1..8d6e5eaf 100644 --- a/src/main/java/scenario/integrita/Server.java +++ b/src/main/java/scenario/integrita/Server.java @@ -88,7 +88,7 @@ public Tuple push(HistoryTreeNode historyTreeNode) { this.status = historyTreeNode.addr; if (NodeAddress.isTreeDigest(historyTreeNode.addr)) { - String msg = historyTreeNode.hash + historyTreeNode.addr.position; + String msg = historyTreeNode.toLeaf(); byte[] signature = Signature.sign(msg, signVerificationKey); return new Tuple(new Object[]{StatusCode.Accept, signature}); } From 7f6a01b93717e788559d4e6abfafccdf71e8bbff Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sat, 15 Jan 2022 10:09:35 -0800 Subject: [PATCH 28/78] introduces cleanDigests --- .../integrita/database/HistoryTreeStore.java | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/src/main/java/scenario/integrita/database/HistoryTreeStore.java b/src/main/java/scenario/integrita/database/HistoryTreeStore.java index e8afe4e5..e4c88386 100644 --- a/src/main/java/scenario/integrita/database/HistoryTreeStore.java +++ b/src/main/java/scenario/integrita/database/HistoryTreeStore.java @@ -2,6 +2,7 @@ import java.util.ArrayList; import java.util.HashMap; +import java.util.Map; import scenario.integrita.historytree.HistoryTreeNode; import scenario.integrita.historytree.NodeAddress; @@ -57,9 +58,20 @@ public HistoryTreeNode get(NodeAddress nodeAddress) { return historyTreeNodes.get(nodeAddress); } - public Integer totalNodes() { - + public int totalNodes() { return this.historyTreeNodes.size(); } + /** + * erases all the past nodes whose `position` precede the position of the supplied `addr` + * @param addr + */ + public void cleanDigests(NodeAddress addr){ + for (Map.Entry e : historyTreeNodes.entrySet()){ + if (NodeAddress.isTreeDigest(e.getKey()) && (e.getKey().position < addr.position) && (e.getKey().position != 1)){ + historyTreeNodes.remove(e.getKey()); + } + } + } + } From f112c14849c34344cee37f61cc3a3aad765a3a74 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sat, 15 Jan 2022 10:09:46 -0800 Subject: [PATCH 29/78] cleans tree digests --- src/main/java/scenario/integrita/Server.java | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/main/java/scenario/integrita/Server.java b/src/main/java/scenario/integrita/Server.java index 8d6e5eaf..679e7d8c 100644 --- a/src/main/java/scenario/integrita/Server.java +++ b/src/main/java/scenario/integrita/Server.java @@ -78,11 +78,14 @@ public Tuple push(HistoryTreeNode historyTreeNode) { } // update the database - db.historyTreeNodes.put(historyTreeNode.addr, historyTreeNode); + if (!NodeAddress.isTemporary(historyTreeNode.addr)) { + db.historyTreeNodes.put(historyTreeNode.addr, historyTreeNode); + } // TODO clean up the database // remove tree digests of the old operations // except the first operation + db.cleanDigests(historyTreeNode.addr); // update the state variable this.status = historyTreeNode.addr; From 230d44efa3e961c41025f4e756237ee60f057535 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 16 Jan 2022 08:55:05 -0800 Subject: [PATCH 30/78] mock implementation of signature --- .../scenario/integrita/signature/Signature.java | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/src/main/java/scenario/integrita/signature/Signature.java b/src/main/java/scenario/integrita/signature/Signature.java index 7d863d38..29724d59 100644 --- a/src/main/java/scenario/integrita/signature/Signature.java +++ b/src/main/java/scenario/integrita/signature/Signature.java @@ -1,16 +1,23 @@ package scenario.integrita.signature; +/** + * signature implementation. + */ public class Signature { - public void init(){ - // @TODO generate keys + public static byte[][] keyGen() { + // @TODO generate keys + byte[][] result = new byte[2][]; + return result; } + public static byte[] sign(String msg, byte[] signature_key) { // @TODO sign using the generated keys byte[] result = new byte[0]; return result; } - public static boolean verify(String msg, byte[] signature, byte[] verification_key){ + + public static boolean verify(String msg, byte[] signature, byte[] verification_key) { // @TODO verify using the generated keys return true; } From 7567e865136e12c7075e3755992506f778fe6095 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 16 Jan 2022 08:59:21 -0800 Subject: [PATCH 31/78] adds signature unit test --- .../integrita/signature/SignatureTest.java | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 src/test/java/scenario/integrita/signature/SignatureTest.java diff --git a/src/test/java/scenario/integrita/signature/SignatureTest.java b/src/test/java/scenario/integrita/signature/SignatureTest.java new file mode 100644 index 00000000..45f32cce --- /dev/null +++ b/src/test/java/scenario/integrita/signature/SignatureTest.java @@ -0,0 +1,19 @@ +package scenario.integrita.signature; + +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import org.junit.jupiter.api.Test; + +public class SignatureTest { + + @Test + public void correctnessTest() { + byte[][] keys = Signature.keyGen(); + String msg = "test message"; + byte[] sign = Signature.sign(msg,keys[0]); + boolean verification = Signature.verify(msg,sign,keys[1]); + assertTrue(verification); + } + +} From 3c2009eef49d3986b4587d86e375239629c657d3 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 16 Jan 2022 09:13:53 -0800 Subject: [PATCH 32/78] adds maxLevel method --- .../integrita/historytree/NodeAddress.java | 48 ++++++++++--------- 1 file changed, 26 insertions(+), 22 deletions(-) diff --git a/src/main/java/scenario/integrita/historytree/NodeAddress.java b/src/main/java/scenario/integrita/historytree/NodeAddress.java index 0bb7384d..1501b418 100644 --- a/src/main/java/scenario/integrita/historytree/NodeAddress.java +++ b/src/main/java/scenario/integrita/historytree/NodeAddress.java @@ -19,26 +19,6 @@ public NodeAddress(int position, int level) { this.level = level; } - //Compare only account numbers - @Override - public boolean equals(Object obj) { - if (this == obj) - return true; - if (obj == null) - return false; - if (getClass() != obj.getClass()) - return false; - NodeAddress other = (NodeAddress) obj; - if ((position != other.position) || (level != other.level)) - return false; - return true; - } - - @Override - public int hashCode() { - return toLabel(this); - } - /** * checks whether the address fields are valid. */ @@ -49,7 +29,7 @@ public static boolean isValid(NodeAddress addr) { if (addr.level < 0) { return false; } - double maxLevel = Math.ceil(Math.log(addr.position) / Math.log(2)); + double maxLevel = maxLevel(addr.position); return !(addr.level > maxLevel); } @@ -97,6 +77,10 @@ public static boolean isLeaf(NodeAddress addr) { return (addr.level == 0); } + public static int maxLevel(int position) { + int maxLev = (int) Math.ceil(Math.log(position) / Math.log(2)); + return maxLev; + } /** * implements the L function of Integrita. @@ -107,7 +91,7 @@ public static boolean isLeaf(NodeAddress addr) { public static int toLabel(NodeAddress addr) { int sum = 0; for (int j = 1; j < addr.position; j++) { - sum = sum + (int) Math.ceil(Math.log(j) / Math.log(2)) + 1; + sum = sum + maxLevel(addr.position) + 1; } sum = sum + addr.level + 1; return sum; @@ -129,4 +113,24 @@ public static int mapServerIndex(NodeAddress addr, int totalNumberServer) { return index; } + //Compare only account numbers + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + NodeAddress other = (NodeAddress) obj; + return (position == other.position) && (level == other.level); + } + + @Override + public int hashCode() { + return toLabel(this); + } + + + } From 3ee862f3b45283ba62b577311eaf418938dbc20a Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 16 Jan 2022 09:14:03 -0800 Subject: [PATCH 33/78] java doc --- src/main/java/scenario/integrita/Server.java | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/src/main/java/scenario/integrita/Server.java b/src/main/java/scenario/integrita/Server.java index 679e7d8c..8bdcab89 100644 --- a/src/main/java/scenario/integrita/Server.java +++ b/src/main/java/scenario/integrita/Server.java @@ -58,6 +58,8 @@ public Tuple push(HistoryTreeNode historyTreeNode) { 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 @@ -69,6 +71,7 @@ public Tuple push(HistoryTreeNode historyTreeNode) { } } + // verify user-side signature on the tree digest if (NodeAddress.isTreeDigest(historyTreeNode.addr)) { // verify signature String msg = historyTreeNode.toLeaf(); @@ -77,12 +80,11 @@ public Tuple push(HistoryTreeNode historyTreeNode) { } } - // update the database + // update the database just for non-empty nodes if (!NodeAddress.isTemporary(historyTreeNode.addr)) { db.historyTreeNodes.put(historyTreeNode.addr, historyTreeNode); } - // TODO clean up the database // remove tree digests of the old operations // except the first operation db.cleanDigests(historyTreeNode.addr); @@ -90,11 +92,14 @@ public Tuple push(HistoryTreeNode historyTreeNode) { // 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, signVerificationKey); 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}); } From 492be4b974afe5ce743bf025ac9c2980fafb95fc Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 16 Jan 2022 09:38:39 -0800 Subject: [PATCH 34/78] adds contains, updates cleanDigest to not update underlying hash map --- .../integrita/database/HistoryTreeStore.java | 18 +++++++++++++++--- 1 file changed, 15 insertions(+), 3 deletions(-) diff --git a/src/main/java/scenario/integrita/database/HistoryTreeStore.java b/src/main/java/scenario/integrita/database/HistoryTreeStore.java index e4c88386..1d20ca0e 100644 --- a/src/main/java/scenario/integrita/database/HistoryTreeStore.java +++ b/src/main/java/scenario/integrita/database/HistoryTreeStore.java @@ -3,6 +3,7 @@ import java.util.ArrayList; import java.util.HashMap; import java.util.Map; +import java.util.Set; import scenario.integrita.historytree.HistoryTreeNode; import scenario.integrita.historytree.NodeAddress; @@ -67,11 +68,22 @@ public int totalNodes() { * @param addr */ public void cleanDigests(NodeAddress addr){ - for (Map.Entry e : historyTreeNodes.entrySet()){ - if (NodeAddress.isTreeDigest(e.getKey()) && (e.getKey().position < addr.position) && (e.getKey().position != 1)){ - historyTreeNodes.remove(e.getKey()); + Set keySet = historyTreeNodes.keySet(); + for ( NodeAddress k : keySet){ + if (NodeAddress.isTreeDigest(k) && (k.position < addr.position) && (k.position != 1)){ + historyTreeNodes.remove(k); } } } + /** + * checks if nodeAddress belongs to HistoryTreeStore object + * @param nodeAddress + * @return + */ + public boolean contains(NodeAddress nodeAddress){ + boolean exists = historyTreeNodes.containsKey(nodeAddress); + return exists; + } + } From 0250ffe1f518c8d6fcf71d0345cf6066c489fb81 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 16 Jan 2022 09:39:05 -0800 Subject: [PATCH 35/78] adds initHistoryTreeStore and testCleanTreeDigest --- .../database/HisoryTreeStoreTest.java | 28 +++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java b/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java index 34cfb338..8a36e47f 100644 --- a/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java +++ b/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java @@ -13,6 +13,22 @@ public class HisoryTreeStoreTest { + /** + * populates a HistoryTreeStore with all the nodes of a history tree at its vth version + * @param v + * @return + */ + public HistoryTreeStore initHistoryTreeStore(int v){ + HistoryTreeStore historyTreeStore = new HistoryTreeStore(); + for (int p=1; p<=v ; p++){ + for(int l=0; l<= NodeAddress.maxLevel(p); l++){ + HistoryTreeNode historyTreeNode = new HistoryTreeNode(new NodeAddress(p, l), OperationType.Insert, 1); + historyTreeStore.insert(historyTreeNode); + } + } + return historyTreeStore; + + } @Test public void TestInsertDeleteGet() { HistoryTreeStore historyTreeStore = new HistoryTreeStore(); @@ -40,4 +56,16 @@ public void TestInsertDeleteGet() { // only historyTreeNode3 is left assertTrue((historyTreeStore.get(historyTreeNode3.addr) == historyTreeNode3)); } + + @Test + public void testCleanTreeDigest(){ + HistoryTreeStore historyTreeStore = initHistoryTreeStore(5); + assertTrue(historyTreeStore.contains(new NodeAddress(1,0))); + assertTrue(historyTreeStore.contains(new NodeAddress(2,NodeAddress.maxLevel(2)))); + assertTrue(historyTreeStore.contains(new NodeAddress(3,NodeAddress.maxLevel(3)))); + assertTrue(historyTreeStore.contains(new NodeAddress(4,NodeAddress.maxLevel(4)))); + assertTrue(historyTreeStore.contains(new NodeAddress(5,NodeAddress.maxLevel(5)))); + historyTreeStore.cleanDigests(new NodeAddress(3,0)); + + } } From 6a6abee351b3e01558091b7e3ec318b6e2e11ba0 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 16 Jan 2022 12:20:18 -0800 Subject: [PATCH 36/78] fixes in-place hashmap update --- .../integrita/database/HistoryTreeStore.java | 21 ++++++++++--------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/src/main/java/scenario/integrita/database/HistoryTreeStore.java b/src/main/java/scenario/integrita/database/HistoryTreeStore.java index 1d20ca0e..e97d0f94 100644 --- a/src/main/java/scenario/integrita/database/HistoryTreeStore.java +++ b/src/main/java/scenario/integrita/database/HistoryTreeStore.java @@ -1,9 +1,6 @@ package scenario.integrita.database; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.Map; -import java.util.Set; +import java.util.*; import scenario.integrita.historytree.HistoryTreeNode; import scenario.integrita.historytree.NodeAddress; @@ -64,24 +61,28 @@ public int totalNodes() { } /** - * erases all the past nodes whose `position` precede the position of the supplied `addr` + * erases all the past nodes whose `position` precede the position of the supplied `addr` exclusively + * * @param addr */ - public void cleanDigests(NodeAddress addr){ + public void cleanDigests(NodeAddress addr) { Set keySet = historyTreeNodes.keySet(); - for ( NodeAddress k : keySet){ - if (NodeAddress.isTreeDigest(k) && (k.position < addr.position) && (k.position != 1)){ - historyTreeNodes.remove(k); + + for (Iterator> it = historyTreeNodes.entrySet().iterator(); it.hasNext(); ) { + Map.Entry entry = it.next(); + if (NodeAddress.isTreeDigest(entry.getKey()) && (entry.getKey().position < addr.position) && (entry.getKey().position != 1)) { + it.remove(); } } } /** * checks if nodeAddress belongs to HistoryTreeStore object + * * @param nodeAddress * @return */ - public boolean contains(NodeAddress nodeAddress){ + public boolean contains(NodeAddress nodeAddress) { boolean exists = historyTreeNodes.containsKey(nodeAddress); return exists; } From 91fdbdf5ef42253f0f3eb37e375c2e66699455f4 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 16 Jan 2022 12:22:03 -0800 Subject: [PATCH 37/78] finalizes CleanTreeDigest unit test --- .../database/HisoryTreeStoreTest.java | 37 ++++++++++++------- 1 file changed, 23 insertions(+), 14 deletions(-) diff --git a/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java b/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java index 8a36e47f..7e0b3805 100644 --- a/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java +++ b/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java @@ -1,5 +1,6 @@ package scenario.integrita.database; +import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.ArrayList; @@ -15,13 +16,14 @@ public class HisoryTreeStoreTest { /** * populates a HistoryTreeStore with all the nodes of a history tree at its vth version + * * @param v * @return */ - public HistoryTreeStore initHistoryTreeStore(int v){ + public HistoryTreeStore initHistoryTreeStore(int v) { HistoryTreeStore historyTreeStore = new HistoryTreeStore(); - for (int p=1; p<=v ; p++){ - for(int l=0; l<= NodeAddress.maxLevel(p); l++){ + for (int p = 1; p <= v; p++) { + for (int l = 0; l <= NodeAddress.maxLevel(p); l++) { HistoryTreeNode historyTreeNode = new HistoryTreeNode(new NodeAddress(p, l), OperationType.Insert, 1); historyTreeStore.insert(historyTreeNode); } @@ -29,14 +31,15 @@ public HistoryTreeStore initHistoryTreeStore(int v){ return historyTreeStore; } + @Test public void TestInsertDeleteGet() { HistoryTreeStore historyTreeStore = new HistoryTreeStore(); // add 3 users - historyTreeStore.users.put( 1, new User(1)); - historyTreeStore.users.put( 2, new User(2)); - historyTreeStore.users.put( 2, new User(2)); + historyTreeStore.users.put(1, new User(1)); + historyTreeStore.users.put(2, new User(2)); + historyTreeStore.users.put(2, new User(2)); // create three nodes, two of which have the same address HistoryTreeNode historyTreeNode1 = new HistoryTreeNode(new NodeAddress(0, 1), OperationType.Insert, 1); @@ -58,14 +61,20 @@ public void TestInsertDeleteGet() { } @Test - public void testCleanTreeDigest(){ + public void testCleanTreeDigest() { HistoryTreeStore historyTreeStore = initHistoryTreeStore(5); - assertTrue(historyTreeStore.contains(new NodeAddress(1,0))); - assertTrue(historyTreeStore.contains(new NodeAddress(2,NodeAddress.maxLevel(2)))); - assertTrue(historyTreeStore.contains(new NodeAddress(3,NodeAddress.maxLevel(3)))); - assertTrue(historyTreeStore.contains(new NodeAddress(4,NodeAddress.maxLevel(4)))); - assertTrue(historyTreeStore.contains(new NodeAddress(5,NodeAddress.maxLevel(5)))); - historyTreeStore.cleanDigests(new NodeAddress(3,0)); - + // check the inclusion of all the tree digests up to version 5 of the tree + assertTrue(historyTreeStore.contains(new NodeAddress(1, 0))); + assertTrue(historyTreeStore.contains(new NodeAddress(2, NodeAddress.maxLevel(2)))); + assertTrue(historyTreeStore.contains(new NodeAddress(3, NodeAddress.maxLevel(3)))); + assertTrue(historyTreeStore.contains(new NodeAddress(4, NodeAddress.maxLevel(4)))); + assertTrue(historyTreeStore.contains(new NodeAddress(5, NodeAddress.maxLevel(5)))); + historyTreeStore.cleanDigests(new NodeAddress(4, 0)); + // tree digests of 2nd, and 3rd operations should be deleted + assertTrue(historyTreeStore.contains(new NodeAddress(1, 0))); + assertFalse(historyTreeStore.contains(new NodeAddress(2, NodeAddress.maxLevel(2)))); + assertFalse(historyTreeStore.contains(new NodeAddress(3, NodeAddress.maxLevel(3)))); + assertTrue(historyTreeStore.contains(new NodeAddress(4, NodeAddress.maxLevel(4)))); + assertTrue(historyTreeStore.contains(new NodeAddress(5, NodeAddress.maxLevel(5)))); } } From 63232e8a1deff9c2d0d0210807145659e8c07cf3 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 16 Jan 2022 12:23:05 -0800 Subject: [PATCH 38/78] adds Server test class --- src/test/java/scenario/integrita/ServerTest.java | 4 ++++ 1 file changed, 4 insertions(+) create mode 100644 src/test/java/scenario/integrita/ServerTest.java diff --git a/src/test/java/scenario/integrita/ServerTest.java b/src/test/java/scenario/integrita/ServerTest.java new file mode 100644 index 00000000..4a17d4b0 --- /dev/null +++ b/src/test/java/scenario/integrita/ServerTest.java @@ -0,0 +1,4 @@ +package scenario.integrita; + +public class ServerTest { +} From 358a1a3402d24a86873a2e76b69b467b24444320 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 16 Jan 2022 12:36:41 -0800 Subject: [PATCH 39/78] reorganization and javadoc --- src/main/java/scenario/integrita/Server.java | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-) diff --git a/src/main/java/scenario/integrita/Server.java b/src/main/java/scenario/integrita/Server.java index 8bdcab89..66980916 100644 --- a/src/main/java/scenario/integrita/Server.java +++ b/src/main/java/scenario/integrita/Server.java @@ -19,14 +19,21 @@ * Integrita server implementation. */ public class Server implements BaseNode { + // Integrita related fields + int index; // server's index + int totalServers; // total number of servers + byte[] signVerificationKey; // server's vk + HistoryTreeStore db; + NodeAddress status; // the last node address seen by the server + + // simulator related properties UUID id; MiddleLayer network; - ArrayList ids; // all ids including self - HistoryTreeStore db; - int totalServers; - int index; - NodeAddress status; - byte[] signVerificationKey; // server's vk + // all UUIDs including self + ArrayList ids; + + + public Server() { } From 9e1a4d1bd01f7b5351a9da6b18a739cb344714c0 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 16 Jan 2022 12:36:53 -0800 Subject: [PATCH 40/78] adds test scenarios --- .../java/scenario/integrita/ServerTest.java | 37 +++++++++++++++++++ 1 file changed, 37 insertions(+) diff --git a/src/test/java/scenario/integrita/ServerTest.java b/src/test/java/scenario/integrita/ServerTest.java index 4a17d4b0..ab54eb49 100644 --- a/src/test/java/scenario/integrita/ServerTest.java +++ b/src/test/java/scenario/integrita/ServerTest.java @@ -1,4 +1,41 @@ package scenario.integrita; +import org.junit.jupiter.api.Test; + public class ServerTest { + + @Test + public void pushTestServerIndex(){ + // create a history tree node whose index maps to the server's index + Server s = new Server(); + s.index = 1; + s.totalServers = 4; + + + // create a history tree node whose index does not map to the server's index + } + + @Test + public void pushTestLabelDistance(){ + // set server's status + + // create a history tree node whose index has more than N difference from the server's status + } + + @Test + public void pushTestTemporaryNodes(){ + // create a temporary history tree node + // push it to the server + // the db should not change + } + + @Test + public void pushTestInsertTreeDigest(){ + // populate a server with proper nodes of the history tree + // create a tree digest + // push it to the server + // check internal state of the server + // the size of db + // the state variable + } } From b0936c48ad6f9c9bd8668977962551919bb97656 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 16 Jan 2022 12:38:53 -0800 Subject: [PATCH 41/78] beatification and reorganising --- src/main/java/scenario/integrita/Server.java | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/src/main/java/scenario/integrita/Server.java b/src/main/java/scenario/integrita/Server.java index 66980916..8a08bdc3 100644 --- a/src/main/java/scenario/integrita/Server.java +++ b/src/main/java/scenario/integrita/Server.java @@ -32,9 +32,7 @@ public class Server implements BaseNode { // all UUIDs including self ArrayList ids; - - - + // Constructors ------------------------------------------------------------------------- public Server() { } @@ -43,12 +41,7 @@ public Server(UUID selfId, MiddleLayer network) { this.network = network; } - @Override - public void onCreate(ArrayList allId) { - this.ids = allId; - this.network.ready(); - } - + // Integrita RPCs --------------------------------------------------------------------- public Tuple push(HistoryTreeNode historyTreeNode) { // @TODO check the user membership via signature @@ -110,7 +103,14 @@ public Tuple push(HistoryTreeNode historyTreeNode) { return new Tuple(new Object[]{StatusCode.Accept, null}); } - // BaseNode interface implementation ------------ + // BaseNode interface implementation --------------------------------------------------- + + @Override + public void onCreate(ArrayList allId) { + this.ids = allId; + this.network.ready(); + } + @Override public void onStart() { From c8eb71dc239b6f3abd51a350d92029284e2f2c80 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 16 Jan 2022 12:45:01 -0800 Subject: [PATCH 42/78] check status is not nill --- src/main/java/scenario/integrita/Server.java | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/src/main/java/scenario/integrita/Server.java b/src/main/java/scenario/integrita/Server.java index 8a08bdc3..22ac6888 100644 --- a/src/main/java/scenario/integrita/Server.java +++ b/src/main/java/scenario/integrita/Server.java @@ -53,11 +53,14 @@ public Tuple push(HistoryTreeNode historyTreeNode) { // the difference between the label of supplied node and the status of the server // should be equal to the total number of servers - int diff = NodeAddress.toLabel(historyTreeNode.addr) - NodeAddress.toLabel(this.status); - if (diff != totalServers) { - return new Tuple(new Object[]{StatusCode.Reject, null}); + 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)) { From 495b7ebc1291347b83b4cf8575ad9ac29eadb0dc Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 16 Jan 2022 12:50:21 -0800 Subject: [PATCH 43/78] adds insert method for user --- .../java/scenario/integrita/database/HistoryTreeStore.java | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/main/java/scenario/integrita/database/HistoryTreeStore.java b/src/main/java/scenario/integrita/database/HistoryTreeStore.java index e97d0f94..dd0df877 100644 --- a/src/main/java/scenario/integrita/database/HistoryTreeStore.java +++ b/src/main/java/scenario/integrita/database/HistoryTreeStore.java @@ -60,6 +60,12 @@ public int totalNodes() { return this.historyTreeNodes.size(); } + public boolean insert(User user) { + // TODO check duplicates + users.put(user.id, user); + return true; + } + /** * erases all the past nodes whose `position` precede the position of the supplied `addr` exclusively * From 8f7a6bb2a42f83b053fa34039991bdd6f833a183 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 16 Jan 2022 12:50:42 -0800 Subject: [PATCH 44/78] replaces map put function with custom function insert --- .../scenario/integrita/database/HisoryTreeStoreTest.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java b/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java index 7e0b3805..e45ad5d4 100644 --- a/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java +++ b/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java @@ -37,9 +37,9 @@ public void TestInsertDeleteGet() { HistoryTreeStore historyTreeStore = new HistoryTreeStore(); // add 3 users - historyTreeStore.users.put(1, new User(1)); - historyTreeStore.users.put(2, new User(2)); - historyTreeStore.users.put(2, new User(2)); + historyTreeStore.insert(new User(1)); + historyTreeStore.insert(new User(2)); + historyTreeStore.insert(new User(3)); // create three nodes, two of which have the same address HistoryTreeNode historyTreeNode1 = new HistoryTreeNode(new NodeAddress(0, 1), OperationType.Insert, 1); From c5c344f69fb795f27bdd2a3050d0e260169896e1 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 16 Jan 2022 12:50:59 -0800 Subject: [PATCH 45/78] fixes formating problems --- .../java/scenario/integrita/ServerTest.java | 24 +++++++++++++++---- 1 file changed, 19 insertions(+), 5 deletions(-) diff --git a/src/test/java/scenario/integrita/ServerTest.java b/src/test/java/scenario/integrita/ServerTest.java index ab54eb49..a92c108c 100644 --- a/src/test/java/scenario/integrita/ServerTest.java +++ b/src/test/java/scenario/integrita/ServerTest.java @@ -1,36 +1,50 @@ package scenario.integrita; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import groovy.lang.Tuple; import org.junit.jupiter.api.Test; +import scenario.integrita.historytree.HistoryTreeNode; +import scenario.integrita.historytree.NodeAddress; +import scenario.integrita.user.User; +import scenario.integrita.utils.OperationType; +import scenario.integrita.utils.StatusCode; public class ServerTest { @Test - public void pushTestServerIndex(){ - // create a history tree node whose index maps to the server's index + public void pushTestServerIndex() { + // set up a server Server s = new Server(); s.index = 1; s.totalServers = 4; + s.db.insert(new User()); + // create a history tree node whose index maps to the server's index + HistoryTreeNode historyTreeNode = new HistoryTreeNode(new NodeAddress(1, 0), OperationType.Insert, 1); + Tuple res = s.push(historyTreeNode); + assertTrue(res.get(0) == StatusCode.Accept); + // create a history tree node whose index does not map to the server's index } @Test - public void pushTestLabelDistance(){ + public void pushTestLabelDistance() { // set server's status // create a history tree node whose index has more than N difference from the server's status } @Test - public void pushTestTemporaryNodes(){ + public void pushTestTemporaryNodes() { // create a temporary history tree node // push it to the server // the db should not change } @Test - public void pushTestInsertTreeDigest(){ + public void pushTestInsertTreeDigest() { // populate a server with proper nodes of the history tree // create a tree digest // push it to the server From 69a132af0dd85aa6518ac0e96079ae457ae8a375 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 16 Jan 2022 13:01:56 -0800 Subject: [PATCH 46/78] renames verification keys to vk --- src/main/java/scenario/integrita/Server.java | 19 ++++++++++++++++--- .../integrita/database/HistoryTreeStore.java | 2 +- .../java/scenario/integrita/user/User.java | 7 +++++-- 3 files changed, 22 insertions(+), 6 deletions(-) diff --git a/src/main/java/scenario/integrita/Server.java b/src/main/java/scenario/integrita/Server.java index 22ac6888..2abf9844 100644 --- a/src/main/java/scenario/integrita/Server.java +++ b/src/main/java/scenario/integrita/Server.java @@ -22,7 +22,8 @@ public class Server implements BaseNode { // Integrita related fields int index; // server's index int totalServers; // total number of servers - byte[] signVerificationKey; // server's vk + byte[] vk; // server's verification key + byte[] sk; // server's signature key HistoryTreeStore db; NodeAddress status; // the last node address seen by the server @@ -41,6 +42,18 @@ public Server(UUID selfId, MiddleLayer network) { this.network = network; } + 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]; + } + // Integrita RPCs --------------------------------------------------------------------- public Tuple push(HistoryTreeNode historyTreeNode) { // @TODO check the user membership via signature @@ -53,7 +66,7 @@ public Tuple push(HistoryTreeNode historyTreeNode) { // 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){ + 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}); @@ -98,7 +111,7 @@ public Tuple push(HistoryTreeNode historyTreeNode) { // server should sign tree digests if (NodeAddress.isTreeDigest(historyTreeNode.addr)) { String msg = historyTreeNode.toLeaf(); - byte[] signature = Signature.sign(msg, signVerificationKey); + byte[] signature = Signature.sign(msg, vk); return new Tuple(new Object[]{StatusCode.Accept, signature}); } diff --git a/src/main/java/scenario/integrita/database/HistoryTreeStore.java b/src/main/java/scenario/integrita/database/HistoryTreeStore.java index dd0df877..6a0129ee 100644 --- a/src/main/java/scenario/integrita/database/HistoryTreeStore.java +++ b/src/main/java/scenario/integrita/database/HistoryTreeStore.java @@ -25,7 +25,7 @@ public HistoryTreeStore(HashMap users, HashMap Date: Sun, 16 Jan 2022 13:02:19 -0800 Subject: [PATCH 47/78] unit test for the push --- src/test/java/scenario/integrita/ServerTest.java | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/src/test/java/scenario/integrita/ServerTest.java b/src/test/java/scenario/integrita/ServerTest.java index a92c108c..adc3860e 100644 --- a/src/test/java/scenario/integrita/ServerTest.java +++ b/src/test/java/scenario/integrita/ServerTest.java @@ -15,10 +15,8 @@ public class ServerTest { @Test public void pushTestServerIndex() { // set up a server - Server s = new Server(); - s.index = 1; - s.totalServers = 4; - s.db.insert(new User()); + Server s = new Server(1, 4); + s.db.insert(new User(1, new byte[0])); // create a history tree node whose index maps to the server's index HistoryTreeNode historyTreeNode = new HistoryTreeNode(new NodeAddress(1, 0), OperationType.Insert, 1); Tuple res = s.push(historyTreeNode); From 59c52d4d01091ff3b997ed81f979e01af2d27f31 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 16 Jan 2022 13:03:51 -0800 Subject: [PATCH 48/78] unittest for unmatched node address --- src/test/java/scenario/integrita/ServerTest.java | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/src/test/java/scenario/integrita/ServerTest.java b/src/test/java/scenario/integrita/ServerTest.java index adc3860e..56ea008b 100644 --- a/src/test/java/scenario/integrita/ServerTest.java +++ b/src/test/java/scenario/integrita/ServerTest.java @@ -16,15 +16,19 @@ public class ServerTest { public void pushTestServerIndex() { // set up a server Server s = new Server(1, 4); + // add a user s.db.insert(new User(1, new byte[0])); + // create a history tree node whose index maps to the server's index HistoryTreeNode historyTreeNode = new HistoryTreeNode(new NodeAddress(1, 0), OperationType.Insert, 1); Tuple res = s.push(historyTreeNode); assertTrue(res.get(0) == StatusCode.Accept); - - // create a history tree node whose index does not map to the server's index + HistoryTreeNode falseHistoryTreeNode = new HistoryTreeNode(new NodeAddress(2, 0), OperationType.Insert, 1); + res = s.push(falseHistoryTreeNode); + assertTrue(res.get(0) == StatusCode.Reject); + } @Test From be243e95ada35c5542ef5b9e5df5ebce413ac855 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sat, 22 Jan 2022 09:01:53 -0800 Subject: [PATCH 49/78] adds tests for toLabel --- .../historytree/NodeAddressTest.java | 24 +++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 src/test/java/scenario/integrita/historytree/NodeAddressTest.java diff --git a/src/test/java/scenario/integrita/historytree/NodeAddressTest.java b/src/test/java/scenario/integrita/historytree/NodeAddressTest.java new file mode 100644 index 00000000..2fec8071 --- /dev/null +++ b/src/test/java/scenario/integrita/historytree/NodeAddressTest.java @@ -0,0 +1,24 @@ +package scenario.integrita.historytree; + +import static org.junit.jupiter.api.Assertions.assertTrue; + +import org.junit.jupiter.api.Test; + + +public class NodeAddressTest { + @Test + public void toLabelTest() { + assertTrue(NodeAddress.toLabel(new NodeAddress(1, 0)) == 1); + + assertTrue(NodeAddress.toLabel(new NodeAddress(2, 0)) == 2); + assertTrue(NodeAddress.toLabel(new NodeAddress(2, 1)) == 3); + + assertTrue(NodeAddress.toLabel(new NodeAddress(3, 0)) == 4); + assertTrue(NodeAddress.toLabel(new NodeAddress(3, 1)) == 5); + assertTrue(NodeAddress.toLabel(new NodeAddress(3, 2)) == 6); + + assertTrue(NodeAddress.toLabel(new NodeAddress(4, 0)) == 7); + assertTrue(NodeAddress.toLabel(new NodeAddress(4, 1)) == 8); + assertTrue(NodeAddress.toLabel(new NodeAddress(4, 2)) == 9); + } +} From de727eac7a00a6816a6c65bd7d7759e40a266f58 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sat, 22 Jan 2022 09:02:10 -0800 Subject: [PATCH 50/78] fixes a bug --- src/main/java/scenario/integrita/historytree/NodeAddress.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/scenario/integrita/historytree/NodeAddress.java b/src/main/java/scenario/integrita/historytree/NodeAddress.java index 1501b418..f9b3c5bb 100644 --- a/src/main/java/scenario/integrita/historytree/NodeAddress.java +++ b/src/main/java/scenario/integrita/historytree/NodeAddress.java @@ -91,7 +91,7 @@ public static int maxLevel(int position) { public static int toLabel(NodeAddress addr) { int sum = 0; for (int j = 1; j < addr.position; j++) { - sum = sum + maxLevel(addr.position) + 1; + sum = sum + maxLevel(j) + 1; } sum = sum + addr.level + 1; return sum; From 3d2aae811bcbe979b039fd6f6b121ec5b7025df6 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sat, 22 Jan 2022 09:02:52 -0800 Subject: [PATCH 51/78] add unit tests for input validation for push --- src/test/java/scenario/integrita/ServerTest.java | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/src/test/java/scenario/integrita/ServerTest.java b/src/test/java/scenario/integrita/ServerTest.java index 56ea008b..6c41cf1b 100644 --- a/src/test/java/scenario/integrita/ServerTest.java +++ b/src/test/java/scenario/integrita/ServerTest.java @@ -24,10 +24,21 @@ public void pushTestServerIndex() { Tuple res = s.push(historyTreeNode); assertTrue(res.get(0) == StatusCode.Accept); - // create a history tree node whose index does not map to the server's index + // create a history tree node whose address does not map to the server's index HistoryTreeNode falseHistoryTreeNode = new HistoryTreeNode(new NodeAddress(2, 0), OperationType.Insert, 1); res = s.push(falseHistoryTreeNode); assertTrue(res.get(0) == StatusCode.Reject); + + // create a history tree node whose address is not the next expected one + falseHistoryTreeNode = new HistoryTreeNode(new NodeAddress(3, 0), OperationType.Insert, 1); + res = s.push(falseHistoryTreeNode); + assertTrue(res.get(0) == StatusCode.Reject); + + // create a history tree node whose address is the next expected one + falseHistoryTreeNode = new HistoryTreeNode(new NodeAddress(3, 1), OperationType.Insert, 1); + res = s.push(falseHistoryTreeNode); + assertTrue(res.get(0) == StatusCode.Accept); + } From b2b24a55f7c1b66a8604a9ee3ebf31241cc4d5b2 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sat, 22 Jan 2022 09:14:04 -0800 Subject: [PATCH 52/78] unit test for not persisting the temporary nodes --- src/test/java/scenario/integrita/ServerTest.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/test/java/scenario/integrita/ServerTest.java b/src/test/java/scenario/integrita/ServerTest.java index 6c41cf1b..60285725 100644 --- a/src/test/java/scenario/integrita/ServerTest.java +++ b/src/test/java/scenario/integrita/ServerTest.java @@ -38,6 +38,10 @@ public void pushTestServerIndex() { falseHistoryTreeNode = new HistoryTreeNode(new NodeAddress(3, 1), OperationType.Insert, 1); res = s.push(falseHistoryTreeNode); assertTrue(res.get(0) == StatusCode.Accept); + assertTrue(s.db.totalNodes() == 1); // the temporary node should not be stored + + // TODO unit test for signature verification + } From d185f84430a973f87e7c7fc9db978e7552f350ec Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sat, 22 Jan 2022 09:14:14 -0800 Subject: [PATCH 53/78] revise a java doc --- src/main/java/scenario/integrita/Server.java | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/main/java/scenario/integrita/Server.java b/src/main/java/scenario/integrita/Server.java index 2abf9844..400dfbe1 100644 --- a/src/main/java/scenario/integrita/Server.java +++ b/src/main/java/scenario/integrita/Server.java @@ -73,7 +73,6 @@ public Tuple push(HistoryTreeNode historyTreeNode) { } } - // verify user-side signature on the leaf // needed for the authorization if (NodeAddress.isLeaf(historyTreeNode.addr)) { @@ -96,7 +95,7 @@ public Tuple push(HistoryTreeNode historyTreeNode) { } } - // update the database just for non-empty nodes + // update the database just for non-temporary nodes if (!NodeAddress.isTemporary(historyTreeNode.addr)) { db.historyTreeNodes.put(historyTreeNode.addr, historyTreeNode); } From c0c32bd5836554aa67c02a57ea548a18d8b61e6d Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sat, 22 Jan 2022 09:27:17 -0800 Subject: [PATCH 54/78] eraser of old tree digests --- .../java/scenario/integrita/ServerTest.java | 30 +++++++++++++------ 1 file changed, 21 insertions(+), 9 deletions(-) diff --git a/src/test/java/scenario/integrita/ServerTest.java b/src/test/java/scenario/integrita/ServerTest.java index 60285725..33a03e56 100644 --- a/src/test/java/scenario/integrita/ServerTest.java +++ b/src/test/java/scenario/integrita/ServerTest.java @@ -1,5 +1,6 @@ package scenario.integrita; +import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertTrue; import groovy.lang.Tuple; @@ -20,30 +21,41 @@ public void pushTestServerIndex() { s.db.insert(new User(1, new byte[0])); // create a history tree node whose index maps to the server's index - HistoryTreeNode historyTreeNode = new HistoryTreeNode(new NodeAddress(1, 0), OperationType.Insert, 1); - Tuple res = s.push(historyTreeNode); + HistoryTreeNode node1 = new HistoryTreeNode(new NodeAddress(1, 0), OperationType.Insert, 1); + Tuple res = s.push(node1); assertTrue(res.get(0) == StatusCode.Accept); // create a history tree node whose address does not map to the server's index - HistoryTreeNode falseHistoryTreeNode = new HistoryTreeNode(new NodeAddress(2, 0), OperationType.Insert, 1); - res = s.push(falseHistoryTreeNode); + HistoryTreeNode falsenode1 = new HistoryTreeNode(new NodeAddress(2, 0), OperationType.Insert, 1); + res = s.push(falsenode1); assertTrue(res.get(0) == StatusCode.Reject); // create a history tree node whose address is not the next expected one - falseHistoryTreeNode = new HistoryTreeNode(new NodeAddress(3, 0), OperationType.Insert, 1); - res = s.push(falseHistoryTreeNode); + HistoryTreeNode falsenode2 = new HistoryTreeNode(new NodeAddress(3, 0), OperationType.Insert, 1); + res = s.push(falsenode2); assertTrue(res.get(0) == StatusCode.Reject); // create a history tree node whose address is the next expected one - falseHistoryTreeNode = new HistoryTreeNode(new NodeAddress(3, 1), OperationType.Insert, 1); - res = s.push(falseHistoryTreeNode); + HistoryTreeNode node2 = new HistoryTreeNode(new NodeAddress(3, 1), OperationType.Insert, 1); + res = s.push(node2); assertTrue(res.get(0) == StatusCode.Accept); assertTrue(s.db.totalNodes() == 1); // the temporary node should not be stored // TODO unit test for signature verification + // add next node + HistoryTreeNode node3 = new HistoryTreeNode(new NodeAddress(4, 2), OperationType.Insert, 1); + res = s.push(node3); + assertTrue(res.get(0) == StatusCode.Accept); + assertTrue(s.db.totalNodes() == 2); // the temporary node should not be stored - + // add next node + // this is a tree digest, so prior tree digests should get erased + HistoryTreeNode node4 = new HistoryTreeNode(new NodeAddress(5, 3), OperationType.Insert, 1); + res = s.push(node4); + assertTrue(res.get(0) == StatusCode.Accept); + assertTrue(s.db.totalNodes() == 2); // the temporary node should not be stored + assertFalse(s.db.contains(node3.addr)); // the previous tree digest should be erased } @Test From 653ed4924d151ec0d455620ce4889f7612211a49 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sat, 22 Jan 2022 09:27:40 -0800 Subject: [PATCH 55/78] temp nodes that are tree digests should be stored --- src/main/java/scenario/integrita/Server.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/scenario/integrita/Server.java b/src/main/java/scenario/integrita/Server.java index 400dfbe1..a2ed8f95 100644 --- a/src/main/java/scenario/integrita/Server.java +++ b/src/main/java/scenario/integrita/Server.java @@ -96,7 +96,7 @@ public Tuple push(HistoryTreeNode historyTreeNode) { } // update the database just for non-temporary nodes - if (!NodeAddress.isTemporary(historyTreeNode.addr)) { + if (!NodeAddress.isTemporary(historyTreeNode.addr) || NodeAddress.isTreeDigest(historyTreeNode.addr)) { db.historyTreeNodes.put(historyTreeNode.addr, historyTreeNode); } From 835a20aa30f4c1f09b3176455bbce80900e89cea Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sat, 22 Jan 2022 09:58:51 -0800 Subject: [PATCH 56/78] adds status getter --- src/main/java/scenario/integrita/Server.java | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/main/java/scenario/integrita/Server.java b/src/main/java/scenario/integrita/Server.java index a2ed8f95..e98feea0 100644 --- a/src/main/java/scenario/integrita/Server.java +++ b/src/main/java/scenario/integrita/Server.java @@ -53,6 +53,11 @@ public Server(int index, int totalServers) { this.sk = keys[0]; this.vk = keys[1]; } + // getters and setters + + public NodeAddress getStatus() { + return status; + } // Integrita RPCs --------------------------------------------------------------------- public Tuple push(HistoryTreeNode historyTreeNode) { From 7e6a3d6389ed9351b63f819810431df8a0085605 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sat, 22 Jan 2022 09:59:01 -0800 Subject: [PATCH 57/78] checks the correct update of status --- src/test/java/scenario/integrita/ServerTest.java | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/src/test/java/scenario/integrita/ServerTest.java b/src/test/java/scenario/integrita/ServerTest.java index 33a03e56..9b9e5b3b 100644 --- a/src/test/java/scenario/integrita/ServerTest.java +++ b/src/test/java/scenario/integrita/ServerTest.java @@ -24,30 +24,36 @@ public void pushTestServerIndex() { HistoryTreeNode node1 = new HistoryTreeNode(new NodeAddress(1, 0), OperationType.Insert, 1); Tuple res = s.push(node1); assertTrue(res.get(0) == StatusCode.Accept); + assertTrue(s.getStatus() == node1.addr); // create a history tree node whose address does not map to the server's index HistoryTreeNode falsenode1 = new HistoryTreeNode(new NodeAddress(2, 0), OperationType.Insert, 1); res = s.push(falsenode1); assertTrue(res.get(0) == StatusCode.Reject); + assertTrue(s.getStatus() == node1.addr); // create a history tree node whose address is not the next expected one HistoryTreeNode falsenode2 = new HistoryTreeNode(new NodeAddress(3, 0), OperationType.Insert, 1); res = s.push(falsenode2); assertTrue(res.get(0) == StatusCode.Reject); + assertTrue(s.getStatus() == node1.addr); // create a history tree node whose address is the next expected one HistoryTreeNode node2 = new HistoryTreeNode(new NodeAddress(3, 1), OperationType.Insert, 1); res = s.push(node2); assertTrue(res.get(0) == StatusCode.Accept); assertTrue(s.db.totalNodes() == 1); // the temporary node should not be stored + assertTrue(s.getStatus() == node2.addr); // TODO unit test for signature verification - // add next node + // add next node, it is a tree digest HistoryTreeNode node3 = new HistoryTreeNode(new NodeAddress(4, 2), OperationType.Insert, 1); res = s.push(node3); assertTrue(res.get(0) == StatusCode.Accept); assertTrue(s.db.totalNodes() == 2); // the temporary node should not be stored + // TODO check server signature on tree digests + assertTrue(s.getStatus() == node3.addr); // add next node // this is a tree digest, so prior tree digests should get erased @@ -56,6 +62,10 @@ public void pushTestServerIndex() { assertTrue(res.get(0) == StatusCode.Accept); assertTrue(s.db.totalNodes() == 2); // the temporary node should not be stored assertFalse(s.db.contains(node3.addr)); // the previous tree digest should be erased + // TODO check server signature on tree digests + assertTrue(s.getStatus() == node4.addr); + + } @Test From b9d45a691a32af038849925811d7fbf8461c9d2b Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sat, 22 Jan 2022 10:23:45 -0800 Subject: [PATCH 58/78] resolves linter issues --- src/main/java/scenario/integrita/Server.java | 17 +++- .../integrita/database/HistoryTreeStore.java | 80 +++++++++---------- .../java/scenario/integrita/hash/Hash.java | 15 ++-- .../integrita/historytree/NodeAddress.java | 10 ++- .../integrita/signature/Signature.java | 13 ++- .../java/scenario/integrita/user/User.java | 3 + .../java/scenario/integrita/ServerTest.java | 4 +- .../database/HisoryTreeStoreTest.java | 6 +- 8 files changed, 90 insertions(+), 58 deletions(-) diff --git a/src/main/java/scenario/integrita/Server.java b/src/main/java/scenario/integrita/Server.java index e98feea0..b653e8ea 100644 --- a/src/main/java/scenario/integrita/Server.java +++ b/src/main/java/scenario/integrita/Server.java @@ -34,14 +34,24 @@ public class Server implements BaseNode { ArrayList 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; @@ -53,13 +63,18 @@ public Server(int index, int totalServers) { this.sk = keys[0]; this.vk = keys[1]; } - // getters and setters + + // getters and setters --------------------- public NodeAddress getStatus() { 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 diff --git a/src/main/java/scenario/integrita/database/HistoryTreeStore.java b/src/main/java/scenario/integrita/database/HistoryTreeStore.java index 6a0129ee..5c9b2026 100644 --- a/src/main/java/scenario/integrita/database/HistoryTreeStore.java +++ b/src/main/java/scenario/integrita/database/HistoryTreeStore.java @@ -14,6 +14,7 @@ public class HistoryTreeStore implements Store { public HashMap users; public HashMap historyTreeNodes; + // constructor ---------------------------------------------- public HistoryTreeStore() { this.users = new HashMap<>(); this.historyTreeNodes = new HashMap<>(); @@ -24,73 +25,72 @@ public HistoryTreeStore(HashMap users, HashMap historyTreeNodes) { - for (HistoryTreeNode node : historyTreeNodes) { - this.insert(node); - } - return true; - } - @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); + // getters and setters --------------------------- + public byte[] getVerificationKey(int userIndex) { + return users.get(userIndex).vk; } + // utility methods ----------------------------- public int totalNodes() { return this.historyTreeNodes.size(); } - public boolean insert(User user) { + /** + * inserts a user to the database. + */ + public boolean insertUser(User user) { // TODO check duplicates users.put(user.id, user); return true; } /** - * erases all the past nodes whose `position` precede the position of the supplied `addr` exclusively - * - * @param addr + * erases all the past nodes whose `position` precede the position of the supplied `addr` exclusively. */ public void cleanDigests(NodeAddress addr) { Set keySet = historyTreeNodes.keySet(); - - for (Iterator> it = historyTreeNodes.entrySet().iterator(); it.hasNext(); ) { + Iterator> it = historyTreeNodes.entrySet().iterator(); + while (it.hasNext()) { Map.Entry entry = it.next(); - if (NodeAddress.isTreeDigest(entry.getKey()) && (entry.getKey().position < addr.position) && (entry.getKey().position != 1)) { + boolean isTreeDigest = NodeAddress.isTreeDigest(entry.getKey()); + if (isTreeDigest && (entry.getKey().position < addr.position) && (entry.getKey().position != 1)) { it.remove(); } } } /** - * checks if nodeAddress belongs to HistoryTreeStore object - * - * @param nodeAddress - * @return + * checks if nodeAddress belongs to HistoryTreeStore object. */ public boolean contains(NodeAddress nodeAddress) { boolean exists = historyTreeNodes.containsKey(nodeAddress); return exists; } + // store API ----------------- + @Override + public boolean insert(HistoryTreeNode historyTreeNode) { + historyTreeNodes.put(historyTreeNode.addr, historyTreeNode); + return true; + } + + @Override + public boolean insertAll(ArrayList historyTreeNodes) { + for (HistoryTreeNode node : historyTreeNodes) { + this.insert(node); + } + return true; + } + + @Override + public boolean delete(NodeAddress nodeAddress) { + historyTreeNodes.remove(nodeAddress); + return true; + } + + @Override + public HistoryTreeNode get(NodeAddress nodeAddress) { + return historyTreeNodes.get(nodeAddress); + } } diff --git a/src/main/java/scenario/integrita/hash/Hash.java b/src/main/java/scenario/integrita/hash/Hash.java index 74cdbc89..a9af4139 100644 --- a/src/main/java/scenario/integrita/hash/Hash.java +++ b/src/main/java/scenario/integrita/hash/Hash.java @@ -1,16 +1,21 @@ package scenario.integrita.hash; -import java.nio.charset.StandardCharsets; //import org.bouncycastle.jcajce.provider.digest.Keccak; //import org.bouncycastle.util.encoders.Hex; +/** + * Hash implementation used in Merkle tree. + */ public class Hash { + /** + * hash function. + */ public static String generateHash(String originalString) { -// Keccak.Digest256 digest256 = new Keccak.Digest256(); -// byte[] hashedByteArray = digest256.digest( -// originalString.getBytes(StandardCharsets.UTF_8)); -// return new String(Hex.encode(hashedByteArray)); + // Keccak.Digest256 digest256 = new Keccak.Digest256(); + // byte[] hashedByteArray = digest256.digest( + // originalString.getBytes(StandardCharsets.UTF_8)); + // return new String(Hex.encode(hashedByteArray)); return ""; } } diff --git a/src/main/java/scenario/integrita/historytree/NodeAddress.java b/src/main/java/scenario/integrita/historytree/NodeAddress.java index f9b3c5bb..9c9dc328 100644 --- a/src/main/java/scenario/integrita/historytree/NodeAddress.java +++ b/src/main/java/scenario/integrita/historytree/NodeAddress.java @@ -116,12 +116,15 @@ public static int mapServerIndex(NodeAddress addr, int totalNumberServer) { //Compare only account numbers @Override public boolean equals(Object obj) { - if (this == obj) + if (this == obj) { return true; - if (obj == null) + } + if (obj == null) { return false; - if (getClass() != obj.getClass()) + } + if (getClass() != obj.getClass()) { return false; + } NodeAddress other = (NodeAddress) obj; return (position == other.position) && (level == other.level); } @@ -132,5 +135,4 @@ public int hashCode() { } - } diff --git a/src/main/java/scenario/integrita/signature/Signature.java b/src/main/java/scenario/integrita/signature/Signature.java index 29724d59..873d4348 100644 --- a/src/main/java/scenario/integrita/signature/Signature.java +++ b/src/main/java/scenario/integrita/signature/Signature.java @@ -5,19 +5,28 @@ */ public class Signature { + /** + * generates signature and verification keys. + */ public static byte[][] keyGen() { // @TODO generate keys byte[][] result = new byte[2][]; return result; } - public static byte[] sign(String msg, byte[] signature_key) { + /** + * signs the message msg using provided signatureKey. + */ + public static byte[] sign(String msg, byte[] signatureKey) { // @TODO sign using the generated keys byte[] result = new byte[0]; return result; } - public static boolean verify(String msg, byte[] signature, byte[] verification_key) { + /** + * verifies the signature against the supplied msg and the verificationKey. + */ + public static boolean verify(String msg, byte[] signature, byte[] verificationKey) { // @TODO verify using the generated keys return true; } diff --git a/src/main/java/scenario/integrita/user/User.java b/src/main/java/scenario/integrita/user/User.java index 9df3baf2..25923f0b 100644 --- a/src/main/java/scenario/integrita/user/User.java +++ b/src/main/java/scenario/integrita/user/User.java @@ -7,11 +7,14 @@ public class User { public Integer id; public byte[] vk; + // constructors ------------------ public User(Integer id) { this.id = id; } + public User() { } + public User(Integer id, byte[] vk) { this.id = id; this.vk = vk; diff --git a/src/test/java/scenario/integrita/ServerTest.java b/src/test/java/scenario/integrita/ServerTest.java index 9b9e5b3b..6b2e97c8 100644 --- a/src/test/java/scenario/integrita/ServerTest.java +++ b/src/test/java/scenario/integrita/ServerTest.java @@ -18,7 +18,7 @@ public void pushTestServerIndex() { // set up a server Server s = new Server(1, 4); // add a user - s.db.insert(new User(1, new byte[0])); + s.db.insertUser(new User(1, new byte[0])); // create a history tree node whose index maps to the server's index HistoryTreeNode node1 = new HistoryTreeNode(new NodeAddress(1, 0), OperationType.Insert, 1); @@ -64,8 +64,6 @@ public void pushTestServerIndex() { assertFalse(s.db.contains(node3.addr)); // the previous tree digest should be erased // TODO check server signature on tree digests assertTrue(s.getStatus() == node4.addr); - - } @Test diff --git a/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java b/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java index e45ad5d4..016c96ca 100644 --- a/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java +++ b/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java @@ -37,9 +37,9 @@ public void TestInsertDeleteGet() { HistoryTreeStore historyTreeStore = new HistoryTreeStore(); // add 3 users - historyTreeStore.insert(new User(1)); - historyTreeStore.insert(new User(2)); - historyTreeStore.insert(new User(3)); + historyTreeStore.insertUser(new User(1)); + historyTreeStore.insertUser(new User(2)); + historyTreeStore.insertUser(new User(3)); // create three nodes, two of which have the same address HistoryTreeNode historyTreeNode1 = new HistoryTreeNode(new NodeAddress(0, 1), OperationType.Insert, 1); From 6ddb0f80303fb7fb414e97832ae3fa906b4c9d1b Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 23 Jan 2022 07:49:47 -0800 Subject: [PATCH 59/78] WIP --- src/main/java/scenario/integrita/Server.java | 2 +- .../integrita/database/HistoryTreeStore.java | 51 +++++++++++++------ .../scenario/integrita/database/Store.java | 9 +++- .../java/scenario/integrita/ServerTest.java | 2 +- .../database/HisoryTreeStoreTest.java | 8 +-- 5 files changed, 49 insertions(+), 23 deletions(-) diff --git a/src/main/java/scenario/integrita/Server.java b/src/main/java/scenario/integrita/Server.java index b653e8ea..b2508332 100644 --- a/src/main/java/scenario/integrita/Server.java +++ b/src/main/java/scenario/integrita/Server.java @@ -117,7 +117,7 @@ public Tuple push(HistoryTreeNode historyTreeNode) { // update the database just for non-temporary nodes if (!NodeAddress.isTemporary(historyTreeNode.addr) || NodeAddress.isTreeDigest(historyTreeNode.addr)) { - db.historyTreeNodes.put(historyTreeNode.addr, historyTreeNode); + db.insert(historyTreeNode); } // remove tree digests of the old operations diff --git a/src/main/java/scenario/integrita/database/HistoryTreeStore.java b/src/main/java/scenario/integrita/database/HistoryTreeStore.java index 5c9b2026..30204868 100644 --- a/src/main/java/scenario/integrita/database/HistoryTreeStore.java +++ b/src/main/java/scenario/integrita/database/HistoryTreeStore.java @@ -11,8 +11,8 @@ */ public class HistoryTreeStore implements Store { - public HashMap users; - public HashMap historyTreeNodes; + private final HashMap users; + private final HashMap historyTreeNodes; // constructor ---------------------------------------------- public HistoryTreeStore() { @@ -36,12 +36,17 @@ public int totalNodes() { return this.historyTreeNodes.size(); } - /** - * inserts a user to the database. - */ - public boolean insertUser(User user) { - // TODO check duplicates - users.put(user.id, user); + public boolean insertAllUsers(ArrayList users) { + for (User u : users) { + this.insert(u); + } + return true; + } + + public boolean insertAllNodes(ArrayList historyTreeNodes) { + for (HistoryTreeNode node : historyTreeNodes) { + this.insert(node); + } return true; } @@ -68,7 +73,8 @@ public boolean contains(NodeAddress nodeAddress) { return exists; } - // store API ----------------- + // ------------------- store API ----------------- + @Override public boolean insert(HistoryTreeNode historyTreeNode) { historyTreeNodes.put(historyTreeNode.addr, historyTreeNode); @@ -76,13 +82,22 @@ public boolean insert(HistoryTreeNode historyTreeNode) { } @Override - public boolean insertAll(ArrayList 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(User user) { + return users.get(user.id); + } + @Override public boolean delete(NodeAddress nodeAddress) { historyTreeNodes.remove(nodeAddress); @@ -90,7 +105,13 @@ public boolean delete(NodeAddress nodeAddress) { } @Override - public HistoryTreeNode get(NodeAddress nodeAddress) { - return historyTreeNodes.get(nodeAddress); + public boolean delete(User user) { + users.remove(user.id); + return true; } + +// @Override +// public boolean contains(User user); +// boolean contains(HistoryTreeNode historyTreeNode); + } diff --git a/src/main/java/scenario/integrita/database/Store.java b/src/main/java/scenario/integrita/database/Store.java index 95aa140e..d9b66230 100644 --- a/src/main/java/scenario/integrita/database/Store.java +++ b/src/main/java/scenario/integrita/database/Store.java @@ -4,6 +4,7 @@ import scenario.integrita.historytree.HistoryTreeNode; import scenario.integrita.historytree.NodeAddress; +import scenario.integrita.user.User; /** * storage api. @@ -11,11 +12,15 @@ public interface Store { boolean insert(HistoryTreeNode historyTreeNode); + boolean insert(User user); - boolean insertAll(ArrayList historyTreeNodes); + HistoryTreeNode get(NodeAddress nodeAddress); + User get(User user); boolean delete(NodeAddress nodeAddress); + boolean delete(User user); - HistoryTreeNode get(NodeAddress nodeAddress); + boolean contains(User user); + boolean contains(HistoryTreeNode historyTreeNode); } diff --git a/src/test/java/scenario/integrita/ServerTest.java b/src/test/java/scenario/integrita/ServerTest.java index 6b2e97c8..7ec2e808 100644 --- a/src/test/java/scenario/integrita/ServerTest.java +++ b/src/test/java/scenario/integrita/ServerTest.java @@ -18,7 +18,7 @@ public void pushTestServerIndex() { // set up a server Server s = new Server(1, 4); // add a user - s.db.insertUser(new User(1, new byte[0])); + s.db.insert(new User(1, new byte[0])); // create a history tree node whose index maps to the server's index HistoryTreeNode node1 = new HistoryTreeNode(new NodeAddress(1, 0), OperationType.Insert, 1); diff --git a/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java b/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java index 016c96ca..496585f9 100644 --- a/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java +++ b/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java @@ -37,9 +37,9 @@ public void TestInsertDeleteGet() { HistoryTreeStore historyTreeStore = new HistoryTreeStore(); // add 3 users - historyTreeStore.insertUser(new User(1)); - historyTreeStore.insertUser(new User(2)); - historyTreeStore.insertUser(new User(3)); + historyTreeStore.insert(new User(1)); + historyTreeStore.insert(new User(2)); + historyTreeStore.insert(new User(3)); // create three nodes, two of which have the same address HistoryTreeNode historyTreeNode1 = new HistoryTreeNode(new NodeAddress(0, 1), OperationType.Insert, 1); @@ -48,7 +48,7 @@ public void TestInsertDeleteGet() { HistoryTreeNode historyTreeNode3 = new HistoryTreeNode(new NodeAddress(2, 1), OperationType.Insert, 2); - historyTreeStore.insertAll(new ArrayList(Arrays.asList(historyTreeNode1, historyTreeNode2, historyTreeNode3))); + historyTreeStore.insertAllNodes(new ArrayList(Arrays.asList(historyTreeNode1, historyTreeNode2, historyTreeNode3))); // duplicates are not allowed assertTrue((historyTreeStore.totalNodes() == 2)); From 8b7097bd0d7eca1d1438aba3c5f5dc91afc12b3d Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 23 Jan 2022 09:21:45 -0800 Subject: [PATCH 60/78] adds contains methods --- .../integrita/database/HistoryTreeStore.java | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/src/main/java/scenario/integrita/database/HistoryTreeStore.java b/src/main/java/scenario/integrita/database/HistoryTreeStore.java index 30204868..fad56d4f 100644 --- a/src/main/java/scenario/integrita/database/HistoryTreeStore.java +++ b/src/main/java/scenario/integrita/database/HistoryTreeStore.java @@ -110,8 +110,16 @@ public boolean delete(User user) { return true; } -// @Override -// public boolean contains(User user); -// boolean contains(HistoryTreeNode historyTreeNode); + @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; + } } From 5d15c71590f483ca0e1ff878a8a3a36752d914c7 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 23 Jan 2022 09:28:49 -0800 Subject: [PATCH 61/78] adds test for contains method --- .../scenario/integrita/database/HisoryTreeStoreTest.java | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java b/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java index 496585f9..1218018a 100644 --- a/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java +++ b/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java @@ -53,11 +53,15 @@ public void TestInsertDeleteGet() { // duplicates are not allowed assertTrue((historyTreeStore.totalNodes() == 2)); + // test contains method + assertTrue(historyTreeStore.contains(historyTreeNode1)); + assertTrue(historyTreeStore.contains(historyTreeNode3)); + historyTreeStore.delete(historyTreeNode1.addr); // check the correct deletion assertTrue((historyTreeStore.totalNodes() == 1)); // only historyTreeNode3 is left - assertTrue((historyTreeStore.get(historyTreeNode3.addr) == historyTreeNode3)); + assertTrue(historyTreeStore.contains(historyTreeNode3)); } @Test From acbf6be6ccc14d686b47275c96d14cd81473a617 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 23 Jan 2022 09:45:32 -0800 Subject: [PATCH 62/78] changes get signature --- src/main/java/scenario/integrita/database/Store.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/scenario/integrita/database/Store.java b/src/main/java/scenario/integrita/database/Store.java index d9b66230..0f10e0dc 100644 --- a/src/main/java/scenario/integrita/database/Store.java +++ b/src/main/java/scenario/integrita/database/Store.java @@ -15,7 +15,7 @@ public interface Store { boolean insert(User user); HistoryTreeNode get(NodeAddress nodeAddress); - User get(User user); + User get(Integer id); boolean delete(NodeAddress nodeAddress); boolean delete(User user); From 9de462ee1f932bf96f6986beee2eba2489e1b39d Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 23 Jan 2022 09:45:56 -0800 Subject: [PATCH 63/78] adds totalUsers util --- .../java/scenario/integrita/database/HistoryTreeStore.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/main/java/scenario/integrita/database/HistoryTreeStore.java b/src/main/java/scenario/integrita/database/HistoryTreeStore.java index fad56d4f..d0e012c4 100644 --- a/src/main/java/scenario/integrita/database/HistoryTreeStore.java +++ b/src/main/java/scenario/integrita/database/HistoryTreeStore.java @@ -36,6 +36,10 @@ public int totalNodes() { return this.historyTreeNodes.size(); } + public int totalUsers(){ + return this.users.size(); + } + public boolean insertAllUsers(ArrayList users) { for (User u : users) { this.insert(u); From 3a0d0f313b6b0036901240ebcc9162b3c95ce3af Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 23 Jan 2022 09:46:20 -0800 Subject: [PATCH 64/78] checks if user exists before accessing it --- .../java/scenario/integrita/database/HistoryTreeStore.java | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/main/java/scenario/integrita/database/HistoryTreeStore.java b/src/main/java/scenario/integrita/database/HistoryTreeStore.java index d0e012c4..458b3e6e 100644 --- a/src/main/java/scenario/integrita/database/HistoryTreeStore.java +++ b/src/main/java/scenario/integrita/database/HistoryTreeStore.java @@ -81,6 +81,9 @@ public boolean contains(NodeAddress nodeAddress) { @Override public boolean insert(HistoryTreeNode historyTreeNode) { + if (this.contains(historyTreeNode)){ + return false; + } historyTreeNodes.put(historyTreeNode.addr, historyTreeNode); return true; } From 145d80c3c839d895d83cb6acf8b59f573b0882b3 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 23 Jan 2022 09:46:42 -0800 Subject: [PATCH 65/78] adds unit test for user related methods --- .../database/HisoryTreeStoreTest.java | 44 ++++++++++++++++++- 1 file changed, 42 insertions(+), 2 deletions(-) diff --git a/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java b/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java index 1218018a..4602f568 100644 --- a/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java +++ b/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java @@ -33,7 +33,7 @@ public HistoryTreeStore initHistoryTreeStore(int v) { } @Test - public void TestInsertDeleteGet() { + public void TestHistoryNodes() { HistoryTreeStore historyTreeStore = new HistoryTreeStore(); // add 3 users @@ -42,7 +42,7 @@ public void TestInsertDeleteGet() { historyTreeStore.insert(new User(3)); // create three nodes, two of which have the same address - HistoryTreeNode historyTreeNode1 = new HistoryTreeNode(new NodeAddress(0, 1), OperationType.Insert, 1); + HistoryTreeNode historyTreeNode1 = new HistoryTreeNode(new NodeAddress(0, 1), OperationType.Delete, 1); // historyTreeNode2 points to the same address as historyTreeNode1 HistoryTreeNode historyTreeNode2 = new HistoryTreeNode(new NodeAddress(0, 1), OperationType.Insert, 2); @@ -50,6 +50,10 @@ public void TestInsertDeleteGet() { historyTreeStore.insertAllNodes(new ArrayList(Arrays.asList(historyTreeNode1, historyTreeNode2, historyTreeNode3))); + // test get method + // insertion of historyTreeNode1 should get through but not historyTreeNode2 + assertTrue(historyTreeStore.get(historyTreeNode1.addr) == historyTreeNode1); + // duplicates are not allowed assertTrue((historyTreeStore.totalNodes() == 2)); @@ -62,8 +66,44 @@ public void TestInsertDeleteGet() { assertTrue((historyTreeStore.totalNodes() == 1)); // only historyTreeNode3 is left assertTrue(historyTreeStore.contains(historyTreeNode3)); + + // test get method + assertTrue(historyTreeStore.get(historyTreeNode3.addr) == historyTreeNode3); + } + + public void TestUsers() { + HistoryTreeStore historyTreeStore = new HistoryTreeStore(); + + // add 3 users + User u1 = new User(1); + User u2 = new User(2); + User u3 = new User(3); + historyTreeStore.insert(u1); + historyTreeStore.insert(u1); + historyTreeStore.insert(u2); + historyTreeStore.insert(u3); + + // check whether the inserted users are correctly included + // insertion of historyTreeNode1 should get through but not historyTreeNode2 + assertTrue(historyTreeStore.get(u1.id) == u1); + assertTrue(historyTreeStore.get(u2.id) == u2); + assertTrue(historyTreeStore.get(u3.id) == u3); + + // duplicates are not allowed + assertTrue((historyTreeStore.totalUsers() == 3)); + + // test contains method + assertTrue(historyTreeStore.contains(u1)); + assertTrue(historyTreeStore.contains(u2)); + + // test delete + historyTreeStore.delete(u3); + // check the correct deletion + assertFalse(historyTreeStore.contains(u3)); } + + @Test public void testCleanTreeDigest() { HistoryTreeStore historyTreeStore = initHistoryTreeStore(5); From 44a4af407a536592319891e183626f9c9101704f Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 23 Jan 2022 09:47:10 -0800 Subject: [PATCH 66/78] updates get user input type --- .../java/scenario/integrita/database/HistoryTreeStore.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/scenario/integrita/database/HistoryTreeStore.java b/src/main/java/scenario/integrita/database/HistoryTreeStore.java index 458b3e6e..82ab0533 100644 --- a/src/main/java/scenario/integrita/database/HistoryTreeStore.java +++ b/src/main/java/scenario/integrita/database/HistoryTreeStore.java @@ -101,8 +101,8 @@ public HistoryTreeNode get(NodeAddress nodeAddress) { } @Override - public User get(User user) { - return users.get(user.id); + public User get(Integer id) { + return users.get(id); } @Override From 448c61808c53cf7848042230fa4b6a10f1a0dba7 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 23 Jan 2022 09:47:49 -0800 Subject: [PATCH 67/78] adds test macro --- .../java/scenario/integrita/database/HisoryTreeStoreTest.java | 1 + 1 file changed, 1 insertion(+) diff --git a/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java b/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java index 4602f568..cfbe9741 100644 --- a/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java +++ b/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java @@ -71,6 +71,7 @@ public void TestHistoryNodes() { assertTrue(historyTreeStore.get(historyTreeNode3.addr) == historyTreeNode3); } + @Test public void TestUsers() { HistoryTreeStore historyTreeStore = new HistoryTreeStore(); From cf924e0601dd0094e9775f750c92c3d26acb20d9 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 23 Jan 2022 09:51:44 -0800 Subject: [PATCH 68/78] unit test for insertAllUsers --- .../scenario/integrita/database/HisoryTreeStoreTest.java | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java b/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java index cfbe9741..3c49af2d 100644 --- a/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java +++ b/src/test/java/scenario/integrita/database/HisoryTreeStoreTest.java @@ -79,10 +79,8 @@ public void TestUsers() { User u1 = new User(1); User u2 = new User(2); User u3 = new User(3); - historyTreeStore.insert(u1); - historyTreeStore.insert(u1); - historyTreeStore.insert(u2); - historyTreeStore.insert(u3); + historyTreeStore.insertAllUsers(new ArrayList(Arrays.asList(u1, u1, u2, u3))); + // check whether the inserted users are correctly included // insertion of historyTreeNode1 should get through but not historyTreeNode2 @@ -103,8 +101,6 @@ public void TestUsers() { assertFalse(historyTreeStore.contains(u3)); } - - @Test public void testCleanTreeDigest() { HistoryTreeStore historyTreeStore = initHistoryTreeStore(5); From f0eaa6ec108cf896aeb64b9472580609cd538318 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 30 Jan 2022 07:34:56 -0800 Subject: [PATCH 69/78] adds pull algorithm --- src/main/java/scenario/integrita/Server.java | 21 ++++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/src/main/java/scenario/integrita/Server.java b/src/main/java/scenario/integrita/Server.java index b2508332..b960d0e5 100644 --- a/src/main/java/scenario/integrita/Server.java +++ b/src/main/java/scenario/integrita/Server.java @@ -13,6 +13,7 @@ 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; /** @@ -138,6 +139,26 @@ public Tuple push(HistoryTreeNode historyTreeNode) { return new Tuple(new Object[]{StatusCode.Accept, 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 From e77e87496099d5aef0cbddb0b0a87b63ba559adb Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 30 Jan 2022 07:36:58 -0800 Subject: [PATCH 70/78] deletes incomplete tests --- .../java/scenario/integrita/ServerTest.java | 24 ------------------- 1 file changed, 24 deletions(-) diff --git a/src/test/java/scenario/integrita/ServerTest.java b/src/test/java/scenario/integrita/ServerTest.java index 6b2e97c8..93ee677c 100644 --- a/src/test/java/scenario/integrita/ServerTest.java +++ b/src/test/java/scenario/integrita/ServerTest.java @@ -65,28 +65,4 @@ public void pushTestServerIndex() { // TODO check server signature on tree digests assertTrue(s.getStatus() == node4.addr); } - - @Test - public void pushTestLabelDistance() { - // set server's status - - // create a history tree node whose index has more than N difference from the server's status - } - - @Test - public void pushTestTemporaryNodes() { - // create a temporary history tree node - // push it to the server - // the db should not change - } - - @Test - public void pushTestInsertTreeDigest() { - // populate a server with proper nodes of the history tree - // create a tree digest - // push it to the server - // check internal state of the server - // the size of db - // the state variable - } } From 0ed1ed049d1d714f39c5c5865c553671711f671c Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 30 Jan 2022 09:33:13 -0800 Subject: [PATCH 71/78] deletes hash code --- src/main/java/scenario/integrita/hash/Hash.java | 12 ++---------- 1 file changed, 2 insertions(+), 10 deletions(-) diff --git a/src/main/java/scenario/integrita/hash/Hash.java b/src/main/java/scenario/integrita/hash/Hash.java index a9af4139..640a5747 100644 --- a/src/main/java/scenario/integrita/hash/Hash.java +++ b/src/main/java/scenario/integrita/hash/Hash.java @@ -1,8 +1,6 @@ package scenario.integrita.hash; - -//import org.bouncycastle.jcajce.provider.digest.Keccak; -//import org.bouncycastle.util.encoders.Hex; +import org.bouncycastle.util.encoders.Hex; /** * Hash implementation used in Merkle tree. @@ -11,11 +9,5 @@ public class Hash { /** * hash function. */ - public static String generateHash(String originalString) { - // Keccak.Digest256 digest256 = new Keccak.Digest256(); - // byte[] hashedByteArray = digest256.digest( - // originalString.getBytes(StandardCharsets.UTF_8)); - // return new String(Hex.encode(hashedByteArray)); - return ""; - } + } From de59939defbe248bb918e601d61768676061d004 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 30 Jan 2022 09:33:25 -0800 Subject: [PATCH 72/78] comment for vk --- src/main/java/scenario/integrita/user/User.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/scenario/integrita/user/User.java b/src/main/java/scenario/integrita/user/User.java index 25923f0b..91d7a119 100644 --- a/src/main/java/scenario/integrita/user/User.java +++ b/src/main/java/scenario/integrita/user/User.java @@ -5,7 +5,7 @@ */ public class User { public Integer id; - public byte[] vk; + public byte[] vk; // signature verification key // constructors ------------------ public User(Integer id) { From a7701d6b4178dbea3da83f0c7367404744c521b8 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 30 Jan 2022 09:35:37 -0800 Subject: [PATCH 73/78] resolves linter issues --- src/main/java/scenario/integrita/hash/Hash.java | 5 ----- 1 file changed, 5 deletions(-) diff --git a/src/main/java/scenario/integrita/hash/Hash.java b/src/main/java/scenario/integrita/hash/Hash.java index 640a5747..4e871d94 100644 --- a/src/main/java/scenario/integrita/hash/Hash.java +++ b/src/main/java/scenario/integrita/hash/Hash.java @@ -1,13 +1,8 @@ package scenario.integrita.hash; -import org.bouncycastle.util.encoders.Hex; - /** * Hash implementation used in Merkle tree. */ public class Hash { - /** - * hash function. - */ } From 068286260846a76c1bbed3b36fca101096f02560 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 30 Jan 2022 09:44:18 -0800 Subject: [PATCH 74/78] resolves linter errors --- .../integrita/database/HistoryTreeStore.java | 27 ++++++++++++------- .../scenario/integrita/database/Store.java | 8 ++++-- 2 files changed, 23 insertions(+), 12 deletions(-) diff --git a/src/main/java/scenario/integrita/database/HistoryTreeStore.java b/src/main/java/scenario/integrita/database/HistoryTreeStore.java index 82ab0533..3ae683ee 100644 --- a/src/main/java/scenario/integrita/database/HistoryTreeStore.java +++ b/src/main/java/scenario/integrita/database/HistoryTreeStore.java @@ -36,10 +36,13 @@ public int totalNodes() { return this.historyTreeNodes.size(); } - public int totalUsers(){ + public int totalUsers() { return this.users.size(); } + /** + * adds all the users supplied by `users` to the `HistoryTreeStore` object. + */ public boolean insertAllUsers(ArrayList users) { for (User u : users) { this.insert(u); @@ -47,6 +50,9 @@ public boolean insertAllUsers(ArrayList users) { return true; } + /** + * inserts all the history nodes contained in the `historyTreeNodes` into the `HistoryTreeStore` instance. + */ public boolean insertAllNodes(ArrayList historyTreeNodes) { for (HistoryTreeNode node : historyTreeNodes) { this.insert(node); @@ -69,19 +75,11 @@ public void cleanDigests(NodeAddress addr) { } } - /** - * checks if nodeAddress belongs to HistoryTreeStore object. - */ - public boolean contains(NodeAddress nodeAddress) { - boolean exists = historyTreeNodes.containsKey(nodeAddress); - return exists; - } - // ------------------- store API ----------------- @Override public boolean insert(HistoryTreeNode historyTreeNode) { - if (this.contains(historyTreeNode)){ + if (this.contains(historyTreeNode)) { return false; } historyTreeNodes.put(historyTreeNode.addr, historyTreeNode); @@ -129,4 +127,13 @@ public boolean contains(HistoryTreeNode historyTreeNode) { return exists; } + /** + * checks if nodeAddress belongs to HistoryTreeStore object. + */ + @Override + public boolean contains(NodeAddress nodeAddress) { + boolean exists = historyTreeNodes.containsKey(nodeAddress); + return exists; + } + } diff --git a/src/main/java/scenario/integrita/database/Store.java b/src/main/java/scenario/integrita/database/Store.java index 0f10e0dc..47ace32c 100644 --- a/src/main/java/scenario/integrita/database/Store.java +++ b/src/main/java/scenario/integrita/database/Store.java @@ -1,7 +1,5 @@ package scenario.integrita.database; -import java.util.ArrayList; - import scenario.integrita.historytree.HistoryTreeNode; import scenario.integrita.historytree.NodeAddress; import scenario.integrita.user.User; @@ -12,15 +10,21 @@ public interface Store { boolean insert(HistoryTreeNode historyTreeNode); + boolean insert(User user); HistoryTreeNode get(NodeAddress nodeAddress); + User get(Integer id); boolean delete(NodeAddress nodeAddress); + boolean delete(User user); boolean contains(User user); + boolean contains(HistoryTreeNode historyTreeNode); + boolean contains(NodeAddress nodeAddress); + } From 057632948b2457d5d10b7ced569e78af8c367bf7 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 30 Jan 2022 09:51:50 -0800 Subject: [PATCH 75/78] java doc for pull method --- src/main/java/scenario/integrita/Server.java | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/src/main/java/scenario/integrita/Server.java b/src/main/java/scenario/integrita/Server.java index b960d0e5..4b634d26 100644 --- a/src/main/java/scenario/integrita/Server.java +++ b/src/main/java/scenario/integrita/Server.java @@ -139,6 +139,16 @@ public Tuple push(HistoryTreeNode historyTreeNode) { 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. + * @param user + * @param nodeAddress + * @return + */ public Tuple pull(User user, NodeAddress nodeAddress){ // check whether user is authorized if (!this.db.contains(user)){ From 5e8ea949eecc349d7b840ff4ac5787975fd02ec2 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 30 Jan 2022 09:57:20 -0800 Subject: [PATCH 76/78] adds pull test --- .../java/scenario/integrita/ServerTest.java | 35 +++++++++---------- 1 file changed, 17 insertions(+), 18 deletions(-) diff --git a/src/test/java/scenario/integrita/ServerTest.java b/src/test/java/scenario/integrita/ServerTest.java index 7ec2e808..ac612224 100644 --- a/src/test/java/scenario/integrita/ServerTest.java +++ b/src/test/java/scenario/integrita/ServerTest.java @@ -67,26 +67,25 @@ public void pushTestServerIndex() { } @Test - public void pushTestLabelDistance() { - // set server's status + public void pullTest() { + // set up a server + Server s = new Server(1, 4); + // add a user + User user1 = new User(1, new byte[0]); + s.db.insert(user1); - // create a history tree node whose index has more than N difference from the server's status - } + // create a history tree node whose index maps to the server's index + NodeAddress nodeAddress1 = new NodeAddress(1, 0); + HistoryTreeNode node1 = new HistoryTreeNode(nodeAddress1, OperationType.Insert, 1); + Tuple pushRes = s.push(node1); + assertTrue(pushRes.get(0) == StatusCode.Accept); + assertTrue(s.getStatus() == node1.addr); + + + Tuple pullRes = s.pull(user1, nodeAddress1); + assertTrue(pullRes.get(0) == node1); + assertTrue(pullRes.get(1) != null); - @Test - public void pushTestTemporaryNodes() { - // create a temporary history tree node - // push it to the server - // the db should not change - } - @Test - public void pushTestInsertTreeDigest() { - // populate a server with proper nodes of the history tree - // create a tree digest - // push it to the server - // check internal state of the server - // the size of db - // the state variable } } From 96b5ff274253d8f4ad76c1f9bd894b7f257b60f2 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 30 Jan 2022 09:59:23 -0800 Subject: [PATCH 77/78] fixes linter errors --- src/main/java/scenario/integrita/Server.java | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/src/main/java/scenario/integrita/Server.java b/src/main/java/scenario/integrita/Server.java index 4b634d26..4ed03cd0 100644 --- a/src/main/java/scenario/integrita/Server.java +++ b/src/main/java/scenario/integrita/Server.java @@ -145,24 +145,21 @@ public Tuple push(HistoryTreeNode historyTreeNode) { * 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. - * @param user - * @param nodeAddress - * @return */ - public Tuple pull(User user, NodeAddress nodeAddress){ + public Tuple pull(User user, NodeAddress nodeAddress) { // check whether user is authorized - if (!this.db.contains(user)){ + if (!this.db.contains(user)) { return new Tuple(new Object[]{null, null}); } - if (!this.db.contains(nodeAddress)){ + 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); + if (NodeAddress.isTreeDigest(nodeAddress)) { + singauture = Signature.sign(res.hash, this.sk); } return new Tuple(new Object[]{res, singauture}); From 7200ebbe2b7dd921976eca3b4296f5ea699520a8 Mon Sep 17 00:00:00 2001 From: Sanaz Date: Sun, 30 Jan 2022 10:04:07 -0800 Subject: [PATCH 78/78] adds todo --- src/main/java/scenario/integrita/Server.java | 1 + 1 file changed, 1 insertion(+) diff --git a/src/main/java/scenario/integrita/Server.java b/src/main/java/scenario/integrita/Server.java index 4ed03cd0..542046e1 100644 --- a/src/main/java/scenario/integrita/Server.java +++ b/src/main/java/scenario/integrita/Server.java @@ -68,6 +68,7 @@ public Server(int index, int totalServers) { // getters and setters --------------------- public NodeAddress getStatus() { + // TODO add signature return status; }