contrast-agent 4.14.0 → 5.2.0

data/lib/contrast/agent/reporting/settings/server_features.rb

@@ -0,0 +1,78 @@
+# 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'
+require 'contrast/agent/reporting/settings/assess_server_feature'
+require 'contrast/agent/reporting/settings/protect_server_feature'
+
+module Contrast
+  module Agent
+    module Reporting
+      # This module will hold all the settings from the TS responce
+      module Settings
+        # All of the settings from TeamServer that apply at the server level.
+        # At least one, but not necessarily all, setting will differ from the agent's current set.
+        # agents are able to replace all server settings with those in this message.
+        class ServerFeatures
+          # The level at which the agent should log. Overridden by agent.logger.level
+          # if set in a local configuration
+          #
+          # @return log_level [String] [ ERROR, WARN, INFO, DEBUG, TRACE ]
+          def log_level
+            @_log_level ||= Contrast::Utils::ObjectShare::EMPTY_STRING
+          end
+
+          # set the log level
+          #
+          # @param log_level [String]
+          # @return log_level [String] [ ERROR, WARN, INFO, DEBUG, TRACE ]
+          def log_level= log_level
+            @_log_level = log_level if log_level.is_a? String
+          end
+
+          # Where to log the agent's log file, if set by the user. Overridden by agent.logger.path
+          # if set in a local configuration.
+          #
+          # @return log_file [String] path
+          def log_file
+            @_log_file ||= Contrast::Utils::ObjectShare::EMPTY_STRING
+          end
+
+          # Set the log file
+          #
+          # @param log_file [String] path
+          # @return log_file [String] path
+          def log_file= log_file
+            @_log_file = log_file if log_file.is_a? String
+          end
+
+          # Controls for the reporting of telemetry events from the agent to TeamServer.
+          # This is NOT for the agent telemetry feature collecting metrics sent to other services.
+          #
+          # @return telemetry [Boolean]
+          def telemetry
+            @_telemetry
+          end
+
+          # sets the telemetry value
+          #
+          # @param telemetry [Boolean]
+          # @return telemetry [Boolean]
+          def telemetry= telemetry
+            @_telemetry = telemetry if !!telemetry == telemetry
+          end
+
+          # @return assess [Contrast::Agent::Reporting::Settings::AssessServerFeature]
+          def assess
+            @_assess ||= Contrast::Agent::Reporting::Settings::AssessServerFeature.new
+          end
+
+          # @return protect [Contrast::Agent::Reporting::Settings::ProtectServerFeature]
+          def protect
+            @_protect ||= Contrast::Agent::Reporting::Settings::ProtectServerFeature.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/contrast/agent/request.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
 require 'resolv'
@@ -17,6 +17,12 @@ module Contrast
     # provides access to the original Rack::Request object as well as extracts
     # data in a format that the Agent expects, caching those transformations in
     # order to avoid repeatedly creating Strings & thrashing GC.
+    #
+    # @attr_reader rack_request [Rack::Request] The passed to the Agent RackRequest to be wrapped.
+    # @attr_accessor route [Contrast::Api::Dtm::RouteCoverage] the route, used for findings, of this request
+    # @attr_accessor observed_route [Contrast::Api::Dtm::ObservedRoute] the route, used for coverage of this request
+    # @attr_accessor new_observed_route [Contrast::Agent::Reporting::ObservedRoute] the route, used for coverage, of
+    # this request
     class Request
       include Contrast::Utils::RequestUtils
       include Contrast::Components::Logger::InstanceMethods
@@ -30,16 +36,31 @@ module Contrast
       LAST_NUMBER_MARKER = '/{n}'
 
       attr_reader :rack_request
-      attr_accessor :route, :observed_route
+      attr_accessor :route, :observed_route, :new_observed_route
 
       # Delegate calls to the following methods to the attribute @rack_request
       def_delegators :@rack_request, :base_url, :content_type, :cookies, :env, :ip, :path, :port, :query_string,
                      :request_method, :scheme, :url, :user_agent
 
+      # Initialize new Contrast Request
+      #
+      # @param rack_request [Rack::Request] The passed to the Agent RackRequest to be wrapped.
       def initialize rack_request
         @rack_request = rack_request
       end
 
+      # The HTTP version of this request
+      # @return [String]
+      def version
+        env = rack_request.env
+        return '1.1' unless env
+
+        version = env['HTTP_VERSION']
+        return '1.1' unless version
+
+        version.split('/')[-1]
+      end
+
       # Returns a normalized form of the URI. In "normal" URIs
       # this will return an unchanged String, but in REST-y
       # URIs this will normalize the digit path tokens, e.g.:
@@ -49,9 +70,11 @@ module Contrast
       # /accounts/{n}/view
       #
       # Should also handle the ;jsessionid.
+      #
+      # @return uri [String]
       def normalized_uri
         @_normalized_uri ||= begin
-          path = rack_request.path
+          path = rack_request.path_info
           uri = path.split(Contrast::Utils::ObjectShare::SEMICOLON)[0]    # remove ;jsessionid
           uri = uri.split(Contrast::Utils::ObjectShare::QUESTION_MARK)[0] # remove ?query_string=
           uri.gsub(INNER_REST_TOKEN, INNER_NUMBER_MARKER)                 # replace interior tokens
@@ -59,6 +82,9 @@ module Contrast
         end
       end
 
+      # Returns the request file type
+      #
+      # @return type [Symbol<:XML, :JSON, :NORMAL>]
       def document_type
         @_document_type ||= if /xml/i.match?(content_type) || body&.start_with?('<?xml')
                               :XML
@@ -70,6 +96,8 @@ module Contrast
       end
 
       # Header keys upcased and any underscores replaced with dashes
+      #
+      # @return headers [Hash]
       def headers
         @_headers ||= with_contrast_scope do
           hash = {}
@@ -85,6 +113,10 @@ module Contrast
         end
       end
 
+      # Try and read the body and return memorized object of the body.
+      # If body contains file, do not parse it, otherwiseBody might be nil
+      #
+      # @return @_body [String, nil] The body of the Rack::Request
       def body
         # Memoize a flag indicating whether we've tried to read the body or not
         # (can't use body because it might be nil)
@@ -121,10 +153,16 @@ module Contrast
         @_dtm ||= Contrast::Api::Dtm::HttpRequest.build(self)
       end
 
+      # flattened hash of request params
+      #
+      # @return parameters [Hash]
       def parameters
         @_parameters ||= with_contrast_scope { normalize_params(rack_request.params) }
       end
 
+      # returns multipart filenames
+      #
+      # @return file_names [Hash]
       def file_names
         @_file_names ||= begin
           names = {}
@@ -136,6 +174,9 @@ module Contrast
         end
       end
 
+      # returns or fenerates the hash checksum for the request
+      #
+      # @return @_hash_id [String] Contrast::Utils::HashDigest generated string checksum
       def hash_id
         @_hash_id ||= Contrast::Utils::HashDigest.generate_request_hash(self)
       end

data/lib/contrast/agent/request_context.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
 require 'contrast/utils/timer'
@@ -9,6 +9,8 @@ require 'contrast/components/logger'
 require 'contrast/components/scope'
 require 'contrast/utils/request_utils'
 require 'contrast/agent/request_context_extend'
+require 'contrast/agent/reporting/reporting_events/observed_route'
+require 'contrast/agent/reporting/input_analysis/input_analysis'
 
 module Contrast
   module Agent
@@ -26,6 +28,8 @@ module Contrast
     # @attr_reader server_activity [Contrast::Api::Dtm::ServerActivity] the server activity found in this request
     # @attr_reader route [Contrast::Api::Dtm::RouteCoverage] the route, used for findings, of this request
     # @attr_reader observed_route [Contrast::Api::Dtm::ObservedRoute] the route, used for coverage, of this request
+    # @attr_reader new_observed_route [Contrast::Agent::Reporting::ObservedRoute] the route, used for coverage, of this
+    # request
     class RequestContext
       include Contrast::Components::Logger::InstanceMethods
       include Contrast::Components::Scope::InstanceMethods
@@ -33,9 +37,10 @@ module Contrast
       include Contrast::Agent::RequestContextExtend
 
       EMPTY_INPUT_ANALYSIS_PB = Contrast::Api::Settings::InputAnalysis.new
+      INPUT_ANALYSIS = Contrast::Agent::Reporting::InputAnalysis.new
 
-      attr_reader :activity, :logging_hash, :observed_route, :request, :response, :route, :speedracer_input_analysis,
-                  :server_activity, :timer
+      attr_reader :activity, :logging_hash, :observed_route, :new_observed_route, :request, :response, :route,
+                  :speedracer_input_analysis, :agent_input_analysis, :server_activity, :timer
 
       def initialize rack_request, app_loaded = true
         with_contrast_scope do
@@ -51,13 +56,14 @@ module Contrast
 
           @server_activity = Contrast::Api::Dtm::ServerActivity.new
 
-          @observed_route = Contrast::Api::Dtm::ObservedRoute.new
-
           # build analyzer
           @do_not_track = false
           @speedracer_input_analysis = EMPTY_INPUT_ANALYSIS_PB
           speedracer_input_analysis.request = request
 
+          @agent_input_analysis = INPUT_ANALYSIS
+          agent_input_analysis.request = request
+
           # flag to indicate whether the app is fully loaded
           @app_loaded = !!app_loaded
 
@@ -68,7 +74,7 @@ module Contrast
             @sample_req, @sample_res = Contrast::Utils::Assess::SamplingUtil.instance.sample?(@request)
           end
 
-          append_route_coverage(Contrast::Agent.framework_manager.get_route_dtm(@request))
+          handle_routes
         end
       end
 
@@ -115,7 +121,19 @@ module Contrast
       def reset_activity
         @activity = Contrast::Api::Dtm::Activity.new(http_request: request.dtm)
         @server_activity = Contrast::Api::Dtm::ServerActivity.new
-        @observed_route = Contrast::Api::Dtm::ObservedRoute.new
+        @observed_route = Contrast::Api::Dtm::ObservedRoute.new # TODO: RUBY-1438 -- remove
+        @new_observed_route = Contrast::Agent::Reporting::ObservedRoute.new
+      end
+
+      private
+
+      def handle_routes
+        @observed_route = Contrast::Api::Dtm::ObservedRoute.new # TODO: RUBY-1438 -- remove
+        @new_observed_route = Contrast::Agent::Reporting::ObservedRoute.new
+        route_dtm = Contrast::Agent.framework_manager.get_route_dtm(@request)
+        new_route_coverage_dtm = Contrast::Agent.framework_manager.get_route_information(@request)
+        append_route_coverage(route_dtm)
+        append_to_new_observed_route(new_route_coverage_dtm)
       end
     end
   end

data/lib/contrast/agent/request_context_extend.rb

@@ -1,12 +1,27 @@
-# Copyright (c) 2021 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
+require 'contrast/agent/assess/rule/response/auto_complete_rule'
+require 'contrast/agent/assess/rule/response/cache_control_header_rule'
+require 'contrast/agent/assess/rule/response/click_jacking_header_rule'
+require 'contrast/agent/assess/rule/response/csp_header_insecure_rule'
+require 'contrast/agent/assess/rule/response/csp_header_missing_rule'
+require 'contrast/agent/assess/rule/response/hsts_header_rule'
+require 'contrast/agent/assess/rule/response/parameters_pollution_rule'
+require 'contrast/agent/assess/rule/response/x_content_type_header_rule'
+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'
+
 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
+    module RequestContextExtend # rubocop:disable Metrics/ModuleLength
+      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.
@@ -30,6 +45,18 @@ module Contrast
         @request.observed_route = @observed_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.
+      #
+      def append_to_new_observed_route route
+        return unless route
+
+        @new_observed_route.signature  = route.route
+        @new_observed_route.verb       = route.verb
+        @new_observed_route.url        = route.url if route.url
+        @request.new_observed_route = @new_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
@@ -55,10 +82,10 @@ module Contrast
         handle_protect_state(service_response)
         ia = service_response.input_analysis
         if ia
-          if logger.trace?
-            logger.trace('Analysis from Contrast Service', evaluations: ia.results.length)
-            logger.trace('Results', input_analysis: ia.inspect)
-          end
+          service_extract_logging ia
+          # using Agent analysis
+          initialize_agent_input_analysis request
+
           @speedracer_input_analysis = ia
           speedracer_input_analysis.request = request
         else
@@ -94,12 +121,41 @@ module Contrast
       # append anything we've learned to the request seen message this is the sum-total of all inventory information
       # that has been accumulated since the last request
       def extract_after rack_response
+        # We must ALWAYS save the response, even if we don't need it here for response sampling. It is used for other
+        # vulnerability detection, most notably XSS, and not capturing it may suppress valid findings.
         @response = Contrast::Agent::Response.new(rack_response)
-        activity.http_response = @response.dtm if @sample_res
+        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
       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.
@@ -124,6 +180,14 @@ module Contrast
         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
@@ -133,6 +197,44 @@ module Contrast
                             rule.build_attack_without_match(self, ia_result, results_by_rule[rule_id])
                           end
       end
+
+      # Sets request to be used with agent and service input analysis.
+      #
+      # @param request [Contrast::Agent::Request] our wrapper around the Rack::Request
+      # for this context
+      def initialize_agent_input_analysis request
+        # using Agent analysis
+        ia = Contrast::Agent::Protect::InputAnalyzer.analyse request
+        if ia
+          @agent_input_analysis = ia
+        else
+          logger.trace('Analysis from Agent was empty.')
+
+        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

@@ -1,8 +1,10 @@
-# Copyright (c) 2021 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
 require 'contrast/components/logger'
 require 'contrast/components/scope'
+require 'contrast/agent/reporting/reporter'
+require 'contrast/agent/reporting/reporting_utilities/dtm_message'
 
 module Contrast
   module Agent
@@ -19,15 +21,49 @@ module Contrast
         @ruleset = ::Contrast::AGENT.ruleset
       end
 
-      # TODO: RUBY-1353
+      # Send Activities messages to TS [Contrast::Agent::Reporting::ServerActivity,
+      #                                 Contrast::Api::Dtm::ServerActivity,
+      #                                 Contrast::Api::Dtm::Activity,
+      #                                 Contrast::Api::Dtm::ObservedRoute]
+      # If bypass is enabled use the reporting service if not than the messages are
+      # send with speedracer
       # TODO: RUBY-1355
-      # TODO: RUBY-1357
       # TODO: RUBY-1358
+      # TODO: RUBY-1438 -- remove
       def send_activity_messages
+        events = [context.activity]
+        unless Contrast::Agent::Reporter.enabled?
+          Contrast::Agent::Inventory::DependencyUsageAnalysis.instance.generate_library_usage(context.activity)
+          events << context.server_activity
+          events << context.observed_route
+        end
+        events.each do |message|
+          Contrast::Agent.messaging_queue&.send_event_eventually(message)
+        end
+      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,
+      # that method should be removed.
+      # TODO: RUBY-1358
+      def report_activity
+        return unless Contrast::Agent::Reporter.enabled?
+
+        reporter = Contrast::Agent.reporter
+        return unless reporter
+
         Contrast::Agent::Inventory::DependencyUsageAnalysis.instance.generate_library_usage(context.activity)
-        [context.server_activity, context.activity, context.observed_route].each do |message|
-          Contrast::Agent.messaging_queue.send_event_eventually(message)
+        [
+          context.new_observed_route,
+          Contrast::Agent::Reporting::DtmMessage.dtm_to_event(context.server_activity),
+          Contrast::Agent::Reporting::DtmMessage.dtm_to_event(context.activity.library_usages)
+        ].each do |event|
+          reporter.send_event(event)
+        rescue StandardError => e
+          logger.warn('Unable to send Event Activity', e)
         end
+        context.activity.library_usages.clear # TODO: RUBY-1355 remove when no longer using activity
       end
 
       # If the response is streaming, we should only perform filtering on our stream safe rules

data/lib/contrast/agent/response.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
 require 'resolv'
@@ -29,6 +29,9 @@ module Contrast
         @is_array = !rack_response.is_a?(Rack::Response)
       end
 
+      # The document type of the response, based on its Content-Type. Can be one of :JSON, :NORMAL, :XML, or nothing.
+      #
+      # @return [Symbol<:XML, :JSON, :NORMAL>, nil]
       def document_type
         case content_type
         when /xml/i
@@ -40,7 +43,10 @@ module Contrast
         end
       end
 
-      # B/c the response can change, we can't memoize this :(
+      # 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
@@ -55,35 +61,37 @@ module Contrast
         context_response
       end
 
+      # The response code of this response
+      #
+      # @return [Integer]
       def response_code
         return unless rack_response
 
         @is_array ? rack_response[0].to_i : rack_response.status
       end
 
+      # The headers of this response
+      #
+      # @return [Hash, nil]
       def headers
         return unless rack_response
 
-        if @is_array
-          rack_response[1]
-        else
-          rack_response.headers
-        end
+        @is_array ? rack_response[1] : rack_response.headers
       end
 
+      # The Content-Type of this response, as set in the headers hash under the key Rack::CONTENT_TYPE
+      #
+      # @return [String, nil]
       def content_type
         return unless rack_response
 
-        if @is_array
-          headers[Rack::CONTENT_TYPE]
-        else
-          rack_response.content_type
-        end
+        @is_array ? headers[Rack::CONTENT_TYPE] : rack_response.content_type
       end
 
-      # The response body can change during the request lifecycle
-      # We should not extract it out as a variable here, or we'll miss those
-      # changes.
+      # The response body can change during the request lifecycle, so we have to look it up every time we need it.
+      # We should not extract it out as a variable here, or we'll miss those changes.
+      #
+      # @return [String, nil]
       def body
         return unless rack_response
 

data/lib/contrast/agent/rule_set.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
 require 'contrast/components/logger'