Improve performance of v1.NewHash (#2194)

* Improve performance of v1.NewHash

Previously, NewHash() made multiple unnecessary heap allocations that have been removed.

I've also added a simple benchmark test to measure the impact. Results below:

Before:

```
go test ./pkg/v1 -run XXX -bench BenchmarkNewHash
goos: darwin
goarch: arm64
pkg: github.com/google/go-containerregistry/pkg/v1
cpu: Apple M1 Pro
BenchmarkNewHash-10    	 8977393	       123.1 ns/op	     160 B/op	       2 allocs/op
PASS
ok  	github.com/google/go-containerregistry/pkg/v1	1.711s
```

After:

```
$ go test ./pkg/v1 -run XXX -bench BenchmarkNewHash
goos: darwin
goarch: arm64
pkg: github.com/google/go-containerregistry/pkg/v1
cpu: Apple M1 Pro
BenchmarkNewHash-10    	15214291	        76.09 ns/op	       0 B/op	       0 allocs/op
PASS
ok  	github.com/google/go-containerregistry/pkg/v1	1.805s
```

* add "Too many separators" cases to TestBadHashes

Author: bmoylan

pkg/v1/hash.go

@@ -84,27 +84,35 @@ func Hasher(name string) (hash.Hash, error) {
 }
 
 func (h *Hash) parse(unquoted string) error {
-	parts := strings.Split(unquoted, ":")
-	if len(parts) != 2 {
+	algo, body, ok := strings.Cut(unquoted, ":")
+	if !ok || algo == "" || body == "" {
 		return fmt.Errorf("cannot parse hash: %q", unquoted)
 	}
 
-	rest := strings.TrimLeft(parts[1], "0123456789abcdef")
+	rest := strings.TrimLeft(body, "0123456789abcdef")
 	if len(rest) != 0 {
 		return fmt.Errorf("found non-hex character in hash: %c", rest[0])
 	}
 
-	hasher, err := Hasher(parts[0])
-	if err != nil {
-		return err
+	var wantBytes int
+	switch algo {
+	case "sha256":
+		wantBytes = crypto.SHA256.Size()
+	default:
+		hasher, err := Hasher(algo)
+		if err != nil {
+			return err
+		}
+		wantBytes = hasher.Size()
 	}
+
 	// Compare the hex to the expected size (2 hex characters per byte)
-	if len(parts[1]) != hasher.Size()*2 {
-		return fmt.Errorf("wrong number of hex digits for %s: %s", parts[0], parts[1])
+	if len(body) != hex.EncodedLen(wantBytes) {
+		return fmt.Errorf("wrong number of hex digits for %s: %s", algo, body)
 	}
 
-	h.Algorithm = parts[0]
-	h.Hex = parts[1]
+	h.Algorithm = algo
+	h.Hex = body
 	return nil
 }
 

pkg/v1/hash_test.go

@@ -51,6 +51,11 @@ func TestBadHashes(t *testing.T) {
 		"sha256:deadbeef",
 		// Bad character
 		"sha256:o123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
+		// Too many separators
+		"sha256:abc:def",
+		"sha256:0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef:",
+		"sha256:0:123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
+		"sha256::0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
 		// Unknown algorithm
 		"md5:0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
 		// Too few parts
@@ -113,3 +118,13 @@ func TestTextMarshalling(t *testing.T) {
 		t.Errorf("mismatched hash: %s != %s", h, g)
 	}
 }
+
+func BenchmarkNewHash(b *testing.B) {
+	b.ReportAllocs()
+	for b.Loop() {
+		_, err := NewHash("sha256:0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef")
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}