ronin 0.0.9

data/lib/ronin/config.rb

@@ -0,0 +1,31 @@
+#
+#--
+# Ronin - A Ruby platform designed for information security and data
+# exploration tasks.
+#
+# Copyright (c) 2006-2008 Hal Brodigan (postmodern.mod3 at 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 program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#++
+#
+
+require 'fileutils'
+
+module Ronin
+  module Config
+    # Ronin home directory
+    PATH = FileUtils.mkdir_p(File.join(ENV['HOME'],'.ronin'))
+  end
+end

data/lib/ronin/console.rb

@@ -0,0 +1,127 @@
+#
+#--
+# Ronin - A Ruby platform designed for information security and data
+# exploration tasks.
+#
+# Copyright (c) 2006-2008 Hal Brodigan (postmodern.mod3 at 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 program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#++
+#
+
+require 'ronin/config'
+
+require 'irb'
+require 'irb/completion'
+
+module Ronin
+  module Console
+    #
+    # Returns the default Console prompt style
+    #
+    def Console.prompt
+      @@console_prompt ||= :SIMPLE
+    end
+
+    #
+    # Sets the default Console prompt style to the specified _style_.
+    #
+    def Console.prompt=(style)
+      @@console_prompt = style
+    end
+
+    #
+    # Returns the default Console indent setting.
+    #
+    def Console.indent
+      @@console_indent ||= true
+    end
+
+    #
+    # Sets the default Console indent setting.
+    #
+    def Console.indent=(value)
+      @@console_indent = value
+    end
+
+    #
+    # Returns the Array of files to require when the Console starts.
+    #
+    def Console.auto_load
+      @@console_auto_load ||= []
+    end
+
+    #
+    # Calls the specified _block_ from within the Console after it is
+    # started.
+    #
+    def Console.setup(&block)
+      Console.setup_blocks << block if block
+    end
+
+    #
+    # Starts a Console with the given _script_. If a _block_ is given, it
+    # will be called from within the Console.
+    #
+    def Console.start(script=nil,&block)
+      IRB.setup(script)
+
+      IRB.conf[:IRB_NAME] = 'ronin'
+      IRB.conf[:PROMPT_MODE] = Console.prompt
+      IRB.conf[:AUTO_INDENT] = Console.indent
+      IRB.conf[:LOAD_MODULES] = Console.auto_load
+
+      irb = IRB::Irb.new(nil,script)
+
+      # configure the irb workspace
+      irb.context.main.instance_eval do
+        require 'ronin'
+        require 'pp'
+
+        include Ronin
+      end
+
+      Console.setup_blocks.each do |setup_block|
+        irb.context.main.instance_eval(&setup_block)
+      end
+
+      # Load console configuration block is given
+      irb.context.main.instance_eval(&block) if block
+
+      IRB.conf[:MAIN_CONTEXT] = irb.context
+
+      trap('SIGINT') do
+        irb.signal_handle
+      end
+
+      catch(:IRB_EXIT) do
+        irb.eval_input
+      end
+
+      print "\n"
+      return nil
+    end
+
+    protected
+
+    #
+    # Returns the Array of setup_blocks to run within the Console after it
+    # is started.
+    #
+    def Console.setup_blocks
+      @@console_setup_blocks ||= []
+    end
+  end
+end

data/lib/ronin/context.rb

@@ -0,0 +1,233 @@
+#
+#--
+# Ronin - A Ruby platform designed for information security and data
+# exploration tasks.
+#
+# Copyright (c) 2006-2008 Hal Brodigan (postmodern.mod3 at 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 program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#++
+#
+
+require 'ronin/exceptions/unknown_context'
+require 'ronin/exceptions/context_not_found'
+require 'ronin/pending_context'
+require 'ronin/extensions/meta'
+
+module Ronin
+  module Context
+    def self.included(base)
+      base.metaclass_def(:contextify) do |name|
+        Context.contexts[name.to_sym] = self
+
+        meta_def(:context_name) { name }
+
+        class_def(:context_name) { name }
+
+        meta_def(:load_context) do |path,*args|
+          Context.load_context(path,self.context_name,*args)
+        end
+
+        # define the top-level context wrappers
+        Kernel.module_eval %{
+          def ronin_#{name}(*args,&block)
+            if (args.empty? && Ronin::Context.is_pending?)
+              Ronin::Context.pending.blocks[:#{name}] = block
+              return nil
+            else
+              new_context = #{self}.new(*args)
+              new_context.instance_eval(&block) if block
+              return new_context
+            end
+          end
+        }
+
+        # define the Ronin-level context loader
+        Ronin.module_eval %{
+          def ronin_load_#{name}(path,*args,&block)
+            new_context = #{self}.load_context(path,*args)
+
+            block.call(new_context) if block
+            return new_context
+          end
+        }
+      end
+    end
+
+    #
+    # Returns a Hash of all defined contexts.
+    #
+    def Context.contexts
+      @@ronin_contexts ||= {}
+    end
+
+    #
+    # Returns +true+ if there is a context defined with the specified
+    # _name_, returns +false+ otherwise.
+    #
+    def Context.is_context?(name)
+      Context.contexts.has_key?(name.to_sym)
+    end
+
+    #
+    # Converts the name of the _base_ class to a context name, returning
+    # it in +String+ form.
+    #
+    #   Context.namify(Ronin::Resources) # => "ronin_resources"
+    #
+    #   Context.namify(Analysis::Audio) # => "ronin_analysis_audio"
+    #
+    def Context.namify(base)
+      # similar to the way Og tableizes Class names
+      base.to_s.downcase.gsub(/::/,'_').gsub(/^ronin_/,'').to_sym
+    end
+
+    #
+    # Returns the Array of contexts which are waiting to be loaded.
+    #
+    def Context.waiting
+      @@ronin_waiting_contexts ||= []
+    end
+
+    #
+    # Returns the pending context being loaded.
+    #
+    def Context.pending
+      Context.waiting.first
+    end
+
+    #
+    # Returns +true+ if there is a pending context present, returns
+    # +false+ otherwise.
+    #
+    def Context.is_pending?
+      !(Context.waiting.empty?)
+    end
+
+    #
+    # Returns the first pending context with the specified _path_.
+    #
+    def Context.loading(path)
+      Context.waiting.each do |pending|
+        if pending.path == path
+          return pending
+        end
+      end
+
+      return nil
+    end
+
+    #
+    # Returns +true+ if the pending context with the specified _path_
+    # is present, returns +false+ otherwise.
+    #
+    def Context.is_loading?(path)
+      !(Context.loading(path).nil?)
+    end
+
+    #
+    # Loads all context blocks from the specified _path_, returning a
+    # PendingContext object containing the context blocks.
+    #
+    def Context.load_blocks(path,&block)
+      path = File.expand_path(path)
+
+      unless File.file?(path)
+        raise(ContextNotFound,"context #{path.dump} doest not exist",caller)
+      end
+
+      # prevent circular loading of contexts
+      unless Context.is_pending?
+        # push on the new pending context
+        Context.waiting.unshift(PendingContext.new(path))
+
+        load(path)
+      end
+
+      # pop off and return the pending context
+      pending_context = Context.waiting.shift
+
+      block.call(pending_context) if block
+      return pending_context
+    end
+
+    #
+    # Loads the context block of the specified _name_ from the specified
+    # _path_, returning the context block. If a _block_ is given it will
+    # be passed the loaded context block.
+    #
+    #   Context.load_block('/path/to/my_exploit.rb',:exploit) # => Proc
+    #
+    #   Context.load_block('/path/to/my_shellcode.rb',:shellcode)
+    #     do |block|
+    #     ...
+    #   end
+    #
+    def Context.load_block(name,path,&block)
+      context_block = Context.load_blocks(path).blocks[name.to_sym]
+
+      block.call(context_block) if block
+      return context_block
+    end
+
+    #
+    # Loads the context of the specified _name_ and from the specified
+    # _path_ with the given _args_. If no contexts were defined with the
+    # specified _name_, an UnknownContext exception will be raised.
+    #
+    #   Context.load_context(:note,'/path/to/my_notes.rb') # => Note
+    #
+    def Context.load_context(name,path,*args)
+      name = name.to_sym
+
+      unless Context.is_context?(name)
+        raise(UnknownContext,"unknown context '#{name}'",caller)
+      end
+
+      new_context = Context.contexts[name].new(*args)
+
+      Context.load_block(name,path) do |context_block|
+        new_context.instance_eval(&context_block) if context_block
+      end
+
+      return new_context
+    end
+
+    #
+    # Loads all contexts from the specified _path_ returning an +Array+
+    # of loaded contexts. If a _block_ is given, it will be passed
+    # each loaded context.
+    #
+    #   Context.load_contexts('/path/to/misc_contexts.rb') # => [...]
+    #
+    def Context.load_contexts(path,&block)
+      new_objs = []
+
+      Context.load_blocks(path) do |pending|
+        pending.blocks.each do |name,context_block|
+          if Context.is_context?(name)
+            new_obj = Context.contexts[name].new
+            new_obj.instance_eval(&context_block)
+
+            new_objs << new_obj
+          end
+        end
+      end
+
+      new_objs.each(&block) if block
+      return new_objs
+    end
+  end
+end

data/lib/ronin/database.rb

@@ -0,0 +1,122 @@
+#
+#--
+# Ronin - A Ruby platform designed for information security and data
+# exploration tasks.
+#
+# Copyright (c) 2006-2008 Hal Brodigan (postmodern.mod3 at 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 program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#++
+#
+
+require 'ronin/exceptions/invalid_database_config'
+require 'ronin/extensions/kernel'
+require 'ronin/config'
+
+require 'yaml'
+require 'dm-core'
+
+module Ronin
+  module Database
+    # Database configuration file
+    CONFIG_FILE = File.join(Config::PATH,'database.yml')
+
+    # Database log file
+    DEFAULT_LOG_PATH = File.join(Config::PATH,'database.log')
+
+    # Database log level
+    DEFAULT_LOG_LEVEL = :info
+
+    # Default configuration of the database
+    DEFAULT_CONFIG = {
+      :adapter => :sqlite3,
+      :database => File.join(Config::PATH,'ronin.db')
+    }
+
+    #
+    # Returns the Database configuration that is stored in the
+    # +CONFIG_FILE+. Defaults to +DEFAULT_CONFIG+ if +CONFIG_FILE+ does not
+    # exist.
+    #
+    def Database.config
+      unless (class_variable_defined?('@@ronin_database_config'))
+        @@ronin_database_config = DEFAULT_CONFIG
+
+        if File.file?(CONFIG_FILE)
+          conf = YAML.load(CONFIG_FILE)
+
+          unless (conf.kind_of?(Hash) || conf.kind_of?(String))
+            raise(InvalidDatabaseConfig,"#{CONFIG_FILE} must contain either a Hash or a String",caller)
+          end
+
+          @@ronin_database_config = conf
+        end
+      end
+
+      return @@ronin_database_config ||= DEFAULT_CONFIG
+    end
+
+    #
+    # Sets the Database configuration to the specified _configuration_.
+    #
+    def Database.config=(configuration)
+      @@ronin_database_config = configuration
+    end
+
+    #
+    # Setup the Database log with the given _options_.
+    #
+    # _options_ may contain the following keys:
+    # <tt>:path</tt>:: The path of the log file. Defaults to
+    #                  +DEFAULT_LOG_PATH+.
+    # <tt>:stream</tt>:: The stream to use for the log.
+    # <tt>:level</tt>:: The level of messages to log.
+    #
+    def Database.setup_log(options={})
+      path = (options[:path] || DEFAULT_LOG_PATH)
+      stream = (options[:stream] || File.new(path,'w+'))
+      level = (options[:level] || DEFAULT_LOG_LEVEL)
+
+      DataMapper::Logger.new(stream,level)
+      return nil
+    end
+
+    #
+    # Sets up the Database with the given _configuration_. If
+    # _configuration is not given, +DEFAULT_CONFIG+ will be used to setup
+    # the Database.
+    #
+    def Database.setup(configuration=Database.config,&block)
+      Database.setup_log
+      DataMapper.setup(:default, configuration)
+
+      block.call if block
+
+      # sourced from http://gist.github.com/3010
+      # in order to fix a has-many lazy-loading bug
+      # in dm-core <= 0.9.4
+      descendants = DataMapper::Resource.descendants.dup
+      descendants.each do |model|
+        descendants.merge(model.descendants) if model.respond_to?(:descendants)
+      end
+      descendants.each do |model|
+        model.relationships.each_value { |r| r.child_key if r.child_model == model }
+      end
+
+      DataMapper.auto_upgrade!
+      return nil
+    end
+  end
+end