net-ssh 7.3.4 → 8.0.0.rc1

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

@@ -127,9 +127,10 @@ module Net
           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
+                identity[:public_key] && identity[:public_key].to_blob == key.to_blob
               }
-              user_identities.delete(corresponding_user_identity) if corresponding_user_identity
+              # 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 }

data/lib/net/ssh/prompt.rb

@@ -41,9 +41,9 @@ module Net
         def ask(prompt, echo = true)
           $stdout.print(prompt)
           $stdout.flush
-          ret = $stdin.noecho(&:gets).chomp
-          $stdout.print("\n")
-          ret
+          ret = echo ? $stdin.gets : $stdin.noecho(&:gets)
+          $stdout.print("\n") unless echo
+          ret.chomp
         end
 
         # success method will be called when the password was accepted

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

@@ -388,13 +388,13 @@ module Net
           originator_address = packet.read_string
           originator_port    = packet.read_long
 
-          puts "REMOTE 0: #{connected_port} #{connected_address} #{originator_address} #{originator_port}"
+          debug { "REMOTE 0: #{connected_port} #{connected_address} #{originator_address} #{originator_port}" }
           remote = @remote_forwarded_ports[[connected_port, connected_address]]
           if remote.nil?
             raise Net::SSH::ChannelOpenFailed.new(1, "unknown request from remote forwarded connection on #{connected_address}:#{connected_port}")
           end
 
-          puts "REMOTE: #{remote.host} #{remote.port}"
+          debug { "REMOTE: #{remote.host} #{remote.port}" }
           client = TCPSocket.new(remote.host, remote.port)
           info { "connected #{connected_address}:#{connected_port} originator #{originator_address}:#{originator_port}" }
 
@@ -409,7 +409,7 @@ module Net
           channel[:invisible] = true
 
           begin
-            agent = Authentication::Agent.connect(logger, session.options[:agent_socket_factory])
+            agent = Authentication::Agent.connect(logger, session.options[:agent_socket_factory], session.options[:identity_agent])
             if (agent.socket.is_a? ::IO)
               prepare_client(agent.socket, channel, :agent)
             else

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

@@ -347,16 +347,16 @@ module Net
 
           packet.read(16) # skip the cookie value
 
-          data[:kex]                = packet.read_string.split(/,/)
-          data[:host_key]           = packet.read_string.split(/,/)
-          data[:encryption_client]  = packet.read_string.split(/,/)
-          data[:encryption_server]  = packet.read_string.split(/,/)
-          data[:hmac_client]        = packet.read_string.split(/,/)
-          data[:hmac_server]        = packet.read_string.split(/,/)
-          data[:compression_client] = packet.read_string.split(/,/)
-          data[:compression_server] = packet.read_string.split(/,/)
-          data[:language_client]    = packet.read_string.split(/,/)
-          data[:language_server]    = packet.read_string.split(/,/)
+          data[:kex]                = read_name_list(packet)
+          data[:host_key]           = read_name_list(packet)
+          data[:encryption_client]  = read_name_list(packet)
+          data[:encryption_server]  = read_name_list(packet)
+          data[:hmac_client]        = read_name_list(packet)
+          data[:hmac_server]        = read_name_list(packet)
+          data[:compression_client] = read_name_list(packet)
+          data[:compression_server] = read_name_list(packet)
+          data[:language_client]    = read_name_list(packet)
+          data[:language_server]    = read_name_list(packet)
 
           # TODO: if first_kex_packet_follows, we need to try to skip the
           # actual kexinit stuff and try to guess what the server is doing...
@@ -366,6 +366,13 @@ module Net
           return data
         end
 
+        # Reads one comma-separated algorithm name-list from a KEXINIT packet.
+        def read_name_list(packet)
+          list = packet.read_string or raise Net::SSH::Exception, "malformed KEXINIT packet from server"
+
+          list.split(/,/)
+        end
+
         # Given the #algorithms map of preferred algorithm types, this constructs
         # a KEXINIT packet to send to the server. It does not actually send it,
         # it simply builds the packet and returns it.

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

@@ -1,4 +1,4 @@
-require 'rbnacl'
+require 'openssl'
 require 'net/ssh/loggable'
 
 module Net
@@ -8,6 +8,15 @@ module Net
       class ChaCha20Poly1305Cipher
         include Net::SSH::Loggable
 
+        POLY1305_ALGORITHM = "POLY1305"
+        POLY1305_KEY_BYTES = 32
+        POLY1305_TAG_BYTES = 16
+        NAME = "chacha20-poly1305@openssh.com"
+        ZERO_BLOCK = "\x00".b * POLY1305_KEY_BYTES
+        ZERO_IV = "\x00".b * 16
+
+        class UnsupportedError < StandardError; end
+
         # Implicit HMAC, no need to do anything
         class ImplicitHMac
           def etm
@@ -24,7 +33,6 @@ module Net
           @chacha_hdr = OpenSSL::Cipher.new("chacha20")
           key_len = @chacha_hdr.key_len
           @chacha_main = OpenSSL::Cipher.new("chacha20")
-          @poly = RbNaCl::OneTimeAuths::Poly1305
           if key.size < key_len * 2
             error { "chacha20_poly1305: keylength doesn't match" }
             raise "chacha20_poly1305: keylength doesn't match"
@@ -43,9 +51,9 @@ module Net
         end
 
         def update_cipher_mac(payload, sequence_number)
-          iv_data = [0, 0, 0, sequence_number].pack("NNNN")
+          iv_data = packet_iv(sequence_number)
           @chacha_main.iv = iv_data
-          poly_key = @chacha_main.update(([0] * 32).pack('C32'))
+          poly_key = @chacha_main.update(ZERO_BLOCK)
 
           packet_length = payload.size
           length_data = [packet_length].pack("N")
@@ -57,35 +65,36 @@ module Net
           unencrypted_data = payload
           packet += @chacha_main.update(unencrypted_data)
 
-          packet += @poly.auth(poly_key, packet)
+          packet += self.class.poly1305_auth(poly_key, packet)
           return packet
         end
 
         def read_length(data, sequence_number)
-          iv_data = [0, 0, 0, sequence_number].pack("NNNN")
+          iv_data = packet_iv(sequence_number)
           @chacha_hdr.iv = iv_data
           @chacha_hdr.update(data).unpack1("N")
         end
 
         def read_and_mac(data, mac, sequence_number)
-          iv_data = [0, 0, 0, sequence_number].pack("NNNN")
+          iv_data = packet_iv(sequence_number)
           @chacha_main.iv = iv_data
-          poly_key = @chacha_main.update(([0] * 32).pack('C32'))
+          poly_key = @chacha_main.update(ZERO_BLOCK)
 
           iv_data[0] = 1.chr
           @chacha_main.iv = iv_data
           unencrypted_data = @chacha_main.update(data[4..])
-          begin
-            ok = @poly.verify(poly_key, mac, data[0..])
-            raise Net::SSH::Exception, "corrupted hmac detected #{name}" unless ok
-          rescue RbNaCl::BadAuthenticatorError
-            raise Net::SSH::Exception, "corrupted hmac detected #{name}"
-          end
+
+          expected_mac = self.class.poly1305_auth(poly_key, data[0..])
+          valid_mac = mac.respond_to?(:bytesize) &&
+                      mac.bytesize == POLY1305_TAG_BYTES &&
+                      OpenSSL.fixed_length_secure_compare(expected_mac, mac)
+          raise Net::SSH::Exception, "corrupted hmac detected #{name}" unless valid_mac
+
           return unencrypted_data
         end
 
         def mac_length
-          16
+          POLY1305_TAG_BYTES
         end
 
         def block_size
@@ -93,7 +102,7 @@ module Net
         end
 
         def name
-          "chacha20-poly1305@openssh.com"
+          NAME
         end
 
         def implicit_mac?
@@ -111,6 +120,70 @@ module Net
         def self.key_length
           64
         end
+
+        def self.iv_len
+          0
+        end
+
+        def self.auth_length
+          POLY1305_TAG_BYTES
+        end
+
+        def self.decrypt_private_key(ciphertext, auth_tag, key, _initialization_vector)
+          raise ArgumentError, "chacha20_poly1305: keylength doesn't match" unless
+            key.respond_to?(:bytesize) && key.bytesize == key_length
+
+          ciphertext = binary_string(ciphertext)
+          chacha = OpenSSL::Cipher.new("chacha20")
+          chacha.decrypt
+          chacha.key = binary_string(key[0...POLY1305_KEY_BYTES])
+
+          iv_data = ZERO_IV.dup
+          chacha.iv = iv_data
+          poly_key = chacha.update(ZERO_BLOCK)
+
+          valid_mac = OpenSSL.fixed_length_secure_compare(poly1305_auth(poly_key, ciphertext), auth_tag)
+          raise Net::SSH::Exception, "corrupted hmac detected #{NAME}" unless valid_mac
+
+          iv_data.setbyte(0, 1)
+          chacha.iv = iv_data
+          chacha.update(ciphertext)
+        end
+
+        def self.ensure_supported!
+          raise UnsupportedError, "OpenSSL::PKey raw private key APIs are unavailable" unless OpenSSL::PKey.respond_to?(:new_raw_private_key)
+
+          OpenSSL::Cipher.new("chacha20")
+
+          tag = poly1305_auth("\x00" * POLY1305_KEY_BYTES, "")
+          raise UnsupportedError, "OpenSSL Poly1305 authentication failed" unless tag.bytesize == POLY1305_TAG_BYTES
+        rescue OpenSSL::Cipher::CipherError, OpenSSL::PKey::PKeyError => e
+          raise UnsupportedError, e.message
+        end
+
+        def self.poly1305_auth(poly_key, data)
+          validate_poly1305_key!(poly_key)
+          OpenSSL::PKey.new_raw_private_key(POLY1305_ALGORITHM, binary_string(poly_key)).sign(nil, binary_string(data))
+        end
+
+        def self.validate_poly1305_key!(poly_key)
+          raise ArgumentError, "invalid Poly1305 key" unless poly_key.respond_to?(:bytesize) && poly_key.bytesize == POLY1305_KEY_BYTES
+        end
+
+        def self.binary_string(string)
+          string.dup.force_encoding('BINARY')
+        end
+        private_class_method :binary_string
+
+        def packet_iv(sequence_number)
+          iv_data = ZERO_IV.dup
+          iv_data.setbyte(12, (sequence_number >> 24) & 0xff)
+          iv_data.setbyte(13, (sequence_number >> 16) & 0xff)
+          iv_data.setbyte(14, (sequence_number >> 8) & 0xff)
+          iv_data.setbyte(15, sequence_number & 0xff)
+          iv_data
+        end
+        private :packet_iv
       end
     end
   end

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

@@ -1,15 +1,34 @@
 module Net
   module SSH
     module Transport
-      # Loads chacha20 poly1305 support which requires optinal dependency rbnacl
+      # Loads chacha20-poly1305 support backed by Ruby OpenSSL APIs.
       module ChaCha20Poly1305CipherLoader
         begin
           require 'net/ssh/transport/chacha20_poly1305_cipher'
+          Net::SSH::Transport::ChaCha20Poly1305Cipher.ensure_supported!
           LOADED = true
           ERROR = nil
         rescue LoadError => e
           ERROR = e
           LOADED = false
+        rescue StandardError => e
+          if defined?(Net::SSH::Transport::ChaCha20Poly1305Cipher::UnsupportedError) &&
+             e.is_a?(Net::SSH::Transport::ChaCha20Poly1305Cipher::UnsupportedError)
+            ERROR = e
+            LOADED = false
+          else
+            raise
+          end
+        end
+
+        def self.raiseUnlessLoaded(message)
+          description = LOADED ? '' : chacha20_poly1305_support_required
+          description += "#{ERROR.class} : \"#{ERROR.message}\"\n" if ERROR
+          raise NotImplementedError, "#{message}\n#{description}" unless LOADED
+        end
+
+        def self.chacha20_poly1305_support_required
+          "net-ssh requires openssl >= 3.2.0 and a crypto backend with ChaCha20 and Poly1305 enabled for chacha20-poly1305@openssh.com support.\n"
         end
       end
     end

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

@@ -100,7 +100,11 @@ module Net
         # if :iv_len option is supplied the third return value will be ivlen
         def self.get_lengths(name, options = {})
           klass = SSH_TO_CLASS[name]
-          return [klass.key_length, klass.block_size] unless klass.nil?
+          unless klass.nil?
+            result = [klass.key_length, klass.block_size]
+            result << klass.iv_len if options[:iv_len]
+            return result
+          end
 
           ossl_name = SSH_TO_OSSL[name]
           if ossl_name.nil? || ossl_name == "none"
@@ -124,6 +128,24 @@ module Net
           end
           result
         end
+
+        def self.auth_length(name)
+          klass = SSH_TO_CLASS[name]
+          return klass.auth_length if klass.respond_to?(:auth_length)
+
+          0
+        end
+
+        def self.decrypt_private_key(name, ciphertext, auth_tag, key, initialization_vector)
+          klass = SSH_TO_CLASS[name]
+          raise Net::SSH::Exception, "#{name} does not support private key decryption" unless
+            klass.respond_to?(:decrypt_private_key)
+
+          raise Net::SSH::Exception, "incorrect auth_tag length" unless
+            auth_tag.respond_to?(:bytesize) && auth_tag.bytesize == klass.auth_length
+
+          klass.decrypt_private_key(ciphertext, auth_tag, key, initialization_vector)
+        end
       end
     end
   end

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

@@ -12,6 +12,7 @@ module Net
         DEBUG                     = 4
         SERVICE_REQUEST           = 5
         SERVICE_ACCEPT            = 6
+        EXT_INFO                  = 7
 
         #--
         # Algorithm negotiation messages

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

@@ -5,7 +5,11 @@ module Net
     module Transport
       ## Extension module for aes(128|256)gcm ciphers
       module GCMCipher
-        # rubocop:disable Metrics/AbcSize
+        BLOCK_SIZE = 16
+        IV_BYTES = 12
+        AUTH_TAG_BYTES = 16
+
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         def self.extended(orig)
           # rubocop:disable Metrics/BlockLength
           orig.class_eval do
@@ -100,15 +104,32 @@ module Net
             end
 
             def mac_length
-              16
+              GCMCipher::AUTH_TAG_BYTES
             end
 
             def block_size
-              16
+              GCMCipher::BLOCK_SIZE
             end
 
             def self.block_size
-              16
+              GCMCipher::BLOCK_SIZE
+            end
+
+            def self.iv_len
+              GCMCipher::IV_BYTES
+            end
+
+            def self.auth_length
+              GCMCipher::AUTH_TAG_BYTES
+            end
+
+            def self.decrypt_private_key(ciphertext, auth_tag, key, initialization_vector)
+              cipher = new(encrypt: false, key: key)
+
+              cipher.nonce = initialization_vector
+              cipher.cipher.auth_tag = auth_tag.to_s
+              cipher.cipher.auth_data = ''
+              cipher.cipher.update(ciphertext.to_s) << cipher.cipher.final
             end
 
             #
@@ -117,7 +138,7 @@ module Net
             # N_MAX       maximum nonce (IV) length        12 octets
             #
             def iv_len
-              12
+              GCMCipher::IV_BYTES
             end
 
             #
@@ -201,7 +222,7 @@ module Net
         end
         # rubocop:enable Metrics/BlockLength
       end
-      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
     end
   end
 end

data/lib/net/ssh/transport/kex/curve25519_sha256.rb

@@ -1,7 +1,4 @@
-gem 'x25519' # raise if the gem x25519 is not installed
-
-require 'x25519'
-
+require 'openssl'
 require 'net/ssh/transport/constants'
 require 'net/ssh/transport/kex/abstract5656'
 
@@ -12,25 +9,60 @@ module Net
         # A key-exchange service implementing the "curve25519-sha256@libssh.org"
         # key-exchange algorithm. (defined in https://tools.ietf.org/html/draft-ietf-curdle-ssh-curves-06)
         class Curve25519Sha256 < Abstract5656
+          ALGORITHM = "X25519"
+          KEY_BYTES = 32
+
+          class UnsupportedError < StandardError; end
+
+          def self.ensure_supported!
+            unless OpenSSL::PKey.respond_to?(:generate_key) && OpenSSL::PKey.respond_to?(:new_raw_public_key)
+              raise UnsupportedError, "OpenSSL::PKey raw public key APIs are unavailable"
+            end
+
+            key = generate_x25519_key
+            public_key = new_raw_public_key(key.raw_public_key)
+            validate_key_bytes!(key.derive(public_key), "shared secret", KEY_BYTES)
+          rescue OpenSSL::PKey::PKeyError => e
+            raise UnsupportedError, e.message
+          end
+
+          def self.generate_x25519_key
+            OpenSSL::PKey.generate_key(ALGORITHM)
+          end
+
+          def self.new_raw_public_key(key)
+            validate_key_bytes!(key, "public key", KEY_BYTES)
+            OpenSSL::PKey.new_raw_public_key(ALGORITHM, binary_string(key))
+          end
+
+          def self.validate_key_bytes!(key, label, expected_bytes)
+            raise ArgumentError, "invalid X25519 #{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
+
           def digester
             OpenSSL::Digest::SHA256
           end
 
           private
 
-          def generate_key # :nodoc:
-            ::X25519::Scalar.generate
+          def generate_key
+            self.class.generate_x25519_key
           end
 
           ## string   Q_C, client's ephemeral public key octet string
           def ecdh_public_key_bytes
-            ecdh.public_key.to_bytes
+            ecdh.raw_public_key
           end
 
           # compute shared secret from server's public key and client's private key
           def compute_shared_secret(server_ecdh_pubkey)
-            pk = ::X25519::MontgomeryU.new(server_ecdh_pubkey)
-            OpenSSL::BN.new(ecdh.diffie_hellman(pk).to_bytes, 2)
+            pk = self.class.new_raw_public_key(server_ecdh_pubkey)
+            OpenSSL::BN.new(ecdh.derive(pk), 2)
           end
         end
       end

data/lib/net/ssh/transport/kex/curve25519_sha256_loader.rb

@@ -2,26 +2,34 @@ module Net
   module SSH
     module Transport
       module Kex
-        # Loads Curve25519Sha256 support which requires optinal dependencies
+        # Loads Curve25519Sha256 support backed by Ruby OpenSSL X25519 APIs.
         module Curve25519Sha256Loader
           begin
             require 'net/ssh/transport/kex/curve25519_sha256'
+            Net::SSH::Transport::Kex::Curve25519Sha256.ensure_supported!
             LOADED = true
             ERROR = nil
           rescue LoadError => e
             ERROR = e
             LOADED = false
+          rescue StandardError => e
+            if defined?(Net::SSH::Transport::Kex::Curve25519Sha256::UnsupportedError) &&
+               e.is_a?(Net::SSH::Transport::Kex::Curve25519Sha256::UnsupportedError)
+              ERROR = e
+              LOADED = false
+            else
+              raise
+            end
           end
 
           def self.raiseUnlessLoaded(message)
-            description = ERROR.is_a?(LoadError) ? dependenciesRequiredForX25519 : ''
-            description << "#{ERROR.class} : \"#{ERROR.message}\"\n" if ERROR
+            description = LOADED ? '' : x25519SupportRequired
+            description += "#{ERROR.class} : \"#{ERROR.message}\"\n" if ERROR
             raise NotImplementedError, "#{message}\n#{description}" unless LOADED
           end
 
-          def self.dependenciesRequiredForX25519
-            result = "net-ssh requires the following gems for x25519 support:\n"
-            result << " * x25519\n"
+          def self.x25519SupportRequired
+            "net-ssh requires openssl >= 3.2.0 and a crypto backend with X25519 enabled for curve25519-sha256 support.\n"
           end
         end
       end

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

@@ -62,6 +62,7 @@ module Net
           @port = options[:port] || DEFAULT_PORT
           @bind_address = options[:bind_address] || nil
           @options = options
+          @host_key_verifier = select_host_key_verifier(options[:verify_host_key])
 
           @socket =
             if (factory = options[:proxy])
@@ -75,20 +76,23 @@ module Net
 
           @socket.extend(PacketStream)
           @socket.logger = @logger
+          set_no_delay unless options[:no_delay] == false
 
           debug { "connection established" }
 
           @queue = []
 
-          @host_key_verifier = select_host_key_verifier(options[:verify_host_key])
-
           @server_version = ServerVersion.new(socket, logger, options[:timeout])
 
           @algorithms = Algorithms.new(self, options)
           @algorithms.start
           wait { algorithms.initialized? }
         rescue Errno::ETIMEDOUT
+          @socket&.close
           raise Net::SSH::ConnectionTimeout
+        rescue StandardError
+          @socket&.close
+          raise
         end
 
         def host_keys
@@ -206,6 +210,10 @@ 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" }
+
             when KEXINIT
               algorithms.accept_kexinit(packet)
 
@@ -276,6 +284,18 @@ module Net
 
         private
 
+        # Turns Nagle's algorithm off on the socket, so that a packet written
+        # while the previous one is still unacknowledged goes out right away
+        # instead of waiting for the server's ACK. A ProxyCommand hands the
+        # transport a pipe rather than a socket, and the command on its other
+        # end owns the TCP connection, so there is nothing to set in that case.
+        def set_no_delay
+          return unless socket.respond_to?(:setsockopt)
+
+          debug { "setting TCP_NODELAY" }
+          socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+        end
+
         # Compatibility verifier which allows users to keep using
         # custom verifier code without adding new :verify_signature
         # method.

data/lib/net/ssh/version.rb

@@ -46,17 +46,17 @@ module Net
       end
 
       # The major component of this version of the Net::SSH library
-      MAJOR = 7
+      MAJOR = 8
 
       # The minor component of this version of the Net::SSH library
-      MINOR = 3
+      MINOR = 0
 
       # 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
-      PRE   = nil
+      PRE   = "rc1"
 
       # The current version of the Net::SSH library as a Version instance
       CURRENT = new(*[MAJOR, MINOR, TINY, PRE].compact)

data/lib/net/ssh.rb

@@ -69,7 +69,7 @@ module Net
       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
-      fingerprint_hash check_host_ip pubkey_algorithms
+      fingerprint_hash check_host_ip pubkey_algorithms no_delay
     ]
 
     # The standard means of starting a new SSH connection. When used with a
@@ -156,6 +156,12 @@ module Net
     #   for better performance if your SSH server supports it (most do).
     # * :max_win_size => maximum size we tell the other side that is supported for
     #   the window.
+    # * :no_delay => turns Nagle's algorithm off on the connection's socket
+    #   (TCP_NODELAY), so a packet written while the previous one is still
+    #   unacknowledged is sent right away instead of waiting for the server's
+    #   ACK. OpenSSH does the same for every connection. Set to +false+ to keep
+    #   Nagle's algorithm on. Has no effect when the socket comes from a
+    #   ProxyCommand, whose command owns the TCP connection. Defaults to +true+.
     # * :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.

data/net-ssh.gemspec

@@ -15,7 +15,7 @@ Gem::Specification.new do |spec|
   spec.description   = %q{Net::SSH: a pure-Ruby implementation of the SSH2 client protocol. It allows you to write programs that invoke and interact with processes on remote servers, via SSH2.}
   spec.homepage      = "https://github.com/net-ssh/net-ssh"
   spec.license       = "MIT"
-  spec.required_ruby_version = Gem::Requirement.new(">= 2.6")
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.7")
   spec.metadata = {
     "changelog_uri" => "https://github.com/net-ssh/net-ssh/blob/master/CHANGES.txt"
   }
@@ -30,13 +30,10 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  unless ENV['NET_SSH_NO_ED25519']
-    spec.add_development_dependency("bcrypt_pbkdf", "~> 1.0") unless RUBY_PLATFORM == "java"
-    spec.add_development_dependency("ed25519", "~> 1.2")
-    spec.add_development_dependency('x25519') unless RUBY_PLATFORM == 'java'
-  end
+  spec.add_dependency("logger")
+  spec.add_dependency("openssl", ">= 3.2.0")
 
-  spec.add_development_dependency('rbnacl', '~> 7.1') unless ENV['NET_SSH_NO_RBNACL']
+  spec.add_development_dependency("bcrypt_pbkdf", "~> 1.0") unless RUBY_PLATFORM == "java"
 
   spec.add_development_dependency "base64"
   spec.add_development_dependency "bundler", ">= 1.17"