rex-core 0.1.1 → 0.1.2

data/lib/rex/io/socket_abstraction.rb

@@ -0,0 +1,205 @@
+# -*- coding: binary -*-
+
+require 'socket'
+require 'fcntl'
+
+module Rex
+module IO
+
+###
+#
+# This class provides an abstraction to a stream based
+# connection through the use of a streaming socketpair.
+#
+###
+module SocketAbstraction
+
+  ###
+  #
+  # Extension information for required Stream interface.
+  #
+  ###
+  module Ext
+
+    #
+    # Initializes peer information.
+    #
+    def initinfo(peer,local)
+      @peer = peer
+      @local = local
+    end
+
+    #
+    # Symbolic peer information.
+    #
+    def peerinfo
+      (@peer || "Remote Pipe")
+    end
+
+    #
+    # Symbolic local information.
+    #
+    def localinfo
+      (@local || "Local Pipe")
+    end
+  end
+
+  #
+  # Override this method to init the abstraction
+  #
+  def initialize_abstraction
+    self.lsock, self.rsock = Rex::Compat.pipe
+  end
+
+  #
+  # This method cleans up the abstraction layer.
+  #
+  def cleanup_abstraction
+    self.lsock.close if (self.lsock and !self.lsock.closed?)
+    self.rsock.close if (self.rsock and !self.rsock.closed?)
+
+    self.lsock = nil
+    self.rsock = nil
+  end
+
+  #
+  # Low-level write to the local side.
+  #
+  def syswrite(buffer)
+    lsock.syswrite(buffer)
+  end
+
+  #
+  # Low-level read from the local side.
+  #
+  def sysread(length)
+    lsock.sysread(length)
+  end
+
+  #
+  # Shuts down the local side of the stream abstraction.
+  #
+  def shutdown(how)
+    lsock.shutdown(how)
+  end
+
+  #
+  # Closes both sides of the stream abstraction.
+  #
+  def close
+    cleanup_abstraction
+    super
+  end
+
+  #
+  # Symbolic peer information.
+  #
+  def peerinfo
+    "Remote-side of Pipe"
+  end
+
+  #
+  # Symbolic local information.
+  #
+  def localinfo
+    "Local-side of Pipe"
+  end
+
+  #
+  # The left side of the stream.
+  #
+  attr_reader :lsock
+  #
+  # The right side of the stream.
+  #
+  attr_reader :rsock
+
+protected
+
+  def monitor_rsock(threadname = "SocketMonitorRemote")
+    self.monitor_thread = Rex::ThreadFactory.spawn(threadname, false) {
+      loop do
+        closed = false
+        buf    = nil
+
+        if not self.rsock
+          wlog("monitor_rsock: the remote socket is nil, exiting loop")
+          break
+        end
+
+        begin
+          s = Rex::ThreadSafe.select( [ self.rsock ], nil, nil, 0.2 )
+          if( s == nil || s[0] == nil )
+            next
+          end
+        rescue Exception => e
+          wlog("monitor_rsock: exception during select: #{e.class} #{e}")
+          closed = true
+        end
+
+        if( closed == false )
+          begin
+            buf = self.rsock.sysread( 32768 )
+            if buf == nil
+              closed = true
+              wlog("monitor_rsock: closed remote socket due to nil read")
+            end
+          rescue EOFError => e
+            closed = true
+            dlog("monitor_rsock: EOF in rsock")
+          rescue ::Exception => e
+            closed = true
+            wlog("monitor_rsock: exception during read: #{e.class} #{e}")
+          end
+        end
+
+        if( closed == false )
+          total_sent   = 0
+          total_length = buf.length
+          while( total_sent < total_length )
+            begin
+              data = buf[total_sent, buf.length]
+
+              # Note that this must be write() NOT syswrite() or put() or anything like it.
+              # Using syswrite() breaks SSL streams.
+              sent = self.write( data )
+
+              # sf: Only remove the data off the queue is write was successfull.
+              #     This way we naturally perform a resend if a failure occured.
+              #     Catches an edge case with meterpreter TCP channels where remote send
+              #     failes gracefully and a resend is required.
+              if (sent.nil?)
+                closed = true
+                wlog("monitor_rsock: failed writing, socket must be dead")
+                break
+              elsif (sent > 0)
+                total_sent += sent
+              end
+            rescue ::IOError, ::EOFError => e
+              closed = true
+              wlog("monitor_rsock: exception during write: #{e.class} #{e}")
+              break
+            end
+          end
+        end
+
+        if( closed )
+          begin
+            self.close_write if self.respond_to?('close_write')
+          rescue IOError
+          end
+          break
+        end
+      end
+    }
+  end
+
+protected
+  attr_accessor :monitor_thread
+  attr_writer :lsock
+  attr_writer :rsock
+
+end
+
+end; end
+

data/lib/rex/io/stream.rb

@@ -0,0 +1,312 @@
+# -*- coding: binary -*-
+require 'rex/sync/thread_safe'
+
+module Rex
+module IO
+
+###
+#
+# This mixin is an abstract representation of a streaming connection.  Streams
+# extend classes that must implement the following methods:
+#
+#   syswrite(buffer)
+#   sysread(length)
+#   shutdown(how)
+#   close
+#   peerinfo
+#   localinfo
+#
+###
+module Stream
+
+  ##
+  #
+  # Abstract methods
+  #
+  ##
+
+  #
+  # This method writes the supplied buffer to the stream.  This method
+  # intelligent reduces the size of supplied buffers so that ruby doesn't get
+  # into a potential global thread blocking state when used on blocking
+  # sockets.  That is, this method will send the supplied buffer in chunks
+  # of, at most, 32768 bytes.
+  #
+  def write(buf, opts = {})
+    total_sent   = 0
+    total_length = buf.length
+    block_size   = 32768
+
+    begin
+      while( total_sent < total_length )
+        s = Rex::ThreadSafe.select( nil, [ fd ], nil, 0.2 )
+        if( s == nil || s[0] == nil )
+          next
+        end
+        data = buf[total_sent, block_size]
+        sent = fd.write_nonblock( data )
+        if sent > 0
+          total_sent += sent
+        end
+      end
+    rescue ::Errno::EAGAIN, ::Errno::EWOULDBLOCK
+      # Sleep for a half a second, or until we can write again
+      Rex::ThreadSafe.select( nil, [ fd ], nil, 0.5 )
+      # Decrement the block size to handle full sendQs better
+      block_size = 1024
+      # Try to write the data again
+      retry
+    rescue ::IOError, ::Errno::EPIPE
+      return nil
+    end
+
+    total_sent
+  end
+
+  #
+  # This method reads data of the supplied length from the stream.
+  #
+  def read(length = nil, opts = {})
+
+    begin
+      return fd.read_nonblock( length )
+    rescue ::Errno::EAGAIN, ::Errno::EWOULDBLOCK
+      # Sleep for a half a second, or until we can read again
+      Rex::ThreadSafe.select( [ fd ], nil, nil, 0.5 )
+      # Decrement the block size to handle full sendQs better
+      retry
+    rescue ::IOError, ::Errno::EPIPE
+      return nil
+    end
+  end
+
+  #
+  # Polls the stream to see if there is any read data available.  Returns
+  # true if data is available for reading, otherwise false is returned.
+  #
+  def has_read_data?(timeout = nil)
+
+    # Allow a timeout of "0" that waits almost indefinitely for input, this
+    # mimics the behavior of Rex::ThreadSafe.select() and fixes some corner
+    # cases of unintentional no-wait timeouts.
+    timeout = 3600 if (timeout and timeout == 0)
+
+    begin
+      if ((rv = ::IO.select([ fd ], nil, nil, timeout)) and
+          (rv[0]) and
+          (rv[0][0] == fd))
+        true
+      else
+        false
+      end
+    rescue ::Errno::EBADF, ::Errno::ENOTSOCK
+      raise ::EOFError
+    rescue StreamClosedError, ::IOError, ::EOFError, ::Errno::EPIPE
+      #  Return false if the socket is dead
+      return false
+    end
+  end
+
+  #
+  # This method returns the selectable file descriptor, or self by default.
+  #
+  def fd
+    self
+  end
+
+  ##
+  #
+  # Common methods
+  #
+  ##
+
+  #
+  # This method writes the supplied buffer to the stream by calling the write
+  # routine.
+  #
+  def <<(buf)
+    return write(buf.to_s)
+  end
+
+  #
+  # This method calls get_once() to read pending data from the socket
+  #
+  def >>
+    get_once
+  end
+
+  #
+  # This method writes to the stream, optionally timing out after a period of
+  # time.
+  #
+  def timed_write(buf, wait = def_write_timeout, opts = {})
+    if (wait and wait > 0)
+      Timeout.timeout(wait) {
+        return write(buf, opts)
+      }
+    else
+      return write(buf, opts)
+    end
+  end
+
+  #
+  # This method reads from the stream, optionally timing out after a period
+  # of time.
+  #
+  def timed_read(length = nil, wait = def_read_timeout, opts = {})
+    if (wait and wait > 0)
+      Timeout.timeout(wait) {
+        return read(length, opts)
+      }
+    else
+      return read(length, opts)
+    end
+  end
+
+  #
+  # This method writes the full contents of the supplied buffer, optionally
+  # with a timeout.
+  #
+  def put(buf, opts = {})
+    return 0 if (buf == nil or buf.length == 0)
+
+    send_len = buf.length
+    send_idx = 0
+    wait     = opts['Timeout'] || 0
+
+    # Keep writing until our send length drops to zero
+    while (send_idx < send_len)
+      curr_len  = timed_write(buf[send_idx, buf.length-send_idx], wait, opts)
+
+      # If the write operation failed due to an IOError, then we fail.
+      return buf.length - send_len if (curr_len == nil)
+
+      send_len -= curr_len
+      send_idx += curr_len
+    end
+
+    return buf.length - send_len
+  end
+
+
+  #
+  # This method emulates the behavior of Pex::Socket::Recv in MSF2
+  #
+  def get_once(length = -1, timeout = def_read_timeout)
+
+    if (has_read_data?(timeout) == false)
+      return nil
+    end
+
+    bsize = (length == -1) ? def_block_size : length
+    data  = read(bsize)
+    raise EOFError if data.nil?
+    data
+  end
+
+  #
+  # This method reads as much data as it can from the wire given a maximum
+  # timeout.
+  #
+  def get(timeout = nil, ltimeout = def_read_loop_timeout, opts = {})
+    # For those people who are used to being able to use a negative timeout!
+    if (timeout and timeout.to_i < 0)
+      timeout = nil
+    end
+
+    # No data in the first place? bust.
+    if (has_read_data?(timeout) == false)
+      return nil
+    end
+
+    buf = ""
+    lps = 0
+    eof = false
+
+    # Keep looping until there is no more data to be gotten..
+    while (has_read_data?(ltimeout) == true)
+      # Catch EOF errors so that we can handle them properly.
+      begin
+        temp = read(def_block_size)
+      rescue EOFError
+        eof = true
+      end
+
+      # If we read zero bytes and we had data, then we've hit EOF
+      if (temp and temp.length == 0)
+        eof = true
+      end
+
+      # If we reached EOF and there are no bytes in the buffer we've been
+      # reading into, then throw an EOF error.
+      if (eof)
+        # If we've already read at least some data, then it's time to
+        # break out and let it be processed before throwing an EOFError.
+        if (buf.length > 0)
+          break
+        else
+          raise EOFError
+        end
+      end
+
+      break if (temp == nil or temp.empty? == true)
+
+      buf += temp
+      lps += 1
+
+      break if (lps >= def_max_loops)
+    end
+
+    # Return the entire buffer we read in
+    return buf
+  end
+
+  ##
+  #
+  # Defaults
+  #
+  ##
+
+  #
+  # The default number of seconds to wait for a write operation to timeout.
+  #
+  def def_write_timeout
+    10
+  end
+
+  #
+  # The default number of seconds to wait for a read operation to timeout.
+  #
+  def def_read_timeout
+    10
+  end
+
+  #
+  # The default number of seconds to wait while in a read loop after read
+  # data has been found.
+  #
+  def def_read_loop_timeout
+    0.1
+  end
+
+  #
+  # The maximum number of read loops to perform before returning to the
+  # caller.
+  #
+  def def_max_loops
+    1024
+  end
+
+  #
+  # The default block size to read in chunks from the wire.
+  #
+  def def_block_size
+    16384
+  end
+
+protected
+
+end
+
+end end
+