Hackathon: monitor page

cmd/keytransparency-monitor/main.go

@@ -42,18 +42,22 @@ import (
 	spb "github.com/google/keytransparency/impl/proto/keytransparency_v1_service"
 	mopb "github.com/google/keytransparency/impl/proto/monitor_v1_service"
 	mupb "github.com/google/keytransparency/impl/proto/mutation_v1_service"
-	_ "github.com/google/trillian/merkle/coniks"    // Register coniks
+	tlogcli "github.com/google/trillian/client"
+	"github.com/google/trillian/crypto/keys/der"
+	_ "github.com/google/trillian/merkle/coniks" // Register coniks
+	"github.com/google/trillian/merkle/hashers"
 	_ "github.com/google/trillian/merkle/objhasher" // Register objhasher
+	"html/template"
 )
 
 var (
 	addr     = flag.String("addr", ":8099", "The ip:port combination to listen on")
-	keyFile  = flag.String("tls-key", "genfiles/server.key", "TLS private key file")
-	certFile = flag.String("tls-cert", "genfiles/server.pem", "TLS cert file")
+	keyFile  = flag.String("tls-key", "../../genfiles/server.key", "TLS private key file")
+	certFile = flag.String("tls-cert", "../../genfiles/server.pem", "TLS cert file")
 
-	signingKey         = flag.String("sign-key", "genfiles/monitor_sign-key.pem", "Path to private key PEM for SMH signing")
+	signingKey         = flag.String("sign-key", "../../genfiles/monitor_sign-key.pem", "Path to private key PEM for SMH signing")
 	signingKeyPassword = flag.String("password", "towel", "Password of the private key PEM file for SMH signing")
-	ktURL              = flag.String("kt-url", "localhost:8080", "URL of key-server.")
+	ktURL              = flag.String("kt-url", "35.184.134.53:8080", "URL of key-server.")
 	insecure           = flag.Bool("insecure", false, "Skip TLS checks")
 	ktCert             = flag.String("kt-cert", "genfiles/server.crt", "Path to kt-server's public key")
 
@@ -65,11 +69,11 @@ var (
 
 func grpcGatewayMux(addr string) (*runtime.ServeMux, error) {
 	ctx := context.Background()
-	creds, err := credentials.NewClientTLSFromFile(*certFile, "")
-	if err != nil {
-		return nil, err
-	}
-	dopts := []grpc.DialOption{grpc.WithTransportCredentials(creds)}
+	//creds, err := credentials.NewClientTLSFromFile(*certFile, "")
+	//if err != nil {
+	//	return nil, err
+	//}
+	dopts := []grpc.DialOption{grpc.WithInsecure()}
 	gwmux := runtime.NewServeMux()
 	if err := mopb.RegisterMonitorServiceHandlerFromEndpoint(ctx, gwmux, addr, dopts); err != nil {
 		return nil, err
@@ -92,19 +96,47 @@ func grpcHandlerFunc(grpcServer *grpc.Server, otherHandler http.Handler) http.Ha
 	})
 }
 
-func main() {
-	flag.Parse()
+// Hackathon only code. Remove later!
+type resHandler struct {
+	store *storage.Storage
+}
 
-	creds, err := credentials.NewServerTLSFromFile(*certFile, *keyFile)
+func (h *resHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	max := h.store.LatestEpoch()
+	results := make([]*storage.MonitoringResult, max)
+	for i:=int64(1); i<= max ; i++  {
+		monRes, err := h.store.Get(i)
+		if err != nil {
+			glog.Errorf("Couldn't retrieve mon result: %v", err)
+		}
+		results[i-1] = monRes
+	}
+	// TODO(ismail) make this file path configurable so that it can be found in
+	// docker as well
+	tmpl, err := template.ParseFiles("/Users/khoffi/go/src/github.com/google/keytransparency/cmd/keytransparency-monitor/web/monitoring.tmpl")
+	if err != nil {
+		glog.Errorf("Could not parse template: %v", err)
+	}
+
+	err = tmpl.Execute(w, results)
 	if err != nil {
-		glog.Exitf("Failed to load server credentials %v", err)
+		glog.Errorf("Could not write result: %v", err)
 	}
+}
+
+func main() {
+	flag.Parse()
+
+	//creds, err := credentials.NewServerTLSFromFile(*certFile, *keyFile)
+	//if err != nil {
+	//	glog.Exitf("Failed to load server credentials %v", err)
+	//}
 
 	// Create gRPC server.
 	grpcServer := grpc.NewServer(
-		grpc.Creds(creds),
+		//grpc.Creds(creds),
 		grpc.StreamInterceptor(grpc_prometheus.StreamServerInterceptor),
-		grpc.UnaryInterceptor(grpc_prometheus.UnaryServerInterceptor),
+		//grpc.UnaryInterceptor(grpc_prometheus.UnaryServerInterceptor),
 	)
 
 	// Connect to the kt-server's mutation API:
@@ -140,14 +172,27 @@ func main() {
 
 	// Insert handlers for other http paths here.
 	mux := http.NewServeMux()
+
+	resultHandler := &resHandler{store:store}
+	mux.Handle("/monitor", resultHandler)
+
 	mux.Handle("/", gwmux)
+	logHasher, err := hashers.NewLogHasher(logTree.GetHashStrategy())
+	if err != nil {
+		glog.Fatalf("Could not initialize log hasher: %v", err)
+	}
+	logPubKey, err := der.UnmarshalPublicKey(logTree.GetPublicKey().GetDer())
+	if err != nil {
+		glog.Fatalf("Failed parsing Log public key: %v", err)
+	}
+	logVerifier := tlogcli.NewLogVerifier(logHasher, logPubKey)
 
-	// initialize the mutations API client and feed the responses it got
-	// into the monitor:
-	mon, err := cmon.New(logTree, mapTree, crypto.NewSHA256Signer(key), store)
+	mon, err := cmon.New(logVerifier, mapTree, crypto.NewSHA256Signer(key), store)
 	if err != nil {
 		glog.Exitf("Failed to initialize monitor: %v", err)
 	}
+	// initialize the mutations API client and feed the responses it got
+	// into the monitor:
 	mutCli := client.New(mcc, *pollPeriod)
 	responses, errs := mutCli.StartPolling(1)
 	go func() {
@@ -169,7 +214,7 @@ func main() {
 
 	// Serve HTTP2 server over TLS.
 	glog.Infof("Listening on %v", *addr)
-	if err := http.ListenAndServeTLS(*addr, *certFile, *keyFile,
+	if err := http.ListenAndServe(*addr, /**certFile, *keyFile,*/
 		grpcHandlerFunc(grpcServer, mux)); err != nil {
 		glog.Errorf("ListenAndServeTLS: %v", err)
 	}

cmd/keytransparency-monitor/web/monitoring.tmpl

@@ -0,0 +1,19 @@
+{{range .}}
+<table>
+        <tr><td>Epoch: {{.Response.Epoch}}</td></tr>
+        <tr><td>Map-id: {{.Response.Smr.MapId}}</td></tr>
+        <tr><td>Log-id: {{.Response.LogRoot.LogId}}</td></tr>
+        <tr><td>SMR roothash: {{.Response.Smr.RootHash}}</td></tr>
+        <tr><td>&nbsp;</td></tr>
+        <tr><td>Errors: </td></tr>
+        {{range .Errors}}
+        <tr>
+        <td>&nbsp;&nbsp;&nbsp;Error: {{.}}</td>
+        </tr>
+        {{end}}
+        <hr>
+        <hr>
+        <hr>
+        &nbsp;
+</table>
+{{end}}

core/monitor/monitor.go

@@ -25,39 +25,39 @@ import (
 	ktpb "github.com/google/keytransparency/core/proto/keytransparency_v1_types"
 
 	"github.com/google/trillian"
+	"github.com/google/trillian/client"
 	tcrypto "github.com/google/trillian/crypto"
-	"github.com/google/trillian/merkle"
+	"github.com/google/trillian/crypto/keys/der"
 	"github.com/google/trillian/merkle/hashers"
 )
 
 // Monitor holds the internal state for a monitor accessing the mutations API
 // and for verifying its responses.
 type Monitor struct {
-	hasher      hashers.MapHasher
-	logPubKey   crypto.PublicKey
+	mapID       int64
+	mapHasher   hashers.MapHasher
 	mapPubKey   crypto.PublicKey
-	logVerifier merkle.LogVerifier
+	logVerifier client.LogVerifier
 	signer      *tcrypto.Signer
-	// TODO(ismail): update last trusted signed log root
-	//trusted     trillian.SignedLogRoot
-	store *storage.Storage
+	trusted     *trillian.SignedLogRoot
+	store       *storage.Storage
 }
 
 // New creates a new instance of the monitor.
-func New(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)
 	}
+	mapPubKey, err := der.UnmarshalPublicKey(mapTree.GetPublicKey().GetDer())
+	if err != nil {
+		return nil, fmt.Errorf("Could not unmarshal map public key: %v", err)
+	}
 	return &Monitor{
-		hasher:      mapHasher,
-		logVerifier: merkle.NewLogVerifier(logHasher),
-		logPubKey:   logTree.GetPublicKey(),
-		mapPubKey:   mapTree.GetPublicKey(),
+		logVerifier: logverifierCli,
+		mapID:       mapTree.TreeId,
+		mapHasher:   mapHasher,
+		mapPubKey:   mapPubKey,
 		signer:      signer,
 		store:       store,
 	}, nil
@@ -70,7 +70,7 @@ func (m *Monitor) Process(resp *ktpb.GetMutationsResponse) error {
 	var smr *trillian.SignedMapRoot
 	var err error
 	seen := time.Now().Unix()
-	errs := m.verifyMutationsResponse(resp)
+	errs := m.VerifyMutationsResponse(resp)
 	if len(errs) == 0 {
 		glog.Infof("Successfully verified mutations response for epoch: %v", resp.Epoch)
 		smr, err = m.signMapRoot(resp)