contrast-agent 3.14.0 → 4.2.0

data/lib/contrast/extension/assess.rb

@@ -30,8 +30,6 @@ module Contrast
       require 'contrast/agent/assess/policy/policy'
       require 'contrast/agent/assess/policy/patcher'
 
-      # classes that don't play nice w/ our standard propagation
-      require 'contrast/extension/assess/assess_extension'
       # this needs to come first b/c array and others work on strings and
       # expect them to be trackable
       require 'contrast/extension/assess/string'

data/lib/contrast/extension/assess/array.rb

@@ -35,37 +35,44 @@ module Contrast
           # operation happens in C, we have to do it here rather than rely on the
           # patch of our String append or concat methods.
           def cs__track_join ary, separator, ret
-            return unless ary
+            return ret unless ary&.any? { |element| Contrast::Agent::Assess::Tracker.tracked?(element) }
             return ret if Contrast::Agent::Patching::Policy::Patch.skip_assess_analysis?
 
             with_contrast_scope do
+              properties = Contrast::Agent::Assess::Tracker.properties(ret)
+              return ret unless properties
+
               shift = 0
               separator_length = separator.nil? ? 0 : separator.to_s.length
+              parent_events = []
               ary.each do |obj|
                 if obj # skip nil here
-                  ret.cs__copy_from(obj, shift)
+                  properties.copy_from(obj, ret, shift)
                   shift += obj.to_s.length
+                  parent_event = Contrast::Agent::Assess::Tracker.properties(obj)&.event
+                  parent_events << parent_event if parent_event
                 end
                 shift += separator_length
               end
-              return ret unless ret.cs__tracked?
+              return ret unless Contrast::Agent::Assess::Tracker.tracked?(ret)
 
-              ret.cs__properties.cleanup_tags
-              ret.cs__properties.build_event(
+              properties.cleanup_tags
+              properties.build_event(
                   ARRAY_JOIN_NODE,
                   ret,
                   ary,
                   ret,
                   [separator])
+              properties.event.instance_variable_set(:@_parent_events, parent_events)
               ret
             end
           end
 
           def instrument_array_track
             @_instrument_array_track ||= begin
-                                           require 'cs__assess_array/cs__assess_array'
-                                           true
-                                         end
+              require 'cs__assess_array/cs__assess_array'
+              true
+            end
           rescue StandardError, LoadError => e
             logger.error('Error loading assess track patch', e)
             false

data/lib/contrast/extension/assess/erb.rb

@@ -7,27 +7,35 @@ module ERBPropagator
     def result_tagger patcher, preshift, ret, _block
       return unless preshift.args.length >= 1
 
+      properties = Contrast::Agent::Assess::Tracker.properties(ret)
+      return unless properties
+
       used_binding = preshift.args[0]
       binding_variable_set = used_binding.local_variables
 
       erb_pre_result = preshift.object.src
+      parent_events = []
       binding_variable_set.each do |bound_var_symbol|
         bound_variable_value = used_binding.local_variable_get(bound_var_symbol)
-        next unless bound_variable_value.cs__respond_to?(:cs__tracked?) && bound_variable_value.cs__tracked?
+        next unless Contrast::Agent::Assess::Tracker.tracked?(bound_variable_value)
         next unless erb_pre_result.include?(bound_var_symbol.to_s)
 
         start_index = ret.index(bound_variable_value)
         next if start_index.nil?
 
-        ret.cs__copy_from(bound_variable_value, start_index)
+        properties.copy_from(bound_variable_value, ret, start_index)
+        parent_event = Contrast::Agent::Assess::Tracker.properties(bound_variable_value)&.event
+        parent_events << parent_event if parent_event
       end
-      ret.cs__properties.build_event(
+      properties.build_event(
           patcher,
           ret,
           preshift.object,
           ret,
           preshift.args,
           1)
+      properties.event.instance_variable_set(:@_parent_events, parent_events)
+
       ret
     end
   end

data/lib/contrast/extension/assess/eval_trigger.rb

@@ -45,9 +45,9 @@ module Contrast
 
           def instrument_basic_object_track
             @_instrument_basic_object_track ||= begin
-                                               require 'cs__assess_basic_object/cs__assess_basic_object'
-                                               true
-                                             end
+              require 'cs__assess_basic_object/cs__assess_basic_object'
+              true
+            end
           rescue StandardError, LoadError => e
             logger.error('Error loading basic object track patch', e)
             false
@@ -55,9 +55,9 @@ module Contrast
 
           def instrument_module_track
             @_instrument_module_track ||= begin
-                                               require 'cs__assess_module/cs__assess_module'
-                                               true
-                                             end
+              require 'cs__assess_module/cs__assess_module'
+              true
+            end
           rescue StandardError, LoadError => e
             logger.error('Error loading module track patch', e)
             false

data/lib/contrast/extension/assess/exec_trigger.rb

@@ -27,10 +27,7 @@ module Contrast
               source,
               Kernel,
               nil,
-              source)
-          # Exec replaces the current process, if we occur in a forked process
-          # our appendage of this finding will not make it to TS
-          Contrast::Agent::AtExitHook.on_exit
+              [source])
         end
 
         private

data/lib/contrast/extension/assess/fiber.rb

@@ -54,7 +54,6 @@ module Contrast
         class << self
           def track_rb_fiber_yield fiber, _method, results
             return unless ASSESS.enabled?
-            return unless Contrast::Utils::DuckUtils.trackable?(fiber)
 
             # results will be nil if StopIteration was raised,
             # otherwise an Array of the yielded arguments
@@ -62,11 +61,11 @@ module Contrast
 
             with_contrast_scope do
               results.each do |result|
-                next unless Contrast::Utils::DuckUtils.trackable?(result)
-                next if result.cs__frozen?
+                result_properties = Contrast::Agent::Assess::Tracker.properties(result)
+                next unless result_properties
 
-                fiber.cs__splat_tags(result)
-                result.cs__properties.build_event(
+                result_properties.splat_from(fiber, result)
+                result_properties.build_event(
                     FIBER_YIELD_NODE,
                     result,
                     fiber,
@@ -80,13 +79,14 @@ module Contrast
 
           def track_rb_fiber_new fiber, _enum, _enum_method, underlying, _underlying_method
             return unless ASSESS.enabled?
-            return unless Contrast::Utils::DuckUtils.trackable?(fiber)
-            return unless Contrast::Utils::DuckUtils.trackable?(underlying)
             return unless underlying.is_a?(String) && !underlying.empty?
 
             with_contrast_scope do
-              underlying.cs__splat_tags(fiber)
-              fiber.cs__properties.build_event(
+              properties = Contrast::Agent::Assess::Tracker.properties(fiber)
+              return unless properties
+
+              properties.splat_from(underlying, fiber)
+              properties.build_event(
                   FIBER_NEW_NODE,
                   fiber,
                   underlying,
@@ -99,9 +99,9 @@ module Contrast
 
           def instrument_fiber_track
             @_instrument_fiber_variables ||= begin
-                require 'cs__assess_fiber_track/cs__assess_fiber_track' if Funchook.available?
-                true
-              end
+              require 'cs__assess_fiber_track/cs__assess_fiber_track' if Funchook.available?
+              true
+            end
           rescue StandardError, LoadError => e
             logger.error('Error loading fiber track patch', e)
             false

data/lib/contrast/extension/assess/hash.rb

@@ -15,10 +15,9 @@ module Contrast
         class << self
           def cs__duplicate_and_freeze object
             return object unless object.is_a?(String) && !object.cs__frozen?
-            return object unless object.cs__tracked?
+            return object unless Contrast::Agent::Assess::Tracker.tracked?(object)
 
-            ret = object.dup
-            object.cs__transfer_properties(ret)
+            ret = Contrast::Agent::Assess::Tracker.duplicate(object)
             ret.cs__freeze
           rescue StandardError
             # we'll rescue this error, but we can't log it here as that will
@@ -27,9 +26,9 @@ module Contrast
 
           def instrument_hash_track
             @_instrument_hash_track ||= begin
-                                            require 'cs__assess_hash/cs__assess_hash'
-                                            true
-                                          end
+              require 'cs__assess_hash/cs__assess_hash'
+              true
+            end
           rescue StandardError, LoadError => e
             logger.error('Error loading hash track patch', e)
             false

data/lib/contrast/extension/assess/kernel.rb

@@ -39,44 +39,47 @@ module Contrast
           # oh, and there's also %<name>type and %{name}... b/c of course there is
           # -HM
           def sprintf_tagger patcher, preshift, ret, _block
+            properties = Contrast::Agent::Assess::Tracker.properties(ret)
+            return unless properties
+
             format_string = preshift.args[0]
             args = preshift.args[1]
 
-            track_sprintf(ret, format_string, args)
+            parent_events = []
+            track_sprintf(ret, format_string, args, parent_events)
 
-            ret.cs__properties.build_event(
+            properties.build_event(
                 patcher,
                 ret,
                 preshift.object,
                 ret,
                 preshift.args,
                 1)
+
+            properties.event.instance_variable_set(:@_parent_events, parent_events)
             ret
           end
 
-          def track_sprintf result, format_string, args
-            handle_sprintf_value(format_string, result)
+          def track_sprintf result, format_string, args, parent_events
+            handle_sprintf_value(format_string, result, parent_events)
             case args
             when String
-              handle_sprintf_value(args, result)
+              handle_sprintf_value(args, result, parent_events)
             when Hash
-              handle_sprintf_hash(args, result)
+              handle_sprintf_hash(args, result, parent_events)
             when Array
-              handle_sprintf_array args, result
+              handle_sprintf_array(args, result, parent_events)
             end
-
-            result
           rescue StandardError => e
             logger.error(
                 'Unable to track dataflow through sprintf', e)
-            result
           end
 
           def instrument_kernel_track
             @_instrument_fiber_variables ||= begin
-                                               require 'cs__assess_kernel/cs__assess_kernel'
-                                               true
-                                             end
+              require 'cs__assess_kernel/cs__assess_kernel'
+              true
+            end
           rescue StandardError, LoadError => e
             logger.error('Error loading kernel track patch', e)
             false
@@ -84,24 +87,26 @@ module Contrast
 
           private
 
-          def handle_sprintf_value value, result
-            return unless Contrast::Utils::DuckUtils.trackable?(value) && value.cs__tracked?
+          def handle_sprintf_value value, result, parent_events
+            properties = Contrast::Agent::Assess::Tracker.properties(result)
+            return unless properties
 
-            value.cs__properties.events.each do |event|
-              result.cs__properties.events << event
-            end
-            value.cs__splat_tags(result)
+            value_properties = Contrast::Agent::Assess::Tracker.properties(value)
+            return unless value_properties
+
+            parent_events << value_properties.event if value_properties.event
+            properties.splat_from(value, result)
           end
 
-          def handle_sprintf_array args, result
+          def handle_sprintf_array args, result, parent_events
             args.each do |value|
-              handle_sprintf_value(value, result)
+              handle_sprintf_value(value, result, parent_events)
             end
           end
 
-          def handle_sprintf_hash args, result
+          def handle_sprintf_hash args, result, parent_events
             args.each_value do |value|
-              handle_sprintf_value(value, result)
+              handle_sprintf_value(value, result, parent_events)
             end
           end
         end

data/lib/contrast/extension/assess/marshal.rb

@@ -22,8 +22,9 @@ module Contrast
 
             # Since we know this is the source of the trigger, we can do some
             # optimization here and return when it is not tracked
-            return unless Contrast::Utils::Assess::TrackingUtil.tracked?(source)
+            return unless Contrast::Agent::Assess::Tracker.tracked?(source)
 
+            args = [source]
             # source might not be all the args passed in, but it is the one we care
             # about. we could pass in all the args in the last param here if it
             # becomes an issue in rendering on TS
@@ -33,17 +34,21 @@ module Contrast
                 source,
                 self,
                 ret,
-                source)
-            ret.cs__copy_from(source) if ret.cs__respond_to?(:cs__copy_from)
+                args)
+            properties = Contrast::Agent::Assess::Tracker.properties(ret)
+            properties.copy_from(source, ret)
+
+            node = Contrast::Agent::Assess::Policy::Policy.instance.find_propagator_node('Marshal', :load, false)
+            properties.build_event(node, ret, self, ret, args)
           rescue StandardError => e
             logger.error('Unable to determine if a trigger occurred in Marshal.load', e)
           end
 
           def instrument_marshal_load
             @_instrument_marshal_load ||= begin
-                                            require 'cs__assess_marshal_module/cs__assess_marshal_module'
-                                            true
-                                          end
+              require 'cs__assess_marshal_module/cs__assess_marshal_module'
+              true
+            end
           rescue StandardError, LoadError => e
             logger.error('Error loading marshal load patch', e)
             false

data/lib/contrast/extension/assess/regexp.rb

@@ -47,8 +47,6 @@ module Contrast
             return if scope_for_current_ec.instance_variable_get(:@contrast_scope) > 1
 
             target = info_hash[:back_ref]
-            return unless Contrast::Utils::DuckUtils.trackable?(target)
-
             with_contrast_scope do
               result = info_hash[:result]
               return unless result
@@ -56,8 +54,11 @@ module Contrast
               string = info_hash[:string]
               return unless string
 
-              string.cs__splat_tags(target)
-              target.cs__properties.build_event(
+              properties = Contrast::Agent::Assess::Tracker.properties(target)
+              return unless properties
+
+              properties.splat_from(string, target)
+              properties.build_event(
                   REGEXP_EQUAL_SQUIGGLE_NODE,
                   target,
                   self,
@@ -70,9 +71,9 @@ module Contrast
 
           def instrument_regexp_track
             @_instrument_regexp_track ||= begin
-                                               require 'cs__assess_regexp/cs__assess_regexp'
-                                               true
-                                             end
+              require 'cs__assess_regexp/cs__assess_regexp'
+              true
+            end
           rescue StandardError, LoadError => e
             logger.error('Error loading regexp track patch', e)
             false

data/lib/contrast/extension/assess/string.rb

@@ -3,13 +3,6 @@
 
 require 'contrast/agent/assess/policy/propagation_node'
 require 'contrast/components/interface'
-require 'contrast/extension/assess/assess_extension'
-
-# This patch installs our extension as early as possible. The alternative is to
-# litter our code with Contrast::Utils::DuckUtils.trackable? checks.
-class String
-  include Contrast::Extension::Assess::AssessExtension
-end
 
 module Contrast
   module Extension
@@ -40,23 +33,32 @@ module Contrast
           def track_interpolation inputs, result
             return unless AGENT.interpolation_enabled?
             return if in_contrast_scope?
-            return unless inputs.any?(&:cs__tracked?)
+            return unless inputs.any? { |input| Contrast::Agent::Assess::Tracker.tracked?(input) }
 
             with_contrast_scope do
+              properties = Contrast::Agent::Assess::Tracker.properties(result)
+              return unless properties
+
+              parent_events = []
               offset = 0
               inputs.each do |input|
-                result.cs__copy_from(input, offset)
+                properties.copy_from(input, result, offset)
                 offset += input.length
+                parent_event = Contrast::Agent::Assess::Tracker.properties(input)&.event
+                parent_events << parent_event if parent_event
               end
-              result.cs__properties.build_event(INTERPOLATION_NODE, result, inputs, result, inputs)
+              properties.build_event(INTERPOLATION_NODE, result, inputs, result, inputs)
+              properties.event.instance_variable_set(:@_parent_events, parent_events)
             end
+          rescue StandardError => e
+            logger.error('Unable to track interpolation', e)
           end
 
           def instrument_string
             @_instrument_string ||= begin
-                                      require 'cs__assess_string/cs__assess_string'
-                                      true
-                                    end
+              require 'cs__assess_string/cs__assess_string'
+              true
+            end
           rescue StandardError, LoadError => e
             logger.error('Error loading hash track patch', e)
             false
@@ -65,14 +67,12 @@ module Contrast
           def instrument_string_interpolation
             if @_instrument_string_interpolation.nil?
               @_instrument_string_interpolation = begin
-                                                    if AGENT.patch_interpolation? && Funchook.available?
-                                                      require 'cs__assess_string_interpolation26/cs__assess_string_interpolation26'
-                                                    end
-                                                    true
-                                                  rescue StandardError, LoadError => e
-                                                    logger.error('Error loading interpolation patch', e)
-                                                    false
-                                                  end
+                require 'cs__assess_string_interpolation26/cs__assess_string_interpolation26' if AGENT.patch_interpolation? && Funchook.available?
+                true
+              rescue StandardError, LoadError => e
+                logger.error('Error loading interpolation patch', e)
+                false
+              end
             end
             @_instrument_string_interpolation
           end