librex 0.0.68 → 0.0.70

data/lib/rex/post/meterpreter/extensions/stdapi/net/socket.rb

@@ -1,4 +1,3 @@
-#!/usr/bin/env ruby
 # -*- coding: binary -*-
 
 require 'thread'
@@ -27,110 +26,112 @@ module Net
 ###
 class Socket
 
-	##
-	#
-	# Constructor
-	#
-	##
-
-	#
-	# Initialize the socket subsystem and start monitoring sockets as they come in.
-	#
-	def initialize(client)
-		self.client = client
-
-		# register the inbound handler for the tcp server channel (allowing us to receive new client connections to a tcp server channel)
-		client.register_inbound_handler( Rex::Post::Meterpreter::Extensions::Stdapi::Net::SocketSubsystem::TcpServerChannel )
-
-	end
-
-	#
-	# Deregister the inbound handler for the tcp server channel
-	#
-	def shutdown
-		client.deregister_inbound_handler(  Rex::Post::Meterpreter::Extensions::Stdapi::Net::SocketSubsystem::TcpServerChannel )
-	end
-
-	##
-	#
-	# Factory
-	#
-	##
-
-	#
-	# Creates an arbitrary client socket channel using the information
-	# supplied in the socket parameters instance.  The 'params' argument
-	# is expected to be of type Rex::Socket::Parameters.
-	#
-	def create( params )
-		res = nil
-
-		if( params.tcp? )
-			if( params.server? )
-				res = create_tcp_server_channel( params )
-			else
-				res = create_tcp_client_channel( params )
-			end
-		elsif( params.udp? )
-			res = create_udp_channel( params )
-		end
-
-		return res
-	end
-
-	#
-	# Create a TCP server channel.
-	#
-	def create_tcp_server_channel(params)
-		begin
-			return SocketSubsystem::TcpServerChannel.open(client, params)
-		rescue ::Rex::Post::Meterpreter::RequestError => e
-			case e.code
-			when 10000 .. 10100
-				raise ::Rex::ConnectionError.new
-			end
-			raise e
-		end
-	end
-
-	#
-	# Creates a TCP client channel.
-	#
-	def create_tcp_client_channel(params)
-		begin
-			channel = SocketSubsystem::TcpClientChannel.open(client, params)
-			if( channel != nil )
-				return channel.lsock
-			end
-			return nil
-		rescue ::Rex::Post::Meterpreter::RequestError => e
-			case e.code
-			when 10000 .. 10100
-				raise ::Rex::ConnectionError.new
-			end
-			raise e
-		end
-	end
-
-	#
-	# Creates a UDP channel.
-	#
-	def create_udp_channel(params)
-		begin
-			return SocketSubsystem::UdpChannel.open(client, params)
-		rescue ::Rex::Post::Meterpreter::RequestError => e
-			case e.code
-				when 10000 .. 10100
-				raise ::Rex::ConnectionError.new
-			end
-			raise e
-		end
-	end
+  ##
+  #
+  # Constructor
+  #
+  ##
+
+  #
+  # Initialize the socket subsystem and start monitoring sockets as they come
+  # in.
+  #
+  def initialize(client)
+    self.client = client
+
+    # register the inbound handler for the tcp server channel (allowing us to
+    # receive new client connections to a tcp server channel)
+    client.register_inbound_handler( Rex::Post::Meterpreter::Extensions::Stdapi::Net::SocketSubsystem::TcpServerChannel )
+
+  end
+
+  #
+  # Deregister the inbound handler for the tcp server channel
+  #
+  def shutdown
+    client.deregister_inbound_handler(  Rex::Post::Meterpreter::Extensions::Stdapi::Net::SocketSubsystem::TcpServerChannel )
+  end
+
+  ##
+  #
+  # Factory
+  #
+  ##
+
+  #
+  # Creates an arbitrary client socket channel using the information supplied
+  # in the socket parameters instance.  The +params+ argument is expected to be
+  # of type Rex::Socket::Parameters.
+  #
+  def create( params )
+    res = nil
+
+    if( params.tcp? )
+      if( params.server? )
+        res = create_tcp_server_channel( params )
+      else
+        res = create_tcp_client_channel( params )
+      end
+    elsif( params.udp? )
+      res = create_udp_channel( params )
+    end
+
+    return res
+  end
+
+  #
+  # Create a TCP server channel.
+  #
+  def create_tcp_server_channel(params)
+    begin
+      return SocketSubsystem::TcpServerChannel.open(client, params)
+    rescue ::Rex::Post::Meterpreter::RequestError => e
+      case e.code
+      when 10000 .. 10100
+        raise ::Rex::ConnectionError.new
+      end
+      raise e
+    end
+  end
+
+  #
+  # Creates a TCP client channel.
+  #
+  def create_tcp_client_channel(params)
+    begin
+      channel = SocketSubsystem::TcpClientChannel.open(client, params)
+      if( channel != nil )
+        return channel.lsock
+      end
+      return nil
+    rescue ::Rex::Post::Meterpreter::RequestError => e
+      case e.code
+      when 10000 .. 10100
+        raise ::Rex::ConnectionError.new
+      end
+      raise e
+    end
+  end
+
+  #
+  # Creates a UDP channel.
+  #
+  def create_udp_channel(params)
+    begin
+      return SocketSubsystem::UdpChannel.open(client, params)
+    rescue ::Rex::Post::Meterpreter::RequestError => e
+      case e.code
+        when 10000 .. 10100
+        raise ::Rex::ConnectionError.new
+      end
+      raise e
+    end
+  end
 
 
 protected
 
-	attr_accessor :client # :nodoc:
+  attr_accessor :client # :nodoc:
 
 end
 

data/lib/rex/post/meterpreter/extensions/stdapi/net/socket_subsystem/tcp_client_channel.rb

@@ -1,4 +1,3 @@
-#!/usr/bin/env ruby
 # -*- coding: binary -*-
 
 require 'thread'
@@ -24,157 +23,157 @@ module SocketSubsystem
 ###
 class TcpClientChannel < Rex::Post::Meterpreter::Stream
 
-	class << self
-		def cls
-			return CHANNEL_CLASS_STREAM
-		end
-	end
-
-	module SocketInterface
-		def type?
-			'tcp'
-		end
-
-		def getsockname
-			return super if not channel
-			# Find the first host in our chain (our address)
-			hops = 0
-			csock = channel.client.sock
-			while(csock.respond_to?('channel'))
-				csock = csock.channel.client.sock
-				hops += 1
-			end
-			tmp,caddr,cport = csock.getsockname
-			tmp,raddr,rport = csock.getpeername
-			maddr,mport = [ channel.params.localhost, channel.params.localport ]
-			[ tmp, "#{caddr}#{(hops > 0) ? "-_#{hops}_" : ""}-#{raddr}", "#{mport}" ]
-		end
-
-		def getpeername
-			return super if not channel
-			tmp,caddr,cport = channel.client.sock.getpeername
-			maddr,mport = [ channel.params.peerhost, channel.params.peerport ]
-			[ tmp, "#{maddr}", "#{mport}" ]
-		end
-
-		attr_accessor :channel
-	end
-
-	#
-	# Simple mixin for lsock in order to help avoid a ruby interpreter issue with ::Socket.pair
-	# Instead of writing to the lsock, reading from the rsock and then writing to the channel,
-	# we use this mixin to directly write to the channel.
-	#
-	# Note: This does not work with OpenSSL as OpenSSL is implemented natively and requires a real
-	# socket to write to and we cant intercept the sockets syswrite at a native level.
-	#
-	# Note: The deadlock only seems to effect the Ruby build for cygwin.
-	#
-	module DirectChannelWrite
-
-		def syswrite( buf )
-			channel._write( buf )
-		end
-
-		attr_accessor :channel
-	end
-
-	##
-	#
-	# Factory
-	#
-	##
-
-	#
-	# Opens a TCP client channel using the supplied parameters.
-	#
-	def TcpClientChannel.open(client, params)
-		c = Channel.create(client, 'stdapi_net_tcp_client', self, CHANNEL_FLAG_SYNCHRONOUS,
-			[
-				{
-					'type'  => TLV_TYPE_PEER_HOST,
-					'value' => params.peerhost
-				},
-				{
-					'type'  => TLV_TYPE_PEER_PORT,
-					'value' => params.peerport
-				},
-				{
-					'type'  => TLV_TYPE_LOCAL_HOST,
-					'value' => params.localhost
-				},
-				{
-					'type'  => TLV_TYPE_LOCAL_PORT,
-					'value' => params.localport
-				},
-				{
-					'type'  => TLV_TYPE_CONNECT_RETRIES,
-					'value' => params.retries
-				}
-			])
-		c.params = params
-		c
-	end
-
-	##
-	#
-	# Constructor
-	#
-	##
-
-	#
-	# Passes the channel initialization information up to the base class.
-	#
-	def initialize( client, cid, type, flags )
-		super( client, cid, type, flags )
-
-		lsock.extend( SocketInterface )
-		lsock.extend( DirectChannelWrite )
-		lsock.channel = self
-
-		rsock.extend( SocketInterface )
-		rsock.channel = self
-
-	end
-
-	#
-	# Closes the write half of the connection.
-	#
-	def close_write
-		return shutdown(1)
-	end
-
-	#
-	# Shutdown the connection
-	#
-	# 0 -> future reads
-	# 1 -> future sends
-	# 2 -> both
-	#
-	def shutdown(how = 1)
-		request = Packet.create_request('stdapi_net_socket_tcp_shutdown')
-
-		request.add_tlv(TLV_TYPE_SHUTDOWN_HOW, how)
-		request.add_tlv(TLV_TYPE_CHANNEL_ID, self.cid)
-
-		response = client.send_request(request)
-
-		return true
-	end
-
-	#
-	# Wrap the _write() call in order to catch some common, but harmless Windows exceptions
-	#
-	def _write(*args)
-		begin
-			super(*args)
-		rescue ::Rex::Post::Meterpreter::RequestError => e
-			case e.code
-			when 10000 .. 10100
-				raise ::Rex::ConnectionError.new
-			end
-		end
-	end
+  class << self
+    def cls
+      return CHANNEL_CLASS_STREAM
+    end
+  end
+
+  module SocketInterface
+    def type?
+      'tcp'
+    end
+
+    def getsockname
+      return super if not channel
+      # Find the first host in our chain (our address)
+      hops = 0
+      csock = channel.client.sock
+      while(csock.respond_to?('channel'))
+        csock = csock.channel.client.sock
+        hops += 1
+      end
+      tmp,caddr,cport = csock.getsockname
+      tmp,raddr,rport = csock.getpeername
+      maddr,mport = [ channel.params.localhost, channel.params.localport ]
+      [ tmp, "#{caddr}#{(hops > 0) ? "-_#{hops}_" : ""}-#{raddr}", "#{mport}" ]
+    end
+
+    def getpeername
+      return super if not channel
+      tmp,caddr,cport = channel.client.sock.getpeername
+      maddr,mport = [ channel.params.peerhost, channel.params.peerport ]
+      [ tmp, "#{maddr}", "#{mport}" ]
+    end
+
+    attr_accessor :channel
+  end
+
+  #
+  # Simple mixin for lsock in order to help avoid a ruby interpreter issue with ::Socket.pair
+  # Instead of writing to the lsock, reading from the rsock and then writing to the channel,
+  # we use this mixin to directly write to the channel.
+  #
+  # Note: This does not work with OpenSSL as OpenSSL is implemented natively and requires a real
+  # socket to write to and we cant intercept the sockets syswrite at a native level.
+  #
+  # Note: The deadlock only seems to effect the Ruby build for cygwin.
+  #
+  module DirectChannelWrite
+
+    def syswrite( buf )
+      channel._write( buf )
+    end
+
+    attr_accessor :channel
+  end
+
+  ##
+  #
+  # Factory
+  #
+  ##
+
+  #
+  # Opens a TCP client channel using the supplied parameters.
+  #
+  def TcpClientChannel.open(client, params)
+    c = Channel.create(client, 'stdapi_net_tcp_client', self, CHANNEL_FLAG_SYNCHRONOUS,
+      [
+        {
+          'type'  => TLV_TYPE_PEER_HOST,
+          'value' => params.peerhost
+        },
+        {
+          'type'  => TLV_TYPE_PEER_PORT,
+          'value' => params.peerport
+        },
+        {
+          'type'  => TLV_TYPE_LOCAL_HOST,
+          'value' => params.localhost
+        },
+        {
+          'type'  => TLV_TYPE_LOCAL_PORT,
+          'value' => params.localport
+        },
+        {
+          'type'  => TLV_TYPE_CONNECT_RETRIES,
+          'value' => params.retries
+        }
+      ])
+    c.params = params
+    c
+  end
+
+  ##
+  #
+  # Constructor
+  #
+  ##
+
+  #
+  # Passes the channel initialization information up to the base class.
+  #
+  def initialize( client, cid, type, flags )
+    super( client, cid, type, flags )
+
+    lsock.extend( SocketInterface )
+    lsock.extend( DirectChannelWrite )
+    lsock.channel = self
+
+    rsock.extend( SocketInterface )
+    rsock.channel = self
+
+  end
+
+  #
+  # Closes the write half of the connection.
+  #
+  def close_write
+    return shutdown(1)
+  end
+
+  #
+  # Shutdown the connection
+  #
+  # 0 -> future reads
+  # 1 -> future sends
+  # 2 -> both
+  #
+  def shutdown(how = 1)
+    request = Packet.create_request('stdapi_net_socket_tcp_shutdown')
+
+    request.add_tlv(TLV_TYPE_SHUTDOWN_HOW, how)
+    request.add_tlv(TLV_TYPE_CHANNEL_ID, self.cid)
+
+    response = client.send_request(request)
+
+    return true
+  end
+
+  #
+  # Wrap the _write() call in order to catch some common, but harmless Windows exceptions
+  #
+  def _write(*args)
+    begin
+      super(*args)
+    rescue ::Rex::Post::Meterpreter::RequestError => e
+      case e.code
+      when 10000 .. 10100
+        raise ::Rex::ConnectionError.new
+      end
+    end
+  end
 end
 
 end; end; end; end; end; end; end