Module: Msf::Handler

This module acts as a base for all handler pseudo-modules. They aren‘t really modules, so don‘t get the wrong idea champs! They‘re merely mixed into dynamically generated payloads to handle monitoring for a connection. Handlers are layered in between the base payload class and any other payload class. A super cool ASCII diagram would look something like this

     Module
       ^
       |
    Payload
       ^
       |
    Handler
       ^
       |
     Stager
       ^
       |
      Stage

Methods

add_handler cleanup_handler create_session general_handler_type handle_connection handler handler_name handler_type new register_session setup_handler start_handler stop_handler wait_for_session wfs_delay

Classes and Modules

Module Msf::Handler::BindTcp
Module Msf::Handler::FindPort
Module Msf::Handler::FindShell
Module Msf::Handler::FindTag
Module Msf::Handler::None
Module Msf::Handler::PassiveX
Module Msf::Handler::ReverseTcp
Module Msf::Handler::ReverseTcpDouble

Constants

Claimed	=	"claimed"		Returned by handlers to indicate that a socket has been claimed for use by the payload.
Unused	=	"unused"		Returned by handlers to indicate that a socket has not been claimed for use.

Attributes

exploit_config	[RW]	Set by the exploit module to configure handler
parent_payload	[RW]	This will be non-nil if the handler has a parent payload that it was spawned from. Right now, this is only the case with generic payloads. The parent payload is used to create a session rather than using the instance itself.

Public Class methods

general_handler_type()

Returns the transport-independent handler type.

handler_type()

Returns the handler type.

new(info = {})

Initializes the session waiter event and other fun stuff.

Public Instance methods

add_handler(opts={})

Start another connection monitor

cleanup_handler()

Terminates the connection handler.

handle_connection(conn)

Handles an established connection supplied in the in and out handles. The handles are passed as parameters in case this handler is capable of handling multiple simultaneous connections. The default behavior is to attempt to create a session for the payload. This path will not be taken for mutli-staged payloads.

handler(sock)

Checks to see if a payload connection has been established on the supplied connection. This is necessary for find-sock style payloads.

handler_name()

Returns the handler‘s name, if any.

setup_handler()

Sets up the connection handler.

start_handler()

Start monitoring for a connection.

stop_handler()

Stop monitoring for a connection.

wait_for_session(t = wfs_delay)

Waits for a session to be created as the result of a handler connection coming in. The return value is a session object instance on success or nil if the timeout expires.

wfs_delay()

The amount of time to wait for a session to come in.

Protected Instance methods

create_session(conn)

Creates a session, if necessary, for the connection that‘s been handled. Sessions are only created if the payload that‘s been mixed in has an associated session.

register_session(session)

Registers a session with the framework and notifies any waiters of the new session.