contrast-agent 5.3.0 → 6.0.0

data/lib/contrast/config/base_configuration.rb

@@ -12,21 +12,24 @@ module Contrast
     class BaseConfiguration
       extend Forwardable
 
-      attr_reader :configuration_map
-
-      alias_method :to_hash, :configuration_map
-      def_delegators :@configuration_map, :empty?, :key?, :delete, :fetch,
-                     :[], :[]=, :each, :each_pair, :each_key, :each_value
-
       EMPTY_VALUE = :EMPTY_VALUE
 
       def initialize hsh = {}, keys = {}
         # holds configuration key value pairs
         # each configuration class can contain nested BaseConfigurations
-        @configuration_map = {}
         traverse_config(hsh, keys)
       end
 
+      def to_hash
+        hsh = {}
+        instance_variables.each do |iv|
+          # strip the '@' to get the key
+          key = iv.to_s[1..]
+          hsh[key] = send(key.to_sym)
+        end
+        hsh
+      end
+
       def assign_value_to_path_array dot_path_array, value
         current_level = self
         dot_path_array[0...-1].each do |segment|
@@ -40,10 +43,6 @@ module Contrast
         nil
       end
 
-      def nil?
-        @configuration_map.empty?
-      end
-
       private
 
       # Traverse the given entity to build out the configuration graph.
@@ -52,51 +51,19 @@ module Contrast
       # traverse, or a value to set or the EMPTY_VALUE symbol, indicating a
       # leaf node.
       #
-      # The spec_keys are the Contrast defined keys used to access a given
-      # configuration. Each child of this class maintains its own set of keys,
-      # as well as Objects to which those keys map.
-      def traverse_config values, spec_keys
+      # 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?)
-        spec_keys.each_pair do |spec_key, spec_value|
-          user_provided_value = internal_nodes ? value_from_key_config(spec_key, values) : EMPTY_VALUE
-          define_methods(spec_key, spec_value, user_provided_value)
-        end
-      end
-
-      def define_methods spec_key, spec_value, user_provided_value
-        str_key = spec_key.to_s
-        assign_config_value(str_key, spec_value, user_provided_value)
-        define_getter(str_key)
-        define_setter(str_key)
-      end
-
-      def assign_config_value str_key, spec_value, user_provided_value
-        @configuration_map[str_key] = if spec_value.is_a?(Class) && spec_value <= Contrast::Config::BaseConfiguration
-                                        spec_value.new(user_provided_value)
-                                      elsif user_provided_value == EMPTY_VALUE
-                                        spec_value
-                                      else
-                                        user_provided_value
-                                      end
+        val = internal_nodes ? value_from_key_config(spec_key, values) : nil
+        val == EMPTY_VALUE ? nil : val
       end
 
       def value_from_key_config key, config_hash
         return config_hash[key] if config_hash.key?(key)
-        return config_hash.fetch(key.to_sym, EMPTY_VALUE) if key.is_a?(String)
-
-        config_hash.fetch(key.to_s, EMPTY_VALUE)
-      end
+        return config_hash.fetch(key.to_sym, nil) if key.is_a?(String)
 
-      def define_getter str_key
-        define_singleton_method str_key.to_sym do
-          @configuration_map[str_key] == EMPTY_VALUE ? nil : @configuration_map[str_key]
-        end
-      end
-
-      def define_setter str_key
-        define_singleton_method "#{ str_key }=".to_sym do |new_value|
-          @configuration_map[str_key] = new_value
-        end
+        config_hash.fetch(key.to_s, nil)
       end
     end
   end

data/lib/contrast/config/certification_configuration.rb

@@ -6,80 +6,23 @@ module Contrast
     # Certificate Configuration
     class CertificationConfiguration < BaseConfiguration
       # @return [String] path to CA Cert file
-      attr_reader :ca_file
+      attr_accessor :ca_file
       # @return [String] path to Certification file
-      attr_reader :cert_file
+      attr_accessor :cert_file
       # @return [String] path to Certification Key file
-      attr_reader :key_file
+      attr_accessor :key_file
+      attr_writer :enable
 
       def initialize hsh = {}
         @enable = traverse_config(hsh, :enable)
         @ca_file = traverse_config(hsh, :ca_file)
         @cert_file = traverse_config(hsh, :cert_file)
         @key_file = traverse_config(hsh, :key_file)
-        @configuration_map = {}
-        build_configuration_map
       end
 
-      # GETTERS
-
-      # @return [Boolean]
+      # @return [Boolean, false]
       def enable
-        return false if @enable.nil?
-
-        @enable
-      end
-
-      # SETTERS
-
-      def enable= value
-        self['enable'] = value
-      end
-
-      def ca_file= value
-        self['ca_file'] = value
-      end
-
-      def cert_file= value
-        self['cert_file'] = value
-      end
-
-      def key_file= value
-        self['key_file'] = 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
+        @enable.nil? ? false : @enable
       end
     end
   end

data/lib/contrast/config/exception_configuration.rb

@@ -8,67 +8,20 @@ module Contrast
     # and Message when Security Exceptions are raised.
     class ExceptionConfiguration < BaseConfiguration
       # @return [Integer] the HTTP status code override
-      attr_reader :override_status
+      attr_accessor :override_status
       # @return [String] the message text override
-      attr_reader :override_message
+      attr_accessor :override_message
+      attr_writer :capture
 
       def initialize hsh = {}
         @capture = traverse_config(hsh, :capture)
         @override_status = traverse_config(hsh, :override_status)
         @override_message = traverse_config(hsh, :override_message)
-        @configuration_map = {}
-        build_configuration_map
       end
 
-      # @return [Boolean] default: false
+      # @return [Boolean, false]
       def capture
-        @capture.nil? ? false : @capture
-      end
-
-      def capture= value
-        self['capture'] = value
-      end
-
-      def override_status= value
-        self['override_status'] = value
-      end
-
-      def override_message= value
-        self['override_message'] = 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
+        !!@capture
       end
     end
   end

data/lib/contrast/config/heap_dump_configuration.rb

@@ -10,6 +10,8 @@ module Contrast
       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)
@@ -17,13 +19,11 @@ module Contrast
         @window_ms = traverse_config(hsh, :window_ms)
         @count = traverse_config(hsh, :count)
         @clean = traverse_config(hsh, :clean)
-        @configuration_map = {}
-        build_configuration_map
       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 +46,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

@@ -7,14 +7,13 @@ module Contrast
     # inventory functionality of the Agent.
     class InventoryConfiguration < 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
       end
 
       # @return [Boolean, true]
@@ -26,52 +25,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

@@ -17,42 +17,6 @@ module Contrast
         @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'
-
-          @configuration_map[str_key] = send(str_key.to_sym)
-        end
       end
     end
   end

data/lib/contrast/config/protect_configuration.rb

@@ -6,14 +6,24 @@ module Contrast
     # 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
+      # @return [Boolean, nil]
+      attr_accessor :enable
+      attr_writer :exceptions, :rules
 
-      def initialize hsh
-        super(hsh, KEYS)
+      def initialize hsh = {}
+        @exceptions = Contrast::Config::ExceptionConfiguration.new(traverse_config(hsh, :exceptions))
+        @rules = Contrast::Config::ProtectRulesConfiguration.new(traverse_config(hsh, :rules))
+        @enable = traverse_config(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

@@ -8,15 +8,24 @@ module Contrast
     # 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
+      # @return [Boolean, nil]
+      attr_accessor :enable
+      # @return [String, nil]
+      attr_accessor :mode
+      # @retrun [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
+      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 +49,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

@@ -8,7 +8,9 @@ module Contrast
     # Common Configuration settings. Those in this section pertain to the
     # protect rule modes of the Agent.
     class ProtectRulesConfiguration < BaseConfiguration
-      attr_reader :disabled_rules
+      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
 
@@ -27,8 +29,6 @@ module Contrast
         @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
       end
 
       def bot_blocker
@@ -75,33 +75,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