pq_crypto 0.6.7 → 0.6.8

data/ext/pqcrypto/pqcrypto_version.h

@@ -2,6 +2,6 @@
 #ifndef PQCRYPTO_VERSION_H
 #define PQCRYPTO_VERSION_H
 
-#define PQCRYPTO_VERSION "0.6.7"
+#define PQCRYPTO_VERSION "0.6.8"
 
 #endif

data/lib/pq_crypto/internal.rb

@@ -29,5 +29,15 @@ module PQCrypto
     def constant_time_equal?(left, right)
       PQCrypto.__send__(:native_ct_equals, left, right)
     end
+
+    def validate_algorithm_match!(expected, actual, algorithms:, family:)
+      unless algorithms.key?(expected)
+        raise SerializationError, "Unsupported #{family} algorithm: #{expected.inspect}"
+      end
+      return if expected == actual
+
+      raise SerializationError,
+            "Expected #{expected.inspect}, got #{actual.inspect} (SPKI key algorithm mismatch)"
+    end
   end
 end

data/lib/pq_crypto/kem.rb

@@ -90,13 +90,13 @@ module PQCrypto
 
       def public_key_from_spki_der(der, algorithm: nil)
         resolved_algorithm, bytes = SPKI.decode_der(der)
-        validate_algorithm_match!(algorithm, resolved_algorithm) if algorithm
+        validate_spki_algorithm!(algorithm, resolved_algorithm) if algorithm
         PublicKey.new(resolve_algorithm!(resolved_algorithm), bytes)
       end
 
       def public_key_from_spki_pem(pem, algorithm: nil)
         resolved_algorithm, bytes = SPKI.decode_pem(pem)
-        validate_algorithm_match!(algorithm, resolved_algorithm) if algorithm
+        validate_spki_algorithm!(algorithm, resolved_algorithm) if algorithm
         PublicKey.new(resolve_algorithm!(resolved_algorithm), bytes)
       end
 
@@ -141,14 +141,9 @@ module PQCrypto
         NATIVE_DISPATCH.fetch(resolve_algorithm!(algorithm)).fetch(operation)
       end
 
-      def validate_algorithm_match!(expected_algorithm, actual_algorithm)
-        expected = resolve_algorithm!(expected_algorithm)
-        return if expected == actual_algorithm
-
-        raise SerializationError,
-              "Expected #{expected.inspect}, got #{actual_algorithm.inspect} (SPKI key algorithm mismatch)"
-      rescue UnsupportedAlgorithmError => e
-        raise SerializationError, e.message
+      def validate_spki_algorithm!(expected_algorithm, actual_algorithm)
+        Internal.validate_algorithm_match!(expected_algorithm, actual_algorithm,
+                                           algorithms: DETAILS, family: "KEM")
       end
     end
 

data/lib/pq_crypto/pkcs8/der.rb

@@ -44,24 +44,39 @@ module PQCrypto
 
         return [first, 1] if first < 0x80
 
+        length_octets = long_length_octet_count(first)
+        length = decode_long_length(der, offset, length_octets)
+
+        [length, 1 + length_octets]
+      end
+
+      def long_length_octet_count(first)
         length_octets = first & 0x7f
         raise SerializationError, "PKCS#8 DER indefinite length is not allowed" if length_octets.zero?
         raise SerializationError, "PKCS#8 DER length is too large" if length_octets > 4
-        if offset + 1 + length_octets > der.bytesize
-          raise SerializationError, "PKCS#8 DER length exceeds available data"
-        end
 
-        length = 0
-        length_octets.times do |i|
-          byte = der.getbyte(offset + 1 + i)
-          length = (length << 8) | byte
-        end
+        length_octets
+      end
 
-        if length < 0x80 || (length_octets > 1 && der.getbyte(offset + 1).zero?)
-          raise SerializationError, "PKCS#8 DER length is not minimally encoded"
+      def decode_long_length(der, offset, length_octets)
+        ensure_long_length_available!(der, offset, length_octets)
+        length = length_octets.times.reduce(0) do |total, index|
+          (total << 8) | der.getbyte(offset + 1 + index)
         end
+        ensure_minimal_long_length!(der, offset, length, length_octets)
+        length
+      end
 
-        [length, 1 + length_octets]
+      def ensure_long_length_available!(der, offset, length_octets)
+        return if offset + 1 + length_octets <= der.bytesize
+
+        raise SerializationError, "PKCS#8 DER length exceeds available data"
+      end
+
+      def ensure_minimal_long_length!(der, offset, length, length_octets)
+        return unless length < 0x80 || (length_octets > 1 && der.getbyte(offset + 1).zero?)
+
+        raise SerializationError, "PKCS#8 DER length is not minimally encoded"
       end
     end
   end

data/lib/pq_crypto/pkcs8/private_key_choice.rb

@@ -6,6 +6,8 @@ module PQCrypto
       SEED_TAG = 0x80
       EXPANDED_TAG = 0x04
       BOTH_TAG = 0x30
+      COMPONENT_TAGS = { seed: SEED_TAG, expanded: EXPANDED_TAG }.freeze
+      COMPONENT_LABELS = { seed: "seed", expanded: "expandedKey" }.freeze
 
       KEYPAIR_FROM_SEED_METHODS = {
         ml_kem_512: :native_ml_kem_512_keypair_from_seed,
@@ -23,9 +25,9 @@ module PQCrypto
 
         case format
         when :seed
-          encode_seed(algorithm, secret_material)
+          encode_component(algorithm, secret_material, format)
         when :expanded
-          encode_expanded(algorithm, secret_material)
+          encode_component(algorithm, secret_material, format)
         when :both
           encode_both(algorithm, secret_material)
         else
@@ -40,10 +42,10 @@ module PQCrypto
         case tag
         when SEED_TAG
           ensure_format_supported!(algorithm, :seed)
-          decode_seed(algorithm, choice_der)
+          decode_component(algorithm, choice_der, :seed)
         when EXPANDED_TAG
           ensure_format_supported!(algorithm, :expanded)
-          decode_expanded(algorithm, choice_der)
+          decode_component(algorithm, choice_der, :expanded)
         when BOTH_TAG
           ensure_format_supported!(algorithm, :both)
           decode_both(algorithm, choice_der)
@@ -104,20 +106,13 @@ module PQCrypto
               "Invalid #{algorithm.inspect} expanded private key length: expected #{expected}, got #{expanded.bytesize}"
       end
 
-      def decode_seed(algorithm, choice_der)
-        _tag, seed, next_offset = DER.decode_tlv(choice_der, 0, expected_tag: SEED_TAG, label: "seed")
-        raise SerializationError, "PKCS#8 seed contains trailing data" unless next_offset == choice_der.bytesize
+      def decode_component(algorithm, choice_der, format)
+        label = COMPONENT_LABELS.fetch(format)
+        _tag, bytes, next_offset = DER.decode_tlv(choice_der, 0, expected_tag: COMPONENT_TAGS.fetch(format), label: label)
+        raise SerializationError, "PKCS#8 #{label} contains trailing data" unless next_offset == choice_der.bytesize
 
-        validate_seed_length!(algorithm, seed)
-        [algorithm, :seed, seed]
-      end
-
-      def decode_expanded(algorithm, choice_der)
-        _tag, bytes, next_offset = DER.decode_tlv(choice_der, 0, expected_tag: EXPANDED_TAG, label: "expandedKey")
-        raise SerializationError, "PKCS#8 expandedKey contains trailing data" unless next_offset == choice_der.bytesize
-
-        validate_expanded_length!(algorithm, bytes)
-        [algorithm, :expanded, bytes]
+        validate_component_length!(algorithm, format, bytes)
+        [algorithm, format, bytes]
       end
 
       def decode_both(algorithm, choice_der)
@@ -135,18 +130,19 @@ module PQCrypto
         [algorithm, :both, [seed_bytes, expanded_bytes]]
       end
 
-      def encode_seed(algorithm, secret_material)
-        seed = Internal.binary_string(secret_material)
-        validate_seed_length!(algorithm, seed)
+      def encode_component(algorithm, secret_material, format)
+        bytes = Internal.binary_string(secret_material)
+        validate_component_length!(algorithm, format, bytes)
 
-        DER.encode_tlv(SEED_TAG, seed)
+        DER.encode_tlv(COMPONENT_TAGS.fetch(format), bytes)
       end
 
-      def encode_expanded(algorithm, secret_material)
-        bytes = Internal.binary_string(secret_material)
-        validate_expanded_length!(algorithm, bytes)
+      def validate_component_length!(algorithm, format, bytes)
+        expected = profile(algorithm).fetch(format == :seed ? :seed_bytes : :expanded_bytes)
+        return if bytes.bytesize == expected
 
-        DER.encode_tlv(EXPANDED_TAG, bytes)
+        raise SerializationError,
+              "Invalid #{algorithm.inspect} #{format} private key length: expected #{expected}, got #{bytes.bytesize}"
       end
 
       def encode_both(algorithm, secret_material)

data/lib/pq_crypto/signature.rb

@@ -80,13 +80,13 @@ module PQCrypto
 
       def public_key_from_spki_der(der, algorithm: nil)
         resolved_algorithm, bytes = SPKI.decode_der(der)
-        validate_algorithm_match!(algorithm, resolved_algorithm) if algorithm
+        validate_spki_algorithm!(algorithm, resolved_algorithm) if algorithm
         PublicKey.new(resolve_algorithm!(resolved_algorithm), bytes)
       end
 
       def public_key_from_spki_pem(pem, algorithm: nil)
         resolved_algorithm, bytes = SPKI.decode_pem(pem)
-        validate_algorithm_match!(algorithm, resolved_algorithm) if algorithm
+        validate_spki_algorithm!(algorithm, resolved_algorithm) if algorithm
         PublicKey.new(resolve_algorithm!(resolved_algorithm), bytes)
       end
 
@@ -147,14 +147,9 @@ module PQCrypto
         NATIVE_DISPATCH.key?(algorithm) && NATIVE_DISPATCH.fetch(algorithm).key?(:check_secret_key)
       end
 
-      def validate_algorithm_match!(expected_algorithm, actual_algorithm)
-        expected = resolve_algorithm!(expected_algorithm)
-        return if expected == actual_algorithm
-
-        raise SerializationError,
-              "Expected #{expected.inspect}, got #{actual_algorithm.inspect} (SPKI key algorithm mismatch)"
-      rescue UnsupportedAlgorithmError => e
-        raise SerializationError, e.message
+      def validate_spki_algorithm!(expected_algorithm, actual_algorithm)
+        Internal.validate_algorithm_match!(expected_algorithm, actual_algorithm,
+                                           algorithms: DETAILS, family: "signature")
       end
 
       def _streaming_sign(secret_key, io, chunk_size, context)
@@ -165,25 +160,12 @@ module PQCrypto
 
         algorithm = secret_key.algorithm
         sk_bytes = secret_key.__send__(:bytes_for_native)
-        begin
-          tr = PQCrypto.__send__(:_native_mldsa_extract_tr, algorithm, sk_bytes)
-        rescue ArgumentError => e
-          raise InvalidKeyError, e.message
-        end
-
-        builder = PQCrypto.__send__(:_native_mldsa_mu_builder_new, tr, context)
-        builder_consumed = false
-        mu = nil
-        begin
-          _drain_io_into_builder(io, builder, chunk_size)
-          mu = PQCrypto.__send__(:_native_mldsa_mu_builder_finalize, builder)
-          builder_consumed = true
+        tr = extract_tr(:_native_mldsa_extract_tr, algorithm, sk_bytes)
+        with_streaming_mu(tr, io, chunk_size, context) do |mu|
           PQCrypto.__send__(:_native_mldsa_sign_mu, algorithm, mu, sk_bytes)
-        ensure
-          PQCrypto.__send__(:_native_mldsa_mu_builder_release, builder) unless builder_consumed
-          PQCrypto.secure_wipe(tr) if tr && !tr.frozen?
-          PQCrypto.secure_wipe(mu) if mu && !mu.frozen?
         end
+      ensure
+        Internal.safe_wipe(tr) if defined?(tr)
       end
 
       def _streaming_verify(public_key, io, signature, chunk_size, context)
@@ -194,26 +176,32 @@ module PQCrypto
 
         algorithm = public_key.algorithm
         pk_bytes = public_key.__send__(:bytes_for_native)
-        begin
-          tr = PQCrypto.__send__(:_native_mldsa_compute_tr, algorithm, pk_bytes)
-        rescue ArgumentError => e
-          raise InvalidKeyError, e.message
+        sig_bytes = Internal.binary_string(signature)
+        tr = extract_tr(:_native_mldsa_compute_tr, algorithm, pk_bytes)
+        with_streaming_mu(tr, io, chunk_size, context) do |mu|
+          PQCrypto.__send__(:_native_mldsa_verify_mu, algorithm, mu, sig_bytes, pk_bytes)
         end
+      ensure
+        Internal.safe_wipe(tr) if defined?(tr)
+      end
+
+      def extract_tr(native_method, algorithm, key_bytes)
+        PQCrypto.__send__(native_method, algorithm, key_bytes)
+      rescue ArgumentError => e
+        raise InvalidKeyError, e.message
+      end
 
-        builder = PQCrypto.__send__(:_native_mldsa_mu_builder_new, tr, context)
-        builder_consumed = false
+      def with_streaming_mu(tr, io, chunk_size, context)
+        builder = nil
         mu = nil
-        sig_bytes = Internal.binary_string(signature)
         begin
+          builder = PQCrypto.__send__(:_native_mldsa_mu_builder_new, tr, context)
           _drain_io_into_builder(io, builder, chunk_size)
           mu = PQCrypto.__send__(:_native_mldsa_mu_builder_finalize, builder)
-          builder_consumed = true
-          PQCrypto.__send__(:_native_mldsa_verify_mu, algorithm, mu, sig_bytes, pk_bytes)
+          yield mu
         ensure
-          PQCrypto.__send__(:_native_mldsa_mu_builder_release, builder) unless builder_consumed
-
-          PQCrypto.secure_wipe(tr) if tr && !tr.frozen?
-          PQCrypto.secure_wipe(mu) if mu && !mu.frozen?
+          PQCrypto.__send__(:_native_mldsa_mu_builder_release, builder) if builder
+          Internal.safe_wipe(mu) if defined?(mu)
         end
       end
 

data/lib/pq_crypto/spki.rb

@@ -39,30 +39,9 @@ module PQCrypto
       def decode_der(der)
         input = String(der).b
         outer = decode_asn1(input)
-        raise SerializationError, "SPKI DER contains trailing data" unless outer.to_der.b == input
-        raise SerializationError, "SPKI must be an ASN.1 SEQUENCE" unless outer.is_a?(OpenSSL::ASN1::Sequence)
-        raise SerializationError, "SPKI SEQUENCE must contain exactly 2 elements" unless outer.value.size == 2
-
-        algorithm_identifier, subject_public_key = outer.value
+        algorithm_identifier, subject_public_key = spki_elements(outer, input)
         algorithm = decode_algorithm_identifier(algorithm_identifier)
-        entry = AlgorithmRegistry.fetch(algorithm)
-        validate_public_key_algorithm!(algorithm, entry)
-
-        unless subject_public_key.is_a?(OpenSSL::ASN1::BitString)
-          raise SerializationError, "SPKI subjectPublicKey must be a BIT STRING"
-        end
-        unless subject_public_key.unused_bits.zero?
-          raise SerializationError, "SPKI subjectPublicKey must have zero unused bits"
-        end
-
-        bytes = String(subject_public_key.value).b
-        expected = entry.fetch(:public_key_bytes)
-        unless bytes.bytesize == expected
-          raise SerializationError,
-                "Invalid #{algorithm.inspect} SPKI public key length: expected #{expected}, got #{bytes.bytesize}"
-        end
-
-        [algorithm, bytes]
+        [algorithm, decode_subject_public_key(algorithm, subject_public_key)]
       rescue OpenSSL::OpenSSLError, TypeError => e
         raise SerializationError, e.message
       end
@@ -80,6 +59,40 @@ module PQCrypto
         raise SerializationError, e.message
       end
 
+      def spki_elements(outer, input)
+        raise SerializationError, "SPKI DER contains trailing data" unless outer.to_der.b == input
+        raise SerializationError, "SPKI must be an ASN.1 SEQUENCE" unless outer.is_a?(OpenSSL::ASN1::Sequence)
+        raise SerializationError, "SPKI SEQUENCE must contain exactly 2 elements" unless outer.value.size == 2
+
+        outer.value
+      end
+
+      def decode_subject_public_key(algorithm, subject_public_key)
+        entry = AlgorithmRegistry.fetch(algorithm)
+        validate_public_key_algorithm!(algorithm, entry)
+        validate_subject_public_key!(subject_public_key)
+
+        bytes = String(subject_public_key.value).b
+        validate_public_key_length!(algorithm, bytes, entry.fetch(:public_key_bytes))
+        bytes
+      end
+
+      def validate_subject_public_key!(subject_public_key)
+        unless subject_public_key.is_a?(OpenSSL::ASN1::BitString)
+          raise SerializationError, "SPKI subjectPublicKey must be a BIT STRING"
+        end
+        return if subject_public_key.unused_bits.zero?
+
+        raise SerializationError, "SPKI subjectPublicKey must have zero unused bits"
+      end
+
+      def validate_public_key_length!(algorithm, bytes, expected)
+        return if bytes.bytesize == expected
+
+        raise SerializationError,
+              "Invalid #{algorithm.inspect} SPKI public key length: expected #{expected}, got #{bytes.bytesize}"
+      end
+
       def decode_algorithm_identifier(value)
         unless value.is_a?(OpenSSL::ASN1::Sequence)
           raise SerializationError, "SPKI algorithm must be an AlgorithmIdentifier SEQUENCE"

data/lib/pq_crypto/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PQCrypto
-  VERSION = "0.6.7"
+  VERSION = "0.6.8"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pq_crypto
 version: !ruby/object:Gem::Version
-  version: 0.6.7
+  version: 0.6.8
 platform: ruby
 authors:
 - Roman Haydarov