elftools 2.0.0 → 2.2.0

data/lib/elftools/elf_file.rb

@@ -105,12 +105,19 @@ module ELFTools
     #========= method about sections
 
     # Number of sections in this file.
+    #
+    # A file with more sections than the ELF header can count records a zero
+    # there and states the number in the first section header instead, which a
+    # file with no section headers at all records as well.
     # @return [Integer] The desired number.
     # @example
     #   elf.num_sections
     #   #=> 29
     def num_sections
-      header.e_shnum
+      count = header.e_shnum.to_i
+      return count unless count.zero? && !header.e_shoff.to_i.zero?
+
+      first_section_header.sh_size.to_i
     end
 
     # Acquire the section named as +name+.
@@ -197,15 +204,25 @@ module ELFTools
     #   elf.section_name_table.name
     #   #=> '.shstrtab'
     def section_name_table
-      section_at(header.e_shstrndx)
+      index = header.e_shstrndx.to_i
+      # An index too large for the ELF header is stated in the first section
+      # header instead.
+      index = first_section_header.sh_link.to_i if index == Constants::SHN_XINDEX
+      section_at(index)
     end
 
     #========= method about segments
 
     # Number of segments in this file.
+    #
+    # A file with more segments than the ELF header can count states the number
+    # in the first section header instead, as it does for the sections.
     # @return [Integer] The desited number.
     def num_segments
-      header.e_phnum
+      count = header.e_phnum.to_i
+      return count unless count == Constants::PN_XNUM
+
+      first_section_header.sh_info.to_i
     end
 
     # Iterate all segments.
@@ -373,15 +390,35 @@ module ELFTools
 
     # bad idea..
     def loaded_headers
-      explore = lambda do |obj|
-        return obj if obj.is_a?(::ELFTools::Structs::ELFStruct)
-        return obj.map(&explore) if obj.is_a?(Array)
+      # By identity, so that a graph that reaches the same thing by many paths,
+      # or leads round in circles, is walked once rather than over and over.
+      headers_in(self, {}.compare_by_identity).flatten
+    end
 
-        obj.instance_variables.map do |s|
-          explore.call(obj.instance_variable_get(s))
-        end
-      end
-      explore.call(self).flatten
+    # The structures reachable from an object, whatever holds them.
+    # @param [Object] obj The object.
+    # @param [Hash] seen What has been reached already.
+    # @return [Array] The structures, nested.
+    def headers_in(obj, seen)
+      # A class is not one of the things a file records.
+      return [] if seen[obj] || obj.is_a?(Module)
+
+      seen[obj] = true
+      return obj if obj.is_a?(::ELFTools::Structs::ELFStruct)
+
+      held_by(obj).map { |held| headers_in(held, seen) }
+    end
+
+    # What an object holds, which a walk of it goes on to.
+    # @param [Object] obj The object.
+    # @return [Enumerable] What it holds.
+    def held_by(obj)
+      return obj if obj.is_a?(Array)
+      # A hash is held by its values, which is where the tags and the symbols
+      # read through the tags are remembered.
+      return obj.each_value if obj.is_a?(Hash)
+
+      obj.instance_variables.map { |name| obj.instance_variable_get(name) }
     end
 
     def identify
@@ -404,6 +441,18 @@ module ELFTools
       raise ELFDataError, format('Invalid EI_DATA "\x%02x"', ei_data) if endian.nil?
     end
 
+    # The first section header, which is where a file too large for the counts
+    # the ELF header records states them.
+    # @return [ELFTools::Structs::ELF_Shdr] The header.
+    def first_section_header
+      @first_section_header ||= begin
+        stream.pos = header.e_shoff.to_i
+        shdr = Structs::ELF_Shdr.new(endian:, offset: stream.pos)
+        shdr.elf_class = elf_class
+        shdr.read(stream)
+      end
+    end
+
     def create_section(n)
       stream.pos = header.e_shoff + n * header.e_shentsize
       shdr = Structs::ELF_Shdr.new(endian:, offset: stream.pos)
@@ -413,6 +462,7 @@ module ELFTools
                                offset_from_vma: method(:offset_from_vma),
                                section_name_table: method(:section_name_table),
                                section_at: method(:section_at),
+                               sections: method(:sections),
                                machine: header.e_machine.to_i)
     end
 

data/lib/elftools/relative_relocations.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'elftools/constants'
+require 'elftools/relocation'
+require 'elftools/structs'
+
+module ELFTools
+  # The relocations a file packs into a bitmap instead of recording one by one.
+  #
+  # Almost every relocation of a file that is loaded anywhere only adds the
+  # load bias to a word, which takes an entry recording an address, a type that
+  # is the same every time, and an addend that repeats what the word already
+  # holds. A file may pack them instead, as a run of addresses in ascending
+  # order, and spend a bit rather than an entry on each.
+  #
+  # An even entry is an address, and relocates the word there. An odd entry is
+  # a bitmap of the words following the last address, a set bit relocating one
+  # of them. Nothing records a type, because every relocation here is the one
+  # {ELFTools::Constants::R.relative} names.
+  class RelativeRelocations
+    # Instantiate a {ELFTools::RelativeRelocations} object.
+    # @param [#pos=, #read] stream Streaming object.
+    # @param [Range<Integer>] bytes The file offsets the table occupies.
+    # @param [Integer] elf_class 32 or 64, the width of an entry.
+    # @param [Symbol] endian +:little+ or +:big+.
+    # @param [Integer] machine
+    #   The machine of the file, which decides what these relocations are of.
+    def initialize(stream, bytes, elf_class:, endian:, machine:)
+      @stream = stream
+      @bytes = bytes
+      @elf_class = elf_class
+      @endian = endian
+      @machine = machine
+    end
+
+    # The relocations the table packs.
+    # @return [Array<ELFTools::Relocation>]
+    #   The relocations, in the ascending order the table records them.
+    def to_a
+      type = Constants::R.relative(@machine)
+      addresses.map do |address, from|
+        fields = Structs::Fields.from(Structs::ELF_Rel, { r_offset: address, r_info: 0 },
+                                      elf_class: @elf_class, endian: @endian, offset: from)
+        relocation = Relocation.new(fields, @stream, machine: @machine)
+        # Through the relocation, so that the type is laid out in +r_info+ the
+        # way the machine lays it out.
+        relocation.type = type if type
+        relocation
+      end
+    end
+
+    private
+
+    # How many bytes an entry takes, which is the width of an address.
+    # @return [Integer] The number.
+    def width
+      @elf_class / 8
+    end
+
+    # Every address the table relocates, and the entry it was read from.
+    # @return [Array<Array(Integer, Integer)>] The addresses.
+    def addresses
+      found = []
+      # Where a bitmap counts from, which an address moves to just past itself.
+      here = 0
+      entries.each do |entry, from|
+        if entry.even?
+          found << [entry, from]
+          here = entry + width
+        else
+          # The lowest bit says the entry is a bitmap rather than an address.
+          (1...(width * 8)).each { |bit| found << [here + ((bit - 1) * width), from] if entry[bit] == 1 }
+          here += ((width * 8) - 1) * width
+        end
+      end
+      found
+    end
+
+    # What the table records, and where each was read from.
+    # @return [Array<Array(Integer, Integer)>] The entries.
+    def entries
+      @stream.pos = @bytes.begin
+      format = "#{width == 8 ? 'Q' : 'L'}#{@endian == :big ? '>' : '<'}"
+      @stream.read(@bytes.size).to_s.unpack("#{format}*").each_with_index.map { |e, i| [e, @bytes.begin + (i * width)] }
+    end
+  end
+end

data/lib/elftools/relocation.rb

@@ -1,28 +1,41 @@
 # frozen_string_literal: true
 
 require 'elftools/constants'
+require 'elftools/structs'
+require 'elftools/util'
 
 module ELFTools
   # A relocation entry.
   #
   # Can be either a REL or RELA relocation.
   class Relocation
-    attr_reader :header # @return [ELFTools::Structs::ELF_Rel, ELFTools::Structs::ELF_Rela] Rel(a) header.
     attr_reader :stream # @return [#pos=, #read] Streaming object.
 
     # Instantiate a {Relocation} object.
-    # @param [ELFTools::Structs::ELF_Rel, ELFTools::Structs::ELF_Rela] header
-    #   The relocation header.
+    # @param [ELFTools::Structs::ELF_Rel, ELFTools::Structs::ELF_Rela, ELFTools::Structs::Fields] header
+    #   The relocation header, or what the file records in one.
+    #   {ELFTools::Structs::Fields} answers what the relocation records until
+    #   something asks for {#header} itself, which builds the structure then.
     # @param [#pos=, #read] stream The streaming object.
     # @param [Integer] machine
     #   The machine of the ELF file, which decides what {#type} means and how
     #   {#header} records it.
     def initialize(header, stream, machine: nil)
-      @header = header
+      @fields = header.is_a?(Structs::Fields) ? header : Structs::Fields.of(header)
       @stream = stream
       @machine = machine
     end
 
+    # The structure the file records this relocation in.
+    #
+    # One is built here for a relocation read without it, which is what
+    # assigning to a field of one needs and what {ELFTools::ELFFile#patches}
+    # reports the changes of.
+    # @return [ELFTools::Structs::ELF_Rel, ELFTools::Structs::ELF_Rela] The structure.
+    def header
+      @fields.struct
+    end
+
     # Which symbol this relocation is against, as an index into the symbol
     # table.
     # @return [Integer] The symbol index.
@@ -37,6 +50,24 @@ module ELFTools
       sym_and_type.last
     end
 
+    # Sets which symbol this relocation is against.
+    # @param [Integer] index The symbol index.
+    # @raise [ArgumentError] If the bits recording it cannot hold it.
+    # @example
+    #   relocation.symbol_index = 3
+    def symbol_index=(index)
+      @fields[:r_info] = info_of(Util.fits!(index, index_bits, 'Symbol index'), type)
+    end
+
+    # Sets what this relocation does.
+    # @param [Integer] type The relocation type.
+    # @raise [ArgumentError] If the bits recording it cannot hold it.
+    # @example
+    #   relocation.type = ELFTools::Constants::R::X86_64::R_X86_64_JUMP_SLOT
+    def type=(type)
+      @fields[:r_info] = info_of(symbol_index, Util.fits!(type, type_bits, 'Relocation type'))
+    end
+
     # The name of {#type}.
     #
     # Every architecture numbers relocation types on its own, so the name is
@@ -51,6 +82,37 @@ module ELFTools
 
     private
 
+    # The +r_info+ recording a symbol index and a type, laid out the way this
+    # file lays it out. The inverse of {#sym_and_type}.
+    # @return [Integer] The +r_info+.
+    def info_of(index, type)
+      return mips64_info_of(index, type) if mips64?
+
+      (index << mask_bit) | type
+    end
+
+    # The +r_info+ as the 64-bit MIPS ABI records it, leaving the bytes the
+    # ABI keeps for itself as they were.
+    # @return [Integer] The +r_info+.
+    def mips64_info_of(index, type)
+      info = @fields[:r_info]
+      return (index << 32) | (info & 0xffff_ff00) | type if @fields.endian == :big
+
+      (info & 0x00ff_ffff_0000_0000) | (type << 56) | index
+    end
+
+    # How many bits record a symbol index.
+    # @return [Integer] The number.
+    def index_bits
+      mips64? ? 32 : (@fields.elf_class - mask_bit)
+    end
+
+    # How many bits record a relocation type.
+    # @return [Integer] The number.
+    def type_bits
+      mips64? ? 8 : mask_bit
+    end
+
     # What +r_info+ records, i.e. a symbol index and a relocation type. Most
     # machines split the field in half between the two, one lays it out its
     # own way.
@@ -58,14 +120,15 @@ module ELFTools
     def sym_and_type
       return mips64_sym_and_type if mips64?
 
-      [header.r_info >> mask_bit, header.r_info & ((1 << mask_bit) - 1)]
+      info = @fields[:r_info]
+      [info >> mask_bit, info & ((1 << mask_bit) - 1)]
     end
 
     # Whether the file records relocations the way the 64-bit MIPS ABI does,
     # which is the one layout that departs from halving +r_info+.
     # @return [Boolean] The answer.
     def mips64?
-      @machine == Constants::EM_MIPS && header.elf_class == 64
+      @machine == Constants::EM_MIPS && @fields.elf_class == 64
     end
 
     # Reads +r_info+ as the 64-bit MIPS ABI records it, i.e. a symbol index of
@@ -81,14 +144,14 @@ module ELFTools
     #   0x0718050000000008 #=> [8, 7]
     # @return [Array(Integer, Integer)] The symbol index and the type.
     def mips64_sym_and_type
-      info = header.r_info.to_i
-      return [info >> 32, info & 0xff] if header.class.self_endian == :big
+      info = @fields[:r_info]
+      return [info >> 32, info & 0xff] if @fields.endian == :big
 
       [info & 0xffff_ffff, info >> 56]
     end
 
     def mask_bit
-      header.elf_class == 32 ? 8 : 32
+      @fields.elf_class == 32 ? 8 : 32
     end
   end
 end

data/lib/elftools/sections/relative_relocation_section.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'elftools/relative_relocations'
+require 'elftools/sections/section'
+
+module ELFTools
+  module Sections
+    # Class of the section packing the relocations that only add the load bias.
+    #
+    # This section is usually named .relr.dyn, and records the very relocations
+    # the +DT_RELR+ tag points at.
+    class RelativeRelocationSection < Section
+      # Instantiate a {RelativeRelocationSection} object.
+      # @param [ELFTools::Structs::ELF_Shdr] header
+      #   See {Section#initialize} for more information.
+      # @param [#pos=, #read] stream
+      #   See {Section#initialize} for more information.
+      # @param [Integer] machine
+      #   The machine of the ELF file, which decides what these relocations
+      #   are of. This should be +e_machine+ of the ELF header.
+      def initialize(header, stream, machine: nil, **_kwargs)
+        @machine = machine
+        super
+      end
+
+      # The relocations the section packs.
+      # @return [Array<ELFTools::Relocation>]
+      #   The relocations, in the ascending order the section records them.
+      # @example
+      #   section.relocations.map(&:type_name).uniq
+      #   #=> ['R_X86_64_RELATIVE']
+      def relocations
+        @relocations ||= RelativeRelocations.new(
+          stream, header.sh_offset.to_i...(header.sh_offset.to_i + header.sh_size.to_i),
+          elf_class: header.elf_class, endian: header.class.self_endian, machine: @machine
+        ).to_a
+      end
+
+      # How many relocations the section packs.
+      # @return [Integer] The number.
+      def num_relocations
+        relocations.size
+      end
+    end
+  end
+end

data/lib/elftools/sections/relocation_section.rb

@@ -78,12 +78,23 @@ module ELFTools
       private
 
       def create_relocation(n)
-        stream.pos = header.sh_offset + n * header.sh_entsize
         klass = rela? ? Structs::ELF_Rela : Structs::ELF_Rel
-        rel = klass.new(endian: header.class.self_endian, offset: stream.pos)
-        rel.elf_class = header.elf_class
-        rel.read(stream)
-        Relocation.new(rel, stream, machine: @machine)
+        fields = Structs::Fields.new(klass, stream, table_offset + (n * entsize),
+                                     elf_class: header.elf_class, endian: header.class.self_endian)
+        Relocation.new(fields, stream, machine: @machine)
+      end
+
+      # Where this table starts in the file, asked of the header once rather
+      # than once for every relocation read.
+      # @return [Integer] The file offset.
+      def table_offset
+        @table_offset ||= header.sh_offset.to_i
+      end
+
+      # How many bytes this table spaces its entries by.
+      # @return [Integer] The number.
+      def entsize
+        @entsize ||= header.sh_entsize.to_i
       end
     end
   end

data/lib/elftools/sections/section.rb

@@ -46,6 +46,37 @@ module ELFTools
         stream.read(header.sh_size)
       end
 
+      # Is this section written to while the file runs?
+      # @return [Boolean] True or false.
+      # @example
+      #   elf.section_by_name('.data').writable?
+      #   #=> true
+      def writable?
+        header.sh_flags.allbits?(Constants::SHF_WRITE)
+      end
+
+      # Is this section executed?
+      # @return [Boolean] True or false.
+      # @example
+      #   elf.section_by_name('.text').executable?
+      #   #=> true
+      def executable?
+        header.sh_flags.allbits?(Constants::SHF_EXECINSTR)
+      end
+
+      # Does this section take memory while the file runs?
+      #
+      # The ones that do are what a file is loaded by, the rest being what is
+      # recorded about it, its symbol names and its debugging information
+      # among them.
+      # @return [Boolean] True or false.
+      # @example
+      #   elf.section_by_name('.symtab').allocated?
+      #   #=> false
+      def allocated?
+        header.sh_flags.allbits?(Constants::SHF_ALLOC)
+      end
+
       # Is this a null section?
       # @return [Boolean] No it's not.
       def null?

data/lib/elftools/sections/sections.rb

@@ -7,9 +7,13 @@ require 'elftools/sections/section'
 require 'elftools/sections/dynamic_section'
 require 'elftools/sections/note_section'
 require 'elftools/sections/null_section'
+require 'elftools/sections/relative_relocation_section'
 require 'elftools/sections/relocation_section'
 require 'elftools/sections/str_tab_section'
 require 'elftools/sections/sym_tab_section'
+require 'elftools/sections/version_definition_section'
+require 'elftools/sections/version_need_section'
+require 'elftools/sections/version_section'
 
 module ELFTools
   # Defines different types of sections in this module.
@@ -27,6 +31,10 @@ module ELFTools
                 when Constants::SHT_NULL then NullSection
                 when Constants::SHT_NOTE then NoteSection
                 when Constants::SHT_RELA, Constants::SHT_REL then RelocationSection
+                when Constants::SHT_RELR then RelativeRelocationSection
+                when Constants::SHT_GNU_versym then VersionSection
+                when Constants::SHT_GNU_verneed then VersionNeedSection
+                when Constants::SHT_GNU_verdef then VersionDefinitionSection
                 when Constants::SHT_STRTAB then StrTabSection
                 when Constants::SHT_SYMTAB, Constants::SHT_DYNSYM then SymTabSection
                 else Section

data/lib/elftools/sections/sym_tab_section.rb

@@ -2,6 +2,8 @@
 
 require 'elftools/sections/section'
 require 'elftools/sections/symbol'
+require 'elftools/structs'
+require 'elftools/version_tables'
 
 module ELFTools
   module Sections
@@ -16,14 +18,15 @@ module ELFTools
       #   See {Section#initialize} for more information.
       # @param [#pos=, #read] stream
       #   See {Section#initialize} for more information.
-      # @param [Proc] section_at
-      #   The method for fetching other sections by index.
-      #   This lambda should be {ELFTools::ELFFile#section_at}.
+      # @param [Proc] sections
+      #   The method for fetching the sections, which is where the names and
+      #   the versions of these symbols are recorded. This lambda should be
+      #   {ELFTools::ELFFile#sections}.
       # @param [Integer] machine
       #   The machine of the ELF file, which decides what the fields of a
       #   symbol mean. This should be +e_machine+ of the ELF header.
-      def initialize(header, stream, section_at: nil, machine: nil, **_kwargs)
-        @section_at = section_at
+      def initialize(header, stream, sections: nil, machine: nil, **_kwargs)
+        @sections = sections
         @machine = machine
         # For faster #symbol_by_name
         super
@@ -91,16 +94,67 @@ module ELFTools
       # Lazy loaded.
       # @return [ELFTools::Sections::StrTabSection] The string table section.
       def symstr
-        @symstr ||= @section_at.call(header.sh_link)
+        @symstr ||= @sections.call[header.sh_link]
       end
 
       private
 
       def create_symbol(n)
-        stream.pos = header.sh_offset + n * header.sh_entsize
-        sym = Structs::ELF_sym[header.elf_class].new(endian: header.class.self_endian, offset: stream.pos)
-        sym.read(stream)
-        Symbol.new(sym, stream, symstr: method(:symstr), machine: @machine)
+        Symbol.new(
+          Structs::Fields.new(Structs::ELF_sym[header.elf_class], stream, table_offset + (n * entsize),
+                              elf_class: header.elf_class, endian: header.class.self_endian),
+          stream, symstr: symstr_reader, machine: @machine, version: -> { version_at(n) }
+        )
+      end
+
+      # Where this table starts in the file, asked of the header once rather
+      # than once for every symbol read.
+      # @return [Integer] The file offset.
+      def table_offset
+        @table_offset ||= header.sh_offset.to_i
+      end
+
+      # How many bytes this table spaces its entries by.
+      # @return [Integer] The number.
+      def entsize
+        @entsize ||= header.sh_entsize.to_i
+      end
+
+      # What reads the section these symbols are named in, kept so that
+      # reading the table does not make one for every symbol.
+      # @return [Method] The method.
+      def symstr_reader
+        @symstr_reader ||= method(:symstr)
+      end
+
+      # The version the +n+-th symbol binds to.
+      # @return [ELFTools::VersionTables::Version, nil]
+      #   The version, +nil+ unless this is the table a file is loaded by and
+      #   the file records versions at all.
+      def version_at(n)
+        return if versions.nil?
+
+        VersionTables.version(versions.version_at(n), versions_by_index)
+      end
+
+      # The section recording which version each of these symbols binds to,
+      # which is the one naming this table.
+      # @return [ELFTools::Sections::VersionSection, nil] The section.
+      def versions
+        return @versions if defined?(@versions)
+
+        @versions = @sections&.call&.find do |sec|
+          sec.is_a?(VersionSection) && @sections.call[sec.header.sh_link].equal?(self)
+        end
+      end
+
+      # The name each index the symbols record names.
+      # @return [Hash{Integer => String}] The names.
+      def versions_by_index
+        @versions_by_index ||= VersionTables.names(
+          @sections.call.grep(VersionNeedSection).flat_map(&:requirements),
+          @sections.call.grep(VersionDefinitionSection).flat_map(&:definitions)
+        )
       end
     end
   end