librex 0.0.13 → 0.0.15

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

@@ -1,16 +0,0 @@
-#!/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

@@ -1,12 +0,0 @@
-#!/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

@@ -1,60 +0,0 @@
-#!/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

@@ -1,46 +0,0 @@
-#!/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

@@ -1,37 +0,0 @@
-#!/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

@@ -1,157 +0,0 @@
-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

@@ -1,35 +0,0 @@
-#!/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

@@ -1,319 +0,0 @@
-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[0, block_size]
-				sent = fd.write_nonblock( data )
-				if sent > 0
-					total_sent += sent
-					buf[0, sent] = ""
-				end
-			end
-		rescue ::Errno::EAGAIN
-			# 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 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)
-
-		# 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
-			# 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
-