Land rapid7#9000, enhance module option registration

Author: busterb

lib/msf/core/opt.rb

@@ -1,7 +1,6 @@
 # -*- coding: binary -*-
 
 module Msf
-
   #
   # Builtin framework options with shortcut methods
   #
@@ -51,22 +50,19 @@ def self.RPORT(default=nil, required=true, desc="The target port")
       Msf::OptPort.new(__method__.to_s, [ required, desc, default ])
     end
 
-    # @return [OptEnum]
-    def self.SSLVersion
-      Msf::OptEnum.new('SSLVersion', [ false,
-        'Specify the version of SSL/TLS to be used (Auto, TLS and SSL23 are auto-negotiate)', 'Auto',
-        ['Auto', 'SSL2', 'SSL3', 'SSL23', 'TLS', 'TLS1', 'TLS1.1', 'TLS1.2']])
+    def self.ssl_supported_options
+      @m ||= ['Auto', 'TLS'] + OpenSSL::SSL::SSLContext::METHODS \
+             .select{|m| !m.to_s.include?('client') && !m.to_s.include?('server')} \
+             .select{|m| OpenSSL::SSL::SSLContext.new(m) && true rescue false} \
+             .map{|m| m.to_s.sub(/v/, '').sub('_', '.')}
     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
+    # @return [OptEnum]
+    def self.SSLVersion
+      Msf::OptEnum.new('SSLVersion',
+        'Specify the version of SSL/TLS to be used (Auto, TLS and SSL23 are auto-negotiate)',
+        enums: self.ssl_supported_options
+      )
     end
 
     CHOST = CHOST()
@@ -78,5 +74,4 @@ class << self
     RPORT = RPORT()
     SSLVersion = SSLVersion()
   end
-
 end

lib/msf/core/opt_base.rb

@@ -22,15 +22,39 @@ class OptBase
     # attrs[3] = possible enum values
     # attrs[4] = Regex to validate the option
     #
-    def initialize(in_name, attrs = [], aliases: [])
+    # Attrs can also be specified explicitly via named parameters, or attrs can
+    # also be a string as standin for the required description field.
+    #
+    def initialize(in_name, attrs = [],
+                   required: false, desc: nil, default: nil, enums: [], regex: nil, aliases: [])
       self.name     = in_name
       self.advanced = false
       self.evasion  = false
-      self.required = attrs[0] || false
-      self.desc     = attrs[1]
-      self.default  = attrs[2]
-      self.enums    = [ *(attrs[3]) ].map { |x| x.to_s }
-      regex_temp    = attrs[4] || nil
+      self.aliases  = aliases
+
+      if attrs.is_a?(String) || attrs.length == 0
+        self.required = required
+        self.desc     = attrs.is_a?(String) ? attrs : desc
+        self.enums    = [ *(enums) ].map { |x| x.to_s }
+        if default.nil? && enums.length > 0
+          self.default = enums[0]
+        else
+          self.default = default
+        end
+        regex_temp = regex
+      else
+        if attrs[0].nil?
+          self.required = required
+        else
+          self.required = attrs[0]
+        end
+        self.desc     = attrs[1] || desc
+        self.default  = attrs[2] || default
+        self.enums    = attrs[3] || enums
+        self.enums    = [ *(self.enums) ].map { |x| x.to_s }
+        regex_temp    = attrs[4] || regex
+      end
+
       if regex_temp
         # convert to string
         regex_temp = regex_temp.to_s if regex_temp.is_a? Regexp
@@ -45,35 +69,34 @@ def initialize(in_name, attrs = [], aliases: [])
           raise("Invalid Regex #{regex_temp}: #{e}")
         end
       end
-      self.aliases = aliases
     end
 
     #
     # Returns true if this is a required option.
     #
     def required?
-      return required
+      required
     end
 
     #
     # Returns true if this is an advanced option.
     #
     def advanced?
-      return advanced
+      advanced
     end
 
     #
     # Returns true if this is an evasion option.
     #
     def evasion?
-      return evasion
+      evasion
     end
 
     #
     # Returns true if the supplied type is equivalent to this option's type.
     #
     def type?(in_type)
-      return (type == in_type)
+      type == in_type
     end
 
     #
@@ -94,15 +117,15 @@ def valid?(value, check_empty: true)
       if regex
         return !!value.match(regex)
       end
-      return true
+      true
     end
 
     #
     # Returns true if the value supplied is nil and it's required to be
     # a valid value
     #
     def empty_required_value?(value)
-      return (required? and value.nil?)
+      required? && value.nil?
     end
 
     #
@@ -169,6 +192,4 @@ def display_value(value)
 
     attr_writer   :required, :desc, :default # :nodoc:
   end
-
 end
-

lib/msf/core/opt_bool.rb

@@ -1,48 +1,33 @@
 # -*- coding: binary -*-
 
 module Msf
+  # Boolean option type
+  class OptBool < OptBase
+    TRUE_REGEX = /^(y|yes|t|1|true)$/i
+    ANY_REGEX = /^(y|yes|n|no|t|f|0|1|true|false)$/i
+
+    # This overrides default from 'nil' to 'false'
+    def initialize(in_name, attrs = [],
+                   required: true, desc: nil, default: false, aliases: [])
+      super
+    end
 
-###
-#
-# Boolean option.
-#
-###
-class OptBool < OptBase
-
-  TrueRegex = /^(y|yes|t|1|true)$/i
-
-  def type
-    return 'bool'
-  end
-
-  def valid?(value, check_empty: true)
-    return false if empty_required_value?(value)
-
-    if ((value != nil and
-        (value.to_s.empty? == false) and
-        (value.to_s.match(/^(y|yes|n|no|t|f|0|1|true|false)$/i) == nil)))
-      return false
+    def type
+      return 'bool'
     end
 
-    true
-  end
+    def valid?(value, check_empty: true)
+      return false if check_empty && empty_required_value?(value)
+      return true if value.nil? && !required?
 
-  def normalize(value)
-    if(value.nil? or value.to_s.match(TrueRegex).nil?)
-      false
-    else
-      true
+      !(value.nil? ||
+        value.to_s.empty? ||
+        value.to_s.match(ANY_REGEX).nil?)
     end
-  end
-
-  def is_true?(value)
-    return normalize(value)
-  end
 
-  def is_false?(value)
-    return !is_true?(value)
+    def normalize(value)
+      !(value.nil? ||
+        value.to_s.match(TRUE_REGEX).nil?)
+    end
   end
-
-end
-
 end

lib/msf/core/opt_enum.rb

@@ -1,48 +1,49 @@
 # -*- coding: binary -*-
 
 module Msf
+  ###
+  #
+  # Enum option.
+  #
+  ###
+  class OptEnum < OptBase
+    def type
+      return 'enum'
+    end
 
-###
-#
-# Enum option.
-#
-###
-class OptEnum < OptBase
-
-  def type
-    return 'enum'
-  end
-
-  def valid?(value=self.value, check_empty: true)
-    return false if check_empty && empty_required_value?(value)
-    return true if value.nil? and !required?
-
-    (value and self.enums.include?(value.to_s))
-  end
-
-  def normalize(value=self.value)
-    return nil if not self.valid?(value)
-    return value.to_s
-  end
-
-  def desc=(value)
-    self.desc_string = value
+    # This overrides required default from 'false' to 'true'
+    def initialize(in_name, attrs = [],
+                   required: true, desc: nil, default: nil, enums: [], aliases: [])
+      super
+    end
 
-    self.desc
-  end
+    def valid?(value = self.value, check_empty: true)
+      return false if check_empty && empty_required_value?(value)
+      return true if value.nil? && !required?
 
-  def desc
-    if self.enums
-      str = self.enums.join(', ')
+      !value.nil? && enums.include?(value.to_s)
     end
-    "#{self.desc_string || ''} (Accepted: #{str})"
-  end
 
+    def normalize(value = self.value)
+      if valid?(value)
+        value.to_s
+      else
+        nil
+      end
+    end
 
-protected
+    def desc=(value)
+      self.desc_string = value
+      desc
+    end
 
-  attr_accessor :desc_string # :nodoc:
+    def desc
+      str = enums.join(', ') if enums
+      "#{desc_string || ''} (Accepted: #{str})"
+    end
 
-end
+    protected
 
+    attr_accessor :desc_string # :nodoc:
+  end
 end