ruby-elf 1.0.0

data/lib/elf/symboltable.rb

@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+# Simple ELF parser for Ruby
+#
+# Copyright © 2007-2010 Diego E. "Flameeyes" Pettenò <flameeyes@gmail.com>
+# Portions inspired by elf.py
+#   Copyright © 2002 Netgraft Corporation
+# Portions inspired by elf.h
+#   Copyright © 1995-2006 Free Software Foundation, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this generator; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+require 'set'
+
+module Elf
+  class SymbolTable < Section
+    def load_internal
+      @symbols = []
+      @symbol_names = {}
+      for i in 1..(@numentries)
+        sym = Symbol.new(@file, self, i-1)
+        @symbols << sym
+        @symbol_names[sym.name] = sym.idx
+      end
+
+      return nil
+    end
+
+    # Exception thrown when requesting a symbol that is not in the
+    # table
+    class UnknownSymbol < Exception
+      def initialize(name_or_idx, section)
+        super("Symbol #{name_or_idx} not found in section #{section.name}")
+      end
+    end
+
+    def [](idx)
+      load unless @symbols
+
+      if idx.is_a?(Numeric)
+        raise UnknownSymbol.new(idx, self) unless @symbols[idx] != nil
+        return @symbols[idx]
+      elsif idx.respond_to?("to_s")
+        idx = idx.to_s
+        raise UnknownSymbol.new(idx, self) unless @symbol_names.has_key?(idx)
+        return @symbols[@symbol_names[idx]]
+      else
+        raise TypeError.new("wrong argument type #{sect_idx_or_name.class} (expected String or Integer)")
+      end
+    end
+
+    # Iterate over each symbols, replaces section.symbol.each
+    def each(&block)
+      symbols.each(&block)
+    end
+
+    include ::Enumerable
+
+    # Return the number of symbols in the section
+    def size
+      symbols.size
+    end
+
+    # Get a set with all the symbols in the table that are defined,
+    # ignoring common, absolute and undefined symbols.
+    def defined_symbols
+      symbols.find_all do |sym|
+        sym.defined?
+      end.to_set
+    end
+
+    private
+    def symbols
+      load unless @symbols
+      @symbols
+    end
+  end
+end
+

data/lib/elf/tools.rb

@@ -0,0 +1,228 @@
+# -*- coding: utf-8 -*-
+# Copyright © 2008-2010 Diego E. "Flameeyes" Pettenò <flameeyes@gmail.com>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this generator; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+require 'getoptlong'
+require 'thread'
+require 'elf'
+
+# This file allows to wrap aroudn the most common features of
+# Ruby-Elf based tools, that follow a series of common traits.
+#
+# The tools using this file are tools that inspect a series of ELF
+# files, passed through command line, stdin, or through a file
+# parameter; they accept a series of arguments that may or might not
+# require arguments (in that latter case they are considered on/off
+# switches), and so on.
+
+# Gets the name of the tool
+def self.to_s
+  File.basename($0)
+end
+
+# Output an error message, prefixed with the tool name.
+def self.puterror(string)
+  return if @quiet
+
+  @output_mutex.synchronize {
+    $stderr.puts "#{to_s}: #{string}"
+  }
+end
+
+# Output a notice about a file, do not prefix with the tool name, do
+# not print if doing recursive analysis
+def self.putnotice(message)
+  return if @quiet or @recursive
+
+  @output_mutex.synchronize {
+    $stderr.puts message
+  }
+end
+
+# Parse the arguments for the tool; it does not parse the @file
+# options, since they are only expected to contain file names,
+# rather than options.
+def self.parse_arguments
+  opts = Options + [
+                    ["--help", "-?", GetoptLong::NO_ARGUMENT],
+                    ["--quiet", "-q", GetoptLong::NO_ARGUMENT],
+                    ["--recursive", "-R", GetoptLong::NO_ARGUMENT],
+                   ]
+
+  opts = GetoptLong.new(*opts)
+  opts.each do |opt, arg|
+    if opt == "--help"
+      # check if we're executing from a tarball or the git repository,
+      # if so we can't use the system man page.
+      require 'pathname'
+      filepath = Pathname.new($0)
+      localman = filepath.dirname + "../manpages" + filepath.basename.sub(".rb", ".1")
+      if localman.exist?
+        exec("man #{localman.to_s}")
+      else
+        exec("man #{to_s}")
+      end
+    end
+
+    attrname = opt.gsub(/^--/, "").gsub("-", "_")
+    attrval = arg.size == 0 ? true : arg
+
+    # If there is a function with the same name of the parameter
+    # defined (with a _cb suffix), call that, otherwise set the
+    # attribute with the same name to the given value.
+    cb = method("#{attrname}_cb") rescue nil
+    case
+    when cb.nil?
+      instance_variable_set("@#{attrname}", attrval)
+    when cb.arity == 0
+      raise ArgumentError("wrong number of arguments in callback (0 for 1)") unless
+        arg.size == 0
+      cb.call
+    when cb.arity == 1
+      # fallback to provide a single "true" parameter if there was no
+      # required argument
+      cb.call(attrval)
+    else
+      raise ArgumentError("wrong number of arguments in callback (#{cb.arity} for #{arg.size})")
+    end
+  end
+end
+
+def execute(filename)
+  begin
+    analysis(filename)
+  rescue Errno::ENOENT, Errno::EACCES, Errno::EISDIR, Elf::File::NotAnELF,
+    Elf::File::InvalidElfClass, Elf::File::InvalidDataEncoding,
+    Elf::File::UnsupportedElfVersion, Elf::File::InvalidOsAbi, Elf::File::InvalidElfType,
+    Elf::File::InvalidMachine => e
+    # The Errno exceptions have their message ending in " - FILENAME",
+    # so we take the FILENAME out and just use the one we know
+    # already.  We also take out the final dot on the phrase so that
+    # we follow the output messages from other tools, like cat.
+    putnotice "#{filename}: #{e.message.gsub(/\.? - .*/, '')}"
+  rescue Exception => e
+    puterror "#{filename}: #{e.message} (#{e.class})\n\t#{e.backtrace.join("\n\t")}"
+    exit -1
+  end
+end
+
+# Try to execute the analysis function on a given filename argument.
+def self.try_execute(filename)
+  begin
+    # if the file name starts with '@', it is not a target, but a file
+    # with a list of targets, so load it with execute_on_file.
+    if filename[0..0] == "@"
+      execute_on_file(filename[1..-1])
+      return
+    end
+
+    # find the file type so we don't have to look it up many times; if
+    # we're running a recursive scan, we don't want to look into
+    # symlinks as they might create loops or duplicate content, while
+    # we usually want to check them out if they are given directly in
+    # the list of files to analyse
+    file_stat = if @recursive
+                  File.lstat(filename)
+                else
+                  File.stat(filename)
+                end
+
+    # if the path references a directory, and we're going to run
+    # recursively, descend into that.
+    if @recursive and file_stat.directory?
+      Dir.foreach(filename) do |children|
+        next if children == "." or children == ".."
+        try_execute(File.join(filename, children))
+      end
+    # if the path does not point to a regular file, ignore it
+    elsif not file_stat.file?
+      putnotice "#{filename}: not a regular file"
+    else
+      @execution_threads.add(Thread.new {
+                               execute(filename)
+                             })
+    end
+  rescue Errno::ENOENT, Errno::EACCES, Errno::EISDIR, Elf::File::NotAnELF => e
+    # The Errno exceptions have their message ending in " - FILENAME",
+    # so we take the FILENAME out and just use the one we know
+    # already.  We also take out the final dot on the phrase so that
+    # we follow the output messages from other tools, like cat.
+    putnotice "#{filename}: #{e.message.gsub(/\.? - .*/, '')}"
+  rescue SystemExit => e
+    exit e.status
+  rescue Exception => e
+    puterror "#{filename}: #{e.message} (#{e.class})\n\t#{e.backtrace.join("\n\t")}"
+    exit -1
+  end
+end
+
+# Execute the analysis function on all the elements of an array.
+def self.execute_on_array(array)
+  array.each do |filename|
+    try_execute(filename)
+  end
+end
+
+# Execute the analysis function on all the lines of a file
+def self.execute_on_file(file)
+  @single_target = false
+
+  file = $stdin if file == "-"
+  file = File.new(file) if file.class == String
+
+  file.each_line do |line|
+    try_execute(line.chomp("\n"))
+  end
+end
+
+def self.main
+  begin
+    @output_mutex = Mutex.new
+    @execution_threads = ThreadGroup.new
+
+    before_options if respond_to? :before_options
+    parse_arguments
+    after_options if respond_to? :after_options
+
+    # We set the @single_target attribute to true if we're given a
+    # single filename as a target, so that tools like elfgrep can
+    # avoid printing again the filename on the output. Since we could
+    # be given a single @-prefixed file to use as a list, we'll reset
+    # @single_target in self.execute_on_file
+    @single_target = (ARGV.size == 1)
+
+    if ARGV.size == 0
+      execute_on_file($stdin)
+    else
+      execute_on_array(ARGV)
+    end
+
+    @execution_threads.list.each do |thread|
+      thread.join
+    end
+
+    results if respond_to? :results
+  rescue Interrupt
+    puterror "Interrupted"
+    exit 1
+  end
+end
+
+at_exit do
+  unless $!
+    main
+  end
+end

data/lib/elf/utils/loader.rb

@@ -0,0 +1,112 @@
+# -*- coding: utf-8 -*-
+# Copyright © 2009-2010 Diego E. "Flameeyes" Pettenò <flameeyes@gmail.com>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this generator; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+require 'elf'
+require 'elf/utils/pool'
+
+# This file provides some utilities to deal with the runtime lodader
+# functions. In particular it provides access to the same kind of
+# library search as the loader provides.
+
+module Elf
+  module Utilities
+    @@system_library_path = nil
+
+    # Convenience function to append an array to the list of system
+    # library paths.
+    #
+    # This is just used to avoid repeating the same block of code for
+    # both the data read from /etc/ld.so.conf and from LD_LIBRARY_PATH
+    # environment variable if requested.
+    def self.append_to_library_path(morepaths)
+      morepaths.each do |path|
+        begin
+          # Since we can have symlinks and similar issues, try to
+          # canonicalise the paths so that we can expect them to be
+          # truly unique (and thus never pass through the same directory
+          # twice).
+          @@system_library_path << Pathname.new(path).realpath.to_s
+        rescue Errno::ENOENT, Errno::EACCES
+        end
+      end
+    end
+
+    # Return the system library path to look for libraries, just like
+    # the loader would.
+    def self.system_library_path
+
+      # Try to cache the request since we most likely have multiple
+      # request per process and we don't care if the settings change
+      # between them.
+      if @@system_library_path.nil?
+        @@system_library_path = Array.new
+
+        # We have to put by default /lib and /usr/lib since they are
+        # implicit in all systems. In particular for Gentoo/Linux
+        # these two are not in the list on x86 systems (but are on
+        # amd64).
+        #
+        # Since LD_LIBRARY_PATH would win over this, but we expect
+        # /etc/ld.so.conf not to, add them here.
+        append_to_library_path(["/lib", "/usr/lib"])
+
+        # We might not have the ld.so.conf file, if that's the case
+        # just ignore it.
+        begin
+          # This implements for now the glibc-style loader
+          # configuration; in the future it might be reimplemented to
+          # take into consideration different operating systems.
+          ::File.open("/etc/ld.so.conf") do |ld_so_conf|
+            ld_so_conf.each_line do |line|
+              # Comment lines in the configuration file are prefixed
+              # with the hash character, and the remaining content is
+              # just a single huge list of paths, separated by colon,
+              # comma, space, tabs or newlines.
+              append_to_library_path(line.gsub(/#.*/, '').split(/[:, \t\n]/))
+            end
+          end
+        rescue Errno::ENOENT
+        end
+
+        # Make sure the resulting list is uniq to avoid scanning the
+        # same directory multiple times.
+        @@system_library_path.uniq!
+      end
+      
+      return @@system_library_path
+    end
+
+    # Return the environment library path
+    #
+    # We assume the LD_LIBRARY_PATH variable is not going to change
+    # between calls.
+    #
+    # TODO: systems like Solaris implement further variables like
+    # LD_LIBRARY_PATH_32 and LD_LIBRARY_PATH_64, we should pay
+    # attention to those too.
+    def self.environment_library_path
+      return [] if ENV['LD_LIBRARY_PATH'].nil?
+
+      ENV['LD_LIBRARY_PATH'].split(":").collect do |path|
+        begin
+          Pathname.new(path).realpath.to_s
+        rescue Errno::ENOENT, Errno::EACCES
+        end
+      end.uniq
+    end
+  end
+end

data/lib/elf/utils/pool.rb

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+# Copyright © 2009 Alex Legler <a3li@gentoo.org>
+# Copyright © 2009-2010 Diego E. "Flameeyes" Pettenò <flameeyes@gmail.com>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this generator; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+require 'elf'
+require 'pathname'
+
+module Elf::Utilities
+  # Pool for ELF files.
+  #
+  # This pool is useful for tools that recurse over a tree of
+  # dependencies to avoid creating multiple instances of Elf::File
+  # accessing the same file.
+  class FilePool
+    @pool = Hash.new
+
+    def self.[](file)
+      realfile = Pathname.new(file).realpath
+      
+      @pool[realfile] ||= Elf::File.new(realfile)
+    end
+  end
+end