ronin 0.1.1 → 0.1.2

data/lib/ronin/ui/shell.rb

@@ -0,0 +1,117 @@
+#
+#--
+# 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
+#++
+#
+
+module Ronin
+  class Shell
+
+    # Default shell prompt
+    DEFAULT_PROMPT = '>'
+
+    # Shell name to use
+    attr_accessor :name
+
+    # Shell prompt
+    attr_accessor :prompt
+
+    #
+    # Creates a new Shell object with the given _options_.
+    #
+    # _options_ may contain the following keys:
+    # <tt>:name</tt>:: The name of the shell.
+    # <tt>:prompt</tt>::The prompt to use for the shell.
+    #
+    def initialize(options={})
+      @name = options[:name]
+      @prompt = (options[:prompt] || DEFAULT_PROMPT)
+    end
+
+    #
+    # Creates and starts a new Shell object with the specified _options_.
+    # If a _block_ is given, it will be passed every command.
+    #
+    def self.start(options={},&block)
+      self.new(options).start(&block)
+    end
+
+    #
+    # Starts the shell using the given _block_ to process commands.
+    #
+    def start(&block)
+      history_rollback = 0
+
+      loop do
+        line = Readline.readline("#{@name}#{@prompt} ")
+
+        if line =~ /^\s*exit\s*$/
+          break
+        else
+          Readline::HISTORY << line
+          history_rollback += 1
+
+          begin
+            block.call(self,line)
+          rescue => e
+            puts "#{e.class.name}: #{e.message}"
+          end
+        end
+      end
+
+      history_rollback.times do
+        Readline::HISTORY.pop
+      end
+
+      return nil
+    end
+
+    #
+    # Equivalent to <tt>STDOUT.putc(char)</tt>.
+    #
+    def putc(char)
+      STDOUT.putc(char)
+    end
+
+    #
+    # Equivalent to <tt>STDOUT.print(string)</tt>.
+    #
+    def print(string)
+      STDOUT.print(string)
+    end
+
+    #
+    # Equivalent to <tt>STDOUT.puts(string)</tt>.
+    #
+    def puts(string)
+      STDOUT.puts(string)
+    end
+
+    alias << puts
+
+    #
+    # Equivalent to <tt>STDOUT.printf(string,*objects)</tt>.
+    #
+    def printf(string,*objects)
+      STDOUT.printf(string,*objects)
+    end
+
+  end
+end

data/lib/ronin/version.rb

@@ -23,5 +23,5 @@
 
 module Ronin
   # Ronin version 
-  VERSION = '0.1.1'
+  VERSION = '0.1.2'
 end

data/lib/ronin/web.rb

@@ -21,4 +21,5 @@
 #++
 #
 
+require 'ronin/web/extensions'
 require 'ronin/web/web'

data/lib/ronin/web/extensions.rb

@@ -0,0 +1 @@
+require 'ronin/web/extensions/hpricot'

data/lib/ronin/web/extensions/hpricot.rb

@@ -0,0 +1,5 @@
+require 'ronin/web/extensions/hpricot/comment'
+require 'ronin/web/extensions/hpricot/tag'
+require 'ronin/web/extensions/hpricot/container'
+require 'ronin/web/extensions/hpricot/elem'
+require 'ronin/web/extensions/hpricot/doc'

data/lib/ronin/web/extensions/hpricot/comment.rb

@@ -0,0 +1,19 @@
+require 'hpricot'
+
+module Hpricot
+  class Comment
+
+    #
+    # Returns +true+ if the comment has the same content the _other_ comment,
+    # returns +false+ otherwise.
+    #
+    def eql?(other)
+      return false unless self.class == other.class
+
+      return content == other.content
+    end
+
+    alias == eql?
+
+  end
+end

data/lib/ronin/web/extensions/hpricot/container.rb

@@ -0,0 +1,46 @@
+require 'hpricot'
+
+module Hpricot
+  module Container
+    #
+    # Iterates over every sub-child, passing each to the specified _block_.
+    #
+    def every_child(&block)
+      each_child do |child|
+        block.call(child)
+
+        if child.kind_of?(Hpricot::Container)
+          child.every_child(&block)
+        end
+      end
+
+      return self
+    end
+
+    #
+    # Iterates over every text node, passing each to the specified _block_.
+    #
+    def all_text(&block)
+      every_child do |child|
+        block.call(child) if child.kind_of?(Text)
+      end
+    end
+
+    #
+    # Returns the number of all sub-children.
+    #
+    def count_children
+      sum = 0
+
+      every_child { |child| sum += 1 }
+      return sum
+    end
+
+    #
+    # Compares the number of sub-children with that of the _other_ element.
+    #
+    def <=>(other)
+      count_children <=> other.count_children
+    end
+  end
+end

data/lib/ronin/web/extensions/hpricot/doc.rb

@@ -0,0 +1,21 @@
+require 'ronin/web/extensions/hpricot/container'
+require 'ronin/web/extensions/hpricot/tag'
+require 'ronin/web/extensions/hpricot/text'
+require 'ronin/web/extensions/hpricot/comment'
+require 'ronin/web/extensions/hpricot/elem'
+
+module Hpricot
+  class Doc
+
+    include Comparable
+
+    #
+    # Returns +true+ if the documents children match the children of the
+    # _other_ document.
+    #
+    def ==(other)
+      children == other.children
+    end
+
+  end
+end

data/lib/ronin/web/extensions/hpricot/elem.rb

@@ -0,0 +1,25 @@
+require 'ronin/web/extensions/hpricot/container'
+
+require 'hpricot'
+
+module Hpricot
+  class Elem
+
+    include Comparable
+
+    #
+    # Returns +true+ if the element has the same starting-tag and
+    # ending-tag as the _other_ element, returns +false+ otherwise.
+    #
+    def eql?(other)
+      return false unless self.class == other.class
+
+      return (stag == other.stag && etag == other.etag)
+    end
+
+    def ==(other)
+      self.eql?(other) && super(other)
+    end
+
+  end
+end

data/lib/ronin/web/extensions/hpricot/tag.rb

@@ -0,0 +1,19 @@
+require 'hpricot'
+
+module Hpricot
+  module Tag
+
+    #
+    # Returns +true+ if the tag has the same name as the _other_ tag,
+    # returns +false+ otherwise.
+    #
+    def eql?(other)
+      return false unless self.class == other.class
+
+      return self.name == other.name
+    end
+
+    alias == eql?
+
+  end
+end

data/lib/ronin/web/extensions/hpricot/text.rb

@@ -0,0 +1,19 @@
+require 'hpricot'
+
+module Hpricot
+  class Text
+
+    #
+    # Returns +true+ if the text node has the same content the _other_ text
+    # node, returns +false+ otherwise.
+    #
+    def eql?(other)
+      return false unless self.class == other.class
+
+      return content == other.content
+    end
+
+    alias == eql?
+
+  end
+end

data/lib/ronin/web/web.rb

@@ -26,6 +26,7 @@ require 'ronin/network/http'
 require 'uri/http'
 require 'mechanize'
 require 'open-uri'
+require 'spidr'
 
 module Ronin
   module Web
@@ -69,10 +70,12 @@ module Ronin
           userinfo = "#{Web.proxy[:user]}:#{Web.proxy[:password]}"
         end
 
-        return URI::HTTP.build(:host => Web.proxy[:host],
-                               :port => Web.proxy[:port],
-                               :userinfo => userinfo,
-                               :path => '/')
+        return URI::HTTP.build(
+          :host => Web.proxy[:host],
+          :port => Web.proxy[:port],
+          :userinfo => userinfo,
+          :path => '/'
+        )
       end
     end
 
@@ -261,5 +264,68 @@ module Ronin
       block.call(body) if block
       return body
     end
+
+    #
+    # Creates a new Spidr::Agent object with the given _options_ and
+    # _block_. If a _block_ is given, it will be passed the newly created
+    # Spidr::Agent object.
+    #
+    # _options_ may contain the following keys:
+    # <tt>:proxy</tt>:: The proxy to use while spidering. Defaults to
+    #                   Web.proxy.
+    # <tt>:user_agent</tt>:: The User-Agent string to send. Defaults to
+    #                        Web.user_agent.
+    # <tt>:referer</tt>:: The referer URL to send.
+    # <tt>:delay</tt>:: Duration in seconds to pause between spidering each
+    #                   link. Defaults to 0.
+    # <tt>:host</tt>:: The host-name to visit.
+    # <tt>:hosts</tt>:: An +Array+ of host patterns to visit.
+    # <tt>:ignore_hosts</tt>:: An +Array+ of host patterns to not visit.
+    # <tt>:ports</tt>:: An +Array+ of port patterns to visit.
+    # <tt>:ignore_ports</tt>:: An +Array+ of port patterns to not visit.
+    # <tt>:links</tt>:: An +Array+ of link patterns to visit.
+    # <tt>:ignore_links</tt>:: An +Array+ of link patterns to not visit.
+    # <tt>:exts</tt>:: An +Array+ of File extension patterns to visit.
+    # <tt>:ignore_exts</tt>:: An +Array+ of File extension patterns to not
+    #                         visit.
+    #
+    def Web.spider_agent(options={},&block)
+      options = Web.spider_default_options.merge(options)
+
+      return Spidr::Agent.new(options,&block)
+    end
+
+    #
+    # Creates a new Spidr::Agent object with the given _options_ and will
+    # begin spidering the specified host _name_. If a _block_ is given it
+    # will be passed the newly created Spidr::Agent object, before the
+    # agent begins spidering.
+    #
+    def Web.spider_host(name,options={},&block)
+      options = Web.spider_default_options.merge(options)
+
+      return Spidr::Agent.host(name,options,&block)
+    end
+
+    #
+    # Creates a new Spidr::Agent object with the given _options_ and will
+    # begin spidering the host of the specified _url_. If a _block_ is
+    # given it will be passed the newly created Spidr::Agent object, before
+    # the agent begins spidering.
+    #
+    def Web.spider_site(url,options={},&block)
+      options = Web.spider_default_options.merge(options)
+
+      return Spidr::Agent.site(url,options,&block)
+    end
+
+    protected
+
+    #
+    # Returns the default options for Spidr::Agent.
+    #
+    def Web.spider_default_options
+      {:proxy => Web.proxy, :user_agent => Web.user_agent}
+    end
   end
 end

data/spec/arch_spec.rb

@@ -1,6 +1,6 @@
 require 'ronin/arch'
 
-require 'spec_helper'
+require 'helpers/database'
 
 describe Arch do
   it "should require a name, endian and address_length attributes" do

data/spec/author_spec.rb

@@ -1,6 +1,6 @@
 require 'ronin/author'
 
-require 'spec_helper'
+require 'helpers/database'
 
 describe Author do
   it "should have a default name" do

data/spec/chars/char_set_spec.rb

@@ -0,0 +1,177 @@
+require 'ronin/chars/chars'
+
+require 'spec_helper'
+
+describe Ronin do
+  describe Chars::CharSet do
+    before(:all) do
+      @integer_range = (0x41..0x43)
+      @string_range = ('A'..'C')
+      @integers = @integer_range.to_a
+      @strings = @string_range.to_a
+
+      @char_set = Chars::CharSet.new(*@strings)
+    end
+
+    it "may be created with String arguments" do
+      @chars = Chars::CharSet.new(*@strings)
+
+      @strings.each do |s|
+        @chars.include_char?(s).should == true
+      end
+    end
+
+    it "may be created with an Array of Strings" do
+      @chars = Chars::CharSet.new(@strings)
+
+      @strings.each do |s|
+        @chars.include_char?(s).should == true
+      end
+    end
+
+    it "may be created with a Range of Strings" do
+      @chars = Chars::CharSet.new(@string_range)
+
+      @strings.each do |s|
+        @chars.include_char?(s).should == true
+      end
+    end
+
+    it "may be created with Integer arguments" do
+      @chars = Chars::CharSet.new(*@integers)
+
+      @integers.each do |i|
+        @chars.include?(i).should == true
+      end
+    end
+
+    it "may be created with an Array of Integers" do
+      @chars = Chars::CharSet.new(@integers)
+
+      @integers.each do |i|
+        @chars.include?(i).should == true
+      end
+    end
+
+    it "may be created with a Range of Integers" do
+      @chars = Chars::CharSet.new(@integer_range)
+
+      @integers.each do |i|
+        @chars.include?(i).should == true
+      end
+    end
+
+    it "should include Strings" do
+      @char_set.include_char?('A').should == true
+    end
+
+    it "should include Integers" do
+      @char_set.include?(0x41).should == true
+    end
+
+    it "should be able to select bytes" do
+      @sub_chars = @char_set.select_bytes { |c| c <= 0x42 }
+
+      @sub_chars.should == [0x41, 0x42]
+    end
+
+    it "should be able to select chars" do
+      @sub_chars = @char_set.select_chars { |c| c <= 'B' }
+
+      @sub_chars.should == ['A', 'B']
+    end
+
+    it "should return a random byte" do
+      @char_set.include?(@char_set.random_byte).should == true
+    end
+
+    it "should return a random char" do
+      @char_set.include_char?(@char_set.random_char).should == true
+    end
+
+    it "should iterate over n random bytes" do
+      @char_set.each_random_byte(10) do |b|
+        @char_set.include?(b).should == true
+      end
+    end
+
+    it "should iterate over n random chars" do
+      @char_set.each_random_char(10) do |c|
+        @char_set.include_char?(c).should == true
+      end
+    end
+
+    it "should return a random Array of bytes" do
+      bytes = @char_set.random_bytes(10)
+
+      bytes.each do |b|
+        @char_set.include?(b).should == true
+      end
+    end
+
+    it "should return a random Array of chars" do
+      chars = @char_set.random_chars(10)
+
+      chars.each do |c|
+        @char_set.include_char?(c).should == true
+      end
+    end
+
+    it "should return a random Array of bytes with a varying length" do
+      bytes = @char_set.random_bytes(5..10)
+
+      bytes.length.between?(5, 10).should == true
+      bytes.each do |b|
+        @char_set.include?(b).should == true
+      end
+    end
+
+    it "should return a random Array of chars with a varying length" do
+      chars = @char_set.random_chars(5..10)
+
+      chars.length.between?(5, 10).should == true
+      chars.each do |c|
+        @char_set.include_char?(c).should == true
+      end
+    end
+
+    it "should return a random String of chars" do
+      @char_set.random_string(10).each_byte do |b|
+        @char_set.include?(b).should == true
+      end
+    end
+
+    it "should return a random String of chars with a varying length" do
+      string = @char_set.random_string(5..10)
+
+      string.length.between?(5, 10)
+      string.each_byte do |b|
+        @char_set.include?(b).should == true
+      end
+    end
+
+    it "should be able to be compared with another set of chars" do
+      (@char_set == Chars::CharSet['A', 'B', 'C']).should == true
+      (@char_set == Chars::CharSet['A', 'C', 'B']).should == true
+    end
+
+    it "should be able to be unioned with another set of chars" do
+      super_set = (@char_set | Chars::CharSet['D'])
+
+      super_set.class.should == Chars::CharSet
+      super_set.should == Chars::CharSet['A', 'B', 'C', 'D']
+    end
+
+    it "should be able to be removed from another set of chars" do
+      sub_set = (@char_set - Chars::CharSet['B'])
+
+      sub_set.class.should == Chars::CharSet
+      sub_set.subset?(@char_set).should == true
+    end
+
+    it "should determine if a String is made up of the characters from the char set" do
+      (@char_set =~ "AABCBAA").should == true
+      (@char_set =~ "AADDEE").should_not == true
+    end
+  end
+end