elftools 2.0.0 → 2.1.0

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/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,7 @@
 
 require 'elftools/sections/section'
 require 'elftools/sections/symbol'
+require 'elftools/version_tables'
 
 module ELFTools
   module Sections
@@ -16,14 +17,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,7 +93,7 @@ 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
@@ -100,7 +102,37 @@ module ELFTools
         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(sym, stream, symstr: method(:symstr), machine: @machine, version: -> { version_at(n) })
+      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

data/lib/elftools/sections/symbol.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'elftools/constants'
+require 'elftools/util'
 
 module ELFTools
   module Sections
@@ -19,11 +20,15 @@ module ELFTools
       #   access {Symbol#name}.
       # @param [Integer] machine
       #   The machine of the ELF file, which a name of a value depends on.
-      def initialize(header, stream, symstr: nil, machine: nil)
+      # @param [Proc] version
+      #   Call this to get the version this symbol binds to, which only the
+      #   symbols a file is loaded by have.
+      def initialize(header, stream, symstr: nil, machine: nil, version: nil)
         @header = header
         @stream = stream
         @symstr = symstr
         @machine = machine
+        @version = version
       end
 
       # Return the symbol name.
@@ -32,6 +37,51 @@ module ELFTools
         @name ||= @symstr.call.name_at(header.st_name)
       end
 
+      # The version this symbol binds to.
+      #
+      # Only the symbols a file is loaded by have one, and only where the file
+      # records the versions at all. {#name} is left as the file records it,
+      # without the version appended.
+      # @return [String, nil] The name of the version.
+      # @example
+      #   elf.dynamic.symbol_by_name('printf').version
+      #   #=> 'GLIBC_2.2.5'
+      def version
+        binding_version&.name
+      end
+
+      # Whether {#version} is one the symbol asks for by name rather than the
+      # default one of its name.
+      # @return [Boolean] The answer.
+      def version_hidden?
+        binding_version&.hidden? || false
+      end
+
+      # What this symbol is worth, which for most of them is the address of
+      # what they name.
+      #
+      # A symbol of a file that is not loaded anywhere records an offset into
+      # the section holding it instead, and one the linker is still to place,
+      # which {ELFTools::Constants::SHN_COMMON} marks, records the alignment it
+      # needs. The ABI leaves the field to the kind of symbol for that reason,
+      # and this answers with what is recorded either way.
+      # @return [Integer] The value.
+      # @example
+      #   elf.section_by_name('.symtab').symbol_by_name('main').value
+      #   #=> 4196061 # 0x4006dd
+      def value
+        header.st_value.to_i
+      end
+
+      # How many bytes what this symbol names takes.
+      # @return [Integer] The number, zero where the file records none.
+      # @example
+      #   elf.section_by_name('.symtab').symbol_by_name('main').size
+      #   #=> 142
+      def size
+        header.st_size.to_i
+      end
+
       # What kind of entity this symbol refers to.
       #
       # The available types are listed in {ELFTools::Constants::STT}.
@@ -43,6 +93,15 @@ module ELFTools
         header.st_info & 0xf
       end
 
+      # Sets what kind of entity this symbol refers to.
+      # @param [Integer] type The type.
+      # @raise [ArgumentError] If the four bits recording it cannot hold it.
+      # @example
+      #   symbol.type = ELFTools::Constants::STT_FUNC
+      def type=(type)
+        header.st_info = (bind << 4) | Util.fits!(type, 4, 'Symbol type')
+      end
+
       # The name of {#type}.
       #
       # A machine names types of its own, so the name is only known when the
@@ -66,6 +125,15 @@ module ELFTools
         header.st_info >> 4
       end
 
+      # Sets how this symbol is linked against others with the same name.
+      # @param [Integer] bind The binding.
+      # @raise [ArgumentError] If the four bits recording it cannot hold it.
+      # @example
+      #   symbol.bind = ELFTools::Constants::STB_WEAK
+      def bind=(bind)
+        header.st_info = (Util.fits!(bind, 4, 'Symbol binding') << 4) | type
+      end
+
       # The name of {#bind}.
       # @return [String] The name.
       # @example
@@ -87,6 +155,19 @@ module ELFTools
         header.st_other & 0x3
       end
 
+      # Sets how this symbol is accessed once it becomes part of an executable
+      # or shared object.
+      #
+      # The rest of +st_other+ is left alone, which some machines record their
+      # own thing in.
+      # @param [Integer] visibility The visibility.
+      # @raise [ArgumentError] If the two bits recording it cannot hold it.
+      # @example
+      #   symbol.visibility = ELFTools::Constants::STV_HIDDEN
+      def visibility=(visibility)
+        header.st_other = (header.st_other.to_i & 0xfc) | Util.fits!(visibility, 2, 'Symbol visibility')
+      end
+
       # The name of {#visibility}.
       # @return [String] The name.
       # @example
@@ -96,6 +177,15 @@ module ELFTools
         Constants::STV.mapping(@machine, visibility)
       end
 
+      # The version this symbol binds to, whatever is asked of it.
+      # @return [ELFTools::Dynamic::Versions::Version, nil] The version.
+      def binding_version
+        return @binding_version if defined?(@binding_version)
+
+        @binding_version = @version&.call
+      end
+      private :binding_version
+
       # The index of the section this symbol is defined in.
       #
       # Values in {ELFTools::Constants::SHN} have special meanings instead of

data/lib/elftools/sections/version_definition_section.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'elftools/sections/section'
+require 'elftools/version_tables'
+
+module ELFTools
+  module Sections
+    # Class of the section recording the versions a file defines for what it
+    # exports.
+    #
+    # This section is usually named .gnu.version_d, and records the very
+    # versions the +DT_VERDEF+ tag points at.
+    class VersionDefinitionSection < Section
+      # Instantiate a {VersionDefinitionSection} object.
+      # @param [ELFTools::Structs::ELF_Shdr] header
+      #   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, which is where the
+      #   names are recorded.
+      def initialize(header, stream, section_at: nil, **_kwargs)
+        @section_at = section_at
+        super
+      end
+
+      # The versions this file defines for what it exports.
+      # @return [Array<ELFTools::VersionTables::Definition>]
+      #   The definitions, in the order the section records them.
+      # @example
+      #   section.definitions.map(&:name).first(3)
+      #   #=> ['libc.so.6', 'GLIBC_2.2.5', 'GLIBC_2.2.6']
+      def definitions
+        @definitions ||= VersionTables.new(stream, @section_at.call(header.sh_link),
+                                           endian: header.class.self_endian)
+                                      .definitions(header.sh_offset.to_i, header.sh_info.to_i)
+      end
+    end
+  end
+end

data/lib/elftools/sections/version_need_section.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'elftools/sections/section'
+require 'elftools/version_tables'
+
+module ELFTools
+  module Sections
+    # Class of the section recording the versions a file needs of the files it
+    # is loaded with.
+    #
+    # This section is usually named .gnu.version_r, and records the very
+    # versions the +DT_VERNEED+ tag points at.
+    class VersionNeedSection < Section
+      # Instantiate a {VersionNeedSection} object.
+      # @param [ELFTools::Structs::ELF_Shdr] header
+      #   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, which is where the
+      #   names are recorded.
+      def initialize(header, stream, section_at: nil, **_kwargs)
+        @section_at = section_at
+        super
+      end
+
+      # The versions this file needs of the files it is loaded with.
+      # @return [Array<ELFTools::VersionTables::Requirement>]
+      #   The requirements, in the order the section records them.
+      # @example
+      #   section.requirements.map { |need| [need.file, need.versions.map(&:name)] }
+      #   #=> [['libc.so.6', ['GLIBC_2.4', 'GLIBC_2.2.5']]]
+      def requirements
+        @requirements ||= VersionTables.new(stream, @section_at.call(header.sh_link),
+                                            endian: header.class.self_endian)
+                                       .requirements(header.sh_offset.to_i, header.sh_info.to_i)
+      end
+    end
+  end
+end

data/lib/elftools/sections/version_section.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'elftools/sections/section'
+
+module ELFTools
+  module Sections
+    # Class of the section recording which version each symbol binds to.
+    #
+    # This section is usually named .gnu.version, and holds an index per symbol
+    # of the table its +sh_link+ names, the very indices the +DT_VERSYM+ tag
+    # points at.
+    class VersionSection < Section
+      # How many symbols the section records a version for.
+      # @return [Integer] The number.
+      def num_versions
+        header.sh_size.to_i / entry_size
+      end
+
+      # What the +n+-th symbol records as its version, which is an index into
+      # the versions a file needs or defines, with the highest bit marking a
+      # version the symbol asks for by name rather than the default one.
+      # @param [Integer] n The symbol index.
+      # @return [Integer, nil] The index, +nil+ if the section records none for it.
+      # @example
+      #   section.version_at(1)
+      #   #=> 2
+      def version_at(n)
+        return if n.negative? || n >= num_versions
+
+        stream.pos = header.sh_offset.to_i + (n * entry_size)
+        stream.read(entry_size).unpack1(header.class.self_endian == :big ? 'S>' : 'S<')
+      end
+
+      private
+
+      # What an entry takes, which the section records and the format fixes at
+      # two bytes either way.
+      # @return [Integer] The number of bytes.
+      def entry_size
+        2
+      end
+    end
+  end
+end

data/lib/elftools/structs.rb

@@ -18,15 +18,73 @@ module ELFTools
       attr_accessor :elf_class # @return [Integer] 32 or 64.
       attr_accessor :offset # @return [Integer] The file offset of this header.
 
-      # Records which fields have been patched.
-      # @return [Hash{Integer => Integer}] Patches.
+      # Reads the structure, remembering the bytes it was read from.
+      #
+      # They are taken back off the stream. A stream that cannot be seeked is
+      # serialized instead.
+      # @param [#pos=, #read] io The streaming object.
+      # @return [ELFTools::Structs::ELFStruct] Itself.
+      def read(io)
+        start = io.pos if io.respond_to?(:pos)
+        super.tap { @source = start.nil? ? to_binary_s : bytes_read(io, start) }
+      end
+
+      # Which bytes of this structure have been changed since it was read.
+      #
+      # Every field answers alike, however deeply it is nested, because what is
+      # compared is the bytes the structure occupies rather than the
+      # assignments that were made to it. A field assigned the value it
+      # already held leaves nothing behind.
+      # @return [Hash{Integer => String}]
+      #   Where each run of changed bytes starts, as an offset into the
+      #   structure, and the bytes it is to be replaced with.
+      # @example
+      #   header.e_ident.ei_abiversion = 41
+      #   header.patches
+      #   #=> { 8 => "\x29" }
       def patches
-        @patches ||= {}
+        return {} if @source.nil?
+
+        changed_runs(@source, to_binary_s)
       end
 
       # BinData hash(Snapshot) that behaves like HashWithIndifferentAccess
       alias to_h snapshot
 
+      private
+
+      # The bytes a read has just taken from a stream, leaving it where the
+      # read left it.
+      # @param [#pos=, #read] io The streaming object.
+      # @param [Integer] start Where the read began.
+      # @return [String] The bytes.
+      def bytes_read(io, start)
+        here = io.pos
+        io.pos = start
+        io.read(here - start).tap { io.pos = here }
+      end
+
+      # Where two strings of bytes differ, as the runs of bytes that differ.
+      #
+      # Only as far as +before+ reaches, so that a patch never covers more of
+      # the file than the structure it came from.
+      # @param [String] before The bytes as they were.
+      # @param [String] after The bytes as they are.
+      # @return [Hash{Integer => String}] Where each run starts, and its bytes.
+      def changed_runs(before, after)
+        runs = {}
+        start = nil
+        (0..before.bytesize).each do |i|
+          if i < before.bytesize && before.getbyte(i) != after.getbyte(i)
+            start ||= i
+          elsif start
+            runs[start] = after.byteslice(start, i - start)
+            start = nil
+          end
+        end
+        runs
+      end
+
       class << self
         # Hooks the constructor.
         #
@@ -41,19 +99,7 @@ module ELFTools
         def new(*args)
           kwargs = args.last.is_a?(Hash) ? args.last : {}
           offset = kwargs.delete(:offset)
-          super.tap do |obj|
-            obj.offset = offset
-            obj.field_names.each do |f|
-              m = :"#{f}="
-              old_method = obj.singleton_method(m)
-              obj.singleton_class.send(:undef_method, m)
-              obj.define_singleton_method(m) do |val|
-                org = obj.send(f)
-                obj.patches[org.abs_offset] = ELFStruct.pack(val, org.num_bytes)
-                old_method.call(val)
-              end
-            end
-          end
+          super.tap { |obj| obj.offset = offset }
         end
 
         # Gets the endianness of current class.
@@ -63,6 +109,10 @@ module ELFTools
         end
 
         # Packs an integer to string.
+        #
+        # @deprecated
+        #   Nothing here packs a patch by hand anymore, see {ELFStruct#patches}.
+        #   This is kept for anyone who called it and goes in the next major.
         # @param [Integer] val
         # @param [Integer] bytes
         # @return [String]
@@ -200,6 +250,49 @@ module ELFTools
       uint32 :shift2    # The second shift the bloom filter is built with
     end
 
+    # An entry of the table of versions a file needs of another, which the
+    # +vn_next+ of the one before it points at.
+    class ELF_Verneed < ELFStruct
+      endian :big_and_little
+      uint16 :vn_version # Revision of this structure
+      uint16 :vn_cnt     # How many versions of the file are needed
+      uint32 :vn_file    # Name of the file, as an offset into the string table
+      uint32 :vn_aux     # Where the versions start, as an offset from here
+      uint32 :vn_next    # Where the next entry is, as an offset from here
+    end
+
+    # A version an {ELF_Verneed} needs, which the +vna_next+ of the one before
+    # it points at.
+    class ELF_Vernaux < ELFStruct
+      endian :big_and_little
+      uint32 :vna_hash  # Hash of the name
+      uint16 :vna_flags # Flags
+      uint16 :vna_other # The index the symbols name this version with
+      uint32 :vna_name  # The name, as an offset into the string table
+      uint32 :vna_next  # Where the next version is, as an offset from here
+    end
+
+    # An entry of the table of versions a file defines, which the +vd_next+ of
+    # the one before it points at.
+    class ELF_Verdef < ELFStruct
+      endian :big_and_little
+      uint16 :vd_version # Revision of this structure
+      uint16 :vd_flags   # Flags
+      uint16 :vd_ndx     # The index the symbols name this version with
+      uint16 :vd_cnt     # How many names follow, the version and its ancestors
+      uint32 :vd_hash    # Hash of the name
+      uint32 :vd_aux     # Where the names start, as an offset from here
+      uint32 :vd_next    # Where the next entry is, as an offset from here
+    end
+
+    # A name an {ELF_Verdef} records, its own or an ancestor's, which the
+    # +vda_next+ of the one before it points at.
+    class ELF_Verdaux < ELFStruct
+      endian :big_and_little
+      uint32 :vda_name # The name, as an offset into the string table
+      uint32 :vda_next # Where the next name is, as an offset from here
+    end
+
     # Note header.
     class ELF_Nhdr < ELFStruct
       endian :big_and_little