sigstore 0.1.1

data/data/_store/staging/trusted_root.json

@@ -0,0 +1,87 @@
+{
+  "mediaType": "application/vnd.dev.sigstore.trustedroot+json;version=0.1",
+  "tlogs": [
+    {
+      "baseUrl": "https://rekor.sigstage.dev",
+      "hashAlgorithm": "SHA2_256",
+      "publicKey": {
+        "rawBytes": "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEDODRU688UYGuy54mNUlaEBiQdTE9nYLr0lg6RXowI/QV/RE1azBn4Eg5/2uTOMbhB1/gfcHzijzFi9Tk+g1Prg==",
+        "keyDetails": "PKIX_ECDSA_P256_SHA_256",
+        "validFor": {
+          "start": "2021-01-12T11:53:27.000Z"
+        }
+      },
+      "logId": {
+        "keyId": "0y8wo8MtY5wrdiIFohx7sHeI5oKDpK5vQhGHI6G+pJY="
+      }
+    }
+  ],
+  "certificateAuthorities": [
+    {
+      "subject": {
+        "organization": "sigstore.dev",
+        "commonName": "sigstore"
+      },
+      "uri": "https://fulcio.sigstage.dev",
+      "certChain": {
+        "certificates": [
+          {
+            "rawBytes": "MIICGTCCAaCgAwIBAgITJta/okfgHvjabGm1BOzuhrwA1TAKBggqhkjOPQQDAzAqMRUwEwYDVQQKEwxzaWdzdG9yZS5kZXYxETAPBgNVBAMTCHNpZ3N0b3JlMB4XDTIyMDQxNDIxMzg0MFoXDTMyMDMyMjE2NTA0NVowNzEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MR4wHAYDVQQDExVzaWdzdG9yZS1pbnRlcm1lZGlhdGUwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAASosAySWJQ/tK5r8T5aHqavk0oI+BKQbnLLdmOMRXHQF/4Hx9KtNfpcdjH9hNKQSBxSlLFFN3tvFCco0qFBzWYwZtsYsBe1l91qYn/9VHFTaEVwYQWIJEEvrs0fvPuAqjajezB5MA4GA1UdDwEB/wQEAwIBBjATBgNVHSUEDDAKBggrBgEFBQcDAzASBgNVHRMBAf8ECDAGAQH/AgEAMB0GA1UdDgQWBBRxhjCmFHxib/n31vQFGn9f/+tvrDAfBgNVHSMEGDAWgBT/QjK6aH2rOnCv3AzUGuI+h49mZTAKBggqhkjOPQQDAwNnADBkAjAM1lbKkcqQlE/UspMTbWNo1y2TaJ44tx3l/FJFceTSdDZ+0W1OHHeU4twie/lq8XgCMHQxgEv26xNNiAGyPXbkYgrDPvbOqp0UeWX4mJnLSrBr3aN/KX1SBrKQu220FmVL0Q=="
+          },
+          {
+            "rawBytes": "MIIB9jCCAXugAwIBAgITDdEJvluliE0AzYaIE4jTMdnFTzAKBggqhkjOPQQDAzAqMRUwEwYDVQQKEwxzaWdzdG9yZS5kZXYxETAPBgNVBAMTCHNpZ3N0b3JlMB4XDTIyMDMyNTE2NTA0NloXDTMyMDMyMjE2NTA0NVowKjEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MREwDwYDVQQDEwhzaWdzdG9yZTB2MBAGByqGSM49AgEGBSuBBAAiA2IABMo9BUNk9QIYisYysC24+2OytoV72YiLonYcqR3yeVnYziPt7Xv++CYE8yoCTiwedUECCWKOcvQKRCJZb9ht4Hzy+VvBx36hK+C6sECCSR0x6pPSiz+cTk1f788ZjBlUZaNjMGEwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFP9CMrpofas6cK/cDNQa4j6Hj2ZlMB8GA1UdIwQYMBaAFP9CMrpofas6cK/cDNQa4j6Hj2ZlMAoGCCqGSM49BAMDA2kAMGYCMQD+kojuzMwztNay9Ibzjuk//ZL5m6T2OCsm45l1lY004pcb984L926BowodoirFMcMCMQDIJtFHhP/1D3a+M3dAGomOb6O4CmTry3TTPbPsAFnv22YA0Y+P21NVoxKDjdu0tkw="
+          }
+        ]
+      },
+      "validFor": {
+        "start": "2022-04-14T21:38:40.000Z"
+      }
+    }
+  ],
+  "ctlogs": [
+    {
+      "baseUrl": "https://ctfe.sigstage.dev/test",
+      "hashAlgorithm": "SHA2_256",
+      "publicKey": {
+        "rawBytes": "MIICCgKCAgEA27A2MPQXm0I0v7/Ly5BIauDjRZF5Jor9vU+QheoE2UIIsZHcyYq3slHzSSHy2lLj1ZD2d91CtJ492ZXqnBmsr4TwZ9jQ05tW2mGIRI8u2DqN8LpuNYZGz/f9SZrjhQQmUttqWmtu3UoLfKz6NbNXUnoo+NhZFcFRLXJ8VporVhuiAmL7zqT53cXR3yQfFPCUDeGnRksnlhVIAJc3AHZZSHQJ8DEXMhh35TVv2nYhTI3rID7GwjXXw4ocz7RGDD37ky6p39Tl5NB71gT1eSqhZhGHEYHIPXraEBd5+3w9qIuLWlp5Ej/K6Mu4ELioXKCUimCbwy+Cs8UhHFlqcyg4AysOHJwIadXIa8LsY51jnVSGrGOEBZevopmQPNPtyfFY3dmXSS+6Z3RD2Gd6oDnNGJzpSyEk410Ag5uvNDfYzJLCWX9tU8lIxNwdFYmIwpd89HijyRyoGnoJ3entd63cvKfuuix5r+GHyKp1Xm1L5j5AWM6P+z0xigwkiXnt+adexAl1J9wdDxv/pUFEESRF4DG8DFGVtbdH6aR1A5/vD4krO4tC1QYUSeyL5Mvsw8WRqIFHcXtgybtxylljvNcGMV1KXQC8UFDmpGZVDSHx6v3e/BHMrZ7gjoCCfVMZ/cFcQi0W2AIHPYEMH/C95J2r4XbHMRdYXpovpOoT5Ca78gsCAwEAAQ==",
+        "keyDetails": "PKCS1_RSA_PKCS1V5",
+        "validFor": {
+          "start": "2021-03-14T00:00:00.000Z",
+          "end": "2022-07-31T00:00:00.000Z"
+        }
+      },
+      "logId": {
+        "keyId": "G3wUKk6ZK6ffHh/FdCRUE2wVekyzHEEIpSG4savnv0w="
+      }
+    },
+    {
+      "baseUrl": "https://ctfe.sigstage.dev/2022",
+      "hashAlgorithm": "SHA2_256",
+      "publicKey": {
+        "rawBytes": "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEh99xuRi6slBFd8VUJoK/rLigy4bYeSYWO/fE6Br7r0D8NpMI94+A63LR/WvLxpUUGBpY8IJA3iU2telag5CRpA==",
+        "keyDetails": "PKIX_ECDSA_P256_SHA_256",
+        "validFor": {
+          "start": "2022-07-01T00:00:00.000Z",
+          "end": "2022-07-31T00:00:00.000Z"
+        }
+      },
+      "logId": {
+        "keyId": "++JKOMQt7SJ3ynUHnCfnDhcKP8/58J4TueMqXuk3HmA="
+      }
+    },
+    {
+      "baseUrl": "https://ctfe.sigstage.dev/2022-2",
+      "hashAlgorithm": "SHA2_256",
+      "publicKey": {
+        "rawBytes": "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE8gEDKNme8AnXuPBgHjrtXdS6miHqc24CRblNEOFpiJRngeq8Ko73Y+K18yRYVf1DXD4AVLwvKyzdNdl5n0jUSQ==",
+        "keyDetails": "PKIX_ECDSA_P256_SHA_256",
+        "validFor": {
+          "start": "2022-07-01T00:00:00.000Z"
+        }
+      },
+      "logId": {
+        "keyId": "KzC83GiIyeLh2CYpXnQfSDkxlgLynDPLXkNA/rKshno="
+      }
+    }
+  ]
+}

data/lib/sigstore/error.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# Copyright 2024 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.
+
+module Sigstore
+  class Error < StandardError
+    class InvalidSignature < Error; end
+    class InvalidBundle < Error; end
+    class InvalidCertificate < Error; end
+    class NoCertificate < Error; end
+    class NoTrustedRoot < Error; end
+    class NoBundle < Error; end
+    class NoSignature < Error; end
+    class InvalidKey < Error; end
+    class InvalidCheckpoint < Error; end
+    class InvalidVerificationInput < Error; end
+
+    class Signing < Error; end
+    class InvalidIdentityToken < Error; end
+
+    class MissingRekorEntry < Error; end
+    class InvalidRekorEntry < Error; end
+    class FailedRekorLookup < Error; end
+    class FailedRekorPost < Error; end
+
+    class Unimplemented < Error; end
+
+    class UnsupportedPlatform < Error; end
+    class UnsupportedKeyType < Error; end
+  end
+end

data/lib/sigstore/internal/json.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# Copyright 2024 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.
+
+module Sigstore::Internal
+  module JSON
+    # Implements https://wiki.laptop.org/go/Canonical_JSON
+    #
+    # TODO: This is a naive implementation. Performance can be improved by
+    #       serializing into a buffer instead of concatenating strings.
+    def self.canonical_generate(data)
+      case data
+      when NilClass
+        "null"
+      when TrueClass
+        "true"
+      when FalseClass
+        "false"
+      when Integer
+        data.to_s
+      when String
+        "\"#{data.gsub(/(["\\])/, '\\\\\1')}\""
+      when Array
+        contents = data.map { |v| canonical_generate(v) }.join(",")
+        "[#{contents}]"
+      when Hash
+        contents = data.sort_by do |k, _|
+          raise ArgumentError, "Non-string key in hash" unless k.is_a?(String)
+
+          k.encode("utf-16").codepoints
+        end
+        contents.map! do |k, v|
+          "#{canonical_generate(k)}:#{canonical_generate(v)}"
+        end
+        "{#{contents.join(",")}}"
+      else
+        raise ArgumentError, "Unsupported data type: #{data.class}"
+      end
+    end
+  end
+end

data/lib/sigstore/internal/key.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+# Copyright 2024 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.
+
+require_relative "util"
+
+module Sigstore
+  module Internal
+    class Key
+      include Loggable
+
+      def self.from_key_details(key_details, key_bytes)
+        case key_details
+        when Common::V1::PublicKeyDetails::PKIX_ECDSA_P256_SHA_256
+          key_type = "ecdsa"
+          key_schema = "ecdsa-sha2-nistp256"
+        when Common::V1::PublicKeyDetails::PKCS1_RSA_PKCS1V5
+          key_type = "rsa"
+          key_schema = "rsa-pkcs1v15-sha256"
+        else
+          raise Error::UnsupportedKeyType, "Unsupported key type #{key_details}"
+        end
+
+        read(key_type, key_schema, key_bytes, key_id: OpenSSL::Digest::SHA256.hexdigest(key_bytes))
+      end
+
+      def self.read(key_type, schema, key_bytes, key_id: nil)
+        case key_type
+        when "ecdsa", "ecdsa-sha2-nistp256"
+          pkey = OpenSSL::PKey::EC.new(key_bytes)
+          EDCSA.new(key_type, schema, pkey, key_id:)
+        when "ed25519"
+          pkey = ED25519.pkey_from_der([key_bytes].pack("H*"))
+          ED25519.new(key_type, schema, pkey, key_id:)
+        when "rsa"
+          pkey = OpenSSL::PKey::RSA.new(key_bytes)
+          RSA.new(key_type, schema, pkey, key_id:)
+        else
+          raise ArgumentError, "Unsupported key type #{key_type}"
+        end.tap do |key|
+          if RUBY_ENGINE == "jruby" && key.to_pem != key_bytes && key.to_der != key_bytes
+            raise Error::UnsupportedPlatform, "Key mismatch: #{key.to_pem.inspect} != #{key_bytes.inspect}"
+          end
+        end
+      rescue OpenSSL::PKey::PKeyError => e
+        raise OpenSSL::PKey::PKeyError, "Invalid key: #{e} for #{key_type} #{schema} #{key_id}"
+      end
+
+      attr_reader :key_type, :schema, :key_id
+
+      def initialize(key_type, schema, key, key_id: nil)
+        @key_type = key_type
+        @key = key
+        @schema = schema
+        @key_id = key_id
+      end
+
+      def to_pem
+        @key.to_pem
+      end
+
+      def to_der
+        @key.to_der
+      end
+
+      def verify(algo, signature, data)
+        @key.verify(algo, signature, data)
+      rescue OpenSSL::PKey::PKeyError => e
+        logger.debug { "Verification failed: #{e}" }
+        false
+      end
+
+      def public_to_der
+        @key.public_to_der
+      end
+
+      class EDCSA < Key
+        def initialize(...)
+          super
+          unless @key_type == "ecdsa" || @key_type == "ecdsa-sha2-nistp256"
+            raise ArgumentError,
+                  "key_type must be edcsa, given #{@key_type}"
+          end
+          unless @key.is_a?(OpenSSL::PKey::EC)
+            raise ArgumentError,
+                  "key must be an OpenSSL::PKey::EC, is #{@key.inspect}"
+          end
+
+          case @schema
+          when "ecdsa-sha2-nistp256"
+            unless @key.group.curve_name == "prime256v1"
+              raise ArgumentError, "Expected prime256v1 curve, got #{@key.group.curve_name}"
+            end
+          else
+            raise ArgumentError, "Unsupported schema #{schema}"
+          end
+        end
+      end
+
+      class RSA < Key
+        def initialize(...)
+          super
+          raise ArgumentError, "key_type must be rsa, given #{@key_type}" unless @key_type == "rsa"
+
+          unless @key.is_a?(OpenSSL::PKey::RSA)
+            raise ArgumentError, "key must be an OpenSSL::PKey::RSA, given #{@key.inspect}"
+          end
+
+          case @schema
+          when "rsassa-pss-sha256"
+            raise Error::UnsupportedPlatform, "RSA-PSS verification unsupported" unless @key.respond_to?(:verify_pss)
+          when "rsa-pkcs1v15-sha256"
+            # supported
+          else
+            raise ArgumentError, "Unsupported schema #{schema}"
+          end
+        end
+
+        def verify(_algo, signature, data)
+          case @schema
+          when "rsassa-pss-sha256"
+            @key.verify_pss("sha256", signature, data, salt_length: :auto, mgf1_hash: "SHA256")
+          when "rsa-pkcs1v15-sha256"
+            super
+          else
+            raise ArgumentError, "Unsupported schema #{schema}"
+          end
+        end
+      end
+
+      class ED25519 < Key
+        def self.pkey_from_der(raw)
+          if OpenSSL::PKey.respond_to?(:new_raw_public_key)
+            OpenSSL::PKey.new_raw_public_key("ed25519", raw)
+          else
+            pem = <<~PEM
+              -----BEGIN PUBLIC KEY-----
+              MCowBQYDK2VwAyEA#{Internal::Util.base64_encode(raw)}
+              -----END PUBLIC KEY-----
+            PEM
+            OpenSSL::PKey.read(pem)
+          end
+        end
+
+        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
+
+          case @schema
+          when "ed25519"
+            # supported
+          else
+            raise ArgumentError, "Unsupported schema #{schema}"
+          end
+        end
+
+        def verify(_algo, signature, data)
+          super(nil, signature, data)
+        end
+      end
+    end
+  end
+end

data/lib/sigstore/internal/keyring.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# Copyright 2024 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.
+
+module Sigstore
+  module Internal
+    class Keyring
+      def initialize(keys:)
+        @keyring = {}
+        keys.each do |key|
+          raise Error, "Duplicate key id #{key.key_id} in keyring" if @keyring.key?(key.key_id)
+
+          @keyring[key.key_id] = key
+        end
+      end
+
+      def verify(key_id:, signature:, data:)
+        key = @keyring.fetch(key_id) { raise KeyError, "key not found: #{key_id.inspect}, known: #{@keyring.keys}" }
+
+        return true if key.verify("SHA256", signature, data)
+
+        raise(Error::InvalidSignature,
+              "invalid signature: #{signature.inspect} over #{data.inspect} with key #{key_id.inspect}")
+      rescue OpenSSL::PKey::PKeyError => e
+        raise(Error::InvalidSignature,
+              "#{e}: invalid signature: #{signature.inspect} over #{data.inspect} with key #{key_id.inspect}")
+      end
+    end
+  end
+end

data/lib/sigstore/internal/merkle.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+# Copyright 2024 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.
+
+require_relative "util"
+
+module Sigstore
+  module Internal
+    module Merkle
+      class MissingInclusionProofError < StandardError; end
+      class MissingHashError < StandardError; end
+      class InvalidInclusionProofError < StandardError; end
+      class InclusionProofSizeError < InvalidInclusionProofError; end
+
+      def self.verify_merkle_inclusion(entry)
+        inclusion_proof = entry.inclusion_proof
+        raise MissingInclusionProofError, "Rekor entry has no inclusion proof" unless inclusion_proof
+
+        leaf_hash = hash_leaf(entry.canonicalized_body)
+        verify_inclusion(inclusion_proof.log_index, inclusion_proof.tree_size,
+                         inclusion_proof.hashes,
+                         inclusion_proof.root_hash, leaf_hash)
+      end
+
+      def self.verify_inclusion(index, tree_size, proof, root, leaf_hash)
+        calc_hash = root_from_inclusion_proof(index, tree_size, proof, leaf_hash)
+
+        return if calc_hash == root
+
+        raise InvalidInclusionProofError,
+              "Inclusion proof contains invalid root hash: " \
+              "expected #{root.unpack1("H*")}, calculated #{calc_hash.unpack1("H*")}"
+      end
+
+      def self.root_from_inclusion_proof(log_index, tree_size, proof, leaf_hash)
+        if log_index >= tree_size
+          raise InclusionProofSizeError,
+                "Log index #{log_index} is greater than tree size #{tree_size}"
+        end
+
+        if leaf_hash.bytesize != 32
+          raise InvalidInclusionProofError,
+                "Leaf hash has wrong size, expected 32 bytes, got #{leaf_hash.size}"
+        end
+
+        if proof.any? { |i| i.bytesize != 32 }
+          raise InvalidInclusionProofError,
+                "Proof hashes have wrong sizes, expected 32 bytes, got #{proof.inspect}"
+        end
+
+        inner, border = decompose_inclusion_proof(log_index, tree_size)
+
+        if proof.size != inner + border
+          raise InclusionProofSizeError,
+                "Inclusion proof has wrong size, expected #{inner + border} hashes, got #{proof.size}"
+        end
+
+        intermediate_result = chain_inner(
+          leaf_hash,
+          (proof[...inner] || raise(MissingHashError, "missing left hashes")),
+          log_index
+        )
+
+        chain_border_right(
+          intermediate_result,
+          proof[inner..] || raise(MissingHashError, "missing right hashes")
+        )
+      end
+
+      def self.decompose_inclusion_proof(log_index, tree_size)
+        inner = (log_index ^ (tree_size - 1)).bit_length
+        border = (log_index >> inner).to_s(2).count("1")
+
+        [inner, border]
+      end
+
+      def self.hash_leaf(data)
+        data = "\u0000#{data}".b
+        OpenSSL::Digest.new("SHA256").digest(data)
+      end
+
+      def self.chain_inner(seed, hashes, log_index)
+        hashes.each_with_index do |hash, i|
+          seed = if ((log_index >> i) & 1).zero?
+                   hash_children(seed, hash)
+                 else
+                   hash_children(hash, seed)
+                 end
+        end
+        seed
+      end
+
+      def self.chain_border_right(seed, hashes)
+        hashes.reduce(seed) do |acc, hash|
+          hash_children(hash, acc)
+        end
+      end
+
+      def self.hash_children(left, right)
+        data = "\u0001#{left}#{right}".b
+        OpenSSL::Digest.new("SHA256").digest(data)
+      end
+    end
+  end
+end

data/lib/sigstore/internal/set.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# Copyright 2024 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.
+
+module Sigstore
+  module Internal
+    module SET
+      def self.verify_set(keyring:, entry:)
+        raise Error, "invalid log entry: no inclusion promise" unless entry.inclusion_promise
+
+        signed_entry_timestamp = entry.inclusion_promise.signed_entry_timestamp
+        log_id = Util.hex_encode(entry.log_id.key_id)
+
+        # https://www.rfc-editor.org/rfc/rfc8785
+        canonical_entry = ::JSON.dump({
+                                        body: Internal::Util.base64_encode(entry.canonicalized_body),
+                                        integratedTime: entry.integrated_time,
+                                        logID: log_id,
+                                        logIndex: entry.log_index
+                                      })
+
+        keyring.verify(
+          key_id: log_id,
+          signature: signed_entry_timestamp,
+          data: canonical_entry
+        )
+      end
+    end
+  end
+end

data/lib/sigstore/internal/util.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# Copyright 2024 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.
+
+module Sigstore
+  module Internal
+    module Util
+      module_function
+
+      def hash_algorithm_name(algorithm)
+        case algorithm
+        when Common::V1::HashAlgorithm::SHA2_256
+          "sha256"
+        when Common::V1::HashAlgorithm::SHA2_384
+          "sha384"
+        when Common::V1::HashAlgorithm::SHA2_512
+          "sha512"
+        else
+          raise ArgumentError, "Unrecognized hash algorithm #{algorithm}"
+        end
+      end
+
+      def hex_encode(string)
+        string.unpack1("H*")
+      end
+
+      def hex_decode(string)
+        [string].pack("H*")
+      end
+
+      def base64_encode(string)
+        [string].pack("m0")
+      end
+
+      def base64_decode(string)
+        string.unpack1("m0")
+      end
+    end
+  end
+end