ronin-support 0.2.0 → 0.3.0

data/ronin-support.gemspec

@@ -99,7 +99,7 @@ Gem::Specification.new do |gemspec|
   end
 
   if gemspec.respond_to?(:required_rubygems_version=)
-    gemspec.required_rubygems_version = metadata['required_ruby_version']
+    gemspec.required_rubygems_version = metadata['required_rubygems_version']
   end
 
   parse_versions = lambda { |versions|

data/spec/extensions/enumerable_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require 'ronin/extensions/enumerable'
+
+describe Enumerable do
+  describe "#map_hash" do
+    it "should map elements to a Hash" do
+      [1, 2, 3].map_hash { |i| i ** 2 }.should == {
+        1 => 1,
+        2 => 4,
+        3 => 9
+      }
+    end
+
+    it "should not map the same element twice" do
+      [1, 2, 2].map_hash { |i| rand }.keys.should =~ [1, 2]
+    end
+
+    it "should set the default_proc of the Hash" do
+      hash = [].map_hash { |i| i ** 2 }
+
+      hash[3].should == 9
+    end
+  end
+end

data/spec/extensions/file_spec.rb

@@ -1,6 +1,8 @@
 require 'spec_helper'
 require 'ronin/extensions/file'
 
+require 'tempfile'
+
 describe File do
   subject { File }
 
@@ -8,6 +10,43 @@ describe File do
     subject.should respond_to(:escape_path)
   end
 
+  describe "each_line" do
+    let(:lines) { %w[one two three] }
+
+    before(:all) do
+      @file = Tempfile.new('ronin-support')
+      @file.puts(*lines)
+      @file.close
+    end
+
+    it "should enumerate over each line in the file" do
+      File.each_line(@file.path).to_a.should == lines
+    end
+  end
+
+  describe "each_row" do
+    let(:rows) do
+      [
+        %w[one two three],
+        %w[four five six]
+      ]
+    end
+
+    let(:separator) { '|' }
+    let(:newline)   { "\r\n" }
+    let(:lines)     { rows.map { |row| row.join(separator) }.join(newline) }
+
+    before(:all) do
+      @file = Tempfile.new('ronin-support')
+      @file.write(lines)
+      @file.close
+    end
+
+    it "should enumerate over each row from each line" do
+      File.each_row(@file.path,separator).to_a.should == rows
+    end
+  end
+
   describe "escape_path" do
     it "should remove null-bytes" do
       File.escape_path("hello\0world\0").should == "helloworld"

data/spec/extensions/ip_addr_spec.rb

@@ -160,10 +160,16 @@ describe IPAddr do
   let(:bad_ip) { IPAddr.new('0.0.0.0') }
 
   describe "#lookup" do
+    let(:nameserver) { '4.2.2.1' }
+
     it "should lookup the host-name for an IP" do
       ip.lookup.should include('localhost')
     end
 
+    it "may lookup host-names via other nameservers" do
+      ip.lookup(nameserver).should be_empty
+    end
+
     it "should return an empty Array for unknown IP addresses" do
       bad_ip.lookup.should be_empty
     end

data/spec/extensions/resolv_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+require 'ronin/extensions/resolv'
+
+describe Resolv do
+  describe "resolver" do
+    let(:nameserver) { '4.2.2.1' }
+
+    subject { Resolv }
+
+    it "should create a new Resolv::DNS object if a nameserver is given" do
+      subject.resolver(nameserver).should be_kind_of(Resolv::DNS)
+    end
+
+    it "should return the default resolver otherwise" do
+      subject.resolver.should == Resolv
+    end
+  end
+end

data/spec/formatting/html/integer_spec.rb

@@ -53,14 +53,14 @@ describe Integer do
   end
 
   describe "#format_js" do
-    let(:js_escaped) { "%26" }
+    let(:js_escaped) { '\x26' }
 
     it "should JavaScript format ascii bytes" do
       subject.format_js.should == js_escaped
     end
 
     it "should JavaScript format unicode bytes" do
-      0xd556.format_js.should == "%uD556"
+      0xd556.format_js.should == '\uD556'
     end
   end
 end

data/spec/formatting/html/string_spec.rb

@@ -94,7 +94,7 @@ describe String do
   end
 
   describe "#format_js" do
-    let(:js_formatted) { "%6F%6E%65%20%26%20%74%77%6F" }
+    let(:js_formatted) { '\x6F\x6E\x65\x20\x26\x20\x74\x77\x6F' }
 
     it "should JavaScript escape all characters" do
       subject.format_js.should == js_formatted

data/spec/formatting/sql/string_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+require 'ronin/formatting/extensions/sql/string'
+
+describe String do
+  before(:all) do
+    @string = '/etc/passwd'
+    @sql_encoded = '0x2f6574632f706173737764'
+    @string_with_quotes = %{"O'Brian"}
+  end
+
+  it "should provide the #sql_escape method" do
+    @string.should respond_to(:sql_escape)
+  end
+
+  it "should provide the #sql_encode method" do
+    @string.should respond_to(:sql_encode)
+  end
+
+  it "should provide the #sql_decode method" do
+    @string.should respond_to(:sql_decode)
+  end
+
+  describe "SQL escaping" do
+    it "should be able to single-quote escape" do
+      @string_with_quotes.sql_escape(:single).should == %{'"O''Brian"'}
+    end
+
+    it "should be able to double-quote escape" do
+      @string_with_quotes.sql_escape(:double).should == %{"""O'Brian"""}
+    end
+  end
+
+  describe "SQL-hex encoding" do
+    it "should be able to be SQL-hex encoded" do
+      @string.sql_encode.should == @sql_encoded
+    end
+
+    it "should return an empty String if empty" do
+      ''.sql_encode.should == ''
+    end
+  end
+
+  describe "SQL-hex decoding" do
+    it "should be able to be SQL-hex decoded" do
+      encoded = @string.sql_encode
+
+      encoded.should == @sql_encoded
+      encoded.sql_decode.should == @string
+    end
+
+    it "should be able to decode SQL comma-escaping" do
+      "'Conan O''Brian'".sql_decode.should == "Conan O'Brian"
+    end
+  end
+end

data/spec/formatting/text/string_spec.rb

@@ -4,6 +4,10 @@ require 'ronin/formatting/text'
 describe String do
   subject { "hello" }
 
+  it "should provide String.generate" do
+    described_class.should respond_to(:generate)
+  end
+
   it "should provide String#format_chars" do
     should respond_to(:format_chars)
   end
@@ -24,6 +28,112 @@ describe String do
     should respond_to(:insert_after)
   end
 
+  describe "generate" do
+    subject { described_class }
+
+    it "should generate Strings from CharSets" do
+      strings = subject.generate(:lowercase_hexadecimal, :numeric).to_a
+
+      strings.grep(/^[0-9a-f][0-9]$/).should == strings
+    end
+
+    it "should generate Strings from lengths of CharSets" do
+      strings = subject.generate([:numeric, 2]).to_a
+
+      strings.grep(/^[0-9]{2}$/).should == strings
+    end
+
+    it "should generate Strings from varying lengths of CharSets" do
+      strings = subject.generate([:numeric, 1..2]).to_a
+
+      strings.grep(/^[0-9]{1,2}$/).should == strings
+    end
+
+    it "should generate Strings from custom CharSets" do
+      strings = subject.generate([%w[a b c], 2]).to_a
+
+      strings.grep(/^[abc]{2}$/).should == strings
+    end
+
+    it "should generate Strings containing known Strings" do
+      strings = subject.generate('foo', [%w[a b c], 2]).to_a
+
+      strings.grep(/^foo[abc]{2}$/).should == strings
+    end
+
+    it "should raise a TypeError for non String, Symbol, Enumerable CharSets" do
+      lambda {
+        subject.generate([Object.new, 2]).to_a
+      }.should raise_error(TypeError)
+    end
+
+    it "should raise an ArgumentError for unknown CharSets" do
+      lambda {
+        subject.generate([:foo_bar, 2]).to_a
+      }.should raise_error(ArgumentError)
+    end
+
+    it "should raise a TypeError for non Integer,Array,Range lengths" do
+      lambda {
+        subject.generate([:numeric, 'foo']).to_a
+      }.should raise_error(TypeError)
+    end
+  end
+
+  describe "#fuzz" do
+    subject { 'GET /one/two/three' }
+
+    it "should match Regexps" do
+      fuzzed = subject.fuzz(/GET/ => ['get']).to_a
+
+      fuzzed.should == ['get /one/two/three']
+    end
+
+    it "should match Strings" do
+      fuzzed = subject.fuzz('GET' => ['get']).to_a
+
+      fuzzed.should == ['get /one/two/three']
+    end
+
+    it "should match Integers" do
+      fuzzed = subject.fuzz(0x20 => ["\t"]).to_a
+
+      fuzzed.should == ["GET\t/one/two/three"]
+    end
+
+    it "should substitute using Procs" do
+      fuzzed = subject.fuzz('GET' => [lambda { |s| s.downcase }]).to_a
+
+      fuzzed.should == ['get /one/two/three']
+    end
+
+    it "should substitute using Integers" do
+      fuzzed = subject.fuzz(' ' => [0x09]).to_a
+
+      fuzzed.should == ["GET\t/one/two/three"]
+    end
+
+    it "should incrementally replace each occurrence" do
+      fuzzed = subject.fuzz('/' => ["\n\r"]).to_a
+
+      fuzzed.should == [
+        "GET \n\rone/two/three",
+        "GET /one\n\rtwo/three",
+        "GET /one/two\n\rthree"
+      ]
+    end
+
+    it "should replace each occurrence with each substitution" do
+      fuzzed = subject.fuzz('GET' => ["\n\rGET", "G\n\rET", "GET\n\r"]).to_a
+
+      fuzzed.should == [
+        "\n\rGET /one/two/three",
+        "G\n\rET /one/two/three",
+        "GET\n\r /one/two/three"
+      ]
+    end
+  end
+
   describe "#format_bytes" do
     it "should format each byte in the String" do
       subject.format_bytes { |b|

data/spec/network/ssl_spec.rb

@@ -2,13 +2,19 @@ require 'spec_helper'
 require 'ronin/network/ssl'
 
 describe Network::SSL do
-  describe 'verify' do
-    it "should map verify mode names to numeric values" do
-      subject.verify(:peer).should == OpenSSL::SSL::VERIFY_PEER
+  describe 'VERIFY' do
+    subject { Network::SSL::VERIFY }
+
+    it "should map verify mode names to OpenSSL VERIFY_* constants" do
+      subject[:peer].should == OpenSSL::SSL::VERIFY_PEER
     end
 
     it "should default to VERIFY_NONE if no verify mode name is given" do
-      subject.verify.should == OpenSSL::SSL::VERIFY_NONE
+      subject[nil].should == OpenSSL::SSL::VERIFY_NONE
+    end
+
+    it "should raise an exception for unknown verify modes" do
+      lambda { subject[:foo_bar] }.should raise_error
     end
   end
 end

data/spec/ui/classes/test_shell.rb

@@ -0,0 +1,22 @@
+require 'ronin/ui/shell'
+
+class TestShell < Ronin::UI::Shell
+
+  def a_public_method
+  end
+
+  protected
+
+  def command1
+    :command1
+  end
+
+  def command_with_arg(arg)
+    arg
+  end
+
+  def command_with_args(*args)
+    args
+  end
+
+end

data/spec/ui/output_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'ronin/ui/output'
+
+describe UI::Output do
+  it "should be quiet by default" do
+    should be_quiet
+  end
+
+  it "may become verbose" do
+    subject.verbose!
+
+    should be_verbose
+    should_not be_quiet
+    should_not be_silent
+  end
+
+  it "may become quiet" do
+    subject.quiet!
+
+    should be_quiet
+    should_not be_silent
+    should_not be_verbose
+  end
+
+  it "may become silent" do
+    subject.silent!
+
+    should be_silent
+    should_not be_quiet
+    should_not be_verbose
+  end
+end

data/spec/ui/shell_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+require 'ronin/ui/shell'
+
+require 'ui/classes/test_shell'
+
+describe UI::Shell do
+  context "with handler callback" do
+    let(:line) { 'one two three' }
+
+    it "should call the input handler with the shell and input line" do
+      lines = []
+      shell = described_class.new { |shell,input| lines << input }
+
+      shell.call(line)
+
+      lines.should == [line]
+    end
+  end
+
+  context "with commands" do
+    subject { TestShell.new }
+
+    describe "#commands" do
+      it "should include builtin methods" do
+        subject.commands.should include(:help, :exit)
+      end
+
+      it "should include protected methods" do
+        subject.commands.should include(:command1, :command_with_arg, :command_with_args)
+      end
+
+      it "should not include public methods" do
+        subject.commands.should_not include(:a_public_method)
+      end
+    end
+
+    describe "#call" do
+      it "should ignore empty lines" do
+        subject.call('').should == false
+      end
+
+      it "should ignore white-space lines" do
+        subject.call("     \t   ").should == false
+      end
+
+      it "should not allow calling the handler method" do
+        subject.call('handler').should == false
+      end
+
+      it "should not allow calling unknown commands" do
+        subject.call('an_unknown_command').should == false
+      end
+
+      it "should not allow calling unknown commands" do
+        subject.call('an_unknown_command').should == false
+      end
+
+      it "should not allow calling public methods" do
+        subject.call('a_public_method').should == false
+      end
+
+      it "should allow calling protected methods" do
+        subject.call('command1').should == :command1
+      end
+
+      it "should raise an exception when passing invalid number of arguments" do
+        lambda {
+          subject.call('command_with_arg too many args')
+        }.should raise_error(ArgumentError)
+      end
+
+      it "should splat the command arguments to the command method" do
+        subject.call('command_with_args one two three').should == [
+          'one', 'two', 'three'
+        ]
+      end
+    end
+  end
+end