ronin-payloads 0.1.0.beta1 → 0.1.0

data/spec/cli/payload_methods_spec.rb

@@ -1,208 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/cli/payload_methods'
-require 'ronin/payloads/cli/command'
-
-describe Ronin::Payloads::CLI::PayloadMethods do
-  module TestPayloadMethods
-    class TestCommand < Ronin::Payloads::CLI::Command
-      include Ronin::Payloads::CLI::PayloadMethods
-    end
-  end
-
-  let(:command_class) { TestPayloadMethods::TestCommand }
-  subject { command_class.new }
-
-  describe "#load_payload" do
-    let(:payload_id) { 'html/encode' }
-
-    it "must call Payloads.load_class with the given ID" do
-      expect(Ronin::Payloads).to receive(:load_class).with(payload_id)
-      expect(subject).to_not receive(:exit)
-
-      subject.load_payload(payload_id)
-    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).to receive(:load_class).with(payload_id).and_raise(exception)
-        expect(subject).to receive(:exit).with(1)
-
-        expect {
-          subject.load_payload(payload_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).to receive(:load_class).with(payload_id).and_raise(exception)
-        expect(subject).to receive(:print_exception).with(exception)
-        expect(subject).to receive(:exit).with(-1)
-
-        expect {
-          subject.load_payload(payload_id)
-        }.to output("#{subject.command_name}: an unhandled exception occurred while loading payload #{payload_id}#{$/}").to_stderr
-      end
-    end
-  end
-
-  describe "#load_payload_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).to receive(:load_class_from_file).with(file)
-      expect(subject).to_not receive(:exit)
-
-      subject.load_payload_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).to receive(:load_class_from_file).with(file).and_raise(exception)
-        expect(subject).to receive(:exit).with(1)
-
-        expect {
-          subject.load_payload_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).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_payload_from(file)
-        }.to output(
-          "#{subject.command_name}: an unhandled exception occurred while loading payload from file #{file}#{$/}"
-        ).to_stderr
-      end
-    end
-  end
-
-  describe "#initialie_payload" do
-    let(:payload_id)    { 'test' }
-    let(:payload_class) { double('Encoder class', id: payload_id) }
-
-    it "must return a new instance of the given payload class" do
-      expect(payload_class).to receive(:new)
-
-      subject.initialize_payload(payload_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(payload_class).to receive(:new).with(**kwargs)
-
-        subject.initialize_payload(payload_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(payload_class).to receive(:new).and_raise(exception)
-        expect(subject).to receive(:exit).with(1)
-
-        expect {
-          subject.initialize_payload(payload_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(payload_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_payload(payload_class)
-        }.to output("#{subject.command_name}: an unhandled exception occurred while initializing payload #{payload_id}#{$/}").to_stderr
-      end
-    end
-  end
-
-  describe "#validate_payload" do
-    let(:payload_id) { 'test' }
-    let(:payload)    { double('Encoder instance', class_id: payload_id) }
-
-    it "must call #perform_validate on #payload" do
-      expect(payload).to receive(:perform_validate)
-
-      subject.validate_payload(payload)
-    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(payload).to receive(:perform_validate).and_raise(exception)
-        expect(subject).to receive(:exit).with(1)
-
-        expect {
-          subject.validate_payload(payload)
-        }.to output("#{subject.command_name}: failed to validate the payload #{payload_id}: #{message}#{$/}").to_stderr
-      end
-    end
-
-    context "when a Ronin::Payloads::ValidationError is raised" do
-      let(:message)   { "param foo was not set" }
-      let(:exception) do
-        Ronin::Payloads::ValidationError.new(message)
-      end
-
-      it "must print an error message and exit with 1" do
-        expect(payload).to receive(:perform_validate).and_raise(exception)
-        expect(subject).to receive(:exit).with(1)
-
-        expect {
-          subject.validate_payload(payload)
-        }.to output("#{subject.command_name}: failed to validate the payload #{payload_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(payload).to receive(:perform_validate).and_raise(exception)
-        expect(subject).to receive(:print_exception).with(exception)
-        expect(subject).to receive(:exit).with(-1)
-
-        expect {
-          subject.validate_payload(payload)
-        }.to output("#{subject.command_name}: an unhandled exception occurred while validating the payload #{payload_id}#{$/}").to_stderr
-      end
-    end
-  end
-end

data/spec/cli/printing_spec.rb

@@ -1,65 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/cli/printing'
-require 'ronin/payloads/cli/command'
-
-require 'ronin/payloads/binary_payload'
-require 'ronin/payloads/asm_payload'
-require 'ronin/payloads/shellcode_payload'
-require 'ronin/payloads/c_payload'
-require 'ronin/payloads/go_payload'
-require 'ronin/payloads/rust_payload'
-require 'ronin/payloads/java_payload'
-require 'ronin/payloads/javascript_payload'
-require 'ronin/payloads/node_js_payload'
-require 'ronin/payloads/command_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::Printing do
-  module TestCLIPrinting
-    class TestCommand < Ronin::Payloads::CLI::Command
-      include Ronin::Payloads::CLI::Printing
-    end
-  end
-
-  let(:command_class) { TestCLIPrinting::TestCommand }
-  subject { command_class.new }
-
-  describe "#payload_type" do
-    {
-      Ronin::Payloads::HTMLPayload         => 'HTML',
-      Ronin::Payloads::XMLPayload          => 'XML',
-      Ronin::Payloads::JavaScriptPayload   => 'JavaScript',
-      Ronin::Payloads::NodeJSPayload       => 'Node.js',
-      Ronin::Payloads::SQLPayload          => 'SQL',
-      Ronin::Payloads::CommandPayload      => 'Command',
-      Ronin::Payloads::ShellPayload        => 'Shell',
-      Ronin::Payloads::PowerShellPayload   => 'PowerShell',
-      Ronin::Payloads::CPayload            => 'C',
-      Ronin::Payloads::GoPayload           => 'Go',
-      Ronin::Payloads::RustPayload         => 'Rust',
-      Ronin::Payloads::JavaPayload         => 'Java',
-      Ronin::Payloads::ColdFusionPayload   => 'ColdFusion',
-      Ronin::Payloads::PHPPayload          => 'PHP',
-      Ronin::Payloads::ASMPayload          => 'ASM',
-      Ronin::Payloads::ShellcodePayload    => 'Shellcode',
-      Ronin::Payloads::BinaryPayload       => 'Binary',
-      Ronin::Payloads::Payload             => 'Custom'
-    }.each do |payload_class,type|
-      context "when the class inherits from #{payload_class}" do
-        let(:klass) { Class.new(payload_class) }
-        let(:type)  { type }
-
-        it "must return '#{type}'" do
-          expect(subject.payload_type(klass)).to eq(type)
-        end
-      end
-    end
-  end
-end

data/spec/cli/ruby_shell_spec.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/cli/ruby_shell'
-
-describe Ronin::Payloads::CLI::RubyShell do
-  describe "#initialize" do
-    it "must default #name to 'ronin-payloads'" do
-      expect(subject.name).to eq('ronin-payloads')
-    end
-
-    it "must default #context to Ronin::Payloads" do
-      expect(subject.context).to be(Ronin::Payloads)
-    end
-  end
-end

data/spec/coldfusion_payload_spec.rb

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

data/spec/command_payload_spec.rb

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

data/spec/encoders/builtin/html/encode_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/encoders/builtin/html/encode'
-
-describe Ronin::Payloads::Encoders::HTML::Encode do
-  it "must inherit from Ronin::Payloads::Encoders::HTMLEncoder" do
-    expect(described_class).to be < Ronin::Payloads::Encoders::HTMLEncoder
-  end
-
-  describe "#encode" do
-    let(:data)    { "hello world" }
-    let(:encoded) { "&#104;&#101;&#108;&#108;&#111;&#32;&#119;&#111;&#114;&#108;&#100;" }
-
-    it "must HTML encode each character" do
-      expect(subject.encode(data)).to eq(encoded)
-    end
-  end
-end

data/spec/encoders/builtin/js/encode_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/encoders/builtin/js/encode'
-
-describe Ronin::Payloads::Encoders::JS::Encode do
-  it "must inherit from Ronin::Payloads::Encoders::JavaScriptEncoder" do
-    expect(described_class).to be < Ronin::Payloads::Encoders::JavaScriptEncoder
-  end
-
-  describe "#encode" do
-    let(:data)    { "hello world" }
-    let(:encoded) { "\\x68\\x65\\x6C\\x6C\\x6F\\x20\\x77\\x6F\\x72\\x6C\\x64" }
-
-    it "must JavaScript encode each character" do
-      expect(subject.encode(data)).to eq(encoded)
-    end
-  end
-end

data/spec/encoders/builtin/powershell/encode_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/encoders/builtin/powershell/encode'
-
-describe Ronin::Payloads::Encoders::PowerShell::Encode do
-  it "must inherit from Ronin::Payloads::Encoders::PowerShellEncoder" do
-    expect(described_class).to be < Ronin::Payloads::Encoders::PowerShellEncoder
-  end
-
-  describe "#encode" do
-    let(:data)    { "hello world" }
-    let(:encoded) { "$([char]0x68)$([char]0x65)$([char]0x6c)$([char]0x6c)$([char]0x6f)$([char]0x20)$([char]0x77)$([char]0x6f)$([char]0x72)$([char]0x6c)$([char]0x64)" }
-
-    it "must PowerShell encode each character" do
-      expect(subject.encode(data)).to eq(encoded)
-    end
-  end
-end

data/spec/encoders/builtin/shell/encode_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/encoders/builtin/shell/encode'
-
-describe Ronin::Payloads::Encoders::Shell::Encode do
-  it "must inherit from Ronin::Payloads::Encoders::ShellEncoder" do
-    expect(described_class).to be < Ronin::Payloads::Encoders::ShellEncoder
-  end
-
-  describe "#encode" do
-    let(:data)    { "hello world" }
-    let(:encoded) { "\\x68\\x65\\x6c\\x6c\\x6f\\x20\\x77\\x6f\\x72\\x6c\\x64" }
-
-    it "must shell encode each character" do
-      expect(subject.encode(data)).to eq(encoded)
-    end
-  end
-end

data/spec/encoders/builtin/sql/encode_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/encoders/builtin/sql/encode'
-
-describe Ronin::Payloads::Encoders::SQL::Encode do
-  it "must inherit from Ronin::Payloads::Encoders::SQLEncoder" do
-    expect(described_class).to be < Ronin::Payloads::Encoders::SQLEncoder
-  end
-
-  describe "#encode" do
-    let(:data)    { "hello world" }
-    let(:encoded) { "0x68656c6c6f20776f726c64" }
-
-    it "must SQL encode the given String" do
-      expect(subject.encode(data)).to eq(encoded)
-    end
-  end
-end

data/spec/encoders/builtin/xml/encode_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/encoders/builtin/xml/encode'
-
-describe Ronin::Payloads::Encoders::XML::Encode do
-  it "must inherit from Ronin::Payloads::Encoders::XMLEncoder" do
-    expect(described_class).to be < Ronin::Payloads::Encoders::XMLEncoder
-  end
-
-  describe "#encode" do
-    let(:data)    { "hello world" }
-    let(:encoded) { "&#104;&#101;&#108;&#108;&#111;&#32;&#119;&#111;&#114;&#108;&#100;" }
-
-    it "must XML encode each character" do
-      expect(subject.encode(data)).to eq(encoded)
-    end
-  end
-end

data/spec/encoders/encoder_spec.rb

@@ -1,62 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/encoders/encoder'
-
-describe Ronin::Payloads::Encoders::Encoder 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::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
-
-  module TestEncoders
-    class TestEncoder < Ronin::Payloads::Encoders::Encoder
-
-      register 'test_encoder'
-
-    end
-  end
-
-  describe ".register" do
-    subject { TestEncoders::TestEncoder }
-
-    it "must register the Encoder class with Encoders.module_registry" do
-      expect(Ronin::Payloads::Encoders.registry['test_encoder']).to be(subject)
-    end
-
-    it "must also set .id" do
-      expect(subject.id).to eq('test_encoder')
-    end
-  end
-
-  describe "#validate" do
-    it "must call #validate_params" do
-      expect(subject).to receive(:validate_params)
-
-      subject.validate
-    end
-  end
-
-  describe "#encode" do
-    let(:data) { "data" }
-
-    it "must raise NotImplementedError by default" do
-      expect {
-        subject.encode(data)
-      }.to raise_error(NotImplementedError,"#{described_class}#encode was not implemented")
-    end
-  end
-end

data/spec/encoders/html_encoder_spec.rb

@@ -1,8 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/encoders/html_encoder'
-
-describe Ronin::Payloads::Encoders::HTMLEncoder do
-  it "must inherit from Ronin::Payloads::Encoders::Encoder" do
-    expect(described_class).to be < Ronin::Payloads::Encoders::Encoder
-  end
-end

data/spec/encoders/javascript_encoder_spec.rb

@@ -1,8 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/encoders/javascript_encoder'
-
-describe Ronin::Payloads::Encoders::JavaScriptEncoder do
-  it "must inherit from Ronin::Payloads::Encoders::Encoder" do
-    expect(described_class).to be < Ronin::Payloads::Encoders::Encoder
-  end
-end

data/spec/encoders/pipeline_spec.rb

@@ -1,153 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/encoders/pipeline'
-require 'ronin/payloads/encoders/encoder'
-
-describe Ronin::Payloads::Encoders::Pipeline do
-  module TestEncoderPipeline
-    class EncoderA < Ronin::Payloads::Encoders::Encoder
-
-      id 'encoder_a'
-
-      def encode(data)
-        "AAA#{data}"
-      end
-
-    end
-
-    class EncoderB < Ronin::Payloads::Encoders::Encoder
-
-      id 'encoder_b'
-
-      def encode(data)
-        "#{data}BBB"
-      end
-
-    end
-
-    class BadEncoder < Ronin::Payloads::Encoders::Encoder
-
-      id 'bad_encoder'
-
-      def encode(data)
-      end
-
-    end
-  end
-
-  describe "#initialize" do
-    subject { described_class.new }
-
-    it "must initialize #encoders to an empty Array" do
-      expect(subject.encoders).to eq([])
-    end
-  end
-
-  let(:encoder_a) { TestEncoderPipeline::EncoderA.new }
-  let(:encoder_b) { TestEncoderPipeline::EncoderB.new }
-  let(:encoders)  { [encoder_a, encoder_b] }
-
-  subject { described_class.new(encoders) }
-  
-  describe "#<<" do
-    subject { described_class.new([encoder_a]) }
-
-    it "must append the encoder to the end of #encoders" do
-      subject << encoder_b
-
-      expect(subject.encoders[0]).to eq(encoder_a)
-      expect(subject.encoders[1]).to eq(encoder_b)
-    end
-
-    it "must return self" do
-      expect(subject << encoder_b).to be(subject)
-    end
-  end
-
-  describe "#empty?" do
-    context "when #encoders is empty" do
-      subject { described_class.new }
-
-      it "must return true" do
-        expect(subject.empty?).to be(true)
-      end
-    end
-
-    context "when #encoders is not empty" do
-      it "must return false" do
-        expect(subject.empty?).to be(false)
-      end
-    end
-  end
-
-  describe "#each" do
-    context "when given a block" do
-      it "must yield each encoder in #encoders" do
-        expect { |b|
-          subject.each(&b)
-        }.to yield_successive_args(*subject.encoders)
-      end
-    end
-
-    context "when no block is given" do
-      it "must return an Enumerator" do
-        expect(subject.each.to_a).to eq(subject.encoders)
-      end
-    end
-  end
-
-  describe "#validate" do
-    it "must also call #validate on each encoder in #encoders" do
-      expect(encoder_a).to receive(:validate)
-      expect(encoder_b).to receive(:validate)
-
-      subject.validate
-    end
-  end
-
-  describe "#[]" do
-    context "when given an Integer" do
-      it "must return the encoder at the given index" do
-        expect(subject[0]).to eq(encoders[0])
-        expect(subject[1]).to eq(encoders[1])
-      end
-    end
-
-    context "when given a String" do
-      it "must return the encoder with the matching id" do
-        expect(subject['encoder_a'].class_id).to eq('encoder_a')
-        expect(subject['encoder_b'].class_id).to eq('encoder_b')
-      end
-
-      context "but there is no encoder with the matching id" do
-        it "must return nil" do
-          expect(subject['foo']).to be(nil)
-        end
-      end
-    end
-  end
-
-  describe "#encode" do
-    let(:payload) { "foo" }
-
-    it "must pass the given payload String through each encoder" do
-      expect(subject.encode(payload)).to eq("AAA#{payload}BBB")
-    end
-
-    it "must not change the given payload String" do
-      subject.encode(payload)
-
-      expect(payload).to eq("foo")
-    end
-
-    context "when one of the encoders in #encoders does not return a String" do
-      let(:bad_encoder) { TestEncoderPipeline::BadEncoder.new }
-      before { subject << bad_encoder }
-
-      it do
-        expect {
-          subject.encode(payload)
-        }.to raise_error(Ronin::Payloads::Encoders::BadEncoder,"no result was returned by the encoder: #{bad_encoder.inspect}")
-      end
-    end
-  end
-end

data/spec/encoders/powershell_encoder_spec.rb

@@ -1,8 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/encoders/powershell_encoder'
-
-describe Ronin::Payloads::Encoders::PowerShellEncoder do
-  it "must inherit from Ronin::Payloads::Encoders::Encoder" do
-    expect(described_class).to be < Ronin::Payloads::Encoders::Encoder
-  end
-end

data/spec/encoders/shell_encoder_spec.rb

@@ -1,8 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/encoders/shell_encoder'
-
-describe Ronin::Payloads::Encoders::ShellEncoder do
-  it "must inherit from Ronin::Payloads::Encoders::Encoder" do
-    expect(described_class).to be < Ronin::Payloads::Encoders::Encoder
-  end
-end

data/spec/encoders/sql_encoder_spec.rb

@@ -1,8 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/encoders/sql_encoder'
-
-describe Ronin::Payloads::Encoders::SQLEncoder do
-  it "must inherit from Ronin::Payloads::Encoders::Encoder" do
-    expect(described_class).to be < Ronin::Payloads::Encoders::Encoder
-  end
-end