Module: Msf::Handler::BindSctp

Includes:
Msf::Handler
Defined in:
lib/msf/core/handler/bind_sctp.rb

Overview

This module implements the Bind SCTP handler. This means that it will attempt to connect to a remote host on a given port for a period of time (typically the duration of an exploit) to see if a the payload has started listening. This can tend to be rather verbose in terms of traffic and in general it is preferable to use reverse payloads.

Constant Summary

Constants included from Msf::Handler

Claimed, Unused

Instance Attribute Summary collapse

Attributes included from Msf::Handler

#exploit_config, #parent_payload, #pending_connections, #session_waiter_event, #sessions

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Msf::Handler

#create_session, #handle_connection, #handler, #handler_name, #interrupt_wait_for_session, #register_session, #setup_handler, #wait_for_session, #wfs_delay

Instance Attribute Details

#conn_threads ⇒ Object (protected)

:nodoc:



193
194
195
 
# File 'lib/msf/core/handler/bind_sctp.rb', line 193

def conn_threads
  @conn_threads
end

#listener_pairs ⇒ Object (protected)

:nodoc:



195
196
197
 
# File 'lib/msf/core/handler/bind_sctp.rb', line 195

def listener_pairs
  @listener_pairs
end

#listener_threads ⇒ Object (protected)

:nodoc:



194
195
196
 
# File 'lib/msf/core/handler/bind_sctp.rb', line 194

def listener_threads
  @listener_threads
end

Class Method Details

.general_handler_type ⇒ Object

Returns the connection oriented general handler type, in this case bind.



29
30
31
 
# File 'lib/msf/core/handler/bind_sctp.rb', line 29

def self.general_handler_type
  "bind"
end

.handler_type ⇒ Object

Returns the handler specific string representation, in this case ‘bind_sctp’.



22
23
24
 
# File 'lib/msf/core/handler/bind_sctp.rb', line 22

def self.handler_type
  return "bind_sctp"
end

Instance Method Details

#add_handler(opts = {}) ⇒ Object

Starts a new connecting thread



75
76
77
78
79
80
81
82
83
84
 
# File 'lib/msf/core/handler/bind_sctp.rb', line 75

def add_handler(opts={})

  # Merge the updated datastore values
  opts.each_pair do |k,v|
    datastore[k] = v
  end

  # Start a new handler
  start_handler
end

#cleanup_handler ⇒ Object

Kills off the connection threads if there are any hanging around.



64
65
66
67
68
69
70
 
# File 'lib/msf/core/handler/bind_sctp.rb', line 64

def cleanup_handler
  # Kill any remaining handle_connection threads that might
  # be hanging around
  conn_threads.each { |thr|
    thr.kill
  }
end

#human_name ⇒ String

A string suitable for displaying to the user

Returns:

  • (String) 


36
37
38
 
# File 'lib/msf/core/handler/bind_sctp.rb', line 36

def human_name
  "bind SCTP"
end

#initialize(info = {}) ⇒ Object

Initializes a bind handler and adds the options common to all bind payloads, such as local port.



44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/msf/core/handler/bind_sctp.rb', line 44

def initialize(info = {})
  super

  register_options(
    [
      Opt::LPORT(4444),
      OptAddress.new('RHOST', [false, 'The target address', '']),
      Opt::Proxies,
      Opt::CPORT,
      Opt::CHOST,
    ], Msf::Handler::BindSctp)

  self.conn_threads = []
  self.listener_threads = []
  self.listener_pairs = {}
end

#start_handler ⇒ Object

Starts monitoring for an outbound connection to become established.



89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
 
# File 'lib/msf/core/handler/bind_sctp.rb', line 89

def start_handler

  # Maximum number of seconds to run the handler
  ctimeout = 150

  if (exploit_config and exploit_config['active_timeout'])
    ctimeout = exploit_config['active_timeout'].to_i
  end

  # Take a copy of the datastore options
  rhost = datastore['RHOST']
  lport = datastore['LPORT']

  # Ignore this if one of the required options is missing
  return if not rhost
  return if not lport

  # Only try the same host/port combination once
  phash = rhost + ':' + lport.to_s
  return if self.listener_pairs[phash]
  self.listener_pairs[phash] = true

  # Start a new handling thread
  self.listener_threads << framework.threads.spawn("BindSctpHandlerListener-#{lport}", false) {
    client = nil

    print_status("Started #{human_name} handler against #{rhost}:#{lport}")

    if (rhost == nil)
      raise ArgumentError,
        "RHOST is not defined; bind stager cannot function.",
        caller
    end

    stime = Time.now.to_i

    while (stime + ctimeout > Time.now.to_i)
      begin
        client = Rex::Socket::Sctp.create(
          'PeerHost' => rhost,
          'PeerPort' => lport.to_i,
          'Proxies'  => datastore['Proxies'],
          'Context'  =>
            {
              'Msf'        => framework,
              'MsfPayload' => self,
              'MsfExploit' => assoc_exploit
            })
      rescue Rex::ConnectionError => e
        vprint_error(e.message)
      rescue
        wlog("Exception caught in bind handler: #{$!.class} #{$!}")
      end

      break if client

      # Wait a second before trying again
      Rex::ThreadSafe.sleep(0.5)
    end

    # Valid client connection?
    if (client)
      # Increment the has connection counter
      self.pending_connections += 1

      # Timeout and datastore options need to be passed through to the client
      opts = {
        :datastore    => datastore,
        :expiration   => datastore['SessionExpirationTimeout'].to_i,
        :comm_timeout => datastore['SessionCommunicationTimeout'].to_i,
        :retry_total  => datastore['SessionRetryTotal'].to_i,
        :retry_wait   => datastore['SessionRetryWait'].to_i
      }

      # Start a new thread and pass the client connection
      # as the input and output pipe.  Client's are expected
      # to implement the Stream interface.
      conn_threads << framework.threads.spawn("BindSctpHandlerSession", false, client) { |client_copy|
        begin
          handle_connection(client_copy, opts)
        rescue => e
          elog('Exception raised from BindSctp.handle_connection', error: e)
        end
      }
    else
      wlog("No connection received before the handler completed")
    end
  }
end

#stop_handler ⇒ Object

Nothing to speak of.



182
183
184
185
186
187
188
189
 
# File 'lib/msf/core/handler/bind_sctp.rb', line 182

def stop_handler
  # Stop the listener threads
  self.listener_threads.each do |t|
    t.kill
  end
  self.listener_threads = []
  self.listener_pairs = {}
end