rex 2.0.8 → 2.0.9

data/lib/rex/post/meterpreter/ui/console/command_dispatcher/stdapi/net.rb

@@ -51,6 +51,20 @@ class Console::CommandDispatcher::Stdapi::Net
     "-p" => [ true,  "The remote port to connect to." ],
     "-L" => [ true,  "The local host to listen on (optional)." ])
 
+  #
+  # Options for the netstat command.
+  #
+  @@netstat_opts = Rex::Parser::Arguments.new(
+    "-h" => [ false, "Help banner." ],
+    "-S" => [ true, "Search string." ])
+
+  #
+  # Options for ARP command.
+  #
+  @@arp_opts = Rex::Parser::Arguments.new(
+    "-h" => [ false, "Help banner." ],
+    "-S" => [ true, "Search string." ])
+
   #
   # List of supported commands.
   #
@@ -107,6 +121,23 @@ class Console::CommandDispatcher::Stdapi::Net
   #
   def cmd_netstat(*args)
     connection_table = client.net.config.netstat
+    search_term = nil
+    @@netstat_opts.parse(args) { |opt, idx, val|
+      case opt
+      when '-S'
+        search_term = val
+        if search_term.nil?
+          print_error("Enter a search term")
+          return true
+        else
+          search_term = /#{search_term}/nmi
+        end
+      when "-h"
+        @@netstat_opts.usage
+        return 0
+
+      end
+    }
     tbl = Rex::Ui::Text::Table.new(
     'Header'  => "Connection list",
     'Indent'  => 4,
@@ -119,7 +150,8 @@ class Console::CommandDispatcher::Stdapi::Net
         "User",
         "Inode",
         "PID/Program name"
-      ])
+      ],
+     'SearchTerm' => search_term)
 
     connection_table.each { |connection|
       tbl << [ connection.protocol, connection.local_addr_str, connection.remote_addr_str,
@@ -138,6 +170,23 @@ class Console::CommandDispatcher::Stdapi::Net
   #
   def cmd_arp(*args)
     arp_table = client.net.config.arp_table
+    search_term = nil
+    @@arp_opts.parse(args) { |opt, idx, val|
+      case opt
+      when '-S'
+        search_term = val
+        if search_term.nil?
+          print_error("Enter a search term")
+          return true
+        else
+          search_term = /#{search_term}/nmi
+        end
+      when "-h"
+        @@arp_opts.usage
+        return 0
+
+      end
+    }
     tbl = Rex::Ui::Text::Table.new(
     'Header'  => "ARP cache",
     'Indent'  => 4,
@@ -146,7 +195,8 @@ class Console::CommandDispatcher::Stdapi::Net
         "IP address",
         "MAC address",
         "Interface"
-      ])
+      ],
+    'SearchTerm' => search_term)
 
     arp_table.each { |arp|
       tbl << [ arp.ip_addr, arp.mac_addr, arp.interface ]

data/lib/rex/post/meterpreter/ui/console/command_dispatcher/stdapi/sys.rb

@@ -21,61 +21,61 @@ class Console::CommandDispatcher::Stdapi::Sys
   # Options used by the 'execute' command.
   #
   @@execute_opts = Rex::Parser::Arguments.new(
-    "-a" => [ true,  "The arguments to pass to the command."                   ],
-    "-c" => [ false, "Channelized I/O (required for interaction)."             ],
-    "-f" => [ true,  "The executable command to run."                          ],
-    "-h" => [ false, "Help menu."                                              ],
-    "-H" => [ false, "Create the process hidden from view."                    ],
-    "-i" => [ false, "Interact with the process after creating it."            ],
-    "-m" => [ false, "Execute from memory."                                    ],
-    "-d" => [ true,  "The 'dummy' executable to launch when using -m."         ],
+    "-a" => [ true,  "The arguments to pass to the command."		   ],
+    "-c" => [ false, "Channelized I/O (required for interaction)."		   ],
+    "-f" => [ true,  "The executable command to run."			   ],
+    "-h" => [ false, "Help menu."						   ],
+    "-H" => [ false, "Create the process hidden from view."			   ],
+    "-i" => [ false, "Interact with the process after creating it."		   ],
+    "-m" => [ false, "Execute from memory."					   ],
+    "-d" => [ true,  "The 'dummy' executable to launch when using -m."	   ],
     "-t" => [ false, "Execute process with currently impersonated thread token"],
-    "-k" => [ false, "Execute process on the meterpreters current desktop"     ],
+    "-k" => [ false, "Execute process on the meterpreters current desktop"	   ],
     "-s" => [ true,  "Execute process in a given session as the session user"  ])
 
   #
   # Options used by the 'reboot' command.
   #
   @@reboot_opts = Rex::Parser::Arguments.new(
-    "-h" => [ false, "Help menu."                                              ],
-    "-f" => [ true,  "Force a reboot, valid values [1|2]"                      ])
+    "-h" => [ false, "Help menu."						   ],
+    "-f" => [ true,  "Force a reboot, valid values [1|2]"			   ])
 
   #
   # Options used by the 'shutdown' command.
   #
   @@shutdown_opts = Rex::Parser::Arguments.new(
-    "-h" => [ false, "Help menu."                                              ],
-    "-f" => [ true,  "Force a shutdown, valid values [1|2]"                    ])
+    "-h" => [ false, "Help menu."						   ],
+    "-f" => [ true,  "Force a shutdown, valid values [1|2]"			   ])
 
   #
   # Options used by the 'reg' command.
   #
   @@reg_opts = Rex::Parser::Arguments.new(
-    "-d" => [ true,  "The data to store in the registry value."                ],
-    "-h" => [ false, "Help menu."                                              ],
-    "-k" => [ true,  "The registry key path (E.g. HKLM\\Software\\Foo)."       ],
-    "-t" => [ true,  "The registry value type (E.g. REG_SZ)."                  ],
-    "-v" => [ true,  "The registry value name (E.g. Stuff)."                   ],
+    "-d" => [ true,  "The data to store in the registry value."		   ],
+    "-h" => [ false, "Help menu."						   ],
+    "-k" => [ true,  "The registry key path (E.g. HKLM\\Software\\Foo)."	   ],
+    "-t" => [ true,  "The registry value type (E.g. REG_SZ)."		   ],
+    "-v" => [ true,  "The registry value name (E.g. Stuff)."		   ],
     "-r" => [ true,  "The remote machine name to connect to (with current process credentials" ],
-    "-w" => [ false, "Set KEY_WOW64 flag, valid values [32|64]."               ])
+    "-w" => [ false, "Set KEY_WOW64 flag, valid values [32|64]."		   ])
 
   #
   # Options for the 'ps' command.
   #
   @@ps_opts = Rex::Parser::Arguments.new(
+    "-S" => [ true,  "String to search for (converts to regex)"                ],
     "-h" => [ false, "Help menu."                                              ],
-    "-S" => [ true,  "Filters processes on the process name using the supplied RegEx"],
-    "-A" => [ true,  "Filters processes on architecture (x86 or x86_64)"       ],
-    "-s" => [ false, "Show only SYSTEM processes"                              ],
+    "-A" => [ true,  "Filters processes on architecture (x86 or x86_64)"	   ],
+    "-s" => [ false, "Show only SYSTEM processes"				   ],
     "-U" => [ true,  "Filters processes on the user using the supplied RegEx"  ])
 
   #
   # Options for the 'suspend' command.
   #
   @@suspend_opts = Rex::Parser::Arguments.new(
-    "-h" => [ false, "Help menu."                                              ],
+    "-h" => [ false, "Help menu."						   ],
     "-c" => [ false, "Continues suspending or resuming even if an error is encountered"],
-    "-r" => [ false, "Resumes the target processes instead of suspending"      ])
+    "-r" => [ false, "Resumes the target processes instead of suspending"	   ])
 
   #
   # List of supported commands.
@@ -93,7 +93,7 @@ class Console::CommandDispatcher::Stdapi::Sys
       "kill"        => "Terminate a process",
       "ps"          => "List running processes",
       "reboot"      => "Reboots the remote computer",
-      "reg"         => "Modify and interact with the remote registry",
+      "reg"	      => "Modify and interact with the remote registry",
       "rev2self"    => "Calls RevertToSelf() on the remote machine",
       "shell"       => "Drop into a system command shell",
       "shutdown"    => "Shuts down the remote computer",
@@ -105,7 +105,7 @@ class Console::CommandDispatcher::Stdapi::Sys
       "clearev"     => [ "stdapi_sys_eventlog_open", "stdapi_sys_eventlog_clear" ],
       "drop_token"  => [ "stdapi_sys_config_drop_token" ],
       "execute"     => [ "stdapi_sys_process_execute" ],
-      "getpid"      => [ "stdapi_sys_process_getpid"  ],
+      "getpid"      => [ "stdapi_sys_process_getpid"	],
       "getprivs"    => [ "stdapi_sys_config_getprivs" ],
       "getuid"      => [ "stdapi_sys_config_getuid" ],
       "getsid"      => [ "stdapi_sys_config_getsid" ],
@@ -113,7 +113,7 @@ class Console::CommandDispatcher::Stdapi::Sys
       "kill"        => [ "stdapi_sys_process_kill" ],
       "ps"          => [ "stdapi_sys_process_get_processes" ],
       "reboot"      => [ "stdapi_sys_power_exitwindows" ],
-      "reg"         => [
+      "reg"	      => [
         "stdapi_registry_load_key",
         "stdapi_registry_unload_key",
         "stdapi_registry_open_key",
@@ -169,7 +169,7 @@ class Console::CommandDispatcher::Stdapi::Sys
     interact    = false
     desktop     = false
     channelized = nil
-    hidden      = nil
+    hidden	    = nil
     from_mem    = false
     dummy_exec  = "cmd"
     cmd_args    = nil
@@ -422,23 +422,24 @@ class Console::CommandDispatcher::Stdapi::Sys
   # Lists running processes.
   #
   def cmd_ps(*args)
+    if args.include?('-h')
+      cmd_ps_help
+      return true
+    end
+
+    # Init vars
     processes = client.sys.process.get_processes
-    @@ps_opts.parse(args) do |opt, idx, val|
+    search_term = nil
+
+    # Parse opts
+    @@ps_opts.parse(args) { |opt, idx, val|
       case opt
-      when "-h"
-        cmd_ps_help
-        return true
-      when "-S"
-        print_line "Filtering on process name..."
-        searched_procs = Rex::Post::Meterpreter::Extensions::Stdapi::Sys::ProcessList.new
-        processes.each do |proc|
-          if val.nil? or val.empty?
-            print_line "You must supply a search term!"
-            return false
-          end
-          searched_procs << proc  if proc["name"].match(/#{val}/)
+      when '-S'
+        search_term = val
+        if search_term.nil?
+          print_error("Enter a search term")
+          return true
         end
-        processes = searched_procs
       when "-A"
         print_line "Filtering on arch..."
         searched_procs = Rex::Post::Meterpreter::Extensions::Stdapi::Sys::ProcessList.new
@@ -448,14 +449,14 @@ class Console::CommandDispatcher::Stdapi::Sys
             print_line "You must select either x86 or x86_64"
             return false
           end
-          searched_procs << proc  if proc["arch"] == val
+          searched_procs << proc if proc["arch"] == val
         end
         processes = searched_procs
       when "-s"
         print_line "Filtering on SYSTEM processes..."
         searched_procs = Rex::Post::Meterpreter::Extensions::Stdapi::Sys::ProcessList.new
         processes.each do |proc|
-          searched_procs << proc  if proc["user"] == "NT AUTHORITY\\SYSTEM"
+          searched_procs << proc if proc["user"] == "NT AUTHORITY\\SYSTEM"
         end
         processes = searched_procs
       when "-U"
@@ -466,22 +467,25 @@ class Console::CommandDispatcher::Stdapi::Sys
             print_line "You must supply a search term!"
             return false
           end
-          searched_procs << proc  if proc["user"].match(/#{val}/)
+          searched_procs << proc if proc["user"].match(/#{val}/)
         end
         processes = searched_procs
       end
-    end
+    }
+
     if (processes.length == 0)
       print_line("No running processes were found.")
     else
+      tbl = processes.to_table('SearchTerm' => search_term)
       print_line
-      print_line(processes.to_table("Indent" => 1).to_s)
-      print_line
+      print_line(tbl.to_s)
     end
     return true
   end
 
   def cmd_ps_help
+    print_line "Usage: ps [ options ]"
+    print_line
     print_line "Use the command with no arguments to see all running processes."
     print_line "The following options can be used to filter those results:"
 
@@ -529,12 +533,12 @@ class Console::CommandDispatcher::Stdapi::Sys
     end
 
     # Initiailze vars
-    key     = nil
-    value   = nil
-    data    = nil
-    type    = nil
+    key	= nil
+    value	= nil
+    data	= nil
+    type	= nil
     wowflag = 0x0000
-    rem     = nil
+    rem	= nil
 
     @@reg_opts.parse(args) { |opt, idx, val|
       case opt
@@ -544,13 +548,13 @@ class Console::CommandDispatcher::Stdapi::Sys
             "Interact with the target machine's registry.\n" +
             @@reg_opts.usage +
             "COMMANDS:\n\n" +
-            "    enumkey    Enumerate the supplied registry key [-k <key>]\n" +
-            "    createkey  Create the supplied registry key  [-k <key>]\n" +
-            "    deletekey  Delete the supplied registry key  [-k <key>]\n" +
+            "    enumkey	Enumerate the supplied registry key [-k <key>]\n" +
+            "    createkey	Create the supplied registry key  [-k <key>]\n" +
+            "    deletekey	Delete the supplied registry key  [-k <key>]\n" +
             "    queryclass Queries the class of the supplied key [-k <key>]\n" +
-            "    setval     Set a registry value [-k <key> -v <val> -d <data>]\n" +
-            "    deleteval  Delete the supplied registry value [-k <key> -v <val>]\n" +
-            "    queryval   Queries the data contents of a value [-k <key> -v <val>]\n\n")
+            "    setval	Set a registry value [-k <key> -v <val> -d <data>]\n" +
+            "    deleteval	Delete the supplied registry value [-k <key> -v <val>]\n" +
+            "    queryval	Queries the data contents of a value [-k <key> -v <val>]\n\n")
           return false
         when "-k"
           key   = val
@@ -641,11 +645,11 @@ class Console::CommandDispatcher::Stdapi::Sys
         when "deletekey"
           open_key = nil
           if not rem
-            open_key = client.sys.registry.open_key(root_key, base_key, KEY_WRITE + wowflag)
+            open_key = client.sys.registry.open_key(root_key, nil, KEY_WRITE + wowflag)
           else
             remote_key = client.sys.registry.open_remote_key(rem, root_key)
             if remote_key
-              open_key = remote_key.open_key(base_key, KEY_WRITE + wowflag)
+              open_key = remote_key.open_key(nil, KEY_WRITE + wowflag)
             end
           end
           open_key.delete_key(base_key)
@@ -672,7 +676,7 @@ class Console::CommandDispatcher::Stdapi::Sys
 
           open_key.set_value(value, client.sys.registry.type2str(type), data)
 
-          print_line("Successful set #{value}.")
+          print_line("Successfully set #{value} of #{type}.")
 
         when "deleteval"
           if (value == nil)
@@ -859,11 +863,11 @@ class Console::CommandDispatcher::Stdapi::Sys
     args.uniq!
     diff = args - valid_pids.map {|e| e.to_s}
     if not diff.empty? # then we had an invalid pid
-      print_error("The following pids are not valid:  #{diff.join(", ").to_s}.")
+      print_error("The following pids are not valid:	#{diff.join(", ").to_s}.")
       if continue
         print_status("Continuing.  Invalid args have been removed from the list.")
       else
-        print_error("Quitting.  Use -c to continue using only the valid pids.")
+        print_error("Quitting.	Use -c to continue using only the valid pids.")
         return false
       end
     end
@@ -912,4 +916,3 @@ end
 end
 end
 end
-

data/lib/rex/post/meterpreter/ui/console/command_dispatcher/stdapi/ui.rb

@@ -89,7 +89,7 @@ class Console::CommandDispatcher::Stdapi::Ui
   def cmd_uictl(*args)
     if (args.length < 2)
       print_line(
-        "Usage: uictl [enable/disable] [keyboard/mouse]")
+        "Usage: uictl [enable/disable] [keyboard/mouse/all]")
       return true
     end
 
@@ -102,6 +102,10 @@ class Console::CommandDispatcher::Stdapi::Ui
           when 'mouse'
             print_line("Enabling mouse...")
             client.ui.enable_mouse
+          when 'all'
+            print_line("Enabling all...")
+            client.ui.enable_keyboard
+            client.ui.enable_mouse
           else
             print_error("Unsupported user interface device: #{args[1]}")
         end
@@ -113,6 +117,10 @@ class Console::CommandDispatcher::Stdapi::Ui
           when 'mouse'
             print_line("Disabling mouse...")
             client.ui.disable_mouse
+          when 'all'
+            print_line("Disabling all...")
+            client.ui.disable_keyboard
+            client.ui.disable_mouse
           else
             print_error("Unsupported user interface device: #{args[1]}")
         end

data/lib/rex/post/meterpreter/ui/console/command_dispatcher/stdapi/webcam.rb

@@ -12,7 +12,6 @@ module Ui
 #
 ###
 class Console::CommandDispatcher::Stdapi::Webcam
-
   Klass = Console::CommandDispatcher::Stdapi::Webcam
 
   include Console::CommandDispatcher
@@ -33,17 +32,16 @@ class Console::CommandDispatcher::Stdapi::Webcam
       "webcam_list"   => [ "webcam_list" ],
       "webcam_snap"   => [ "webcam_start", "webcam_get_frame", "webcam_stop" ],
       "webcam_stream" => [ "webcam_start", "webcam_get_frame", "webcam_stop" ],
-      "record_mic"    => [ "webcam_audio_record" ],
+      "record_mic"    => [ "webcam_audio_record" ]
     }
 
-    all.delete_if do |cmd, desc|
+    all.delete_if do |cmd, _desc|
       del = false
       reqs[cmd].each do |req|
         next if client.commands.include? req
         del = true
         break
       end
-
       del
     end
 
@@ -58,23 +56,26 @@ class Console::CommandDispatcher::Stdapi::Webcam
   end
 
   def cmd_webcam_list
-    begin
-      client.webcam.webcam_list.each_with_index { |name, indx|
-        print_line("#{indx + 1}: #{name}")
-      }
-      return true
-    rescue
+    if client.webcam.webcam_list.length == 0
       print_error("No webcams were found")
-      return false
+      return
+    end
+
+    client.webcam.webcam_list.each_with_index do |name, indx|
+      print_line("#{indx + 1}: #{name}")
     end
   end
 
   def cmd_webcam_snap(*args)
+    if client.webcam.webcam_list.length == 0
+      print_error("Target does not have a webcam")
+      return
+    end
+
     path    = Rex::Text.rand_text_alpha(8) + ".jpeg"
     quality = 50
     view    = true
     index   = 1
-    wc_list = []
 
     webcam_snap_opts = Rex::Parser::Arguments.new(
       "-h" => [ false, "Help Banner" ],
@@ -84,51 +85,44 @@ class Console::CommandDispatcher::Stdapi::Webcam
       "-v" => [ true, "Automatically view the JPEG image (Default: '#{view}')" ]
     )
 
-    webcam_snap_opts.parse( args ) { | opt, idx, val |
+    webcam_snap_opts.parse(args) do |opt, _idx, val|
       case opt
-        when "-h"
-          print_line( "Usage: webcam_snap [options]\n" )
-          print_line( "Grab a frame from the specified webcam." )
-          print_line( webcam_snap_opts.usage )
-          return
-        when "-i"
-          index = val.to_i
-        when "-q"
-          quality = val.to_i
-        when "-p"
-          path = val
-        when "-v"
-          view = false if ( val =~ /^(f|n|0)/i )
+      when "-h"
+        print_line("Usage: webcam_snap [options]\n")
+        print_line("Grab a frame from the specified webcam.")
+        print_line(webcam_snap_opts.usage)
+        return
+      when "-i"
+        index = val.to_i
+      when "-q"
+        quality = val.to_i
+      when "-p"
+        path = val
+      when "-v"
+        view = false if val =~ /^(f|n|0)/i
       end
-    }
+    end
+
     begin
-      wc_list << client.webcam.webcam_list
-    rescue
+      print_status("Starting...")
+      client.webcam.webcam_start(index)
+      webcam_started = true
+      data = client.webcam.webcam_get_frame(quality)
+      print_good("Got frame")
+    ensure
+      client.webcam.webcam_stop if webcam_started
+      print_status("Stopped")
     end
-    if wc_list.length > 0
-      begin
-        print_status("Starting...")
-        client.webcam.webcam_start(index)
-        data = client.webcam.webcam_get_frame(quality)
-        print_good("Got frame")
-      ensure
-        client.webcam.webcam_stop
-        print_status("Stopped")
-      end
 
-      if( data )
-        ::File.open( path, 'wb' ) do |fd|
-          fd.write( data )
-        end
-        path = ::File.expand_path( path )
-        print_line( "Webcam shot saved to: #{path}" )
-        Rex::Compat.open_file( path ) if view
+    if data
+      ::File.open(path, 'wb') do |fd|
+        fd.write(data)
       end
-      return true
-    else
-      print_error("No webcams where found")
-      return false
+      path = ::File.expand_path(path)
+      print_line("Webcam shot saved to: #{path}")
+      Rex::Compat.open_file(path) if view
     end
+    true
   end
 
   def cmd_webcam_chat(*args)
@@ -144,39 +138,42 @@ class Console::CommandDispatcher::Stdapi::Webcam
       "-s" => [ false, "WebSocket server" ]
     )
 
-    webcam_chat_opts.parse( args ) { | opt, idx, val |
+    webcam_chat_opts.parse(args) do |opt, _idx, val|
       case opt
-        when "-h"
-          print_line( "Usage: webcam_chat [options]\n" )
-          print_line( "Starts a video conversation with your target." )
-          print_line( "Browser Requirements:")
-          print_line( "Chrome: version 23 or newer" )
-          print_line( "Firefox: version 22 or newer" )
-          print_line( webcam_chat_opts.usage )
-          return
-        when "-s"
-          server = val.to_s
+      when "-h"
+        print_line("Usage: webcam_chat [options]\n")
+        print_line("Starts a video conversation with your target.")
+        print_line("Browser Requirements:")
+        print_line("Chrome: version 23 or newer")
+        print_line("Firefox: version 22 or newer")
+        print_line(webcam_chat_opts.usage)
+        return
+      when "-s"
+        server = val.to_s
       end
-    }
-
+    end
 
     begin
       print_status("Webcam chat session initialized.")
       client.webcam.webcam_chat(server)
-    rescue RuntimeError => e 
+    rescue RuntimeError => e
       print_error(e.message)
     end
   end
 
   def cmd_webcam_stream(*args)
+    if client.webcam.webcam_list.length == 0
+      print_error("Target does not have a webcam")
+      return
+    end
+
     print_status("Starting...")
-    stream_path    = Rex::Text.rand_text_alpha(8) + ".jpeg"
+    stream_path = Rex::Text.rand_text_alpha(8) + ".jpeg"
     player_path = Rex::Text.rand_text_alpha(8) + ".html"
     duration = 1800
     quality  = 50
     view     = true
     index    = 1
-    wc_list  = []
 
     webcam_snap_opts = Rex::Parser::Arguments.new(
       "-h" => [ false, "Help Banner" ],
@@ -188,30 +185,30 @@ class Console::CommandDispatcher::Stdapi::Webcam
       "-v" => [ true, "Automatically view the stream (Default: '#{view}')" ]
     )
 
-    webcam_snap_opts.parse( args ) { | opt, idx, val |
+    webcam_snap_opts.parse(args) do |opt, _idx, val|
       case opt
-        when "-h"
-          print_line( "Usage: webcam_stream [options]\n" )
-          print_line( "Stream from the specified webcam." )
-          print_line( webcam_snap_opts.usage )
-          return
-        when "-d"
-          duration = val.to_i
-        when "-i"
-          index = val.to_i
-        when "-q"
-          quality = val.to_i
-        when "-s"
-          stream_path = val
-        when "-t"
-          player_path = val
-        when "-v"
-          view = false if ( val =~ /^(f|n|0)/i )
+      when "-h"
+        print_line("Usage: webcam_stream [options]\n")
+        print_line("Stream from the specified webcam.")
+        print_line(webcam_snap_opts.usage)
+        return
+      when "-d"
+        duration = val.to_i
+      when "-i"
+        index = val.to_i
+      when "-q"
+        quality = val.to_i
+      when "-s"
+        stream_path = val
+      when "-t"
+        player_path = val
+      when "-v"
+        view = false if val =~ /^(f|n|0)/i
       end
-    }
+    end
 
     print_status("Preparing player...")
-    html = %Q|<html>
+    html = %|<html>
 <head>
 <META HTTP-EQUIV="PRAGMA" CONTENT="NO-CACHE">
 <META HTTP-EQUIV="CACHE-CONTROL" CONTENT="NO-CACHE">
@@ -264,7 +261,7 @@ Status     : <span id="status"></span>
     end
     if view
       print_status("Opening player at: #{player_path}")
-      Rex::Compat.open_file(player_path) 
+      Rex::Compat.open_file(player_path)
     else
       print_status("Please open the player manually with a browser: #{player_path}")
     end
@@ -272,72 +269,70 @@ Status     : <span id="status"></span>
     print_status("Streaming...")
     begin
       client.webcam.webcam_start(index)
-      ::Timeout.timeout(duration) {
+      webcam_started = true
+      ::Timeout.timeout(duration) do
         while client do
           data = client.webcam.webcam_get_frame(quality)
           if data
             ::File.open(stream_path, 'wb') do |f|
-             f.write(data)
+              f.write(data)
             end
             data = nil
           end
         end
-      }
+      end
     rescue ::Timeout::Error
     ensure
-      client.webcam.webcam_stop
+      client.webcam.webcam_stop if webcam_started
     end
 
     print_status("Stopped")
   end
 
   def cmd_record_mic(*args)
-    path    = Rex::Text.rand_text_alpha(8) + ".wav"
-    play    = true
-    duration   = 1
+    path = Rex::Text.rand_text_alpha(8) + ".wav"
+    play = true
+    duration = 1
 
     record_mic_opts = Rex::Parser::Arguments.new(
       "-h" => [ false, "Help Banner" ],
       "-d" => [ true, "Number of seconds to record (Default: 1)" ],
-      "-f" => [ true, "The wav file path (Default: '#{::File.expand_path( "[randomname].wav" )}')" ],
+      "-f" => [ true, "The wav file path (Default: '#{::File.expand_path('[randomname].wav')}')" ],
       "-p" => [ true, "Automatically play the captured audio (Default: '#{play}')" ]
     )
 
-    record_mic_opts.parse( args ) { | opt, idx, val |
+    record_mic_opts.parse(args) do |opt, _idx, val|
       case opt
-        when "-h"
-          print_line( "Usage: record_mic [options]\n" )
-          print_line( "Records audio from the default microphone." )
-          print_line( record_mic_opts.usage )
-          return
-        when "-d"
-          duration = val.to_i
-        when "-f"
-          path = val
-        when "-p"
-          play = false if ( val =~ /^(f|n|0)/i )
+      when "-h"
+        print_line("Usage: record_mic [options]\n")
+        print_line("Records audio from the default microphone.")
+        print_line(record_mic_opts.usage)
+        return
+      when "-d"
+        duration = val.to_i
+      when "-f"
+        path = val
+      when "-p"
+        play = false if val =~ /^(f|n|0)/i
       end
-    }
+    end
 
     print_status("Starting...")
     data = client.webcam.record_mic(duration)
     print_status("Stopped")
 
-    if( data )
-      ::File.open( path, 'wb' ) do |fd|
-        fd.write( data )
+    if data
+      ::File.open(path, 'wb') do |fd|
+        fd.write(data)
       end
-      path = ::File.expand_path( path )
-      print_line( "Audio saved to: #{path}" )
-      Rex::Compat.play_sound( path ) if play
+      path = ::File.expand_path(path)
+      print_line("Audio saved to: #{path}")
+      Rex::Compat.play_sound(path) if play
     end
-    return true
+    true
   end
-
 end
-
 end
 end
 end
 end
-