Merge branch 'upstream/master' into connection-recovery

Author: OJ

Gemfile.lock

@@ -177,7 +177,7 @@ GEM
       json (~> 1.4)
     recog (1.0.27)
       nokogiri
-    redcarpet (3.1.2)
+    redcarpet (3.2.3)
     rkelly-remix (0.0.6)
     robots (0.10.1)
     rspec (2.99.0)

data/meterpreter/meterpreter.py

@@ -749,7 +749,7 @@ def create_response(self, request):
 		resp = struct.pack('>I', len(resp) + 4) + resp
 		return resp
 
-if not hasattr(os, 'fork') or (hasattr(os, 'fork') and os.fork() == 0):
+if not hasattr(os, 'fork') or has_osxsc or (hasattr(os, 'fork') and os.fork() == 0):
 	if hasattr(os, 'setsid'):
 		try:
 			os.setsid()

lib/metasploit/framework/login_scanner/http.rb

@@ -224,7 +224,7 @@ def send_request(opts)
           configure_http_client(cli)
 
           if realm
-            cli.set_config('domain' => credential.realm)
+            cli.set_config('domain' => realm)
           end
 
           begin

lib/msf/core/db_manager/import/nmap.rb

@@ -164,9 +164,7 @@ def import_nmap_xml(args={}, &block)
         data[:host]  = hobj || addr
         data[:info]  = extra if not extra.empty?
         data[:task]  = args[:task]
-        if p["name"] != "unknown"
-          data[:name] = p["name"]
-        end
+        data[:name]  = p['tunnel'] ? "#{p['tunnel']}/#{p['name'] || 'unknown'}" : p['name']
         report_service(data)
       }
       #Parse the scripts output

lib/msf/core/exploit.rb

@@ -1218,10 +1218,31 @@ def reset_session_counts
   # Failure tracking
   ##
 
+  # Raises a Msf::Exploit::Failed exception. It overrides the fail_with method
+  # in lib/msf/core/module.rb
+  #
+  # @param reason [String] A constant from Msf::Module::Failure.
+  #                        If the reason does not come from there, then it will default to
+  #                        Msf::Module::Failure::Unknown.
+  # @param msg [String] (Optional) A message about the failure.
+  # @raise [Msf::Exploit::Failed] A custom Msf::Exploit::Failed exception.
+  # @return [void]
+  # @see Msf::Module::Failure
+  # @see Msf::Module#fail_with
+  # @example
+  #   fail_with(Msf::Module::Failure::NoAccess, 'Unable to login to upload payload')
   def fail_with(reason,msg=nil)
-    self.fail_reason = reason
+    # The reason being registered here will be used later on, so it's important we don't actually
+    # provide a made-up one.
+    allowed_values = Msf::Module::Failure.constants.collect {|e| Msf::Module::Failure.const_get(e)}
+    if allowed_values.include?(reason)
+      self.fail_reason = reason
+    else
+      self.fail_reason = Msf::Module::Failure::Unknown
+    end
+
     self.fail_detail = msg
-    raise Msf::Exploit::Failed, (msg || "No reason given")
+    raise Msf::Exploit::Failed, (msg || "No failure message given")
   end
 
   def report_failure

lib/msf/core/handler/reverse_http.rb

@@ -163,7 +163,9 @@ def setup_handler
   def stop_handler
     if self.service
       self.service.remove_resource("/")
-      Rex::ServiceManager.stop_service(self.service) if self.sessions == 0
+      if self.service.resources.empty? && self.sessions == 0
+        Rex::ServiceManager.stop_service(self.service)
+      end
     end
   end
 

lib/msf/core/module.rb

@@ -3,6 +3,8 @@
 
 module Msf
 
+  autoload :OptionContainer, 'msf/core/option_container'
+
 ###
 #
 # The module base class is responsible for providing the common interface
@@ -276,7 +278,18 @@ def debugging?
   end
 
   #
-  # Support fail_with for all module types, allow specific classes to override
+  # Raises a RuntimeError failure message. This is meant to be used for all non-exploits,
+  # and allows specific classes to override.
+  #
+  # @param reason [String] A reason about the failure.
+  # @param msg [String] (Optional) A message about the failure.
+  # @raise [RuntimeError]
+  # @return [void]
+  # @note If you are writing an exploit, you don't use this API. Instead, please refer to the
+  #       API documentation from lib/msf/core/exploit.rb.
+  # @see Msf::Exploit#fail_with
+  # @example
+  #   fail_with('No Access', 'Unable to login')
   #
   def fail_with(reason, msg=nil)
     raise RuntimeError, "#{reason.to_s}: #{msg}"

lib/msf/core/opt.rb

@@ -0,0 +1,74 @@
+# -*- coding: binary -*-
+
+module Msf
+
+  #
+  # Builtin framework options with shortcut methods
+  #
+  # @example
+  #   register_options(
+  #     [
+  #       Opt::RHOST,
+  #       Opt::RPORT(21),
+  #     ]
+  #   )
+  #   register_advanced_options([Opt::Proxies])
+  #
+  module Opt
+
+    # @return [OptAddress]
+    def self.CHOST(default=nil, required=false, desc="The local client address")
+      Msf::OptAddress.new(__method__.to_s, [ required, desc, default ])
+    end
+
+    # @return [OptPort]
+    def self.CPORT(default=nil, required=false, desc="The local client port")
+      Msf::OptPort.new(__method__.to_s, [ required, desc, default ])
+    end
+
+    # @return [OptAddress]
+    def self.LHOST(default=nil, required=true, desc="The listen address")
+      Msf::OptAddress.new(__method__.to_s, [ required, desc, default ])
+    end
+
+    # @return [OptPort]
+    def self.LPORT(default=nil, required=true, desc="The listen port")
+      Msf::OptPort.new(__method__.to_s, [ required, desc, default ])
+    end
+
+    # @return [OptString]
+    def self.Proxies(default=nil, required=false, desc="A proxy chain of format type:host:port[,type:host:port][...]")
+      Msf::OptString.new(__method__.to_s, [ required, desc, default ])
+    end
+
+    # @return [OptAddress]
+    def self.RHOST(default=nil, required=true, desc="The target address")
+      Msf::OptAddress.new(__method__.to_s, [ required, desc, default ])
+    end
+
+    # @return [OptPort]
+    def self.RPORT(default=nil, required=true, desc="The target port")
+      Msf::OptPort.new(__method__.to_s, [ required, desc, default ])
+    end
+
+    # These are unused but remain for historical reasons
+    class << self
+      alias builtin_chost CHOST
+      alias builtin_cport CPORT
+      alias builtin_lhost LHOST
+      alias builtin_lport LPORT
+      alias builtin_proxies Proxies
+      alias builtin_rhost RHOST
+      alias builtin_rport RPORT
+    end
+
+    CHOST = CHOST()
+    CPORT = CPORT()
+    LHOST = LHOST()
+    LPORT = LPORT()
+    Proxies = Proxies()
+    RHOST = RHOST()
+    RPORT = RPORT()
+  end
+
+end

lib/msf/core/opt_address.rb

@@ -0,0 +1,37 @@
+# -*- coding: binary -*-
+
+module Msf
+
+###
+#
+# Network address option.
+#
+###
+class OptAddress < OptBase
+  def type
+    return 'address'
+  end
+
+  def valid?(value)
+    return false if empty_required_value?(value)
+    return false unless value.kind_of?(String) or value.kind_of?(NilClass)
+
+    if (value != nil and value.empty? == false)
+      begin
+        getaddr_result = ::Rex::Socket.getaddress(value, true)
+        # Covers a wierdcase where an incomplete ipv4 address will have it's
+        # missing octets filled in  with 0's. (e.g 192.168 become 192.0.0.168)
+        # which does not feel like a legit behaviour
+        if value =~ /^\d{1,3}(\.\d{1,3}){1,3}$/
+          return false unless value =~ Rex::Socket::MATCH_IPV4
+        end
+      rescue
+        return false
+      end
+    end
+
+    return super
+  end
+end
+
+end

lib/msf/core/opt_address_range.rb

@@ -0,0 +1,51 @@
+# -*- coding: binary -*-
+
+module Msf
+
+###
+#
+# Network address range option.
+#
+###
+class OptAddressRange < OptBase
+  def type
+    return 'addressrange'
+  end
+
+  def normalize(value)
+    return nil unless value.kind_of?(String)
+    if (value =~ /^file:(.*)/)
+      path = $1
+      return false if not File.exists?(path) or File.directory?(path)
+      return File.readlines(path).map{ |s| s.strip}.join(" ")
+    elsif (value =~ /^rand:(.*)/)
+      count = $1.to_i
+      return false if count < 1
+      ret = ''
+      count.times {
+        ret << " " if not ret.empty?
+        ret << [ rand(0x100000000) ].pack("N").unpack("C*").map{|x| x.to_s }.join(".")
+      }
+      return ret
+    end
+    return value
+  end
+
+  def valid?(value)
+    return false if empty_required_value?(value)
+    return false unless value.kind_of?(String) or value.kind_of?(NilClass)
+
+    if (value != nil and value.empty? == false)
+      normalized = normalize(value)
+      return false if normalized.nil?
+      walker = Rex::Socket::RangeWalker.new(normalized)
+      if (not walker or not walker.valid?)
+        return false
+      end
+    end
+
+    return super
+  end
+end
+
+end