Add Policy WithKey() for verifing content you know is signed with a key

docs/verification.md

@@ -83,14 +83,18 @@ Next, we'll create a verifier with some options, which will enable SCT verificat
 	}
 ```
 
-Then, we need to prepare the expected artifact digest and certificate identity. Note that these options may be omitted, but only if the options `WithoutIdentitiesUnsafe`/`WithoutArtifactUnsafe` are provided. This is a failsafe to ensure that the caller is aware that simply verifying the bundle is not enough, you must also verify the contents of the bundle against a specific identity and artifact.
+Then, we need to prepare the expected artifact digest. Note that this option has an alternative option `WithoutArtifactUnsafe`. This is a failsafe to ensure that the caller is aware that simply verifying the bundle is not enough, you must also verify the contents of the bundle against a specific artifact.
 
 ```go
 	digest, err := hex.DecodeString("76176ffa33808b54602c7c35de5c6e9a4deb96066dba6533f50ac234f4f1f4c6b3527515dc17c06fbe2860030f410eee69ea20079bd3a2c6f3dcf3b329b10751")
 	if err != nil {
 		panic(err)
 	}
+```
+
+In this case, we also need to prepare the expected certificate identity. Note that this option has an alternative option `WithoutIdentitiesUnsafe`. This is a failsafe to ensure that the caller is aware that simply verifying the bundle is not enough, you must also verify the contents of the bundle against a specific identity. If your bundle was signed with a key, and thus does not have a certificate identity, a better choice is to use the `WithKey` option.
 
+```go
 	certID, err := verify.NewShortCertificateIdentity("https://token.actions.githubusercontent.com", "", "", "^https://github.com/sigstore/sigstore-js/")
 	if err != nil {
 		panic(err)

pkg/verify/certificate_identity.go

@@ -172,9 +172,5 @@ func (c CertificateIdentity) Verify(actualCert certificate.Summary) error {
 	if err = c.SubjectAlternativeName.Verify(actualCert); err != nil {
 		return err
 	}
-	if err = certificate.CompareExtensions(c.Extensions, actualCert.Extensions); err != nil {
-		return err
-	}
-
-	return nil
+	return certificate.CompareExtensions(c.Extensions, actualCert.Extensions)
 }

pkg/verify/signed_entity.go

@@ -271,6 +271,7 @@ func (pc PolicyBuilder) BuildConfig() (*PolicyConfig, error) {
 type PolicyConfig struct {
 	weDoNotExpectAnArtifact bool
 	weDoNotExpectIdentities bool
+	weExpectSigningKey      bool
 	certificateIdentities   CertificateIdentities
 	verifyArtifact          bool
 	artifact                io.Reader
@@ -317,6 +318,12 @@ func (p *PolicyConfig) WeExpectIdentities() bool {
 	return !p.weDoNotExpectIdentities
 }
 
+// WeExpectSigningKey returns true if we expect the SignedEntity to be signed
+// with a key and not a certificate.
+func (p *PolicyConfig) WeExpectSigningKey() bool {
+	return p.weExpectSigningKey
+}
+
 func NewPolicy(artifactOpt ArtifactPolicyOption, options ...PolicyOption) PolicyBuilder {
 	return PolicyBuilder{artifactPolicy: artifactOpt, policyOptions: options}
 }
@@ -365,12 +372,29 @@ func WithCertificateIdentity(identity CertificateIdentity) PolicyOption {
 		if p.weDoNotExpectIdentities {
 			return errors.New("can't use WithCertificateIdentity while using WithoutIdentitiesUnsafe")
 		}
+		if p.weExpectSigningKey {
+			return errors.New("can't use WithCertificateIdentity while using WithKey")
+		}
 
 		p.certificateIdentities = append(p.certificateIdentities, identity)
 		return nil
 	}
 }
 
+// WithKey allows the caller of Verify to require the SignedEntity being
+// verified was signed with a key and not a certificate.
+func WithKey() PolicyOption {
+	return func(p *PolicyConfig) error {
+		if len(p.certificateIdentities) > 0 {
+			return errors.New("can't use WithKey while using WithCertificateIdentity")
+		}
+
+		p.weExpectSigningKey = true
+		p.weDoNotExpectIdentities = true
+		return nil
+	}
+}
+
 // WithoutArtifactUnsafe allows the caller of Verify to skip checking whether
 // the SignedEntity was created from, or references, an artifact.
 //
@@ -495,6 +519,10 @@ func (v *SignedEntityVerifier) Verify(entity SignedEntity, pb PolicyBuilder) (*V
 	// If the bundle was signed with a long-lived key, and does not have a Fulcio certificate,
 	// then skip the certificate verification steps
 	if leafCert := verificationContent.GetCertificate(); leafCert != nil {
+		if policy.WeExpectSigningKey() {
+			return nil, errors.New("expected key signature, not certificate")
+		}
+
 		signedWithCertificate = true
 
 		// From spec:

pkg/verify/signed_entity_test.go

@@ -243,6 +243,16 @@ func TestVerifyPolicyOptionErors(t *testing.T) {
 	assert.True(t, p.WeExpectAnArtifact())
 	assert.False(t, p.WeExpectIdentities())
 
+	// ---
+
+	noArtifactKeyHappyPath := verify.NewPolicy(verify.WithoutArtifactUnsafe(), verify.WithKey())
+	p, err = noArtifactKeyHappyPath.BuildConfig()
+	assert.Nil(t, err)
+	assert.NotNil(t, p)
+
+	assert.True(t, p.WeExpectSigningKey())
+	assert.False(t, p.WeExpectIdentities())
+
 	// let's exercise the different error cases!
 	// 1. can't combine WithoutArtifactUnsafe with other Artifact options
 	// technically a hack that requires casting but better safe than sorry:
@@ -279,6 +289,11 @@ func TestVerifyPolicyOptionErors(t *testing.T) {
 
 	_, err = verifier.Verify(entity, badIdentityPolicyCombo)
 	assert.NotNil(t, err)
+
+	// 5. can't expect certificate and key signature
+	badIdentityPolicyCombo2 := verify.NewPolicy(verify.WithoutArtifactUnsafe(), verify.WithCertificateIdentity(goodCertID), verify.WithKey())
+	_, err = badIdentityPolicyCombo2.BuildConfig()
+	assert.NotNil(t, err)
 }
 
 func TestEntitySignedByPublicGoodWithCertificateIdentityVerifiesSuccessfully(t *testing.T) {