contrast-agent 6.7.0 → 6.9.0

data/lib/contrast/config/certification_configuration.rb

@@ -1,11 +1,17 @@
 # Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
+require 'contrast/components/base'
+
 module Contrast
   module Config
     # Certificate Configuration
     class CertificationConfiguration
       include Contrast::Config::BaseConfiguration
+      include Contrast::Components::ComponentBase
+
+      CANON_NAME = 'api.certification'
+      CONFIG_VALUES = %w[ca_file cert_file key_file enable].cs__freeze
 
       # @return [String] path to CA Cert file
       attr_accessor :ca_file
@@ -28,6 +34,14 @@ module Contrast
       def enable
         @enable.nil? ? false : @enable
       end
+
+      # Converts current configuration to effective config values class and appends them to
+      # EffectiveConfig class.
+      #
+      # @param effective_config [Contrast::Agent::DiagnosticsConfig::EffectiveConfig]
+      def to_effective_config effective_config
+        add_effective_config_values(effective_config, CONFIG_VALUES, CANON_NAME, CONTRAST)
+      end
     end
   end
 end

data/lib/contrast/config/config.rb

@@ -0,0 +1,46 @@
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+require 'contrast/config/effective_config'
+
+module Contrast
+  module Agent
+    module DiagnosticsConfig
+      # This class is responsible for logging to file the effective Agent configurations after startup.
+      class Config
+        attr_reader :effective_config
+
+        MESSAGE_FAIL = 'Unable to connect to Contrast, configuration details from the Contrast UI will not be included.'
+        MESSAGE_SUCCESSFUL = 'Connected to Contrast.'
+        CONN_STATUS_MSG_FAILURE = 'Unable to connect to Contrast, insufficient connection properties provided.'
+
+        def initialize
+          @effective_config = Contrast::Agent::DiagnosticsConfig::EffectiveConfig.new
+          @config_status = Contrast::Utils::ObjectShare::EMPTY_STRING
+        end
+
+        # This method will set the status from the request/response cycles
+        #
+        # @param response [Contrast::Agent::Reporting::Response]
+        def determine_config_status response
+          return unless response
+          # If we encounter for some of the startup events failure - always return failure
+          return if @config_status == MESSAGE_FAIL || CONN_STATUS_MSG_FAILURE
+
+          response_code = response.code.to_s
+          @config_status = response_code.starts_with?('2') ? MESSAGE_SUCCESSFUL : MESSAGE_FAIL
+          nil
+        end
+
+        # This method will set the status message from the config validation
+        def populate_fail_connection
+          @config_status = CONN_STATUS_MSG_FAILURE
+        end
+
+        def to_controlled_hash
+          @effective_config.to_controlled_hash.merge({ Status: @config_status })
+        end
+      end
+    end
+  end
+end

data/lib/contrast/config/diagnostics.rb

@@ -0,0 +1,114 @@
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+require 'json'
+require 'fileutils'
+require 'contrast/utils/timer'
+require 'contrast/utils/log_utils'
+require 'contrast/components/logger'
+require 'contrast/utils/object_share'
+require 'contrast/config/config'
+require 'contrast/config/effective_config'
+require 'contrast/config/effective_config_value'
+
+module Contrast
+  module Agent
+    module DiagnosticsConfig
+      # This class is responsible for logging to file the effective Agent configurations after startup.
+      class Diagnostics
+        include Contrast::Components::Logger::InstanceMethods
+        include Contrast::Utils::LogUtils
+
+        # @return [String] path to write the file.
+        attr_reader :path
+
+        DEFAULT_PATH = File.join(Dir.pwd).cs__freeze
+        ERROR_MESSAGE = '[Configuration Diagnostics] Could not write effective Agent configuration to file'
+        FILE_NAME = 'contrast_connection.json'
+        WRITE = 'w+'
+
+        # @param path [String] path to write to file.
+        def initialize path
+          @path = path if path && !path.empty?
+        end
+
+        # Write current settings to file.
+        #
+        # @param reset [Boolean] should we reset the config we have
+        # @return [Boolean]
+        def write_to_file reset: true
+          logger&.info('[Configuration Diagnostics] Writing Effective Configurations to file', path: dir_name)
+          status = false
+          write_to_file_logic(status, reset: reset)
+        rescue IOError => e
+          logger&.warn(ERROR_MESSAGE, e)
+          false
+        end
+
+        def extract_settings
+          Contrast::AGENT.to_effective_config(config.effective_config)
+          Contrast::API.to_effective_config(config.effective_config)
+          Contrast::APP_CONTEXT.to_effective_config(config.effective_config)
+          Contrast::ASSESS.to_effective_config(config.effective_config)
+          Contrast::INVENTORY.to_effective_config(config.effective_config)
+          Contrast::PROTECT.to_effective_config(config.effective_config)
+        end
+
+        # Determine the path of the current logger and permissions required for
+        # writing to path.
+        #
+        # @return [String] Path
+        def dir_name
+          @_dir_name ||= if write_permission?(@path)
+                           File.dirname(File.absolute_path(@path))
+                         else
+                           DEFAULT_PATH
+                         end
+        rescue Errno::EROFS => e
+          logger.warn(ERROR_MESSAGE, e)
+        end
+
+        # Returns effective configurations of the agent.
+        #
+        # @return [Contrast::Agent::DiagnosticsConfig::Config]
+        def config
+          @_config ||= Contrast::Agent::DiagnosticsConfig::Config.new
+        end
+
+        # Reset the state of the current effective config.
+        def reset_config
+          @_config = Contrast::Agent::DiagnosticsConfig::Config.new
+        end
+
+        def to_controlled_hash
+          {
+              ReportCreate: report_create_time,
+              Config: config.to_controlled_hash
+          }
+        end
+
+        def write_to_file_logic status, reset: true
+          # We need to reset the config before updating it's values
+          reset_config if reset
+          extract_settings
+          File.open(File.join(dir_name, FILE_NAME), WRITE) do |file|
+            file.truncate(0)
+            file.write(JSON.pretty_generate(to_controlled_hash, { space: Contrast::Utils::ObjectShare::EMPTY_STRING }))
+            status = true if file
+            file.close
+          end
+          status
+        end
+
+        private
+
+        # Return current time in iso8601 format.
+        #
+        # @return [String] Time of creation
+        def report_create_time
+          Contrast::Utils::Timer.time_now
+        end
+      end
+    end
+  end
+end

data/lib/contrast/config/diagnostics_tools.rb

@@ -0,0 +1,98 @@
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+require 'contrast/utils/object_share'
+
+module Contrast
+  module Agent
+    module DiagnosticsConfig
+      # Diagnostics tools to be included in config components.
+      module DiagnosticsTools
+        CHECK = 'd'
+
+        # Converts current configuration for array of values to effective config values class and appends them to
+        # EffectiveConfig class. Must be used inside Config Components only.
+        #
+        # @param effective_config [Contrast::Agent::DiagnosticsConfig::EffectiveConfig]
+        # @param config_values [Array<String>] array of the names of values.
+        # @param canonical_prefix [String] starting of the path to config => api.proxy...
+        # @param name_prefix [String] the name of the config prefix => contrast.api_key, contrast.url
+        def add_effective_config_values effective_config, config_values, canonical_prefix, name_prefix
+          return if config_values.to_s.empty?
+
+          config_values.each do |config|
+            Contrast::Agent::DiagnosticsConfig::EffectiveConfigValue.new.tap do |value|
+              next if (config_val = send(config.to_sym)).to_s.empty?
+
+              config_name = assign_name(config)
+              value.canonical_name = "#{ canonical_prefix }.#{ config_name }"
+              value.name = "#{ name_prefix }.#{ config_name }"
+              value.value = config_val
+              value.source = Contrast::CONFIG.sources.get(value.canonical_name)
+              if value.source == Contrast::Components::Config::Sources::YAML
+                value.filename = Contrast::CONFIG.config_file_path
+              end
+              effective_config.values << value
+            rescue StandardError => e
+              log_error(e)
+              next
+            end
+          end
+        end
+
+        # Converts current configuration for single value to effective config values class and appends them to
+        # EffectiveConfig class. Must be used inside Config Components only.
+        #
+        # @param effective_config [Contrast::Agent::DiagnosticsConfig::EffectiveConfig]
+        # @param config_name [String] name of the config.
+        # @param config_value [String, Boolean] value of the config.
+        # @param canonical_prefix [String] starting of the path to config => api.proxy...
+        # @param name_prefix [String] the name of the config prefix => contrast.api_key, contrast.url
+        def add_single_effective_value effective_config, config_name, config_value, canonical_prefix, name_prefix
+          Contrast::Agent::DiagnosticsConfig::EffectiveConfigValue.new.tap do |value|
+            break if config_value.to_s.empty?
+
+            value.value = config_value
+            value.canonical_name = "#{ canonical_prefix }.#{ config_name }"
+            value.name = "#{ name_prefix }.#{ config_name }"
+            value.source = Contrast::CONFIG.sources.get(value.canonical_name)
+            if value.source == Contrast::Components::Config::Sources::YAML
+              value.filename = Contrast::CONFIG.config_file_path
+            end
+            effective_config.values << value
+          rescue StandardError => e
+            log_error(e)
+            next
+          end
+        end
+
+        private
+
+        # Assigns a proper name for the config removing '?' out of method names.
+        #
+        # @param config [String] name of the configuration
+        # @return [String]
+        def assign_name config
+          return Contrast::Utils::ObjectShare::EMPTY_STRING unless config
+
+          name = config.dup
+          if name.end_with?(Contrast::Utils::ObjectShare::QUESTION_MARK)
+            # check and remove '?' : start_bundled_service? => start_bundled_service
+            name.delete!(Contrast::Utils::ObjectShare::QUESTION_MARK)
+            name.chop! if name.end_with?(CHECK)
+            name
+          end
+          name
+        end
+
+        # Logs any caught error.
+        #
+        # @param error [StandardError]
+        def log_error error
+          Contrast::CONFIG.proto_logger.warn('Could not write effective config to file: ',
+                                             error: error, backtrace: error.backtrace)
+        end
+      end
+    end
+  end
+end

data/lib/contrast/config/effective_config.rb

@@ -0,0 +1,65 @@
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+require 'contrast/config/effective_config_value'
+
+module Contrast
+  module Agent
+    module DiagnosticsConfig
+      # The current effective config received from all authorized configuration channels.
+      class EffectiveConfig
+        # Value of effective agent configurations
+        #
+        # @return [Array]
+        attr_reader :values
+
+        def initialize
+          @values = []
+        end
+
+        def to_controlled_hash
+          {
+              EffectiveConfig: { values: @values&.map(&:to_controlled_hash) },
+              File: yaml_config_settings,
+              Environment: environment_settings,
+              CommandLine: command_line_settings,
+              ContrastUI: contrast_ui_settings
+          }
+        end
+
+        private
+
+        def yaml_config_settings
+          {
+              Path: Contrast::CONFIG.config_file_path,
+              Values: Contrast::CONFIG.sources.for(Contrast::Components::Config::Sources::YAML)
+          }
+        end
+
+        def command_line_settings
+          flatten_settings(Contrast::CONFIG.sources.for(Contrast::Components::Config::Sources::CLI))
+        end
+
+        def contrast_ui_settings
+          flatten_settings(Contrast::CONFIG.sources.for(Contrast::Components::Config::Sources::CONTRASTUI))
+        end
+
+        def flatten_settings data, path = []
+          data.each_with_object([]) do |(k, v), entries|
+            if v.cs__is_a?(Hash)
+              entries.concat(flatten_settings(v, path.dup.append(k.to_sym)))
+            else
+              entries << { "#{ path.join('.') }.#{ k }" => Contrast::CONFIG.config.loaded_config.dig(*path, k) }
+            end
+          end.flatten # rubocop:disable Style/MethodCalledOnDoEndBlock
+        end
+
+        def environment_settings
+          ENV.select { |e| e.to_s.start_with?(Contrast::Components::Config::CONTRAST_ENV_MARKER) }.
+              to_a.
+              map { |e| Hash[*e] }
+        end
+      end
+    end
+  end
+end

data/lib/contrast/config/effective_config_value.rb

@@ -0,0 +1,32 @@
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+module Contrast
+  module Agent
+    module DiagnosticsConfig
+      # All In effect config values stored in a easy to write representation.
+      class EffectiveConfigValue
+        # @return [String] Name of the config starting form root of yaml config.
+        attr_accessor :canonical_name
+        # @return [String] Name of the config.
+        attr_accessor :name
+        # @return [String] Value set for the config.
+        attr_accessor :value
+        # @return [String] The source for the entry in the config.
+        attr_accessor :source
+        # @return [String,nil] The filename for the source of the config, if the source was "yaml".
+        attr_accessor :filename
+
+        def to_controlled_hash
+          {
+              canonical_name: canonical_name,
+              name: name, # rubocop:disable Security/Module/Name
+              value: value,
+              Source: source,
+              Filename: filename
+          }.compact
+        end
+      end
+    end
+  end
+end

data/lib/contrast/config/exception_configuration.rb

@@ -1,20 +1,32 @@
 # Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
+require 'contrast/components/base'
+
 module Contrast
   module Config
     # Common Configuration settings. Those in this section pertain to the exception handling in Ruby, allowing for the
     # override of Response Code and Message when Security Exceptions are raised.
     class ExceptionConfiguration
       include Contrast::Config::BaseConfiguration
+      include Contrast::Components::ComponentBase
+
+      CANON_NAME = 'agent.ruby.exception'
+      CONFIG_VALUES = %w[capture override_status override_message].cs__freeze
 
       # @return [Integer] the HTTP status code override
       attr_accessor :override_status
       # @return [String] the message text override
       attr_accessor :override_message
       attr_writer :capture
+      # @return [String]
+      attr_reader :canon_name
+      # @return [Array]
+      attr_reader :config_values
 
       def initialize hsh = {}
+        @config_values = CONFIG_VALUES
+        @canon_name = CANON_NAME
         return unless hsh
 
         @capture = hsh[:capture]

data/lib/contrast/config/protect_rule_configuration.rb

@@ -33,24 +33,24 @@ module Contrast
       end
 
       # To convert the user input mode from config to a standard format used by TS & SR, we need to convert the given
-      # String to its Contrast::Api::Settings::ProtectionRule::Mode equivalent. If a nonsense value is provided, it'll
+      # String to its recognized symbol equivalent. If a nonsense value is provided, it'll
       # be treated the same as disabling the rule.
       #
-      # @return [Contrast::Api::Settings::ProtectionRule::Mode, nil]
+      # @return [Symbol]
       def applicable_mode
         return unless mode
 
-        case mode
+        case mode.downcase
         when 'permit'
-          Contrast::Api::Settings::ProtectionRule::Mode::PERMIT
+          :PERMIT
         when 'block_at_perimeter'
-          Contrast::Api::Settings::ProtectionRule::Mode::BLOCK_AT_PERIMETER
+          :BLOCK_AT_PERIMETER
         when 'block'
-          Contrast::Api::Settings::ProtectionRule::Mode::BLOCK
+          :BLOCK
         when 'monitor'
-          Contrast::Api::Settings::ProtectionRule::Mode::MONITOR
+          :MONITOR
         else
-          Contrast::Api::Settings::ProtectionRule::Mode::NO_ACTION
+          :NO_ACTION
         end
       end
     end

data/lib/contrast/config/protect_rules_configuration.rb

@@ -10,84 +10,47 @@ module Contrast
       include Contrast::Config::BaseConfiguration
 
       attr_accessor :disabled_rules
-      attr_writer :bot_blocker, :cmd_injection, :sql_injection, :nosql_injection, :untrusted_deserialization,
-                  :xxe, :path_traversal, :reflected_xss, :unsafe_file_upload, :rule_base, :cmdi_command_backdoors,
-                  :sqli_dangerous_function
+      attr_reader :bot_blocker,
+                  :cmd_injection, :cmd_injection_command_backdoors,
+                  :cmd_injection_semantic_chained_commands, :cmd_injection_semantic_dangerous_paths,
+                  :method_tampering,
+                  :nosql_injection,
+                  :path_traversal, :path_traversal_semantic_file_security_bypass,
+                  :reflected_xss,
+                  :sql_injection, :sql_injection_semantic_dangerous_functions,
+                  :unsafe_file_upload,
+                  :untrusted_deserialization,
+                  :xxe,
+                  :rule_base
 
       BASE_RULE = 'Contrast::Agent::Protect::Rule::Base'.cs__freeze
 
       def initialize hsh = {} # rubocop:disable Metrics/AbcSize
         return unless hsh
 
+        # IVs must be with the same name as rule_id
         @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'])
+        @cmd_injection_command_backdoors =
+          Contrast::Config::ProtectRuleConfiguration.new(hsh[:'cmd-injection-command-backdoors'])
+        @cmd_injection_semantic_chained_commands =
+          Contrast::Config::ProtectRuleConfiguration.new(hsh[:'cmd-injection-semantic-chained-commands'])
+        @cmd_injection_semantic_dangerous_paths =
+          Contrast::Config::ProtectRuleConfiguration.new(hsh[:'cmd-injection-semantic-dangerous-paths'])
         @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'])
+        @path_traversal_semantic_file_security_bypass =
+          Contrast::Config::ProtectRuleConfiguration.new(hsh[:'path-traversal-semantic-file-security-bypass'])
         @reflected_xss = Contrast::Config::ProtectRuleConfiguration.new(hsh[:'reflected-xss'])
         @sql_injection = Contrast::Config::ProtectRuleConfiguration.new(hsh[:'sql-injection'])
-        @sqli_dangerous_function =
+        @sql_injection_semantic_dangerous_functions =
           Contrast::Config::ProtectRuleConfiguration.new(hsh[:'sql-injection-semantic-dangerous-functions'])
         @unsafe_file_upload = Contrast::Config::ProtectRuleConfiguration.new(hsh[:'unsafe-file-upload'])
         @untrusted_deserialization = Contrast::Config::ProtectRuleConfiguration.new(hsh[:'untrusted-deserialization'])
-        @cmdi_command_backdoors = Contrast::Config::ProtectRuleConfiguration.new(hsh[
-                                                                                   :'cmd-injection-command-backdoors'
-                                                                                 ])
-        @xxe = Contrast::Config::ProtectRuleConfiguration.new(hsh[:xxe])
-      end
-
-      def bot_blocker
-        @bot_blocker ||= Contrast::Config::ProtectRuleConfiguration.new
-      end
-
-      def cmd_injection
-        @cmd_injection ||= Contrast::Config::ProtectRuleConfiguration.new
-      end
-
-      def sql_injection
-        @sql_injection ||= Contrast::Config::ProtectRuleConfiguration.new
-      end
-
-      def nosql_injection
-        @nosql_injection ||= Contrast::Config::ProtectRuleConfiguration.new
-      end
-
-      def untrusted_deserialization
-        @untrusted_deserialization ||= Contrast::Config::ProtectRuleConfiguration.new
-      end
-
-      def method_tampering
-        @method_tampering ||= Contrast::Config::ProtectRuleConfiguration.new
-      end
-
-      def xxe
-        @xxe ||= Contrast::Config::ProtectRuleConfiguration.new
-      end
-
-      def path_traversal
-        @path_traversal ||= Contrast::Config::ProtectRuleConfiguration.new
-      end
-
-      def reflected_xss
-        @reflected_xss ||= Contrast::Config::ProtectRuleConfiguration.new
-      end
-
-      def unsafe_file_upload
-        @unsafe_file_upload ||= Contrast::Config::ProtectRuleConfiguration.new
-      end
-
-      def cmdi_command_backdoors
-        @cmdi_command_backdoors ||= Contrast::Config::ProtectRuleConfiguration.new
-      end
-
-      def rule_base
-        @rule_base ||= Contrast::Config::ProtectRuleConfiguration.new
-      end
-
-      def sqli_dangerous_function
-        @sqli_dangerous_function = Contrast::Config::ProtectRuleConfiguration.new
+        @xxe = Contrast::Config::ProtectRuleConfiguration.new(hsh['xxe'])
       end
 
       def []= key, value

data/lib/contrast/config/request_audit_configuration.rb

@@ -1,13 +1,18 @@
 # Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
+require 'contrast/components/base'
+
 module Contrast
   module Config
     # This class holds the Common Settings for the hidden functionality of the TS
     class RequestAuditConfiguration
       include Contrast::Config::BaseConfiguration
+      include Contrast::Components::ComponentBase
 
       DEFAULT_PATH = './messages'
+      CANON_NAME = 'api.request_audit'
+      CONFIG_VALUES = %w[enable requests responses path].cs__freeze
 
       attr_writer :enable, :requests, :responses, :path
 
@@ -39,6 +44,14 @@ module Contrast
       def path
         @path.nil? ? DEFAULT_PATH : @path
       end
+
+      # Converts current configuration to effective config values class and appends them to
+      # EffectiveConfig class.
+      #
+      # @param effective_config [Contrast::Agent::DiagnosticsConfig::EffectiveConfig]
+      def to_effective_config effective_config
+        add_effective_config_values(effective_config, CONFIG_VALUES, CANON_NAME, "#{ CONTRAST }.#{ CANON_NAME }")
+      end
     end
   end
 end

data/lib/contrast/config/server_configuration.rb

@@ -1,12 +1,18 @@
 # Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
+require 'contrast/config/base_configuration'
+
 module Contrast
   module Config
     # Common Configuration settings. Those in this section pertain to the server identification functionality of the
     # Agent.
     class ServerConfiguration
       include Contrast::Config::BaseConfiguration
+      include Contrast::Components::ComponentBase
+
+      CANON_NAME = 'server'
+      CONFIG_VALUES = %w[tags environment version].cs__freeze
 
       # @return [String, nil]
       attr_reader :name
@@ -14,14 +20,19 @@ module Contrast
       attr_accessor :path
       # @return [String, nil]
       attr_accessor :type
-      # @return [Array, nil]
-      attr_accessor :tags
+      attr_writer :tags
       # @return [String, nil]
       attr_accessor :environment
       # @return [String, nil]
       attr_accessor :version
+      # @return [String]
+      attr_reader :canon_name
+      # @return [Array]
+      attr_reader :config_values
 
       def initialize hsh = {}
+        @config_values = CONFIG_VALUES
+        @canon_name = CANON_NAME
         return unless hsh
 
         @path = hsh[:path]
@@ -31,6 +42,34 @@ module Contrast
         @environment = hsh[:environment]
         @version = hsh[:version]
       end
+
+      # @return [String, nil]
+      def tags
+        stringify_array(@tags)
+      end
+
+      # Converts current configuration to effective config values class and appends them to
+      # EffectiveConfig class.
+      #
+      # @param effective_config [Contrast::Agent::DiagnosticsConfig::EffectiveConfig]
+      def to_effective_config effective_config
+        super
+        add_single_effective_value(effective_config,
+                                   'type',
+                                   Contrast::APP_CONTEXT.server_type,
+                                   CANON_NAME,
+                                   "#{ CONTRAST }.#{ CANON_NAME }")
+        add_single_effective_value(effective_config,
+                                   'name',
+                                   Contrast::APP_CONTEXT.server_name,
+                                   CANON_NAME,
+                                   "#{ CONTRAST }.#{ CANON_NAME }")
+        add_single_effective_value(effective_config,
+                                   'path',
+                                   Contrast::APP_CONTEXT.server_path,
+                                   CANON_NAME,
+                                   "#{ CONTRAST }.#{ CANON_NAME }")
+      end
     end
   end
 end