librex 0.0.1

data/lib/rex/text.rb.ut.rb

@@ -0,0 +1,168 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.join(File.dirname(__FILE__), '..'))
+
+require 'test/unit'
+require 'rex/text'
+require 'rex/exceptions'
+class Rex::Text::UnitTest < Test::Unit::TestCase
+
+	def test_uri_encode
+		srand(0)
+		assert_equal('A1%21', Rex::Text.uri_encode('A1!'), 'uri encode')
+		assert_equal('A1!', Rex::Text.uri_encode('A1!', 'none'), 'uri encode: none')
+		assert_equal('A1%21', Rex::Text.uri_encode('A1!', 'hex-normal'), 'uri encode: hex-normal')
+		assert_equal('%41%31%21', Rex::Text.uri_encode('A1!', 'hex-all'), 'uri encode: hex-all')
+		assert_equal('A1%u01c3', Rex::Text.uri_encode('A1!', 'u-normal'), 'uri encode: u-normal')
+		assert_equal('%uff21%u2081%uff01', Rex::Text.uri_encode('A1!', 'u-all'), 'uri encode: u-all')
+		srand(0)
+		assert_equal("%uff2d%uff49%uff43%uff52%uff4f%uff53%uff4f%uff46%uff54%u2004%uff45%uff4e%uff43%uff4f%uff44%uff49%uff4e%uff47%u3000%uff44%uff52%uff49%uff56%uff45%uff53%u2005%uff4d%uff45%u2000%uff43%uff52%uff41%uff5a%uff59%uff01", Rex::Text.uri_encode('Microsoft encoding drives me crazy!', 'u-half'))
+
+		assert_raises(TypeError) {
+			Rex::Text.uri_encode('a', 'umpa lumpa')
+		}
+	end
+
+    def test_html_encode
+        assert_equal('&#x41', Rex::Text.html_encode('A'), 'html_encode default')
+        assert_equal('&#x41', Rex::Text.html_encode('A','hex'), 'html_encode hex')
+        assert_equal('&#65', Rex::Text.html_encode('A','int'), 'html_encode int')
+        assert_equal('&#0000065', Rex::Text.html_encode('A','int-wide'), 'html_encode int-wide')
+
+        assert_raises(TypeError) {
+            Rex::Text.html_encode('a', 'umpa lumpa')
+        }
+    end
+
+	def test_rand_text
+		srand(0)
+		assert_equal("\254/u\300C\373\303g\t\323", Rex::Text.rand_text(10), 'rand text 1')
+		assert_equal("\025\362$WF\330X\214:\301", Rex::Text.rand_text(10), 'rand text 2')
+		assert_equal("\346'W\256XQ\245\031MH", Rex::Text.rand_text(10), 'rand text 3')
+		assert_equal('bababbabba', Rex::Text.rand_text(10, nil, 'ab'), 'rand text with specified "good"')
+		assert_equal('MA', Rex::Text.rand_state(), 'rand state')
+		assert_equal('xzdttongb.5gfk0xjly3.aak.fmo0rp.com', Rex::Text.rand_hostname(), 'rand hostname')
+		assert_equal('9aaf811799', Rex::Text.rand_text_hex(10), 'rand hex')
+	end
+
+
+	def test_unicode
+		assert_equal("a\x00b\x00c\x00", Rex::Text.to_unicode('abc'), 'unicode, default = little endian')
+		assert_equal("a\x00b\x00c\x00", Rex::Text.to_unicode('abc', 'utf-16le'), 'utf-16le')
+		assert_equal("\x00a\x00b\x00c", Rex::Text.to_unicode('abc', 'utf-16be'), 'utf-16be')
+		assert_equal("a\x00\x00\x00b\x00\x00\x00c\x00\x00\x00", Rex::Text.to_unicode('abc', 'utf-32le'), 'utf-32le')
+		assert_equal("\x00\x00\x00a\x00\x00\x00b\x00\x00\x00c", Rex::Text.to_unicode('abc', 'utf-32be'), 'utf-32be')
+		assert_equal("abc+-abc-+AAA-", Rex::Text.to_unicode("abc+abc-\x00", 'utf-7'), 'utf-7')
+		assert_equal("+AGE-+AGI-+AGM-+ACs-+AGE-+AGI-+AGM-+AC0-+AAA-", Rex::Text.to_unicode("abc+abc-\x00", 'utf-7', 'all'), 'utf-7-all')
+
+		assert_equal("a\303\272", Rex::Text.to_unicode("a\xFA", 'utf-8'))
+		assert_equal("\xC1\xA1", Rex::Text.to_unicode('a', 'utf-8', 'overlong', 2), 'utf-8 overlong')
+		assert_equal("\xE0\x81\xA1", Rex::Text.to_unicode('a', 'utf-8', 'overlong', 3), 'utf-8 overlong')
+		assert_equal("\xF0\x80\x81\xA1", Rex::Text.to_unicode('a', 'utf-8', 'overlong', 4), 'utf-8 overlong')
+		assert_equal("\xF8\x80\x80\x81\xA1", Rex::Text.to_unicode('a', 'utf-8', 'overlong', 5), 'utf-8 overlong')
+		assert_equal("\xFC\x80\x80\x80\x81\xA1", Rex::Text.to_unicode('a', 'utf-8', 'overlong', 6), 'utf-8 overlong')
+		assert_equal("\xFE\x80\x80\x80\x80\x81\xA1", Rex::Text.to_unicode('a', 'utf-8', 'overlong', 7), 'utf-8 overlong')
+		100.times {
+			assert(["\xC1\x21","\xC1\x61","\xC1\xE1"].include?(Rex::Text.to_unicode('a', 'utf-8', 'invalid')), 'utf-8 invalid')
+			assert(["\xE0\x01\x21","\xE0\x01\x61","\xE0\x01\xA1","\xE0\x01\xE1","\xE0\x41\x21","\xE0\x41\x61","\xE0\x41\xA1","\xE0\x41\xE1","\xE0\x81\x21","\xE0\x81\x61","\xE0\x81\xA1","\xE0\x81\xE1","\xE0\xC1\x21","\xE0\xC1\x61","\xE0\xC1\xA1","\xE0\xC1\xE1"].include?(Rex::Text.to_unicode('a', 'utf-8', 'invalid', 3)), 'utf-8 invalid 3 byte')
+		}
+
+		a = ["\xC1\x21","\xC1\x61","\xC1\xE1"]
+		10.times {
+			encoded = Rex::Text.to_unicode('a', 'utf-8', 'invalid')
+			if a.include?(encoded)
+				a.delete(encoded)
+			end
+		}
+		assert_equal([], a, 'all possible values')
+
+		assert_raises(TypeError) {
+			Rex::Text.to_unicode('a', 'utf-8', '', 8)
+		}
+		assert_raises(TypeError) {
+			Rex::Text.to_unicode('a', 'utf-8', 'foo', 6)
+		}
+
+		assert_raises(TypeError) {
+			Rex::Text.to_unicode('a', 'uhwtfms', -1)
+		}
+
+		100.times {
+			assert(["\x01\x00","\x01\x02","\x01\x04","\x01\xcd","\x01\xde","\xff\x21"].include?(Rex::Text.to_unicode('A', 'uhwtfms')), 'uhwtfms')
+			assert(["\x00\xc0","\x00\xc1","\x00\xc2","\x00\xc3","\x00\xc4","\x00\xc5"].include?(Rex::Text.to_unicode('A', 'uhwtfms', 949)), 'uhwtfms codepage 949')
+		}
+
+		a = ["\x01\x00","\x01\x02","\x01\x04","\x01\xcd","\x01\xde","\xff\x21"]
+		20.times {
+			encoded = Rex::Text.to_unicode('A', 'uhwtfms')
+			if a.include?(encoded)
+				a.delete(encoded)
+			end
+		}
+		assert_equal([], a, 'all possible values uhwtfms')
+		
+		assert_raises(TypeError) {
+			Rex::Text.to_unicode('a', 'uhwtfms-half', 1)
+		}
+
+		assert_equal("\xFF\x01", Rex::Text.to_unicode('!', 'uhwtfms-half'))
+		srand(0)
+		assert_equal("\xff\x2d\xff\x49\xff\x43\xff\x52\xff\x4f\xff\x53\xff\x4f\xff\x46\xff\x54\x20\x04\xff\x45\xff\x4e\xff\x43\xff\x4f\xff\x44\xff\x49\xff\x4e\xff\x47\x30\x00\xff\x44\xff\x52\xff\x49\xff\x56\xff\x45\xff\x53\x20\x05\xff\x4d\xff\x45\x20\x00\xff\x43\xff\x52\xff\x41\xff\x5a\xff\x59\xff\x01", Rex::Text.to_unicode('Microsoft encoding drives me crazy!', 'uhwtfms-half'))
+	end
+
+	def test_zlib
+		assert_equal("x\332\313\310T\310\315\317\005\000\a\225\002;", Rex::Text.zlib_deflate('hi mom'), 'compress')
+		assert_equal('hi mom', Rex::Text.zlib_inflate("x\234\313\310T\310\315\317\005\000\a\225\002;"), 'decompress')
+	end
+
+	def test_gzip
+		string = Rex::Text.gzip('hi mom')
+		assert_equal("\x1f\x8b\x08\x00", string.slice!(0,4), 'gzip headers')
+		
+		# skip the next 6 bytes as it is host & time specific (zlib's example gun does, so why not us too?)
+		string.slice!(0,6)
+		
+		assert_equal("\xcb\xc8\x54\xc8\xcd\xcf\x05\x00\x68\xa4\x1c\xf0\x06\x00\x00\x00", string, 'gzip data')
+
+		assert_equal('hi mom', Rex::Text.ungzip("\037\213\010\000|\261\275C\002\003\313\310T\310\315\317\005\000h\244\034\360\006\000\000\000"), 'ungzip')
+	end
+
+	def test_badchar_index
+		assert_equal(nil, Rex::Text.badchar_index('abcdef', 'gzk'))
+		assert_equal(2, Rex::Text.badchar_index('123avd', 'ly3'))
+	end
+	
+	def test_hexify
+		str = "\x01\x02\xff\x00"
+	
+		assert_equal("\\x01\\x02\\xff\\x00", Rex::Text.to_hex(str), 'to_hex')
+		assert_equal("ABC01ABC02ABCffABC00", Rex::Text.to_hex(str, 'ABC'), 'to_hex with prefix')
+		assert_equal('%u0102%uff00', Rex::Text.to_hex(str, '%u', 2), 'to_hex with chunk size of 2')
+		
+		# to_hex, without providing enouigh data to chunk on a given size
+		assert_raises(RuntimeError){ Rex::Text.to_hex('a', '', 2) }
+
+		assert_equal("buf = \n\"\\x01\\x02\\xff\\x00\"\n", Rex::Text.to_ruby(str), 'to_ruby')
+		assert_equal("my $buf = \n\"\\x01\\x02\\xff\\x00\";\n", Rex::Text.to_perl(str), 'to_perl')
+		assert_equal("unsigned char buf[] = \n\"\\x01\\x02\\xff\\x00\";\n", Rex::Text.to_c(str), 'to_c')
+	
+		# 0 -> 20
+		str = "\000\001\002\003\004\005\006\a\010\t\n\v\f\r\016\017\020\021\022\023"
+
+		assert_equal("buf = \n\"\\x00\\x01\\x02\\x03\" +\n\"\\x04\\x05\\x06\\x07\" +\n\"\\x08\\x09\\x0a\\x0b\" +\n\"\\x0c\\x0d\\x0e\\x0f\" +\n\"\\x10\\x11\\x12\\x13\"\n", Rex::Text.to_ruby(str, 20), 'to_ruby with wrap')
+		assert_equal("my $buf = \n\"\\x00\\x01\\x02\\x03\" .\n\"\\x04\\x05\\x06\\x07\" .\n\"\\x08\\x09\\x0a\\x0b\" .\n\"\\x0c\\x0d\\x0e\\x0f\" .\n\"\\x10\\x11\\x12\\x13\";\n", Rex::Text.to_perl(str, 20), 'to_perl with wrap')
+		assert_equal("unsigned char buf[] = \n\"\\x00\\x01\\x02\\x03\\x04\"\n\"\\x05\\x06\\x07\\x08\\x09\"\n\"\\x0a\\x0b\\x0c\\x0d\\x0e\"\n\"\\x0f\\x10\\x11\\x12\\x13\";\n", Rex::Text.to_c(str, 20, "buf"), 'to_c with wrap')
+		assert_equal("\\x0a", Rex::Text.to_hex("\n"), 'to_hex newline')
+	end
+
+	def test_wordwrap
+		txt = "this is a test of the word wrap features"
+
+		assert_equal("this is a \ntest of \nthe word \nwrap \nfeatures\n", Rex::Text.wordwrap(txt, 0, 10))
+	end
+
+	def test_transforms
+		assert_equal("acbd18db4cc2f85cedef654fccc4a4d8", Rex::Text.md5('foo'))
+	end
+
+end

data/lib/rex/time.rb

@@ -0,0 +1,65 @@
+module Rex
+
+###
+#
+# Extended time related functions.
+#
+###
+module ExtTime
+
+	#
+	# Convert seconds to a string that is broken down into years, days, hours,
+	# minutes, and second.
+	#
+	def self.sec_to_s(seconds)
+		parts = [ 31536000, 86400, 3600, 60, 1 ].map { |d|
+			if ((c = seconds / d) > 0) 
+				seconds -= c.truncate * d
+				c.truncate
+			else
+				0
+			end
+		}.reverse
+
+		str = ''
+
+		[ "sec", "min", "hour", "day", "year" ].each_with_index { |name, idx|
+			next if (!parts[idx] or parts[idx] == 0)
+
+			str = "#{parts[idx]} #{name + ((parts[idx] != 1) ? 's' :'')} " + str
+		}
+
+		str.empty? ? "0 secs" : str.strip
+	end
+
+	#
+	# Converts a string in the form n years g days x hours y mins z secs.
+	#
+	def self.str_to_sec(str)
+		fields = str.split(/ /)
+		secs   = 0
+
+		fields.each_with_index { |f, idx|
+			val = 0
+			case f
+				when /^year/
+					val = 31536000
+				when /^day/
+					val = 86400
+				when /^hour/
+					val = 3600
+				when /^min/
+					val = 60
+				when /^sec/
+					val = 1
+			end
+
+			secs += val * fields[idx-1].to_i
+		}
+
+		secs
+	end
+
+end
+
+end

data/lib/rex/transformer.rb

@@ -0,0 +1,115 @@
+module Rex
+
+###
+#
+# Transformer - more than meets the eye!
+#
+# This class, aside from having a kickass name, is responsible for translating
+# object instances of one or more types into a single list instance of one or
+# more types.  This is useful for translating object instances that be can
+# either strings or an array of strings into an array of strings, for
+# instance.  It lets you make things take a uniform structure in an abstract
+# manner.
+#
+###
+class Transformer
+
+	#
+	# Translates the object instance supplied in src_instance to an instance of
+	# dst_class.  The dst_class parameter's instance must support the <<
+	# operator.  An example call to this method looks something like:
+	#
+	# Transformer.transform(string, Array, [ String ], target)
+	#
+	def Transformer.transform(src_instance, dst_class, supported_classes,
+			target = nil)
+		dst_instance = dst_class.new
+
+		if (src_instance.kind_of?(Array))
+			src_instance.each { |src_inst|
+				Transformer.transform_single(src_inst, dst_instance,
+						supported_classes, target)
+			}
+		elsif (!src_instance.kind_of?(NilClass))
+			Transformer.transform_single(src_instance, dst_instance,
+					supported_classes, target)
+		end
+
+		return dst_instance
+	end
+
+protected
+
+	#
+	# Transform a single source instance.
+	#
+	def Transformer.transform_single(src_instance, dst_instance,
+			supported_classes, target)
+		# If the src instance's class is supported, just add it to the dst
+		# instance
+		if (supported_classes.include?(src_instance.class))
+			dst_instance << src_instance
+		# If the src instance's class is an array, then we should check to see
+		# if any of the supporting classes support from_a.
+		elsif (src_instance.kind_of?(Array))
+			new_src_instance = nil
+
+			# Walk each supported class calling from_a if exported
+			supported_classes.each { |sup_class|
+				next if (sup_class.respond_to?('from_a') == false)
+
+				new_src_instance = sup_class.from_a(src_instance)
+
+				if (new_src_instance != nil)
+					dst_instance << new_src_instance
+					break
+				end
+			}
+
+			# If we don't have a valid new src instance, then we suck
+			if (new_src_instance == nil)
+				bomb_translation(src_instance, target)
+			end
+
+		# If the source instance is a string, query each of the supported
+		# classes to see if they can serialize it to their particular data
+		# type.
+		elsif (src_instance.kind_of?(String))
+			new_src_instance = nil
+
+			# Walk each supported class calling from_s if exported
+			supported_classes.each { |sup_class|
+				next if (sup_class.respond_to?('from_s') == false)
+
+				new_src_instance = sup_class.from_s(src_instance)
+
+				if (new_src_instance != nil)
+					dst_instance << new_src_instance
+					break
+				end
+			}
+
+			# If we don't have a valid new src instance, then we suck
+			if (new_src_instance == nil)
+				bomb_translation(src_instance, target)
+			end
+		# Otherwise, bomb translation
+		else
+			bomb_translation(src_instance, target)
+		end
+	end
+
+	def Transformer.bomb_translation(src_instance, target) # :nodoc:
+		error = "Invalid source class (#{src_instance.class})"
+
+		if (target != nil)
+			error += " for #{target}"
+		end
+
+		raise ArgumentError, error, caller
+	end
+
+end
+
+end
+

data/lib/rex/transformer.rb.ut.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.join(File.dirname(__FILE__), '..'))
+
+require 'test/unit'
+require 'rex/exceptions'
+require 'rex/transformer'
+
+class Rex::Transformer::UnitTest < Test::Unit::TestCase
+	class Pizza
+		def Pizza.from_s(str)
+		end
+	end
+
+	class ArrayTester
+		def self.from_a(a)
+			a[0] + a[1]
+		end
+	end
+
+	def test_transformer
+		a = Rex::Transformer.transform([ 'yo', 'ho' ], Array, [ String ], 'Jones')
+
+		assert_equal(2, a.length, "invalid array length")
+		assert_equal('yo', a[0], "invalid first element")
+		assert_equal('ho', a[1], "invalid second element")
+
+		assert_raise(Rex::ArgumentError, "invalid transform") {
+			Rex::Transformer.transform('dog', Array, [ Pizza ], 'bob')
+		}
+	end
+
+	def test_from_a
+		a = Rex::Transformer.transform([ [ 'one', 'two' ] ], Array, [ ArrayTester ], 'Jimmy')
+
+		assert_equal('onetwo', a[0], "invalid from_a conversion")
+	end
+end

data/lib/rex/ui.rb

@@ -0,0 +1,21 @@
+#
+# This file includes everything needed to interact with the user interface
+# wrappers of the rex library.
+#
+
+# General classes
+require 'rex/ui/output'
+require 'rex/ui/progress_tracker'
+
+# Text-based user interfaces
+require 'rex/ui/text/input'
+require 'rex/ui/text/shell'
+require 'rex/ui/text/dispatcher_shell'
+require 'rex/ui/text/irb_shell'
+
+require 'rex/ui/text/color'
+require 'rex/ui/text/table'
+
+# Ui subscriber
+require 'rex/ui/subscriber'
+require 'rex/ui/interactive'

data/lib/rex/ui/interactive.rb

@@ -0,0 +1,252 @@
+module Rex
+module Ui
+
+###
+#
+# This class implements the stubs that are needed to provide an interactive
+# user interface that is backed against something arbitrary.
+#
+###
+module Interactive
+
+	#
+	# Interactive sessions by default may interact with the local user input
+	# and output.
+	#
+	include Rex::Ui::Subscriber
+
+	#
+	# Starts interacting with the session at the most raw level, simply 
+	# forwarding input from user_input to rstream and forwarding input from
+	# rstream to user_output.
+	#
+	def interact(user_input, user_output)
+	
+		# Detach from any existing console
+		if(self.interacting)
+			detach()
+		end
+
+		init_ui(user_input, user_output)
+
+		self.interacting = true
+		self.completed = false
+
+		eof = false
+
+		# Start the readline stdin monitor 
+		# XXX disabled
+		# user_input.readline_start() if user_input.supports_readline
+		
+		# Handle suspend notifications
+		handle_suspend
+		
+		# As long as we're interacting...
+		while (self.interacting == true)
+
+			begin
+				_interact
+
+			rescue Interrupt
+				# If we get an interrupt exception, ask the user if they want to
+				# abort the interaction.  If they do, then we return out of
+				# the interact function and call it a day.
+				eof = true if (_interrupt)
+		
+			rescue EOFError, Errno::ECONNRESET, IOError
+				# If we reach EOF or the connection is reset...
+				eof = true
+				
+			end
+
+			break if eof
+		end
+
+		begin
+		
+			# Restore the suspend handler
+			restore_suspend
+
+			# If we've hit eof, call the interact complete handler
+			_interact_complete if (eof == true)
+
+			# Shutdown the readline thread
+ 			# XXX disabled
+			# user_input.readline_stop() if user_input.supports_readline
+			
+			# Detach from the input/output handles
+			reset_ui()
+					
+		ensure
+			# Mark this as completed
+			self.completed = true
+		end
+
+		# Return whether or not EOF was reached
+		return eof
+	end
+
+	#
+	# Stops the current interaction
+	#
+	def detach
+		if (self.interacting)
+			self.interacting = false
+			while(not self.completed)
+				select(nil, nil, nil, 0.25)	
+			end
+		end
+	end
+
+	#
+	# Whether or not the session is currently being interacted with
+	#
+	attr_accessor   :interacting
+	
+	#
+	# Whether or not the session has completed interaction
+	#
+	attr_accessor	:completed
+
+protected
+	
+	#
+	# The original suspend proc.
+	#
+	attr_accessor :orig_suspend
+
+	#
+	# Stub method that is meant to handler interaction
+	#
+	def _interact
+	end
+
+	#
+	# Called when an interrupt is sent.
+	#
+	def _interrupt
+		true
+	end
+
+	#
+	# Called when a suspend is sent.
+	#
+	def _suspend
+		false
+	end
+
+	#
+	# Called when interaction has completed and one of the sides has closed.
+	#
+	def _interact_complete
+		true
+	end
+
+	#
+	# Read from remote and write to local.
+	#
+	def _stream_read_remote_write_local(stream)
+		data = stream.get
+
+		user_output.print(data)
+	end
+
+	#
+	# Read from local and write to remote.
+	#
+	def _stream_read_local_write_remote(stream)
+		data = user_input.gets
+		
+		stream.put(data)
+	end
+
+	#
+	# The local file descriptor handle.
+	#
+	def _local_fd
+		user_input.fd
+	end
+
+	#
+	# The remote file descriptor handle.
+	#
+	def _remote_fd(stream)
+		stream.fd
+	end
+
+	#
+	# Interacts with two streaming connections, reading data from one and
+	# writing it to the other.  Both are expected to implement Rex::IO::Stream.
+	#
+	def interact_stream(stream)
+		while self.interacting
+		
+			# Select input and rstream
+			sd = Rex::ThreadSafe.select([ _local_fd, _remote_fd(stream) ], nil, nil, 0.25)
+			
+			# Cycle through the items that have data
+			# From the stream?  Write to user_output.
+			sd[0].each { |s|
+				if (s == _remote_fd(stream))
+					_stream_read_remote_write_local(stream)
+				# From user_input?  Write to stream.
+				elsif (s == _local_fd)
+					_stream_read_local_write_remote(stream)
+				end
+			} if (sd)
+			
+			Thread.pass
+		end
+	end
+
+	#
+	# Installs a signal handler to monitor suspend signal notifications.
+	#
+	def handle_suspend
+		if (orig_suspend == nil)
+			begin
+				self.orig_suspend = Signal.trap("TSTP") {
+					_suspend
+				}
+			rescue
+			end
+		end
+	end
+
+	#
+	# Restores the previously installed signal handler for suspend
+	# notifications.
+	#
+	def restore_suspend
+		if (orig_suspend)
+			begin
+				Signal.trap("TSTP", orig_suspend)
+			rescue
+			end
+
+			self.orig_suspend = nil
+		end
+	end
+
+	#
+	# Prompt the user for input if possible.
+	# XXX: This is not thread-safe on Windows
+	#
+	def prompt(query)
+		if (user_output and user_input)
+			user_output.print("\n" + query)
+			user_input.sysread(2)
+		end
+	end
+	
+	#
+	# Check the return value of a yes/no prompt
+	#
+	def prompt_yesno(query)
+		(prompt(query + " [y/N]  ") =~ /^y/i) ? true : false
+	end
+
+end
+
+end
+end