metasploit-runner 0.1.8 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ade37ee5ad6a5f514b47ade631cc9c3c2504ef65
-  data.tar.gz: f3ca83cd02dec9d40044cd9e6d0f9b636c394bd3
+  metadata.gz: 250b963d7aab6e8e6ef915674a0de8edca5c50bf
+  data.tar.gz: e54e5098ef8f5f70fff4d7e540ca99e50c087809
 SHA512:
-  metadata.gz: 7b8567fecac69cb76a7b1f3ebced3073aff8356a86e0d62d5b0cc361ca93d8a504d1f29d3b3627aadec406e13cb2625c090511256ac5ddedd9d9b9287fd069f9
-  data.tar.gz: 3a8e4a7e9bd96837186a965a73da69b92d1681ced7b00e9043f49a6d4cd12d08a5b7f5a79e127cac353db45f8646daea9ed216f9dbfe0243b580938c9f7491d2
+  metadata.gz: eb5fca636b93affc501761b1aaf9c33bad357dc8fce3a32533eaf71af7c67d01345372948c00634ba663b8e4a82fceaa2077ce43f7fc4a2b32be4657c5257f5e
+  data.tar.gz: 58cbe28bc29feda56e45b39de9e82008fbe1f23e7f05e0e5a5c0a45a8f4f844816687daa2d87249cbb0665e10042c16111d84ef6b63a47a31dbc86802e13326b

data/README.md

@@ -29,15 +29,15 @@ This gem allows you to specify the Metasploit Connection URL, Metasploit Connect
 The nexpose_console_name is optional, if you specify a nexpose console name it will use the workspace_name, and nexpose console name to pull scan data from a nexpose console.
 IMPORTANT: Your "Site Name" in Nexpose, must match your "Workspace" name in Metasploit and you must add your Nexpose Console to Metasploit for this to work properly.
 
-    $ exploit "connection_url" "port" "uri" "use_ssl" "token" "workspace_name" "nexpose_console_name" "device_ip_to_scan" "os_filter"
+    $ exploit "connection_url" "port" "uri" "use_ssl" "token" "workspace_name" "nexpose_console_name" "device_ip_to_scan" "os_filter" "module_filter"
 
 Example WITH Nexpose Console Integration:
 
-    $ exploit "sploit.mydomain.com" "3790" "/api/1.0" "<true/false>" "asdlkjhsdfuw1228340asdasf8" "mycoolsoftware-build-28" "nexpose-console-1" "10.0.0.1" "<true/false>"
+    $ exploit "sploit.mydomain.com" "3790" "/api/1.0" "<true/false>" "asdlkjhsdfuw1228340asdasf8" "mycoolsoftware-build-28" "nexpose-console-1" "10.0.0.1" "<true/false>" "exploit/windows/smb/psexec"
 
 Example WITHOUT Nexpose Console Integration:
 
-    $ exploit "sploit.mydomain.com" "3790" "/api/1.0" "true" "asdlkjhsdfuw1228340asdasf8" "mycoolsoftware-build-28" "" "10.0.0.1" "false"
+    $ exploit "sploit.mydomain.com" "3790" "/api/1.0" "true" "asdlkjhsdfuw1228340asdasf8" "mycoolsoftware-build-28" "" "10.0.0.1" "false" "exploit/windows/smb/psexec"
 
 Additionally, an os filter may be passed in to determine which modules will be ran during an exploit.  The os filter parameter will default to false (all modules will run) if you do not pass a value.
 
@@ -56,7 +56,7 @@ The if you do not pass the following options they will default to the respective
 
 Example using the defaults:
 
-    $ exploit "sploit.mydomain.com" "" "" "" "asdlkjhsdfuw1228340asdasf8" "mycoolsoftware-build-28" "nexpose-console-1" "10.0.0.1" ""
+    $ exploit "sploit.mydomain.com" "" "" "" "asdlkjhsdfuw1228340asdasf8" "mycoolsoftware-build-28" "nexpose-console-1" "10.0.0.1" "" ""
 
 ## Contributing
 

data/bin/exploit

@@ -3,4 +3,4 @@
 require 'metasploit/exploit'
 
 $stdout.sync = true
-Metasploit::Exploit.start ARGV[0], ARGV[1], ARGV[2], ARGV[3], ARGV[4], ARGV[5], ARGV[6], ARGV[7], ARGV[8]
+Metasploit::Exploit.start ARGV[0], ARGV[1], ARGV[2], ARGV[3], ARGV[4], ARGV[5], ARGV[6], ARGV[7], ARGV[8], ARGV[9]

data/lib/MetasploitPenTestScript/version.rb

@@ -1,3 +1,3 @@
 module MetasploitPenTestScript
-  VERSION = "0.1.8"
+  VERSION = "0.1.9"
 end

data/lib/metasploit/constants.rb

@@ -20,4 +20,6 @@ module CONSTANTS
   SKIPPING_IMPORT_MESSAGE = '[*] Nexpose Console option was not passed, skipping Nexpose Import'
   USING_OS_FILTER_MESSAGE = '[*] The OS Filter is set to TRUE so we are limiting the modules to just the ones applicable to this Operating System'
   NO_OS_FILTER = '[*] We did not receive an option for the OS Filter or you set it to FALSE, either way we are backing the truck up and using all modules'
+  USING_MODULE_FILTER = '[*] Filtering exploits based on your desired modules'
+  NO_MODULE_FILTER = '[*] Not filtering any modules'
 end

data/lib/metasploit/exploit.rb

@@ -4,8 +4,17 @@ require 'metasploit/exploit_run_description'
 
 module Metasploit
   module Exploit
-    def Exploit.start(connection_url, port, uri, use_ssl, token, workspace_name, nexpose_console_name, device_ip_to_scan, use_os_filter)
-      run_details = ExploitRunDescription.new connection_url, port, uri, use_ssl, token, workspace_name, nexpose_console_name, device_ip_to_scan, use_os_filter
+    def Exploit.start(connection_url,
+                      port,  
+                      uri, 
+                      use_ssl, 
+                      token, 
+                      workspace_name, 
+                      nexpose_console_name, 
+                      device_ip_to_scan, 
+                      use_os_filter, 
+                      module_filter)
+      run_details = ExploitRunDescription.new connection_url, port, uri, use_ssl, token, workspace_name, nexpose_console_name, device_ip_to_scan, use_os_filter, module_filter
       run_details.verify
 
       rpc_client = get_new_metasploit_rpc_connection(run_details)
@@ -62,6 +71,13 @@ module Metasploit
         puts CONSTANTS::NO_OS_FILTER
       end
 
+      if run_details.module_filter.nil? || run_details.module_filter.empty?
+        puts CONSTANTS::NO_MODULE_FILTER
+      else
+        puts CONSTANTS::USING_MODULE_FILTER
+        puts run_details.module_filter
+      end
+
       sploit = rpc_client.call('pro.start_exploit', run_details.get_exploit_options)
 
       wait_for_task_to_stop_running(rpc_client, CONSTANTS::EXPLOIT_MESSAGE, sploit['task_id'])

data/lib/metasploit/exploit_run_description.rb

@@ -1,12 +1,31 @@
 class ExploitRunDescription
-  attr_accessor :connection_url, :port, :uri, :use_ssl, :token, :workspace_name, :nexpose_console_name, :device_ip_to_scan, :use_os_filter
+  attr_accessor :connection_url, 
+    :port, 
+    :uri, 
+    :use_ssl, 
+    :token, 
+    :workspace_name, 
+    :nexpose_console_name, 
+    :device_ip_to_scan, 
+    :use_os_filter, 
+    :module_filter
+
   @@port_value = ''
   @@uri_value = ''
   @@use_ssl_value = ''
   @@device_ip_to_scan_value = ''
   @@use_os_filter_value = ''
 
-  def initialize(connection_url, port, uri, use_ssl, token, workspace_name, nexpose_console_name, device_ip_to_scan, use_os_filter)
+  def initialize(connection_url,
+                 port, 
+                 uri, 
+                 use_ssl, 
+                 token, 
+                 workspace_name, 
+                 nexpose_console_name, 
+                 device_ip_to_scan, 
+                 use_os_filter,
+                 module_filter)
     self.connection_url = connection_url
     @@port_value = port
     @@uri_value = uri
@@ -16,6 +35,7 @@ class ExploitRunDescription
     self.nexpose_console_name = nexpose_console_name
     @@device_ip_to_scan_value = device_ip_to_scan
     self.use_os_filter = use_os_filter
+    self.module_filter = module_filter
   end
 
   def verify
@@ -57,7 +77,8 @@ class ExploitRunDescription
       "DS_LimitSessions" => true,
       "DS_MATCH_VULNS" => true,
       "DS_MATCH_PORTS" => true,
-      "DS_FilterByOS" => self.use_os_filter}
+      "DS_FilterByOS" => self.use_os_filter,
+      "DS_ModuleFilter" => self.module_filter}
   end
 
   def device_ip_to_scan

data/spec/exploit_run_description_spec.rb

@@ -9,7 +9,8 @@ describe 'exploit_run_description' do
       @expected_uri = '/api/1.1'
       @expected_ssl = false
       @expected_os_filter = false
-      @expected_workspace_name = 'workspacename'
+      @expected_module_filter = 'exploit/windows/smb/psexec'
+      @expected_workspacename = 'workspacename'
       @expected_nexpose_console_name = 'nexpose_console_name'
       @expected_webscan_task_id = '12'
       @expected_import_task_id = '1'
@@ -17,7 +18,7 @@ describe 'exploit_run_description' do
       @mock_rpc_client = get_mock_rpc_client
       @mock_device_ip_to_scan = '127.0.0.1'
       @mock_device_url_to_scan = "http://#{@mock_device_ip_to_scan}"
-
+      
       @exploit_run_description = ExploitRunDescription.new @expected_connection,
                                                           @expected_port,
                                                           @expected_uri,
@@ -26,7 +27,8 @@ describe 'exploit_run_description' do
                                                           @expected_workspace_name,
                                                           @expected_nexpose_console_name,
                                                           @mock_device_ip_to_scan,
-                                                          @expected_os_filter
+                                                          @expected_os_filter,
+                                                          @expected_module_filter
 
     end
 
@@ -40,6 +42,7 @@ describe 'exploit_run_description' do
       expect(@exploit_run_description.nexpose_console_name).to eq(@expected_nexpose_console_name)
       expect(@exploit_run_description.device_ip_to_scan).to eq(@mock_device_url_to_scan)
       expect(@exploit_run_description.use_os_filter).to eq(@expected_os_filter)
+      expect(@exploit_run_description.module_filter).to eq(@expected_module_filter)
     end
 
     it 'should use 3790 as default if port is empty string' do

data/spec/exploit_spec.rb

@@ -31,6 +31,7 @@ describe 'exploit' do
       @expected_match_vulns = true
       @expected_match_ports = true
       @expected_ssl_version ='TLS1'
+      @expected_module_filter = 'exploit/windows/smb/psexec'
       @mock_rpc_client = get_mock_rpc_client
       @mock_device_ip_to_scan = '127.0.0.1'
       @mock_device_url_to_scan = "http://#{@mock_device_ip_to_scan}"
@@ -44,22 +45,22 @@ describe 'exploit' do
                                     .with(expected_options)
                                     .and_return(@mock_rpc_client)
 
-        Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl, @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter)
+        Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl, @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter, @expected_module_filter)
       end
 
       it 'should throw an error if no token is passed' do
-        expect { Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl, '', @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter) }.to raise_error(StandardError, 'PWNED! Token is required')
-        expect { Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl, nil, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter) }.to raise_error(StandardError, 'PWNED! Token is required')
+        expect { Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl, '', @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter, @expected_module_filter) }.to raise_error(StandardError, 'PWNED! Token is required')
+        expect { Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl, nil, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter, @expected_module_filter) }.to raise_error(StandardError, 'PWNED! Token is required')
       end
 
       it 'should throw an error if no connection url is passed' do
-        expect { Metasploit::Exploit.start('', @expected_port, @expected_uri, @expected_ssl, @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter) }.to raise_error(StandardError, 'PWNED! Connection URL is required')
-        expect { Metasploit::Exploit.start(nil, @expected_port, @expected_uri, @expected_ssl, @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter) }.to raise_error(StandardError, 'PWNED! Connection URL is required')
+        expect { Metasploit::Exploit.start('', @expected_port, @expected_uri, @expected_ssl, @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter, @expected_module_filter) }.to raise_error(StandardError, 'PWNED! Connection URL is required')
+        expect { Metasploit::Exploit.start(nil, @expected_port, @expected_uri, @expected_ssl, @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter, @expected_module_filter) }.to raise_error(StandardError, 'PWNED! Connection URL is required')
       end
 
       it 'should throw an error if no ip address is passed' do
-        expect { Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl, @expected_token, @expected_workspace_name, @expected_nexpose_console_name, '', @expected_use_os_filter) }.to raise_error(StandardError, 'PWNED! Device IP to scan is required')
-        expect { Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl, @expected_token, @expected_workspace_name, @expected_nexpose_console_name, nil, @expected_use_os_filter) }.to raise_error(StandardError, 'PWNED! Device IP to scan is required')
+        expect { Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl, @expected_token, @expected_workspace_name, @expected_nexpose_console_name, '', @expected_use_os_filter, @expected_module_filter) }.to raise_error(StandardError, 'PWNED! Device IP to scan is required')
+        expect { Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl, @expected_token, @expected_workspace_name, @expected_nexpose_console_name, nil, @expected_use_os_filter, @expected_module_filter) }.to raise_error(StandardError, 'PWNED! Device IP to scan is required')
       end
 
       it 'should use 3790 as default if port is empty string' do
@@ -69,7 +70,7 @@ describe 'exploit' do
                                     .with(expected_options)
                                     .and_return(@mock_rpc_client)
 
-        Metasploit::Exploit.start(@expected_connection, '', @expected_uri, @expected_ssl, @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter)
+        Metasploit::Exploit.start(@expected_connection, '', @expected_uri, @expected_ssl, @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter, @expected_module_filter)
       end
     end
 
@@ -78,21 +79,21 @@ describe 'exploit' do
         expect(@mock_rpc_client).to receive(:call)
                                    .with('pro.workspace_add', {'name' => @expected_workspace_name})
 
-        Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter)
+        Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter, @expected_module_filter)
       end
 
       it 'should throw an error if workspace name is invalid' do
-        expect { Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl, @expected_token, '', @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter) }.to raise_error(StandardError, 'PWNED! Workspace Name is required')
-        expect { Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl, @expected_token, nil, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter) }.to raise_error(StandardError, 'PWNED! Workspace Name is required')
+        expect { Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl, @expected_token, '', @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter, @expected_module_filter) }.to raise_error(StandardError, 'PWNED! Workspace Name is required')
+        expect { Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl, @expected_token, nil, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter, @expected_module_filter) }.to raise_error(StandardError, 'PWNED! Workspace Name is required')
       end
     end
 
     describe 'should skip nexpose import' do
       it 'should skip the import if nexpose_console variable is empty or nil' do
-        expect {Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl, @expected_token, @expected_workspace_name, '', @mock_device_ip_to_scan, @expected_use_os_filter)}.to output(/\[\*\] Nexpose Console option was not passed, skipping Nexpose Import/).to_stdout
-        expect {Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl, @expected_token, @expected_workspace_name, nil, @mock_device_ip_to_scan, @expected_use_os_filter)}.to output(/\[\*\] Nexpose Console option was not passed, skipping Nexpose Import/).to_stdout
-        expect {Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl, @expected_token, @expected_workspace_name, '', @mock_device_ip_to_scan, @expected_use_os_filter)}.to_not output(/\[\*\] Importing.../).to_stdout
-        expect {Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl, @expected_token, @expected_workspace_name, nil, @mock_device_ip_to_scan, @expected_use_os_filter)}.to_not output(/\[\*\] Importing...'/).to_stdout
+        expect {Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl, @expected_token, @expected_workspace_name, '', @mock_device_ip_to_scan, @expected_use_os_filter, @expected_module_filter)}.to output(/\[\*\] Nexpose Console option was not passed, skipping Nexpose Import/).to_stdout
+        expect {Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl, @expected_token, @expected_workspace_name, nil, @mock_device_ip_to_scan, @expected_use_os_filter, @expected_module_filter)}.to output(/\[\*\] Nexpose Console option was not passed, skipping Nexpose Import/).to_stdout
+        expect {Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl, @expected_token, @expected_workspace_name, '', @mock_device_ip_to_scan, @expected_use_os_filter, @expected_module_filter)}.to_not output(/\[\*\] Importing.../).to_stdout
+        expect {Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl, @expected_token, @expected_workspace_name, nil, @mock_device_ip_to_scan, @expected_use_os_filter, @expected_module_filter)}.to_not output(/\[\*\] Importing...'/).to_stdout
       end
     end
 
@@ -104,7 +105,7 @@ describe 'exploit' do
                                                              'DS_NEXPOSE_CONSOLE' => @expected_nexpose_console_name,
                                                              'DS_NEXPOSE_SITE' => @expected_workspace_name})
 
-        Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter)
+        Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter, @expected_module_filter)
       end
 
       describe 'wait to be over' do
@@ -119,7 +120,7 @@ describe 'exploit' do
         it 'should call to check the status of an import' do
           expect(@mock_rpc_client).to receive(:call).with('pro.task_status', @expected_import_task_id)
 
-          Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter)
+          Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter, @expected_module_filter)
         end
 
         it 'should call to check the status until it is not running' do
@@ -135,7 +136,7 @@ describe 'exploit' do
                                       .once
                                       .ordered
 
-          Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter)
+          Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter, @expected_module_filter)
         end
 
         it 'should sleep for 3 seconds if the status is still running' do
@@ -154,7 +155,7 @@ describe 'exploit' do
           #Expecting 7 because we are mocking 6 above and the global :call mock in get_mock_rpc_client
           expect(Metasploit::Exploit).to receive(:sleep).with(3).exactly(7).times
 
-          Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter)
+          Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter, @expected_module_filter)
         end
       end
     end
@@ -165,7 +166,7 @@ describe 'exploit' do
                                     .with('pro.start_webscan', {'workspace' => @expected_workspace_name,
                                                                 'DS_URLS' => @mock_device_url_to_scan})
 
-        Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter)
+        Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter, @expected_module_filter)
       end
 
       describe 'wait for scan to be over' do
@@ -179,7 +180,7 @@ describe 'exploit' do
         it 'should call to check the status of the scan' do
           expect(@mock_rpc_client).to receive(:call).with('pro.task_status', @expected_webscan_task_id)
 
-          Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter)
+          Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter, @expected_module_filter)
         end
 
         it 'should call to check the status until it is not running' do
@@ -195,7 +196,7 @@ describe 'exploit' do
                                       .once
                                       .ordered
 
-          Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter)
+          Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter, @expected_module_filter)
         end
 
         it 'should sleep for 3 seconds if the status is still running' do
@@ -214,7 +215,7 @@ describe 'exploit' do
           #Expecting 7 because we are mocking 6 above and the global :call mock in get_mock_rpc_client
           expect(Metasploit::Exploit).to receive(:sleep).with(3).exactly(7).times
 
-          Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter)
+          Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter, @expected_module_filter)
         end
       end
     end
@@ -232,7 +233,7 @@ describe 'exploit' do
                                                                   'DS_MAX_INSTANCES' => @expected_audit_max_instances
                                                                 })
 
-        Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter)
+       Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter, @expected_module_filter)
       end
 
       describe 'wait for audit to be over' do
@@ -253,7 +254,7 @@ describe 'exploit' do
         it 'should call to check the status of the audit' do
           expect(@mock_rpc_client).to receive(:call).with('pro.task_status', @expected_audit_task_id)
 
-          Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter)
+          Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter, @expected_module_filter)
         end
 
         it 'should call to check the status until it is not running' do
@@ -269,7 +270,7 @@ describe 'exploit' do
                                       .once
                                       .ordered
 
-          Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter)
+          Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter, @expected_module_filter)
         end
 
         it 'should sleep for 3 seconds if the status is still running' do
@@ -288,7 +289,7 @@ describe 'exploit' do
           #Expecting 7 because we are mocking 6 above and the global :call mock in get_mock_rpc_client
           expect(Metasploit::Exploit).to receive(:sleep).with(3).exactly(7).times
 
-          Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter)
+          Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter, @expected_module_filter)
         end
       end
     end
@@ -297,7 +298,8 @@ describe 'exploit' do
 
       it 'should kick off an exploit' do
         expect(@mock_rpc_client).to receive(:call)
-                                    .with('pro.start_exploit', {"workspace" => @expected_workspace_name,
+                                    .with('pro.start_exploit', {
+                                                                "workspace" => @expected_workspace_name,
                                                                 "DS_WHITELIST_HOSTS" => @mock_device_ip_to_scan,
                                                                 "DS_MinimumRank" => @expected_minimum_rank,
                                                                 "DS_EXPLOIT_SPEED" => @expected_exploit_speed,
@@ -305,14 +307,17 @@ describe 'exploit' do
                                                                 "DS_LimitSessions" => @expected_session_limit,
                                                                 "DS_MATCH_VULNS" => @expected_match_vulns,
                                                                 "DS_MATCH_PORTS" => @expected_match_ports,
-                                                                "DS_FilterByOS" =>  @expected_use_os_filter})
+                                                                "DS_FilterByOS" =>  @expected_use_os_filter,
+                                                                "DS_ModuleFilter" => @expected_module_filter
+                                                               })
 
-        Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter)
+        Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter, @expected_module_filter)
       end
 
       it 'should use a operating system filter if its set to true' do
         expect(@mock_rpc_client).to receive(:call)
-                                    .with('pro.start_exploit', {"workspace" => @expected_workspace_name,
+                                    .with('pro.start_exploit', {
+                                                                "workspace" => @expected_workspace_name,
                                                                 "DS_WHITELIST_HOSTS" => @mock_device_ip_to_scan,
                                                                 "DS_MinimumRank" => @expected_minimum_rank,
                                                                 "DS_EXPLOIT_SPEED" => @expected_exploit_speed,
@@ -320,9 +325,11 @@ describe 'exploit' do
                                                                 "DS_LimitSessions" => @expected_session_limit,
                                                                 "DS_MATCH_VULNS" => @expected_match_vulns,
                                                                 "DS_MATCH_PORTS" => @expected_match_ports,
-                                                                "DS_FilterByOS" =>  @expected_use_os_filter})
+                                                                "DS_FilterByOS" =>  @expected_use_os_filter,
+                                                                "DS_ModuleFilter" => @expected_module_filter
+                                                                })
 
-        Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, true)
+        Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, true, @expected_module_filter)
       end
 
       it 'should not use a operating system filter if its set to false' do
@@ -335,9 +342,45 @@ describe 'exploit' do
                                                                 "DS_LimitSessions" => @expected_session_limit,
                                                                 "DS_MATCH_VULNS" => @expected_match_vulns,
                                                                 "DS_MATCH_PORTS" => @expected_match_ports,
-                                                                "DS_FilterByOS" =>  false})
+                                                                "DS_FilterByOS" =>  false,
+                                                                "DS_ModuleFilter" => @expected_module_filter
+                                                                })
 
-        Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, false)
+        Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, false, @expected_module_filter)
+      end
+
+      it 'should not use a module filter if no modules are passed' do
+        expect(@mock_rpc_client).to receive(:call)
+                                    .with('pro.start_exploit', {"workspace" => @expected_workspace_name,
+                                                                "DS_WHITELIST_HOSTS" => @mock_device_ip_to_scan,
+                                                                "DS_MinimumRank" => @expected_minimum_rank,
+                                                                "DS_EXPLOIT_SPEED" => @expected_exploit_speed,
+                                                                "DS_EXPLOIT_TIMEOUT" => @expected_exploit_timeout,
+                                                                "DS_LimitSessions" => @expected_session_limit,
+                                                                "DS_MATCH_VULNS" => @expected_match_vulns,
+                                                                "DS_MATCH_PORTS" => @expected_match_ports,
+                                                                "DS_FilterByOS" =>  false,
+                                                                "DS_ModuleFilter" => ''
+        })
+
+        Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, false, '')
+      end
+
+      it 'should use a module filter if a module is passed' do
+        expect(@mock_rpc_client).to receive(:call)
+                                    .with('pro.start_exploit', {"workspace" => @expected_workspace_name,
+                                                                "DS_WHITELIST_HOSTS" => @mock_device_ip_to_scan,
+                                                                "DS_MinimumRank" => @expected_minimum_rank,
+                                                                "DS_EXPLOIT_SPEED" => @expected_exploit_speed,
+                                                                "DS_EXPLOIT_TIMEOUT" => @expected_exploit_timeout,
+                                                                "DS_LimitSessions" => @expected_session_limit,
+                                                                "DS_MATCH_VULNS" => @expected_match_vulns,
+                                                                "DS_MATCH_PORTS" => @expected_match_ports,
+                                                                "DS_FilterByOS" =>  false,
+                                                                "DS_ModuleFilter" => @expected_module_filter
+        })
+
+        Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, false, @expected_module_filter)
       end
 
       describe 'wait for exploit to be over' do
@@ -352,14 +395,16 @@ describe 'exploit' do
                                                                   "DS_LimitSessions" => @expected_session_limit,
                                                                   "DS_MATCH_VULNS" => @expected_match_vulns,
                                                                   "DS_MATCH_PORTS" => @expected_match_ports,
-                                                                  "DS_FilterByOS" =>  @expected_use_os_filter})
+                                                                  "DS_FilterByOS" =>  @expected_use_os_filter,
+                                                                  "DS_ModuleFilter" => @expected_module_filter
+                                                                  })
                                       .and_return({'task_id' => @expected_exploit_task_id})
         end
 
         it 'should call to check the status of the exploit' do
           expect(@mock_rpc_client).to receive(:call).with('pro.task_status', @expected_exploit_task_id)
 
-          Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter)
+          Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter, @expected_module_filter)
         end
 
         it 'should call to check the status until it is not running' do
@@ -375,7 +420,7 @@ describe 'exploit' do
                                       .once
                                       .ordered
 
-          Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter)
+          Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter, @expected_module_filter)
         end
 
         it 'should sleep for 3 seconds if the status is still running' do
@@ -394,7 +439,7 @@ describe 'exploit' do
           #Expecting 7 because we are mocking 6 above and the global :call mock in get_mock_rpc_client
           expect(Metasploit::Exploit).to receive(:sleep).with(3).exactly(7).times
 
-          Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter)
+          Metasploit::Exploit.start(@expected_connection, @expected_port, @expected_uri, @expected_ssl,  @expected_token, @expected_workspace_name, @expected_nexpose_console_name, @mock_device_ip_to_scan, @expected_use_os_filter, @expected_module_filter)
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: metasploit-runner
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.9
 platform: ruby
 authors:
 - Nathan Gibson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-15 00:00:00.000000000 Z
+date: 2015-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msfrpc-client