net-ssh 7.3.6 → 8.1.2

data/lib/net/ssh/connection/session.rb

@@ -24,7 +24,7 @@ module Net
       #     # 'ssh' is an instance of Net::SSH::Connection::Session
       #     ssh.exec! "/etc/init.d/some_process start"
       #   end
-      class Session
+      class Session # rubocop:disable Metrics/ClassLength
         include Loggable
         include Constants
 
@@ -53,6 +53,10 @@ module Net
         # The list of callbacks for pending requests. See #send_global_request.
         attr_reader :pending_requests # :nodoc:
 
+        # A "session" channel opened ahead of time by :preopen_channels, and
+        # the server's confirmation for it once that has arrived.
+        SpareChannel = Struct.new(:local_id, :remote_id, :window_size, :packet_size) # :nodoc:
+
         class NilChannel
           def initialize(session)
             @session = session
@@ -74,13 +78,20 @@ module Net
           @channel_id_counter = -1
           @channels = Hash.new(NilChannel.new(self))
           @listeners = { transport.socket => nil }
+          @read_paused = {}
+          @draining = {}
           @pending_requests = []
           @channel_open_handlers = {}
           @on_global_request = {}
           @properties = (options[:properties] || {}).dup
 
           @max_pkt_size = (options.key?(:max_pkt_size) ? options[:max_pkt_size] : 0x8000)
-          @max_win_size = (options.key?(:max_win_size) ? options[:max_win_size] : 0x20000)
+          @max_win_size = (options.key?(:max_win_size) ? options[:max_win_size] : Channel::DEFAULT_MAX_WIN_SIZE)
+
+          @preopen_channels = options.fetch(:preopen_channels, false)
+          @spare_channel = nil
+          @spare_wanted = false
+          @preopened = []
 
           @keepalive = Keepalive.new(self)
 
@@ -119,13 +130,21 @@ module Net
         # successfully closed, and then closes the underlying transport layer
         # connection.
         def close
+          stop_preopening
           info { "closing remaining channels (#{channels.length} open)" }
-          channels.each { |id, channel| channel.close }
+
+          channels.each do |id, channel|
+            channel.eof!
+            channel.close
+          end
+
           begin
             loop(0.1) { channels.any? }
           rescue Net::SSH::Disconnect
             raise unless channels.empty?
           end
+          @draining.each_key(&:close)
+          @draining.clear
           transport.close
         end
 
@@ -134,6 +153,7 @@ module Net
         # when the connection needs to close but you don't know the status of the
         # underlying protocol's state).
         def shutdown!
+          stop_preopening
           transport.shutdown!
         end
 
@@ -146,10 +166,13 @@ module Net
         # a +true+ value for +include_invisible+, then those will be counted.
         #
         # This can be useful for determining whether the event loop should continue
-        # to be run.
+        # to be run. A forwarded socket still writing out data that arrived before
+        # its channel closed also counts as busy.
         #
         #   ssh.loop { ssh.busy? }
         def busy?(include_invisible = false)
+          return true if @draining.any?
+
           if include_invisible
             channels.any?
           else
@@ -246,8 +269,10 @@ module Net
         # Called by event loop to process available data before going to
         # event multiplexing
         def ev_preprocess(&block)
+          confirm_preopened_channels
           dispatch_incoming_packets(raise_disconnect_errors: false)
           each_channel { |id, channel| channel.process unless channel.local_closed? }
+          open_spare_channel
         end
 
         # Returns the file descriptors the event loop should wait for read/write events,
@@ -255,7 +280,7 @@ module Net
         def ev_do_calculate_rw_wait(wait)
           r = listeners.keys
           w = r.select { |w2| w2.respond_to?(:pending_write?) && w2.pending_write? }
-          [r, w, io_select_wait(wait)]
+          [r.reject { |io| @read_paused.key?(io) }, w, io_select_wait(wait)]
         end
 
         # This is called internally as part of #process.
@@ -281,6 +306,7 @@ module Net
 
           Array(writers).each do |writer|
             writer.send_pending
+            close_if_drained(writer) if @draining.key?(writer)
           end
         end
 
@@ -335,14 +361,20 @@ module Net
         #   end
         #
         #   channel.wait
+        #
+        # With the :preopen_channels option a plain "session" channel reuses
+        # the spare opened ahead of time, if there is one. Its callback still
+        # runs from the event loop, as if the server had just confirmed it.
         def open_channel(type = "session", *extra, &on_confirm)
-          local_id = get_next_channel_id
+          spare = take_spare_channel if type == "session" && extra.empty?
+          local_id = spare ? spare.local_id : get_next_channel_id
 
           channel = Channel.new(self, type, local_id, @max_pkt_size, @max_win_size, &on_confirm)
-          msg = Buffer.from(:byte, CHANNEL_OPEN, :string, type, :long, local_id,
-                            :long, channel.local_maximum_window_size,
-                            :long, channel.local_maximum_packet_size, *extra)
-          send_message(msg)
+          if spare
+            @preopened << [channel, spare] if spare.remote_id
+          else
+            send_channel_open(type, channel.local_id, channel.local_maximum_window_size, channel.local_maximum_packet_size, *extra)
+          end
 
           channels[local_id] = channel
         end
@@ -416,7 +448,10 @@ module Net
         #
         #   matches = ssh.exec!("grep something /some/files")
         #
-        # the returned string has an exitstatus method to query its exit status
+        # With a block, output goes to the block and an empty string is returned,
+        # unless the block sets <tt>ch[:result]</tt>, which is returned instead.
+        # Either way the returned string has an exitstatus method to query the
+        # command's exit status.
         def exec!(command, status: nil, &block)
           block_or_concat = block || Proc.new do |ch, type, data|
             ch[:result] ||= String.new
@@ -427,10 +462,10 @@ module Net
           channel = exec(command, status: status, &block_or_concat)
           channel.wait
 
-          channel[:result] ||= String.new unless block
           channel[:result] &&= channel[:result].force_encoding("UTF-8") unless block
+          channel[:result] ||= String.new(encoding: Encoding::UTF_8)
 
-          StringWithExitstatus.new(channel[:result], status[:exit_code]) if channel[:result]
+          StringWithExitstatus.new(channel[:result], status[:exit_code])
         end
 
         # Enqueues a message to be sent to the server as soon as the socket is
@@ -485,9 +520,36 @@ module Net
         # Removes the given io object from the listeners collection, so that the
         # event loop will no longer monitor it.
         def stop_listening_to(io)
+          @read_paused.delete(io)
+          @draining.delete(io)
           listeners.delete(io)
         end
 
+        # Internal and experimental, used by port forwarding: stops the event
+        # loop from reading +io+ while it keeps flushing its pending output.
+        def pause_reading(io) # :nodoc:
+          raise ArgumentError, "the transport socket can't be paused" if io.equal?(transport.socket)
+
+          @read_paused[io] = true if listeners.key?(io)
+        end
+
+        def resume_reading(io) # :nodoc:
+          @read_paused.delete(io)
+        end
+
+        def reading_paused?(io) # :nodoc:
+          @read_paused.key?(io)
+        end
+
+        # Internal and experimental, used by port forwarding: stops reading +io+
+        # but keeps flushing its pending output, then closes it and stops
+        # listening, as OpenSSH's chan_rcvd_oclose does.
+        def close_when_drained(io) # :nodoc:
+          pause_reading(io)
+          @draining[io] = true
+          close_if_drained(io)
+        end
+
         # Returns a reference to the Net::SSH::Service::Forward service, which can
         # be used for forwarding ports over SSH.
         def forward
@@ -560,11 +622,20 @@ module Net
         end
 
         def force_channel_cleanup_on_close
+          stop_preopening
+          @preopened.clear
           channels.each do |id, channel|
             channel_closed(channel)
           end
         end
 
+        def close_if_drained(io)
+          return if io.pending_write? && !io.closed? && !closed? && listeners.key?(io)
+
+          io.close unless io.closed?
+          stop_listening_to(io)
+        end
+
         def channel_closed(channel)
           channel.remote_closed!
           channel.close
@@ -644,18 +715,37 @@ module Net
 
         def channel_open_confirmation(packet)
           info { "channel_open_confirmation: #{packet[:local_id]} #{packet[:remote_id]} #{packet[:window_size]} #{packet[:packet_size]}" }
+          if (spare = spare_channel(packet))
+            spare.remote_id = packet[:remote_id]
+            spare.window_size = packet[:window_size]
+            spare.packet_size = packet[:packet_size]
+            return
+          end
+
           channel = channels[packet[:local_id]]
           channel.do_open_confirmation(packet[:remote_id], packet[:window_size], packet[:packet_size])
         end
 
         def channel_open_failure(packet)
           error { "channel_open_failed: #{packet[:local_id]} #{packet[:reason_code]} #{packet[:description]}" }
+          if spare_channel(packet)
+            info { "preopen_channels: server refused the spare channel, no longer pre-opening" }
+            stop_preopening
+            @spare_channel = nil
+            return
+          end
+
           channel = channels.delete(packet[:local_id])
           channel.do_open_failed(packet[:reason_code], packet[:description])
         end
 
         def channel_window_adjust(packet)
           info { "channel_window_adjust: #{packet[:local_id]} +#{packet[:extra_bytes]}" }
+          if (spare = spare_channel(packet))
+            spare.window_size += packet[:extra_bytes]
+            return
+          end
+
           channels[packet[:local_id]].do_window_adjust(packet[:extra_bytes])
         end
 
@@ -676,11 +766,20 @@ module Net
 
         def channel_eof(packet)
           info { "channel_eof: #{packet[:local_id]}" }
+          return if spare_channel(packet)
+
           channels[packet[:local_id]].do_eof
         end
 
         def channel_close(packet)
           info { "channel_close: #{packet[:local_id]}" }
+          if (spare = spare_channel(packet))
+            send_message(Buffer.from(:byte, CHANNEL_CLOSE, :long, spare.remote_id))
+            @spare_channel = nil
+            # Wait for the next plain open_channel before opening another, so a server closing spares can't make us loop.
+            @spare_wanted = false
+            return
+          end
 
           channel = channels[packet[:local_id]]
           channel_closed(channel)
@@ -696,6 +795,45 @@ module Net
           channels[packet[:local_id]].do_failure
         end
 
+        def send_channel_open(type, local_id, window_size, packet_size, *extra)
+          send_message(Buffer.from(:byte, CHANNEL_OPEN, :string, type, :long, local_id,
+                                   :long, window_size, :long, packet_size, *extra))
+        end
+
+        def take_spare_channel
+          return unless @preopen_channels
+
+          @spare_wanted = true
+          spare = @spare_channel
+          @spare_channel = nil
+          spare
+        end
+
+        def open_spare_channel
+          return unless @spare_wanted && @preopen_channels && @spare_channel.nil? && !closed?
+
+          @spare_channel = SpareChannel.new(get_next_channel_id)
+          info { "preopen_channels: opening spare channel #{@spare_channel.local_id}" }
+          send_channel_open("session", @spare_channel.local_id, @max_win_size, @max_pkt_size)
+        end
+
+        # An unused spare is never closed, as that would cost round trips just before the transport goes away;
+        # it stays in @spare_channel to absorb the server's late replies for it.
+        def stop_preopening
+          @preopen_channels = false
+        end
+
+        def confirm_preopened_channels
+          until @preopened.empty?
+            channel, spare = @preopened.shift
+            channel.do_open_confirmation(spare.remote_id, spare.window_size, spare.packet_size)
+          end
+        end
+
+        def spare_channel(packet)
+          @spare_channel if @spare_channel && @spare_channel.local_id == packet[:local_id]
+        end
+
         def io_select_wait(wait)
           [wait, max_select_wait_time].compact.min
         end

data/lib/net/ssh/errors.rb

@@ -19,6 +19,16 @@ module Net
     # timeouted unexpectedly.
     class Timeout < Disconnect; end
 
+    # This exception is raised when a key blob has a key type that Net::SSH
+    # cannot parse.
+    class UnsupportedKeyType < Net::SSH::Exception; end
+
+    # Raised when a session connected through an OpenSSH ControlMaster (see the
+    # :control_master option of Net::SSH.start) is asked for something the
+    # master's proxy mode cannot carry, such as remote port forwarding, agent
+    # or X11 forwarding, or other global requests.
+    class NotSupportedOverControlMaster < Net::SSH::Exception; end
+
     # This exception is primarily used internally, but if you have a channel
     # request handler (see Net::SSH::Connection::Channel#on_request) that you
     # want to fail in such a way that the server knows it failed, you can
@@ -62,19 +72,21 @@ module Net
         @data && @data[:fingerprint]
       end
 
-      # Returns the host name for the remote host, as reported by the socket.
+      # Returns the host name that was connected to.
       def host
-        @data && @data[:peer] && @data[:peer][:host]
+        session&.host
       end
 
-      # Returns the port number for the remote host, as reported by the socket.
+      # Returns the port number that was connected to.
       def port
-        @data && @data[:peer] && @data[:peer][:port]
+        session&.port
       end
 
-      # Returns the IP address of the remote host, as reported by the socket.
+      # Returns the IP address of the remote host, as reported by the socket,
+      # or nil when connected through a ProxyCommand.
       def ip
-        @data && @data[:peer] && @data[:peer][:ip]
+        peer_ip = session&.socket&.peer_ip
+        peer_ip unless peer_ip == Net::SSH::Transport::PacketStream::PROXY_COMMAND_HOST_IP
       end
 
       # Returns the key itself, as reported by the remote host.
@@ -87,6 +99,12 @@ module Net
       def remember_host!
         @callback.call
       end
+
+      private
+
+      def session
+        @data && @data[:session]
+      end
     end
 
     # Raised when the cached key for a particular host does not match the
@@ -102,5 +120,15 @@ module Net
     # you want to proceed anyway, simply call the remember_host! method on the
     # exception, and then retry.
     class HostKeyUnknown < HostKeyError; end
+
+    # Raised when the key given by the host, or the CA that signed its
+    # certificate, is marked @revoked in a known hosts file. A revoked key must
+    # never be accepted, so unlike the other host key errors this one can't be
+    # overridden: #remember_host! just raises it again.
+    class HostKeyRevoked < HostKeyError
+      def remember_host!
+        raise self
+      end
+    end
   end
 end

data/lib/net/ssh/key_factory.rb

@@ -2,6 +2,7 @@ require 'net/ssh/transport/openssl'
 require 'net/ssh/prompt'
 
 require 'net/ssh/authentication/ed25519_loader'
+require 'net/ssh/authentication/security_key'
 
 module Net
   module SSH
@@ -92,7 +93,7 @@ module Net
           blob = nil
           begin
             blob = fields.shift
-          end while !blob.nil? && !/^(ssh-(rsa|dss|ed25519)|ecdsa-sha2-nistp\d+)(-cert-v01@openssh\.com)?$/.match(blob)
+          end while !blob.nil? && !public_key_type?(blob)
           blob = fields.shift
 
           raise Net::SSH::Exception, "public key at #{filename} is not valid" if blob.nil?
@@ -104,6 +105,11 @@ module Net
 
         private
 
+        def public_key_type?(type)
+          /^(ssh-(rsa|dss|ed25519)|ecdsa-sha2-nistp\d+)(-cert-v01@openssh\.com)?$/.match?(type) ||
+            Net::SSH::Authentication::SecurityKey.understands?(type)
+        end
+
         # rubocop:disable Style/Documentation, Lint/DuplicateMethods
         class KeyType
           def self.read(key_data, passphrase)

data/lib/net/ssh/known_hosts.rb

@@ -1,6 +1,5 @@
 require 'strscan'
 require 'openssl'
-require 'delegate'
 require 'net/ssh/buffer'
 require 'net/ssh/authentication/ed25519_loader'
 
@@ -8,8 +7,11 @@ module Net
   module SSH
     module HostKeyEntries
       # regular public key entry
-      class PubKey < Delegator
-        def initialize(key, comment: nil) # rubocop:disable Lint/MissingSuper
+      class PubKey
+        # The public key itself, e.g. an OpenSSL::PKey::PKey.
+        attr_reader :key
+
+        def initialize(key, comment: nil)
           @key = key
           @comment = comment
         end
@@ -26,14 +28,22 @@ module Net
           @key.to_blob
         end
 
-        def __getobj__
-          Kernel.warn("Calling Net::SSH::Buffer methods on HostKeyEntries PubKey is deprecated")
-          @key
-        end
-
         def matches_key?(server_key)
           @key.ssh_type == server_key.ssh_type && @key.to_blob == server_key.to_blob
         end
+
+        def method_missing(name, *args, &block)
+          return super unless @key.respond_to?(name)
+
+          raise NoMethodError.new(
+            "undefined method `#{name}' for #{self.class}; call it on #key, the wrapped public key",
+            name
+          )
+        end
+
+        def respond_to_missing?(_name, _include_private = false)
+          false
+        end
       end
 
       # @cert-authority entry
@@ -93,6 +103,22 @@ module Net
           server_key.critical_options.empty?
         end
       end
+
+      # @revoked entry
+      class Revoked
+        def initialize(key, comment: nil)
+          @key = key
+          @comment = comment
+        end
+
+        # Returns true for the revoked key itself and for any certificate that
+        # wraps it or is signed by it, matching OpenSSH's check_key_not_revoked.
+        def matches_key?(server_key)
+          keys = [server_key]
+          keys += [server_key.key, server_key.signature_key] if server_key.respond_to?(:signature_key)
+          keys.any? { |key| key.ssh_type == @key.ssh_type && key.to_blob == @key.to_blob }
+        end
+      end
     end
 
     # Represents the result of a search in known hosts
@@ -101,11 +127,17 @@ module Net
       include Enumerable
       attr_reader :host
 
-      def initialize(host_keys, host, known_hosts, options = {})
+      def initialize(host_keys, host, known_hosts, options = {}, revoked_keys = [])
         @host_keys = host_keys
         @host = host
         @known_hosts = known_hosts
         @options = options
+        @revoked_keys = revoked_keys
+      end
+
+      # Returns true if a @revoked known-hosts entry for this host matches +key+.
+      def revoked?(key)
+        @revoked_keys.any? { |entry| entry.matches_key?(key) }
       end
 
       def add_host_key(key)
@@ -151,11 +183,14 @@ module Net
         # Searches all known host files (see KnownHosts.hostfiles) for all keys
         # of the given host. Returns an enumerable of keys found.
         def search_for(host, options = {})
-          HostKeys.new(search_in(hostfiles(options), host, options), host, self, options)
+          files = hostfiles(options)
+          revoked_keys = files.flat_map { |file| KnownHosts.new(file).revoked_keys_for(host) }
+          HostKeys.new(search_in(files, host, options), host, self, options, revoked_keys)
         end
 
         # Search for all known keys for the given host, in every file given in
-        # the +files+ array. Returns the list of keys.
+        # the +files+ array. Returns the list of keys. @revoked entries are not
+        # included.
         def search_in(files, host, options = {})
           files.flat_map { |file| KnownHosts.new(file).keys_for(host, options) }
         end
@@ -219,46 +254,50 @@ module Net
       #   "[net.ssh.test]:5555"
       #   "[1,2,3,4]:5555"
       #   "[net.ssh.test]:5555,[1.2.3.4]:5555
+      #
+      # @revoked entries are not included, see revoked_keys_for.
       def keys_for(host, options = {})
         keys = []
-        return keys unless File.readable?(source)
-
         entries = host.split(/,/)
         host_name = entries[0]
         host_ip = entries[1]
 
-        File.open(source) do |file|
-          file.each_line do |line|
-            if line.start_with?('@')
-              marker, hosts, type, key_content, comment = line.split(' ')
-            else
-              marker = nil
-              hosts, type, key_content, comment = line.split(' ')
-            end
+        each_entry do |marker, hostlist, key_content, comment|
+          next if marker == "@revoked"
 
-            # Skip empty line or one that is commented
-            next if hosts.nil? || hosts.start_with?('#')
+          found = hostlist.any? { |pattern| match(host_name, pattern) } || known_host_hash?(hostlist, entries)
+          next unless found
 
-            hostlist = hosts.split(',')
+          found = hostlist.include?(host_ip) if options[:check_host_ip] && entries.size > 1 && hostlist.size > 1
+          next unless found
 
-            next unless SUPPORTED_TYPE.include?(type)
+          raw_key = read_key(key_content)
+
+          keys <<
+            if marker == "@cert-authority"
+              HostKeyEntries::CertAuthority.new(raw_key, comment: comment)
+            else
+              HostKeyEntries::PubKey.new(raw_key, comment: comment)
+            end
+        end
+
+        keys
+      end
 
-            found = hostlist.any? { |pattern| match(host_name, pattern) } || known_host_hash?(hostlist, entries)
-            next unless found
+      # Returns the @revoked entries for the given host, which takes the same
+      # formats as keys_for. An entry matching any of the comma-separated names
+      # counts, so :check_host_ip can't narrow a revocation.
+      def revoked_keys_for(host)
+        keys = []
+        entries = host.split(/,/)
 
-            found = hostlist.include?(host_ip) if options[:check_host_ip] && entries.size > 1 && hostlist.size > 1
-            next unless found
+        each_entry do |marker, hostlist, key_content, comment|
+          next unless marker == "@revoked"
 
-            blob = key_content.unpack("m*").first
-            raw_key = Net::SSH::Buffer.new(blob).read_key
+          found = entries.any? { |entry| hostlist.any? { |pattern| match(entry, pattern) } }
+          next unless found || known_host_hash?(hostlist, entries)
 
-            keys <<
-              if marker == "@cert-authority"
-                HostKeyEntries::CertAuthority.new(raw_key, comment: comment)
-              else
-                HostKeyEntries::PubKey.new(raw_key, comment: comment)
-              end
-          end
+          keys << HostKeyEntries::Revoked.new(read_key(key_content), comment: comment)
         end
 
         keys
@@ -303,6 +342,32 @@ module Net
           file.puts "#{host} #{key.ssh_type} #{blob}"
         end
       end
+
+      private
+
+      # Yields the marker, host patterns, key and comment of each usable line.
+      def each_entry
+        return unless File.readable?(source)
+
+        File.open(source) do |file|
+          file.each_line do |line|
+            fields = line.split(' ')
+            marker = fields.shift if fields.first&.start_with?('@')
+            hosts, type, key_content, comment = fields
+
+            # Skip empty line or one that is commented
+            next if hosts.nil? || hosts.start_with?('#')
+
+            next unless SUPPORTED_TYPE.include?(type)
+
+            yield marker, hosts.split(','), key_content, comment
+          end
+        end
+      end
+
+      def read_key(key_content)
+        Net::SSH::Buffer.new(key_content.unpack("m*").first).read_key
+      end
     end
   end
 end