metasploit-framework/lib/rubocop/cop/lint/detect_invalid_pack_directives.rb

# frozen_string_literal: true

module RuboCop
  module Cop
    module Lint
      # Looks for invalid pack/unpack directives with Ruby 3.3.0 some directives
      # that used to not raise errors, now will - context: https://bugs.ruby-lang.org/issues/19150:
      #   * Array#pack now raises ArgumentError for unknown directives
      #   * String#unpack now raises ArgumentError for unknown directives
      #
      # @example
      #   # bad
      #   ```
      #   3.3.0-preview1 :003 > [0x1].pack('<L')
      #   <internal:pack>:8:in `pack': unknown pack directive '<' in '<L' (ArgumentError)
      #   ```
      #
      #   # good
      #   ```
      #   3.3.0-preview1 :001 > [0x1].pack('L<')
      #     => "\x01\x00\x00\x00"
      #   ```
      class DetectInvalidPackDirectives < RuboCop::Cop::Base
        # https://github.com/ruby/ruby/blob/7cfabe1acc55b24fc2c479a87efa71cf74e9e8fc/pack.c#L38
        MODIFIABLE_DIRECTIVES = %w[s S i I l L q Q j J]

        # https://github.com/ruby/ruby/blob/7cfabe1acc55b24fc2c479a87efa71cf74e9e8fc/pack.c#L298
        ACCEPTABLE_DIRECTIVES = %w[U m A B H a A Z b B h H c C s S i I l L q Q j J n N v V f F e E d D g G x X @ % U u m M P p w]

        # @param [RuboCop::AST::SendNode] node Node for the ruby `send` method
        # @return [[RuboCop::AST::Node], raise] offense when an invalid directive is found, or raise if unexpected error found
        def on_send(node)
          _callee, method_name = *node

          return unless %i[pack unpack pack1 unpack1].include?(method_name)

          args = node.arguments
          return if args.empty?

          args.each do |arg|
            next unless string_arg?(arg)

            # if multiline arguments are passed
            if arg.type == :dstr
              idx = []

              pack_directive = arg.children.map do |child|
                if begin_arg?(child)
                  next
                else
                  idx << child.children.first.length
                  child.children.join
                end
              end.join

            # elsif single line arguments are passed
            elsif arg.type == :str
              pack_directive = arg.children.first
            end

            error = validate_directive(pack_directive)
            if error.nil?
              next
            else
              offense_range = get_error_range(arg, error[:index], idx)
              return if offense_range.nil?

              add_offense(offense_range, message: error[:message])
            end
          end
        end

        private

        # Check if the pack directives are valid. See link for pack docs https://apidock.com/ruby/Array/pack
        #
        # Code based on https://github.com/ruby/ruby/blob/6391132c03ac08da0483adb986ff9a54e41f9e14/pack.c#L196
        # adapted into Ruby
        #
        # @param [String] pack_directive The ruby pack/unpack directive to validate
        # @return [Hash,nil] A hash with the message and index that the invalidate directive was found at, or nil.
        def validate_directive(pack_directive)
          # current pointer value
          p = 0

          # end of pointer range
          pend = pack_directive.length

          while p < pend
            explicit_endian = 0
            type_index = p

            # get data type
            type = pack_directive[type_index]
            p += 1

            if type.blank?
              next
            end

            if type == '#'
              p += 1 while p < pend && pack_directive[p] != "\n"
              next
            end

            # Modifiers
            loop do
              case pack_directive[p]
              when '_', '!'
                if MODIFIABLE_DIRECTIVES.include?(type)
                  p += 1
                else
                  return { message: "'#{pack_directive[p]}' allowed only after types #{MODIFIABLE_DIRECTIVES.join}", index: p }
                end
              when '<', '>'
                unless MODIFIABLE_DIRECTIVES.include?(type)
                  return { message: "'#{pack_directive[p]}' allowed only after types #{MODIFIABLE_DIRECTIVES.join}", index: p }
                end

                if explicit_endian != 0
                  return { message: "Can't use both '<' and '>'.", index: p }
                end

                explicit_endian = pack_directive[p]
                p += 1
              else
                break
              end
            end

            # Data length
            if pack_directive[p] == '*'
              p += 1
            elsif pack_directive[p]&.match?(/\d/)
              p += 1 while pack_directive[p]&.match?(/\d/)
            end

            # Check type
            unless ACCEPTABLE_DIRECTIVES.include?(type)
              return { message: "unknown pack directive '#{type}' in '#{pack_directive}'", index: type_index }
            end
          end

          nil
        end

        # Checks if the current node is of type `:str` or `:dstr` - `dstr` being multiline
        #
        # @param [RuboCop::AST::SendNode] node Node for the ruby `send` method
        # @return [TrueClass, FalseClass]
        def string_arg?(node)
          node&.type == :str || node&.type == :dstr
        end

        # Check if the node if of type `:begin`
        #
        # @param [RuboCop::AST::SendNode] node Node for the ruby `send` method
        # @return [TrueClass, FalseClass]
        def begin_arg?(node)
          node.type == :begin
        end

        # Get the range of the offense to more accurately raise offenses against specific directives
        #
        # @param [RuboCop::AST::DstrNode, RuboCop::AST::StrNode ] arg The node that need its range calculated
        # @param [Integer] p The current pointer value
        # @param [Array] idx An array holding to number of indexes for the node
        # @return [Parser::Source::Range] The range of the node value
        def get_error_range(arg, p, idx)
          # Logic for multiline strings
          if arg.type == :dstr
            total = 0
            index = 0

            idx.each_with_index do |idx_length, count|
              if total < p
                total += idx_length
                index = count
              end
            end
            adjusted_index = p - idx[0..(index - 1)].sum

            indexed_arg = arg.children[index]

            if begin_arg?(indexed_arg)
              return nil
            else
              newline_adjustment = indexed_arg.children.first[0..adjusted_index].scan(/[\n\t]/).count
            end

            # If there's opening quotes present, i.e. "a", instead of heredoc which doesn't have preceding opening quotes:
            if indexed_arg.loc.begin
              range_start = indexed_arg.loc.begin.end_pos + (p - adjusted_index)
            else
              expression = processed_source.raw_source[indexed_arg.loc.expression.begin.begin_pos...indexed_arg.loc.expression.end.end_pos]
              if expression[/^\s+/].nil?
                leading_whitespace_size = 0
              else
                leading_whitespace_size = expression[/^\s+/].length
              end
              adjusted_index += leading_whitespace_size
              range_start = indexed_arg.loc.expression.begin_pos + (adjusted_index + newline_adjustment)
            end
          # Logic for single line strings
          else
            newline_adjustment = arg.children.first[0..p].scan(/[\n\t]/).count
            range_start = arg.loc.begin.end_pos + (p + newline_adjustment)
          end

          range_end = range_start + 1

          Parser::Source::Range.new(arg.loc.expression.source_buffer, range_start, range_end)
        end
      end
    end
  end
end