Simplify erasure code by separating bitrot from erasure code (#5959)

cmd/xl-v1-metadata.go

@@ -20,92 +20,17 @@ import (
 	"context"
 	"encoding/hex"
 	"encoding/json"
-	"errors"
 	"fmt"
-	"hash"
 	"path"
 	"sort"
 	"sync"
 	"time"
 
-	"github.com/minio/highwayhash"
 	"github.com/minio/minio/cmd/logger"
-	sha256 "github.com/minio/sha256-simd"
-	"golang.org/x/crypto/blake2b"
 )
 
 const erasureAlgorithmKlauspost = "klauspost/reedsolomon/vandermonde"
 
-// magic HH-256 key as HH-256 hash of the first 100 decimals of π as utf-8 string with a zero key.
-var magicHighwayHash256Key = []byte("\x4b\xe7\x34\xfa\x8e\x23\x8a\xcd\x26\x3e\x83\xe6\xbb\x96\x85\x52\x04\x0f\x93\x5d\xa3\x9f\x44\x14\x97\xe0\x9d\x13\x22\xde\x36\xa0")
-
-// BitrotAlgorithm specifies a algorithm used for bitrot protection.
-type BitrotAlgorithm uint
-
-const (
-	// SHA256 represents the SHA-256 hash function
-	SHA256 BitrotAlgorithm = 1 + iota
-	// HighwayHash256 represents the HighwayHash-256 hash function
-	HighwayHash256
-	// BLAKE2b512 represents the BLAKE2b-256 hash function
-	BLAKE2b512
-)
-
-// DefaultBitrotAlgorithm is the default algorithm used for bitrot protection.
-var DefaultBitrotAlgorithm = HighwayHash256
-
-var bitrotAlgorithms = map[BitrotAlgorithm]string{
-	SHA256:         "sha256",
-	BLAKE2b512:     "blake2b",
-	HighwayHash256: "highwayhash256",
-}
-
-// New returns a new hash.Hash calculating the given bitrot algorithm.
-// New logs error and exits if the algorithm is not supported or not
-// linked into the binary.
-func (a BitrotAlgorithm) New() hash.Hash {
-	switch a {
-	case SHA256:
-		return sha256.New()
-	case BLAKE2b512:
-		b2, _ := blake2b.New512(nil) // New512 never returns an error if the key is nil
-		return b2
-	case HighwayHash256:
-		hh, _ := highwayhash.New(magicHighwayHash256Key) // New will never return error since key is 256 bit
-		return hh
-	}
-	logger.CriticalIf(context.Background(), errors.New("Unsupported bitrot algorithm"))
-	return nil
-}
-
-// Available reports whether the given algorihm is a supported and linked into the binary.
-func (a BitrotAlgorithm) Available() bool {
-	_, ok := bitrotAlgorithms[a]
-	return ok
-}
-
-// String returns the string identifier for a given bitrot algorithm.
-// If the algorithm is not supported String panics.
-func (a BitrotAlgorithm) String() string {
-	name, ok := bitrotAlgorithms[a]
-	if !ok {
-		logger.CriticalIf(context.Background(), errors.New("Unsupported bitrot algorithm"))
-	}
-	return name
-}
-
-// BitrotAlgorithmFromString returns a bitrot algorithm from the given string representation.
-// It returns 0 if the string representation does not match any supported algorithm.
-// The zero value of a bitrot algorithm is never supported.
-func BitrotAlgorithmFromString(s string) (a BitrotAlgorithm) {
-	for alg, name := range bitrotAlgorithms {
-		if name == s {
-			return alg
-		}
-	}
-	return
-}
-
 // objectPartInfo Info of each part kept in the multipart metadata
 // file after CompleteMultipartUpload() is called.
 type objectPartInfo struct {
@@ -129,15 +54,15 @@ type ChecksumInfo struct {
 	Hash      []byte
 }
 
+type checksumInfoJSON struct {
+	Name      string `json:"name"`
+	Algorithm string `json:"algorithm"`
+	Hash      string `json:"hash"`
+}
+
 // MarshalJSON marshals the ChecksumInfo struct
 func (c ChecksumInfo) MarshalJSON() ([]byte, error) {
-	type checksuminfo struct {
-		Name      string `json:"name"`
-		Algorithm string `json:"algorithm"`
-		Hash      string `json:"hash"`
-	}
-
-	info := checksuminfo{
+	info := checksumInfoJSON{
 		Name:      c.Name,
 		Algorithm: c.Algorithm.String(),
 		Hash:      hex.EncodeToString(c.Hash),
@@ -145,28 +70,25 @@ func (c ChecksumInfo) MarshalJSON() ([]byte, error) {
 	return json.Marshal(info)
 }
 
-// UnmarshalJSON unmarshals the the given data into the ChecksumInfo struct
+// UnmarshalJSON - should never be called, instead xlMetaV1UnmarshalJSON() should be used.
 func (c *ChecksumInfo) UnmarshalJSON(data []byte) error {
-	type checksuminfo struct {
-		Name      string `json:"name"`
-		Algorithm string `json:"algorithm"`
-		Hash      string `json:"hash"`
-	}
-
-	var info checksuminfo
-	err := json.Unmarshal(data, &info)
-	if err != nil {
+	logger.LogIf(context.Background(), errUnexpected)
+	var info checksumInfoJSON
+	if err := json.Unmarshal(data, &info); err != nil {
 		return err
 	}
-	c.Algorithm = BitrotAlgorithmFromString(info.Algorithm)
-	if !c.Algorithm.Available() {
-		return errBitrotHashAlgoInvalid
-	}
-	c.Hash, err = hex.DecodeString(info.Hash)
+	sum, err := hex.DecodeString(info.Hash)
 	if err != nil {
 		return err
 	}
 	c.Name = info.Name
+	c.Algorithm = BitrotAlgorithmFromString(info.Algorithm)
+	c.Hash = sum
+
+	if !c.Algorithm.Available() {
+		logger.LogIf(context.Background(), errBitrotHashAlgoInvalid)
+		return errBitrotHashAlgoInvalid
+	}
 	return nil
 }