ronin-payloads 0.1.0.beta1 → 0.1.1

data/spec/mixins/bind_shell_spec.rb

@@ -1,73 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/mixins/bind_shell'
-require 'ronin/payloads/payload'
-
-describe Ronin::Payloads::Mixins::BindShell do
-  module TestBindShellMixin
-    class TestPayload < Ronin::Payloads::Payload
-      include Ronin::Payloads::Mixins::BindShell
-    end
-  end
-
-  let(:payload_class) { TestBindShellMixin::TestPayload }
-
-  it "must also include Ronin::Payloads::Mixins::PostEx" do
-    expect(payload_class).to include(Ronin::Payloads::Mixins::PostEx)
-  end
-
-  describe ".included" do
-    subject { payload_class }
-
-    it "must add a required 'host' param" do
-      expect(subject.params[:host]).to_not be_nil
-      expect(subject.params[:host].type).to be_kind_of(Ronin::Core::Params::Types::String)
-      expect(subject.params[:host].required?).to be(true)
-      expect(subject.params[:host].desc).to eq('The host to connect to')
-    end
-
-    it "must add a required 'port' param" do
-      expect(subject.params[:port]).to_not be_nil
-      expect(subject.params[:port].type).to be_kind_of(Ronin::Core::Params::Types::Integer)
-      expect(subject.params[:port].required?).to be(true)
-      expect(subject.params[:port].desc).to eq('The port to listen on')
-    end
-  end
-
-  let(:host) { 'example.com' }
-  let(:port) { 1337 }
-
-  subject do
-    payload_class.new(params: {host: host, port: port})
-  end
-
-  describe "#host" do
-    it "must return the 'host' param value" do
-      expect(subject.host).to eq(host)
-    end
-  end
-
-  describe "#port" do
-    it "must return the 'port' param value" do
-      expect(subject.port).to eq(port)
-    end
-  end
-
-  describe "#perform_postlaunch" do
-    let(:addrinfo) { Addrinfo.tcp(host,port) }
-    let(:socket)   { double('TCPSocket') }
-
-    before { allow(socket).to receive(:remote_address).and_return(addrinfo) }
-
-    let(:session) { Ronin::PostEx::Sessions::BindShell.new(socket) }
-
-    it "must print a message about connecting to host:port, create a new Ronin::PostEx::Sesssions::BindShell session, set #session, then print a message about being connected to host:port" do
-      expect(subject).to receive(:print_info).with("Connecting to #{host}:#{port} ...")
-      expect(Ronin::PostEx::Sessions::BindShell).to receive(:connect).with(host,port).and_return(session)
-      expect(subject).to receive(:print_info).with("Connected to #{host}:#{port}!")
-
-      subject.perform_postlaunch
-
-      expect(subject.session).to be(session)
-    end
-  end
-end

data/spec/mixins/build_dir.rb

@@ -1,64 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/mixins/build_dir'
-
-require 'ronin/payloads/payload'
-
-describe Ronin::Payloads::Mixins::BuildDir do
-  module TestBuildDirMixin
-    class TestPayload < Ronin::Payloads::Payload
-      include Ronin::Payloads::Mixins::BuildDir
-
-      id 'test-payload'
-
-      def build
-        @payload = 'built payload'
-      end
-    end
-  end
-
-  let(:payload_class) { TestBuildDirMixin::TestPayload }
-  subject { payload_class.new }
-
-  describe "#perform_build" do
-    before { subject.perform_build }
-
-    it "must set #build_dir to a temporary directory using the payload ID then build the payload" do
-      expect(subject.build_dir).to match(%r{\A/tmp/ronin-payloads-#{payload_class.id}-\d+-\d+-[a-z0-9]+\z})
-      expect(File.directory?(subject.build_dir)).to be(true)
-
-      expect(subject.payload).to eq('built payload')
-    end
-
-    context "when the payload ID contains a '/'" do
-      module TestBuildDirmixin
-        class TestPayloadWithDirSeparatorInID < Ronin::Payloads::Payload
-          include Ronin::Payloads::Mixins::BuildDir
-
-          id 'test/payload'
-
-          def build
-            @payload = 'built payload'
-          end
-        end
-      end
-
-      let(:payload_class) { TestBuildDirmixin::TestPayloadWithDirSeparatorInID }
-
-      it "must replace any '/' characters with a '-'" do
-        expect(subject.build_dir).to match(%r{\A/tmp/ronin-payloads-test-payload-\d+-\d+-[a-z0-9]+\z})
-      end
-    end
-  end
-
-  describe "#perform_cleanup" do
-    it "must delete #build_dir" do
-      subject.perform_build
-
-      build_dir = subject.build_dir
-
-      subject.perform_cleanup
-
-      expect(File.exist?(build_dir)).to be(false)
-    end
-  end
-end

data/spec/mixins/erb_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/mixins/erb'
-
-require 'ronin/payloads/payload'
-
-describe Ronin::Payloads::Mixins::ERB do
-  module TestErbMixin
-    class TestPayload < Ronin::Payloads::Payload
-      include Ronin::Payloads::Mixins::ERB
-    end
-  end
-
-  let(:payload_class) { TestErbMixin::TestPayload }
-  subject { payload_class.new }
-
-  it "must include Ronin::Support::Text::ERB::Mixin" do
-    expect(payload_class).to include(Ronin::Support::Text::ERB::Mixin)
-  end
-end

data/spec/mixins/network_spec.rb

@@ -1,75 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/mixins/network'
-
-require 'ronin/payloads/payload'
-
-describe Ronin::Payloads::Mixins::Network do
-  module TestNetworkMixin
-    class TestPayload < Ronin::Payloads::Payload
-      include Ronin::Payloads::Mixins::Network
-    end
-  end
-
-  let(:payload_class) { TestNetworkMixin::TestPayload }
-  subject { payload_class.new }
-
-  describe "#pack_ipv4" do
-    context "when given an IPv4 address" do
-      let(:ip) { '1.2.3.4' }
-
-      it "must pack the IPv4 address as a 32bit integer in network byte-order" do
-        expect(subject.pack_ipv4(ip)).to eq("\x01\x02\x03\x04".b)
-      end
-
-      context "when given the `negate: true` keyword argument" do
-        it "must invert the bits of the packed IPv4 address" do
-          expect(subject.pack_ipv4(ip, negate: true)).to eq("\xfe\xfd\xfc\xfb".b)
-        end
-      end
-    end
-
-    context "when given an IPv6 address" do
-      let(:ip) { '::1' }
-
-      it do
-        expect {
-          subject.pack_ipv4(ip)
-        }.to raise_error(ArgumentError,"IP must be an IPv4 address: #{ip.inspect}")
-      end
-    end
-  end
-
-  describe "#pack_ipv6" do
-    context "when given an IPv6 address" do
-      let(:ip) { '1111:2222:3333:4444:5555:6666:7777:8888' }
-
-      it "must pack the IPv6 address as a 128bit integer in network byte-order" do
-        expect(subject.pack_ipv6(ip)).to eq("\x11\x11\x22\x22\x33\x33\x44\x44\x55\x55\x66\x66\x77\x77\x88\x88".b)
-      end
-
-      context "when given the `negate: true` keyword argument" do
-        it "must invert the bits of the packed IPv4 address" do
-          expect(subject.pack_ipv6(ip, negate: true)).to eq("\xee\xee\xdd\xdd\xcc\xcc\xbb\xbb\xaa\xaa\x99\x99\x88\x88\x77\x77".b)
-        end
-      end
-    end
-
-    context "when given an IPv4 address" do
-      let(:ip) { '1.2.3.4' }
-
-      it do
-        expect {
-          subject.pack_ipv6(ip)
-        }.to raise_error(ArgumentError,"IP must be an IPv6 address: #{ip.inspect}")
-      end
-    end
-  end
-
-  describe "#pack_port" do
-    let(:port) { 0xff00 }
-
-    it "must pack the port number as a 16bit integer in network byte-ordeR" do
-      expect(subject.pack_port(port)).to eq("\xff\x00".b)
-    end
-  end
-end

data/spec/mixins/post_ex_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/mixins/post_ex'
-
-require 'ronin/payloads/payload'
-require 'ronin/post_ex/sessions/session'
-
-describe Ronin::Payloads::Mixins::PostEx do
-  module TestPostExMixin
-    class TestPayload < Ronin::Payloads::Payload
-      include Ronin::Payloads::Mixins::PostEx
-    end
-  end
-
-  let(:payload_class) { TestPostExMixin::TestPayload }
-  subject { payload_class.new }
-
-  let(:session) { Ronin::PostEx::Sessions::Session.new }
-
-  describe "#session=" do
-    before { subject.session = session }
-
-    it "must set #session" do
-      expect(subject.session).to be(session)
-    end
-  end
-
-  describe "#perform_cleanup" do
-    context "when #session is set" do
-      before { subject.session = session }
-
-      it "must call #session.close and set #session to nil" do
-        expect(session).to receive(:close)
-
-        subject.perform_cleanup
-
-        expect(subject.session).to be(nil)
-      end
-    end
-  end
-end

data/spec/mixins/resolve_host_spec.rb

@@ -1,322 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/mixins/resolve_host'
-
-require 'ronin/payloads/payload'
-require 'resolv'
-
-describe Ronin::Payloads::Mixins::ResolveHost do
-  module TestResolveHostMixin
-    class TestPayload < Ronin::Payloads::Payload
-      include Ronin::Payloads::Mixins::ResolveHost
-
-      param :host, String, desc: 'The host name'
-    end
-  end
-
-  let(:host) { 'example.com' }
-  let(:ipv4_addresses) { %w[93.184.216.34] }
-  let(:ipv6_addresses) { %w[2606:2800:220:1:248:1893:25c8:1946] }
-  let(:ip_addresses)   { ipv4_addresses + ipv6_addresses }
-  let(:addresses)      { Resolv.getaddresses(host) }
-
-  let(:payload_class) { TestResolveHostMixin::TestPayload }
-  subject do
-    payload_class.new(
-      params: {
-        host: host
-      }
-    )
-  end
-
-  describe "#host_addresses" do
-    context "when the host has addresses" do
-      it "must return the IPv4 and IPv6 addresses for the host" do
-        expect(subject.host_addresses).to eq(addresses)
-      end
-    end
-
-    context "when the host is an IPv4 address" do
-      let(:host) { '127.0.0.1' }
-
-      it "must return an Array containing the host" do
-        expect(subject.host_addresses).to eq([host])
-      end
-    end
-
-    context "when the host is an IPv6 address" do
-      let(:host) { '::1' }
-
-      it "must return an Array containing the host" do
-        expect(subject.host_addresses).to eq([host])
-      end
-    end
-
-    context "when the host has no addresses" do
-      let(:host) { 'does.not.exist' }
-
-      it "must return an empty Array" do
-        expect(subject.host_addresses).to eq([])
-      end
-    end
-  end
-
-  describe "#host_address" do
-    context "when the host has addresses" do
-      it "must return the first IP addresses for the host" do
-        expect(addresses).to include(subject.host_address)
-      end
-    end
-
-    context "when the host is an IPv4 address" do
-      let(:host) { '127.0.0.1' }
-
-      it "must return the host" do
-        expect(subject.host_address).to eq(host)
-      end
-    end
-
-    context "when the host is an IPv6 address" do
-      let(:host) { '::1' }
-
-      it "must return the host" do
-        expect(subject.host_address).to eq(host)
-      end
-    end
-
-    context "when the host has no addresses" do
-      let(:host) { 'does.not.exist' }
-
-      it "must return nil "do
-        expect(subject.host_address).to be(nil)
-      end
-    end
-  end
-
-  describe "#host_ip_addresses" do
-    context "when the host has addresses" do
-      it "must return the IPv4 and IPv6 addresses for the host" do
-        expect(subject.host_ip_addresses).to eq(ip_addresses)
-      end
-    end
-
-    context "when the host is an IPv4 address" do
-      let(:host) { '127.0.0.1' }
-
-      it "must return an Array containing the host" do
-        expect(subject.host_ip_addresses).to eq([host])
-      end
-    end
-
-    context "when the host is an IPv6 address" do
-      let(:host) { '::1' }
-
-      it "must return an Array containing the host" do
-        expect(subject.host_ip_addresses).to eq([host])
-      end
-    end
-
-    context "when the host has no addresses" do
-      let(:host) { 'does.not.exist' }
-
-      it "must return an empty Array" do
-        expect(subject.host_ip_addresses).to eq([])
-      end
-    end
-  end
-
-  describe "#host_ip_address" do
-    context "when the host has addresses" do
-      it "must return the first IP addresses for the host" do
-        expect(ip_addresses).to include(subject.host_ip_address)
-      end
-    end
-
-    context "when the host is an IPv4 address" do
-      let(:host) { '127.0.0.1' }
-
-      it "must return the host" do
-        expect(subject.host_ip_address).to eq(host)
-      end
-    end
-
-    context "when the host is an IPv6 address" do
-      let(:host) { '::1' }
-
-      it "must return the host" do
-        expect(subject.host_ip_address).to eq(host)
-      end
-    end
-
-    context "when the host has no addresses" do
-      let(:host) { 'does.not.exist' }
-
-      it "must return nil "do
-        expect(subject.host_ip_address).to be(nil)
-      end
-    end
-  end
-
-  describe "#host_ipv4_addresses" do
-    context "when the host has addresses" do
-      it "must return the IPv4 addresses for the host" do
-        expect(subject.host_ipv4_addresses).to eq(ipv4_addresses)
-      end
-    end
-
-    context "when the host is an IPv4 address" do
-      let(:host) { '127.0.0.1' }
-
-      it "must return an Array containing the host" do
-        expect(subject.host_ipv4_addresses).to eq([host])
-      end
-    end
-
-    context "when the host is an IPv6 address" do
-      let(:host) { '::1' }
-
-      it do
-        expect {
-          subject.host_ipv4_addresses
-        }.to raise_error(Ronin::Payloads::ValidationError,"host must be a hostname or an IPv4 address, was an IPv6 address: #{host.inspect}")
-      end
-    end
-
-    context "when the host only has IPv6 addresses" do
-      let(:host) { 'ipv6.wtfismyip.com' }
-
-      it "must return an empty Array" do
-        expect(subject.host_ipv4_addresses).to eq([])
-      end
-    end
-
-    context "when the host has no addresses" do
-      let(:host) { 'does.not.exist' }
-
-      it "must return an empty Array" do
-        expect(subject.host_ipv4_addresses).to eq([])
-      end
-    end
-  end
-
-  describe "#host_ipv4_address" do
-    context "when the host has addresses" do
-      it "must return the first IP addresses for the host" do
-        expect(ipv4_addresses).to include(subject.host_ipv4_address)
-      end
-    end
-
-    context "when the host is an IPv4 address" do
-      let(:host) { '127.0.0.1' }
-
-      it "must return the host" do
-        expect(subject.host_ipv4_address).to eq(host)
-      end
-    end
-
-    context "when the host is an IPv6 address" do
-      let(:host) { '::1' }
-
-      it do
-        expect {
-          subject.host_ipv4_address
-        }.to raise_error(Ronin::Payloads::ValidationError,"host must be a hostname or an IPv4 address, was an IPv6 address: #{host.inspect}")
-      end
-    end
-
-    context "when the host only has IPv6 addresses" do
-      let(:host) { 'ipv6.wtfismyip.com' }
-
-      it "must return nil" do
-        expect(subject.host_ipv4_address).to be(nil)
-      end
-    end
-
-    context "when the host has no addresses" do
-      let(:host) { 'does.not.exist' }
-
-      it "must return nil "do
-        expect(subject.host_ipv4_address).to be(nil)
-      end
-    end
-  end
-
-  describe "#host_ipv6_addresses" do
-    context "when the host has addresses" do
-      it "must return the IPv4 and IPv6 addresses for the host" do
-        expect(subject.host_ipv6_addresses).to eq(ipv6_addresses)
-      end
-    end
-
-    context "when the host is an IPv4 address" do
-      let(:host) { '127.0.0.1' }
-
-      it "must return an IPv6-to-IPv4 mapped address" do
-        expect(subject.host_ipv6_addresses).to eq(["::ffff:#{host}"])
-      end
-    end
-
-    context "when the host is an IPv6 address" do
-      let(:host) { '::1' }
-
-      it "must return an Array containing the host" do
-        expect(subject.host_ipv6_addresses).to eq([host])
-      end
-    end
-
-    context "when the host only has IPv4 addresses" do
-      let(:host) { 'a.resolvers.level3.net' }
-
-      it "must return an empty Array" do
-        expect(subject.host_ipv6_addresses).to eq([])
-      end
-    end
-
-    context "when the host has no addresses" do
-      let(:host) { 'does.not.exist' }
-
-      it "must return an empty Array" do
-        expect(subject.host_ipv6_addresses).to eq([])
-      end
-    end
-  end
-
-  describe "#host_ipv6_address" do
-    context "when the host has addresses" do
-      it "must return the first IP addresses for the host" do
-        expect(ipv6_addresses).to include(subject.host_ipv6_address)
-      end
-    end
-
-    context "when the host is an IPv4 address" do
-      let(:host) { '127.0.0.1' }
-
-      it "must return an IPv6-to-IPv4 mapped address" do
-        expect(subject.host_ipv6_address).to eq("::ffff:#{host}")
-      end
-    end
-
-    context "when the host is an IPv6 address" do
-      let(:host) { '::1' }
-
-      it "must return an Array containing the host" do
-        expect(subject.host_ipv6_address).to eq(host)
-      end
-    end
-
-    context "when the host only has IPv4 addresses" do
-      let(:host) { 'a.resolvers.level3.net' }
-
-      it "must return nil" do
-        expect(subject.host_ipv6_address).to be(nil)
-      end
-    end
-
-    context "when the host has no addresses" do
-      let(:host) { 'does.not.exist' }
-
-      it "must return nil "do
-        expect(subject.host_ipv6_address).to be(nil)
-      end
-    end
-  end
-end

data/spec/mixins/reverse_shell_spec.rb

@@ -1,103 +0,0 @@
-require 'spec_helper'
-require 'ronin/payloads/mixins/reverse_shell'
-require 'ronin/payloads/payload'
-
-describe Ronin::Payloads::Mixins::ReverseShell do
-  module TestReverseShellMixin
-    class TestPayload < Ronin::Payloads::Payload
-      include Ronin::Payloads::Mixins::ReverseShell
-    end
-  end
-
-  let(:payload_class) { TestReverseShellMixin::TestPayload }
-
-  describe ".included" do
-    subject { payload_class }
-
-    it "must add a required 'host' param" do
-      expect(subject.params[:host]).to_not be_nil
-      expect(subject.params[:host].type).to be_kind_of(Ronin::Core::Params::Types::String)
-      expect(subject.params[:host].required?).to be(true)
-      expect(subject.params[:host].desc).to eq('The host to connect back to')
-    end
-
-    it "must add a required 'port' param" do
-      expect(subject.params[:port]).to_not be_nil
-      expect(subject.params[:port].type).to be_kind_of(Ronin::Core::Params::Types::Integer)
-      expect(subject.params[:port].required?).to be(true)
-      expect(subject.params[:port].desc).to eq('The port to connect back to')
-    end
-  end
-
-  let(:host) { '127.0.0.1' }
-  let(:port) { 1337 }
-
-  subject do
-    payload_class.new(params: {host: host, port: port})
-  end
-
-  describe "#host" do
-    it "must return the 'host' param value" do
-      expect(subject.host).to eq(host)
-    end
-  end
-
-  describe "#port" do
-    it "must return the 'port' param value" do
-      expect(subject.port).to eq(port)
-    end
-  end
-
-  describe "#perform_prelaunch" do
-    let(:server_socket) { double('TCPServer') }
-
-    it "must create a new TCPServer that listens on #host and #port and set @server" do
-      expect(TCPServer).to receive(:new).with(port,host).and_return(server_socket)
-      expect(server_socket).to receive(:listen).with(1)
-
-      subject.perform_prelaunch
-
-      expect(subject.instance_variable_get(:@server)).to be(server_socket)
-    end
-  end
-
-  describe "#perform_postlaunch" do
-    let(:server_socket) { double('TCPServer') }
-    let(:client_socket) { double('TCPSocket') }
-
-    let(:client_ip)   { '1.2.3.4' }
-    let(:client_port) { 8888 }
-    let(:client_addrinfo)    { Addrinfo.tcp(client_ip,client_port) }
-
-    before do
-      allow(client_socket).to receive(:remote_address).and_return(client_addrinfo)
-    end
-
-    before { subject.instance_variable_set(:@server,server_socket) }
-
-    it "must print a message about waiting for a connection on host:port, accept a connection, create a new Ronin::PostEx::Sessions::ReverseShell with the new connection, set @session, and print a message about a new connection on host:port" do
-      expect(subject).to receive(:print_info).with("Waiting for connection on #{host}:#{port} ...")
-      expect(server_socket).to receive(:accept).and_return(client_socket)
-      expect(subject).to receive(:print_info).with("Accepted connection from #{client_ip}:#{client_port}!")
-
-      subject.perform_postlaunch
-
-      expect(subject.session).to be_kind_of(Ronin::PostEx::Sessions::ReverseShell)
-      expect(subject.session.io).to be(client_socket)
-    end
-  end
-
-  describe "#perform_cleanup" do
-    let(:server_socket) { double('TCPServer') }
-
-    before { subject.instance_variable_set(:@server,server_socket) }
-
-    it "must call @server.close and set @server to nil" do
-      expect(server_socket).to receive(:close)
-
-      subject.perform_cleanup
-
-      expect(subject.instance_variable_get(:@server)).to be(nil)
-    end
-  end
-end