contrast-agent 3.9.1 → 6.15.3

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

@@ -0,0 +1,87 @@
+# Copyright (c) 2023 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+require 'json'
+require 'contrast/utils/object_share'
+
+module Contrast
+  module Agent
+    module Reporting
+      # This is the new Route Coverage class which will include all the needed information for the new reporting system
+      # to relay this information in the Route Observation messages. These observations are used by TeamServer to
+      # construct the route coverage information for the assess feature. They represent those methods which map to
+      # externally accessible endpoints within the application, as registered to the application framework. This also
+      # includes the literal URL and HTTP Verb used to invoke them, as they must have been called at this point to be
+      # recorded.
+      class RouteCoverage
+        # @param [String] the method signature used to uniquely identify the coverage report.
+        attr_accessor :route
+        # @param [String] the normalized URL used to access the method in the route.
+        attr_accessor :url
+        # @param [String] the HTTP Verb used  to access the method in the route.
+        attr_accessor :verb
+        # @param [Integer] the number of times this was hit; no longer needed as it can be derived.
+        attr_reader :count
+
+        def initialize
+          @route = Contrast::Utils::ObjectShare::EMPTY_STRING
+          @verb = Contrast::Utils::ObjectShare::EMPTY_STRING
+          @url = Contrast::Utils::ObjectShare::EMPTY_STRING
+          @count = 0
+        end
+
+        # Parse the given controller and route from a Rack based application framework in order to create an instance
+        # of this class
+        #
+        # @param final_controller [Class<Grape::API>, Class<Sinatra::Base>] the controller responsible for the
+        #   definition of the entrypoint of the route actively being executed
+        # @param method [String] the HTTP request method of the route actively being executed
+        # @param route_pattern [Grape::Router::Route, Mustermann::Sinatra] the pattern to which the url maps
+        # @param url [String] the literal url of the route actively being executed
+        # @return [Contrast::Agent::Reporting::RouteCoverage]
+        def attach_rack_based_data final_controller, method, route_pattern, url = nil
+          if Contrast::Utils::ClassUtil.truly_defined?('Grape::Router::Route') &&
+                route_pattern.cs__is_a?(Grape::Router::Route)
+
+            safe_pattern = route_pattern.pattern&.path&.to_s
+            safe_url = source_or_string(url || safe_pattern)
+          else
+            safe_pattern = source_or_string(route_pattern)
+            safe_url = source_or_string(url || route_pattern)
+          end
+
+          self.route = "#{ final_controller }##{ method } #{ safe_pattern }"
+          self.verb = Contrast::Utils::StringUtils.force_utf8(method)
+          self.url = Contrast::Utils::StringUtils.force_utf8(safe_url)
+          self
+        end
+
+        # Convert ActionDispatch::Journey::Route to Contrast::Agent::Reporting::RouteCoverage
+        #
+        # @param journey_obj [ActionDispatch::Journey::Route] a rails route
+        # @param url [String, nil] use url from string instead of journey object.
+        # @return [Contrast::Agent::Reporting::RouteCoverage]
+        def attach_rails_data journey_obj, url = nil
+          self.route = "#{ journey_obj.defaults[:controller] }##{ journey_obj.defaults[:action] }"
+
+          verb = source_or_string(journey_obj.verb)
+          self.verb = Contrast::Utils::StringUtils.force_utf8(verb)
+
+          url ||= source_or_string(journey_obj.path.spec)
+          self.url = Contrast::Utils::StringUtils.force_utf8(url)
+          self
+        end
+
+        def source_or_string obj
+          if obj.cs__is_a?(Regexp)
+            obj.source
+          elsif obj.cs__respond_to?(:safe_string)
+            obj.safe_string
+          else
+            obj.to_s
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# Copyright (c) 2023 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+require 'contrast/agent/reporting/reporting_events/route_discovery_observation'
+require 'contrast/agent/reporting/reporting_events/reportable_hash'
+require 'contrast/utils/duck_utils'
+
+module Contrast
+  module Agent
+    module Reporting
+      # This is the new Route Discovery class which will include all the needed information for the new reporting
+      # system to relay this information in the Application Update messages. These discoveries are used by TeamServer
+      # to construct the route coverage information for the assess feature. They represent those methods which map to
+      # externally accessible endpoints within the application, as registered to the application framework. They may or
+      # may not have been invoked at the time of reporting.
+      #
+      class RouteDiscovery < Contrast::Agent::Reporting::ReportableHash
+        # @return [Array<Contrast::Agent::Reporting::RouteDiscoveryObservation>] the routes and verbs seen that match
+        #   to this Route.
+        attr_reader :observations
+        # @return [String] the unique identifier for this route; typically the method signature. Required for
+        #   reporting.
+        attr_accessor :signature
+
+        # @param signature [String]
+        # @param observation [Contrast::Agent::Reporting::RouteDiscoveryObservation]
+        def initialize signature, observation
+          @signature = signature
+          @observations = []
+          observations << observation
+          super()
+        end
+
+        # Convert the instance variables on the class, and other information, into the identifiers required for
+        # TeamServer to process the JSON form of this message.
+        #
+        # @return [Hash]
+        # @raise [ArgumentError]
+        def to_controlled_hash
+          validate
+          {
+              count: 0, # we have this to make TS happy
+              observations: @observations.map(&:to_controlled_hash),
+              signature: @signature
+          }
+        end
+
+        # Ensure the required fields are present.
+        #
+        # @raise [ArgumentError]
+        def validate
+          return unless Contrast::Utils::DuckUtils.empty_duck?(signature)
+
+          raise(ArgumentError, "#{ self } did not have a proper signature. Unable to continue.")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# Copyright (c) 2023 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+require 'contrast/utils/string_utils'
+require 'contrast/agent/reporting/reporting_events/reportable_hash'
+require 'contrast/utils/duck_utils'
+
+module Contrast
+  module Agent
+    module Reporting
+      # This is the new Route Discovery Observation class which will include all the needed information for the new
+      # reporting system to relay this information in the Application Update messages. These route observations are
+      # used by TeamServer to construct the route coverage information for the assess feature. They represent the
+      # literal URL and HTTP verb used to invoke a method in the application, as routed by the application framework.
+      class RouteDiscoveryObservation < Contrast::Agent::Reporting::ReportableHash
+        # @return [String] the URL requested to hit this endpoint. Required for reporting; required attributes
+        attr_accessor :url
+        # @return [String] the HTTP Method requested to his this endpoint. Empty means all, so is allowed for
+        #   reporting; optional attributes
+        attr_accessor :verb
+
+        def initialize url, verb
+          @url = url
+          @verb = verb if Contrast::Utils::StringUtils.present?(verb)
+          super()
+        end
+
+        # Convert the instance variables on the class, and other information, into the identifiers required for
+        # TeamServer to process the JSON form of this message.
+        #
+        # @return [Hash]
+        # @raise [ArgumentError]
+        def to_controlled_hash
+          validate
+          { url: url, verb: verb }.compact
+        end
+
+        # Ensure the required fields are present.
+        #
+        # @raise [ArgumentError]
+        def validate
+          return unless Contrast::Utils::DuckUtils.empty_duck?(url)
+
+          raise(ArgumentError, "#{ self } did not have a proper url. Unable to continue.")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# Copyright (c) 2023 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+require 'contrast/agent/reporting/reporting_events/reporting_event'
+require 'contrast/utils/timer'
+
+module Contrast
+  module Agent
+    module Reporting
+      # This is the new ServerReportingEvent class which will include all the needed and mutual information for those
+      # events which correspond to Servers, such as Servers Activity.
+      #
+      # @abstract
+      class ServerReportingEvent < Contrast::Agent::Reporting::ReportingEvent
+        protected
+
+        # The timestamp field is a bit of a misnomer. It's really the time, in ms, since the settings for this
+        # application have been updated. If I've never updated, then it's been 0ms since then.
+        #
+        # @return [Integer]
+        def since_last_update
+          (update_time = Contrast::SETTINGS.last_server_update_ms) ? Contrast::Utils::Timer.now_ms - update_time : 0
+        end
+
+        # Human readable last time update for header set. Set to 0 if the agent is just starting and have not received
+        # the latest header from TS.
+        #
+        # @return [String]
+        def since_last_update_httpdate
+          Contrast::SETTINGS.server_settings_last_httpdate || Contrast::Utils::Timer.ms_to_httpdate(0)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# Copyright (c) 2023 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+require 'contrast/agent/reporting/reporting_events/server_reporting_event'
+require 'contrast/agent/reporting/reporting_utilities/endpoints'
+require 'contrast/utils/timer'
+
+module Contrast
+  module Agent
+    module Reporting
+      # This class will initialize a GET request to be send to TS. The server settings endpoint is the way the Agent
+      # receives server sittings - Protect rules settings, patterns, keywords and deny/allow lists, log setting.
+      class ServerSettings < Contrast::Agent::Reporting::ServerReportingEvent
+        def initialize
+          @event_method = :GET
+          @event_endpoint = Contrast::Agent::Reporting::Endpoints.server_settings
+          super()
+        end
+
+        def file_name
+          'server-settings'
+        end
+
+        # Attach the last server settings received timestamp to the request as it is required.
+        #
+        # If-Modified-Since: <day-name>, <day> <month> <year> <hour>:<minute>:<second> GMT
+        # @param request [Net::HTTPRequest]
+        def attach_headers request
+          request['If-Modified-Since'] = since_last_update_httpdate
+        end
+
+        # @return [Hash]
+        # @raise [ArgumentError]
+        def to_controlled_hash
+          {}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,133 @@
+# Copyright (c) 2023 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+require 'contrast/components/logger'
+require 'fileutils'
+require 'json'
+
+module Contrast
+  module Agent
+    module Reporting
+      # This class will facilitate the Audit functionality and it will be
+      # controlled from the configuration classes
+      class Audit
+        include Contrast::Components::Logger::InstanceMethods
+
+        attr_reader :path_for_requests, :path_for_responses
+
+        def initialize
+          generate_paths if enabled?
+        end
+
+        # This method will be handling the auditing of the requests and responses we send to TeamServer. If the audit
+        # feature is enabled, we'll log to file the request and/or response JSON objects.
+        #
+        # @param event [Contrast::Agent::Reporting::ReportingEvent] One of the DTMs valid for the
+        #   event field of Contrast::Agent::Reporting::ReportingEvent
+        # @param response_data [Net::HTTP::Response]
+        def audit_event event, response_data = nil
+          return unless ::Contrast::API.request_audit_requests || ::Contrast::API.request_audit_responses
+
+          file_name = event.cs__respond_to?(:file_name) ? event.file_name : event.cs__class.cs__name.to_s.downcase
+          data = event.event_json
+          log_data(:request, file_name, data) if data
+          return unless ::Contrast::API.request_audit_responses
+
+          data = response_data&.body ||
+              { response_code: response_data.code, response_body: 'There is no available response body' }.to_json
+          log_data(:response, file_name, data)
+        rescue StandardError => e
+          logger.error('Audit failed with error: ', event: event, error: e)
+        end
+
+        private
+
+        # This method will proceed with passing the data with to the writing method
+        # @param type [Symbol] This is the type of the file /:request, :response/
+        # @param file_name[String] file_name to log
+        # @param data[String] String representation if the logged data
+        def log_data type, file_name, data = nil
+          write_to_file(type, file_name, data) if enabled?
+        end
+
+        # This method will be actually writing to the file
+        # @param type [Symbol] This is the type of the file /:request, :response/
+        # @param event_name [String] the type portion of the file to which to write
+        # @param data [any] The data to be written to the file
+        def write_to_file type, event_name, data = nil
+          time = Time.now.to_i
+          destination = type == :request ? path_for_requests : path_for_responses
+          # If the feature is disabled or we have yet to create the directory structure, then we could have a nil
+          # destination. In that case, take no action
+          return unless destination
+
+          filename = "#{ time }_#{ Thread.current.object_id }_#{ event_name.gsub('::', '-') }_teamserver_#{ type }.json"
+          filepath = File.join(destination, filename)
+          logger.debug('Writing to file', eventname: event_name, filename: filename, filepath: filepath)
+          # Here is use append mode, because of a slightly possibility of overwriting an existing file
+          File.open(filepath, 'a') { |f| f.write(Contrast::Utils::StringUtils.force_utf8(data)) }
+        rescue StandardError => e
+          logger.warn('Saving audit failed', e: e)
+        end
+
+        # Here we will generate the directories for the requests and responses
+        def generate_paths
+          message_directories = File.expand_path(path_to_audits)
+          make_directory(message_directories) unless Dir.exist?(message_directories)
+
+          requests_destination = File.expand_path(File.join(message_directories, '/requests'))
+          responses_destination = File.expand_path(File.join(message_directories, '/responses'))
+
+          make_directory(requests_destination) if enabled_for_requests? && !Dir.exist?(requests_destination)
+          make_directory(responses_destination) if enabled_for_responses? && !Dir.exist?(responses_destination)
+
+          @path_for_requests ||= requests_destination if enabled_for_requests?
+          @path_for_responses ||= responses_destination if enabled_for_responses?
+        rescue StandardError => e
+          logger.warn('Generating the paths failed with: ', e: e)
+        end
+
+        # Make the directory provided, including any required intermediary directories.
+        # We do this here in order to make allow us to easily override directory
+        # creation while testing.
+        def make_directory directory
+          FileUtils.mkdir_p(directory)
+        end
+
+        # Retrieves the configuration value if the request audit is enabled
+        # @return [Boolean]
+        def enabled?
+          ::Contrast::API.request_audit_enable
+        end
+
+        # The boolean values for the requests and the responses should be taken under
+        # consideration only if it's in combination with enabled
+        # So in order for us to actually audit the requests, we need:
+        # - enabled? -> ture and enabled_for_requests? -> true
+        # The same is for the responses
+        #
+        #
+        # Retrieve the configuration value if the audit for requests is enabled
+        # @return [Boolean]
+        def enabled_for_requests?
+          ::Contrast::API.request_audit_requests
+        end
+
+        # Retrieve the configuration value if the audit for responses is enabled
+        # @return [Boolean]
+        def enabled_for_responses?
+          ::Contrast::API.request_audit_requests
+        end
+
+        # Retrieve the configuration value for the path of the audits
+        # The value will be read from the configuration yml
+        # but if it isn't defined any - here will be returned the default path from
+        # Contrast::Config::RequestAuditConfiguration::DEFAULT_PATH
+        # @return [String]
+        def path_to_audits
+          ::Contrast::API.request_audit_path
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# Copyright (c) 2023 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+require 'contrast/agent/reporting/reporting_events/preflight_message'
+require 'contrast/agent/reporting/reporting_events/preflight'
+require 'contrast/agent/reporting/reporting_events/route_discovery'
+require 'contrast/agent/reporting/reporting_utilities/reporting_storage'
+require 'contrast/utils/duck_utils'
+
+module Contrast
+  module Agent
+    module Reporting
+      # This module will handle the building of new preflights prior to
+      # sending them.
+      module BuildPreflight
+        class << self
+          # @param finding [Contrast::Agent::Reporting::Finding]
+          # @return [Contrast::Agent::Reporting::Preflight, nil]
+          def generate finding
+            return unless 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
+            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)
+
+            nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,176 @@
+# Copyright (c) 2023 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+require 'contrast/components/logger'
+require 'contrast/utils/object_share'
+require 'base64'
+
+module Contrast
+  module Agent
+    module Reporting
+      # This is the class which will hold up all the Endpoints we use for the direct report from the agent. It builds
+      # the full URLs needed for communication.
+      module Endpoints
+        extend Contrast::Components::Logger::InstanceMethods
+
+        APP_LANGUAGE = Contrast::Utils::ObjectShare::RUBY.upcase.cs__freeze
+        ENDPOINT_VERSION = '/v1.0'.cs__freeze
+        NG_ENDPOINTS = {
+            application_activity: "#{ Contrast::API.api_url }/api/ng/activity/application",
+            application_create: "#{ Contrast::API.api_url }/api/ng/applications/create",
+            agent_startup: "#{ Contrast::API.api_url }/api/ng/servers/"
+        }.cs__freeze
+
+        class << self
+          # @return [String,nil]
+          def application_startup
+            with_rescue do
+              "#{ application_endpoint }/startup".cs__freeze
+            end
+          end
+
+          # @return [String,nil]
+          def application_settings
+            with_rescue do
+              "#{ application_endpoint }/settings".cs__freeze
+            end
+          end
+
+          # @return [String,nil]
+          def application_inventory
+            with_rescue do
+              "#{ application_endpoint }/inventory".cs__freeze
+            end
+          end
+
+          def application_activity
+            with_rescue do
+              NG_ENDPOINTS[:application_activity].cs__freeze
+            end
+          end
+
+          # @return [String,nil]
+          def library_usage
+            with_rescue do
+              "#{ application_endpoint }/library-usage".cs__freeze
+            end
+          end
+
+          # @return [String,nil]
+          def heartbeat
+            with_rescue do
+              "#{ application_endpoint }/heartbeat".cs__freeze
+            end
+          end
+
+          # @return [String,nil]
+          def observed_route
+            with_rescue do
+              "#{ route_endpoint }/observed".cs__freeze
+            end
+          end
+
+          def server_settings
+            with_rescue do
+              "#{ server_endpoint }/settings".cs__freeze
+            end
+          end
+
+          # @return [String,nil]
+          def trace_observed
+            with_rescue do
+              "#{ trace_endpoint }/observed".cs__freeze
+            end
+          end
+
+          private
+
+          # Returns the URL needed to connect to endpoints in TeamServer required for application related information.
+          #
+          # @return [String]
+          def application_endpoint
+            @_application_endpoint ||= "#{ Contrast::API.api_url }/agents#{ ENDPOINT_VERSION }/applications" \
+                                       "#{ server_path_segment }#{ application_path_segment }"
+          end
+
+          # Returns the URL needed to connect to endpoints in TeamServer required for route related information.
+          #
+          # @return [String]
+          def route_endpoint
+            @_route_endpoint ||= "#{ Contrast::API.api_url }/agents#{ ENDPOINT_VERSION }/routes" \
+                                 "#{ server_path_segment }#{ application_path_segment }"
+          end
+
+          # Returns the URL needed to connect to endpoints in TeamServer required for server related information.
+          #
+          # @return [String]
+          def server_endpoint
+            @_server_endpoint ||= "#{ Contrast::API.api_url }/agents#{ ENDPOINT_VERSION }/servers" \
+                                  "#{ server_path_segment }"
+          end
+
+          # Returns the URL needed to connect to endpoints in TeamServer required for trace/finding related information.
+          #
+          # @return [String]
+          def trace_endpoint
+            @_trace_endpoint ||= "#{ Contrast::API.api_url }/agents#{ ENDPOINT_VERSION }/traces" \
+                                 "#{ server_path_segment }#{ application_path_segment }"
+          end
+
+          # The server host, path, and type; required for endpoints that are server specific.
+          #
+          # @return [String]
+          def server_path_segment
+            @_server_path_segment ||= "/#{ Base64.urlsafe_encode64(server_host_name, padding: false) }" \
+                                      "/#{ Base64.urlsafe_encode64(server_path, padding: false) }" \
+                                      "/#{ Base64.urlsafe_encode64(server_type, padding: false) }"
+          end
+
+          # The application language and name; required for endpoints that are application specific.
+          #
+          # @return [String]
+          def application_path_segment
+            @_application_path_segment ||= "/#{ Base64.urlsafe_encode64(APP_LANGUAGE, padding: false) }" \
+                                           "/#{ Base64.urlsafe_encode64(app_name, padding: false) }"
+          end
+
+          # @return [String,nil]
+          def server_host_name
+            return @_server_host_name unless @_server_host_name.nil?
+
+            @_server_host_name = ::Contrast::APP_CONTEXT.server_name
+          end
+
+          # @return [String,nil]
+          def server_path
+            return @_server_path unless @_server_path.nil?
+
+            @_server_path = ::Contrast::APP_CONTEXT.server_path
+          end
+
+          # @return [String,nil]
+          def server_type
+            return @_server_type unless @_server_type.nil?
+
+            @_server_type = ::Contrast::APP_CONTEXT.server_type
+          end
+
+          # @return [String,nil]
+          def app_name
+            return @_app_name unless @_app_name.nil?
+
+            @_app_name = ::Contrast::APP_CONTEXT.name # rubocop:disable Security/Module/Name
+          end
+
+          # @return [String,nil]
+          def with_rescue
+            yield
+          rescue StandardError => e
+            logger.debug('Endpoint failed with the following error', e)
+            Contrast::Utils::ObjectShare::EMPTY_STRING
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# Copyright (c) 2023 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/version'
+require 'base64'
+
+module Contrast
+  module Agent
+    module Reporting
+      # This class will build the required headers for agent reporting to TS
+      class Headers
+        attr_reader :app_name, :api_key, :agent_version, :app_language, :app_path, :app_version, :authorization,
+                    :server_name, :server_path, :server_type, :content_type, :encoding, :compression
+
+        include Contrast::Utils::ObjectShare
+        ENCODING = 'base64'
+        CONTENT_TYPE = 'application/json'
+        COMPRESSION = 'gzip'
+
+        def initialize
+          @app_name = Base64.strict_encode64(Contrast::APP_CONTEXT.name) # rubocop:disable Security/Module/Name
+          @api_key = Contrast::API.api_key
+          @agent_version = [RUBY, Contrast::Agent::VERSION].join(SPACE)
+          @app_language = RUBY
+          @app_path = Base64.strict_encode64(Contrast::APP_CONTEXT.path)
+          @app_version = Contrast::APP_CONTEXT.version
+          @authorization = Base64.strict_encode64("#{ Contrast::API.user_name }:#{ Contrast::API.service_key }")
+          @server_name = Base64.strict_encode64(Contrast::APP_CONTEXT.server_name)
+          @server_path = Base64.strict_encode64(Contrast::APP_CONTEXT.server_path)
+          @server_type = Base64.strict_encode64(Contrast::APP_CONTEXT.server_type)
+          @content_type = CONTENT_TYPE
+          @encoding = ENCODING
+          @compression = COMPRESSION
+        end
+
+        def to_contrast_hash
+          {
+              app_name: @app_name,
+              api_key: @api_key,
+              agent_version: @agent_version,
+              app_language: @app_language,
+              app_path: @app_path,
+              app_version: @app_version,
+              authorization: @authorization,
+              server_name: @server_name,
+              server_path: @server_path,
+              server_type: @server_type,
+              content_type: @content_type,
+              encoding: @encoding,
+              compression: @compression
+          }.cs__freeze
+        end
+      end
+    end
+  end
+end