image/manifest: Add DigestWithAlgorithm function

Add a new `manifest.DigestWithAlgorithm` function that
allows computing the digest of a manifest using a specified algorithm
(e.g., SHA256, SHA512) while properly handling v2s1 signed manifest
signature stripping.

This addresses the need for skopeo's `--manifest-digest` flag to support
different digest algorithms while correctly handling all manifest types,
particularly Docker v2s1 signed manifests that require signature
stripping before digest computation.

Signed-off-by: Lokesh Mandvekar <[email protected]>

Author: lsm5

image/internal/manifest/manifest.go

@@ -107,25 +107,45 @@ func GuessMIMEType(manifest []byte) string {
 	return ""
 }
 
-// Digest returns the a digest of a docker manifest, with any necessary implied transformations like stripping v1s1 signatures.
-// This is publicly visible as c/image/manifest.Digest.
-func Digest(manifest []byte) (digest.Digest, error) {
+// stripManifestSignature strips v1s1 signatures from a manifest if present.
+// Returns the manifest bytes (either the original or the unsigned payload).
+func stripManifestSignature(manifest []byte) ([]byte, error) {
 	if GuessMIMEType(manifest) == DockerV2Schema1SignedMediaType {
 		sig, err := libtrust.ParsePrettySignature(manifest, "signatures")
 		if err != nil {
-			return "", err
+			return nil, err
 		}
 		manifest, err = sig.Payload()
 		if err != nil {
 			// Coverage: This should never happen, libtrust's Payload() can fail only if joseBase64UrlDecode() fails, on a string
 			// that libtrust itself has josebase64UrlEncode()d
-			return "", err
+			return nil, err
 		}
 	}
+	return manifest, nil
+}
 
+// Digest returns the a digest of a docker manifest, with any necessary implied transformations like stripping v1s1 signatures.
+// This is publicly visible as c/image/manifest.Digest.
+func Digest(manifest []byte) (digest.Digest, error) {
+	manifest, err := stripManifestSignature(manifest)
+	if err != nil {
+		return "", err
+	}
 	return digest.FromBytes(manifest), nil
 }
 
+// DigestWithAlgorithm returns the digest of a docker manifest using the specified algorithm,
+// with any necessary implied transformations like stripping v1s1 signatures.
+// This is publicly visible as c/image/manifest.DigestWithAlgorithm.
+func DigestWithAlgorithm(manifest []byte, algo digest.Algorithm) (digest.Digest, error) {
+	manifest, err := stripManifestSignature(manifest)
+	if err != nil {
+		return "", err
+	}
+	return algo.FromBytes(manifest), nil
+}
+
 // MatchesDigest returns true iff the manifest matches expectedDigest.
 // Error may be set if this returns false.
 // Note that this is not doing ConstantTimeCompare; by the time we get here, the cryptographic signature must already have been verified,

image/internal/manifest/manifest_test.go

@@ -73,6 +73,65 @@ func TestDigest(t *testing.T) {
 	assert.Equal(t, digest.Digest(digestSha256EmptyTar), actualDigest)
 }
 
+func TestDigestWithAlgorithm(t *testing.T) {
+	sha256Cases := []struct {
+		path           string
+		expectedDigest digest.Digest
+	}{
+		{"v2s2.manifest.json", TestDockerV2S2ManifestDigest},
+		{"v2s1.manifest.json", TestDockerV2S1ManifestDigest},
+		{"v2s1-unsigned.manifest.json", TestDockerV2S1UnsignedManifestDigest},
+	}
+	for _, c := range sha256Cases {
+		manifest, err := os.ReadFile(filepath.Join("testdata", c.path))
+		require.NoError(t, err)
+		actualDigest, err := DigestWithAlgorithm(manifest, digest.SHA256)
+		require.NoError(t, err)
+		assert.Equal(t, c.expectedDigest, actualDigest, c.path)
+		defaultDigest, err := Digest(manifest)
+		require.NoError(t, err)
+		assert.Equal(t, defaultDigest, actualDigest, c.path)
+	}
+
+	// Test with SHA512
+	for _, c := range sha256Cases {
+		manifest, err := os.ReadFile(filepath.Join("testdata", c.path))
+		require.NoError(t, err)
+		actualDigest, err := DigestWithAlgorithm(manifest, digest.SHA512)
+		require.NoError(t, err)
+		assert.Equal(t, digest.SHA512, actualDigest.Algorithm())
+		sha256Digest, err := DigestWithAlgorithm(manifest, digest.SHA256)
+		require.NoError(t, err)
+		assert.NotEqual(t, sha256Digest, actualDigest, c.path)
+	}
+
+	// Test that v2s1 signed manifest signature stripping works with different algorithms
+	manifest, err := os.ReadFile("testdata/v2s1.manifest.json")
+	require.NoError(t, err)
+	unsignedManifest, err := os.ReadFile("testdata/v2s1-unsigned.manifest.json")
+	require.NoError(t, err)
+
+	// Both signed and unsigned should produce the same digest for each algorithm
+	for _, algo := range []digest.Algorithm{digest.SHA256, digest.SHA512} {
+		signedDigest, err := DigestWithAlgorithm(manifest, algo)
+		require.NoError(t, err)
+		unsignedDigest, err := DigestWithAlgorithm(unsignedManifest, algo)
+		require.NoError(t, err)
+		assert.Equal(t, unsignedDigest, signedDigest, "algorithm: %s", algo)
+	}
+
+	manifest, err = os.ReadFile("testdata/v2s1-invalid-signatures.manifest.json")
+	require.NoError(t, err)
+	_, err = DigestWithAlgorithm(manifest, digest.SHA256)
+	assert.Error(t, err)
+	_, err = DigestWithAlgorithm(manifest, digest.SHA512)
+	assert.Error(t, err)
+
+	actualDigest, err := DigestWithAlgorithm([]byte{}, digest.SHA256)
+	require.NoError(t, err)
+	assert.Equal(t, digest.Digest(digestSha256EmptyTar), actualDigest)
+}
+
 func TestMatchesDigest(t *testing.T) {
 	cases := []struct {
 		path           string

image/manifest/manifest.go

@@ -113,6 +113,12 @@ func Digest(manifestBlob []byte) (digest.Digest, error) {
 	return manifest.Digest(manifestBlob)
 }
 
+// DigestWithAlgorithm returns the digest of a docker manifest using the specified algorithm,
+// with any necessary implied transformations like stripping v1s1 signatures.
+func DigestWithAlgorithm(manifestBlob []byte, algo digest.Algorithm) (digest.Digest, error) {
+	return manifest.DigestWithAlgorithm(manifestBlob, algo)
+}
+
 // MatchesDigest returns true iff the manifest matches expectedDigest.
 // Error may be set if this returns false.
 // Note that this is not doing ConstantTimeCompare; by the time we get here, the cryptographic signature must already have been verified,