Stop using deprecated digest.Digest.Hex

mtrmac · mtrmac · commit cae39439d835 · 2024-05-09T18:30:47.000+02:00
Should not change behavior.

Signed-off-by: Miloslav Trmač &lt;mitr@redhat.com&gt;
diff --git a/docker/internal/tarfile/writer.go b/docker/internal/tarfile/writer.go
@@ -164,7 +164,7 @@ func (w *Writer) writeLegacyMetadataLocked(layerDescriptors []manifest.Schema2De
 			return fmt.Errorf("marshaling layer config: %w", err)
 		}
 		delete(layerConfig, "layer_id")
-		layerID := digest.Canonical.FromBytes(b).Hex()
+		layerID := digest.Canonical.FromBytes(b).Encoded()
 		layerConfig["id"] = layerID
 
 		configBytes, err := json.Marshal(layerConfig)
@@ -309,26 +309,26 @@ func (w *Writer) Close() error {
 // NOTE: This is an internal implementation detail, not a format property, and can change
 // any time.
 func (w *Writer) configPath(configDigest digest.Digest) (string, error) {
-	if err := configDigest.Validate(); err != nil { // digest.Digest.Hex() panics on failure, and could possibly result in unexpected paths, so validate explicitly.
+	if err := configDigest.Validate(); err != nil { // digest.Digest.Encoded() panics on failure, and could possibly result in unexpected paths, so validate explicitly.
 		return "", err
 	}
-	return configDigest.Hex() + ".json", nil
+	return configDigest.Encoded() + ".json", nil
 }
 
 // physicalLayerPath returns a path we choose for storing a layer with the specified digest
 // (the actual path, i.e. a regular file, not a symlink that may be used in the legacy format).
 // NOTE: This is an internal implementation detail, not a format property, and can change
 // any time.
 func (w *Writer) physicalLayerPath(layerDigest digest.Digest) (string, error) {
-	if err := layerDigest.Validate(); err != nil { // digest.Digest.Hex() panics on failure, and could possibly result in unexpected paths, so validate explicitly.
+	if err := layerDigest.Validate(); err != nil { // digest.Digest.Encoded() panics on failure, and could possibly result in unexpected paths, so validate explicitly.
 		return "", err
 	}
-	// Note that this can't be e.g. filepath.Join(l.Digest.Hex(), legacyLayerFileName); due to the way
+	// Note that this can't be e.g. filepath.Join(l.Digest.Encoded(), legacyLayerFileName); due to the way
 	// writeLegacyMetadata constructs layer IDs differently from inputinfo.Digest values (as described
 	// inside it), most of the layers would end up in subdirectories alone without any metadata; (docker load)
 	// tries to load every subdirectory as an image and fails if the config is missing.  So, keep the layers
 	// in the root of the tarball.
-	return layerDigest.Hex() + ".tar", nil
+	return layerDigest.Encoded() + ".tar", nil
 }
 
 type tarFI struct {
diff --git a/docker/registries_d.go b/docker/registries_d.go
@@ -288,10 +288,10 @@ func (ns registryNamespace) signatureTopLevel(write bool) string {
 // base is not nil from the caller
 // NOTE: Keep this in sync with docs/signature-protocols.md!
 func lookasideStorageURL(base lookasideStorageBase, manifestDigest digest.Digest, index int) (*url.URL, error) {
-	if err := manifestDigest.Validate(); err != nil { // digest.Digest.Hex() panics on failure, and could possibly result in a path with ../, so validate explicitly.
+	if err := manifestDigest.Validate(); err != nil { // digest.Digest.Encoded() panics on failure, and could possibly result in a path with ../, so validate explicitly.
 		return nil, err
 	}
 	sigURL := *base
-	sigURL.Path = fmt.Sprintf("%s@%s=%s/signature-%d", sigURL.Path, manifestDigest.Algorithm(), manifestDigest.Hex(), index+1)
+	sigURL.Path = fmt.Sprintf("%s@%s=%s/signature-%d", sigURL.Path, manifestDigest.Algorithm(), manifestDigest.Encoded(), index+1)
 	return &sigURL, nil
 }
diff --git a/internal/image/docker_schema2.go b/internal/image/docker_schema2.go
@@ -366,7 +366,7 @@ func v1IDFromBlobDigestAndComponents(blobDigest digest.Digest, others ...string)
 	if err := blobDigest.Validate(); err != nil {
 		return "", err
 	}
-	parts := append([]string{blobDigest.Hex()}, others...)
+	parts := append([]string{blobDigest.Encoded()}, others...)
 	v1IDHash := sha256.Sum256([]byte(strings.Join(parts, " ")))
 	return hex.EncodeToString(v1IDHash[:]), nil
 }
diff --git a/manifest/docker_schema1.go b/manifest/docker_schema1.go
@@ -342,5 +342,5 @@ func (m *Schema1) ImageID(diffIDs []digest.Digest) (string, error) {
 	if err != nil {
 		return "", err
 	}
-	return digest.FromBytes(image).Hex(), nil
+	return digest.FromBytes(image).Encoded(), nil
 }
diff --git a/manifest/docker_schema2.go b/manifest/docker_schema2.go
@@ -295,7 +295,7 @@ func (m *Schema2) ImageID([]digest.Digest) (string, error) {
 	if err := m.ConfigDescriptor.Digest.Validate(); err != nil {
 		return "", err
 	}
-	return m.ConfigDescriptor.Digest.Hex(), nil
+	return m.ConfigDescriptor.Digest.Encoded(), nil
 }
 
 // CanChangeLayerCompression returns true if we can compress/decompress layers with mimeType in the current image
diff --git a/manifest/oci.go b/manifest/oci.go
@@ -260,7 +260,7 @@ func (m *OCI1) ImageID(diffIDs []digest.Digest) (string, error) {
 	if err := m.Config.Digest.Validate(); err != nil {
 		return "", err
 	}
-	return m.Config.Digest.Hex(), nil
+	return m.Config.Digest.Encoded(), nil
 }
 
 // CanChangeLayerCompression returns true if we can compress/decompress layers with mimeType in the current image
diff --git a/oci/layout/oci_delete_test.go b/oci/layout/oci_delete_test.go
@@ -318,15 +318,15 @@ func loadFixture(t *testing.T, fixtureName string) string {
 func assertBlobExists(t *testing.T, blobsDir string, blobDigest string) {
 	digest, err := digest.Parse(blobDigest)
 	require.NoError(t, err)
-	blobPath := filepath.Join(blobsDir, digest.Algorithm().String(), digest.Hex())
+	blobPath := filepath.Join(blobsDir, digest.Algorithm().String(), digest.Encoded())
 	_, err = os.Stat(blobPath)
 	require.NoError(t, err)
 }
 
 func assertBlobDoesNotExist(t *testing.T, blobsDir string, blobDigest string) {
 	digest, err := digest.Parse(blobDigest)
 	require.NoError(t, err)
-	blobPath := filepath.Join(blobsDir, digest.Algorithm().String(), digest.Hex())
+	blobPath := filepath.Join(blobsDir, digest.Algorithm().String(), digest.Encoded())
 	_, err = os.Stat(blobPath)
 	require.True(t, os.IsNotExist(err))
 }
diff --git a/oci/layout/oci_transport.go b/oci/layout/oci_transport.go
@@ -256,5 +256,5 @@ func (ref ociReference) blobPath(digest digest.Digest, sharedBlobDir string) (st
 	} else {
 		blobDir = filepath.Join(ref.dir, imgspecv1.ImageBlobsDir)
 	}
-	return filepath.Join(blobDir, digest.Algorithm().String(), digest.Hex()), nil
+	return filepath.Join(blobDir, digest.Algorithm().String(), digest.Encoded()), nil
 }
diff --git a/ostree/ostree_dest.go b/ostree/ostree_dest.go
@@ -164,7 +164,7 @@ func (d *ostreeImageDestination) PutBlobWithOptions(ctx context.Context, stream
 		return private.UploadedBlob{}, err
 	}
 
-	hash := blobDigest.Hex()
+	hash := blobDigest.Encoded()
 	d.blobs[hash] = &blobToImport{Size: size, Digest: blobDigest, BlobPath: blobPath}
 	return private.UploadedBlob{Digest: blobDigest, Size: size}, nil
 }
@@ -282,8 +282,8 @@ func generateTarSplitMetadata(output *bytes.Buffer, file string) (digest.Digest,
 func (d *ostreeImageDestination) importBlob(selinuxHnd *C.struct_selabel_handle, repo *otbuiltin.Repo, blob *blobToImport) error {
 	// TODO: This can take quite some time, and should ideally be cancellable using a context.Context.
 
-	ostreeBranch := fmt.Sprintf("ociimage/%s", blob.Digest.Hex())
-	destinationPath := filepath.Join(d.tmpDirPath, blob.Digest.Hex(), "root")
+	ostreeBranch := fmt.Sprintf("ociimage/%s", blob.Digest.Encoded())
+	destinationPath := filepath.Join(d.tmpDirPath, blob.Digest.Encoded(), "root")
 	if err := ensureDirectoryExists(destinationPath); err != nil {
 		return err
 	}
@@ -323,7 +323,7 @@ func (d *ostreeImageDestination) importBlob(selinuxHnd *C.struct_selabel_handle,
 }
 
 func (d *ostreeImageDestination) importConfig(repo *otbuiltin.Repo, blob *blobToImport) error {
-	ostreeBranch := fmt.Sprintf("ociimage/%s", blob.Digest.Hex())
+	ostreeBranch := fmt.Sprintf("ociimage/%s", blob.Digest.Encoded())
 	destinationPath := filepath.Dir(blob.BlobPath)
 
 	return d.ostreeCommit(repo, ostreeBranch, destinationPath, []string{fmt.Sprintf("docker.size=%d", blob.Size)})
@@ -348,10 +348,10 @@ func (d *ostreeImageDestination) TryReusingBlobWithOptions(ctx context.Context,
 		d.repo = repo
 	}
 
-	if err := info.Digest.Validate(); err != nil { // digest.Digest.Hex() panics on failure, so validate explicitly.
+	if err := info.Digest.Validate(); err != nil { // digest.Digest.Encoded() panics on failure, so validate explicitly.
 		return false, private.ReusedBlob{}, err
 	}
-	branch := fmt.Sprintf("ociimage/%s", info.Digest.Hex())
+	branch := fmt.Sprintf("ociimage/%s", info.Digest.Encoded())
 
 	found, data, err := readMetadata(d.repo, branch, "docker.uncompressed_digest")
 	if err != nil || !found {
@@ -479,7 +479,7 @@ func (d *ostreeImageDestination) Commit(context.Context, types.UnparsedImage) er
 		if err := layer.Digest.Validate(); err != nil { // digest.Digest.Encoded() panics on failure, so validate explicitly.
 			return err
 		}
-		hash := layer.Digest.Hex()
+		hash := layer.Digest.Encoded()
 		if err = checkLayer(hash); err != nil {
 			return err
 		}
@@ -488,7 +488,7 @@ func (d *ostreeImageDestination) Commit(context.Context, types.UnparsedImage) er
 		if err := layer.BlobSum.Validate(); err != nil { // digest.Digest.Encoded() panics on failure, so validate explicitly.
 			return err
 		}
-		hash := layer.BlobSum.Hex()
+		hash := layer.BlobSum.Encoded()
 		if err = checkLayer(hash); err != nil {
 			return err
 		}
diff --git a/ostree/ostree_src.go b/ostree/ostree_src.go
@@ -289,7 +289,7 @@ func (s *ostreeImageSource) GetBlob(ctx context.Context, info types.BlobInfo, ca
 	if err := info.Digest.Validate(); err != nil { // digest.Digest.Encoded() panics on failure, so validate explicitly.
 		return nil, -1, err
 	}
-	blob := info.Digest.Hex()
+	blob := info.Digest.Encoded()
 
 	// Ensure s.compressed is initialized.  It is build by LayerInfosForCopy.
 	if s.compressed == nil {
@@ -301,7 +301,7 @@ func (s *ostreeImageSource) GetBlob(ctx context.Context, info types.BlobInfo, ca
 	}
 	compressedBlob, isCompressed := s.compressed[info.Digest]
 	if isCompressed {
-		blob = compressedBlob.Hex()
+		blob = compressedBlob.Encoded()
 	}
 	branch := fmt.Sprintf("ociimage/%s", blob)
 
@@ -424,7 +424,7 @@ func (s *ostreeImageSource) LayerInfosForCopy(ctx context.Context, instanceDiges
 	layerBlobs := man.LayerInfos()
 
 	for _, layerBlob := range layerBlobs {
-		branch := fmt.Sprintf("ociimage/%s", layerBlob.Digest.Hex())
+		branch := fmt.Sprintf("ociimage/%s", layerBlob.Digest.Encoded())
 		found, uncompressedDigestStr, err := readMetadata(s.repo, branch, "docker.uncompressed_digest")
 		if err != nil || !found {
 			return nil, err
diff --git a/pkg/blobinfocache/sqlite/sqlite.go b/pkg/blobinfocache/sqlite/sqlite.go
@@ -229,7 +229,7 @@ func ensureDBHasCurrentSchema(db *sql.DB) error {
 	// * This schema uses the text representation of digests.
 	//
 	//   We use the fairly wasteful text with hexadecimal digits because digest.Digest does not define a binary representation;
-	//   and the way digest.Digest.Hex() is deprecated in favor of digest.Digest.Encoded(), and the way digest.Algorithm
+	//   and the way digest.Digest.Encoded() is deprecated in favor of digest.Digest.Encoded(), and the way digest.Algorithm
 	//   is documented to “define the string encoding” suggests that assuming a hexadecimal representation and turning that
 	//   into binary ourselves is not a good idea in general; we would have to special-case the currently-known algorithm
 	//   — and that would require us to implement two code paths, one of them basically never exercised / never tested.
diff --git a/sif/src.go b/sif/src.go
@@ -111,7 +111,7 @@ func newImageSource(ctx context.Context, sys *types.SystemContext, ref sifRefere
 		History: []imgspecv1.History{
 			{
 				Created:   &created,
-				CreatedBy: fmt.Sprintf("/bin/sh -c #(nop) ADD file:%s in %c", layerDigest.Hex(), os.PathSeparator),
+				CreatedBy: fmt.Sprintf("/bin/sh -c #(nop) ADD file:%s in %c", layerDigest.Encoded(), os.PathSeparator),
 				Comment:   "imported from SIF, uuid: " + sifImg.ID(),
 			},
 			{
diff --git a/storage/storage_dest.go b/storage/storage_dest.go
@@ -564,7 +564,7 @@ func (s *storageImageDestination) computeID(m manifest.Manifest) string {
 	}
 	// ordinaryImageID is a digest of a config, which is a JSON value.
 	// To avoid the risk of collisions, start the input with @ so that the input is not a valid JSON.
-	tocImageID := digest.FromString("@With TOC:" + tocIDInput).Hex()
+	tocImageID := digest.FromString("@With TOC:" + tocIDInput).Encoded()
 	logrus.Debugf("Ordinary storage image ID %s; a layer was looked up by TOC, so using image ID %s", ordinaryImageID, tocImageID)
 	return tocImageID
 }
@@ -651,11 +651,11 @@ func (s *storageImageDestination) singleLayerIDComponent(layerIndex int, blobDig
 	defer s.lock.Unlock()
 
 	if d, found := s.lockProtected.indexToTOCDigest[layerIndex]; found {
-		return "@TOC=" + d.Hex(), false // "@" is not a valid start of a digest.Digest, so this is unambiguous.
+		return "@TOC=" + d.Encoded(), false // "@" is not a valid start of a digest.Digest, so this is unambiguous.
 	}
 
 	if d, found := s.lockProtected.blobDiffIDs[blobDigest]; found {
-		return d.Hex(), true // This looks like chain IDs, and it uses the traditional value.
+		return d.Encoded(), true // This looks like chain IDs, and it uses the traditional value.
 	}
 	return "", false
 }
@@ -731,7 +731,7 @@ func (s *storageImageDestination) commitLayer(index int, info addedLayerInfo, si
 
 	id := layerIDComponent
 	if !layerIDComponentStandalone || parentLayer != "" {
-		id = digest.Canonical.FromString(parentLayer + "+" + layerIDComponent).Hex()
+		id = digest.Canonical.FromString(parentLayer + "+" + layerIDComponent).Encoded()
 	}
 	if layer, err2 := s.imageRef.transport.store.Layer(id); layer != nil && err2 == nil {
 		// There's already a layer that should have the right contents, just reuse it.
diff --git a/storage/storage_test.go b/storage/storage_test.go
@@ -437,8 +437,8 @@ func TestWriteRead(t *testing.T) {
 		manifest = strings.ReplaceAll(manifest, "%ch", config.compressedDigest.String())
 		manifest = strings.ReplaceAll(manifest, "%ls", fmt.Sprintf("%d", layer.compressedSize))
 		manifest = strings.ReplaceAll(manifest, "%cs", fmt.Sprintf("%d", config.compressedSize))
-		manifest = strings.ReplaceAll(manifest, "%li", layer.compressedDigest.Hex())
-		manifest = strings.ReplaceAll(manifest, "%ci", config.compressedDigest.Hex())
+		manifest = strings.ReplaceAll(manifest, "%li", layer.compressedDigest.Encoded())
+		manifest = strings.ReplaceAll(manifest, "%ci", config.compressedDigest.Encoded())
 		t.Logf("this manifest is %q", manifest)
 		err = dest.PutManifest(context.Background(), []byte(manifest), nil)
 		require.NoError(t, err)
diff --git a/tarball/tarball_src.go b/tarball/tarball_src.go
@@ -117,7 +117,7 @@ func (r *tarballReference) NewImageSource(ctx context.Context, sys *types.System
 
 		history = append(history, imgspecv1.History{
 			Created:   &blobTime,
-			CreatedBy: fmt.Sprintf("/bin/sh -c #(nop) ADD file:%s in %c", diffID.Hex(), os.PathSeparator),
+			CreatedBy: fmt.Sprintf("/bin/sh -c #(nop) ADD file:%s in %c", diffID.Encoded(), os.PathSeparator),
 			Comment:   comment,
 		})
 		// Use the mtime of the most recently modified file as the image's creation time.

Original file line number	Diff line number	Diff line change
`@@ -288,10 +288,10 @@ func (ns registryNamespace) signatureTopLevel(write bool) string {`
`288`	`288`	`// base is not nil from the caller`
`289`	`289`	`// NOTE: Keep this in sync with docs/signature-protocols.md!`
`290`	`290`	`func lookasideStorageURL(base lookasideStorageBase, manifestDigest digest.Digest, index int) (*url.URL, error) {`
`291`		`- if err := manifestDigest.Validate(); err != nil { // digest.Digest.Hex() panics on failure, and could possibly result in a path with ../, so validate explicitly.`
	`291`	`+ if err := manifestDigest.Validate(); err != nil { // digest.Digest.Encoded() panics on failure, and could possibly result in a path with ../, so validate explicitly.`
`292`	`292`	`return nil, err`
`293`	`293`	`}`
`294`	`294`	`sigURL := *base`
`295`		`- sigURL.Path = fmt.Sprintf("%s@%s=%s/signature-%d", sigURL.Path, manifestDigest.Algorithm(), manifestDigest.Hex(), index+1)`
	`295`	`+ sigURL.Path = fmt.Sprintf("%s@%s=%s/signature-%d", sigURL.Path, manifestDigest.Algorithm(), manifestDigest.Encoded(), index+1)`
`296`	`296`	`return &sigURL, nil`
`297`	`297`	`}`
Original file line number	Diff line number	Diff line change
`@@ -366,7 +366,7 @@ func v1IDFromBlobDigestAndComponents(blobDigest digest.Digest, others ...string)`
`366`	`366`	`if err := blobDigest.Validate(); err != nil {`
`367`	`367`	`return "", err`
`368`	`368`	`}`
`369`		`- parts := append([]string{blobDigest.Hex()}, others...)`
	`369`	`+ parts := append([]string{blobDigest.Encoded()}, others...)`
`370`	`370`	`v1IDHash := sha256.Sum256([]byte(strings.Join(parts, " ")))`
`371`	`371`	`return hex.EncodeToString(v1IDHash[:]), nil`
`372`	`372`	`}`
Original file line number	Diff line number	Diff line change
`@@ -342,5 +342,5 @@ func (m *Schema1) ImageID(diffIDs []digest.Digest) (string, error) {`
`342`	`342`	`if err != nil {`
`343`	`343`	`return "", err`
`344`	`344`	`}`
`345`		`- return digest.FromBytes(image).Hex(), nil`
	`345`	`+ return digest.FromBytes(image).Encoded(), nil`
`346`	`346`	`}`
Original file line number	Diff line number	Diff line change
`@@ -295,7 +295,7 @@ func (m *Schema2) ImageID([]digest.Digest) (string, error) {`
`295`	`295`	`if err := m.ConfigDescriptor.Digest.Validate(); err != nil {`
`296`	`296`	`return "", err`
`297`	`297`	`}`
`298`		`- return m.ConfigDescriptor.Digest.Hex(), nil`
	`298`	`+ return m.ConfigDescriptor.Digest.Encoded(), nil`
`299`	`299`	`}`
`300`	`300`
`301`	`301`	`// CanChangeLayerCompression returns true if we can compress/decompress layers with mimeType in the current image`
Original file line number	Diff line number	Diff line change
`@@ -260,7 +260,7 @@ func (m *OCI1) ImageID(diffIDs []digest.Digest) (string, error) {`
`260`	`260`	`if err := m.Config.Digest.Validate(); err != nil {`
`261`	`261`	`return "", err`
`262`	`262`	`}`
`263`		`- return m.Config.Digest.Hex(), nil`
	`263`	`+ return m.Config.Digest.Encoded(), nil`
`264`	`264`	`}`
`265`	`265`
`266`	`266`	`// CanChangeLayerCompression returns true if we can compress/decompress layers with mimeType in the current image`
Original file line number	Diff line number	Diff line change
`@@ -256,5 +256,5 @@ func (ref ociReference) blobPath(digest digest.Digest, sharedBlobDir string) (st`
`256`	`256`	`} else {`
`257`	`257`	`blobDir = filepath.Join(ref.dir, imgspecv1.ImageBlobsDir)`
`258`	`258`	`}`
`259`		`- return filepath.Join(blobDir, digest.Algorithm().String(), digest.Hex()), nil`
	`259`	`+ return filepath.Join(blobDir, digest.Algorithm().String(), digest.Encoded()), nil`
`260`	`260`	`}`
Original file line number	Diff line number	Diff line change
`@@ -164,7 +164,7 @@ func (d *ostreeImageDestination) PutBlobWithOptions(ctx context.Context, stream`
`164`	`164`	`return private.UploadedBlob{}, err`
`165`	`165`	`}`
`166`	`166`
`167`		`- hash := blobDigest.Hex()`
	`167`	`+ hash := blobDigest.Encoded()`
`168`	`168`	`d.blobs[hash] = &blobToImport{Size: size, Digest: blobDigest, BlobPath: blobPath}`
`169`	`169`	`return private.UploadedBlob{Digest: blobDigest, Size: size}, nil`
`170`	`170`	`}`
`@@ -282,8 +282,8 @@ func generateTarSplitMetadata(output *bytes.Buffer, file string) (digest.Digest,`
`282`	`282`	`func (d ostreeImageDestination) importBlob(selinuxHnd C.struct_selabel_handle, repo otbuiltin.Repo, blob blobToImport) error {`
`283`	`283`	`// TODO: This can take quite some time, and should ideally be cancellable using a context.Context.`
`284`	`284`
`285`		`- ostreeBranch := fmt.Sprintf("ociimage/%s", blob.Digest.Hex())`
`286`		`- destinationPath := filepath.Join(d.tmpDirPath, blob.Digest.Hex(), "root")`
	`285`	`+ ostreeBranch := fmt.Sprintf("ociimage/%s", blob.Digest.Encoded())`
	`286`	`+ destinationPath := filepath.Join(d.tmpDirPath, blob.Digest.Encoded(), "root")`
`287`	`287`	`if err := ensureDirectoryExists(destinationPath); err != nil {`
`288`	`288`	`return err`
`289`	`289`	`}`
`@@ -323,7 +323,7 @@ func (d ostreeImageDestination) importBlob(selinuxHnd C.struct_selabel_handle,`
`323`	`323`	`}`
`324`	`324`
`325`	`325`	`func (d ostreeImageDestination) importConfig(repo otbuiltin.Repo, blob *blobToImport) error {`
`326`		`- ostreeBranch := fmt.Sprintf("ociimage/%s", blob.Digest.Hex())`
	`326`	`+ ostreeBranch := fmt.Sprintf("ociimage/%s", blob.Digest.Encoded())`
`327`	`327`	`destinationPath := filepath.Dir(blob.BlobPath)`
`328`	`328`
`329`	`329`	`return d.ostreeCommit(repo, ostreeBranch, destinationPath, []string{fmt.Sprintf("docker.size=%d", blob.Size)})`
`@@ -348,10 +348,10 @@ func (d *ostreeImageDestination) TryReusingBlobWithOptions(ctx context.Context,`
`348`	`348`	`d.repo = repo`
`349`	`349`	`}`
`350`	`350`
`351`		`- if err := info.Digest.Validate(); err != nil { // digest.Digest.Hex() panics on failure, so validate explicitly.`
	`351`	`+ if err := info.Digest.Validate(); err != nil { // digest.Digest.Encoded() panics on failure, so validate explicitly.`
`352`	`352`	`return false, private.ReusedBlob{}, err`
`353`	`353`	`}`
`354`		`- branch := fmt.Sprintf("ociimage/%s", info.Digest.Hex())`
	`354`	`+ branch := fmt.Sprintf("ociimage/%s", info.Digest.Encoded())`
`355`	`355`
`356`	`356`	`found, data, err := readMetadata(d.repo, branch, "docker.uncompressed_digest")`
`357`	`357`	`if err != nil \|\| !found {`
`@@ -479,7 +479,7 @@ func (d *ostreeImageDestination) Commit(context.Context, types.UnparsedImage) er`
`479`	`479`	`if err := layer.Digest.Validate(); err != nil { // digest.Digest.Encoded() panics on failure, so validate explicitly.`
`480`	`480`	`return err`
`481`	`481`	`}`
`482`		`- hash := layer.Digest.Hex()`
	`482`	`+ hash := layer.Digest.Encoded()`
`483`	`483`	`if err = checkLayer(hash); err != nil {`
`484`	`484`	`return err`
`485`	`485`	`}`
`@@ -488,7 +488,7 @@ func (d *ostreeImageDestination) Commit(context.Context, types.UnparsedImage) er`
`488`	`488`	`if err := layer.BlobSum.Validate(); err != nil { // digest.Digest.Encoded() panics on failure, so validate explicitly.`
`489`	`489`	`return err`
`490`	`490`	`}`
`491`		`- hash := layer.BlobSum.Hex()`
	`491`	`+ hash := layer.BlobSum.Encoded()`
`492`	`492`	`if err = checkLayer(hash); err != nil {`
`493`	`493`	`return err`
`494`	`494`	`}`