sigstore 0.2.3 → 0.3.0

data/lib/sigstore/internal/key.rb

@@ -21,7 +21,7 @@ module Sigstore
     class Key
       include Loggable
 
-      def self.from_key_details(key_details, key_bytes)
+      def self.from_key_details(key_details, key_bytes, key_id: nil)
         case key_details
         when Common::V1::PublicKeyDetails::PKIX_ECDSA_P256_SHA_256
           key_type = "ecdsa"
@@ -29,15 +29,34 @@ module Sigstore
         when Common::V1::PublicKeyDetails::PKCS1_RSA_PKCS1V5
           key_type = "rsa"
           key_schema = "rsa-pkcs1v15-sha256"
+        when Common::V1::PublicKeyDetails::PKIX_ED25519
+          # Rekor v2 (tiled) logs sign checkpoints with an Ed25519 key. The raw_bytes
+          # are a DER-encoded SubjectPublicKeyInfo, not the bare 32-byte key. The log id
+          # is a C2SP signed-note key hash over the log's name, not a digest of the key
+          # bytes, so it cannot be recomputed from the key alone; the trusted root must
+          # declare it. Without it the key could never match a real entry, so refuse to
+          # register an unusable key.
+          unless key_id
+            raise Error::MissingLogId,
+                  "Ed25519 (Rekor v2) key has no declared log id; the trusted root must provide log_id.key_id"
+          end
+
+          return ED25519.new("ed25519", "ed25519", ED25519.public_key_from_spki_der(key_bytes), key_id:)
         else
           # Skip unrecognized key types instead of raising an error.
           # This allows the library to work with newer trusted roots that include
-          # key types we don't yet support (e.g., PKIX_ED25519 for Rekor v2).
+          # key types we don't yet support.
           logger.warn { "Skipping unrecognized key type: #{key_details}" }
           return nil
         end
 
-        read(key_type, key_schema, key_bytes, key_id: OpenSSL::Digest::SHA256.hexdigest(key_bytes))
+        # The transparency log declares its own log id in the trusted root; prefer it so
+        # the keyring is keyed the same way entries reference the log. For ECDSA/RSA keys
+        # the log id is a plain SHA-256 of the key bytes, so it can be recomputed when the
+        # trusted root omits it.
+        key_id ||= OpenSSL::Digest::SHA256.hexdigest(key_bytes)
+
+        read(key_type, key_schema, key_bytes, key_id:)
       end
 
       def self.read(key_type, schema, key_bytes, key_id: nil)
@@ -141,8 +160,27 @@ module Sigstore
       end
 
       class ED25519 < Key
+        # jruby-openssl cannot parse or verify Ed25519 keys, so on JRuby we hold a
+        # java.security.PublicKey instead of an OpenSSL::PKey and route loading and
+        # verification through the JDK (mirroring the java.security path in X509).
+        JAVA_ED25519 = RUBY_ENGINE == "jruby"
+
+        # Load an Ed25519 public key from a DER-encoded SubjectPublicKeyInfo.
+        def self.public_key_from_spki_der(der)
+          if JAVA_ED25519
+            spec = java.security.spec.X509EncodedKeySpec.new(der.to_java_bytes)
+            java.security.KeyFactory.getInstance("Ed25519").generatePublic(spec)
+          else
+            OpenSSL::PKey.read(der)
+          end
+        end
+
+        # +raw+ is the bare 32-byte public key, not a SubjectPublicKeyInfo.
         def self.pkey_from_der(raw)
-          if OpenSSL::PKey.respond_to?(:new_raw_public_key)
+          if JAVA_ED25519
+            # Wrap the raw key in the fixed Ed25519 SubjectPublicKeyInfo prefix.
+            public_key_from_spki_der(["302a300506032b6570032100"].pack("H*") + raw)
+          elsif OpenSSL::PKey.respond_to?(:new_raw_public_key)
             OpenSSL::PKey.new_raw_public_key("ed25519", raw)
           else
             pem = <<~PEM
@@ -156,27 +194,54 @@ module Sigstore
 
         def initialize(...)
           super
-          unless @key_type == "ed25519"
-            raise ArgumentError,
-                  "key_type must be ed25519, given #{@key_type}"
-          end
-          unless @key.is_a?(OpenSSL::PKey::PKey) && @key.oid == "ED25519"
-            raise ArgumentError,
-                  "key must be an OpenSSL::PKey::PKey with oid ED25519, is #{@key.inspect}"
-          end
-          raise ArgumentError, "schema must be #{schema}" unless @schema == schema
+          raise ArgumentError, "key_type must be ed25519, given #{@key_type}" unless @key_type == "ed25519"
 
-          case @schema
-          when "ed25519"
-            # supported
-          else
-            raise ArgumentError, "Unsupported schema #{schema}"
+          if JAVA_ED25519
+            unless @key.respond_to?(:getAlgorithm) && %w[Ed25519 EdDSA].include?(@key.getAlgorithm)
+              raise ArgumentError, "key must be a java Ed25519 PublicKey, is #{@key.inspect}"
+            end
+          elsif !(@key.is_a?(OpenSSL::PKey::PKey) && @key.oid == "ED25519")
+            raise ArgumentError, "key must be an OpenSSL::PKey::PKey with oid ED25519, is #{@key.inspect}"
           end
+
+          raise ArgumentError, "Unsupported schema #{schema}" unless @schema == "ed25519"
         end
 
         def verify(_algo, signature, data)
+          return java_verify(signature, data) if JAVA_ED25519
+
           super(nil, signature, data)
         end
+
+        # Ed25519 keys do not implement #to_der; the SubjectPublicKeyInfo DER is the
+        # public encoding.
+        def to_der
+          return String.from_java_bytes(@key.getEncoded).b if JAVA_ED25519
+
+          @key.public_to_der
+        end
+
+        def public_to_der
+          to_der
+        end
+
+        def to_pem
+          return super unless JAVA_ED25519
+
+          "-----BEGIN PUBLIC KEY-----\n#{Internal::Util.base64_encode(to_der)}\n-----END PUBLIC KEY-----\n"
+        end
+
+        private
+
+        def java_verify(signature, data)
+          sig = java.security.Signature.getInstance("Ed25519")
+          sig.initVerify(@key)
+          sig.update(data.to_java_bytes)
+          sig.verify(signature.to_java_bytes)
+        rescue java.security.GeneralSecurityException => e
+          logger.debug { "Ed25519 verification failed: #{e}" }
+          false
+        end
       end
     end
   end

data/lib/sigstore/internal/util.rb

@@ -47,6 +47,13 @@ module Sigstore
       def base64_decode(string)
         string.unpack1("m0")
       end
+
+      # The DSSE Pre-Authentication Encoding over a payload and its type, as
+      # defined by the DSSE v1 spec. This is the byte string that is signed (and
+      # verified) for a DSSE envelope.
+      def dsse_pae(payload_type, payload)
+        "DSSEv1 #{payload_type.bytesize} #{payload_type} #{payload.bytesize} #{payload}".b
+      end
     end
   end
 end

data/lib/sigstore/internal/x509.rb

@@ -111,7 +111,12 @@ module Sigstore
         end
 
         def tbs_certificate_der
-          if openssl.respond_to?(:tbs_bytes)
+          # jruby-openssl < 0.19.0's X509::Certificate#tbs_bytes does not preserve
+          # extension order after reassigning extensions, yielding the wrong TBS and
+          # breaking SCT verification. Fall through to the manual ASN.1 path there,
+          # which manipulates the DER directly and is engine-independent.
+          if openssl.respond_to?(:tbs_bytes) &&
+             (RUBY_ENGINE != "jruby" || Gem::Version.new(JOpenSSL::VERSION) >= Gem::Version.new("0.19.0"))
             cert = openssl.dup
             short_name = Extension::PrecertificateSignedCertificateTimestamps.oid.short_name
             cert.extensions = cert.extensions.reject! do |ext|

data/lib/sigstore/models.rb

@@ -92,6 +92,16 @@ module Sigstore
         raise Error::InvalidVerificationInput, "bundle with message_signature requires an artifact"
       end
 
+      @hashed_input = self.class.hashed_input_for(artifact)
+
+      freeze
+    end
+
+    # Derive the SHA2-256 HashOutput the verifier checks signatures and Rekor
+    # entries against, from any of the Artifact oneof variants: the raw bytes
+    # (:artifact), a "sha256:"-prefixed URI (:artifact_uri), or a typed digest
+    # (:artifact_digest, protobuf-specs v0.5.1+).
+    def self.hashed_input_for(artifact)
       case artifact.data
       when :artifact_uri
         unless artifact.artifact_uri.start_with?("sha256:")
@@ -99,26 +109,40 @@ module Sigstore
                 "artifact_uri must be prefixed with 'sha256:'"
         end
 
-        @hashed_input = Common::V1::HashOutput.new.tap do |hash_output|
+        Common::V1::HashOutput.new.tap do |hash_output|
           hash_output.algorithm = Common::V1::HashAlgorithm::SHA2_256
           hexdigest = artifact.artifact_uri.split(":", 2).last
           hash_output.digest = Internal::Util.hex_decode(hexdigest)
         end
       when :artifact
-        @hashed_input = Common::V1::HashOutput.new.tap do |hash_output|
+        Common::V1::HashOutput.new.tap do |hash_output|
           hash_output.algorithm = Common::V1::HashAlgorithm::SHA2_256
           hash_output.digest = OpenSSL::Digest.new("SHA256").update(artifact.artifact).digest
         end
+      when :artifact_digest
+        # The rest of the pipeline (message-signature and Rekor digest checks)
+        # operates on SHA2-256, so reject other algorithms.
+        artifact.artifact_digest.tap do |hash_output|
+          unless hash_output.algorithm == Common::V1::HashAlgorithm::SHA2_256
+            raise Error::InvalidVerificationInput,
+                  "unsupported artifact digest algorithm: #{hash_output.algorithm}"
+          end
+        end
       else
         raise Error::InvalidVerificationInput, "Unsupported artifact data: #{artifact.data}"
       end
-
-      freeze
     end
   end
 
   class SBundle < DelegateClass(Bundle::V1::Bundle)
-    attr_reader :bundle_type, :leaf_certificate
+    attr_reader :bundle_type, :leaf_certificate, :signing_key_hint
+
+    # A bundle whose signing identity is a bare public key (a "managed" /
+    # bring-your-own-key signature) rather than a Fulcio-issued certificate.
+    # The key itself is supplied out-of-band; the bundle only carries a hint.
+    def key_based?
+      !@signing_key_hint.nil?
+    end
 
     def initialize(*)
       super
@@ -138,11 +162,24 @@ module Sigstore
       new(bundle)
     end
 
-    def expected_tlog_entry(hashed_input)
+    # +verifier_pem+ is the PEM of the public key the entry should be bound to. For
+    # certificate bundles it defaults to the leaf certificate's PEM; for managed-key
+    # bundles the caller passes the supplied key's SubjectPublicKeyInfo PEM.
+    def expected_tlog_entry(hashed_input, verifier_pem = leaf_certificate&.to_pem)
       case content
       when :message_signature
-        expected_hashed_rekord_tlog_entry(hashed_input)
+        expected_hashed_rekord_tlog_entry(hashed_input, verifier_pem)
       when :dsse_envelope
+        # The DSSE-v1 (Rekor v1) expected-entry builders embed the signing leaf
+        # certificate. Key-based (managed-key) DSSE is only supported on Rekor v2, whose
+        # consistency check runs before this method; reaching here without a leaf
+        # certificate means a key-based bundle carries a v1 DSSE entry, which we cannot
+        # build an expected entry for. Fail cleanly rather than dereferencing a nil cert.
+        if leaf_certificate.nil?
+          raise Error::InvalidBundle,
+                "key-based DSSE bundles are only supported with Rekor v2 entries"
+        end
+
         rekor_entry = verification_material.tlog_entries.first
         canonicalized_body = begin
           JSON.parse(rekor_entry.canonicalized_body)
@@ -152,9 +189,9 @@ module Sigstore
 
         case kind_version = canonicalized_body.values_at("kind", "apiVersion")
         when %w[dsse 0.0.1]
-          expected_dsse_0_0_1_tlog_entry
+          expected_dsse_0_0_1_tlog_entry(verifier_pem)
         when %w[intoto 0.0.2]
-          expected_intoto_0_0_2_tlog_entry
+          expected_intoto_0_0_2_tlog_entry(verifier_pem)
         else
           raise Error::InvalidRekorEntry, "Unhandled rekor entry kind/version: #{kind_version.inspect}"
         end
@@ -193,7 +230,10 @@ module Sigstore
 
       case verification_material.content
       when :public_key
-        raise Error::Unimplemented, "public_key content of bundle"
+        # Managed key: the verifying key is provided out-of-band; the bundle only
+        # carries a hint identifying it. There is no certificate to anchor.
+        @signing_key_hint = verification_material.public_key.hint
+        return
       when :x509_certificate_chain
         certs = verification_material.x509_certificate_chain.certificates.map do |cert|
           Internal::X509::Certificate.read(cert.raw_bytes)
@@ -211,13 +251,13 @@ module Sigstore
       raise Error::InvalidBundle, "expected certificate to be leaf" unless @leaf_certificate.leaf?
     end
 
-    def expected_hashed_rekord_tlog_entry(hashed_input)
+    def expected_hashed_rekord_tlog_entry(hashed_input, verifier_pem)
       {
         "spec" => {
           "signature" => {
             "content" => Internal::Util.base64_encode(message_signature.signature),
             "publicKey" => {
-              "content" => Internal::Util.base64_encode(leaf_certificate.to_pem)
+              "content" => Internal::Util.base64_encode(verifier_pem)
             }
           },
           "data" => {
@@ -232,7 +272,7 @@ module Sigstore
       }
     end
 
-    def expected_intoto_0_0_2_tlog_entry
+    def expected_intoto_0_0_2_tlog_entry(_verifier_pem)
       {
         "apiVersion" => "0.0.2",
         "kind" => "intoto",
@@ -263,7 +303,7 @@ module Sigstore
       }
     end
 
-    def expected_dsse_0_0_1_tlog_entry
+    def expected_dsse_0_0_1_tlog_entry(verifier_pem)
       {
         "apiVersion" => "0.0.1",
         "kind" => "dsse",
@@ -276,7 +316,7 @@ module Sigstore
             dsse_envelope.signatures.map do |sig|
               {
                 "signature" => Internal::Util.base64_encode(sig.sig),
-                "verifier" => Internal::Util.base64_encode(leaf_certificate.to_pem)
+                "verifier" => Internal::Util.base64_encode(verifier_pem)
               }
             end
         }

data/lib/sigstore/oidc.rb

@@ -123,6 +123,9 @@ module Sigstore
         end
 
         def validate_nbf(nbf, now, leeway)
+          # The nbf ("not before") claim is optional (RFC 7519); skip validation when absent.
+          return if nbf.nil?
+
           raise Error::InvalidIdentityToken, "nbf claim must be an integer" unless nbf.is_a?(Integer)
           raise Error::InvalidIdentityToken, "nbf claim is in the future" if nbf > now + leeway
         end

data/lib/sigstore/policy.rb

@@ -87,6 +87,14 @@ module Sigstore
       end
     end
 
+    # No identity to check: used for managed-key (bring-your-own-key) verification,
+    # where trust comes from the supplied key rather than a certificate identity.
+    class UnsafeNoOp
+      def verify(_cert)
+        VerificationSuccess.new
+      end
+    end
+
     class Identity
       def initialize(identity:, issuer:)
         @identity = identity

data/lib/sigstore/rekor/checkpoint.rb

@@ -65,15 +65,25 @@ module Sigstore
 
         def verify(rekor_keyring, key_id)
           data = note.encode("utf-8")
-          signatures.each do |signature|
-            sig_hash = key_id[0, 4]
-            if signature.sig_hash != sig_hash
-              raise Error::InvalidCheckpoint,
-                    "sig_hash hint #{signature.sig_hash.inspect} does not match key_id #{sig_hash.inspect}"
-            end
-
+          key_hint = key_id[0, 4]
+
+          # A checkpoint may also carry cosignatures from witnesses whose verification
+          # keys we do not yet know; their key hints differ from the log's, and the
+          # signed-note / Rekor v2 spec says to ignore those lines. We require that at
+          # least one signature made with the log's own key verifies.
+          candidates = signatures.select { |signature| signature.sig_hash == key_hint }
+          raise Error::InvalidCheckpoint, "no checkpoint signature matching the log key" if candidates.empty?
+
+          # Keyring#verify raises KeyError when the log key id is not in the keyring (an
+          # untrusted or unknown log); treat that as a non-verifying candidate so it fails
+          # closed via the check below rather than escaping as an uncaught exception.
+          verified = candidates.any? do |signature|
             rekor_keyring.verify(key_id: key_id.unpack1("H*"), signature: signature.signature, data:)
+          rescue Error::InvalidSignature, KeyError
+            false
           end
+
+          raise Error::InvalidCheckpoint, "no valid checkpoint signature from the log key" unless verified
         end
       end
 

data/lib/sigstore/rekor/client.rb

@@ -44,6 +44,39 @@ module Sigstore
       end
     end
 
+    # Client for the Rekor v2 (tiled / rekor-tiles) API. Unlike v1, creating an
+    # entry returns a fully-formed protobuf TransparencyLogEntry (including the
+    # inclusion proof and checkpoint) directly, so there is no separate retrieval
+    # step. See https://github.com/sigstore/rekor-tiles/blob/main/CLIENTS.md
+    class V2Client
+      def initialize(url:)
+        @url = URI.join("#{url.chomp("/")}/", "api/v2/")
+
+        net = defined?(Gem::Net) ? Gem::Net : Net
+        @session = net::HTTP.new(@url.host, @url.port)
+        @session.use_ssl = true
+      end
+
+      # Submit a proposed entry (a CreateEntryRequest, as a Hash) and return the
+      # integrated V1::TransparencyLogEntry. The log only responds once the entry
+      # has been included, so this call can take a while.
+      def create_entry(payload)
+        resp = @session.post2(URI.join(@url, "log/entries").path, payload.to_json,
+                              { "Content-Type" => "application/json", "Accept" => "application/json",
+                                "User-Agent" => Sigstore::USER_AGENT })
+
+        unless %w[200 201].include?(resp.code)
+          raise Error::FailedRekorPost,
+                "#{resp.code} #{resp.message.inspect}\n#{JSON.pretty_generate(payload)}\n#{resp.body}"
+        end
+        unless resp.content_type == "application/json"
+          raise Error::FailedRekorPost, "Unexpected content type: #{resp.content_type.inspect}"
+        end
+
+        V1::TransparencyLogEntry.decode_json(resp.body, registry: REGISTRY)
+      end
+    end
+
     class Log
       def initialize(url, session:)
         @url = url