feat: verifies namespace hash format to prevent panic in validateSibl…

…ingsNamespaceOrder (#185)

## Overview
Closes #138 

## Checklist
- [x] New and updated code has appropriate documentation
- [x] New and updated code has new and/or updated testing
- [x] Required CI checks are passing
- [x] Visual proof for any user facing features like CLI or
documentation updates
- [x] Linked issues closed with keywords

hasher.go

@@ -207,14 +207,16 @@ func (n *Hasher) ValidateNodeFormat(node []byte) (err error) {
 // validateSiblingsNamespaceOrder checks whether left and right as two sibling
 // nodes in an NMT have correct namespace IDs relative to each other, more
 // specifically, the maximum namespace ID of the left sibling should not exceed
-// the minimum namespace ID of the right sibling. It returns ErrUnorderedSiblings error if the check fails. Note that the function assumes
-// that the left and right nodes are in correct format, i.e., they are
-// namespaced hash values. Otherwise, it panics.
+// the minimum namespace ID of the right sibling. It returns ErrUnorderedSiblings error if the check fails.
 func (n *Hasher) validateSiblingsNamespaceOrder(left, right []byte) (err error) {
-	// each NMT node has two namespace IDs for the min and max
-	totalNamespaceLen := 2 * n.NamespaceLen
-	leftMaxNs := namespace.ID(left[n.NamespaceLen:totalNamespaceLen])
-	rightMinNs := namespace.ID(right[:n.NamespaceLen])
+	if err := n.ValidateNodeFormat(left); err != nil {
+		return fmt.Errorf("%w: left node does not match the namesapce hash format", err)
+	}
+	if err := n.ValidateNodeFormat(right); err != nil {
+		return fmt.Errorf("%w: right node does not match the namesapce hash format", err)
+	}
+	leftMaxNs := namespace.ID(MaxNamespace(left, n.NamespaceSize()))
+	rightMinNs := namespace.ID(MinNamespace(right, n.NamespaceSize()))
 
 	// check the namespace range of the left and right children
 	if rightMinNs.Less(leftMaxNs) {

hasher_test.go

@@ -277,6 +277,9 @@ func TestHashNode_ChildrenNamespaceRange(t *testing.T) {
 }
 
 func TestValidateSiblingsNamespaceOrder(t *testing.T) {
+	// create a dummy hash to use as the digest of the left and right child
+	randHash := createByteSlice(sha256.Size, 0x01)
+
 	type children struct {
 		l []byte // namespace hash of the left child with the format of MinNs||MaxNs||h
 		r []byte // namespace hash of the right child with the format of MinNs||MaxNs||h
@@ -288,19 +291,29 @@ func TestValidateSiblingsNamespaceOrder(t *testing.T) {
 		children children
 		wantErr  bool
 	}{
+		{
+			"wrong left node format", 2,
+			children{concat([]byte{0, 0, 1, 1}, randHash[:len(randHash)-1]), concat([]byte{0, 0, 1, 1}, randHash)},
+			true,
+		},
+		{
+			"wrong right node format", 2,
+			children{concat([]byte{0, 0, 1, 1}, randHash), concat([]byte{0, 0, 1, 1}, randHash[:len(randHash)-1])},
+			true,
+		},
 		{
 			"left.maxNs>right.minNs", 2,
-			children{[]byte{0, 0, 1, 1}, []byte{0, 0, 1, 1}},
+			children{concat([]byte{0, 0, 1, 1}, randHash), concat([]byte{0, 0, 1, 1}, randHash)},
 			true,
 		},
 		{
 			"left.maxNs=right.minNs", 2,
-			children{[]byte{0, 0, 1, 1}, []byte{1, 1, 2, 2}},
+			children{concat([]byte{0, 0, 1, 1}, randHash), concat([]byte{1, 1, 2, 2}, randHash)},
 			false,
 		},
 		{
 			"left.maxNs<right.minNs", 2,
-			children{[]byte{0, 0, 1, 1}, []byte{2, 2, 3, 3}},
+			children{concat([]byte{0, 0, 1, 1}, randHash), concat([]byte{2, 2, 3, 3}, randHash)},
 			false,
 		},
 	}