ronin-core 0.1.0.beta1

data/spec/cli/options/param_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+require 'ronin/core/cli/options/param'
+require 'ronin/core/cli/command'
+
+describe Ronin::Core::CLI::Options::Param do
+  module TestParamOption
+    class TestCommand < Ronin::Core::CLI::Command
+      include Ronin::Core::CLI::Options::Param
+    end
+  end
+
+  let(:command_class) { TestParamOption::TestCommand }
+
+  describe ".included" do
+    subject { command_class }
+
+    it "must add a -p,--param option to the options" do
+      expect(subject.options[:param]).to_not be_nil
+      expect(subject.options[:param].value?).to be(true)
+      expect(subject.options[:param].value.type).to be_kind_of(Regexp)
+      expect(subject.options[:param].value.usage).to eq('NAME=VALUE')
+      expect(subject.options[:param].desc).to eq('Sets a param')
+    end
+  end
+
+  subject { command_class.new }
+
+  describe "#initialize" do
+    it "must set #params to an empty Hash" do
+      expect(subject.params).to eq({})
+    end
+  end
+
+  describe "options" do
+    context "when given --param foo=bar" do
+      before { subject.option_parser.parse(%w[--param foo=bar]) }
+
+      it "must set the :foo key to 'bar' in #params" do
+        expect(subject.params[:foo]).to eq('bar')
+      end
+    end
+
+    context "when given --param foo=" do
+      it do
+        expect {
+          subject.option_parser.parse(%w[--param foo=])
+        }.to raise_error(OptionParser::InvalidArgument)
+      end
+    end
+
+    context "when given --param =bar" do
+      it do
+        expect {
+          subject.option_parser.parse(%w[--param =bar])
+        }.to raise_error(OptionParser::InvalidArgument)
+      end
+    end
+
+    context "when given --param =" do
+      it do
+        expect {
+          subject.option_parser.parse(%w[--param =])
+        }.to raise_error(OptionParser::InvalidArgument)
+      end
+    end
+  end
+end

data/spec/cli/options/values/arches_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+require 'ronin/core/cli/options/values/arches'
+
+describe "Ronin::Core::CLI::Options::Values::ARCHES" do
+  subject { Ronin::Core::CLI::Options::Values::ARCHES }
+
+  it "must map 'x86' to :x86" do
+    expect(subject['x86']).to eq(:x86)
+  end
+
+  it "must map 'x86-64' to :x86_64" do
+    expect(subject['x86-64']).to eq(:x86_64)
+  end
+
+  it "must map 'amd64' to :x86_64" do
+    expect(subject['amd64']).to eq(:x86_64)
+  end
+
+  it "must map 'ia64' to :ia64" do
+    expect(subject['ia64']).to eq(:ia64)
+  end
+
+  it "must map 'ppc' to :ppc" do
+    expect(subject['ppc']).to eq(:ppc)
+  end
+
+  it "must map 'ppc64' to :ppc64" do
+    expect(subject['ppc64']).to eq(:ppc64)
+  end
+
+  it "must map 'arm' to :arm" do
+    expect(subject['arm']).to eq(:arm)
+  end
+
+  it "must map 'armbe' to :arm_be" do
+    expect(subject['armbe']).to eq(:arm_be)
+  end
+
+  it "must map 'arm64' to :arm64" do
+    expect(subject['arm64']).to eq(:arm64)
+  end
+
+  it "must map 'arm64be' to :arm64_be" do
+    expect(subject['arm64be']).to eq(:arm64_be)
+  end
+
+  it "must map 'mips' to :mips" do
+    expect(subject['mips']).to eq(:mips)
+  end
+
+  it "must map 'mipsle' to :mips_le" do
+    expect(subject['mipsle']).to eq(:mips_le)
+  end
+
+  it "must map 'mips64' to :mips64" do
+    expect(subject['mips64']).to eq(:mips64)
+  end
+
+  it "must map 'mips64le' to :mips64_le" do
+    expect(subject['mips64le']).to eq(:mips64_le)
+  end
+end

data/spec/cli/printing/arch_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+require 'ronin/core/cli/printing/arch'
+require 'ronin/core/cli/command'
+
+describe Ronin::Core::CLI::Printing::Arch do
+  module TestPrintingArch
+    class TestCommand < Ronin::Core::CLI::Command
+      include Ronin::Core::CLI::Printing::Arch
+    end
+  end
+
+  let(:command_class) { TestPrintingArch::TestCommand }
+  subject { command_class.new }
+
+  describe "#arch_name" do
+    context "when given :x86" do
+      it "must return 'x86'" do
+        expect(subject.arch_name(:x86)).to eq('x86')
+      end
+    end
+
+    context "when given :x86_64" do
+      it "must return 'x86-64'" do
+        expect(subject.arch_name(:x86_64)).to eq('x86-64')
+      end
+    end
+
+    context "when given :ia64" do
+      it "must return 'ia64'" do
+        expect(subject.arch_name(:ia64)).to eq('IA64')
+      end
+    end
+
+    context "when given :amd64" do
+      it "must return 'x86-64'" do
+        expect(subject.arch_name(:amd64)).to eq('x86-64')
+      end
+    end
+
+    context "when given :ppc" do
+      it "must return 'PPC'" do
+        expect(subject.arch_name(:ppc)).to eq('PPC')
+      end
+    end
+
+    context "when given :ppc64" do
+      it "must return 'PPC64'" do
+        expect(subject.arch_name(:ppc64)).to eq('PPC64')
+      end
+    end
+
+    context "when given :mips" do
+      it "must return 'MIPS'" do
+        expect(subject.arch_name(:mips)).to eq('MIPS')
+      end
+    end
+
+    context "when given :mips_le" do
+      it "must return 'MIPS (LE)'" do
+        expect(subject.arch_name(:mips_le)).to eq('MIPS (LE)')
+      end
+    end
+
+    context "when given :mips_be" do
+      it "must return 'MIPS'" do
+        expect(subject.arch_name(:mips_be)).to eq('MIPS')
+      end
+    end
+
+    context "when given :mips64" do
+      it "must return 'MIPS64'" do
+        expect(subject.arch_name(:mips64)).to eq('MIPS64')
+      end
+    end
+
+    context "when given :mips64_le" do
+      it "must return 'MIPS64 (LE)'" do
+        expect(subject.arch_name(:mips64_le)).to eq('MIPS64 (LE)')
+      end
+    end
+
+    context "when given :mips64_be" do
+      it "must return 'MIPS64'" do
+        expect(subject.arch_name(:mips64_be)).to eq('MIPS64')
+      end
+    end
+
+    context "when given :arm" do
+      it "must return 'ARM'" do
+        expect(subject.arch_name(:arm)).to eq('ARM')
+      end
+    end
+
+    context "when given :arm_le" do
+      it "must return 'ARM'" do
+        expect(subject.arch_name(:arm_le)).to eq('ARM')
+      end
+    end
+
+    context "when given :arm_be" do
+      it "must return 'ARM (BE)'" do
+        expect(subject.arch_name(:arm_be)).to eq('ARM (BE)')
+      end
+    end
+
+    context "when given :arm64" do
+      it "must return 'ARM64'" do
+        expect(subject.arch_name(:arm64)).to eq('ARM64')
+      end
+    end
+
+    context "when given :arm64_le" do
+      it "must return 'ARM64'" do
+        expect(subject.arch_name(:arm64_le)).to eq('ARM64')
+      end
+    end
+
+    context "when given :arm64_be" do
+      it "must return 'ARM64 (BE)'" do
+        expect(subject.arch_name(:arm64_be)).to eq('ARM64 (BE)')
+      end
+    end
+
+    context "when given an unknown architecture" do
+      it "must return the String version of the architecture" do
+        expect(subject.arch_name(:foo)).to eq('foo')
+      end
+    end
+  end
+end

data/spec/cli/printing/metadata_spec.rb

@@ -0,0 +1,211 @@
+require 'spec_helper'
+require 'ronin/core/cli/printing/metadata'
+require 'ronin/core/cli/command'
+require 'ronin/core/metadata/authors'
+require 'ronin/core/metadata/description'
+require 'ronin/core/metadata/references'
+
+describe Ronin::Core::CLI::Printing::Metadata do
+  module TestPrintingMetadata
+    class TestCommand < Ronin::Core::CLI::Command
+      include Ronin::Core::CLI::Printing::Metadata
+    end
+  end
+
+  let(:command_class) { TestPrintingMetadata::TestCommand }
+  subject { command_class.new }
+
+  describe ".included" do
+    subject { command_class }
+
+    it "must add a -v,--verbose option" do
+      expect(subject.options[:verbose]).to_not be_nil
+    end
+  end
+
+  describe "#print_authors" do
+    module TestPrintingAuthors
+      class WithoutAuthors
+        include Ronin::Core::Metadata::Authors
+      end
+
+      class WithAuthors
+        include Ronin::Core::Metadata::Authors
+
+        author 'John Doe', email:   'john.doe@example.com',
+                           pgp:     '0x123456789',
+                           website: 'https://johndoe.name',
+                           blog:    'https://johndoe.name/blog',
+                           github:  '@johndoe',
+                           gitlab:  '@johndoe',
+                           twitter: '@johndoe',
+                           discord: 'https://discord.gg/1234'
+
+        author 'John Smith', email:   'john.smith@example.com',
+                             pgp:     '0xABCDEF',
+                             website: 'https://johnsmith.name',
+                             blog:    'https://johnsmith.name/blog',
+                             github:  '@john.smith',
+                             gitlab:  '@john.smith',
+                             twitter: '@john.smith',
+                             discord: 'https://discord.gg/ABCDEF'
+      end
+    end
+
+    context "when the class does not have any authors" do
+      let(:klass) { TestPrintingAuthors::WithoutAuthors }
+
+      it "must not print anything" do
+        expect {
+          subject.print_authors(klass)
+        }.to_not output.to_stdout
+      end
+    end
+
+    context "when the class does have authors" do
+      let(:klass) { TestPrintingAuthors::WithAuthors }
+
+      it "must print 'Authors:' and a list of authors" do
+        expect {
+          subject.print_authors(klass)
+        }.to output(
+          [
+            'Authors:',
+            '',
+            "  * #{klass.authors[0]}",
+            "  * #{klass.authors[1]}",
+            '',
+            ''
+          ].join($/)
+        ).to_stdout
+      end
+
+      context "when --verbose mode is enabled" do
+        before { allow(subject).to receive(:verbose?).and_return(true) }
+
+        it "must print the authors and any author metadata as indented lists" do
+          expect {
+            subject.print_authors(klass)
+          }.to output(
+            [
+              'Authors:',
+              '',
+              "  * #{klass.authors[0]}",
+              "    * PGP: #{klass.authors[0].pgp}",
+              "    * Website: #{klass.authors[0].website}",
+              "    * Blog: #{klass.authors[0].blog}",
+              "    * GitHub: #{klass.authors[0].github_url}",
+              "    * GitLab: #{klass.authors[0].gitlab_url}",
+              "    * Twitter: #{klass.authors[0].twitter_url}",
+              "    * Discord: #{klass.authors[0].discord}",
+              "  * #{klass.authors[1]}",
+              "    * PGP: #{klass.authors[1].pgp}",
+              "    * Website: #{klass.authors[1].website}",
+              "    * Blog: #{klass.authors[1].blog}",
+              "    * GitHub: #{klass.authors[1].github_url}",
+              "    * GitLab: #{klass.authors[1].gitlab_url}",
+              "    * Twitter: #{klass.authors[1].twitter_url}",
+              "    * Discord: #{klass.authors[1].discord}",
+              '',
+              ''
+            ].join($/)
+          ).to_stdout
+        end
+      end
+    end
+  end
+
+  describe "#print_description" do
+    module TestPrintingDescription
+      class WithoutDescription
+        include Ronin::Core::Metadata::Description
+      end
+
+      class WithDescription
+        include Ronin::Core::Metadata::Description
+
+        description <<~DESC
+          Foo bar baz
+
+          Qux quux gorge
+        DESC
+      end
+    end
+
+    context "when the class does not have a description" do
+      let(:klass) { TestPrintingDescription::WithoutDescription }
+
+      it "must not print anything" do
+        expect {
+          subject.print_description(klass)
+        }.to_not output.to_stdout
+      end
+    end
+
+    context "when the class does have a description" do
+      let(:klass) { TestPrintingDescription::WithDescription }
+
+      it "must print 'Description:' and the indented description text" do
+        expect {
+          subject.print_description(klass)
+        }.to output(
+          [
+            'Description:',
+            '',
+            "  #{klass.description.lines[0].chomp}",
+            "  #{klass.description.lines[1].chomp}",
+            "  #{klass.description.lines[2].chomp}",
+            '',
+            ''
+          ].join($/)
+        ).to_stdout
+      end
+    end
+  end
+
+  describe "#print_references" do
+    module TestPrintingReferences
+      class WithoutReferences
+        include Ronin::Core::Metadata::References
+      end
+
+      class WithReferences
+        include Ronin::Core::Metadata::References
+
+        references [
+          'https://example.com/url1',
+          'https://example.com/url2'
+        ]
+      end
+    end
+
+    context "when the class has no references" do
+      let(:klass) { TestPrintingReferences::WithoutReferences }
+
+      it "must not print anything" do
+        expect {
+          subject.print_references(klass)
+        }.to_not output.to_stdout
+      end
+    end
+
+    context "when the class has references" do
+      let(:klass) { TestPrintingReferences::WithReferences }
+
+      it "must print 'References:' and the list of reference URLs" do
+        expect {
+          subject.print_references(klass)
+        }.to output(
+          [
+            'References:',
+            '',
+            "  * #{klass.references[0]}",
+            "  * #{klass.references[1]}",
+            '',
+            ''
+          ].join($/)
+        ).to_stdout
+      end
+    end
+  end
+end

data/spec/cli/printing/os_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+require 'ronin/core/cli/printing/os'
+require 'ronin/core/cli/command'
+
+describe Ronin::Core::CLI::Printing::OS do
+  module TestPrintingOS
+    class TestCommand < Ronin::Core::CLI::Command
+      include Ronin::Core::CLI::Printing::OS
+    end
+  end
+
+  let(:command_class) { TestPrintingOS::TestCommand }
+  subject { command_class.new }
+
+  describe "#os_name" do
+    context "when given :unix" do
+      it "must return 'UNIX'" do
+        expect(subject.os_name(:unix)).to eq('UNIX')
+      end
+    end
+
+    context "when given :bsd" do
+      it "must return 'BSD'" do
+        expect(subject.os_name(:bsd)).to eq('BSD')
+      end
+    end
+
+    context "when given :freebsd" do
+      it "must return 'FreeBSD'" do
+        expect(subject.os_name(:freebsd)).to eq('FreeBSD')
+      end
+    end
+
+    context "when given :openbsd" do
+      it "must return 'OpenBSD'" do
+        expect(subject.os_name(:openbsd)).to eq('OpenBSD')
+      end
+    end
+
+    context "when given :netbsd" do
+      it "must return 'NetBSD'" do
+        expect(subject.os_name(:netbsd)).to eq('NetBSD')
+      end
+    end
+
+    context "when given :linux" do
+      it "must return 'Linux'" do
+        expect(subject.os_name(:linux)).to eq('Linux')
+      end
+    end
+
+    context "when given :macos" do
+      it "must return 'macOS'" do
+        expect(subject.os_name(:macos)).to eq('macOS')
+      end
+    end
+
+    context "when given :windows" do
+      it "must return 'Windows'" do
+        expect(subject.os_name(:windows)).to eq('Windows')
+      end
+    end
+  end
+end

data/spec/cli/printing/params_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+require 'ronin/core/cli/printing/params'
+require 'ronin/core/cli/command'
+require 'ronin/core/params/mixin'
+
+describe Ronin::Core::CLI::Printing::Params do
+  module TestPrintingParams
+    class TestClass
+
+      include Ronin::Core::Params::Mixin
+
+      param :foo, String, required: true,
+                          desc: 'Foo param'
+      param :bar, Integer, default: 42,
+                           desc: 'Bar param'
+
+    end
+
+    class TestClassWithoutParams
+      include Ronin::Core::Params::Mixin
+    end
+
+    class TestCommand < Ronin::Core::CLI::Command
+      include Ronin::Core::CLI::Printing::Params
+    end
+  end
+
+  let(:test_class)   { TestPrintingParams::TestClass   }
+  let(:test_command) { TestPrintingParams::TestCommand }
+  subject { test_command.new }
+
+  describe "#print_params" do
+    context "when the class has defined params" do
+      it "must print Params: and the params table" do
+        expect {
+          subject.print_params(test_class)
+        }.to output(
+          [
+            "Params:",
+            "",
+            "  ┌──────┬─────────┬──────────┬─────────┬─────────────┐",
+            "  │ Name │  Type   │ Required │ Default │ Description │",
+            "  ├──────┼─────────┼──────────┼─────────┼─────────────┤",
+            "  │ foo  │ String  │ Yes      │         │ Foo param   │",
+            "  │ bar  │ Integer │ No       │ 42      │ Bar param   │",
+            "  └──────┴─────────┴──────────┴─────────┴─────────────┘",
+            ""
+          ].join($/)
+        ).to_stdout
+      end
+    end
+
+    context "when the class does not have any defined params" do
+      let(:test_class) { TestPrintingParams::TestClassWithoutParams }
+
+      it "must not print anything" do
+        expect {
+          subject.print_params(test_class)
+        }.to_not output.to_stdout
+      end
+    end
+  end
+end

data/spec/cli/ruby_shell.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+require 'ronin/core/cli/ruby_shell'
+
+describe Ronin::Core::CLI::RubyShell do
+  describe "#initialize" do
+    it "must default #name to 'ronin'" do
+      expect(subject.name).to eq('ronin')
+    end
+
+    context "when given a name: keyword argument" do
+      let(:name) { 'ronin-foo' }
+
+      subject { described_class.new(name: name) }
+
+      it "must set #name" do
+        expect(subject.name).to eq(name)
+      end
+    end
+
+    it "must default #context to nil" do
+      expect(subject.context).to be(nil)
+    end
+
+    context "when given a context: keyword argument" do
+      let(:context) { Object.new }
+
+      subject { described_class.new(context: context) }
+
+      it "must set #context" do
+        expect(subject.context).to be(context)
+      end
+    end
+  end
+
+  describe "#configure" do
+    before { subject.configure }
+
+    it "must call IRB.setup" do
+      expect(IRB.conf.length).to be > 1
+    end
+
+    it "must set IRB.conf[:IRB_NAME] to #name" do
+      expect(IRB.conf[:IRB_NAME]).to eq(subject.name)
+    end
+
+    let(:colors)          { subject.colors(STDOUT) }
+    let(:red)             { colors::RED }
+    let(:bright_red)      { colors::BRIGHT_RED }
+    let(:bold)            { colors::BOLD }
+    let(:reset_intensity) { colors::RESET_INTENSITY }
+    let(:reset_color)     { colors::RESET_COLOR     }
+
+    it "must set IRB.conf[:PROMPT][:RONIN]" do
+      expect(IRB.conf[:PROMPT][:RONIN]).to eq(
+        {
+          AUTO_INDENT: true,
+          PROMPT_I: "#{red}irb#{reset_color}#{bold}#{bright_red}(#{reset_color}#{reset_intensity}#{red}%N#{reset_color}#{bold}#{bright_red})#{reset_color}#{reset_intensity}#{bold}#{bright_red}>#{reset_color}#{reset_intensity} ",
+          PROMPT_S: "#{red}irb#{reset_color}#{bold}#{bright_red}(#{reset_color}#{reset_intensity}#{red}%N#{reset_color}#{bold}#{bright_red})#{reset_color}#{reset_intensity}%l ",
+          PROMPT_C: "#{red}irb#{reset_color}#{bold}#{bright_red}(#{reset_color}#{reset_intensity}#{red}%N#{reset_color}#{bold}#{bright_red})#{reset_color}#{reset_intensity}* ",
+          RETURN: "=> %s#{$/}"
+        }
+      )
+    end
+
+    it "must set IRB.conf[:PROMPT_MODE] to :RONIN" do
+      expect(IRB.conf[:PROMPT_MODE]).to eq(:RONIN)
+    end
+
+    after do
+      IRB.conf[:IRB_NAME] = nil
+      IRB.conf[:PROMPT].delete(:RONIN)
+      IRB.conf[:PROMPT_MODE] = :DEFAULT
+    end
+  end
+
+  describe "#start" do
+    let(:fixtures_dir) { File.expand_path(File.join(__dir__,'fixtures')) }
+    let(:console_bin)  { File.join(fixtures_dir,'irb_command') }
+
+    it "must print a prompt then read and evaluate Ruby" do
+      output = nil
+
+      IO.popen(console_bin,'r+') do |io|
+        io.puts "1 + 1"
+        io.puts "exit"
+
+        output = io.read
+      end
+
+      expect(output).to eq([
+        "Switch to inspect mode.",
+        "irb(ronin)> 1 + 1",
+        "=> 2",
+        "irb(ronin)> exit",
+        ''
+      ].join($/))
+    end
+  end
+end