ronin-fuzzer 0.1.0.beta1

data/spec/fuzzer_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+require 'ronin/fuzzing/fuzzer'
+
+describe Ronin::Fuzzing::Fuzzer do
+  let(:string) { 'GET /one/two/three' }
+
+  describe "#initialize" do
+    subject { described_class }
+
+    context "patterns" do
+      let(:substitutions) { ['bar'] }
+
+      it "should accept Regexps" do
+        fuzzer = subject.new(/foo/ => substitutions)
+
+        expect(fuzzer.rules).to have_key(/foo/)
+      end
+
+      context "when given Strings" do
+        subject { described_class.new('foo' => substitutions) }
+
+        it "should convert to Regexp" do
+          expect(subject.rules).to have_key(/foo/)
+        end
+      end
+
+      context "when given Symbols" do
+        subject { described_class.new(:word => substitutions) }
+
+        it "should lookup the Ronin::Support::Text::Patterns constant" do
+          expect(subject.rules).to have_key(Ronin::Support::Text::Patterns::WORD)
+        end
+      end
+
+      context "otherwise" do
+        it "should raise a TypeError" do
+          expect {
+            subject.new(Object.new => substitutions)
+          }.to raise_error(TypeError)
+        end
+      end
+    end
+
+    context "substitutions" do
+      let(:pattern) { /foo/ }
+
+      it "should accept Enumerable values" do
+        fuzzer = subject.new(pattern => ['bar'])
+
+        expect(fuzzer.rules[pattern]).to eq(['bar'])
+      end
+
+      context "when given Symbols" do
+        subject { described_class.new(pattern => :bad_strings) }
+
+        it "should map to an Enumerator for a Fuzzing method" do
+          expect(subject.rules[pattern]).to be_kind_of(Enumerable)
+        end
+      end
+
+      context "otherwise" do
+        it "should raise a TypeError" do
+          expect {
+            subject.new(pattern => Object.new)
+          }.to raise_error(TypeError)
+        end
+      end
+    end
+  end
+
+  describe "#each" do
+    let(:string) { "foo bar" }
+
+    subject { described_class.new(/o/ => ['O', '0'], /a/ => ['A', '@']) }
+
+    it "should apply each fuzzing rule individually" do
+      expect(subject.each(string).to_a).to match_array([
+        "fOo bar",
+        "f0o bar",
+        "foO bar",
+        "fo0 bar",
+        "foo bAr",
+        "foo b@r"
+      ])
+    end
+
+    context "when mutations contain Integers" do
+      subject { described_class.new(/o/ => [48]) }
+
+      it "should convert them to characters" do
+        expect(subject.each(string).to_a).to match_array([
+          "f0o bar",
+          "fo0 bar"
+        ])
+      end
+    end
+
+    context "when mutations contain Procs" do
+      subject { described_class.new(/o/ => [lambda { |str| str.upcase }]) }
+
+      it "should call them with the matched String" do
+        expect(subject.each(string).to_a).to match_array([
+          "fOo bar",
+          "foO bar"
+        ])
+      end
+    end
+  end
+end

data/spec/fuzzing_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require 'ronin/fuzzing'
+
+describe Ronin::Fuzzing do
+  describe "[]" do
+    let(:method) { :bad_strings }
+
+    it "should return Enumerators for fuzzing methods" do
+      expect(subject[method]).to be_kind_of(Enumerable)
+    end
+
+    it "should raise NoMethodError for unknown methods" do
+      expect {
+        subject[:foo]
+      }.to raise_error(NoMethodError)
+    end
+
+    it "should not allow accessing inherited methods" do
+      expect {
+        subject[:instance_eval]
+      }.to raise_error(NoMethodError)
+    end
+  end
+end

data/spec/mutator_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+require 'ronin/fuzzing/mutator'
+
+describe Ronin::Fuzzing::Mutator do
+  let(:string) { 'GET /one/two/three' }
+
+  describe "#initialize" do
+    subject { described_class }
+
+    context "patterns" do
+      let(:substitutions) { ['bar'] }
+
+      it "should accept Regexps" do
+        fuzzer = subject.new(/foo/ => substitutions)
+
+        expect(fuzzer.rules).to have_key(/foo/)
+      end
+
+      context "when given Strings" do
+        subject { described_class.new('foo' => substitutions) }
+
+        it "should convert to Regexp" do
+          expect(subject.rules).to have_key(/foo/)
+        end
+      end
+
+      context "when given Symbols" do
+        subject { described_class.new(:word => substitutions) }
+
+        it "should lookup the Ronin::Support::Text::Patterns constant" do
+          expect(subject.rules).to have_key(Ronin::Support::Text::Patterns::WORD)
+        end
+      end
+
+      context "otherwise" do
+        it "should raise a TypeError" do
+          expect {
+            subject.new(Object.new => substitutions)
+          }.to raise_error(TypeError)
+        end
+      end
+    end
+
+    context "mutations" do
+      let(:pattern) { /foo/ }
+
+      it "should accept Enumerable values" do
+        fuzzer = subject.new(pattern => ['bar'])
+
+        expect(fuzzer.rules[pattern]).to eq(['bar'])
+      end
+
+      context "when given Symbols" do
+        subject { described_class.new(pattern => :bad_strings) }
+
+        it "should map to an Enumerator for a Fuzzing method" do
+          expect(subject.rules[pattern]).to be_kind_of(Enumerable)
+        end
+      end
+
+      context "otherwise" do
+        it "should raise a TypeError" do
+          expect {
+            subject.new(pattern => Object.new)
+          }.to raise_error(TypeError)
+        end
+      end
+    end
+  end
+
+  describe "#each" do
+    let(:string) { "foo bar" }
+
+    subject { described_class.new(/o/ => ['0'], /a/ => ['@']) }
+
+    it "should apply every combination of mutation rules" do
+      expect(subject.each(string).to_a).to match_array([
+        "f0o bar",
+        "fo0 bar",
+        "f00 bar",
+        "foo b@r",
+        "f0o b@r",
+        "fo0 b@r",
+        "f00 b@r"
+      ])
+    end
+
+    context "when mutations contain Integers" do
+      subject { described_class.new(/o/ => [48]) }
+
+      it "should convert them to characters" do
+        expect(subject.each(string).to_a).to match_array([
+          "f0o bar",
+          "fo0 bar",
+          "f00 bar"
+        ])
+      end
+    end
+
+    context "when mutations contain Procs" do
+      subject { described_class.new(/o/ => [lambda { |str| str.upcase }]) }
+
+      it "should call them with the matched String" do
+        expect(subject.each(string).to_a).to match_array([
+          "fOo bar",
+          "foO bar",
+          "fOO bar"
+        ])
+      end
+    end
+  end
+end

data/spec/repeater_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+require 'ronin/fuzzing/repeater'
+
+describe Ronin::Fuzzing::Repeater do
+  describe "#initialize" do
+    subject { described_class }
+
+    context "when lengths is an Integer" do
+      it "should coerce lengths to an Enumerable" do
+        repeator = subject.new(10)
+
+        expect(repeator.lengths).to be_kind_of(Enumerable)
+      end
+    end
+
+    context "when lengths is not Enumerable or an Integer" do
+      it "should raise a TypeError" do
+        expect {
+          subject.new(Object.new)
+        }.to raise_error(TypeError)
+      end
+    end
+  end
+
+  describe "#each" do
+    let(:repeatable) { 'A' }
+
+    context "when lengths was an Integer" do
+      let(:length) { 10 }
+
+      subject { described_class.new(length) }
+
+      it "should yield one repeated value" do
+        values = subject.each(repeatable).to_a
+        
+        expect(values).to eq([repeatable * length])
+      end
+    end
+
+    context "when lengths was Enumerable" do
+      let(:lengths) { (1..4) }
+
+      subject { described_class.new(lengths) }
+
+      it "should yield repeated values for each length" do
+        values = subject.each(repeatable).to_a
+
+        expect(values).to eq([
+          repeatable * 1,
+          repeatable * 2,
+          repeatable * 3,
+          repeatable * 4
+        ])
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

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

data/spec/template_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'ronin/fuzzing/template'
+
+describe Ronin::Fuzzing::Template do
+  subject { described_class }
+
+  it "should generate Strings from CharSets" do
+    strings = subject.new([:lowercase_hexadecimal, :numeric]).to_a
+
+    expect(strings.grep(/^[0-9a-f][0-9]$/)).to eq(strings)
+  end
+
+  it "should generate Strings from lengths of CharSets" do
+    strings = subject.new([[:numeric, 2]]).to_a
+
+    expect(strings.grep(/^[0-9]{2}$/)).to eq(strings)
+  end
+
+  it "should generate Strings from varying lengths of CharSets" do
+    strings = subject.new([[:numeric, 1..2]]).to_a
+
+    expect(strings.grep(/^[0-9]{1,2}$/)).to eq(strings)
+  end
+
+  it "should generate Strings from custom CharSets" do
+    strings = subject.new([[%w[a b c], 2]]).to_a
+
+    expect(strings.grep(/^[abc]{2}$/)).to eq(strings)
+  end
+
+  it "should generate Strings containing known Strings" do
+    strings = subject.new(['foo', [%w[a b c], 2]]).to_a
+
+    expect(strings.grep(/^foo[abc]{2}$/)).to eq(strings)
+  end
+
+  it "should raise a TypeError for non String, Symbol, Enumerable CharSets" do
+    expect {
+      subject.new([[Object.new, 2]]).to_a
+    }.to raise_error(TypeError)
+  end
+
+  it "should raise an ArgumentError for unknown CharSets" do
+    expect {
+      subject.new([[:foo_bar, 2]]).to_a
+    }.to raise_error(ArgumentError)
+  end
+
+  it "should raise a TypeError for non Integer,Array,Range lengths" do
+    expect {
+      subject.new([[:numeric, 'foo']]).to_a
+    }.to raise_error(TypeError)
+  end
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: ronin-fuzzer
+version: !ruby/object:Gem::Version
+  version: 0.1.0.beta1
+platform: ruby
+authors:
+- Postmodern
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-01-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: combinatorics
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: ronin-support
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0.beta1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0.beta1
+- !ruby/object:Gem::Dependency
+  name: ronin-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0.beta1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0.beta1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: 'A Ruby library for generating, mutating, and fuzzing data.
+
+  '
+email: postmodern.mod3@gmail.com
+executables:
+- ronin-fuzzer
+extensions: []
+extra_rdoc_files:
+- COPYING.txt
+- ChangeLog.md
+- README.md
+files:
+- ".document"
+- ".github/workflows/ruby.yml"
+- ".gitignore"
+- ".rspec"
+- ".ruby-version"
+- ".yardopts"
+- COPYING.txt
+- ChangeLog.md
+- Gemfile
+- README.md
+- Rakefile
+- bin/ronin-fuzzer
+- gemspec.yml
+- lib/ronin/fuzzer/cli.rb
+- lib/ronin/fuzzer/cli/command.rb
+- lib/ronin/fuzzer/cli/commands/fuzz.rb
+- lib/ronin/fuzzer/root.rb
+- lib/ronin/fuzzer/version.rb
+- lib/ronin/fuzzing.rb
+- lib/ronin/fuzzing/core_ext.rb
+- lib/ronin/fuzzing/core_ext/string.rb
+- lib/ronin/fuzzing/fuzzer.rb
+- lib/ronin/fuzzing/mutator.rb
+- lib/ronin/fuzzing/repeater.rb
+- lib/ronin/fuzzing/template.rb
+- man/ronin-fuzzer-fuzz.1
+- man/ronin-fuzzer-fuzz.1.md
+- ronin-fuzzer.gemspec
+- spec/core_ext/string_spec.rb
+- spec/fuzzer_spec.rb
+- spec/fuzzing_spec.rb
+- spec/mutator_spec.rb
+- spec/repeater_spec.rb
+- spec/spec_helper.rb
+- spec/template_spec.rb
+homepage: https://ronin-rb.dev/
+licenses:
+- LGPL-3.0
+metadata:
+  documentation_uri: https://rubydoc.info/gems/ronin-fuzzer
+  source_code_uri: https://github.com/ronin-rb/ronin-fuzzer
+  bug_tracker_uri: https://github.com/ronin-rb/ronin-fuzzer/issues
+  changelog_uri: https://github.com/ronin-rb/ronin-fuzzer/blob/master/ChangeLog.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.26
+signing_key:
+specification_version: 4
+summary: generate, mutate, and fuzz data
+test_files:
+- spec/core_ext/string_spec.rb
+- spec/fuzzer_spec.rb
+- spec/fuzzing_spec.rb
+- spec/mutator_spec.rb
+- spec/repeater_spec.rb
+- spec/template_spec.rb