ronin-fuzzer 0.1.0.beta1

data/lib/ronin/fuzzing/fuzzer.rb

@@ -0,0 +1,112 @@
+#
+# ronin-fuzzer - A Ruby library for generating, mutating, and fuzzing data.
+#
+# Copyright (c) 2006-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# This file is part of ronin-fuzzer.
+#
+# ronin-fuzzer is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ronin-fuzzer is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ronin-fuzzer.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+require 'ronin/fuzzing'
+require 'ronin/support/text/patterns'
+
+require 'strscan'
+
+module Ronin
+  module Fuzzing
+    #
+    # Fuzzing class that incrementally fuzzes a String, given substitution
+    # rules.
+    #
+    # @api semipublic
+    #
+    class Fuzzer
+
+      PATTERNS = Support::Text::Patterns
+
+      # Patterns and their substitutions
+      attr_reader :rules
+
+      #
+      # Initializes a new Fuzzer.
+      #
+      # @param [Hash{Regexp,String,Symbol => Enumerable,Symbol}] rules
+      #   Patterns and their substitutions.
+      #
+      def initialize(rules)
+        @rules = {}
+        
+        rules.each do |pattern,substitution|
+          pattern = case pattern
+                    when Regexp then pattern
+                    when String then Regexp.new(Regexp.escape(pattern))
+                    when Symbol then PATTERNS.const_get(pattern.upcase)
+                    else
+                      raise(TypeError,"cannot convert #{pattern.inspect} to a Regexp")
+                    end
+
+          substitution = case substitution
+                         when Enumerable then substitution
+                         when Symbol     then Fuzzing[substitution]
+                         else
+                           raise(TypeError,"substitutions must be Enumerable or a Symbol")
+                         end
+
+          @rules[pattern] = substitution
+        end
+      end
+
+      #
+      # Incrementally fuzzes the String.
+      #
+      # @yield [fuzz]
+      #   The given block will be passed every fuzzed String.
+      #
+      # @yieldparam [String] fuzz
+      #   A fuzzed String.
+      #
+      # @return [Enumerator]
+      #   If no block is given, an Enumerator will be returned.
+      #
+      def each(string)
+        return enum_for(__method__,string) unless block_given?
+
+        @rules.each do |pattern,substitution|
+          scanner = StringScanner.new(string)
+          indices = []
+
+          while scanner.scan_until(pattern)
+            indices << [scanner.pos - scanner.matched_size, scanner.matched_size]
+          end
+
+          indices.each do |index,length|
+            substitution.each do |substitute|
+              substitute = case substitute
+                           when Proc    then substitute[string[index,length]]
+                           when Integer then substitute.chr
+                           else              substitute.to_s
+                           end
+
+              fuzzed = string.dup
+              fuzzed[index,length] = substitute
+              yield fuzzed
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/ronin/fuzzing/mutator.rb

@@ -0,0 +1,163 @@
+#
+# ronin-fuzzer - A Ruby library for generating, mutating, and fuzzing data.
+#
+# Copyright (c) 2006-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# This file is part of ronin-fuzzer.
+#
+# ronin-fuzzer is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ronin-fuzzer is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ronin-fuzzer.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+require 'ronin/fuzzing'
+require 'ronin/support/text/patterns'
+
+require 'combinatorics/list_comprehension'
+require 'combinatorics/power_set'
+require 'combinatorics/generator'
+require 'strscan'
+require 'set'
+
+module Ronin
+  module Fuzzing
+    #
+    # Fuzzer class that permutates over every mutation of a String, given
+    # mutation rules.
+    #
+    # @api semipublic
+    #
+    class Mutator
+
+      PATTERNS = Support::Text::Patterns
+
+      # Mutation rules
+      attr_reader :rules
+
+      #
+      # Initialize the Mutator.
+      #
+      # @param [Hash{Regexp,String,Symbol => Symbol,Enumerable}] rules
+      #   The patterns and substitutions to mutate the String with.
+      #
+      # @raise [TypeError]
+      #   A mutation pattern was not a Regexp, String or Symbol.
+      #   A mutation substitution was not a Symbol or Enumerable.
+      #
+      def initialize(rules)
+        @rules = {}
+        
+        rules.each do |pattern,mutation|
+          pattern = case pattern
+                    when Regexp
+                      pattern
+                    when String
+                      Regexp.new(Regexp.escape(pattern))
+                    when Symbol
+                      PATTERNS.const_get(pattern.upcase)
+                    else
+                      raise(TypeError,"cannot convert #{pattern.inspect} to a Regexp")
+                    end
+
+          mutation = case mutation
+                     when Enumerable
+                       mutation
+                     when Symbol
+                       Ronin::Fuzzing[mutation]
+                     else
+                       raise(TypeError,"mutation #{mutation.inspect} must be a Symbol or Enumerable")
+                     end
+
+          @rules[pattern] = mutation
+        end
+      end
+
+      #
+      # Permutes over every possible mutation of the String.
+      #
+      # @param [String] string
+      #   The String to be mutated.
+      #
+      # @yield [mutant]
+      #   The given block will be yielded every possible mutant String.
+      #
+      # @yieldparam [String] mutant
+      #   A mutated String.
+      #
+      # @return [Enumerator]
+      #   If no block is given, an Enumerator will be returned.
+      #
+      def each(string)
+        return enum_for(__method__,string) unless block_given?
+
+        matches = Set[]
+
+        @rules.each do |pattern,mutation|
+          scanner = StringScanner.new(string)
+
+          while scanner.scan_until(pattern)
+            length   = scanner.matched_size
+            index    = scanner.pos - length
+            original = scanner.matched
+
+            mutator = Combinatorics::Generator.new do |g|
+              mutation.each do |mutate|
+                g.yield case mutate
+                        when Proc
+                          mutate.call(original)
+                        when Integer
+                          mutate.chr
+                        else
+                          mutate.to_s
+                        end
+              end
+            end
+
+            matches << [index, length, mutator]
+          end
+        end
+
+        matches.powerset do |submatches|
+          # ignore the empty Set
+          next if submatches.empty?
+
+          # sort the submatches by index
+          submatches = submatches.sort_by { |index,length,mutator| index }
+          sets       = []
+          prev_index = 0
+
+          submatches.each do |index,length,mutator|
+            # add the previous substring to the set of Strings
+            if index > prev_index
+              sets << [string[prev_index,index - prev_index]]
+            end
+
+            # add the mutator to the set of Strings
+            sets << mutator
+
+            prev_index = index + length
+          end
+
+          # add the remaining substring to the set of Strings
+          if prev_index < string.length
+            sets << [string[prev_index..-1]]
+          end
+
+          sets.comprehension { |strings| yield strings.join }
+        end
+
+        return nil
+      end
+
+    end
+  end
+end

data/lib/ronin/fuzzing/repeater.rb

@@ -0,0 +1,81 @@
+#
+# ronin-fuzzer - A Ruby library for generating, mutating, and fuzzing data.
+#
+# Copyright (c) 2006-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# This file is part of ronin-fuzzer.
+#
+# ronin-fuzzer is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ronin-fuzzer is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ronin-fuzzer.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+module Ronin
+  module Fuzzing
+    #
+    # Fuzzing class that generates repeated data.
+    #
+    # @api semipublic
+    #
+    class Repeater
+
+      # The lengths to repeat the data by
+      attr_reader :lengths
+
+      #
+      # Initializes a new Repeater.
+      #
+      # @param [Enumerable, Integer] lengths
+      #   The lengths to repeat the data by.
+      #
+      # @raise [TypeError]
+      #   `lengths` must either be Enumerable or an Integer.
+      #
+      def initialize(lengths)
+        @lengths = case lengths
+                   when Integer
+                     [lengths]
+                   when Enumerable
+                     lengths
+                   else
+                     raise(TypeError,"argument must be Enumerable or an Integer")
+                   end
+      end
+
+      #
+      # Enumerates through each length of repeated data.
+      #
+      # @param [#*] repeatable
+      #   The repeatable data.
+      #
+      # @yield [repeated]
+      #   The given block will be passed every repeated String.
+      #
+      # @yieldparam [String] repeated
+      #   A repeated version of the String.
+      #
+      # @return [Enumerator]
+      #   If no block is given, an Enumerator will be returned.
+      #
+      def each(repeatable)
+        return enum_for(__method__,repeatable) unless block_given?
+
+        @lengths.each do |length|
+          yield(repeatable * length)
+        end
+
+        return nil
+      end
+
+    end
+  end
+end

data/lib/ronin/fuzzing/template.rb

@@ -0,0 +1,133 @@
+#
+# ronin-fuzzer - A Ruby library for generating, mutating, and fuzzing data.
+#
+# Copyright (c) 2006-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# This file is part of ronin-fuzzer.
+#
+# ronin-fuzzer is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ronin-fuzzer is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ronin-fuzzer.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+require 'chars'
+require 'combinatorics/generator'
+require 'combinatorics/list_comprehension'
+
+module Ronin
+  module Fuzzing
+    #
+    # Fuzzing class that generates Strings based on a template.
+    #
+    # @api semipublic
+    #
+    class Template
+
+      include Enumerable
+
+      #
+      # Initializes a new Fuzzing template.
+      #
+      # @param [Array(<String,Symbol,Enumerable>, <Integer,Array,Range>)] fields
+      #   The fields which defines the string or character sets which will
+      #   make up parts of the String.
+      #
+      # @raise [ArgumentError]
+      #   A given character set name was unknown.
+      #
+      # @raise [TypeError]
+      #   A given string set was not a String, Symbol or Enumerable.
+      #   A given string set length was not an Integer or Enumerable.
+      #
+      def initialize(fields)
+        @enumerators = []
+
+        fields.each do |(set,length)|
+          enum = case set
+                 when String
+                   [set].each
+                 when Enumerable
+                   set.each
+                 when Symbol
+                   name = set.upcase
+
+                   unless Chars.const_defined?(name)
+                     raise(ArgumentError,"unknown charset #{set.inspect}")
+                   end
+
+                   Chars.const_get(name).each_char
+                 else
+                   raise(TypeError,"set must be a String, Symbol or Enumerable")
+                 end
+
+          case length
+          when Integer
+            length.times { @enumerators << enum.dup }
+          when Array, Range
+            @enumerators << Combinatorics::Generator.new do |g|
+              length.each do |sublength|
+                superset = Array.new(sublength) { enum.dup }
+
+                superset.comprehension { |strings| g.yield strings.join }
+              end
+            end
+          when nil
+            @enumerators << enum
+          else
+            raise(TypeError,"length must be an Integer, Range or Array")
+          end
+        end
+      end
+
+      #
+      # @see #initialize
+      #
+      def self.[](*fields)
+        new(fields)
+      end
+
+      #
+      # Generate permutations of Strings from a format template.
+      #
+      # @yield [string]
+      #   The given block will be passed each unique String.
+      #
+      # @yieldparam [String] string
+      #   A newly generated String.
+      #
+      # @return [Enumerator]
+      #   If no block is given, an Enumerator will be returned.
+      #
+      def each
+        return enum_for(__method__) unless block_given?
+
+        @enumerators.comprehension do |fields|
+          string = ''
+
+          fields.each do |field|
+            string << case field
+                      when Integer
+                        field.chr
+                      else
+                        field.to_s
+                      end
+          end
+
+          yield string
+        end
+
+        return nil
+      end
+
+    end
+  end
+end