poolparty 1.3.15 → 1.4.0

data/vendor/gems/net-ssh/lib/net/ssh/transport/packet_stream.rb

@@ -1,230 +0,0 @@
-require 'net/ssh/buffered_io'
-require 'net/ssh/errors'
-require 'net/ssh/packet'
-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
-    include BufferedIo
-
-    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
-            begin
-              Socket.gethostbyname(Socket.gethostname).first
-            rescue
-              lwarn { "the client ipaddr/name could not be determined" }
-              "unknown"
-            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 ||= begin
-        addr = getpeername
-        Socket.getnameinfo(addr, Socket::NI_NUMERICHOST | Socket::NI_NUMERICSERV).first
-      end
-    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
-        fill if available_for_read?
-        poll_next_packet
-
-      when :block then
-        loop do
-          packet = poll_next_packet
-          return packet if packet
-
-          loop do
-            result = IO.select([self]) or next
-            break if result.first.any?
-          end
-
-          if fill <= 0
-            raise Net::SSH::Disconnect, "connection closed by remote host"
-          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, 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 = 4 + payload.length + 1
-
-      # compute the padding length
-      padding_length = client.cipher.block_size - (actual_length % client.cipher.block_size)
-      padding_length += client.cipher.block_size if padding_length < 4
-
-      # compute the packet length (sans the length field itself)
-      packet_length = payload.length + padding_length + 1
-
-      if packet_length < 16
-        padding_length += client.cipher.block_size
-        packet_length = payload.length + padding_length + 1
-      end
-
-      padding = Array.new(padding_length) { rand(256) }.pack("C*")
-
-      unencrypted_data = [packet_length, padding_length, payload, padding].pack("NCA*A*")
-      mac = client.hmac.digest([client.sequence_number, unencrypted_data].pack("NA*"))
-
-      encrypted_data = client.update_cipher(unencrypted_data) << client.final_cipher
-      message = encrypted_data + mac
-
-      debug { "queueing packet nr #{client.sequence_number} type #{payload.getbyte(0)} len #{packet_length}" }
-      enqueue(message)
-
-      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
-
-    # 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
-
-    protected
-
-      # 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
-
-      # 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.cipher.block_size < 4 ? 4 : server.cipher.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
-        end
-
-        need = @packet_length + 4 - server.cipher.block_size
-        raise Net::SSH::Exception, "padding error, need #{need} block #{server.cipher.block_size}" if need % server.cipher.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)
-          @packet.append(server.update_cipher(data))
-        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) || ""
-
-        @packet.append(server.final_cipher)
-        padding_length = @packet.read_byte
-
-        payload = @packet.read(@packet_length - padding_length - 1)
-        padding = @packet.read(padding_length) if padding_length > 0
-
-        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
-
-        # try to decompress the payload, in case compression is active
-        payload = server.decompress(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
-
-end; end; end

data/vendor/gems/net-ssh/lib/net/ssh/transport/server_version.rb

@@ -1,60 +0,0 @@
-require 'net/ssh/errors'
-require 'net/ssh/loggable'
-require 'net/ssh/version'
-
-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
-
-    # 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
-
-    # 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)
-      @header = ""
-      @version = nil
-      @logger = logger
-      negotiate!(socket)
-    end
-
-    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)
-        info { "negotiating protocol version" }
-
-        loop do
-          @version = socket.readline
-          break if @version.nil? || @version.match(/^SSH-/)
-          @header << @version
-        end
-
-        @version.chomp!
-        debug { "remote is `#{@version}'" }
-
-        unless @version.match(/^SSH-(1\.99|2\.0)-/)
-          raise Net::SSH::Exception, "incompatible SSH version `#{@version}'"
-        end
-
-        debug { "local is `#{PROTO_VERSION}'" }
-        socket.write "#{PROTO_VERSION}\r\n"
-      end
-  end
-end; end; end

data/vendor/gems/net-ssh/lib/net/ssh/transport/session.rb

@@ -1,276 +0,0 @@
-require 'socket'
-require 'timeout'
-
-require 'net/ssh/errors'
-require 'net/ssh/loggable'
-require 'net/ssh/version'
-require 'net/ssh/transport/algorithms'
-require 'net/ssh/transport/constants'
-require 'net/ssh/transport/packet_stream'
-require 'net/ssh/transport/server_version'
-require 'net/ssh/verifiers/null'
-require 'net/ssh/verifiers/strict'
-require 'net/ssh/verifiers/lenient'
-
-module Net; module SSH; module Transport
-
-  # The transport layer represents the lowest level of the SSH protocol, and
-  # implements basic message exchanging and protocol initialization. It will
-  # never be instantiated directly (unless you really know what you're about),
-  # but will instead be created for you automatically when you create a new
-  # SSH session via Net::SSH.start.
-  class Session
-    include Constants, Loggable
-
-    # The standard port for the SSH protocol.
-    DEFAULT_PORT = 22
-
-    # The host to connect to, as given to the constructor.
-    attr_reader :host
-
-    # The port number to connect to, as given in the options to the constructor.
-    # If no port number was given, this will default to DEFAULT_PORT.
-    attr_reader :port
-
-    # The underlying socket object being used to communicate with the remote
-    # host.
-    attr_reader :socket
-
-    # The ServerVersion instance that encapsulates the negotiated protocol
-    # version.
-    attr_reader :server_version
-
-    # The Algorithms instance used to perform key exchanges.
-    attr_reader :algorithms
-
-    # The host-key verifier object used to verify host keys, to ensure that
-    # the connection is not being spoofed.
-    attr_reader :host_key_verifier
-
-    # The hash of options that were given to the object at initialization.
-    attr_reader :options
-
-    # Instantiates a new transport layer abstraction. This will block until
-    # the initial key exchange completes, leaving you with a ready-to-use
-    # transport session.
-    def initialize(host, options={})
-      self.logger = options[:logger]
-
-      @host = host
-      @port = options[:port] || DEFAULT_PORT
-      @options = options
-
-      debug { "establishing connection to #{@host}:#{@port}" }
-      factory = options[:proxy] || TCPSocket
-      @socket = timeout(options[:timeout] || 0) { factory.open(@host, @port) }
-      @socket.extend(PacketStream)
-      @socket.logger = @logger
-
-      debug { "connection established" }
-
-      @queue = []
-
-      @host_key_verifier = select_host_key_verifier(options[:paranoid])
-
-      @server_version = ServerVersion.new(socket, logger)
-
-      @algorithms = Algorithms.new(self, options)
-      wait { algorithms.initialized? }
-    end
-
-    # Returns the host (and possibly IP address) in a format compatible with
-    # SSH known-host files.
-    def host_as_string
-      @host_as_string ||= begin
-        string = "#{host}"
-        string = "[#{string}]:#{port}" if port != DEFAULT_PORT
-        if socket.peer_ip != host
-          string2 = socket.peer_ip
-          string2 = "[#{string2}]:#{port}" if port != DEFAULT_PORT
-          string << "," << string2
-        end
-        string
-      end
-    end
-
-    # Returns true if the underlying socket has been closed.
-    def closed?
-      socket.closed?
-    end
-
-    # Cleans up (see PacketStream#cleanup) and closes the underlying socket.
-    def close
-      socket.cleanup
-      socket.close
-    end
-
-    # Performs a "hard" shutdown of the connection. In general, this should
-    # never be done, but it might be necessary (in a rescue clause, for instance,
-    # when the connection needs to close but you don't know the status of the
-    # underlying protocol's state).
-    def shutdown!
-      error { "forcing connection closed" }
-      socket.close
-    end
-
-    # Returns a new service_request packet for the given service name, ready
-    # for sending to the server.
-    def service_request(service)
-      Net::SSH::Buffer.from(:byte, SERVICE_REQUEST, :string, service)
-    end
-
-    # Requests a rekey operation, and blocks until the operation completes.
-    # If a rekey is already pending, this returns immediately, having no
-    # effect.
-    def rekey!
-      if !algorithms.pending?
-        algorithms.rekey!
-        wait { algorithms.initialized? }
-      end
-    end
-
-    # Returns immediately if a rekey is already in process. Otherwise, if a
-    # rekey is needed (as indicated by the socket, see PacketStream#if_needs_rekey?)
-    # one is performed, causing this method to block until it completes.
-    def rekey_as_needed
-      return if algorithms.pending?
-      socket.if_needs_rekey? { rekey! }
-    end
-
-    # Returns a hash of information about the peer (remote) side of the socket,
-    # including :ip, :port, :host, and :canonized (see #host_as_string).
-    def peer
-      @peer ||= { :ip => socket.peer_ip, :port => @port.to_i, :host => @host, :canonized => host_as_string }
-    end
-
-    # Blocks until a new packet is available to be read, and returns that
-    # packet. See #poll_message.
-    def next_message
-      poll_message(:block)
-    end
-
-    # Tries to read the next packet from the socket. If mode is :nonblock (the
-    # default), this will not block and will return nil if there are no packets
-    # waiting to be read. Otherwise, this will block until a packet is
-    # available. Note that some packet types (DISCONNECT, IGNORE, UNIMPLEMENTED,
-    # DEBUG, and KEXINIT) are handled silently by this method, and will never
-    # be returned.
-    #
-    # If a key-exchange is in process and a disallowed packet type is
-    # received, it will be enqueued and otherwise ignored. When a key-exchange
-    # is not in process, and consume_queue is true, packets will be first
-    # read from the queue before the socket is queried.
-    def poll_message(mode=:nonblock, consume_queue=true)
-      loop do
-        if consume_queue && @queue.any? && algorithms.allow?(@queue.first)
-          return @queue.shift
-        end
-
-        packet = socket.next_packet(mode)
-        return nil if packet.nil?
-
-        case packet.type
-        when DISCONNECT
-          raise Net::SSH::Disconnect, "disconnected: #{packet[:description]} (#{packet[:reason_code]})"
-
-        when IGNORE
-          debug { "IGNORE packet recieved: #{packet[:data].inspect}" }
-
-        when UNIMPLEMENTED
-          lwarn { "UNIMPLEMENTED: #{packet[:number]}" }
-
-        when DEBUG
-          send(packet[:always_display] ? :fatal : :debug) { packet[:message] }
-
-        when KEXINIT
-          algorithms.accept_kexinit(packet)
-
-        else
-          return packet if algorithms.allow?(packet)
-          push(packet)
-        end
-      end
-    end
-
-    # Waits (blocks) until the given block returns true. If no block is given,
-    # this just waits long enough to see if there are any pending packets. Any
-    # packets read are enqueued (see #push).
-    def wait
-      loop do
-        break if block_given? && yield
-        message = poll_message(:nonblock, false)
-        push(message) if message
-        break if !block_given?
-      end
-    end
-
-    # Adds the given packet to the packet queue. If the queue is non-empty,
-    # #poll_message will return packets from the queue in the order they
-    # were received.
-    def push(packet)
-      @queue.push(packet)
-    end
-
-    # Sends the given message via the packet stream, blocking until the
-    # entire message has been sent.
-    def send_message(message)
-      socket.send_packet(message)
-    end
-
-    # Enqueues the given message, such that it will be sent at the earliest
-    # opportunity. This does not block, but returns immediately.
-    def enqueue_message(message)
-      socket.enqueue_packet(message)
-    end
-
-    # Configure's the packet stream's client state with the given set of
-    # options. This is typically used to define the cipher, compression, and
-    # hmac algorithms to use when sending packets to the server.
-    def configure_client(options={})
-      socket.client.set(options)
-    end
-
-    # Configure's the packet stream's server state with the given set of
-    # options. This is typically used to define the cipher, compression, and
-    # hmac algorithms to use when reading packets from the server.
-    def configure_server(options={})
-      socket.server.set(options)
-    end
-
-    # Sets a new hint for the packet stream, which the packet stream may use
-    # to change its behavior. (See PacketStream#hints).
-    def hint(which, value=true)
-      socket.hints[which] = value
-    end
-
-    public
-
-      # this method is primarily for use in tests
-      attr_reader :queue #:nodoc:
-
-    private
-
-      # Instantiates a new host-key verification class, based on the value of
-      # the parameter. When true or nil, the default Lenient verifier is
-      # returned. If it is false, the Null verifier is returned, and if it is
-      # :very, the Strict verifier is returned. If the argument happens to
-      # respond to :verify, it is returned directly. Otherwise, an exception
-      # is raised.
-      def select_host_key_verifier(paranoid)
-        case paranoid
-        when true, nil then
-          Net::SSH::Verifiers::Lenient.new
-        when false then
-          Net::SSH::Verifiers::Null.new
-        when :very then
-          Net::SSH::Verifiers::Strict.new
-        else
-          if paranoid.respond_to?(:verify)
-            paranoid
-          else
-            raise ArgumentError, "argument to :paranoid is not valid: #{paranoid.inspect}"
-          end
-        end
-      end
-  end
-end; end; end