ronin 0.1.2 → 0.1.3

data/lib/ronin/ui/console.rb

@@ -3,7 +3,7 @@
 # Ronin - A Ruby platform designed for information security and data
 # exploration tasks.
 #
-# Copyright (c) 2006-2008 Hal Brodigan (postmodern.mod3 at gmail.com)
+# 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

data/lib/ronin/ui/shell.rb

@@ -3,7 +3,7 @@
 # Ronin - A Ruby platform designed for information security and data
 # exploration tasks.
 #
-# Copyright (c) 2006-2008 Hal Brodigan (postmodern.mod3 at gmail.com)
+# 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

data/lib/ronin/version.rb

@@ -3,7 +3,7 @@
 # Ronin - A Ruby platform designed for information security and data
 # exploration tasks.
 #
-# Copyright (c) 2006-2008 Hal Brodigan (postmodern.mod3 at gmail.com)
+# 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
@@ -23,5 +23,5 @@
 
 module Ronin
   # Ronin version 
-  VERSION = '0.1.2'
+  VERSION = '0.1.3'
 end

data/lib/ronin/web.rb

@@ -3,7 +3,7 @@
 # Ronin - A Ruby platform designed for information security and data
 # exploration tasks.
 #
-# Copyright (c) 2006-2008 Hal Brodigan (postmodern.mod3 at gmail.com)
+# 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

data/lib/ronin/web/web.rb

@@ -3,7 +3,7 @@
 # Ronin - A Ruby platform designed for information security and data
 # exploration tasks.
 #
-# Copyright (c) 2006-2008 Hal Brodigan (postmodern.mod3 at gmail.com)
+# 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

data/spec/chars/char_set_spec.rb

@@ -2,176 +2,174 @@ 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
+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)
+  it "may be created with String arguments" do
+    @chars = Chars::CharSet.new(*@strings)
 
-      @strings.each do |s|
-        @chars.include_char?(s).should == true
-      end
+    @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)
+  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
+    @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)
+  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
+    @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)
+  it "may be created with Integer arguments" do
+    @chars = Chars::CharSet.new(*@integers)
 
-      @integers.each do |i|
-        @chars.include?(i).should == true
-      end
+    @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)
+  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
+    @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)
+  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
+    @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 Strings" do
+    @char_set.include_char?('A').should == true
+  end
 
-    it "should include Integers" do
-      @char_set.include?(0x41).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 }
+  it "should be able to select bytes" do
+    @sub_chars = @char_set.select_bytes { |c| c <= 0x42 }
 
-      @sub_chars.should == [0x41, 0x42]
-    end
+    @sub_chars.should == [0x41, 0x42]
+  end
 
-    it "should be able to select chars" do
-      @sub_chars = @char_set.select_chars { |c| c <= 'B' }
+  it "should be able to select chars" do
+    @sub_chars = @char_set.select_chars { |c| c <= 'B' }
 
-      @sub_chars.should == ['A', 'B']
-    end
+    @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 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 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
+  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
+  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)
+  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
+    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)
+  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
+    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)
+  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
+    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)
+  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
+    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
+  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)
+  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
+    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 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'])
+  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
+    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'])
+  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
+    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
+  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

data/spec/chars/chars_spec.rb

@@ -2,81 +2,72 @@ require 'ronin/chars/chars'
 
 require 'spec_helper'
 
-describe Ronin do
-  describe Chars do
-    before(:all) do
-      @numeric_string = Chars.numeric.random_string(10)
-      @octal_string = Chars.octal.random_string(10)
-      @uppercase_hex_string = Chars.uppercase_hexadecimal.random_string(10)
-      @lowercase_hex_string = Chars.lowercase_hexadecimal.random_string(10)
-      @hex_string = Chars.hexadecimal.random_string(10)
-      @uppercase_alpha_string = Chars.uppercase_alpha.random_string(10)
-      @lowercase_alpha_string = Chars.lowercase_alpha.random_string(10)
-      @alpha_string = Chars.alpha.random_string(10)
-      @alpha_numeric = Chars.alpha_numeric.random_string(10)
-      @space_string = Chars.space.random_string(10)
-      @punctuation_string = Chars.punctuation.random_string(10)
-      @symbols_string = Chars.symbols.random_string(10)
-      @control_string = Chars.control.random_string(10)
-      @ascii_string = Chars.ascii.random_string(10)
-      @all_string = Chars.all.random_string(10)
-    end
-
-    it "should provide a numeric CharSet" do
-      (@numeric_string =~ /[0-9]{10}/).should_not be_nil
-    end
-
-    it "should provide an octal CharSet" do
-      (@octal_string =~ /[0-7]{10}/).should_not be_nil
-    end
-
-    it "should provide an upper-case hexadecimal CharSet" do
-      (@uppercase_hex_string =~ /[0-9A-F]{10}/).should_not be_nil
-    end
+describe Chars do
+  before(:all) do
+    @numeric_string = Chars.numeric.random_string(10)
+    @octal_string = Chars.octal.random_string(10)
+    @uppercase_hex_string = Chars.uppercase_hexadecimal.random_string(10)
+    @lowercase_hex_string = Chars.lowercase_hexadecimal.random_string(10)
+    @hex_string = Chars.hexadecimal.random_string(10)
+    @uppercase_alpha_string = Chars.uppercase_alpha.random_string(10)
+    @lowercase_alpha_string = Chars.lowercase_alpha.random_string(10)
+    @alpha_string = Chars.alpha.random_string(10)
+    @alpha_numeric = Chars.alpha_numeric.random_string(10)
+    @space_string = Chars.space.random_string(10)
+    @punctuation_string = Chars.punctuation.random_string(10)
+    @symbols_string = Chars.symbols.random_string(10)
+    @control_string = Chars.control.random_string(10)
+    @ascii_string = Chars.ascii.random_string(10)
+    @all_string = Chars.all.random_string(10)
+  end
 
-    it "should provide a lower-case hexadecimal CharSet" do
-      (@lowercase_hex_string =~ /[0-9a-f]{10}/).should_not be_nil
-    end
+  it "should provide a numeric CharSet" do
+    (@numeric_string =~ /[0-9]{10}/).should_not be_nil
+  end
 
-    it "should provide a hexadecimal CharSet" do
-      (@hex_string =~ /[0-9A-Fa-f]{10}/).should_not be_nil
-    end
+  it "should provide an octal CharSet" do
+    (@octal_string =~ /[0-7]{10}/).should_not be_nil
+  end
 
-    it "should provide an upper-case alpha CharSet" do
-      (@uppercase_alpha_string =~ /[A-Z]{10}/).should_not be_nil
-    end
+  it "should provide an upper-case hexadecimal CharSet" do
+    (@uppercase_hex_string =~ /[0-9A-F]{10}/).should_not be_nil
+  end
 
-    it "should provide a lower-case alpha CharSet" do
-      (@lowercase_alpha_string =~ /[a-z]{10}/).should_not be_nil
-    end
+  it "should provide a lower-case hexadecimal CharSet" do
+    (@lowercase_hex_string =~ /[0-9a-f]{10}/).should_not be_nil
+  end
 
-    it "should provide an alpha CharSet" do
-      (@alpha_string =~ /[A-Za-z]{10}/).should_not be_nil
-    end
+  it "should provide a hexadecimal CharSet" do
+    (@hex_string =~ /[0-9A-Fa-f]{10}/).should_not be_nil
+  end
 
-    it "should provide an alpha-numeric CharSet" do
-      (@alpha_numeric_string =~ /[A-Za-z0-9]{10}/).should_not be_nil
-    end
+  it "should provide an upper-case alpha CharSet" do
+    (@uppercase_alpha_string =~ /[A-Z]{10}/).should_not be_nil
+  end
 
-    it "should provide a space CharSet" do
-      (@space_string =~ /[ \f\n\r\t\v]{10}/).should_not be_nil
-    end
+  it "should provide a lower-case alpha CharSet" do
+    (@lowercase_alpha_string =~ /[a-z]{10}/).should_not be_nil
+  end
 
-    it "should provide a punctuation CharSet" do
-      (@punctuation_string =~ /[ \'\"\`\,\;\:\~\-\(\)\[\]\{\}\.\?\!]{10}/).should_not be_nil
-    end
+  it "should provide an alpha CharSet" do
+    (@alpha_string =~ /[A-Za-z]{10}/).should_not be_nil
+  end
 
-    it "should provide a symbols CharSet" do
-      #(@symbols_string =~ /[\@\#\$\%\^\&\*\_\+\=\|\\\<\>\/]{10}/).should_not be_nil
-    end
+  it "should provide an alpha-numeric CharSet" do
+    (@alpha_numeric_string =~ /[A-Za-z0-9]{10}/).should_not be_nil
+  end
 
-    it "should provide a control CharSet" do
-    end
+  it "should provide a space CharSet" do
+    (@space_string =~ /[ \f\n\r\t\v]{10}/).should_not be_nil
+  end
 
-    it "should provide an ascii CharSet" do
-    end
+  it "should provide a punctuation CharSet" do
+    (@punctuation_string =~ /[ \'\"\`\,\;\:\~\-\(\)\[\]\{\}\.\?\!]{10}/).should_not be_nil
+  end
 
-    it "should provide an 'all' CharSet" do
+  it "should provide a symbols CharSet" do
+    pending "need to fix the testing regex" do
+      (@symbols_string =~ /[\@\#\$\%\^\&\*\_\+\=\|\\\<\>\/]{10}/).should_not be_nil
     end
   end
 end