Ozan/merkletree

src/main/java/crypto/Sha3256Hasher.java

@@ -5,14 +5,21 @@
 
 import model.codec.EncodedEntity;
 import model.crypto.Sha3256Hash;
+import model.lightchain.Identifier;
 
 /**
  * Implements SHA3-256 hashing functionality.
  */
 public class Sha3256Hasher implements Hasher {
-
   private static final String HASH_ALG_SHA_3_256 = "SHA3-256";
 
+  private static byte[] concat(final byte[] e1, final byte[] e2) {
+    byte[] result = new byte[e1.length + e2.length];
+    System.arraycopy(e1, 0, result, 0, e1.length);
+    System.arraycopy(e2, 0, result, e1.length, e2.length);
+    return result;
+  }
+
   /**
    * Computes hash of the given encoded entity.
    *
@@ -21,12 +28,52 @@ public class Sha3256Hasher implements Hasher {
    */
   @Override
   public Sha3256Hash computeHash(EncodedEntity e) {
+    return this.computeHash(e.getBytes());
+  }
+
+  /**
+   * Computes hash of the given identifier.
+   *
+   * @param id input identifier
+   * @return SHA3-256 hash object of the entity
+   */
+  public Sha3256Hash computeHash(Identifier id) {
+    return this.computeHash(id.getBytes());
+  }
+
+  /**
+   * Computes hash of the given bytes.
+   *
+   * @param bytes input bytes.
+   * @return SHA3-256 hash object of the given bytes.
+   */
+  public Sha3256Hash computeHash(byte[] bytes) {
     try {
       MessageDigest md = MessageDigest.getInstance(HASH_ALG_SHA_3_256);
-      byte[] hashValue = md.digest(e.getBytes());
+      byte[] hashValue = md.digest(bytes);
       return new Sha3256Hash(hashValue);
     } catch (NoSuchAlgorithmException ex) {
       throw new IllegalStateException(HASH_ALG_SHA_3_256 + "algorithm not found.", ex);
     }
   }
+
+  /**
+   * Commutative hashing of two given byte arrays.
+   *
+   * @param b1 first byte array.
+   * @param b2 second byte array.
+   * @return SHA3-256 hash object of the commutative concatenation of the two byte arrays.
+   */
+  public Sha3256Hash computeHash(byte[] b1, byte[] b2) {
+    try {
+      MessageDigest md = MessageDigest.getInstance(HASH_ALG_SHA_3_256);
+      return new Sha3256Hash(md.digest(concat(b1, b2)));
+    } catch (NoSuchAlgorithmException ex) {
+      throw new IllegalStateException(HASH_ALG_SHA_3_256 + "algorithm not found.", ex);
+    }
+  }
+
+  public Sha3256Hash computeHash(Sha3256Hash h1, Sha3256Hash h2) {
+    return computeHash(h1.getBytes(), h2.getBytes());
+  }
 }

src/main/java/modules/ads/AuthenticatedDataStructure.java

@@ -10,4 +10,6 @@ public interface AuthenticatedDataStructure {
   AuthenticatedEntity put(Entity e);
 
   AuthenticatedEntity get(Identifier id);
+
+  int size();
 }

src/main/java/modules/ads/AuthenticatedEntity.java

@@ -7,7 +7,7 @@
  * that entity against a root identifier.
  */
 public abstract class AuthenticatedEntity extends Entity {
-  abstract Entity getEntity();
+  public abstract Entity getEntity();
 
-  abstract MembershipProof getMembershipProof();
+  public abstract MembershipProof getMembershipProof();
 }

src/main/java/modules/ads/MembershipProof.java

@@ -1,6 +1,8 @@
 package modules.ads;
 
-import model.lightchain.Identifier;
+import java.util.ArrayList;
+
+import model.crypto.Sha3256Hash;
 
 /**
  * Represents a Merkle Proof of membership against a certain root identifier.
@@ -9,15 +11,16 @@ public interface MembershipProof {
   /**
    * Root of the authenticated data structure that this proof belongs to.
    *
-   * @return root identifier.
+   * @return hash value of the root node.
    */
-  Identifier getRoot();
+  Sha3256Hash getRoot();
 
   /**
-   * Sibling of the given identifier on the membership Merkle Proof path to the root.
+   * Returns the path of the proof of membership.
    *
-   * @param identifier identifier of the entity.
-   * @return sibling of given identifier.
+   * @return path of the proof of membership.
    */
-  Identifier getSiblingOf(Identifier identifier);
+  ArrayList<Sha3256Hash> getPath();
+
+  ArrayList<Boolean> getIsLeftNode();
 }

src/main/java/modules/ads/merkletree/MerkleNode.java

@@ -0,0 +1,117 @@
+package modules.ads.merkletree;
+
+import crypto.Sha3256Hasher;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import model.Entity;
+import model.crypto.Sha3256Hash;
+
+/**
+ * A node in the Merkle tree.
+ */
+public class MerkleNode {
+  private static final Sha3256Hasher hasher = new Sha3256Hasher();
+  private MerkleNode left;
+  private MerkleNode right;
+  private MerkleNode parent;
+  private boolean isLeft;
+  private Sha3256Hash hash;
+
+  /**
+   * Default constructor.
+   */
+  public MerkleNode() {
+    this.left = null;
+    this.right = null;
+    this.parent = null;
+    this.isLeft = false;
+    this.hash = null;
+  }
+
+  /**
+   * Constructor with entity and isLeft.
+   *
+   * @param e      input entity
+   * @param isLeft boolean that specifies if the node is left child or not
+   */
+  public MerkleNode(Entity e, boolean isLeft) {
+    this.left = null;
+    this.right = null;
+    this.parent = null;
+    this.isLeft = isLeft;
+    this.hash = hasher.computeHash(e.id());
+  }
+
+  /**
+   * Constructor with hash of the entity.
+   *
+   * @param hash input hash of the entity corresponding to that node
+   */
+  public MerkleNode(Sha3256Hash hash) {
+    this.left = null;
+    this.right = null;
+    this.parent = null;
+    this.isLeft = false;
+    this.hash = hash;
+  }
+
+  /**
+   * Constructor of a parent node.
+   *
+   * @param hash  input hash of the entity corresponding to that node
+   * @param left  left child of the node
+   * @param right right child of the node
+   */
+  @SuppressFBWarnings(value = "EI_EXPOSE_REP2", justification = "left and right are intentionally mutable externally")
+  public MerkleNode(Sha3256Hash hash, MerkleNode left, MerkleNode right) {
+    this.left = left;
+    this.right = right;
+    this.parent = null;
+    this.isLeft = false;
+    this.hash = hash;
+  }
+
+  @SuppressFBWarnings(value = "EI_EXPOSE_REP", justification = "internal representation is intentionally returned")
+  public MerkleNode getLeft() {
+    return left;
+  }
+
+  @SuppressFBWarnings(value = "EI_EXPOSE_REP", justification = "internal representation is intentionally returned")
+  public MerkleNode getRight() {
+    return right;
+  }
+
+  @SuppressFBWarnings(value = "EI_EXPOSE_REP", justification = "internal representation is intentionally returned")
+  public MerkleNode getParent() {
+    return parent;
+  }
+
+  @SuppressFBWarnings(value = "EI_EXPOSE_REP2", justification = "parent is intentionally mutable externally")
+  public void setParent(MerkleNode parent) {
+    this.parent = parent;
+  }
+
+  public Sha3256Hash getHash() {
+    return hash;
+  }
+
+  public boolean isLeft() {
+    return isLeft;
+  }
+
+  public void setLeft(boolean isLeft) {
+    this.isLeft = isLeft;
+  }
+
+  /**
+   * Returns the sibling of the node.
+   *
+   * @return the sibling of the node
+   */
+  public MerkleNode getSibling() {
+    if (isLeft()) {
+      return parent.getRight();
+    } else {
+      return parent.getLeft();
+    }
+  }
+}

src/main/java/modules/ads/merkletree/MerkleProof.java

@@ -0,0 +1,71 @@
+package modules.ads.merkletree;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Objects;
+
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import model.crypto.Sha3256Hash;
+import modules.ads.MembershipProof;
+
+/**
+ * A proof of membership in a Merkle tree.
+ */
+public class MerkleProof implements MembershipProof {
+  private ArrayList<Sha3256Hash> path;
+  private final ArrayList<Boolean> isLeftNode;
+  private final Sha3256Hash root;
+
+  /**
+   * Constructs a proof from a list of hashes and a root.
+   *
+   * @param path       the list of hashes
+   * @param root       the root
+   * @param isLeftNode the list of isLeft Boolean values of the hashes
+   */
+  public MerkleProof(ArrayList<Sha3256Hash> path, Sha3256Hash root, ArrayList<Boolean> isLeftNode) {
+    this.path = new ArrayList<>(path);
+    this.root = root;
+    this.isLeftNode = new ArrayList<>(isLeftNode);
+  }
+
+  @Override
+  public ArrayList<Sha3256Hash> getPath() {
+    return new ArrayList<>(path);
+  }
+
+  public void setPath(ArrayList<Sha3256Hash> path) {
+    this.path = new ArrayList<>(path);
+  }
+
+  @SuppressFBWarnings(value = "EI_EXPOSE_REP", justification = "internal representation is intentionally returned")
+  public ArrayList<Boolean> getIsLeftNode() {
+    return isLeftNode;
+  }
+
+  public Sha3256Hash getRoot() {
+    return root;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    MerkleProof proof = (MerkleProof) o;
+    for (int i = 0; i < path.size(); i++) {
+      if (!Arrays.equals(path.get(i).getBytes(), proof.path.get(i).getBytes())) {
+        return false;
+      }
+    }
+    return root.equals(proof.root);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(path, root);
+  }
+}