ronin-support 0.5.2 → 1.0.0.beta1

data/spec/fuzzing/fuzzer_spec.rb

@@ -1,109 +0,0 @@
-require 'spec_helper'
-require 'ronin/fuzzing/fuzzer'
-
-describe Fuzzing::Fuzzer do
-  let(:string) { 'GET /one/two/three' }
-
-  describe "#initialize" do
-    subject { described_class }
-
-    context "patterns" do
-      let(:substitutions) { ['bar'] }
-
-      it "should accept Regexps" do
-        fuzzer = subject.new(/foo/ => substitutions)
-
-        expect(fuzzer.rules).to have_key(/foo/)
-      end
-
-      context "when given Strings" do
-        subject { described_class.new('foo' => substitutions) }
-
-        it "should convert to Regexp" do
-          expect(subject.rules).to have_key(/foo/)
-        end
-      end
-
-      context "when given Symbols" do
-        subject { described_class.new(:word => substitutions) }
-
-        it "should lookup the Regexp constant" do
-          expect(subject.rules).to have_key(Regexp::WORD)
-        end
-      end
-
-      context "otherwise" do
-        it "should raise a TypeError" do
-          expect {
-            subject.new(Object.new => substitutions)
-          }.to raise_error(TypeError)
-        end
-      end
-    end
-
-    context "substitutions" do
-      let(:pattern) { /foo/ }
-
-      it "should accept Enumerable values" do
-        fuzzer = subject.new(pattern => ['bar'])
-
-        expect(fuzzer.rules[pattern]).to eq(['bar'])
-      end
-
-      context "when given Symbols" do
-        subject { described_class.new(pattern => :bad_strings) }
-
-        it "should map to an Enumerator for a Fuzzing method" do
-          expect(subject.rules[pattern]).to be_kind_of(Enumerable)
-        end
-      end
-
-      context "otherwise" do
-        it "should raise a TypeError" do
-          expect {
-            subject.new(pattern => Object.new)
-          }.to raise_error(TypeError)
-        end
-      end
-    end
-  end
-
-  describe "#each" do
-    let(:string) { "foo bar" }
-
-    subject { described_class.new(/o/ => ['O', '0'], /a/ => ['A', '@']) }
-
-    it "should apply each fuzzing rule individually" do
-      expect(subject.each(string).to_a).to match_array([
-        "fOo bar",
-        "f0o bar",
-        "foO bar",
-        "fo0 bar",
-        "foo bAr",
-        "foo b@r"
-      ])
-    end
-
-    context "when mutations contain Integers" do
-      subject { described_class.new(/o/ => [48]) }
-
-      it "should convert them to characters" do
-        expect(subject.each(string).to_a).to match_array([
-          "f0o bar",
-          "fo0 bar"
-        ])
-      end
-    end
-
-    context "when mutations contain Procs" do
-      subject { described_class.new(/o/ => [lambda { |str| str.upcase }]) }
-
-      it "should call them with the matched String" do
-        expect(subject.each(string).to_a).to match_array([
-          "fOo bar",
-          "foO bar"
-        ])
-      end
-    end
-  end
-end

data/spec/fuzzing/fuzzing_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-require 'ronin/fuzzing/fuzzing'
-
-describe Fuzzing do
-  describe "[]" do
-    let(:method) { :bad_strings }
-
-    it "should return Enumerators for fuzzing methods" do
-      expect(subject[method]).to be_kind_of(Enumerable)
-    end
-
-    it "should raise NoMethodError for unknown methods" do
-      expect {
-        subject[:foo]
-      }.to raise_error(NoMethodError)
-    end
-
-    it "should not allow accessing inherited methods" do
-      expect {
-        subject[:instance_eval]
-      }.to raise_error(NoMethodError)
-    end
-  end
-end

data/spec/fuzzing/mutator_spec.rb

@@ -1,112 +0,0 @@
-require 'spec_helper'
-require 'ronin/fuzzing/mutator'
-
-describe Fuzzing::Mutator do
-  let(:string) { 'GET /one/two/three' }
-
-  describe "#initialize" do
-    subject { described_class }
-
-    context "patterns" do
-      let(:substitutions) { ['bar'] }
-
-      it "should accept Regexps" do
-        fuzzer = subject.new(/foo/ => substitutions)
-
-        expect(fuzzer.rules).to have_key(/foo/)
-      end
-
-      context "when given Strings" do
-        subject { described_class.new('foo' => substitutions) }
-
-        it "should convert to Regexp" do
-          expect(subject.rules).to have_key(/foo/)
-        end
-      end
-
-      context "when given Symbols" do
-        subject { described_class.new(:word => substitutions) }
-
-        it "should lookup the Regexp constant" do
-          expect(subject.rules).to have_key(Regexp::WORD)
-        end
-      end
-
-      context "otherwise" do
-        it "should raise a TypeError" do
-          expect {
-            subject.new(Object.new => substitutions)
-          }.to raise_error(TypeError)
-        end
-      end
-    end
-
-    context "mutations" do
-      let(:pattern) { /foo/ }
-
-      it "should accept Enumerable values" do
-        fuzzer = subject.new(pattern => ['bar'])
-
-        expect(fuzzer.rules[pattern]).to eq(['bar'])
-      end
-
-      context "when given Symbols" do
-        subject { described_class.new(pattern => :bad_strings) }
-
-        it "should map to an Enumerator for a Fuzzing method" do
-          expect(subject.rules[pattern]).to be_kind_of(Enumerable)
-        end
-      end
-
-      context "otherwise" do
-        it "should raise a TypeError" do
-          expect {
-            subject.new(pattern => Object.new)
-          }.to raise_error(TypeError)
-        end
-      end
-    end
-  end
-
-  describe "#each" do
-    let(:string) { "foo bar" }
-
-    subject { described_class.new(/o/ => ['0'], /a/ => ['@']) }
-
-    it "should apply every combination of mutation rules" do
-      expect(subject.each(string).to_a).to match_array([
-        "f0o bar",
-        "fo0 bar",
-        "f00 bar",
-        "foo b@r",
-        "f0o b@r",
-        "fo0 b@r",
-        "f00 b@r"
-      ])
-    end
-
-    context "when mutations contain Integers" do
-      subject { described_class.new(/o/ => [48]) }
-
-      it "should convert them to characters" do
-        expect(subject.each(string).to_a).to match_array([
-          "f0o bar",
-          "fo0 bar",
-          "f00 bar"
-        ])
-      end
-    end
-
-    context "when mutations contain Procs" do
-      subject { described_class.new(/o/ => [lambda { |str| str.upcase }]) }
-
-      it "should call them with the matched String" do
-        expect(subject.each(string).to_a).to match_array([
-          "fOo bar",
-          "foO bar",
-          "fOO bar"
-        ])
-      end
-    end
-  end
-end

data/spec/fuzzing/repeater_spec.rb

@@ -1,57 +0,0 @@
-require 'spec_helper'
-require 'ronin/fuzzing/repeater'
-
-describe Fuzzing::Repeater do
-  describe "#initialize" do
-    subject { described_class }
-
-    context "when lengths is an Integer" do
-      it "should coerce lengths to an Enumerable" do
-        repeator = subject.new(10)
-
-        expect(repeator.lengths).to be_kind_of(Enumerable)
-      end
-    end
-
-    context "when lengths is not Enumerable or an Integer" do
-      it "should raise a TypeError" do
-        expect {
-          subject.new(Object.new)
-        }.to raise_error(TypeError)
-      end
-    end
-  end
-
-  describe "#each" do
-    let(:repeatable) { 'A' }
-
-    context "when lengths was an Integer" do
-      let(:length) { 10 }
-
-      subject { described_class.new(length) }
-
-      it "should yield one repeated value" do
-        values = subject.each(repeatable).to_a
-        
-        expect(values).to eq([repeatable * length])
-      end
-    end
-
-    context "when lengths was Enumerable" do
-      let(:lengths) { (1..4) }
-
-      subject { described_class.new(lengths) }
-
-      it "should yield repeated values for each length" do
-        values = subject.each(repeatable).to_a
-
-        expect(values).to eq([
-          repeatable * 1,
-          repeatable * 2,
-          repeatable * 3,
-          repeatable * 4
-        ])
-      end
-    end
-  end
-end

data/spec/fuzzing/template_spec.rb

@@ -1,54 +0,0 @@
-require 'spec_helper'
-require 'ronin/fuzzing/template'
-
-describe Fuzzing::Template do
-  subject { described_class }
-
-  it "should generate Strings from CharSets" do
-    strings = subject.new([:lowercase_hexadecimal, :numeric]).to_a
-
-    expect(strings.grep(/^[0-9a-f][0-9]$/)).to eq(strings)
-  end
-
-  it "should generate Strings from lengths of CharSets" do
-    strings = subject.new([[:numeric, 2]]).to_a
-
-    expect(strings.grep(/^[0-9]{2}$/)).to eq(strings)
-  end
-
-  it "should generate Strings from varying lengths of CharSets" do
-    strings = subject.new([[:numeric, 1..2]]).to_a
-
-    expect(strings.grep(/^[0-9]{1,2}$/)).to eq(strings)
-  end
-
-  it "should generate Strings from custom CharSets" do
-    strings = subject.new([[%w[a b c], 2]]).to_a
-
-    expect(strings.grep(/^[abc]{2}$/)).to eq(strings)
-  end
-
-  it "should generate Strings containing known Strings" do
-    strings = subject.new(['foo', [%w[a b c], 2]]).to_a
-
-    expect(strings.grep(/^foo[abc]{2}$/)).to eq(strings)
-  end
-
-  it "should raise a TypeError for non String, Symbol, Enumerable CharSets" do
-    expect {
-      subject.new([[Object.new, 2]]).to_a
-    }.to raise_error(TypeError)
-  end
-
-  it "should raise an ArgumentError for unknown CharSets" do
-    expect {
-      subject.new([[:foo_bar, 2]]).to_a
-    }.to raise_error(ArgumentError)
-  end
-
-  it "should raise a TypeError for non Integer,Array,Range lengths" do
-    expect {
-      subject.new([[:numeric, 'foo']]).to_a
-    }.to raise_error(TypeError)
-  end
-end

data/spec/mixin_spec.rb

@@ -1,51 +0,0 @@
-require 'spec_helper'
-require 'ronin/mixin'
-
-module Mixins
-  module Test1
-  end
-
-  module Test2
-  end
-end
-
-describe Mixin do
-  subject do
-    Module.new do
-      include Mixin
-
-      mixin Mixins::Test1, Mixins::Test2
-      mixin { @var = 1 }
-    end
-  end
-
-  context "when included" do
-    let(:klass) do
-      Class.new.tap { |klass| klass.send :include, subject }
-    end
-
-    it "should include the mixed in modules" do
-      expect(klass).to include(Mixins::Test1)
-      expect(klass).to include(Mixins::Test2)
-    end
-
-    it "should evaluate the mixin block" do
-      expect(klass.instance_variable_get("@var")).to eq(1)
-    end
-  end
-
-  context "when extended" do
-    let(:object) do
-      Object.new.tap { |obj| obj.extend(subject) }
-    end
-
-    it "should extend the mixed in modules" do
-      expect(object).to be_kind_of(Mixins::Test1)
-      expect(object).to be_kind_of(Mixins::Test2)
-    end
-
-    it "should evaluate the mixin block" do
-      expect(object.instance_variable_get("@var")).to eq(1)
-    end
-  end
-end

data/spec/network/dns_spec.rb

@@ -1,203 +0,0 @@
-require 'spec_helper'
-require 'ronin/network/dns'
-
-require 'ipaddr'
-
-describe Network::DNS do
-  let(:server) { '4.2.2.1' }
-
-  describe "nameserver" do
-    it "should be nil by default" do
-      expect(subject.nameserver).to be_nil
-    end
-  end
-
-  describe "nameserver=" do
-    it "should accept Strings" do
-      subject.nameserver = server
-
-      expect(subject.nameserver).to eq(server)
-    end
-
-    it "should accept nil" do
-      subject.nameserver = server
-      subject.nameserver = nil
-
-      expect(subject.nameserver).to be_nil
-    end
-
-    it "should convert non-nil values to Strings" do
-      subject.nameserver = IPAddr.new(server)
-
-      expect(subject.nameserver).to eq(server)
-    end
-  end
-
-  describe "#dns_resolver" do
-    subject do
-      obj = Object.new
-      obj.extend described_class
-      obj
-    end
-
-    it "should return Resolv when passed no nameserver" do
-      expect(subject.dns_resolver(nil)).to eq(Resolv)
-    end
-
-    it "should return Resolv::DNS when passed a nameserver" do
-      expect(subject.dns_resolver(server)).to be_kind_of(Resolv::DNS)
-    end
-  end
-
-  describe "helper methods", :network do
-    let(:hostname)         { 'example.com' }
-    let(:bad_hostname)     { 'foo.bar' }
-    let(:address)          { '93.184.216.34' }
-    let(:bad_address)      { '0.0.0.0' }
-    let(:reverse_address)  { '192.0.43.10' }
-    let(:reverse_ipaddr)   { IPAddr.new(reverse_address) }
-    let(:reverse_hostname) { '43-10.any.icann.org' }
-
-    subject do
-      obj = Object.new
-      obj.extend described_class
-      obj
-    end
-
-    describe "#dns_lookup" do
-      it "should lookup the address for a hostname" do
-        expect(subject.dns_lookup(hostname)).to eq(address)
-      end
-
-      it "should return nil for unknown hostnames" do
-        expect(subject.dns_lookup(bad_hostname)).to be_nil
-      end
-
-      it "should accept non-String hostnames" do
-        expect(subject.dns_lookup(hostname.to_sym)).to eq(address)
-      end
-
-      it "should accept an additional nameserver argument" do
-        expect(subject.dns_lookup(hostname,server)).to eq(address)
-      end
-
-      context "when given a block" do
-        it "should yield the resolved address" do
-          resolved_address = nil
-
-          subject.dns_lookup(hostname) do |address|
-            resolved_address = address
-          end
-
-          expect(resolved_address).to eq(address)
-        end
-
-        it "should not yield unresolved addresses" do
-          resolved_address = nil
-
-          subject.dns_lookup(bad_hostname) do |address|
-            resolved_address = address
-          end
-
-          expect(resolved_address).to be_nil
-        end
-      end
-    end
-
-    describe "#dns_lookup_all" do
-      it "should lookup all addresses for a hostname" do
-        expect(subject.dns_lookup_all(hostname)).to include(address)
-      end
-
-      it "should return an empty Array for unknown hostnames" do
-        expect(subject.dns_lookup_all(bad_hostname)).to eq([])
-      end
-
-      it "should accept non-String hostnames" do
-        expect(subject.dns_lookup_all(hostname.to_sym)).to include(address)
-      end
-
-      it "should accept an additional nameserver argument" do
-        expect(subject.dns_lookup_all(hostname,server)).to include(address)
-      end
-
-      context "when given a block" do
-        it "should yield the resolved address" do
-          expect(subject.enum_for(:dns_lookup,hostname).to_a).to eq([address])
-        end
-
-        it "should not yield unresolved addresses" do
-          expect(subject.enum_for(:dns_lookup,bad_hostname).to_a).to eq([])
-        end
-      end
-    end
-
-    describe "#dns_reverse_lookup" do
-      it "should lookup the address for a hostname" do
-        expect(subject.dns_reverse_lookup(reverse_address)).to eq(reverse_hostname)
-      end
-
-      it "should return nil for unknown hostnames" do
-        expect(subject.dns_reverse_lookup(bad_address)).to be_nil
-      end
-
-      it "should accept non-String addresses" do
-        expect(subject.dns_reverse_lookup(reverse_ipaddr)).to eq(reverse_hostname)
-      end
-
-      it "should accept an additional nameserver argument" do
-        expect(subject.dns_reverse_lookup(reverse_address,server)).to eq(reverse_hostname)
-      end
-
-      context "when given a block" do
-        it "should yield the resolved hostname" do
-          resolved_hostname = nil
-
-          subject.dns_reverse_lookup(reverse_address) do |hostname|
-            resolved_hostname = hostname
-          end
-
-          expect(resolved_hostname).to eq(reverse_hostname)
-        end
-
-        it "should not yield unresolved hostnames" do
-          resolved_hostname = nil
-
-          subject.dns_reverse_lookup(bad_address) do |hostname|
-            resolved_hostname = hostname
-          end
-
-          expect(resolved_hostname).to be_nil
-        end
-      end
-    end
-
-    describe "#dns_reverse_lookup_all" do
-      it "should lookup all addresses for a hostname" do
-        expect(subject.dns_reverse_lookup_all(reverse_address)).to include(reverse_hostname)
-      end
-
-      it "should return an empty Array for unknown hostnames" do
-        expect(subject.dns_reverse_lookup_all(bad_address)).to eq([])
-      end
-
-      it "should accept non-String addresses" do
-        expect(subject.dns_reverse_lookup_all(reverse_ipaddr)).to include(reverse_hostname)
-      end
-
-      it "should accept an additional nameserver argument" do
-        expect(subject.dns_reverse_lookup_all(reverse_address,server)).to include(reverse_hostname)
-      end
-
-      context "when given a block" do
-        it "should yield the resolved hostnames" do
-          expect(subject.enum_for(:dns_reverse_lookup_all,reverse_address).to_a).to eq([reverse_hostname])
-        end
-
-        it "should not yield unresolved hostnames" do
-          expect(subject.enum_for(:dns_reverse_lookup_all,bad_address).to_a).to eq([])
-        end
-      end
-    end
-  end
-end

data/spec/network/ftp_spec.rb

@@ -1,81 +0,0 @@
-require 'spec_helper'
-require 'ronin/network/ftp'
-
-describe Network::FTP do
-  describe "helpers", :network do
-    subject do
-      obj = Object.new
-      obj.extend described_class
-      obj
-    end
-
-    let(:host) { 'ftp.osuosl.org' }
-
-    describe "#ftp_connect" do
-      it "should return a Net::FTP object" do
-        ftp = subject.ftp_connect(host)
-
-        expect(ftp).to be_kind_of(Net::FTP)
-        ftp.close
-      end
-
-      it "should connect to an FTP service" do
-        ftp = subject.ftp_connect(host)
-
-        expect(ftp).not_to be_closed
-        ftp.close
-      end
-
-      describe ":passive" do
-        it "should set passive mode by default" do
-          ftp = subject.ftp_connect(host)
-
-          expect(ftp.passive).to be(true)
-          ftp.close
-        end
-
-        it "should allow disabling passive mode" do
-          ftp = subject.ftp_connect(host, :passive => false)
-
-          expect(ftp.passive).to be(false)
-          ftp.close
-        end
-      end
-
-      context "when given a block" do
-        it "should yield the new Net::FTP object" do
-          ftp = subject.ftp_connect(host) do |ftp|
-            expect(ftp).to be_kind_of(Net::FTP)
-          end
-
-          ftp.close
-        end
-      end
-    end
-
-    describe "#ftp_session" do
-      it "should yield a new Net::FTP object" do
-        yielded_ftp = nil
-
-        subject.ftp_session(host) do |ftp|
-          yielded_ftp = ftp
-        end
-
-        expect(yielded_ftp).to be_kind_of(Net::FTP)
-      end
-
-      it "should close the FTP session after yielding it" do
-        session  = nil
-        was_open = nil
-
-        subject.ftp_session(host) do |ftp|
-          session   = ftp
-          was_open  = !ftp.closed?
-        end
-
-        expect(was_open).to be(true)
-        expect(session).to be_closed
-      end
-    end
-  end
-end