ronin 0.1.4 → 0.2.0

data/lib/ronin/{cache → platform}/extension_cache.rb

@@ -21,11 +21,11 @@
 #++
 #
 
-require 'ronin/cache/extension'
-require 'ronin/cache/exceptions/extension_not_found'
+require 'ronin/platform/extension'
+require 'ronin/platform/exceptions/extension_not_found'
 
 module Ronin
-  module Cache
+  module Platform
     class ExtensionCache < Hash
 
       #
@@ -34,11 +34,13 @@ module Ronin
       #
       def initialize(&block)
         super() do |hash,key|
-          hash[name] = load_extension(key.to_s)
+          name = key.to_s
+
+          hash[name] = load_extension(name)
         end
 
         at_exit do
-          each_extension { |ext| ext.perform_teardown }
+          each_extension { |ext| ext.teardown! }
         end
 
         block.call(self) if block
@@ -72,12 +74,12 @@ module Ronin
       def load_extension(name,&block)
         name = name.to_s
 
-        unless Extension.exists?(name)
+        unless Platform.overlays.has_extension?(name)
           raise(ExtensionNotFound,"extension #{name.dump} does not eixst",caller)
         end
 
         return Extension.load(name) do |ext|
-          ext.perform_setup
+          ext.setup!
 
           block.call(ext) if block
         end

data/lib/ronin/{cache → platform}/maintainer.rb

@@ -22,7 +22,7 @@
 #
 
 module Ronin
-  module Cache
+  module Platform
     class Maintainer
 
       # Name of the maintainer

data/lib/ronin/platform/object_cache.rb

@@ -0,0 +1,94 @@
+#
+#--
+# Ronin - A Ruby platform designed for information security and data
+# exploration tasks.
+#
+# Copyright (c) 2006-2009 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/objectify'
+
+module Ronin
+  module Platform
+    module ObjectCache
+      #
+      # Returns all paths within the specified _directory_ pointing
+      # to object files.
+      #
+      def ObjectCache.paths(directory)
+        Dir[File.join(directory,'**','*.rb')]
+      end
+
+      #
+      # Finds all cached objects, passing each to the given _block_.
+      #
+      def ObjectCache.each(directory=nil,&block)
+        attributes = {}
+
+        if directory
+          attributes.merge!(:object_path.like => File.join(directory,'%'))
+        end
+
+        Objectify.object_contexts.each_value do |base|
+          base.all(attributes).each(&block)
+        end
+
+        return true
+      end
+
+      #
+      # Cache all objects loaded from the paths within the specified
+      # _directory_.
+      #
+      def ObjectCache.cache(directory)
+        ObjectCache.paths(directory).each do |path|
+          Objectify.cache_objects(path)
+        end
+
+        return true
+      end
+
+      #
+      # Mirror all objects that were previously cached from paths within
+      # the specified _directory_. Also cache objects which have yet to
+      # be cached.
+      #
+      def ObjectCache.mirror(directory)
+        new_paths = ObjectCache.paths(directory)
+
+        ObjectCache.each(directory) do |obj|
+          new_paths.delete(obj.object_path)
+
+          obj.mirror
+        end
+
+        # cache the remaining new paths
+        new_paths.each { |path| Objectify.cache_objects(path) }
+        return true
+      end
+
+      #
+      # Deletes all cached objects that existed in the specified _directory_.
+      #
+      def ObjectCache.expunge(directory)
+        ObjectCache.each(directory) { |obj| obj.destroy }
+        return true
+      end
+    end
+  end
+end

data/lib/ronin/platform/overlay.rb

@@ -0,0 +1,274 @@
+#
+#--
+# Ronin - A Ruby platform designed for information security and data
+# exploration tasks.
+#
+# Copyright (c) 2006-2009 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/platform/exceptions/extension_not_found'
+require 'ronin/platform/maintainer'
+require 'ronin/platform/extension'
+
+require 'rexml/document'
+require 'repertoire'
+
+module Ronin
+  module Platform
+    class Overlay < Repertoire::Repository
+
+      # Overlay metadata XML file name
+      METADATA_FILE = 'ronin.xml'
+
+      # Overlay lib directory
+      LIB_DIR = 'lib'
+
+      # Overlay objects directory
+      OBJECTS_DIR = 'objects'
+
+      # Local path to the overlay
+      attr_reader :path
+
+      # Name of the overlay
+      attr_reader :name
+
+      # URI that the overlay was installed from
+      attr_reader :uri
+
+      # Title of the overlay
+      attr_reader :title
+
+      # License that the overlay contents is under
+      attr_reader :license
+
+      # Source URI of the overlay
+      attr_reader :source
+
+      # Source View URI of the overlay
+      attr_reader :source_view
+
+      # Website URI for the overlay
+      attr_reader :website
+
+      # Maintainers of the overlay
+      attr_reader :maintainers
+
+      # Description
+      attr_reader :description
+
+      # The objects directory
+      attr_reader :objects_dir
+
+      #
+      # Creates a new Overlay object with the specified _path_, _media_type_
+      # and _uri_.
+      #
+      def initialize(path,media_type=nil,uri=nil,&block)
+        @path = File.expand_path(path)
+        @name = File.basename(@path)
+        @objects_dir = File.join(@path,OBJECTS_DIR)
+        @uri = uri
+
+        super(@path,Repertoire::Media.types[media_type])
+
+        initialize_metadata(&block)
+      end
+
+      #
+      # Media type of the overlay.
+      #
+      def media_type
+        if @media
+          return @media.name
+        else
+          return nil
+        end
+      end
+
+      #
+      # Returns the paths of all extensions within the overlay.
+      #
+      def extension_paths
+        directories.reject do |dir|
+          name = File.basename(dir)
+
+          (name == OBJECTS_DIR) || (name == LIB_DIR)
+        end
+      end
+
+      #
+      # Returns the names of all extensions within the overlay.
+      #
+      def extensions
+        extension_paths.map { |dir| File.basename(dir) }
+      end
+
+      #
+      # Returns +true+ if the overlay contains the extension with the
+      # specified _name_, returns +false+ otherwise.
+      #
+      def has_extension?(name)
+        name = File.basename(name.to_s)
+
+        return false if name == OBJECTS_DIR
+        return File.directory?(File.join(@path,name))
+      end
+
+      #
+      # Returns the <tt>lib/</tt> directories of the extensions within
+      # the overlay.
+      #
+      def lib_dirs
+        dirs = []
+
+        find_directory = lambda { |path|
+          dirs << path if File.directory?(path)
+        }
+
+        find_directory.call(File.join(@path,LIB_DIR))
+
+        extension_paths.each do |path|
+          find_directory.call(File.join(path,Extension::LIB_DIR))
+        end
+
+        return dirs
+      end
+
+      #
+      # Activates the overlay by adding the lib_dirs to the
+      # <tt>$LOAD_PATH</tt>.
+      #
+      def activate!
+        lib_dirs.each do |path|
+          $LOAD_PATH << path unless $LOAD_PATH.include?(path)
+        end
+
+        return true
+      end
+
+      #
+      # Deactivates the overlay by removing the lib_dirs to the
+      # <tt>$LOAD_PATH</tt>.
+      #
+      def deactive!
+        paths = lib_dirs
+
+        $LOAD_PATH.reject! { |path| paths.include?(path) }
+        return true
+      end
+
+      #
+      # Updates the overlay and reloads it's metadata. If a _block_
+      # is given it will be called after the overlay has been updated.
+      #
+      def update(&block)
+        if media_type
+          Repertoire.update(:media => media_type, :path => @path, :uri => @uri)
+        end
+
+        return initialize_metadata(&block)
+      end
+
+      #
+      # Deletes the overlay then removes it from the overlay cache.
+      # If a _block_ is given, it will be passed the overlay after it
+      # has been uninstalled.
+      #
+      def uninstall(&block)
+        Repertoire.delete(@path)
+
+        block.call(self) if block
+        return self
+      end
+
+      #
+      # Returns the +name+ of the Overlay.
+      #
+      def to_s
+        @name.to_s
+      end
+
+      protected
+
+      #
+      # Loads the overlay metadata from the METADATA_FILE within the
+      # overlay +path+. If a _block_ is given, it will be passed the
+      # overlay after the metadata has been loaded.
+      #
+      def initialize_metadata(&block)
+        metadata_path = File.join(@path,METADATA_FILE)
+
+        # set to default values
+        @title = @name
+        @license = nil
+
+        @source = @uri
+        @source_view = @source
+        @website = @source_view
+
+        @maintainers = []
+        @description = nil
+
+        if File.file?(metadata_path)
+          doc = REXML::Document.new(open(metadata_path))
+          overlay = doc.elements['/ronin-overlay']
+
+          overlay.each_element('title[.]:first') do |title|
+            @title = title.text.strip
+          end
+
+          overlay.each_element('license[.]:first') do |license|
+            @license = license.text.strip
+          end
+
+          overlay.each_element('source[.]:first') do |source|
+            @source = source.text.strip
+          end
+
+          overlay.each_element('source-view[.]:first') do |source_view|
+            @source_view = source_view.text.strip
+          end
+
+          overlay.each_element('website[.]:first') do |website|
+            @website = website.text.strip
+          end
+
+          overlay.each_element('maintainers/maintainer') do |maintainer|
+            if (name = maintainer.text('name'))
+              name.strip!
+            end
+
+            if (email = maintainer.text('email'))
+              email.strip!
+            end
+
+            @maintainers << Maintainer.new(name,email)
+          end
+
+          overlay.each_element('description[.]:first') do |description|
+            @description = description.text.strip
+          end
+        end
+
+        block.call(self) if block
+        return self
+      end
+
+    end
+  end
+end

data/lib/ronin/platform/overlay_cache.rb

@@ -0,0 +1,318 @@
+#
+#--
+# Ronin - A Ruby platform designed for information security and data
+# exploration tasks.
+#
+# Copyright (c) 2006-2009 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/platform/exceptions/overlay_cached'
+require 'ronin/platform/exceptions/overlay_not_found'
+require 'ronin/platform/overlay'
+require 'ronin/config'
+
+require 'yaml'
+
+module Ronin
+  module Platform
+    class OverlayCache < Hash
+
+      # Default overlay cache directory
+      CACHE_DIR = File.join(Ronin::Config::PATH,'overlays')
+
+      # Name of the overlay cache file
+      CACHE_FILE = File.join(Ronin::Config::PATH,'overlays.yaml')
+
+      # Path of cache file
+      attr_reader :path
+
+      #
+      # Create a new OverlayCache object with the specified _path_. The
+      # _path_ defaults to <tt>CACHE_FILE</tt>. If a _block_ is given,
+      # it will be passed the newly created OverlayCache object.
+      #
+      def initialize(path=CACHE_FILE,&block)
+        super()
+
+        @path = path
+        @dirty = false
+
+        if File.file?(@path)
+          descriptions = YAML.load(File.read(@path))
+
+          if descriptions.kind_of?(Array)
+            descriptions.each do |overlay|
+              if overlay.kind_of?(Hash)
+                overlay = Overlay.new(
+                  overlay[:path],
+                  overlay[:media],
+                  overlay[:uri]
+                )
+
+                self[overlay.name] = overlay
+              end
+            end
+          end
+        end
+
+        at_exit(&method(:save))
+
+        block.call(self) if block
+      end
+
+      #
+      # Returns +true+ if the overlay cache has been modified, returns
+      # +false+ otherwise.
+      #
+      def dirty?
+        @dirty == true
+      end
+
+      alias names keys
+      alias overlays values
+      alias each_overlay each_value
+
+      #
+      # Returns the Ovlerays which match the specified _block_.
+      #
+      #   cache.with do |overlay|
+      #     overlay.author == 'the dude'
+      #   end
+      #
+      def with(&block)
+        values.select(&block)
+      end
+
+      #
+      # Returns +true+ if the cache contains the Overlay with the
+      # matching _name_, returns +false+ otherwise.
+      #
+      def has?(name)
+        has_key?(name.to_s)
+      end
+
+      #
+      # Returns the Overlay with the matching _name_.
+      #
+      def get(name)
+        name = name.to_s
+
+        unless has?(name)
+          raise(OverlayNotFound,"overlay #{name.dump} is not present in cache #{self.to_s.dump}",caller)
+        end
+
+        return self[name]
+      end
+
+      #
+      # Returns the paths of the Overlays contained in the cache.
+      #
+      def paths
+        overlays.map { |overlay| overlay.path }
+      end
+
+      #
+      # Returns +true+ if the extension with the specified _name_ exists
+      # within any of the overlays in the overlay cache, returns +false+
+      # otherwise.
+      #
+      def has_extension?(name)
+        each_overlay do |overlay|
+          return true if overlay.extensions.include?(name)
+        end
+
+        return false
+      end
+
+      #
+      # Returns the names of all extensions within the overlay cache.
+      #
+      def extensions
+        ext_names = []
+
+        each_overlay do |overlay|
+          overlay.extensions.each do |name|
+            ext_names << name unless ext_names.include?(name)
+          end
+        end
+
+        return ext_names
+      end
+
+      #
+      # Returns the paths of all extensions with the specified _name_.
+      #
+      def extension_paths(name)
+        ext_paths = []
+
+        each_overlay do |overlay|
+          overlay.extension_paths.each do |path|
+            ext_paths << path if File.basename(path) == name
+          end
+        end
+
+        return ext_paths
+      end
+
+      #
+      # Adds the specified _overlay_ with the specified _name_ to the
+      # overlay cache.
+      #
+      def []=(name,overlay)
+        super(name.to_s,overlay)
+
+        overlay.activate!
+        return overlay
+      end
+
+      #
+      # Adds the _overlay_ to the cache. If a _block_ is given, it will
+      # be passed the cache after the _overlay_ is added. The _overlay_
+      # will be returned.
+      #
+      #   cache.add(overlay)
+      #   # => #<Ronin::Platform::Overlay: ...>
+      #
+      #   cache.add(overlay) do |cache|
+      #     puts "Overlay #{overlay} added"
+      #   end
+      #
+      def add(overlay,&block)
+        name = overlay.name.to_s
+
+        if has?(name)
+          raise(OverlayCached,"overlay #{name.dump} already present in the cache #{self.to_s.dump}",caller)
+        end
+
+        self[overlay.name.to_s] = overlay
+        dirty!
+
+        block.call(self) if block
+        return self
+      end
+
+      #
+      # Updates all the cached Overlays. If a _block_ is given it will
+      # be passed the overlays as they are updated.
+      #
+      #   update
+      #   # => #<Ronin::Platform::OverlayCache: ...>
+      #
+      #   update do |overlay|
+      #     puts "#{overaly} is updated"
+      #   end
+      #
+      def update(&block)
+        overlays.each do |overlay|
+          overlay.deactive!
+          overlay.update(&block)
+          overlay.active!
+        end
+
+        return self
+      end
+
+      #
+      # Removes the overlay with the specified _name_ from the cache. If a
+      # _block_ is given, it will be passed the removed overlay. The cache
+      # will be returned, after the overlay is removed.
+      #
+      #   cache.remove('hello_word')
+      #   # => #<Ronin::Platform::Overlay: ...>
+      #
+      #   cache.remove('hello_word') do |overlay|
+      #     puts "Overlay #{overlay} removed"
+      #   end
+      #
+      def remove(name,&block)
+        name = name.to_s
+
+        overlay = get(name)
+        overlay.deactive!
+
+        delete_if { |key,value| key == name }
+        dirty!
+
+        block.call(overlay) if block
+        return self
+      end
+
+      #
+      # Uninstalls the overlay with the specified _name_. If a _block_
+      # is given, it will be passed the uninstalled overlay. The cache
+      # will be returned, after the overlay is removed.
+      #
+      #   cache.uninstall('hello_word')
+      #   # => #<Ronin::Platform::Overlay: ...>
+      #
+      #   cache.uninstall('hello_word') do |overlay|
+      #     puts "Overlay #{overlay} uninstalled"
+      #   end
+      #
+      def uninstall(name,&block)
+        remove do |overlay|
+          overlay.uninstall(&block)
+        end
+      end
+
+      #
+      # Saves the overlay cache.
+      #
+      def save
+        return false unless dirty?
+
+        parent_directory = File.dirname(@path)
+
+        unless File.directory?(parent_directory)
+          FileUtils.mkdir_p(parent_directory)
+        end
+
+        File.open(@path,'w') do |output|
+          descriptions = overlays.map do |overlay|
+            {
+              :path => overlay.path,
+              :media => overlay.media_type,
+              :uri => overlay.uri
+            }
+          end
+
+          YAML.dump(descriptions,output)
+        end
+
+        return true
+      end
+
+      #
+      # Returns the +path+ of the cache.
+      #
+      def to_s
+        @path.to_s
+      end
+
+      protected
+
+      #
+      # Marks the overlay cache as dirty.
+      #
+      def dirty!
+        @dirty = true
+      end
+
+    end
+  end
+end