Merge branch 'main' of github.com:ounsworth/merkle-tree-certs

Author: ounsworth

demo/config.go

@@ -24,6 +24,7 @@ const (
 	VersionPlants01
 	VersionPlants02
 	VersionPlants04
+	VersionPlants05
 )
 
 func (v DraftVersion) String() string {
@@ -38,6 +39,8 @@ func (v DraftVersion) String() string {
 		return "plants-02"
 	case VersionPlants04:
 		return "plants-04"
+	case VersionPlants05:
+		return "plants-05"
 	}
 	panic(fmt.Sprintf("unknown version %d", v))
 }
@@ -67,6 +70,8 @@ func DraftVersionFromString(s string) (v DraftVersion, ok bool) {
 		return VersionPlants02, true
 	case "plants-04":
 		return VersionPlants04, true
+	case "plants-05":
+		return VersionPlants05, true
 
 	default:
 		return 0, false
@@ -150,9 +155,14 @@ type CosignerConfig struct {
 	PrivateKey         []byte
 }
 
+type SerialConfig struct {
+	Log   uint16
+	Index uint64
+}
+
 type CACertConfig struct {
 	CertConfigBase
-	MinSerial uint64
+	MinSerial, MaxSerial SerialConfig
 }
 
 type CertConfigBase struct {

demo/encode.go

@@ -128,8 +128,10 @@ func addSubject(b *cryptobyte.Builder, entry *EntryConfig) {
 }
 
 type mtcCAInfo struct {
+	version   DraftVersion
 	cosigner  *Cosigner
 	minSerial uint64
+	maxSerial uint64
 }
 
 func addExtensions(b *cryptobyte.Builder, config *CertConfigBase, mtcCA *mtcCAInfo) {
@@ -242,6 +244,9 @@ func addExtensions(b *cryptobyte.Builder, config *CertConfigBase, mtcCA *mtcCAIn
 							}
 						})
 						seq.AddASN1Uint64(mtcCA.minSerial)
+						if mtcCA.version >= VersionPlants05 {
+							seq.AddASN1Uint64(mtcCA.maxSerial)
+						}
 					})
 				})
 			})
@@ -423,6 +428,15 @@ func CreateCACertificate(config *CAConfig, cosigner *Cosigner) ([]byte, error) {
 		return nil, err
 	}
 
+	if config.CACert.MinSerial.Index >= 1<<48 {
+		return nil, fmt.Errorf("invalid MinSerial index")
+	}
+	if config.CACert.MaxSerial.Index >= 1<<48 {
+		return nil, fmt.Errorf("invalid MaxSerial index")
+	}
+	minSerial := (uint64(config.CACert.MinSerial.Log) << 48) | config.CACert.MinSerial.Index
+	maxSerial := (uint64(config.CACert.MaxSerial.Log) << 48) | config.CACert.MaxSerial.Index
+
 	b := cryptobyte.NewBuilder(nil)
 	b.AddASN1(cbasn1.SEQUENCE, func(cert *cryptobyte.Builder) {
 		cert.AddASN1(cbasn1.SEQUENCE, func(tbs *cryptobyte.Builder) {
@@ -433,9 +447,12 @@ func CreateCACertificate(config *CAConfig, cosigner *Cosigner) ([]byte, error) {
 			addValidity(tbs, &config.CACert.CertConfigBase)
 			addX509Name(tbs, config.ID) // Subject
 			tbs.AddBytes(spki)
+
 			addExtensions(tbs, &config.CACert.CertConfigBase, &mtcCAInfo{
+				version:   config.Version,
 				cosigner:  cosigner,
-				minSerial: config.CACert.MinSerial,
+				minSerial: minSerial,
+				maxSerial: maxSerial,
 			})
 		})
 		addUnsignedSigAlg(cert)

demo/log.go

@@ -10,6 +10,13 @@ const HashSize = sha256.Size
 
 type HashValue = [HashSize]byte
 
+func HashEmpty() HashValue {
+	h := sha256.New()
+	var ret HashValue
+	h.Sum(ret[:0])
+	return ret
+}
+
 func HashLeaf(b []byte) HashValue {
 	h := sha256.New()
 	h.Write([]byte{0})
@@ -30,9 +37,12 @@ func HashNode(left, right *HashValue) HashValue {
 }
 
 func IsValidSubtree(start, end int) bool {
-	if 0 > start || start >= end {
+	if 0 > start || start > end {
 		return false
 	}
+	if start == end {
+		return true
+	}
 	ceil := uint(1) << (bits.UintSize - bits.LeadingZeros(uint(end-start-1)))
 	return uint(start)&(ceil-1) == 0
 }
@@ -74,6 +84,9 @@ func (mt *MerkleTree) SubtreeHash(start, end int) (HashValue, error) {
 	if end > mt.Size() {
 		return HashValue{}, fmt.Errorf("subtree [%d, %d) contains more elements than tree of size %d", start, end, mt.Size())
 	}
+	if start == end {
+		return HashEmpty(), nil
+	}
 	// Start at the largest complete subtree on the right edge.
 	last := end - 1
 	level := bits.TrailingZeros(^uint(last - start))
@@ -138,6 +151,9 @@ func (mt *MerkleTree) SubtreeConsistencyProof(start, end, n int) ([]byte, error)
 	if n > mt.Size() {
 		return nil, fmt.Errorf("tree of size %d is larger than the Merkle Tree of size %d", n, mt.Size())
 	}
+	if start == end {
+		return nil, nil
+	}
 	return mt.subtreeSubproof(start, end, 0, n, true)
 }
 
@@ -193,14 +209,14 @@ func (mt *MerkleTree) subtreeSubproof(start, end, lo, hi int, known bool) ([]byt
 }
 
 func SubtreesForInterval(start, end int) (start1, end1, start2, end2 int, err error) {
-	if 0 > start || start >= end {
+	if 0 > start || start > end {
 		err = fmt.Errorf("invalid interval [%d, %d)", start, end)
 		return
 	}
-	if end-start == 1 {
+	if end-start <= 1 {
 		start1 = start
-		start2 = start
 		end1 = end
+		start2 = end
 		end2 = end
 		return
 	}

demo/log_test.go

@@ -88,7 +88,8 @@ func TestSubtreesForInterval(t *testing.T) {
 		start1, end1 int
 		start2, end2 int
 	}{
-		{start: 8, end: 9, start1: 8, end1: 9, start2: 8, end2: 9},
+		{start: 9, end: 9, start1: 9, end1: 9, start2: 9, end2: 9},
+		{start: 8, end: 9, start1: 8, end1: 9, start2: 9, end2: 9},
 		{start: 5, end: 13, start1: 4, end1: 8, start2: 8, end2: 13},
 		{start: 7, end: 9, start1: 7, end1: 8, start2: 8, end2: 9},
 	}

demo/mtc.json

@@ -1,5 +1,5 @@
 {
-  "Version": "plants-04",
+  "Version": "plants-05",
   "ID": "32473.1",
   "LogNumber": 1,
   "Cosigners": [
@@ -28,7 +28,9 @@
     "NotBefore": "2020-01-01T00:00:00Z",
     "NotAfter": "2030-12-31T23:59:59Z",
     "IsCA": true,
-    "KeyUsage": ["CertSign"]
+    "KeyUsage": ["CertSign"],
+    "MinSerial": {"Log": 1, "Index": 0},
+    "MaxSerial": {"Log": 5, "Index": 281474976710655}
   },
   "Entries": [
     {

demo/vectors_test.go

@@ -38,8 +38,8 @@ func writeProofLine(w io.Writer, prefix string, proof []byte) {
 func TestSubtreeHashVectors(t *testing.T) {
 	tree := subtreeVectorTree()
 	h := sha256.New()
-	for end := 1; end <= subtreeVectorMax; end++ {
-		for start := 0; start < end; start++ {
+	for end := 0; end <= subtreeVectorMax; end++ {
+		for start := 0; start <= end; start++ {
 			if !IsValidSubtree(start, end) {
 				continue
 			}
@@ -50,7 +50,7 @@ func TestSubtreeHashVectors(t *testing.T) {
 			fmt.Fprintf(h, "[%d, %d) %x\n", start, end, subtreeHash[:])
 		}
 	}
-	const want = "94a95384a8c69acea9b50d035a58285b3a777cb7a724005faa5e1f1e1190007f"
+	const want = "b82806ad4265bb151c1119c0f4db437bb4d1a1f887b3a7fba1cd4ebf552e3e81"
 	if got := fmt.Sprintf("%x", h.Sum(nil)); got != want {
 		t.Errorf("subtree hash vector = %s, want %s", got, want)
 	}
@@ -59,8 +59,8 @@ func TestSubtreeHashVectors(t *testing.T) {
 func TestSubtreeInclusionProofVectors(t *testing.T) {
 	tree := subtreeVectorTree()
 	h := sha256.New()
-	for end := 1; end <= subtreeVectorMax; end++ {
-		for start := 0; start < end; start++ {
+	for end := 0; end <= subtreeVectorMax; end++ {
+		for start := 0; start <= end; start++ {
 			if !IsValidSubtree(start, end) {
 				continue
 			}
@@ -83,8 +83,8 @@ func TestSubtreeConsistencyProofVectors(t *testing.T) {
 	tree := subtreeVectorTree()
 	h := sha256.New()
 	for n := 0; n <= subtreeVectorMax; n++ {
-		for end := 1; end <= n; end++ {
-			for start := 0; start < end; start++ {
+		for end := 0; end <= n; end++ {
+			for start := 0; start <= end; start++ {
 				if !IsValidSubtree(start, end) {
 					continue
 				}
@@ -96,28 +96,24 @@ func TestSubtreeConsistencyProofVectors(t *testing.T) {
 			}
 		}
 	}
-	const want = "c586ebbb73a5621baf2140095d87dde934e3b6503a562a1a5215b8209edd083d"
+	const want = "10fa99b37bf9bf9ffa26b412fbd98bd75363256d0b75d61bc4538b9c9c5a0a74"
 	if got := fmt.Sprintf("%x", h.Sum(nil)); got != want {
 		t.Errorf("subtree consistency proof vector = %s, want %s", got, want)
 	}
 }
 
 func TestEfficientCoveringSubtreeVectors(t *testing.T) {
 	h := sha256.New()
-	for end := 1; end <= subtreeVectorMax; end++ {
-		for start := 0; start < end; start++ {
-			if IsValidSubtree(start, end) {
-				fmt.Fprintf(h, "[%d, %d)\n", start, end)
-				continue
-			}
+	for end := 0; end <= subtreeVectorMax; end++ {
+		for start := 0; start <= end; start++ {
 			start1, end1, start2, end2, err := SubtreesForInterval(start, end)
 			if err != nil {
 				t.Fatalf("SubtreesForInterval(%d, %d): %v", start, end, err)
 			}
 			fmt.Fprintf(h, "[%d, %d) [%d, %d)\n", start1, end1, start2, end2)
 		}
 	}
-	const want = "e0aecb912a10c57d753b6ecc64db73217f9bc4ed10fcb4e9062be3b6fbe1ebfd"
+	const want = "7fd9c8b926e9d2b5cf831560e8ce295a5ef97ad5c5ede4ea0dea28a8c8fc8bb0"
 	if got := fmt.Sprintf("%x", h.Sum(nil)); got != want {
 		t.Errorf("efficient covering subtree vector = %s, want %s", got, want)
 	}