msfrpc-client 1.1.0 → 1.1.1

data/examples/msfrpc_pro_import.rb

@@ -0,0 +1,91 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'optparse'
+require 'msfrpc-client'
+require 'rex/ui'
+
+def usage(ropts)
+  $stderr.puts ropts
+
+  if @rpc and @rpc.token
+    wspaces = @rpc.call("pro.workspaces") rescue {}
+    if wspaces.keys.length > 0
+      $stderr.puts "Active Projects:"
+      wspaces.each_pair do |k,v|
+        $stderr.puts "\t#{k}"
+      end
+    end
+  end
+  exit(1)
+end
+
+opts = {}
+
+# Parse script-specific options
+parser = Msf::RPC::Client.option_parser(opts)
+parser.separator('Task Options:')
+
+parser.on("--path PATH") do |path|
+  opts[:path] = path
+end
+
+parser.on("--project PROJECT") do |project|
+  opts[:project] = project
+end
+
+parser.on("--help") do
+  $stderr.puts parser
+  exit(1)
+end
+parser.separator('')
+
+parser.parse!(ARGV)
+@rpc  = Msf::RPC::Client.new(opts)
+
+if not @rpc.token
+  $stderr.puts "Error: Invalid RPC server options specified"
+  $stderr.puts parser
+  exit(1)
+end
+
+project   = opts[:project]   || usage(parser)
+path     = opts[:path]    || usage(parser)
+user      = @rpc.call("pro.default_admin_user")['username']
+task     = @rpc.call("pro.start_import", {
+      'workspace'    => project,
+      'username'     => user,
+      'DS_PATH'    => path
+})
+
+if not task['task_id']
+  $stderr.puts "[-] Error starting the task: #{task.inspect}"
+  exit(0)
+end
+
+puts "[*] Creating Task ID #{task['task_id']}..."
+while true
+  select(nil, nil, nil, 0.50)
+
+  stat = @rpc.call("pro.task_status", task['task_id'])
+
+  if stat['status'] == 'invalid'
+    $stderr.puts "[-] Error checking task status"
+    exit(0)
+  end
+
+  info = stat[ task['task_id'] ]
+
+  if not info
+    $stderr.puts "[-] Error finding the task"
+    exit(0)
+  end
+
+  if info['status'] == "error"
+    $stderr.puts "[-] Error generating report: #{info['error']}"
+    exit(0)
+  end
+
+  break if info['progress'] == 100
+end
+
+$stdout.puts "[+] Task Complete!"

data/examples/msfrpc_pro_nexpose.rb

@@ -0,0 +1,148 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'optparse'
+require 'msfrpc-client'
+require 'rex/ui'
+
+def usage(ropts)
+  $stderr.puts ropts
+
+  if @rpc and @rpc.token
+    wspaces = @rpc.call("pro.workspaces") rescue {}
+    if wspaces.keys.length > 0
+      $stderr.puts "Active Projects:"
+      wspaces.each_pair do |k,v|
+        $stderr.puts "\t#{k}"
+      end
+    end
+  end
+  $stderr.puts ""
+  exit(1)
+end
+
+opts = {}
+
+# Parse script-specific options
+parser = Msf::RPC::Client.option_parser(opts)
+parser.separator('NeXpose Specific Options:')
+
+parser.on("--project PROJECT") do |x|
+  opts[:project] = x
+end
+
+parser.on("--targets TARGETS") do |x|
+  opts[:targets] = [x]
+end
+
+parser.on("--nexpose-host HOST") do |x|
+  opts[:nexpose_host] = x
+end
+
+parser.on("--nexpose-user USER") do |x|
+  opts[:nexpose_user] = x
+end
+
+parser.on("--nexpose-pass PASSWORD") do |x|
+  opts[:nexpose_pass] = x
+end
+
+parser.on("--nexpose-pass-file PATH") do |x|
+  opts[:nexpose_pass_file] = x
+end
+
+parser.on("--scan-template TEMPLATE (optional)") do |x|
+  opts[:scan_template] = x
+end
+
+parser.on("--nexpose-port PORT (optional)") do |x|
+  opts[:nexpose_port] = x
+end
+
+parser.on("--blacklist BLACKLIST (optional)") do |x|
+  opts[:blacklist] = x
+end
+
+parser.on("--help") do
+  $stderr.puts parser
+  exit(1)
+end
+
+parser.separator('')
+parser.parse!(ARGV)
+
+@rpc  = Msf::RPC::Client.new(opts)
+
+if not @rpc.token
+  $stderr.puts "Error: Invalid RPC server options specified"
+  $stderr.puts parser
+  exit(1)
+end
+
+# Get the password from the file
+if opts[:nexpose_pass_file]
+  nexpose_pass = File.open(opts[:nexpose_pass_file],"r").read.chomp!
+else
+  nexpose_pass = opts[:nexpose_pass] || usage(parser)
+end
+
+# Store the user's settings
+project       = opts[:project]    || usage(parser),
+targets       = opts[:targets]    || usage(parser),
+blacklist      = opts[:blacklist],
+nexpose_host      = opts[:nexpose_host]     || usage(parser),
+nexpose_port      = opts[:nexpose_port]    || "3780",
+nexpose_user      = opts[:nexpose_user]    || "nxadmin"
+scan_template      = opts[:scan_template]    || "pentest-audit"
+
+# Get the default user
+user       = @rpc.call("pro.default_admin_user")['username']
+
+options = {
+        'workspace'      => project,
+        'username'       => user,
+        'DS_WHITELIST_HOSTS'    => targets,
+        'DS_NEXPOSE_HOST'    => nexpose_host,
+        'DS_NEXPOSE_PORT'    => nexpose_port,
+        'DS_NEXPOSE_USER'    => nexpose_user,
+        'nexpose_pass'      => nexpose_pass,
+        'DS_SCAN_TEMPLATE'    => scan_template
+}
+
+puts "DEBUG: Running task with #{options}"
+
+# Create the task object with all options
+task     = @rpc.call("pro.start_exploit", options)
+
+
+if not task['task_id']
+  $stderr.puts "[-] Error starting the task: #{task.inspect}"
+  exit(0)
+end
+
+puts "[*] Creating Task ID #{task['task_id']}..."
+while true
+  select(nil, nil, nil, 0.50)
+
+  stat = @rpc.call("pro.task_status", task['task_id'])
+
+  if stat['status'] == 'invalid'
+    $stderr.puts "[-] Error checking task status"
+    exit(0)
+  end
+
+  info = stat[ task['task_id'] ]
+
+  if not info
+    $stderr.puts "[-] Error finding the task"
+    exit(0)
+  end
+
+  if info['status'] == "error"
+    $stderr.puts "[-] Error generating report: #{info['error']}"
+    exit(0)
+  end
+
+  break if info['progress'] == 100
+end
+
+$stdout.puts "[+] Task Complete!"

data/examples/msfrpc_pro_report.rb

@@ -6,43 +6,43 @@ require 'msfrpc-client'
 require 'rex/ui'
 
 def usage(ropts)
-	$stderr.puts ropts
-
-	if @rpc and @rpc.token
-		wspaces = @rpc.call("pro.workspaces") rescue {}
-		if wspaces.keys.length > 0
-			$stderr.puts "Active Projects:"
-			wspaces.each_pair do |k,v|
-				$stderr.puts "\t#{k}"
-			end
-		end
-	end
-	$stderr.puts ""
-	exit(1)
+  $stderr.puts ropts
+
+  if @rpc and @rpc.token
+    wspaces = @rpc.call("pro.workspaces") rescue {}
+    if wspaces.keys.length > 0
+      $stderr.puts "Active Projects:"
+      wspaces.each_pair do |k,v|
+        $stderr.puts "\t#{k}"
+      end
+    end
+  end
+  $stderr.puts ""
+  exit(1)
 end
 
 opts  = {
-	:format => 'PDF'
+  :format => 'PDF'
 }
 
 parser = Msf::RPC::Client.option_parser(opts)
 
 parser.separator('Report Options:')
 parser.on("--format FORMAT") do |v|
-	opts[:format] = v.upcase
+  opts[:format] = v.upcase
 end
 
 parser.on("--project PROJECT") do |v|
-	opts[:project] = v
+  opts[:project] = v
 end
 
 parser.on("--output OUTFILE") do |v|
-	opts[:output] = v
+  opts[:output] = v
 end
 
 parser.on("--help") do
-	$stderr.puts ropts
-	exit(1)
+  $stderr.puts ropts
+  exit(1)
 end
 parser.separator('')
 
@@ -50,9 +50,9 @@ parser.parse!(ARGV)
 @rpc  = Msf::RPC::Client.new(opts)
 
 if not @rpc.token
-	$stderr.puts "Error: Invalid RPC server options specified"
-	$stderr.puts parser
-	exit(1)
+  $stderr.puts "Error: Invalid RPC server options specified"
+  $stderr.puts parser
+  exit(1)
 end
 
 wspace = opts[:project] || usage(parser)
@@ -61,66 +61,66 @@ rtype  = opts[:format]
 user   = @rpc.call("pro.default_admin_user")['username']
 
 task = @rpc.call("pro.start_report", {
-	'DS_WHITELIST_HOSTS'        => "",
-	'DS_BLACKLIST_HOSTS'        => "",
-	'workspace'                 => wspace,
-	'username'                  => user,
-	'DS_MaskPasswords'          => false,
-	'DS_IncludeTaskLog'         => false,
-	'DS_JasperDisplaySession'   => true,
-	'DS_JasperDisplayCharts'    => true,
-	'DS_LootExcludeScreenshots' => false,
-	'DS_LootExcludePasswords'   => false,
-	'DS_JasperTemplate'         => "msfxv3.jrxml",
-	'DS_REPORT_TYPE'            => rtype.upcase,
-	'DS_UseJasper'              => true,
-	'DS_UseCustomReporting'     => true,
-	'DS_JasperProductName'      => "Metasploit Pro",
-	'DS_JasperDbEnv'            => "production",
-	'DS_JasperLogo'             => '',
-	'DS_JasperDisplaySections'  => "1,2,3,4,5,6,7,8",
-	'DS_EnablePCIReport'        => true,
-	'DS_EnableFISMAReport'      => true,
-	'DS_JasperDisplayWeb'       => true,
+  'DS_WHITELIST_HOSTS'        => "",
+  'DS_BLACKLIST_HOSTS'        => "",
+  'workspace'                 => wspace,
+  'username'                  => user,
+  'DS_MaskPasswords'          => false,
+  'DS_IncludeTaskLog'         => false,
+  'DS_JasperDisplaySession'   => true,
+  'DS_JasperDisplayCharts'    => true,
+  'DS_LootExcludeScreenshots' => false,
+  'DS_LootExcludePasswords'   => false,
+  'DS_JasperTemplate'         => "msfxv3.jrxml",
+  'DS_REPORT_TYPE'            => rtype.upcase,
+  'DS_UseJasper'              => true,
+  'DS_UseCustomReporting'     => true,
+  'DS_JasperProductName'      => "Metasploit Pro",
+  'DS_JasperDbEnv'            => "production",
+  'DS_JasperLogo'             => '',
+  'DS_JasperDisplaySections'  => "1,2,3,4,5,6,7,8",
+  'DS_EnablePCIReport'        => true,
+  'DS_EnableFISMAReport'      => true,
+  'DS_JasperDisplayWeb'       => true,
 })
 
 
 if not task['task_id']
-	$stderr.puts "[-] Error generating the report: #{task.inspect}"
-	exit(0)
+  $stderr.puts "[-] Error generating the report: #{task.inspect}"
+  exit(0)
 end
 
 puts "[*] Report is generating with Task ID #{task['task_id']}..."
 while true
-	select(nil, nil, nil, 0.50)
-	stat = @rpc.call("pro.task_status", task['task_id'])
-	if stat['status'] == 'invalid'
-		$stderr.puts "[-] Error checking task status"
-		exit(0)
-	end
-
-	info = stat[ task['task_id'] ]
-
-	if not info
-		$stderr.puts "[-] Error finding the task"
-		exit(0)
-	end
-
-	if info['status'] == "error"
-		$stderr.puts "[-] Error generating report: #{info['error']}"
-		exit(0)
-	end
-
-	break if info['progress'] == 100
+  select(nil, nil, nil, 0.50)
+  stat = @rpc.call("pro.task_status", task['task_id'])
+  if stat['status'] == 'invalid'
+    $stderr.puts "[-] Error checking task status"
+    exit(0)
+  end
+
+  info = stat[ task['task_id'] ]
+
+  if not info
+    $stderr.puts "[-] Error finding the task"
+    exit(0)
+  end
+
+  if info['status'] == "error"
+    $stderr.puts "[-] Error generating report: #{info['error']}"
+    exit(0)
+  end
+
+  break if info['progress'] == 100
 end
 
 report = @rpc.call('pro.report_download_by_task', task['task_id'])
 if report and report['data']
-	::File.open(fname, "wb") do |fd|
-		fd.write(report['data'])
-	end
-	$stderr.puts "[-] Report saved to #{::File.expand_path(fname)}"
+  ::File.open(fname, "wb") do |fd|
+    fd.write(report['data'])
+  end
+  $stderr.puts "[-] Report saved to #{::File.expand_path(fname)}"
 else
-	$stderr.puts "[-] Error downloading report: #{report.inspect}"
+  $stderr.puts "[-] Error downloading report: #{report.inspect}"
 end
 

data/lib/msfrpc-client/client.rb

@@ -1,8 +1,10 @@
+# -*- coding: binary -*-
+
 # MessagePack for data encoding (http://www.msgpack.org/)
 require 'msgpack'
 
 # Standardize option parsing
-require "optparse"
+require 'optparse'
 
 # Parse configuration file
 require 'yaml'
@@ -15,207 +17,291 @@ require 'rex/proto/http'
 require 'msfrpc-client/constants'
 
 module Msf
-module RPC
-
-class Client
-
-	attr_accessor :token, :info
-
-	#
-	# Create a new RPC Client instance
-	#
-	def initialize(config={})
-
-		self.info = {
-			:host => '127.0.0.1',
-			:port => 3790,
-			:uri  => '/api/' + Msf::RPC::API_VERSION,
-			:ssl  => true,
-			:ssl_version => 'TLS1',
-			:context     => {}
-		}.merge(config)
-
-		# Set the token
-		self.token = self.info[:token]
-
-		if not self.token and (info[:user] and info[:pass])
-			login(info[:user], info[:pass])
-		end
-	end
-
-	#
-	# Authenticate using a username and password
-	#
-	def login(user,pass)
-		res = self.call("auth.login", user, pass)
-		if(not (res and res['result'] == "success"))
-			raise RuntimeError, "authentication failed"
-		end
-		self.token = res['token']
-		true
-	end
-
-	#
-	# Prepend the authentication token as the first parameter
-	# of every call except auth.login. This simplifies the
-	# calling API.
-	#
-	def call(meth, *args)
-		if(meth != "auth.login")
-			if(not self.token)
-				raise RuntimeError, "client not authenticated"
-			end
-			args.unshift(self.token)
-		end
-
-		args.unshift(meth)
-
-		if not @cli
-			@cli = Rex::Proto::Http::Client.new(info[:host], info[:port], info[:context], info[:ssl], info[:ssl_version])
-			@cli.set_config(
-				:vhost => info[:host],
-				:agent => "Metasploit Pro RPC Client/#{API_VERSION}",
-				:read_max_data => (1024*1024*512)
-			)
-		end
-
-		req = @cli.request_cgi(
-			'method' => 'POST',
-			'uri'    => self.info[:uri],
-			'ctype'  => 'binary/message-pack',
-			'data'   => args.to_msgpack
-		)
-
-		res = @cli.send_recv(req)
-
-		if res and [200, 401, 403, 500].include?(res.code)
-			resp = MessagePack.unpack(res.body)
-
-			if resp and resp.kind_of?(::Hash) and resp['error'] == true
-				raise Msf::RPC::ServerException.new(res.code, resp['error_message'] || resp['error_string'], resp['error_class'], resp['error_backtrace'])
-			end
-
-			return resp
-		else
-			raise RuntimeError, res.inspect
-		end
-	end
-
-
-	#
-	# Class methods
-	#
-
-
-	#
-	# Provides a parser object that understands the
-	# RPC specific options
-	#
-	def self.option_parser(options)
-		parser = OptionParser.new
-
-		parser.banner = "Usage: #{$0} [options]"
-		parser.separator('')
-		parser.separator('RPC Options:')
-
-		parser.on("--rpc-host HOST") do |v|
-			options[:host] = v
-		end
-
-		parser.on("--rpc-port PORT") do |v|
-			options[:port] = v.to_i
-		end
-
-		parser.on("--rpc-ssl <true|false>") do |v|
-			options[:ssl] = v
-		end
-
-		parser.on("--rpc-uri URI") do |v|
-			options[:uri] = v
-		end
-
-		parser.on("--rpc-user USERNAME") do |v|
-			options[:user] = v
-		end
-
-		parser.on("--rpc-pass PASSWORD") do |v|
-			options[:pass] = v
-		end
-
-		parser.on("--rpc-token TOKEN") do |v|
-			options[:token] = v
-		end
-
-		parser.on("--rpc-config CONFIG-FILE") do |v|
-			options[:config] = v
-		end
-
-		parser.on("--rpc-help") do
-			$stderr.puts parser
-			exit(1)
-		end
-
-		parser.separator('')
-
-		parser
-	end
-
-	#
-	# Load options from the command-line, environment.
-	# and any configuration files specified
-	#
-	def self.option_handler(options={})
-		options[:host]   ||= ENV['MSFRPC_HOST']
-		options[:port]   ||= ENV['MSFRPC_PORT']
-		options[:uri]    ||= ENV['MSFRPC_URI']
-		options[:user]   ||= ENV['MSFRPC_USER']
-		options[:pass]   ||= ENV['MSFRPC_PASS']
-		options[:ssl]    ||= ENV['MSFRPC_SSL']
-		options[:token]  ||= ENV['MSFRPC_TOKEN']
-		options[:config] ||= ENV['MSFRPC_CONFIG']
-
-		empty_keys = options.keys.select{|k| options[k].nil? }
-		empty_keys.each { |k| options.delete(k) }
-
-		config_file = options.delete(:config)
-
-		if config_file
-			yaml_data = ::File.read(config_file) rescue nil
-			if yaml_data
-				yaml = ::YAML.load(yaml_data) rescue nil
-				if yaml and yaml.kind_of?(::Hash) and yaml['options']
-					yaml['options'].each_pair do |k,v|
-						case k
-						when 'ssl'
-							options[k.intern] = !!(v.to_s =~ /^(t|y|1)/i)
-						when 'port'
-							options[k.intern] = v.to_i
-						else
-						  options[k.intern] = v
-					  end
-					end
-				else
-					$stderr.puts "[-] Could not parse configuration file: #{config_file}"
-					exit(1)
-				end
-			else
-				$stderr.puts "[-] Could not read configuration file: #{config_file}"
-				exit(1)
-			end
-		end
-
-		if options[:port]
-			options[:port] = options[:port].to_i
-		end
-
-		if options[:ssl]
-			options[:ssl] = !!(options[:ssl].to_s =~ /^(t|y|1)/i)
-		end
-
-		options
-	end
-
-end
+  module RPC
+    class Client
+      # @!attribute token
+      #   @return [String] A login token.
+      attr_accessor :token
+
+      # @!attribute info
+      #   @return [Hash] Login information.
+      attr_accessor :info
+
+      # Initializes the RPC client to connect to: https://127.0.0.1:3790 (TLS1)
+      # The connection information is overridden through the optional info hash.
+      #
+      # @param [Hash] info Information needed for the initialization.
+      # @option info [String] :token A token used by the client.
+      # @return [void]
+
+      def initialize(info = {})
+        @user = nil
+        @pass = nil
+
+        self.info = {
+          host:  '127.0.0.1',
+          port:  3790,
+          uri:   '/api/',
+          ssl:   true,
+          ssl_version: 'TLS1.2',
+          context: {}
+        }.merge(info)
+
+        self.token = self.info[:token]
+      end
+
+      # Logs in by calling the 'auth.login' API. The authentication token will
+      # expire after 5 minutes, but will automatically be rewnewed when you
+      # make a new RPC request.
+      #
+      # @param [String] user Username.
+      # @param [String] pass Password.
+      # @raise RuntimeError Indicating a failed authentication.
+      # @return [TrueClass] Indicating a successful login.
+
+      def login(user, pass)
+        @user = user
+        @pass = pass
+        res = self.call('auth.login', user, pass)
+        unless res && res['result'] == 'success'
+          raise Msf::RPC::Exception.new('Authentication failed')
+        end
+        self.token = res['token']
+        true
+      end
+
+
+      # Attempts to login again with the last known user name and password.
+      #
+      # @return [TrueClass] Indicating a successful login.
+
+      def re_login
+        login(@user, @pass)
+      end
+
+
+      # Calls an API.
+      #
+      # @param [String] meth The RPC API to call.
+      # @param [Array<string>] args The arguments to pass.
+      # @raise [RuntimeError] Something is wrong while calling the remote API,
+      #                       including:
+      #                       * A missing token (your client needs to
+      #                         authenticate).
+      #                       * A unexpected response from the server, such as
+      #                         a timeout or unexpected HTTP code.
+      # @raise [Msf::RPC::ServerException] The RPC service returns an error.
+      # @return [Hash] The API response. It contains the following keys:
+      #  * 'version' [String] Framework version.
+      #  * 'ruby' [String] Ruby version.
+      #  * 'api' [String] API version.
+      # @example
+      #  # This will return something like this:
+      #  # {"version"=>"4.11.0-dev",
+      #  #  "ruby"=>"2.1.5 x86_64-darwin14.0 2014-11-13", "api"=>"1.0"}
+      #  rpc.call('core.version')
+
+      def call(meth, *args)
+        if meth == 'auth.logout'
+          do_logout_cleanup
+        end
+
+        unless meth == 'auth.login'
+          unless self.token
+            raise Msf::RPC::Exception.new('Client not authenticated')
+          end
+          args.unshift(self.token)
+        end
+
+        args.unshift(meth)
+
+        begin
+          send_rpc_request(args)
+        rescue Msf::RPC::ServerException => e
+          if e.message =~ /Invalid Authentication Token/i &&
+             meth != 'auth.login' && @user && @pass
+            re_login
+            args[1] = self.token
+            retry
+          else
+            raise e
+          end
+        ensure
+          @cli.close if @cli
+        end
+      end
+
+      # Closes the client.
+      #
+      # @return [void]
+      def close
+        if @cli && @cli.conn?
+          @cli.close
+        end
+        @cli = nil
+      end
+
+      #
+      # Class methods
+      #
+
+      #
+      # Provides a parser object that understands the
+      # RPC specific options
+      #
+      def self.option_parser(options)
+        parser = OptionParser.new
+
+        parser.banner = "Usage: #{$PROGRAM_NAME} [options]"
+        parser.separator('')
+        parser.separator('RPC Options:')
+
+        parser.on('--rpc-host HOST') do |v|
+          options[:host] = v
+        end
+
+        parser.on('--rpc-port PORT') do |v|
+          options[:port] = v.to_i
+        end
+
+        parser.on('--rpc-ssl <true|false>') do |v|
+          options[:ssl] = v
+        end
+
+        parser.on('--rpc-uri URI') do |v|
+          options[:uri] = v
+        end
+
+        parser.on('--rpc-user USERNAME') do |v|
+          options[:user] = v
+        end
+
+        parser.on('--rpc-pass PASSWORD') do |v|
+          options[:pass] = v
+        end
+
+        parser.on('--rpc-token TOKEN') do |v|
+          options[:token] = v
+        end
+
+        parser.on('--rpc-config CONFIG-FILE') do |v|
+          options[:config] = v
+        end
+
+        parser.on('--rpc-help') do
+          $stderr.puts parser
+          exit(1)
+        end
+
+        parser.separator('')
+
+        parser
+      end
+
+      #
+      # Load options from the command-line, environment.
+      # and any configuration files specified
+      #
+      def self.option_handler(options = {})
+        options[:host]   ||= ENV['MSFRPC_HOST']
+        options[:port]   ||= ENV['MSFRPC_PORT']
+        options[:uri]    ||= ENV['MSFRPC_URI']
+        options[:user]   ||= ENV['MSFRPC_USER']
+        options[:pass]   ||= ENV['MSFRPC_PASS']
+        options[:ssl]    ||= ENV['MSFRPC_SSL']
+        options[:token]  ||= ENV['MSFRPC_TOKEN']
+        options[:config] ||= ENV['MSFRPC_CONFIG']
+
+        empty_keys = options.keys.select { |k| options[k].nil? }
+        empty_keys.each { |k| options.delete(k) }
+
+        config_file = options.delete(:config)
+
+        if config_file
+          yaml_data = ::File.read(config_file) rescue nil
+          if yaml_data
+            yaml = ::YAML.load(yaml_data) rescue nil
+            if yaml && yaml.is_a?(::Hash) && yaml['options']
+              yaml['options'].each_pair do |k, v|
+                case k
+                when 'ssl'
+                  options[k.intern] = !!(v.to_s =~ /^(t|y|1)/i)
+                when 'port'
+                  options[k.intern] = v.to_i
+                else
+                  options[k.intern] = v
+                end
+              end
+            else
+              $stderr.puts "Could not parse configuration file: #{config_file}"
+              exit(1)
+            end
+          else
+            $stderr.puts "Could not read configuration file: #{config_file}"
+            exit(1)
+          end
+        end
+
+        options[:port] = options[:port].to_i if options[:port]
+
+        options[:ssl] = !!(options[:ssl].to_s =~ /^(t|y|1)/i) if options[:ssl]
+
+        options
+      end
+
+      private
+
+      def send_rpc_request(args)
+        unless @cli
+          @cli = Rex::Proto::Http::Client.new(info[:host], info[:port], info[:context], info[:ssl], info[:ssl_version])
+          @cli.set_config(
+            vhost: info[:host],
+            agent: "Metasploit RPC Client/#{API_VERSION}",
+            read_max_data: 1024 * 1024 * 512
+          )
+        end
+
+        req = @cli.request_cgi(
+          'method' => 'POST',
+          'uri'    => self.info[:uri],
+          'ctype'  => 'binary/message-pack',
+          'data'   => args.to_msgpack
+        )
+
+        begin
+          res = @cli.send_recv(req)
+        rescue => e
+            raise Msf::RPC::ServerException.new(000, e.message, e.class)
+        end
+
+        if res && [200, 401, 403, 500].include?(res.code)
+          resp = MessagePack.unpack(res.body)
+
+          # Boolean true versus truthy check required here;
+          # RPC responses such as { "error" => "Here I am" } and
+          # { "error" => # "" } must be accommodated.
+          if resp && resp.is_a?(::Hash) && resp['error'] == true
+            raise Msf::RPC::ServerException.new(
+              resp['error_code'] || res.code,
+              resp['error_message'] || resp['error_string'],
+              resp['error_class'], resp['error_backtrace']
+            )
+          end
+
+          return resp
+        else
+          if res
+            raise Msf::RPC::Exception.new(res.inspect)
+          else
+            raise Msf::RPC::Exception.new('Unknown error parsing or sending response')
+          end
+        end
+      end
+
+      def do_logout_cleanup
+        @user = nil
+        @pass = nil
+      end
+    end
+  end
 end
-end
-