ruby-gobuster 0.1.0

data/lib/gobuster/response.rb

@@ -0,0 +1,68 @@
+module Gobuster
+  #
+  # Represents a HTTP resposne found by `gobuster dir` or `gobuster fuzz`.
+  #
+  class Response
+
+    # The path of the response.
+    #
+    # @return [String, nil]
+    attr_reader :path
+
+    # The URL of the response.
+    #
+    # @return [String, nil]
+    attr_reader :url
+
+    # The HTTP status code.
+    #
+    # @return [Integer]
+    attr_reader :status
+
+    # The size of the response.
+    #
+    # @return [Integer]
+    attr_reader :size
+
+    #
+    # Initializes the HTTP response.
+    #
+    # @param [String, nil] path
+    #
+    # @param [String, nil] url
+    #
+    # @param [Integer] status
+    #
+    # @param [Integer] size
+    #
+    # @raise [ArgumentError]
+    #   The `path:` or `url:` keyword argument is required.
+    #
+    def initialize(path: nil, url: nil, status: , size: )
+      if url
+        @url  = url
+        @path = nil
+      elsif path
+        @url  = nil
+        @path = path
+      else
+        raise(ArgumentError,"path: or url: keyword argument must be given")
+      end
+
+      @status = status
+      @size   = size
+    end
+
+    #
+    # Converts the response to a String.
+    #
+    # @return [String]
+    #
+    def to_s
+      @path || @url
+    end
+
+    alias to_str to_s
+
+  end
+end

data/lib/gobuster/s3_bucket.rb

@@ -0,0 +1,33 @@
+module Gobuster
+  #
+  # Represents an S3 bucket found by `gobuster s3`.
+  #
+  class S3Bucket
+
+    # The URL to the S3 bucket.
+    #
+    # @return [String]
+    attr_reader :url
+
+    #
+    # Initializes the S3 bucket.
+    #
+    # @param [String] url
+    #
+    def initialize(url)
+      @url = url
+    end
+
+    #
+    # Converts the S3 bucket to a String.
+    #
+    # @return [String]
+    #
+    def to_s
+      @url
+    end
+
+    alias to_str to_s
+
+  end
+end

data/lib/gobuster/version.rb

@@ -0,0 +1,4 @@
+module Gobuster
+  # ruby-gobuster version
+  VERSION = '0.1.0'
+end

data/ruby-gobuster.gemspec

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+require 'yaml'
+
+Gem::Specification.new do |gem|
+  gemspec = YAML.load_file('gemspec.yml')
+
+  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)
+
+                  require 'gobuster/version'
+                  Gobuster::VERSION
+                end
+
+  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']
+  gem.metadata    = gemspec['metadata'] if gemspec['metadata']
+
+  glob = lambda { |patterns| gem.files & Dir[*patterns] }
+
+  gem.files = `git ls-files`.split($/)
+  gem.files = glob[gemspec['files']] if gemspec['files']
+
+  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.'
+
+  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}']
+
+  gem.require_paths = Array(gemspec.fetch('require_paths') {
+    %w[ext lib].select { |dir| File.directory?(dir) }
+  })
+
+  gem.requirements              = Array(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']
+
+  split = lambda { |string| string.split(/,\s*/) }
+
+  if gemspec['dependencies']
+    gemspec['dependencies'].each do |name,versions|
+      gem.add_dependency(name,split[versions])
+    end
+  end
+
+  if gemspec['development_dependencies']
+    gemspec['development_dependencies'].each do |name,versions|
+      gem.add_development_dependency(name,split[versions])
+    end
+  end
+end

data/spec/command_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+require 'gobuster/command'
+
+describe Gobuster::Command do
+  describe described_class::Duration do
+    describe "#validate" do
+      context "when given nil" do
+        let(:value) { nil }
+
+        it "must return [false, \"cannot be nil\"]" do
+          expect(subject.validate(value)).to eq(
+            [false, "cannot be nil"]
+          )
+        end
+      end
+
+      context "when given a String" do
+        context "when given an empty String" do
+          let(:value) { "" }
+
+          it "must return [false, \"does not allow an empty value\"]" do
+            expect(subject.validate(value)).to eq(
+              [false, "does not allow an empty value"]
+            )
+          end
+        end
+
+        context "when given a number" do
+          let(:value) { "10" }
+
+          it "must return [false, \"must be a number and end with 'm', 's', 'ms', or 'ns'\"]" do
+            expect(subject.validate(value)).to eq(
+              [false, "must be a number and end with 'm', 's', 'ms', or 'ns'"]
+            )
+          end
+        end
+
+        context "when given a number that ends with a unit" do
+          let(:value) { "10s" }
+
+          it "must return true" do
+            expect(subject.validate(value)).to be(true)
+          end
+
+          context "but the unit isn't recognized" do
+            let(:value) { "10x" }
+
+            it "must return [false, \"must be a number and end with 'm', 's', 'ms', or 'ns'\"]" do
+              expect(subject.validate(value)).to eq(
+                [false, "must be a number and end with 'm', 's', 'ms', or 'ns'"]
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/fixtures/dir_output.txt

@@ -0,0 +1,3 @@
+/dev                  (Status: 200) [Size: 175527]
+/test                 (Status: 200) [Size: 176368]
+/www                  (Status: 200) [Size: 166374]

data/spec/fixtures/dns_output.txt

@@ -0,0 +1,2 @@
+Found: www.twitter.com
+Found: dev.twitter.com

data/spec/fixtures/fuzz_output.txt

@@ -0,0 +1,5 @@
+Found: [Status=200] [Length=1256] http://example.com
+Found: [Status=200] [Length=1256] http://example.com
+Found: [Status=200] [Length=1256] http://example.com
+Found: [Status=200] [Length=1256] http://example.com
+Found: [Status=200] [Length=1256] http://example.com

data/spec/fixtures/s3_output.txt

@@ -0,0 +1,5 @@
+http://www.s3.amazonaws.com/
+http://admin.s3.amazonaws.com/
+http://test.s3.amazonaws.com/
+http://downloads.s3.amazonaws.com/
+http://dev.s3.amazonaws.com/

data/spec/hostname_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'gobuster/hostname'
+
+describe Gobuster::Hostname do
+  let(:name) { 'www.example.com' }
+
+  subject { described_class.new(name) }
+
+  describe "#initialize" do
+    it "must set #name" do
+      expect(subject.name).to eq(name)
+    end
+  end
+
+  describe "#to_s" do
+    it "must return #name" do
+      expect(subject.to_s).to eq(name)
+    end
+  end
+
+  describe "#to_str" do
+    it "must return #name" do
+      expect(subject.to_str).to eq(name)
+    end
+  end
+end

data/spec/output_file_spec.rb

@@ -0,0 +1,174 @@
+require 'spec_helper'
+require 'gobuster/output_file'
+
+describe Gobuster::OutputFile do
+  let(:fixtures_dir) { File.expand_path(File.join(__dir__,'fixtures')) }
+
+  describe "PARSERS" do
+    subject { described_class::PARSERS }
+
+    describe ":dir" do
+      it { expect(subject[:dir]).to eq(Gobuster::Parsers::Dir) }
+    end
+
+    describe ":dns" do
+      it { expect(subject[:dns]).to eq(Gobuster::Parsers::DNS) }
+    end
+
+    describe ":fuzz" do
+      it { expect(subject[:fuzz]).to eq(Gobuster::Parsers::Fuzz) }
+    end
+
+    describe ":s3" do
+      it { expect(subject[:s3]).to eq(Gobuster::Parsers::S3) }
+    end
+  end
+
+  describe "#initialize" do
+    let(:path)   { "/path/to/file.txt" }
+    let(:format) { :dir }
+
+    subject { described_class.new(path, format: format) }
+
+    it "must set #path" do
+      expect(subject.path).to eq(path)
+    end
+
+    it "must set #format" do
+      expect(subject.format).to be(format)
+    end
+
+    it "must set #parser based on #format" do
+      expect(subject.parser).to eq(described_class::PARSERS[subject.format])
+    end
+  end
+
+  let(:path) { File.join(fixtures_dir,'dir_output.txt') }
+
+  subject { described_class.new(path) }
+
+  describe "#each" do
+    context "when initialized with `gobuster dir` output file" do
+      let(:path) { File.join(fixtures_dir,'dir_output.txt') }
+
+      subject { described_class.new(path, format: :dir) }
+
+      context "and when a block is given" do
+        it "must yield each parsed Response object" do
+          yielded_responses = []
+
+          subject.each do |response|
+            yielded_responses << response
+          end
+
+          expect(yielded_responses).to_not be_empty
+          expect(yielded_responses).to all(be_kind_of(Gobuster::Response))
+        end
+      end
+
+      context "and when no block is given" do
+        it "must return an Enumerator of the parsed Response objects" do
+          responses = subject.each.to_a
+
+          expect(responses).to_not be_empty
+          expect(responses).to all(be_kind_of(Gobuster::Response))
+        end
+      end
+    end
+
+    context "when initialized with `gobuster dns` output file" do
+      let(:path) { File.join(fixtures_dir,'dns_output.txt') }
+
+      subject { described_class.new(path, format: :dns) }
+
+      context "and when a block is given" do
+        it "must yield each parsed Hostname object" do
+          yielded_hostnames = []
+
+          subject.each do |hostname|
+            yielded_hostnames << hostname
+          end
+
+          expect(yielded_hostnames).to_not be_empty
+          expect(yielded_hostnames).to all(be_kind_of(Gobuster::Hostname))
+        end
+      end
+
+      context "and when no block is given" do
+        it "must return an Enumerator of the parsed Hostname objects" do
+          hostnames = subject.each.to_a
+
+          expect(hostnames).to_not be_empty
+          expect(hostnames).to all(be_kind_of(Gobuster::Hostname))
+        end
+      end
+    end
+
+    context "when initialized with `gobuster fuzz` output file" do
+      let(:path) { File.join(fixtures_dir,'fuzz_output.txt') }
+
+      subject { described_class.new(path, format: :fuzz) }
+
+      context "and when a block is given" do
+        it "must yield each parsed Response object" do
+          yielded_responses = []
+
+          subject.each do |response|
+            yielded_responses << response
+          end
+
+          expect(yielded_responses).to_not be_empty
+          expect(yielded_responses).to all(be_kind_of(Gobuster::Response))
+        end
+      end
+
+      context "and when no block is given" do
+        it "must return an Enumerator of the parsed Response objects" do
+          responses = subject.each.to_a
+
+          expect(responses).to_not be_empty
+          expect(responses).to all(be_kind_of(Gobuster::Response))
+        end
+      end
+    end
+
+    context "when initialized with `gobuster s3` output file" do
+      let(:path) { File.join(fixtures_dir,'s3_output.txt') }
+
+      subject { described_class.new(path, format: :s3) }
+
+      context "and when a block is given" do
+        it "must yield each parsed S3Bucket object" do
+          yielded_s3_buckets = []
+
+          subject.each do |s3_bucket|
+            yielded_s3_buckets << s3_bucket
+          end
+
+          expect(yielded_s3_buckets).to_not be_empty
+          expect(yielded_s3_buckets).to all(be_kind_of(Gobuster::S3Bucket))
+        end
+      end
+
+      context "and when no block is given" do
+        it "must return an Enumerator of the parsed S3Bucket objects" do
+          s3_buckets = subject.each.to_a
+
+          expect(s3_buckets).to_not be_empty
+          expect(s3_buckets).to all(be_kind_of(Gobuster::S3Bucket))
+        end
+      end
+    end
+  end
+
+  describe "#to_s" do
+    let(:path)   { "/path/to/file.txt" }
+    let(:format) { :dir }
+
+    subject { described_class.new(path, format: format) }
+
+    it "must return #path" do
+      expect(subject.to_s).to eq(path)
+    end
+  end
+end

data/spec/parsers/dir_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'gobuster/parsers/dir'
+
+describe Gobuster::Parsers::Dir do
+  describe ".parse" do
+    let(:path)   { '/test' }
+    let(:status) { 200     }
+    let(:size)   { 176368  }
+
+    let(:line) { "#{path}                 (Status: #{status}) [Size: #{size}]" }
+    let(:io)   { StringIO.new(line + $/) }
+
+    it "must parse each line and yield Gobuster::Response objects" do
+      yielded_responses = []
+
+      subject.parse(io) do |response|
+        yielded_responses << response
+      end
+
+      expect(yielded_responses.length).to eq(1)
+      expect(yielded_responses.first).to be_kind_of(Gobuster::Response)
+
+      yielded_response = yielded_responses.first
+
+      expect(yielded_response.path).to eq(path)
+      expect(yielded_response.status).to eq(status)
+      expect(yielded_response.size).to eq(size)
+    end
+  end
+end

data/spec/parsers/dns_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'gobuster/parsers/dns'
+
+describe Gobuster::Parsers::DNS do
+  describe ".parse" do
+    let(:name) { "www.twitter.com" }
+    let(:line) { "Found: #{name}" }
+    let(:io)   { StringIO.new(line + $/) }
+
+    it "must parse each line and yield Gobuster::Hostname objects" do
+      yielded_hostnames = []
+
+      subject.parse(io) do |hostname|
+        yielded_hostnames << hostname
+      end
+
+      expect(yielded_hostnames.length).to eq(1)
+      expect(yielded_hostnames.first).to be_kind_of(Gobuster::Hostname)
+
+      yielded_hostname = yielded_hostnames.first
+
+      expect(yielded_hostname.name).to eq(name)
+    end
+  end
+end

data/spec/parsers/fuzz_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+require 'gobuster/parsers/fuzz'
+
+describe Gobuster::Parsers::Fuzz do
+  describe ".parse" do
+    let(:url)    { '/test' }
+    let(:status) { 200     }
+    let(:size)   { 176368  }
+
+    let(:line) { "Found: [Status=#{status}] [Length=#{size}] #{url}" }
+    let(:io)   { StringIO.new(line + $/) }
+
+    it "must parse each line and yield Gobuster::Response objects" do
+      yielded_responses = []
+
+      subject.parse(io) do |response|
+        yielded_responses << response
+      end
+
+      expect(yielded_responses.length).to eq(1)
+      expect(yielded_responses.first).to be_kind_of(Gobuster::Response)
+
+      yielded_response = yielded_responses.first
+
+      expect(yielded_response.url).to eq(url)
+      expect(yielded_response.path).to be(nil)
+      expect(yielded_response.status).to eq(status)
+      expect(yielded_response.size).to eq(size)
+    end
+  end
+end

data/spec/parsers/s3_bucket_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'gobuster/parsers/s3'
+
+describe Gobuster::Parsers::S3 do
+  describe ".parse" do
+    let(:url)  { "http://test.s3.amazonaws.com/" }
+    let(:line) { url }
+    let(:io)   { StringIO.new(line + $/) }
+
+    it "must parse each line and yield Gobuster::S3Bucket objects" do
+      yielded_s3_buckets = []
+
+      subject.parse(io) do |s3_bucket|
+        yielded_s3_buckets << s3_bucket
+      end
+
+      expect(yielded_s3_buckets.length).to eq(1)
+      expect(yielded_s3_buckets.first).to be_kind_of(Gobuster::S3Bucket)
+
+      yielded_s3_bucket = yielded_s3_buckets.first
+
+      expect(yielded_s3_bucket.url).to eq(url)
+    end
+  end
+end

data/spec/response_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+require 'gobuster/response'
+
+describe Gobuster::Response do
+  let(:path)   { '/test' }
+  let(:url)    { "https://example.com#{path}" }
+  let(:status) { 200 }
+  let(:size)   { 176368 }
+
+  describe "#initialize" do
+    context "when initialized with the path: keyword argument" do
+      subject { described_class.new(path: path, status: status, size: size) }
+
+      it "must set #path" do
+        expect(subject.path).to eq(path)
+      end
+
+      it "must set #url to nil" do
+        expect(subject.url).to be(nil)
+      end
+
+      it "must set #status" do
+        expect(subject.status).to eq(status)
+      end
+
+      it "must set #size" do
+        expect(subject.size).to eq(size)
+      end
+    end
+
+    context "when initialized with the url: keyword argument" do
+      subject { described_class.new(url: url, status: status, size: size) }
+
+      it "must set #url" do
+        expect(subject.url).to eq(url)
+      end
+
+      it "must set #path to nil" do
+        expect(subject.path).to be(nil)
+      end
+
+      it "must set #status" do
+        expect(subject.status).to eq(status)
+      end
+
+      it "must set #size" do
+        expect(subject.size).to eq(size)
+      end
+    end
+  end
+
+  describe "#to_s" do
+    context "when initialized with the path: keyword argument" do
+      subject { described_class.new(path: path, status: status, size: size) }
+
+      it "must return #path" do
+        expect(subject.to_s).to eq(path)
+      end
+    end
+
+    context "when initialized with the url: keyword argument" do
+      subject { described_class.new(url: url, status: status, size: size) }
+
+      it "must return #url" do
+        expect(subject.to_s).to eq(url)
+      end
+    end
+  end
+
+  describe "#to_str" do
+    context "when initialized with the path: keyword argument" do
+      subject { described_class.new(path: path, status: status, size: size) }
+
+      it "must return #path" do
+        expect(subject.to_s).to eq(path)
+      end
+    end
+
+    context "when initialized with the url: keyword argument" do
+      subject { described_class.new(url: url, status: status, size: size) }
+
+      it "must return #url" do
+        expect(subject.to_s).to eq(url)
+      end
+    end
+  end
+end

data/spec/s3_bucket_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'gobuster/s3_bucket'
+
+describe Gobuster::S3Bucket do
+  let(:url) { 'http://test.s3.amazonaws.com/' }
+
+  subject { described_class.new(url) }
+
+  describe "#initialize" do
+    it "must set #url" do
+      expect(subject.url).to eq(url)
+    end
+  end
+
+  describe "#to_s" do
+    it "must return #url" do
+      expect(subject.to_s).to eq(url)
+    end
+  end
+
+  describe "#to_str" do
+    it "must return #url" do
+      expect(subject.to_str).to eq(url)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'rspec'
+require 'simplecov'
+SimpleCov.start