pq_crypto 0.6.6 → 0.6.8

data/ext/pqcrypto/pqcrypto_secure.h

@@ -29,7 +29,9 @@ typedef enum {
     PQ_ERROR_RANDOM = -7,
     PQ_ERROR_BUFFER = -8,
     PQ_ERROR_NOMEM = -9,
-    PQ_ERROR_OPENSSL = -10
+    PQ_ERROR_OPENSSL = -10,
+    PQ_ERROR_INVALID_PUBLIC_KEY = -11,
+    PQ_ERROR_INVALID_SECRET_KEY = -12
 } pq_error_t;
 
 typedef struct {
@@ -83,6 +85,17 @@ int pq_mlkem512_decapsulate(uint8_t *shared_secret, const uint8_t *ciphertext,
 int pq_mlkem1024_decapsulate(uint8_t *shared_secret, const uint8_t *ciphertext,
                              const uint8_t *secret_key);
 
+int pq_mlkem_check_public_key(const uint8_t *public_key);
+int pq_mlkem_check_secret_key(const uint8_t *secret_key);
+int pq_mlkem512_check_public_key(const uint8_t *public_key);
+int pq_mlkem512_check_secret_key(const uint8_t *secret_key);
+int pq_mlkem1024_check_public_key(const uint8_t *public_key);
+int pq_mlkem1024_check_secret_key(const uint8_t *secret_key);
+
+int pq_mldsa_check_secret_key(const uint8_t *secret_key);
+int pq_mldsa44_check_secret_key(const uint8_t *secret_key);
+int pq_mldsa87_check_secret_key(const uint8_t *secret_key);
+
 int pq_sign_keypair(uint8_t *public_key, uint8_t *secret_key);
 int pq_mldsa44_sign_keypair(uint8_t *public_key, uint8_t *secret_key);
 int pq_mldsa87_sign_keypair(uint8_t *public_key, uint8_t *secret_key);

data/ext/pqcrypto/pqcrypto_version.h

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

data/lib/pq_crypto/internal.rb

@@ -8,6 +8,16 @@ module PQCrypto
       String(value).b
     end
 
+    def frozen_binary_string(value)
+      binary_string(value).freeze
+    end
+
+    def strict_boolean!(value, name:)
+      return value if value.equal?(true) || value.equal?(false)
+
+      raise ArgumentError, "#{name} must be true or false (got #{value.inspect})"
+    end
+
     def safe_wipe(value)
       return unless value.is_a?(String) && !value.frozen?
 
@@ -19,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

@@ -14,18 +14,24 @@ module PQCrypto
         keypair_from_seed: :native_ml_kem_512_keypair_from_seed,
         encapsulate: :native_ml_kem_512_encapsulate,
         decapsulate: :native_ml_kem_512_decapsulate,
+        check_public_key: :native_ml_kem_512_check_public_key,
+        check_secret_key: :native_ml_kem_512_check_secret_key,
       }.freeze,
       ml_kem_768: {
         keypair: :native_ml_kem_keypair,
         keypair_from_seed: :native_ml_kem_keypair_from_seed,
         encapsulate: :native_ml_kem_encapsulate,
         decapsulate: :native_ml_kem_decapsulate,
+        check_public_key: :native_ml_kem_check_public_key,
+        check_secret_key: :native_ml_kem_check_secret_key,
       }.freeze,
       ml_kem_1024: {
         keypair: :native_ml_kem_1024_keypair,
         keypair_from_seed: :native_ml_kem_1024_keypair_from_seed,
         encapsulate: :native_ml_kem_1024_encapsulate,
         decapsulate: :native_ml_kem_1024_decapsulate,
+        check_public_key: :native_ml_kem_1024_check_public_key,
+        check_secret_key: :native_ml_kem_1024_check_secret_key,
       }.freeze,
     }.freeze
 
@@ -68,23 +74,29 @@ module PQCrypto
         SecretKey.new(resolve_algorithm!(resolved_algorithm), bytes)
       end
 
-      def secret_key_from_pkcs8_der(der, passphrase: nil)
-        secret_key_from_decoded_pkcs8(*PKCS8.decode_der(der, passphrase: passphrase))
+      def secret_key_from_pkcs8_der(der, passphrase: nil, require_encrypted: false)
+        require_encrypted = Internal.strict_boolean!(require_encrypted, name: "require_encrypted")
+        secret_key_from_decoded_pkcs8(
+          *PKCS8.decode_der(der, passphrase: passphrase, require_encrypted: require_encrypted)
+        )
       end
 
-      def secret_key_from_pkcs8_pem(pem, passphrase: nil)
-        secret_key_from_decoded_pkcs8(*PKCS8.decode_pem(pem, passphrase: passphrase))
+      def secret_key_from_pkcs8_pem(pem, passphrase: nil, require_encrypted: false)
+        require_encrypted = Internal.strict_boolean!(require_encrypted, name: "require_encrypted")
+        secret_key_from_decoded_pkcs8(
+          *PKCS8.decode_pem(pem, passphrase: passphrase, require_encrypted: require_encrypted)
+        )
       end
 
       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
 
@@ -121,18 +133,17 @@ module PQCrypto
         end
       end
 
+      def checkable?(algorithm)
+        NATIVE_DISPATCH.key?(algorithm) && NATIVE_DISPATCH.fetch(algorithm).key?(:check_public_key)
+      end
+
       def native_method_for(algorithm, operation)
         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
 
@@ -158,8 +169,19 @@ module PQCrypto
 
       def initialize(algorithm, bytes)
         @algorithm = algorithm
-        @bytes = Internal.binary_string(bytes)
+        @bytes = Internal.frozen_binary_string(bytes)
         validate_length!
+        validate_structure!
+      end
+
+      def valid?
+        if @algorithm == :ml_kem_768_x25519_xwing
+          mlkem_half = @bytes.byteslice(0, KEM.details(:ml_kem_768).fetch(:public_key_bytes))
+          return PQCrypto.__send__(:native_ml_kem_check_public_key, mlkem_half)
+        end
+        return true unless KEM.send(:checkable?, @algorithm)
+
+        PQCrypto.__send__(KEM.send(:native_method_for, @algorithm, :check_public_key), @bytes)
       end
 
       def to_bytes
@@ -219,6 +241,10 @@ module PQCrypto
         expected = KEM.details(@algorithm).fetch(:public_key_bytes)
         raise InvalidKeyError, "Invalid KEM public key length" unless @bytes.bytesize == expected
       end
+
+      def validate_structure!
+        raise InvalidKeyError, "Invalid #{@algorithm} public key: FIPS 203 modulus check failed" unless valid?
+      end
     end
 
     class SecretKey
@@ -230,6 +256,13 @@ module PQCrypto
         @seed = seed.nil? ? nil : Internal.binary_string(seed)
         validate_length!
         validate_seed_length! if @seed
+        validate_structure!
+      end
+
+      def valid?
+        return true unless KEM.send(:checkable?, @algorithm)
+
+        PQCrypto.__send__(KEM.send(:native_method_for, @algorithm, :check_secret_key), @bytes)
       end
 
       def self.from_seed(algorithm, seed)
@@ -298,6 +331,10 @@ module PQCrypto
         raise InvalidKeyError, "Invalid KEM secret key length" unless @bytes.bytesize == expected
       end
 
+      def validate_structure!
+        raise InvalidKeyError, "Invalid #{@algorithm} secret key: FIPS 203 hash check failed" unless valid?
+      end
+
       def pkcs8_material(format)
         case format
         when :expanded

data/lib/pq_crypto/key.rb

@@ -17,22 +17,24 @@ module PQCrypto
         end
       end
 
-      def from_pem(pem, passphrase: nil)
+      def from_pem(pem, passphrase: nil, require_encrypted: false)
+        require_encrypted = Internal.strict_boolean!(require_encrypted, name: "require_encrypted")
         text = String(pem)
         if text.include?(SPKI::PEM_BEGIN)
           public_key_from_spki_pem(text)
         elsif text.include?(PKCS8::PEM_BEGIN) || text.include?(PKCS8::ENCRYPTED_PEM_BEGIN)
-          secret_key_from_pkcs8_pem(text, passphrase: passphrase)
+          secret_key_from_pkcs8_pem(text, passphrase: passphrase, require_encrypted: require_encrypted)
         else
           raise SerializationError, "Unsupported PEM label for PQCrypto::Key.from_pem"
         end
       end
 
-      def from_der(der, passphrase: nil)
+      def from_der(der, passphrase: nil, require_encrypted: false)
+        require_encrypted = Internal.strict_boolean!(require_encrypted, name: "require_encrypted")
         public_key_from_spki_der(der)
       rescue SerializationError => spki_error
         begin
-          secret_key_from_pkcs8_der(der, passphrase: passphrase)
+          secret_key_from_pkcs8_der(der, passphrase: passphrase, require_encrypted: require_encrypted)
         rescue SerializationError => pkcs8_error
           raise SerializationError,
                 "Unable to decode DER as SPKI or PKCS#8 (SPKI: #{spki_error.message}; PKCS#8: #{pkcs8_error.message})"
@@ -56,12 +58,16 @@ module PQCrypto
         public_key_from_algorithm_and_bytes(algorithm, bytes)
       end
 
-      def secret_key_from_pkcs8_pem(pem, passphrase: nil)
-        secret_key_from_decoded_pkcs8(*PKCS8.decode_pem(pem, passphrase: passphrase))
+      def secret_key_from_pkcs8_pem(pem, passphrase: nil, require_encrypted: false)
+        secret_key_from_decoded_pkcs8(
+          *PKCS8.decode_pem(pem, passphrase: passphrase, require_encrypted: require_encrypted)
+        )
       end
 
-      def secret_key_from_pkcs8_der(der, passphrase: nil)
-        secret_key_from_decoded_pkcs8(*PKCS8.decode_der(der, passphrase: passphrase))
+      def secret_key_from_pkcs8_der(der, passphrase: nil, require_encrypted: false)
+        secret_key_from_decoded_pkcs8(
+          *PKCS8.decode_der(der, passphrase: passphrase, require_encrypted: require_encrypted)
+        )
       end
 
       def secret_key_from_decoded_pkcs8(algorithm, format, material)

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/pkcs8.rb

@@ -70,10 +70,16 @@ module PQCrypto
         der = encode_der(algorithm, secret_material, format: format, passphrase: passphrase, iterations: iterations)
         pkcs8_native { PQCrypto.__send__(:native_pkcs8_der_to_pem, der, !passphrase.nil?) }
       end
-
-      def decode_der(der, passphrase: nil)
+      def decode_der(der, passphrase: nil, require_encrypted: false)
+        require_encrypted = Internal.strict_boolean!(require_encrypted, name: "require_encrypted")
         input = Internal.binary_string(der)
-        return decode_encrypted_der(input, passphrase: passphrase) if encrypted_der?(input)
+        encrypted = encrypted_der?(input)
+
+        if require_encrypted && !encrypted
+          raise SerializationError, "PKCS#8 input is not encrypted, but require_encrypted: true was requested"
+        end
+
+        return decode_encrypted_der(input, passphrase: passphrase) if encrypted
 
         oid, choice_der = private_key_info_from_der(input)
         algorithm = AlgorithmRegistry.by_standard_oid(oid)
@@ -83,15 +89,17 @@ module PQCrypto
         PrivateKeyChoice.validate_secret_key_algorithm!(algorithm, entry)
         PrivateKeyChoice.decode(algorithm, Internal.binary_string(choice_der))
       rescue ArgumentError => e
+        raise if e.message.start_with?("require_encrypted")
         raise SerializationError, e.message
       ensure
         Internal.safe_wipe(choice_der) if defined?(choice_der)
       end
 
-      def decode_pem(pem, passphrase: nil)
+      def decode_pem(pem, passphrase: nil, require_encrypted: false)
+        require_encrypted = Internal.strict_boolean!(require_encrypted, name: "require_encrypted")
         _encrypted, der = pkcs8_native { PQCrypto.__send__(:native_pkcs8_pem_to_der, String(pem)) }
         begin
-          decode_der(der, passphrase: passphrase)
+          decode_der(der, passphrase: passphrase, require_encrypted: require_encrypted)
         ensure
           Internal.safe_wipe(der)
         end

data/lib/pq_crypto/signature.rb

@@ -14,18 +14,21 @@ module PQCrypto
         sign: :native_ml_dsa_44_sign,
         verify: :native_ml_dsa_44_verify,
         keypair_from_seed: :native_ml_dsa_44_keypair_from_seed,
+        check_secret_key: :native_ml_dsa_44_check_secret_key,
       }.freeze,
       ml_dsa_65: {
         keypair: :native_sign_keypair,
         sign: :native_sign,
         verify: :native_verify,
         keypair_from_seed: :native_ml_dsa_keypair_from_seed,
+        check_secret_key: :native_ml_dsa_check_secret_key,
       }.freeze,
       ml_dsa_87: {
         keypair: :native_ml_dsa_87_keypair,
         sign: :native_ml_dsa_87_sign,
         verify: :native_ml_dsa_87_verify,
         keypair_from_seed: :native_ml_dsa_87_keypair_from_seed,
+        check_secret_key: :native_ml_dsa_87_check_secret_key,
       }.freeze,
     }.freeze
 
@@ -33,7 +36,8 @@ module PQCrypto
       def generate(algorithm = CANONICAL_ALGORITHM)
         algorithm = resolve_algorithm!(algorithm)
         public_key, secret_key = PQCrypto.__send__(native_method_for(algorithm, :keypair))
-        Keypair.new(PublicKey.new(algorithm, public_key), SecretKey.new(algorithm, secret_key))
+        Keypair.new(PublicKey.new(algorithm, public_key),
+                    SecretKey.new(algorithm, secret_key, freshly_generated: true))
       end
 
       def public_key_from_bytes(algorithm, bytes)
@@ -76,22 +80,28 @@ 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
 
-      def secret_key_from_pkcs8_der(der, passphrase: nil)
-        secret_key_from_decoded_pkcs8(*PKCS8.decode_der(der, passphrase: passphrase))
+      def secret_key_from_pkcs8_der(der, passphrase: nil, require_encrypted: false)
+        require_encrypted = Internal.strict_boolean!(require_encrypted, name: "require_encrypted")
+        secret_key_from_decoded_pkcs8(
+          *PKCS8.decode_der(der, passphrase: passphrase, require_encrypted: require_encrypted)
+        )
       end
 
-      def secret_key_from_pkcs8_pem(pem, passphrase: nil)
-        secret_key_from_decoded_pkcs8(*PKCS8.decode_pem(pem, passphrase: passphrase))
+      def secret_key_from_pkcs8_pem(pem, passphrase: nil, require_encrypted: false)
+        require_encrypted = Internal.strict_boolean!(require_encrypted, name: "require_encrypted")
+        secret_key_from_decoded_pkcs8(
+          *PKCS8.decode_pem(pem, passphrase: passphrase, require_encrypted: require_encrypted)
+        )
       end
 
       def details(algorithm)
@@ -118,7 +128,7 @@ module PQCrypto
           SecretKey.new(algorithm, material)
         when :seed
           _public_key, expanded = PQCrypto.__send__(native_method_for(algorithm, :keypair_from_seed), material)
-          SecretKey.new(algorithm, expanded, seed: material)
+          SecretKey.new(algorithm, expanded, seed: material, freshly_generated: true)
         when :both
           _seed, expanded = material
           SecretKey.new(algorithm, expanded, seed: _seed)
@@ -133,14 +143,13 @@ 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
+      def secret_key_checkable?(algorithm)
+        NATIVE_DISPATCH.key?(algorithm) && NATIVE_DISPATCH.fetch(algorithm).key?(:check_secret_key)
+      end
 
-        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)
@@ -151,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)
@@ -180,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
 
@@ -264,7 +266,7 @@ module PQCrypto
 
       def initialize(algorithm, bytes)
         @algorithm = algorithm
-        @bytes = Internal.binary_string(bytes)
+        @bytes = Internal.frozen_binary_string(bytes)
         validate_length!
       end
 
@@ -343,18 +345,25 @@ module PQCrypto
     class SecretKey
       attr_reader :algorithm
 
-      def initialize(algorithm, bytes, seed: nil)
+      def initialize(algorithm, bytes, seed: nil, freshly_generated: false)
         @algorithm = algorithm
         @bytes = Internal.binary_string(bytes)
         @seed = seed.nil? ? nil : Internal.binary_string(seed)
         validate_length!
         validate_seed_length! if @seed
+        validate_structure! unless freshly_generated
+      end
+
+      def valid?
+        return true unless Signature.send(:secret_key_checkable?, @algorithm)
+
+        PQCrypto.__send__(Signature.send(:native_method_for, @algorithm, :check_secret_key), @bytes)
       end
 
       def self.from_seed(algorithm, seed)
         seed_bytes = Internal.binary_string(seed)
         _public_key, expanded = PQCrypto.__send__(Signature.send(:native_method_for, algorithm, :keypair_from_seed), seed_bytes)
-        new(algorithm, expanded, seed: seed_bytes)
+        new(algorithm, expanded, seed: seed_bytes, freshly_generated: true)
       rescue ArgumentError => e
         raise InvalidKeyError, e.message
       end
@@ -424,6 +433,10 @@ module PQCrypto
         raise InvalidKeyError, "Invalid signature secret key length" unless @bytes.bytesize == expected
       end
 
+      def validate_structure!
+        raise InvalidKeyError, "Invalid #{@algorithm} secret key: ML-DSA structure check failed" unless valid?
+      end
+
       def pkcs8_material(format)
         case format
         when :expanded