ony-ruby-elf 1.1.0

data/lib/elf/symboltable.rb

@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+# Simple ELF parser for Ruby
+#
+# Copyright © 2007-2010 Diego Elio Pettenò <flameeyes@flameeyes.eu>
+# 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 count
+      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,259 @@
+# -*- coding: utf-8 -*-
+# Copyright © 2008-2010 Diego Elio Pettenò <flameeyes@flameeyes.eu>
+#
+# 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.
+
+module Elf
+  class Tool
+    def self.inherited(klass)
+      raise Exception.new("Another Tool has been already defined") if @tool_defined
+      @tool_defined = true
+
+      at_exit do
+        unless $!
+          klass.main
+        end
+      end
+    end
+
+    # 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
+
+    def self.after_options
+    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 = GetoptLong.new(*@options)
+      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.
+          manpage = File.expand_path("../../../manpages/#{to_s}.1", __FILE__)
+          manpage = to_s unless File.exist?(manpage)
+          exec("man #{manpage}")
+        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
+
+      @parsed_options = true
+    end
+
+    def self.single_target?
+      raise Exception.new("You can't call this until options are parsed") unless @parsed_options
+
+      # We consider having a single target means that we're given exactly
+      # one argument, and that argument is not a targets' list itself.
+      return @targets.size == 1
+    end
+
+    def self.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
+
+    def self.thread_execute(filename)
+      # If our child set @execution_threads to nil, it doesn't really
+      # support running multithreaded, this is the case for instance
+      # of the link collision harvester script, where the db access
+      # and pkey generation has to be synchronous.
+      unless @execution_threads.nil?
+        @execution_threads.add(Thread.new {
+                                 execute(filename)
+                               })
+      else
+        execute(filename)
+      end
+    end
+
+    # Try to execute the analysis function on a given filename argument.
+    def self.try_execute(filename)
+      begin
+        # 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
+          thread_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(param)
+      param = ::File.new(param) if param.is_a? String
+      param = param.read.split(/\r?\n/) if param.is_a? IO
+
+      param.each do |filename|
+        try_execute(filename)
+      end
+    end
+
+    def self.results
+    end
+
+    def self.initialize
+      @output_mutex = Mutex.new
+      @execution_threads = ThreadGroup.new
+
+      @options = [
+                  ["--help", "-?", GetoptLong::NO_ARGUMENT],
+                  ["--quiet", "-q", GetoptLong::NO_ARGUMENT],
+                  ["--recursive", "-R", GetoptLong::NO_ARGUMENT],
+                 ]
+    end
+
+    def self.main
+      initialize
+
+      begin
+        parse_arguments
+
+        # collect all the arguments passed; if the argument starts
+        # with '@', then open the file and split the lines in further
+        # arguments.
+        @targets = ARGV.collect { |argument|
+          if argument[0..0] == "@"
+            ::File.read(argument[1..-1]).split(/\r?\n/)
+          else
+            argument
+          end
+        }.flatten
+
+        after_options
+
+        # if we have no targets (neither direct arguments, nor added
+        # by #after_options, we readthe targets from stdin.
+        if @targets.empty?
+          $stdin.each_line { |input|
+            try_execute(input.sub(/\r?\n/, ''))
+          }
+        else
+          $stdin.close
+          @targets.uniq.each { |target| try_execute(target) }
+        end
+
+        if @execution_threads
+          @execution_threads.list.each do |thread|
+            thread.join
+          end
+        end
+
+        results
+      rescue Interrupt
+        puterror "Interrupted"
+        exit 1
+      end
+    end
+  end
+end

data/lib/elf/utils/loader.rb

@@ -0,0 +1,112 @@
+# -*- coding: utf-8 -*-
+# Copyright © 2009-2010 Diego Elio Pettenò <flameeyes@flameeyes.eu>
+#
+# 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