net-ssh 8.0.4 → 8.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 110d479784d8cc56b52a5a3e9b14e5f23dbf556873b64a8e1563df31b1205911
-  data.tar.gz: e0f0d31f6476b896ddc6354906cc1b861f99687365a0783527b738e69f4d4e15
+  metadata.gz: 07eacca644427ed0543e1a428d7075c1d5fd4a0da378e83959dcd312cd7f3500
+  data.tar.gz: eb50984faecccca334a68cd2b8fc04a749010e85e3cad2acb5e868b44bd168e6
 SHA512:
-  metadata.gz: 985c71acd2df6c9e5a287c8e64c6e960cd80bd47c5d18837e1381a7c38f09ee2bbad51e3946f8d26d5f467c4999fca322e3ce4b48aa16115c2d434f675cf52cd
-  data.tar.gz: 81a1286e7e73a6c6b17a4a64e5c5004844a734bfa0118d39041ff291eb0e364c9fa4d3777cd7c745fb0ba038bd1aed2cef191b9c001cfb47937b7154a0506813
+  metadata.gz: 0eab425719d3294df5ece8aff6758c4a627a67b366b661d1a4475b9979c5dea5e614ab583f559fd3a4d36ccd7d8f0cb35776e99a955007830a6ed0b3b37c04bb
+  data.tar.gz: 4c5a4eaeff4882604a01156bf22322d81c864f26b0637cb0400554206c514aa137a00f9b83ed637001a7ffb4ef599d49d512862963b1dd1041db6886dae44754

data/CHANGES.txt

@@ -1,3 +1,17 @@
+=== 8.1.1
+
+  * Security: refuse host keys marked `@revoked` in known_hosts, and certificates of such a key or signed by it, by raising the new `Net::SSH::HostKeyRevoked`, which `remember_host!` can't override; these lines were loaded as trusted keys, so every verifier except `:never` accepted the revoked key [GHSA-hjwv-j52r-xcg7]
+
+=== 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/errors.rb

@@ -120,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/known_hosts.rb

@@ -103,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
@@ -111,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)
@@ -161,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
@@ -229,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
 
-            found = hostlist.any? { |pattern| match(host_name, pattern) } || known_host_hash?(hostlist, entries)
-            next unless found
+        keys
+      end
 
-            found = hostlist.include?(host_ip) if options[:check_host_ip] && entries.size > 1 && hostlist.size > 1
-            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(/,/)
 
-            blob = key_content.unpack("m*").first
-            raw_key = Net::SSH::Buffer.new(blob).read_key
+        each_entry do |marker, hostlist, key_content, comment|
+          next unless marker == "@revoked"
 
-            keys <<
-              if marker == "@cert-authority"
-                HostKeyEntries::CertAuthority.new(raw_key, comment: comment)
-              else
-                HostKeyEntries::PubKey.new(raw_key, comment: comment)
-              end
-          end
+          found = entries.any? { |entry| hostlist.any? { |pattern| match(entry, pattern) } }
+          next unless found || known_host_hash?(hostlist, entries)
+
+          keys << HostKeyEntries::Revoked.new(read_key(key_content), comment: comment)
         end
 
         keys
@@ -313,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

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