Find all valid entries in verify-blob

.github/workflows/github-oidc.yaml

@@ -49,3 +49,8 @@ jobs:
           set -e
           # Build and publish an image.
           make sign-keyless-container
+
+      - name: Build and sign a blob
+        run: |
+          set -e
+          make sign-blob-experimental

.gitignore

@@ -27,3 +27,5 @@
 
 bin*
 dist/
+
+test/verify-experimental*

cmd/cosign/cli/verify/verify_blob.go

@@ -44,6 +44,7 @@ import (
 	sigs "github.com/sigstore/cosign/pkg/signature"
 
 	ctypes "github.com/sigstore/cosign/pkg/types"
+	"github.com/sigstore/rekor/pkg/generated/client"
 	"github.com/sigstore/rekor/pkg/generated/models"
 	"github.com/sigstore/rekor/pkg/types"
 	hashedrekord "github.com/sigstore/rekor/pkg/types/hashedrekord/v0.0.1"
@@ -161,44 +162,74 @@ func VerifyBlobCmd(ctx context.Context, ko sign.KeyOpts, certRef, certEmail, cer
 		if len(uuids) == 0 {
 			return errors.New("could not find a tlog entry for provided blob")
 		}
+		return verifySigByUUID(ctx, ko, rClient, certEmail, certOidcIssuer, sig, b64sig, uuids, blobBytes)
+	}
+
+	// Use the DSSE verifier if the payload is a DSSE with the In-Toto format.
+	if isIntotoDSSE(blobBytes) {
+		verifier = dsse.WrapVerifier(verifier)
+	}
+
+	// verify the signature
+	if err := verifier.VerifySignature(bytes.NewReader([]byte(sig)), bytes.NewReader(blobBytes)); err != nil {
+		return err
+	}
+
+	// verify the rekor entry
+	if err := verifyRekorEntry(ctx, ko, verifier, cert, b64sig, blobBytes); err != nil {
+		return err
+	}
+
+	fmt.Fprintln(os.Stderr, "Verified OK")
+	return nil
+}
 
-		tlogEntry, err := cosign.GetTlogEntry(ctx, rClient, uuids[0])
+func verifySigByUUID(ctx context.Context, ko sign.KeyOpts, rClient *client.Rekor, certEmail, certOidcIssuer, sig, b64sig string, uuids []string, blobBytes []byte) error {
+	var validSigExists bool
+	for _, u := range uuids {
+		tlogEntry, err := cosign.GetTlogEntry(ctx, rClient, u)
 		if err != nil {
-			return err
+			continue
 		}
 
 		certs, err := extractCerts(tlogEntry)
 		if err != nil {
-			return err
+			continue
 		}
 
 		co := &cosign.CheckOpts{
 			RootCerts:      fulcio.GetRoots(),
 			CertEmail:      certEmail,
 			CertOidcIssuer: certOidcIssuer,
 		}
-		cert = certs[0]
-		verifier, err = cosign.ValidateAndUnpackCert(cert, co)
+		cert := certs[0]
+		verifier, err := cosign.ValidateAndUnpackCert(cert, co)
 		if err != nil {
-			return err
+			continue
+		}
+		// Use the DSSE verifier if the payload is a DSSE with the In-Toto format.
+		if isIntotoDSSE(blobBytes) {
+			verifier = dsse.WrapVerifier(verifier)
+		}
+		// verify the signature
+		if err := verifier.VerifySignature(bytes.NewReader([]byte(sig)), bytes.NewReader(blobBytes)); err != nil {
+			continue
 		}
-	}
 
-	// Use the DSSE verifier if the payload is a DSSE with the In-Toto format.
-	if isIntotoDSSE(blobBytes) {
-		verifier = dsse.WrapVerifier(verifier)
+		// verify the rekor entry
+		if err := verifyRekorEntry(ctx, ko, verifier, cert, b64sig, blobBytes); err != nil {
+			continue
+		}
+		validSigExists = true
 	}
+	if !validSigExists {
+		fmt.Fprintln(os.Stderr, `WARNING: No valid entries were found in rekor to verify this blob.
 
-	// verify the signature
-	if err := verifier.VerifySignature(bytes.NewReader([]byte(sig)), bytes.NewReader(blobBytes)); err != nil {
-		return err
-	}
+Transparency log support for blobs is experimental, and occasionally an entry isn't found even if one exists.
 
-	// verify the rekor entry
-	if err := verifyRekorEntry(ctx, ko, verifier, cert, b64sig, blobBytes); err != nil {
-		return err
+We recommend requesting the certificate/signature from the original signer of this blob and manually verifying with cosign verify-blob --cert [cert] --signature [signature].`)
+		return fmt.Errorf("could not find a valid tlog entry for provided blob, found %d invalid entries", len(uuids))
 	}
-
 	fmt.Fprintln(os.Stderr, "Verified OK")
 	return nil
 }

test/ci.mk

@@ -31,3 +31,7 @@ sign-keyless-sget:
 
 .PHONY: sign-keyless-container
 sign-keyless-container: ko sign-keyless-cosign sign-keyless-cosigned sign-keyless-sget
+
+.PHONY: sign-blob-experimental
+sign-blob-experimental:
+	./sign_blob_test.sh

test/sign_blob_test.sh

@@ -0,0 +1,75 @@
+#!/usr/bin/env bash
+#
+# Copyright 2021 The Sigstore Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# This test checks that verify-blob will iterate over all entries and check for at least one valid entry before erroring out
+# This is to prevent verify-blob from only checking the most recent entry, which could result
+# in a "denial of service" type attack if someone signs a piece of software
+# with their own certificate which doesn't chain up to Sigstore
+
+set -ex
+
+export COSIGN_EXPERIMENTAL=1
+
+echo "Creating a unique blob"
+BLOB=verify-experimental-blob
+date > $BLOB
+
+echo "Sign the blob with cosign first and upload to rekor"
+SIG=$(cosign sign-blob $BLOB)
+
+echo "Verifying ..."
+cosign verify-blob -signature $SIG $BLOB
+
+# Now, sign the blob with a self-signed certificate and upload to rekor
+SIG_FILE=verify-experimental-signature
+openssl dgst -sha256 -sign testdata/test_blob_private_key -out $SIG_FILE $BLOB
+openssl dgst -sha256 -verify testdata/test_blob_public_key -signature $SIG_FILE $BLOB
+
+SHA256HASH=$(sha256sum $BLOB |  cut -f1 -d' ')
+
+SIGNATURE=$(cat $SIG_FILE | base64)
+echo "Signature: $SIGNATURE"
+
+CERT=$(cat testdata/test_blob_cert.pem | base64)
+echo "Cert: $CERT"
+
+JSON_BODY_FILE=verify-experimental-blob-http-body.json
+cat <<EOF > $JSON_BODY_FILE
+{
+    "apiVersion": "0.0.1",
+    "spec": {
+        "data": {
+            "hash": {
+                "algorithm": "sha256",
+                "value": "$SHA256HASH"
+            }
+        },
+        "signature": {
+            "content": "$SIGNATURE",
+            "publicKey": {
+                "content": "$CERT"
+            }
+        }
+    },
+    "kind": "hashedrekord"
+}
+EOF
+
+curl -X POST https://rekor.sigstore.dev/api/v1/log/entries -H 'Content-Type: application/json'  -d @$JSON_BODY_FILE
+
+# Verifying should still work
+echo "Verifying ..."
+cosign verify-blob --signature $SIG $BLOB

test/testdata/test_blob_cert.pem

@@ -0,0 +1,13 @@
+-----BEGIN CERTIFICATE-----
+MIIB9jCCAZwCCQDmJAPXiurv9jAKBggqhkjOPQQDAjCBgjELMAkGA1UEBhMCVVMx
+CzAJBgNVBAgMAkNBMQswCQYDVQQHDAJTRjEQMA4GA1UECgwHQ29tcGFueTENMAsG
+A1UECwwEVW5pdDEYMBYGA1UEAwwPd3d3LmV4YW1wbGUub3JnMR4wHAYJKoZIhvcN
+AQkBFg9lbWFpbEBlbWFpbC5jb20wHhcNMjIwMzI4MTgwNDIwWhcNMjIwNDI3MTgw
+NDIwWjCBgjELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMQswCQYDVQQHDAJTRjEQ
+MA4GA1UECgwHQ29tcGFueTENMAsGA1UECwwEVW5pdDEYMBYGA1UEAwwPd3d3LmV4
+YW1wbGUub3JnMR4wHAYJKoZIhvcNAQkBFg9lbWFpbEBlbWFpbC5jb20wWTATBgcq
+hkjOPQIBBggqhkjOPQMBBwNCAAR1Q4hB1jtagrdsVxygtDa/rli00U7n/1I/NSw8
+yoMRQ+MOAjRhg3gtcV0tha34L6150qJirQHbfocsao8X6wFmMAoGCCqGSM49BAMC
+A0gAMEUCIQDkZ4ZmFOK2Ze+znScge1JidTRzxNxCLbrdfc5yEJia2QIgCEjIY6Zo
+QUwiyuC3ll5a9GDc4swfguZq9kOFX9bD0XQ=
+-----END CERTIFICATE-----

test/testdata/test_blob_private_key

@@ -0,0 +1,8 @@
+-----BEGIN EC PARAMETERS-----
+BggqhkjOPQMBBw==
+-----END EC PARAMETERS-----
+-----BEGIN EC PRIVATE KEY-----
+MHcCAQEEIMJRdxVQ7AH6z1BlE9ucEMSAQhY431IFHe0oVCH7Iw49oAoGCCqGSM49
+AwEHoUQDQgAEdUOIQdY7WoK3bFccoLQ2v65YtNFO5/9SPzUsPMqDEUPjDgI0YYN4
+LXFdLYWt+C+tedKiYq0B236HLGqPF+sBZg==
+-----END EC PRIVATE KEY-----

test/testdata/test_blob_public_key

@@ -0,0 +1,4 @@
+-----BEGIN PUBLIC KEY-----
+MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEdUOIQdY7WoK3bFccoLQ2v65YtNFO
+5/9SPzUsPMqDEUPjDgI0YYN4LXFdLYWt+C+tedKiYq0B236HLGqPF+sBZg==
+-----END PUBLIC KEY-----