Rename hashalgorithm to hash_algorithm to match spec

Author: vcsjones

lib/ssh_data/encoding.rb

@@ -8,12 +8,12 @@ module Encoding
     OPENSSH_SIGNATURE_VERSION = 0x01
 
     OPENSSH_SIGNATURE_FIELDS = [
-      [:sigversion,    :uint32],
-      [:publickey,     :string_public_key],
-      [:namespace,     :string],
-      [:reserved,      :string],
-      [:hashalgorithm, :string],
-      [:signature,     :string],
+      [:sigversion,     :uint32],
+      [:publickey,      :string_public_key],
+      [:namespace,      :string],
+      [:reserved,       :string],
+      [:hash_algorithm, :string],
+      [:signature,      :string],
     ]
 
     OPENSSH_PRIVATE_KEY_FIELDS = [

lib/ssh_data/signature.rb

@@ -20,7 +20,7 @@ class Signature
       PublicKey::ALGO_RSA_SHA2_512,
     ]
 
-    attr_reader :sigversion, :namespace, :signature, :reserved, :hashalgorithm
+    attr_reader :sigversion, :namespace, :signature, :reserved, :hash_algorithm
 
     # Parses a PEM armored SSH signature.
     # pem - A PEM encoded SSH signature.
@@ -47,13 +47,13 @@ def self.parse_blob(blob)
       new(**data)
     end
 
-    def initialize(sigversion:, publickey:, namespace:, reserved:, hashalgorithm:, signature:)
+    def initialize(sigversion:, publickey:, namespace:, reserved:, hash_algorithm:, signature:)
       if sigversion > MAX_SUPPORTED_VERSION || sigversion < MIN_SUPPORTED_VERSION
         raise UnsupportedError, "Signature version is not supported"
       end
 
-      unless SUPPORTED_HASH_ALGORITHMS.has_key?(hashalgorithm)
-        raise UnsupportedError, "Hash algorithm #{hashalgorithm} is not supported."
+      unless SUPPORTED_HASH_ALGORITHMS.has_key?(hash_algorithm)
+        raise UnsupportedError, "Hash algorithm #{hash_algorithm} is not supported."
       end
 
       # Spec: empty namespaces are not permitted.
@@ -66,13 +66,13 @@ def initialize(sigversion:, publickey:, namespace:, reserved:, hashalgorithm:, s
       @publickey = publickey
       @namespace = namespace
       @reserved = reserved
-      @hashalgorithm = hashalgorithm
+      @hash_algorithm = hash_algorithm
       @signature = signature
     end
 
     def verify(signed_data)
       key = public_key
-      digest_algorithm = SUPPORTED_HASH_ALGORITHMS[@hashalgorithm]
+      digest_algorithm = SUPPORTED_HASH_ALGORITHMS[@hash_algorithm]
 
       if key.is_a?(PublicKey::RSA)
         sig_algo, * = Encoding.decode_signature(@signature)
@@ -85,14 +85,14 @@ def verify(signed_data)
         end
       end
 
-      raise AlgorithmError, "Unsupported digest algorithm #{@hashalgorithm}" if digest_algorithm.nil?
+      raise AlgorithmError, "Unsupported digest algorithm #{@hash_algorithm}" if digest_algorithm.nil?
 
       message_digest = digest_algorithm.digest(signed_data)
       blob =
         SIGNATURE_PREAMBLE +
         Encoding.encode_string(@namespace) +
         Encoding.encode_string(@reserved || "") +
-        Encoding.encode_string(@hashalgorithm) +
+        Encoding.encode_string(@hash_algorithm) +
         Encoding.encode_string(message_digest)
 
       key.verify(blob, @signature)

spec/encoding_spec.rb

@@ -823,7 +823,7 @@
       expect(data[:sigversion]).to eq(1)
       expect(data[:reserved]).to be_empty
       expect(data[:namespace]).to eq("file")
-      expect(data[:hashalgorithm]).to eq("sha512")
+      expect(data[:hash_algorithm]).to eq("sha512")
       expect(data[:signature]).not_to be_empty
       expect(data[:publickey]).not_to be_empty
     end

spec/signature_spec.rb

@@ -72,7 +72,7 @@
           expect(subject.sigversion).to eq(1)
           expect(subject.namespace).to eq("file")
           expect(subject.reserved).to be_empty
-          expect(subject.hashalgorithm).to eq("sha512")
+          expect(subject.hash_algorithm).to eq("sha512")
         end
       end
     end