Class: Rex::Proto::Proxy::Socks4a::Client

Inherits:

Object

• Object
• Rex::Proto::Proxy::Socks4a::Client

Defined in:

lib/rex/proto/proxy/socks4a.rb

Overview

A client connected to the Socks4a server.

Defined Under Namespace

Modules: Relay Classes: Packet

Constant Summary

REQUEST_VERSION =

4

REPLY_VERSION =

0

COMMAND_CONNECT =

1

COMMAND_BIND =

2

REQUEST_GRANTED =

90

REQUEST_REJECT_FAILED =

91

REQUEST_REJECT_CONNECT =

92

REQUEST_REJECT_USERID =

93

HOST =

1

PORT =

2

Instance Method Summary

• #initialize(server, sock) ⇒ Client constructor

  Create a new client connected to the server.

• #start ⇒ Object

  Start handling the client connection.

• #stop ⇒ Object

  Stop handling the client connection.

Constructor Details

#initialize(server, sock) ⇒ Client

Create a new client connected to the server.

# File 'lib/rex/proto/proxy/socks4a.rb', line 223

def initialize( server, sock )
  @server        = server
  @lsock         = sock
  @rsock         = nil
  @client_thread = nil
  @mutex         = ::Mutex.new
end

Instance Method Details

#start ⇒ Object

Start handling the client connection.

# File 'lib/rex/proto/proxy/socks4a.rb', line 234

def start
  # create a thread to handle this client request so as to not block the socks4a server
  @client_thread = Rex::ThreadFactory.spawn("SOCKS4AProxyClient", false) do
    begin
      @server.add_client( self )
      # get the initial client request packet
      request = Packet.recv( @lsock )
      raise "Invalid Socks4 request packet received." if not request
      # handle the request
      begin
        # handle socks4a conenct requests
        if( request.is_connect? )
          # perform the connection request
          params = {
            'PeerHost' => request.dest_ip,
            'PeerPort' => request.dest_port,
          }
          params['Context'] = @server.opts['Context'] if @server.opts.has_key?('Context')

          @rsock = Rex::Socket::Tcp.create( params )
          # and send back success to the client
          response         = Packet.new
          response.version = REPLY_VERSION
          response.command = REQUEST_GRANTED
          @lsock.put( response.to_r )
        # handle socks4a bind requests
        elsif( request.is_bind? )
          # create a server socket for this request
          params = {
            'LocalHost' => '0.0.0.0',
            'LocalPort' => 0,
          }
          params['Context'] = @server.opts['Context'] if @server.opts.has_key?('Context')
          bsock = Rex::Socket::TcpServer.create( params )
          # send back the bind success to the client
          response           = Packet.new
          response.version   = REPLY_VERSION
          response.command   = REQUEST_GRANTED
          response.dest_ip   = '0.0.0.0'
          response.dest_port = bsock.getlocalname()[PORT]
          @lsock.put( response.to_r )
          # accept a client connection (2 minute timeout as per spec)
          begin
            ::Timeout.timeout( 120 ) do
              @rsock = bsock.accept
            end
          rescue ::Timeout::Error
            raise "Timeout reached on accept request."
          end
          # close the listening socket
          bsock.close
          # verify the connection is from the dest_ip origionally specified by the client
          rpeer = @rsock.getpeername
          raise "Got connection from an invalid peer." if( rpeer[HOST] != request.dest_ip )
          # send back the client connect success to the client
          #
          # sf: according to the spec we send this response back to the client, however
          #     I have seen some clients who bawk if they get this second response.
          #
          response           = Packet.new
          response.version   = REPLY_VERSION
          response.command   = REQUEST_GRANTED
          response.dest_ip   = rpeer[HOST]
          response.dest_port = rpeer[PORT]
          @lsock.put( response.to_r )
        else
          raise "Unknown request command received #{request.command} received."
        end
      rescue
        # send back failure to the client
        response         = Packet.new
        response.version = REPLY_VERSION
        response.command = REQUEST_REJECT_FAILED
        @lsock.put( response.to_r )
        # raise an exception to close this client connection
        raise "Failed to handle the clients request."
      end
      # setup the two way relay for full duplex io
      @lsock.extend( Relay )
      @rsock.extend( Relay )
      # start the socket relays...
      @lsock.relay( self, @rsock )
      @rsock.relay( self, @lsock )
    rescue
      wlog( "Client.start - #{$!}" )
      self.stop
    end
  end
end

#stop ⇒ Object

Stop handling the client connection.

# File 'lib/rex/proto/proxy/socks4a.rb', line 327

def stop
  @mutex.synchronize do
    if( not @closed )

      begin
        @lsock.close if @lsock
      rescue
      end

      begin
        @rsock.close if @rsock
      rescue
      end

      @client_thread.kill if( @client_thread and @client_thread.alive? )

      @server.remove_client( self )

      @closed = true
    end
  end
end