contrast-agent 4.14.1 → 5.0.0

data/lib/contrast/agent/class_reopener.rb

@@ -1,258 +0,0 @@
-# Copyright (c) 2021 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
-# frozen_string_literal: true
-
-return unless RUBY_VERSION < '2.6.0' # TODO: RUBY-714 remove guard w/ EOL of 2.5
-
-require 'ripper'
-require 'contrast/extension/module'
-require 'contrast/components/logger'
-require 'contrast/components/scope'
-require 'contrast/logger/log'
-
-# This method is left purposefully at the top level namespace. Moving it
-# elsewhere will break functionality as it executes evaluations against the
-# namespace from which it is called -- ie putting it in Contrast would make all
-# changes it intends for Foo happen to Contrast::Foo instead
-#
-# @param _class_name [String] the name of the class in which the eval will
-#   redefine functionality
-# @param content [String] the String content that will function as the code in
-#   the given class
-def unbound_eval _class_name, content
-  # Yuck, this is a top-level method that has to break encapsulation
-  # in order to access scoping!
-  ::Contrast::SCOPE.scope_for_current_ec.enter_contrast_scope!
-  eval(content) # rubocop:disable Security/Eval
-rescue Exception # rubocop:disable Lint/RescueException
-  # We can't use components here, so we have to access the log directly. I hate
-  # it, but we'll have to deal with it until we remove 2.5 support.
-  Contrast::Logger::Log.instance.logger.error('Unable to perform unbound eval of new content', module: class_name)
-  # And we need to return nil here, not the value from the logger.
-  nil
-ensure
-  ::Contrast::SCOPE.scope_for_current_ec.exit_contrast_scope!
-end
-
-module Contrast
-  module Agent
-    # TODO: RUBY-714 remove w/ EOL of 2.5
-    # @deprecated Changes to this class are discouraged as this approach is
-    #   being phased out with support for those language versions.
-    class ClassReopener
-      include Contrast::Components::Logger::InstanceMethods
-      include Contrast::Components::Scope::InstanceMethods
-
-      END_NEW_LINE = "end\n"
-      PROTECTED_WITH_NEW_LINE = "protected\n"
-      PRIVATE_WITH_NEW_LINE = "private\n"
-      CLASS_SELF_LINE = "class << self\n"
-
-      attr_reader :public_singleton_methods, :class_module_path, :class_name, :files, :is_class, :name_space,
-                  :public_instance_methods, :protected_instance_methods, :private_instance_methods, :locations
-
-      def initialize module_data
-        @class_module_path = module_data.mod_name
-        clazz = module_data.mod
-        @is_class = clazz.is_a?(Class)
-        @public_instance_methods = []
-        @protected_instance_methods = []
-        @private_instance_methods = []
-        @public_singleton_methods = []
-        @files = {}
-        @name_space = []
-        @class_name = nil
-        @locations = Hash.new { |h, k| h[k] = [] }
-        gather_modules
-      end
-
-      # Indicates if any methods were rewritten for this class.
-      #
-      # @return [Boolean]
-      def staged_changes?
-        public_singleton_methods.any? ||
-            public_instance_methods.any? ||
-            protected_instance_methods.any? ||
-            private_instance_methods.any?
-      end
-
-      # Indicates if this class was written from the given location.
-      #
-      # @param source_location [Array<String, Integer>] the result of a
-      #   Method#source_location call
-      # @return [Boolean]
-      def written_from_location? source_location
-        return false unless source_location
-
-        file = source_location[0]
-        location = source_location[1]
-        locations[file].include?(location)
-      end
-
-      # Marks that this class was written from the given location.
-      #
-      # @param source_location [Array<String, Integer>] the result of a
-      #   Method#source_location call
-      # @return [Boolean]
-      def written_from_location! source_location
-        return false unless source_location
-
-        file = source_location[0]
-        location = source_location[1]
-        locations[file] << location
-      end
-
-      # Evaluate the patches that have been staged for this class, replacing
-      # the method definitions with those our rewrite.
-      def commit_patches
-        with_contrast_scope do
-          return unless staged_changes?
-
-          content = build_content
-          valid = Ripper.sexp(content)
-          unbound_eval(class_name, content) if !!valid && !class_name.empty?
-        end
-      end
-
-      # Find the sourcecode of the method at the given location and return it
-      # if it is complete and compilable.
-      #
-      # @param location [Array<String, Integer>] the result of a
-      #   Method#source_location call
-      # @param method_name [Symbol] the name of the method defined at the given
-      #   location
-      # @return [String, nil] the code defining the method or nil if no valid
-      #   code could be found.
-      def source_code location, method_name
-        file_name = location[0]
-        line_number = location[1]
-        return unless file_contents_available?(file_name, line_number)
-
-        files[file_name] = File.readlines(file_name) unless files.key?(file_name)
-        lines = files[file_name]
-        code = +''
-        # location#line_number is 1 based, arrays are 0 based
-        line_number -= 1
-        lines[line_number..-1].each do |line|
-          code << line
-          next unless compiles?(code)
-          break if complete?(code)
-        end
-        unless complete?(code) && compiles?(code)
-          logger.warn(
-              'Failed to determine sourcecode for rewriting.',
-              file: file_name,
-              method: method_name,
-              line_number: line_number)
-          return
-        end
-        code
-      end
-
-      private
-
-      def file_contents_available? file_name, line_number
-        return false unless file_name && line_number
-        return false unless File.exist?(file_name) && File.readable?(file_name)
-        return false if File.empty?(file_name)
-
-        true
-      end
-
-      def gather_modules
-        return if class_module_path.nil?
-
-        segments = class_module_path.split(Contrast::Utils::ObjectShare::DOUBLE_COLON)
-        @class_name = segments.last
-        current = nil
-        segments[0..-2].each do |chunk|
-          defined = current ? current.cs__const_defined?(chunk) : Module.cs__const_defined?(chunk)
-          next unless defined
-
-          current = current ? current.cs__const_get(chunk) : Module.cs__const_get(chunk)
-          case current
-          when Class
-            name_space << [chunk, Class]
-          when Module
-            name_space << [chunk, Module]
-          end
-        end
-      end
-
-      # code which ends with a , or \ is incomplete.
-      #
-      # @param code [String] the text to determine if complete
-      # @return [Boolean]
-      def complete? code
-        code !~ /[,\\]\s*\z/
-      end
-
-      # code which does not resolve to RubyVM::InstructionSequence does not
-      # compile
-      #
-      # @param code [String] the text to determine if compiles
-      # @return [Boolean]
-      def compiles? code
-        old_verbose = $VERBOSE
-        $VERBOSE = nil
-        RubyVM::InstructionSequence.compile(code)
-        true
-      rescue SyntaxError => _e
-        false
-      ensure
-        $VERBOSE = old_verbose
-      end
-
-      def build_content
-        content = +''
-        name_space.each do |arr|
-          name = arr[0]
-          type = arr[1]
-          if type == Class
-            content << "class #{ name }\n"
-          elsif type == Module
-            content << "module #{ name }\n"
-          end
-        end
-
-        # Set the name to be a class or module
-        content << if is_class
-                     "class #{ class_name }\n"
-                   else
-                     "module #{ class_name }\n"
-                   end
-
-        # Recreate the updated class methods
-        if public_singleton_methods.any?
-          content << CLASS_SELF_LINE
-          content << public_singleton_methods.join(Contrast::Utils::ObjectShare::NEW_LINE)
-          content << Contrast::Utils::ObjectShare::NEW_LINE
-          content << END_NEW_LINE
-        end
-
-        # Recreate the updated instance methods
-        if public_instance_methods.any?
-          content << public_instance_methods.join(Contrast::Utils::ObjectShare::NEW_LINE)
-          content << Contrast::Utils::ObjectShare::NEW_LINE
-        end
-
-        if protected_instance_methods.any?
-          content << PROTECTED_WITH_NEW_LINE
-          content << protected_instance_methods.join(Contrast::Utils::ObjectShare::NEW_LINE)
-          content << Contrast::Utils::ObjectShare::NEW_LINE
-        end
-
-        if private_instance_methods.any?
-          content << PRIVATE_WITH_NEW_LINE
-          content << private_instance_methods.join(Contrast::Utils::ObjectShare::NEW_LINE)
-          content << Contrast::Utils::ObjectShare::NEW_LINE
-        end
-
-        content << END_NEW_LINE
-        name_space.length.times do
-          content << END_NEW_LINE
-        end
-        content
-      end
-    end
-  end
-end

data/lib/contrast/agent/rewriter.rb

@@ -1,259 +0,0 @@
-# Copyright (c) 2021 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
-# frozen_string_literal: true
-
-# intentional -- we're using a << operator here
-
-return unless RUBY_VERSION < '2.6.0' # TODO: RUBY-714 remove guard w/ EOL of 2.5
-
-require 'contrast/agent/class_reopener'
-require 'contrast/agent/patching/policy/patch_status'
-require 'contrast/components/logger'
-require 'contrast/components/scope'
-require 'contrast/utils/ruby_ast_rewriter'
-
-module Contrast
-  module Agent
-    # Used for Ruby 2.5 to allow us to rewrite those methods which have
-    # interpolation in them.
-    #
-    # TODO: RUBY-714 remove w/ EOL of 2.5
-    # @deprecated Changes to this class are discouraged as this approach is
-    #   being phased out with support for those language versions.
-    class Rewriter
-      extend Contrast::Components::Logger::InstanceMethods
-      extend Contrast::Components::Scope::InstanceMethods
-
-      SELF_DEFINITION = 'def self.'
-      DEFINITION = 'def '
-
-      class << self
-        def rewrite_class module_data, redo_rewrite = false
-          mod = module_data.mod
-          return unless mod
-
-          status = Contrast::Agent::Patching::Policy::PatchStatus.get_status(mod)
-          return if (status.rewritten? || status.rewriting?) && !redo_rewrite
-
-          status.rewriting!
-
-          # default-initialize to nil within top-level method scope
-          # so that it's available w/in the `ensure` block
-          opener = nil
-          with_contrast_scope do
-            unless should_rewrite?(module_data)
-              status.no_rewrite!
-              return
-            end
-
-            opener = Contrast::Agent::ClassReopener.new(module_data)
-            if opener.nil? || (instance_methods.empty? && singleton_methods.empty?)
-              status.no_rewrite!
-              return
-            end
-
-            rewrite_all_methods(opener, mod, mod.public_instance_methods(false), :PUBLIC_INSTANCE)
-            rewrite_all_methods(opener, mod, mod.protected_instance_methods(false), :PROTECTED_INSTANCE)
-            rewrite_all_methods(opener, mod, mod.private_instance_methods(false), :PRIVATE_INSTANCE)
-            rewrite_all_methods(opener, mod, mod.singleton_methods(false), :SINGLETON)
-            status.rewritten!
-          end
-        rescue SyntaxError, StandardError => e
-          opener = nil
-          mod ||= module_data.mod
-          logger.debug('Reopening threw a handled exception - skipping rewriting', e, module: module_data.mod_name)
-          status ||= Contrast::Agent::Patching::Policy::PatchStatus.get_status(mod)
-          status.failed_rewrite!
-        ensure
-          opener&.commit_patches
-          logger.trace('Rewriting complete',
-                       module: module_data.mod_name,
-                       result: Contrast::Agent::Patching::Policy::PatchStatus.get_status(
-                           module_data.mod).rewrite_status)
-        end
-
-        private
-
-        def location_available? location
-          return unless location
-          return false if location.empty? || location[0].empty? || location[0].include?('eval')
-
-          true
-        end
-
-        def rewrite_all_methods opener, clazz, methods, type
-          methods.each do |method|
-            # Skip contrast woven methods.
-            # There should be a better way to do this
-            next if method.to_s.start_with?('cs__')
-
-            original_source_code = source_code(opener, clazz, method, type)
-            next if original_source_code.nil?
-            next if unrepeatable?(original_source_code)
-            next unless interpolations?(original_source_code)
-
-            replace_method_definition(opener, clazz, method, original_source_code, type)
-          end
-        end
-
-        def source_code opener, clazz, method_name, type
-          return unless method_exists?(clazz, method_name, type)
-
-          method_instance = method_instance(clazz, method_name, type)
-          return if method_instance.nil?
-
-          location = method_instance.source_location
-          return unless location_available?(location)
-          return if opener.written_from_location?(location)
-
-          opener.written_from_location!(location)
-          opener.source_code(location, method_name)
-        rescue SyntaxError
-          logger.debug('Can\'t parse method source', error: 'SyntaxError', module: clazz.cs__name, method: method_name)
-        rescue StandardError => e
-          if defined?(MethodSource) && defined?(MethodSource::SourceNotFoundError)
-            logger.debug(
-                'Can\'t parse method source',
-                e,
-                error: 'SourceNotFoundError',
-                module: clazz.cs__name,
-                method: method_name)
-          else
-            logger.debug('Can\'t lookup method source', module: clazz.cs__name, method: method_name)
-          end
-        end
-
-        def method_exists? clazz, method_name, type
-          case type
-          when :SINGLETON
-            clazz.cs__singleton_class.public_method_defined?(method_name)
-          when :PUBLIC_INSTANCE
-            clazz.public_method_defined?(method_name)
-          when :PROTECTED_INSTANCE
-            clazz.protected_method_defined?(method_name)
-          when :PRIVATE_INSTANCE
-            clazz.private_method_defined?(method_name)
-          end
-        end
-
-        def method_instance clazz, method_name, type
-          case type
-          when :SINGLETON
-            clazz.singleton_method(method_name)
-          else
-            clazz.instance_method(method_name)
-          end
-        end
-
-        def replace_method_definition opener, clazz, method, original_source_code, type
-          new_method_source = rewrite_method(original_source_code)
-          return unless valid_code?(new_method_source)
-
-          case type
-          when :SINGLETON
-            opener.public_singleton_methods << new_method_source
-          when :PUBLIC_INSTANCE
-            opener.public_instance_methods << new_method_source
-          when :PROTECTED_INSTANCE
-            opener.protected_instance_methods << new_method_source
-          when :PRIVATE_INSTANCE
-            opener.private_instance_methods << new_method_source
-          end
-        rescue StandardError => e
-          logger.debug('Can\'t rewrite in class_eval', e, module: clazz.cs__name, method: method)
-        end
-
-        def rewrite_method original_source_code
-          new_code = rewrite(original_source_code)
-          remove_self_definition(new_code)
-        end
-
-        def rewrite source
-          @rewriter ||= Contrast::Utils::RubyAstRewriter.new
-          @rewriter.rewrite(source)
-        end
-
-        def remove_self_definition new_code
-          new_code.gsub(SELF_DEFINITION, DEFINITION)
-        end
-
-        # attempt to generate an AST for the rewritten code, if one can be generated we can assume it is at least valid ruby
-        # if it returns nil that means that the AST was unable to build due to an error and we should use the original source code
-        def valid_code? new_content
-          !Ripper.sexp(new_content).nil?
-        end
-
-        def interpolations? method_source
-          method_source.match?(/^.*".*#(\$\w+|@\w+|@@\w+|\{.*\}).*".*$/)
-        end
-
-        # These functions cannot be repeated -- when doing replace things, we
-        # should comment these lines out.
-        # cannot repeat class foo <
-        #                         bar
-        UNREPEATABLE_FUNCTIONS = /(^|\s)(class\s*\W.*<|included(\s+do|\s*{))/.cs__freeze
-
-        # these methods dynamically create functions. replacing them in rails
-        # resulted in a lot of undefined_ errors. i know we'll have to figure
-        # out how to support them, but baby steps
-        UNREPEATABLE_ACCESSOR_FUNCTIONS =
-          /(^|\s)((cattr_accessor|cattr_reader|cattr_writer|attr_reader|attr_writer|attr_accessor|mattr_accessor|mattr_reader|mattr_writer|public) )/.cs__freeze
-        # evals are scary and terrify me. we shouldn't rewrite them if we don't
-        # have to
-        POTENTIALLY_UNREPEATABLE_FUNCTIONS =
-          /(class_eval|instance_eval|method_eval|eval|module_eval|define_method|define_method_attribute|require_dependency|instance_predicate)/.cs__freeze
-        # Binding a Constant, ie starting with ::, affects the lookup of that
-        # Constant. Since we're effectively moving the file in which it would
-        # be declared, we cannot repeat this lookup, so we cannot replace this
-        # file
-        BOUND_CONSTANTS = /(^|\s)::\w/.cs__freeze
-
-        DISABLE_FUNCTIONS_REGEXP = /(^|\s)((undef|include|extend|alias|alias_method|require|require_relative|send) )/.cs__freeze
-        def unrepeatable? original_source_code
-          (original_source_code.index('__dir__') ||
-            original_source_code.index('File.dirname') ||
-            original_source_code.index('__FILE__') ||
-            original_source_code.match?(UNREPEATABLE_FUNCTIONS) ||
-            original_source_code.match?(UNREPEATABLE_ACCESSOR_FUNCTIONS) ||
-            original_source_code.match?(POTENTIALLY_UNREPEATABLE_FUNCTIONS) ||
-            original_source_code.match?(BOUND_CONSTANTS) ||
-            original_source_code.match?(DISABLE_FUNCTIONS_REGEXP))
-        end
-
-        UNTOUCHABLE_MODULES = %w[
-          AbstractController
-          ActionCable ActionController ActionDispatch ActionMailer ActionPack ActionView
-          ActiveModel ActiveRecord ActiveSupport
-          Brakeman
-          Contrast
-          Debase
-          Debugger
-          Erubis
-          GraphQL
-          NewRelic
-          Pry
-          Puma
-          PhusionPassenger
-          Rails::Application Rails::Engine Rails::Railtie
-          Rake
-          RSpec
-          Warden
-          WEBrick
-        ].cs__freeze
-        def should_rewrite? module_data
-          clazz = module_data.mod
-          name = module_data.mod_name
-          return false unless clazz
-
-          # Name can be nil for anonymous modules. We won't work on them.
-          return false unless name
-          return false if name == Contrast::Utils::ObjectShare::CLASS
-          return false if name == Contrast::Utils::ObjectShare::MODULE
-
-          # We've ran into issues rewriting these Modules. Ideally, we'll solve
-          # the issues and this check will go away
-          UNTOUCHABLE_MODULES.none? { |untouchable| name.include?(untouchable) }
-        end
-      end
-    end
-  end
-end

data/lib/contrast/framework/rails/rewrite/action_controller_railties_helper_inherited.rb

@@ -1,37 +0,0 @@
-# Copyright (c) 2021 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
-# frozen_string_literal: true
-
-return unless RUBY_VERSION < '2.6.0' # TODO: RUBY-714 remove guard w/ EOL of 2.5
-
-module Contrast
-  module Framework
-    module Rails
-      module Rewrite
-        # Used to monkey patch all the inherited calls in action_pack
-        #
-        # This is the usual entry point for Rails inheritance work, so it should
-        # catch most of the calls to inherited.
-        # TODO: RUBY-714 remove w/ EOL of 2.5
-        # @deprecated Changes to this class are discouraged as this approach is
-        #   being phased out with support for those language versions.
-        module ActionControllerRailtiesHelperInherited
-          def self.instrument
-            @_instrument ||= begin
-              ::ActionController::Railties::Helpers.class_eval do
-                alias_method :cs__patched_helper_inherited, :inherited
-                def inherited klass # rubocop:disable Lint/MissingSuper
-                  klass&.instance_variable_set(:@cs__defining_class, true)
-                  # This calls the original inherited, which should handle super as needed.
-                  cs__patched_helper_inherited(klass)
-                ensure
-                  klass&.instance_variable_set(:@cs__defining_class, false)
-                end
-              end
-              true
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/contrast/framework/rails/rewrite/active_record_attribute_methods_read.rb

@@ -1,41 +0,0 @@
-# Copyright (c) 2021 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
-# frozen_string_literal: true
-
-return unless RUBY_VERSION < '2.6.0' # TODO: RUBY-714 remove guard w/ EOL of 2.5
-
-module Contrast
-  module Framework
-    module Rails
-      module Rewrite
-        # Rails / ActiveRecord are sneaky. They define attributes of a class in
-        # one method, then monkey patch allocate in another and finally invoke
-        # module_eval in this method... but of course they use a '_tmp_' header
-        # for the method name and then alias it in this module to name it what
-        # we expect
-        #
-        # TODO: RUBY-714 remove w/ EOL of 2.5
-        # @deprecated Changes to this class are discouraged as this approach is
-        #   being phased out with support for those language versions.
-        module ActiveRecordAttributeMethodsRead
-          def self.instrument
-            @_instrument ||= begin
-              ::ActiveRecord::AttributeMethods::Read::ClassMethods.class_eval do
-                alias_method :cs__patched_define_method_attribute, :define_method_attribute
-
-                def define_method_attribute *args, &block
-                  ret = cs__patched_define_method_attribute(*args, &block)
-                  method_name = args[0]
-                  Contrast::Agent::Assess::Policy::Patcher.patch_assess_method(self, method_name)
-                  ret
-                end
-
-                protected :cs__patched_define_method_attribute, :define_method_attribute
-              end
-              true
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/contrast/framework/rails/rewrite/active_record_named.rb

@@ -1,75 +0,0 @@
-# Copyright (c) 2021 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
-# frozen_string_literal: true
-
-return unless RUBY_VERSION < '2.6.0' # TODO: RUBY-714 remove guard w/ EOL of 2.5
-
-require 'contrast/components/logger'
-
-module Contrast
-  module Framework
-    module Rails
-      module Rewrite
-        # Our patch into the ActiveRecord::Scoping::Named::ClassMethods Module,
-        # allowing for the runtime rewrite of interpolation calls defined in
-        # methods defined dynamically during application execution.
-        #
-        # TODO: RUBY-714 remove w/ EOL of 2.5
-        # @deprecated Changes to this class are discouraged as this approach is
-        #   being phased out with support for those language versions.
-        class ActiveRecordNamed
-          include Contrast::Components::Logger::InstanceMethods
-          extend Contrast::Components::Logger::InstanceMethods
-
-          class << self
-            def rewrite mod, method_name, body
-              return body unless ::Contrast::AGENT.rewrite_interpolation?
-              return body unless body.is_a?(Proc)
-
-              location = body.source_location
-              return body unless location_available?(location)
-
-              opener = Contrast::Agent::ClassReopener.new(Contrast::Agent::ModuleData.new(mod))
-              original_source_code = opener.source_code(location, method_name)
-              return body unless original_source_code
-              return body if Contrast::Agent::Rewriter.send(:unrepeatable?, original_source_code)
-              return body unless Contrast::Agent::Rewriter.send(:interpolations?, original_source_code)
-
-              # the code looks like 'source :some_method_name, ->lambda_literal'
-              # we just need the lambda
-              body_start = original_source_code.index(',') + 1
-              original_source_code = original_source_code[body_start..-1]
-
-              new_method_source = Contrast::Agent::Rewriter.send(:rewrite_method, original_source_code)
-              return body unless Contrast::Agent::Rewriter.send(:valid_code?, new_method_source)
-
-              unbound_eval(cs__name, new_method_source)
-            rescue SyntaxError, StandardError => e
-              logger.debug('Can\'t parse method source in scoped method', e, method: method_name)
-              body
-            end
-
-            # Good news, once we patch the body once, the source location
-            # becomes eval. We may need to fix this later though (so it may
-            # be bad news)
-            def location_available? location
-              return false if location.nil?
-              return false if location.empty? || location[0].empty? || location[0].include?('eval')
-
-              true
-            end
-
-            def instrument
-              @_instrument_named_track ||= begin
-                require 'cs__assess_active_record_named/cs__assess_active_record_named'
-                true
-              end
-            rescue StandardError, LoadError => e
-              logger.error('Error loading active record named track patch', e)
-              false
-            end
-          end
-        end
-      end
-    end
-  end
-end