necropsy 0.2.0 → 0.3.0

data/lib/necropsy/analyzers/dynamic/redis_input_limits.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module Necropsy
+  module Analyzers
+    module Dynamic
+      class RedisInputLimits
+        DEFAULTS = {
+          'connect_timeout' => 5.0,
+          'read_timeout' => 5.0,
+          'total_timeout' => 15.0,
+          'max_response_bytes' => 16 * 1024 * 1024,
+          'max_bulk_bytes' => 8 * 1024 * 1024,
+          'max_array_elements' => 100_000,
+          'max_resp_depth' => 16,
+          'max_keys' => 1_000,
+          'max_payload_depth' => 64
+        }.freeze
+        TIMEOUT_KEYS = %w[connect_timeout read_timeout total_timeout].freeze
+        INTEGER_KEYS = (DEFAULTS.keys - TIMEOUT_KEYS).freeze
+
+        attr_reader(*DEFAULTS.keys.map(&:to_sym))
+
+        def initialize(config)
+          TIMEOUT_KEYS.each { |key| instance_variable_set("@#{key}", positive_float(config, key)) }
+          INTEGER_KEYS.each { |key| instance_variable_set("@#{key}", positive_integer(config, key)) }
+        end
+
+        def validate_payload!(payload)
+          stack = [[payload, 0]]
+          until stack.empty?
+            value, depth = stack.pop
+            raise Error, 'Redis coverage payload exceeds maximum nesting depth' if depth > max_payload_depth
+            if (value.is_a?(Hash) || value.is_a?(Array)) && value.length > max_array_elements
+              raise Error, 'Redis coverage payload exceeds maximum collection size'
+            end
+
+            children = value.is_a?(Hash) ? value.flat_map { |key, child| [key, child] } : Array(value)
+            stack.concat(children.map { |child| [child, depth + 1] }) if value.is_a?(Hash) || value.is_a?(Array)
+          end
+          payload
+        end
+
+        private
+
+        def positive_float(config, key)
+          value = Float(config.fetch(key, DEFAULTS.fetch(key)))
+          return value if value.positive? && value.finite?
+
+          invalid_limit!(key)
+        rescue ArgumentError, TypeError
+          invalid_limit!(key)
+        end
+
+        def positive_integer(config, key)
+          value = Integer(config.fetch(key, DEFAULTS.fetch(key)))
+          return value if value.positive?
+
+          invalid_limit!(key)
+        rescue ArgumentError, TypeError
+          invalid_limit!(key)
+        end
+
+        def invalid_limit!(key)
+          raise Error, "analyzers.dynamic.coverband.#{key} must be a finite positive number"
+        end
+      end
+
+      class RedisDeadline
+        def initialize(seconds)
+          @expires_at = monotonic_time + seconds
+        end
+
+        def remaining
+          seconds = @expires_at - monotonic_time
+          raise Error, 'Redis total timeout exceeded' unless seconds.positive?
+
+          seconds
+        end
+
+        def check!
+          remaining
+          nil
+        end
+
+        private
+
+        def monotonic_time
+          Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        end
+      end
+
+      class RedisCredentialRedactor
+        REDACTED = '[REDACTED]'
+
+        def initialize(source)
+          @source = source.to_s
+          @safe_source = @source.sub(%r{(?<=://)[^/@\s]+@}, "#{REDACTED}@")
+          @secrets = credentials(@source)
+        end
+
+        def redact(message)
+          sanitized = message.to_s.gsub(@source, @safe_source)
+          @secrets.reduce(sanitized) { |text, secret| text.gsub(secret, REDACTED) }
+        end
+
+        private
+
+        def credentials(source)
+          uri = URI(source)
+          [uri.user, uri.password].compact.flat_map do |credential|
+            [credential, URI.decode_www_form_component(credential)]
+          end.reject(&:empty?).uniq.sort_by { |value| -value.length }
+        rescue URI::Error, ArgumentError
+          []
+        end
+      end
+    end
+  end
+end

data/lib/necropsy/analyzers/dynamic/redis_nonblocking_io.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'io/wait'
+
+module Necropsy
+  module Analyzers
+    module Dynamic
+      module RedisNonblockingIO
+        private
+
+        def finish_tls_connect(ssl_socket)
+          expires_at = monotonic_time + limits.connect_timeout
+          loop do
+            status = ssl_socket.connect_nonblock(exception: false)
+            return unless wait_status?(status)
+
+            wait_for_io(status, io: ssl_socket.to_io, expires_at: expires_at,
+                                label: 'Redis TLS handshake timeout exceeded')
+          rescue IO::WaitReadable
+            wait_for_io(:wait_readable, io: ssl_socket.to_io, expires_at: expires_at,
+                                        label: 'Redis TLS handshake timeout exceeded')
+          rescue IO::WaitWritable
+            wait_for_io(:wait_writable, io: ssl_socket.to_io, expires_at: expires_at,
+                                        label: 'Redis TLS handshake timeout exceeded')
+          end
+        end
+
+        def write_all(value)
+          offset = 0
+          expires_at = monotonic_time + limits.read_timeout
+          while offset < value.bytesize
+            check_io_deadline!(expires_at, 'Redis write timeout exceeded')
+            begin
+              written = socket.write_nonblock(value.byteslice(offset, value.bytesize - offset), exception: false)
+              if wait_status?(written)
+                wait_for_io(written, io: socket.to_io, expires_at: expires_at, label: 'Redis write timeout exceeded')
+              elsif written&.positive?
+                offset += written
+              else
+                domain_error('Redis closed the connection while writing a request')
+              end
+            rescue IO::WaitReadable
+              wait_for_io(:wait_readable, io: socket.to_io, expires_at: expires_at,
+                                          label: 'Redis write timeout exceeded')
+            rescue IO::WaitWritable
+              wait_for_io(:wait_writable, io: socket.to_io, expires_at: expires_at,
+                                          label: 'Redis write timeout exceeded')
+            end
+          end
+          check_io_deadline!(expires_at, 'Redis write timeout exceeded')
+        end
+
+        def read_nonblock(length)
+          expires_at = monotonic_time + limits.read_timeout
+          loop do
+            value = socket.read_nonblock(length, exception: false)
+            return value if value.is_a?(String) && !value.empty?
+
+            domain_error('Redis closed the connection while reading a response') if value.nil? || value == ''
+            wait_for_io(value, io: socket.to_io, expires_at: expires_at, label: 'Redis read timeout exceeded')
+          rescue IO::WaitReadable
+            wait_for_io(:wait_readable, io: socket.to_io, expires_at: expires_at, label: 'Redis read timeout exceeded')
+          rescue IO::WaitWritable
+            wait_for_io(:wait_writable, io: socket.to_io, expires_at: expires_at, label: 'Redis read timeout exceeded')
+          end
+        end
+
+        def wait_status?(value)
+          %i[wait_readable wait_writable].include?(value)
+        end
+
+        def check_io_deadline!(expires_at, label)
+          deadline.check!
+          domain_error(label) unless (expires_at - monotonic_time).positive?
+        end
+
+        def wait_for_io(status, io:, expires_at:, label:)
+          timeout = [expires_at - monotonic_time, deadline.remaining].min
+          domain_error(label) unless timeout.positive?
+
+          ready = status == :wait_readable ? io.wait_readable(timeout) : io.wait_writable(timeout)
+          return if ready
+
+          deadline.check!
+          domain_error(label)
+        end
+
+        def monotonic_time
+          Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        end
+      end
+    end
+  end
+end

data/lib/necropsy/analyzers/dynamic/redis_payload_loader.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'uri'
+require 'yaml'
+
+require_relative 'coverband_payload_set'
+require_relative 'redis_input_limits'
+require_relative 'redis_transport'
+
+module Necropsy
+  module Analyzers
+    module Dynamic
+      class RedisPayloadLoader
+        DEFAULT_PATTERN = 'coverband*'
+
+        def initialize(source:, config:)
+          @redactor = RedisCredentialRedactor.new(source)
+          @uri = parse_uri(source)
+          @config = config
+          @limits = RedisInputLimits.new(config)
+        end
+
+        def load
+          start_session
+          transport.connect
+          authenticate
+          select_database
+          payload_processor.merge(keys.filter_map { |key| payload_for_key(key) })
+        rescue RedisCommandError, Error => e
+          raise Error, redactor.redact(e.message), cause: nil
+        rescue StandardError => e
+          raise Error, redactor.redact("Could not load Redis coverage: #{e.message}"), cause: nil
+        ensure
+          transport&.close
+        end
+
+        private
+
+        attr_reader :uri, :config, :limits, :redactor, :transport, :deadline, :payload_processor
+
+        def parse_uri(source)
+          parsed = URI(source)
+          return parsed if %w[redis rediss].include?(parsed.scheme) && parsed.host
+
+          raise Error, 'Invalid Redis source URI'
+        rescue URI::Error, ArgumentError
+          raise Error, 'Invalid Redis source URI', cause: nil
+        end
+
+        def start_session
+          @deadline = RedisDeadline.new(limits.total_timeout)
+          @payload_processor = CoverbandPayloadSet.new(limits: limits, deadline: deadline)
+          @transport = RedisTransport.new(uri: uri, limits: limits, deadline: deadline, redactor: redactor)
+        end
+
+        def authenticate
+          return unless uri.password
+
+          password = URI.decode_www_form_component(uri.password)
+          return command('AUTH', password) unless uri.user
+
+          command('AUTH', URI.decode_www_form_component(uri.user), password)
+        end
+
+        def select_database
+          database = uri.path.to_s.delete_prefix('/')
+          command('SELECT', database) unless database.empty?
+        end
+
+        def keys
+          configured = Array(config['keys'] || config['key'] || query['key']).compact
+          return validate_key_count!(configured) unless configured.empty?
+
+          scan(pattern: config['pattern'] || query['pattern'] || DEFAULT_PATTERN)
+        end
+
+        def query
+          @query ||= URI.decode_www_form(uri.query.to_s).to_h
+        end
+
+        def scan(pattern:)
+          cursor = '0'
+          found = []
+          loop do
+            deadline.check!
+            cursor, batch = scan_page(cursor, pattern)
+            append_keys!(found, batch)
+            break if cursor == '0'
+          end
+          found
+        end
+
+        def scan_page(cursor, pattern)
+          response = command('SCAN', cursor, 'MATCH', pattern)
+          valid = response.is_a?(Array) && response.length == 2 && response.last.is_a?(Array)
+          raise Error, 'Malformed Redis SCAN response' unless valid
+
+          next_cursor = response.first.to_s
+          raise Error, 'Malformed Redis SCAN cursor' unless next_cursor.match?(/\A\d+\z/)
+
+          [next_cursor, response.last]
+        end
+
+        def append_keys!(found, batch)
+          raise Error, 'Redis key count exceeds configured limit' if found.length + batch.length > limits.max_keys
+
+          found.concat(batch)
+        end
+
+        def validate_key_count!(keys)
+          raise Error, 'Redis key count exceeds configured limit' if keys.length > limits.max_keys
+
+          keys
+        end
+
+        def payload_for_key(key)
+          value = command('GET', key)
+          return nil if value.nil? || value.empty?
+
+          payload = parse_payload(value)
+          raise Error, 'Redis coverage payload must be a mapping' unless payload.is_a?(Hash)
+
+          limits.validate_payload!(payload)
+        rescue RedisCommandError => e
+          raise unless e.message.start_with?('WRONGTYPE')
+
+          parse_hash_payload(command('HGETALL', key))
+        end
+
+        def command(*parts)
+          transport.command(*parts)
+        end
+
+        def parse_payload(value)
+          return nil if value.nil? || value.empty?
+
+          parsed = begin
+            JSON.parse(value, max_nesting: limits.max_payload_depth)
+          rescue JSON::ParserError
+            parse_yaml_payload(value)
+          end
+          limits.validate_payload!(parsed)
+        end
+
+        def parse_yaml_payload(value)
+          YAML.safe_load(value, aliases: false)
+        rescue Psych::Exception, ArgumentError, EncodingError, SystemStackError => e
+          raise Error, redactor.redact("Invalid Redis coverage payload: #{e.message}"), cause: nil
+        end
+
+        def parse_hash_payload(entries)
+          active_payload_processor.from_hash_entries(entries) { |value| parse_payload(value) }
+        end
+
+        def active_payload_processor
+          @active_payload_processor ||= CoverbandPayloadSet.new(
+            limits: limits,
+            deadline: (@deadline ||= RedisDeadline.new(limits.total_timeout))
+          )
+        end
+      end
+    end
+  end
+end

data/lib/necropsy/analyzers/dynamic/redis_transport.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require 'openssl'
+require 'socket'
+require 'timeout'
+
+require_relative 'redis_nonblocking_io'
+
+module Necropsy
+  module Analyzers
+    module Dynamic
+      class RedisCommandError < StandardError; end
+
+      class RedisTransport
+        include RedisNonblockingIO
+
+        CRLF = "\r\n"
+
+        def initialize(uri:, limits:, deadline:, redactor:)
+          @uri = uri
+          @limits = limits
+          @deadline = deadline
+          @redactor = redactor
+          @response_bytes = 0
+          @read_buffer = +''
+        end
+
+        def connect
+          @tcp_socket = connect_tcp
+          @socket = uri.scheme == 'rediss' ? connect_tls : tcp_socket
+          deadline.check!
+          self
+        rescue Error
+          close
+          raise
+        rescue SystemCallError, SocketError, IO::TimeoutError, OpenSSL::SSL::SSLError => e
+          close
+          domain_error("Could not connect securely to Redis at #{target}: #{e.message}")
+        end
+
+        def close
+          socket&.close
+          tcp_socket&.close unless socket.equal?(tcp_socket)
+        rescue IOError, SystemCallError
+          nil
+        ensure
+          @socket = nil
+          @tcp_socket = nil
+        end
+
+        def command(*parts)
+          deadline.check!
+          write_all(redis_command(parts))
+          response = read_response
+          deadline.check!
+          response
+        rescue RedisCommandError
+          raise
+        rescue IOError, SystemCallError, OpenSSL::SSL::SSLError => e
+          domain_error("Redis connection failed: #{e.message}")
+        end
+
+        private
+
+        attr_reader :uri, :limits, :deadline, :redactor, :socket, :tcp_socket
+
+        def connect_tcp
+          expires_at = monotonic_time + limits.connect_timeout
+          last_error = nil
+          addresses(expires_at).each do |address|
+            candidate = Socket.new(address.afamily, address.socktype, address.protocol)
+            begin
+              finish_tcp_connect(candidate, address, expires_at)
+              return candidate
+            rescue SystemCallError, SocketError => e
+              candidate.close
+              last_error = e
+            rescue Error
+              candidate.close
+              raise
+            end
+          end
+          raise(last_error || SocketError.new("No Redis address found for #{uri.host}"))
+        end
+
+        def addresses(expires_at)
+          timeout = [expires_at - monotonic_time, deadline.remaining].min
+          domain_error('Redis address resolution timeout exceeded') unless timeout.positive?
+
+          # Limit asynchronous interruption to pure resolution, before any socket resource exists.
+          resolved = Timeout.timeout(timeout) do
+            Addrinfo.getaddrinfo(uri.host, uri.port || 6379, nil, :STREAM)
+          end
+          deadline.check!
+          domain_error('Redis address resolution timeout exceeded') unless (expires_at - monotonic_time).positive?
+          resolved
+        rescue Timeout::Error
+          deadline.check!
+          domain_error('Redis address resolution timeout exceeded')
+        end
+
+        def finish_tcp_connect(candidate, address, expires_at)
+          status = candidate.connect_nonblock(address, exception: false)
+          return unless wait_status?(status)
+
+          wait_for_io(status, io: candidate, expires_at: expires_at, label: 'Redis connect timeout exceeded')
+          error = candidate.getsockopt(Socket::SOL_SOCKET, Socket::SO_ERROR).int
+          raise SystemCallError.new("connect(2) for #{target}", error) unless error.zero?
+        rescue Errno::EISCONN
+          nil
+        end
+
+        def connect_tls
+          context = OpenSSL::SSL::SSLContext.new
+          store = OpenSSL::X509::Store.new
+          store.set_default_paths
+          context.cert_store = store
+          context.verify_mode = OpenSSL::SSL::VERIFY_PEER
+          context.verify_hostname = true if context.respond_to?(:verify_hostname=)
+
+          ssl_socket = OpenSSL::SSL::SSLSocket.new(tcp_socket, context)
+          ssl_socket.sync_close = true
+          ssl_socket.hostname = uri.host
+          finish_tls_connect(ssl_socket)
+          ssl_socket.post_connection_check(uri.host)
+          ssl_socket
+        rescue StandardError
+          ssl_socket&.close
+          raise
+        end
+
+        def target
+          "#{uri.host}:#{uri.port || 6379}"
+        end
+
+        def redis_command(parts)
+          encoded = parts.flat_map { |part| ["$#{part.to_s.bytesize}", part.to_s] }
+          (["*#{parts.length}"] + encoded).join(CRLF) + CRLF
+        end
+
+        def read_response(depth = 0)
+          prefix = read_exact(1)
+          case prefix
+          when '+' then read_line
+          when '-' then raise RedisCommandError, redactor.redact(read_line)
+          when ':' then read_integer('integer')
+          when '$' then read_bulk_string
+          when '*' then read_array(depth)
+          else domain_error("Malformed Redis response prefix #{prefix.inspect}")
+          end
+        end
+
+        def read_bulk_string
+          length = read_integer('bulk length', nullable: true)
+          return nil if length == -1
+
+          domain_error('Invalid negative Redis bulk length') if length.negative?
+          domain_error('Redis bulk response exceeds configured limit') if length > limits.max_bulk_bytes
+
+          value = read_exact(length)
+          domain_error('Malformed Redis bulk response terminator') unless read_exact(2) == CRLF
+          value
+        end
+
+        def read_array(depth)
+          length = read_integer('array length', nullable: true)
+          return nil if length == -1
+
+          domain_error('Invalid negative Redis array length') if length.negative?
+          domain_error('Redis array response exceeds configured element limit') if length > limits.max_array_elements
+
+          child_depth = depth + 1
+          domain_error('Redis response exceeds configured nesting depth') if child_depth > limits.max_resp_depth
+          Array.new(length) { read_response(child_depth) }
+        end
+
+        def read_integer(label, nullable: false)
+          text = read_line
+          domain_error("Malformed Redis #{label}") unless text.match?(/\A-?\d+\z/)
+
+          value = Integer(text, 10)
+          domain_error("Invalid negative Redis #{label}") if value.negative? && (!nullable || value < -1)
+          value
+        end
+
+        def read_line
+          loop do
+            if (terminator = @read_buffer.index(CRLF))
+              return @read_buffer.slice!(0, terminator + CRLF.bytesize).delete_suffix(CRLF)
+            end
+
+            fill_buffer
+          end
+        end
+
+        def read_exact(length)
+          fill_buffer while @read_buffer.bytesize < length
+          @read_buffer.slice!(0, length)
+        end
+
+        def fill_buffer
+          deadline.check!
+          remaining = limits.max_response_bytes - @response_bytes
+          domain_error('Redis response exceeds configured byte limit') unless remaining.positive?
+
+          chunk = read_nonblock([4096, remaining].min)
+          @response_bytes += chunk.bytesize
+          @read_buffer << chunk
+        end
+
+        def domain_error(message)
+          raise Error, redactor.redact(message), cause: nil
+        end
+      end
+    end
+  end
+end

data/lib/necropsy/analyzers/dynamic/runtime_reference.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Necropsy
+  module Analyzers
+    module Dynamic
+      module RuntimeReference
+        module_function
+
+        def build(symbol_id:, file: nil, line: nil, definition_id: nil)
+          {
+            'definition_id' => definition_id,
+            'symbol_id' => symbol_id,
+            'file' => file,
+            'line' => line
+          }.compact
+        end
+
+        def normalize(value)
+          return value if value.is_a?(String)
+          return unless value.is_a?(Hash)
+
+          data = value.to_h { |key, item| [key.to_s, item] }
+          symbol_id = data['symbol_id']
+          return unless symbol_id.is_a?(String) && !symbol_id.empty?
+          return unless valid_optional_string?(data, 'definition_id') && valid_optional_string?(data, 'file')
+
+          line = normalize_line(data['line'])
+          return if data.key?('line') && !data['line'].nil? && line.nil?
+
+          build(
+            definition_id: optional_string(data['definition_id']),
+            symbol_id: symbol_id,
+            file: optional_string(data['file']),
+            line: line
+          )
+        end
+
+        def sort_key(reference)
+          normalized = normalize(reference)
+          return ['', reference.to_s, '', 0] unless normalized.is_a?(Hash)
+
+          [
+            normalized.fetch('definition_id', ''),
+            normalized.fetch('symbol_id'),
+            normalized.fetch('file', ''),
+            normalized.fetch('line', 0)
+          ]
+        end
+
+        def key(reference)
+          sort_key(reference)
+        end
+
+        def preferred(structured:, legacy:)
+          return Array(legacy) if structured.nil?
+
+          structured_values = Array(structured)
+          structured_symbols = structured_values.filter_map do |reference|
+            normalize(reference).then { |normalized| normalized['symbol_id'] if normalized.is_a?(Hash) }
+          end.to_set
+          structured_values + Array(legacy).reject { |symbol_id| structured_symbols.include?(symbol_id) }
+        end
+
+        def malformed?(reference)
+          !reference.is_a?(String) && normalize(reference).nil?
+        end
+
+        def relative_file(root, path)
+          expanded = File.expand_path(path)
+          prefix = "#{File.expand_path(root)}/"
+          return unless expanded.start_with?(prefix)
+
+          expanded.delete_prefix(prefix)
+        end
+
+        def optional_string(value)
+          value if value.is_a?(String) && !value.empty?
+        end
+        private_class_method :optional_string
+
+        def valid_optional_string?(data, key)
+          !data.key?(key) || data[key].nil? || (data[key].is_a?(String) && !data[key].empty?)
+        end
+        private_class_method :valid_optional_string?
+
+        def normalize_line(value)
+          return if value.nil?
+
+          line = Integer(value, exception: false)
+          line if line&.positive?
+        end
+        private_class_method :normalize_line
+      end
+    end
+  end
+end