contrast-agent 7.4.0 → 7.5.0

data/lib/contrast/agent/protect/rule/input_classification/encoding.rb

@@ -37,7 +37,7 @@ module Contrast
             # The Base64 method will return printable ascii characters, so we can use this to determine if the value is
             # encoded or not.
             #
-            # The solution in this case is encodind the value, and then decoding it. If the value is already encoded
+            # The solution in this case is encoding the value, and then decoding it. If the value is already encoded
             # it will not be eq to the original value. If the value is not encoded, it will be eq to the original value.
             #
             # @param value [String] input to check for encoding status.
@@ -96,11 +96,43 @@ module Contrast
             def cs__decode64 value, input_type
               return value unless cs__base64?(value, input_type)
 
-              Base64.decode64(value)
+              new_value = try_base64_decode(value)
+              new_value, success = normalize_encoding(new_value)
+              return new_value if success
+
+              value
             rescue StandardError => e
               logger.error('Error while decoding base64', error: e, message: e.message, backtrace: e.backtrace)
               value
             end
+
+            private
+
+            # Try and decode the value, do not use decoding if the value have zero bytes.
+            def try_base64_decode value
+              new_value = Base64.decode64(value)
+              # check for null bytes:
+              return new_value unless new_value.bytes.select(&:zero?).any?
+
+              value
+            end
+
+            # Detecting encoded Base64 is not perfect. In some cases it will detect certain inputs as
+            # encoded and will try to decode them. Even if the decoding is successful, the value may be
+            # encoded back to ASCII format. AgentLib will raise UTF-8 error in this case.
+            # This method will try to normalize the encoding to UTF-8. If the encoding fails, this means
+            # that the decoding was not successful and the value will be returned as is. Otherwise a
+            # base64 decoded string with ASCII-8BIT encoding will be parsed to UTF-8 without errors.
+            #
+            # @param value [String] input to normalize.
+            # @return [Array<String, Boolean>] normalized value and success flag.
+            def normalize_encoding value
+              new_value = value.dup.encode!('Windows-1252').force_encoding('UTF-8')
+              [new_value, true]
+            rescue StandardError
+              # encoding failed, or the decoding from base64 failed.
+              [nil, false]
+            end
           end
         end
       end

data/lib/contrast/agent/protect/rule/no_sqli/no_sqli.rb

@@ -32,6 +32,9 @@ module Contrast
             NAME
           end
 
+          # Return the specific blocking message for this rule.
+          #
+          # @return [String] the reason for the raised security exception.
           def block_message
             BLOCK_MESSAGE
           end
@@ -56,9 +59,9 @@ module Contrast
             return unless result
 
             append_to_activity(context, result)
-
+            record_triggered(context)
             cef_logging(result, :successful_attack)
-            raise(Contrast::SecurityException.new(self, BLOCK_MESSAGE)) if blocked?
+            raise(Contrast::SecurityException.new(self, BLOCK_MESSAGE)) if blocked_violation?(result)
           end
 
           def build_attack_with_match context, input_analysis_result, result, candidate_string, **kwargs

data/lib/contrast/agent/protect/rule/path_traversal/path_traversal.rb

@@ -26,6 +26,8 @@ module Contrast
             JSON_VALUE, MULTIPART_VALUE, MULTIPART_FIELD_NAME, XML_VALUE, DWR_VALUE, URI
           ].cs__freeze
 
+          BLOCK_MESSAGE = 'Path Traversal rule triggered. Request blocked.'
+
           def rule_name
             NAME
           end
@@ -48,6 +50,13 @@ module Contrast
             APPLICABLE_USER_INPUTS
           end
 
+          # Return the specific blocking message for this rule.
+          #
+          # @return [String] the reason for the raised security exception.
+          def block_message
+            BLOCK_MESSAGE
+          end
+
           # Path Traversal input classification
           #
           # @return [module<Contrast::Agent::Protect::Rule::PathTraversalInputClassification>]
@@ -55,19 +64,15 @@ module Contrast
             @_classification ||= Contrast::Agent::Protect::Rule::PathTraversalInputClassification.cs__freeze
           end
 
-          def infilter context, method, path
+          def infilter context, _method, path
             return unless infilter?(context)
 
             result = find_attacker(context, path)
             return unless result
 
             append_to_activity(context, result)
-            return unless blocked?
-
-            result_rule_name = Contrast::Utils::StringUtils.transform_string(result.rule_id)
-            cef_logging(result, :successful_attack, value: path)
-            exception_messasge = "#{ result_rule_name } rule triggered. Call to File.#{ method } blocked."
-            raise(Contrast::SecurityException.new(self, exception_messasge))
+            record_triggered(context)
+            raise(Contrast::SecurityException.new(self, block_message)) if blocked_violation?(result)
           end
 
           protected

data/lib/contrast/agent/protect/rule/path_traversal/path_traversal_semantic_security_bypass.rb

@@ -53,10 +53,10 @@ module Contrast
             return unless result
 
             append_to_activity(context, result)
-            return unless blocked?
+            record_triggered(context)
+            return unless blocked_violation?(result)
 
             result_rule_name = Contrast::Utils::StringUtils.transform_string(result.rule_id)
-            cef_logging(result, :successful_attack, value: path)
             exception_messasge = "#{ result_rule_name } rule triggered. Call to File.#{ method } blocked."
             raise(Contrast::SecurityException.new(self, exception_messasge))
           end

data/lib/contrast/agent/protect/rule/sqli/sqli_base_rule.rb

@@ -26,9 +26,8 @@ module Contrast
             return unless result
 
             append_to_activity(context, result)
-
-            cef_logging(result, :successful_attack)
-            raise(Contrast::SecurityException.new(self, BLOCK_MESSAGE)) if blocked?
+            record_triggered(context)
+            raise(Contrast::SecurityException.new(self, BLOCK_MESSAGE)) if blocked_violation?(result)
           end
         end
       end

data/lib/contrast/agent/protect/rule/sqli/sqli_semantic/sqli_dangerous_functions.rb

@@ -26,9 +26,8 @@ module Contrast
             return unless result
 
             append_to_activity(context, result)
-
-            cef_logging(result, :successful_attack)
-            raise(Contrast::SecurityException.new(self, BLOCK_MESSAGE)) if blocked?
+            record_triggered(context)
+            raise(Contrast::SecurityException.new(self, BLOCK_MESSAGE)) if blocked_violation?(result)
           end
 
           protected
@@ -39,8 +38,8 @@ module Contrast
 
           def build_violation context, potential_attack_string
             result = build_attack_result(context)
-            update_successful_attack_response(context, nil, result, potential_attack_string)
             append_sample(context, nil, result, potential_attack_string)
+            update_successful_attack_response(context, nil, result, potential_attack_string)
             result
           end
 

data/lib/contrast/agent/protect/rule/unsafe_file_upload/unsafe_file_upload.rb

@@ -28,6 +28,9 @@ module Contrast
             APPLICABLE_USER_INPUTS
           end
 
+          # Return the specific blocking message for this rule.
+          #
+          # @return [String] the reason for the raised security exception.
           def block_message
             BLOCK_MESSAGE
           end

data/lib/contrast/agent/protect/rule/utils/builders.rb

@@ -29,8 +29,8 @@ module Contrast
           #   this input
           def build_attack_with_match context, ia_result, result, candidate_string, **kwargs
             result ||= build_attack_result(context)
-            update_successful_attack_response(context, ia_result, result, candidate_string)
             append_sample(context, ia_result, result, candidate_string, **kwargs)
+            update_successful_attack_response(context, ia_result, result, candidate_string)
 
             result
           end
@@ -53,8 +53,8 @@ module Contrast
           #   this input
           def build_attack_without_match context, ia_result, result, **kwargs
             result ||= build_attack_result(context)
-            update_perimeter_attack_response(context, ia_result, result)
             append_sample(context, ia_result, result, nil, **kwargs)
+            update_perimeter_attack_response(context, ia_result, result)
 
             result
           end
@@ -97,11 +97,10 @@ module Contrast
           # @param potential_attack_string [String]
           def build_violation context, potential_attack_string
             result = build_attack_result(context)
+            append_sample(context, nil, result, potential_attack_string)
             update_successful_attack_response(context, nil, result, potential_attack_string)
             return unless result
 
-            append_sample(context, nil, result, potential_attack_string)
-            cef_logging(result, :successful_attack)
             result
           end
         end

data/lib/contrast/agent/protect/rule/utils/filters.rb

@@ -25,11 +25,12 @@ module Contrast
 
             ia_results.each do |ia_result|
               result = build_attack_result(context)
-              build_attack_without_match(context, ia_result, result)
-              append_to_activity(context, result)
+              result = build_attack_without_match(context, ia_result, result)
+              next unless result
 
-              cef_logging(result, :successful_attack)
-              raise(Contrast::SecurityException.new(self, block_message)) if blocked?
+              append_to_activity(context, result)
+              record_triggered(context)
+              raise(Contrast::SecurityException.new(self, block_message)) if blocked_violation?(result)
             end
           end
 
@@ -39,10 +40,10 @@ module Contrast
           # @param context [Contrast::Agent::RequestContext]
           # @return [Boolean]
           def prefilter? context
-            return false unless context
             return false unless enabled?
-            return false unless (results = gather_ia_results(context)) && results.any?
             return false if protect_excluded_by_url?(rule_name)
+            return false unless context
+            return false unless (results = gather_ia_results(context)) && results.any?
             return false if protect_excluded_by_input?(results)
 
             true
@@ -52,13 +53,20 @@ module Contrast
           # have a different implementation based on the rule. As such, there
           # is not parent implementation.
           #
-          # @param _context [Contrast::Agent::RequestContext] the context for
+          # @param context [Contrast::Agent::RequestContext] the context for
           #   the current request
-          # @param _match_string [String] the input that violated the rule and
+          # @param match_string [String] the input that violated the rule and
           #   matched the attack detection logic
           # @param _kwargs [Hash] key-value pairs used by the rule to build a
           #   report.
-          def infilter _context, _match_string, **_kwargs; end
+          def infilter context, match_string, _kwargs
+            return unless infilter?(context)
+            return unless (result = build_violation(context, match_string))
+
+            append_to_activity(context, result)
+            record_triggered(context)
+            raise(Contrast::SecurityException.new(self, block_message)) if blocked?
+          end
 
           # Infilter check always called before infilter to check if the rule is infilter
           # capable, not disabled or in other way excluded by url or input exclusions.
@@ -74,6 +82,18 @@ module Contrast
             true
           end
 
+          # Check befor commiting infilter
+          #
+          # @param context [Contrast::Agent::RequestContext]
+          def postfilter? context
+            return false unless enabled? && POSTFILTER_MODES.include?(mode)
+            return false if protect_excluded_by_url?(rule_name)
+            return false if protect_excluded_by_input?(gather_ia_results(context))
+            return false if mode == :NO_ACTION || mode == :PERMIT
+
+            true
+          end
+
           # Actions required for the rules that have to happen after the
           # application has completed its processing of the request.
           #
@@ -88,18 +108,14 @@ module Contrast
           # @param context [Contrast::Agent::RequestContext]
           # @raise [Contrast::SecurityException]
           def postfilter context
-            return unless enabled? && POSTFILTER_MODES.include?(mode)
-            return false if protect_excluded_by_url?(rule_name)
-            return if protect_excluded_by_input?(gather_ia_results(context))
-
-            return if mode == :NO_ACTION || mode == :PERMIT
+            return unless postfilter?(context)
 
             result = find_postfilter_attacker(context, nil)
             return unless result&.samples&.any?
 
-            cef_logging(result)
             append_to_activity(context, result)
-            return unless result.response == :BLOCKED
+            record_triggered(context)
+            return unless blocked_violation?(result)
 
             raise(Contrast::SecurityException.new(self, "#{ rule_name } triggered in postfilter. Response blocked."))
           end

data/lib/contrast/agent/protect/rule/xss/xss.rb

@@ -3,6 +3,8 @@
 
 require 'contrast/agent/protect/rule/base'
 require 'contrast/agent/protect/rule/xss/reflected_xss_input_classification'
+require 'contrast/agent/reporting/details/xss_details'
+require 'contrast/agent/reporting/details/xss_match'
 require 'contrast/agent/reporting/input_analysis/input_type'
 
 module Contrast
@@ -25,10 +27,56 @@ module Contrast
             NAME
           end
 
+          # Return the specific blocking message for this rule.
+          #
+          # @return [String] the reason for the raised security exception.
           def block_message
             BLOCK_MESSAGE
           end
 
+          # Prefilter check always called before infilter to check if the rule is infilter
+          # capable, not disabled or in other way excluded by url or input exclusions.
+          #
+          # @param context [Contrast::Agent::RequestContext]
+          # @return [Boolean]
+          def prefilter? context
+            return false unless enabled?
+            return false if protect_excluded_by_url?(rule_name)
+            return false unless context
+            return false unless (results = gather_ia_results(context)) && results.any?
+            return false if protect_excluded_by_input?(results)
+
+            true
+          end
+
+          def prefilter context
+            return unless prefilter?(context)
+
+            ia_results = gather_ia_results(context)
+
+            ia_results.each do |ia_result|
+              result = build_attack_result(context)
+              result = build_attack_without_match(context, ia_result, result)
+              next unless result
+
+              append_to_activity(context, result)
+              # XSS is being triggered, so we need to add it to the triggered rules,
+              # So the IA won't be done for this rule again for the current request.
+              record_triggered(context)
+              raise(Contrast::SecurityException.new(self, block_message)) if blocked_violation?(result)
+            end
+          end
+
+          # XSS is evaluated only on prefilter
+          def infilter? _context
+            false
+          end
+
+          # XSS is evaluated only on prefilter
+          def postfilter? _context
+            false
+          end
+
           # XSS Upload input classification
           #
           # @return [module<Contrast::Agent::Protect::Rule::ReflectedXssInputClassification>]
@@ -43,6 +91,38 @@ module Contrast
           def applicable_user_inputs
             APPLICABLE_USER_INPUTS
           end
+
+          # Adding XSS details
+          #
+          # @param context [Contrast::Agent::RequestContext]
+          # @param ia_result [Contrast::Agent::Reporting::InputAnalysisResult]
+          # @param _xss_string
+          # @param **_kwargs
+          # @return [Contrast::Agent::Reporting::RaspRuleSample]
+          def build_sample context, ia_result, _xss_string, **_kwargs
+            sample = build_base_sample(context, ia_result)
+            sample.details = Contrast::Agent::Reporting::Details::XssDetails.new
+            sample.details.input = ia_result.value
+
+            # TODO: RUBY-99999 check the if the ReflectedXss matches are needed.
+            xss_match = Contrast::Agent::Reporting::Details::XssMatch.new(ia_result.value)
+            sample.details.matches << xss_match unless xss_match.empty?
+
+            sample
+          end
+
+          private
+
+          # @param context [Contrast::Agent::RequestContext]
+          # @param potential_attack_string [String, nil]
+          # @return [Contrast::Agent::Reporting::AttackResult, nil]
+          def find_postfilter_attacker context, potential_attack_string, **kwargs
+            ia_results = gather_ia_results(context)
+            ia_results.reject! do |ia_result|
+              ia_result.score_level == Contrast::Agent::Reporting::ScoreLevel::IGNORE
+            end
+            find_attacker_with_results(context, potential_attack_string, ia_results, **kwargs)
+          end
         end
       end
     end

data/lib/contrast/agent/protect/rule/xxe/xxe.rb

@@ -26,6 +26,13 @@ module Contrast
             NAME
           end
 
+          # Return the specific blocking message for this rule.
+          #
+          # @return [String] the reason for the raised security exception.
+          def block_message
+            BLOCK_MESSAGE
+          end
+
           # Given an xml, evaluate it for an XXE attack. There's no return here
           # as this method handles appending the evaluation to the request
           # context, connecting it to the reporting mechanism at request end.
@@ -43,9 +50,9 @@ module Contrast
             return unless result
 
             append_to_activity(context, result)
-            return unless blocked?
+            record_triggered(context)
+            return unless blocked_violation?(result)
 
-            cef_logging(result, :successful_attack, value: xml)
             raise(Contrast::SecurityException.new(self, BLOCK_MESSAGE))
           end
 

data/lib/contrast/agent/reporting/details/xss_match.rb

@@ -9,6 +9,9 @@ module Contrast
       module Details
         # Matcher data for XSS rule.
         class XssMatch
+          EVIDENCE_START = /<script.*?>/i.cs__freeze
+          EVIDENCE_END = %r{</script.*?>}i.cs__freeze
+
           # @return [Integer] in ms
           attr_accessor :evidence_start
           # @return [String]
@@ -16,6 +19,16 @@ module Contrast
           # @return [Integer]
           attr_accessor :offset
 
+          # @param xss_string [String] to check for matches.
+          def initialize xss_string = ''
+            return if xss_string.empty?
+
+            @evidence_start = xss_string.index(EVIDENCE_START)
+            @offset = (xss_string[0...@evidence_start] || '').length
+            @evidence = xss_string[@evidence_start...xss_string.index(EVIDENCE_END)].gsub(EVIDENCE_START, '').
+                gsub(EVIDENCE_END, '')
+          end
+
           def to_controlled_hash
             {
                 evidenceStart: evidence_start,
@@ -23,6 +36,10 @@ module Contrast
                 offset: offset
             }
           end
+
+          def empty?
+            evidence_start.nil? || evidence.nil? || offset.nil?
+          end
         end
       end
     end

data/lib/contrast/agent/reporting/input_analysis/input_analysis.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require 'contrast/utils/object_share'
+require 'contrast/utils/duck_utils'
 require 'contrast/agent/reporting/input_analysis/input_analysis_result'
 
 module Contrast
@@ -12,10 +13,20 @@ module Contrast
         # @return [Hash] Stored request inputs for this context.
         attr_accessor :inputs
 
+        # Records rules triggered on sink.
+        #
+        # @return [Array<String>] array with rule names.
         def triggered_rules
           @_triggered_rules ||= []
         end
 
+        # Records rules with input analysis for current request.
+        #
+        # @return [Array<String>] array with rule names.
+        def analysed_rules
+          @_analysed_rules ||= []
+        end
+
         # result from input analysis
         #
         # @return @_results [Array<Contrast::Agent::Reporting::Settings::InputAnalysisResult>]
@@ -44,6 +55,27 @@ module Contrast
         def request= request
           @_request = request if request.instance_of?(Contrast::Agent::Request)
         end
+
+        # Check if the InputAnalysis is empty.
+        def no_inputs?
+          Contrast::Utils::DuckUtils.empty_duck?(inputs)
+        end
+
+        # We add the analysed rules to the list. The IA won't be build for this rule,
+        # since already it's already available.
+        #
+        # @param rule_name [String] name to record.
+        def record_analysed_rule rule_name
+          analysed_rules << rule_name unless triggered_rules.include?(rule_name)
+        end
+
+        # We add the triggered rules to the list. After request analysis will skip this rule
+        # as already triggered.
+        #
+        # @param rule_name [String] name to record.
+        def record_rule_triggered rule_name
+          triggered_rules << rule_name unless triggered_rules.include?(rule_name)
+        end
       end
     end
   end

data/lib/contrast/agent/reporting/input_analysis/input_type.rb

@@ -33,42 +33,12 @@ module Contrast
           # @return
           def to_a
             @_to_a ||= [
-              UNDEFINED_TYPE, BODY, COOKIE_NAME, COOKIE_VALUE, HEADER, PARAMETER_NAME, PARAMETER_VALUE,
-              QUERYSTRING, URI, SOCKET, JSON_VALUE, JSON_ARRAYED_VALUE, MULTIPART_CONTENT_TYPE, MULTIPART_VALUE,
-              MULTIPART_FIELD_NAME, MULTIPART_NAME, XML_VALUE, DWR_VALUE, METHOD, REQUEST, URL_PARAMETER, UNKNOWN
+              UNDEFINED_TYPE, BODY, COOKIE_NAME, COOKIE_VALUE, HEADER, PARAMETER_NAME,
+              PARAMETER_VALUE, QUERYSTRING, URI, SOCKET, JSON_VALUE, JSON_ARRAYED_VALUE, MULTIPART_CONTENT_TYPE,
+              MULTIPART_VALUE, MULTIPART_FIELD_NAME, MULTIPART_NAME, XML_VALUE, DWR_VALUE, METHOD, REQUEST,
+              URL_PARAMETER, UNKNOWN
             ]
           end
-
-          # This is a hash of the input types and their corresponding values.
-          #
-          # @return [Hash]
-
-          def to_hash
-            {
-                UNDEFINED_TYPE: '1',
-                BODY: '2',
-                COOKIE_NAME: '3',
-                COOKIE_VALUE: '4',
-                HEADER: '5',
-                PARAMETER_NAME: '6',
-                PARAMETER_VALUE: '7',
-                QUERYSTRING: '8',
-                URI: '9',
-                SOCKET: '10',
-                JSON_VALUE: '11',
-                JSON_ARRAYED_VALUE: '12',
-                MULTIPART_CONTENT_TYPE: '13',
-                MULTIPART_VALUE: '14',
-                MULTIPART_FIELD_NAME: '15',
-                MULTIPART_NAME: '16',
-                XML_VALUE: '17',
-                DWR_VALUE: '18',
-                METHOD: '19',
-                REQUEST: '20',
-                URL_PARAMETER: '21',
-                UNKNOWN: '22'
-            }
-          end
         end
       end
     end

data/lib/contrast/agent/reporting/reporting_events/finding.rb

@@ -119,16 +119,12 @@ module Contrast
               ruleId: rule_id,
               session_id: ::Contrast::ASSESS.session_id,
               version: 4
-          }
+          }.compact
         end
 
         # @raise [ArgumentError]
         def validate
           raise(ArgumentError, "#{ self } did not have a proper rule. Unable to continue.") unless @rule_id
-
-          unless ::Contrast::ASSESS.session_id
-            raise(ArgumentError, "#{ self } did not have a proper session id. Unable to continue.")
-          end
           if event_based? && events.empty?
             raise(ArgumentError, "#{ self } did not have proper events for #{ @rule_id }. Unable to continue.")
           end

data/lib/contrast/agent/reporting/reporting_events/preflight_message.rb

@@ -43,11 +43,11 @@ module Contrast
               appPath: ::Contrast::APP_CONTEXT.name, # rubocop:disable Security/Module/Name
               appVersion: ::Contrast::APP_CONTEXT.version,
               code: CODE,
-              data: '',
+              data: @data || '',
               key: 0,
               session_id: ::Contrast::ASSESS.session_id,
               routes: @routes.map(&:to_controlled_hash)
-          }
+          }.compact
         end
 
         # @raise [ArgumentError]
@@ -55,9 +55,6 @@ module Contrast
           unless Contrast::Utils::StringUtils.present?(data)
             raise(ArgumentError, "#{ cs__class } did not have a proper data. Unable to continue.")
           end
-          unless ::Contrast::ASSESS.session_id
-            raise(ArgumentError, "#{ cs__class } did not have a proper session id. Unable to continue.")
-          end
           unless Contrast::APP_CONTEXT.name # rubocop:disable Security/Module/Name
             raise(ArgumentError, "#{ cs__class } did not have a proper Application Name. Unable to continue.")
           end

data/lib/contrast/agent/reporting/reporting_utilities/build_preflight.rb

@@ -17,14 +17,14 @@ module Contrast
           # @param finding [Contrast::Agent::Reporting::Finding]
           # @return [Contrast::Agent::Reporting::Preflight, nil]
           def generate finding
-            return unless finding
+            return unless finding&.cs__is_a?(Contrast::Agent::Reporting::Finding)
 
             new_preflight = Contrast::Agent::Reporting::Preflight.new
             new_preflight_message = Contrast::Agent::Reporting::PreflightMessage.new
-            finding.routes.each do |route|
-              new_preflight_message.routes << route
+            routes = finding.routes
+            unless Contrast::Utils::DuckUtils.empty_duck?(routes)
+              routes.each { |route| new_preflight_message.routes << route }
             end
-            new_preflight_message.hash_code = finding.hash_code
             new_preflight_message.data = "#{ finding.rule_id },#{ finding.hash_code }"
             new_preflight.messages << new_preflight_message
             return new_preflight unless Contrast::Utils::DuckUtils.empty_duck?(new_preflight.messages)

data/lib/contrast/agent/reporting/reporting_utilities/reporter_client_utils.rb

@@ -118,7 +118,11 @@ module Contrast
           mode.resend.reset_rescue_attempts
           findings_to_return.each do |index|
             preflight_message = event.messages[index.to_i]
-            corresponding_finding = Contrast::Agent::Reporting::ReportingStorage.delete(preflight_message&.data)
+            preflight_data = preflight_message&.data
+            corresponding_finding = Contrast::Agent::Reporting::ReportingStorage.delete(preflight_data)
+            if Contrast::Agent::REQUEST_TRACKER.current
+              Contrast::Agent::REQUEST_TRACKER.current.reported_findings << preflight_data
+            end
             next unless corresponding_finding
 
             send_event(corresponding_finding, connection)

data/lib/contrast/agent/reporting/reporting_utilities/response_handler_utils.rb

@@ -263,7 +263,7 @@ module Contrast
           extract_response_last_modified(response, event)
           populate_response(response_data, event)
         rescue StandardError => e
-          logger.error('Unable to convert response', e)
+          logger.error('Unable to convert response', error: e)
           nil
         end