[WIP] DB backend hooks

README.md

@@ -22,6 +22,7 @@ The packages in this library implement the various components of the CONIKS syst
 - ``client``: Client-side protocol cgo hooks
 - ``crypto``: Cryptographic algorithms and operations
 - ``merkletree``: Merkle prefix tree and related data structures
+- ``storage``: DB hooks for storage backend (currently the library supports key-value db only)
 - ``utils``: Utility functions 
 - ``storage``: DB hooks for storage backend (currently the library supports key-value db only)
 

client/cgo/cgotest.go

@@ -103,7 +103,7 @@ func testVerifyHashChain(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	pad, err := merkletree.NewPAD(merkletree.NewPolicies(2, vrfPrivKey), signKey, 10)
+	pad, err := merkletree.NewPAD(merkletree.NewPolicies(2, vrfPrivKey), nil, signKey, 10)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -133,7 +133,7 @@ func testVerifyAuthPath(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	pad, err := merkletree.NewPAD(merkletree.NewPolicies(2, vrfPrivKey), signKey, 10)
+	pad, err := merkletree.NewPAD(merkletree.NewPolicies(2, vrfPrivKey), nil, signKey, 10)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -209,7 +209,7 @@ func testVerifyProofOfAbsenceSamePrefix(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	pad, err := merkletree.NewPAD(merkletree.NewPolicies(2, vrfPrivKey), signKey, 10)
+	pad, err := merkletree.NewPAD(merkletree.NewPolicies(2, vrfPrivKey), nil, signKey, 10)
 	if err != nil {
 		t.Fatal(err)
 	}

merkletree/merkletree.go

@@ -9,12 +9,18 @@ import (
 )
 
 var (
-	ErrorInvalidTree = errors.New("[merkletree] invalid tree")
+	ErrorInvalidTree = errors.New("[merkletree] Invalid tree")
 )
 
 const (
-	EmptyBranchIdentifier = 'E'
-	LeafIdentifier        = 'L'
+	EmptyBranchIdentifier  = 'E'
+	LeafIdentifier         = 'L'
+	InteriorNodeIdentifier = 'I'
+	NodeKeyIdentifier      = 'N'
+	STRIdentifier          = 'S'
+	PoliciesIdentifier     = 'P'
+	EpochIdentifier        = 'O'
+	TreeNonceIdentifier    = 'T'
 )
 
 type MerkleTree struct {

merkletree/merkletreekv.go

@@ -0,0 +1,104 @@
+package merkletree
+
+import (
+	"errors"
+
+	"github.com/coniks-sys/coniks-go/crypto"
+	"github.com/coniks-sys/coniks-go/storage/kv"
+	"github.com/coniks-sys/coniks-go/utils"
+)
+
+var (
+	ErrorBadTreeNonce = errors.New("[merkletree] Bad tree nonce")
+)
+
+func NewMerkleTreeFromKV(db kv.DB, epoch uint64) (*MerkleTree, error) {
+	nonceKey := append([]byte{TreeNonceIdentifier}, util.ULongToBytes(epoch)...)
+	val, err := db.Get(nonceKey)
+	var nonce []byte
+	if err != nil {
+		return nil, err
+	} else if len(val) != crypto.HashSizeByte {
+		return nil, ErrorBadTreeNonce
+	} else {
+		nonce = val
+	}
+	m := new(MerkleTree)
+	m.nonce = nonce
+	root, err := m.reconstructTree(db, nil, epoch, []bool{})
+	if err != nil {
+		return nil, err
+	}
+	m.root = root.(*interiorNode)
+	m.hash = m.root.Hash(m)
+	return m, nil
+}
+
+func (m *MerkleTree) reconstructTree(db kv.DB, parent MerkleNode, epoch uint64, prefixBits []bool) (MerkleNode, error) {
+	n, err := loadNode(db, epoch, prefixBits)
+	if err != nil {
+		return nil, err
+	}
+
+	if _, ok := n.(*emptyNode); ok {
+		n.(*emptyNode).parent = parent
+		return n, nil
+	}
+	if _, ok := n.(*userLeafNode); ok {
+		n.(*userLeafNode).parent = parent
+		return n, nil
+	}
+	n.(*interiorNode).parent = parent
+	n.(*interiorNode).leftChild, err = m.reconstructTree(db, n, epoch, append(prefixBits, false))
+	if err != nil {
+		return nil, err
+	}
+	n.(*interiorNode).rightChild, err = m.reconstructTree(db, n, epoch, append(prefixBits, true))
+	if err != nil {
+		return nil, err
+	}
+	return n, nil
+}
+
+func ReconstructBranch(db kv.DB, epoch uint64, index []byte) (*MerkleTree, error) {
+	indexBits := util.ToBits(index)
+	m := new(MerkleTree)
+	root, err := loadNode(db, epoch, []bool{})
+	if err != nil {
+		return nil, err
+	}
+	m.root = root.(*interiorNode)
+	var parent = root
+loadingLoop:
+	for depth := 1; depth < len(indexBits); depth++ {
+		n, err := loadNode(db, epoch, indexBits[:depth])
+		if err != nil {
+			return nil, err
+		}
+		if indexBits[depth-1] {
+			parent.(*interiorNode).rightChild = n
+		} else {
+			parent.(*interiorNode).leftChild = n
+		}
+		switch n.(type) {
+		case *userLeafNode:
+			n.(*userLeafNode).parent = parent
+			break loadingLoop
+		case *emptyNode:
+			n.(*emptyNode).parent = parent
+			break loadingLoop
+		case *interiorNode:
+			n.(*interiorNode).parent = parent
+		}
+		parent = n
+	}
+
+	return m, nil
+}
+
+func (m *MerkleTree) StoreToKV(epoch uint64, wb kv.Batch) {
+	// store tree nodes
+	m.root.storeToKV(epoch, []bool{}, wb)
+	// store tree nonce
+	wb.Put(append([]byte{TreeNonceIdentifier}, util.ULongToBytes(epoch)...), m.nonce)
+}

merkletree/merkletreekv_test.go

@@ -0,0 +1,128 @@
+package merkletree
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/coniks-sys/coniks-go/storage/kv"
+	"github.com/coniks-sys/coniks-go/utils"
+)
+
+func TestTreeStore(t *testing.T) {
+	util.WithDB(func(db kv.DB) {
+		key1 := "key1"
+		val1 := []byte("value1")
+		key2 := "key2"
+		val2 := []byte("value2")
+
+		m1, err := NewMerkleTree()
+		if err != nil {
+			t.Fatal(err)
+		}
+		index1 := vrfPrivKey1.Compute([]byte(key1))
+		if err := m1.Set(index1, key1, val1); err != nil {
+			t.Fatal(err)
+		}
+		index2 := vrfPrivKey1.Compute([]byte(key2))
+		if err := m1.Set(index2, key2, val2); err != nil {
+			t.Fatal(err)
+		}
+		m1.recomputeHash()
+
+		wb := db.NewBatch()
+		m1.StoreToKV(1, wb)
+		err = db.Write(wb)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		m2, err := NewMerkleTreeFromKV(db, 1)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !bytes.Equal(m2.nonce, m1.nonce) ||
+			!bytes.Equal(m2.root.Hash(m1), m1.hash) {
+			t.Fatal("Bad tree construction")
+		}
+
+		ap := m2.Get(index1)
+		if ap.Leaf.Value() == nil {
+			t.Error("Cannot find key:", key1)
+			return
+		}
+		if !bytes.Equal(ap.Leaf.Value(), val1) {
+			t.Error(key1, "value mismatch")
+		}
+
+		ap = m2.Get(index2)
+		if ap.Leaf.Value() == nil {
+			t.Error("Cannot find key:", key2)
+			return
+		}
+		if !bytes.Equal(ap.Leaf.Value(), val2) {
+			t.Error(key2, "value mismatch")
+		}
+	})
+}
+
+func TestReconstructBranch(t *testing.T) {
+	util.WithDB(func(db kv.DB) {
+		key1 := "key1"
+		val1 := []byte("value1")
+		key2 := "key3"
+		val2 := []byte("value2")
+
+		m1, err := NewMerkleTree()
+		if err != nil {
+			t.Fatal(err)
+		}
+		index1 := vrfPrivKey1.Compute([]byte(key1))
+		if err := m1.Set(index1, key1, val1); err != nil {
+			t.Fatal(err)
+		}
+		index2 := vrfPrivKey1.Compute([]byte(key2))
+		if err := m1.Set(index2, key2, val2); err != nil {
+			t.Fatal(err)
+		}
+		m1.recomputeHash()
+
+		wb := db.NewBatch()
+		m1.StoreToKV(1, wb)
+		err = db.Write(wb)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		m2_1, err := ReconstructBranch(db, 1, index1)
+		if err != nil {
+			t.Fatal(err)
+		}
+		ap := m2_1.Get(index1)
+		if ap.Leaf.Value() == nil {
+			t.Error("Cannot find key:", key1)
+			return
+		}
+		if !bytes.Equal(ap.Leaf.Value(), val1) {
+			t.Error(key1, "value mismatch",
+				"want", val1,
+				"get", ap.Leaf.Value())
+		}
+
+		m2_2, err := ReconstructBranch(db, 1, index2)
+		if err != nil {
+			t.Fatal(err)
+		}
+		ap = m2_2.Get(index2)
+		if ap.Leaf.Value() == nil {
+			t.Error("Cannot find key:", key2)
+			return
+		}
+		if !bytes.Equal(ap.Leaf.Value(), val2) {
+			t.Error(key2, "value mismatch")
+		}
+	})
+}

merkletree/node.go

@@ -2,6 +2,7 @@ package merkletree
 
 import (
 	"github.com/coniks-sys/coniks-go/crypto"
+	"github.com/coniks-sys/coniks-go/storage/kv"
 	"github.com/coniks-sys/coniks-go/utils"
 )
 
@@ -70,6 +71,7 @@ type MerkleNode interface {
 	isEmpty() bool
 	Hash(*MerkleTree) []byte
 	Clone(*interiorNode) MerkleNode
+	storeToKV(epoch uint64, prefixBits []bool, wb kv.Batch)
 }
 
 var _ MerkleNode = (*userLeafNode)(nil)
@@ -147,11 +149,11 @@ func (n *emptyNode) Clone(parent *interiorNode) MerkleNode {
 	}
 }
 
-func (n *userLeafNode) isEmpty() bool {
+func (n *interiorNode) isEmpty() bool {
 	return false
 }
 
-func (n *interiorNode) isEmpty() bool {
+func (n *userLeafNode) isEmpty() bool {
 	return false
 }