net-ssh 7.3.9 → 8.0.0.beta3

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/errors.rb

@@ -102,15 +102,5 @@ module Net
     # you want to proceed anyway, simply call the remember_host! method on the
     # exception, and then retry.
     class HostKeyUnknown < HostKeyError; end
-
-    # Raised when the key given by the host, or the CA that signed its
-    # certificate, is marked @revoked in a known hosts file. A revoked key must
-    # never be accepted, so unlike the other host key errors this one can't be
-    # overridden: #remember_host! just raises it again.
-    class HostKeyRevoked < HostKeyError
-      def remember_host!
-        raise self
-      end
-    end
   end
 end

data/lib/net/ssh/key_factory.rb

@@ -55,7 +55,7 @@ module Net
           prompter = nil
           result =
             begin
-              key_type.read(data, passphrase)
+              key_type.read(data, passphrase || 'invalid')
             rescue *key_type.error_classes => e
               encrypted_key = !!key_type.encrypted_key?(data, e) if encrypted_key.nil?
               if encrypted_key && ask_passphrase
@@ -138,9 +138,8 @@ module Net
             raise Exception, "TODO: subclasses should implement"
           end
 
-          # A nil passphrase would make OpenSSL prompt on the terminal itself.
           def self.read(key_data, passphrase)
-            open_ssl_class.new(key_data, passphrase || 'invalid')
+            open_ssl_class.new(key_data, passphrase)
           end
 
           def self.encrypted_key?(key_data, error)
@@ -150,7 +149,7 @@ module Net
 
         class OpenSSLPKeyType < OpenSSLKeyTypeBase
           def self.read(key_data, passphrase)
-            open_ssl_class.read(key_data, passphrase || 'invalid')
+            open_ssl_class.read(key_data, passphrase)
           end
 
           def self.open_ssl_class

data/lib/net/ssh/known_hosts.rb

@@ -93,22 +93,6 @@ 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
@@ -117,17 +101,11 @@ module Net
       include Enumerable
       attr_reader :host
 
-      def initialize(host_keys, host, known_hosts, options = {}, revoked_keys = [])
+      def initialize(host_keys, host, known_hosts, options = {})
         @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)
@@ -173,14 +151,11 @@ 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 = {})
-          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)
+          HostKeys.new(search_in(hostfiles(options), host, options), host, self, options)
         end
 
         # Search for all known keys for the given host, in every file given in
-        # the +files+ array. Returns the list of keys. @revoked entries are not
-        # included.
+        # the +files+ array. Returns the list of keys.
         def search_in(files, host, options = {})
           files.flat_map { |file| KnownHosts.new(file).keys_for(host, options) }
         end
@@ -244,50 +219,46 @@ 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]
 
-        each_entry do |marker, hostlist, key_content, comment|
-          next if marker == "@revoked"
-
-          found = hostlist.any? { |pattern| match(host_name, pattern) } || known_host_hash?(hostlist, entries)
-          next unless found
-
-          found = hostlist.include?(host_ip) if options[:check_host_ip] && entries.size > 1 && hostlist.size > 1
-          next unless found
-
-          raw_key = read_key(key_content)
-
-          keys <<
-            if marker == "@cert-authority"
-              HostKeyEntries::CertAuthority.new(raw_key, comment: comment)
+        File.open(source) do |file|
+          file.each_line do |line|
+            if line.start_with?('@')
+              marker, hosts, type, key_content, comment = line.split(' ')
             else
-              HostKeyEntries::PubKey.new(raw_key, comment: comment)
+              marker = nil
+              hosts, type, key_content, comment = line.split(' ')
             end
-        end
 
-        keys
-      end
+            # Skip empty line or one that is commented
+            next if hosts.nil? || hosts.start_with?('#')
 
-      # 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(/,/)
+            hostlist = hosts.split(',')
+
+            next unless SUPPORTED_TYPE.include?(type)
+
+            found = hostlist.any? { |pattern| match(host_name, pattern) } || known_host_hash?(hostlist, entries)
+            next unless found
 
-        each_entry do |marker, hostlist, key_content, comment|
-          next unless marker == "@revoked"
+            found = hostlist.include?(host_ip) if options[:check_host_ip] && entries.size > 1 && hostlist.size > 1
+            next unless found
 
-          found = entries.any? { |entry| hostlist.any? { |pattern| match(entry, pattern) } }
-          next unless found || known_host_hash?(hostlist, entries)
+            blob = key_content.unpack("m*").first
+            raw_key = Net::SSH::Buffer.new(blob).read_key
 
-          keys << HostKeyEntries::Revoked.new(read_key(key_content), comment: comment)
+            keys <<
+              if marker == "@cert-authority"
+                HostKeyEntries::CertAuthority.new(raw_key, comment: comment)
+              else
+                HostKeyEntries::PubKey.new(raw_key, comment: comment)
+              end
+          end
         end
 
         keys
@@ -332,32 +303,6 @@ 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/proxy/command.rb

@@ -16,11 +16,6 @@ module Net
       #     ...
       #   end
       class Command
-        # The command line is run by the shell, so like OpenSSH 9.6 (CVE-2023-51385) we refuse
-        # host and user names containing shell metacharacters rather than substituting them.
-        INVALID_HOST_NAME = /\A-|[[:space:][:cntrl:]'`"$\\;&<>|(){},]/.freeze
-        INVALID_USER_NAME = /\A-|[[:cntrl:]'`";&<>|(){}]|[[:space:]]-|\\\z/.freeze
-
         # The command line template
         attr_reader :command_line_template
 
@@ -46,13 +41,13 @@ module Net
           command_line = @command_line_template.gsub(/%(.)/) {
             case $1
             when 'h'
-              validate_host_name!(host)
+              host
             when 'p'
-              validate_port!(port)
+              port.to_s
             when 'r'
               remote_user = connection_options && connection_options[:remote_user]
               if remote_user
-                validate_user_name!(remote_user)
+                remote_user
               else
                 raise ArgumentError, "remote user name not available"
               end
@@ -122,26 +117,6 @@ module Net
           Process.kill('TERM', io.pid)
           Thread.new { io.close }
         end
-
-        private
-
-        def validate_host_name!(host)
-          raise ArgumentError, "host name contains invalid characters: #{host.inspect}" if host.to_s.match?(INVALID_HOST_NAME)
-
-          host
-        end
-
-        def validate_user_name!(user)
-          raise ArgumentError, "user name contains invalid characters: #{user.inspect}" if user.to_s.match?(INVALID_USER_NAME)
-
-          user
-        end
-
-        def validate_port!(port)
-          raise ArgumentError, "port is not a number: #{port.inspect}" unless port.to_s.match?(/\A\d+\z/)
-
-          port.to_s
-        end
       end
     end
   end

data/lib/net/ssh/proxy/jump.rb

@@ -1,4 +1,3 @@
-require 'shellwords'
 require 'uri'
 require 'net/ssh/proxy/command'
 
@@ -35,50 +34,20 @@ module Net
         # We cannot build the ProxyCommand template until we know if the :config
         # option was specified during `Net::SSH.start`.
         def build_proxy_command_equivalent(connection_options = nil)
-          raise ArgumentError, "no jump host given" if jump_proxies.empty?
-
+          first_jump, extra_jumps = jump_proxies.split(",", 2)
           config = connection_options && connection_options[:config]
-          uri, *extra_jumps = jump_proxies.split(",", -1).map { |jump| validate_jump!(jump) }
+          uri = URI.parse("ssh://#{first_jump}")
 
           template = "ssh".dup
-          template << " -l #{escape(uri.user)}" if uri.user
-          template << " -p #{uri.port}" if uri.port
-          template << " -J #{escape(extra_jumps.map { |jump| jump_spec(jump) }.join(','))}" unless extra_jumps.empty?
-          template << " -F #{Shellwords.escape(config)}" if config != true && config
+          template << " -l #{uri.user}"    if uri.user
+          template << " -p #{uri.port}"    if uri.port
+          template << " -J #{extra_jumps}" if extra_jumps
+          template << " -F #{config}" if config != true && config
           template << " -W %h:%p "
-          template << escape(uri.host)
+          template << uri.host
 
           @command_line_template = template
         end
-
-        private
-
-        # Escape for the shell, and double any % so it survives the %h/%p
-        # substitution done on the template in Command#open.
-        def escape(value)
-          Shellwords.escape(value).gsub("%", "%%")
-        end
-
-        # Only [user@]host[:port] is checked, so anything else URI accepts (a path,
-        # query, fragment or password) must be refused before it reaches the shell.
-        def validate_jump!(jump)
-          uri = URI.parse("ssh://#{jump}")
-          raise URI::InvalidURIError if uri.host.to_s.empty? || jump_spec(uri) != jump
-
-          validate_user_name!(uri.user) if uri.user
-          validate_host_name!(uri.host)
-          validate_port!(uri.port) if uri.port
-          uri
-        rescue URI::InvalidURIError
-          raise ArgumentError, "jump host is not [user@]host[:port]: #{jump.inspect}"
-        end
-
-        def jump_spec(uri)
-          spec = uri.host.dup
-          spec.prepend("#{uri.user}@") if uri.user
-          spec << ":#{uri.port}" if uri.port
-          spec
-        end
       end
     end
   end

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

@@ -405,12 +405,6 @@ module Net
 
         # The callback used when an auth-agent channel is requested by the server.
         def auth_agent_channel(session, channel, packet)
-          # Like OpenSSH, only relay the local agent when forwarding was requested (GHSA-qpg5-fx6p-8cq3).
-          unless session.options[:forward_agent] || @agent_forwarded
-            error { "server tried agent forwarding, which was not requested; refusing" }
-            raise Net::SSH::ChannelOpenFailed.new(1, "agent forwarding was not requested")
-          end
-
           info { "opening auth-agent channel" }
           channel[:invisible] = true
 

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