Class: Ronin::Fuzzing::Template

Inherits:
Object
  • Object
show all
Includes:
Enumerable
Defined in:
lib/ronin/fuzzing/template.rb

Overview

Fuzzing class that generates Strings based on a template.

Since:

  • 0.5.0

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Enumerable

#map_hash

Constructor Details

#initialize(fields) ⇒ Template

Initializes a new Fuzzing template.

Parameters:

  • fields (Array(<String,Symbol,Enumerable>, <Integer,Array,Range>))

    The fields which defines the string or character sets which will make up parts of the String.

Raises:

  • (ArgumentError)

    A given character set name was unknown.

  • (TypeError)

    A given string set was not a String, Symbol or Enumerable. A given string set length was not an Integer or Enumerable.

Since:

  • 0.5.0


51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
# File 'lib/ronin/fuzzing/template.rb', line 51

def initialize(fields)
  @enumerators = []

  fields.each do |(set,length)|
    enum = case set
           when String
             [set].each
           when Enumerable
             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
           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

Class Method Details

.[](*fields) ⇒ Object

See Also:

Since:

  • 0.5.0


94
95
96
# File 'lib/ronin/fuzzing/template.rb', line 94

def self.[](*fields)
  new(fields)
end

Instance Method Details

#each {|string| ... } ⇒ Enumerator

Generate permutations of Strings from a format template.

Yields:

  • (string)

    The given block will be passed each unique String.

Yield Parameters:

  • string (String)

    A newly generated String.

Returns:

  • (Enumerator)

    If no block is given, an Enumerator will be returned.

Since:

  • 0.5.0


110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
# File 'lib/ronin/fuzzing/template.rb', line 110

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