net-ssh 4.2.0 → 7.0.1

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/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,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-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
+    '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 = {})
+  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,55 +1,57 @@
-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
-      # 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
+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
+          # 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; end; end
+end

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

@@ -0,0 +1,130 @@
+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
+
+          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:
+            unless matching?(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)
+
+            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
+
+            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

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

@@ -0,0 +1,72 @@
+require 'net/ssh/transport/kex/abstract'
+
+module Net
+  module SSH
+    module Transport
+      module Kex
+        # Implement key-exchange algorithm from Elliptic Curve Algorithm Integration
+        # in the Secure Shell Transport Layer (RFC 5656)
+        class Abstract5656 < Abstract
+          alias ecdh dh
+
+          def curve_name
+            raise NotImplementedError, 'abstract class: curve_name not implemented'
+          end
+
+          private
+
+          def get_message_types
+            [KEXECDH_INIT, KEXECDH_REPLY]
+          end
+
+          def build_signature_buffer(result)
+            response = Net::SSH::Buffer.new
+            response.write_string data[:client_version_string],
+                                  data[:server_version_string],
+                                  data[:client_algorithm_packet],
+                                  data[:server_algorithm_packet],
+                                  result[:key_blob],
+                                  ecdh_public_key_bytes,
+                                  result[:server_ecdh_pubkey]
+            response.write_bignum result[:shared_secret]
+            response
+          end
+
+          def send_kexinit # :nodoc:
+            init, reply = get_message_types
+
+            # send the KEXECDH_INIT message
+            ## byte     SSH_MSG_KEX_ECDH_INIT
+            ## string   Q_C, client's ephemeral public key octet string
+            buffer = Net::SSH::Buffer.from(:byte, init, :mstring, ecdh_public_key_bytes)
+            connection.send_message(buffer)
+
+            # expect the following KEXECDH_REPLY message
+            ## byte     SSH_MSG_KEX_ECDH_REPLY
+            ## string   K_S, server's public host key
+            ## string   Q_S, server's ephemeral public key octet string
+            ## string   the signature on the exchange hash
+            buffer = connection.next_message
+            raise Net::SSH::Exception, 'expected REPLY' unless buffer.type == reply
+
+            result = {}
+            result[:key_blob] = buffer.read_string
+            result[:server_key] = Net::SSH::Buffer.new(result[:key_blob]).read_key
+            result[:server_ecdh_pubkey] = buffer.read_string
+            result[:shared_secret] = compute_shared_secret(result[:server_ecdh_pubkey])
+
+            sig_buffer = Net::SSH::Buffer.new(buffer.read_string)
+            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}'"
+            end
+
+            result[:server_sig] = sig_buffer.read_string
+
+            result
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+gem 'x25519' # raise if the gem x25519 is not installed
+
+require 'x25519'
+
+require 'net/ssh/transport/constants'
+require 'net/ssh/transport/kex/abstract5656'
+
+module Net
+  module SSH
+    module Transport
+      module Kex
+        # A key-exchange service implementing the "curve25519-sha256@libssh.org"
+        # key-exchange algorithm. (defined in https://tools.ietf.org/html/draft-ietf-curdle-ssh-curves-06)
+        class Curve25519Sha256 < Abstract5656
+          def digester
+            OpenSSL::Digest::SHA256
+          end
+
+          private
+
+          def generate_key # :nodoc:
+            ::X25519::Scalar.generate
+          end
+
+          ## string   Q_C, client's ephemeral public key octet string
+          def ecdh_public_key_bytes
+            ecdh.public_key.to_bytes
+          end
+
+          # compute shared secret from server's public key and client's private key
+          def compute_shared_secret(server_ecdh_pubkey)
+            pk = ::X25519::MontgomeryU.new(server_ecdh_pubkey)
+            OpenSSL::BN.new(ecdh.diffie_hellman(pk).to_bytes, 2)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Net
+  module SSH
+    module Transport
+      module Kex
+        # Loads Curve25519Sha256 support which requires optinal dependencies
+        module Curve25519Sha256Loader
+          begin
+            require 'net/ssh/transport/kex/curve25519_sha256'
+            LOADED = true
+            ERROR = nil
+          rescue LoadError => e
+            ERROR = e
+            LOADED = false
+          end
+
+          def self.raiseUnlessLoaded(message)
+            description = ERROR.is_a?(LoadError) ? dependenciesRequiredForX25519 : ''
+            description << "#{ERROR.class} : \"#{ERROR.message}\"\n" if ERROR
+            raise NotImplementedError, "#{message}\n#{description}" unless LOADED
+          end
+
+          def self.dependenciesRequiredForX25519
+            result = "net-ssh requires the following gems for x25519 support:\n"
+            result << " * x25519\n"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,44 +1,37 @@
 require 'net/ssh/transport/kex/diffie_hellman_group1_sha1'
 
-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)
-  class DiffieHellmanGroup14SHA1 < DiffieHellmanGroup1SHA1
-    include Constants, Loggable
-
-    # The value of 'P', as a string, in hexadecimal
-    P_s = "FFFFFFFF" "FFFFFFFF" "C90FDAA2" "2168C234" +
-          "C4C6628B" "80DC1CD1" "29024E08" "8A67CC74" +
-          "020BBEA6" "3B139B22" "514A0879" "8E3404DD" +
-          "EF9519B3" "CD3A431B" "302B0A6D" "F25F1437" +
-          "4FE1356D" "6D51C245" "E485B576" "625E7EC6" +
-          "F44C42E9" "A637ED6B" "0BFF5CB6" "F406B7ED" +
-          "EE386BFB" "5A899FA5" "AE9F2411" "7C4B1FE6" +
-          "49286651" "ECE45B3D" "C2007CB8" "A163BF05" +
-          "98DA4836" "1C55D39A" "69163FA8" "FD24CF5F" +
-          "83655D23" "DCA3AD96" "1C62F356" "208552BB" +
-          "9ED52907" "7096966D" "670C354E" "4ABC9804" +
-          "F1746C08" "CA18217C" "32905E46" "2E36CE3B" +
-          "E39E772C" "180E8603" "9B2783A2" "EC07A28F" +
-          "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
-
-    # The group constant
-    G = 2
-
-    private
-
-    def get_p
-      OpenSSL::BN.new(P_s, P_r)
-    end
-
-    def get_g
-      G
+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)
+        class DiffieHellmanGroup14SHA1 < DiffieHellmanGroup1SHA1
+          # The value of 'P', as a string, in hexadecimal
+          P_s = "FFFFFFFF" "FFFFFFFF" "C90FDAA2" "2168C234" +
+                "C4C6628B" "80DC1CD1" "29024E08" "8A67CC74" +
+                "020BBEA6" "3B139B22" "514A0879" "8E3404DD" +
+                "EF9519B3" "CD3A431B" "302B0A6D" "F25F1437" +
+                "4FE1356D" "6D51C245" "E485B576" "625E7EC6" +
+                "F44C42E9" "A637ED6B" "0BFF5CB6" "F406B7ED" +
+                "EE386BFB" "5A899FA5" "AE9F2411" "7C4B1FE6" +
+                "49286651" "ECE45B3D" "C2007CB8" "A163BF05" +
+                "98DA4836" "1C55D39A" "69163FA8" "FD24CF5F" +
+                "83655D23" "DCA3AD96" "1C62F356" "208552BB" +
+                "9ED52907" "7096966D" "670C354E" "4ABC9804" +
+                "F1746C08" "CA18217C" "32905E46" "2E36CE3B" +
+                "E39E772C" "180E8603" "9B2783A2" "EC07A28F" +
+                "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
+
+          # The group constant
+          G = 2
+        end
+      end
     end
   end
-end; end; end; end
+end

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