contrast-agent 5.2.0 → 6.1.0

data/lib/contrast/config/heap_dump_configuration.rb

@@ -3,27 +3,31 @@
 
 module Contrast
   module Config
-    # Common Configuration settings. Those in this section pertain to the
-    # Heap Dump collection functionality of the Agent.
-    class HeapDumpConfiguration < BaseConfiguration
+    # Common Configuration settings. Those in this section pertain to the Heap Dump collection functionality of the
+    # Agent.
+    class HeapDumpConfiguration
+      include Contrast::Config::BaseConfiguration
+
       DEFAULT_PATH = 'contrast_heap_dumps' # saved
       DEFAULT_MS = 10_000
       DEFAULT_COUNT = 5
 
+      attr_writer :enable, :path, :delay_ms, :window_ms, :count, :clean
+
       def initialize hsh = {}
-        @enable = traverse_config(hsh, :enable)
-        @path = traverse_config(hsh, :path)
-        @delay_ms = traverse_config(hsh, :delay_ms)
-        @window_ms = traverse_config(hsh, :window_ms)
-        @count = traverse_config(hsh, :count)
-        @clean = traverse_config(hsh, :clean)
-        @configuration_map = {}
-        build_configuration_map
+        return unless hsh
+
+        @enable = hsh[:enable]
+        @path = hsh[:path]
+        @delay_ms = hsh[:delay_ms]
+        @window_ms = hsh[:window_ms]
+        @count = hsh[:count]
+        @clean = hsh[:clean]
       end
 
-      # @return [Boolean, false] should dumps be taken
+      # @return [Boolean, Contrast::Utils::ObjectShare::FALSE] should dumps be taken
       def enable
-        !!@enable
+        @enable.nil? ? Contrast::Utils::ObjectShare::FALSE : @enable
       end
 
       # @return [String, DEFAULT_PATH] dir to which dumps should be
@@ -46,67 +50,9 @@ module Contrast
         @count ||= DEFAULT_COUNT
       end
 
-      # @return [Boolean, false] remove temporary objects or not
+      # @return [Boolean, Contrast::Utils::ObjectShare::FALSE] remove temporary objects or not
       def clean
-        !!@clean
-      end
-
-      def enable= value
-        self['enable'] = value
-      end
-
-      def path= value
-        self['path'] = value
-      end
-
-      def delay_ms= value
-        self['delay_ms'] = value
-      end
-
-      def window_ms= value
-        self['window_ms'] = value
-      end
-
-      def count= value
-        self['count'] = value
-      end
-
-      def clean= value
-        self['clean'] = value
-      end
-
-      # TODO: RUBY-1493 MOVE TO BASE CONFIG
-
-      def []= key, value
-        instance_variable_set("@#{ key }".to_sym, value)
-        @configuration_map[key] = value
-      end
-
-      def [] key
-        send(key.to_sym)
-      end
-
-      # Traverse the given entity to build out the configuration graph.
-      #
-      # The values will be either a hash, indicating internal nodes to
-      # traverse, or a value to set or the EMPTY_VALUE symbol, indicating a
-      # leaf node.
-      #
-      # The spec_key are the Contrast defined keys based on the instance variables of
-      # a given configuration.
-      def traverse_config values, spec_key
-        internal_nodes = values.cs__respond_to?(:has_key?)
-        val = internal_nodes ? value_from_key_config(spec_key, values) : nil
-        val == EMPTY_VALUE ? nil : val
-      end
-
-      def build_configuration_map
-        instance_variables.each do |key|
-          str_key = key.to_s.tr('@', '')
-          next if str_key == 'configuration_map'
-
-          @configuration_map[str_key] = send(str_key.to_sym)
-        end
+        @clean.nil? ? Contrast::Utils::ObjectShare::FALSE : @clean
       end
     end
   end

data/lib/contrast/config/inventory_configuration.rb

@@ -3,18 +3,20 @@
 
 module Contrast
   module Config
-    # Common Configuration settings. Those in this section pertain to the
-    # inventory functionality of the Agent.
-    class InventoryConfiguration < BaseConfiguration
+    # Common Configuration settings. Those in this section pertain to the inventory functionality of the Agent.
+    class InventoryConfiguration
+      include Contrast::Config::BaseConfiguration
+
       # @return [Array, nil] tags
-      attr_reader :tags
+      attr_accessor :tags
+      attr_writer :enable, :analyze_libraries
 
       def initialize hsh = {}
-        @enable = traverse_config(hsh, :enable)
-        @analyze_libraries = traverse_config(hsh, :analyze_libraries)
-        @tags = traverse_config(hsh, :tags)
-        @configuration_map = {}
-        build_configuration_map
+        return unless hsh
+
+        @enable = hsh[:enable]
+        @analyze_libraries = hsh[:analyze_libraries]
+        @tags = hsh[:tags]
       end
 
       # @return [Boolean, true]
@@ -26,52 +28,6 @@ module Contrast
       def analyze_libraries
         @analyze_libraries.nil? ? true : @analyze_libraries
       end
-
-      def enable= value
-        self['enable'] = value
-      end
-
-      def analyze_libraries= value
-        self['analyze_libraries'] = value
-      end
-
-      def tags= value
-        self['tags'] = value
-      end
-
-      # TODO: RUBY-1493 MOVE TO BASE CONFIG
-
-      def []= key, value
-        instance_variable_set("@#{ key }".to_sym, value)
-        @configuration_map[key] = value
-      end
-
-      def [] key
-        send(key.to_sym)
-      end
-
-      # Traverse the given entity to build out the configuration graph.
-      #
-      # The values will be either a hash, indicating internal nodes to
-      # traverse, or a value to set or the EMPTY_VALUE symbol, indicating a
-      # leaf node.
-      #
-      # The spec_key are the Contrast defined keys based on the instance variables of
-      # a given configuration.
-      def traverse_config values, spec_key
-        internal_nodes = values.cs__respond_to?(:has_key?)
-        val = internal_nodes ? value_from_key_config(spec_key, values) : nil
-        val == EMPTY_VALUE ? nil : val
-      end
-
-      def build_configuration_map
-        instance_variables.each do |key|
-          str_key = key.to_s.tr('@', '')
-          next if str_key == 'configuration_map'
-
-          @configuration_map[str_key] = send(str_key.to_sym)
-        end
-      end
     end
   end
 end

data/lib/contrast/config/logger_configuration.rb

@@ -3,9 +3,10 @@
 
 module Contrast
   module Config
-    # Common Configuration settings. Those in this section pertain to the
-    # logging in the Agent.
-    class LoggerConfiguration < BaseConfiguration
+    # Common Configuration settings. Those in this section pertain to the logging in the Agent.
+    class LoggerConfiguration
+      include Contrast::Config::BaseConfiguration
+
       # @return [String, nil]
       attr_accessor :path
       # @return [String, nil]
@@ -14,45 +15,11 @@ module Contrast
       attr_accessor :progname
 
       def initialize hsh = {}
-        @path = traverse_config(hsh, :path)
-        @level = traverse_config(hsh, :level)
-        @progname = traverse_config(hsh, :progname)
-        @configuration_map = {}
-        build_configuration_map
-      end
-
-      # TODO: RUBY-1493 MOVE TO BASE CONFIG
-
-      def []= key, value
-        instance_variable_set("@#{ key }".to_sym, value)
-        @configuration_map[key] = value
-      end
-
-      def [] key
-        send(key.to_sym)
-      end
-
-      # Traverse the given entity to build out the configuration graph.
-      #
-      # The values will be either a hash, indicating internal nodes to
-      # traverse, or a value to set or the EMPTY_VALUE symbol, indicating a
-      # leaf node.
-      #
-      # The spec_key are the Contrast defined keys based on the instance variables of
-      # a given configuration.
-      def traverse_config values, spec_key
-        internal_nodes = values.cs__respond_to?(:has_key?)
-        val = internal_nodes ? value_from_key_config(spec_key, values) : nil
-        val == EMPTY_VALUE ? nil : val
-      end
-
-      def build_configuration_map
-        instance_variables.each do |key|
-          str_key = key.to_s.tr('@', '')
-          next if str_key == 'configuration_map'
+        return unless hsh
 
-          @configuration_map[str_key] = send(str_key.to_sym)
-        end
+        @path = hsh[:path]
+        @level = hsh[:level]
+        @progname = hsh[:progname]
       end
     end
   end

data/lib/contrast/config/protect_configuration.rb

@@ -3,17 +3,30 @@
 
 module Contrast
   module Config
-    # Common Configuration settings. Those in this section pertain to the
-    # protect functionality of the Agent.
-    class ProtectConfiguration < BaseConfiguration
-      KEYS = {
-          exceptions: Contrast::Config::ExceptionConfiguration,
-          rules: Contrast::Config::ProtectRulesConfiguration,
-          enable: EMPTY_VALUE
-      }.cs__freeze
+    # Common Configuration settings. Those in this section pertain to the protect functionality of the Agent.
+    class ProtectConfiguration
+      include Contrast::Config::BaseConfiguration
 
-      def initialize hsh
-        super(hsh, KEYS)
+      # @return [Boolean, nil]
+      attr_accessor :enable
+      attr_writer :exceptions, :rules
+
+      def initialize hsh = {}
+        return unless hsh
+
+        @exceptions = Contrast::Config::ExceptionConfiguration.new(hsh[:exceptions])
+        @rules = Contrast::Config::ProtectRulesConfiguration.new(hsh[:rules])
+        @enable = hsh[:enable]
+      end
+
+      # @return [Contrast::Config::ExceptionConfiguration]
+      def exceptions
+        @exceptions ||= Contrast::Config::ExceptionConfiguration.new
+      end
+
+      # @return [Contrast::Config::ProtectRulesConfiguration]
+      def rules
+        @rules ||= Contrast::Config::ProtectRulesConfiguration.new
       end
     end
   end

data/lib/contrast/config/protect_rule_configuration.rb

@@ -5,18 +5,31 @@ require 'set'
 
 module Contrast
   module Config
-    # Common Configuration settings. Those in this section pertain to the
-    # rule mode of a single protect rule in the Agent.
-    class ProtectRuleConfiguration < BaseConfiguration
-      attr_accessor :enable, :mode, :disable_system_commands, :detect_custom_code_accessing_system_files
+    # Common Configuration settings. Those in this section pertain to the rule mode of a single protect rule in the
+    # Agent.
+    class ProtectRuleConfiguration
+      include Contrast::Config::BaseConfiguration
+
+      # @return [Boolean, nil]
+      attr_accessor :enable
+      # @return [String, nil]
+      attr_accessor :mode
+      # @return [Boolean, nil]
+      attr_accessor :disable_system_commands
+      attr_writer :detect_custom_code_accessing_system_files
 
       def initialize hsh = {}
-        @enable = traverse_config(hsh, :enable)
-        @mode = traverse_config(hsh, :mode)
-        @disable_system_commands = traverse_config(hsh, :disable_system_commands)
-        @detect_custom_code_accessing_system_files = traverse_config(hsh, :detect_custom_code_accessing_system_files)
-        @configuration_map = {}
-        build_configuration_map
+        return unless hsh
+
+        @enable = hsh[:enable]
+        @mode = hsh[:mode]
+        @disable_system_commands = hsh[:disable_system_commands]
+        @detect_custom_code_accessing_system_files = hsh[:detect_custom_code_accessing_system_files]
+      end
+
+      # @return [Boolean, true]
+      def detect_custom_code_accessing_system_files
+        @detect_custom_code_accessing_system_files.nil? ? true : @detect_custom_code_accessing_system_files
       end
 
       # To convert the user input mode from config to a standard format used by TS & SR, we need to convert the given
@@ -40,33 +53,6 @@ module Contrast
           Contrast::Api::Settings::ProtectionRule::Mode::NO_ACTION
         end
       end
-
-      def [] key
-        send(key.to_sym)
-      end
-
-      # Traverse the given entity to build out the configuration graph.
-      #
-      # The values will be either a hash, indicating internal nodes to
-      # traverse, or a value to set or the EMPTY_VALUE symbol, indicating a
-      # leaf node.
-      #
-      # The spec_key are the Contrast defined keys based on the instance variables of
-      # a given configuration.
-      def traverse_config values, spec_key
-        internal_nodes = values.cs__respond_to?(:has_key?)
-        val = internal_nodes ? value_from_key_config(spec_key, values) : nil
-        val == EMPTY_VALUE ? nil : val
-      end
-
-      def build_configuration_map
-        instance_variables.each do |key|
-          str_key = key.to_s.tr('@', '')
-          next if str_key == 'configuration_map'
-
-          @configuration_map[str_key] = send(str_key.to_sym)
-        end
-      end
     end
   end
 end

data/lib/contrast/config/protect_rules_configuration.rb

@@ -5,30 +5,31 @@ require 'contrast/config/protect_rule_configuration'
 
 module Contrast
   module Config
-    # Common Configuration settings. Those in this section pertain to the
-    # protect rule modes of the Agent.
-    class ProtectRulesConfiguration < BaseConfiguration
-      attr_reader :disabled_rules
+    # Common Configuration settings. Those in this section pertain to the protect rule modes of the Agent.
+    class ProtectRulesConfiguration
+      include Contrast::Config::BaseConfiguration
+
+      attr_accessor :disabled_rules
+      attr_writer :bot_blocker, :cmd_injection, :sql_injection, :nosql_injection, :untrusted_deserialization,
+                  :method_tampering, :xxe, :path_traversal, :reflected_xss, :unsafe_file_upload, :rule_base
 
       BASE_RULE = 'Contrast::Agent::Protect::Rule::Base'.cs__freeze
 
       def initialize hsh = {}
-        @disabled_rules = traverse_config(hsh, :disabled_rules)
-        @bot_blocker = Contrast::Config::ProtectRuleConfiguration.new(traverse_config(hsh, 'bot-blocker'))
-        @cmd_injection = Contrast::Config::ProtectRuleConfiguration.new(traverse_config(hsh, 'cmd-injection'))
-        @sql_injection = Contrast::Config::ProtectRuleConfiguration.new(traverse_config(hsh, 'sql-injection'))
-        @nosql_injection = Contrast::Config::ProtectRuleConfiguration.new(traverse_config(hsh, 'nosql-injection'))
-        @untrusted_deserialization = Contrast::Config::ProtectRuleConfiguration.new(traverse_config(
-                                                                                        hsh,
-                                                                                        'untrusted-deserialization'))
-        @method_tampering = Contrast::Config::ProtectRuleConfiguration.new(traverse_config(hsh, 'method-tampering'))
-        @xxe = Contrast::Config::ProtectRuleConfiguration.new(traverse_config(hsh, :xxe))
-        @path_traversal = Contrast::Config::ProtectRuleConfiguration.new(traverse_config(hsh, 'path-traversal'))
-        @reflected_xss = Contrast::Config::ProtectRuleConfiguration.new(traverse_config(hsh, 'reflected-xss'))
-        @unsafe_file_upload = Contrast::Config::ProtectRuleConfiguration.new(traverse_config(hsh, 'unsafe-file-upload'))
-        @rule_base = Contrast::Config::ProtectRuleConfiguration.new(traverse_config(hsh, BASE_RULE))
-        @configuration_map = {}
-        build_configuration_map
+        return unless hsh
+
+        @disabled_rules = hsh[:disabled_rules]
+        @rule_base = Contrast::Config::ProtectRuleConfiguration.new(hsh[BASE_RULE.to_sym])
+        @bot_blocker = Contrast::Config::ProtectRuleConfiguration.new(hsh[:'bot-blocker'])
+        @cmd_injection = Contrast::Config::ProtectRuleConfiguration.new(hsh[:'cmd-injection'])
+        @method_tampering = Contrast::Config::ProtectRuleConfiguration.new(hsh[:'method-tampering'])
+        @nosql_injection = Contrast::Config::ProtectRuleConfiguration.new(hsh[:'nosql-injection'])
+        @path_traversal = Contrast::Config::ProtectRuleConfiguration.new(hsh[:'path-traversal'])
+        @reflected_xss = Contrast::Config::ProtectRuleConfiguration.new(hsh[:'reflected-xss'])
+        @sql_injection = Contrast::Config::ProtectRuleConfiguration.new(hsh[:'sql-injection'])
+        @unsafe_file_upload = Contrast::Config::ProtectRuleConfiguration.new(hsh[:'unsafe-file-upload'])
+        @untrusted_deserialization = Contrast::Config::ProtectRuleConfiguration.new(hsh[:'untrusted-deserialization'])
+        @xxe = Contrast::Config::ProtectRuleConfiguration.new(hsh[:xxe])
       end
 
       def bot_blocker
@@ -75,33 +76,28 @@ module Contrast
         @rule_base ||= Contrast::Config::ProtectRuleConfiguration.new
       end
 
+      def []= key, value
+        instance_variable_set("@#{ convert_key(key) }".to_sym, value)
+      end
+
       def [] key
-        send(return_proper_class(key).to_sym)
+        send(convert_key(key).to_sym)
       end
 
-      # Traverse the given entity to build out the configuration graph.
-      #
-      # The values will be either a hash, indicating internal nodes to
-      # traverse, or a value to set or the EMPTY_VALUE symbol, indicating a
-      # leaf node.
-      #
-      # The spec_key are the Contrast defined keys based on the instance variables of
-      # a given configuration.
-      def traverse_config values, spec_key
-        internal_nodes = values.cs__respond_to?(:has_key?)
-        val = internal_nodes ? value_from_key_config(spec_key, values) : nil
-        val == EMPTY_VALUE ? nil : val
-      end
-
-      def build_configuration_map
-        change_vals = { '@' => '', '-' => '_' }
-        regexp = Regexp.union(change_vals.keys)
-        instance_variables.each do |key|
-          str_key = key.to_s.gsub(regexp, change_vals)
-          next if str_key == 'configuration_map'
-
-          @configuration_map[return_proper_class(str_key)] = send(str_key.to_sym)
+      def convert_key key
+        return_proper_class(key).to_s.tr('-', '_')
+      end
+
+      # Convert instance variable names to format expected by TS
+      # for adding to the hash
+      def to_hash
+        hsh = {}
+        instance_variables.each do |iv|
+          # strip the '@' to get the key
+          key = return_proper_class(iv.to_s.delete('@'))
+          hsh[key.tr('_', '-')] = send(key.to_sym)
         end
+        hsh
       end
 
       # This method is to handle the specific case of

data/lib/contrast/config/request_audit_configuration.rb

@@ -3,81 +3,42 @@
 
 module Contrast
   module Config
-    # This class holds the Common Settings for the
-    # hidden functionality of the TS
-    class RequestAuditConfiguration < BaseConfiguration
+    # This class holds the Common Settings for the hidden functionality of the TS
+    class RequestAuditConfiguration
+      include Contrast::Config::BaseConfiguration
+
       DEFAULT_PATH = './messages'
 
+      attr_writer :enable, :requests, :responses, :path
+
       def initialize hsh = {}
-        @enable = traverse_config(hsh, :enable)
-        @requests = traverse_config(hsh, :requests)
-        @responses = traverse_config(hsh, :responses)
-        @path = traverse_config(hsh, :path)
-        @configuration_map = {}
-        build_configuration_map
+        return unless hsh
+
+        @enable = hsh[:enable]
+        @requests = hsh[:requests]
+        @responses = hsh[:responses]
+        @path = hsh[:path]
       end
 
+      # @return [Boolean, false]
       def enable
         @enable.nil? ? false : @enable
       end
 
+      # @return [Boolean, false]
       def requests
         @requests.nil? ? false : @requests
       end
 
+      # @return [Boolean, false]
       def responses
         @responses.nil? ? false : @responses
       end
 
+      # @return [String, ::DEFAULT_PATH]
       def path
         @path.nil? ? DEFAULT_PATH : @path
       end
-
-      def enable= value
-        self['enable'] = value
-      end
-
-      def requests= value
-        self['requests'] = value
-      end
-
-      def responses= value
-        self['responses'] = value
-      end
-
-      def path= value
-        self['path'] = value
-      end
-
-      # TODO: RUBY-1493 MOVE TO BASE CONFIG
-
-      def []= key, value
-        instance_variable_set("@#{ key }".to_sym, value)
-        @configuration_map[key] = value
-      end
-
-      # Traverse the given entity to build out the configuration graph.
-      #
-      # The values will be either a hash, indicating internal nodes to
-      # traverse, or a value to set or the EMPTY_VALUE symbol, indicating a
-      # leaf node.
-      #
-      # The spec_key are the Contrast defined keys based on the instance variables of
-      # a given configuration.
-      def traverse_config values, spec_key
-        internal_nodes = values.cs__respond_to?(:has_key?)
-        val = internal_nodes ? value_from_key_config(spec_key, values) : nil
-        val == EMPTY_VALUE ? nil : val
-      end
-
-      def build_configuration_map
-        instance_variables.each do |key|
-          str_key = key.to_s.tr('@', '')
-          next if str_key == 'configuration_map'
-
-          @configuration_map[str_key] = send(str_key.to_sym)
-        end
-      end
     end
   end
 end

data/lib/contrast/config/root_configuration.rb

@@ -4,23 +4,80 @@
 module Contrast
   module Config
     # The base of the Common Configuration settings.
-    class RootConfiguration < BaseConfiguration
-      KEYS = {
-          api: Contrast::Config::ApiConfiguration,
-          enable: BaseConfiguration::EMPTY_VALUE,
-          agent: Contrast::Config::AgentConfiguration,
-          application: Contrast::Config::ApplicationConfiguration,
-          server: Contrast::Config::ServerConfiguration,
-          assess: Contrast::Config::AssessConfiguration,
-          inventory: Contrast::Config::InventoryConfiguration,
-          protect: Contrast::Config::ProtectConfiguration,
-          service: Contrast::Config::ServiceConfiguration
-      }.cs__freeze
+    class RootConfiguration
+      include Contrast::Config::BaseConfiguration
+
+      # @return [Contrast::Config::ApiConfiguration]
+      attr_writer :api
+      # @return [Contrast::Config::AgentConfiguration]
+      attr_writer :agent
+      # @return [Contrast::Config::ApplicationConfiguration]
+      attr_writer :application
+      # @return [Contrast::Config::ServerConfiguration]
+      attr_writer :server
+      # @return [Contrast::Config::AssessConfiguration]
+      attr_writer :assess
+      # @return [Contrast::Config::InventoryConfiguration]
+      attr_writer :inventory
+      # @return [Contrast::Config::ProtectConfiguration]
+      attr_writer :protect
+      # @return [Contrast::Config::ServiceConfiguration]
+      attr_writer :service
+      # @return [Boolean, nil]
+      attr_accessor :enable
 
       def initialize hsh = {}
         raise ArgumentError, 'Expected a hash' unless hsh.is_a?(Hash)
 
-        super(hsh, KEYS)
+        @api = Contrast::Config::ApiConfiguration.new(hsh[:api])
+        @enable = hsh[:enable]
+        @agent = Contrast::Config::AgentConfiguration.new(hsh[:agent])
+        @application = Contrast::Config::ApplicationConfiguration.new(hsh[:application])
+        @server = Contrast::Config::ServerConfiguration.new(hsh[:server])
+        @assess = Contrast::Config::AssessConfiguration.new(hsh[:assess])
+        @inventory = Contrast::Config::InventoryConfiguration.new(hsh[:inventory])
+        @protect = Contrast::Config::ProtectConfiguration.new(hsh[:protect])
+        @service = Contrast::Config::ServiceConfiguration.new(hsh[:service])
+      end
+
+      # @return [Contrast::Config::ApiConfiguration]
+      def api
+        @api ||= Contrast::Config::ApiConfiguration.new
+      end
+
+      # @return [Contrast::Config::AgentConfiguration]
+      def agent
+        @agent ||= Contrast::Config::AgentConfiguration.new
+      end
+
+      # @return [Contrast::Config::ApplicationConfiguration]
+      def application
+        @application ||= Contrast::Config::ApplicationConfiguration.new
+      end
+
+      # @return [Contrast::Config::ServerConfiguration]
+      def server
+        @server ||= Contrast::Config::ServerConfiguration.new
+      end
+
+      # @return [Contrast::Config::AssessConfiguration]
+      def assess
+        @assess ||= Contrast::Config::AssessConfiguration.new
+      end
+
+      # @return [Contrast::Config::InventoryConfiguration]
+      def inventory
+        @inventory ||= Contrast::Config::InventoryConfiguration.new
+      end
+
+      # @return [Contrast::Config::ProtectConfiguration]
+      def protect
+        @protect ||= Contrast::Config::ProtectConfiguration.new
+      end
+
+      # @return [Contrast::Config::ServiceConfiguration]
+      def service
+        @service ||= Contrast::Config::ServiceConfiguration.new
       end
     end
   end