solana-ruby-kit 8.4.0 → 8.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 874d4a76636d15a05ab0474d28d1ea069b1a8c1d50b18d9178a9f0639747fd92
-  data.tar.gz: 28cfc822396c2c7156daa6da853e25be997b4febbcbdec66e71aa687ad05c782
+  metadata.gz: 3067fc0036448f0aef241f14f4e0b95f0faf6d6cedd4ed8aae5206d6e3169e28
+  data.tar.gz: a689c349c2e41d519b6e06814319d9760b2816bf59f48109d8d839790c4e6312
 SHA512:
-  metadata.gz: ca743643e0257eadc50274add4ce4f843dcb19f4c63ca9a4c1b4e9ebf3310e02945eee1d6b5cfe2d91fb153452e8d03ea6a44b6becad3a210c8f92f04350c2f5
-  data.tar.gz: 162cdeb79aee32775b4e35bc1fb80be095e11cb65f15217c3b93076de5172c76181ed94bb26b7d3b16a7b65394a28676b352cca03cee16ecb62ac96ab218b188
+  metadata.gz: a02f7ce5743af32d1d6401f2023fc7293e33abfe1c0f495ec91f00a7ca4399e6fd654c7baa3f3c966ed34d6495514607432315323fb3425f294e8bf1713035ae
+  data.tar.gz: bfd06cf91f1fc1652cb5a578b822595c5f976537561fddbad22e04e6dc5567f1284b211b4e41be6472426005f3f4b0197c486fe5d87a046e2dac8989e30acb61

data/README.md

@@ -133,6 +133,9 @@ kp = Keys.create_key_pair_from_private_key_bytes(seed_bytes)
 # Sign / verify
 sig = Keys.sign_bytes(kp.signing_key, data)
 ok  = Keys.verify_signature(kp.verify_key, sig, data)
+# verify_signature is strict: a small-order public key or signature R
+# component returns false (as the Solana runtime does), and passing anything
+# other than an RbNaCl::VerifyKey raises KEYS__VERIFICATION_REQUIRES_EXTRACTABLE_PUBLIC_KEY.
 
 # Base58-encode a signature
 Keys.encode_signature(sig)   # => Signature string
@@ -477,6 +480,11 @@ may *begin* with the sentinel's bytes, or decoding stops early at that item.
 Second, under `:optional` / `:omitted` the sentinel must be no wider than the
 smallest item, or a short trailing item is silently dropped.
 
+An item codec with a fixed size of zero (e.g. `struct_codec([])`) can never
+reach a sentinel or the end of the bytes, so pairing one with a `SentinelSize`
+or `:remainder` raises `CODECS__UNEXPECTED_ZERO_FIXED_SIZE_ITEM_FOR_ARRAY_LIKE_SIZE_STRATEGY`
+when the codec is built. Explicit counts and prefixes still allow it.
+
 #### Tap combinators
 
 Wrap a codec in one that observes a value - or the bytes - without changing it,

data/lib/solana/ruby/kit/codecs/data_structures.rb

@@ -132,6 +132,7 @@ module Solana::Ruby::Kit
       end
       def array_codec(element_codec, size: nil, require_size_prefix: false, description: nil)
         description ||= 'array'
+        ArrayLikeSize.assert_item_codec_supports_size_strategy(description, size, element_codec.fixed_size)
         case size
         when nil          then ArrayLikeSize.prefixed(element_codec, Numbers.u32_codec, require_size_prefix)
         when Codec        then ArrayLikeSize.prefixed(element_codec, size, require_size_prefix)
@@ -244,6 +245,20 @@ module Solana::Ruby::Kit
       extend T::Sig
       extend self
 
+      # Raises when a zero-byte item codec is paired with a strategy that relies
+      # on items consuming bytes to make progress: a sentinel could never be
+      # reached, nor could the end of the bytes under +:remainder+.
+      sig { params(description: String, size: T.untyped, item_fixed_size: T.nilable(Integer)).void }
+      def assert_item_codec_supports_size_strategy(description, size, item_fixed_size)
+        return unless item_fixed_size&.zero?
+        return unless size == :remainder || size.is_a?(SentinelSize)
+
+        Kernel.raise SolanaError.new(
+          SolanaError::CODECS__UNEXPECTED_ZERO_FIXED_SIZE_ITEM_FOR_ARRAY_LIKE_SIZE_STRATEGY,
+          { codec_description: description, size_strategy: size == :remainder ? 'remainder' : 'sentinel' }
+        )
+      end
+
       # A count prefix written and read with +prefix+.
       sig { params(element_codec: Codec, prefix: Codec, require_size_prefix: T::Boolean).returns(Codec) }
       def prefixed(element_codec, prefix, require_size_prefix)

data/lib/solana/ruby/kit/codecs/strings.rb

@@ -191,11 +191,20 @@ module Solana::Ruby::Kit
         Codec.new(enc, dec)
       end
 
-      # Hex codec — lower-case hex string ↔ binary bytes.
+      # Hex codec — lower-case hex string ↔ binary bytes. Spaces are ignored on
+      # encode; any other non-hex character raises. An odd-length string keeps
+      # its last digit as a final low-nibble byte (+'abc'+ → +0xab 0x0c+), as
+      # upstream's base16 encoder does — +pack('H*')+ alone would pad it into
+      # the high nibble (+0xc0+).
       sig { returns(Codec) }
       def hex_codec
         enc = Encoder.new do |v|
-          [v.to_s.tr(' ', '')].pack('H*')
+          value = v.to_s.tr(' ', '')
+          unless value.match?(/\A\h*\z/)
+            Kernel.raise SolanaError.new(SolanaError::CODECS__INVALID_STRING_FOR_HEX_CODEC, { value: v.to_s })
+          end
+          value = "#{value[0...-1]}0#{value[-1]}" if value.length.odd?
+          [value].pack('H*')
         end
         dec = Decoder.new do |bytes, offset|
           remaining = bytes.b.byteslice(offset..) || ''.b

data/lib/solana/ruby/kit/errors.rb

@@ -36,6 +36,7 @@ module Solana::Ruby::Kit
     KEYS__PUBLIC_KEY_MUST_MATCH_PRIVATE_KEY              = :SOLANA_ERROR__KEYS__PUBLIC_KEY_MUST_MATCH_PRIVATE_KEY
     KEYS__INVALID_SIGNATURE_BYTE_LENGTH                  = :SOLANA_ERROR__KEYS__INVALID_SIGNATURE_BYTE_LENGTH
     KEYS__SIGNATURE_STRING_LENGTH_OUT_OF_RANGE           = :SOLANA_ERROR__KEYS__SIGNATURE_STRING_LENGTH_OUT_OF_RANGE
+    KEYS__VERIFICATION_REQUIRES_EXTRACTABLE_PUBLIC_KEY   = :SOLANA_ERROR__KEYS__VERIFICATION_REQUIRES_EXTRACTABLE_PUBLIC_KEY
 
     # ── Instructions ──────────────────────────────────────────────────────────
     INSTRUCTIONS__EXPECTED_TO_HAVE_ACCOUNTS              = :SOLANA_ERROR__INSTRUCTIONS__EXPECTED_TO_HAVE_ACCOUNTS
@@ -104,6 +105,8 @@ module Solana::Ruby::Kit
     # context: { codec_description:, hex_sentinel:, sentinel: }
     CODECS__SENTINEL_MISSING_AT_END_OF_BYTES             = :SOLANA_ERROR__CODECS__SENTINEL_MISSING_AT_END_OF_BYTES
     CODECS__SENTINEL_MUST_NOT_BE_EMPTY                   = :SOLANA_ERROR__CODECS__SENTINEL_MUST_NOT_BE_EMPTY
+    # context: { codec_description:, size_strategy: }
+    CODECS__UNEXPECTED_ZERO_FIXED_SIZE_ITEM_FOR_ARRAY_LIKE_SIZE_STRATEGY = :SOLANA_ERROR__CODECS__UNEXPECTED_ZERO_FIXED_SIZE_ITEM_FOR_ARRAY_LIKE_SIZE_STRATEGY
 
     # ── RPC / JSON-RPC ────────────────────────────────────────────────────────
     RPC__INTEGER_OVERFLOW_WHILE_SERIALIZING_LARGE_INTEGER = :SOLANA_ERROR__RPC__INTEGER_OVERFLOW_WHILE_SERIALIZING_LARGE_INTEGER
@@ -200,6 +203,7 @@ module Solana::Ruby::Kit
         KEYS__PUBLIC_KEY_MUST_MATCH_PRIVATE_KEY          => 'The public key does not match the private key',
         KEYS__INVALID_SIGNATURE_BYTE_LENGTH              => 'Signature must be 64 bytes, got %{actual_length}',
         KEYS__SIGNATURE_STRING_LENGTH_OUT_OF_RANGE       => 'Signature string length out of range (64–88 chars), got %{actual_length}',
+        KEYS__VERIFICATION_REQUIRES_EXTRACTABLE_PUBLIC_KEY => 'Signatures can only be verified using a public key (an RbNaCl::VerifyKey).',
 
         # Instructions
         INSTRUCTIONS__EXPECTED_TO_HAVE_ACCOUNTS          => 'Expected instruction to have accounts',
@@ -260,6 +264,7 @@ module Solana::Ruby::Kit
         CODECS__NUMBER_OUT_OF_RANGE                      => 'Codec [%{codec_description}] expected number to be in the range [%{min}, %{max}], got %{value}.',
         CODECS__SENTINEL_MISSING_AT_END_OF_BYTES         => 'Codec [%{codec_description}] expected sentinel [%{hex_sentinel}] to terminate the collection, but reached the end of the byte array without it.',
         CODECS__SENTINEL_MUST_NOT_BE_EMPTY               => 'The sentinel must not be empty.',
+        CODECS__UNEXPECTED_ZERO_FIXED_SIZE_ITEM_FOR_ARRAY_LIKE_SIZE_STRATEGY => 'Codec [%{codec_description}] cannot use the [%{size_strategy}] size strategy: the item codec has a fixed size of zero and consumes no bytes.',
 
         # RPC
         RPC__INTEGER_OVERFLOW_WHILE_SERIALIZING_LARGE_INTEGER   => 'Integer overflow while serializing large integer %{value}',

data/lib/solana/ruby/kit/keys/signatures.rb

@@ -4,6 +4,7 @@
 require 'rbnacl'
 require_relative '../errors'
 require_relative '../encoding/base58'
+require_relative 'small_order'
 
 module Solana::Ruby::Kit
   module Keys
@@ -144,11 +145,23 @@ module Solana::Ruby::Kit
     # Mirrors `verifySignature(key, signature, data)` in TypeScript.
     # Returns false rather than raising on mismatch, matching the TS return type.
     #
+    # Verification is strict: a public key or a signature `R` component that is
+    # a point of small order is rejected without consulting RbNaCl, matching the
+    # Solana runtime whatever the linked libsodium does itself. Upstream raises
+    # for a non-extractable or non-public CryptoKey; an RbNaCl::VerifyKey always
+    # exposes its bytes, so here only a non-VerifyKey (e.g. a SigningKey) raises.
+    #
     # @param verify_key  [RbNaCl::VerifyKey]
     # @param sig_bytes   [SignatureBytes]
     # @param data        [String] binary string that was signed
     sig { params(verify_key: T.untyped, sig_bytes: SignatureBytes, data: String).returns(T::Boolean) }
     def verify_signature(verify_key, sig_bytes, data)
+      unless verify_key.is_a?(RbNaCl::VerifyKey)
+        Kernel.raise SolanaError.new(SolanaError::KEYS__VERIFICATION_REQUIRES_EXTRACTABLE_PUBLIC_KEY)
+      end
+      return false if SmallOrder.small_order_point_encoding?(verify_key.to_bytes)
+      return false if SmallOrder.small_order_point_encoding?(sig_bytes.value.byteslice(0, 32).to_s)
+
       verify_key.verify(sig_bytes.value, data.b)
       true
     rescue RbNaCl::BadSignatureError

data/lib/solana/ruby/kit/keys/small_order.rb

@@ -0,0 +1,46 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Solana::Ruby::Kit
+  module Keys
+    extend T::Sig
+
+    # Mirrors the private `isSmallOrderPointEncoding` in @solana/keys
+    # (`small-order.ts`). An Ed25519 public key or signature `R` that is a point
+    # of small order lets trivially forged signatures verify against any data;
+    # the Solana runtime rejects them, so `verify_signature` does too.
+    module SmallOrder
+      extend T::Sig
+      extend self
+
+      P = T.let((1 << 255) - 19, Integer)
+
+      # The y-coordinates of the eight small-order points (the x sign bit picks
+      # between each pair, so it is masked off before the lookup). The two large
+      # ones are parsed from Strings because Sorbet rejects bignum literals.
+      SMALL_ORDER_Y_COORDINATES = T.let(
+        [
+          0,
+          1,
+          P - 1,
+          Integer('2707385501144840649318225287225658788936804267575313519463743609750303402022'),
+          Integer('55188659117513257062467267217118295137698188065244968500265048394206261417927')
+        ].freeze,
+        T::Array[Integer]
+      )
+
+      # True when +bytes+ (a 32-byte binary String) encodes a point of small
+      # order, canonically or not (a y-coordinate >= p is reduced mod p first).
+      # Any other length returns false.
+      sig { params(bytes: String).returns(T::Boolean) }
+      def small_order_point_encoding?(bytes)
+        bytes = bytes.b
+        return false unless bytes.bytesize == 32
+
+        last = bytes.getbyte(31).to_i & 0x7f
+        y    = (bytes.byteslice(0, 31).to_s + last.chr).reverse.unpack1('H*').to_i(16)
+        SMALL_ORDER_Y_COORDINATES.include?(y % P)
+      end
+    end
+  end
+end

data/lib/solana/ruby/kit/offchain_messages/codec.rb

@@ -105,9 +105,9 @@ module Solana::Ruby::Kit
         # `Signature` holds a base58 string (that is what `sign_offchain_message` returns),
         # so it has to be decoded back to the 64 raw bytes RbNaCl expects.
         sig_bytes = Solana::Ruby::Kit::Encoding::Base58.decode(signature.to_s)
-        vk.verify(sig_bytes, payload)
-        true
-      rescue RbNaCl::BadSignatureError, RbNaCl::LengthError
+        # Through Keys.verify_signature for its small-order key/`R` rejection.
+        Keys.verify_signature(vk, Keys.signature_bytes(sig_bytes), payload)
+      rescue RbNaCl::LengthError, SolanaError
         false
       end
     end

data/lib/solana/ruby/kit/version.rb

@@ -4,7 +4,7 @@
 module Solana
   module Ruby
     module Kit
-      VERSION = '8.4.0'
+      VERSION = '8.5.0'
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solana-ruby-kit
 version: !ruby/object:Gem::Version
-  version: 8.4.0
+  version: 8.5.0
 platform: ruby
 authors:
 - Paul Zupan, Idhra Inc.
@@ -246,6 +246,7 @@ files:
 - lib/solana/ruby/kit/keys/private_key.rb
 - lib/solana/ruby/kit/keys/public_key.rb
 - lib/solana/ruby/kit/keys/signatures.rb
+- lib/solana/ruby/kit/keys/small_order.rb
 - lib/solana/ruby/kit/offchain_messages.rb
 - lib/solana/ruby/kit/offchain_messages/codec.rb
 - lib/solana/ruby/kit/offchain_messages/message.rb