elftools 1.3.1 → 2.1.0

data/lib/elftools/dynamic.rb

@@ -1,5 +1,15 @@
 # frozen_string_literal: true
 
+require 'elftools/constants'
+require 'elftools/dynamic/string_table'
+require 'elftools/dynamic/symbols'
+require 'elftools/dynamic/versions'
+require 'elftools/dynamic/tag'
+require 'elftools/exceptions'
+require 'elftools/relative_relocations'
+require 'elftools/relocation'
+require 'elftools/structs'
+
 module ELFTools
   # Define common methods for dynamic sections and dynamic segments.
   #
@@ -8,6 +18,9 @@ module ELFTools
   #   and {ELFTools::Segments::DynamicSegment} because methods here assume some
   #   attributes exist.
   module Dynamic
+    include Symbols
+    include Versions
+
     # Iterate all tags.
     #
     # @note
@@ -18,8 +31,8 @@ module ELFTools
     # @return [Enumerator<ELFTools::Dynamic::Tag>, Array<ELFTools::Dynamic::Tag>]
     #   If block is not given, an enumerator will be returned.
     #   Otherwise, return array of tags.
-    def each_tags(&block)
-      return enum_for(:each_tags) unless block_given?
+    def each_tag(&block)
+      return enum_for(:each_tag) unless block_given?
 
       arr = []
       0.step do |i|
@@ -30,11 +43,14 @@ module ELFTools
       arr
     end
 
+    # The name this used to go by, kept so that it keeps working.
+    alias each_tags each_tag
+
     # Use {#tags} to get all tags.
     # @return [Array<ELFTools::Dynamic::Tag>]
     #   Array of tags.
     def tags
-      @tags ||= each_tags.to_a
+      @tags ||= each_tag.to_a
     end
 
     # Get a tag of specific type.
@@ -63,7 +79,7 @@ module ELFTools
     #   #=> #<ELFTools::Dynamic::Tag:0x0055d3d2d91b28 @header={:d_tag=>3, :d_val=>6295552}>
     def tag_by_type(type)
       type = Util.to_constant(Constants::DT, type)
-      each_tags.find { |tag| tag.header.d_tag == type }
+      each_tag.find { |tag| tag.header.d_tag == type }
     end
 
     # Get tags of specific type.
@@ -75,7 +91,7 @@ module ELFTools
     # @see #tag_by_type
     def tags_by_type(type)
       type = Util.to_constant(Constants::DT, type)
-      each_tags.select { |tag| tag.header.d_tag == type }
+      each_tag.select { |tag| tag.header.d_tag == type }
     end
 
     # Get the +n+-th tag.
@@ -100,7 +116,25 @@ module ELFTools
       dyn.elf_class = header.elf_class
       stream.pos = tag_start + n * dyn.num_bytes
       dyn.offset = stream.pos
-      @tag_at_map[n] = Tag.new(dyn.read(stream), stream, method(:str_offset))
+      @tag_at_map[n] = Tag.new(dyn.read(stream), stream, string_table)
+    end
+
+    # The relocations the tags point at.
+    #
+    # Three tables record them: the one +DT_REL+ or +DT_RELA+ names, the one
+    # +DT_JMPREL+ names, whose entries are of the kind +DT_PLTREL+ names, and
+    # the one +DT_RELR+ names, which packs the relocations that only add the
+    # load bias into a bitmap and so records no type of its own.
+    # @return [Array<ELFTools::Relocation>] The relocations, in the order the
+    #   tags record them, the packed ones last.
+    # @raise [ELFTools::ELFError]
+    #   If a table is not in any loadable segment.
+    # @example
+    #   elf.dynamic.relocations.map(&:type_name).uniq
+    #   #=> ['R_X86_64_GLOB_DAT', 'R_X86_64_JUMP_SLOT']
+    def relocations
+      @relocations ||= relocation_tables.flat_map { |start, size, rela| read_relocations(start, size, rela) } +
+                       packed_relocations
     end
 
     private
@@ -109,69 +143,92 @@ module ELFTools
       header.class.self_endian
     end
 
-    # Get the DT_STRTAB's +d_val+ offset related to file.
-    def str_offset
-      # TODO: handle DT_STRTAB not exitsts.
-      @str_offset ||= @offset_from_vma.call(tag_by_type(:strtab).header.d_val.to_i)
+    # Where each table of relocations starts, the tag recording how many bytes
+    # it takes, and whether its entries record an addend.
+    # @return [Array<Array(ELFTools::Dynamic::Tag, ELFTools::Dynamic::Tag, Boolean)>] The tables.
+    def relocation_tables
+      tables = %i[rel rela].filter_map do |type|
+        tag = tag_by_type(type)
+        [tag, tag_by_type(:"#{type}sz"), type == :rela] if tag
+      end
+      jmprel = tag_by_type(:jmprel)
+      return tables if jmprel.nil?
+
+      tables << [jmprel, tag_by_type(:pltrelsz), tag_by_type(:pltrel).header.d_val.to_i == Constants::DT_RELA]
     end
 
-    # A tag class.
-    class Tag
-      attr_reader :header # @return [ELFTools::Structs::ELF_Dyn] The dynamic tag header.
-      attr_reader :stream # @return [#pos=, #read] Streaming object.
-
-      # Instantiate a {ELFTools::Dynamic::Tag} object.
-      # @param [ELF_Dyn] header The dynamic tag header.
-      # @param [#pos=, #read] stream Streaming object.
-      # @param [Method] str_offset
-      #   Call this method to get the string offset related
-      #   to file.
-      def initialize(header, stream, str_offset)
-        @header = header
-        @stream = stream
-        @str_offset = str_offset
-      end
+    # Reads the table +DT_RELR+ names, which is absent from most files.
+    # @return [Array<ELFTools::Relocation>] The relocations, empty without it.
+    def packed_relocations
+      start = tag_by_type(:relr)
+      return [] if start.nil?
 
-      # Some dynamic have name.
-      TYPE_WITH_NAME = [Constants::DT_NEEDED,
-                        Constants::DT_SONAME,
-                        Constants::DT_RPATH,
-                        Constants::DT_RUNPATH].freeze
-      # Return the content of this tag records.
-      #
-      # For normal tags, this method just return
-      # +header.d_val+. For tags with +header.d_val+
-      # in meaning of string offset (e.g. DT_NEEDED), this method would
-      # return the string it specified.
-      # Tags with type in {TYPE_WITH_NAME} are those tags with name.
-      # @return [Integer, String] The content this tag records.
-      # @example
-      #   dynamic = elf.segment_by_type(:dynamic)
-      #   dynamic.tag_by_type(:init).value
-      #   #=> 4195600 # 0x400510
-      #   dynamic.tag_by_type(:needed).value
-      #   #=> 'libc.so.6'
-      def value
-        name || header.d_val.to_i
-      end
+      offset = offset_of(start)
+      RelativeRelocations.new(stream, offset...(offset + tag_by_type(:relrsz).header.d_val.to_i),
+                              elf_class: header.elf_class, endian:, machine: @machine).to_a
+    end
 
-      # Is this tag has a name?
-      #
-      # The criteria here is if this tag's type is in {TYPE_WITH_NAME}.
-      # @return [Boolean] Is this tag has a name.
-      def name?
-        TYPE_WITH_NAME.include?(header.d_tag)
+    # Reads one table of relocations.
+    # @return [Array<ELFTools::Relocation>] The relocations.
+    def read_relocations(start, size, rela)
+      klass = rela ? Structs::ELF_Rela : Structs::ELF_Rel
+      offset = offset_of(start)
+      # An entry takes what its structure takes. DT_RELAENT and DT_RELENT
+      # record the same number, which a file has no way of disagreeing with
+      # and every file here agrees with.
+      entsize = struct(klass).num_bytes
+      Array.new(size.header.d_val.to_i / entsize) do |i|
+        Relocation.new(read_struct(klass, offset + (i * entsize)), stream, machine: @machine)
       end
+    end
+
+    # A structure of the endianness and the class the file records it in.
+    # @param [Class] klass The structure class.
+    # @return [ELFTools::Structs::ELFStruct] The structure, before it is read.
+    def struct(klass)
+      struct = klass.new(endian:)
+      struct.elf_class = header.elf_class
+      struct
+    end
+
+    # Reads a structure the file records at a file offset.
+    # @param [Class] klass The structure class.
+    # @param [Integer] offset The file offset.
+    # @return [ELFTools::Structs::ELFStruct] The structure.
+    def read_struct(klass, offset)
+      struct = struct(klass)
+      struct.offset = offset
+      stream.pos = offset
+      struct.read(stream)
+    end
 
-      # Return the name of this tag.
-      #
-      # Only tags with name would return a name.
-      # Others would return +nil+.
-      # @return [String, nil] The name.
-      def name
-        return nil unless name?
+    # The file offset the address a tag records points at.
+    # @param [ELFTools::Dynamic::Tag] tag The tag.
+    # @return [Integer] The file offset.
+    # @raise [ELFTools::ELFError]
+    #   If the address is not in any loadable segment.
+    def offset_of(tag)
+      vma = tag.header.d_val.to_i
+      @offset_from_vma.call(vma) ||
+        raise(ELFError, format('Invalid %s address 0x%x', Constants::DT.mapping(@machine, tag.header.d_tag.to_i), vma))
+    end
+
+    # The names the tags and the symbols point at.
+    # @return [ELFTools::Dynamic::StringTable] The string table.
+    def string_table
+      @string_table ||= StringTable.new(stream, method(:str_offset))
+    end
+
+    # Get the DT_STRTAB's +d_val+ offset related to file.
+    # @return [Integer] The file offset.
+    # @raise [ELFTools::ELFError]
+    #   If DT_STRTAB is absent, or its address is not in any loadable segment.
+    def str_offset
+      @str_offset ||= begin
+        strtab = tag_by_type(:strtab)
+        raise ELFError, 'DT_STRTAB not found' if strtab.nil?
 
-        Util.cstring(stream, @str_offset.call + header.d_val.to_i)
+        offset_of(strtab)
       end
     end
   end

data/lib/elftools/elf_file.rb

@@ -59,6 +59,25 @@ module ELFTools
       note.desc.unpack1('H*')
     end
 
+    # The dynamic tags of this file, read from the view that its type makes
+    # authoritative.
+    #
+    # A relocatable file is linked by its sections, so its sections answer and
+    # any segment it carries is disregarded, being something no linker reads.
+    # An executable or a shared object is loaded by its segments alone, so the
+    # segment answers and the section recording the same tags is metadata a
+    # tool may have stripped or rewritten.
+    # @return [ELFTools::Segments::DynamicSegment, ELFTools::Sections::DynamicSection, nil]
+    #   The tags, +nil+ if the view that decides records none.
+    # @example
+    #   elf.dynamic.tag_by_type(:needed).name
+    #   #=> 'libc.so.6'
+    def dynamic
+      return sections_by_type(:dynamic).first if header.e_type.to_i == Constants::ET_REL
+
+      segment_by_type(:dynamic) || sections_by_type(:dynamic).first
+    end
+
     # Get machine architecture.
     #
     # Mappings of architecture can be found
@@ -67,7 +86,7 @@ module ELFTools
     #   Name of architecture.
     # @example
     #   elf.machine
-    #   #=> 'Advanced Micro Devices X86-64'
+    #   #=> 'Advanced Micro Devices X86-64 processor'
     def machine
       ELFTools::Constants::EM.mapping(header.e_machine)
     end
@@ -105,7 +124,7 @@ module ELFTools
     #   elf.section_by_name('no such section')
     #   #=> nil
     def section_by_name(name)
-      each_sections.find { |sec| sec.name == name }
+      each_section.find { |sec| sec.name == name }
     end
 
     # Iterate all sections.
@@ -119,19 +138,22 @@ module ELFTools
     # @return [Enumerator<ELFTools::Sections::Section>, Array<ELFTools::Sections::Section>]
     #   As +Array#each+, if block is not given, a enumerator will be returned,
     #   otherwise, the whole sections will be returned.
-    def each_sections(&block)
-      return enum_for(:each_sections) unless block_given?
+    def each_section(&block)
+      return enum_for(:each_section) unless block_given?
 
       Array.new(num_sections) do |i|
         section_at(i).tap(&block)
       end
     end
 
+    # The name this used to go by, kept so that it keeps working.
+    alias each_sections each_section
+
     # Simply use {#sections} to get all sections.
     # @return [Array<ELFTools::Sections::Section>]
     #   Whole sections.
     def sections
-      each_sections.to_a
+      each_section.to_a
     end
 
     # Acquire the +n+-th section, 0-based.
@@ -160,17 +182,21 @@ module ELFTools
     #   elf.sections_by_type(:rela)
     #   #=> [#<ELFTools::Sections::RelocationSection:0x00563cd3219970>,
     #   #    #<ELFTools::Sections::RelocationSection:0x00563cd3b89d70>]
-    def sections_by_type(type, &block)
+    def sections_by_type(type, &)
       type = Util.to_constant(Constants::SHT, type)
-      Util.select_by_type(each_sections, type, &block)
+      Util.select_by_type(each_section, type, &)
     end
 
-    # Get the string table section.
+    # The section the names of the sections are recorded in, which the ELF
+    # header names by index.
     #
-    # This section is acquired by using the +e_shstrndx+
-    # in ELF header.
-    # @return [ELFTools::Sections::StrTabSection] The desired section.
-    def strtab_section
+    # It is not the section the names of the symbols are recorded in, which
+    # {ELFTools::Sections::SymTabSection#symstr} answers.
+    # @return [ELFTools::Sections::StrTabSection] The section.
+    # @example
+    #   elf.section_name_table.name
+    #   #=> '.shstrtab'
+    def section_name_table
       section_at(header.e_shstrndx)
     end
 
@@ -192,19 +218,22 @@ module ELFTools
     # @yieldreturn [void]
     # @return [Array<ELFTools::Segments::Segment>]
     #   Whole segments will be returned.
-    def each_segments(&block)
-      return enum_for(:each_segments) unless block_given?
+    def each_segment(&block)
+      return enum_for(:each_segment) unless block_given?
 
       Array.new(num_segments) do |i|
         segment_at(i).tap(&block)
       end
     end
 
+    # The name this used to go by, kept so that it keeps working.
+    alias each_segments each_segment
+
     # Simply use {#segments} to get all segments.
     # @return [Array<ELFTools::Segments::Segment>]
     #   Whole segments.
     def segments
-      each_segments.to_a
+      each_segment.to_a
     end
 
     # Get the first segment with +p_type=type+.
@@ -250,7 +279,7 @@ module ELFTools
     #   #=> nil # no such segment exists
     def segment_by_type(type)
       type = Util.to_constant(Constants::PT, type)
-      each_segments.find { |seg| seg.header.p_type == type }
+      each_segment.find { |seg| seg.header.p_type == type }
     end
 
     # Fetch all segments with specific type.
@@ -263,9 +292,9 @@ module ELFTools
     # @yieldparam [ELFTools::Segments::Segment] segment A segment in specific type.
     # @yieldreturn [void]
     # @return [Array<ELFTools::Segments::Segment>] The target segments.
-    def segments_by_type(type, &block)
+    def segments_by_type(type, &)
       type = Util.to_constant(Constants::PT, type)
-      Util.select_by_type(each_segments, type, &block)
+      Util.select_by_type(each_segment, type, &)
     end
 
     # Acquire the +n+-th segment, 0-based.
@@ -285,7 +314,7 @@ module ELFTools
     # This method should work no matter ELF is a PIE or not.
     # This method refers from (actually equals to) binutils/readelf.c#offset_from_vma.
     # @param [Integer] vma The virtual address to be queried.
-    # @return [Integer] Related file offset.
+    # @return [Integer?] Related file offset. +nil+ if the queried region has no content in file.
     # @example
     #   elf = ELFTools::ELFFile.new(File.open('/bin/cat'))
     #   elf.offset_from_vma(0x401337)
@@ -294,6 +323,25 @@ module ELFTools
       segments_by_type(:load) do |seg|
         return seg.vma_to_offset(vma) if seg.vma_in?(vma, size)
       end
+
+      nil
+    end
+
+    # Get virtual address given offset in file
+    #
+    # @param [Integer] offset The file offset to be queried.
+    # @return [Integer?] Related virtual address. Note this is raw address, not always adjusted for base address.
+    #                    +nil+ if offset is invalid.
+    # @example
+    #   elf = ELFTools::ELFFile.new(File.open('/bin/cat'))
+    #   elf.vma_from_offset(0x1337)
+    #   #=> 0x401337
+    def vma_from_offset(offset, size = 1)
+      segments_by_type(:load) do |seg|
+        return seg.offset_to_vma(offset) if seg.offset_in?(offset, size)
+      end
+
+      nil
     end
 
     # The patch status.
@@ -363,15 +411,19 @@ module ELFTools
       shdr.read(stream)
       Sections::Section.create(shdr, stream,
                                offset_from_vma: method(:offset_from_vma),
-                               strtab: method(:strtab_section),
-                               section_at: method(:section_at))
+                               section_name_table: method(:section_name_table),
+                               section_at: method(:section_at),
+                               sections: method(:sections),
+                               machine: header.e_machine.to_i)
     end
 
     def create_segment(n)
       stream.pos = header.e_phoff + n * header.e_phentsize
       phdr = Structs::ELF_Phdr[elf_class].new(endian:, offset: stream.pos)
       phdr.elf_class = elf_class
-      Segments::Segment.create(phdr.read(stream), stream, offset_from_vma: method(:offset_from_vma))
+      Segments::Segment.create(phdr.read(stream), stream,
+                               offset_from_vma: method(:offset_from_vma),
+                               machine: header.e_machine.to_i)
     end
   end
 end

data/lib/elftools/lazy_array.rb

@@ -7,6 +7,9 @@ module ELFTools
   # 'lazy loading' objects.
   # Mainly used when loading sections, segments, and
   # symbols.
+  #
+  # Only {#[]} loads an element on demand, any other method
+  # of +Array+ loads all elements before it operates.
   class LazyArray < SimpleDelegator
     # Instantiate a {LazyArray} object.
     # @param [Integer] size
@@ -28,7 +31,8 @@ module ELFTools
     #   p arr[3]
     #   # 9
     def initialize(size, &block)
-      super(Array.new(size))
+      @array = Array.new(size)
+      super(@array)
       @block = block
     end
 
@@ -36,14 +40,48 @@ module ELFTools
     #
     # Elements are lazy loaded at the first time
     # access it.
+    # @param [Integer] i
+    #   The index, negative index is *not* supported.
     # @return [Object]
     #   The element, returned type is the
     #   return type of block given in {#initialize}.
+    #   +nil+ if +i+ is out of bound.
     def [](i)
-      # XXX: support negative index?
-      return nil unless i.between?(0, __getobj__.size - 1)
+      return nil unless i.between?(0, size - 1)
 
-      __getobj__[i] ||= @block.call(i)
+      @array[i] ||= @block.call(i)
+    end
+
+    # The size of this array.
+    #
+    # This method never loads any element.
+    # @return [Integer]
+    #   The size given in {#initialize}.
+    def size
+      @array.size
+    end
+    alias length size
+
+    # Loads all elements.
+    #
+    # Called whenever a method other than {#[]} and {#size} is invoked, so that
+    # those methods operate on a fully loaded array.
+    # @return [Array]
+    #   The loaded array.
+    # @example
+    #   arr = LazyArray.new(3) { |i| i * i }
+    #   p arr.map { |v| v + 1 }
+    #   # [1, 2, 5]
+    def __getobj__
+      @array.each_index { |i| self[i] }
+      @array
+    end
+
+    private
+
+    # Queries the array without loading any element.
+    def respond_to_missing?(name, include_private = false)
+      @array.respond_to?(name, include_private)
     end
   end
 end

data/lib/elftools/note.rb

@@ -41,8 +41,8 @@ module ELFTools
     # @return [Enumerator<ELFTools::Note::Note>, Array<ELFTools::Note::Note>]
     #   If block is not given, an enumerator will be returned.
     #   Otherwise, return the array of notes.
-    def each_notes
-      return enum_for(:each_notes) unless block_given?
+    def each_note
+      return enum_for(:each_note) unless block_given?
 
       @notes_offset_map ||= {}
       cur = note_start
@@ -61,11 +61,14 @@ module ELFTools
       notes
     end
 
+    # The name this used to go by, kept so that it keeps working.
+    alias each_notes each_note
+
     # Simply +#notes+ to get all notes.
     # @return [Array<ELFTools::Note::Note>]
     #   Whole notes.
     def notes
-      each_notes.to_a
+      each_note.to_a
     end
 
     private

data/lib/elftools/relative_relocations.rb

@@ -0,0 +1,88 @@
+# 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|
+        rel = Structs::ELF_Rel.new(endian: @endian, offset: from)
+        rel.elf_class = @elf_class
+        rel.r_offset = address
+        relocation = Relocation.new(rel, @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