librex 0.0.1

data/lib/rex/file.rb.ut.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.join(File.dirname(__FILE__), '..'))
+
+require 'test/unit'
+require 'rex/file'
+
+class Rex::FileUtils::UnitTest < ::Test::Unit::TestCase
+	Klass = Rex::FileUtils
+
+	def test_find_full_path
+		assert_not_nil(Klass.find_full_path("ls"))
+		assert_nil(Klass.find_full_path("cookie monster cake"))
+	end
+		
+end

data/lib/rex/image_source.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+# $Id: image_source.rb 5413 2008-02-13 02:43:56Z ramon $
+
+module Rex
+module ImageSource
+
+end
+end
+
+require 'rex/image_source/disk'
+require 'rex/image_source/memory'

data/lib/rex/image_source/disk.rb

@@ -0,0 +1,60 @@
+#!/usr/bin/env ruby
+
+# $Id: disk.rb 5401 2008-02-09 04:35:21Z ramon $
+
+require 'rex/image_source/image_source'
+require 'rex/struct2'
+
+module Rex
+module ImageSource
+class Disk < ImageSource
+
+	attr_accessor :file, :file_offset, :size
+
+	WINDOW_SIZE     = 4096
+	WINDOW_OVERLAP  = 64
+
+	def initialize(_file, _offset = 0, _len = nil)
+		_len = _file.stat.size if !_len
+
+		self.file         = _file
+		self.file_offset  = _offset
+		self.size         = _len
+	end
+
+	def read(offset, len)
+		if offset < 0 || offset+len > size
+			raise RangeError, "Offset #{offset} outside of image source", caller
+		end
+
+		file.seek(file_offset + offset)
+		file.read(len)
+	end
+	
+	def index(search, offset = 0)
+		# do a sliding window search across the disk
+		while offset < size
+
+			# get a full window size if we can, we
+			# don't want to read past our boundaries
+			wsize = size - offset
+			wsize = WINDOW_SIZE if wsize > WINDOW_SIZE
+
+			window = self.read(offset, wsize)
+			res = window.index(search)
+			return res + offset if res
+			offset += WINDOW_SIZE - WINDOW_OVERLAP
+		end
+	end
+
+	def subsource(offset, len)
+		self.class.new(file, file_offset+offset, len)
+	end
+
+	def close
+		file.close
+	end
+end
+
+end
+end

data/lib/rex/image_source/image_source.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+
+# $Id: image_source.rb 5401 2008-02-09 04:35:21Z ramon $
+
+module Rex
+module ImageSource
+class ImageSource
+
+	#
+	# Um, just some abstract class stuff I guess, this is the interface
+	# that any image sources should subscribe to...
+	#
+
+	def subsource(offset, len)
+		raise "do something"
+	end
+
+	def size
+		raise "do something"
+	end
+
+	def file_offset
+		raise "do something"
+	end
+
+	def close
+		raise "do something"
+	end
+
+	def read_asciiz(offset)
+		# FIXME, make me better
+		string = ''
+		loop do
+			char = read(offset, 1)
+			break if char == "\x00"
+			offset += 1
+			string << char
+		end
+		return string
+	end
+		
+
+end
+
+end
+end

data/lib/rex/image_source/memory.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+# $Id: memory.rb 5401 2008-02-09 04:35:21Z ramon $
+
+require 'rex/image_source/image_source'
+require 'rex/struct2'
+
+module Rex
+module ImageSource
+class Memory < ImageSource
+
+	attr_accessor :rawdata, :size, :file_offset
+
+	def initialize(_rawdata, _file_offset = 0)
+		self.rawdata     = _rawdata
+		self.size        = _rawdata.length
+		self.file_offset = _file_offset
+	end
+
+	def read(offset, len)
+		rawdata[offset, len]
+	end
+
+	def subsource(offset, len)
+		self.class.new(rawdata[offset, len], offset + file_offset)
+	end
+
+	def close
+	end
+
+	def index(*args)
+		rawdata.index(*args)
+	end
+end
+
+end
+end

data/lib/rex/io/bidirectional_pipe.rb

@@ -0,0 +1,157 @@
+module Rex
+module IO
+
+require 'rex/ui/text/output'
+require 'rex/ui/text/output/buffer'
+require 'rex/ui/text/input/buffer'
+
+class BidirectionalPipe < Rex::Ui::Text::Input
+
+	def initialize
+		@subscribers_out = {}
+		@subscribers_ref = {}
+		@subscribers_idx = 0
+		@pipe_input = Rex::Ui::Text::Input::Buffer.new
+
+		# We are the shell, the input, and the output
+		self.output = self
+		self.input  = self
+	end
+
+	def pipe_input
+		@pipe_input
+	end
+
+	def close
+		@pipe_input.close
+	end
+
+	def has_subscriber?(id)
+		@subscribers_out.has_key?(id)
+	end
+
+	def create_subscriber(id=nil)
+		id ||= (@subscribers_idx += 1).to_s
+		@subscribers_out[id] = Rex::Ui::Text::Output::Buffer.new
+		return id
+	end
+
+	def create_subscriber_proc(id=nil, &block)
+		id = create_subscriber(id)
+		@subscribers_ref[id] = block
+	end
+
+	def remove_subscriber(id)
+		@subscribers_out.delete(id)
+		@subscribers_ref.delete(id)
+	end
+
+	def write_input(buf)
+		@pipe_input.put(buf)
+	end
+
+	def read_subscriber(id)
+		output = @subscribers_out[id]
+
+		return '' if output.nil?
+
+		buf = output.buf
+
+		output.reset
+
+		buf
+	end
+
+	def print(msg='')
+		@subscribers_out.each_pair { |id, buf|
+			begin
+				@subscribers_ref[id] ? @subscribers_ref[id].call(msg) : buf.print(msg)
+			rescue ::Exception => e
+				# $stderr.puts "Error handling subscriber #{id}: #{e} #{e.backtrace.inspect}"
+				raise e
+			end
+		}
+		msg
+	end
+
+	def print_error(msg='')
+		print_line('[-] ' + msg)
+	end
+
+	def print_line(msg='')
+		print(msg + "\n")
+	end
+
+	def print_good(msg='')
+		print_line('[+] ' + msg)
+	end
+
+	def print_debug(msg='')
+		print_line('[!] ' + msg)
+	end
+
+	def flush
+	end
+
+	def print_status(msg='')
+		print_line('[*] ' + msg)
+	end
+
+	#
+	# Wrappers for the pipe_input methods
+	#
+
+	def close
+		@pipe_input.close
+	end
+
+	def sysread(len = 1)
+		@pipe_input.sysread(len)
+	end
+
+	def put(msg)
+		@pipe_input.put(msg)
+	end
+
+	def gets
+		@pipe_input.gets
+	end
+
+	def eof?
+		@pipe_input.eof?
+	end
+
+	def fd
+		@pipe_input.fd
+	end
+
+	#
+	# Wrappers for shell methods
+	#
+
+	attr_accessor :output, :prompt, :input
+
+	def intrinsic_shell?
+		true
+	end
+
+	def supports_readline
+		false
+	end
+
+	def supports_color?
+		false
+	end
+
+	def pgets
+		gets
+	end
+
+
+protected
+
+end
+
+end
+end
+

data/lib/rex/io/datagram_abstraction.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+
+require 'socket'
+
+module Rex
+module IO
+
+###
+#
+# This class provides an abstraction to a datagram based
+# connection through the use of a datagram socketpair.
+#
+###
+module DatagramAbstraction
+
+	#
+	# Creates a streaming socket pair
+	#
+	def initialize_abstraction
+		self.lsock, self.rsock = Rex::Socket.udp_socket_pair()
+	end
+
+
+	# The left side of the stream (local)
+	attr_reader :lsock
+	# The right side of the stream (remote)
+	attr_reader :rsock
+	
+protected
+	attr_writer :lsock
+	attr_writer :rsock
+
+end
+
+end; end

data/lib/rex/io/stream.rb

@@ -0,0 +1,313 @@
+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
+		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[0, 32768]
+				sent = fd.syswrite( data )
+				if sent > 0
+					total_sent += sent
+					buf[0, sent] = ""
+				end
+			end
+		rescue ::IOError, ::Errno::EPIPE
+			return nil if (fd.abortive_close == true)
+			raise $!
+		end
+		total_sent
+	end
+
+	#
+	# This method reads data of the supplied length from the stream.
+	#
+	def read(length = nil, opts = {})
+		# XXX handle length being nil
+		begin
+			fd.readpartial(length)
+		rescue ::IOError, ::EOFError, ::Errno::EPIPE
+			return nil if (fd.abortive_close == true)
+			raise $!
+		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)
+		begin
+			if RUBY_VERSION =~ /^1\.9\./
+				if ((rv = ::Kernel.select([ fd ], nil, nil, timeout)) and
+				    (rv[0]) and
+				    (rv[0][0] == fd))
+					true
+				else
+					false
+				end
+			else
+				if ((rv = Rex::ThreadSafe.select([ fd ], nil, nil, timeout)) and
+				    (rv[0]) and
+				    (rv[0][0] == fd))
+					true
+				else
+					false
+				end
+			end
+		rescue StreamClosedError, ::IOError, ::EOFError, ::Errno::EPIPE
+			# If the thing that lead to the closure was an abortive close, then
+			# don't raise the stream closed error.
+			return false if (fd.abortive_close == true)
+
+			raise $!
+		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
+
+		begin
+			return read(bsize)
+		rescue Exception
+		end
+
+		return ''
+	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
+
+	#
+	# This flag indicates whether or not an abortive close has been issued.
+	#
+	attr_accessor :abortive_close
+
+protected
+
+end
+
+end end
+