sigstore 0.2.2 → 0.3.0

data/lib/sigstore/verifier.rb

@@ -15,6 +15,7 @@
 # limitations under the License.
 
 require_relative "trusted_root"
+require_relative "policy"
 require_relative "internal/keyring"
 require_relative "internal/merkle"
 require_relative "internal/set"
@@ -54,20 +55,36 @@ module Sigstore
       for_trust_root(trust_root:)
     end
 
-    def verify(input:, policy:, offline:)
+    # +key+ is an out-of-band public key (an OpenSSL::PKey) used to verify "managed"
+    # (bring-your-own-key) bundles, which carry a public key hint instead of a Fulcio
+    # certificate. It must be supplied for, and only for, such bundles.
+    def verify(input:, policy:, offline:, key: nil)
       # First, establish a time for the signature. This timestamp is required to validate the certificate chain,
       # so this step comes first.
 
       bundle = input.sbundle
       materials = bundle.verification_material
 
+      if bundle.key_based?
+        unless key
+          return VerificationFailure.new("bundle is signed with a managed key but no verifying key was provided")
+        end
+      elsif key
+        return VerificationFailure.new("a verifying key was provided but the bundle contains a signing certificate")
+      end
+
       # 1)
       # If the verification policy uses the Timestamping Service, the Verifier MUST verify the timestamping response
       # using the Timestamping Service root key material, as described in Spec: Timestamping Service, with the raw bytes
       # of the signature as the timestamped data. The Verifier MUST then extract a timestamp from the timestamping
       # response. If verification or timestamp parsing fails, the Verifier MUST abort.
 
-      timestamps = extract_timestamp_from_verification_data(materials.timestamp_verification_data) || []
+      # Only resolve the data the timestamp binds to (and enforce its constraints) when
+      # there is a timestamp to verify; absent timestamp data there is nothing to bind.
+      timestamp_data = materials.timestamp_verification_data
+      timestamps = extract_timestamp_from_verification_data(
+        timestamp_data, timestamp_data && timestamped_data(bundle)
+      ) || []
 
       # 2)
       # If the verification policy uses timestamps from the Transparency Service, the Verifier MUST verify the signature
@@ -79,7 +96,7 @@ module Sigstore
       begin
         # TODO: should this instead be an input to the verify method?
         # See https://docs.google.com/document/d/1kbhK2qyPPk8SLavHzYSDM8-Ueul9_oxIMVFuWMWKz0E/edit?disco=AAABQVV-gT0
-        entry = find_rekor_entry(bundle, input.hashed_input, offline:)
+        entry = find_rekor_entry(bundle, input.hashed_input, offline:, signing_key: key)
       rescue Sigstore::Error::MissingRekorEntry
         return VerificationFailure.new("Rekor entry not found")
       else
@@ -95,7 +112,16 @@ module Sigstore
 
       Internal::SET.verify_set(keyring: @rekor_keyring, entry:) if entry.inclusion_promise
 
-      timestamps << Time.at(entry.integrated_time).utc
+      # Rekor v1 entries carry an integrated time signed by the log; Rekor v2 (tiled)
+      # entries do not, and rely on a Timestamping Service response for the signing time.
+      integrated_time = entry.integrated_time
+      timestamps << Time.at(integrated_time).utc if integrated_time&.positive?
+
+      if timestamps.empty?
+        return VerificationFailure.new(
+          "no trusted signing time available (no timestamp authority response and no log integrated time)"
+        )
+      end
 
       # 3)
       # The Verifier MUST perform certification path validation (RFC 5280 §6) of the certificate chain with the
@@ -104,44 +130,60 @@ module Sigstore
       # timestamp from the Timestamping Service. If a timestamp from the Transparency Service is available, the Verifier
       # MUST perform path validation using the timestamp from the Transparency Service. If both are available, the
       # Verifier performs path validation twice. If either fails, verification fails.
+      #
+      # Steps 3-5 are certificate-specific: a managed-key bundle has no certificate to do
+      # path validation, SCT verification, or identity-policy checks against, so they are
+      # skipped. The signature (and its binding to the Rekor entry) is still verified below
+      # against the supplied key.
 
-      chains = timestamps.map do |ts|
-        chain, err = Internal::X509.validate_chain(@fulcio_cert_chains, bundle.leaf_certificate, ts)
-        return err if err
-
-        chain
+      if bundle.key_based? && !policy.is_a?(Policy::UnsafeNoOp)
+        logger.warn do
+          "ignoring identity policy #{policy.class} for managed-key bundle: managed-key " \
+            "verification trusts the supplied key, not a certificate identity"
+        end
       end
 
-      chains.uniq! { |chain| chain.map(&:to_der) }
-      unless chains.size == 1
-        raise "expected exactly one certificate chain, got #{chains.size} chains:\n" +
-              chains.map do |chain|
-                chain.map(&:to_text).join("\n")
-              end.join("\n\n")
-      end
+      unless bundle.key_based?
+        chains = timestamps.map do |ts|
+          chain, err = Internal::X509.validate_chain(@fulcio_cert_chains, bundle.leaf_certificate, ts)
+          return err if err
 
-      # 4)
-      # Unless performing online verification (see §Alternative Workflows), the Verifier MUST extract the
-      # SignedCertificateTimestamp embedded in the leaf certificate, and verify it as in RFC 9162 §8.1.3,
-      # using the verification key from the Certificate Transparency Log.
-      chain = chains.first
-      if (result = verify_scts(bundle.leaf_certificate, chain)) && !result.verified?
-        return result
-      end
+          chain
+        end
 
-      # 5)
-      # The Verifier MUST then check the certificate against the verification policy.
+        chains.uniq! { |chain| chain.map(&:to_der) }
+        unless chains.size == 1
+          raise "expected exactly one certificate chain, got #{chains.size} chains:\n" +
+                chains.map do |chain|
+                  chain.map(&:to_text).join("\n")
+                end.join("\n\n")
+        end
 
-      usage_ext = bundle.leaf_certificate.extension(Internal::X509::Extension::KeyUsage)
-      return VerificationFailure.new("Key usage is not of type `digital signature`") unless usage_ext.digital_signature
+        # 4)
+        # Unless performing online verification (see §Alternative Workflows), the Verifier MUST extract the
+        # SignedCertificateTimestamp embedded in the leaf certificate, and verify it as in RFC 9162 §8.1.3,
+        # using the verification key from the Certificate Transparency Log.
+        chain = chains.first
+        if (result = verify_scts(bundle.leaf_certificate, chain)) && !result.verified?
+          return result
+        end
 
-      extended_key_usage = bundle.leaf_certificate.extension(Internal::X509::Extension::ExtendedKeyUsage)
-      unless extended_key_usage.code_signing?
-        return VerificationFailure.new("Extended key usage is not of type `code signing`")
-      end
+        # 5)
+        # The Verifier MUST then check the certificate against the verification policy.
 
-      policy_check = policy.verify(bundle.leaf_certificate)
-      return policy_check unless policy_check.verified?
+        usage_ext = bundle.leaf_certificate.extension(Internal::X509::Extension::KeyUsage)
+        unless usage_ext.digital_signature
+          return VerificationFailure.new("Key usage is not of type `digital signature`")
+        end
+
+        extended_key_usage = bundle.leaf_certificate.extension(Internal::X509::Extension::ExtendedKeyUsage)
+        unless extended_key_usage.code_signing?
+          return VerificationFailure.new("Extended key usage is not of type `code signing`")
+        end
+
+        policy_check = policy.verify(bundle.leaf_certificate)
+        return policy_check unless policy_check.verified?
+      end
 
       # 6)
       # By this point, the Verifier has already verified the signature by the Transparency Service (§Establishing a Time
@@ -156,10 +198,17 @@ module Sigstore
       #  * The key or certificate from the parsed body is the same as in the input certificate.
       #  * The “subject” of the parsed body matches the artifact.
 
-      signing_key = bundle.leaf_certificate.public_key
+      signing_key = bundle.key_based? ? key : bundle.leaf_certificate.public_key
 
       case bundle.content
       when :message_signature
+        # The messageDigest is an unauthenticated hint, but when present it must be
+        # consistent with the artifact being verified.
+        message_digest = bundle.message_signature.message_digest
+        if message_digest && !message_digest.digest.empty? && message_digest.digest != input.hashed_input.digest
+          return VerificationFailure.new("message digest does not match the artifact")
+        end
+
         verified = verify_raw(signing_key, bundle.message_signature.signature, input.hashed_input.digest)
         return VerificationFailure.new("Signature verification failed") unless verified
       when :dsse_envelope
@@ -173,7 +222,9 @@ module Sigstore
           rescue JSON::ParserError
             raise Error::InvalidBundle, "invalid JSON for in-toto statement in DSSE payload"
           end
-          verify_in_toto(input, in_toto)
+          if (result = verify_in_toto(input, in_toto))
+            return result
+          end
         else
           raise Sigstore::Error::Unimplemented,
                 "unsupported DSSE payload type: #{bundle.dsse_envelope.payloadType.inspect}"
@@ -201,12 +252,9 @@ module Sigstore
     end
 
     def verify_dsse(dsse_envelope, public_key)
-      payload = dsse_envelope.payload
-      payload_type = dsse_envelope.payloadType
       signatures = dsse_envelope.signatures
 
-      pae = "DSSEv1 #{payload_type.bytesize} #{payload_type} " \
-            "#{payload.bytesize} #{payload}".b
+      pae = dsse_pae(dsse_envelope)
 
       raise Error::InvalidBundle, "DSSEv1 envelope missing signatures" if signatures.empty?
 
@@ -215,26 +263,32 @@ module Sigstore
       end
     end
 
+    def dsse_pae(dsse_envelope)
+      Internal::Util.dsse_pae(dsse_envelope.payloadType, dsse_envelope.payload)
+    end
+
     def verify_in_toto(input, in_toto_payload)
-      type = in_toto_payload.fetch("_type")
+      type = in_toto_payload["_type"]
       raise Error::InvalidBundle, "Expected in-toto statement, got #{type.inspect}" unless type == "https://in-toto.io/Statement/v1"
 
-      subject = in_toto_payload.fetch("subject")
-      raise Error::InvalidBundle, "Expected in-toto statement with subject" unless subject && subject.size == 1
-
-      subject = subject.first
-      digest = subject.fetch("digest")
-      raise Error::InvalidBundle, "Expected in-toto statement with digest" if !digest || digest.empty?
+      subjects = in_toto_payload["subject"]
+      raise Error::InvalidBundle, "Expected in-toto statement with subject" if !subjects || subjects.empty?
 
+      expected_algorithm = Internal::Util.hash_algorithm_name(input.hashed_input.algorithm)
       expected_hexdigest = Internal::Util.hex_encode(input.hashed_input.digest)
-      digest.each do |name, value|
-        next if expected_hexdigest == value
 
-        return VerificationFailure.new(
-          "in-toto subject does not match for #{input.hashed_input.algorithm} of #{subject.fetch("name")}: " \
-          "expected #{name} to be #{value}, got #{expected_hexdigest}"
-        )
-      end
+      matched = subjects.map do |subject|
+        digest = subject["digest"]
+        raise Error::InvalidBundle, "Expected in-toto statement with digest" if !digest || digest.empty?
+
+        digest[expected_algorithm] == expected_hexdigest
+      end.any?
+
+      return if matched
+
+      VerificationFailure.new(
+        "None of in-toto subjects matches artifact for #{expected_algorithm}: #{expected_hexdigest}"
+      )
     end
 
     public
@@ -318,13 +372,22 @@ module Sigstore
           raise Error::Unimplemented, "only x509_entry and precert_entry supported, given #{sct.entry_type.inspect}"
         end
 
-      [sct.version, 0, sct.timestamp, sct.entry_type, signed_entry, 0].pack(<<~PACK)
+      [
+        sct.version,
+        0,
+        sct.timestamp,
+        sct.entry_type,
+        signed_entry,
+        sct.extensions_bytes&.bytesize.to_i,
+        sct.extensions_bytes
+      ].pack(<<~PACK)
         C # version
         C # signature_type
         Q> # timestamp
         n # entry_type
         a#{signed_entry.bytesize} # signed_entry
         n # extensions length
+        a#{sct.extensions_bytes&.bytesize.to_i} # extension
       PACK
     end
 
@@ -336,7 +399,24 @@ module Sigstore
       issuer
     end
 
-    def extract_timestamp_from_verification_data(data)
+    # The raw bytes a Timestamping Service response is expected to be computed over: the
+    # signature in the bundle (RFC 3161 message imprint covers these bytes).
+    def timestamped_data(bundle)
+      case bundle.content
+      when :message_signature
+        bundle.message_signature.signature
+      when :dsse_envelope
+        # The timestamp binds to a single signature; with more than one envelope
+        # signature it is ambiguous which one the imprint covers, so refuse to bind
+        # only the first (mirrors the v2 consistency path, which requires exactly one).
+        signatures = bundle.dsse_envelope.signatures
+        raise Error::InvalidBundle, "expected exactly one DSSE signature to bind a timestamp to" if signatures.size > 1
+
+        signatures.first&.sig
+      end
+    end
+
+    def extract_timestamp_from_verification_data(data, signed_data)
       # TODO: allow requiring a verified timestamp
       unless data
         logger.debug { "no timestamp verification data" }
@@ -352,6 +432,13 @@ module Sigstore
         return
       end
 
+      # The timestamp MUST be computed over the bundle signature (the RFC 3161 message
+      # imprint covers it). Without signature bytes to bind it to we cannot perform that
+      # binding, so fail closed rather than accept a timestamp over arbitrary data.
+      if signed_data.nil? || signed_data.empty?
+        raise Error::InvalidTimestamp, "no signature available to bind the timestamp to"
+      end
+
       authorities = @timestamp_authorities.map do |ta|
         store = OpenSSL::X509::Store.new
         chain = ta.cert_chain.certificates.map do |cert|
@@ -368,19 +455,37 @@ module Sigstore
         resp = OpenSSL::Timestamp::Response.new(ts.signed_timestamp)
 
         req = OpenSSL::Timestamp::Request.new
-        req.cert_requested = !resp.token.certificates.empty?
-        # TODO: verify the message imprint against the signature in the bundle
+        req.cert_requested = !(resp.token.certificates.nil? || resp.token.certificates.empty?)
         req.message_imprint = resp.token_info.message_imprint
         req.algorithm = resp.token_info.algorithm
-        req.policy_id = resp.token_info.policy_id
-        req.nonce = resp.token_info.nonce
+        req.policy_id = resp.token_info.policy_id if resp.token_info.policy_id
+        req.nonce = resp.token_info.nonce if resp.token_info.nonce
         req.version = resp.token_info.version
 
-        # TODO: verify the hashed message in the message imprint
-        # against the signature in the bundle
+        # The message imprint must cover the bundle's signature; otherwise the timestamp
+        # attests to unrelated data and must be rejected.
+        expected_imprint =
+          begin
+            OpenSSL::Digest.new(resp.token_info.algorithm).digest(signed_data)
+          rescue StandardError => e
+            raise Error::InvalidTimestamp,
+                  "unsupported timestamp digest algorithm #{resp.token_info.algorithm.inspect}: #{e}"
+          end
+        unless resp.token_info.message_imprint == expected_imprint
+          raise Error::InvalidTimestamp, "timestamp message imprint does not match the bundle signature"
+        end
+
+        verified = authorities.any? do |ta, chain, store|
+          # The timestamp must fall within the window the trusted root says this
+          # Timestamping Service was valid for, independent of cert-chain validity.
+          gen_time = resp.token_info.gen_time
+          valid_for = ta.valid_for
+          if valid_for
+            next false if valid_for.start && gen_time < valid_for.start.to_time
+            next false if valid_for.end && gen_time > valid_for.end.to_time
+          end
 
-        authorities.any? do |ta, chain, store|
-          store.time = resp.token_info.gen_time
+          store.time = gen_time
 
           resp.verify(req, store, chain) &&
             (logger.debug do
@@ -389,13 +494,14 @@ module Sigstore
         rescue OpenSSL::Timestamp::TimestampError => e
           logger.error { "timestamp verification failed (#{e})" }
           false
-        end ||
-          raise(OpenSSL::Timestamp::TimestampError, "timestamp verification failed")
+        end
+        raise Error::InvalidTimestamp, "timestamp verification failed" unless verified
+
         resp.token_info.gen_time
       end
     end
 
-    def find_rekor_entry(bundle, hashed_input, offline:)
+    def find_rekor_entry(bundle, hashed_input, offline:, signing_key: nil)
       raise Error::InvalidBundle, "multiple tlog entries" if bundle.verification_material.tlog_entries.size > 1
 
       rekor_entry = bundle.verification_material.tlog_entries&.first
@@ -407,7 +513,25 @@ module Sigstore
           "has_inclusion_promise=#{has_inclusion_promise} has_inclusion_proof=#{has_inclusion_proof}"
       end
 
-      expected_entry = bundle.expected_tlog_entry(hashed_input)
+      # Rekor v2 (tiled) entries always ship an inclusion proof in the bundle and have no
+      # online retrieval API; detect them from the embedded entry and verify consistency
+      # against the bundle directly, rather than reconstructing a v1 canonicalized body.
+      if rekor_entry && (v2_body = rekor_v2_body(rekor_entry))
+        # A v2 entry has no integrated time and no online retrieval API, so the only
+        # binding to the log is the Merkle inclusion proof and its checkpoint signature.
+        # Require them here so the v2 path can never reach the offline warn-and-skip
+        # branch in #verify (even though #validate_version! also enforces this for
+        # non-0.1 bundles): without a checkpoint there is nothing to verify against.
+        unless rekor_entry.inclusion_proof&.checkpoint
+          raise Error::InvalidBundle, "Rekor v2 entry must contain an inclusion proof with a checkpoint"
+        end
+
+        verify_rekor_v2_entry_consistency(bundle, hashed_input, v2_body, signing_key:)
+        return rekor_entry
+      end
+
+      verifier_pem = signing_key&.public_to_pem || bundle.leaf_certificate&.to_pem
+      expected_entry = bundle.expected_tlog_entry(hashed_input, verifier_pem)
 
       entry = if offline
                 logger.debug { "Offline verification, skipping rekor" }
@@ -424,11 +548,7 @@ module Sigstore
 
       logger.debug { "Found rekor entry: #{entry}" }
 
-      actual_body = begin
-        JSON.parse(entry.canonicalized_body)
-      rescue JSON::ParserError
-        raise Error::InvalidRekorEntry, "invalid JSON in rekor entry canonicalized_body"
-      end
+      actual_body = parse_canonicalized_body(entry)
       if bundle.dsse_envelope?
         # since the hash is over the uncanonicalized envelope, we need to remove it
         #
@@ -458,6 +578,96 @@ module Sigstore
       entry
     end
 
+    # Parsed canonicalized body if this is a Rekor v2 (hashedrekord 0.0.2) entry, else nil.
+    # A body that is not JSON returns nil so the v1 reconstruction path handles it.
+    def rekor_v2_body(entry)
+      body = parse_canonicalized_body(entry)
+      body if body.values_at("kind", "apiVersion") == ["hashedrekord", "0.0.2"]
+    rescue Error::InvalidRekorEntry
+      nil
+    end
+
+    def parse_canonicalized_body(entry)
+      JSON.parse(entry.canonicalized_body)
+    rescue JSON::ParserError
+      raise Error::InvalidRekorEntry, "invalid JSON in rekor entry canonicalized_body"
+    end
+
+    # Verify that a Rekor v2 hashedrekord (0.0.2) entry corresponds to the artifact,
+    # signature, and signing certificate in the bundle. The Merkle inclusion proof and
+    # checkpoint signature bind this body to the log; #find_rekor_entry has already
+    # confirmed both are present, and #verify performs that verification. Here we bind
+    # the body to the inputs we are verifying.
+    def verify_rekor_v2_entry_consistency(bundle, hashed_input, body, signing_key: nil)
+      spec = body.dig("spec", "hashedRekordV002")
+      raise Error::InvalidRekorEntry, "missing hashedRekordV002 spec" unless spec
+
+      logged_algorithm = spec.dig("data", "algorithm")
+      logged_digest = decode_base64_field(spec.dig("data", "digest"), "data.digest")
+      logged_signature = decode_base64_field(spec.dig("signature", "content"), "signature.content")
+
+      if bundle.key_based?
+        logged_key = decode_base64_field(
+          spec.dig("signature", "verifier", "publicKey", "rawBytes"),
+          "signature.verifier.publicKey.rawBytes"
+        )
+        unless logged_key == signing_key.public_to_der
+          raise Error::InvalidRekorEntry, "rekor entry public key does not match the supplied key"
+        end
+      else
+        logged_cert = decode_base64_field(
+          spec.dig("signature", "verifier", "x509Certificate", "rawBytes"),
+          "signature.verifier.x509Certificate.rawBytes"
+        )
+        unless logged_cert == bundle.leaf_certificate.to_der
+          raise Error::InvalidRekorEntry, "rekor entry certificate does not match the bundle certificate"
+        end
+      end
+
+      expected_algorithm, expected_digest, expected_signature =
+        rekor_v2_expected_data_and_signature(bundle, hashed_input)
+
+      unless logged_algorithm == expected_algorithm
+        raise Error::InvalidRekorEntry,
+              "rekor entry data algorithm #{logged_algorithm.inspect} does not match " \
+              "expected #{expected_algorithm.inspect}"
+      end
+      unless logged_digest == expected_digest
+        raise Error::InvalidRekorEntry, "rekor entry data digest does not match the artifact"
+      end
+      return if logged_signature == expected_signature
+
+      raise Error::InvalidRekorEntry, "rekor entry signature does not match the bundle signature"
+    end
+
+    # The expected [data.algorithm, data.digest, signature] for the bundle, named to match
+    # the Rekor v2 `hashedRekordV002` spec fields (algorithm uses the proto enum name).
+    def rekor_v2_expected_data_and_signature(bundle, hashed_input)
+      case bundle.content
+      when :message_signature
+        [hashed_input.algorithm.name, hashed_input.digest, bundle.message_signature.signature]
+      when :dsse_envelope
+        # "hashedrekord-over-DSSE": the logged data is SHA2-256 of PAE(payloadType, payload)
+        # and the logged signature is the (single) DSSE envelope signature.
+        signatures = bundle.dsse_envelope.signatures
+        unless signatures.size == 1
+          raise Error::InvalidRekorEntry, "expected exactly one DSSE signature for a Rekor v2 entry"
+        end
+
+        ["SHA2_256", OpenSSL::Digest::SHA256.digest(dsse_pae(bundle.dsse_envelope)), signatures.first.sig]
+      else
+        raise Error::InvalidBundle, "expected either message_signature or dsse_envelope"
+      end
+    end
+
+    def decode_base64_field(value, name)
+      raise Error::InvalidRekorEntry, "missing #{name} in rekor entry" unless value
+
+      Internal::Util.base64_decode(value)
+    rescue ArgumentError
+      raise Error::InvalidRekorEntry, "invalid base64 in #{name} of rekor entry"
+    end
+
     def diff_json(a, b) # rubocop:disable Naming/MethodParameterName
       return nil if a == b
 

data/lib/sigstore/version.rb

@@ -15,5 +15,6 @@
 # limitations under the License.
 
 module Sigstore
-  VERSION = "0.2.2"
+  VERSION = "0.3.0"
+  USER_AGENT = "sigstore-ruby/#{VERSION}".freeze
 end

data/lib/sigstore.rb

@@ -43,5 +43,6 @@ module Sigstore
   end
 end
 
+require_relative "sigstore/signing_config"
 require_relative "sigstore/verifier"
 require_relative "sigstore/signer"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sigstore
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - The Sigstore Authors
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-10-25 00:00:00.000000000 Z
+date: 2026-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logger
@@ -39,20 +39,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: protobug_in_toto_attestation_protos
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
 - !ruby/object:Gem::Dependency
   name: protobug_sigstore_protos
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: 0.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: 0.2.0
 - !ruby/object:Gem::Dependency
   name: uri
   requirement: !ruby/object:Gem::Requirement
@@ -98,6 +112,7 @@ files:
 - lib/sigstore/rekor/checkpoint.rb
 - lib/sigstore/rekor/client.rb
 - lib/sigstore/signer.rb
+- lib/sigstore/signing_config.rb
 - lib/sigstore/trusted_root.rb
 - lib/sigstore/tuf.rb
 - lib/sigstore/tuf/config.rb