net-ssh 5.0.2 → 6.1.0

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

@@ -19,30 +19,17 @@ module Net
           "idea-cbc"                    => "idea-cbc",
           "cast128-cbc"                 => "cast-cbc",
           "rijndael-cbc@lysator.liu.se" => "aes-256-cbc",
-          "arcfour128"                  => "rc4",
-          "arcfour256"                  => "rc4",
-          "arcfour512"                  => "rc4",
-          "arcfour"                     => "rc4",
-    
           "3des-ctr"                    => "des-ede3",
           "blowfish-ctr"                => "bf-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"
-        }
-    
-        # Ruby's OpenSSL bindings always return a key length of 16 for RC4 ciphers
-        # resulting in the error: OpenSSL::CipherError: key length too short.
-        # The following ciphers will override this key length.
-        KEY_LEN_OVERRIDE = {
-          "arcfour256"                  => 32,
-          "arcfour512"                  => 64
+
+          'aes256-ctr'                  => 'aes-256-ctr',
+          'aes192-ctr'                  => 'aes-192-ctr',
+          'aes128-ctr'                  => 'aes-128-ctr',
+          'cast128-ctr'                 => 'cast5-ecb',
+
+          'none'                        => 'none'
         }
-    
+
         # Returns true if the underlying OpenSSL library supports the given cipher,
         # and false otherwise.
         def self.supported?(name)
@@ -72,12 +59,11 @@ module Net
               cipher = Net::SSH::Transport::OpenSSLAESCTR.new(cipher)
             end
           end
-          cipher.iv = Net::SSH::Transport::KeyExpander.expand_key(cipher.iv_len, options[:iv], options) if ossl_name != "rc4"
+          cipher.iv = Net::SSH::Transport::KeyExpander.expand_key(cipher.iv_len, options[:iv], options)
     
-          key_len = KEY_LEN_OVERRIDE[name] || cipher.key_len
+          key_len = cipher.key_len
           cipher.key_len = key_len
           cipher.key = Net::SSH::Transport::KeyExpander.expand_key(key_len, options[:key], options)
-          cipher.update(" " * 1536) if (ossl_name == "rc4" && name != "arcfour")
     
           return cipher
         end
@@ -94,13 +80,11 @@ module Net
             result << 0 if options[:iv_len]
           else
             cipher = OpenSSL::Cipher.new(ossl_name)
-            key_len = KEY_LEN_OVERRIDE[name] || cipher.key_len
+            key_len = cipher.key_len
             cipher.key_len = key_len
     
             block_size =
               case ossl_name
-              when "rc4"
-                8
               when /\-ctr/
                 Net::SSH::Transport::OpenSSLAESCTR.block_size
               else

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

@@ -2,11 +2,10 @@ module Net
   module SSH 
     module Transport
       module Constants
-    
         #--
         # Transport layer generic messages
         #++
-    
+
         DISCONNECT                = 1
         IGNORE                    = 2
         UNIMPLEMENTED             = 3
@@ -17,19 +16,24 @@ module Net
         #--
         # Algorithm negotiation messages
         #++
-    
+
         KEXINIT                   = 20
         NEWKEYS                   = 21
-    
+
         #--
         # Key exchange method specific messages
         #++
-    
+
         KEXDH_INIT                = 30
         KEXDH_REPLY               = 31
-    
+
         KEXECDH_INIT              = 30
         KEXECDH_REPLY             = 31
+
+        KEXDH_GEX_GROUP           = 31
+        KEXDH_GEX_INIT            = 32
+        KEXDH_GEX_REPLY           = 33
+        KEXDH_GEX_REQUEST         = 34
       end
     end
   end

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

@@ -88,14 +88,8 @@ module Net::SSH::Transport
         end
 
         def final
-          unless @remaining.empty?
-            s = xor!(@remaining, _update(@counter))
-          else
-            s = ""
-          end
-
+          s = @remaining.empty? ? '' : xor!(@remaining, _update(@counter))
           @remaining = ""
-
           s
         end
 

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

@@ -7,6 +7,8 @@ require 'net/ssh/transport/hmac/sha2_256'
 require 'net/ssh/transport/hmac/sha2_256_96'
 require 'net/ssh/transport/hmac/sha2_512'
 require 'net/ssh/transport/hmac/sha2_512_96'
+require 'net/ssh/transport/hmac/sha2_256_etm'
+require 'net/ssh/transport/hmac/sha2_512_etm'
 require 'net/ssh/transport/hmac/ripemd160'
 require 'net/ssh/transport/hmac/none'
 
@@ -15,21 +17,21 @@ 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-ripemd160' => RIPEMD160,
-    'hmac-ripemd160@openssh.com' => RIPEMD160,
-    'none' => None
+    '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
   }
 
-  # add mapping to sha2 hmac algorithms if they're available
-  MAP['hmac-sha2-256']    = SHA2_256    if defined?(::Net::SSH::Transport::HMAC::SHA2_256)
-  MAP['hmac-sha2-256-96'] = SHA2_256_96 if defined?(::Net::SSH::Transport::HMAC::SHA2_256_96)
-  MAP['hmac-sha2-512']    = SHA2_512    if defined?(::Net::SSH::Transport::HMAC::SHA2_512)
-  MAP['hmac-sha2-512-96'] = SHA2_512_96 if defined?(::Net::SSH::Transport::HMAC::SHA2_512_96)
-
   # 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 = {})

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

@@ -9,6 +9,18 @@ module Net
         # The base class of all OpenSSL-based HMAC algorithm wrappers.
         class Abstract
           class <<self
+            def etm(*v)
+              @etm = false if !defined?(@etm)
+              if v.empty?
+                @etm = superclass.etm if @etm.nil? && superclass.respond_to?(:etm)
+                return @etm
+              elsif v.length == 1
+                @etm = v.first
+              else
+                raise ArgumentError, "wrong number of arguments (#{v.length} for 1)"
+              end
+            end
+
             def key_length(*v)
               @key_length = nil if !defined?(@key_length)
               if v.empty?
@@ -46,6 +58,10 @@ module Net
             end
           end
 
+          def etm
+            self.class.etm
+          end
+
           def key_length
             self.class.key_length
           end

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

@@ -1,15 +1,11 @@
 require 'net/ssh/transport/hmac/abstract'
 
-if defined?(OpenSSL::Digest::SHA256) # need openssl support
-  module Net::SSH::Transport::HMAC
-
-    # The SHA-256 HMAC algorithm. This has a mac and key length of 32, and
-    # uses the SHA-256 digest algorithm.
-    class SHA2_256 < Abstract
-      mac_length   32
-      key_length   32
-      digest_class OpenSSL::Digest::SHA256
-    end
-
+module Net::SSH::Transport::HMAC
+  # The SHA-256 HMAC algorithm. This has a mac and key length of 32, and
+  # uses the SHA-256 digest algorithm.
+  class SHA2_256 < Abstract
+    mac_length   32
+    key_length   32
+    digest_class OpenSSL::Digest::SHA256
   end
 end

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

@@ -1,13 +1,9 @@
 require 'net/ssh/transport/hmac/abstract'
 
 module Net::SSH::Transport::HMAC
-
-  if defined?(SHA2_256) # need openssl support
-    # The SHA256-96 HMAC algorithm. This returns only the first 12 bytes of
-    # the digest.
-    class SHA2_256_96 < SHA2_256
-      mac_length 12
-    end
+  # The SHA256-96 HMAC algorithm. This returns only the first 12 bytes of
+  # the digest.
+  class SHA2_256_96 < SHA2_256
+    mac_length 12
   end
-
 end

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

@@ -0,0 +1,12 @@
+require 'net/ssh/transport/hmac/abstract'
+
+module Net::SSH::Transport::HMAC
+  # The SHA-256 Encrypt-Then-Mac HMAC algorithm. This has a mac and
+  # key length of 32, and uses the SHA-256 digest algorithm.
+  class SHA2_256_Etm < Abstract
+    etm          true
+    mac_length   32
+    key_length   32
+    digest_class OpenSSL::Digest::SHA256
+  end
+end

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

@@ -1,14 +1,11 @@
 require 'net/ssh/transport/hmac/abstract'
 
 module Net::SSH::Transport::HMAC
-
-  if defined?(OpenSSL::Digest::SHA512) # need openssl support
-    # The SHA-512 HMAC algorithm. This has a mac and key length of 64, and
-    # uses the SHA-512 digest algorithm.
-    class SHA2_512 < Abstract
-      mac_length   64
-      key_length   64
-      digest_class OpenSSL::Digest::SHA512
-    end
+  # The SHA-512 HMAC algorithm. This has a mac and key length of 64, and
+  # uses the SHA-512 digest algorithm.
+  class SHA2_512 < Abstract
+    mac_length   64
+    key_length   64
+    digest_class OpenSSL::Digest::SHA512
   end
 end

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

@@ -1,13 +1,9 @@
 require 'net/ssh/transport/hmac/abstract'
 
 module Net::SSH::Transport::HMAC
-
-  if defined?(SHA2_512) # need openssl support
-    # The SHA2-512-96 HMAC algorithm. This returns only the first 12 bytes of
-    # the digest.
-    class SHA2_512_96 < SHA2_512
-      mac_length 12
-    end
+  # The SHA2-512-96 HMAC algorithm. This returns only the first 12 bytes of
+  # the digest.
+  class SHA2_512_96 < SHA2_512
+    mac_length 12
   end
-
 end

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

@@ -0,0 +1,12 @@
+require 'net/ssh/transport/hmac/abstract'
+
+module Net::SSH::Transport::HMAC
+  # The SHA-512 Encrypt-Then-Mac HMAC algorithm. This has a mac and
+  # key length of 64, and uses the SHA-512 digest algorithm.
+  class SHA2_512_Etm < Abstract
+    etm          true
+    mac_length   64
+    key_length   64
+    digest_class OpenSSL::Digest::SHA512
+  end
+end

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

@@ -2,25 +2,28 @@ require 'net/ssh/transport/kex/diffie_hellman_group1_sha1'
 require 'net/ssh/transport/kex/diffie_hellman_group14_sha1'
 require 'net/ssh/transport/kex/diffie_hellman_group_exchange_sha1'
 require 'net/ssh/transport/kex/diffie_hellman_group_exchange_sha256'
+require 'net/ssh/transport/kex/ecdh_sha2_nistp256'
+require 'net/ssh/transport/kex/ecdh_sha2_nistp384'
+require 'net/ssh/transport/kex/ecdh_sha2_nistp521'
+require 'net/ssh/transport/kex/curve25519_sha256_loader'
 
 module Net::SSH::Transport
   module Kex
     # Maps the supported key-exchange algorithms as named by the SSH protocol
     # to their corresponding implementors.
     MAP = {
-      'diffie-hellman-group-exchange-sha1' => DiffieHellmanGroupExchangeSHA1,
-      'diffie-hellman-group1-sha1'         => DiffieHellmanGroup1SHA1,
-      'diffie-hellman-group14-sha1'        => DiffieHellmanGroup14SHA1
+      'diffie-hellman-group1-sha1'           => DiffieHellmanGroup1SHA1,
+      'diffie-hellman-group14-sha1'          => DiffieHellmanGroup14SHA1,
+      'diffie-hellman-group-exchange-sha1'   => DiffieHellmanGroupExchangeSHA1,
+      'diffie-hellman-group-exchange-sha256' => DiffieHellmanGroupExchangeSHA256,
+      'ecdh-sha2-nistp256'                   => EcdhSHA2NistP256,
+      'ecdh-sha2-nistp384'                   => EcdhSHA2NistP384,
+      'ecdh-sha2-nistp521'                   => EcdhSHA2NistP521
     }
-    MAP['diffie-hellman-group-exchange-sha256'] = DiffieHellmanGroupExchangeSHA256 if defined?(DiffieHellmanGroupExchangeSHA256)
-    if defined?(OpenSSL::PKey::EC)
-      require 'net/ssh/transport/kex/ecdh_sha2_nistp256'
-      require 'net/ssh/transport/kex/ecdh_sha2_nistp384'
-      require 'net/ssh/transport/kex/ecdh_sha2_nistp521'
 
-      MAP['ecdh-sha2-nistp256'] = EcdhSHA2NistP256
-      MAP['ecdh-sha2-nistp384'] = EcdhSHA2NistP384
-      MAP['ecdh-sha2-nistp521'] = EcdhSHA2NistP521
+    if Net::SSH::Transport::Kex::Curve25519Sha256Loader::LOADED
+      MAP['curve25519-sha256'] = Curve25519Sha256
+      MAP['curve25519-sha256@libssh.org'] = Curve25519Sha256
     end
   end
 end

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

@@ -0,0 +1,123 @@
+require 'net/ssh/buffer'
+require 'net/ssh/errors'
+require 'net/ssh/loggable'
+require 'net/ssh/transport/openssl'
+require 'net/ssh/transport/constants'
+
+module Net
+  module SSH
+    module Transport
+      module Kex
+        # Abstract class that implement Diffie-Hellman Key Exchange
+        # See https://tools.ietf.org/html/rfc4253#page-21
+        class Abstract
+          include Loggable
+          include Constants
+
+          attr_reader :algorithms
+          attr_reader :connection
+          attr_reader :data
+          attr_reader :dh
+
+          # Create a new instance of the Diffie-Hellman Key Exchange algorithm.
+          # The Diffie-Hellman (DH) key exchange provides a shared secret that
+          # cannot be determined by either party alone.  The key exchange is
+          # combined with a signature with the host key to provide host
+          # authentication.
+          def initialize(algorithms, connection, data)
+            @algorithms = algorithms
+            @connection = connection
+
+            @data = data.dup
+            @dh = generate_key
+            @logger = @data.delete(:logger)
+          end
+
+          # Perform the key-exchange for the given session, with the given
+          # data. This method will return a hash consisting of the
+          # following keys:
+          #
+          # * :session_id
+          # * :server_key
+          # * :shared_secret
+          # * :hashing_algorithm
+          #
+          # The caller is expected to be able to understand how to use these
+          # deliverables.
+          def exchange_keys
+            result = send_kexinit
+            verify_server_key(result[:server_key])
+            session_id = verify_signature(result)
+            confirm_newkeys
+
+            {
+              session_id: session_id,
+              server_key: result[:server_key],
+              shared_secret: result[:shared_secret],
+              hashing_algorithm: digester
+            }
+          end
+
+          def digester
+            raise NotImplementedError, 'abstract class: digester not implemented'
+          end
+
+          private
+
+          # 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
+              raise Net::SSH::Exception, "host key algorithm mismatch '#{key.ssh_type}' != '#{algorithms.host_key}'"
+            end
+
+            blob, fingerprint = generate_key_fingerprint(key)
+
+            unless connection.host_key_verifier.verify(key: key, key_blob: blob, fingerprint: fingerprint, session: connection)
+              raise Net::SSH::Exception, 'host key verification failed'
+            end
+          end
+
+          def generate_key_fingerprint(key)
+            blob = Net::SSH::Buffer.from(:key, key).to_s
+
+            fingerprint = Net::SSH::Authentication::PubKeyFingerprint.fingerprint(blob, @connection.options[:fingerprint_hash] || 'SHA256')
+
+            [blob, fingerprint]
+          rescue StandardError => e
+            [nil, "(could not generate fingerprint: #{e.message})"]
+          end
+
+          # 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:
+            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) }
+              raise Net::SSH::Exception, 'could not verify server signature'
+            end
+
+            hash
+          end
+
+          # Send the NEWKEYS message, and expect the NEWKEYS message in
+          # reply.
+          def confirm_newkeys #:nodoc:
+            # send own NEWKEYS message first (the wodSSHServer won't send first)
+            response = Net::SSH::Buffer.new
+            response.write_byte(NEWKEYS)
+            connection.send_message(response)
+
+            # wait for the server's NEWKEYS message
+            buffer = connection.next_message
+            raise Net::SSH::Exception, 'expected NEWKEYS' unless buffer.type == NEWKEYS
+          end
+        end
+      end
+    end
+  end
+end