contrast-agent 4.13.0 → 5.0.0

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

@@ -1,35 +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
-        # 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 ActiveRecordTimeZoneInherited
-          def self.instrument
-            @_instrument ||= begin
-              ::ActiveRecord::AttributeMethods::TimeZoneConversion::ClassMethods.class_eval do
-                private
-
-                alias_method :cs__patched_inherited, :inherited
-                def inherited klass # rubocop:disable Lint/MissingSuper
-                  klass&.instance_variable_set(:@cs__defining_class, true)
-                  cs__patched_inherited(klass) # This calls the original inherited, which should handle super as needed.
-                ensure
-                  klass&.instance_variable_set(:@cs__defining_class, false)
-                end
-              end
-              true
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/contrast/utils/requests_client.rb

@@ -1,150 +0,0 @@
-# Copyright (c) 2021 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
-# frozen_string_literal: true
-
-require 'net/http'
-require 'contrast/components/logger'
-require 'contrast/utils/object_share'
-require 'contrast/agent/version'
-require 'socket'
-
-module Contrast
-  module Utils
-    # This module creates a Net::HTTP client and initiates a connection to the provided result
-    module RequestsClient
-      ENDPOINT = 'api/v1/telemetry/metrics' # /TelemetryEvent.path
-
-      class << self
-        include Contrast::Components::Logger::InstanceMethods
-        # This method initializes the Net::HTTP client we'll need
-        # @param url [String]
-        # @return [Net::HTTP, nil]
-        def initialize_connection url
-          addr = URI(url)
-          return if addr.host.nil? || addr.port.nil?
-          return if addr.scheme != 'https'
-
-          @_net_http_client = Net::HTTP.new(addr.host, addr.port)
-          @_net_http_client.open_timeout = 5
-          @_net_http_client.read_timeout = 5
-          @_net_http_client.use_ssl = true
-          @_net_http_client.verify_mode = OpenSSL::SSL::VERIFY_PEER
-          @_net_http_client.verify_depth = 5
-          @_net_http_client.start
-          return unless @_net_http_client.started?
-
-          logger.warn('Starting Telemetry connection test')
-          return unless connection_verified? @_net_http_client
-
-          @_net_http_client
-        rescue Net::OpenTimeout, Net::ReadTimeout => e
-          logger.warn('Telemetry connection failed', e.message)
-          nil
-        end
-
-        # This method will be responsible for building the request
-        # @param event[Contrast::Agent::TelemetryEvent,Contrast::Agent::StartupMetricsTelemetryEvent]
-        # @return [Net::HTTP::Post]
-        def build_request event
-          return unless valid_event? event
-
-          string_body = event.to_json.to_s
-          header = { 'User-Agent' => "<#{ Contrast::Utils::ObjectShare::RUBY }>-<#{ Contrast::Agent::VERSION }>" }
-          path = ENDPOINT + event.path
-          @_request = Net::HTTP::Post.new(path, header)
-          @_request.body = string_body
-          @_request
-        end
-
-        # This method will create the actual request and send it
-        # @param event[Contrast::Agent::TelemetryEvent]
-        # @param connection[Net::HTTP]
-        def send_request event, connection
-          return if connection.nil? || event.nil?
-          return unless valid_event? event
-
-          req = build_request event
-          connection.request req
-        end
-
-        # This method will handle the response from the tenant
-        # @param res [Net::HTTPResponse]
-        # @return sleep_time [Integer, nil]
-        def handle_response res
-          status_code = res.code.to_i
-          ready_after = if res.to_hash.keys.map(&:downcase).include?('ready-after')
-                          res['Ready-After']
-                        else
-                          60
-                        end
-          ready_after if status_code == 429
-        end
-
-        # This method will be responsible for validating the event
-        # @param event[Contrast::Agent::TelemetryEvent,Contrast::Agent::StartupMetricsTelemetryEvent]
-        def valid_event? event
-          return false unless event.cs__is_a?(Contrast::Agent::TelemetryEvent)
-          return false unless event.cs__is_a?(Contrast::Agent::StartupMetricsTelemetryEvent)
-
-          true
-        end
-
-        # Validates connection with Telemetry assigned domain.
-        # If connection is running, SSL certificate of the endpoint is valid, Ip address is resolvable
-        # and response is received without peer's reset or refuse of connection,
-        # then validation returns true. Error handling is in place so that the work of the agent will continue as
-        # normal without Telemetry.
-        #
-        # @param client [Net::HTTP]
-        # @return [Boolean] true | false
-        def connection_verified? client
-          return @_connection_verified unless @_connection_verified.nil?
-
-          # Before RUBY 2.7 there is no #ipaddr
-          ipaddr = if RUBY_VERSION < '2.7.0'
-                     socket = TCPSocket.open(client.address, client.port)
-                     ipaddr = socket.peeraddr[3]
-                     socket.close
-                     ipaddr
-                   else
-                     client.ipaddr
-                   end
-          response = client.request(Net::HTTP::Get.new(client.address))
-          verify_cert = OpenSSL::SSL.verify_certificate_identity(client.peer_cert, client.address)
-          resolved = resolved? client.address, ipaddr
-          @_connection_verified = if resolved && response && verify_cert
-                                    true
-                                  else
-                                    false
-                                  end
-        rescue OpenSSL::SSL::SSLError, Resolv::ResolvError, Errno::ECONNRESET, Errno::ECONNREFUSED,
-               Errno::ETIMEDOUT, Errno::ESHUTDOWN, Errno::EHOSTDOWN, Errno::EHOSTUNREACH, Errno::EISCONN,
-               Errno::ECONNABORTED, Errno::ENETRESET, Errno::ENETUNREACH => e
-
-          logger.warn('Telemetry connection failed', e.message)
-          false
-        end
-
-        private
-
-        # Resolves the address of the assigned telemetry domain to array of corresponding IPs (if more than one)
-        # and runs a matcher to see if current connection IP is in the list.
-        # This is called within #verify_connection, if called on it's own there will be no
-        # error handling.
-        #
-        # @param address [String] Human friendly address of assigned telemetry domain
-        # @param ipaddr [String] Machine friendly IP address of the assigned telemetry domain
-        # @return[Boolean] true if both addresses are resolved | false if one of the addresses
-        # is non-resolvable
-        def resolved? address, ipaddr
-          return @_resolved unless @_resolved.nil?
-
-          @_resolved = if (addresses = Resolv.getaddresses address)
-                         addresses.any? { |addr| addr.include?(ipaddr) }
-                       else
-                         false
-                       end
-        end
-      end
-    end
-  end
-end

data/lib/contrast/utils/ruby_ast_rewriter.rb

@@ -1,82 +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 'parser/current'
-module Contrast
-  module Utils
-    # This utility allows us to parse and rewrite the AST in Ruby 2.5,
-    # allowing us to track String interpolation propagation by replacing those
-    # events with String#+ events instead.
-    #
-    # 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 RubyAstRewriter < Parser::TreeRewriter
-      VARIABLES = %i[ivar cvar gvar].cs__freeze
-
-      # Rewrite the given source_string, converting the interpolation action
-      # therein to a concatenation action
-      #
-      # @param source_string [String] the String to rewrite
-      # @return [String] either the rewritten string or the original on error.
-      def rewrite source_string
-        ast = Parser::CurrentRuby.parse(source_string)
-        buffer = Parser::Source::Buffer.new('rewrite')
-        buffer.source = source_string
-        begin
-          super(buffer, ast)
-        rescue StandardError => _e
-          source_string
-        end
-      end
-
-      # This overloads the on_dstr method in Parser::AST::Processor to handle
-      # the replace within the given node.
-      def on_dstr node
-        return if node.children.all? { |child_node| child_node.type == :str }
-        new_content = +'('
-        idx = 0
-        while idx < node.children.length
-          #node.children.each_with_index do |child_node, index|
-          child_node = node.children[idx]
-          # A begin node looks like #{some_code} in ruby, we do a substring
-          # from [2...-1] to get rid of the #{ & trailing }.
-          if child_node.type == :begin
-            code = child_node.
-              location.
-              expression.
-              source_buffer.
-              source[child_node.location.begin.begin_pos...child_node.location.end.end_pos]
-            code = code[2...-1]
-            new_content += "((#{ code }).to_s)"
-
-            # For interpolations that use class, instance, or global variables,
-            # those are NOT within a begin block, but instead are a ivar, cvar,
-            # or gvar node, not stripping of interpolation markers required.
-          elsif VARIABLES.include?(child_node.type)
-            variable = child_node.children.first
-            new_content << "((#{ variable }).to_s)"
-
-            # When interpolation includes strings before or after an
-            # interpolation they are simple :str nodes, in order to preserve
-            # escaping we need to do a dump of the string value.
-          elsif child_node.type == :str
-            literal_value = child_node.children.first
-            literal_value = literal_value.dump[1...-1]
-            new_content <<  "\"#{ literal_value }\""
-          end
-          new_content << ' + ' unless idx == node.children.length - 1
-          idx += 1
-        end
-        new_content << ')'
-        if node.location.cs__respond_to?(:heredoc_body)
-          replace(node.location.heredoc_body, new_content)
-        else
-          replace(node.location.expression, new_content)
-        end
-      end
-    end
-  end
-end