net-ssh 6.1.0 → 7.1.0

data/lib/net/ssh/transport/algorithms.rb

@@ -33,12 +33,15 @@ module Net
                        ecdsa-sha2-nistp256
                        ssh-rsa-cert-v01@openssh.com
                        ssh-rsa-cert-v00@openssh.com
-                       ssh-rsa],
+                       ssh-rsa
+                       rsa-sha2-256
+                       rsa-sha2-512],
 
           kex: %w[ecdh-sha2-nistp521
                   ecdh-sha2-nistp384
                   ecdh-sha2-nistp256
                   diffie-hellman-group-exchange-sha256
+                  diffie-hellman-group14-sha256
                   diffie-hellman-group14-sha1],
 
           encryption: %w[aes256-ctr aes192-ctr aes128-ctr],
@@ -143,7 +146,7 @@ module Net
 
         # Instantiates a new Algorithms object, and prepares the hash of preferred
         # algorithms based on the options parameter and the ALGORITHMS constant.
-        def initialize(session, options={})
+        def initialize(session, options = {})
           @session = session
           @logger = session.logger
           @options = options
@@ -275,7 +278,7 @@ module Net
             # existing known key for the host has preference.
 
             existing_keys = session.host_keys
-            host_keys = existing_keys.map { |key| key.ssh_type }.uniq
+            host_keys = existing_keys.flat_map { |key| key.respond_to?(:ssh_types) ? key.ssh_types : [key.ssh_type] }.uniq
             algorithms[:host_key].each do |name|
               host_keys << name unless host_keys.include?(name)
             end
@@ -366,10 +369,10 @@ module Net
           language    = algorithms[:language].join(",")
 
           Net::SSH::Buffer.from(:byte, KEXINIT,
-            :long, [rand(0xFFFFFFFF), rand(0xFFFFFFFF), rand(0xFFFFFFFF), rand(0xFFFFFFFF)],
-            :mstring, [kex, host_key, encryption, encryption, hmac, hmac],
-            :mstring, [compression, compression, language, language],
-            :bool, false, :long, 0)
+                                :long, [rand(0xFFFFFFFF), rand(0xFFFFFFFF), rand(0xFFFFFFFF), rand(0xFFFFFFFF)],
+                                :mstring, [kex, host_key, encryption, encryption, hmac, hmac],
+                                :mstring, [compression, compression, language, language],
+                                :bool, false, :long, 0)
         end
 
         # Given the parsed server KEX packet, and the client's preferred algorithm
@@ -435,13 +438,13 @@ module Net
           debug { "exchanging keys" }
 
           algorithm = Kex::MAP[kex].new(self, session,
-            client_version_string: Net::SSH::Transport::ServerVersion::PROTO_VERSION,
-            server_version_string: session.server_version.version,
-            server_algorithm_packet: @server_packet,
-            client_algorithm_packet: @client_packet,
-            need_bytes: kex_byte_requirement,
-            minimum_dh_bits: options[:minimum_dh_bits],
-            logger: logger)
+                                        client_version_string: Net::SSH::Transport::ServerVersion::PROTO_VERSION,
+                                        server_version_string: session.server_version.version,
+                                        server_algorithm_packet: @server_packet,
+                                        client_algorithm_packet: @client_packet,
+                                        need_bytes: kex_byte_requirement,
+                                        minimum_dh_bits: options[:minimum_dh_bits],
+                                        logger: logger)
           result = algorithm.exchange_keys
 
           secret   = result[:shared_secret].to_ssh

data/lib/net/ssh/transport/cipher_factory.rb

@@ -3,31 +3,30 @@ require 'net/ssh/transport/ctr.rb'
 require 'net/ssh/transport/key_expander'
 require 'net/ssh/transport/identity_cipher'
 
-module Net 
-  module SSH 
+module Net
+  module SSH
     module Transport
-
       # Implements a factory of OpenSSL cipher algorithms.
       class CipherFactory
         # Maps the SSH name of a cipher to it's corresponding OpenSSL name
         SSH_TO_OSSL = {
-          "3des-cbc"                    => "des-ede3-cbc",
-          "blowfish-cbc"                => "bf-cbc",
-          "aes256-cbc"                  => "aes-256-cbc",
-          "aes192-cbc"                  => "aes-192-cbc",
-          "aes128-cbc"                  => "aes-128-cbc",
-          "idea-cbc"                    => "idea-cbc",
-          "cast128-cbc"                 => "cast-cbc",
+          "3des-cbc" => "des-ede3-cbc",
+          "blowfish-cbc" => "bf-cbc",
+          "aes256-cbc" => "aes-256-cbc",
+          "aes192-cbc" => "aes-192-cbc",
+          "aes128-cbc" => "aes-128-cbc",
+          "idea-cbc" => "idea-cbc",
+          "cast128-cbc" => "cast-cbc",
           "rijndael-cbc@lysator.liu.se" => "aes-256-cbc",
-          "3des-ctr"                    => "des-ede3",
-          "blowfish-ctr"                => "bf-ecb",
+          "3des-ctr" => "des-ede3",
+          "blowfish-ctr" => "bf-ecb",
 
-          'aes256-ctr'                  => 'aes-256-ctr',
-          'aes192-ctr'                  => 'aes-192-ctr',
-          'aes128-ctr'                  => 'aes-128-ctr',
-          'cast128-ctr'                 => 'cast5-ecb',
+          "aes256-ctr" => ::OpenSSL::Cipher.ciphers.include?("aes-256-ctr") ? "aes-256-ctr" : "aes-256-ecb",
+          "aes192-ctr" => ::OpenSSL::Cipher.ciphers.include?("aes-192-ctr") ? "aes-192-ctr" : "aes-192-ecb",
+          "aes128-ctr" => ::OpenSSL::Cipher.ciphers.include?("aes-128-ctr") ? "aes-128-ctr" : "aes-128-ecb",
+          'cast128-ctr' => 'cast5-ecb',
 
-          'none'                        => 'none'
+          'none' => 'none'
         }
 
         # Returns true if the underlying OpenSSL library supports the given cipher,
@@ -35,23 +34,25 @@ module Net
         def self.supported?(name)
           ossl_name = SSH_TO_OSSL[name] or raise NotImplementedError, "unimplemented cipher `#{name}'"
           return true if ossl_name == "none"
+
           return OpenSSL::Cipher.ciphers.include?(ossl_name)
         end
-    
+
         # Retrieves a new instance of the named algorithm. The new instance
         # will be initialized using an iv and key generated from the given
         # iv, key, shared, hash and digester values. Additionally, the
         # cipher will be put into encryption or decryption mode, based on the
         # value of the +encrypt+ parameter.
-        def self.get(name, options={})
+        def self.get(name, options = {})
           ossl_name = SSH_TO_OSSL[name] or raise NotImplementedError, "unimplemented cipher `#{name}'"
           return IdentityCipher if ossl_name == "none"
+
           cipher = OpenSSL::Cipher.new(ossl_name)
-    
+
           cipher.send(options[:encrypt] ? :encrypt : :decrypt)
-    
+
           cipher.padding = 0
-    
+
           if name =~ /-ctr(@openssh.org)?$/
             if ossl_name !~ /-ctr/
               cipher.extend(Net::SSH::Transport::CTR)
@@ -60,14 +61,14 @@ module Net
             end
           end
           cipher.iv = Net::SSH::Transport::KeyExpander.expand_key(cipher.iv_len, options[:iv], options)
-    
+
           key_len = cipher.key_len
           cipher.key_len = key_len
           cipher.key = Net::SSH::Transport::KeyExpander.expand_key(key_len, options[:key], options)
-    
+
           return cipher
         end
-    
+
         # Returns a two-element array containing the [ key-length,
         # block-size ] for the named cipher algorithm. If the cipher
         # algorithm is unknown, or is "none", 0 is returned for both elements
@@ -82,7 +83,7 @@ module Net
             cipher = OpenSSL::Cipher.new(ossl_name)
             key_len = cipher.key_len
             cipher.key_len = key_len
-    
+
             block_size =
               case ossl_name
               when /\-ctr/
@@ -90,14 +91,13 @@ module Net
               else
                 cipher.block_size
               end
-    
+
             result = [key_len, block_size]
             result << cipher.iv_len if options[:iv_len]
           end
           result
         end
       end
-
     end
   end
 end

data/lib/net/ssh/transport/constants.rb

@@ -1,5 +1,5 @@
-module Net 
-  module SSH 
+module Net
+  module SSH
     module Transport
       module Constants
         #--
@@ -12,7 +12,7 @@ module Net
         DEBUG                     = 4
         SERVICE_REQUEST           = 5
         SERVICE_ACCEPT            = 6
-    
+
         #--
         # Algorithm negotiation messages
         #++

data/lib/net/ssh/transport/ctr.rb

@@ -2,7 +2,7 @@ require 'openssl'
 require 'delegate'
 
 module Net::SSH::Transport
-  #:nodoc:
+  # :nodoc:
   class OpenSSLAESCTR < SimpleDelegator
     def initialize(original)
       super
@@ -26,13 +26,13 @@ module Net::SSH::Transport
     end
   end
 
-  #:nodoc:
+  # :nodoc:
   # Pure-Ruby implementation of Stateful Decryption Counter(SDCTR) Mode
   # for Block Ciphers. See RFC4344 for detail.
   module CTR
     def self.extended(orig)
       orig.instance_eval {
-        @remaining = ""
+        @remaining = String.new
         @counter = nil
         @counter_len = orig.block_size
         orig.encrypt
@@ -67,13 +67,13 @@ module Net::SSH::Transport
         end
 
         def reset
-          @remaining = ""
+          @remaining = String.new
         end
 
         def update(data)
           @remaining += data
 
-          encrypted = ""
+          encrypted = String.new
 
           offset = 0
           while (@remaining.bytesize - offset) >= block_size
@@ -89,13 +89,13 @@ module Net::SSH::Transport
 
         def final
           s = @remaining.empty? ? '' : xor!(@remaining, _update(@counter))
-          @remaining = ""
+          @remaining = String.new
           s
         end
 
         def xor!(s1, s2)
           s = []
-          s1.unpack('Q*').zip(s2.unpack('Q*')) {|a,b| s.push(a ^ b) }
+          s1.unpack('Q*').zip(s2.unpack('Q*')) {|a, b| s.push(a ^ b) }
           s.pack('Q*')
         end
         singleton_class.send(:private, :xor!)

data/lib/net/ssh/transport/hmac/abstract.rb

@@ -5,10 +5,9 @@ module Net
   module SSH
     module Transport
       module HMAC
-
         # The base class of all OpenSSL-based HMAC algorithm wrappers.
         class Abstract
-          class <<self
+          class << self
             def etm(*v)
               @etm = false if !defined?(@etm)
               if v.empty?
@@ -77,19 +76,19 @@ module Net
           # The key in use for this instance.
           attr_reader :key
 
-          def initialize(key=nil)
+          def initialize(key = nil)
             self.key = key
           end
 
           # Sets the key to the given value, truncating it so that it is the correct
           # length.
           def key=(value)
-            @key = value ? value.to_s[0,key_length] : nil
+            @key = value ? value.to_s[0, key_length] : nil
           end
 
           # Compute the HMAC digest for the given data string.
           def digest(data)
-            OpenSSL::HMAC.digest(digest_class.new, key, data)[0,mac_length]
+            OpenSSL::HMAC.digest(digest_class.new, key, data)[0, mac_length]
           end
         end
       end

data/lib/net/ssh/transport/hmac/md5.rb

@@ -1,12 +1,10 @@
 require 'net/ssh/transport/hmac/abstract'
 
 module Net::SSH::Transport::HMAC
-
   # The MD5 HMAC algorithm.
   class MD5 < Abstract
     mac_length   16
     key_length   16
     digest_class OpenSSL::Digest::MD5
   end
-
 end

data/lib/net/ssh/transport/hmac/md5_96.rb

@@ -1,11 +1,9 @@
 require 'net/ssh/transport/hmac/md5'
 
 module Net::SSH::Transport::HMAC
-
   # The MD5-96 HMAC algorithm. This returns only the first 12 bytes of
   # the digest.
   class MD5_96 < MD5
     mac_length 12
   end
-
 end

data/lib/net/ssh/transport/hmac/none.rb

@@ -1,7 +1,6 @@
 require 'net/ssh/transport/hmac/abstract'
 
 module Net::SSH::Transport::HMAC
-
   # The "none" algorithm. This has a key and mac length of 0.
   class None < Abstract
     key_length 0
@@ -11,5 +10,4 @@ module Net::SSH::Transport::HMAC
       ""
     end
   end
-
 end

data/lib/net/ssh/transport/hmac/ripemd160.rb

@@ -1,7 +1,6 @@
 require 'net/ssh/transport/hmac/abstract'
 
 module Net::SSH::Transport::HMAC
-
   # The RIPEMD-160 HMAC algorithm. This has a mac and key length of 20, and
   # uses the RIPEMD-160 digest algorithm.
   class RIPEMD160 < Abstract
@@ -9,5 +8,4 @@ module Net::SSH::Transport::HMAC
     key_length   20
     digest_class OpenSSL::Digest::RIPEMD160
   end
-
 end

data/lib/net/ssh/transport/hmac/sha1.rb

@@ -1,7 +1,6 @@
 require 'net/ssh/transport/hmac/abstract'
 
 module Net::SSH::Transport::HMAC
-
   # The SHA1 HMAC algorithm. This has a mac and key length of 20, and
   # uses the SHA1 digest algorithm.
   class SHA1 < Abstract
@@ -9,5 +8,4 @@ module Net::SSH::Transport::HMAC
     key_length   20
     digest_class OpenSSL::Digest::SHA1
   end
-
 end

data/lib/net/ssh/transport/hmac/sha1_96.rb

@@ -1,11 +1,9 @@
 require 'net/ssh/transport/hmac/sha1'
 
 module Net::SSH::Transport::HMAC
-
   # The SHA1-96 HMAC algorithm. This returns only the first 12 bytes of
   # the digest.
   class SHA1_96 < SHA1
     mac_length 12
   end
-
 end

data/lib/net/ssh/transport/hmac.rb

@@ -17,24 +17,24 @@ require 'net/ssh/transport/hmac/none'
 module Net::SSH::Transport::HMAC
   # The mapping of SSH hmac algorithms to their implementations
   MAP = {
-    'hmac-md5'                      => MD5,
-    'hmac-md5-96'                   => MD5_96,
-    'hmac-sha1'                     => SHA1,
-    'hmac-sha1-96'                  => SHA1_96,
-    'hmac-sha2-256'                 => SHA2_256,
-    'hmac-sha2-256-96'              => SHA2_256_96,
-    'hmac-sha2-512'                 => SHA2_512,
-    'hmac-sha2-512-96'              => SHA2_512_96,
+    'hmac-md5' => MD5,
+    'hmac-md5-96' => MD5_96,
+    'hmac-sha1' => SHA1,
+    'hmac-sha1-96' => SHA1_96,
+    'hmac-sha2-256' => SHA2_256,
+    'hmac-sha2-256-96' => SHA2_256_96,
+    'hmac-sha2-512' => SHA2_512,
+    'hmac-sha2-512-96' => SHA2_512_96,
     'hmac-sha2-256-etm@openssh.com' => SHA2_256_Etm,
     'hmac-sha2-512-etm@openssh.com' => SHA2_512_Etm,
-    'hmac-ripemd160'                => RIPEMD160,
-    'hmac-ripemd160@openssh.com'    => RIPEMD160,
-    'none'                          => None
+    'hmac-ripemd160' => RIPEMD160,
+    'hmac-ripemd160@openssh.com' => RIPEMD160,
+    'none' => None
   }
 
   # Retrieves a new hmac instance of the given SSH type (+name+). If +key+ is
   # given, the new instance will be initialized with that key.
-  def self.get(name, key="", parameters = {})
+  def self.get(name, key = "", parameters = {})
     impl = MAP[name] or raise ArgumentError, "hmac not found: #{name.inspect}"
     impl.new(Net::SSH::Transport::KeyExpander.expand_key(impl.key_length, key, parameters))
   end

data/lib/net/ssh/transport/identity_cipher.rb

@@ -1,59 +1,57 @@
-module Net 
-  module SSH 
+module Net
+  module SSH
     module Transport
-
       # A cipher that does nothing but pass the data through, unchanged. This
       # keeps things in the code nice and clean when a cipher has not yet been
       # determined (i.e., during key exchange).
       class IdentityCipher
-        class <<self
+        class << self
           # A default block size of 8 is required by the SSH2 protocol.
           def block_size
             8
           end
-    
+
           # Returns an arbitrary integer.
           def iv_len
             4
           end
-    
+
           # Does nothing. Returns self.
           def encrypt
             self
           end
-    
+
           # Does nothing. Returns self.
           def decrypt
             self
           end
-    
+
           # Passes its single argument through unchanged.
           def update(text)
             text
           end
-    
+
           # Returns the empty string.
           def final
             ""
           end
-    
+
           # The name of this cipher, which is "identity".
           def name
             "identity"
           end
-    
+
           # Does nothing. Returns nil.
           def iv=(v)
             nil
           end
-    
+
           # Does nothing. Returns self.
           def reset
             self
           end
         end
       end
-
     end
   end
 end

data/lib/net/ssh/transport/kex/abstract.rb

@@ -64,11 +64,16 @@ module Net
 
           private
 
+          def matching?(key_ssh_type, host_key_alg)
+            return true if key_ssh_type == host_key_alg
+            return true if key_ssh_type == 'ssh-rsa' && ['rsa-sha2-512', 'rsa-sha2-256'].include?(host_key_alg)
+          end
+
           # Verify that the given key is of the expected type, and that it
           # really is the key for the session's host. Raise Net::SSH::Exception
           # if it is not.
-          def verify_server_key(key) #:nodoc:
-            if key.ssh_type != algorithms.host_key
+          def verify_server_key(key) # :nodoc:
+            unless matching?(key.ssh_type, algorithms.host_key)
               raise Net::SSH::Exception, "host key algorithm mismatch '#{key.ssh_type}' != '#{algorithms.host_key}'"
             end
 
@@ -92,12 +97,14 @@ module Net
           # Verify the signature that was received. Raise Net::SSH::Exception
           # if the signature could not be verified. Otherwise, return the new
           # session-id.
-          def verify_signature(result) #:nodoc:
+          def verify_signature(result) # :nodoc:
             response = build_signature_buffer(result)
 
             hash = digester.digest(response.to_s)
 
-            unless connection.host_key_verifier.verify_signature { result[:server_key].ssh_do_verify(result[:server_sig], hash) }
+            server_key = result[:server_key]
+            server_sig = result[:server_sig]
+            unless connection.host_key_verifier.verify_signature { server_key.ssh_do_verify(server_sig, hash, host_key: algorithms.host_key) }
               raise Net::SSH::Exception, 'could not verify server signature'
             end
 
@@ -106,7 +113,7 @@ module Net
 
           # Send the NEWKEYS message, and expect the NEWKEYS message in
           # reply.
-          def confirm_newkeys #:nodoc:
+          def confirm_newkeys # :nodoc:
             # send own NEWKEYS message first (the wodSSHServer won't send first)
             response = Net::SSH::Buffer.new
             response.write_byte(NEWKEYS)

data/lib/net/ssh/transport/kex/abstract5656.rb

@@ -32,7 +32,7 @@ module Net
             response
           end
 
-          def send_kexinit #:nodoc:
+          def send_kexinit # :nodoc:
             init, reply = get_message_types
 
             # send the KEXECDH_INIT message

data/lib/net/ssh/transport/kex/curve25519_sha256.rb

@@ -1,6 +1,7 @@
 gem 'x25519' # raise if the gem x25519 is not installed
 
 require 'x25519'
+
 require 'net/ssh/transport/constants'
 require 'net/ssh/transport/kex/abstract5656'
 
@@ -17,7 +18,7 @@ module Net
 
           private
 
-          def generate_key #:nodoc:
+          def generate_key # :nodoc:
             ::X25519::Scalar.generate
           end
 

data/lib/net/ssh/transport/kex/diffie_hellman_group14_sha1.rb

@@ -1,8 +1,8 @@
 require 'net/ssh/transport/kex/diffie_hellman_group1_sha1'
 
-module Net 
-  module SSH 
-    module Transport 
+module Net
+  module SSH
+    module Transport
       module Kex
         # A key-exchange service implementing the "diffie-hellman-group14-sha1"
         # key-exchange algorithm. (defined in RFC 4253)
@@ -24,7 +24,7 @@ module Net
                 "B5C55DF0" "6F4C52C9" "DE2BCBF6" "95581718" +
                 "3995497C" "EA956AE5" "15D22618" "98FA0510" +
                 "15728E5A" "8AACAA68" "FFFFFFFF" "FFFFFFFF"
-      
+
           # The radix in which P_s represents the value of P
           P_r = 16
 

data/lib/net/ssh/transport/kex/diffie_hellman_group14_sha256.rb

@@ -0,0 +1,11 @@
+require 'net/ssh/transport/kex/diffie_hellman_group14_sha1'
+
+module Net::SSH::Transport::Kex
+  # A key-exchange service implementing the "diffie-hellman-group14-sha256"
+  # key-exchange algorithm.
+  class DiffieHellmanGroup14SHA256 < DiffieHellmanGroup14SHA1
+    def digester
+      OpenSSL::Digest::SHA256
+    end
+  end
+end

data/lib/net/ssh/transport/kex/diffie_hellman_group1_sha1.rb

@@ -59,26 +59,26 @@ module Net
 
           # Generate a DH key with a private key consisting of the given
           # number of bytes.
-          def generate_key #:nodoc:
-            dh = OpenSSL::PKey::DH.new
-
-            if dh.respond_to?(:set_pqg)
-              p, g = get_parameters
-              dh.set_pqg(p, nil, g)
+          def generate_key # :nodoc:
+            p, g = get_parameters
+
+            asn1 = OpenSSL::ASN1::Sequence(
+              [
+                OpenSSL::ASN1::Integer(p),
+                OpenSSL::ASN1::Integer(g)
+              ]
+            )
+
+            dh_params = OpenSSL::PKey::DH.new(asn1.to_der)
+            # XXX No private key size check! In theory the latter call should work but fails on OpenSSL 3.0 as
+            # dh_paramgen_subprime_len is now reserved for DHX algorithm
+            # key = OpenSSL::PKey.generate_key(dh_params, "dh_paramgen_subprime_len" => data[:need_bytes]/8)
+            if OpenSSL::PKey.respond_to?(:generate_key)
+              OpenSSL::PKey.generate_key(dh_params)
             else
-              dh.p, dh.g = get_parameters
-            end
-
-            dh.generate_key!
-            until dh.valid? && dh.priv_key.num_bytes == data[:need_bytes]
-              if dh.respond_to?(:set_key)
-                dh.set_key(nil, OpenSSL::BN.rand(data[:need_bytes] * 8))
-              else
-                dh.priv_key = OpenSSL::BN.rand(data[:need_bytes] * 8)
-              end
-              dh.generate_key!
+              dh_params.generate_key!
+              dh_params
             end
-            dh
           end
 
           # Send the KEXDH_INIT message, and expect the KEXDH_REPLY. Return the
@@ -86,7 +86,7 @@ module Net
           #
           # Parse the buffer from a KEXDH_REPLY message, returning a hash of
           # the extracted values.
-          def send_kexinit #:nodoc:
+          def send_kexinit # :nodoc:
             init, reply = get_message_types
 
             # send the KEXDH_INIT message
@@ -108,8 +108,8 @@ module Net
             sig_type = sig_buffer.read_string
             if sig_type != algorithms.host_key_format
               raise Net::SSH::Exception,
-                "host key algorithm mismatch for signature " +
-                "'#{sig_type}' != '#{algorithms.host_key_format}'"
+                    "host key algorithm mismatch for signature " +
+                    "'#{sig_type}' != '#{algorithms.host_key_format}'"
             end
             result[:server_sig] = sig_buffer.read_string