elftools 0.1.0

data/lib/elftools/sections/sym_tab_section.rb

@@ -0,0 +1,123 @@
+require 'elftools/sections/section'
+
+module ELFTools
+  module Sections
+    # Class of symbol table section.
+    # Usually for section .symtab and .dynsym,
+    # which will refer to symbols in ELF file.
+    class SymTabSection < Section
+      # Instantiate a {SymTabSection} object.
+      # There's a +section_at+ lambda for {SymTabSection}
+      # to easily fetch other sections.
+      # @param [ELFTools::ELF_Shdr] header
+      #   See {Section#initialize} for more information.
+      # @param [File] 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}.
+      def initialize(header, stream, section_at: nil, **_kwagrs)
+        @section_at = section_at
+        # For faster #symbol_by_name
+        @symbol_name_map = {}
+        super
+      end
+
+      # Number of symbols.
+      # @return [Integer] The number.
+      # @example
+      #   symtab.num_symbols
+      #   #=> 75
+      def num_symbols
+        header.sh_size / header.sh_entsize
+      end
+
+      # Acquire the +n+-th symbol, 0-based.
+      #
+      # Symbols are lazy loaded.
+      # @param [Integer] n The index.
+      # @return [ELFTools:Symbol, NilClass]
+      #   The target symbol.
+      #   If +n+ is out of bound, +nil+ is returned.
+      def symbol_at(n)
+        @symbols ||= LazyArray.new(num_symbols, &method(:create_symbol))
+        @symbols[n]
+      end
+
+      # Iterate all symbols.
+      #
+      # All symbols are lazy loading, the symbol
+      # only be created whenever accessing it.
+      # This method is useful for {#symbol_by_name}
+      # since not all symbols need to be created.
+      # @param [Block] block
+      #   Just like +Array#each+, you can give a block.
+      # @return [Array<ELFTools::symbol>]
+      #   The whole symbols will be returned.
+      def each_symbols
+        Array.new(num_symbols) do |i|
+          sym = symbol_at(i)
+          block_given? ? yield(sym) : sym
+        end
+      end
+
+      alias symbols each_symbols
+
+      # Get symbol by it's name.
+      # @param [String] name
+      #   The name of symbol.
+      # @return [ELFTools::Symbol] Desired symbol.
+      def symbol_by_name(name)
+        return @symbol_name_map[name] if @symbol_name_map[name]
+        each_symbols do |symbol|
+          @symbol_name_map[symbol.name] = symbol
+          return symbol if symbol.name == name
+        end
+        nil
+      end
+
+      # Return the symbol string section.
+      # Lazy loaded.
+      # @return [ELFTools::Sections::StrTabSection] The string table section.
+      def symstr
+        @symstr ||= @section_at.call(header.sh_link)
+      end
+
+      private
+
+      def create_symbol(n)
+        stream.pos = header.sh_offset + n * header.sh_entsize
+        sym = ELF_sym[header.elf_class].new(endian: header.class.self_endian)
+        sym.read(stream)
+        Symbol.new(sym, stream, symstr: method(:symstr))
+      end
+    end
+
+    # Class of symbol.
+    # XXX: Should this class be defined in an independent file?
+    class Symbol
+      attr_reader :header # @return [ELFTools::ELF32_sym, ELFTools::ELF64_sym] Section header.
+      attr_reader :stream # @return [File] Streaming object.
+
+      # Instantiate a {ELFTools::Symbol} object.
+      # @param [ELFTools::ELF32_sym, ELFTools::ELF64_sym] header
+      #   The symbol header.
+      # @param [File] stream The streaming object.
+      # @param [ELFTools::Sections::StrTabSection, Proc] symstr
+      #   The symbol string section.
+      #   If +Proc+ is given, it will be called at the first time
+      #   access {Symbol#name}.
+      def initialize(header, stream, symstr: nil)
+        @header = header
+        @stream = stream
+        @symstr = symstr
+      end
+
+      # Return the symbol name.
+      # @return [String] The name.
+      def name
+        @name ||= @symstr.call.name_at(header.st_name)
+      end
+    end
+  end
+end

data/lib/elftools/segments/dynamic_segment.rb

@@ -0,0 +1,18 @@
+require 'elftools/segments/segment'
+require 'elftools/dynamic'
+
+module ELFTools
+  module Segments
+    # Class for dynamic table segment.
+    #
+    # This class knows how to get the list of dynamic tags.
+    class DynamicSegment < Segment
+      include Dynamic # rock!
+      # Get the start address of tags.
+      # @return [Integer] Start address of tags.
+      def tag_start
+        header.p_offset
+      end
+    end
+  end
+end

data/lib/elftools/segments/interp_segment.rb

@@ -0,0 +1,18 @@
+require 'elftools/segments/segment'
+
+module ELFTools
+  module Segments
+    # For DT_INTERP segment, knows how to get path of
+    # ELF interpreter.
+    class InterpSegment < Segment
+      # Get the path of interpreter.
+      # @return [String] Path to the interpreter.
+      # @example
+      #   interp_segment.interp_name
+      #   #=> '/lib64/ld-linux-x86-64.so.2'
+      def interp_name
+        data[0..-2] # remove last null byte
+      end
+    end
+  end
+end

data/lib/elftools/segments/note_segment.rb

@@ -0,0 +1,24 @@
+require 'elftools/note'
+require 'elftools/segments/segment'
+
+module ELFTools
+  module Segments
+    # Class of note segment.
+    class NoteSegment < Segment
+      # Load note related methods.
+      include ELFTools::Note
+
+      # Address offset of notes start.
+      # @return [Integer] The offset.
+      def note_start
+        header.p_offset
+      end
+
+      # The total size of notes in this segment.
+      # @return [Integer] The size.
+      def note_total_size
+        header.p_filesz
+      end
+    end
+  end
+end

data/lib/elftools/segments/segment.rb

@@ -0,0 +1,44 @@
+module ELFTools
+  module Segments
+    # Base class of segments.
+    class Segment
+      attr_reader :header # @return [ELFTools::ELF32_Phdr, ELFTools::ELF64_Phdr] Program header.
+      attr_reader :stream # @return [File] Streaming object.
+
+      # Instantiate a {Segment} object.
+      # @param [ELFTools::ELF32_Phdr, ELFTools::ELF64_Phdr] header
+      #   Program header.
+      # @param [File] stream
+      #   Streaming object.
+      def initialize(header, stream)
+        @header = header
+        @stream = stream
+      end
+
+      # The content in this segment.
+      # @return [String] The content.
+      def data
+        stream.pos = header.p_offset
+        stream.read(header.p_filesz)
+      end
+
+      # Is this segment readable?
+      # @return [Boolean] Ture or false.
+      def readable?
+        (header.p_flags & 4) == 4
+      end
+
+      # Is this segment writable?
+      # @return [Boolean] Ture or false.
+      def writable?
+        (header.p_flags & 2) == 2
+      end
+
+      # Is this segment executable?
+      # @return [Boolean] Ture or false.
+      def executable?
+        (header.p_flags & 1) == 1
+      end
+    end
+  end
+end

data/lib/elftools/segments/segments.rb

@@ -0,0 +1,30 @@
+# Require this file to load all segment classes.
+
+require 'elftools/segments/segment'
+
+require 'elftools/segments/dynamic_segment'
+require 'elftools/segments/interp_segment'
+require 'elftools/segments/note_segment'
+
+module ELFTools
+  # Module for defining different types of segments.
+  module Segments
+    # Class methods of {Segments::Segment}.
+    class << Segment
+      # Use different class according to +header.p_type+.
+      # @param [ELFTools::ELF32_Phdr, ELFTools::ELF64_Phdr] header Program header of a segment.
+      # @param [File] stream Streaming object.
+      # @return [ELFTools::Segments::Segment]
+      #   Return object dependes on +header.p_type+.
+      def create(header, stream, *args)
+        klass = case header.p_type
+                when Constants::PT_DYNAMIC then DynamicSegment
+                when Constants::PT_INTERP then InterpSegment
+                when Constants::PT_NOTE then NoteSegment
+                else Segment
+                end
+        klass.new(header, stream, *args)
+      end
+    end
+  end
+end

data/lib/elftools/structures.rb

@@ -0,0 +1,133 @@
+require 'bindata'
+module ELFTools
+  # The base structure to define common methods.
+  class ELFStruct < BinData::Record
+    CHOICE_SIZE_T = {
+      selection: :elf_class, choices: { 32 => :uint32, 64 => :uint64 }
+    }.freeze
+
+    attr_accessor :elf_class # @return [Integer] 32 or 64.
+
+    # Hacking to get endian of current class
+    # @return [Symbol, NilClass] +:little+ or +:big+.
+    def self.self_endian
+      bindata_name[-2..-1] == 'ge' ? :big : :little
+    end
+  end
+
+  # ELF header structure.
+  class ELF_Ehdr < ELFStruct
+    endian :big_and_little
+    struct :e_ident do
+      string :magic, read_length: 4
+      int8 :ei_class
+      int8 :ei_data
+      int8 :ei_version
+      int8 :ei_osabi
+      int8 :ei_abiversion
+      string :ei_padding, read_length: 7 # no use
+    end
+    uint16 :e_type
+    uint16 :e_machine
+    uint32 :e_version
+    # entry point
+    choice :e_entry, **CHOICE_SIZE_T
+    choice :e_phoff, **CHOICE_SIZE_T
+    choice :e_shoff, **CHOICE_SIZE_T
+    uint32 :e_flags
+    uint16 :e_ehsize # size of this header
+    uint16 :e_phentsize # size of each segment
+    uint16 :e_phnum # number of segments
+    uint16 :e_shentsize # size of each section
+    uint16 :e_shnum # number of sections
+    uint16 :e_shstrndx # index of string table section
+  end
+
+  # Section header structure.
+  class ELF_Shdr < ELFStruct
+    endian :big_and_little
+    uint32 :sh_name
+    uint32 :sh_type
+    choice :sh_flags, **CHOICE_SIZE_T
+    choice :sh_addr, **CHOICE_SIZE_T
+    choice :sh_offset, **CHOICE_SIZE_T
+    choice :sh_size, **CHOICE_SIZE_T
+    uint32 :sh_link
+    uint32 :sh_info
+    choice :sh_addralign, **CHOICE_SIZE_T
+    choice :sh_entsize, **CHOICE_SIZE_T
+  end
+
+  # Program header structure for 32bit.
+  class ELF32_Phdr < ELFStruct
+    endian :big_and_little
+    uint32 :p_type
+    uint32 :p_offset
+    uint32 :p_vaddr
+    uint32 :p_paddr
+    uint32 :p_filesz
+    uint32 :p_memsz
+    uint32 :p_flags
+    uint32 :p_align
+  end
+
+  # Program header structure for 64bit.
+  class ELF64_Phdr < ELFStruct
+    endian :big_and_little
+    uint32 :p_type
+    uint32 :p_flags
+    uint64 :p_offset
+    uint64 :p_vaddr
+    uint64 :p_paddr
+    uint64 :p_filesz
+    uint64 :p_memsz
+    uint64 :p_align
+  end
+  ELF_Phdr = {
+    32 => ELF32_Phdr,
+    64 => ELF64_Phdr
+  }.freeze
+
+  # Symbol structure for 32bit.
+  class ELF32_sym < ELFStruct
+    endian :big_and_little
+    uint32 :st_name
+    uint32 :st_value
+    uint32 :st_size
+    uint8 :st_info
+    uint8 :st_other
+    uint16 :st_shndx
+  end
+
+  # Symbol structure for 64bit.
+  class ELF64_sym < ELFStruct
+    endian :big_and_little
+    uint32 :st_name  # Symbol name, index in string tbl
+    uint8 :st_info   # Type and binding attributes
+    uint8 :st_other  # No defined meaning, 0
+    uint16 :st_shndx # Associated section index
+    uint64 :st_value # Value of the symbol
+    uint64 :st_size  # Associated symbol size
+  end
+  ELF_sym = {
+    32 => ELF32_sym,
+    64 => ELF64_sym
+  }.freeze
+
+  # Note header.
+  class ELF_Nhdr < ELFStruct
+    endian :big_and_little
+    uint32 :n_namesz # Name size
+    uint32 :n_descsz # Content size
+    uint32 :n_type   # Content type
+  end
+
+  # Dynamic tag header.
+  class ELF_Dyn < ELFStruct
+    endian :big_and_little
+    choice :d_tag, selection: :elf_class, choices: { 32 => :int32, 64 => :int64 }
+    # This is an union type named +d_un+ in original source,
+    # simplify it to be +d_val+ here.
+    choice :d_val, **CHOICE_SIZE_T
+  end
+end

data/lib/elftools/util.rb

@@ -0,0 +1,51 @@
+module ELFTools
+  # Define some util methods.
+  module Util
+    # Class methods.
+    module ClassMethods
+      # Round up the number to be mulitple of
+      # +2**bit+.
+      # @param [Integer] num Number to be rounded-up.
+      # @param [Integer] bit How many bit to be aligned.
+      # @return [Integer] See examples.
+      # @example
+      #   align(10, 1) #=> 10
+      #   align(10, 2) #=> 12
+      #   align(10, 3) #=> 16
+      #   align(10, 4) #=> 16
+      #   align(10, 5) #=> 32
+      def align(num, bit)
+        n = 2**bit
+        return num if (num % n).zero?
+        (num + n) & ~(n - 1)
+      end
+
+      # Fetch the correct value from module +mod+.
+      #
+      # See {ELFTools::ELFFile#segment_by_type} for how to
+      # use this method.
+      # @param [Module] mod The module defined constant numbers.
+      # @param [Integer, Symbol, String] val
+      #   Desired value.
+      # @return [Integer]
+      #   Currently this method always return a value
+      #   from {ELFTools::Constants}.
+      def to_constant(mod, val)
+        # Ignore the outest name.
+        module_name = mod.name.sub('ELFTools::', '')
+        # if val is an integer, check if exists in mod
+        if val.is_a?(Integer)
+          return val if mod.constants.any? { |c| mod.const_get(c) == val }
+          raise ArgumentError, "No constants in #{module_name} is #{val}"
+        end
+        val = val.to_s.upcase
+        prefix = module_name.split('::')[-1]
+        val = prefix + '_' + val unless val.start_with?(prefix)
+        val = val.to_sym
+        raise ArgumentError, "No constants in #{module_name} named \"#{val}\"" unless mod.const_defined?(val)
+        mod.const_get(val)
+      end
+    end
+    extend ClassMethods
+  end
+end

data/lib/elftools/version.rb

@@ -0,0 +1,3 @@
+module ELFTools
+  VERSION = '0.1.0'.freeze
+end

data/lib/elftools.rb

@@ -0,0 +1,9 @@
+require 'elftools/constants'
+require 'elftools/elf_file'
+require 'elftools/version'
+
+# The ELF parsing tools!
+# Main entry point is {ELFTools::ELFFile}, see it
+# for more information.
+module ELFTools
+end

metadata

@@ -0,0 +1,153 @@
+--- !ruby/object:Gem::Specification
+name: elftools
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- david942j
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-03-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bindata
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.47'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.47'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.13.0
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+description: |2
+    A light weight ELF parser. elftools is designed to be a low-level ELF parser.
+    Inspired by https://github.com/eliben/pyelftools.
+email:
+- david942j@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/elftools.rb
+- lib/elftools/constants.rb
+- lib/elftools/dynamic.rb
+- lib/elftools/elf_file.rb
+- lib/elftools/exceptions.rb
+- lib/elftools/lazy_array.rb
+- lib/elftools/note.rb
+- lib/elftools/sections/dynamic_section.rb
+- lib/elftools/sections/note_section.rb
+- lib/elftools/sections/null_section.rb
+- lib/elftools/sections/section.rb
+- lib/elftools/sections/sections.rb
+- lib/elftools/sections/str_tab_section.rb
+- lib/elftools/sections/sym_tab_section.rb
+- lib/elftools/segments/dynamic_segment.rb
+- lib/elftools/segments/interp_segment.rb
+- lib/elftools/segments/note_segment.rb
+- lib/elftools/segments/segment.rb
+- lib/elftools/segments/segments.rb
+- lib/elftools/structures.rb
+- lib/elftools/util.rb
+- lib/elftools/version.rb
+homepage: https://github.com/david942j/rbelftools
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.10
+signing_key: 
+specification_version: 4
+summary: ELFTools - Pure ruby library for parsing ELF files
+test_files: []