ronin-exploits 1.0.0.beta2 → 1.0.0.beta3

data/spec/metadata/default_port_spec.rb

@@ -1,62 +0,0 @@
-require 'spec_helper'
-require 'ronin/exploits/metadata/default_port'
-
-describe Ronin::Exploits::Metadata::DefaultPort do
-  module TestMetadataDefaultPort
-    class WithNoDefaultPortSet
-      include Ronin::Exploits::Metadata::DefaultPort
-    end
-
-    class WithDefaultPortSet
-      include Ronin::Exploits::Metadata::DefaultPort
-
-      default_port 111
-    end
-
-    class InheritsItsDefaultPort < WithDefaultPortSet
-      include Ronin::Exploits::Metadata::DefaultPort
-    end
-
-    class OverridesItsInheritedDefaultPort < WithDefaultPortSet
-      include Ronin::Exploits::Metadata::DefaultPort
-
-      default_port 222
-    end
-  end
-
-  describe ".default_port" do
-    subject { test_class }
-
-    context "and when default port is not set in the class" do
-      let(:test_class) { TestMetadataDefaultPort::WithNoDefaultPortSet }
-
-      it "must default to nil" do
-        expect(subject.default_port).to be(nil)
-      end
-    end
-
-    context "and when default port is set in the class" do
-      let(:test_class) { TestMetadataDefaultPort::WithDefaultPortSet }
-
-      it "must return the set default_port" do
-        expect(subject.default_port).to eq(111)
-      end
-    end
-
-    context "but when the default port was set in the superclass" do
-      let(:test_class) { TestMetadataDefaultPort::InheritsItsDefaultPort }
-
-      it "must return the default port set in the superclass" do
-        expect(subject.default_port).to eq(111)
-      end
-
-      context "but the default port is overridden in the sub-class" do
-        let(:test_class) { TestMetadataDefaultPort::OverridesItsInheritedDefaultPort }
-
-        it "must return the default port set in the sub-class" do
-          expect(subject.default_port).to eq(222)
-        end
-      end
-    end
-  end
-end

data/spec/metadata/header_name_spec.rb

@@ -1,67 +0,0 @@
-require 'spec_helper'
-require 'ronin/exploits/metadata/header_name'
-
-describe Ronin::Exploits::Metadata::HeaderName do
-  describe ".header_name" do
-    subject { test_class }
-
-    context "and when header_name is not set in the class" do
-      module TestMetadataHeaderName
-        class WithNoHeaderNameSet
-          include Ronin::Exploits::Metadata::HeaderName
-        end
-      end
-
-      let(:test_class) { TestMetadataHeaderName::WithNoHeaderNameSet }
-
-      it "must default to nil" do
-        expect(subject.header_name).to be(nil)
-      end
-    end
-
-    context "and when header_name is set in the class" do
-      module TestMetadataHeaderName
-        class WithHeaderNameSet
-          include Ronin::Exploits::Metadata::HeaderName
-
-          header_name 'test'
-        end
-      end
-
-      let(:test_class) { TestMetadataHeaderName::WithHeaderNameSet }
-
-      it "must return the set header_name" do
-        expect(subject.header_name).to eq("test")
-      end
-    end
-
-    context "but when the header_name was set in the superclass" do
-      module TestMetadataHeaderName
-        class InheritsItsHeaderName < WithHeaderNameSet
-        end
-      end
-
-      let(:test_class) { TestMetadataHeaderName::InheritsItsHeaderName }
-
-      it "must return the header_name set in the superclass" do
-        expect(subject.header_name).to eq("test")
-      end
-
-      context "but the header_name is overridden in the sub-class" do
-        module TestMetadataHeaderName
-          class OverridesItsInheritedHeaderName < WithHeaderNameSet
-            header_name "test2"
-          end
-        end
-
-        let(:test_class) do
-          TestMetadataHeaderName::OverridesItsInheritedHeaderName
-        end
-
-        it "must return the header_name set in the sub-class" do
-          expect(subject.header_name).to eq("test2")
-        end
-      end
-    end
-  end
-end

data/spec/metadata/os_spec.rb

@@ -1,164 +0,0 @@
-require 'spec_helper'
-require 'ronin/exploits/metadata/os'
-
-describe Ronin::Exploits::Metadata::OS do
-  module TestMetadataOS
-    class WithNoOSSet
-      include Ronin::Exploits::Metadata::OS
-    end
-
-    class WithOSSet
-      include Ronin::Exploits::Metadata::OS
-
-      os :linux
-    end
-
-    class InheritsItsOS < WithOSSet
-      include Ronin::Exploits::Metadata::OS
-    end
-
-    class OverridesItsInheritedOS < WithOSSet
-      include Ronin::Exploits::Metadata::OS
-
-      os :macos
-    end
-
-    class WithNoOSVersionSet
-      include Ronin::Exploits::Metadata::OS
-
-      os :linux
-    end
-
-    class WithOSVersionSet
-      include Ronin::Exploits::Metadata::OS
-
-      os :linux
-      os_version '5.x'
-    end
-
-    class InheritsItsOSVersion < WithOSVersionSet
-      include Ronin::Exploits::Metadata::OS
-    end
-
-    class OverridesItsInheritedOSVersion < WithOSVersionSet
-      include Ronin::Exploits::Metadata::OS
-
-      os :macos
-      os_version '13'
-    end
-  end
-
-  describe ".os" do
-    subject { test_class }
-
-    context "and when os is not set in the class" do
-      let(:test_class) { TestMetadataOS::WithNoOSSet }
-
-      it "must default to nil" do
-        expect(subject.os).to be(nil)
-      end
-    end
-
-    context "and when os is set in the class" do
-      let(:test_class) { TestMetadataOS::WithOSSet }
-
-      it "must return the set os" do
-        expect(subject.os).to eq(:linux)
-      end
-    end
-
-    context "but when the os was set in the superclass" do
-      let(:test_class) { TestMetadataOS::InheritsItsOS }
-
-      it "must return the os set in the superclass" do
-        expect(subject.os).to eq(:linux)
-      end
-
-      context "but the os is overridden in the sub-class" do
-        let(:test_class) { TestMetadataOS::OverridesItsInheritedOS }
-
-        it "must return the os set in the sub-class" do
-          expect(subject.os).to eq(:macos)
-        end
-      end
-    end
-  end
-
-  describe ".os_version" do
-    subject { test_class }
-
-    context "and when os is not set in the class" do
-      let(:test_class) { TestMetadataOS::WithNoOSVersionSet }
-
-      it "must default to nil" do
-        expect(subject.os_version).to be(nil)
-      end
-    end
-
-    context "and when os_version is set in the class" do
-      let(:test_class) { TestMetadataOS::WithOSVersionSet }
-
-      it "must return the set os_version" do
-        expect(subject.os_version).to eq('5.x')
-      end
-    end
-
-    context "but when the os was set in the superclass" do
-      let(:test_class) { TestMetadataOS::InheritsItsOSVersion }
-
-      it "must return the os_version set in the superclass" do
-        expect(subject.os_version).to eq('5.x')
-      end
-
-      context "but the os is overridden in the sub-class" do
-        let(:test_class) do
-          TestMetadataOS::OverridesItsInheritedOSVersion
-        end
-
-        it "must return the os_version set in the sub-class" do
-          expect(subject.os_version).to eq('13')
-        end
-      end
-    end
-  end
-
-  describe "#os" do
-    subject { test_class.new }
-
-    context "when the Exploit class has .os set" do
-      let(:test_class) { TestMetadataOS::WithOSSet }
-
-      it "must return the Exploit classes .os" do
-        expect(subject.os).to eq(test_class.os)
-      end
-    end
-
-    context "when the Exploit class does not have .os set" do
-      let(:test_class) { TestMetadataOS::WithNoOSSet }
-
-      it "must return nil" do
-        expect(subject.os).to be(nil)
-      end
-    end
-  end
-
-  describe "#os_version" do
-    subject { test_class.new }
-
-    context "when the Exploit class has .os_version set" do
-      let(:test_class) { TestMetadataOS::WithOSVersionSet }
-
-      it "must return the Exploit classes .os_version" do
-        expect(subject.os_version).to eq(test_class.os_version)
-      end
-    end
-
-    context "when the Exploit class does not have .os_version set" do
-      let(:test_class) { TestMetadataOS::WithNoOSVersionSet }
-
-      it "must return nil" do
-        expect(subject.os_version).to be(nil)
-      end
-    end
-  end
-end

data/spec/metadata/shouts_spec.rb

@@ -1,100 +0,0 @@
-require 'spec_helper'
-require 'ronin/exploits/metadata/shouts'
-
-describe Ronin::Exploits::Metadata::Shouts do
-  describe ".shouts" do
-    subject { test_class }
-
-    context "and when shouts is not set in the class" do
-      module TestMetadataShouts
-        class WithNoShoutsSet
-          include Ronin::Exploits::Metadata::Shouts
-        end
-      end
-
-      let(:test_class) { TestMetadataShouts::WithNoShoutsSet }
-
-      it "must default to []" do
-        expect(subject.shouts).to eq([])
-      end
-    end
-
-    context "and when shouts is set in the class" do
-      module TestMetadataShouts
-        class WithShoutsSet
-          include Ronin::Exploits::Metadata::Shouts
-
-          shouts [
-            'https://example.com/link1',
-            'https://example.com/link2'
-          ]
-        end
-      end
-
-      let(:test_class) { TestMetadataShouts::WithShoutsSet }
-
-      it "must return the set shouts" do
-        expect(subject.shouts).to eq(
-          [
-            'https://example.com/link1',
-            'https://example.com/link2'
-          ]
-        )
-      end
-    end
-
-    context "but when the shouts was set in the superclass" do
-      module TestMetadataShouts
-        class InheritsItsShouts < WithShoutsSet
-          include Ronin::Exploits::Metadata::Shouts
-        end
-      end
-
-      let(:test_class) { TestMetadataShouts::InheritsItsShouts }
-
-      it "must return the shouts set in the superclass" do
-        expect(subject.shouts).to eq(
-          [
-            'https://example.com/link1',
-            'https://example.com/link2'
-          ]
-        )
-      end
-
-      context "but the shouts is overridden in the sub-class" do
-        module TestMetadataShouts
-          class OverridesItsInheritedShouts < WithShoutsSet
-            include Ronin::Exploits::Metadata::Shouts
-
-            shouts [
-              'https://example.com/link3'
-            ]
-          end
-        end
-
-        let(:test_class) do
-          TestMetadataShouts::OverridesItsInheritedShouts
-        end
-
-        it "must return the shouts in the sub-class and the superclass" do
-          expect(subject.shouts).to eq(
-            [
-              'https://example.com/link1',
-              'https://example.com/link2',
-              'https://example.com/link3'
-            ]
-          )
-        end
-
-        it "must not modify the superclass'es shouts" do
-          expect(subject.superclass.shouts).to eq(
-            [
-              'https://example.com/link1',
-              'https://example.com/link2'
-            ]
-          )
-        end
-      end
-    end
-  end
-end

data/spec/metadata/url_path_spec.rb

@@ -1,67 +0,0 @@
-require 'spec_helper'
-require 'ronin/exploits/metadata/url_path'
-
-describe Ronin::Exploits::Metadata::URLPath do
-  describe ".url_path" do
-    subject { test_class }
-
-    context "and when url_path is not set in the class" do
-      module TestMetadataURLPath
-        class WithNoURLPathSet
-          include Ronin::Exploits::Metadata::URLPath
-        end
-      end
-
-      let(:test_class) { TestMetadataURLPath::WithNoURLPathSet }
-
-      it "must default to '/'" do
-        expect(subject.url_path).to eq('/')
-      end
-    end
-
-    context "and when url_path is set in the class" do
-      module TestMetadataURLPath
-        class WithURLPathSet
-          include Ronin::Exploits::Metadata::URLPath
-
-          url_path '/test'
-        end
-      end
-
-      let(:test_class) { TestMetadataURLPath::WithURLPathSet }
-
-      it "must return the set url_path" do
-        expect(subject.url_path).to eq("/test")
-      end
-    end
-
-    context "but when the url_path was set in the superclass" do
-      module TestMetadataURLPath
-        class InheritsItsURLPath < WithURLPathSet
-        end
-      end
-
-      let(:test_class) { TestMetadataURLPath::InheritsItsURLPath }
-
-      it "must return the url_path set in the superclass" do
-        expect(subject.url_path).to eq("/test")
-      end
-
-      context "but the url_path is overridden in the sub-class" do
-        module TestMetadataURLPath
-          class OverridesItsInheritedURLPath < WithURLPathSet
-            url_path "/test2"
-          end
-        end
-
-        let(:test_class) do
-          TestMetadataURLPath::OverridesItsInheritedURLPath
-        end
-
-        it "must return the url_path set in the sub-class" do
-          expect(subject.url_path).to eq("/test2")
-        end
-      end
-    end
-  end
-end

data/spec/metadata/url_query_param_spec.rb

@@ -1,67 +0,0 @@
-require 'spec_helper'
-require 'ronin/exploits/metadata/url_query_param'
-
-describe Ronin::Exploits::Metadata::URLQueryParam do
-  describe ".url_query_param" do
-    subject { test_class }
-
-    context "and when url_query_param is not set in the class" do
-      module TestMetadataURLQueryParam
-        class WithNoURLQueryParamSet
-          include Ronin::Exploits::Metadata::URLQueryParam
-        end
-      end
-
-      let(:test_class) { TestMetadataURLQueryParam::WithNoURLQueryParamSet }
-
-      it "must default to nil" do
-        expect(subject.url_query_param).to be(nil)
-      end
-    end
-
-    context "and when url_query_param is set in the class" do
-      module TestMetadataURLQueryParam
-        class WithURLQueryParamSet
-          include Ronin::Exploits::Metadata::URLQueryParam
-
-          url_query_param 'test'
-        end
-      end
-
-      let(:test_class) { TestMetadataURLQueryParam::WithURLQueryParamSet }
-
-      it "must return the set url_query_param" do
-        expect(subject.url_query_param).to eq("test")
-      end
-    end
-
-    context "but when the url_query_param was set in the superclass" do
-      module TestMetadataURLQueryParam
-        class InheritsItsURLQueryParam < WithURLQueryParamSet
-        end
-      end
-
-      let(:test_class) { TestMetadataURLQueryParam::InheritsItsURLQueryParam }
-
-      it "must return the url_query_param set in the superclass" do
-        expect(subject.url_query_param).to eq("test")
-      end
-
-      context "but the url_query_param is overridden in the sub-class" do
-        module TestMetadataURLQueryParam
-          class OverridesItsInheritedURLQueryParam < WithURLQueryParamSet
-            url_query_param "test2"
-          end
-        end
-
-        let(:test_class) do
-          TestMetadataURLQueryParam::OverridesItsInheritedURLQueryParam
-        end
-
-        it "must return the url_query_param set in the sub-class" do
-          expect(subject.url_query_param).to eq("test2")
-        end
-      end
-    end
-  end
-end

data/spec/mixins/binary_spec.rb

@@ -1,129 +0,0 @@
-require 'spec_helper'
-require 'ronin/exploits/mixins/binary'
-
-require 'ronin/exploits/exploit'
-require 'ronin/exploits/metadata/arch'
-require 'ronin/exploits/metadata/os'
-
-describe Ronin::Exploits::Mixins::Binary do
-  module TestBinaryMixin
-    class ExploitWithArchSet < Ronin::Exploits::Exploit
-      include Ronin::Exploits::Metadata::Arch
-      include Ronin::Exploits::Mixins::Binary
-
-      arch :x86
-    end
-
-    class ExploitWithoutArch < Ronin::Exploits::Exploit
-      include Ronin::Exploits::Mixins::Binary
-    end
-
-    class ExploitWithoutArchSet < Ronin::Exploits::Exploit
-      include Ronin::Exploits::Metadata::Arch
-      include Ronin::Exploits::Mixins::Binary
-    end
-
-    class ExploitWithArchSetButWithoutOSSet < Ronin::Exploits::Exploit
-      include Ronin::Exploits::Metadata::Arch
-      include Ronin::Exploits::Metadata::OS
-      include Ronin::Exploits::Mixins::Binary
-
-      arch :x86
-    end
-
-    class ExploitWithArchAndOSSet < Ronin::Exploits::Exploit
-      include Ronin::Exploits::Metadata::Arch
-      include Ronin::Exploits::Metadata::OS
-      include Ronin::Exploits::Mixins::Binary
-
-      arch :x86
-      os :linux
-    end
-  end
-
-  subject { exploit_class.new }
-
-  describe "#perform_validate" do
-    context "when the exploit class does not define an #arch method" do
-      let(:exploit_class) { TestBinaryMixin::ExploitWithoutArch }
-
-      it do
-        expect {
-          subject.perform_validate
-        }.to raise_error(Ronin::Exploits::ValidationError,"exploit #{exploit_class} did not include Ronin::Exploits::Metadata::Arch or Ronin::Exploits::Mixins::HasTargets")
-      end
-    end
-
-    context "when the exploit class's #arch method returns nil" do
-      let(:exploit_class) { TestBinaryMixin::ExploitWithoutArchSet }
-
-      it do
-        expect {
-          subject.perform_validate
-        }.to raise_error(Ronin::Exploits::ValidationError,"exploit #{exploit_class} did not include define an architecture")
-      end
-    end
-
-    context "when the exploit class defines an architecture" do
-      let(:exploit_class) { TestBinaryMixin::ExploitWithArchSet }
-
-      it do
-        expect {
-          subject.perform_validate
-        }.to_not raise_error
-      end
-    end
-  end
-
-  describe "#platform" do
-    context "when #arch returns nil" do
-      let(:exploit_class) { TestBinaryMixin::ExploitWithoutArchSet }
-
-      it "must return Ronin::Support::Binary::CTypes" do
-        expect(subject.platform).to be(Ronin::Support::Binary::CTypes)
-      end
-    end
-
-    context "when #arch returns a architecture name" do
-      let(:exploit_class) { TestBinaryMixin::ExploitWithArchSet }
-
-      it "must return the according Ronin::Support::Binary::CTypes::Arch:: module" do
-        expect(subject.platform).to be(Ronin::Support::Binary::CTypes::Arch::X86)
-      end
-
-      context "and when #os is defined" do
-        context "and it returns an OS name" do
-          let(:exploit_class) do
-            TestBinaryMixin::ExploitWithArchAndOSSet
-          end
-
-          it "must return the according Ronin::Support::Binary::CTypes::OS object with the according Ronin::Support::Binary::CTypes::Arch:: module inside it" do
-            expect(subject.platform).to be_kind_of(Ronin::Support::Binary::CTypes::OS::Linux)
-            expect(subject.platform.types).to be(Ronin::Support::Binary::CTypes::Arch::X86)
-          end
-        end
-
-        context "but it returns nil" do
-          let(:exploit_class) do
-            TestBinaryMixin::ExploitWithArchSetButWithoutOSSet
-          end
-
-          it "must still return the according Ronin::Support::Binary::CTypes::Arch:: module" do
-            expect(subject.platform).to be(Ronin::Support::Binary::CTypes::Arch::X86)
-          end
-        end
-      end
-    end
-  end
-
-  describe "#pack" do
-    let(:exploit_class) { TestBinaryMixin::ExploitWithArchSet }
-
-    let(:type)  { :uint32    }
-    let(:value) { 0x12345678 }
-
-    it "must pack the value using the type from #platform" do
-      expect(subject.pack(type,value)).to eq("\x78\x56\x34\x12".b)
-    end
-  end
-end