Remove adapter, move test to the proof package

Author: pav-kv

hasher.go

@@ -0,0 +1,27 @@
+// Copyright 2017 Google LLC. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package merkle
+
+// LogHasher provides the hash functions needed to compute dense merkle trees.
+type LogHasher interface {
+	// EmptyRoot supports returning a special case for the root of an empty tree.
+	EmptyRoot() []byte
+	// HashLeaf computes the hash of a leaf that exists.
+	HashLeaf(leaf []byte) []byte
+	// HashChildren computes interior nodes.
+	HashChildren(l, r []byte) []byte
+	// Size returns the number of bytes the Hash* functions will return.
+	Size() int
+}

log_verifier.go

@@ -12,10 +12,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package merkle
+package proof
 
 import (
-	"bytes"
 	"encoding/hex"
 	"fmt"
 	"strings"
@@ -212,23 +211,16 @@ func corruptConsistencyProof(size1, size2 uint64, root1, root2 []byte, proof [][
 	return ret
 }
 
-func verifierCheck(v *LogVerifier, leafIndex, treeSize uint64, proof [][]byte, root, leafHash []byte) error {
-	// Verify original inclusion proof.
-	got, err := v.RootFromInclusionProof(leafIndex, treeSize, leafHash, proof)
-	if err != nil {
-		return err
-	}
-	if !bytes.Equal(got, root) {
-		return fmt.Errorf("got root:\n%x\nexpected:\n%x", got, root)
-	}
-	if err := v.VerifyInclusion(leafIndex, treeSize, leafHash, proof, root); err != nil {
+func verifierCheck(nh NodeHasher, leafIndex, treeSize uint64, proof [][]byte, root, leafHash []byte) error {
+	// FIXME: GetRootFromInclusionProof
+	if err := VerifyInclusion(nh, leafIndex, treeSize, leafHash, proof, root); err != nil {
 		return err
 	}
 
 	probes := corruptInclusionProof(leafIndex, treeSize, proof, root, leafHash)
 	var wrong []string
 	for _, p := range probes {
-		if err := v.VerifyInclusion(p.leafIndex, p.treeSize, p.leafHash, p.proof, p.root); err == nil {
+		if err := VerifyInclusion(nh, p.leafIndex, p.treeSize, p.leafHash, p.proof, p.root); err == nil {
 			wrong = append(wrong, p.desc)
 		}
 	}
@@ -238,9 +230,9 @@ func verifierCheck(v *LogVerifier, leafIndex, treeSize uint64, proof [][]byte, r
 	return nil
 }
 
-func verifierConsistencyCheck(v *LogVerifier, size1, size2 uint64, root1, root2 []byte, proof [][]byte) error {
+func verifierConsistencyCheck(nh NodeHasher, size1, size2 uint64, root1, root2 []byte, proof [][]byte) error {
 	// Verify original consistency proof.
-	if err := v.VerifyConsistency(size1, size2, root1, root2, proof); err != nil {
+	if err := VerifyConsistency(nh, size1, size2, proof, root1, root2); err != nil {
 		return err
 	}
 	// For simplicity test only non-trivial proofs that have root1 != root2,
@@ -252,7 +244,7 @@ func verifierConsistencyCheck(v *LogVerifier, size1, size2 uint64, root1, root2
 	probes := corruptConsistencyProof(size1, size2, root1, root2, proof)
 	var wrong []string
 	for _, p := range probes {
-		if err := v.VerifyConsistency(p.size1, p.size2, p.root1, p.root2, p.proof); err == nil {
+		if err := VerifyConsistency(nh, p.size1, p.size2, p.proof, p.root1, p.root2); err == nil {
 			wrong = append(wrong, p.desc)
 		}
 	}
@@ -263,10 +255,10 @@ func verifierConsistencyCheck(v *LogVerifier, size1, size2 uint64, root1, root2
 }
 
 func TestVerifyInclusionSingleEntry(t *testing.T) {
-	v := NewLogVerifier(rfc6962.DefaultHasher)
+	hasher := rfc6962.DefaultHasher
 	data := []byte("data")
 	// Root and leaf hash for 1-entry tree are the same.
-	hash := v.hasher.HashLeaf(data)
+	hash := hasher.HashLeaf(data)
 	// The corresponding inclusion proof is empty.
 	proof := [][]byte{}
 	emptyHash := []byte{}
@@ -282,7 +274,7 @@ func TestVerifyInclusionSingleEntry(t *testing.T) {
 		// {emptyHash, emptyHash, true}, // Wrong hash size. FIXME
 	} {
 		t.Run(fmt.Sprintf("test:%d", i), func(t *testing.T) {
-			err := v.VerifyInclusion(0, 1, tc.leaf, proof, tc.root)
+			err := VerifyInclusion(hasher, 0, 1, tc.leaf, proof, tc.root)
 			if got, want := err != nil, tc.wantErr; got != want {
 				t.Errorf("error: %v, want %v", got, want)
 			}
@@ -291,21 +283,21 @@ func TestVerifyInclusionSingleEntry(t *testing.T) {
 }
 
 func TestVerifyInclusion(t *testing.T) {
-	v := NewLogVerifier(rfc6962.DefaultHasher)
+	hasher := rfc6962.DefaultHasher
 	proof := [][]byte{}
 
 	probes := []struct {
 		index, size uint64
 	}{{0, 0}, {0, 1}, {1, 0}, {2, 1}}
 	for _, p := range probes {
 		t.Run(fmt.Sprintf("probe:%d:%d", p.index, p.size), func(t *testing.T) {
-			if err := v.VerifyInclusion(p.index, p.size, sha256SomeHash, proof, []byte{}); err == nil {
+			if err := VerifyInclusion(hasher, p.index, p.size, sha256SomeHash, proof, []byte{}); err == nil {
 				t.Error("Incorrectly verified invalid root/leaf")
 			}
-			if err := v.VerifyInclusion(p.index, p.size, []byte{}, proof, sha256EmptyTreeHash); err == nil {
+			if err := VerifyInclusion(hasher, p.index, p.size, []byte{}, proof, sha256EmptyTreeHash); err == nil {
 				t.Error("Incorrectly verified invalid root/leaf")
 			}
-			if err := v.VerifyInclusion(p.index, p.size, sha256SomeHash, proof, sha256EmptyTreeHash); err == nil {
+			if err := VerifyInclusion(hasher, p.index, p.size, sha256SomeHash, proof, sha256EmptyTreeHash); err == nil {
 				t.Error("Incorrectly verified invalid root/leaf")
 			}
 		})
@@ -316,15 +308,15 @@ func TestVerifyInclusion(t *testing.T) {
 		p := inclusionProofs[i]
 		t.Run(fmt.Sprintf("proof:%d", i), func(t *testing.T) {
 			leafHash := rfc6962.DefaultHasher.HashLeaf(leaves[p.leaf-1])
-			if err := verifierCheck(&v, p.leaf-1, p.size, p.proof, roots[p.size-1], leafHash); err != nil {
+			if err := verifierCheck(hasher, p.leaf-1, p.size, p.proof, roots[p.size-1], leafHash); err != nil {
 				t.Errorf("verifierCheck(): %s", err)
 			}
 		})
 	}
 }
 
 func TestVerifyConsistency(t *testing.T) {
-	v := NewLogVerifier(rfc6962.DefaultHasher)
+	hasher := rfc6962.DefaultHasher
 
 	root1 := []byte("don't care 1")
 	root2 := []byte("don't care 2")
@@ -358,7 +350,7 @@ func TestVerifyConsistency(t *testing.T) {
 	}
 	for i, p := range tests {
 		t.Run(fmt.Sprintf("test:%d:size:%d-%d", i, p.size1, p.size2), func(t *testing.T) {
-			err := verifierConsistencyCheck(&v, p.size1, p.size2, p.root1, p.root2, p.proof)
+			err := verifierConsistencyCheck(hasher, p.size1, p.size2, p.root1, p.root2, p.proof)
 			if p.wantErr && err == nil {
 				t.Errorf("Incorrectly verified")
 			} else if !p.wantErr && err != nil {
@@ -370,7 +362,7 @@ func TestVerifyConsistency(t *testing.T) {
 	for i := 0; i < 4; i++ {
 		p := consistencyProofs[i]
 		t.Run(fmt.Sprintf("proof:%d", i), func(t *testing.T) {
-			err := verifierConsistencyCheck(&v, p.size1, p.size2,
+			err := verifierConsistencyCheck(hasher, p.size1, p.size2,
 				roots[p.size1-1], roots[p.size2-1], p.proof)
 			if err != nil {
 				t.Fatalf("Failed to verify known good proof: %s", err)