librex 0.0.20 → 0.0.21

data/lib/rex/io/stream.rb

@@ -0,0 +1,319 @@
+require 'rex/sync/thread_safe'
+
+module Rex
+module IO
+
+###
+#
+# This mixin is an abstract representation of a streaming connection.  Streams
+# extend classes that must implement the following methods:
+#
+#   syswrite(buffer)
+#   sysread(length)
+#   shutdown(how)
+#   close
+#   peerinfo
+#   localinfo
+#
+###
+module Stream
+
+	##
+	#
+	# Abstract methods
+	#
+	##
+
+	#
+	# This method writes the supplied buffer to the stream.  This method
+	# intelligent reduces the size of supplied buffers so that ruby doesn't get
+	# into a potential global thread blocking state when used on blocking
+	# sockets.  That is, this method will send the supplied buffer in chunks
+	# of, at most, 32768 bytes.
+	#
+	def write(buf, opts = {})
+		total_sent   = 0
+		total_length = buf.length
+		block_size   = 32768
+		begin
+			while( total_sent < total_length )
+				s = Rex::ThreadSafe.select( nil, [ fd ], nil, 0.2 )
+				if( s == nil || s[0] == nil )
+					next
+				end
+				data = buf[0, block_size]
+				sent = fd.write_nonblock( data )
+				if sent > 0
+					total_sent += sent
+					buf[0, sent] = ""
+				end
+			end
+		rescue ::Errno::EAGAIN
+			# Sleep for a half a second, or until we can write again
+			Rex::ThreadSafe.select( nil, [ fd ], nil, 0.5 )
+			# Decrement the block size to handle full sendQs better
+			block_size = 1024
+			# Try to write the data again
+			retry
+		rescue ::IOError, ::Errno::EPIPE
+			return nil if (fd.abortive_close == true)
+			raise $!
+		end
+		total_sent
+	end
+
+	#
+	# This method reads data of the supplied length from the stream.
+	#
+	def read(length = nil, opts = {})
+		# XXX handle length being nil
+		begin
+			fd.readpartial(length)
+		rescue ::IOError, ::EOFError, ::Errno::EPIPE
+			return nil if (fd.abortive_close == true)
+			raise $!
+		end
+	end
+
+	#
+	# Polls the stream to see if there is any read data available.  Returns
+	# true if data is available for reading, otherwise false is returned.
+	#
+	def has_read_data?(timeout = nil)
+
+		# Allow a timeout of "0" that waits almost indefinitely for input, this
+		# mimics the behavior of Rex::ThreadSafe.select() and fixes some corner
+		# cases of unintentional no-wait timeouts.
+		timeout = 3600 if (timeout and timeout == 0)
+
+		begin
+			if ((rv = ::IO.select([ fd ], nil, nil, timeout)) and
+			    (rv[0]) and
+			    (rv[0][0] == fd))
+				true
+			else
+				false
+			end
+		rescue ::Errno::EBADF, ::Errno::ENOTSOCK
+			raise ::EOFError
+		rescue StreamClosedError, ::IOError, ::EOFError, ::Errno::EPIPE
+			# If the thing that lead to the closure was an abortive close, then
+			# don't raise the stream closed error.
+			return false if (fd.abortive_close == true)
+
+			raise $!
+		end
+	end
+
+	#
+	# This method returns the selectable file descriptor, or self by default.
+	#
+	def fd
+		self
+	end
+
+	##
+	#
+	# Common methods
+	#
+	##
+
+	#
+	# This method writes the supplied buffer to the stream by calling the write
+	# routine.
+	#
+	def <<(buf)
+		return write(buf.to_s)
+	end
+
+	#
+	# This method calls get_once() to read pending data from the socket
+	#
+	def >>
+		get_once
+	end
+
+	#
+	# This method writes to the stream, optionally timing out after a period of
+	# time.
+	#
+	def timed_write(buf, wait = def_write_timeout, opts = {})
+		if (wait and wait > 0)
+			Timeout.timeout(wait) {
+				return write(buf, opts)
+			}
+		else
+			return write(buf, opts)
+		end
+	end
+
+	#
+	# This method reads from the stream, optionally timing out after a period
+	# of time.
+	#
+	def timed_read(length = nil, wait = def_read_timeout, opts = {})
+		if (wait and wait > 0)
+			Timeout.timeout(wait) {
+				return read(length, opts)
+			}
+		else
+			return read(length, opts)
+		end
+	end
+
+	#
+	# This method writes the full contents of the supplied buffer, optionally
+	# with a timeout.
+	#
+	def put(buf, opts = {})
+		return 0 if (buf == nil or buf.length == 0)
+
+		send_len = buf.length
+		send_idx = 0
+		wait     = opts['Timeout'] || 0
+
+		# Keep writing until our send length drops to zero
+		while (send_idx < send_len)
+			curr_len  = timed_write(buf[send_idx, buf.length-send_idx], wait, opts)
+
+			# If the write operation failed due to an IOError, then we fail.
+			return buf.length - send_len if (curr_len == nil)
+
+			send_len -= curr_len
+			send_idx += curr_len
+		end
+
+		return buf.length - send_len
+	end
+
+
+	#
+	# This method emulates the behavior of Pex::Socket::Recv in MSF2
+	#
+	def get_once(length = -1, timeout = def_read_timeout)
+
+		if (has_read_data?(timeout) == false)
+			return nil
+		end
+
+		bsize = (length == -1) ? def_block_size : length
+
+		begin
+			return read(bsize)
+		rescue Exception
+		end
+
+		return ''
+	end
+
+	#
+	# This method reads as much data as it can from the wire given a maximum
+	# timeout.
+	#
+	def get(timeout = nil, ltimeout = def_read_loop_timeout, opts = {})
+		# For those people who are used to being able to use a negative timeout!
+		if (timeout and timeout.to_i < 0)
+			timeout = nil
+		end
+
+		# No data in the first place? bust.
+		if (has_read_data?(timeout) == false)
+			return nil
+		end
+
+		buf = ""
+		lps = 0
+		eof = false
+
+		# Keep looping until there is no more data to be gotten..
+		while (has_read_data?(ltimeout) == true)
+			# Catch EOF errors so that we can handle them properly.
+			begin
+				temp = read(def_block_size)
+			rescue EOFError
+				eof = true
+			end
+
+			# If we read zero bytes and we had data, then we've hit EOF
+			if (temp and temp.length == 0)
+				eof = true
+			end
+
+			# If we reached EOF and there are no bytes in the buffer we've been
+			# reading into, then throw an EOF error.
+			if (eof)
+				# If we've already read at least some data, then it's time to
+				# break out and let it be processed before throwing an EOFError.
+				if (buf.length > 0)
+					break
+				else
+					raise EOFError
+				end
+			end
+
+			break if (temp == nil or temp.empty? == true)
+
+			buf += temp
+			lps += 1
+
+			break if (lps >= def_max_loops)
+		end
+
+		# Return the entire buffer we read in
+		return buf
+	end
+
+	##
+	#
+	# Defaults
+	#
+	##
+
+	#
+	# The default number of seconds to wait for a write operation to timeout.
+	#
+	def def_write_timeout
+		10
+	end
+
+	#
+	# The default number of seconds to wait for a read operation to timeout.
+	#
+	def def_read_timeout
+		10
+	end
+
+	#
+	# The default number of seconds to wait while in a read loop after read
+	# data has been found.
+	#
+	def def_read_loop_timeout
+		0.1
+	end
+
+	#
+	# The maximum number of read loops to perform before returning to the
+	# caller.
+	#
+	def def_max_loops
+		1024
+	end
+
+	#
+	# The default block size to read in chunks from the wire.
+	#
+	def def_block_size
+		16384
+	end
+
+	#
+	# This flag indicates whether or not an abortive close has been issued.
+	#
+	attr_accessor :abortive_close
+
+protected
+
+end
+
+end end
+

data/lib/rex/io/stream_abstraction.rb

@@ -0,0 +1,197 @@
+#!/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 = Rex::ThreadFactory.spawn("StreamMonitorRemote", false) {
+			loop do
+				closed = false
+				buf    = nil
+
+				if not self.rsock
+					wlog("monitor_rsock: the remote socket is nil, exiting loop")
+					break
+				end
+
+				begin
+					s = Rex::ThreadSafe.select( [ self.rsock ], nil, nil, 0.2 )
+					if( s == nil || s[0] == nil )
+						next
+					end
+				rescue Exception => e
+					wlog("monitor_rsock: exception during select: #{e.class} #{e}")
+					closed = true
+				end
+
+				if( closed == false )
+					begin
+						buf = self.rsock.sysread( 32768 )
+						if buf == nil
+							closed = true
+							wlog("monitor_rsock: closed remote socket due to nil read")
+						end
+
+					rescue ::Exception
+						closed = true
+						wlog("monitor_rsock: exception during read: #{e.class} #{e}")						
+					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
+							wlog("monitor_rsock: exception during write: #{e.class} #{e}")
+							break
+						end
+					end
+				end
+
+				if( closed )
+					self.close_write if self.respond_to?('close_write')
+					break
+				end
+			end
+		}
+	end
+
+protected
+	attr_accessor :monitor_thread
+	attr_writer :lsock
+	attr_writer :rsock
+
+end
+
+end; end
+