contrast-agent 6.6.4 → 6.8.0

data/lib/contrast/agent/request_context_extend.rb

@@ -13,38 +13,20 @@ require 'contrast/agent/assess/rule/response/x_xss_protection_header_rule'
 require 'contrast/agent/protect/input_analyzer/input_analyzer'
 require 'contrast/components/logger'
 require 'contrast/utils/log_utils'
+require 'contrast/utils/string_utils'
 
 module Contrast
   module Agent
     # This class extends RequestContexts: this class acts to encapsulate information about the currently
     # executed request, making it available to the Agent for the duration of the request in a standardized
     # and normalized format which the Agent understands.
-    module RequestContextExtend # rubocop:disable Metrics/ModuleLength
+    module RequestContextExtend
       include Contrast::Utils::CEFLogUtils
       include Contrast::Components::Logger::InstanceMethods
-      BUILD_ATTACK_LOGGER_MESSAGE = 'Building attack result from Contrast Service input analysis result'
       # Convert the discovered route for this request to appropriate forms and disseminate it to those locations
       # where it is necessary for our route coverage and finding vulnerability discovery features to function.
       #
-      # @param route [Contrast::Api::Dtm::RouteCoverage, nil] the route of the current request, as determined from the
-      #   framework
-      def append_route_coverage route
-        return unless route
-
-        # For our findings
-        @route = route
-
-        # For SR findings
-        @activity.routes << route
-
-        # For TS routes
-        @request.route = route
-      end
-
-      # Convert the discovered route for this request to appropriate forms and disseminate it to those locations
-      # where it is necessary for our route coverage and finding vulnerability discovery features to function.
-      #
-      # @param route [Contrast::Api::Dtm::RouteCoverage]
+      # @param route [Contrast::Agent::Reporting::RouteCoverage]
       def append_to_observed_route route
         return unless route
 
@@ -52,70 +34,30 @@ module Contrast
         @observed_route.verb       = route.verb
         @observed_route.url        = route.url if route.url
         @request.observed_route    = @observed_route
-      end
 
-      # Collect the results for the given rule with the given action
-      #
-      # @param rule [String] the id of the rule to which the results apply
-      # @param response_type [Symbol] the result of the response, matching a value of
-      #   Contrast::Api::Dtm::AttackResult::ResponseType
-      # @return [Array<Contrast::Api::Dtm::AttackResult>]
-      def results_for rule, response_type = nil
-        if response_type.nil?
-          activity.results.select { |r| r.rule_id == rule }
-        else
-          activity.results.select { |r| r.rule_id == rule && r.response == response_type }
-        end
+        observation = Contrast::Agent::Reporting::RouteDiscoveryObservation.new(route.url, route.verb)
+        @discovered_route = Contrast::Agent::Reporting::RouteDiscovery.new(route.route, observation)
+        @request.discovered_route = @discovered_route
       end
 
+      # If protect is enabled for this request, examine said request for any possible attack input. If those inputs
+      # provided match a rule which should block at the perimeter, that will be raised here.
+      #
       # @raise [Contrast::SecurityException]
-      def service_extract_request
+      def protect_input_analysis
         return false unless ::Contrast::AGENT.enabled?
         return false unless ::Contrast::PROTECT.enabled?
         return false if @do_not_track
 
-        service_response = Contrast::Agent&.messaging_queue&.send_event_immediately(@activity.http_request)
-        return false unless service_response
-
-        handle_protect_state(service_response)
-        ia = service_response.input_analysis
-        if ia
-          service_extract_logging(ia)
-          # TODO: RUBY-1629
-          # using Agent analysis
-          # initialize_agent_input_analysis request
-
-          @speedracer_input_analysis = ia
-          speedracer_input_analysis.request = request
+        if (ia = Contrast::Agent::Protect::InputAnalyzer.analyse(request))
+          @agent_input_analysis = ia
         else
-          logger.trace('Analysis from Contrast Service was empty.')
-          false
+          logger.trace('Analysis from Agent was empty.')
         end
       rescue Contrast::SecurityException => e
         raise(e)
       rescue StandardError => e
-        logger.warn('Unable to extract Contrast Service information from request', e)
-        false
-      end
-
-      # NOTE: this method is only used as a backstop if Speedracer sends Input Evaluations when the protect state
-      # indicates a security exception should be thrown. This method ensures that the attack reports are generated.
-      # Normally these should be generated on Speedracer for any attacks detected during prefilter.
-      #
-      # @param agent_settings [Contrast::Api::Settings::AgentSettings]
-      # @raise[Contrast::SecurityException]
-      def handle_protect_state agent_settings
-        return unless agent_settings&.protect_state
-
-        state = agent_settings.protect_state
-        @uuid = state.uuid
-        @do_not_track = true unless state.track_request
-        return unless state.security_exception
-
-        # If Contrast Service has NOT handled the input analysis, handle them here
-        build_attack_results(agent_settings)
-        logger.debug('Contrast Service said to block this request')
-        raise(Contrast::SecurityException.new(nil, (state.security_message || 'Blocking suspicious behavior')))
+        logger.warn('Unable to extract protect information from request', e)
       end
 
       # append anything we've learned to the request seen message this is the sum-total of all inventory information
@@ -126,101 +68,18 @@ module Contrast
         @response = Contrast::Agent::Response.new(rack_response)
         return unless @sample_res
 
-        #
-        # TODO: RUBY-1376 once all rules translated, move this to if/else w/ the enabled
-        if Contrast::Agent::Reporter.enabled?
-          Contrast::Agent::Assess::Rule::Response::AutoComplete.new.analyze(@response)
-          Contrast::Agent::Assess::Rule::Response::CacheControl.new.analyze(@response)
-          Contrast::Agent::Assess::Rule::Response::ClickJacking.new.analyze(@response)
-          Contrast::Agent::Assess::Rule::Response::CspHeaderMissing.new.analyze(@response)
-          Contrast::Agent::Assess::Rule::Response::CspHeaderInsecure.new.analyze(@response)
-          Contrast::Agent::Assess::Rule::Response::HSTSHeader.new.analyze(@response)
-          Contrast::Agent::Assess::Rule::Response::ParametersPollution.new.analyze(@response)
-          Contrast::Agent::Assess::Rule::Response::XContentType.new.analyze(@response)
-          Contrast::Agent::Assess::Rule::Response::XXssProtection.new.analyze(@response)
-        else
-          activity.http_response = @response.dtm
-        end
+        Contrast::Agent::Assess::Rule::Response::AutoComplete.new.analyze(@response)
+        Contrast::Agent::Assess::Rule::Response::CacheControl.new.analyze(@response)
+        Contrast::Agent::Assess::Rule::Response::ClickJacking.new.analyze(@response)
+        Contrast::Agent::Assess::Rule::Response::CspHeaderMissing.new.analyze(@response)
+        Contrast::Agent::Assess::Rule::Response::CspHeaderInsecure.new.analyze(@response)
+        Contrast::Agent::Assess::Rule::Response::HSTSHeader.new.analyze(@response)
+        Contrast::Agent::Assess::Rule::Response::ParametersPollution.new.analyze(@response)
+        Contrast::Agent::Assess::Rule::Response::XContentType.new.analyze(@response)
+        Contrast::Agent::Assess::Rule::Response::XXssProtection.new.analyze(@response)
       rescue StandardError => e
         logger.error('Unable to extract information after request', e)
       end
-
-      # This here is for things we don't have implemented
-      def log_to_cef
-        activity.results.each { |attack_result| logging_logic(attack_result, attack_result.rule_id.downcase) }
-      end
-
-      # @param input_analysis [Contrast::Api::Settings::InputAnalysis]
-      def service_extract_logging input_analysis
-        log_to_cef
-        logger.trace('Analysis from Contrast Service', evaluations: input_analysis.results.length) if logger.trace?
-        logger.trace('Results', input_analysis: input_analysis.inspect) if logger.trace?
-      end
-
-      private
-
-      # Generate attack results directly from any evaluations on the agent settings object.
-      #
-      # @param agent_settings [Contrast::Api::Settings::AgentSettings]
-      def build_attack_results agent_settings
-        return unless agent_settings&.input_analysis&.results&.any?
-
-        results_by_rule = {}
-        agent_settings.input_analysis.results.each do |ia_result|
-          rule_id = ia_result.rule_id
-          rule = ::Contrast::PROTECT.rule(rule_id)
-          next unless rule
-
-          logger.debug(BUILD_ATTACK_LOGGER_MESSAGE, result: ia_result.inspect) if logger.debug?
-          results_by_rule[rule_id] = attack_result(rule, rule_id, ia_result, results_by_rule)
-        end
-
-        results_by_rule.each_pair do |_, attack_result|
-          logger.info('Blocking attack result', rule: attack_result.rule_id)
-          activity.results << attack_result
-        end
-      end
-
-      # Generates the attack result
-      #
-      # @param rule [Contrast::Agent::Protect::Rule, Contrast::Agent::Assess::Rule]
-      # @param rule_id [String] String name of the rule
-      # @param ia_result [Contrast::Api::Settings::InputAnalysisResult] the
-      #   analysis of the input that was determined to be an attack
-      # @param results_by_rule [Hash] attack results from any evaluations on the agent settings object.
-      # @return [Contrast::Api::Dtm::AttackResult] the attack result from this input
-      def attack_result rule, rule_id, ia_result, results_by_rule
-        @_attack_result = if rule.mode == :BLOCK
-                            # special case for rules (like reflected xss) that used to have an infilter / block mode
-                            # but now are just block at perimeter
-                            rule.build_attack_with_match(self, ia_result, results_by_rule[rule_id], ia_result.value)
-                          else
-                            rule.build_attack_without_match(self, ia_result, results_by_rule[rule_id])
-                          end
-      end
-
-      def logging_logic result, rule_id
-        rules = %w[bot_blocker virtual_patch ip_denylist]
-        return unless rules.include?(rule_id)
-
-        rule_details = Contrast::Api::Dtm::RaspRuleSample.to_controlled_hash(result.samples[0]).fetch(rule_id.to_sym)
-        outcome = Contrast::Api::Dtm::AttackResult::ResponseType.get_name_by_tag(result.response)
-        case rule_id
-        when /bot_blocker/i
-          blocker_to_json = Contrast::Api::Dtm::BotBlockerDetails.to_controlled_hash(rule_details)
-          cef_logger.bot_blocking_message(blocker_to_json, outcome)
-        when /virtual_patch/i
-          virtual_patch_to_json = Contrast::Api::Dtm::VirtualPatchDetails.to_controlled_hash(rule_details)
-          cef_logger.virtual_patch_message(virtual_patch_to_json, outcome)
-        when /ip_denylist/i
-          sender_ip = extract_sender_ip
-          ip_denylist_to_json = Contrast::Api::Dtm::IpDenylistDetails.to_controlled_hash(rule_details)
-          return unless sender_ip
-          return unless sender_ip.include?(ip_denylist_to_json[:ip])
-
-          cef_logger.ip_denylisted_message(sender_ip, ip_denylist_to_json, outcome)
-        end
-      end
     end
   end
 end

data/lib/contrast/agent/request_handler.rb

@@ -4,7 +4,6 @@
 require 'contrast/components/logger'
 require 'contrast/components/scope'
 require 'contrast/agent/reporting/reporter'
-require 'contrast/agent/reporting/reporting_utilities/dtm_message'
 require 'contrast/agent/reporting/masker/masker'
 
 module Contrast
@@ -22,13 +21,6 @@ module Contrast
         @ruleset = ::Contrast::AGENT.ruleset
       end
 
-      # Send Activities messages to TS [Contrast::Api::Dtm::Activity]
-      # TODO: RUBY-1704
-      # TODO: RUBY-1438
-      def send_activity_messages
-        Contrast::Agent.messaging_queue&.send_event_eventually(context.activity)
-      end
-
       # reports events[Contrast::Agent::Reporting::ReporterEvent] to TS
       # This method is used to send our JSON messages directly to TeamServer at the end of each request. As we move
       # more endpoints over, this method will take the messages originally sent by #send_actiivty_messages. At the end,
@@ -37,11 +29,9 @@ module Contrast
         return unless (reporter = Contrast::Agent.reporter)
 
         reporter.send_event(context.observed_route)
-        return unless Contrast::Agent::Reporter.enabled?
-
         # Mask Sensitive Data
         Contrast::Agent::Reporting::Masker.mask(context.activity)
-        event = Contrast::Agent::Reporting::DtmMessage.dtm_to_event(context.activity)
+        event = context.activity
         reporter.send_event(event)
       end
 

data/lib/contrast/agent/response.rb

@@ -45,24 +45,6 @@ module Contrast
         end
       end
 
-      # A form of the Rack::Response which we can report to the Service to be sent to TeamServer for processing. B/c
-      # the response can change, we can't memoize this :(
-      #
-      # @return [Contrast::Api::Dtm::HttpResponse]
-      def dtm
-        context_response = Contrast::Api::Dtm::HttpResponse.new
-        context_response.response_code = response_code.to_i
-        headers&.each_pair do |key, value|
-          append_pair(context_response.normalized_response_headers, key, value)
-        end
-        context_response.response_body_binary = Contrast::Utils::StringUtils.force_utf8(body)
-
-        doc_type = document_type
-        context_response.document_type = doc_type if doc_type
-
-        context_response
-      end
-
       # The response code of this response
       #
       # @return [Integer]

data/lib/contrast/agent/telemetry/events/event.rb

@@ -21,7 +21,7 @@ module Contrast
           ''
         end
 
-        def to_hash **_args
+        def to_controlled_hash **_args
           {
               tags: @tags,
               timestamp: @timestamp,

data/lib/contrast/agent/telemetry/events/metric_event.rb

@@ -19,7 +19,7 @@ module Contrast
           @fields['_filler'] = 0
         end
 
-        def to_hash **_args
+        def to_controlled_hash **_args
           super.merge!({ fields: @fields })
         end
       end

data/lib/contrast/agent/telemetry/events/startup_metrics_event.rb

@@ -50,7 +50,7 @@ module Contrast
         def initialize
           super
           @settings = []
-          add_config_keys(::Contrast::CONFIG.root, 'root')
+          add_config_keys(::Contrast::CONFIG.config, 'root')
           @settings << ENV.keys.select { |v| v.starts_with?('CONTRAST') }
           @settings.flatten
           add_tags
@@ -70,9 +70,9 @@ module Contrast
         end
 
         def add_config_keys config, nested_key
-          config.to_hash.reject! { |_k, v| REJECTED_VALUES.include?(v) }
+          config.to_contrast_hash.reject! { |_k, v| REJECTED_VALUES.include?(v) }
 
-          config.to_hash.each do |k, v|
+          config.to_contrast_hash.each do |k, v|
             unless v.cs__class <= Contrast::Config::BaseConfiguration
               @settings << "#{ nested_key }.#{ k }"
               next

data/lib/contrast/agent/thread_watcher.rb

@@ -2,8 +2,6 @@
 # frozen_string_literal: true
 
 require 'contrast/components/logger'
-require 'contrast/agent/service_heartbeat'
-require 'contrast/api/communication/messaging_queue'
 require 'contrast/agent/reporting/report'
 require 'contrast/agent/reporting/reporter_heartbeat'
 require 'contrast/agent/telemetry/base'
@@ -16,10 +14,6 @@ module Contrast
 
       # @return [Contrast::Utils::HeapDumpUtil]
       attr_reader :heapdump_util
-      # @return [Contrast::Agent::ServiceHeartbeat, nil]
-      attr_reader :heartbeat
-      # @return [Contrast::Api::Communication::MessagingQueue, nil]
-      attr_reader :messaging_queue
       # @return [Contrast::Agent::Reporter]
       attr_reader :reporter
       # @return [Contrast::Agent::ReporterHeartbeat]
@@ -28,10 +22,6 @@ module Contrast
       def initialize
         @pids = {}
         @heapdump_util = Contrast::Utils::HeapDumpUtil.new
-        unless ::Contrast::CONTRAST_SERVICE.unnecessary?
-          @heartbeat = Contrast::Agent::ServiceHeartbeat.new
-          @messaging_queue = Contrast::Api::Communication::MessagingQueue.new
-        end
         @reporter = Contrast::Agent::Reporter.new
         @reporter_heartbeat = Contrast::Agent::ReporterHeartbeat.new
         @telemetry = Contrast::Agent::Telemetry::Base.new if Contrast::Agent::Telemetry::Base.enabled?
@@ -42,16 +32,13 @@ module Contrast
         return unless ::Contrast::AGENT.enabled?
 
         logger.debug('ThreadWatcher started threads')
-        heartbeat_status = init_thread(heartbeat)
-        messaging_status = init_thread(messaging_queue)
-        @pids[Process.pid] = messaging_status && heartbeat_status
+        reporter_status = init_thread(reporter)
+        reporter_heartbeat_status = init_thread(reporter_heartbeat)
+        @pids[Process.pid] = reporter_status && reporter_heartbeat_status
         if Contrast::Agent::Telemetry::Base.enabled?
           telemetry_status = init_thread(telemetry_queue)
           @pids[Process.pid] = @pids[Process.pid] && telemetry_status
         end
-        reporter_status = init_thread(reporter)
-        reporter_heartbeat_status = init_thread(reporter_heartbeat)
-        @pids[Process.pid] = @pids[Process.pid] && reporter_status && reporter_heartbeat_status
         @pids
       end
 
@@ -63,8 +50,6 @@ module Contrast
       end
 
       def shutdown!
-        heartbeat&.stop!
-        messaging_queue&.stop!
         heapdump_util&.stop!
         telemetry_queue&.stop!
         reporter&.stop!

data/lib/contrast/agent/version.rb

@@ -3,6 +3,6 @@
 
 module Contrast
   module Agent
-    VERSION = '6.6.4'
+    VERSION = '6.8.0'
   end
 end

data/lib/contrast/agent.rb

@@ -42,9 +42,6 @@ require 'contrast/utils/thread_tracker'
 # Framework support
 require 'contrast/framework/manager'
 
-# Communication to SR
-require 'contrast/api/communication'
-
 require 'contrast/agent/thread_watcher'
 
 module Contrast
@@ -66,11 +63,6 @@ module Contrast
       thread_watcher.heapdump_util
     end
 
-    # @return [nil, Contrast::Api::Communication::MessagingQueue]
-    def self.messaging_queue
-      thread_watcher.messaging_queue
-    end
-
     # @return [nil, Contrast::Agent::Telemetry::Base]
     def self.telemetry_queue
       thread_watcher.telemetry_queue
@@ -87,14 +79,11 @@ module Contrast
   end
 end
 
-require 'contrast/api'
-
 require 'contrast/utils/resource_loader'
 require 'contrast/utils/duck_utils'
 require 'contrast/agent/tracepoint_hook'
 require 'contrast/agent/at_exit_hook'
 
-# communication with contrast service
 require 'contrast/agent/exclusion_matcher'
 
 # threads that handle contrast scope

data/lib/contrast/agent_lib/api/command_injection.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: false
+
+require 'ffi'
+# require the gem
+require 'contrast-agent-lib'
+
+module Contrast
+  module AgentLib
+    # This module is defined in Rust as external, we used it here.
+    # Initializes the AgentLib. Here will be all methods from
+    # the C bindings  contrast_c::cmdi_semantic_chained_command module.
+    module CommandInjection
+      extend FFI::Library
+      ffi_lib ContrastAgentLib::CONTRAST_C
+
+      attach_function :get_index_of_chained_command, [:string], :long_long
+      attach_function :does_command_contain_dangerous_path, [:string], :int
+
+      private
+
+      # Checks that a given shell command contained a chained command.
+      # This is used for the cmd-injection-semantic-chained-commands rule.
+      #
+      # @param cmd [String] command to check.
+      # @return index[Integer] Returns the index of the command chaining if found.
+      # If the chaining index is >= 0, an injection is detected. Returns -1 when
+      # no command chaining is found.
+      def dl__index_of_chained_command cmd
+        get_index_of_chained_command(cmd)
+      end
+
+      # Checks if a given shell command is trying to access a dangerous path.
+      # This is used for the cmd-injection-semantic-dangerous-paths rule.
+      #
+      # @param path [String] path to check.
+      # @return index[Boolean] Returns 1 if a dangerous path is found.
+      # Returns 0 if no dangerous paths are found.
+      def dl__dangerous_path? path
+        return false if does_command_contain_dangerous_path(path).zero?
+
+        true
+      end
+    end
+  end
+end

data/lib/contrast/agent_lib/api/init.rb

@@ -0,0 +1,101 @@
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: false
+
+require 'ffi'
+# require the gem
+require 'contrast-agent-lib'
+
+module Contrast
+  module AgentLib
+    # This module is defined in Rust as external, we used it here.
+    # Initializes the AgentLib. Here will be all methods from
+    # the C bindings agent_init mod.
+    module Init
+      extend FFI::Library
+      ffi_lib ContrastAgentLib::CONTRAST_C
+
+      # Init
+      #
+      # 0 => OK, -1 => Err
+      # The attach function could be called also like this:
+      # attach_function :ruby_name, :c_name, [ :params ], :returns, { :options => values }
+      # an that way we define a ruby_name for the C method, but we alias to make a documentation
+      # for the method.
+      #
+      # Also we extend the FFI::Library inside this module so we could also redefine the
+      # attach_function to our taste, not worry about it leaking outside of this module.
+      #
+      # @param [Symbol] Name of required function.
+      # @param [Array] An array of argument types.
+      # @return [Integer] Return type of the function.
+      attach_function :init, [], :int
+
+      # TODO: RUBY-1693
+      #  Initialize agent lib without any optional settings. To set optional settings consider using
+      # `init_with_options` instead If you want to enable logging, it must be set using environment variables
+      # `CONTRAST_AGENTLIB_LOG_LEVEL` - set to log level.  Must of one of ERROR, WARN, INFO, DEBUG or TRACE
+      # `CONTRAST_AGENTLIB_LOG_DIR` - must point to an accessible directory where logs will be written.
+      #  The name of the log file
+      # is auto-generated and cannot be set. The format is 'libcontrast_<date>_<process_id>.log'
+      #
+      # If these environment variables are not present during `init`, agent-lib will be initialized with
+      # logging disabled and you will not be able to re-enable it using `change_log_settings`
+      # @param [Symbol] Name of required function.
+      # @param [Array] An array of argument types.
+      # @return [Integer] Return type of the function.
+      attach_function :init_with_options, %i[bool string string], :int
+
+      # TODO: RUBY-1693
+      # Change log settings for agent lib after it's been initialized.  This api must be used after init
+      #
+      # Safety
+      # The `log_level` parameter must point to must point to an UTF-8 encoded string C-string
+      # @param enable_logging [Boolean] flag to enable or disable logging.
+      # @param log_level [String] UTF-8 encoded string indicating the maximum log level
+      # if logging is enabled
+      attach_function :change_log_settings, %i[bool string], :int
+
+      # TODO: RUBY-1693
+      # Initialize AgentLib with options.
+      # If init returns 0 = successful setup with options
+      # if init returns 1 = unsuccessful setup with options
+      #
+      # @param enable_logging [Boolean] flag to enable or disable logging.
+      # @param log_dir [String] path to existing log directory.
+      # @param log_level [String] OFF, ERROR, WARN, INFO, DEBUG or TRACE.
+      # @return [Boolean] true if initialized false if not.
+      def dl__init_with_options enable_logging, log_dir, log_level
+        # This is useful for scope sensitive string pointers, if function ends and
+        # you need them to be picked up after the C function.
+        init_with_options(enable_logging, log_dir, log_level).zero?
+      end
+
+      private
+
+      # Initialize AgentLib without options. Log level could not be set after.
+      # If you want to set the log levels you can do it be ENV variables:
+      # EVN [CONTRAST_AGENTLIB_LOG_LEVEL] - set to log level.  Must of one of ERROR, WARN, INFO, DEBUG or TRACE
+      # ENV['CONTRAST_AGENTLIB_LOG_DIR'] - must point to an accessible directory where logs will be written.
+      # The name of the log file.
+      #
+      # @return [Boolean] true if initialized, false if not.
+      def dl__init
+        init.zero?
+      end
+
+      # TODO: RUBY-1693
+      # Change the log settings. This api must be called after the dl__init_with_options.
+      #
+      # @param enable_log [Boolean] flag to enable or disable logging this sets the inner flag.
+      # @param log_level [String] OFF, ERROR, WARN, INFO, DEBUG or TRACE.
+      # @return [Boolean] true if initialized false if not.
+      def dl__change_log_settings enable_log, log_level
+        # transform to C strings pointers here and pass to function.
+        log_dir_pointer = FFI::MemoryPointer.from_string(log_level.dup.force_encoding('UTF-8'))
+        return true if change_log_settings(enable_log, log_dir_pointer).zero?
+
+        false
+      end
+    end
+  end
+end