Add a module that defines a common -p,--param NAME=value option that populates a params Hash.

Add Ronin::Core::Console using the new and improved irb gem. This will replace Ronin::UI::Console in ronin.

Add a TipFile class for parsing the tips.yml file format. The TipFile class should provide a .parse or .load method, and a random method which returns a random Tip object. The YAML file format will look something like:

---
- text: |
    To do blah blah lbah:
    
      ruby_code_here
      
  tags: [tag1, tag2]
- text: ...
  tags: ...

Add a Tip class which represents an individual tip object (text: String, tags: Array<Sting>).

Post-0.1.0 bug fix release.

Add tab-completion support to Ronin::Core::CLI::Shell. It should be possible to tab-complete command names, as well as additional arguments/options for a command.

fo<TAB><TAB>
foo
foot
food

foo --b<TAB><TAB>
--bytes

This can be accomplished using Reline.completion_proc = ->(line) { ...}. Each command should also have an optional array of known completion values.

command :foo, usage: '[options]', summary: '...', completion: %w[--bytes --count -c ...]

Temporarily disable truffleruby in the CI matrix, due to a truffleruby bug with splatting keyword arguments, which breaks command_kit.

Due to jruby still working on 2.7 and 3.0 support, and that command_kit does not support ruby 2.6, jruby will be temporarily disabled in the CI matrix. Re-enable jruby support once they achieve 2.7 support.

Add more professional Logging module that prints >>> message, *** warning, and !!! error messages (as opposed to [+] message, [*] message, [!] message).

Copy ANSI formatting from ruby-install

If STDOUT is a TTY, then add ANSI styling to the Ronin::Core::Console prompt.

As of reline 0.4.0, reline now supports custom color schemes for the tab-completion menu. Ronin could customize the default cyan background + grey text + magenta highlighted text completion menu.

Release version 0.2.0.

Add a "module registry" API that allows Classes to register themselves into a parent Module. It must allow requiring a Class from within a sub-directory (ex: exploits/). The loaded Class would then register itself into the parent Module with a given name. The parent Module would then allow accessing these classes via arbitrary String name.

Pseudo Code

module Ronin
  module Exploits
    include Ronin::Core::Registry.new(dir: `exploits`)
  end

  class Exploit
    def self.register(name)
      Exploits.register(name,self)
    end
  end
end

class SomeExploit < Ronin::Exploits::Exploit

  register 'some_exploit'

  # ...
end

Ronin::Exploits.load('some_exploit')
# => SomeExploit
Ronin::Exploits.registry['some_exploit']
# => SomeExploit

See Also

See Bundler::Audit::CLI::Formats for an example of the Module Registry pattern.

Add a module to contain common printing methods for printing class metadata.

Switch to using require_relative to load other ronin/core/ files to improve load-times.

Re-add JRuby to the CI matrix now that JRuby 9.4 has been released, which adds Ruby 3.1 support.

Add Ronin::Core::Shell and use the pure-Ruby reline library. This means that even if libreadline wasn't installed or the ruby wasn't built with libreadline support, we can still have Readline functionality.

Must also parse the input command line using Shellwords.shellwords to un-escape any double quoted Strings.

It must also support defining shell commands as methods, since the shell will likely also have some shared state that all commands interact with (ex: a @http variable). Commands will have a name, usage, and longer help text. Commands may also have one/two-letter aliases.

Command Pseudo Code

command 'foo', '[ARGS] ARG', <<HELP
The foo command bla bla bla

Bla bla bla

    foo --bar baz
    
HELP

def foo(args=[])
  # ...
end

Example Reline Code

require "reline"

prompt = 'prompt> '
use_history = true

begin
  while true
    text = Reline.readline(prompt, use_history)

    if text.nil?
      puts
      break
    end

    puts 'You entered:'
    puts text
  end
# If you want to exit, type Ctrl-C
rescue Interrupt
  puts '^C'
  exit 0
end

Rename CLI::Console to CLI::RubyShell` to avoid confusion.

Release 0.1.3 which includes an enhancement for ClassRegistry's load_class_from_file.

Add a module to download a http(s):// file to a destination directory.

Add a Ronin::Core::Metadata::Description mixin that adds a description class method for adding a block of text describing the module.

Example

class Exploit

  include Ronin::Core::Metadata::Description
  
  description <<~DESC
    Bla bla bla
    
      $ command
      
    Blah blah blah
  DESC
  
end

If $stdout is a TTY, then add ANSI styling to the Ronin::Core::Shell prompt.

Allow the > in the shell prompt to be configurable via a sigil variable.

Add a Ronin::Core::Metadata::Summary mixin that adds a summary class method.

Add a module for interacting with the system:

• determine the OS
• parse $PATH
• determine if an executable is installed
• determine if wget or curl is installed.
• download files using wget or curl.

Add a metadata mixin called Ronin::Core::Metadata::ModuleName so Exploits/Payloads/etc can define a module-name as well as register themselves with the Ronin::Core::ModuleRegistry.

Add a method which accepts a Ronin::Core::Params::Param object and returns a placeholder usage string. This will be used in other libraries to build example commands that accept certain params.

Add a Ronin::Core::CLI::TipCommand base class which other ronin-* libraries can extend to add their own tips command. It should support loading tips from a tips.yml file, printing a random tip, printing all tips, and filtering tips by tags.

Add a params API for defining configurable params in a class. Must support defining the param type (defaults to String), a default value, and a description. Support basic param types: String, Integer, Boolean, Float, Enum, URI.

Example Code

class BaseClass

  include Ronin::Core::Params::Mixin

end

class MyModule < BaseClass

  param :str, desc: 'A basic param'

  param :feature_flag, Boolean, desc: 'A boolean param'

  param :num1, Integer, desc: 'A param with a type'

  param :num2, Integer, default: 42,
                       desc: 'A param with a default value'

  param :num3, Integer, default: ->{ rand(42) },
                        desc: 'A param with a dynamic default value'

  param :enum, Enum[:one, :two, :three],
               desc: 'An enum param'

end

mod = MyModule.new(params: {num1: 1, enum: :two})
mod.params
# => {:num2=>42, :num3=>25, :num1=>1, :enum=>:two}

Add rubocop to the repository.

• Add the rubocop gem to the Gemfile.
• Train rubocop on the existing code (rubocop --auto-gen-config) and try to fix as many 1-2 time syntax violations.
• Add a rubocop task and add it to the CI.

Add common classes for handling writing data to .txt, .csv, .json, or .ndjson files. These can be reused by any other command that supports --output / --output-format options.

Add a common base class for all other ronin-* completion commands.

Add a module which prints a sick ASCII art Ronin banner along with the --help output.

Add a module that can extract any archive into a destination directory. See ruby-install's extract function as an example.

Rescue and print any unhandled exceptions raised by the command method being called.

Add a Ronin::Core::Metadata::References mixin to allow adding reference URLs.

Examples

  include Ronin::Core::Metadata::References
  
  references {
    "Title Here" => "https://...",
    # ...
  }

Release rc1 for 0.2.0.

In the same way that the CommandShell has a default help command, it should also have a default quit command.

• Rename Metadata::Author to Metadata::Authors.
• Add a Author class for representing a single author.
• Add a .authors class method for containing authors.
• Add a .author method for defining authors.

Add a Ronin::Core::Metadata::Author mixin that adds a author class method for setting the license of a module.

Example

include Ronin::Core::Metadata::Author

author 'John Smith'

Support reading multi-line input using Reline.readmultiline(prompt, use_history) { |multiline_input| ... } with a block that checks if the last line is the closing line. We will need to count opening/closing quotes to determine if the input has been "closed". Example: https://github.com/ruby/reline#multi-line-editing-mode

Split the Ronin::Core::CLI::Shell class into two classes, Shell and CommandShell. The Shell class will only read input and execute an arbitrary "command" string. CommandShell will have commands and command methods.

Add CommandShell::Command#method name and allow command to accept a method_name: keyword argument. This will allow defining shell commands that contain -, . or other characters not allowed in ruby method names.

Add a lower-level Params::Types::Map type, which Params::Types::Enum will inherit from. This type will allow defining an arbitrary mapping of String values to other Ruby objects:

param :arch, Map[
  'x86-64' => :x86_64,
  ...
], desc: 'The architecture to compile for'