ronin-payloads 0.1.0.beta1 → 0.1.0

data/spec/c_payload_spec.rb

@@ -1,139 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/c_payload'
-
-describe Ronin::Payloads::CPayload do
-  it "must inherit from Ronin::Payloads::BinaryPayload" do
-    expect(described_class.superclass).to be(Ronin::Payloads::BinaryPayload)
-  end
-
-  describe ".cc" do
-    subject { described_class }
-
-    before do
-      @cc = ENV['CC']
-      ENV.delete('CC')
-    end
-
-    context "when ENV['CC'] is set" do
-      let(:cc) { 'gcc' }
-
-      before { ENV['CC'] = cc }
-
-      it "must return ENV['CC']" do
-        expect(subject.cc).to eq(cc)
-      end
-
-      after { ENV.delete('CC') }
-    end
-
-    context "when ENV['CC'] is not set" do
-      it "must return 'cc'" do
-        expect(subject.cc).to eq('cc')
-      end
-    end
-
-    after { ENV['CC'] = @cc if @cc }
-  end
-
-  describe "params" do
-    subject { described_class }
-
-    it "must define a :cc param" do
-      expect(subject.params[:cc]).to_not be_nil
-    end
-
-    it "must default the :cc param to #{described_class}.cc" do
-      expect(subject.params[:cc].default_value).to eq(subject.cc)
-    end
-  end
-
-  describe "#compile" do
-    let(:source_files) { %w[foo.c bar.c baz.c] }
-    let(:output)       { 'output' } 
-
-    it "must call system with params[:cc], the output and source files" do
-      expect(subject).to receive(:system).with(
-        subject.params[:cc],'-o',output,*source_files
-      ).and_return(true)
-
-      subject.compile(*source_files, output: output)
-    end
-
-    context "when the defs: keyword argument is given" do
-      context "and it's an Array" do
-        let(:def1) { 'foo' }
-        let(:def2) { 'bar=baz' }
-        let(:defs) { [def1, def2] }
-
-        it "must append the values with '-D' flags" do
-          expect(subject).to receive(:system).with(
-            subject.params[:cc],
-            '-o', output,
-            "-D#{def1}",
-            "-D#{def2}",
-            *source_files
-          ).and_return(true)
-
-          subject.compile(*source_files, output: output, defs: defs)
-        end
-      end
-
-      context "and it's a Hash" do
-        let(:name1)  { "foo" }
-        let(:value1) { "1"   }
-        let(:name2)  { "bar" }
-        let(:value2) { "2"   }
-
-        let(:def1) { "#{name1}=#{value1}" }
-        let(:def2) { "#{name2}=#{value2}" }
-        let(:defs) { {name1 => value1, name2 => value2} }
-
-        it "must append the values with '-D' flags" do
-          expect(subject).to receive(:system).with(
-            subject.params[:cc],
-            '-o', output,
-            "-D#{def1}",
-            "-D#{def2}",
-            *source_files
-          ).and_return(true)
-
-          subject.compile(*source_files, output: output, defs: defs)
-        end
-      end
-
-      context "but it's not an Array or a Hash" do
-        let(:defs) { Object.new }
-
-        it do
-          expect {
-            subject.compile(*source_files, output: output, defs: defs)
-          }.to raise_error(ArgumentError,"defs must be either an Array or a Hash: #{defs.inspect}")
-        end
-      end
-    end
-
-    context "when system() returns false" do
-      let(:source_file) { 'foo.go' }
-
-      it do
-        allow(subject).to receive(:system).and_return(false)
-
-        expect {
-          subject.compile(source_file, output: output)
-        }.to raise_error(Ronin::Payloads::BuildFailed,"cc command failed: #{subject.params[:cc]} -o #{output} #{source_file}")
-      end
-    end
-
-    context "when system() returns nil" do
-      let(:source_file) { 'foo.go' }
-
-      it do
-        allow(subject).to receive(:system).and_return(nil)
-
-        expect {
-          subject.compile(source_file, output: output)
-        }.to raise_error(Ronin::Payloads::BuildFailed,"cc command not installed")
-      end
-    end
-  end
-end

data/spec/cli/commands/show_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/cli/commands/show'
-
-require 'ronin/payloads/binary_payload'
-require 'ronin/payloads/asm_payload'
-require 'ronin/payloads/shellcode_payload'
-require 'ronin/payloads/c_payload'
-require 'ronin/payloads/java_payload'
-require 'ronin/payloads/javascript_payload'
-require 'ronin/payloads/node_js_payload'
-require 'ronin/payloads/shell_payload'
-require 'ronin/payloads/powershell_payload'
-require 'ronin/payloads/coldfusion_payload'
-require 'ronin/payloads/php_payload'
-require 'ronin/payloads/sql_payload'
-require 'ronin/payloads/html_payload'
-require 'ronin/payloads/xml_payload'
-require 'ronin/payloads/mixins/typescript'
-
-describe Ronin::Payloads::CLI::Commands::Show do
-end

data/spec/cli/encoder_methods_spec.rb

@@ -1,275 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/cli/encoder_methods'
-require 'ronin/payloads/cli/command'
-
-describe Ronin::Payloads::CLI::EncoderMethods do
-  module TestEncoderMethods
-    class TestCommand < Ronin::Payloads::CLI::Command
-      include Ronin::Payloads::CLI::EncoderMethods
-    end
-  end
-
-  let(:command_class) { TestEncoderMethods::TestCommand }
-  subject { command_class.new }
-
-  describe "#encoder_type" do
-    context "when given a HTMLEncoder class" do
-      module TestEncoderMethods
-        class TestHTMLEncoder < Ronin::Payloads::Encoders::HTMLEncoder
-        end
-      end
-
-      let(:klass) { TestEncoderMethods::TestHTMLEncoder }
-
-      it "must return 'html'" do
-        expect(subject.encoder_type(klass)).to eq('html')
-      end
-    end
-
-    context "when given a JavaScriptEncoder class" do
-      module TestEncoderMethods
-        class TestJavaScriptEncoder < Ronin::Payloads::Encoders::JavaScriptEncoder
-        end
-      end
-
-      let(:klass) { TestEncoderMethods::TestJavaScriptEncoder }
-
-      it "must return 'javascript'" do
-        expect(subject.encoder_type(klass)).to eq('javascript')
-      end
-    end
-
-    context "when given a ShellEncoder class" do
-      module TestEncoderMethods
-        class TestShellEncoder < Ronin::Payloads::Encoders::ShellEncoder
-        end
-      end
-
-      let(:klass) { TestEncoderMethods::TestShellEncoder }
-
-      it "must return 'shell'" do
-        expect(subject.encoder_type(klass)).to eq('shell')
-      end
-    end
-
-    context "when given a PowerShellEncoder class" do
-      module TestEncoderMethods
-        class TestPowerShellEncoder < Ronin::Payloads::Encoders::PowerShellEncoder
-        end
-      end
-
-      let(:klass) { TestEncoderMethods::TestPowerShellEncoder }
-
-      it "must return 'powershell'" do
-        expect(subject.encoder_type(klass)).to eq('powershell')
-      end
-    end
-
-    context "when given a SQLgEncoder class" do
-      module TestEncoderMethods
-        class TestSQLgEncoder < Ronin::Payloads::Encoders::SQLEncoder
-        end
-      end
-
-      let(:klass) { TestEncoderMethods::TestSQLgEncoder }
-
-      it "must return 'sql'" do
-        expect(subject.encoder_type(klass)).to eq('sql')
-      end
-    end
-  end
-
-  describe "#load_encoder" do
-    let(:encoder_id) { 'html/encode' }
-
-    it "must call Encoders.load_class with the given ID" do
-      expect(Ronin::Payloads::Encoders).to receive(:load_class).with(encoder_id)
-      expect(subject).to_not receive(:exit)
-
-      subject.load_encoder(encoder_id)
-    end
-
-    context "when Ronin::Payloads::Encoders::ClassNotfound is raised" do
-      let(:message) { "class not found" }
-      let(:exception) do
-        Ronin::Payloads::Encoders::ClassNotFound.new(message)
-      end
-
-      it "must print an error message and exit with an error code" do
-        expect(Ronin::Payloads::Encoders).to receive(:load_class).with(encoder_id).and_raise(exception)
-        expect(subject).to receive(:exit).with(1)
-
-        expect {
-          subject.load_encoder(encoder_id)
-        }.to output("#{subject.command_name}: #{message}#{$/}").to_stderr
-      end
-    end
-
-    context "when another type of exception is raised" do
-      let(:message)   { "unexpected error" }
-      let(:exception) { RuntimeError.new(message) }
-
-      it "must print the exception, an error message, and exit with -1" do
-        expect(Ronin::Payloads::Encoders).to receive(:load_class).with(encoder_id).and_raise(exception)
-        expect(subject).to receive(:print_exception).with(exception)
-        expect(subject).to receive(:exit).with(-1)
-
-        expect {
-          subject.load_encoder(encoder_id)
-        }.to output("#{subject.command_name}: an unhandled exception occurred while loading encoder #{encoder_id}#{$/}").to_stderr
-      end
-    end
-  end
-
-  describe "#load_encoder_from" do
-    let(:file) { '/path/to/html/encode.rb' }
-
-    it "must call Payloads.load_class with the given ID and file" do
-      expect(Ronin::Payloads::Encoders).to receive(:load_class_from_file).with(file)
-      expect(subject).to_not receive(:exit)
-
-      subject.load_encoder_from(file)
-    end
-
-    context "when Ronin::Payloads::ClassNotfound is raised" do
-      let(:message) { "class not found" }
-      let(:exception) do
-        Ronin::Payloads::ClassNotFound.new(message)
-      end
-
-      it "must print an error message and exit with an error code" do
-        expect(Ronin::Payloads::Encoders).to receive(:load_class_from_file).with(file).and_raise(exception)
-        expect(subject).to receive(:exit).with(1)
-
-        expect {
-          subject.load_encoder_from(file)
-        }.to output("#{subject.command_name}: #{message}#{$/}").to_stderr
-      end
-    end
-
-    context "when another type of exception is raised" do
-      let(:message)   { "unexpected error" }
-      let(:exception) { RuntimeError.new(message) }
-
-      it "must print the exception, an error message, and exit with -1" do
-        expect(Ronin::Payloads::Encoders).to receive(:load_class_from_file).with(file).and_raise(exception)
-        expect(subject).to receive(:print_exception).with(exception)
-        expect(subject).to receive(:exit).with(-1)
-
-        expect {
-          subject.load_encoder_from(file)
-        }.to output(
-          "#{subject.command_name}: an unhandled exception occurred while loading encoder from file #{file}#{$/}"
-        ).to_stderr
-      end
-    end
-  end
-
-  describe "#initialie_encoder" do
-    let(:encoder_id)    { 'test' }
-    let(:encoder_class) { double('Encoder class', id: encoder_id) }
-
-    it "must return a new instance of the given encoder class" do
-      expect(encoder_class).to receive(:new)
-
-      subject.initialize_encoder(encoder_class)
-    end
-
-    context "when additional keyword arguments are given" do
-      let(:kwargs) do
-        {foo: 1, bar: 2}
-      end
-
-      it "must pass them to new()" do
-        expect(encoder_class).to receive(:new).with(**kwargs)
-
-        subject.initialize_encoder(encoder_class,**kwargs)
-      end
-    end
-
-    context "when a Core::Params::ParamError is raised" do
-      let(:message)   { "param foo was not set" }
-      let(:exception) { Ronin::Core::Params::RequiredParam.new(message) }
-
-      it "must print an error message and exit with 1" do
-        expect(encoder_class).to receive(:new).and_raise(exception)
-        expect(subject).to receive(:exit).with(1)
-
-        expect {
-          subject.initialize_encoder(encoder_class)
-        }.to output("#{subject.command_name}: #{message}#{$/}").to_stderr
-      end
-    end
-
-    context "when another type of exception is raised" do
-      let(:message)   { "unexpected error" }
-      let(:exception) { RuntimeError.new(message) }
-
-      it "must print the exception, an error message, and exit with -1" do
-        expect(encoder_class).to receive(:new).and_raise(exception)
-        expect(subject).to receive(:print_exception).with(exception)
-        expect(subject).to receive(:exit).with(-1)
-
-        expect {
-          subject.initialize_encoder(encoder_class)
-        }.to output("#{subject.command_name}: an unhandled exception occurred while initializing encoder #{encoder_id}#{$/}").to_stderr
-      end
-    end
-  end
-
-  describe "#validate_encoder" do
-    let(:encoder_id) { 'test' }
-    let(:encoder)    { double('Encoder instance', class_id: encoder_id) }
-
-    it "must return a new instance of the given encoder class" do
-      expect(encoder).to receive(:validate)
-
-      subject.validate_encoder(encoder)
-    end
-
-    context "when a Core::Params::ParamError is raised" do
-      let(:message)   { "param foo was not set" }
-      let(:exception) { Ronin::Core::Params::RequiredParam.new(message) }
-
-      it "must print an error message and exit with 1" do
-        expect(encoder).to receive(:validate).and_raise(exception)
-        expect(subject).to receive(:exit).with(1)
-
-        expect {
-          subject.validate_encoder(encoder)
-        }.to output("#{subject.command_name}: failed to validate the encoder #{encoder_id}: #{message}#{$/}").to_stderr
-      end
-    end
-
-    context "when a Ronin::Payloads::Encoders::ValidationError is raised" do
-      let(:message)   { "param foo was not set" }
-      let(:exception) do
-        Ronin::Payloads::Encoders::ValidationError.new(message)
-      end
-
-      it "must print an error message and exit with 1" do
-        expect(encoder).to receive(:validate).and_raise(exception)
-        expect(subject).to receive(:exit).with(1)
-
-        expect {
-          subject.validate_encoder(encoder)
-        }.to output("#{subject.command_name}: failed to validate the encoder #{encoder_id}: #{message}#{$/}").to_stderr
-      end
-    end
-
-    context "when another type of exception is raised" do
-      let(:message)   { "unexpected error" }
-      let(:exception) { RuntimeError.new(message) }
-
-      it "must print the exception, an error message, and exit with -1" do
-        expect(encoder).to receive(:validate).and_raise(exception)
-        expect(subject).to receive(:print_exception).with(exception)
-        expect(subject).to receive(:exit).with(-1)
-
-        expect {
-          subject.validate_encoder(encoder)
-        }.to output("#{subject.command_name}: an unhandled exception occurred while validating the encoder #{encoder_id}#{$/}").to_stderr
-      end
-    end
-  end
-end

data/spec/cli/format_option_spec.rb

@@ -1,187 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/cli/format_option'
-require 'ronin/payloads/cli/command'
-
-require 'stringio'
-
-describe Ronin::Payloads::CLI::FormatOption do
-  module TestFormatOption
-    class TestCommand < Ronin::Payloads::CLI::Command
-      include Ronin::Payloads::CLI::FormatOption
-    end
-  end
-
-  let(:command_class) { TestFormatOption::TestCommand }
-  subject { command_class.new }
-
-  describe ".included" do
-    subject { command_class }
-
-    it "must add a -F,--format c|shell|js|ruby option" do
-      expect(subject.options[:format]).to_not be(nil)
-      expect(subject.options[:format].short).to eq('-F')
-      expect(subject.options[:format].value).to_not be(nil)
-      expect(subject.options[:format].value.type).to eq(
-        [:hex, :c, :shell, :powershell, :xml, :html, :js, :ruby]
-      )
-      expect(subject.options[:format].desc).to eq('Formats the outputed data')
-    end
-  end
-
-  describe "parse_options" do
-    context "when given '--format hex'" do
-      before { subject.parse_options(%w[--format hex]) }
-
-      it "must set #format to Ronin::Support::Encoding::Hex.escape" do
-        expect(subject.format).to eq(
-          Ronin::Support::Encoding::Hex.method(:escape)
-        )
-      end
-    end
-
-    context "when given '--format c'" do
-      before { subject.parse_options(%w[--format c]) }
-
-      it "must set #format to Ronin::Support::Encoding::C.quote" do
-        expect(subject.format).to eq(
-          Ronin::Support::Encoding::C.method(:quote)
-        )
-      end
-    end
-
-    context "when given '--format shell'" do
-      before { subject.parse_options(%w[--format shell]) }
-
-      it "must set #format to Ronin::Support::Encoding::Shell.quote" do
-        expect(subject.format).to eq(
-          Ronin::Support::Encoding::Shell.method(:quote)
-        )
-      end
-    end
-
-    context "when given '--format powershell'" do
-      before { subject.parse_options(%w[--format powershell]) }
-
-      it "must set #format to Ronin::Support::Encoding::PowerShell.quote" do
-        expect(subject.format).to eq(
-          Ronin::Support::Encoding::PowerShell.method(:quote)
-        )
-      end
-    end
-
-    context "when given '--format xml'" do
-      before { subject.parse_options(%w[--format xml]) }
-
-      it "must set #format to Ronin::Support::Encoding::XML.escape" do
-        expect(subject.format).to eq(
-          Ronin::Support::Encoding::XML.method(:escape)
-        )
-      end
-    end
-
-    context "when given '--format html'" do
-      before { subject.parse_options(%w[--format html]) }
-
-      it "must set #format to Ronin::Support::Encoding::HTML.escape" do
-        expect(subject.format).to eq(
-          Ronin::Support::Encoding::HTML.method(:escape)
-        )
-      end
-    end
-
-    context "when given '--format js'" do
-      before { subject.parse_options(%w[--format js]) }
-
-      it "must set #format to Ronin::Support::Encoding::JS.quote" do
-        expect(subject.format).to eq(
-          Ronin::Support::Encoding::JS.method(:quote)
-        )
-      end
-    end
-
-    context "when given '--format ruby'" do
-      before { subject.parse_options(%w[--format ruby]) }
-
-      it "must set #format to Ronin::Support::Encoding::Ruby.quote" do
-        expect(subject.format).to eq(
-          Ronin::Support::Encoding::Ruby.method(:quote)
-        )
-      end
-    end
-  end
-
-  describe "#format_data" do
-    let(:data) { "hello world" }
-
-    context "when #format is set" do
-      before { subject.parse_options(%w[--format html]) }
-
-      it "must call #encode on the #format" do
-        expect(subject.format_data(data)).to eq(
-          Ronin::Support::Encoding::HTML.escape(data)
-        )
-      end
-    end
-
-    context "when #format is not set" do
-      it "must return the data" do
-        expect(subject.format_data(data)).to eq(data)
-      end
-    end
-  end
-
-  describe "#print_data" do
-    let(:data) { "hello world" }
-
-    let(:stdout) { StringIO.new }
-    subject { command_class.new(stdout: stdout) }
-
-    context "when stdout is a TTY" do
-      before { expect(stdout).to receive(:tty?).and_return(true) }
-
-      context "when #format is set" do
-        before { subject.parse_options(%w[--format html]) }
-
-        it "must print the formatted data" do
-          subject.print_data(data)
-
-          expect(stdout.string).to eq(
-            "#{Ronin::Support::Encoding::HTML.escape(data)}#{$/}"
-          )
-        end
-      end
-
-      context "when #format is not set" do
-        it "must print the unformatted data" do
-          subject.print_data(data)
-
-          expect(stdout.string).to eq("#{data}#{$/}")
-        end
-      end
-    end
-
-    context "when stdout not is a TTY" do
-      before { expect(stdout).to receive(:tty?).and_return(false) }
-
-      context "when #format is set" do
-        before { subject.parse_options(%w[--format html]) }
-
-        it "must print the formatted data without a newline" do
-          subject.print_data(data)
-
-          expect(stdout.string).to eq(
-            "#{Ronin::Support::Encoding::HTML.escape(data)}"
-          )
-        end
-      end
-
-      context "when #format is not set" do
-        it "must print the unformatted data without a newline" do
-          subject.print_data(data)
-
-          expect(stdout.string).to eq(data)
-        end
-      end
-    end
-  end
-end

data/spec/cli/payload_command_spec.rb

@@ -1,68 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/cli/payload_command'
-require 'ronin/payloads/payload'
-
-describe Ronin::Payloads::CLI::PayloadCommand do
-  module TestPayloadCommand
-    class TestPayload < Ronin::Payloads::Payload
-      register 'test_payload_command'
-    end
-
-    class TestCommand < Ronin::Payloads::CLI::PayloadCommand
-    end
-  end
-
-  let(:payload_class) { TestPayloadCommand::TestPayload }
-  let(:command_class) { TestPayloadCommand::TestCommand }
-  subject { command_class.new }
-
-  describe "#load_payload" do
-    let(:id) { payload_class.id }
-
-    before do
-      expect(Ronin::Payloads).to receive(:load_class).with(id).and_return(payload_class)
-    end
-
-    it "must load the payload class and return the payload class" do
-      expect(subject.load_payload(id)).to be(payload_class)
-    end
-
-    it "must also set #payload_class" do
-      subject.load_payload(id)
-
-      expect(subject.payload_class).to be(payload_class)
-    end
-  end
-
-  describe "#load_payload_from" do
-    let(:file) { "path/to/payload/file.rb" }
-
-    before do
-      expect(Ronin::Payloads).to receive(:load_class_from_file).with(file).and_return(payload_class)
-    end
-
-    it "must load the payload class and return the payload class" do
-      expect(subject.load_payload_from(file)).to be(payload_class)
-    end
-
-    it "must also set #payload_class" do
-      subject.load_payload_from(file)
-
-      expect(subject.payload_class).to be(payload_class)
-    end
- end
-
-  describe "#initialize_payload" do
-    before { subject.load_payload(payload_class.id) }
-
-    it "must initialize a new payload object using #payload_class" do
-      expect(subject.initialize_payload).to be_kind_of(payload_class)
-    end
-
-    it "must also set #payload" do
-      subject.initialize_payload
-
-      expect(subject.payload).to be_kind_of(payload_class)
-    end
-  end
-end