Add option to sign multiple artifacts with the same key and certificate

README.md

@@ -136,8 +136,8 @@ usage: sigstore sign [-h] [--identity-token TOKEN] [--oidc-client-id ID]
                      [--oidc-disable-ambient-providers] [--oidc-issuer URL]
                      [--no-default-files] [--signature FILE]
                      [--certificate FILE] [--bundle FILE]
-                     [--output-directory DIR] [--overwrite] [--staging]
-                     [--rekor-url URL] [--rekor-root-pubkey FILE]
+                     [--output-directory DIR] [--overwrite] [--single-cert]
+                     [--staging] [--rekor-url URL] [--rekor-root-pubkey FILE]
                      [--fulcio-url URL] [--ctfe FILE]
                      FILE [FILE ...]
 
@@ -179,6 +179,9 @@ Output options:
   --overwrite           Overwrite preexisting signature and certificate
                         outputs, if present (default: False)
 
+  --single-cert         Use a single signing certificate and key to sign 
+                        multiple artifacts (default: False)
+
 Sigstore instance options:
   --staging             Use sigstore's staging instances, instead of the
                         default production instances. This option will be

sigstore/_cli.py

@@ -329,6 +329,12 @@ def _parser() -> argparse.ArgumentParser:
         default=_boolify_env("SIGSTORE_OVERWRITE"),
         help="Overwrite preexisting signature and certificate outputs, if present",
     )
+    output_options.add_argument(
+        "--single-cert",
+        action="store_true",
+        default=_boolify_env("SIGSTORE_SINGLE_CERT"),
+        help="Use a single signing certificate and key to sign multiple artifacts",
+    )
 
     instance_options = sign.add_argument_group("Sigstore instance options")
     _add_shared_instance_options(instance_options)
@@ -614,10 +620,10 @@ def _sign(args: argparse.Namespace) -> None:
     # Select the signer to use.
     if args.staging:
         logger.debug("sign: staging instances requested")
-        signer = Signer.staging()
+        signer = Signer.staging(single_certificate=args.single_cert)
         args.oidc_issuer = STAGING_OAUTH_ISSUER_URL
     elif args.fulcio_url == DEFAULT_FULCIO_URL and args.rekor_url == DEFAULT_REKOR_URL:
-        signer = Signer.production()
+        signer = Signer.production(single_certificate=args.single_cert)
     else:
         # Assume "production" keys if none are given as arguments
         updater = TrustUpdater.production()
@@ -636,6 +642,7 @@ def _sign(args: argparse.Namespace) -> None:
         signer = Signer(
             fulcio=FulcioClient(args.fulcio_url),
             rekor=RekorClient(args.rekor_url, rekor_keyring, ct_keyring),
+            single_certificate=args.single_cert,
         )
 
     # The order of precedence is as follows:

sigstore/sign.py

@@ -82,7 +82,7 @@ class Signer:
     The primary API for signing operations.
     """
 
-    def __init__(self, *, fulcio: FulcioClient, rekor: RekorClient):
+    def __init__(self, *, fulcio: FulcioClient, rekor: RekorClient, single_certificate: bool=False):
         """
         Create a new `Signer`.
 
@@ -91,27 +91,79 @@ def __init__(self, *, fulcio: FulcioClient, rekor: RekorClient):
 
         `rekor` is a `RekorClient` capable of connecting to a Rekor instance
         and creating transparency log entries.
+
+        `single_certificate` indicates if a single private key and signing certificate
+        should be generated to sign multiple artifacts.
         """
         self._fulcio = fulcio
         self._rekor = rekor
+        self._single_certificate = single_certificate
+        self._signing_certificate = None
+        self._private_key = None
 
     @classmethod
-    def production(cls) -> Signer:
+    def production(cls, single_certificate=False) -> Signer:
         """
         Return a `Signer` instance configured against Sigstore's production-level services.
         """
         updater = TrustUpdater.production()
         rekor = RekorClient.production(updater)
-        return cls(fulcio=FulcioClient.production(), rekor=rekor)
+        return cls(fulcio=FulcioClient.production(), rekor=rekor, single_certificate=single_certificate)
 
     @classmethod
-    def staging(cls) -> Signer:
+    def staging(cls, single_certificate=False) -> Signer:
         """
         Return a `Signer` instance configured against Sigstore's staging-level services.
         """
         updater = TrustUpdater.staging()
         rekor = RekorClient.staging(updater)
-        return cls(fulcio=FulcioClient.staging(), rekor=rekor)
+        return cls(fulcio=FulcioClient.staging(), rekor=rekor, single_certificate=single_certificate)
+
+    @property
+    def private_key(self) -> ec.EllipticCurvePrivateKey:
+        """Get or generate a signing key."""
+        if not self._single_certificate or self._private_key is None:
+            self._private_key = ec.generate_private_key(ec.SECP384R1())
+
+        return self._private_key
+
+    @property
+    def signing_cert(self) -> FulcioCertificateSigningResponse:
+        """Get or request a signing certificate for Fulcio."""
+        def get_signing_cert(identity_token: str) -> FulcioCertificateSigningResponse:
+            if not self._single_certificate or self._signing_certificate is None:
+                logger.debug("Retrieving signed certificate...")
+
+                oidc_identity = Identity(identity_token)
+                logger.debug(f"cert-identity: {oidc_identity.proof}")
+                logger.debug(f"cert-oidc-issuer: {oidc_identity.issuer}")
+
+                # Build an X.509 Certificiate Signing Request
+                builder = (
+                    x509.CertificateSigningRequestBuilder()
+                    .subject_name(
+                        x509.Name(
+                            [
+                                x509.NameAttribute(NameOID.EMAIL_ADDRESS, oidc_identity.proof),
+                            ]
+                        )
+                    )
+                    .add_extension(
+                        x509.BasicConstraints(ca=False, path_length=None),
+                        critical=True,
+                    )
+                )
+                certificate_request = builder.sign(self.private_key, hashes.SHA256())
+
+                certificate_response = self._fulcio.signing_cert.post(
+                    certificate_request, identity_token
+                )
+
+                self._signing_certificate = certificate_response
+            return self._signing_certificate
+
+        return get_signing_cert
+
 
     def sign(
         self,
@@ -122,34 +174,10 @@ def sign(
         input_digest = sha256_streaming(input_)
 
         logger.debug("Generating ephemeral keys...")
-        private_key = ec.generate_private_key(ec.SECP384R1())
+        private_key = self.private_key
 
         logger.debug("Retrieving signed certificate...")
-
-        oidc_identity = Identity(identity_token)
-        logger.debug(f"cert-identity: {oidc_identity.proof}")
-        logger.debug(f"cert-oidc-issuer: {oidc_identity.issuer}")
-
-        # Build an X.509 Certificiate Signing Request
-        builder = (
-            x509.CertificateSigningRequestBuilder()
-            .subject_name(
-                x509.Name(
-                    [
-                        x509.NameAttribute(NameOID.EMAIL_ADDRESS, oidc_identity.proof),
-                    ]
-                )
-            )
-            .add_extension(
-                x509.BasicConstraints(ca=False, path_length=None),
-                critical=True,
-            )
-        )
-        certificate_request = builder.sign(private_key, hashes.SHA256())
-
-        certificate_response = self._fulcio.signing_cert.post(
-            certificate_request, identity_token
-        )
+        certificate_response = self.signing_cert(identity_token)
 
         # TODO(alex): Retrieve the public key via TUF
         #