net-ssh 4.2.0 → 7.0.1

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

@@ -1,227 +1,122 @@
-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
-
-  # A key-exchange service implementing the "diffie-hellman-group1-sha1"
-  # key-exchange algorithm.
-  class 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" "ECE65381" "FFFFFFFF" "FFFFFFFF"
-
-    # The radix in which P_s represents the value of P
-    P_r = 16
-
-    # 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 }
-    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.
-      def get_parameters
-        [p, g]
-      end
-
-      # Returns the INIT/REPLY constants used by this algorithm.
-      def get_message_types
-        [KEXDH_INIT, KEXDH_REPLY]
-      end
-
-      # Build the signature buffer to use when verifying a signature from
-      # the server.
-      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]
-        response.write_bignum dh.pub_key,
-                              result[:server_dh_pubkey],
-                              result[:shared_secret]
-        response
-      end
-
-      # 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)
-        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)
+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 < Abstract
+          # 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" "ECE65381" "FFFFFFFF" "FFFFFFFF"
+
+          # The radix in which P_s represents the value of P
+          P_r = 16
+
+          # The group constant
+          G = 2
+
+          def digester
+            OpenSSL::Digest::SHA1
           end
-          dh.generate_key!
-        end
-        dh
-      end
 
-      # Send the KEXDH_INIT message, and expect the KEXDH_REPLY. Return the
-      # resulting buffer.
-      #
-      # Parse the buffer from a KEXDH_REPLY message, returning a hash of
-      # the extracted values.
-      def send_kexinit #:nodoc:
-        init, reply = get_message_types
-
-        # send the KEXDH_INIT message
-        buffer = Net::SSH::Buffer.from(:byte, init, :bignum, dh.pub_key)
-        connection.send_message(buffer)
-
-        # expect the KEXDH_REPLY message
-        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_dh_pubkey] = buffer.read_bignum
-        result[:shared_secret] = OpenSSL::BN.new(dh.compute_key(result[:server_dh_pubkey]), 2)
-
-        sig_buffer = Net::SSH::Buffer.new(buffer.read_string)
-        sig_type = sig_buffer.read_string
-        if sig_type != algorithms.host_key
-          raise Net::SSH::Exception,
-            "host key algorithm mismatch for signature " +
-            "'#{sig_type}' != '#{algorithms.host_key}'"
-        end
-        result[:server_sig] = sig_buffer.read_string
-
-        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
+          private
 
-        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 = OpenSSL::Digest::MD5.hexdigest(blob).scan(/../).join(":")
+          # Returns the DH key parameters for the current connection. [p, q]
+          def get_parameters
+            [
+              OpenSSL::BN.new(self.class::P_s, self.class::P_r),
+              self.class::G
+            ]
+          end
 
-        [blob, fingerprint]
-      rescue ::Exception => e
-        [nil, "(could not generate fingerprint: #{e.message})"]
-      end
+          # Returns the INIT/REPLY constants used by this algorithm.
+          def get_message_types
+            [KEXDH_INIT, KEXDH_REPLY]
+          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)
+          # Build the signature buffer to use when verifying a signature from
+          # the server.
+          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]
+            response.write_bignum dh.pub_key,
+                                  result[:server_dh_pubkey],
+                                  result[:shared_secret]
+            response
+          end
 
-        hash = @digester.digest(response.to_s)
+          # Generate a DH key with a private key consisting of the given
+          # number of bytes.
+          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_params.generate_key!
+              dh_params
+            end
+          end
 
-        unless result[:server_key].ssh_do_verify(result[:server_sig], hash)
-          raise Net::SSH::Exception, "could not verify server signature"
+          # Send the KEXDH_INIT message, and expect the KEXDH_REPLY. Return the
+          # resulting buffer.
+          #
+          # Parse the buffer from a KEXDH_REPLY message, returning a hash of
+          # the extracted values.
+          def send_kexinit # :nodoc:
+            init, reply = get_message_types
+
+            # send the KEXDH_INIT message
+            buffer = Net::SSH::Buffer.from(:byte, init, :bignum, dh.pub_key)
+            connection.send_message(buffer)
+
+            # expect the KEXDH_REPLY message
+            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_dh_pubkey] = buffer.read_bignum
+            result[:shared_secret] = OpenSSL::BN.new(dh.compute_key(result[:server_dh_pubkey]), 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
+          end
         end
-
-        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; end; end
+end

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

@@ -3,80 +3,70 @@ 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.
-      def compute_need_bits
-
-        # for Compatibility: OpenSSH requires (need_bits * 2 + 1) length of parameter
-        need_bits = data[:need_bytes] * 8 * 2 + 1
-
-        data[:minimum_dh_bits] ||= MINIMUM_BITS
-
-        if need_bits < data[:minimum_dh_bits]
-          need_bits = data[:minimum_dh_bits]
-        elsif need_bits > MAXIMUM_BITS
-          need_bits = MAXIMUM_BITS
-        end
-
-        data[:need_bits ] = need_bits
-        data[:need_bytes] = need_bits / 8
-      end
-
-      # Returns the DH key parameters for the given session.
-      def get_parameters
-        compute_need_bits
-
-        # request the DH key parameters for the given number of bits.
-        buffer = Net::SSH::Buffer.from(:byte, KEXDH_GEX_REQUEST, :long, data[:minimum_dh_bits],
-          :long, data[:need_bits], :long, MAXIMUM_BITS)
-        connection.send_message(buffer)
+    # Compute the number of bits needed for the given number of bytes.
+    def compute_need_bits
+      # for Compatibility: OpenSSH requires (need_bits * 2 + 1) length of parameter
+      need_bits = data[:need_bytes] * 8 * 2 + 1
 
-        buffer = connection.next_message
-        unless buffer.type == KEXDH_GEX_GROUP
-          raise Net::SSH::Exception, "expected KEXDH_GEX_GROUP, got #{buffer.type}"
-        end
+      data[:minimum_dh_bits] ||= MINIMUM_BITS
 
-        p = buffer.read_bignum
-        g = buffer.read_bignum
-
-        [p, g]
+      if need_bits < data[:minimum_dh_bits]
+        need_bits = data[:minimum_dh_bits]
+      elsif need_bits > MAXIMUM_BITS
+        need_bits = MAXIMUM_BITS
       end
 
-      # Returns the INIT/REPLY constants used by this algorithm.
-      def get_message_types
-        [KEXDH_GEX_INIT, KEXDH_GEX_REPLY]
-      end
-
-      # Build the signature buffer to use when verifying a signature from
-      # the server.
-      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]
-        response.write_long MINIMUM_BITS,
-                            data[:need_bits],
-                            MAXIMUM_BITS
-        response.write_bignum dh.p, dh.g, dh.pub_key,
-                              result[:server_dh_pubkey],
-                              result[:shared_secret]
-        response
-      end
+      data[:need_bits] = need_bits
+      data[:need_bytes] = need_bits / 8
+    end
+
+    # Returns the DH key parameters for the given session.
+    def get_parameters
+      compute_need_bits
+
+      # request the DH key parameters for the given number of bits.
+      buffer = Net::SSH::Buffer.from(:byte, KEXDH_GEX_REQUEST, :long, data[:minimum_dh_bits],
+                                     :long, data[:need_bits], :long, MAXIMUM_BITS)
+      connection.send_message(buffer)
+
+      buffer = connection.next_message
+      raise Net::SSH::Exception, "expected KEXDH_GEX_GROUP, got #{buffer.type}" unless buffer.type == KEXDH_GEX_GROUP
+
+      p = buffer.read_bignum
+      g = buffer.read_bignum
+
+      [p, g]
+    end
+
+    # Returns the INIT/REPLY constants used by this algorithm.
+    def get_message_types
+      [KEXDH_GEX_INIT, KEXDH_GEX_REPLY]
+    end
+
+    # Build the signature buffer to use when verifying a signature from
+    # the server.
+    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]
+      response.write_long MINIMUM_BITS,
+                          data[:need_bits],
+                          MAXIMUM_BITS
+      response.write_bignum dh.p, dh.g, dh.pub_key,
+                            result[:server_dh_pubkey],
+                            result[:shared_secret]
+      response
+    end
   end
-
 end

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,93 +1,39 @@
-require 'net/ssh/transport/constants'
-require 'net/ssh/transport/kex/diffie_hellman_group1_sha1'
-
-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 Constants, Loggable
-
-    attr_reader :ecdh
-
-    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
-      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
-        raise Net::SSH::Exception,
-        "host key algorithm mismatch for signature " +
-          "'#{sig_type}' != '#{algorithms.host_key}'"
+require 'net/ssh/transport/kex/abstract5656'
+
+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 < Abstract5656
+          def digester
+            OpenSSL::Digest::SHA256
+          end
+
+          def curve_name
+            OpenSSL::PKey::EC::CurveNameAlias['nistp256']
+          end
+
+          private
+
+          def generate_key # :nodoc:
+            OpenSSL::PKey::EC.generate(curve_name)
+          end
+
+          # 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(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
-      result[:server_sig] = sig_buffer.read_string
-
-      return result
     end
   end
-end; end; end; end
+end

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

@@ -1,13 +1,21 @@
-module Net; module SSH; module Transport; module Kex
+require 'net/ssh/transport/kex/ecdh_sha2_nistp256'
 
-  # A key-exchange service implementing the "ecdh-sha2-nistp256"
-  # key-exchange algorithm. (defined in RFC 5656)
-  class EcdhSHA2NistP384 < EcdhSHA2NistP256
-    def digester
-      OpenSSL::Digest::SHA384
-    end
-    def curve_name
-      OpenSSL::PKey::EC::CurveNameAlias['nistp384']
+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
+          def digester
+            OpenSSL::Digest::SHA384
+          end
+
+          def curve_name
+            OpenSSL::PKey::EC::CurveNameAlias['nistp384']
+          end
+        end
+      end
     end
   end
-end; end; end; end
+end