TLS LogRootV1 Format

crypto/data_formats.go

@@ -24,7 +24,6 @@ import (
 )
 
 // This file contains struct specific mappings and data structures.
-// TODO(gdbelvin): remove data-structure specific operations.
 
 // Constants used as map keys when building input for ObjectHash. They must not be changed
 // as this will change the output of hashRoot()

trillian.proto

@@ -27,6 +27,22 @@ import "google/protobuf/any.proto";
 import "google/protobuf/duration.proto";
 import "google/protobuf/timestamp.proto";
 
+
+// LogRootFormat specifies the fields that are covered by the
+// SignedLogRoot signature, as well as their ordering and formats. 
+enum LogRootFormat {
+   LOG_ROOT_FORMAT_UNKNOWN = 0;
+   LOG_ROOT_FORMAT_V1 = 1;
+}
+
+// MapRootFormat specifies the fields that are covered by the
+// SignedMapRoot signature, as well as their ordering and formats. 
+enum MapRootFormat {
+   MAP_ROOT_FORMAT_UNKNOWN = 0;
+   MAP_ROOT_FORMAT_V1 = 1;
+}
+
+
 // What goes in here?
 // Things which are exposed through the public trillian APIs.
 

types/logroot.go

@@ -0,0 +1,87 @@
+// Copyright 2018 Google Inc. 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 types defines serialization and parsing functions for SignedLogRoot
+// and SignedMapRoot fields.
+package types
+
+import (
+	"encoding/binary"
+	"fmt"
+
+	"github.com/google/certificate-transparency-go/tls"
+
+	"github.com/google/trillian"
+)
+
+// LogRootV1 holds the TLS-deserialization of the following structure
+// (described in RFC5246 section 4 notation):
+// struct {
+//   uint64 tree_size;
+//   opaque root_hash<0..128>;
+//   uint64 timestamp_nanos;
+//   uint64 revision;
+//   opaque metadata<0..65535>;
+// } LogRootV1;
+type LogRootV1 struct {
+	TreeSize       uint64
+	RootHash       []byte `tls:"minlen:0,maxlen:128"`
+	TimestampNanos uint64
+	Revision       uint64
+	Metadata       []byte `tls:"minlen:0,maxlen:65535"`
+}
+
+// LogRoot holds the TLS-deserialization of the following structure
+// (described in RFC5246 section 4 notation):
+// enum { v1(1), (65535)} Version;
+// struct {
+//   Version version;
+//   select(version) {
+//     case v1: LogRootV1;
+//   }
+// } LogRoot;
+type LogRoot struct {
+	Version tls.Enum   `tls:"size:2"`
+	V1      *LogRootV1 `tls:"selector:Version,val:1"`
+}
+
+// UnmarshalBinary verifies that logRootBytes is a TLS serialized LogRoot, has
+// the LOG_ROOT_FORMAT_V1 tag, and populates the caller with the deserialized
+// *LogRootV1.
+func (l *LogRootV1) UnmarshalBinary(logRootBytes []byte) error {
+	if logRootBytes == nil {
+		return fmt.Errorf("nil log root")
+	}
+	version := binary.BigEndian.Uint16(logRootBytes)
+	if version != uint16(trillian.LogRootFormat_LOG_ROOT_FORMAT_V1) {
+		return fmt.Errorf("invalid LogRoot.Version: %v, want %v",
+			version, trillian.LogRootFormat_LOG_ROOT_FORMAT_V1)
+	}
+
+	var logRoot LogRoot
+	if _, err := tls.Unmarshal(logRootBytes, &logRoot); err != nil {
+		return err
+	}
+
+	*l = *logRoot.V1
+	return nil
+}
+
+// MarshalBinary returns a canonical TLS serialization of LogRoot.
+func (l *LogRootV1) MarshalBinary() ([]byte, error) {
+	return tls.Marshal(LogRoot{
+		Version: tls.Enum(trillian.LogRootFormat_LOG_ROOT_FORMAT_V1),
+		V1:      l,
+	})
+}