net-ssh 7.3.6 → 8.1.2

data/lib/net/ssh/proxy/https.rb

@@ -1,5 +1,6 @@
 require 'socket'
 require 'openssl'
+require 'resolv'
 require 'net/ssh/proxy/errors'
 require 'net/ssh/proxy/http'
 
@@ -15,10 +16,14 @@ module Net
         # can be used to tweak this proxy connection. In addition to the options
         # taken by Net::SSH::Proxy::HTTP it supports:
         #
-        # * :ssl_context => the SSL configuration to use for the connection
+        # * :ssl_context => the SSL configuration to use for the connection. The
+        #   default verifies the proxy's certificate and hostname against the
+        #   system trust store. For a self-signed or private CA certificate pass a
+        #   context with it in +cert_store+, or, to skip verification and expose
+        #   the proxy credentials to a man-in-the-middle, a context with
+        #   +verify_mode+ set to OpenSSL::SSL::VERIFY_NONE.
         def initialize(proxy_host, proxy_port = 80, options = {})
-          @ssl_context = options.delete(:ssl_context) ||
-                           OpenSSL::SSL::SSLContext.new
+          @ssl_context = options.delete(:ssl_context) || default_ssl_context
           super(proxy_host, proxy_port, options)
         end
 
@@ -41,9 +46,28 @@ module Net
           plain_socket = super(connect_timeout)
           OpenSSL::SSL::SSLSocket.new(plain_socket, @ssl_context).tap do |socket|
             socket.extend(SSLSocketCompatibility)
-            socket.connect
+            # SNI must not carry an IP address (RFC 6066).
+            socket.hostname = proxy_host unless Resolv::AddressRegex.match?(proxy_host)
+            begin
+              socket.connect
+              socket.post_connection_check(proxy_host) if verify_peer?
+            rescue StandardError
+              socket.close
+              raise
+            end
           end
         end
+
+        private
+
+        def default_ssl_context
+          OpenSSL::SSL::SSLContext.new.tap(&:set_params)
+        end
+
+        # verify_mode is nil on a bare SSLContext in older openssl gems.
+        def verify_peer?
+          @ssl_context.verify_mode.to_i != OpenSSL::SSL::VERIFY_NONE
+        end
       end
     end
   end

data/lib/net/ssh/proxy/jump.rb

@@ -15,14 +15,33 @@ module Net
       #   Net::SSH.start('host', 'user', :proxy => proxy) do |ssh|
       #     ...
       #   end
+      #
+      # ssh_config options for the jump host can be given as a Hash via
+      # +options:+; each is passed to the ssh command as +-o Key=value+:
+      #
+      #   proxy = Net::SSH::Proxy::Jump.new('user@proxy', options: { 'StrictHostKeyChecking' => 'no' })
+      #
+      # Options that ssh_config allows more than once (+IdentityFile+,
+      # +CertificateFile+ and +SendEnv+) take an Array and are passed once per
+      # element; an empty Array passes nothing:
+      #
+      #   proxy = Net::SSH::Proxy::Jump.new('user@proxy', options: { 'IdentityFile' => ['~/.ssh/jump', '~/.ssh/jump_old'] })
+      #
+      # A +nil+ value, alone or in an Array, raises ArgumentError, as it does
+      # for the options passed to Net::SSH.start; omit the option instead.
+      #
+      # The options apply to the first jump host only; any further hosts in
+      # the chain are connected to by that host's own ssh.
       class Jump < Command
         # The jump proxies
         attr_reader :jump_proxies
 
         # Create a new socket factory that tunnels via multiple jump proxes as
         # [user@]host[:port].
-        def initialize(jump_proxies)
+        def initialize(jump_proxies, options: {})
           @jump_proxies = jump_proxies
+          @options = options
+          validate_options!
         end
 
         # Return a new socket connected to the given host and port via the jump
@@ -35,28 +54,62 @@ module Net
         # We cannot build the ProxyCommand template until we know if the :config
         # option was specified during `Net::SSH.start`.
         def build_proxy_command_equivalent(connection_options = nil)
-          extra_jumps = jump_proxies.split(",", 2)[1]
+          raise ArgumentError, "no jump host given" if jump_proxies.empty?
+
           config = connection_options && connection_options[:config]
-          uri, = jump_proxies.split(",").map { |jump| validate_jump!(jump) }
+          uri, *extra_jumps = jump_proxies.split(",", -1).map { |jump| validate_jump!(jump) }
 
           template = "ssh".dup
-          template << " -l #{uri.user}"    if uri.user
-          template << " -p #{uri.port}"    if uri.port
-          template << " -J #{extra_jumps}" if extra_jumps
-          template << " -F #{Shellwords.escape(config)}" if config != true && config
+          template << " -l #{escape(uri.user)}" if uri.user
+          template << " -p #{uri.port}" if uri.port
+          template << " -J #{escape(extra_jumps.map { |jump| jump_spec(jump) }.join(','))}" unless extra_jumps.empty?
+          template << " -F #{escape(config)}" if config != true && config
+          @options.each do |key, values|
+            Array(values).each { |value| template << " -o #{escape(key)}=#{escape(value)}" }
+          end
           template << " -W %h:%p "
-          template << uri.host
+          template << escape(uri.host)
 
           @command_line_template = template
         end
 
         private
 
+        # Like Net::SSH.start, reject nil option values (alone or in an Array)
+        # rather than silently passing nothing or an empty value to ssh.
+        def validate_options!
+          nil_keys = @options.select { |_key, value| value.nil? || (value.is_a?(Array) && value.include?(nil)) }.keys
+          return if nil_keys.empty?
+
+          raise ArgumentError, "nil is not allowed for #{nil_keys.map(&:inspect).join(', ')} in Net::SSH::Proxy::Jump options; " \
+                               "omit the option to use the default or ssh_config value"
+        end
+
+        # Escape for the shell, and double any % so it survives the %h/%p
+        # substitution done on the template in Command#open.
+        def escape(value)
+          Shellwords.escape(value).gsub("%", "%%")
+        end
+
+        # Only [user@]host[:port] is checked, so anything else URI accepts (a path,
+        # query, fragment or password) must be refused before it reaches the shell.
         def validate_jump!(jump)
           uri = URI.parse("ssh://#{jump}")
+          raise URI::InvalidURIError if uri.host.to_s.empty? || jump_spec(uri) != jump
+
           validate_user_name!(uri.user) if uri.user
           validate_host_name!(uri.host)
+          validate_port!(uri.port) if uri.port
           uri
+        rescue URI::InvalidURIError
+          raise ArgumentError, "jump host is not [user@]host[:port]: #{jump.inspect}"
+        end
+
+        def jump_spec(uri)
+          spec = uri.host.dup
+          spec.prepend("#{uri.user}@") if uri.user
+          spec << ":#{uri.port}" if uri.port
+          spec
         end
       end
     end

data/lib/net/ssh/service/forward.rb

@@ -320,6 +320,11 @@ module Net
           session.listen_to(client)
           channel[:socket] = client
 
+          # Grant window only for data the local end has accepted, so a slow
+          # reader stalls the remote sender instead of filling our memory.
+          channel.grant_window_on_consume!
+          client.on_sent { |bytes| channel.consumed(bytes) }
+
           channel.on_data do |ch, data|
             debug { "data:#{data.length} on #{type} forwarded channel" }
             ch[:socket].enqueue(data)
@@ -327,36 +332,40 @@ module Net
 
           channel.on_eof do |ch|
             debug { "eof #{type} on #{type} forwarded channel" }
-            begin
-              ch[:socket].send_pending
-              ch[:socket].shutdown Socket::SHUT_WR
-            rescue IOError => e
-              if e.message =~ /closed/ then
-                debug { "epipe in on_eof => shallowing exception:#{e}" }
-              else
-                raise
-              end
-            rescue Errno::EPIPE => e
-              debug { "epipe in on_eof => shallowing exception:#{e}" }
-            rescue Errno::ENOTCONN => e
-              debug { "enotconn in on_eof => shallowing exception:#{e}" }
-            end
+            ch[:socket].shutdown_write_when_drained
           end
 
           channel.on_close do |ch|
             debug { "closing #{type} forwarded channel" }
-            ch[:socket].close if !client.closed?
-            session.stop_listening_to(ch[:socket])
+            session.close_when_drained(ch[:socket])
           end
 
           channel.on_process do |ch|
-            if ch[:socket].closed?
+            socket = ch[:socket]
+            if socket.closed?
               ch.info { "#{type} forwarded connection closed" }
+              session.stop_listening_to(socket)
               ch.close
-            elsif ch[:socket].available > 0
-              data = ch[:socket].read_available(8192)
-              ch.debug { "read #{data.length} bytes from client, sending over #{type} forwarded connection" }
-              ch.send_data(data)
+            elsif ch.eof?
+              # Like OpenSSH's chan_shutdown_read: data already read still goes out before CHANNEL_EOF, the rest is dropped.
+              ch.output.append(socket.read_available) if socket.available > 0
+              session.pause_reading(socket)
+            else
+              if socket.available > 0
+                data = socket.read_available(8192)
+                ch.debug { "read #{data.length} bytes from client, sending over #{type} forwarded connection" }
+                ch.send_data(data)
+              end
+
+              # Like OpenSSH's channel_pre_open, only read more once the remote
+              # window can take what is already queued; writes to the socket keep
+              # flowing. ch.output is still unsent here because Channel#process
+              # runs this block before enqueue_pending_output.
+              if ch.output.length + socket.available < ch.remote_window_size.to_i
+                session.resume_reading(socket)
+              else
+                session.pause_reading(socket)
+              end
             end
           end
         end
@@ -371,6 +380,8 @@ module Net
           end
 
           channel.on_process do |ch|
+            next if ch.eof?
+
             data = ch[:socket].read(8192)
             if data
               ch.debug { "read #{data.length} bytes from client, sending over #{type} forwarded connection" }
@@ -388,13 +399,13 @@ module Net
           originator_address = packet.read_string
           originator_port    = packet.read_long
 
-          puts "REMOTE 0: #{connected_port} #{connected_address} #{originator_address} #{originator_port}"
+          debug { "REMOTE 0: #{connected_port} #{connected_address} #{originator_address} #{originator_port}" }
           remote = @remote_forwarded_ports[[connected_port, connected_address]]
           if remote.nil?
             raise Net::SSH::ChannelOpenFailed.new(1, "unknown request from remote forwarded connection on #{connected_address}:#{connected_port}")
           end
 
-          puts "REMOTE: #{remote.host} #{remote.port}"
+          debug { "REMOTE: #{remote.host} #{remote.port}" }
           client = TCPSocket.new(remote.host, remote.port)
           info { "connected #{connected_address}:#{connected_port} originator #{originator_address}:#{originator_port}" }
 
@@ -415,7 +426,7 @@ module Net
           channel[:invisible] = true
 
           begin
-            agent = Authentication::Agent.connect(logger, session.options[:agent_socket_factory])
+            agent = Authentication::Agent.connect(logger, session.options[:agent_socket_factory], session.options[:identity_agent])
             if (agent.socket.is_a? ::IO)
               prepare_client(agent.socket, channel, :agent)
             else

data/lib/net/ssh/test.rb

@@ -73,7 +73,8 @@ module Net
       def transport(options = {})
         @transport ||= Net::SSH::Transport::Session.new(
           options[:host] || "localhost",
-          options.merge(kex: "test", host_key: "ssh-rsa", append_all_supported_algorithms: true, verify_host_key: :never, proxy: socket(options))
+          options.merge(kex: "test", host_key: "ssh-rsa", encryption: "+none", hmac: "+none",
+                        append_all_supported_algorithms: true, verify_host_key: :never, proxy: socket(options))
         )
       end
 

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

@@ -8,6 +8,7 @@ require 'net/ssh/transport/kex'
 require 'net/ssh/transport/kex/curve25519_sha256_loader'
 require 'net/ssh/transport/server_version'
 require 'net/ssh/authentication/ed25519_loader'
+require 'net/ssh/authentication/security_key'
 
 module Net
   module SSH
@@ -19,7 +20,7 @@ module Net
       #
       # You will never instantiate or reference this directly. It is used
       # internally by the transport layer.
-      class Algorithms
+      class Algorithms # rubocop:disable Metrics/ClassLength
         include Loggable
         include Constants
 
@@ -31,18 +32,14 @@ module Net
                        ecdsa-sha2-nistp521
                        ecdsa-sha2-nistp384
                        ecdsa-sha2-nistp256
-                       ssh-rsa-cert-v01@openssh.com
-                       ssh-rsa-cert-v00@openssh.com
-                       ssh-rsa
-                       rsa-sha2-256
-                       rsa-sha2-512],
+                       rsa-sha2-512
+                       rsa-sha2-256],
 
           kex: %w[ecdh-sha2-nistp521
                   ecdh-sha2-nistp384
                   ecdh-sha2-nistp256
                   diffie-hellman-group-exchange-sha256
-                  diffie-hellman-group14-sha256
-                  diffie-hellman-group14-sha1],
+                  diffie-hellman-group14-sha256],
 
           encryption: %w[aes256-ctr
                          aes192-ctr
@@ -51,8 +48,18 @@ module Net
                          aes128-gcm@openssh.com],
 
           hmac: %w[hmac-sha2-512-etm@openssh.com hmac-sha2-256-etm@openssh.com
+                   hmac-sha1-etm@openssh.com
                    hmac-sha2-512 hmac-sha2-256
-                   hmac-sha1]
+                   hmac-sha1],
+
+          pubkey_algorithms: %w[ssh-ed25519-cert-v01@openssh.com
+                                ecdsa-sha2-nistp256-cert-v01@openssh.com ecdsa-sha2-nistp384-cert-v01@openssh.com
+                                ecdsa-sha2-nistp521-cert-v01@openssh.com
+                                rsa-sha2-512-cert-v01@openssh.com rsa-sha2-256-cert-v01@openssh.com
+                                ssh-ed25519
+                                ecdsa-sha2-nistp256 ecdsa-sha2-nistp384 ecdsa-sha2-nistp521] +
+                             [Authentication::SecurityKey::SK_SSH_ED25519, Authentication::SecurityKey::SK_ECDSA_SHA2_NISTP256] +
+                             %w[rsa-sha2-512 rsa-sha2-256]
         }.freeze
 
         if Net::SSH::Transport::ChaCha20Poly1305CipherLoader::LOADED
@@ -76,10 +83,12 @@ module Net
 
         # Define all algorithms, with the deprecated, supported by Net::SSH.
         ALGORITHMS = {
-          host_key: DEFAULT_ALGORITHMS[:host_key] + %w[ssh-dss],
+          host_key: DEFAULT_ALGORITHMS[:host_key] +
+                    %w[ssh-rsa-cert-v01@openssh.com ssh-rsa-cert-v00@openssh.com ssh-rsa ssh-dss],
 
           kex: DEFAULT_ALGORITHMS[:kex] +
-               %w[diffie-hellman-group-exchange-sha1
+               %w[diffie-hellman-group14-sha1
+                  diffie-hellman-group-exchange-sha1
                   diffie-hellman-group1-sha1],
 
           encryption: DEFAULT_ALGORITHMS[:encryption] +
@@ -98,10 +107,20 @@ module Net
                    hmac-md5 hmac-md5-96
                    none],
 
+          pubkey_algorithms: DEFAULT_ALGORITHMS[:pubkey_algorithms] + %w[ssh-rsa-cert-v01@openssh.com ssh-rsa ssh-dss],
+
           compression: %w[none zlib@openssh.com zlib],
           language: %w[]
         }.freeze
 
+        # Not added by append_all_supported_algorithms; only used when named explicitly.
+        EXPLICIT_ONLY_ALGORITHMS = {
+          encryption: %w[none],
+          hmac: %w[none]
+        }.freeze
+
+        DEPRECATED_HOST_KEY = 'ssh-rsa-cert-v00@openssh.com'.freeze
+
         # The underlying transport layer session that supports this object
         attr_reader :session
 
@@ -269,11 +288,16 @@ module Net
 
           ALGORITHMS.each do |algorithm, supported|
             algorithms[algorithm] = compose_algorithm_list(
-              supported, options[algorithm] || DEFAULT_ALGORITHMS[algorithm],
-              options[:append_all_supported_algorithms]
+              supported,
+              DEFAULT_ALGORITHMS[algorithm],
+              options[algorithm] || DEFAULT_ALGORITHMS[algorithm],
+              options[:append_all_supported_algorithms],
+              supported - EXPLICIT_ONLY_ALGORITHMS.fetch(algorithm, [])
             )
           end
 
+          warn_deprecated_host_key if host_key_explicitly_named?(DEPRECATED_HOST_KEY)
+
           # for convention, make sure our list has the same keys as the server
           # list
 
@@ -287,7 +311,11 @@ module Net
             # existing known key for the host has preference.
 
             existing_keys = session.host_keys
-            host_keys = existing_keys.flat_map { |key| key.respond_to?(:ssh_types) ? key.ssh_types : [key.ssh_type] }.uniq
+            host_keys = existing_keys.flat_map { |key| key.respond_to?(:ssh_types) ? key.ssh_types : [key.ssh_type] }
+            # A known ssh-rsa key also verifies with rsa-sha2-*, and must not re-enable disabled SHA-1 algorithms.
+            disabled_sha1 = %w[ssh-rsa ssh-rsa-cert-v01@openssh.com ssh-rsa-cert-v00@openssh.com] - algorithms[:host_key]
+            host_keys = host_keys.flat_map { |type| type == 'ssh-rsa' ? %w[rsa-sha2-512 rsa-sha2-256 ssh-rsa] : [type] }
+            host_keys = (host_keys - disabled_sha1).uniq
             algorithms[:host_key].each do |name|
               host_keys << name unless host_keys.include?(name)
             end
@@ -296,21 +324,27 @@ module Net
         end
 
         # Composes the list of algorithms by taking supported algorithms and matching with supplied options.
-        def compose_algorithm_list(supported, option, append_all_supported_algorithms = false)
+        def compose_algorithm_list(supported, defaults, option, append_all_supported_algorithms = false, appendable = supported)
           return supported.dup unless option
 
           list = []
           option = Array(option).compact.uniq
 
-          if option.first && option.first.start_with?('+', '-')
-            list = supported.dup
-
-            appends = option.select { |opt| opt.start_with?('+') }.map { |opt| opt[1..-1] }
-            deletions = option.select { |opt| opt.start_with?('-') }.map { |opt| opt[1..-1] }
+          if option.first && option.first.start_with?('+', '-', '^')
+            ops = { '^' => [], '+' => [], '-' => [] }
+            cur_list = nil
+            option.each do |cur_opt|
+              if ops.key?(cur_opt[0])
+                cur_list = ops[cur_opt[0]]
+                cur_opt = cur_opt[1..-1]
+              end
+              cur_list << cur_opt
+            end
 
-            list.concat(appends)
+            list = ops['^'] + defaults + ops['+']
+            list.concat(appendable) if append_all_supported_algorithms
 
-            deletions.each do |opt|
+            ops['-'].each do |opt|
               if opt.include?('*')
                 opt_escaped = Regexp.escape(opt)
                 algo_re = /\A#{opt_escaped.gsub('\*', '[A-Za-z\d\-@\.]*')}\z/
@@ -325,7 +359,7 @@ module Net
             list = option
 
             if append_all_supported_algorithms
-              supported.each { |name| list << name unless list.include?(name) }
+              appendable.each { |name| list << name unless list.include?(name) }
             end
           end
 
@@ -341,22 +375,35 @@ module Net
           list
         end
 
+        def host_key_explicitly_named?(name)
+          algorithms[:host_key].include?(name) &&
+            Array(options[:host_key]).any? { |opt| opt.to_s.delete_prefix('+').delete_prefix('^') == name }
+        end
+
+        def warn_deprecated_host_key
+          return if @deprecated_host_key_warned
+
+          @deprecated_host_key_warned = true
+          Kernel.warn("#{DEPRECATED_HOST_KEY} is deprecated and will be removed in a future version; " \
+                      "net-ssh cannot parse v00 certificates, use ssh-rsa-cert-v01@openssh.com or a modern host key type instead")
+        end
+
         # Parses a KEXINIT packet from the server.
         def parse_server_algorithm_packet(packet)
           data = { raw: packet.content }
 
           packet.read(16) # skip the cookie value
 
-          data[:kex]                = packet.read_string.split(/,/)
-          data[:host_key]           = packet.read_string.split(/,/)
-          data[:encryption_client]  = packet.read_string.split(/,/)
-          data[:encryption_server]  = packet.read_string.split(/,/)
-          data[:hmac_client]        = packet.read_string.split(/,/)
-          data[:hmac_server]        = packet.read_string.split(/,/)
-          data[:compression_client] = packet.read_string.split(/,/)
-          data[:compression_server] = packet.read_string.split(/,/)
-          data[:language_client]    = packet.read_string.split(/,/)
-          data[:language_server]    = packet.read_string.split(/,/)
+          data[:kex]                = read_name_list(packet)
+          data[:host_key]           = read_name_list(packet)
+          data[:encryption_client]  = read_name_list(packet)
+          data[:encryption_server]  = read_name_list(packet)
+          data[:hmac_client]        = read_name_list(packet)
+          data[:hmac_server]        = read_name_list(packet)
+          data[:compression_client] = read_name_list(packet)
+          data[:compression_server] = read_name_list(packet)
+          data[:language_client]    = read_name_list(packet)
+          data[:language_server]    = read_name_list(packet)
 
           # TODO: if first_kex_packet_follows, we need to try to skip the
           # actual kexinit stuff and try to guess what the server is doing...
@@ -366,11 +413,21 @@ module Net
           return data
         end
 
+        # Reads one comma-separated algorithm name-list from a KEXINIT packet.
+        def read_name_list(packet)
+          list = packet.read_string or raise Net::SSH::Exception, "malformed KEXINIT packet from server"
+
+          list.split(/,/)
+        end
+
         # Given the #algorithms map of preferred algorithm types, this constructs
         # a KEXINIT packet to send to the server. It does not actually send it,
         # it simply builds the packet and returns it.
         def build_client_algorithm_packet
-          kex         = algorithms[:kex].join(",")
+          kex_names   = algorithms[:kex]
+          # RFC 8308: ext-info-c is only meaningful in the first key exchange.
+          kex_names  += %w[ext-info-c] unless session_id
+          kex         = kex_names.join(",")
           host_key    = algorithms[:host_key].join(",")
           encryption  = algorithms[:encryption].join(",")
           hmac        = algorithms[:hmac].join(",")
@@ -391,6 +448,7 @@ module Net
         def negotiate_algorithms
           @kex                = negotiate(:kex)
           @host_key           = negotiate(:host_key)
+          warn_deprecated_host_key if @host_key == DEPRECATED_HOST_KEY
           @encryption_client  = negotiate(:encryption_client)
           @encryption_server  = negotiate(:encryption_server)
           @hmac_client        = negotiate(:hmac_client)