net-ssh 7.3.6 → 8.0.2

data/Rakefile

@@ -9,7 +9,11 @@ require "rake"
 require "rake/clean"
 require "bundler/gem_tasks"
 
-require "rdoc/task"
+begin
+  require "rdoc/task"
+rescue LoadError
+  # rdoc is no longer a default gem as of Ruby 4.0; the rest of the Rakefile works without it.
+end
 
 desc "When releasing make sure NET_SSH_BUILDGEM_SIGNED is set"
 task :check_NET_SSH_BUILDGEM_SIGNED do
@@ -24,20 +28,23 @@ CLEAN.include ['pkg', 'rdoc']
 name = "net-ssh"
 
 require_relative "lib/net/ssh/version"
+require_relative "rakelib/changelog"
 version = Net::SSH::Version::CURRENT
 
 extra_files = %w[LICENSE.txt THANKS.txt CHANGES.txt]
-RDoc::Task.new do |rdoc|
-  rdoc.rdoc_dir = "rdoc"
-  rdoc.title = "#{name} #{version}"
-  rdoc.generator = 'hanna' # gem install hanna-nouveau
-  rdoc.main = 'README.md'
-  rdoc.rdoc_files.include("README*")
-  rdoc.rdoc_files.include("bin/*.rb")
-  rdoc.rdoc_files.include("lib/**/*.rb")
-  extra_files.each { |file|
-    rdoc.rdoc_files.include(file) if File.exist?(file)
-  }
+if defined?(RDoc::Task)
+  RDoc::Task.new do |rdoc|
+    rdoc.rdoc_dir = "rdoc"
+    rdoc.title = "#{name} #{version}"
+    rdoc.generator = 'hanna' # gem install hanna-nouveau
+    rdoc.main = 'README.md'
+    rdoc.rdoc_files.include("README*")
+    rdoc.rdoc_files.include("bin/*.rb")
+    rdoc.rdoc_files.include("lib/**/*.rb")
+    extra_files.each { |file|
+      rdoc.rdoc_files.include(file) if File.exist?(file)
+    }
+  end
 end
 
 namespace :cert do
@@ -103,6 +110,15 @@ def change_version(&block)
     raise ArgumentError, "Cound not find line: TINY = \"#{tiny}\" in #{version_file}" unless found[:tiny] || new_tiny == tiny
   end
 
+  begin
+    heading = Changelog.heading(Net::SSH::Version::MAJOR, Net::SSH::Version::MINOR, new_tiny, new_pre)
+    section = Changelog.new(__dir__).release(heading)
+  rescue StandardError
+    FileUtils.rm_f "#{version_file}.new"
+    raise
+  end
+  puts section ? "Added to CHANGES.txt:\n#{section}" : "Nothing to release for a pre-release, CHANGES.txt unchanged"
+
   FileUtils.mv version_file, "#{version_file}.old"
   FileUtils.mv "#{version_file}.new", version_file
 end
@@ -142,6 +158,44 @@ namespace :vbump do
   end
 end
 
+namespace :changelog do
+  changelog = Changelog.new(__dir__)
+
+  desc "Validate the fragments in changelog.d/"
+  task :check do
+    count = changelog.check.size
+    puts "#{count} valid changelog fragment#{'s' unless count == 1}"
+  rescue Changelog::Error => e
+    abort e.message
+  end
+
+  desc "Print the CHANGES.txt section the next version bump would write"
+  task :preview, [:heading] do |_t, args|
+    puts changelog.section(args[:heading] || "Unreleased") || "Nothing to release"
+  rescue Changelog::Error => e
+    abort e.message
+  end
+
+  desc "Create a fragment: rake \"changelog:new[1234,change,Text of the entry]\""
+  task :new, [:number, :type] do |_t, args|
+    abort "Usage: rake \"changelog:new[<PR number>,<#{Changelog::TYPES.keys.join('|')}>,<text>]\"" unless args[:number] && args[:type]
+    # Rake splits arguments on commas and strips the spaces around them, so take the text from the raw task string.
+    raw = Rake.application.top_level_tasks.find { |t| t.start_with?("changelog:new[") }
+    text = raw&.[](/\A[^\[]*\[[^,]*,[^,]*,\s*(.*)\]\z/m, 1) || args.extras.join(", ")
+    puts "Created #{changelog.new_fragment(args[:number], args[:type], text)}"
+  rescue Changelog::Error => e
+    abort e.message
+  end
+
+  desc "Write the fragments to CHANGES.txt under a heading, e.g. rake \"changelog:release[7.3.4]\" (vbump does this)"
+  task :release, [:heading] do |_t, args|
+    abort "Usage: rake \"changelog:release[<version heading>]\"" unless args[:heading]
+    puts changelog.release(args[:heading]) || "Nothing to release"
+  rescue Changelog::Error => e
+    abort e.message
+  end
+end
+
 namespace :rdoc do
   desc "Update gh-pages branch"
   task :publish do

data/appveyor.yml

@@ -4,16 +4,9 @@ skip_tags: true
 
 environment:
   matrix:
-    - ruby_version: "jruby-9.1.2.0"
-    - ruby_version: "26-x64"
-    - ruby_version: "25-x64"
-    - ruby_version: "24-x64"
-    - ruby_version: "23"
-    - ruby_version: "23-x64"
-
-matrix:
-  allow_failures:
-    - ruby_version: "jruby-9.1.2.0"
+    - ruby_version: "31-x64"
+    - ruby_version: "30-x64"
+    - ruby_version: "27-x64"
 
 #init:
 #  - ps: iex ((new-object net.webclient).DownloadString('https://raw.githubusercontent.com/appveyor/ci/master/scripts/enable-rdp.ps1'))
@@ -27,12 +20,8 @@ platform:
 
 install:
   - SET PATH=C:\Ruby%ruby_version%\bin;%PATH%
-  - if "%ruby_version%" == "jruby-9.1.2.0" ( cinst javaruntime -i )
-  - if "%ruby_version%" == "jruby-9.1.2.0" ( cinst jruby --version 9.1.2.0 -i --allow-empty-checksums )
-  - if "%ruby_version%" == "jruby-9.1.2.0" ( SET "PATH=C:\jruby-9.1.2.0\bin\;%PATH%" )
   - ruby --version
-  - gem install bundler --no-document --user-install -v 1.17
-  - SET BUNDLE_GEMFILE=Gemfile.noed25519
+  - gem install bundler --no-document --user-install -v 2.4.22
   - bundle install --retry=3
   - cinst freesshd
   - cinst putty --allow-empty-checksums
@@ -51,7 +40,6 @@ install:
           }
 
 test_script:
-  - SET BUNDLE_GEMFILE=Gemfile.noed25519
   - SET NET_SSH_RUN_WIN_INTEGRATION_TESTS=YES
   - bundle exec rake test
 

data/changelog.d/README.md

@@ -0,0 +1 @@
+Changelog fragments: one `<PR number>.<type>.txt` file per user-visible change, assembled into `CHANGES.txt` when the version is bumped. See [CONTRIBUTING.md](../CONTRIBUTING.md#changelog).

data/docker-compose.yml

@@ -13,11 +13,5 @@ services:
     build:
       context: .
       args: 
-        RUBY_VERSION: 2.7
+        RUBY_VERSION: 2.7.8
         BUNDLERV: "-v 2.2.28"
-  ruby-2.6:
-    build:
-      context: .
-      args: 
-        RUBY_VERSION: 2.6
-        BUNDLERV: "-v 2.4.22"

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

@@ -17,6 +17,9 @@ module Net
       # An exception for indicating that the SSH agent is not available.
       class AgentNotAvailable < AgentError; end
 
+      # Raised when the agent closes the connection before replying.
+      class AgentClosedConnection < AgentError; end
+
       # This class implements a simple client for the ssh-agent protocol. It
       # does not implement any specific protocol, but instead copies the
       # behavior of the ssh-agent functions in the OpenSSH library (3.8).
@@ -83,12 +86,18 @@ module Net
         # socket reports that it is an SSH2-compatible agent, this will fail
         # (it only supports the ssh-agent distributed by OpenSSH).
         def connect!(agent_socket_factory = nil, identity_agent = nil)
+          @agent_socket_factory = agent_socket_factory
+          @identity_agent = identity_agent
+          open_agent_socket!
+        end
+
+        def open_agent_socket!
           debug { "connecting to ssh-agent" }
           @socket =
-            if agent_socket_factory
-              agent_socket_factory.call
-            elsif identity_agent
-              unix_socket_class.open(File.expand_path(identity_agent))
+            if @agent_socket_factory
+              @agent_socket_factory.call
+            elsif @identity_agent
+              unix_socket_class.open(File.expand_path(@identity_agent))
             elsif ENV['SSH_AUTH_SOCK'] && unix_socket_class
               unix_socket_class.open(File.expand_path(ENV['SSH_AUTH_SOCK']))
             elsif Gem.win_platform? && RUBY_ENGINE != "jruby"
@@ -100,6 +109,7 @@ module Net
           error { "could not connect to ssh-agent: #{e.message}" }
           raise AgentNotAvailable, $!.message
         end
+        private :open_agent_socket!
 
         # Attempts to negotiate the SSH agent protocol version. Raises an error
         # if the version could not be negotiated successfully.
@@ -114,6 +124,11 @@ module Net
           elsif type != SSH_AGENT_RSA_IDENTITIES_ANSWER1 && type != SSH_AGENT_RSA_IDENTITIES_ANSWER2
             raise AgentNotAvailable, "unknown response from agent: #{type}, #{body.to_s.inspect}"
           end
+        rescue AgentClosedConnection
+          # Agents built on ssh-agent-lib <= 0.6.0 (e.g. older Proton Pass) drop the connection on
+          # this legacy request but handle the rest of the protocol (#1008).
+          debug { "ssh-agent closed the connection on the version request; assuming a modern agent and reconnecting" }
+          open_agent_socket!
         end
 
         # Return an array of all identities (public keys) known to the agent.
@@ -137,7 +152,7 @@ module Net
               key.extend(Comment)
               key.comment = comment_str
               identities.push key
-            rescue NotImplementedError => e
+            rescue Net::SSH::UnsupportedKeyType, NotImplementedError => e
               error { "ignoring unimplemented key:#{e.message} #{comment_str}" }
             end
           end
@@ -223,8 +238,14 @@ module Net
         # tuple consisting of the packet type, and the packet's body (which
         # is returned as a Net::SSH::Buffer).
         def read_packet
-          buffer = Net::SSH::Buffer.new(@socket.read(4))
-          buffer.append(@socket.read(buffer.read_long))
+          header = @socket.read(4)
+          raise AgentClosedConnection, "agent closed the connection" if header.nil?
+
+          buffer = Net::SSH::Buffer.new(header)
+          body = @socket.read(buffer.read_long)
+          raise AgentClosedConnection, "agent closed the connection" if body.nil?
+
+          buffer.append(body)
           type = buffer.read_byte
           debug { "received agent packet #{type} len #{buffer.length - 4}" }
           return type, buffer
@@ -235,6 +256,9 @@ module Net
         def send_and_wait(type, *args)
           send_packet(type, *args)
           read_packet
+        rescue Errno::ECONNRESET, Errno::EPIPE => e
+          # Linux reports an agent that closes with our request unread as a reset, not EOF.
+          raise AgentClosedConnection, "agent closed the connection (#{e.class})"
         end
 
         # Returns +true+ if the parameter indicates a "failure" response from
@@ -261,13 +285,13 @@ module Net
           when /^ecdsa\-sha2\-(\w*)-cert-v01@openssh\.com$/
             Net::SSH::Buffer.from(:string, priv_key.to_blob, :bignum, priv_key.key.private_key).to_s
           when /^ssh-ed25519$/
-            Net::SSH::Buffer.from(:string, priv_key.public_key.verify_key.to_bytes,
-                                  :string, priv_key.sign_key.keypair).to_s
+            Net::SSH::Buffer.from(:string, priv_key.public_key_bytes,
+                                  :string, priv_key.private_key_bytes_for_agent).to_s
           when /^ssh-ed25519-cert-v01@openssh\.com$/
             # Unlike the other certificate types, the public key is included after the certifiate.
             Net::SSH::Buffer.from(:string, priv_key.to_blob,
-                                  :string, priv_key.key.public_key.verify_key.to_bytes,
-                                  :string, priv_key.key.sign_key.keypair).to_s
+                                  :string, priv_key.key.public_key_bytes,
+                                  :string, priv_key.key.private_key_bytes_for_agent).to_s
           when /^ssh-rsa$/
             # `n` and `e` are reversed compared to the ordering in `OpenSSL::PKey::RSA#to_blob`.
             Net::SSH::Buffer.from(:bignum, priv_key.n, :bignum, priv_key.e, :bignum, priv_key.d,

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

@@ -1,25 +1,57 @@
-gem 'ed25519', '~> 1.2'
-gem 'bcrypt_pbkdf', '~> 1.0' unless RUBY_PLATFORM == "java"
-
-require 'ed25519'
-
+require 'openssl'
 require 'net/ssh/transport/cipher_factory'
 require 'net/ssh/authentication/pub_key_fingerprint'
-require 'bcrypt_pbkdf' unless RUBY_PLATFORM == "java"
 
 module Net
   module SSH
     module Authentication
       module ED25519
-        class SigningKeyFromFile < SimpleDelegator
-          def initialize(pk, sk)
-            key = ::Ed25519::SigningKey.from_keypair(sk)
-            raise ArgumentError, "pk does not match sk" unless pk == key.verify_key.to_bytes
+        ALGORITHM = "ED25519"
+        KEY_BYTES = 32
+        PRIVATE_KEY_BYTES = 64
 
-            super(key)
+        class UnsupportedError < StandardError; end
+
+        def self.ensure_supported!
+          unless OpenSSL::PKey.respond_to?(:new_raw_public_key) && OpenSSL::PKey.respond_to?(:new_raw_private_key)
+            raise UnsupportedError, "OpenSSL::PKey raw public/private key APIs are unavailable"
           end
+
+          key = new_private_key("\x00" * KEY_BYTES)
+          signature = sign(key, "")
+          public_key = new_public_key(key.raw_public_key)
+          raise UnsupportedError, "OpenSSL Ed25519 signature verification failed" unless verify(public_key, signature, "")
+        rescue OpenSSL::PKey::PKeyError => e
+          raise UnsupportedError, e.message
+        end
+
+        def self.new_public_key(key)
+          validate_key_bytes!(key, "public key", KEY_BYTES)
+          OpenSSL::PKey.new_raw_public_key(ALGORITHM, binary_string(key))
+        end
+
+        def self.new_private_key(key)
+          validate_key_bytes!(key, "private key", KEY_BYTES)
+          OpenSSL::PKey.new_raw_private_key(ALGORITHM, binary_string(key))
+        end
+
+        def self.sign(key, data)
+          key.sign(nil, data)
+        end
+
+        def self.verify(key, signature, data)
+          key.verify(nil, signature, data)
+        end
+
+        def self.validate_key_bytes!(key, label, expected_bytes)
+          raise ArgumentError, "invalid Ed25519 #{label}" unless key.respond_to?(:bytesize) && key.bytesize == expected_bytes
         end
 
+        def self.binary_string(string)
+          string.dup.force_encoding('BINARY')
+        end
+        private_class_method :binary_string
+
         class OpenSSHPrivateKeyLoader
           CipherFactory = Net::SSH::Transport::CipherFactory
 
@@ -41,13 +73,8 @@ module Net
             end
           end
 
-          def self.check_bcrypt_kdf!(rounds, password)
-            raise ArgumentError.new("Private key bcrypt rounds #{rounds} exceeds #{MAX_KDF_ROUNDS}") if rounds > MAX_KDF_ROUNDS
-            raise DecryptError.new("Passphrase required for encrypted private key", encrypted_key: true) if password.nil? || password.empty?
-          end
-
           def self.read(datafull, password)
-            datafull = datafull.strip
+            datafull = datafull.strip.encode(universal_newline: true)
             raise ArgumentError.new("Expected #{MBEGIN} at start of private key") unless datafull.start_with?(MBEGIN)
             raise ArgumentError.new("Expected #{MEND} at end of private key") unless datafull.end_with?(MEND)
 
@@ -55,7 +82,7 @@ module Net
             data = datab64.unpack1("m")
             raise ArgumentError.new("Expected #{MAGIC} at start of decoded private key") unless data.start_with?(MAGIC)
 
-            buffer = Net::SSH::Buffer.new(data[MAGIC.size + 1..-1])
+            buffer = Net::SSH::Buffer.new(data[(MAGIC.size + 1)..-1])
 
             ciphername = buffer.read_string
             raise ArgumentError.new("#{ciphername} in private key is not supported") unless
@@ -71,29 +98,35 @@ module Net
             _pubkey = buffer.read_string
 
             len = buffer.read_long
+            encrypted_private = buffer.read(len)
 
             keylen, blocksize, ivlen = CipherFactory.get_lengths(ciphername, iv_len: true)
             raise ArgumentError.new("Private key len:#{len} is not a multiple of #{blocksize}") if
-              ((len < blocksize) || ((blocksize > 0) && (len % blocksize) != 0))
+              (len < blocksize) || ((blocksize > 0) && (len % blocksize) != 0)
+
+            raise ArgumentError.new("Private key len:#{len} exceeds available data") unless encrypted_private.bytesize == len
+
+            authlen = CipherFactory.auth_length(ciphername)
+            auth_tag = authlen > 0 ? buffer.read(authlen) : nil
 
             if kdfname == 'bcrypt'
               salt = kdfopts.read_string
               rounds = kdfopts.read_long
+              raise ArgumentError.new("Private key bcrypt rounds #{rounds} exceeds #{MAX_KDF_ROUNDS}") if rounds > MAX_KDF_ROUNDS
 
-              raise "BCryptPbkdf is not implemented for jruby" if RUBY_PLATFORM == "java"
-
-              check_bcrypt_kdf!(rounds, password)
-
-              key = BCryptPbkdf::key(password, salt, keylen + ivlen, rounds)
-              raise DecryptError.new("BCyryptPbkdf failed", encrypted_key: true) unless key
+              key = bcrypt_pbkdf_key(password, salt, keylen + ivlen, rounds)
             else
-              key = '\x00' * (keylen + ivlen)
+              key = "\x00" * (keylen + ivlen)
             end
 
-            cipher = CipherFactory.get(ciphername, key: key[0...keylen], iv: key[keylen...keylen + ivlen], decrypt: true)
-
-            decoded = cipher.update(buffer.remainder_as_buffer.to_s)
-            decoded << cipher.final
+            decoded = decrypt_private_key(
+              ciphername,
+              encrypted_private,
+              auth_tag,
+              key: key[0...keylen],
+              iv: key[keylen...(keylen + ivlen)],
+              encrypted_key: kdfname == 'bcrypt'
+            )
 
             decoded = Net::SSH::Buffer.new(decoded)
             check1 = decoded.read_long
@@ -109,15 +142,50 @@ module Net
               decoded.read_private_keyblob(type_name)
             end
           end
+
+          def self.bcrypt_pbkdf_key(password, salt, length, rounds)
+            begin
+              require_bcrypt_pbkdf
+            rescue LoadError
+              raise DecryptError.new("bcrypt_pbkdf is required to decrypt bcrypt-encrypted OpenSSH private keys")
+            end
+            raise DecryptError.new("Passphrase required for encrypted private key", encrypted_key: true) if password.nil? || password.empty?
+
+            key = BCryptPbkdf::key(password, salt, length, rounds)
+            raise DecryptError.new("BCryptPbkdf failed", encrypted_key: true) unless key
+
+            key
+          end
+
+          def self.require_bcrypt_pbkdf
+            require 'bcrypt_pbkdf'
+          end
+
+          def self.decrypt_private_key(ciphername, encrypted_private, auth_tag, options)
+            if auth_tag
+              return CipherFactory.decrypt_private_key(
+                ciphername,
+                encrypted_private,
+                auth_tag,
+                options[:key],
+                options[:iv]
+              )
+            end
+
+            cipher = CipherFactory.get(ciphername, key: options[:key], iv: options[:iv], decrypt: true)
+            decoded = cipher.update(encrypted_private)
+            decoded << cipher.final
+          rescue Net::SSH::Exception, OpenSSL::Cipher::CipherError
+            raise DecryptError.new("Decrypt failed on private key", encrypted_key: options[:encrypted_key])
+          end
         end
 
         class PubKey
           include Net::SSH::Authentication::PubKeyFingerprint
 
-          attr_reader :verify_key
-
           def initialize(data)
-            @verify_key = ::Ed25519::VerifyKey.new(data)
+            ED25519.validate_key_bytes!(data, "public key", KEY_BYTES)
+            @public_key_bytes = data.dup.force_encoding('BINARY')
           end
 
           def self.read_keyblob(buffer)
@@ -125,7 +193,7 @@ module Net
           end
 
           def to_blob
-            Net::SSH::Buffer.from(:mstring, "ssh-ed25519".dup, :string, @verify_key.to_bytes).to_s
+            Net::SSH::Buffer.from(:mstring, "ssh-ed25519".dup, :string, public_key_bytes).to_s
           end
 
           def ssh_type
@@ -137,22 +205,26 @@ module Net
           end
 
           def ssh_do_verify(sig, data, options = {})
-            @verify_key.verify(sig, data)
+            ED25519.verify(verify_key, sig, data)
           end
 
           def to_pem
             # TODO this is not pem
-            ssh_type + [@verify_key.to_bytes].pack("m")
+            ssh_type + [public_key_bytes].pack("m")
+          end
+
+          def public_key_bytes
+            @public_key_bytes.dup
+          end
+
+          def verify_key
+            @verify_key ||= ED25519.new_public_key(@public_key_bytes)
           end
         end
 
         class PrivKey
           CipherFactory = Net::SSH::Transport::CipherFactory
 
-          MBEGIN = "-----BEGIN OPENSSH PRIVATE KEY-----\n"
-          MEND = "-----END OPENSSH PRIVATE KEY-----\n"
-          MAGIC = "openssh-key-v1"
-
           attr_reader :sign_key
 
           def initialize(buffer)
@@ -160,8 +232,17 @@ module Net
             sk = buffer.read_string
             _comment = buffer.read_string
 
-            @pk = pk
-            @sign_key = SigningKeyFromFile.new(pk, sk)
+            ED25519.validate_key_bytes!(pk, "public key", KEY_BYTES)
+            ED25519.validate_key_bytes!(sk, "private key field", PRIVATE_KEY_BYTES)
+
+            private_key_bytes = sk[0, KEY_BYTES]
+            raise ArgumentError, "Ed25519 private key does not include matching public key" unless sk[KEY_BYTES, KEY_BYTES] == pk
+
+            @sign_key = ED25519.new_private_key(private_key_bytes)
+            raise ArgumentError, "Ed25519 public key does not match private key" unless @sign_key.raw_public_key == pk
+
+            @public_key_bytes = pk.dup.force_encoding('BINARY')
+            @private_key_bytes = private_key_bytes.dup.force_encoding('BINARY')
           end
 
           def to_blob
@@ -177,11 +258,23 @@ module Net
           end
 
           def public_key
-            PubKey.new(@pk)
+            PubKey.new(public_key_bytes)
           end
 
           def ssh_do_sign(data, sig_alg = nil)
-            @sign_key.sign(data)
+            ED25519.sign(@sign_key, data)
+          end
+
+          def public_key_bytes
+            @public_key_bytes.dup
+          end
+
+          def private_key_bytes
+            @private_key_bytes.dup
+          end
+
+          def private_key_bytes_for_agent
+            private_key_bytes + public_key_bytes
           end
 
           def self.read(data, password)

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

@@ -1,29 +1,34 @@
 module Net
   module SSH
     module Authentication
-      # Loads ED25519 support which requires optinal dependecies like
-      # ed25519, bcrypt_pbkdf
+      # Loads ED25519 support backed by Ruby OpenSSL raw key APIs.
       module ED25519Loader
         begin
           require 'net/ssh/authentication/ed25519'
+          Net::SSH::Authentication::ED25519.ensure_supported!
           LOADED = true
           ERROR = nil
         rescue LoadError => e
           ERROR = e
           LOADED = false
+        rescue StandardError => e
+          if defined?(Net::SSH::Authentication::ED25519::UnsupportedError) &&
+             e.is_a?(Net::SSH::Authentication::ED25519::UnsupportedError)
+            ERROR = e
+            LOADED = false
+          else
+            raise
+          end
         end
 
         def self.raiseUnlessLoaded(message)
-          description = ERROR.is_a?(LoadError) ? dependenciesRequiredForED25519 : +''
-          description << "#{ERROR.class} : \"#{ERROR.message}\"\n" if ERROR
+          description = LOADED ? '' : ed25519SupportRequired
+          description += "#{ERROR.class} : \"#{ERROR.message}\"\n" if ERROR
           raise NotImplementedError, "#{message}\n#{description}" unless LOADED
         end
 
-        def self.dependenciesRequiredForED25519
-          result = +"net-ssh requires the following gems for ed25519 support:\n"
-          result << " * ed25519 (>= 1.2, < 2.0)\n"
-          result << " * bcrypt_pbkdf (>= 1.0, < 2.0)\n" unless RUBY_PLATFORM == "java"
-          result << "See https://github.com/net-ssh/net-ssh/issues/565 for more information\n"
+        def self.ed25519SupportRequired
+          "net-ssh requires openssl >= 3.2.0 and a crypto backend with Ed25519 enabled for ed25519 support.\n"
         end
       end
     end

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

@@ -124,17 +124,16 @@ module Net
 
           user_identities = load_identities(prepared_identities, false, true)
 
-          if agent
-            agent.identities.each do |key|
-              corresponding_user_identity = user_identities.detect { |identity|
-                identity[:public_key] && identity[:public_key].to_pem == key.to_pem
-              }
-              user_identities.delete(corresponding_user_identity) if corresponding_user_identity
-
-              if !options[:keys_only] || corresponding_user_identity
-                known_identities[key] = { from: :agent, identity: key }
-                yield key
-              end
+          agent_identities.each do |key|
+            corresponding_user_identity = user_identities.detect { |identity|
+              identity[:public_key] && identity[:public_key].to_blob == key.to_blob
+            }
+            # By identity: EC::Point#== raises TypeError when compared with other key types.
+            user_identities.reject! { |identity| identity.equal?(corresponding_user_identity) }
+
+            if !options[:keys_only] || corresponding_user_identity
+              known_identities[key] = { from: :agent, identity: key }
+              yield key
             end
           end
 
@@ -246,6 +245,18 @@ module Net
 
         private
 
+        # Like OpenSSH's pubkey_prepare, an agent that fails to list its keys is
+        # dropped for the session so that key files are still tried.
+        def agent_identities
+          return [] unless agent
+
+          agent.identities
+        rescue AgentError => e
+          error { "could not get identities from agent: #{e.class} (#{e.message})" }
+          self.use_agent = false
+          []
+        end
+
         # Load keycerts from files and data.
         def keycerts
           keycert_files.map { |keycert_file| KeyFactory.load_public_key(keycert_file) } +

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

@@ -20,9 +20,7 @@ module Net
           # this.
           attr_reader :key_manager
 
-          # So far only affects algorithms used for rsa keys, but can be
-          # extended to other keys, e.g after reading of
-          # PubkeyAcceptedAlgorithms option from ssh_config file is implemented.
+          # public key algorithms to be used
           attr_reader :pubkey_algorithms
 
           # Instantiates a new authentication method.
@@ -31,11 +29,7 @@ module Net
             @key_manager = options[:key_manager]
             @options = options
             @prompt = options[:password_prompt]
-            @pubkey_algorithms = options[:pubkey_algorithms] \
-              || %w[rsa-sha2-256-cert-v01@openssh.com
-                    ssh-rsa-cert-v01@openssh.com
-                    rsa-sha2-256
-                    ssh-rsa]
+            @pubkey_algorithms = session.transport.pubkey_algorithms
             self.logger = session.logger
           end