contrast-agent 3.9.0 → 3.11.0

data/ext/cs__assess_regexp_track/cs__assess_regexp_track.h

@@ -1,29 +0,0 @@
-#include <funchook.h>
-#include <ruby.h>
-
-static VALUE regexp_class;
-static VALUE track_rb_n_match;
-static VALUE track_rb_pre_match;
-static VALUE track_rb_post_match;
-static VALUE track_rb_reg_match_last;
-
-VALUE rb_reg_match_pre(VALUE match);
-static VALUE *(*rb_reg_match_pre_original)(VALUE match);
-
-VALUE rb_reg_match_post(VALUE match);
-static VALUE *(*rb_reg_match_post_original)(VALUE match);
-
-VALUE rb_reg_match_last(VALUE match);
-static VALUE *(*rb_reg_match_last_original)(VALUE match);
-
-VALUE rb_reg_nth_match(int nth, VALUE match);
-static VALUE *(*rb_reg_nth_match_original)(int nth, VALUE match);
-
-static VALUE rb_reg_match_pre_hook(VALUE match);
-static VALUE rb_reg_match_post_hook(VALUE match);
-static VALUE rb_reg_match_last_hook(VALUE match);
-static VALUE rb_reg_nth_match_hook(int nth, VALUE match);
-
-static int install_regexp_hooks();
-
-void Init_cs__assess_regexp_track(void);

data/ext/cs__assess_regexp_track/extconf.rb

@@ -1,2 +0,0 @@
-$TO_MAKE = File.basename(__dir__)
-require_relative '../extconf_common'

data/lib/contrast/agent/assess/frozen_properties.rb

@@ -1,41 +0,0 @@
-# Copyright (c) 2020 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
-# frozen_string_literal: true
-
-cs__scoped_require 'set'
-cs__scoped_require 'base64'
-cs__scoped_require 'contrast/utils/tag_util'
-cs__scoped_require 'contrast/utils/prevent_serialization'
-
-module Contrast
-  module Agent
-    module Assess
-      # This class is used as an NoOP version of Properties. We'll pass this to
-      # any attempt to access Properties on a frozen object including
-      # AssessExtension iff that object did not have Properties before it was
-      # placed in a frozen state.
-      class FrozenProperties
-        include Contrast::Utils::PreventSerialization
-
-        def events
-          Contrast::Utils::ObjectShare::EMPTY_ARRAY
-        end
-
-        def properties
-          Contrast::Utils::ObjectShare::EMPTY_HASH
-        end
-
-        def tracked?
-          false
-        end
-
-        def tagged? _label
-          false
-        end
-
-        def any_tags_between? _start, _finish
-          false
-        end
-      end
-    end
-  end
-end

data/lib/contrast/agent/logger_manager.rb

@@ -1,116 +0,0 @@
-# Copyright (c) 2020 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
-# frozen_string_literal: true
-
-cs__scoped_require 'logger'
-
-cs__scoped_require 'contrast/extensions/ruby_core/module'
-cs__scoped_require 'contrast/components/interface'
-
-module Contrast
-  module Agent
-    # This class functions to serve as a wrapper around our logging, as we need
-    # to be able to dynamically update level based on updates to TeamServer.
-    class LoggerManager
-      include Contrast::Components::Interface
-      access_component :app_context, :logging, :config
-
-      DEFAULT_NAME     = 'contrast.log'
-      DEFAULT_LEVEL    = ::Logger::INFO
-      VALID_LEVELS     = %w[INFO WARN DEBUG FATAL UNKNOWN ERROR].cs__freeze
-      STDOUT_STR       = 'STDOUT'
-      STDERR_STR       = 'STDERR'
-
-      attr_reader :current,
-                  :previous_path,
-                  :previous_level
-
-      def initialize
-        update
-      rescue StandardError => e
-        Contrast::Agent::FeatureState::Logging::FALLBACK.puts 'Unable to initialize regular logger in LoggerManager.'
-        Contrast::Agent::FeatureState::Logging::FALLBACK.puts e.backtrace.join(Contrast::Utils::ObjectShare::NEW_LINE)
-      end
-
-      def update log_file = nil, log_level = nil
-        config = CONFIG.root.agent.logger
-
-        config_path  = config.path&.length.to_i.positive? ? config.path : nil
-        config_level = config.level&.length&.positive? ? config.level : nil
-
-        # config > settings > default
-        path        = valid_path(config_path   || log_file)
-        level_const = valid_level(config_level || log_level)
-
-        # don't needlessly recreate logger
-        return if @current && (path == previous_path) && (level_const == previous_level)
-
-        @previous_path  = path
-        @previous_level = level_const
-
-        @current = build(path: path, level_const: level_const)
-
-        @current.debug { 'Initialized new contrast agent logger' }
-
-        self
-      rescue StandardError => e
-        Contrast::Agent::FeatureState::Logging::FALLBACK.puts 'Unable to process update to LoggerManager.'
-        Contrast::Agent::FeatureState::Logging::FALLBACK.puts e.backtrace.join(Contrast::Utils::ObjectShare::NEW_LINE)
-      end
-
-      private
-
-      def default_progname
-        'Contrast Agent'
-      end
-
-      def build path: STDOUT_STR, progname: default_progname, level_const: DEFAULT_LEVEL
-        current = case path
-                  when STDOUT_STR, STDERR_STR
-                    ::Logger.new(Object.cs__const_get(path))
-                  else
-                    ::Logger.new(path)
-                  end
-
-        current.progname = progname
-        current.level = level_const
-
-        current.formatter = proc do |severity_f, datetime_f, progname_f, msg_f|
-          "#{ datetime_f.strftime('%Y-%m-%d %H:%M:%S,%L') } [#{ progname_f }] #{ severity_f } - #{ msg_f }\n"
-        end
-
-        current
-      end
-
-      def valid_path path
-        path = path.nil? ? Contrast::Utils::ObjectShare::EMPTY_STRING : path
-        return path if path == STDOUT_STR
-        return path if path == STDERR_STR
-
-        path = DEFAULT_NAME if path.empty?
-        if Contrast::Utils::IOUtil.write_permission?(path)
-          path
-        else
-          if File.directory?(path)
-            Contrast::Agent::FeatureState::Logging::FALLBACK.puts "Unable to create log in directory: #{ path }. \n Writing to standard out instead"
-          else
-            Contrast::Agent::FeatureState::Logging::FALLBACK.puts "Unable to write to log file: #{ path } \n Writing to standard out instead"
-          end
-
-          STDOUT_STR
-        end
-      end
-
-      def valid_level level
-        level = level.nil? ? DEFAULT_LEVEL : level
-        level = 'DEBUG' if level == 'TRACE'
-        if VALID_LEVELS.include?(level)
-          Object.cs__const_get("::Logger::#{ level }")
-        else
-          DEFAULT_LEVEL
-        end
-      rescue StandardError
-        DEFAULT_LEVEL
-      end
-    end
-  end
-end

data/lib/contrast/delegators.rb

@@ -1,9 +0,0 @@
-# Copyright (c) 2020 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
-# frozen_string_literal: true
-
-module Contrast
-  # Used to define decorators for objects to add behavior without polluting the namespace
-  module Delegators
-  end
-end
-cs__scoped_require 'contrast/delegators/application_update'

data/lib/contrast/delegators/application_update.rb

@@ -1,32 +0,0 @@
-# Copyright (c) 2020 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
-# frozen_string_literal: true
-
-module Contrast
-  module Delegators
-    # Used to decorate the ApplicationUpdate protobuf model so it can own some of the data massaging required for
-    # AppUpdate dtm
-    class ApplicationUpdate < SimpleDelegator
-      def append_view_technology_descriptor_data view_technology_descriptors
-        view_technology_descriptors.each do |vtd|
-          vtd.technology_names.each do |tech_name|
-            @delegate_sd_obj.technologies[tech_name] = true
-          end
-        end
-      end
-
-      # TS only allows you to report 500 routes per application
-      def append_route_coverage_data route_coverage_dtms
-        route_coverage_dtms.take(500).each do |route_coverage_dtm|
-          @delegate_sd_obj.routes << route_coverage_dtm
-        end
-      end
-
-      def append_platform_version platform_version
-        @delegate_sd_obj.platform = Contrast::Api::Dtm::Platform.new if @delegate_sd_obj.platform.nil?
-        @delegate_sd_obj.platform.major = platform_version.major
-        @delegate_sd_obj.platform.minor = platform_version.minor
-        @delegate_sd_obj.platform.build = platform_version.patch
-      end
-    end
-  end
-end

data/lib/contrast/utils/comment_range.rb

@@ -1,19 +0,0 @@
-# Copyright (c) 2020 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
-# frozen_string_literal: true
-
-module Contrast
-  module Utils
-    # Stores the range of a comment
-    class CommentRange
-      COMMENT_START = /<!--/.cs__freeze
-      COMMENT_END = '-->'
-
-      attr_reader :open, :close
-
-      def initialize open_idx, close_idx
-        @open = open_idx
-        @close = close_idx
-      end
-    end
-  end
-end

data/lib/contrast/utils/environment_util.rb

@@ -1,82 +0,0 @@
-# Copyright (c) 2020 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
-# frozen_string_literal: true
-
-cs__scoped_require 'socket'
-
-cs__scoped_require 'contrast/extensions/ruby_core/module'
-cs__scoped_require 'contrast/components/interface'
-cs__scoped_require 'contrast/utils/object_share'
-cs__scoped_require 'contrast/utils/string_utils'
-
-module Contrast
-  module Utils
-    # Gather information about the application and server environment
-    # that the agent is running in.
-    class EnvironmentUtil
-      CS_VERSION = 'VERSION'
-
-      # Possible names of constants that would hold version info
-      # TODO - RUBY-770
-      VERSION_CONSTANT_CANDIDATES = %w[
-        VERSION
-        ::VERSION
-        Version::VERSION
-        ::Version::VERSION
-        ::Application::VERSION
-      ].cs__freeze
-
-      class << self
-        ######### These are helpers ####################
-
-        def present? str
-          !str.nil? && !str.to_s.empty?
-        end
-
-        ######### Actually env/framework dependent ####################
-
-        # See CONTRAST-16380 for more details
-        # TODO RUBY-770
-        def determine_application_version
-          @_determine_application_version ||= begin
-            candidates = VERSION_CONSTANT_CANDIDATES.map do |name|
-              # If there's a constant named 'name' (VERSION, etc.), get its value.
-              begin
-                name.split('::').inject(Object) do |mod, class_name|
-                  mod.cs__const_get(class_name)
-                end
-              rescue LoadError, StandardError
-                nil
-              end
-            end
-            candidates.compact!
-            candidate = candidates.first || ENV[CS_VERSION]
-
-            case candidate
-            when Hash
-              candidate.values.join(Contrast::Utils::ObjectShare::PERIOD)
-            when Array
-              candidate.join(Contrast::Utils::ObjectShare::PERIOD)
-            when String
-              candidate
-            when NilClass
-              return nil
-            else
-              candidate.inspect
-            end
-          end
-        end
-
-        # Read libraries from the gemfile and append to the given ApplicationUpdate message
-        # or other class that has a libraries map association
-        # TODO - RUBY-770
-        def add_library_to_app_update app_update_pb, library_tags = ''
-          libraries = Contrast::Utils::GemfileReader.instance.library_pb_list
-          libraries.each do |n|
-            n.tags = library_tags
-            app_update_pb.libraries[n.hash_code] = n
-          end
-        end
-      end
-    end
-  end
-end

data/lib/contrast/utils/performs_logging.rb

@@ -1,152 +0,0 @@
-# Copyright (c) 2020 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
-# frozen_string_literal: true
-
-cs__scoped_require 'contrast/utils/object_share'
-cs__scoped_require 'contrast/components/interface'
-
-module Contrast
-  module Utils
-    # This utility allows us wrap our calls to logging, allowing runtime
-    # determination as to whether or not an event should be logged, based upon
-    # the Logging Configuration as specified in Common Configuration.
-    module PerformsLogging
-      include Contrast::Components::Interface
-
-      COULDNT_INIT_CONFIG = '!!! Contrast could not initialize agent from config, flushing loq queue to TARGET !!!'
-      FLUSHING_LOG_QUEUE  = '!!! Contrast exited before logger could initialize, flushing log queue to TARGET !!!'
-
-      TARGET = STDOUT
-
-      # idiom for propagating class methods
-      def self.included base
-        base.send :include, InstanceMethods
-        base.extend ClassMethods
-      end
-
-      # Grouping to allow for these methods to be included into another Module
-      # on include of the PerformsLogging Module. They'll function as instance
-      # methods in that Module.
-      module InstanceMethods #:nodoc:
-        @_log_mutex = Mutex.new
-        @_log_queue = []
-
-        protected
-
-        def init_log_queueing
-          # Queue log messages & defer logging until logger gets initialized.
-          # (Logger depends on config, so logging config errors implies
-          # circular dependencies.)
-          at_exit do
-            # Ideally we flush the queue when we detect agent init is impossible,
-            # if worse comes to worse we do it here.
-            if @_log_queue
-              lq = @_log_queue
-              if lq&.any?
-                TARGET.puts '!!! Contrast exited before logger could initialize, flushing log queue to TARGET !!!'
-                while (message = lq.pop)
-                  TARGET.puts "[#{ message[2].upcase }]\t#{ message[1] }"
-                end
-              end
-            end
-          end
-        end
-
-        def abort_log_queues
-          TARGET.puts COULDNT_INIT_CONFIG
-          if @_log_queue
-            TARGET.puts FLUSHING_LOG_QUEUE
-            while (message = @_log_queue.pop)
-              TARGET.puts "[#{ message[2].upcase }]\t#{ message[1] }"
-            end
-          end
-          @_log_queue = nil
-          @_log_mutex = nil
-        end
-
-        def flush_log_queues
-          return unless @_log_queue
-
-          # Monkeypatch this class so that the next call to #instance flushes the log queue.
-          # (Flushing the log queue within #initialize
-          # causes a deadlock, as singleton classes' #initialize
-          # gets wrapped within a mutex, and our logger will
-          # try to reference the singleton instance.)
-          self.class.class_eval do
-            class << self
-              alias_method :__instance_original, :instance
-              def instance
-                @_log_mutex.synchronize do
-                  # Restore old #instance method.
-                  class_eval do
-                    class << self
-                      def instance
-                        __instance_original
-                      end
-                    end
-                  end
-                  # Flush log queue.
-                  if @_log_queue
-                    while (message = @_log_queue.pop)
-                      log_with_level(*message, skip_queue: true)
-                    end
-                  end
-                  @_log_queue = nil
-                end
-                @_log_mutex = nil
-                __instance_original
-              end
-            end
-          end
-        end
-      end
-
-      module ClassMethods #:nodoc:
-        def log_error msg, exception = nil
-          log_with_level exception, msg, :error
-        end
-
-        def log_warn msg, exception = nil
-          log_with_level exception, msg, :warn
-        end
-
-        def log_info msg, exception = nil
-          log_with_level exception, msg, :info
-        end
-
-        def log_debug msg, exception = nil
-          log_with_level exception, msg, :debug
-        end
-
-        def debug_with_time msg
-          a = Contrast::Utils::Timer.now_ms
-          ret = yield if block_given?
-          z = Contrast::Utils::Timer.now_ms
-          log_with_level(nil, "#{ msg }: pid=#{ Process.pid }, elapsed=#{ z - a }ms", :debug)
-          ret
-        end
-
-        def log_with_level exception, msg, level, skip_queue: false
-          # Log messages are queued until the logger is initialized.
-          # If agent init fails, flush the log to TARGET.
-          if (lq = @_log_queue) && !skip_queue
-            lq.push [exception, msg, level]
-            return nil
-          end
-
-          if exception&.respond_to?(:message)
-            tmp = msg.nil? ? exception.message.to_s : "#{ exception.class.name }: #{ msg }: #{ exception.message }"
-            logger.send(level, tmp)
-
-            exception.backtrace.first(10).each { |line| logger.debug(line) } if logger.debug? && exception.cs__respond_to?(:backtrace) && exception.backtrace
-          elsif msg.to_s != Contrast::Utils::ObjectShare::EMPTY_STRING
-            logger.send(level, msg.to_s)
-          end
-
-          nil # ensure no return value
-        rescue StandardError
-          nil # NOOP
-        end
-      end
-    end
-  end
-end