use client.LogVerifier instead merkler.LogVerifier

Author: liamsi

core/monitor/monitor.go

@@ -35,24 +35,19 @@ import (
 // Monitor holds the internal state for a monitor accessing the mutations API
 // and for verifying its responses.
 type Monitor struct {
-	mapID          int64
-	logHasher      hashers.LogHasher
-	mapHasher      hashers.MapHasher
-	logPubKey      crypto.PublicKey
-	mapPubKey      crypto.PublicKey
-	logVerifier    merkle.LogVerifier
-	logVerifierCli client.LogVerifier
-	signer         *tcrypto.Signer
-	trusted        *trillian.SignedLogRoot
-	store          *storage.Storage
+	mapID       int64
+	logHasher   hashers.LogHasher
+	mapHasher   hashers.MapHasher
+	logPubKey   crypto.PublicKey
+	mapPubKey   crypto.PublicKey
+	logVerifier client.LogVerifier
+	signer      *tcrypto.Signer
+	trusted     *trillian.SignedLogRoot
+	store       *storage.Storage
 }
 
 // New creates a new instance of the monitor.
-func New(logverifierCli client.LogVerifier, logTree, mapTree *trillian.Tree, signer *tcrypto.Signer, store *storage.Storage) (*Monitor, error) {
-	logHasher, err := hashers.NewLogHasher(logTree.GetHashStrategy())
-	if err != nil {
-		return nil, fmt.Errorf("Failed creating LogHasher: %v", err)
-	}
+func New(logverifierCli client.LogVerifier, mapTree *trillian.Tree, signer *tcrypto.Signer, store *storage.Storage) (*Monitor, error) {
 	mapHasher, err := hashers.NewMapHasher(mapTree.GetHashStrategy())
 	if err != nil {
 		return nil, fmt.Errorf("Failed creating MapHasher: %v", err)
@@ -62,15 +57,12 @@ func New(logverifierCli client.LogVerifier, logTree, mapTree *trillian.Tree, sig
 		return nil, fmt.Errorf("Could not unmarshal map public key: %v", err)
 	}
 	return &Monitor{
-		logVerifierCli: logverifierCli,
-		mapID:          mapTree.TreeId,
-		mapHasher:      mapHasher,
-		logHasher:      logHasher,
-		logVerifier:    merkle.NewLogVerifier(logHasher),
-		logPubKey:      logTree.GetPublicKey(),
-		mapPubKey:      mapPubKey,
-		signer:         signer,
-		store:          store,
+		logVerifier: logverifierCli,
+		mapID:       mapTree.TreeId,
+		mapHasher:   mapHasher,
+		mapPubKey:   mapPubKey,
+		signer:      signer,
+		store:       store,
 	}, nil
 }
 

core/monitor/verify.go

@@ -32,7 +32,6 @@ import (
 
 	"github.com/google/keytransparency/core/mutator/entry"
 	ktpb "github.com/google/keytransparency/core/proto/keytransparency_v1_types"
-	"fmt"
 )
 
 var (
@@ -73,33 +72,15 @@ func (m *Monitor) VerifyMutationsResponse(in *ktpb.GetMutationsResponse) []error
 
 
 	// TODO(ismail): pass in a (trillian) logverifier instead
-	// - create an equivalent map verifier (in trillian)
-	//   between different error types (like below)
 	// - create a set of fixed error messages so the caller can differentiate
-	if err := m.logVerifierCli.VerifyRoot(m.trusted, in.GetLogRoot(), in.GetLogInclusion()); err != nil {
+	//   between different error types (like below)
+	// - also, create an equivalent map verifier (in trillian)
+	if err := m.logVerifier.VerifyRoot(m.trusted, in.GetLogRoot(), in.GetLogConsistency()); err != nil {
+		// this could be one of ErrInvalidLogSignature, ErrInvalidLogConsistencyProof
 		errList = append(errList, err)
 	}
-	logRoot := in.GetLogRoot()
-	// Verify SignedLogRoot signature.
-	hash := tcrypto.HashLogRoot(*logRoot)
-	if err := tcrypto.Verify(m.logPubKey, hash, logRoot.GetSignature()); err != nil {
-		glog.Infof("couldn't verify signature on log root: %v: %v", logRoot, err)
-		errList = append(errList, ErrInvalidLogSignature)
-	}
-
-	if m.trusted != nil && m.trusted.GetTreeSize() > 0 {
-		// Verify consistency proof:
-		err := m.logVerifier.VerifyConsistencyProof(
-			m.trusted.TreeSize, logRoot.TreeSize,
-			m.trusted.RootHash, logRoot.RootHash,
-			in.GetLogConsistency())
-		if err != nil {
-			errList = append(errList, ErrInvalidLogConsistencyProof)
-		}
-	} else {
-		// trust the first log root we see, don't verify anything yet
-		m.trusted = in.GetLogRoot()
-	}
+	// updated trusted log root
+	m.trusted = in.GetLogRoot()
 
 	b, err := json.Marshal(in.GetSmr())
 	if err != nil {
@@ -108,15 +89,9 @@ func (m *Monitor) VerifyMutationsResponse(in *ktpb.GetMutationsResponse) []error
 	}
 	leafIndex := in.GetSmr().GetMapRevision()
 	treeSize := in.GetLogRoot().GetTreeSize()
-	leafHash := m.logHasher.HashLeaf(b)
-	err = m.logVerifier.VerifyInclusionProof(
-		leafIndex,
-		treeSize,
-		in.GetLogInclusion(),
-		in.GetLogRoot().GetRootHash(),
-		leafHash)
+	err = m.logVerifier.VerifyInclusionAtIndex(in.GetLogRoot(), b, leafIndex, in.GetLogInclusion())
 	if err != nil {
-		glog.Errorf("m.logVerifier.VerifyInclusionProof((%v, %v, _): %v", leafIndex, treeSize, err)
+		glog.Errorf("m.logVerifier.VerifyInclusionAtIndex((%v, %v, _): %v", leafIndex, treeSize, err)
 		errList = append(errList, ErrInvalidLogInclusion)
 	}
 
@@ -129,24 +104,20 @@ func (m *Monitor) VerifyMutationsResponse(in *ktpb.GetMutationsResponse) []error
 	// reset to the state before it was signed:
 	smr.Signature = nil
 	// verify signature on map root:
-	fmt.Println("tcrypto.VerifyObject:")
-	fmt.Println(m.mapPubKey)
-	fmt.Println(smr)
-	fmt.Println(in.GetSmr().GetSignature())
 	if err := tcrypto.VerifyObject(m.mapPubKey, smr, in.GetSmr().GetSignature()); err != nil {
 		glog.Infof("couldn't verify signature on map root: %v", err)
 		errList = append(errList, ErrInvalidMapSignature)
 	}
 
 	//
-	// mutations verification:
+	// mutations verification
 	//
 
 	// we need the old root for verifying the inclusion of the old leafs in the
 	// previous epoch. Storage always stores the mutations response independent
 	// from if the checks succeeded or not.
 	var oldRoot []byte
-	if m.store.LatestEpoch() > 0 {
+	if m.store.LatestEpoch() > 1 {
 		// retrieve the old root hash from storage!
 		monRes, err := m.store.Get(in.Epoch - 1)
 		if err != nil {
@@ -158,7 +129,7 @@ func (m *Monitor) VerifyMutationsResponse(in *ktpb.GetMutationsResponse) []error
 			errList = append(errList, err...)
 		}
 	} else {
-		// TODO oldRoot is the hash of the initial tree
+		// TODO oldRoot is the hash of the initial empty sparse merkle tree
 	}
 
 	return errList