Used ED25519ph algorithm with sign/verify commands

Signed-off-by: Riccardo Schirone <riccardo.schirone@trailofbits.com>

Author: ret2libc

cmd/cosign/cli/sign/sign.go

@@ -138,7 +138,7 @@ func SignCmd(ro *options.RootOptions, ko options.KeyOpts, signOpts options.SignO
 	ctx, cancel := context.WithTimeout(context.Background(), ro.Timeout)
 	defer cancel()
 
-	sv, err := SignerFromKeyOpts(ctx, signOpts.Cert, signOpts.CertChain, ko)
+	sv, err := signerFromKeyOptsWithSVOpts(ctx, "", "", ko, signature.WithED25519ph())
 	if err != nil {
 		return fmt.Errorf("getting signer: %w", err)
 	}
@@ -261,7 +261,12 @@ func signDigest(ctx context.Context, digest name.Digest, payload []byte, ko opti
 		if err != nil {
 			return err
 		}
-		s = irekor.NewSigner(s, rClient)
+
+		hashAlgorithm, err := getHashAlgorithmFromSignerVerifier(sv)
+		if err != nil {
+			return err
+		}
+		s = irekor.NewSigner(s, rClient, hashAlgorithm)
 	}
 
 	ociSig, _, err := s.Sign(ctx, bytes.NewReader(payload))

cmd/cosign/cli/verify/verify.go

@@ -218,7 +218,7 @@ func (c *VerifyCommand) Exec(ctx context.Context, images []string) (err error) {
 	var pubKey signature.Verifier
 	switch {
 	case keyRef != "":
-		pubKey, err = sigs.PublicKeyFromKeyRefWithHashAlgo(ctx, keyRef, c.HashAlgorithm)
+		pubKey, err = sigs.PublicKeyFromKeyRefWithOpts(ctx, keyRef, c.HashAlgorithm, signature.WithED25519ph())
 		if err != nil {
 			return fmt.Errorf("loading public key: %w", err)
 		}
@@ -251,7 +251,7 @@ func (c *VerifyCommand) Exec(ctx context.Context, images []string) (err error) {
 			if err != nil {
 				return fmt.Errorf("getting Fulcio intermediates: %w", err)
 			}
-			pubKey, err = cosign.ValidateAndUnpackCert(cert, co)
+			pubKey, err = cosign.ValidateAndUnpackCertWithOpts(cert, co, cosign.WithSignerVerifierOptions(signature.WithED25519ph()))
 			if err != nil {
 				return err
 			}
@@ -261,7 +261,7 @@ func (c *VerifyCommand) Exec(ctx context.Context, images []string) (err error) {
 			if err != nil {
 				return err
 			}
-			pubKey, err = cosign.ValidateAndUnpackCertWithChain(cert, chain, co)
+			pubKey, err = cosign.ValidateAndUnpackCertWithOpts(cert, co, cosign.WithChain(chain), cosign.WithSignerVerifierOptions(signature.WithED25519ph()))
 			if err != nil {
 				return err
 			}

internal/pkg/cosign/rekor/signer.go

@@ -17,7 +17,6 @@ package rekor
 import (
 	"context"
 	"crypto"
-	"crypto/sha256"
 	"encoding/base64"
 	"fmt"
 	"io"
@@ -49,7 +48,8 @@ func uploadToTlog(rekorBytes []byte, rClient *client.Rekor, upload tlogUploadFn)
 type signerWrapper struct {
 	inner cosign.Signer
 
-	rClient *client.Rekor
+	rClient       *client.Rekor
+	hashAlgorithm crypto.Hash
 }
 
 var _ cosign.Signer = (*signerWrapper)(nil)
@@ -91,11 +91,11 @@ func (rs *signerWrapper) Sign(ctx context.Context, payload io.Reader) (oci.Signa
 	}
 
 	bundle, err := uploadToTlog(rekorBytes, rs.rClient, func(r *client.Rekor, b []byte) (*models.LogEntryAnon, error) {
-		checkSum := sha256.New()
+		checkSum := cosignv1.NewCryptoNamedHash(rs.hashAlgorithm)
 		if _, err := checkSum.Write(payloadBytes); err != nil {
 			return nil, err
 		}
-		return cosignv1.TLogUpload(ctx, r, sigBytes, checkSum, b)
+		return cosignv1.TLogUploadWithCustomHash(ctx, r, sigBytes, checkSum, b)
 	})
 	if err != nil {
 		return nil, nil, err
@@ -110,9 +110,10 @@ func (rs *signerWrapper) Sign(ctx context.Context, payload io.Reader) (oci.Signa
 }
 
 // NewSigner returns a `cosign.Signer` which uploads the signature to Rekor
-func NewSigner(inner cosign.Signer, rClient *client.Rekor) cosign.Signer {
+func NewSigner(inner cosign.Signer, rClient *client.Rekor, hashAlgorithm crypto.Hash) cosign.Signer {
 	return &signerWrapper{
-		inner:   inner,
-		rClient: rClient,
+		inner:         inner,
+		rClient:       rClient,
+		hashAlgorithm: hashAlgorithm,
 	}
 }

internal/pkg/cosign/rekor/signer_test.go

@@ -56,7 +56,7 @@ func TestSigner(t *testing.T) {
 		}}},
 	}
 
-	testSigner := NewSigner(payloadSigner, &mClient)
+	testSigner := NewSigner(payloadSigner, &mClient, crypto.SHA256)
 
 	testPayload := "test payload"
 

pkg/cosign/verify.go

@@ -165,6 +165,33 @@ type CheckOpts struct {
 	ExperimentalOCI11 bool
 }
 
+type validateCertOpts struct {
+	chain  []*x509.Certificate
+	svOpts []signature.SignerVerifierOption
+}
+
+type ValidateAndUnpackCertOption func(*validateCertOpts)
+
+func WithChain(chain []*x509.Certificate) ValidateAndUnpackCertOption {
+	return func(o *validateCertOpts) {
+		o.chain = chain
+	}
+}
+
+func WithSignerVerifierOptions(svOpts ...signature.SignerVerifierOption) ValidateAndUnpackCertOption {
+	return func(o *validateCertOpts) {
+		o.svOpts = svOpts
+	}
+}
+
+func makeValidateAndUnpackCertOpts(opts ...ValidateAndUnpackCertOption) *validateCertOpts {
+	o := &validateCertOpts{}
+	for _, opt := range opts {
+		opt(o)
+	}
+	return o
+}
+
 // This is a substitutable signature verification function that can be used for verifying
 // attestations of blobs.
 type signatureVerificationFn func(
@@ -223,11 +250,35 @@ func ValidateAndUnpackCert(cert *x509.Certificate, co *CheckOpts) (signature.Ver
 	return ValidateAndUnpackCertWithOpts(cert, co)
 }
 
+// ValidateAndUnpackCertWithChain creates a Verifier from a certificate. Verifies that the certificate
+// chains up to the provided root. Chain should start with the parent of the certificate and end with the root.
+// Optionally verifies the subject and issuer of the certificate.
+func ValidateAndUnpackCertWithChain(cert *x509.Certificate, chain []*x509.Certificate, co *CheckOpts) (signature.Verifier, error) {
+	return ValidateAndUnpackCertWithOpts(cert, co, WithChain(chain))
+}
+
 // ValidateAndUnpackCertWithOpts creates a Verifier from a certificate. Verifies that the certificate
 // chains up to a trusted root. Optionally verifies the subject and issuer of the certificate.
-// Accept SignerVerifier options to customize the verifier.
-func ValidateAndUnpackCertWithOpts(cert *x509.Certificate, co *CheckOpts, svOpts ...signature.SignerVerifierOption) (signature.Verifier, error) {
-	verifier, err := signature.LoadVerifierWithOpts(cert.PublicKey, crypto.SHA256, svOpts...)
+// Accept chain and signerVerifierOptions as optional parameters.
+func ValidateAndUnpackCertWithOpts(cert *x509.Certificate, co *CheckOpts, opts ...ValidateAndUnpackCertOption) (signature.Verifier, error) {
+	o := makeValidateAndUnpackCertOpts(opts...)
+
+	if o.chain != nil {
+		if len(o.chain) == 0 {
+			return nil, errors.New("no chain provided to validate certificate")
+		}
+		rootPool := x509.NewCertPool()
+		rootPool.AddCert(o.chain[len(o.chain)-1])
+		co.RootCerts = rootPool
+
+		subPool := x509.NewCertPool()
+		for _, c := range o.chain[:len(o.chain)-1] {
+			subPool.AddCert(c)
+		}
+		co.IntermediateCerts = subPool
+	}
+
+	verifier, err := signature.LoadVerifierWithOpts(cert.PublicKey, crypto.SHA256, o.svOpts...)
 	if err != nil {
 		return nil, fmt.Errorf("invalid certificate found on signature: %w", err)
 	}
@@ -411,26 +462,6 @@ func validateCertExtensions(ce CertExtensions, co *CheckOpts) error {
 	return nil
 }
 
-// ValidateAndUnpackCertWithChain creates a Verifier from a certificate. Verifies that the certificate
-// chains up to the provided root. Chain should start with the parent of the certificate and end with the root.
-// Optionally verifies the subject and issuer of the certificate.
-func ValidateAndUnpackCertWithChain(cert *x509.Certificate, chain []*x509.Certificate, co *CheckOpts) (signature.Verifier, error) {
-	if len(chain) == 0 {
-		return nil, errors.New("no chain provided to validate certificate")
-	}
-	rootPool := x509.NewCertPool()
-	rootPool.AddCert(chain[len(chain)-1])
-	co.RootCerts = rootPool
-
-	subPool := x509.NewCertPool()
-	for _, c := range chain[:len(chain)-1] {
-		subPool.AddCert(c)
-	}
-	co.IntermediateCerts = subPool
-
-	return ValidateAndUnpackCert(cert, co)
-}
-
 func tlogValidateEntry(ctx context.Context, client *client.Rekor, rekorPubKeys *TrustedTransparencyLogPubKeys,
 	sig oci.Signature, pem []byte) (*models.LogEntryAnon, error) {
 	b64sig, err := sig.Base64Signature()
@@ -741,7 +772,7 @@ func verifyInternal(ctx context.Context, sig oci.Signature, h v1.Hash,
 				co.IntermediateCerts = pool
 			}
 		}
-		verifier, err = ValidateAndUnpackCertWithOpts(cert, co, svOpts...)
+		verifier, err = ValidateAndUnpackCertWithOpts(cert, co, WithSignerVerifierOptions(svOpts...))
 		if err != nil {
 			return false, err
 		}
@@ -824,7 +855,7 @@ func VerifyBlobSignature(ctx context.Context, sig oci.Signature, co *CheckOpts)
 
 // VerifyImageSignature verifies a signature
 func VerifyImageSignature(ctx context.Context, sig oci.Signature, h v1.Hash, co *CheckOpts) (bundleVerified bool, err error) {
-	return verifyInternal(ctx, sig, h, verifyOCISignature, co)
+	return verifyInternal(ctx, sig, h, verifyOCISignature, co, signature.WithED25519ph())
 }
 
 func loadSignatureFromFile(ctx context.Context, sigRef string, signedImgRef name.Reference, co *CheckOpts) (oci.Signatures, error) {