ronin-payloads 0.1.0.beta1 → 0.1.1

data/spec/mixins/tempfile_spec.rb

@@ -1,97 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/mixins/tempfile'
-
-require 'ronin/payloads/payload'
-
-describe Ronin::Payloads::Mixins::Tempfile do
-  module TestFileBuilderMixin
-    class TestPayload < Ronin::Payloads::Payload
-      include Ronin::Payloads::Mixins::Tempfile
-    end
-  end
-
-  let(:payload_class) { TestFileBuilderMixin::TestPayload }
-  subject { payload_class.new }
-
-  describe "#tempfile" do
-    context "when given a block" do
-      it "must yield a new Tempfile object" do
-        expect { |b|
-          subject.tempfile(&b)
-        }.to yield_with_args(Tempfile)
-      end
-
-      it "must create the tempfile" do
-        subject.tempfile do |tempfile|
-          expect(File.file?(tempfile.path)).to be(true)
-        end
-      end
-
-      context "when given a file name" do
-        let(:name) { 'foo' }
-
-        it "must add the file name to the tempfile name" do
-          subject.tempfile(name) do |tempfile|
-            expect(tempfile.path).to match(%r{\A/tmp/ronin-payloads-#{name}-\d+-\d+-[a-z0-9]+\z})
-          end
-        end
-
-        context "when given the ext: keyword argument" do
-          let(:ext) { '.txt' }
-
-          it "must also append the file extension to the tempfile name" do
-            subject.tempfile(name, ext: ext) do |tempfile|
-              expect(tempfile.path).to match(%r{\A/tmp/ronin-payloads-#{name}-\d+-\d+-[a-z0-9]+#{Regexp.escape(ext)}\z})
-            end
-          end
-        end
-      end
-
-      context "when given the ext: keyword argument" do
-        let(:ext) { '.txt' }
-
-        it "must append the file extension to the tempfile name" do
-          subject.tempfile(ext: ext) do |tempfile|
-            expect(tempfile.path).to match(%r{\A/tmp/ronin-payloads-\d+-\d+-[a-z0-9]+#{Regexp.escape(ext)}\z})
-          end
-        end
-      end
-    end
-
-    context "when no block is given" do
-      it "must return a Tempfile object" do
-        expect(subject.tempfile).to be_kind_of(Tempfile)
-      end
-
-      context "when given a file name" do
-        let(:name) { 'foo' }
-
-        it "must add the file name to the tempfile name" do
-          tempfile = subject.tempfile(name)
-
-          expect(tempfile.path).to match(%r{\A/tmp/ronin-payloads-#{name}-\d+-\d+-[a-z0-9]+\z})
-        end
-
-        context "when given the ext: keyword argument" do
-          let(:ext) { '.txt' }
-
-          it "must also append the file extension to the tempfile name" do
-            tempfile = subject.tempfile(name, ext: ext)
-
-            expect(tempfile.path).to match(%r{\A/tmp/ronin-payloads-#{name}-\d+-\d+-[a-z0-9]+#{Regexp.escape(ext)}\z})
-          end
-        end
-      end
-
-      context "when given the ext: keyword argument" do
-        let(:ext) { '.txt' }
-
-        it "must append the file extension to the tempfile name" do
-          tempfile = subject.tempfile(ext: ext)
-
-          expect(tempfile.path).to match(%r{\A/tmp/ronin-payloads-\d+-\d+-[a-z0-9]+#{Regexp.escape(ext)}\z})
-        end
-      end
-    end
-  end
-end

data/spec/mixins/typescript_spec.rb

@@ -1,92 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/mixins/typescript'
-require 'ronin/payloads/javascript_payload'
-
-describe Ronin::Payloads::Mixins::TypeScript do
-  module TestTypeScriptMixin
-    class TestPayload < Ronin::Payloads::JavaScriptPayload
-      include Ronin::Payloads::Mixins::TypeScript
-    end
-  end
-
-  let(:payload_class) { TestTypeScriptMixin::TestPayload }
-
-  describe ".tsc" do
-    subject { described_class }
-
-    context "when ENV['TSC'] is set" do
-      let(:tsc) { 'tsc' }
-
-      before { ENV['TSC'] = tsc }
-
-      it "must return ENV['TSC']" do
-        expect(subject.tsc).to eq(tsc)
-      end
-    end
-
-    context "when ENV['TSC'] is not set" do
-      before(:all) do
-        @tsc = ENV['TSC']
-        ENV.delete('TSC')
-      end
-
-      it "must return 'tsc'" do
-        expect(subject.tsc).to eq('tsc')
-      end
-
-      after(:all) do
-        ENV['TSC'] = @tsc if @tsc
-      end
-    end
-  end
-
-  describe "params" do
-    subject { payload_class }
-
-    it "must define a :tsc param" do
-      expect(subject.params[:tsc]).to_not be_nil
-    end
-
-    it "must default the :tsc param to #{described_class}.tsc" do
-      expect(subject.params[:tsc].default_value).to eq(described_class.tsc)
-    end
-  end
-
-  subject { payload_class.new }
-
-  describe "#compile" do
-    let(:source_files) { %w[foo.ts bar.ts baz.ts] }
-
-    it "must call system with params[:tsc] and additional source files" do
-      expect(subject).to receive(:system).with(
-        subject.params[:tsc], *source_files
-      ).and_return(true)
-
-      subject.compile(*source_files)
-    end
-
-    context "when system() returns false" do
-      let(:source_file) { 'foo.ts' }
-
-      it do
-        allow(subject).to receive(:system).and_return(false)
-
-        expect {
-          subject.compile(source_file)
-        }.to raise_error(Ronin::Payloads::BuildFailed,"tsc command failed: #{subject.params[:tsc]} #{source_file}")
-      end
-    end
-
-    context "when system() returns nil" do
-      let(:source_file) { 'foo.rs' }
-
-      it do
-        allow(subject).to receive(:system).and_return(nil)
-
-        expect {
-          subject.compile(source_file)
-        }.to raise_error(Ronin::Payloads::BuildFailed,"tsc command not installed")
-      end
-    end
-  end
-end

data/spec/node_js_payload_spec.rb

@@ -1,8 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/node_js_payload'
-
-describe Ronin::Payloads::NodeJSPayload do
-  it "must inherit from Ronin::Payloads::Payload" do
-    expect(described_class.superclass).to be(Ronin::Payloads::Payload)
-  end
-end

data/spec/payload_spec.rb

@@ -1,288 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/payload'
-require 'ronin/payloads/encoders/encoder'
-
-describe Ronin::Payloads::Payload do
-  it "must include Ronin::Core::Metadata::ID" do
-    expect(described_class).to include(Ronin::Core::Metadata::ID)
-  end
-
-  it "must include Ronin::Core::Metadata::Authors" do
-    expect(described_class).to include(Ronin::Core::Metadata::Authors)
-  end
-
-  it "must include Ronin::Core::Metadata::Summary" do
-    expect(described_class).to include(Ronin::Core::Metadata::Summary)
-  end
-
-  it "must include Ronin::Core::Metadata::Description" do
-    expect(described_class).to include(Ronin::Core::Metadata::Description)
-  end
-
-  it "must include Ronin::Core::Metadata::References" do
-    expect(described_class).to include(Ronin::Core::Metadata::References)
-  end
-
-  it "must include Ronin::Core::Params::Mixin" do
-    expect(described_class).to include(Ronin::Core::Params::Mixin)
-  end
-
-  it "must include Ronin::Support::CLI::Printing" do
-    expect(described_class).to include(Ronin::Support::CLI::Printing)
-  end
-
-  describe "#build" do
-    subject { described_class.new }
-
-    it "must return nil by default" do
-      expect(subject.build).to be(nil)
-    end
-
-    it "must not set @payload by default" do
-      subject.build
-
-      expect(subject.instance_variable_get('@payload')).to be(nil)
-    end
-  end
-
-  describe "#cleanup" do
-    subject { described_class.new }
-
-    it "must return nil by default" do
-      expect(subject.cleanup).to be(nil)
-    end
-  end
-
-  module TestPayload
-    class TestEncoder < Ronin::Payloads::Encoders::Encoder
-
-      def encode(payload)
-        payload.upcase
-      end
-
-    end
-
-    class TestPayload < Ronin::Payloads::Payload
-
-      register 'test_payload'
-
-      def build
-        @payload = "the payload"
-      end
-
-    end
-  end
-
-  let(:test_encoder_class) { TestPayload::TestEncoder }
-  let(:test_encoder)       { test_encoder_class.new   }
-
-  let(:test_class) { TestPayload::TestPayload }
-  subject { test_class.new }
-
-  describe ".register" do
-    subject { test_class }
-
-    it "must register the payload class into Payloads.registry" do
-      expect(Ronin::Payloads.registry['test_payload']).to eq(subject)
-    end
-
-    it "must also set .id" do
-      expect(subject.id).to eq('test_payload')
-    end
-  end
-
-  describe "#perform_validate" do
-    it "must call #validate_params" do
-      expect(subject).to receive(:validate_params)
-
-      subject.perform_validate
-    end
-
-    it "must also call #validate" do
-      expect(subject).to receive(:validate)
-
-      subject.perform_validate
-    end
-
-    context "when #encoders is populated" do
-      let(:encoder1) { test_encoder_class.new }
-      let(:encoder2) { test_encoder_class.new }
-
-      subject { test_class.new(encoders: [encoder1, encoder2]) }
-
-      it "must also call #validate on each #encoder" do
-        expect(encoder1).to receive(:validate)
-        expect(encoder2).to receive(:validate)
-        expect(subject).to receive(:validate_params)
-
-        subject.perform_validate
-      end
-    end
-  end
-
-  describe "#built?" do
-    context "when @payload is set by #build" do
-      before { subject.build }
-
-      it "must return true" do
-        expect(subject.built?).to be(true)
-      end
-    end
-
-    context "when @payload is not set" do
-      it "must return false" do
-        expect(subject.built?).to be(false)
-      end
-    end
-  end
-
-  describe "#perform_build" do
-    subject { described_class.new }
-
-    it "must call #build and then check #built?" do
-      expect(subject).to receive(:build)
-      expect(subject).to receive(:built?).and_return(true)
-
-      subject.perform_build
-    end
-
-    context "when the #build method did not set @payload" do
-      it do
-        expect {
-          subject.perform_build
-        }.to raise_error(Ronin::Payloads::PayloadNotBuilt,/^the payload was not built for some reason: /)
-      end
-    end
-  end
-
-  describe "#built_payload" do
-    it "must return the built payload" do
-      expect(subject.built_payload).to eq("the payload")
-    end
-
-    it "must not re-build the payload when called multiple times" do
-      expect(subject.built_payload).to be(subject.built_payload)
-    end
-  end
-
-  describe "#rebuild_payload" do
-    before { subject.build }
-
-    it "must forcibly re-build the payload" do
-      previously_built_payload = subject.payload
-
-      subject.rebuild_payload
-
-      expect(subject.payload).to eq(previously_built_payload)
-      expect(subject.payload).to_not be(previously_built_payload)
-    end
-  end
-
-  describe "#encode_payload" do
-    subject { test_class.new(encoders: [test_encoder]) }
-
-    it "must encode the built payload" do
-      expect(subject.encode_payload).to eq(
-        test_encoder.encode(subject.built_payload)
-      )
-    end
-
-    it "must return a new String each time" do
-      encoded_payload = subject.encoded_payload
-
-      expect(subject.encode_payload).to eq(encoded_payload)
-      expect(subject.encode_payload).to_not be(encoded_payload)
-    end
-  end
-
-  describe "#encoded_payload" do
-    subject { test_class.new(encoders: [test_encoder]) }
-
-    it "must encode the built payload" do
-      expect(subject.encoded_payload).to eq(
-        test_encoder.encode(subject.built_payload)
-      )
-    end
-
-    it "must not re-encode the payload when called multiple times" do
-      expect(subject.encoded_payload).to be(subject.encoded_payload)
-    end
-  end
-
-  describe "#reencode_payload" do
-    subject { test_class.new(encoders: [test_encoder]) }
-
-    before { subject.encoded_payload }
-
-    it "must forcibly re-encoded the payload" do
-      previously_encoded_payload = subject.encoded_payload
-
-      subject.reencode_payload
-
-      expect(subject.encoded_payload).to eq(previously_encoded_payload)
-      expect(subject.encoded_payload).to_not be(previously_encoded_payload)
-    end
-  end
-
-  describe "#perform_prelaunch" do
-    subject { described_class.new }
-
-    it "must call #prelaunch" do
-      expect(subject).to receive(:prelaunch)
-
-      subject.perform_prelaunch
-    end
-  end
-
-  describe "#perform_postlaunch" do
-    subject { described_class.new }
-
-    it "must call #postlaunch" do
-      expect(subject).to receive(:postlaunch)
-
-      subject.perform_postlaunch
-    end
-  end
-
-  describe "#perform_cleanup" do
-    subject { described_class.new }
-
-    it "must call #cleanup" do
-      expect(subject).to receive(:cleanup)
-
-      subject.perform_cleanup
-    end
-
-    it "must set @payload to nil" do
-      subject.instance_variable_set('@payload',"foo")
-
-      subject.perform_cleanup
-
-      expect(subject.instance_variable_get('@payload')).to be(nil)
-    end
-  end
-
-  describe "#length" do
-    subject { test_class.new(encoders: [test_encoder]) }
-
-    it "must return the size of the encoded payload in bytes" do
-      expect(subject.length).to eq(subject.encoded_payload.length)
-    end
-  end
-
-  describe "#bytesize" do
-    subject { test_class.new(encoders: [test_encoder]) }
-
-    it "must return the size of the encoded payload in bytes" do
-      expect(subject.bytesize).to eq(subject.encoded_payload.bytesize)
-    end
-  end
-
-  describe "#to_s" do
-    subject { test_class.new(encoders: [test_encoder]) }
-
-    it "must return the encoded payload" do
-      expect(subject.to_s).to eq(subject.encoded_payload)
-    end
-  end
-end

data/spec/payloads_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads'
-require 'ronin/payloads/root'
-
-describe Ronin::Payloads do
-  it "should have a version" do
-    expect(subject.const_defined?('VERSION')).to eq(true)
-  end
-
-  it "must include Ronin::Core::ClassRegistry" do
-    expect(subject).to include(Ronin::Core::ClassRegistry)
-  end
-
-  it "must include Ronin::Repos::ClassDir" do
-    expect(subject).to include(Ronin::Repos::ClassDir)
-  end
-
-  it "must set .class_dir to 'ronin/payloads/builtin'" do
-    expect(subject.class_dir).to eq(
-      File.join(
-        Ronin::Payloads::ROOT, 'lib', 'ronin', 'payloads', 'builtin'
-      )
-    )
-  end
-
-  it "must set .repo_class_dir to 'payloads'" do
-    expect(subject.repo_class_dir).to eq('payloads')
-  end
-end

data/spec/php_payload_spec.rb

@@ -1,8 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/php_payload'
-
-describe Ronin::Payloads::PHPPayload do
-  it "must inherit from Ronin::Payloads::Payload" do
-    expect(described_class.superclass).to be(Ronin::Payloads::Payload)
-  end
-end

data/spec/powershell_payload_spec.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/powershell_payload'
-
-describe Ronin::Payloads::PowerShellPayload do
-  it "must inherit from Ronin::Payloads::Payload" do
-    expect(described_class.superclass).to be(Ronin::Payloads::Payload)
-  end
-
-  describe ".encoder_class" do
-    subject { described_class }
-
-    it do
-      expect(subject.encoder_class).to be(Ronin::Payloads::Encoders::PowerShellEncoder)
-    end
-  end
-end

data/spec/python_payload_spec.rb

@@ -1,8 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/python_payload'
-
-describe Ronin::Payloads::PythonPayload do
-  it "must inherit from Ronin::Payloads::Payload" do
-    expect(described_class.superclass).to be(Ronin::Payloads::Payload)
-  end
-end

data/spec/ruby_payload_spec.rb

@@ -1,8 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/ruby_payload'
-
-describe Ronin::Payloads::RubyPayload do
-  it "must inherit from Ronin::Payloads::Payload" do
-    expect(described_class.superclass).to be(Ronin::Payloads::Payload)
-  end
-end

data/spec/rust_payload_spec.rb

@@ -1,116 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/rust_payload'
-
-describe Ronin::Payloads::RustPayload do
-  it "must inherit from Ronin::Payloads::BinaryPayload" do
-    expect(described_class.superclass).to be(Ronin::Payloads::BinaryPayload)
-  end
-
-  describe "#compile" do
-    let(:source_files) { %w[foo.rs bar.rs baz.rs] }
-
-    it "must call system with `rustc` and source files" do
-      expect(subject).to receive(:system).with(
-        'rustc', *source_files
-      ).and_return(true)
-
-      subject.compile(*source_files)
-    end
-
-    context "when the output: keyword is given" do
-      let(:output) { 'output' } 
-
-      it "must call system with 'rustc', the output, and source files" do
-        expect(subject).to receive(:system).with(
-          'rustc','-o', output, *source_files
-        ).and_return(true)
-
-        subject.compile(*source_files, output: output)
-      end
-    end
-
-    context "when the target: keyword is given" do
-      let(:target) { 'aarch64-unknown-linux-gnu' } 
-
-      it "must call system with 'rustc', the target, and source files" do
-        expect(subject).to receive(:system).with(
-          'rustc','--target', target, *source_files
-        ).and_return(true)
-
-        subject.compile(*source_files, target: target)
-      end
-    end
-
-    context "when the cfg: keyword is given" do
-      context "and it's a Hash" do
-        let(:key1)   { 'foo' }
-        let(:value1) { 42    }
-        let(:key2)   { 'bar' }
-        let(:value2) { "baz" }
-        let(:cfg) do
-          {key1 => value1, key2 => value2}
-        end
-
-        it "must call system with 'rustc', --cfg='key=value' arguments, and the source files" do
-          expect(subject).to receive(:system).with(
-            'rustc', '--cfg', "#{key1}=\"#{value1}\"",
-                     '--cfg', "#{key2}=\"#{value2}\"",
-                     *source_files
-          ).and_return(true)
-
-          subject.compile(*source_files, cfg: cfg)
-        end
-      end
-
-      context "and it's an Array" do
-        let(:value1) { :foo  }
-        let(:value2) { "baz" }
-        let(:cfg)    { [value1, value2] }
-
-        it "must call system with 'rustc', --cfg='key=value' arguments, and the source files" do
-          expect(subject).to receive(:system).with(
-            'rustc', '--cfg', value1.to_s, '--cfg', value2.to_s, *source_files
-          ).and_return(true)
-
-          subject.compile(*source_files, cfg: cfg)
-        end
-      end
-
-      context "but it's not a Hash or an Array" do
-        let(:cfg) { Object.new }
-
-        it do
-          expect {
-            subject.compile(*source_files, cfg: cfg)
-          }.to raise_error(ArgumentError,"cfg value must be either a Hash or an Array: #{cfg.inspect}")
-        end
-      end
-    end
-
-    context "when system() returns false" do
-      let(:output)      { 'output' } 
-      let(:source_file) { 'foo.rs' }
-
-      it do
-        allow(subject).to receive(:system).and_return(false)
-
-        expect {
-          subject.compile(source_file, output: output)
-        }.to raise_error(Ronin::Payloads::BuildFailed,"rustc command failed: rustc -o #{output} #{source_file}")
-      end
-    end
-
-    context "when system() returns nil" do
-      let(:output)      { 'output' } 
-      let(:source_file) { 'foo.rs' }
-
-      it do
-        allow(subject).to receive(:system).and_return(nil)
-
-        expect {
-          subject.compile(source_file, output: output)
-        }.to raise_error(Ronin::Payloads::BuildFailed,"rustc command not installed")
-      end
-    end
-  end
-end

data/spec/shell_payload_spec.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/shell_payload'
-
-describe Ronin::Payloads::ShellPayload do
-  it "must inherit from Ronin::Payloads::CommandPayload" do
-    expect(described_class.superclass).to be(Ronin::Payloads::CommandPayload)
-  end
-
-  describe ".encoder_class" do
-    subject { described_class }
-
-    it do
-      expect(subject.encoder_class).to be(Ronin::Payloads::Encoders::ShellEncoder)
-    end
-  end
-end