rex-core 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d87573fa044f8ef47e4077c871ffed4fd951947d
-  data.tar.gz: 81c929507834cb718d47433d7c63d2e86d364062
+  metadata.gz: 63a58cfcf3d6b9062c2bdca3eefca305eca585c7
+  data.tar.gz: 4185786772da9b7207faac16ad71fc808914ca83
 SHA512:
-  metadata.gz: 5906b4a8e2d4468d0b1ff364c054480c287b5a6ffe61c6a6ddb4080306e81c9c26d67fad47a67846d9b830c21fe964173bc68f25de04ea16114df3087da993a8
-  data.tar.gz: 6eb4511807ab5a2425591993c30c0e8fe98aad0732117cd365b7f28f2c5346c81f9260285e395d136f719ef6878b4b9c78ce8d059477d81350e7a29932df7ee8
+  metadata.gz: a0a38f7fd810b004bec6aca74ed6101fd01c3d2473256c1c510acd840047e8887560a4c6cca8c0f7d03650a2e33d6b2eae39cf588704cb6ff177da0282b50b46
+  data.tar.gz: e977b465922469f9682a6c91065ce5fc2c0cf50a356f0f643a986166689dea6499e96e6421cb752df62b644c1797d9c633e54ecb1d32c379ded339a66fed92ba

data.tar.gz.sig

@@ -1,2 +1,3 @@
-_����9�P�q�D�=!�/���X�pY�(9�F��8�J�U����rb�jV��K纮GD�#�be�3*:k"M����J��:x�����E�X���~����$�
-��#�^��(�}�������UF�bW�H�g�Eͣ�6��_#kX�g�T�e�q��KJ0�8Oj�m�a�e{I�H,#������{ܽ����?_5�{�b��L�L����h��{Kj4�"���C��ֈg�Tק�!��&�u
+�+�^e�L��Ĺ��_��	�kj�N迒�T$Rr3]�t�36x� "�DJ*��%B���b���O���æh��R*YS�|�r�����<��r
+�-^��`��n��`f�{�-K}��P
�]���B�\FtBD5���z��M�)�X�l�����\�N'�Q��
+P���)46�P1 N⮏�V�h���B

data/lib/rex/core/version.rb

@@ -1,5 +1,5 @@
 module Rex
   module Core
-    VERSION = "0.1.1"
+    VERSION = "0.1.2"
   end
 end

data/lib/rex/exceptions.rb

@@ -0,0 +1,307 @@
+# -*- coding: binary -*-
+
+module Rex
+
+###
+#
+# Base mixin for all exceptions that can be thrown from inside Rex.
+#
+###
+module Exception
+end
+
+###
+#
+# This exception is raised when a timeout occurs.
+#
+###
+class TimeoutError < Interrupt
+  include Exception
+
+  def to_s
+    "Operation timed out."
+  end
+end
+
+###
+#
+# This exception is raised when a method is called or a feature is used that
+# is not implemented.
+#
+###
+class NotImplementedError < ::NotImplementedError
+  include Exception
+
+  def to_s
+    "The requested method is not implemented."
+  end
+end
+
+###
+#
+# This exception is raised when a generalized runtime error occurs.
+#
+###
+class RuntimeError < ::RuntimeError
+  include Exception
+end
+
+###
+#
+# This exception is raised when an invalid argument is supplied to a method.
+#
+###
+class ArgumentError < ::ArgumentError
+  include Exception
+
+  def initialize(message = nil)
+    @message = message
+  end
+
+  def to_s
+    str = 'An invalid argument was specified.'
+    if @message
+      str << " #{@message}"
+    end
+    str
+  end
+end
+
+###
+#
+# This exception is raised when an argument that was supplied to a method
+# could not be parsed correctly.
+#
+###
+class ArgumentParseError < ::ArgumentError
+  include Exception
+
+  def to_s
+    "The argument could not be parsed correctly."
+  end
+end
+
+###
+#
+# This exception is raised when an argument is ambiguous.
+#
+###
+class AmbiguousArgumentError < ::RuntimeError
+  include Exception
+
+  def initialize(name = nil)
+    @name = name
+  end
+
+  def to_s
+    "The name #{@name} is ambiguous."
+  end
+end
+
+###
+#
+# This error is thrown when a stream is detected as being closed.
+#
+###
+class StreamClosedError < ::IOError
+  include Exception
+
+  def initialize(stream)
+    @stream = stream
+  end
+
+  def stream
+    @stream
+  end
+
+  def to_s
+    "Stream #{@stream} is closed."
+  end
+end
+
+##
+#
+# Socket exceptions
+#
+##
+
+###
+#
+# This exception is raised when a general socket error occurs.
+#
+###
+module SocketError
+  include Exception
+
+  def to_s
+    "A socket error occurred."
+  end
+end
+
+###
+#
+# This exception is raised when there is some kind of error related to
+# communication with a host.
+#
+###
+module HostCommunicationError
+  def initialize(addr = nil, port = nil)
+    self.host = addr
+    self.port = port
+  end
+
+  #
+  # This method returns a printable address and optional port associated
+  # with the host that triggered the exception.
+  #
+  def addr_to_s
+    if host and port
+      "(#{host}:#{port})"
+    elsif host
+      "(#{host})"
+    else
+      ""
+    end
+  end
+
+  attr_accessor :host, :port
+end
+
+
+###
+#
+# This is a generic exception for errors that cause a connection to fail.
+#
+###
+class ConnectionError < ::IOError
+  include SocketError
+  include HostCommunicationError
+end
+
+###
+#
+# This exception is raised when a connection attempt fails because the remote
+# side refused the connection.
+#
+###
+class ConnectionRefused < ConnectionError
+  def to_s
+    "The connection was refused by the remote host #{addr_to_s}."
+  end
+end
+
+###
+#
+# This exception is raised when a connection attempt fails because the remote
+# side is unreachable.
+#
+###
+class HostUnreachable < ConnectionError
+  def to_s
+    "The host #{addr_to_s} was unreachable."
+  end
+end
+
+###
+#
+# This exception is raised when a connection attempt times out.
+#
+###
+class ConnectionTimeout < ConnectionError
+  def to_s
+    "The connection timed out #{addr_to_s}."
+  end
+end
+
+###
+#
+# This connection error is raised when an attempt is made to connect
+# to a broadcast or network address.
+#
+###
+class InvalidDestination < ConnectionError
+  include SocketError
+  include HostCommunicationError
+
+  def to_s
+    "The destination is invalid: #{addr_to_s}."
+  end
+end
+
+###
+#
+# This exception is raised when an attempt to use an address or port that is
+# already in use or onot available occurs. such as binding to a host on a
+# given port that is already in use, or when a bind address is specified that
+# is not available to the host.
+#
+###
+class BindFailed < ::ArgumentError
+  include SocketError
+  include HostCommunicationError
+
+  def to_s
+    "The address is already in use or unavailable: #{addr_to_s}."
+  end
+end
+
+##
+#
+# This exception is listed for backwards compatibility. We had been
+# using AddressInUse as the exception for both bind errors and connection
+# errors triggered by connection attempts to broadcast and network addresses.
+# The two classes above have split this into their respective sources, but
+# callers may still expect the old behavior.
+#
+##
+class AddressInUse < ConnectionError
+  include SocketError
+  include HostCommunicationError
+
+  def to_s
+    "The address is already in use or unavailable: #{addr_to_s}."
+  end
+end
+
+
+###
+#
+# This exception is raised when an unsupported internet protocol is specified.
+#
+###
+class UnsupportedProtocol < ::ArgumentError
+  include SocketError
+
+  def initialize(proto = nil)
+    self.proto = proto
+  end
+
+  def to_s
+    "The protocol #{proto} is not supported."
+  end
+
+  attr_accessor :proto
+end
+
+
+###
+#
+# This exception is raised when a proxy fails to pass a connection
+#
+###
+class ConnectionProxyError < ConnectionError
+  def initialize(host,port,ptype,reason)
+    super(host,port)
+    self.ptype = ptype
+    self.reason = reason
+  end
+
+  def to_s
+    self.ptype + ": " + self.reason
+  end
+
+  attr_accessor :ptype, :reason
+end
+
+end
+

data/lib/rex/io/datagram_abstraction.rb

@@ -0,0 +1,26 @@
+# -*- coding: binary -*-
+
+require 'rex/io/socket_abstraction'
+
+module Rex
+module IO
+
+###
+#
+# This class provides an abstraction to a datagram based
+# connection through the use of a datagram socketpair.
+#
+###
+module DatagramAbstraction
+  include Rex::IO::SocketAbstraction
+
+  #
+  # Creates a streaming socket pair
+  #
+  def initialize_abstraction
+    self.lsock, self.rsock = Rex::Socket.udp_socket_pair
+  end
+
+end
+
+end; end

data/lib/rex/io/ring_buffer.rb

@@ -0,0 +1,369 @@
+# -*- coding: binary -*-
+#
+# This class implements a ring buffer with "cursors" in the form of sequence numbers.
+# To use this class, pass in a file descriptor and a ring size, the class will read
+# data from the file descriptor and store it in the ring. If the ring becomes full,
+# the oldest item will be overwritten. To emulate a stream interface, call read_data
+# to grab the last sequence number and any buffered data, call read_data again,
+# passing in the sequence number and all data newer than that sequence will be
+# returned, along with a new sequence to read from.
+#
+
+require 'rex/socket'
+
+module Rex
+module IO
+
+class RingBuffer
+
+  attr_accessor :queue     # The data queue, essentially an array of two-element arrays, containing a sequence and data buffer
+  attr_accessor :seq       # The next available sequence number
+  attr_accessor :fd        # The associated socket or IO object for this ring buffer
+  attr_accessor :size      # The number of available slots in the queue
+  attr_accessor :mutex     # The mutex locking access to the queue
+  attr_accessor :beg       # The index of the earliest data fragment in the ring
+  attr_accessor :cur       # The sequence number of the earliest data fragment in the ring
+  attr_accessor :monitor   # The thread handle of the built-in monitor when used
+  attr_accessor :monitor_thread_error  # :nodoc: #
+
+  #
+  # Create a new ring buffer
+  #
+  def initialize(socket, opts={})
+    self.size  = opts[:size] || (1024 * 4)
+    self.fd    = socket
+    self.seq   = 0
+    self.beg   = 0
+    self.cur   = 0
+    self.queue = Array.new( self.size )
+    self.mutex = Mutex.new
+  end
+
+  def inspect
+    "#<Rex::IO::RingBuffer @size=#{size} @fd=#{fd} @seq=#{seq} @beg=#{beg} @cur=#{cur}>"
+  end
+
+  #
+  # Start the built-in monitor, not called when used in a larger framework
+  #
+  def start_monitor
+    self.monitor = monitor_thread if not self.monitor
+  end
+
+  #
+  # Stop the built-in monitor
+  #
+  def stop_monitor
+    self.monitor.kill if self.monitor
+    self.monitor = nil
+  end
+
+  #
+  # The built-in monitor thread (normally unused with Metasploit)
+  #
+  def monitor_thread
+    Thread.new do
+      begin
+      while self.fd
+        buff = self.fd.get_once(-1, 1.0)
+        next if not buff
+        store_data(buff)
+      end
+      rescue ::Exception => e
+        self.monitor_thread_error = e
+      end
+    end
+  end
+
+  #
+  # Push data back into the associated stream socket. Logging must occur
+  # elsewhere, this function is simply a passthrough.
+  #
+  def put(data, opts={})
+    self.fd.put(data, opts={})
+  end
+
+  #
+  # The clear_data method wipes the ring buffer
+  #
+  def clear_data
+    self.mutex.synchronize do
+      self.seq   = 0
+      self.beg   = 0
+      self.cur   = 0
+      self.queue = Array.new( self.size )
+    end
+  end
+
+  #
+  # The store_data method is used to insert data into the ring buffer.
+  #
+  def store_data(data)
+    self.mutex.synchronize do
+      # self.cur points to the array index of queue containing the last item
+      # adding data will result in cur + 1 being used to store said data
+      # if cur is larger than size - 1, it will wrap back around. If cur
+      # is *smaller* beg, beg is increemnted to cur + 1 (and wrapped if
+      # necessary
+
+      loc = 0
+      if self.seq > 0
+        loc = ( self.cur + 1 ) % self.size
+
+        if loc <= self.beg
+          self.beg = (self.beg + 1) % self.size
+        end
+      end
+
+      self.queue[loc] = [self.seq += 1, data]
+      self.cur = loc
+    end
+  end
+
+  #
+  # The read_data method returns a two element array with the new reader cursor (a sequence number)
+  # and the returned data buffer (if any). A result of nil/nil indicates that no data is available
+  #
+  def read_data(ptr=nil)
+    self.mutex.synchronize do
+
+    # Verify that there is data in the queue
+    return [nil,nil] if not self.queue[self.beg]
+
+    # Configure the beginning read pointer (sequence number, not index)
+    ptr ||= self.queue[self.beg][0]
+    return [nil,nil] if not ptr
+
+    # If the pointer is below our baseline, we lost some data, so jump forward
+    if ptr < self.queue[self.beg][0]
+      ptr = self.queue[self.beg][0]
+    end
+
+    # Calculate how many blocks exist between the current sequence number
+    # and the requested pointer, this becomes the number of blocks we will
+    # need to read to satisfy the result. Due to the mutex block, we do
+    # not need to scan to find the sequence of the starting block or
+    # check the sequence of the ending block.
+    dis = self.seq - ptr
+
+    # If the requested sequnce number is less than our base pointer, it means
+    # that no new data is available and we should return empty.
+    return [nil,nil] if dis < 0
+
+    # Calculate the beginning block index and number of blocks to read
+    off = ptr - self.queue[self.beg][0]
+    set = (self.beg + off) % self.size
+
+
+    # Build the buffer by reading forward by the number of blocks needed
+    # and return the last read sequence number, plus one, as the new read
+    # pointer.
+    buff = ""
+    cnt  = 0
+    lst  = ptr
+    ptr.upto(self.seq) do |i|
+      block = self.queue[ (set + cnt) % self.size ]
+      lst,data = block[0],block[1]
+      buff += data
+      cnt += 1
+    end
+
+    return [lst + 1, buff]
+
+    end
+  end
+
+  #
+  # The base_sequence method returns the earliest sequence number in the queue. This is zero until
+  # all slots are filled and the ring rotates.
+  #
+  def base_sequence
+    self.mutex.synchronize do
+      return 0 if not self.queue[self.beg]
+      return self.queue[self.beg][0]
+    end
+  end
+
+  #
+  # The last_sequence method returns the "next" sequence number where new data will be
+  # available.
+  #
+  def last_sequence
+    self.seq
+  end
+
+  #
+  # The create_steam method assigns a IO::Socket compatible object to the ringer buffer
+  #
+  def create_stream
+    Stream.new(self)
+  end
+
+  #
+  # The select method returns when there is a chance of new data
+  # XXX: This is mostly useless and requires a rewrite to use a
+  #      real select or notify mechanism
+  #
+  def select
+    ::IO.select([ self.fd ], nil, [ self.fd ], 0.10)
+  end
+
+  #
+  # The wait method blocks until new data is available
+  #
+  def wait(seq)
+    nseq = nil
+    while not nseq
+      nseq,data = read_data(seq)
+      select
+    end
+  end
+
+  #
+  # The wait_for method blocks until new data is available or the timeout is reached
+  #
+  def wait_for(seq,timeout=1)
+    begin
+      ::Timeout.timeout(timeout) do
+        wait(seq)
+      end
+    rescue ::Timeout::Error
+    end
+  end
+
+  #
+  # This class provides a backwards compatible "stream" socket that uses
+  # the parents ring buffer.
+  #
+  class Stream
+    attr_accessor :ring
+    attr_accessor :seq
+    attr_accessor :buff
+
+    def initialize(ring)
+      self.ring = ring
+      self.seq  = ring.base_sequence
+      self.buff = ''
+    end
+
+    def read(len=nil)
+      if len and self.buff.length >= len
+        data = self.buff.slice!(0,len)
+        return data
+      end
+
+      while true
+        lseq, data = self.ring.read_data( self.seq )
+        return if not lseq
+
+        self.seq  = lseq
+        self.buff << data
+        if len
+          if self.buff.length >= len
+            return self.buff.slice!(0,len)
+          else
+            IO.select(nil, nil, nil, 0.25)
+            next
+          end
+        end
+
+        data = self.buff
+        self.buff = ''
+
+        return data
+
+        # Not reached
+        break
+      end
+
+    end
+
+    def write(data)
+      self.ring.write(data)
+    end
+  end
+
+end
+
+end
+end
+
+=begin
+
+server = Rex::Socket.create_tcp_server('LocalPort' => 0)
+lport  = server.getsockname[2]
+client = Rex::Socket.create_tcp('PeerHost' => '127.0.0.1', 'PeerPort' => lport)
+conn   = server.accept
+
+r = Rex::IO::RingBuffer.new(conn, {:size => 1024*1024})
+client.put("1")
+client.put("2")
+client.put("3")
+
+s,d = r.read_data
+
+client.put("4")
+client.put("5")
+client.put("6")
+s,d = r.read_data(s)
+
+client.put("7")
+client.put("8")
+client.put("9")
+s,d = r.read_data(s)
+
+client.put("0")
+s,d = r.read_data(s)
+
+test_counter = 11
+1.upto(100) do
+  client.put( "X" )
+  test_counter += 1
+end
+
+sleep(1)
+
+s,d = r.read_data
+p s
+p d
+
+fdata = ''
+File.open("/bin/ls", "rb") do |fd|
+  fdata = fd.read(fd.stat.size)
+  fdata = fdata * 10
+  client.put(fdata)
+end
+
+sleep(1)
+
+s,vdata = r.read_data(s)
+
+if vdata != fdata
+  puts "DATA FAILED"
+else
+  puts "DATA VERIFIED"
+end
+
+r.clear_data
+
+a = r.create_stream
+b = r.create_stream
+
+client.put("ABC123")
+sleep(1)
+
+p a.read
+p b.read
+
+client.put("$$$$$$")
+sleep(1)
+
+p a.read
+p b.read
+
+c = r.create_stream
+p c.read
+
+=end
+
+