librex 0.0.68 → 0.0.70

data/lib/rex/io/stream_abstraction.rb

@@ -1,4 +1,3 @@
-#!/usr/bin/env ruby
 # -*- coding: binary -*-
 
 require 'socket'
@@ -15,191 +14,194 @@ module IO
 ###
 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
-
-	#
-	# Low-level write to the local side.
-	#
-	def syswrite(buffer)
-		lsock.syswrite(buffer)
-	end
-	
-	#
-	# Low-level read 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
+  ###
+  #
+  # 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
+
+  #
+  # Low-level write to the local side.
+  #
+  def syswrite(buffer)
+    lsock.syswrite(buffer)
+  end
+
+  #
+  # Low-level read 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 => e
-						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[total_sent, buf.length]
-							
-							# Note that this must be write() NOT syswrite() or put() or anything like it.
-							# Using syswrite() breaks SSL streams.
-							sent = self.write( data )
-
-							# sf: Only remove the data off the queue is write 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.nil?)
-								closed = true
-								wlog("monitor_rsock: failed writing, socket must be dead")
-								break
-							elsif (sent > 0)
-								total_sent += sent
-							end
-						rescue ::IOError, ::EOFError => e
-							closed = true
-							wlog("monitor_rsock: exception during write: #{e.class} #{e}")
-							break
-						end
-					end
-				end
-
-				if( closed )
-					begin
-						self.close_write if self.respond_to?('close_write')
-					rescue IOError
-					end
-					break
-				end
-			end
-		}
-	end
+  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 EOFError => e
+            closed = true
+            dlog("monitor_rsock: EOF in rsock")
+          rescue ::Exception => e
+            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[total_sent, buf.length]
+
+              # Note that this must be write() NOT syswrite() or put() or anything like it.
+              # Using syswrite() breaks SSL streams.
+              sent = self.write( data )
+
+              # sf: Only remove the data off the queue is write 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.nil?)
+                closed = true
+                wlog("monitor_rsock: failed writing, socket must be dead")
+                break
+              elsif (sent > 0)
+                total_sent += sent
+              end
+            rescue ::IOError, ::EOFError => e
+              closed = true
+              wlog("monitor_rsock: exception during write: #{e.class} #{e}")
+              break
+            end
+          end
+        end
+
+        if( closed )
+          begin
+            self.close_write if self.respond_to?('close_write')
+          rescue IOError
+          end
+          break
+        end
+      end
+    }
+  end
 
 protected
-	attr_accessor :monitor_thread
-	attr_writer :lsock
-	attr_writer :rsock
+  attr_accessor :monitor_thread
+  attr_writer :lsock
+  attr_writer :rsock
 
 end
 

data/lib/rex/io/stream_server.rb

@@ -17,202 +17,202 @@ module IO
 ###
 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.client_waiter = ::Queue.new
-
-		self.listener_thread = Rex::ThreadFactory.spawn("StreamServerListener", false) {
-			monitor_listener
-		}
-		self.clients_thread = Rex::ThreadFactory.spawn("StreamServerClientMonitor", false) {
-			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:
-	attr_accessor :client_waiter
+  ##
+  #
+  # 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.client_waiter = ::Queue.new
+
+    self.listener_thread = Rex::ThreadFactory.spawn("StreamServerListener", false) {
+      monitor_listener
+    }
+    self.clients_thread = Rex::ThreadFactory.spawn("StreamServerClientMonitor", false) {
+      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:
+  attr_accessor :client_waiter
 
 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}")
-					::IO.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)
-				
-				# Notify the client monitor
-				self.client_waiter.push(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
-		
-			# Wait for a notify if our client list is empty
-			if (clients.length == 0)
-				self.client_waiter.pop
-				next
-			end
-
-			sd = Rex::ThreadSafe.select(clients, nil, nil, nil)
-
-			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
+  #
+  # 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}")
+          ::IO.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)
+
+        # Notify the client monitor
+        self.client_waiter.push(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
+
+      # Wait for a notify if our client list is empty
+      if (clients.length == 0)
+        self.client_waiter.pop
+        next
+      end
+
+      sd = Rex::ThreadSafe.select(clients, nil, nil, nil)
+
+      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