ronin-support 0.5.0.rc1 → 0.5.0.rc2

data/ChangeLog.md

@@ -6,6 +6,10 @@
 * Added {Ronin::Binary::Template}.
 * Added {Ronin::Binary::Struct}.
 * Added {Ronin::Binary::Hexdump::Parser}.
+* Added {Ronin::Fuzzing::Template}.
+* Added {Ronin::Fuzzing::Repeater}.
+* Added {Ronin::Fuzzing::Fuzzer}.
+* Added {Ronin::Fuzzing::Mutator}.
 * Added {Ronin::Wordlist.create}.
 * Added {Ronin::Wordlist#path} and {Ronin::Wordlist#words}.
 * Added {Ronin::Wordlist#save}.
@@ -44,6 +48,7 @@
   * Support unhexdumping floats / doubles.
 * Allow {String#mutate} to accept Symbols that map to {Ronin::Fuzzing}
   generator methods.
+* {Ronin::Fuzzing.[]} now raises a `NoMethodError` for unknown fuzzing methods.
 * Use `module_function` in {Ronin::Fuzzing}, so the generator methods can be
   included into other Classes/Modules.
 * Require uri-query_params ~> 0.6.
@@ -127,7 +132,7 @@
   was not being escaped.
 * Allow {Ronin::Network::HTTP.request} to accept `:query` and `:query_params`
   options.
-* Fixed a bug in {Ronin::Network::Mixins::HTTP#http_session}, where
+* Fixed a bug in `Ronin::Network::Mixins::HTTP#http_session`, where
   normalized options were not being yielded.
 * {Ronin::Network::HTTP#http_get_headers} and
   {Ronin::Network::HTTP#http_post_headers} now return a Hash of Capitalized

data/lib/ronin/fuzzing/extensions/string.rb

@@ -17,21 +17,20 @@
 # along with Ronin Support.  If not, see <http://www.gnu.org/licenses/>.
 #
 
-require 'ronin/extensions/regexp'
+require 'ronin/fuzzing/template'
+require 'ronin/fuzzing/repeater'
+require 'ronin/fuzzing/fuzzer'
+require 'ronin/fuzzing/mutator'
 require 'ronin/fuzzing/fuzzing'
-
-require 'combinatorics/generator'
-require 'combinatorics/list_comprehension'
-require 'combinatorics/power_set'
-require 'chars'
+require 'ronin/extensions/regexp'
 
 class String
 
   #
   # Generate permutations of Strings from a format template.
   #
-  # @param [Array(<String,Symbol,Enumerable>, <Integer,Array,Range>)] template
-  #   The template which defines the string or character sets which will
+  # @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.
   #
   # @yield [string]
@@ -86,69 +85,14 @@ class String
   #
   # @api public
   #
-  def self.generate(*template)
-    return enum_for(:generate,*template) unless block_given?
-
-    sets = []
-
-    template.each do |pattern|
-      set, length = pattern
-      set = case set
-            when String
-              [set].each
-            when Symbol
-              name = set.to_s.upcase
-
-              unless Chars.const_defined?(name)
-                raise(ArgumentError,"unknown charset #{set.inspect}")
-              end
-
-              Chars.const_get(name).each_char
-            when Enumerable
-              set
-            else
-              raise(TypeError,"set must be a String, Symbol or Enumerable")
-            end
-
-      case length
-      when Integer
-        length.times { sets << set.dup }
-      when Array, Range
-        sets << Combinatorics::Generator.new do |g|
-          length.each do |sublength|
-            superset = Array.new(sublength) { set.dup }
-
-            superset.comprehension { |strings| g.yield strings.join }
-          end
-        end
-      when nil
-        sets << set
-      else
-        raise(TypeError,"length must be an Integer, Range or Array")
-      end
-    end
-
-    sets.comprehension do |strings|
-      new_string = ''
-
-      strings.each do |string|
-        new_string << case string
-                      when Integer
-                        string.chr
-                      else
-                        string.to_s
-                      end
-      end
-
-      yield new_string
-    end
-    return nil
+  def self.generate(*fields,&block)
+    Ronin::Fuzzing::Template.new(fields).each(&block)
   end
 
   #
   # Repeats the String.
   #
-  # @param [Enumerable, Integer] n
+  # @param [Enumerable, Integer] lengths
   #   The number of times to repeat the String.
   #
   # @yield [repeated]
@@ -181,26 +125,17 @@ class String
   #
   # @since 0.4.0
   #
-  def repeating(n)
-    if n.kind_of?(Integer)
-      # if n is an Integer, simply multiply the String and return
-      repeated = (self * n)
+  def repeating(lengths,&block)
+    case lengths
+    when Integer
+      # if lengths is an Integer, simply multiply the String and return
+      repeated = (self * lengths)
 
       yield repeated if block_given?
       return repeated
+    else
+      return Ronin::Fuzzing::Repeater.new(lengths).each(self,&block)
     end
-
-    return enum_for(:repeating,n) unless block_given?
-
-    unless n.kind_of?(Enumerable)
-      raise(TypeError,"argument must be Enumerable or an Integer")
-    end
-
-    n.each do |length|
-      yield(self * length)
-    end
-
-    return self
   end
 
   #
@@ -232,54 +167,8 @@ class String
   #
   # @api public
   #
-  def fuzz(substitutions={})
-    return enum_for(:fuzz,substitutions) unless block_given?
-
-    substitutions.each do |pattern,substitution|
-      pattern = case pattern
-                when Regexp
-                  pattern
-                when String
-                  Regexp.new(Regexp.escape(pattern))
-                when Symbol
-                  Regexp.const_get(pattern.to_s.upcase)
-                else
-                  raise(TypeError,"cannot convert #{pattern.inspect} to a Regexp")
-                end
-
-      substitution = case substitution
-                      when Enumerable
-                        substitution
-                      when Symbol
-                        Ronin::Fuzzing[substitution]
-                      else
-                        raise(TypeError,"substitutions must be Enumerable or a Symbol")
-                      end
-
-      scanner = StringScanner.new(self)
-      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
-                         substitute.call(self[index,length])
-                       when Integer
-                         substitute.chr
-                       else
-                         substitute.to_s
-                       end
-
-          fuzzed = dup
-          fuzzed[index,length] = substitute
-          yield fuzzed
-        end
-      end
-    end
+  def fuzz(substitutions={},&block)
+    Ronin::Fuzzing::Fuzzer.new(substitutions).each(self,&block)
   end
 
   #
@@ -310,84 +199,8 @@ class String
   #
   # @api public
   #
-  def mutate(mutations={})
-    return enum_for(:mutate,mutations) unless block_given?
-
-    matches = Set[]
-
-    mutations.each do |pattern,mutation|
-      pattern = case pattern
-                when Regexp
-                  pattern
-                when String
-                  Regexp.new(Regexp.escape(pattern))
-                when Symbol
-                  Regexp.const_get(pattern.to_s.upcase)
-                else
-                  raise(TypeError,"cannot convert #{pattern.inspect} to a Regexp")
-                end
-
-      mutation = case mutation
-                 when Symbol
-                   Ronin::Fuzzing[mutation]
-                 when Enumerable
-                   mutation
-                 else
-                   raise(TypeError,"mutation #{mutation.inspect} must be a Symbol or Enumerable")
-                 end
-
-      scanner = StringScanner.new(self)
-
-      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 << [self[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 < self.length
-        sets << [self[prev_index..-1]]
-      end
-
-      sets.comprehension { |strings| yield strings.join }
-    end
+  def mutate(mutations={},&block)
+    Ronin::Fuzzing::Mutator.new(mutations).each(self,&block)
   end
 
 end

data/lib/ronin/fuzzing/fuzzer.rb

@@ -0,0 +1,118 @@
+#
+# Copyright (c) 2006-2012 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# This file is part of Ronin Support.
+#
+# Ronin Support 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 Support 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 Support.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+require 'ronin/fuzzing/fuzzing'
+require 'ronin/extensions/regexp'
+
+require 'strscan'
+
+module Ronin
+  module Fuzzing
+    #
+    # Fuzzing class that incrementally fuzzes a String, given substitution
+    # rules.
+    #
+    # @api semipublic
+    #
+    # @since 0.5.0
+    #
+    class Fuzzer
+
+      # Patterns and their substitutions
+      attr_reader :rules
+
+      #
+      # Initializes a new Fuzzer.
+      #
+      # @param [Hash{Regexp,String => #each}] rules
+      #   Patterns and their substitutions.
+      #
+      def initialize(rules)
+        @rules = {}
+        
+        rules.each do |pattern,substitution|
+          pattern = case pattern
+                    when Regexp
+                      pattern
+                    when String
+                      Regexp.new(Regexp.escape(pattern))
+                    when Symbol
+                      Regexp.const_get(pattern.to_s.upcase)
+                    else
+                      raise(TypeError,"cannot convert #{pattern.inspect} to a Regexp")
+                    end
+
+          substitution = case substitution
+                         when Enumerable
+                           substitution
+                         when Symbol
+                           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
+                             substitute.call(string[index,length])
+                           when Integer
+                             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/fuzzing.rb

@@ -58,12 +58,17 @@ module Ronin
     # @return [Enumerator]
     #   An Enumerator for the fuzzer method.
     #
+    # @raise [NoMethodError]
+    #   The fuzzing method could not be found.
+    #
     # @api semipublic
     #
     def self.[](name)
-      if (!Object.respond_to?(name) && respond_to?(name))
-        enum_for(name)
+      if (!respond_to?(name) || Module.respond_to?(name))
+        raise(NoMethodError,"no such fuzzing method: #{name}")
       end
+
+      return enum_for(name)
     end
 
     module_function

data/lib/ronin/fuzzing/mutator.rb

@@ -0,0 +1,161 @@
+#
+# Copyright (c) 2006-2012 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# This file is part of Ronin Support.
+#
+# Ronin Support 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 Support 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 Support.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+require 'ronin/fuzzing/fuzzing'
+require 'ronin/extensions/regexp'
+
+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
+    #
+    # @since 0.5.0
+    #
+    class Mutator
+
+      # 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
+                      Regexp.const_get(pattern.to_s.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