librex 0.0.20 → 0.0.21

data/lib/rex/ui/text/irb_shell.rb

@@ -0,0 +1,57 @@
+module Rex
+module Ui
+module Text
+
+###
+#
+# This class wraps the creation of an IRB shell.
+#
+###
+class IrbShell
+
+	@@IrbInitialized = false
+
+	def initialize(binding)
+		@binding_ctx = binding
+	end
+
+	#
+	# Runs the IRB shell until completion.  The binding parameter initializes
+	# IRB to the appropriate binding context.
+	#
+	def run
+		# Initialize IRB by setting up its internal configuration hash and
+		# stuff.
+		if (@@IrbInitialized == false)
+			load('irb.rb')
+
+			IRB.setup(nil)
+			IRB.conf[:PROMPT_MODE]  = :SIMPLE
+
+			@@IrbInitialized = true
+		end
+
+		# Create a new IRB instance
+		irb = IRB::Irb.new(IRB::WorkSpace.new(@binding_ctx))
+
+		# Set the primary irb context so that exit and other intrinsic
+		# commands will work.
+		IRB.conf[:MAIN_CONTEXT] = irb.context
+
+		# Trap interrupt
+		old_sigint = trap("SIGINT") do
+			irb.signal_handle
+		end
+
+		# Keep processing input until the cows come home...
+		catch(:IRB_EXIT) do
+			irb.eval_input
+		end
+
+		trap("SIGINT", old_sigint)
+	end
+
+end
+end
+end
+end

data/lib/rex/ui/text/output.rb

@@ -0,0 +1,80 @@
+require 'rex/ui'
+
+module Rex
+module Ui
+module Text
+
+###
+#
+# This class implements text-based output but is not
+# tied to an output medium.
+#
+###
+class Output < Rex::Ui::Output
+
+	require 'rex/ui/text/output/stdio'
+	require 'rex/ui/text/output/socket'
+	require 'rex/ui/text/output/buffer'
+	require 'rex/ui/text/output/file'
+	require 'rex/ui/text/color'
+
+	include Rex::Ui::Text::Color
+
+	def initialize
+		@config = {
+			:color => :auto, # true, false, :auto
+		}
+		super
+	end
+	attr_reader :config
+
+	def disable_color
+		@config[:color] = false
+	end
+
+	def enable_color
+		@config[:color] = true
+	end
+
+	def auto_color
+		@config[:color] = :auto
+	end
+
+	def update_prompt(prompt = nil)
+		return if prompt.nil?
+		substitute_colors(prompt, true)
+	end
+
+	def print_error(msg = '')
+		print_line("%bld%red[-]%clr #{msg}")
+	end
+
+	def print_good(msg = '')
+		print_line("%bld%grn[+]%clr #{msg}")
+	end
+
+	def print_debug(msg = '')
+		print_line("%bld%cya[!]%clr #{msg}")
+	end
+
+	def print_status(msg = '')
+		print_line("%bld%blu[*]%clr #{msg}")
+	end
+
+	def print_line(msg = '')
+		print(msg + "\n")
+	end
+
+	def print(msg = '')
+		print_raw(substitute_colors(msg))
+	end
+
+	def reset
+	end
+
+end
+
+end
+end
+end
+

data/lib/rex/ui/text/output/buffer.rb

@@ -0,0 +1,61 @@
+require 'rex/ui'
+
+module Rex
+module Ui
+module Text
+
+###
+#
+# This class implements output against a buffer.
+#
+###
+class Output::Buffer < Rex::Ui::Text::Output
+
+	#
+	# Initializes an output buffer.
+	#
+	def initialize
+		self.buf = ''
+	end
+
+	def supports_color?
+		false
+	end
+
+	#
+	# Appends the supplied message to the output buffer.
+	#
+	def print_raw(msg = '')
+		self.buf += msg || ''
+
+		msg
+	end
+
+
+	#
+	# Read everything out of the buffer and reset it
+	#
+	def dump_buffer
+		self.buf ||= ''
+		buffer = self.buf.dup
+		reset()
+		buffer
+	end
+
+	#
+	# Reset the buffer to an empty string.
+	#
+	def reset
+		self.buf = ''
+	end
+
+	#
+	# The underlying buffer state.
+	#
+	attr_accessor :buf
+
+end
+
+end
+end
+end

data/lib/rex/ui/text/output/file.rb

@@ -0,0 +1,43 @@
+require 'rex/ui'
+
+module Rex
+module Ui
+module Text
+
+###
+#
+# This class implements output against a file
+#
+###
+class Output::File < Rex::Ui::Text::Output
+
+	attr_accessor :fd
+
+	def initialize(path)
+		self.fd = ::File.open(path, "wb")
+	end
+
+	def supports_color?
+		false
+	end
+
+	#
+	# Prints the supplied message to file output.
+	#
+	def print_raw(msg = '')
+		return if not self.fd
+		self.fd.write(msg)
+		self.fd.flush
+		msg
+	end
+
+	def close
+		self.fd.close if self.fd
+		self.fd = nil
+	end
+end
+
+end
+end
+end
+

data/lib/rex/ui/text/output/socket.rb

@@ -0,0 +1,43 @@
+require 'rex/ui'
+
+module Rex
+module Ui
+module Text
+
+###
+#
+# This class implements the output interface against a socket.
+#
+###
+class Output::Socket < Rex::Ui::Text::Output
+
+	def initialize(sock)
+		@sock = sock
+		super()
+	end
+
+	def supports_color?
+		case config[:color]
+		when true
+			# Allow color if the user forces it on
+			return true
+		else
+			false
+		end
+	end
+
+	#
+	# Prints the supplied message to the socket.
+	#
+	def print_raw(msg = '')
+		@sock.write(msg)
+		@sock.flush
+
+		msg
+	end
+end
+
+end
+end
+end
+

data/lib/rex/ui/text/output/stdio.rb

@@ -0,0 +1,40 @@
+require 'rex/ui'
+
+module Rex
+module Ui
+module Text
+
+###
+#
+# This class implements output against standard out.
+#
+###
+class Output::Stdio < Rex::Ui::Text::Output
+
+	def supports_color?
+		case config[:color]
+		when true
+			return true
+		when false
+			return false
+		else # auto
+			term = Rex::Compat.getenv('TERM')
+			return (term and term.match(/(?:vt10[03]|xterm(?:-color)?|linux|screen|rxvt)/i) != nil)
+		end
+	end
+
+	#
+	# Prints the supplied message to standard output.
+	#
+	def print_raw(msg = '')
+		$stdout.print(msg)
+		$stdout.flush
+
+		msg
+	end
+end
+
+end
+end
+end
+

data/lib/rex/ui/text/progress_tracker.rb

@@ -0,0 +1,56 @@
+require 'rex/ui/progress_tracker'
+
+module Rex
+module Ui
+module Text
+
+###
+#
+# This module implements progress tracking against a text interface.
+#
+###
+class ProgressTracker < Rex::Ui::ProgressTracker
+
+	def initialize(output)
+		self.output = output
+		self.start  = 0
+		self.stop   = 0
+		self.pos    = 0
+	end
+
+	#
+	# Passes a generic status message that isn't necessarily associated
+	# with a step event.
+	#
+	def status(msg = '')
+		output.print_status(msg)
+	end
+
+	#
+	# Updates the status associated with the current step.
+	#
+	def step_status(msg = '')
+		output.print_status("#{pos}: #{msg}") if (msg and msg.length > 0)
+	end
+
+	#
+	# An error occurred that may result in aborting the progress.
+	#
+	def error(msg = '')
+		output.print_error(msg)
+	end
+
+	#
+	# Progress has been aborted, the reason is supplied in msg.
+	#
+	def abort(msg = '')
+		output.print_error("fatal: #{msg}")
+	end
+
+	attr_accessor :output
+
+end
+
+end
+end
+end

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

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.join(File.dirname(__FILE__), '..', '..', '..'))
+
+require 'test/unit'
+require 'rex/ui'
+
+class Rex::Ui::Text::ProgressTracker::UnitTest < Test::Unit::TestCase
+
+	def test_stuff
+		output   = Rex::Ui::Text::Output::Buffer.new
+		pt       = Rex::Ui::Text::ProgressTracker.new(output)
+
+		pt.range = 1..10
+	
+		assert_equal(1, pt.start)
+		assert_equal(10, pt.stop)
+
+		pt.start = 2
+		assert_equal(2, pt.start)
+		pt.stop = 9
+		assert_equal(9, pt.stop)
+		assert_equal(2, pt.pos)
+		assert_equal('', output.buf)
+		assert_equal(3, pt.step)
+		assert_equal(4, pt.step("test"))
+		assert_equal("[*] 4: test\n", output.buf)
+		output.reset
+		assert_equal("[-] bad\n", pt.error("bad"))
+		output.reset
+		assert_equal("[-] fatal: bad\n", pt.abort("bad"))
+	end
+
+end

data/lib/rex/ui/text/shell.rb

@@ -0,0 +1,328 @@
+require 'rex/ui'
+
+module Rex
+module Ui
+module Text
+
+###
+#
+# The shell class provides a command-prompt style interface in a
+# generic fashion.
+#
+###
+module Shell
+
+	###
+	#
+	# This module is meant to be mixed into an input medium class instance as a
+	# means of extending it to display a prompt before each call to gets.
+	#
+	###
+	module InputShell
+		attr_accessor :prompt, :output
+
+		def pgets
+			output.print(prompt)
+			output.flush
+
+			output.prompting
+			buf = gets
+			output.prompting(false)
+
+			buf
+		end
+	end
+
+	#
+	# Initializes a shell that has a prompt and can be interacted with.
+	#
+	def initialize(prompt, prompt_char = '>', histfile = nil)
+		# Set the stop flag to false
+		self.stop_flag      = false
+		self.disable_output = false
+		self.stop_count	    = 0
+
+		# Initialize the prompt
+		self.init_prompt = prompt
+		self.prompt_char = prompt_char
+
+		self.histfile = histfile
+		self.hist_last_saved = 0
+	end
+
+	def init_tab_complete
+		if (self.input and self.input.supports_readline)
+			self.input = Input::Readline.new(lambda { |str| tab_complete(str) })
+			if Readline::HISTORY.length == 0 and histfile and File.exists?(histfile)
+				File.readlines(histfile).each { |e|
+					Readline::HISTORY << e.chomp
+				}
+				self.hist_last_saved = Readline::HISTORY.length
+			end
+			self.input.output = self.output
+			update_prompt(input.prompt)
+		end
+	end
+
+	#
+	# Initializes the user interface input/output classes.
+	#
+	def init_ui(in_input = nil, in_output = nil)
+		# Initialize the input and output methods
+		self.input  = in_input
+		self.output = in_output
+
+		if (self.input)
+			# Extend the input medium as an input shell if the input medium
+			# isn't intrinsicly a shell.
+			if (self.input.intrinsic_shell? == false)
+				self.input.extend(InputShell)
+			end
+
+			self.input.output = self.output
+		end
+		update_prompt('')
+	end
+
+	#
+	# Resets the user interface handles.
+	#
+	def reset_ui
+		init_ui
+	end
+
+	#
+	# Sets the log source that should be used for logging input and output.
+	#
+	def set_log_source(log_source)
+		self.log_source = log_source
+	end
+
+	#
+	# Unsets the log source so that logging becomes disabled.
+	#
+	def unset_log_source
+		set_log_source(nil)
+	end
+
+	#
+	# Performs tab completion on the supplied string.
+	#
+	def tab_complete(str)
+		return tab_complete_proc(str) if (tab_complete_proc)
+	end
+
+	#
+	# Run the command processing loop.
+	#
+	def run(&block)
+
+		begin
+
+			while true
+				# If the stop flag was set or we've hit EOF, break out
+				break if (self.stop_flag or self.stop_count > 1)
+
+				init_tab_complete
+				line = input.pgets
+				log_output(input.prompt)
+
+				# If a block was passed in, pass the line to it.  If it returns true,
+				# break out of the shell loop.
+				if (block)
+					break if (line == nil or block.call(line))
+				elsif(input.eof? or line == nil)
+				# If you have sessions active, this will give you a shot to exit gravefully
+				# If you really are ambitious, 2 eofs will kick this out
+					self.stop_count += 1
+					next if(self.stop_count > 1)
+					run_single("quit")
+				else
+				# Otherwise, call what should be an overriden instance method to
+				# process the line.
+					ret = run_single(line)
+					# don't bother saving lines that couldn't be found as a
+					# command, create the file if it doesn't exist
+					if ret and self.histfile
+						File.open(self.histfile, "a+") { |f|
+							f.puts(line)
+						}
+					end
+					self.stop_count = 0
+				end
+
+			end
+		# Prevent accidental console quits
+		rescue ::Interrupt
+			output.print("Interrupt: use the 'exit' command to quit\n")
+			retry
+		end
+	end
+
+	#
+	# Stop processing user input.
+	#
+	def stop
+		self.stop_flag = true
+	end
+
+	#
+	# Checks to see if the shell has stopped.
+	#
+	def stopped?
+		self.stop_flag
+	end
+
+	#
+	# Change the input prompt.
+	#
+	def update_prompt(prompt = nil, new_prompt_char = nil)
+		if (self.input)
+			if (prompt)
+				new_prompt = self.init_prompt + ' ' + prompt + prompt_char + ' '
+			else
+				new_prompt = self.prompt || ''
+			end
+
+			# Save the prompt before any substitutions
+			self.prompt = new_prompt
+
+			# Set the actual prompt to the saved prompt with any substitutions
+			# or updates from our output driver, be they color or whatever
+			self.input.prompt = self.output.update_prompt(new_prompt)
+			self.prompt_char  = new_prompt_char if (new_prompt_char)
+		end
+	end
+
+	#
+	# Output shortcuts
+	#
+
+	#
+	# Prints an error message to the output handle.
+	#
+	def print_error(msg='')
+		return if (output.nil?)
+
+		self.on_print_proc.call(msg) if self.on_print_proc
+		# Errors are not subject to disabled output
+		log_output(output.print_error(msg))
+	end
+
+	#
+	# Prints a status message to the output handle.
+	#
+	def print_status(msg='')
+		return if (disable_output == true)
+
+		self.on_print_proc.call(msg) if self.on_print_proc
+		log_output(output.print_status(msg))
+	end
+
+	#
+	# Prints a good message to the output handle.
+	#
+	def print_good(msg='')
+		return if (disable_output == true)
+
+		self.on_print_proc.call(msg) if self.on_print_proc
+		log_output(output.print_good(msg))
+	end
+
+	#
+	# Prints a line of text to the output handle.
+	#
+	def print_line(msg='')
+		return if (disable_output == true)
+
+		self.on_print_proc.call(msg) if self.on_print_proc
+		log_output(output.print_line(msg))
+	end
+
+	#
+	# Prints a raw message to the output handle.
+	#
+	def print(msg='')
+		return if (disable_output == true)
+		self.on_print_proc.call(msg) if self.on_print_proc
+		log_output(output.print(msg))
+	end
+
+	#
+	# Whether or not output has been disabled.
+	#
+	attr_accessor :disable_output
+	#
+	# The input handle to read user input from.
+	#
+	attr_reader   :input
+	#
+	# The output handle to write output to.
+	#
+	attr_reader   :output
+
+	attr_accessor :on_command_proc
+	attr_accessor :on_print_proc
+
+protected
+
+	#
+	# Parse a line into an array of arguments.
+	#
+	def parse_line(line)
+		log_input(line)
+
+		line.gsub!(/(\r|\n)/, '')
+
+		begin
+			return args = Rex::Parser::Arguments.from_s(line)
+		rescue ::ArgumentError
+			print_error("Parse error: #{$!}")
+		end
+
+		return []
+	end
+
+	#
+	# Print the prompt, but do not log it.
+	#
+	def _print_prompt(prompt)
+		output.print(prompt)
+	end
+
+	#
+	# Writes the supplied input to the log source if one has been registered.
+	#
+	def log_input(buf)
+		rlog(buf, log_source) if (log_source)
+	end
+
+	#
+	# Writes the supplied output to the log source if one has been registered.
+	#
+	def log_output(buf)
+		rlog(buf, log_source) if (log_source)
+	end
+
+	attr_writer   :input, :output # :nodoc:
+	attr_accessor :stop_flag, :init_prompt # :nodoc:
+	attr_accessor :prompt # :nodoc:
+	attr_accessor :prompt_char, :tab_complete_proc # :nodoc:
+	attr_accessor :histfile # :nodoc:
+	attr_accessor :hist_last_saved # the number of history lines when last saved/loaded
+	attr_accessor :log_source, :stop_count # :nodoc:
+
+end
+
+###
+#
+# Pseudo-shell interface that simply includes the Shell mixin.
+#
+###
+class PseudoShell
+	include Shell
+end
+
+
+end end end
+