librex 0.0.1

data/lib/rex/io/stream_abstraction.rb

@@ -0,0 +1,186 @@
+#!/usr/bin/env ruby
+
+require 'socket'
+require 'fcntl'
+
+module Rex
+module IO
+
+###
+#
+# This class provides an abstraction to a stream based
+# connection through the use of a streaming socketpair.
+#
+###
+module StreamAbstraction
+
+	###
+	#
+	# Extension information for required Stream interface.
+	#
+	###
+	module Ext
+
+		#
+		# Initializes peer information.
+		#
+		def initinfo(peer,local)
+			@peer = peer
+			@local = local
+		end
+
+		#
+		# Symbolic peer information.
+		#
+		def peerinfo
+			(@peer || "Remote Pipe")
+		end
+
+		#
+		# Symbolic local information.
+		#
+		def localinfo
+			(@local || "Local Pipe")
+		end
+	end
+
+	#
+	# This method creates a streaming socket pair and initializes it.
+	#
+	def initialize_abstraction
+		self.lsock, self.rsock = Rex::Socket.tcp_socket_pair()
+		self.lsock.extend(Rex::IO::Stream)
+		self.lsock.extend(Ext)
+		self.rsock.extend(Rex::IO::Stream)
+
+    self.monitor_rsock
+
+	end
+
+	#
+	# This method cleans up the abstraction layer.
+	#
+	def cleanup_abstraction
+		self.lsock.close if (self.lsock)
+		self.rsock.close if (self.rsock)
+
+		self.lsock = nil
+		self.rsock = nil
+	end
+
+	#
+	# Writes to the local side.
+	#
+	def syswrite(buffer)
+		lsock.syswrite(buffer)
+	end
+
+	#
+	# Reads from the local side.
+	#
+	def sysread(length)
+		lsock.sysread(length)
+	end
+
+	#
+	# Shuts down the local side of the stream abstraction.
+	#
+	def shutdown(how)
+		lsock.shutdown(how)
+	end
+
+	#
+	# Closes both sides of the stream abstraction.
+	#
+	def close
+		cleanup_abstraction
+	end
+
+	#
+	# Symbolic peer information.
+	#
+	def peerinfo
+		"Remote-side of Pipe"
+	end
+
+	#
+	# Symbolic local information.
+	#
+	def localinfo
+		"Local-side of Pipe"
+	end
+
+	#
+	# The left side of the stream.
+	#
+	attr_reader :lsock
+	#
+	# The right side of the stream.
+	#
+	attr_reader :rsock
+
+protected
+
+	def monitor_rsock
+		self.monitor_thread = ::Thread.new {
+			loop do
+				closed = false
+				buf    = nil
+
+				begin
+					s = Rex::ThreadSafe.select( [ self.rsock ], nil, nil, 0.2 )
+					if( s == nil || s[0] == nil )
+						next
+					end
+				rescue Exception => e
+					closed = true
+				end
+
+				if( closed == false )
+					begin
+						buf = self.rsock.sysread( 32768 )
+						closed = true if( buf == nil )
+					rescue
+						closed = true
+					end
+				end
+
+				if( closed == false )
+					total_sent   = 0
+					total_length = buf.length
+					while( total_sent < total_length )
+						begin
+							data = buf[0, buf.length]
+							sent = self.write( data )
+							# sf: Only remove the data off the queue is syswrite was successfull.
+							#     This way we naturally perform a resend if a failure occured.
+							#     Catches an edge case with meterpreter TCP channels where remote send
+							#     failes gracefully and a resend is required.
+							if( sent > 0 )
+								total_sent += sent
+								buf[0, sent] = ""
+							end
+						rescue ::IOError => e
+							closed = true
+							break
+						end
+					end
+				end
+
+				if( closed )
+					self.close_write
+					::Thread.exit
+				end
+			end
+		}
+	end
+
+protected
+	attr_accessor :monitor_thread
+	attr_writer :lsock
+	attr_writer :rsock
+
+end
+
+end; end
+

data/lib/rex/io/stream_server.rb

@@ -0,0 +1,211 @@
+module Rex
+module IO
+
+###
+#
+# This mixin provides the framework and interface for implementing a streaming
+# server that can listen for and accept stream client connections.  Stream
+# servers extend this class and are required to implement the following
+# methods:
+#
+#   accept
+#   fd
+#
+###
+module StreamServer
+
+	##
+	#
+	# Abstract methods
+	#
+	##
+
+	##
+	#
+	# Default server monitoring and client management implementation follows
+	# below.
+	#
+	##
+
+	#
+	# This callback is notified when a client connects.
+	#
+	def on_client_connect(client)
+		if (on_client_connect_proc)
+			on_client_connect_proc.call(client)
+		end
+	end
+
+	#
+	# This callback is notified when a client connection has data that needs to
+	# be processed.
+	#
+	def on_client_data(client)
+		if (on_client_data_proc)
+			on_client_data_proc.call(client)
+		end
+	end
+
+	#
+	# This callback is notified when a client connection has closed.
+	#
+	def on_client_close(client)
+		if (on_client_close_proc)
+			on_client_close_proc.call(client)
+		end
+	end
+
+	#
+	# Start monitoring the listener socket for connections and keep track of
+	# all client connections.
+	#
+	def start
+		self.clients = []
+
+		self.listener_thread = Thread.new {
+			monitor_listener
+		}
+		self.clients_thread = Thread.new {
+			monitor_clients
+		}
+	end
+
+	#
+	# Terminates the listener monitoring threads and closes all active clients.
+	#
+	def stop
+		self.listener_thread.kill
+		self.clients_thread.kill
+
+		self.clients.each { |cli|
+			close_client(cli)
+		}
+	end
+
+	#
+	# This method closes a client connection and cleans up the resources
+	# associated with it.
+	#
+	def close_client(client)
+		if (client)
+			clients.delete(client)
+
+			begin
+				client.close
+			rescue IOError
+			end
+		end
+	end
+
+	#
+	# This method waits on the server listener thread
+	#
+	def wait
+		self.listener_thread.join if self.listener_thread
+	end
+
+	##
+	#
+	# Callback procedures.
+	#
+	##
+
+	#
+	# This callback procedure can be set and will be called when new clients
+	# connect.
+	#
+	attr_accessor :on_client_connect_proc
+	#
+	# This callback procedure can be set and will be called when clients
+	# have data to be processed.
+	#
+	attr_accessor :on_client_data_proc
+	#
+	# This callback procedure can be set and will be called when a client
+	# disconnects from the server.
+	#
+	attr_accessor :on_client_close_proc
+
+	attr_accessor :clients # :nodoc:
+	attr_accessor :listener_thread, :clients_thread # :nodoc:
+
+protected
+
+	#
+	# This method monitors the listener socket for new connections and calls
+	# the +on_client_connect+ callback routine.
+	#
+	def monitor_listener
+
+		while true
+			begin
+				cli = accept
+				if not cli
+					elog("The accept() returned nil in stream server listener monitor:  #{fd.inspect}")
+					::Kernel.select(nil, nil, nil, 0.10)
+					next
+				end
+
+				# Append to the list of clients
+				self.clients << cli
+
+				# Initialize the connection processing
+				on_client_connect(cli)
+
+			# Skip exceptions caused by accept() [ SSL ]
+			rescue ::EOFError, ::Errno::ECONNRESET, ::Errno::ENOTCONN, ::Errno::ECONNABORTED
+			rescue ::Interrupt
+				raise $!
+			rescue ::Exception
+				elog("Error in stream server server monitor: #{$!}")
+				rlog(ExceptionCallStack)
+				break
+			end
+		end
+	end
+
+	#
+	# This method monitors client connections for data and calls the
+	# +on_client_data+ routine when new data arrives.
+	#
+	def monitor_clients
+		begin
+			if (clients.length == 0)
+				Rex::ThreadSafe::sleep(0.25)
+				next
+			end
+
+			sd = Rex::ThreadSafe.select(clients)
+
+			sd[0].each { |cfd|
+				begin
+					on_client_data(cfd)
+				rescue ::EOFError, ::Errno::ECONNRESET, ::Errno::ENOTCONN, ::Errno::ECONNABORTED
+					on_client_close(cfd)
+					close_client(cfd)
+				rescue ::Interrupt
+					raise $!
+				rescue ::Exception
+					close_client(cfd)
+					elog("Error in stream server client monitor: #{$!}")
+					rlog(ExceptionCallStack)
+
+				end
+			}
+
+		rescue ::Rex::StreamClosedError => e
+			# Remove the closed stream from the list
+			clients.delete(e.stream)
+		rescue ::Interrupt
+			raise $!
+		rescue ::Exception
+			elog("Error in stream server client monitor: #{$!}")
+			rlog(ExceptionCallStack)
+		end while true
+	end
+
+end
+
+end
+end
+

data/lib/rex/job_container.rb

@@ -0,0 +1,202 @@
+module Rex
+
+###
+#
+# This class is the concrete representation of an abstract job.
+#
+###
+class Job
+
+	#
+	# Creates an individual job instance and initializes it with the supplied
+	# parameters.
+	#
+	def initialize(container, jid, name, ctx, run_proc, clean_proc)
+		self.container  = container
+		self.jid        = jid
+		self.name       = name
+		self.run_proc   = run_proc
+		self.clean_proc = clean_proc
+		self.ctx        = ctx
+		self.start_time = nil
+	end
+
+	#
+	# Runs the job in the context of its own thread if the async flag is false.
+	# Otherwise, the job is run inline.
+	#
+	def start(async = false)
+		self.start_time = Time.now
+		if (async)
+			self.job_thread = Thread.new {
+				# Deschedule our thread momentarily
+				select(nil, nil, nil, 0.01)
+				
+				begin
+					run_proc.call(ctx)
+				ensure
+					clean_proc.call(ctx)
+					container.remove_job(self)
+				end
+			}
+		else
+			begin
+				run_proc.call(ctx)
+			rescue ::Exception
+				container.stop_job(jid)
+				raise $!
+			end
+		end
+	end
+
+	#
+	# Stops the job if it's currently running and calls its cleanup procedure
+	#
+	def stop
+		if (self.job_thread)
+			self.job_thread.kill
+			self.job_thread = nil
+		end
+			
+		clean_proc.call(ctx) if (clean_proc)
+	end
+
+	#
+	# Surfaces the setings from the job to determine the current settings
+	#
+	def info
+		ret = {}
+		con = nil
+		ret['jid'] = self.jid
+		ret['name'] = self.name
+		if(self.ctx.class == Array)
+			con  = self.ctx[0]
+			
+		else
+			con = self.ctx
+		end
+		ret['datastore'] = con.datastore
+		if(con.kind_of? Msf::Exploit::Remote::HttpServer)
+			
+			ret['datastore']['URIPATH'] = con.get_resource()
+		end
+		ret
+	end
+
+	#
+	# The name of the job.
+	#
+	attr_reader :name
+	#
+	# The job identifier as assigned by the job container.
+	#
+	attr_reader :jid
+
+	# 
+	# The time at which this job was started
+	#
+	attr_reader   :start_time #:nodoc:
+
+protected
+
+	attr_writer   :name #:nodoc:
+	attr_writer   :jid #:nodoc:
+	attr_accessor :job_thread #:nodoc:
+	attr_accessor :container #:nodoc:
+	attr_accessor :run_proc #:nodoc:
+	attr_accessor :clean_proc #:nodoc:
+	attr_accessor :ctx #:nodoc:
+	attr_writer   :start_time #:nodoc:
+
+end
+
+###
+#
+# This class contains zero or more abstract jobs that can be enumerated and
+# stopped in a generic fashion.  This is used to provide a mechanism for
+# keeping track of arbitrary contexts that may or may not require a dedicated
+# thread.
+#
+###
+class JobContainer < Hash
+
+	def initialize
+		self.job_id_pool = 0
+	end
+
+	#
+	# Adds an already running task as a symbolic job to the container.
+	#
+	def add_job(name, ctx, run_proc, clean_proc)
+		real_name = name
+		count     = 0
+		jid       = job_id_pool
+
+		self.job_id_pool += 1
+
+		# If we were not supplied with a job name, pick one from the hat
+		if (real_name == nil)
+			real_name = '#' + jid.to_s
+		end
+
+		# Find a unique job name
+		while (j = self[real_name])
+			real_name  = name + " #{count}"
+			count     += 1
+		end
+
+		j = Job.new(self, jid, real_name, ctx, run_proc, clean_proc)
+
+		self[jid.to_s] = j
+	end
+
+	#
+	# Starts a job using the supplied name and run/clean procedures.
+	#
+	def start_job(name, ctx, run_proc, clean_proc = nil)
+		j = add_job(name, ctx, run_proc, clean_proc)
+		j.start
+
+		j.jid
+	end
+
+	#
+	# Starts a background job that doesn't call the cleanup routine or run
+	# the run_proc in its own thread.  Rather, the run_proc is called
+	# immediately and the clean_proc is never called until the job is removed
+	# from the job container.
+	#
+	def start_bg_job(name, ctx, run_proc, clean_proc = nil, async = true)
+		j = add_job(name, ctx, run_proc, clean_proc)
+		j.start(async)
+
+		j.jid
+	end
+
+	#
+	# Stops the job with the supplied name and forces it to cleanup.  Stopping
+	# the job also leads to its removal.
+	#
+	def stop_job(jid)
+		if (j = self[jid.to_s])
+			j.stop
+
+			remove_job(j)
+		end
+	end
+
+	#
+	# Removes a job that was previously running.  This is typically called when
+	# a job completes its task.
+	#
+	def remove_job(inst)
+		self.delete(inst.jid.to_s)
+	end
+
+protected
+
+	attr_accessor :job_id_pool # :nodoc:
+
+end
+
+end