net-ssh 5.2.0 → 6.0.0

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

@@ -4,13 +4,9 @@ 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 Loggable
-          include Constants
-      
           # The value of 'P', as a string, in hexadecimal
           P_s = "FFFFFFFF" "FFFFFFFF" "C90FDAA2" "2168C234" +
                 "C4C6628B" "80DC1CD1" "29024E08" "8A67CC74" +
@@ -31,19 +27,9 @@ module Net
       
           # 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
-          end
         end
       end
     end

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

@@ -1,20 +1,12 @@
-require 'net/ssh/buffer'
-require 'net/ssh/errors'
-require 'net/ssh/loggable'
-require 'net/ssh/transport/openssl'
-require 'net/ssh/transport/constants'
+require 'net/ssh/transport/kex/abstract'
 
 module Net
   module SSH
     module Transport
       module Kex
-
         # A key-exchange service implementing the "diffie-hellman-group1-sha1"
         # key-exchange algorithm.
-        class DiffieHellmanGroup1SHA1
-          include Loggable
-          include Constants
-
+        class DiffieHellmanGroup1SHA1 < Abstract
           # The value of 'P', as a string, in hexadecimal
           P_s = "FFFFFFFF" "FFFFFFFF" "C90FDAA2" "2168C234" +
                 "C4C6628B" "80DC1CD1" "29024E08" "8A67CC74" +
@@ -31,67 +23,18 @@ module Net
           # The group constant
           G = 2
 
-          attr_reader :p
-          attr_reader :g
-          attr_reader :digester
-          attr_reader :algorithms
-          attr_reader :connection
-          attr_reader :data
-          attr_reader :dh
-
-          # Create a new instance of the DiffieHellmanGroup1SHA1 algorithm.
-          # The data is a Hash of symbols representing information
-          # required by this algorithm, which was acquired during earlier
-          # processing.
-          def initialize(algorithms, connection, data)
-            @p = get_p
-            @g = get_g
-
-            @digester = OpenSSL::Digest::SHA1
-            @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
-
-            return { session_id: session_id,
-                     server_key: result[:server_key],
-                     shared_secret: result[:shared_secret],
-                     hashing_algorithm: digester }
+          def digester
+            OpenSSL::Digest::SHA1
           end
 
           private
 
-          def get_p
-            OpenSSL::BN.new(P_s, P_r)
-          end
-
-          def get_g
-            G
-          end
-
-          # Returns the DH key parameters for the current connection.
+          # Returns the DH key parameters for the current connection. [p, q]
           def get_parameters
-            [p, g]
+            [
+              OpenSSL::BN.new(self.class::P_s, self.class::P_r),
+              self.class::G
+            ]
           end
 
           # Returns the INIT/REPLY constants used by this algorithm.
@@ -172,59 +115,7 @@ module Net
 
             return result
           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
-              raise Net::SSH::Exception,
-                "host key algorithm mismatch " +
-                "'#{key.ssh_type}' != '#{algorithms.host_key}'"
-            end
-
-            blob, fingerprint = generate_key_fingerprint(key)
-
-            raise Net::SSH::Exception, "host key verification failed" unless connection.host_key_verifier.verify(key: key, key_blob: blob, fingerprint: fingerprint, session: connection)
-          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 ::Exception => 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)
-
-            raise Net::SSH::Exception, "could not verify server signature" unless connection.host_key_verifier.verify_signature { result[:server_key].ssh_do_verify(result[:server_sig], hash) }
-
-            return 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

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

@@ -3,18 +3,12 @@ require 'net/ssh/transport/constants'
 require 'net/ssh/transport/kex/diffie_hellman_group1_sha1'
 
 module Net::SSH::Transport::Kex
-
   # A key-exchange service implementing the
   # "diffie-hellman-group-exchange-sha1" key-exchange algorithm.
   class DiffieHellmanGroupExchangeSHA1 < DiffieHellmanGroup1SHA1
     MINIMUM_BITS      = 1024
     MAXIMUM_BITS      = 8192
 
-    KEXDH_GEX_GROUP   = 31
-    KEXDH_GEX_INIT    = 32
-    KEXDH_GEX_REPLY   = 33
-    KEXDH_GEX_REQUEST = 34
-
     private
 
     # Compute the number of bits needed for the given number of bytes.

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

@@ -1,15 +1,11 @@
 require 'net/ssh/transport/kex/diffie_hellman_group_exchange_sha1'
 
 module Net::SSH::Transport::Kex
-  if defined?(OpenSSL::Digest::SHA256)
-    # A key-exchange service implementing the
-    # "diffie-hellman-group-exchange-sha256" key-exchange algorithm.
-    class DiffieHellmanGroupExchangeSHA256 < DiffieHellmanGroupExchangeSHA1
-      def initialize(*args)
-        super(*args)
-
-        @digester = OpenSSL::Digest::SHA256
-      end
+  # A key-exchange service implementing the
+  # "diffie-hellman-group-exchange-sha256" key-exchange algorithm.
+  class DiffieHellmanGroupExchangeSHA256 < DiffieHellmanGroupExchangeSHA1
+    def digester
+      OpenSSL::Digest::SHA256
     end
   end
 end

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

@@ -1,97 +1,36 @@
-require 'net/ssh/transport/constants'
-require 'net/ssh/transport/kex/diffie_hellman_group1_sha1'
+require 'net/ssh/transport/kex/abstract5656'
 
-module Net 
-  module SSH 
-    module Transport 
+module Net
+  module SSH
+    module Transport
       module Kex
-
         # A key-exchange service implementing the "ecdh-sha2-nistp256"
         # key-exchange algorithm. (defined in RFC 5656)
-        class EcdhSHA2NistP256 < DiffieHellmanGroup1SHA1
-          include Loggable
-          include Constants
-      
-          attr_reader :ecdh
-      
+        class EcdhSHA2NistP256 < Abstract5656
           def digester
             OpenSSL::Digest::SHA256
           end
-      
+
           def curve_name
             OpenSSL::PKey::EC::CurveNameAlias['nistp256']
           end
-      
-          def initialize(algorithms, connection, data)
-            @algorithms = algorithms
-            @connection = connection
-      
-            @digester = digester
-            @data = data.dup
-            @ecdh = generate_key
-            @logger = @data.delete(:logger)
-          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.to_bn.to_s(2),
-                                  result[:server_ecdh_pubkey]
-            response.write_bignum result[:shared_secret]
-            response
-          end
-      
+
           def generate_key #:nodoc:
             OpenSSL::PKey::EC.new(curve_name).generate_key
           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.to_bn.to_s(2))
-            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 = Hash.new
-            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
-      
-            # compute shared secret from server's public key and client's private key
+
+          # compute shared secret from server's public key and client's private key
+          def compute_shared_secret(server_ecdh_pubkey)
             pk = OpenSSL::PKey::EC::Point.new(OpenSSL::PKey::EC.new(curve_name).group,
-                                              OpenSSL::BN.new(result[:server_ecdh_pubkey], 2))
-            result[:shared_secret] = OpenSSL::BN.new(ecdh.dh_compute_key(pk), 2)
-      
-            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
-      
-            return result
+                                              OpenSSL::BN.new(server_ecdh_pubkey, 2))
+            OpenSSL::BN.new(ecdh.dh_compute_key(pk), 2)
+          end
+
+          ## string   Q_C, client's ephemeral public key octet string
+          def ecdh_public_key_bytes
+            ecdh.public_key.to_bn.to_s(2)
           end
         end
       end

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

@@ -1,8 +1,9 @@
-module Net 
-  module SSH 
-    module Transport 
-      module Kex
+require 'net/ssh/transport/kex/ecdh_sha2_nistp256'
 
+module Net
+  module SSH
+    module Transport
+      module Kex
         # A key-exchange service implementing the "ecdh-sha2-nistp256"
         # key-exchange algorithm. (defined in RFC 5656)
         class EcdhSHA2NistP384 < EcdhSHA2NistP256

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

@@ -1,8 +1,9 @@
-module Net 
-  module SSH 
-    module Transport 
-      module Kex
+require 'net/ssh/transport/kex/ecdh_sha2_nistp256'
 
+module Net
+  module SSH
+    module Transport
+      module Kex
         # A key-exchange service implementing the "ecdh-sha2-nistp521"
         # key-exchange algorithm. (defined in RFC 5656)
         class EcdhSHA2NistP521 < EcdhSHA2NistP256

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

@@ -98,9 +98,9 @@ module OpenSSL
         sig_r = sig[0,20].unpack("H*")[0].to_i(16)
         sig_s = sig[20,20].unpack("H*")[0].to_i(16)
         a1sig = OpenSSL::ASN1::Sequence([
-           OpenSSL::ASN1::Integer(sig_r),
-           OpenSSL::ASN1::Integer(sig_s)
-        ])
+                                          OpenSSL::ASN1::Integer(sig_r),
+                                          OpenSSL::ASN1::Integer(sig_s)
+                                        ])
         return verify(OpenSSL::Digest::SHA1.new, a1sig.to_der, data)
       end
 
@@ -121,132 +121,129 @@ module OpenSSL
       end
     end
 
-    if defined?(OpenSSL::PKey::EC)
-      # This class is originally defined in the OpenSSL module. As needed, methods
-      # have been added to it by the Net::SSH module for convenience in dealing
-      # with SSH functionality.
-      class EC
-        CurveNameAlias = {
-          "nistp256" => "prime256v1",
-          "nistp384" => "secp384r1",
-          "nistp521" => "secp521r1"
-        }
-
-        CurveNameAliasInv = {
-          "prime256v1" => "nistp256",
-          "secp384r1" => "nistp384",
-          "secp521r1" => "nistp521"
-        }
-
-        def self.read_keyblob(curve_name_in_type, buffer)
-          curve_name_in_key = buffer.read_string
-          raise Net::SSH::Exception, "curve name mismatched (`#{curve_name_in_key}' with `#{curve_name_in_type}')" unless curve_name_in_type == curve_name_in_key
-          public_key_oct = buffer.read_string
-          begin
-            key = OpenSSL::PKey::EC.new(OpenSSL::PKey::EC::CurveNameAlias[curve_name_in_key])
-            group = key.group
-            point = OpenSSL::PKey::EC::Point.new(group, OpenSSL::BN.new(public_key_oct, 2))
-            key.public_key = point
-
-            return key
-          rescue OpenSSL::PKey::ECError
-            raise NotImplementedError, "unsupported key type `#{type}'"
-          end
+    # This class is originally defined in the OpenSSL module. As needed, methods
+    # have been added to it by the Net::SSH module for convenience in dealing
+    # with SSH functionality.
+    class EC
+      CurveNameAlias = {
+        'nistp256' => 'prime256v1',
+        'nistp384' => 'secp384r1',
+        'nistp521' => 'secp521r1'
+      }.freeze
+
+      CurveNameAliasInv = {
+        'prime256v1' => 'nistp256',
+        'secp384r1' => 'nistp384',
+        'secp521r1' => 'nistp521'
+      }.freeze
+
+      def self.read_keyblob(curve_name_in_type, buffer)
+        curve_name_in_key = buffer.read_string
+
+        unless curve_name_in_type == curve_name_in_key
+          raise Net::SSH::Exception, "curve name mismatched (`#{curve_name_in_key}' with `#{curve_name_in_type}')"
         end
 
-        # Returns the description of this key type used by the
-        # SSH2 protocol, like "ecdsa-sha2-nistp256"
-        def ssh_type
-          "ecdsa-sha2-#{CurveNameAliasInv[self.group.curve_name]}"
-        end
+        public_key_oct = buffer.read_string
+        begin
+          key = OpenSSL::PKey::EC.new(OpenSSL::PKey::EC::CurveNameAlias[curve_name_in_key])
+          group = key.group
+          point = OpenSSL::PKey::EC::Point.new(group, OpenSSL::BN.new(public_key_oct, 2))
+          key.public_key = point
 
-        def ssh_signature_type
-          ssh_type
+          return key
+        rescue OpenSSL::PKey::ECError
+          raise NotImplementedError, "unsupported key type `#{type}'"
         end
+      end
 
-        def digester
-          if self.group.curve_name =~ /^[a-z]+(\d+)\w*\z/
-            curve_size = $1.to_i
-            if curve_size <= 256
-              OpenSSL::Digest::SHA256.new
-            elsif curve_size <= 384
-              OpenSSL::Digest::SHA384.new
-            else
-              OpenSSL::Digest::SHA512.new
-            end
-          else
+      # Returns the description of this key type used by the
+      # SSH2 protocol, like "ecdsa-sha2-nistp256"
+      def ssh_type
+        "ecdsa-sha2-#{CurveNameAliasInv[group.curve_name]}"
+      end
+
+      def ssh_signature_type
+        ssh_type
+      end
+
+      def digester
+        if group.curve_name =~ /^[a-z]+(\d+)\w*\z/
+          curve_size = Regexp.last_match(1).to_i
+          if curve_size <= 256
             OpenSSL::Digest::SHA256.new
+          elsif curve_size <= 384
+            OpenSSL::Digest::SHA384.new
+          else
+            OpenSSL::Digest::SHA512.new
           end
+        else
+          OpenSSL::Digest::SHA256.new
         end
-        private :digester
+      end
+      private :digester
 
-        # Converts the key to a blob, according to the SSH2 protocol.
-        def to_blob
-          @blob ||= Net::SSH::Buffer.from(:string, ssh_type,
-                                          :string, CurveNameAliasInv[self.group.curve_name],
-                                          :mstring, self.public_key.to_bn.to_s(2)).to_s
-          @blob
-        end
+      # Converts the key to a blob, according to the SSH2 protocol.
+      def to_blob
+        @blob ||= Net::SSH::Buffer.from(:string, ssh_type,
+                                        :string, CurveNameAliasInv[group.curve_name],
+                                        :mstring, public_key.to_bn.to_s(2)).to_s
+        @blob
+      end
 
-        # Verifies the given signature matches the given data.
-        def ssh_do_verify(sig, data)
-          digest = digester.digest(data)
-          a1sig = nil
+      # Verifies the given signature matches the given data.
+      def ssh_do_verify(sig, data)
+        digest = digester.digest(data)
+        a1sig = nil
 
-          begin
-            sig_r_len = sig[0,4].unpack("H*")[0].to_i(16)
-            sig_l_len = sig[4 + sig_r_len,4].unpack("H*")[0].to_i(16)
+        begin
+          sig_r_len = sig[0, 4].unpack('H*')[0].to_i(16)
+          sig_l_len = sig[4 + sig_r_len, 4].unpack('H*')[0].to_i(16)
 
-            sig_r = sig[4,sig_r_len].unpack("H*")[0]
-            sig_s = sig[4 + sig_r_len + 4,sig_l_len].unpack("H*")[0]
+          sig_r = sig[4, sig_r_len].unpack('H*')[0]
+          sig_s = sig[4 + sig_r_len + 4, sig_l_len].unpack('H*')[0]
 
-            a1sig = OpenSSL::ASN1::Sequence([
-              OpenSSL::ASN1::Integer(sig_r.to_i(16)),
-              OpenSSL::ASN1::Integer(sig_s.to_i(16))
-            ])
-          rescue StandardError
-          end
+          a1sig = OpenSSL::ASN1::Sequence([
+                                            OpenSSL::ASN1::Integer(sig_r.to_i(16)),
+                                            OpenSSL::ASN1::Integer(sig_s.to_i(16))
+                                          ])
+        rescue StandardError
+        end
 
-          if a1sig == nil
-            return false
-          else
-            dsa_verify_asn1(digest, a1sig.to_der)
-          end
+        if a1sig.nil?
+          return false
+        else
+          dsa_verify_asn1(digest, a1sig.to_der)
         end
+      end
+
+      # Returns the signature for the given data.
+      def ssh_do_sign(data)
+        digest = digester.digest(data)
+        sig = dsa_sign_asn1(digest)
+        a1sig = OpenSSL::ASN1.decode(sig)
 
-        # Returns the signature for the given data.
-        def ssh_do_sign(data)
-          digest = digester.digest(data)
-          sig = dsa_sign_asn1(digest)
-          a1sig = OpenSSL::ASN1.decode(sig)
+        sig_r = a1sig.value[0].value
+        sig_s = a1sig.value[1].value
 
-          sig_r = a1sig.value[0].value
-          sig_s = a1sig.value[1].value
+        Net::SSH::Buffer.from(:bignum, sig_r, :bignum, sig_s).to_s
+      end
 
-          return Net::SSH::Buffer.from(:bignum, sig_r, :bignum, sig_s).to_s
+      class Point
+        # Returns the description of this key type used by the
+        # SSH2 protocol, like "ecdsa-sha2-nistp256"
+        def ssh_type
+          "ecdsa-sha2-#{CurveNameAliasInv[group.curve_name]}"
         end
 
-        class Point
-          # Returns the description of this key type used by the
-          # SSH2 protocol, like "ecdsa-sha2-nistp256"
-          def ssh_type
-            "ecdsa-sha2-#{CurveNameAliasInv[self.group.curve_name]}"
-          end
-
-          # Converts the key to a blob, according to the SSH2 protocol.
-          def to_blob
-            @blob ||= Net::SSH::Buffer.from(:string, ssh_type,
-                                            :string, CurveNameAliasInv[self.group.curve_name],
-                                            :mstring, self.to_bn.to_s(2)).to_s
-            @blob
-          end
+        # Converts the key to a blob, according to the SSH2 protocol.
+        def to_blob
+          @blob ||= Net::SSH::Buffer.from(:string, ssh_type,
+                                          :string, CurveNameAliasInv[group.curve_name],
+                                          :mstring, to_bn.to_s(2)).to_s
+          @blob
         end
       end
-    else
-      class OpenSSL::PKey::ECError < RuntimeError
-        # for compatibility with interpreters
-        # without EC support (i.e. JRuby)
-      end
     end
   end
 end