ronin-exploits 0.3.1 → 1.0.0.beta1

data/spec/metadata/default_port_spec.rb

@@ -0,0 +1,62 @@
+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

@@ -0,0 +1,67 @@
+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

@@ -0,0 +1,164 @@
+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

@@ -0,0 +1,100 @@
+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

@@ -0,0 +1,67 @@
+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

@@ -0,0 +1,67 @@
+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

@@ -0,0 +1,129 @@
+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