net-ssh 4.2.0 → 7.0.1

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

@@ -1,248 +1,280 @@
 require 'net/ssh/buffered_io'
 require 'net/ssh/errors'
 require 'net/ssh/packet'
-require 'net/ssh/ruby_compat'
 require 'net/ssh/transport/cipher_factory'
 require 'net/ssh/transport/hmac'
 require 'net/ssh/transport/state'
 
+module Net
+  module SSH
+    module Transport
+      # A module that builds additional functionality onto the Net::SSH::BufferedIo
+      # module. It adds SSH encryption, compression, and packet validation, as
+      # per the SSH2 protocol. It also adds an abstraction for polling packets,
+      # to allow for both blocking and non-blocking reads.
+      module PacketStream
+        PROXY_COMMAND_HOST_IP = '<no hostip for proxy command>'.freeze
 
-module Net; module SSH; module Transport
+        include BufferedIo
 
-  # A module that builds additional functionality onto the Net::SSH::BufferedIo
-  # module. It adds SSH encryption, compression, and packet validation, as
-  # per the SSH2 protocol. It also adds an abstraction for polling packets,
-  # to allow for both blocking and non-blocking reads.
-  module PacketStream
-    PROXY_COMMAND_HOST_IP = '<no hostip for proxy command>'.freeze
-
-    include BufferedIo
-
-    def self.extended(object)
-      object.__send__(:initialize_ssh)
-    end
+        def self.extended(object)
+          object.__send__(:initialize_ssh)
+        end
 
-    # The map of "hints" that can be used to modify the behavior of the packet
-    # stream. For instance, when authentication succeeds, an "authenticated"
-    # hint is set, which is used to determine whether or not to compress the
-    # data when using the "delayed" compression algorithm.
-    attr_reader :hints
-
-    # The server state object, which encapsulates the algorithms used to interpret
-    # packets coming from the server.
-    attr_reader :server
-
-    # The client state object, which encapsulates the algorithms used to build
-    # packets to send to the server.
-    attr_reader :client
-
-    # The name of the client (local) end of the socket, as reported by the
-    # socket.
-    def client_name
-      @client_name ||= begin
-        sockaddr = getsockname
-        begin
-          Socket.getnameinfo(sockaddr, Socket::NI_NAMEREQD).first
-        rescue
-          begin
-            Socket.getnameinfo(sockaddr).first
-          rescue
+        # The map of "hints" that can be used to modify the behavior of the packet
+        # stream. For instance, when authentication succeeds, an "authenticated"
+        # hint is set, which is used to determine whether or not to compress the
+        # data when using the "delayed" compression algorithm.
+        attr_reader :hints
+
+        # The server state object, which encapsulates the algorithms used to interpret
+        # packets coming from the server.
+        attr_reader :server
+
+        # The client state object, which encapsulates the algorithms used to build
+        # packets to send to the server.
+        attr_reader :client
+
+        # The name of the client (local) end of the socket, as reported by the
+        # socket.
+        def client_name
+          @client_name ||= begin
+            sockaddr = getsockname
             begin
-              Socket.gethostbyname(Socket.gethostname).first
-            rescue
-              lwarn { "the client ipaddr/name could not be determined" }
-              "unknown"
+              Socket.getnameinfo(sockaddr, Socket::NI_NAMEREQD).first
+            rescue StandardError
+              begin
+                Socket.getnameinfo(sockaddr).first
+              rescue StandardError
+                begin
+                  Socket.gethostbyname(Socket.gethostname).first
+                rescue StandardError
+                  lwarn { "the client ipaddr/name could not be determined" }
+                  "unknown"
+                end
+              end
             end
           end
         end
-      end
-    end
 
-    # The IP address of the peer (remote) end of the socket, as reported by
-    # the socket.
-    def peer_ip
-      @peer_ip ||=
-        if respond_to?(:getpeername)
-          addr = getpeername
-          Socket.getnameinfo(addr, Socket::NI_NUMERICHOST | Socket::NI_NUMERICSERV).first
-        else
-          PROXY_COMMAND_HOST_IP
+        # The IP address of the peer (remote) end of the socket, as reported by
+        # the socket.
+        def peer_ip
+          @peer_ip ||=
+            if respond_to?(:getpeername)
+              addr = getpeername
+              Socket.getnameinfo(addr, Socket::NI_NUMERICHOST | Socket::NI_NUMERICSERV).first
+            else
+              PROXY_COMMAND_HOST_IP
+            end
         end
-    end
 
-    # Returns true if the IO is available for reading, and false otherwise.
-    def available_for_read?
-      result = Net::SSH::Compat.io_select([self], nil, nil, 0)
-      result && result.first.any?
-    end
+        # Returns true if the IO is available for reading, and false otherwise.
+        def available_for_read?
+          result = IO.select([self], nil, nil, 0)
+          result && result.first.any?
+        end
 
-    # Returns the next full packet. If the mode parameter is :nonblock (the
-    # default), then this will return immediately, whether a packet is
-    # available or not, and will return nil if there is no packet ready to be
-    # returned. If the mode parameter is :block, then this method will block
-    # until a packet is available.
-    def next_packet(mode=:nonblock)
-      case mode
-      when :nonblock then
-        packet = poll_next_packet
-        return packet if packet
-
-        if available_for_read?
-          if fill <= 0
-            result = poll_next_packet
-            if result.nil?
-              raise Net::SSH::Disconnect, "connection closed by remote host"
-            else
-              return result
+        # Returns the next full packet. If the mode parameter is :nonblock (the
+        # default), then this will return immediately, whether a packet is
+        # available or not, and will return nil if there is no packet ready to be
+        # returned. If the mode parameter is :block, then this method will block
+        # until a packet is available or timeout seconds have passed.
+        def next_packet(mode = :nonblock, timeout = nil)
+          case mode
+          when :nonblock then
+            packet = poll_next_packet
+            return packet if packet
+
+            if available_for_read?
+              if fill <= 0
+                result = poll_next_packet
+                if result.nil?
+                  raise Net::SSH::Disconnect, "connection closed by remote host"
+                else
+                  return result
+                end
+              end
             end
-          end
-        end
-        poll_next_packet
+            poll_next_packet
 
-      when :block then
-        loop do
-          packet = poll_next_packet
-          return packet if packet
+          when :block then
+            loop do
+              packet = poll_next_packet
+              return packet if packet
 
-          loop do
-            result = Net::SSH::Compat.io_select([self]) or next
-            break if result.first.any?
-          end
+              result = IO.select([self], nil, nil, timeout)
+              raise Net::SSH::ConnectionTimeout, "timeout waiting for next packet" unless result
+              raise Net::SSH::Disconnect, "connection closed by remote host" if fill <= 0
+            end
 
-          if fill <= 0
-            raise Net::SSH::Disconnect, "connection closed by remote host"
+          else
+            raise ArgumentError, "expected :block or :nonblock, got #{mode.inspect}"
           end
         end
 
-      else
-        raise ArgumentError, "expected :block or :nonblock, got #{mode.inspect}"
-      end
-    end
+        # Enqueues a packet to be sent, and blocks until the entire packet is
+        # sent.
+        def send_packet(payload)
+          enqueue_packet(payload)
+          wait_for_pending_sends
+        end
 
-    # Enqueues a packet to be sent, and blocks until the entire packet is
-    # sent.
-    def send_packet(payload)
-      enqueue_packet(payload)
-      wait_for_pending_sends
-    end
+        # Enqueues a packet to be sent, but does not immediately send the packet.
+        # The given payload is pre-processed according to the algorithms specified
+        # in the client state (compression, cipher, and hmac).
+        def enqueue_packet(payload)
+          # try to compress the packet
+          payload = client.compress(payload)
 
-    # Enqueues a packet to be sent, but does not immediately send the packet.
-    # The given payload is pre-processed according to the algorithms specified
-    # in the client state (compression, cipher, and hmac).
-    def enqueue_packet(payload)
-      # try to compress the packet
-      payload = client.compress(payload)
+          # the length of the packet, minus the padding
+          actual_length = (client.hmac.etm ? 0 : 4) + payload.bytesize + 1
 
-      # the length of the packet, minus the padding
-      actual_length = 4 + payload.bytesize + 1
+          # compute the padding length
+          padding_length = client.block_size - (actual_length % client.block_size)
+          padding_length += client.block_size if padding_length < 4
 
-      # compute the padding length
-      padding_length = client.block_size - (actual_length % client.block_size)
-      padding_length += client.block_size if padding_length < 4
+          # compute the packet length (sans the length field itself)
+          packet_length = payload.bytesize + padding_length + 1
 
-      # compute the packet length (sans the length field itself)
-      packet_length = payload.bytesize + padding_length + 1
+          if packet_length < 16
+            padding_length += client.block_size
+            packet_length = payload.bytesize + padding_length + 1
+          end
 
-      if packet_length < 16
-        padding_length += client.block_size
-        packet_length = payload.bytesize + padding_length + 1
-      end
+          padding = Array.new(padding_length) { rand(256) }.pack("C*")
 
-      padding = Array.new(padding_length) { rand(256) }.pack("C*")
+          if client.hmac.etm
+            debug { "using encrypt-then-mac" }
 
-      unencrypted_data = [packet_length, padding_length, payload, padding].pack("NCA*A*")
-      mac = client.hmac.digest([client.sequence_number, unencrypted_data].pack("NA*"))
+            # Encrypt padding_length, payload, and padding. Take MAC
+            # from the unencrypted packet_lenght and the encrypted
+            # data.
+            length_data = [packet_length].pack("N")
 
-      encrypted_data = client.update_cipher(unencrypted_data) << client.final_cipher
-      message = encrypted_data + mac
+            unencrypted_data = [padding_length, payload, padding].pack("CA*A*")
 
-      debug { "queueing packet nr #{client.sequence_number} type #{payload.getbyte(0)} len #{packet_length}" }
-      enqueue(message)
+            encrypted_data = client.update_cipher(unencrypted_data) << client.final_cipher
 
-      client.increment(packet_length)
+            mac_data = length_data + encrypted_data
 
-      self
-    end
+            mac = client.hmac.digest([client.sequence_number, mac_data].pack("NA*"))
 
-    # Performs any pending cleanup necessary on the IO and its associated
-    # state objects. (See State#cleanup).
-    def cleanup
-      client.cleanup
-      server.cleanup
-    end
+            message = mac_data + mac
+          else
+            unencrypted_data = [packet_length, padding_length, payload, padding].pack("NCA*A*")
 
-    # If the IO object requires a rekey operation (as indicated by either its
-    # client or server state objects, see State#needs_rekey?), this will
-    # yield. Otherwise, this does nothing.
-    def if_needs_rekey?
-      if client.needs_rekey? || server.needs_rekey?
-        yield
-        client.reset! if client.needs_rekey?
-        server.reset! if server.needs_rekey?
-      end
-    end
+            mac = client.hmac.digest([client.sequence_number, unencrypted_data].pack("NA*"))
 
-    protected
+            encrypted_data = client.update_cipher(unencrypted_data) << client.final_cipher
 
-      # Called when this module is used to extend an object. It initializes
-      # the states and generally prepares the object for use as a packet stream.
-      def initialize_ssh
-        @hints  = {}
-        @server = State.new(self, :server)
-        @client = State.new(self, :client)
-        @packet = nil
-        initialize_buffered_io
-      end
+            message = encrypted_data + mac
+          end
+
+          debug { "queueing packet nr #{client.sequence_number} type #{payload.getbyte(0)} len #{packet_length}" }
+          enqueue(message)
 
-      # Tries to read the next packet. If there is insufficient data to read
-      # an entire packet, this returns immediately, otherwise the packet is
-      # read, post-processed according to the cipher, hmac, and compression
-      # algorithms specified in the server state object, and returned as a
-      # new Packet object.
-      def poll_next_packet
-        if @packet.nil?
-          minimum = server.block_size < 4 ? 4 : server.block_size
-          return nil if available < minimum
-          data = read_available(minimum)
-
-          # decipher it
-          @packet = Net::SSH::Buffer.new(server.update_cipher(data))
-          @packet_length = @packet.read_long
+          client.increment(packet_length)
+
+          self
+        end
+
+        # Performs any pending cleanup necessary on the IO and its associated
+        # state objects. (See State#cleanup).
+        def cleanup
+          client.cleanup
+          server.cleanup
         end
 
-        need = @packet_length + 4 - server.block_size
-        raise Net::SSH::Exception, "padding error, need #{need} block #{server.block_size}" if need % server.block_size != 0
+        # If the IO object requires a rekey operation (as indicated by either its
+        # client or server state objects, see State#needs_rekey?), this will
+        # yield. Otherwise, this does nothing.
+        def if_needs_rekey?
+          if client.needs_rekey? || server.needs_rekey?
+            yield
+            client.reset! if client.needs_rekey?
+            server.reset! if server.needs_rekey?
+          end
+        end
 
-        return nil if available < need + server.hmac.mac_length
+        protected
 
-        if need > 0
-          # read the remainder of the packet and decrypt it.
-          data = read_available(need)
-          @packet.append(server.update_cipher(data))
+        # Called when this module is used to extend an object. It initializes
+        # the states and generally prepares the object for use as a packet stream.
+        def initialize_ssh
+          @hints  = {}
+          @server = State.new(self, :server)
+          @client = State.new(self, :client)
+          @packet = nil
+          initialize_buffered_io
         end
 
-        # get the hmac from the tail of the packet (if one exists), and
-        # then validate it.
-        real_hmac = read_available(server.hmac.mac_length) || ""
+        # Tries to read the next packet. If there is insufficient data to read
+        # an entire packet, this returns immediately, otherwise the packet is
+        # read, post-processed according to the cipher, hmac, and compression
+        # algorithms specified in the server state object, and returned as a
+        # new Packet object.
+        # rubocop:disable Metrics/AbcSize
+        def poll_next_packet
+          aad_length = server.hmac.etm ? 4 : 0
+
+          if @packet.nil?
+            minimum = server.block_size < 4 ? 4 : server.block_size
+            return nil if available < minimum + aad_length
+
+            data = read_available(minimum + aad_length)
+
+            # decipher it
+            if server.hmac.etm
+              @packet_length = data.unpack("N").first
+              @mac_data = data
+              @packet = Net::SSH::Buffer.new(server.update_cipher(data[aad_length..-1]))
+            else
+              @packet = Net::SSH::Buffer.new(server.update_cipher(data))
+              @packet_length = @packet.read_long
+            end
+          end
 
-        @packet.append(server.final_cipher)
-        padding_length = @packet.read_byte
+          need = @packet_length + 4 - aad_length - server.block_size
+          raise Net::SSH::Exception, "padding error, need #{need} block #{server.block_size}" if need % server.block_size != 0
+
+          return nil if available < need + server.hmac.mac_length
+
+          if need > 0
+            # read the remainder of the packet and decrypt it.
+            data = read_available(need)
+            @mac_data += data if server.hmac.etm
+            @packet.append(server.update_cipher(data))
+          end
 
-        payload = @packet.read(@packet_length - padding_length - 1)
+          # get the hmac from the tail of the packet (if one exists), and
+          # then validate it.
+          real_hmac = read_available(server.hmac.mac_length) || ""
 
-        my_computed_hmac = server.hmac.digest([server.sequence_number, @packet.content].pack("NA*"))
-        raise Net::SSH::Exception, "corrupted mac detected" if real_hmac != my_computed_hmac
+          @packet.append(server.final_cipher)
+          padding_length = @packet.read_byte
 
-        # try to decompress the payload, in case compression is active
-        payload = server.decompress(payload)
+          payload = @packet.read(@packet_length - padding_length - 1)
 
-        debug { "received packet nr #{server.sequence_number} type #{payload.getbyte(0)} len #{@packet_length}" }
+          my_computed_hmac = if server.hmac.etm
+                               server.hmac.digest([server.sequence_number, @mac_data].pack("NA*"))
+                             else
+                               server.hmac.digest([server.sequence_number, @packet.content].pack("NA*"))
+                             end
+          raise Net::SSH::Exception, "corrupted hmac detected #{server.hmac.class}" if real_hmac != my_computed_hmac
 
-        server.increment(@packet_length)
-        @packet = nil
+          # try to decompress the payload, in case compression is active
+          payload = server.decompress(payload)
 
-        return Packet.new(payload)
+          debug { "received packet nr #{server.sequence_number} type #{payload.getbyte(0)} len #{@packet_length}" }
+
+          server.increment(@packet_length)
+          @packet = nil
+
+          return Packet.new(payload)
+        end
       end
+      # rubocop:enable Metrics/AbcSize
+    end
   end
-
-end; end; end
+end

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

@@ -2,77 +2,76 @@ require 'net/ssh/errors'
 require 'net/ssh/loggable'
 require 'net/ssh/version'
 
-module Net; module SSH; module Transport
+module Net
+  module SSH
+    module Transport
+      # Negotiates the SSH protocol version and trades information about server
+      # and client. This is never used directly--it is always called by the
+      # transport layer as part of the initialization process of the transport
+      # layer.
+      #
+      # Note that this class also encapsulates the negotiated version, and acts as
+      # the authoritative reference for any queries regarding the version in effect.
+      class ServerVersion
+        include Loggable
 
-  # Negotiates the SSH protocol version and trades information about server
-  # and client. This is never used directly--it is always called by the
-  # transport layer as part of the initialization process of the transport
-  # layer.
-  #
-  # Note that this class also encapsulates the negotiated version, and acts as
-  # the authoritative reference for any queries regarding the version in effect.
-  class ServerVersion
-    include Loggable
+        # The SSH version string as reported by Net::SSH
+        PROTO_VERSION = "SSH-2.0-Ruby/Net::SSH_#{Net::SSH::Version::CURRENT} #{RUBY_PLATFORM}"
 
-    # The SSH version string as reported by Net::SSH
-    PROTO_VERSION = "SSH-2.0-Ruby/Net::SSH_#{Net::SSH::Version::CURRENT} #{RUBY_PLATFORM}"
+        # Any header text sent by the server prior to sending the version.
+        attr_reader :header
 
-    # Any header text sent by the server prior to sending the version.
-    attr_reader :header
+        # The version string reported by the server.
+        attr_reader :version
 
-    # The version string reported by the server.
-    attr_reader :version
+        # Instantiates a new ServerVersion and immediately (and synchronously)
+        # negotiates the SSH protocol in effect, using the given socket.
+        def initialize(socket, logger, timeout = nil)
+          @header = String.new
+          @version = nil
+          @logger = logger
+          negotiate!(socket, timeout)
+        end
 
-    # Instantiates a new ServerVersion and immediately (and synchronously)
-    # negotiates the SSH protocol in effect, using the given socket.
-    def initialize(socket, logger, timeout = nil)
-      @header = ""
-      @version = nil
-      @logger = logger
-      negotiate!(socket, timeout)
-    end
+        private
 
-    private
+        # Negotiates the SSH protocol to use, via the given socket. If the server
+        # reports an incompatible SSH version (e.g., SSH1), this will raise an
+        # exception.
+        def negotiate!(socket, timeout)
+          info { "negotiating protocol version" }
 
-      # Negotiates the SSH protocol to use, via the given socket. If the server
-      # reports an incompatible SSH version (e.g., SSH1), this will raise an
-      # exception.
-      def negotiate!(socket, timeout)
-        info { "negotiating protocol version" }
+          debug { "local is `#{PROTO_VERSION}'" }
+          socket.write "#{PROTO_VERSION}\r\n"
+          socket.flush
 
-        debug { "local is `#{PROTO_VERSION}'" }
-        socket.write "#{PROTO_VERSION}\r\n"
-        socket.flush
+          raise Net::SSH::ConnectionTimeout, "timeout during server version negotiating" if timeout && !IO.select([socket], nil, nil, timeout)
 
-        if timeout && !IO.select([socket], nil, nil, timeout)
-          raise Net::SSH::ConnectionTimeout, "timeout during server version negotiating"
-        end
-        loop do
-          @version = ""
           loop do
-            begin
-              b = socket.readpartial(1)
-              raise Net::SSH::Disconnect, "connection closed by remote host" if b.nil?
-            rescue EOFError
-              raise Net::SSH::Disconnect, "connection closed by remote host"
+            @version = String.new
+            loop do
+              begin
+                b = socket.readpartial(1)
+                raise Net::SSH::Disconnect, "connection closed by remote host" if b.nil?
+              rescue EOFError
+                raise Net::SSH::Disconnect, "connection closed by remote host"
+              end
+              @version << b
+              break if b == "\n"
             end
-            @version << b
-            break if b == "\n"
+            break if @version.match(/^SSH-/)
+
+            @header << @version
           end
-          break if @version.match(/^SSH-/)
-          @header << @version
-        end
 
-        @version.chomp!
-        debug { "remote is `#{@version}'" }
+          @version.chomp!
+          debug { "remote is `#{@version}'" }
 
-        unless @version.match(/^SSH-(1\.99|2\.0)-/)
-          raise Net::SSH::Exception, "incompatible SSH version `#{@version}'"
-        end
+          raise Net::SSH::Exception, "incompatible SSH version `#{@version}'" unless @version.match(/^SSH-(1\.99|2\.0)-/)
 
-        if timeout && !IO.select(nil, [socket], nil, timeout)
-          raise Net::SSH::ConnectionTimeout, "timeout during client version negotiating"
+          raise Net::SSH::ConnectionTimeout, "timeout during client version negotiating" if timeout && !IO.select(nil, [socket], nil, timeout)
         end
       end
+    end
   end
-end; end; end
+end