librex 0.0.17 → 0.0.18

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

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