contrast-agent 5.0.0 → 5.3.0

data/lib/contrast/config/assess_configuration.rb

@@ -6,18 +6,112 @@ module Contrast
     # Common Configuration settings. Those in this section pertain to the
     # assess functionality of the Agent.
     class AssessConfiguration < BaseConfiguration
-      KEYS = {
-          tags: EMPTY_VALUE,
-          enable: EMPTY_VALUE,
-          enable_scan_response: true,
-          enable_dynamic_sources: true,
-          sampling: Contrast::Config::SamplingConfiguration,
-          rules: Contrast::Config::AssessRulesConfiguration,
-          stacktraces: 'ALL'
-      }.cs__freeze
-
-      def initialize hsh
-        super(hsh, KEYS)
+      # @return [String, nil]
+      attr_reader :tags
+
+      DEFAULT_STACKTRACES = 'ALL'
+
+      def initialize hsh = {}
+        @enable = traverse_config(hsh, :enable)
+        @tags = traverse_config(hsh, :tags)
+        @enable_scan_response = traverse_config(hsh, :enable_scan_response)
+        @enable_dynamic_sources = traverse_config(hsh, :enable_dynamic_sources)
+        @sampling = Contrast::Config::SamplingConfiguration.new(traverse_config(hsh, :sampling))
+        @rules = Contrast::Config::AssessRulesConfiguration.new(traverse_config(hsh, :rules))
+        @stacktraces = traverse_config(hsh, :stacktraces)
+        @configuration_map = {}
+        build_configuration_map
+      end
+
+      # @return [Boolean, true]
+      def enable
+        @enable.nil? ? true : @enable
+      end
+
+      # @return [Boolean, true]
+      def enable_scan_response
+        @enable_scan_response.nil? ? true : @enable_scan_response
+      end
+
+      # @return [Boolean, true]
+      def enable_dynamic_sources
+        @enable_dynamic_sources.nil? ? true : @enable_dynamic_sources
+      end
+
+      # @return [Contrast::Config::SamplingConfiguration]
+      def sampling
+        @sampling ||= Contrast::Config::SamplingConfiguration.new
+      end
+
+      # @return [Contrast::Config::AssessRulesConfiguration]
+      def rules
+        @rules ||= Contrast::Config::AssessRulesConfiguration.new
+      end
+
+      # @return [String] stacktrace level
+      def stacktraces
+        @stacktraces ||= DEFAULT_STACKTRACES
+      end
+
+      def enable= value
+        self['enable'] = value
+      end
+
+      def tags= value
+        self['tags'] = value
+      end
+
+      def enable_scan_response= value
+        self['enable_scan_response'] = value
+      end
+
+      def enable_dynamic_sources= value
+        self['enable_dynamic_sources'] = value
+      end
+
+      def sampling= value
+        self['sampling'] = value
+      end
+
+      def rules= value
+        self['rules'] = value
+      end
+
+      def stacktraces= value
+        self['stacktraces'] = 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

data/lib/contrast/config/assess_rules_configuration.rb

@@ -6,10 +6,51 @@ module Contrast
     # Common Configuration settings. Those in this section pertain to the
     # disabled assess rule functionality of the Agent.
     class AssessRulesConfiguration < BaseConfiguration
-      KEYS = { disabled_rules: EMPTY_VALUE }.cs__freeze
+      # @return [Array, nil] list of disabled assess rules
+      attr_reader :disabled_rules
 
-      def initialize hsh
-        super(hsh, KEYS)
+      def initialize hsh = {}
+        @disabled_rules = traverse_config(hsh, :disabled_rules)
+        @configuration_map = {}
+        build_configuration_map
+      end
+
+      def disabled_rules= value
+        self['disabled_rules'] = 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

data/lib/contrast/config/base_configuration.rb

@@ -30,6 +30,7 @@ module Contrast
       def assign_value_to_path_array dot_path_array, value
         current_level = self
         dot_path_array[0...-1].each do |segment|
+          segment = segment.tr('-', '_')
           current_level = current_level.send(segment) if current_level.cs__respond_to?(segment)
         end
         last_entry = dot_path_array[-1]

data/lib/contrast/config/certification_configuration.rb

@@ -5,10 +5,81 @@ module Contrast
   module Config
     # Certificate Configuration
     class CertificationConfiguration < BaseConfiguration
-      KEYS = { enable: false, ca_file: EMPTY_VALUE, cert_file: EMPTY_VALUE, key_file: EMPTY_VALUE }.cs__freeze
+      # @return [String] path to CA Cert file
+      attr_reader :ca_file
+      # @return [String] path to Certification file
+      attr_reader :cert_file
+      # @return [String] path to Certification Key file
+      attr_reader :key_file
 
-      def initialize hsh
-        super(hsh, KEYS)
+      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]
+      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
       end
     end
   end

data/lib/contrast/config/exception_configuration.rb

@@ -7,10 +7,68 @@ module Contrast
     # exception handling in Ruby, allowing for the override of Response Code
     # and Message when Security Exceptions are raised.
     class ExceptionConfiguration < BaseConfiguration
-      KEYS = { capture: EMPTY_VALUE, override_status: EMPTY_VALUE, override_message: EMPTY_VALUE }.cs__freeze
+      # @return [Integer] the HTTP status code override
+      attr_reader :override_status
+      # @return [String] the message text override
+      attr_reader :override_message
 
-      def initialize hsh
-        super(hsh, KEYS)
+      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
+      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
       end
     end
   end

data/lib/contrast/config/heap_dump_configuration.rb

@@ -6,23 +6,107 @@ module Contrast
     # Common Configuration settings. Those in this section pertain to the
     # Heap Dump collection functionality of the Agent.
     class HeapDumpConfiguration < BaseConfiguration
-      KEYS = {
-          enable:                                                                   # should dumps be taken
-            Contrast::Utils::ObjectShare::FALSE,
-          path:                                                                     # dir to which dumps should be
-            'contrast_heap_dumps', # saved
-          delay_ms:                                                                 # time, in ms, after initialization
-            10_000, # to delay before taking dump
-          window_ms:                                                                # ms between each dump
-            10_000, #
-          count:                                                                    # number of dumps to take
-            5, #
-          clean:                                                                    # remove temporary objects or not
-            Contrast::Utils::ObjectShare::FALSE #
-      }.cs__freeze
-
-      def initialize hsh
-        super(hsh, KEYS)
+      DEFAULT_PATH = 'contrast_heap_dumps' # saved
+      DEFAULT_MS = 10_000
+      DEFAULT_COUNT = 5
+
+      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
+      end
+
+      # @return [Boolean, false] should dumps be taken
+      def enable
+        !!@enable
+      end
+
+      # @return [String, DEFAULT_PATH] dir to which dumps should be
+      def path
+        @path ||= DEFAULT_PATH
+      end
+
+      # @return [Integer, DEFAULT_MS] time, in ms, after initialization
+      def delay_ms
+        @delay_ms ||= DEFAULT_MS
+      end
+
+      # @return [Integer, DEFAULT_MS] ms between each dump
+      def window_ms
+        @window_ms ||= DEFAULT_MS
+      end
+
+      # @return [Integer, DEFAULT_MS] number of dumps to take
+      def count
+        @count ||= DEFAULT_COUNT
+      end
+
+      # @return [Boolean, 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
       end
     end
   end

data/lib/contrast/config/inventory_configuration.rb

@@ -6,10 +6,71 @@ module Contrast
     # Common Configuration settings. Those in this section pertain to the
     # inventory functionality of the Agent.
     class InventoryConfiguration < BaseConfiguration
-      KEYS = { enable: true, analyze_libraries: true, tags: EMPTY_VALUE }.cs__freeze
+      # @return [Array, nil] tags
+      attr_reader :tags
 
-      def initialize hsh
-        super(hsh, KEYS)
+      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]
+      def enable
+        @enable.nil? ? true : @enable
+      end
+
+      # @return [Boolean, true]
+      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

data/lib/contrast/config/logger_configuration.rb

@@ -6,10 +6,53 @@ module Contrast
     # Common Configuration settings. Those in this section pertain to the
     # logging in the Agent.
     class LoggerConfiguration < BaseConfiguration
-      KEYS = { path: EMPTY_VALUE, level: EMPTY_VALUE, progname: EMPTY_VALUE }.cs__freeze
+      # @return [String, nil]
+      attr_accessor :path
+      # @return [String, nil]
+      attr_accessor :level
+      # @return [String, nil]
+      attr_accessor :progname
 
-      def initialize hsh
-        super(hsh, KEYS)
+      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'
+
+          @configuration_map[str_key] = send(str_key.to_sym)
+        end
       end
     end
   end

data/lib/contrast/config/protect_rule_configuration.rb

@@ -8,15 +8,15 @@ 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
-      KEYS = {
-          enable: EMPTY_VALUE,
-          mode: EMPTY_VALUE,
-          disable_system_commands: EMPTY_VALUE,
-          detect_custom_code_accessing_system_files: true
-      }.cs__freeze
-
-      def initialize hsh
-        super(hsh, KEYS)
+      attr_accessor :enable, :mode, :disable_system_commands, :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
 
       # To convert the user input mode from config to a standard format used by TS & SR, we need to convert the given
@@ -40,6 +40,33 @@ 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