contrast-agent 3.9.1 → 6.15.3

data/lib/contrast/agent/assess/policy/propagator/split.rb

@@ -1,9 +1,14 @@
-# Copyright (c) 2020 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# Copyright (c) 2023 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
-cs__scoped_require 'contrast/agent/assess/policy/preshift'
-cs__scoped_require 'contrast/components/interface'
-cs__scoped_require 'contrast/utils/thread_tracker'
+require 'contrast/agent/assess/policy/preshift'
+require 'contrast/components/agent'
+require 'contrast/components/logger'
+require 'contrast/components/scope'
+require 'contrast/utils/thread_tracker'
+require 'contrast/utils/assess/event_limit_utils'
+require 'contrast/utils/assess/split_utils'
+require 'contrast/agent/assess/events/event_data'
 
 module Contrast
   module Agent
@@ -12,169 +17,158 @@ module Contrast
         module Propagator
           # This class is specifically for String#split & String#grapheme_clusters propagation
           # it propagates tag ranges from a string to elements within an untracked array
-          class Split < Contrast::Agent::Assess::Policy::Propagator::Base
-            include Contrast::Components::Interface
-
-            access_component :agent, :logging
-
+          class Split < Contrast::Agent::Assess::Policy::Propagator::Base # rubocop:disable  Metrics/ClassLength
+            extend Contrast::Components::Scope::InstanceMethods
+            extend Contrast::Components::Logger::InstanceMethods
+            extend Contrast::Utils::Assess::SplitUtils
+            extend Contrast::Utils::Assess::EventLimitUtils
             SPLIT_TRACKER = Contrast::Utils::ThreadTracker.new
+
             class << self
+              # Propagate taint from a source as it is split into composite sections.
+              #
+              # @param propagation_node [Contrast::Agent::Assess::Policy::PropagationNode]
+              #   the node that governs this propagation event.
+              # @param preshift [Contrast::Agent::Assess::PreShift] The capture
+              #   of the state of the code just prior to the invocation of the
+              #   patched method.
+              # @param target [Array, String] the target to which to propagate.
+              # @return [nil] so as not to risk changing the result of the propagation.
               def propagate propagation_node, preshift, target
-                return Contrast::Agent::Assess::Policy::Propagator::Keep.propagate(propagation_node, preshift, target) unless target.is_a?(Array)
+                return unless target.is_a?(Array) # apply_post_patch is called, but split with block returns a string.
 
-                source = find_source(propagation_node.sources[0], preshift)
+                logger.trace('Propagation detected', node_id: propagation_node.id, target_id: target.__id__)
 
-                separator_length = if propagation_node.method_name == :grapheme_clusters
-                                     # grapheme_clusters break the string apart based on each "user-perceived" character
-                                     0
-                                   else
-                                     # The default for String#split is to use a single whitespace
-                                     preshift&.args&.first&.to_s&.length || $FIELD_SEPARATOR&.to_s&.length || 1
-                                   end
+                source = find_source(propagation_node.sources[0], preshift)
+                return unless (source_properties = Contrast::Agent::Assess::Tracker.properties(source))
 
-                current_index = 0
-                target.each do |elem|
-                  elem_length = elem.length
-                  range = Contrast::Agent::Assess::AdjustedSpan.new(current_index, current_index + elem_length)
-                  tags = source.cs__properties.tags_at_range(range)
-
-                  elem.cs__properties.clear_tags
-                  tags.each_pair do |key, value|
-                    elem.cs__properties.set_tags(key, value)
-                  end
-                  source.cs__properties.events.each do |event|
-                    elem.cs__properties.add_event(event)
-                  end
-                  elem.cs__properties.build_event(propagation_node, elem, preshift.object, target, preshift.args, 0)
-                  elem.cs__properties.add_properties(propagation_node.properties)
-                  current_index = current_index + elem_length + separator_length
-                end
+                update_element_properties(propagation_node, target, preshift, source_properties)
+                increment_event_count(propagation_node)
+                nil
               end
 
-              # Marks the point in which the String#split method is called.
-              # Responsible for building the context required to propagate when
-              # the results of #split are yielded directly to a block
+              # Context for block split execution.
               #
-              # @param string [String] the String on which split is invoked
-              # @param args [Array<Object>] the arguments passed to the
-              #   original split call
-              def begin_split string, args
-                save_split_depth!
-                depth = SPLIT_TRACKER.get(:split_depth)
-                save_split_index!(depth)
-                save_split_value!(depth, string, args)
-              rescue Exception => e # rubocop:disable Lint/RescueException
-                # don't let our errors propagate and disable String#split for
-                # this since we're in an error state
-                logger.warn(e, 'Unable to record split context')
-                end_split
-              end
-
-              # Marks the point in which the String#split method is exited.
-              # Responsible for removing the context required to propagate when
-              # the results of #split are yielded directly to a block
-              def end_split
-                depth = SPLIT_TRACKER.get(:split_depth)
-                return unless depth
-
-                depth -= 1
-                if depth.negative?
-                  SPLIT_TRACKER.delete(:split_depth)
-                  SPLIT_TRACKER.delete(:split_index)
-                  SPLIT_TRACKER.delete(:split_value)
-                else
-                  SPLIT_TRACKER.set(:split_depth, depth)
+              # @param string [String] the String on which split is invoked.
+              # @param args [Array<Object>] the arguments passed to the original split call.
+              def wrap_split string, args
+                # String#split start. Build context and yield.
+                begin
+                  enter_split_scope!
+                  save_split_index!
+                  save_split_value!(string, args)
+                rescue Exception => e # rubocop:disable Lint/RescueException
+                  logger.warn('Unable to record split context', e)
+                end
+                yield
+              ensure
+                # String#split exit. Remove propagation context.
+                begin
+                  exit_split_scope!
+                  unless in_split_scope?
+                    SPLIT_TRACKER.delete(:split_index)
+                    SPLIT_TRACKER.delete(:split_value)
+                  end
+                rescue StandardError => e
+                  logger.warn('Unable to remove split context', e)
                 end
-              rescue StandardError => e
-                logger.warn(e, 'Unable to remove split context')
               end
 
-              # This method is called whenever an rb_yield is called. We need
-              # to leave it as soon as possible with as little work as
-              # possible.
+              # This method is called whenever an rb_yield is called.
+              # We need to leave it as soon as possible with as little work as possible.
               #
-              # @param target [String] the entity being passed to the yield
-              #   block
+              # @param target [String] the entity being passed to the yield block
               def propagate_yield target
-                depth = SPLIT_TRACKER.get(:split_depth)
-                return unless depth
-
-                source = SPLIT_TRACKER.get(:split_value)&.fetch(depth)
-                return unless source
-
-                index = SPLIT_TRACKER.get(:split_index)&.fetch(depth)
-                return unless index
+                return unless (source = SPLIT_TRACKER.get(:split_value)&.fetch(split_scope_depth))
+                return unless (index = SPLIT_TRACKER.get(:split_index)&.fetch(split_scope_depth))
+                return unless (properties = Contrast::Agent::Assess::Tracker.properties!(target))
 
                 true_source = source[index]
-                target.cs__copy_from(true_source)
+                properties.copy_from(true_source, target)
               rescue StandardError => e
-                logger.warn(e, 'Unable to track within split context')
+                logger.warn('Unable to track within split context', e)
               ensure
-                if defined?(depth) && defined?(index) && depth && index
+                if in_split_scope? && index
                   idx = SPLIT_TRACKER.get(:split_index)
-                  idx[depth] = index + 1 if defined?(idx) && idx.is_a?(Array)
+                  idx[split_scope_depth] = index + 1 if defined?(idx) && idx.is_a?(Array)
                 end
               end
 
+              # Load patch.
               def instrument_string_split
-                if @_instrument_string_split.nil?
-                  @_instrument_string_split = begin
-                                                cs__scoped_require 'cs__assess_yield_track/cs__assess_yield_track' if AGENT.patch_yield?
-                                                true
-                                              rescue StandardError => e
-                                                logger.error(e, 'Error loading split rb_yield patch')
-                                                false
-                                              end
+                @_instrument_string_split ||= begin
+                  if ::Contrast::AGENT.patch_yield? && Funchook.available?
+                    require('cs__assess_yield_track/cs__assess_yield_track')
+                  end
+                  true
+                rescue StandardError => e
+                  logger.error('Error loading split rb_yield patch', e)
+                  false
                 end
-                @_instrument_string_split
               end
 
               private
 
-              def save_split_depth!
-                depth = SPLIT_TRACKER.get(:split_depth)
-                if depth
-                  depth += 1
-                  SPLIT_TRACKER.set(:split_depth, depth)
-                else
-                  SPLIT_TRACKER.set(:split_depth, 0)
-                end
+              # grapheme_clusters break the string apart based on each "user-perceived" character. Otherwise, the
+              # default for String#split is to use a single whitespace.
+              #
+              # @param propagation_node [Contrast::Agent::Assess::Policy::PropagationNode] the node that governs this
+              #   propagation event.
+              # @param preshift [Contrast::Agent::Assess::PreShift] The capture of the state of the code just prior to
+              #   the invocation of the patched method.
+              def find_separator_length propagation_node, preshift
+                return 0 if propagation_node.method_name == :grapheme_clusters
+
+                preshift&.args&.first&.to_s&.length || $FIELD_SEPARATOR&.to_s&.length || 1
               end
 
-              def save_split_index! depth
-                split_index = SPLIT_TRACKER.get(:split_index)
-                unless split_index
+              # Save index of the current split object.
+              # Create index tracking array as needed.
+              def save_split_index!
+                unless (split_index = SPLIT_TRACKER.get(:split_index))
                   split_index = []
                   SPLIT_TRACKER.set(:split_index, split_index)
                 end
-                # save the index to the ThreadLocal; not useless
-                split_index[depth] = 0 # rubocop:disable Lint/UselessSetterCall
+                # save the index to the ThreadLocal; not useless.
+                split_index[split_scope_depth] = 0 # rubocop:disable Lint/UselessSetterCall
               end
 
-              def save_split_value! depth, string, args
+              # Save value of the current split object.
+              # Create value tracking array as needed.
+              def save_split_value! string, args
                 preshift = Contrast::Agent::Assess::PreShift.build_preshift(split_node, string, args)
                 target = string.split
                 propagate(split_node, preshift, target)
-                split_value = SPLIT_TRACKER.get(:split_value)
-                unless split_value
+                unless (split_value = SPLIT_TRACKER.get(:split_value))
                   split_value = []
                   SPLIT_TRACKER.set(:split_value, split_value)
                 end
-                # save the target to the ThreadLocal; not useless
-                split_value[depth] = target # rubocop:disable Lint/UselessSetterCall
+                # Save the target to the ThreadLocal; not useless.
+                split_value[split_scope_depth] = target # rubocop:disable Lint/UselessSetterCall
               end
 
-              # Quick hook to the String#split propagation node in our Assess
-              # policy
-              #
-              # @return [Contrast::Agent::Assess::Policy::PropagationNode]
-              #   String#split node
-              def split_node
-                @_split_node ||= begin
-                                   Contrast::Agent::Assess::Policy::Policy.instance.propagators.find do |node|
-                                     node.class_name == 'String' && node.method_name == :split && node.instance_method?
-                                   end
-                                 end
+              def update_element_properties propagation_node, target, preshift, source_properties
+                separator_length = find_separator_length(propagation_node, preshift)
+                current_index = 0
+                target.each do |target_elem|
+                  next unless (elem_properties = Contrast::Agent::Assess::Tracker.properties!(target_elem))
+
+                  # Get tags for element from source by element range.
+                  range = current_index...(current_index + target_elem.length)
+                  tags = source_properties.tags_at_range(range)
+                  # Set element properties accordingly.
+                  elem_properties.clear_tags
+                  tags.each_pair { |key, value| elem_properties.set_tags(key, value) }
+                  event_data = Contrast::Agent::Assess::Events::EventData.new(propagation_node,
+                                                                              target_elem,
+                                                                              preshift.object,
+                                                                              target,
+                                                                              preshift.args)
+                  elem_properties.build_event(event_data, 0)
+                  elem_properties.add_properties(propagation_node.properties)
+
+                  current_index = range.end + separator_length
+                end
               end
             end
           end
@@ -184,31 +178,23 @@ module Contrast
   end
 end
 
-if RUBY_VERSION >= '2.6.0'
-  # Special class to handle String#split in 2.6 which, when given a block,
-  # propagates each split piece directly
-  class String
-    alias_method :cs__patched_string_split_special, :split
-
-    # override of the the standard split method to handle the 2.6 direct
-    # yield case.
-    #
-    # Note: because this patch is applied before our standard propagation, this
-    # call wrapped in it. As such, any call here happens in scope, so there is
-    # no need to manage it on our own.
-    def split *args, &block
-      if block
-        Contrast::Agent::Assess::Policy::Propagator::Split.begin_split(self, args)
-        begin
-          cs__patched_string_split_special(*args, &block)
-        ensure
-          Contrast::Agent::Assess::Policy::Propagator::Split.end_split
-        end
-      else
+# Special class to handle String#split in which, when given a block, propagates each split piece directly.
+class String
+  alias_method :cs__patched_string_split_special, :split
+
+  # Override of the the standard split method to handle the direct yield case.
+  #
+  # Note: because this patch is applied before our standard propagation, this call is wrapped in it. As such, any call
+  # here happens in scope, so there is no need to manage it on our own.
+  def split *args, &block
+    if block
+      Contrast::Agent::Assess::Policy::Propagator::Split.wrap_split(self, args) do
         cs__patched_string_split_special(*args, &block)
       end
+    else
+      cs__patched_string_split_special(*args, &block)
     end
   end
-
-  Contrast::Agent::Assess::Policy::Propagator::Split.instrument_string_split
 end
+
+Contrast::Agent::Assess::Policy::Propagator::Split.instrument_string_split

data/lib/contrast/agent/assess/policy/propagator/substitution.rb

@@ -1,6 +1,8 @@
-# Copyright (c) 2020 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# Copyright (c) 2023 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
+require 'contrast/agent/assess/policy/propagator/substitution_utils'
+
 module Contrast
   module Agent
     module Assess
@@ -12,11 +14,9 @@ module Contrast
           # in a 'get it work' state. hopefully, we'll be in
           # a 'get it right' state soon.
           class Substitution
-            include Contrast::Components::Interface
-            access_component :logging
-
-            CAPTURE_GROUP_REGEXP = /\\[[:digit:]]/.cs__freeze
-            CAPTURE_NAME_REGEXP = /\\k<[[:alpha:]]/.cs__freeze
+            include Contrast::Components::Logger::InstanceMethods
+            extend Contrast::Components::Logger::InstanceMethods
+            extend Contrast::Agent::Assess::Policy::Propagator::SubstitutionUtils
 
             class << self
               # gsub is hard. there are four versions of this method
@@ -33,132 +33,7 @@ module Contrast
               end
 
               def sub_tagger patcher, preshift, ret, block
-                substitution_tagger(patcher, preshift, ret, !block.nil?, false)
-              end
-
-              private
-
-              def substitution_tagger patcher, preshift, ret, block, global = true
-                return ret unless ret
-
-                begin
-                  source = preshift.object
-                  self_tracked = Contrast::Utils::DuckUtils.quacks_to?(source, :cs__tracked?) &&
-                      source.cs__tracked?
-                  args = preshift.args[1]
-                  incoming_tracked = args && determine_tracked(args)
-                  return ret unless self_tracked || incoming_tracked
-
-                  if block
-                    block_sub(self_tracked, source, ret)
-                  elsif args.is_a?(String)
-                    string_sub(self_tracked, preshift, ret, args, incoming_tracked, global)
-                  elsif args.is_a?(Hash)
-                    hash_sub(self_tracked, source, ret)
-                  else # Enumerator, only for gsub
-                    pattern_gsub(preshift, ret)
-                  end
-                  string_build_event(patcher, preshift, ret)
-                rescue StandardError => e
-                  logger.error('Unable to apply gsub propagator', e)
-                end
-                ret
-              end
-
-              def determine_tracked args
-                # if there's no arg, it can't be tracked
-                return false unless args
-
-                # if it's a string, just ask if it's tracked
-                if args.is_a?(String)
-                  Contrast::Utils::DuckUtils.quacks_to?(args, :cs__tracked?) && args.cs__tracked?
-                  # if it's a hash, ask if it has a tracked string
-                elsif args.is_a?(Hash)
-                  args.values.any? { |value| value.is_a?(String) && Contrast::Utils::DuckUtils.quacks_to?(value, :cs__tracked?) && value.cs__tracked? }
-                  # this should never happen
-                else
-                  false
-                end
-              end
-
-              def string_sub self_tracked, preshift, ret, incoming, incoming_tracked, global
-                pattern = preshift.args[0]
-                source = preshift.object
-
-                # We can't efficiently find the places that things were
-                # copied from regexp / captures. Trading accuracy for
-                # performance
-                if incoming.match?(CAPTURE_GROUP_REGEXP) || incoming.match?(CAPTURE_NAME_REGEXP)
-                  source.cs__splat_tags(ret) if self_tracked
-                  return
-                end
-
-                # if it's just a straight insert, that we can do
-                # Copy the tags from us to the return
-                ret.cs__copy_from(source)
-                # Figure out where inserts occurred
-                last_idx = 0
-                ranges = []
-                # For each insert, move the tag ranges
-                while last_idx
-                  idx = source.index(pattern, last_idx)
-                  break unless idx
-
-                  last_idx = idx ? idx + 1 : nil
-                  start_index = idx
-                  end_index = idx + incoming.length
-                  ranges << Contrast::Agent::Assess::AdjustedSpan.new(start_index, end_index)
-                  break unless global
-                end
-                ret.cs__properties.delete_tags_at_ranges(ranges)
-                ret.cs__properties.shift_tags(ranges)
-                return unless incoming_tracked
-
-                tags = incoming.cs__properties.tag_keys
-                ranges.each do |range|
-                  tags.each do |tag|
-                    ret.cs__properties.add_tag(tag, range)
-                  end
-                end
-              end
-
-              def block_sub self_tracked, source, ret
-                source.cs__splat_tags(ret) if self_tracked
-              end
-
-              def hash_sub self_tracked, source, ret
-                source.cs__splat_tags(ret) if self_tracked
-              end
-
-              def pattern_gsub preshift, ret
-                return unless ret
-
-                source = preshift.object
-                source.cs__properties.tag_keys.each do |key|
-                  span = Contrast::Agent::Assess::AdjustedSpan.new(0, 1)
-                  ret.cs__properties.add_tag(key, span)
-                end
-              end
-
-              def string_build_event patcher, preshift, ret
-                return unless Contrast::Utils::DuckUtils.quacks_to?(ret, :cs__tracked?) && ret.cs__tracked?
-
-                args = preshift.args
-                if args.length > 1
-                  arg = args[1]
-                  if Contrast::Utils::DuckUtils.quacks_to?(arg, :cs__properties)
-                    arg.cs__properties.events.each do |event|
-                      ret.cs__properties.events << event
-                    end
-                  end
-                end
-                ret.cs__properties.build_event(
-                    patcher,
-                    ret,
-                    preshift.object,
-                    ret,
-                    args,
-                    2)
+                substitution_tagger(patcher, preshift, ret, !block.nil?, global: false)
               end
             end
           end