net-ssh 8.0.4 → 8.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 110d479784d8cc56b52a5a3e9b14e5f23dbf556873b64a8e1563df31b1205911
-  data.tar.gz: e0f0d31f6476b896ddc6354906cc1b861f99687365a0783527b738e69f4d4e15
+  metadata.gz: 8a3eb4e5ac79bff25a68aaecd501c437bf0145a7458c8edd00f90e3b9ae14641
+  data.tar.gz: cabb7b40f56ed19ca61a1a09eccff1745618a62e258a9c2ba1804fdfbf02c44b
 SHA512:
-  metadata.gz: 985c71acd2df6c9e5a287c8e64c6e960cd80bd47c5d18837e1381a7c38f09ee2bbad51e3946f8d26d5f467c4999fca322e3ce4b48aa16115c2d434f675cf52cd
-  data.tar.gz: 81a1286e7e73a6c6b17a4a64e5c5004844a734bfa0118d39041ff291eb0e364c9fa4d3777cd7c745fb0ba038bd1aed2cef191b9c001cfb47937b7154a0506813
+  metadata.gz: e748a76a0dff8328c8d12da44f8372814c15260fa04f428459145f626cbde231173475d0b8547f907f0d5c983e4abf9ca8f23ef0eb26469a0558d259ee7997e1
+  data.tar.gz: c54425a607b9056a9bbd15985791911948a86548a1a6b0f8894aa193dc35aa703a2435ad25c11a0b7c622a7b6605d4815dcd8006864f311c8c0443b8a02acd63

data/CHANGES.txt

@@ -1,3 +1,13 @@
+=== 8.1.0
+
+  * BREAKING: Publickey auth offers each RSA key and certificate once, with the first `pubkey_algorithms` entry the server lists in RFC 8308 `server-sig-algs`, as OpenSSH does, so refused RSA keys no longer use up `MaxAuthTries` two or three at a time. Servers that send no `server-sig-algs` (OpenSSH 7.1 and older, some other servers) are offered RSA keys only as `ssh-rsa`, and only when it's enabled (e.g. `pubkey_algorithms: %w[+ssh-rsa]`); by default RSA keys are skipped there instead of being tried with rsa-sha2-512/256; OpenSSH 7.2 to 9.5 servers that accept only `ssh-rsa` still list rsa-sha2-* in `server-sig-algs`, so they need `ssh-rsa` first (`pubkey_algorithms: %w[^ssh-rsa]`) [#886, #1077]
+  * BREAKING: A `Match` block containing a condition net-ssh does not support (`exec`, `canonical`, `final`, `localnetwork`, `tagged`, ...) no longer matches and prints a warning, where the condition used to be ignored; `Match User`, `OriginalHost` and `LocalUser` are now evaluated, so e.g. `Match User x Host y` no longer applies to every user [#782, #1076]
+  * BREAKING: Net::SSH.start no longer prompts for passwords, passphrases or keyboard-interactive responses when $stdin is not a TTY, matching OpenSSH; this fixes Errno::EPIPE in background jobs. Pass `prompt_without_tty: true` to prompt anyway, e.g. for a piped password [#967, #1073]
+  * Package only `lib`, `CHANGES.txt`, `LICENSE.txt` and `README.md` in the gem, about 10% smaller. Thanks @yuri-zubov [#1081]
+  * Buffer#append now forces BINARY encoding so Channel#send_data chunks multibyte UTF-8 data by bytes instead of characters and no longer exceeds the remote maximum packet size [#1080, #1079]
+  * The default password prompt runs the `SSH_ASKPASS` program when there is no terminal, following the OpenSSH `SSH_ASKPASS_REQUIRE` and `DISPLAY` rules [#1075]
+  * Publickey and hostbased authentication now log key fingerprints using `:fingerprint_hash` (default SHA256) instead of MD5, fixing a crash with debug logging on FIPS-enabled OpenSSL [#936, #1074]
+
 === 8.0.4
 
   * Security: validate every ProxyJump hop, not only the first, as [user@]host[:port] (refusing a path, query, fragment or password) and shell-escape the hops passed to ssh -J; a hop such as `evil/x&$(cmd)` ran `cmd` through the shell [GHSA-g2r2-x3p2-5677]

data/lib/net/ssh/authentication/certificate.rb

@@ -78,8 +78,8 @@ module Net
           key.to_pem
         end
 
-        def fingerprint
-          key.fingerprint
+        def fingerprint(algorithm = 'MD5')
+          key.fingerprint(algorithm)
         end
 
         # Signs the certificate with key.

data/lib/net/ssh/authentication/methods/abstract.rb

@@ -66,6 +66,10 @@ module Net
           private
 
           attr_reader :prompt
+
+          def fingerprint(identity)
+            identity.fingerprint(@options[:fingerprint_hash] || 'SHA256')
+          end
         end
       end
     end

data/lib/net/ssh/authentication/methods/hostbased.rb

@@ -31,7 +31,7 @@ module Net
           # Attempts to perform host-based authentication of the user, using
           # the given host identity (key).
           def authenticate_with(identity, next_service, username, key_manager)
-            debug { "trying hostbased (#{identity.fingerprint})" }
+            debug { "trying hostbased (#{fingerprint(identity)})" }
             client_username = ENV['USER'] || username
 
             req = build_request(identity, next_service, username, "#{hostname}.", client_username)
@@ -46,10 +46,10 @@ module Net
 
             case message.type
             when USERAUTH_SUCCESS
-              info { "hostbased succeeded (#{identity.fingerprint})" }
+              info { "hostbased succeeded (#{fingerprint(identity)})" }
               return true
             when USERAUTH_FAILURE
-              info { "hostbased failed (#{identity.fingerprint})" }
+              info { "hostbased failed (#{fingerprint(identity)})" }
 
               raise Net::SSH::Authentication::DisallowedMethod unless
                 message[:authentications].split(/,/).include? 'hostbased'

data/lib/net/ssh/authentication/methods/publickey.rb

@@ -8,6 +8,25 @@ module Net
       module Methods
         # Implements the "publickey" SSH authentication method.
         class Publickey < Abstract
+          RSA_CERT = "ssh-rsa-cert-v01@openssh.com".freeze
+
+          # Key algorithms usable with each RSA key type, mapped to the signature algorithm they imply.
+          RSA_SIGNATURE_ALGORITHMS = {
+            "ssh-rsa" => {
+              "rsa-sha2-512" => "rsa-sha2-512",
+              "rsa-sha2-256" => "rsa-sha2-256",
+              "ssh-rsa" => "ssh-rsa"
+            }.freeze,
+            RSA_CERT => {
+              "rsa-sha2-512-cert-v01@openssh.com" => "rsa-sha2-512",
+              "rsa-sha2-256-cert-v01@openssh.com" => "rsa-sha2-256",
+              RSA_CERT => "ssh-rsa"
+            }.freeze
+          }.freeze
+
+          # Servers that OpenSSH flags with SSH_BUG_SIGTYPE (compat.c): no RSA/SHA-2 certificate signatures.
+          SIGTYPE_BUG = /\A(OpenSSH_[2-5]|OpenSSH_6\.[56]|OpenSSH_7\.[0-7]|Sun_SSH_1\.0)/.freeze
+
           # Attempts to perform public-key authentication for the given
           # username, trying each identity known to the key manager. If any of
           # them succeed, returns +true+, otherwise returns +false+. This
@@ -46,7 +65,7 @@ module Net
           end
 
           def authenticate_with_alg(identity, next_service, username, alg, sig_alg = nil)
-            debug { "trying publickey (#{identity.fingerprint}) alg #{alg}" }
+            debug { "trying publickey (#{fingerprint(identity)}) alg #{alg}" }
             send_request(identity, username, next_service, alg)
 
             message = session.next_message
@@ -66,10 +85,10 @@ module Net
 
               case message.type
               when USERAUTH_SUCCESS
-                debug { "publickey succeeded (#{identity.fingerprint})" }
+                debug { "publickey succeeded (#{fingerprint(identity)})" }
                 return true
               when USERAUTH_FAILURE
-                debug { "publickey failed (#{identity.fingerprint})" }
+                debug { "publickey failed (#{fingerprint(identity)})" }
 
                 raise Net::SSH::Authentication::DisallowedMethod unless
                   message[:authentications].split(/,/).include? 'publickey'
@@ -94,43 +113,36 @@ module Net
           # username, with the given identity (public key). Returns +true+ if
           # successful, or +false+ otherwise.
           def authenticate_with(identity, next_service, username)
+            alg = key_algorithm(identity)
+            if alg.nil?
+              debug { "skipping publickey (#{identity.fingerprint}): no mutual signature algorithm for #{identity.ssh_type}" }
+              return false
+            end
+
+            authenticate_with_alg(identity, next_service, username, alg, RSA_SIGNATURE_ALGORITHMS.dig(identity.ssh_type, alg))
+          end
+
+          # Picks the single algorithm to offer for the identity, following
+          # key_sig_algorithm() in OpenSSH 10.2 sshconnect2.c.
+          def key_algorithm(identity)
             type = identity.ssh_type
-            if type == "ssh-rsa"
-              pubkey_algorithms.each do |pk_alg|
-                case pk_alg
-                when "rsa-sha2-512", "rsa-sha2-256", "ssh-rsa"
-                  if authenticate_with_alg(identity, next_service, username, pk_alg, pk_alg)
-                    # success
-                    return true
-                  end
-                end
-              end
-            elsif type == "ssh-rsa-cert-v01@openssh.com"
-              pubkey_algorithms.each do |pk_alg|
-                case pk_alg
-                when "rsa-sha2-512-cert-v01@openssh.com"
-                  if authenticate_with_alg(identity, next_service, username, pk_alg, "rsa-sha2-512")
-                    # success
-                    return true
-                  end
-                when "rsa-sha2-256-cert-v01@openssh.com"
-                  if authenticate_with_alg(identity, next_service, username, pk_alg, "rsa-sha2-256")
-                    # success
-                    return true
-                  end
-                when "ssh-rsa-cert-v01@openssh.com"
-                  if authenticate_with_alg(identity, next_service, username, pk_alg)
-                    # success
-                    return true
-                  end
-                end
-              end
-            elsif pubkey_algorithms.include?(type) && authenticate_with_alg(identity, next_service, username, type)
-              # success
-              return true
+            server_sig_algs = session.transport.server_sig_algs
+            server_software = session.transport.server_version.version.to_s.sub(/\ASSH-[\d.]+-/, "")
+
+            if server_sig_algs.nil? || !RSA_SIGNATURE_ALGORITHMS.key?(type) ||
+               (type == RSA_CERT && server_software.match?(SIGTYPE_BUG))
+              return type if pubkey_algorithms.include?(type)
+
+              return nil
+            end
+
+            # OpenSSH 7.4 accepts RSA/SHA-2 signatures but leaves them out of server-sig-algs.
+            server_sig_algs = %w[rsa-sha2-256 rsa-sha2-512] if type == "ssh-rsa" && server_software.start_with?("OpenSSH_7.4")
+
+            pubkey_algorithms.find do |alg|
+              sig_alg = RSA_SIGNATURE_ALGORITHMS[type][alg]
+              sig_alg && server_sig_algs.include?(sig_alg)
             end
-            # failure
-            return false
           end
         end
       end

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

@@ -137,7 +137,8 @@ module Net
           begin
             auth_class = Methods.const_get(method_name.split(/\W+/).map { |p| p.capitalize }.join)
             method = auth_class.new(self,
-                                    key_manager: key_manager, password_prompt: options[:password_prompt])
+                                    key_manager: key_manager, password_prompt: options[:password_prompt],
+                                    fingerprint_hash: options[:fingerprint_hash])
           rescue NameError
             debug {"Mechanism #{method_name} was requested, but isn't a known type.  Ignoring it."}
             return false

data/lib/net/ssh/buffer.rb

@@ -145,7 +145,7 @@ module Net
       # Appends the given text to the end of the buffer. Does not alter the
       # read position. Returns the buffer object itself.
       def append(text)
-        @content << text
+        @content << text.b
         self
       end
 
@@ -359,7 +359,7 @@ module Net
       # Writes the given data literally into the string. Does not alter the
       # read position. Returns the buffer object.
       def write(*data)
-        data.each { |datum| @content << datum.dup.force_encoding('BINARY') }
+        data.each { |datum| @content << datum.b }
         self
       end
 

data/lib/net/ssh/config.rb

@@ -1,3 +1,6 @@
+require 'etc'
+require 'set'
+
 module Net
   module SSH
     # The Net::SSH::Config class is used to parse OpenSSH configuration files,
@@ -69,9 +72,19 @@ module Net
         # given +files+ (defaulting to the list of files returned by
         # #default_files), translates the resulting hash into the options
         # recognized by Net::SSH, and returns them.
-        def for(host, files = expandable_default_files)
+        #
+        # +user+ is the remote user given explicitly (e.g. to Net::SSH.start),
+        # used by <tt>Match User</tt>; when nil, the User set so far by the
+        # config, then the local user name, is used, as in OpenSSH.
+        #
+        # Match supports +all+, +Host+, +OriginalHost+, +User+ and +LocalUser+,
+        # each optionally negated with a leading "!". A Match block with any
+        # other condition (+exec+, +canonical+, +final+, +localnetwork+,
+        # +tagged+, ...) never matches, and a warning naming the condition is
+        # printed with Kernel#warn once per config line.
+        def for(host, files = expandable_default_files, user: nil)
           translate(files.inject({}) { |settings, file|
-            load(file, host, settings)
+            load(file, host, settings, user: user)
           })
         end
 
@@ -81,15 +94,16 @@ module Net
         # ones. Returns a hash containing the OpenSSH options. (See
         # #translate for how to convert the OpenSSH options into Net::SSH
         # options.)
-        def load(path, host, settings = {}, base_dir = nil)
+        def load(path, host, settings = {}, base_dir = nil, user: nil)
           file = File.expand_path(path)
           base_dir ||= File.dirname(file)
           return settings unless File.readable?(file)
 
           globals = {}
-          block_matched = false
-          block_seen = false
+          block_matched = block_seen = false
+          lineno = 0
           IO.foreach(file) do |line|
+            lineno += 1
             next if line =~ /^\s*(?:#.*)?$/
 
             # As in OpenSSH, the keyword ends at the first whitespace or "=".
@@ -127,7 +141,7 @@ module Net
               block_seen = true
               settings[key] = host
             elsif key == 'match'
-              block_matched = eval_match_conditions(value, host, settings)
+              block_matched = eval_match_conditions(value, host, [user, settings['user'], globals['user']].compact.first, "#{file} line #{lineno}")
               block_seen = true
             elsif !block_seen
               case key
@@ -135,7 +149,7 @@ module Net
                 (globals[key] ||= []) << value
               when 'include'
                 included_file_paths(base_dir, value).each do |file_path|
-                  globals = load(file_path, host, globals, base_dir)
+                  globals = load(file_path, host, globals, base_dir, user: user)
                 end
               else
                 globals[key] = value unless settings.key?(key)
@@ -146,7 +160,7 @@ module Net
                 (settings[key] ||= []) << value
               when 'include'
                 included_file_paths(base_dir, value).each do |file_path|
-                  settings = load(file_path, host, settings, base_dir)
+                  settings = load(file_path, host, settings, base_dir, user: user)
                 end
               else
                 settings[key] = value unless settings.key?(key)
@@ -325,7 +339,7 @@ module Net
 
         # Converts an ssh_config pattern into a regex for matching against
         # host names.
-        def pattern2regex(pattern)
+        def pattern2regex(pattern, ignore_case: true)
           tail = pattern
           prefix = String.new
           while !tail.empty? do
@@ -341,7 +355,7 @@ module Net
               fail "Unpexpcted sep:#{sep}"
             end
           end
-          Regexp.new("^" + prefix + "$", true)
+          Regexp.new("^" + prefix + "$", ignore_case)
         end
 
         # Converts the given size into an integer number of bytes.
@@ -374,39 +388,82 @@ module Net
           str.scan(/([^"\s]+)?(?:"([^"]+)")?\s*/).map(&:join)
         end
 
-        def eval_match_conditions(condition, host, settings)
+        MATCH_CONDITIONS_WITHOUT_ARGUMENT = %w[all canonical final].freeze
+        SUPPORTED_MATCH_CONDITIONS = %w[all host originalhost user localuser].freeze
+
+        def eval_match_conditions(condition, host, remote_user, location)
           # Not using `\s` for whitespace matching as canonical
           # ssh_config parser implementation (OpenSSH) has specific character set.
           # Ref: https://github.com/openssh/openssh-portable/blob/2581333d564d8697837729b3d07d45738eaf5a54/misc.c#L237-L239
-          conditions = condition.split(/[ \t\r\n]+|(?<!=)=(?!=)/).reject(&:empty?)
-          return true if conditions == ["all"]
-
-          conditions = conditions.each_slice(2)
-          condition_matches = []
-          conditions.each do |(kind, exprs)|
-            exprs = unquote(exprs)
-
-            case kind.downcase
-            when "all"
-              raise "all cannot be mixed with other conditions"
-            when "host"
-              if exprs.start_with?('!')
-                negated = true
-                exprs = exprs[1..-1]
-              else
-                negated = false
-              end
-              condition_met = false
-              exprs.split(",").each do |expr|
-                condition_met = condition_met || host =~ pattern2regex(expr)
-              end
-              condition_matches << (true && negated ^ condition_met)
-              # else
-              # warn "net-ssh: Unsupported expr in Match block: #{kind}"
-            end
+          tokens = condition.split(/[ \t\r\n]+|(?<!=)=(?!=)/).reject(&:empty?)
+          return true if tokens == ["all"]
+
+          conditions = parse_match_conditions(tokens)
+          unsupported = conditions.find { |_kind, name, exprs|
+            !SUPPORTED_MATCH_CONDITIONS.include?(name) || (name != 'all' && exprs.nil?)
+          }
+          if unsupported
+            warn_unsupported_match(unsupported[0], location)
+            return false
+          end
+
+          !conditions.empty? && conditions.all? do |kind, name, exprs|
+            kind.start_with?('!') ^ match_condition?(name, exprs, host, remote_user || local_user, conditions.size)
+          end
+        end
+
+        def parse_match_conditions(tokens)
+          conditions = []
+          until tokens.empty?
+            kind = tokens.shift
+            name = kind.delete_prefix('!').downcase
+            exprs = tokens.shift unless MATCH_CONDITIONS_WITHOUT_ARGUMENT.include?(name)
+            conditions << [kind, name, exprs && unquote(exprs)]
+          end
+          conditions
+        end
+
+        def match_condition?(name, exprs, host, remote_user, condition_count)
+          case name
+          when "all"
+            raise "all cannot be mixed with other conditions" if condition_count > 1
+
+            true
+          when "host"
+            negated = exprs.start_with?('!')
+            exprs = exprs[1..-1] if negated
+            negated ^ exprs.split(",").any? { |expr| host =~ pattern2regex(expr) }
+          when "originalhost"
+            match_pattern_list(host, exprs)
+          when "user"
+            match_pattern_list(remote_user, exprs, ignore_case: false)
+          when "localuser"
+            match_pattern_list(local_user, exprs, ignore_case: false)
+          end
+        end
+
+        # OpenSSH's match_pattern_list: true if any pattern matches and no "!pattern" does.
+        def match_pattern_list(string, list, ignore_case: true)
+          matched = false
+          list.split(",").each do |pattern|
+            negated = pattern.start_with?('!')
+            next unless string =~ pattern2regex(negated ? pattern[1..-1] : pattern, ignore_case: ignore_case)
+            return false if negated
+
+            matched = true
           end
+          matched
+        end
+
+        def warn_unsupported_match(kind, location)
+          @warned_unsupported_matches ||= Set.new
+          return unless @warned_unsupported_matches.add?([location, kind])
+
+          Kernel.warn("net-ssh: #{location}: unsupported Match condition '#{kind}', the Match block is skipped")
+        end
 
-          !condition_matches.empty? && condition_matches.all?
+        def local_user
+          Etc.getpwuid&.name || Etc.getlogin
         end
 
         # As in OpenSSH's argv_split, "#" starts a comment only at the start of a token and outside quotes.

data/lib/net/ssh/multiplex.rb

@@ -25,8 +25,9 @@ module Net
         keepalive keepalive_interval keepalive_maxcount kex key_data keycert_data
         keycerts keys keys_only known_hosts languages minimum_dh_bits no_delay
         non_interactive number_of_password_prompts passphrase password
-        password_prompt proxy pubkey_algorithms rekey_blocks_limit rekey_limit
-        rekey_packet_limit use_agent user_known_hosts_file verify_host_key
+        password_prompt prompt_without_tty proxy pubkey_algorithms
+        rekey_blocks_limit rekey_limit rekey_packet_limit use_agent
+        user_known_hosts_file verify_host_key
       ].freeze
 
       VALUES = [:auto, false, nil].freeze

data/lib/net/ssh/prompt.rb

@@ -26,22 +26,48 @@ module Net
 
       def initialize(options = {}); end
 
+      # Whether the default prompt has a terminal or an askpass program to ask with.
+      def self.can_ask?
+        $stdin.tty? || !askpass.nil?
+      end
+
+      # The SSH_ASKPASS program to ask with instead of the terminal, chosen with
+      # the SSH_ASKPASS_REQUIRE and DISPLAY rules described in ssh(1).
+      def self.askpass
+        program = ENV['SSH_ASKPASS'].to_s
+        return nil if program.empty?
+
+        display = !ENV['DISPLAY'].to_s.empty? || !ENV['WAYLAND_DISPLAY'].to_s.empty?
+        case ENV['SSH_ASKPASS_REQUIRE'].to_s.downcase
+        when 'force' then program
+        when 'never' then nil
+        when 'prefer' then (program if display)
+        else (program if display && !$stdin.tty?)
+        end
+      end
+
       # default prompt object implementation. More sophisticated implemenetations
       # might implement caching.
       class Prompter
         def initialize(info)
+          @askpass = Prompt.askpass
+          @header = []
           if info[:type] == 'keyboard-interactive'
-            $stdout.puts(info[:name]) unless info[:name].empty?
-            $stdout.puts(info[:instruction]) unless info[:instruction].empty?
+            @header << info[:name] unless info[:name].empty?
+            @header << info[:instruction] unless info[:instruction].empty?
           end
+          $stdout.puts(@header) unless @askpass || @header.empty?
         end
 
         # ask input from user, a prompter might ask for multiple inputs
         # (like user and password) in a single session.
         def ask(prompt, echo = true)
+          return ask_askpass(prompt) if @askpass
+
           $stdout.print(prompt)
           $stdout.flush
-          ret = echo ? $stdin.gets : $stdin.noecho(&:gets)
+          hide = !echo && $stdin.tty?
+          ret = hide ? $stdin.noecho(&:gets) : $stdin.gets
           $stdout.print("\n") unless echo
           ret.chomp
         end
@@ -49,6 +75,18 @@ module Net
         # success method will be called when the password was accepted
         # It's a good time to save password asked to a cache.
         def success; end
+
+        private
+
+        # Like OpenSSH, a cancelled or failed askpass answers with an empty string.
+        def ask_askpass(prompt)
+          text = (@header + [prompt]).join("\n")
+          @header = []
+          answer = IO.popen([@askpass, text], &:read)
+          Process.last_status.success? ? answer.chomp : ""
+        rescue SystemCallError
+          ""
+        end
       end
 
       # start password session. Multiple questions might be asked multiple times

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

@@ -424,7 +424,10 @@ module Net
         # 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(",")

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

@@ -56,6 +56,11 @@ module Net
         # The hash of options that were given to the object at initialization.
         attr_reader :options
 
+        # The signature algorithms the server accepts for publickey
+        # authentication, from its RFC 8308 server-sig-algs extension, or nil if
+        # it did not send one.
+        attr_reader :server_sig_algs
+
         # Instantiates a new transport layer abstraction. This will block until
         # the initial key exchange completes, leaving you with a ready-to-use
         # transport session.
@@ -219,9 +224,8 @@ module Net
             when DEBUG
               send(packet[:always_display] ? :fatal : :debug) { packet[:message] }
 
-            # We don't advertise ext-info-c, but some servers send EXT_INFO anyway (#955).
             when EXT_INFO
-              debug { "ignoring EXT_INFO packet" }
+              accept_ext_info(packet)
 
             when KEXINIT
               algorithms.accept_kexinit(packet)
@@ -300,6 +304,20 @@ module Net
 
         private
 
+        # Parses an RFC 8308 EXT_INFO packet, which servers send after the first
+        # NEWKEYS and possibly again just before USERAUTH_SUCCESS.
+        def accept_ext_info(packet)
+          count = packet.read_long or raise Net::SSH::Exception, "malformed EXT_INFO packet from server"
+          count.times do
+            name = packet.read_string
+            value = packet.read_string
+            raise Net::SSH::Exception, "malformed EXT_INFO packet from server" if name.nil? || value.nil?
+
+            debug { "EXT_INFO #{name}: #{value}" }
+            @server_sig_algs = value.split(",") if name == "server-sig-algs"
+          end
+        end
+
         def shift_queue
           packet = @queue.shift
           @queued_bytes -= packet.length

data/lib/net/ssh/version.rb

@@ -49,10 +49,10 @@ module Net
       MAJOR = 8
 
       # The minor component of this version of the Net::SSH library
-      MINOR = 0
+      MINOR = 1
 
       # The tiny component of this version of the Net::SSH library
-      TINY  = 4
+      TINY  = 0
 
       # The prerelease component of this version of the Net::SSH library
       # nil allowed

data/lib/net/ssh.rb

@@ -69,7 +69,7 @@ module Net
       host_name user properties passphrase keys_only max_pkt_size
       max_win_size send_env set_env use_agent number_of_password_prompts
       append_all_supported_algorithms non_interactive password_prompt
-      agent_socket_factory minimum_dh_bits verify_host_key
+      prompt_without_tty agent_socket_factory minimum_dh_bits verify_host_key
       fingerprint_hash check_host_ip pubkey_algorithms no_delay
       control_master control_path preopen_channels
     ]
@@ -216,7 +216,10 @@ module Net
     # * :non_interactive => set to true if your app is non interactive and prefers
     #   authentication failure vs password prompt. Non-interactive applications
     #   should set it to true to prefer failing a password/etc auth methods vs.
-    #   asking for password.
+    #   asking for password. Like OpenSSH, Net::SSH never prompts when $stdin is
+    #   not a TTY (e.g. in a background job), so it defaults to +true+ then,
+    #   unless :password_prompt or :prompt_without_tty is given or an
+    #   SSH_ASKPASS program can be used (see Net::SSH::Prompt.askpass).
     # * :passphrase => the passphrase to use when loading a private key (default
     #   is +nil+, for no passphrase)
     # * :password => the password to use to login
@@ -227,6 +230,10 @@ module Net
     #   costs one round trip instead of two. The spare counts against the
     #   server's MaxSessions; if the server refuses it, pre-opening stops for
     #   the session. Defaults to +false+.
+    # * :prompt_without_tty => set to +true+ to prompt for passwords, key
+    #   passphrases and keyboard-interactive responses on $stdout/$stdin even
+    #   when $stdin is not a TTY, e.g. to read a password piped into the
+    #   process. Defaults to +false+.
     # * :properties => a hash of key/value pairs to add to the new connection's
     #   properties (see Net::SSH::Connection::Session#properties)
     # * :proxy => a proxy instance (see Proxy) to use when connecting
@@ -306,7 +313,7 @@ module Net
       assign_defaults(options)
 
       options[:user] = user if user
-      options = configuration_for(host, options.fetch(:config, true)).merge(options)
+      options = configuration_for(host, options.fetch(:config, true), user: options[:user]).merge(options)
       host = options.fetch(:host_name, host)
 
       options[:check_host_ip] = true unless options.key?(:check_host_ip)
@@ -365,15 +372,17 @@ module Net
     # be a file name (or array of file names) of SSH configuration file(s)
     # to read.
     #
+    # +user+ is the explicitly requested remote user, matched by <tt>Match User</tt>.
+    #
     # See Net::SSH::Config for the full description of all supported options.
-    def self.configuration_for(host, use_ssh_config)
+    def self.configuration_for(host, use_ssh_config, user: nil)
       files = case use_ssh_config
               when true then Net::SSH::Config.expandable_default_files
               when false, nil then return {}
               else Array(use_ssh_config)
               end
 
-      Net::SSH::Config.for(host, files)
+      Net::SSH::Config.for(host, files, user: user)
     end
 
     def self.assign_defaults(options)
@@ -382,6 +391,9 @@ module Net
         options[:logger].level = Logger::FATAL
       end
 
+      unless options[:password_prompt] || options[:prompt_without_tty] || Prompt.can_ask?
+        options[:non_interactive] = true
+      end
       options[:password_prompt] ||= Prompt.default(options)
 
       %i[password passphrase].each do |key|