ronin 1.4.1 → 1.5.0.rc1

data/man/ronin-update.1.md

@@ -0,0 +1,67 @@
+# ronin-update 1 "April 2012" Ronin "User Manuals"
+
+## SYNOPSIS
+
+`ronin update` [*options*] [*REPO*]
+
+## DESCRIPTION
+
+Updates Ronin Repositories.
+
+## ARGUMENTS
+
+*REPO*
+  The name of the Repository to update.
+
+## OPTIONS
+
+`-v`, `--[no-]verbose`
+  Enable verbose output.
+
+`-q`, `--[no-]quiet`
+  Disable verbose output.
+
+`--[no-]silent`
+  Silence all output.
+
+`--[no-]color`
+  Enables color output.
+
+## EXAMPLES
+
+`ronin update repo`
+  Updates the repository with with the name `repo`.
+
+`ronin update repo@github.com`
+  Updates the repository with the name `repo` and from `github.com`.
+
+## FILES
+
+*~/.ronin/*
+  Ronin configuration directory.
+
+*~/.ronin/repos*
+  Installation directory for Ronin Repositories.
+
+*~/.ronin/database.log*
+  Database log.
+
+*~/.ronin/database.sqlite3*
+  The default sqlite3 Database file.
+
+*~/.ronin/database.yml*
+  Optional Database configuration.
+
+## ENVIRONMENT
+
+HOME
+  Specifies the home directory of the user. Ronin will search for the `.ronin`
+  configuration directory within the home directory.
+
+## AUTHOR
+
+Postmodern <postmodern.mod3@gmail.com>
+
+## SEE ALSO
+
+ronin-install(1) ronin-repos(1) ronin-uninstall(1)

data/man/ronin-urls.1.md

@@ -0,0 +1,84 @@
+# ronin-urls 1 "April 2012" Ronin "User Manuals"
+
+## SYNOPSIS
+
+`ronin urls` [*options*]
+
+## DESCRIPTION
+
+Manages URLs.
+
+## OPTIONS
+
+`-v`, `--[no-]verbose`
+  Enable verbose output.
+
+`-q`, `--[no-]quiet`
+  Disable verbose output.
+
+`--[no-]silent`
+  Silence all output.
+
+`--[no-]color`
+  Enables color output.
+
+`-D`, `--database` *URI*
+  The database to URI (`mysql://user:password@host/ronin`).
+
+`--[no-]csv`
+  CSV output.
+
+`--[no-]xml`
+  XML output.
+
+`--[no-]yaml`
+  YAML output.
+
+`--[no-]json`
+  JSON output.
+
+`-i`, `--import` *FILE*
+  Imports HostNames from the FILE.
+
+`--[no-]http`
+  Searches for `http://` URLs.
+
+`--[no-]https`
+  Searches for `https://` URLs.
+
+`-H`, `--hosts` *HOST* [...]
+  Searches for URLs with the given HOST name(s).
+
+`-p`, `--with-ports` *PORT* [...]
+  Searches for URLs associated with the PORT(s).
+
+`-d`, `--directory` *DIRECTORY*
+  Searches for URLs sharing the DIRECTORY.
+
+`-q`, `--with-query-param` *NAME* [...]
+  Searches for URLs containing the query-param NAME.
+
+`-Q`, `--with-query-value` *VALUE* [...]
+  Searches for URLs containing the query-param VALUE.
+
+`-l`, `--[no-]list`
+  Lists the HostNames.
+
+## FILES
+
+*~/.ronin/*
+  Ronin configuration directory.
+
+*~/.ronin/database.log*
+  Database log.
+
+*~/.ronin/database.sqlite3*
+  The default sqlite3 Database file.
+
+*~/.ronin/database.yml*
+  Optional Database configuration.
+
+## AUTHOR
+
+Postmodern <postmodern.mod3@gmail.com>
+

data/man/ronin-wordlist.1.md

@@ -0,0 +1,53 @@
+# ronin-wordlist 1 "April 2012" Ronin "User Manuals"
+
+## SYNOPSIS
+
+`ronin wordlist` [*options*] [*TEMPLATE*]
+
+## DESCRIPTION
+
+Builds and/or mutates Wordlists.
+
+## ARGUMENTS
+
+*TEMPLATE*
+  Options word template to generate the wordlist with (`alpha:7 numeric:1-3`).
+
+## OPTIONS
+
+`-v`, `--[no-]verbose`
+  Enable verbose output.
+
+`-q`, `--[no-]quiet`
+  Disable verbose output.
+
+`--[no-]silent`
+  Silence all output.
+
+`--[no-]color`
+  Enables color output.
+
+`-i`, `--input` *FILE*
+  The input text FILE to parse.
+
+`-o`, `--output` *PATH*
+  The output PATH to write the wordlist to.
+
+`-m`, `--mutations` *STRING*:*SUBSTITUTE*
+  Mutations to apply to the words. If STRING is found within a word, it will be
+  replaced with SUBSTITUTE.
+
+## EXAMPLES
+
+`ronin wordlist alpha:7 numeric:1-3`
+  Enumerates through every possible word, with each word beginning with seven
+  alphabetic characters and ending in 1-3 numeric characters.
+
+`ronin wordlist --input text.txt -m e:3 -m a:@ -m o:0`
+  Builds a wordlist from a text file, applying basic "leet-speak" mutation rules
+  to each word.
+
+## AUTHOR
+
+Postmodern <postmodern.mod3@gmail.com>
+

data/man/ronin.1.md

@@ -0,0 +1,26 @@
+# ronin 1 "April 2012" Ronin "User Manuals"
+
+## SYNOPSIS
+
+`ronin` [*COMMAND*] [*options*]
+
+## DESCRIPTION
+
+Runs a Ronin COMMAND or the starts Ronin Console.
+
+## ARGUMENTS
+
+*COMMAND*
+  The Ronin command to execute.
+
+## OPTIONS
+
+Additional options for the COMMAND or the Ronin Console.
+
+## AUTHOR
+
+Postmodern <postmodern.mod3@gmail.com>
+
+## SEE ALSO
+
+ronin-console(1)

data/ronin.gemspec

@@ -2,130 +2,59 @@
 
 require 'yaml'
 
-Gem::Specification.new do |gemspec|
-  root = File.dirname(__FILE__)
-  lib_dir = File.join(root,'lib')
-  files = if File.directory?('.git')
-            `git ls-files`.split($/)
-          elsif File.directory?('.hg')
-            `hg manifest`.split($/)
-          elsif File.directory?('.svn')
-            `svn ls -R`.split($/).select { |path| File.file?(path) }
-          else
-            Dir['{**/}{.*,*}'].select { |path| File.file?(path) }
-          end
+Gem::Specification.new do |gem|
+  gemspec = YAML.load_file('gemspec.yml')
 
-  filter_files = lambda { |paths|
-    case paths
-    when Array
-      (files & paths)
-    when String
-      (files & Dir[paths])
-    end
-  }
-
-  version = {
-    :file => 'ronin/version',
-    :constant => 'Ronin::VERSION'
-  }
-
-  defaults = {
-    'name' => File.basename(root),
-    'files' => files,
-    'executables' => filter_files['bin/*'].map { |path| File.basename(path) },
-    'test_files' => filter_files['{test/{**/}*_test.rb,spec/{**/}*_spec.rb}'],
-    'extra_doc_files' => filter_files['*.{txt,rdoc,md,markdown,tt,textile}'],
-  }
+  gem.name    = gemspec.fetch('name')
+  gem.version = gemspec.fetch('version') do
+                  lib_dir = File.join(File.dirname(__FILE__),'lib')
+                  $LOAD_PATH << lib_dir unless $LOAD_PATH.include?(lib_dir)
 
-  metadata = defaults.merge(YAML.load_file('gemspec.yml'))
+                  require 'ronin/version'
+                  Ronin::VERSION
+                end
 
-  gemspec.name = metadata.fetch('name',defaults[:name])
-  gemspec.version = if metadata['version']
-                      metadata['version']
-                    else
-                      $LOAD_PATH << lib_dir unless $LOAD_PATH.include?(lib_dir)
+  gem.summary     = gemspec['summary']
+  gem.description = gemspec['description']
+  gem.licenses    = Array(gemspec['license'])
+  gem.authors     = Array(gemspec['authors'])
+  gem.email       = gemspec['email']
+  gem.homepage    = gemspec['homepage']
 
-                      require version[:file]
-                      eval(version[:constant])
-                    end
+  glob = lambda { |patterns| gem.files & Dir[*patterns] }
 
-  gemspec.summary = metadata.fetch('summary',metadata['description'])
-  gemspec.description = metadata.fetch('description',metadata['summary'])
+  gem.files = `git ls-files`.split($/)
+  gem.files = glob[gemspec['files']] if gemspec['files']
 
-  case metadata['license']
-  when Array
-    gemspec.licenses = metadata['license']
-  when String
-    gemspec.license = metadata['license']
+  gem.executables = gemspec.fetch('executables') do
+    glob['bin/*'].map { |path| File.basename(path) }
   end
+  gem.default_executable = gem.executables.first if Gem::VERSION < '1.7.'
 
-  case metadata['authors']
-  when Array
-    gemspec.authors = metadata['authors']
-  when String
-    gemspec.author = metadata['authors']
-  end
-
-  gemspec.email = metadata['email']
-  gemspec.homepage = metadata['homepage']
+  gem.extensions       = glob[gemspec['extensions'] || 'ext/**/extconf.rb']
+  gem.test_files       = glob[gemspec['test_files'] || '{test/{**/}*_test.rb']
+  gem.extra_rdoc_files = glob[gemspec['extra_doc_files'] || '*.{txt,md}']
 
-  case metadata['require_paths']
-  when Array
-    gemspec.require_paths = metadata['require_paths']
-  when String
-    gemspec.require_path = metadata['require_paths']
-  end
+  gem.require_paths = Array(gemspec.fetch('require_paths') {
+    %w[ext lib].select { |dir| File.directory?(dir) }
+  })
 
-  gemspec.files = filter_files[metadata['files']]
+  gem.requirements              = gemspec['requirements']
+  gem.required_ruby_version     = gemspec['required_ruby_version']
+  gem.required_rubygems_version = gemspec['required_rubygems_version']
+  gem.post_install_message      = gemspec['post_install_message']
 
-  gemspec.executables = metadata['executables']
-  gemspec.extensions = metadata['extensions']
-
-  if Gem::VERSION < '1.7.'
-    gemspec.default_executable = gemspec.executables.first
-  end
-
-  gemspec.test_files = filter_files[metadata['test_files']]
-
-  unless gemspec.files.include?('.document')
-    gemspec.extra_rdoc_files = metadata['extra_doc_files']
-  end
-
-  gemspec.post_install_message = metadata['post_install_message']
-  gemspec.requirements = metadata['requirements']
-
-  if gemspec.respond_to?(:required_ruby_version=)
-    gemspec.required_ruby_version = metadata['required_ruby_version']
-  end
-
-  if gemspec.respond_to?(:required_rubygems_version=)
-    gemspec.required_rubygems_version = metadata['required_rubygems_version']
-  end
-
-  parse_versions = lambda { |versions|
-    case versions
-    when Array
-      versions.map { |v| v.to_s }
-    when String
-      versions.split(/,\s*/)
-    end
-  }
-
-  if metadata['dependencies']
-    metadata['dependencies'].each do |name,versions|
-      gemspec.add_dependency(name,parse_versions[versions])  
-    end
-  end
+  split = lambda { |string| string.split(/,\s*/) }
 
-  if metadata['runtime_dependencies']
-    metadata['runtime_dependencies'].each do |name,versions|
-      gemspec.add_runtime_dependency(name,parse_versions[versions])  
+  if gemspec['dependencies']
+    gemspec['dependencies'].each do |name,versions|
+      gem.add_dependency(name,split[versions])
     end
   end
 
-  if metadata['development_dependencies']
-    metadata['development_dependencies'].each do |name,versions|
-      gemspec.add_development_dependency(name,parse_versions[versions])  
+  if gemspec['development_dependencies']
+    gemspec['development_dependencies'].each do |name,versions|
+      gem.add_development_dependency(name,split[versions])
     end
   end
 end

data/spec/installation_spec.rb

@@ -23,6 +23,7 @@ describe Installation do
       hosts.rb
       install.rb
       ips.rb
+      net/proxy.rb
       repos.rb
       update.rb
       urls.rb
@@ -32,7 +33,7 @@ describe Installation do
   }
 
   describe "each_file" do
-    let(:pattern)  { File.join(directory,'*.rb') }
+    let(:pattern)  { File.join(directory,'**','*.rb') }
     let(:expected) { files.map { |name| File.join(directory,name) } }
 
     it "should enumerate over the files which match a glob pattern" do

data/spec/spec_helper.rb

@@ -6,9 +6,11 @@ require 'model/models/described_model'
 require 'model/models/licensed_model'
 require 'model/models/named_model'
 require 'model/models/titled_model'
+require 'classes/my_script'
 require 'helpers/repositories'
 
 require 'ronin/spec/database'
+require 'ronin/spec/ui/output'
 
 include Ronin
 

data/spec/ui/cli/classes/test_command.rb

@@ -4,6 +4,13 @@ class TestCommand < Ronin::UI::CLI::Command
 
   summary 'Tests the default task'
 
+  usage '[options] PATH FILE [..]'
+
+  examples [
+    'test_command --foo PATH',
+    'test_command --foo PATH FILE ...'
+  ]
+
   option :foo
 
   argument :path

data/spec/ui/cli/command_spec.rb

@@ -6,8 +6,241 @@ require 'ui/cli/classes/test_command'
 describe UI::CLI::Command do
   subject { TestCommand }
 
-  it "should have a command name" do
-    subject.command_name.should == 'test_command'
+  describe "command_name" do
+    it "should be derived from the Class name" do
+      subject.command_name.should == 'test_command'
+    end
+  end
+
+  describe "usage" do
+    context "without an argument" do
+      it "should return the set usage" do
+        subject.usage.should == '[options] PATH FILE [..]'
+      end
+    end
+
+    context "with an argument" do
+      let(:expected) { 'FOO' }
+
+      subject { Class.new(described_class) }
+      before  { subject.usage expected }
+
+      it "should set the usage" do
+        subject.usage.should == expected
+      end
+    end
+
+    context "default" do
+      subject { Class.new(described_class).usage }
+
+      it { should == '[options]' }
+    end
+
+    context "inherited" do
+      let(:superclass) { TestCommand }
+
+      subject { Class.new(superclass).usage }
+
+      it "should default to the usage of the superclass" do
+        subject.should == superclass.usage
+      end
+    end
+  end
+
+  describe "summary" do
+    context "without an argument" do
+      it "should return the set summary" do
+        subject.summary.should == 'Tests the default task'
+      end
+    end
+
+    context "with an argument" do
+      let(:expected) { 'Performs foo' }
+
+      subject { Class.new(described_class) }
+      before  { subject.summary expected }
+
+      it "should set the usage" do
+        subject.summary.should == expected
+      end
+    end
+
+    context "default" do
+      subject { Class.new(described_class).summary }
+
+      it { should == nil }
+    end
+
+    context "inherited" do
+      let(:superclass) { TestCommand }
+
+      subject { Class.new(superclass).summary }
+
+      it "should default to the summary of the superclass" do
+        subject.should == superclass.summary
+      end
+    end
+  end
+
+  describe "examples" do
+    context "without an argument" do
+      it "should return the set summary" do
+        # subject.example.should == 'Tests the default task'
+      end
+    end
+
+    context "with an argument" do
+      let(:expected) do
+        ['test_command --foo PATH', 'test_command --foo PATH FILE ...']
+      end
+
+      subject { Class.new(described_class) }
+      before  { subject.examples expected }
+
+      it "should set the usage" do
+        subject.examples.should == expected
+      end
+    end
+
+    context "default" do
+      subject { Class.new(described_class).examples }
+
+      it { should == [] }
+    end
+
+    context "inherited" do
+      let(:superclass) { TestCommand }
+
+      subject { Class.new(superclass).examples }
+
+      it "should default to the examples of the superclass" do
+        subject.should == superclass.examples
+      end
+    end
+  end
+
+  describe "options" do
+    subject { Class.new(described_class).options }
+
+    context "inherited" do
+      it "should be {} by default" do
+        subject.should == {}
+      end
+    end
+
+    context described_class do
+      subject { described_class.options }
+
+      it "should have a :verbose option" do
+        subject.should have_key(:verbose)
+      end
+
+      it "should have a :quiet option" do
+        subject.should have_key(:quiet)
+      end
+
+      it "should have a :silent option" do
+        subject.should have_key(:silent)
+      end
+
+      it "should have a :color option" do
+        subject.should have_key(:color)
+      end
+
+      describe "color option" do
+        subject { described_class.new.color }
+
+        context "when $stdout is a TTY" do
+          it { should be_true }
+        end
+
+        context "when $stdout is not a TTY" do
+          before do
+            @old_stdout = $stdout
+            $stdout     = StringIO.new
+          end
+
+          it { should be_false }
+
+          after do
+            $stdout = @old_stdout
+          end
+        end
+      end
+    end
+  end
+
+  describe "option" do
+    let(:name) { :foo }
+
+    it "should define an option" do
+      subject.options[name].should be_kind_of(Hash)
+    end
+
+    it "should define a parameter" do
+      subject.should have_param(name)
+    end
+  end
+
+  describe "each_option" do
+    let(:expected) { [:verbose, :quiet, :silent, :color, :foo] }
+
+    it "should iterate over each option" do
+      names = []
+
+      subject.each_option do |name,options|
+        names << name
+      end
+
+      names.should =~ expected
+    end
+  end
+
+  describe "options?" do
+    it "should test if there are any defined options" do
+      subject.options?.should be_true
+    end
+  end
+
+  describe "arguments" do
+    context "inherited" do
+      subject { Class.new(described_class).arguments }
+
+      it { should == [] }
+    end
+  end
+
+  describe "argument" do
+    let(:name) { :foo }
+
+    subject { Class.new(described_class) }
+    before  { subject.argument name      }
+
+    it "should add to arguments" do
+      subject.arguments.should include(name)
+    end
+
+    it "should define a parameter" do
+      subject.should have_param(name)
+    end
+  end
+
+  describe "each_argument" do
+    let(:expected) { [:path, :files] }
+
+    it "should iterate over each option" do
+      names = []
+
+      subject.each_argument { |name| names << name }
+
+      names.should =~ expected
+    end
+  end
+
+  describe "arguments?" do
+    it "should test if there are any defined arguments" do
+      subject.arguments?.should be_true
+    end
   end
 
   describe "#run" do
@@ -51,9 +284,4 @@ describe UI::CLI::Command do
       subject.files.should == files
     end
   end
-
-  it "should have zero indentation by default" do
-    command = subject.new
-    command.instance_variable_get('@indent').should == 0
-  end
 end