ronin 0.1.1 → 0.1.2

data/lib/ronin/chars/chars.rb

@@ -52,9 +52,6 @@ module Ronin
     # The alpha-numeric character set
     ALPHA_NUMERIC = ALPHA + NUMERIC
 
-    # The space character set
-    SPACE = CharSet.new(' ', "\f", "\n", "\r", "\t", "\v")
-
     # The punctuation character set
     PUNCTUATION = CharSet.new(' ', '\'', '"', '`', ',', ';', ':', '~', '-',
                               '(', ')', '[', ']', '{', '}', '.', '?', '!')
@@ -63,6 +60,12 @@ module Ronin
     SYMBOLS = PUNCTUATION + ['@', '#', '$', '%', '^', '&', '*', '_', '+',
                              '=', '|', '\\', '<', '>', '/']
 
+    # The space character set
+    SPACE = CharSet.new(' ', "\f", "\n", "\r", "\t", "\v")
+
+    # The set of printable characters (including spaces)
+    PRINTABLE = ALPHA_NUMERIC + PUNCTUATION + SYMBOLS + SPACE
+
     # The control-char character set
     CONTROL = CharSet.new(0..0x1f, 0x7f)
 
@@ -135,13 +138,6 @@ module Ronin
       ALPHA_NUMERIC
     end
 
-    #
-    # The space character set.
-    #
-    def Chars.space
-      SPACE
-    end
-
     #
     # The punctuation character set.
     #
@@ -156,6 +152,20 @@ module Ronin
       SYMBOLS
     end
 
+    #
+    # The space character set.
+    #
+    def Chars.space
+      SPACE
+    end
+
+    #
+    # The set of printable characters, including spaces.
+    #
+    def Chars.printable
+      PRINTABLE
+    end
+
     #
     # The control-char character set.
     #

data/lib/ronin/{parameters/param.rb → code/emittable.rb}

@@ -22,24 +22,42 @@
 #
 
 module Ronin
-  module Parameters
-    class Param
+  module Code
+    module Emittable
+      #
+      # Default emit method which simply returns +nil+.
+      #
+      def emit
+        []
+      end
 
-      # Name of parameter
-      attr_reader :name
+      protected
 
-      # Description of parameter
-      attr_reader :description
+      #
+      # Emits a Token with the specified _name_.
+      #
+      def emit_token(name)
+        [Token.new(name)]
+      end
 
       #
-      # Creates a new Param object with the specified _name_ and the given
-      # _description_.
+      # Emits the specified _value_ if _value_ is an Emittable object,
+      # otherwise _value_ will be returned.
       #
-      def initialize(name,description='')
-        @name = name.to_sym
-        @description = description
+      def emit_value(value)
+        if value.kind_of?(Emittable)
+          return value.emit
+        else
+          return [value]
+        end
       end
 
+      #
+      # Emits each of the specified _valueis_.
+      #
+      def emit_values(values)
+        values.inject([]) { |tokens,value| tokens + emit_value(value) }
+      end
     end
   end
 end

data/lib/ronin/code/symbol_table.rb

@@ -52,6 +52,19 @@ module Ronin
         @table[name.to_s]
       end
 
+      #
+      # Returns a Hash of the symbol names and their values.
+      #
+      def symbols
+        hash = {}
+
+        @table.each do |name,symbol|
+          hash[name] = symbol.value
+        end
+
+        return hash
+      end
+
       #
       # Sets the symbol values en-mass using the specified _hash_ of
       # symbol names and their values.

data/lib/ronin/{parameters/class_param.rb → code/token.rb}

@@ -21,25 +21,52 @@
 #++
 #
 
-require 'ronin/parameters/param'
+require 'ronin/code/emittable'
 
 module Ronin
-  module Parameters
-    class ClassParam < Param
+  module Code
+    class Token
+      
+      include Emittable
 
-      # Default value of the class parameter
-      attr_accessor :value
+      # Value of the token
+      attr_reader :value
 
       #
-      # Creates a new ClassParam object with the specified _name_,
-      # given _description_ and _value_.
+      # Creates a new Token object with the specified _value_.
       #
-      def initialize(name,description='',value=nil)
-        super(name,description)
-
+      def initialize(value)
         @value = value
       end
 
+      #
+      # Emits the token.
+      #
+      def emit
+        [self]
+      end
+
+      #
+      # Returns +true+ if the token has the same value as the specified
+      # _other_ token, returns +false+ otherwise.
+      #
+      def ==(other)
+        self.value == other.value
+      end
+
+      #
+      # Inspects the token.
+      #
+      def inspect
+        "#<Token:#{@value.inspect}>"
+      end
+
+      #
+      # Returns the String form of the token.
+      #
+      def to_s
+        @value.to_s
+      end
     end
   end
 end

data/lib/ronin/config.rb

@@ -27,5 +27,38 @@ module Ronin
   module Config
     # Ronin home directory
     PATH = FileUtils.mkdir_p(File.join(ENV['HOME'],'.ronin'))
+
+    # Path to static directory
+    STATIC_DIR = File.expand_path(File.join(File.dirname(__FILE__),'..','..','static'))
+
+    # Main configuration file
+    CONFIG_PATH = File.expand_path(File.join(PATH,'config.rb'))
+
+    # Configuration files directory
+    CONFIG_DIR = File.expand_path(File.join(PATH,'config'))
+
+    # Temporary file directory
+    TMP_DIR = FileUtils.mkdir_p(File.join(PATH,'tmp'))
+
+    #
+    # Require the Ronin configuration file with the given _name_ in the
+    # Ronin configuration files directory. If _name_ is not given, than the
+    # main Ronin configuration file will be loaded.
+    #
+    #   # Load the main config file at <tt>~/.ronin/config.rb</tt>
+    #   Config.load # => true
+    #
+    #   # Load a specific config file in <tt>~/.ronin/config/</tt>
+    #   Config.load 'sql' # => true
+    #
+    def Config.load(name=nil)
+      if name
+        path = File.expand_path(File.join(CONFIG_DIR,name))
+      else
+        path = CONFIG_PATH
+      end
+
+      require path if File.file?(path)
+    end
   end
 end

data/lib/ronin/context.rb

@@ -29,40 +29,44 @@ require 'ronin/extensions/meta'
 module Ronin
   module Context
     def self.included(base)
-      base.metaclass_def(:contextify) do |name|
-        Context.contexts[name.to_sym] = self
+      base.module_eval do
+        def self.contextify(name)
+          name = name.to_sym
 
-        meta_def(:context_name) { name }
+          Context.contexts[name] = self
 
-        class_def(:context_name) { name }
+          meta_def(:context_name) { name }
 
-        meta_def(:load_context) do |path,*args|
-          Context.load_context(self.context_name,path,*args)
-        end
+          class_def(:context_name) { name }
 
-        # 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
+          meta_def(:load_context) do |path,*args|
+            Context.load_context(self.context_name,path,*args)
           end
-        }
 
-        # define the Ronin-level context loader
-        Ronin.module_eval %{
-          def ronin_load_#{name}(path,*args,&block)
-            new_context = #{self}.load_context(path,*args)
+          # 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
+          }
 
-            block.call(new_context) if block
-            return new_context
-          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
     end
 
@@ -90,7 +94,6 @@ module Ronin
     #   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
 
@@ -221,12 +224,12 @@ module Ronin
             new_obj = Context.contexts[name].new
             new_obj.instance_eval(&context_block)
 
+            block.call(new_obj) if block
             new_objs << new_obj
           end
         end
       end
 
-      new_objs.each(&block) if block
       return new_objs
     end
   end

data/lib/ronin/database.rb

@@ -22,13 +22,12 @@
 #
 
 require 'ronin/exceptions/invalid_database_config'
-require 'ronin/extensions/kernel'
-require 'ronin/config'
 require 'ronin/arch'
 require 'ronin/platform'
 require 'ronin/author'
 require 'ronin/license'
 require 'ronin/product'
+require 'ronin/config'
 
 require 'yaml'
 require 'dm-core'

data/lib/ronin/extensions.rb

@@ -25,4 +25,3 @@ require 'ronin/extensions/meta'
 require 'ronin/extensions/hash'
 require 'ronin/extensions/uri'
 require 'ronin/extensions/string'
-require 'ronin/extensions/kernel'

data/lib/ronin/extensions/string.rb

@@ -83,4 +83,45 @@ class String
     return self[prefix.length...(length - postfix.length)]
   end
 
+  #
+  # Inspects the string, returning a C style encoded version of the string.
+  #
+  #   "hello\x00\073\x90\r\n"
+  #   # => "hello\0;\x90\r\n"
+  #
+  def inspect
+    c_string = ''
+
+    each_byte do |b|
+      c_string << case b
+                  when 0x00
+                    "\\0"
+                  when 0x07
+                    "\\a"
+                  when 0x08
+                    "\\b"
+                  when 0x09
+                    "\\t"
+                  when 0x0a
+                    "\\n"
+                  when 0x0b
+                    "\\v"
+                  when 0x0c
+                    "\\f"
+                  when 0x0d
+                    "\\r"
+                  when 0x22
+                    "\\\""
+                  when 0x5c
+                    "\\\\"
+                  when (0x20..0x7e)
+                    b.chr
+                  else
+                    ("\\x%.2x" % b)
+                  end
+    end
+
+    return "\"#{c_string}\""
+  end
+
 end

data/lib/ronin/extensions/uri/query_params.rb

@@ -47,6 +47,14 @@ module URI
       return new_query
     end
 
+    #
+    # Iterates over every query parameter, passing each to the given
+    # _block_.
+    #
+    def each_query_param(&block)
+      @query_params.each(&block)
+    end
+
     protected
 
     #

data/lib/ronin/formatting/extensions/binary/string.rb

@@ -56,6 +56,16 @@ class String
     return integer
   end
 
+  #
+  # XOR encodes the string using the specified _key_.
+  #
+  def xor(key)
+    encoded = ''
+
+    each_byte { |b| encoded << (b ^ key).chr }
+    return encoded
+  end
+
   #
   # Returns the base64 encoded form of the string.
   #

data/lib/ronin/{program.rb → hexdump.rb}

@@ -21,5 +21,5 @@
 #++
 #
 
-require 'ronin/program/program'
-require 'ronin/program/commands'
+require 'ronin/hexdump/hexdump'
+require 'ronin/hexdump/extensions'

data/lib/ronin/{parameters/exceptions/missing_param.rb → hexdump/extensions.rb}

@@ -21,9 +21,5 @@
 #++
 #
 
-module Ronin
-  module Parameters
-    class MissingParam < RuntimeError
-    end
-  end
-end
+require 'ronin/hexdump/extensions/file'
+require 'ronin/hexdump/extensions/kernel'