librex 0.0.20 → 0.0.21

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/ring_buffer.rb

@@ -0,0 +1,364 @@
+#
+# 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
+	
+	#
+	# 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 
+	#
+	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)
+		self.fd.put(data)
+	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
+
+