Merkle Tree implementation

Author: scDisorder

.gitignore

@@ -0,0 +1,54 @@
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, built with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# compiled npm output
+dist/
+tmp/
+out-tsc/
+# Only exists if Bazel was run
+bazel-out/
+
+# profiling files
+chrome-profiler-events*.json
+speed-measure-plugin*.json
+
+# IDEs and editors
+.idea/
+.project
+.classpath
+.c9/
+*.launch
+.settings/
+*.sublime-workspace
+
+# IDE - VSCode
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+.history/*
+
+# misc
+/.sass-cache
+/connect.lock
+/coverage
+/libpeerconnection.log
+npm-debug.log
+yarn-error.log
+testem.log
+/typings
+
+# System Files
+.DS_Store
+Thumbs.db

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Dmitrii Limonov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,4 @@
+# Merkle Tree
+
+An implementation of a Merkle Tree written in Go.
+

go.mod

@@ -0,0 +1,3 @@
+module github.com/scDisorder/merkle
+
+go 1.17

merkle_tree.go

@@ -0,0 +1,189 @@
+package merkletree
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"fmt"
+	"hash"
+)
+
+type MerkleTree struct {
+	Root         *Node
+	merkleRoot   []byte
+	Leafs        []*Node
+	hashStrategy func() hash.Hash
+}
+
+// MerkleRoot returns hash of the root node
+func (m *MerkleTree) MerkleRoot() []byte {
+	return m.merkleRoot
+}
+
+// MerklePath returns merkle path and indexes (left or right leaf)
+func (m *MerkleTree) MerklePath(content Content) ([][]byte, []int64, error) {
+	for _, l := range m.Leafs {
+		ok, err := l.C.Equals(content)
+		if err != nil {
+			return nil, nil, err
+		}
+
+		if ok {
+			leafParent := l.Parent
+
+			var merklePath [][]byte
+			var indices []int64
+
+			for leafParent != nil {
+				if bytes.Equal(leafParent.Left.Hash, leafParent.Hash) {
+					merklePath = append(merklePath, leafParent.Right.Hash)
+					indices = append(indices, 1)
+				} else {
+					merklePath = append(merklePath, leafParent.Left.Hash)
+					indices = append(indices, 0)
+				}
+
+				l = leafParent
+				leafParent = leafParent.Parent
+			}
+
+			return merklePath, indices, nil
+		}
+	}
+
+	return nil, nil, nil
+}
+
+// Rebuilt is a helper func which rebuilds the tree with existing contents
+func (m *MerkleTree) Rebuilt() error {
+	var contents []Content
+	for _, c := range m.Leafs {
+		contents = append(contents, c.C)
+	}
+
+	root, leafs, err := buildWithContent(contents, m)
+	if err != nil {
+		return err
+	}
+
+	m.Root = root
+	m.Leafs = leafs
+	m.merkleRoot = root.Hash
+
+	return nil
+}
+
+// RebuiltWith is a helper func which rebuilds the tree by replacing content passed as argument
+func (m *MerkleTree) RebuiltWith(contents []Content) error {
+	root, leafs, err := buildWithContent(contents, m)
+	if err != nil {
+		return err
+	}
+
+	m.Root = root
+	m.Leafs = leafs
+	m.merkleRoot = root.Hash
+
+	return nil
+}
+
+// VerifyTree validates hash on each level
+func (m *MerkleTree) VerifyTree() (bool, error) {
+	merkleRoot, err := m.Root.verify()
+	if err != nil {
+		return false, err
+	}
+
+	if bytes.Compare(merkleRoot, m.MerkleRoot()) == 0 {
+		return true, nil
+	}
+
+	return false, nil
+}
+
+// VerifyContent indicates if given content is a part of the tree
+func (m *MerkleTree) VerifyContent(c Content) (bool, error) {
+	for _, l := range m.Leafs {
+		ok, err := l.C.Equals(c)
+		if err != nil {
+			return false, err
+		}
+
+		if ok {
+			leafParent := l.Parent
+
+			for leafParent != nil {
+				h := m.hashStrategy()
+
+				right, err := leafParent.Right.verify()
+				if err != nil {
+					return false, err
+				}
+
+				left, err := leafParent.Left.verify()
+				if err != nil {
+					return false, err
+				}
+
+				if _, err := h.Write(append(left, right...)); err != nil {
+					return false, err
+				}
+
+				if bytes.Compare(h.Sum(nil), leafParent.Hash) != 0 {
+					return false, nil
+				}
+
+				leafParent = leafParent.Parent
+			}
+
+			return true, nil
+		}
+	}
+
+	return false, nil
+}
+
+// returns merkle tree string representation
+func (m *MerkleTree) String() string {
+	s := ""
+	for _, l := range m.Leafs {
+		s += fmt.Sprint(l)
+		s += "\n"
+	}
+	return s
+}
+
+func NewTree(contents []Content) (*MerkleTree, error) {
+	defaultHashStrategy := sha256.New
+
+	tree := &MerkleTree{
+		hashStrategy: defaultHashStrategy,
+	}
+
+	root, leafs, err := buildWithContent(contents, tree)
+	if err != nil {
+		return nil, err
+	}
+
+	tree.Root = root
+	tree.Leafs = leafs
+	tree.merkleRoot = root.Hash
+
+	return tree, nil
+}
+
+func NewTreeWithHashStrategy(contents []Content, hashStrategy func() hash.Hash) (*MerkleTree, error) {
+	tree := &MerkleTree{
+		hashStrategy: hashStrategy,
+	}
+
+	root, leafs, err := buildWithContent(contents, tree)
+	if err != nil {
+		return nil, err
+	}
+
+	tree.Root = root
+	tree.Leafs = leafs
+	tree.merkleRoot = root.Hash
+
+	return tree, nil
+}

merkle_tree_test.go

@@ -0,0 +1,63 @@
+package merkletree
+
+import (
+	"crypto/sha256"
+	"log"
+	"testing"
+)
+
+type TestContent struct {
+	x string
+}
+
+// CalculateHash hashes the values of a TestContent
+func (t TestContent) CalculateHash() ([]byte, error) {
+	h := sha256.New()
+	if _, err := h.Write([]byte(t.x)); err != nil {
+		return nil, err
+	}
+
+	return h.Sum(nil), nil
+}
+
+// Equals tests for equality of two Contents
+func (t TestContent) Equals(other Content) (bool, error) {
+	return t.x == other.(TestContent).x, nil
+}
+
+func Test(t *testing.T) {
+	//Build list of Content to build tree
+	var list []Content
+	list = append(list, TestContent{x: "So"})
+	list = append(list, TestContent{x: "Much"})
+	list = append(list, TestContent{x: "Content"})
+	list = append(list, TestContent{x: "Wow"})
+
+	//Create a new Merkle Tree from the list of Content
+	tree, err := NewTree(list)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	//Get the Merkle Root of the tree
+	mr := tree.MerkleRoot()
+	log.Println(mr)
+
+	// Verify the entire tree (hashes for each node) is valid
+	vt, err := tree.VerifyTree()
+	if err != nil {
+		log.Fatal(err)
+	}
+	log.Println("Verify Tree: ", vt)
+
+	// Verify a specific content in the tree
+	vc, err := tree.VerifyContent(list[0])
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	log.Println("Verify Content: ", vc)
+
+	//String representation
+	log.Println(t)
+}