net-ssh-backports 6.3.0.backports

data/lib/net/ssh/known_hosts.rb

@@ -0,0 +1,264 @@
+require 'strscan'
+require 'openssl'
+require 'base64'
+require 'net/ssh/buffer'
+require 'net/ssh/authentication/ed25519_loader'
+
+module Net
+  module SSH
+    module HostKeyEntries
+      # regular public key entry
+      class PubKey < Delegator
+        def initialize(key, comment: nil) # rubocop:disable Lint/MissingSuper
+          @key = key
+          @comment = comment
+        end
+
+        def ssh_type
+          @key.ssh_type
+        end
+
+        def ssh_types
+          [ssh_type]
+        end
+
+        def to_blob
+          @key.to_blob
+        end
+
+        def __getobj__
+          Kernel.warn("Calling Net::SSH::Buffer methods on HostKeyEntries PubKey is deprecated")
+          @key
+        end
+
+        def matches_key?(server_key)
+          @key.ssh_type == server_key.ssh_type && @key.to_blob == server_key.to_blob
+        end
+      end
+
+      # @cert-authority entry
+      class CertAuthority
+        def ssh_types
+          %w[
+            ecdsa-sha2-nistp256-cert-v01@openssh.com
+            ecdsa-sha2-nistp384-cert-v01@openssh.com
+            ecdsa-sha2-nistp521-cert-v01@openssh.com
+            ssh-ed25519-cert-v01@openssh.com
+            ssh-rsa-cert-v01@openssh.com
+            ssh-rsa-cert-v00@openssh.com
+          ]
+        end
+
+        def initialize(key, comment: nil)
+          @key = key
+          @comment = comment
+        end
+
+        def matches_key?(server_key)
+          if ssh_types.include?(server_key.ssh_type)
+            server_key.signature_valid? && (server_key.signature_key.to_blob == @key.to_blob)
+          else
+            false
+          end
+        end
+      end
+    end
+
+    # Represents the result of a search in known hosts
+    # see search_for
+    class HostKeys
+      include Enumerable
+      attr_reader :host
+
+      def initialize(host_keys, host, known_hosts, options = {})
+        @host_keys = host_keys
+        @host = host
+        @known_hosts = known_hosts
+        @options = options
+      end
+
+      def add_host_key(key)
+        @known_hosts.add(@host, key, @options)
+        @host_keys.push(key)
+      end
+
+      def each(&block)
+        @host_keys.each(&block)
+      end
+
+      def empty?
+        @host_keys.empty?
+      end
+    end
+
+    # Searches an OpenSSH-style known-host file for a given host, and returns all
+    # matching keys. This is used to implement host-key verification, as well as
+    # to determine what key a user prefers to use for a given host.
+    #
+    # This is used internally by Net::SSH, and will never need to be used directly
+    # by consumers of the library.
+    class KnownHosts
+      SUPPORTED_TYPE = %w[ssh-rsa ssh-dss
+                          ecdsa-sha2-nistp256
+                          ecdsa-sha2-nistp384
+                          ecdsa-sha2-nistp521]
+
+      SUPPORTED_TYPE.push('ssh-ed25519') if Net::SSH::Authentication::ED25519Loader::LOADED
+
+      class <<self
+        # 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)
+        end
+
+        # Search for all known keys for the given host, in every file given in
+        # 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
+
+        # Looks in the given +options+ hash for the :user_known_hosts_file and
+        # :global_known_hosts_file keys, and returns an array of all known
+        # hosts files. If the :user_known_hosts_file key is not set, the
+        # default is returned (~/.ssh/known_hosts and ~/.ssh/known_hosts2). If
+        # :global_known_hosts_file is not set, the default is used
+        # (/etc/ssh/ssh_known_hosts and /etc/ssh/ssh_known_hosts2).
+        #
+        # If you only want the user known host files, you can pass :user as
+        # the second option.
+        def hostfiles(options, which=:all)
+          files = []
+
+          files += Array(options[:user_known_hosts_file] || %w[~/.ssh/known_hosts ~/.ssh/known_hosts2]) if which == :all || which == :user
+
+          if which == :all || which == :global
+            files += Array(options[:global_known_hosts_file] || %w[/etc/ssh/ssh_known_hosts /etc/ssh/ssh_known_hosts2])
+          end
+
+          return files
+        end
+
+        # Looks in all user known host files (see KnownHosts.hostfiles) and tries to
+        # add an entry for the given host and key to the first file it is able
+        # to.
+        def add(host, key, options={})
+          hostfiles(options, :user).each do |file|
+            KnownHosts.new(file).add(host, key)
+            return
+          rescue SystemCallError
+            # try the next hostfile
+          end
+        end
+      end
+
+      # The host-key file name that this KnownHosts instance will use to search
+      # for keys.
+      attr_reader :source
+
+      # Instantiate a new KnownHosts instance that will search the given known-hosts
+      # file. The path is expanded file File.expand_path.
+      def initialize(source)
+        @source = File.expand_path(source)
+      end
+
+      # Returns an array of all keys that are known to be associatd with the
+      # given host. The +host+ parameter is either the domain name or ip address
+      # of the host, or both (comma-separated). Additionally, if a non-standard
+      # port is being used, it may be specified by putting the host (or ip, or
+      # both) in square brackets, and appending the port outside the brackets
+      # after a colon. Possible formats for +host+, then, are;
+      #
+      #   "net.ssh.test"
+      #   "1.2.3.4"
+      #   "net.ssh.test,1.2.3.4"
+      #   "[net.ssh.test]:5555"
+      #   "[1,2,3,4]:5555"
+      #   "[net.ssh.test]:5555,[1.2.3.4]:5555
+      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
+
+            # Skip empty line or one that is commented
+            next if hosts.nil? || hosts.start_with?('#')
+
+            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
+
+            found = hostlist.include?(host_ip) if options[:check_host_ip] && entries.size > 1 && hostlist.size > 1
+            next unless found
+
+            blob = key_content.unpack("m*").first
+            raw_key = Net::SSH::Buffer.new(blob).read_key
+
+            keys <<
+              if marker == "@cert-authority"
+                HostKeyEntries::CertAuthority.new(raw_key, comment: comment)
+              else
+                HostKeyEntries::PubKey.new(raw_key, comment: comment)
+              end
+          end
+        end
+
+        keys
+      end
+
+      def match(host, pattern)
+        if pattern.include?('*') || pattern.include?('?')
+          # see man 8 sshd for pattern details
+          pattern_regexp = pattern.split('*', -1).map do |x|
+            x.split('?', -1).map do |y|
+              Regexp.escape(y)
+            end.join('.')
+          end.join('.*')
+
+          host =~ Regexp.new("\\A#{pattern_regexp}\\z")
+        else
+          host == pattern
+        end
+      end
+
+      # Indicates whether one of the entries matches an hostname that has been
+      # stored as a HMAC-SHA1 hash in the known hosts.
+      def known_host_hash?(hostlist, entries)
+        if hostlist.size == 1 && hostlist.first =~ /\A\|1(\|.+){2}\z/
+          chunks = hostlist.first.split(/\|/)
+          salt = Base64.decode64(chunks[2])
+          digest = OpenSSL::Digest.new('sha1')
+          entries.each do |entry|
+            hmac = OpenSSL::HMAC.digest(digest, salt, entry)
+            return true if Base64.encode64(hmac).chomp == chunks[3]
+          end
+        end
+        false
+      end
+
+      # Tries to append an entry to the current source file for the given host
+      # and key. If it is unable to (because the file is not writable, for
+      # instance), an exception will be raised.
+      def add(host, key)
+        File.open(source, "a") do |file|
+          blob = [Net::SSH::Buffer.from(:key, key).to_s].pack("m*").gsub(/\s/, "")
+          file.puts "#{host} #{key.ssh_type} #{blob}"
+        end
+      end
+    end
+  end
+end

data/lib/net/ssh/loggable.rb

@@ -0,0 +1,62 @@
+module Net
+  module SSH
+    # A simple module to make logging easier to deal with. It assumes that the
+    # logger instance (if not nil) quacks like a Logger object (in Ruby's
+    # standard library). Although used primarily internally by Net::SSH, it
+    # can easily be used to add Net::SSH-like logging to your own programs.
+    #
+    #   class MyClass
+    #     include Net::SSH::Loggable
+    #   end
+    #
+    #   Net::SSH.start(...) do |ssh|
+    #     obj = MyClass.new
+    #     obj.logger = ssh.logger
+    #     ...
+    #   end
+    module Loggable
+      # The logger instance that will be used to log messages. If nil, nothing
+      # will be logged.
+      attr_accessor :logger
+
+      # Displays the result of yielding if the log level is Logger::DEBUG or
+      # greater.
+      def debug
+        logger.add(Logger::DEBUG, nil, facility) { yield } if logger && logger.debug?
+      end
+
+      # Displays the result of yielding if the log level is Logger::INFO or
+      # greater.
+      def info
+        logger.add(Logger::INFO, nil, facility) { yield } if logger && logger.info?
+      end
+
+      # Displays the result of yielding if the log level is Logger::WARN or
+      # greater. (Called lwarn to avoid shadowing with Kernel#warn.)
+      def lwarn
+        logger.add(Logger::WARN, nil, facility) { yield } if logger && logger.warn?
+      end
+
+      # Displays the result of yielding if the log level is Logger:ERROR or
+      # greater.
+      def error
+        logger.add(Logger::ERROR, nil, facility) { yield } if logger && logger.error?
+      end
+
+      # Displays the result of yielding if the log level is Logger::FATAL or
+      # greater.
+      def fatal
+        logger.add(Logger::FATAL, nil, facility) { yield } if logger && logger.fatal?
+      end
+
+      private
+
+      # Sets the "facility" value, used for reporting where a log message
+      # originates. It defaults to the name of class with the object_id
+      # appended.
+      def facility
+        @facility ||= self.class.to_s.gsub(/::/, ".").gsub(/([a-z])([A-Z])/, "\\1_\\2").downcase + "[%x]" % object_id
+      end
+    end
+  end
+end

data/lib/net/ssh/packet.rb

@@ -0,0 +1,106 @@
+require 'net/ssh/buffer'
+require 'net/ssh/transport/constants'
+require 'net/ssh/authentication/constants'
+require 'net/ssh/connection/constants'
+
+module Net
+  module SSH
+    # A specialization of Buffer that knows the format of certain common
+    # packet types. It auto-parses those packet types, and allows them to
+    # be accessed via the #[] accessor.
+    #
+    #   data = some_channel_request_packet
+    #   packet = Net::SSH::Packet.new(data)
+    #
+    #   p packet.type #-> 98 (CHANNEL_REQUEST)
+    #   p packet[:request]
+    #   p packet[:want_reply]
+    #
+    # This is used exclusively internally by Net::SSH, and unless you're doing
+    # protocol-level manipulation or are extending Net::SSH in some way, you'll
+    # never need to use this class directly.
+    class Packet < Buffer
+      @@types = {}
+
+      # Register a new packet type that should be recognized and auto-parsed by
+      # Net::SSH::Packet. Note that any packet type that is not preregistered
+      # will not be autoparsed.
+      #
+      # The +pairs+ parameter must be either empty, or an array of two-element
+      # tuples, where the first element of each tuple is the name of the field,
+      # and the second is the type.
+      #
+      #   register DISCONNECT, [:reason_code, :long], [:description, :string], [:language, :string]
+      def self.register(type, *pairs)
+        @@types[type] = pairs
+      end
+
+      include Connection::Constants
+      include Authentication::Constants
+      include Transport::Constants
+
+      #--
+      # These are the recognized packet types. All other packet types will be
+      # accepted, but not auto-parsed, requiring the client to parse the
+      # fields using the methods provided by Net::SSH::Buffer.
+      #++
+
+      register DISCONNECT,                %i[reason_code long], %i[description string], %i[language string]
+      register IGNORE,                    %i[data string]
+      register UNIMPLEMENTED,             %i[number long]
+      register DEBUG,                     %i[always_display bool], %i[message string], %i[language string]
+      register SERVICE_ACCEPT,            %i[service_name string]
+      register USERAUTH_BANNER,           %i[message string], %i[language string]
+      register USERAUTH_FAILURE,          %i[authentications string], %i[partial_success bool]
+      register GLOBAL_REQUEST,            %i[request_type string], %i[want_reply bool], %i[request_data buffer]
+      register CHANNEL_OPEN,              %i[channel_type string], %i[remote_id long], %i[window_size long], %i[packet_size long]
+      register CHANNEL_OPEN_CONFIRMATION, %i[local_id long], %i[remote_id long], %i[window_size long], %i[packet_size long]
+      register CHANNEL_OPEN_FAILURE,      %i[local_id long], %i[reason_code long], %i[description string], %i[language string]
+      register CHANNEL_WINDOW_ADJUST,     %i[local_id long], %i[extra_bytes long]
+      register CHANNEL_DATA,              %i[local_id long], %i[data string]
+      register CHANNEL_EXTENDED_DATA,     %i[local_id long], %i[data_type long], %i[data string]
+      register CHANNEL_EOF,               %i[local_id long]
+      register CHANNEL_CLOSE,             %i[local_id long]
+      register CHANNEL_REQUEST,           %i[local_id long], %i[request string], %i[want_reply bool], %i[request_data buffer]
+      register CHANNEL_SUCCESS,           %i[local_id long]
+      register CHANNEL_FAILURE,           %i[local_id long]
+
+      # The (integer) type of this packet.
+      attr_reader :type
+
+      # Create a new packet from the given payload. This will automatically
+      # parse the packet if it is one that has been previously registered with
+      # Packet.register; otherwise, the packet will need to be manually parsed
+      # using the methods provided in the Net::SSH::Buffer superclass.
+      def initialize(payload)
+        @named_elements = {}
+        super
+        @type = read_byte
+        instantiate!
+      end
+
+      # Access one of the auto-parsed fields by name. Raises an error if no
+      # element by the given name exists.
+      def [](name)
+        name = name.to_sym
+        raise ArgumentError, "no such element #{name}" unless @named_elements.key?(name)
+
+        @named_elements[name]
+      end
+
+      private
+
+      # Parse the packet's contents and assign the named elements, as described
+      # by the registered format for the packet.
+      def instantiate!
+        (@@types[type] || []).each do |name, datatype|
+          @named_elements[name.to_sym] = if datatype == :buffer
+                                           remainder_as_buffer
+                                         else
+                                           send("read_#{datatype}")
+                                         end
+        end
+      end
+    end
+  end
+end

data/lib/net/ssh/prompt.rb

@@ -0,0 +1,62 @@
+require 'io/console'
+
+module Net
+  module SSH
+    # Default prompt implementation, called for asking password from user.
+    # It will never be instantiated directly, but will instead be created for
+    # you automatically.
+    #
+    # A custom prompt objects can implement caching, or different UI. The prompt
+    # object should implemnted a start method, which should return something implementing
+    # ask and success. Net::SSH uses it like:
+    #
+    #   prompter = options[:password_prompt].start({type:'password'})
+    #   while !ok && max_retries < 3
+    #     user = prompter.ask("user: ", true)
+    #     password = prompter.ask("password: ", false)
+    #     ok = send(user, password)
+    #     prompter.sucess if ok
+    #   end
+    #
+    class Prompt
+      # factory
+      def self.default(options = {})
+        @default ||= new(options)
+      end
+
+      def initialize(options = {}); end
+
+      # default prompt object implementation. More sophisticated implemenetations
+      # might implement caching.
+      class Prompter
+        def initialize(info)
+          if info[:type] == 'keyboard-interactive'
+            $stdout.puts(info[:name]) unless info[:name].empty?
+            $stdout.puts(info[:instruction]) unless info[:instruction].empty?
+          end
+        end
+
+        # ask input from user, a prompter might ask for multiple inputs
+        # (like user and password) in a single session.
+        def ask(prompt, echo=true)
+          $stdout.print(prompt)
+          $stdout.flush
+          ret = $stdin.noecho(&:gets).chomp
+          $stdout.print("\n")
+          ret
+        end
+
+        # success method will be called when the password was accepted
+        # It's a good time to save password asked to a cache.
+        def success; end
+      end
+
+      # start password session. Multiple questions might be asked multiple times
+      # on the returned object. Info hash tries to uniquely identify the password
+      # session, so caching implementations can save passwords properly.
+      def start(info)
+        Prompter.new(info)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,123 @@
+require 'socket'
+require 'rubygems'
+require 'net/ssh/proxy/errors'
+
+module Net
+  module SSH
+    module Proxy
+      # An implementation of a command proxy. To use it, instantiate it,
+      # then pass the instantiated object via the :proxy key to
+      # Net::SSH.start:
+      #
+      #   require 'net/ssh/proxy/command'
+      #
+      #   proxy = Net::SSH::Proxy::Command.new('ssh relay nc %h %p')
+      #   Net::SSH.start('host', 'user', :proxy => proxy) do |ssh|
+      #     ...
+      #   end
+      class Command
+        # The command line template
+        attr_reader :command_line_template
+
+        # The command line for the session
+        attr_reader :command_line
+
+        # Timeout in seconds in open, defaults to 60
+        attr_accessor :timeout
+
+        # Create a new socket factory that tunnels via a command executed
+        # with the user's shell, which is composed from the given command
+        # template.  In the command template, `%h' will be substituted by
+        # the host name to connect and `%p' by the port.
+        def initialize(command_line_template)
+          @command_line_template = command_line_template
+          @command_line = nil
+          @timeout = 60
+        end
+
+        # Return a new socket connected to the given host and port via the
+        # proxy that was requested when the socket factory was instantiated.
+        def open(host, port, connection_options = nil)
+          command_line = @command_line_template.gsub(/%(.)/) {
+            case $1
+            when 'h'
+              host
+            when 'p'
+              port.to_s
+            when 'r'
+              remote_user = connection_options && connection_options[:remote_user]
+              if remote_user
+                remote_user
+              else
+                raise ArgumentError, "remote user name not available"
+              end
+            when '%'
+              '%'
+            else
+              raise ArgumentError, "unknown key: #{$1}"
+            end
+          }
+          begin
+            io = IO.popen(command_line, "r+")
+            begin
+              if result = IO.select([io], nil, [io], @timeout)
+                if result.last.any? || io.eof?
+                  raise "command failed"
+                end
+              else
+                raise "command timed out"
+              end
+            rescue StandardError
+              close_on_error(io)
+              raise
+            end
+          rescue StandardError => e
+            raise ConnectError, "#{e}: #{command_line}"
+          end
+          @command_line = command_line
+          if Gem.win_platform?
+            # read_nonblock and write_nonblock are not available on Windows
+            # pipe. Use sysread and syswrite as a replacement works.
+            def io.send(data, flag)
+              syswrite(data)
+            end
+
+            def io.recv(size)
+              sysread(size)
+            end
+          else
+            def io.send(data, flag)
+              begin
+                result = write_nonblock(data)
+              rescue IO::WaitWritable, Errno::EINTR
+                IO.select(nil, [self])
+                retry
+              end
+              result
+            end
+
+            def io.recv(size)
+              begin
+                result = read_nonblock(size)
+              rescue IO::WaitReadable, Errno::EINTR
+                timeout_in_seconds = 20
+                if IO.select([self], nil, [self], timeout_in_seconds) == nil
+                  raise "Unexpected spurious read wakeup"
+                end
+
+                retry
+              end
+              result
+            end
+          end
+          io
+        end
+
+        def close_on_error(io)
+          Process.kill('TERM', io.pid)
+          Thread.new { io.close }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+require 'net/ssh/errors'
+
+module Net
+  module SSH
+    module Proxy
+      # A general exception class for all Proxy errors.
+      class Error < Net::SSH::Exception; end
+
+      # Used for reporting proxy connection errors.
+      class ConnectError < Error; end
+
+      # Used when the server doesn't recognize the user's credentials.
+      class UnauthorizedError < Error; end
+    end
+  end
+end