dfuzz 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9d357bf3301dd7c682ec2da083387fb19ec0b713
+  data.tar.gz: a352d7e660207450f6b0062fdb67680dfa255f22
+SHA512:
+  metadata.gz: e5c25fc9cda6e3663a8a684c595529a89bab0659b9e4f762252d722a876228d4216962f85ac9fe79d087bc4ddff25db62403dc2c56ee2693c9ddaaca8e5d470f
+  data.tar.gz: adc0c2a308b0a1137ed14278beb77d1e499e40c4551b76d6002efc7236fc14d31cdcf768dd7f55109399fcb45668396b9bcba735480ea3030bb15e059004f2fe

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/README.rdoc

@@ -0,0 +1,18 @@
+= dfuzz
+
+Description goes here.
+
+== Contributing to dfuzz
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2005-2008 Dino Dai Zovi
+Copyright (c) 2011-2016 tduehr. See LICENSE.txt for further details.

data/Rakefile

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "dfuzz"
+  gem.homepage = "http://github.com/tduehr/dfuzz"
+  gem.summary = %Q{Fuzz generators}
+  gem.description = %Q{Fuzzing payload generators for pentesting}
+  gem.email = "timur.duehr@nccgroup.trust"
+  gem.authors = ["tduehr", "Dino Dai Zovi"]
+  gem.add_development_dependency "jeweler", "~> 2.1.2"
+  gem.add_development_dependency "yard", "~> 0.9.5"
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+    test.rcov_opts << '--exclude "gems/*"'
+  end
+rescue LoadError
+end
+
+task :default => :test
+
+require 'yard'
+YARD::Rake::YardocTask.new

data/VERSION

@@ -0,0 +1 @@
+0.3.0

data/dfuzz.gemspec

@@ -0,0 +1,57 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+# stub: dfuzz 0.3.0 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "dfuzz"
+  s.version = "0.3.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib"]
+  s.authors = ["tduehr", "Dino Dai Zovi"]
+  s.date = "2016-11-03"
+  s.description = "Fuzzing payload generators for pentesting"
+  s.email = "timur.duehr@nccgroup.trust"
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "dfuzz.gemspec",
+    "lib/dfuzz.rb",
+    "lib/dfuzz/block.rb",
+    "lib/dfuzz/char.rb",
+    "lib/dfuzz/fudge.rb",
+    "lib/dfuzz/generator.rb",
+    "lib/dfuzz/generator18.rb",
+    "lib/dfuzz/integer.rb",
+    "lib/dfuzz/sequential.rb",
+    "lib/dfuzz/string.rb",
+    "test/helper.rb",
+    "test/test_dfuzz.rb"
+  ]
+  s.homepage = "http://github.com/tduehr/dfuzz"
+  s.rubygems_version = "2.5.1"
+  s.summary = "Fuzz generators"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<jeweler>, ["~> 2.1.2"])
+      s.add_development_dependency(%q<yard>, ["~> 0.9.5"])
+    else
+      s.add_dependency(%q<jeweler>, ["~> 2.1.2"])
+      s.add_dependency(%q<yard>, ["~> 0.9.5"])
+    end
+  else
+    s.add_dependency(%q<jeweler>, ["~> 2.1.2"])
+    s.add_dependency(%q<yard>, ["~> 0.9.5"])
+  end
+end
+

data/lib/dfuzz.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+#
+# = fuzz.rb
+#
+# Fuzz Generators
+#
+# Ruby 1.8 Generators use continuations (which are slow) and leak
+# memory like crazy, so use generators.rb from Ruby 1.9.
+#
+# Author:: Dai Zovi, Dino <ddz@theta44.org>
+# License:: Private
+# Revision:: $Id$
+#
+
+if RUBY_VERSION < "1.9"
+  require 'dfuzz/generator18'
+else
+  require 'dfuzz/generator'
+end
+
+require 'dfuzz/fudge'
+require 'dfuzz/integer'
+require 'dfuzz/char'
+require 'dfuzz/block'
+require 'dfuzz/sequential'
+require 'dfuzz/string'
+
+module DFuzz
+  #
+  # Modules for higher-level tokens (e-mail addresses, asn1, etc)
+  #
+  class EmailAddress < Generator
+    def initialize()
+    end
+  end
+
+end

data/lib/dfuzz/block.rb

@@ -0,0 +1,28 @@
+module DFuzz
+  # Serially generate each variable in turn (equivalent to
+  # recursively nesting generators)
+  class Block
+    def initialize(defaults, generators)
+      @defaults = defaults
+      @generators = generators
+    end
+
+    def run(&block)
+      generators_index = 0
+
+      # Baseline
+      block.call(@defaults)
+
+      # Iterate through generators, fully exhausting each and
+      # calling the code block with each set of values
+      @generators.each { |g|
+        values = Array.new(@defaults)
+        while (g.next?)
+          values[generators_index] = g.next
+          block.call(values)
+        end
+        generators_index += 1;
+      }
+    end
+  end
+end

data/lib/dfuzz/char.rb

@@ -0,0 +1,37 @@
+module DFuzz
+  class Char < Generator
+    def initialize(c=:default)
+      c = case c
+      when :all
+        (0..256).map(&:chr)
+      when :alpha
+        ('A'..'Z').to_a + ('a'..'z').to_a
+      when Enumerator
+        c
+      when ::String
+        c.chars
+      when :default
+        ["A", "0", "~", "`", "!", "@", "#", "$", "%", "^", "&",
+         "*", "(", ")", "-", "=", "+", "[", "]", "|",
+         ":", "'", "\"", ",", "<", ".", ">", "/",
+         " ", "~", "_", "{", "}", "\x7f","\x00",
+         "\x88","\x89","\x8f",
+         "\x98","\x99","\x9f",
+         "\xa8","\xa9","\xaf",
+         "\xb8","\xb9","\xbf",
+         "\xc8","\xc9","\xcf",
+         "\xd8","\xd9","\xdf",
+         "\xe8","\xe9","\xef",
+         "\xf8","\xf9","\xff"
+       ]
+      else
+        c.to_enum
+      end
+      super() {|yldr|
+        c.each do |char|
+          yldr.yield char
+        end
+      }
+    end
+  end
+end

data/lib/dfuzz/fudge.rb

@@ -0,0 +1,22 @@
+require 'dfuzz/generator'
+
+module DFuzz
+  # Generate Xi-F...Xi+F for each Xi in boundaries and fudge_factor F
+  class Fudge < DFuzz::Generator
+    def initialize(boundaries, fudge_factor, mask = nil)
+      super() { |g|
+        boundaries.each {|b|
+          0.upto(fudge_factor) { |f|
+            if (mask)
+              g.yield((b+f) & mask)
+              g.yield((b-f) & mask)
+            else
+              g.yield b+f
+              g.yield b-f
+            end
+          }
+        }
+      }
+    end
+  end
+end

data/lib/dfuzz/generator.rb

@@ -0,0 +1,16 @@
+module DFuzz
+  class Generator < ::Enumerator
+    def next?
+      begin
+        self.peek
+        true
+      rescue StopIteration
+        false
+      end
+    end
+
+    # def to_a; self; end
+    def shift; next? ? self.next : nil; end
+    def empty?; !self.next?; end
+  end
+end

data/lib/dfuzz/generator18.rb

@@ -0,0 +1,385 @@
+#!/usr/bin/env ruby
+#--
+# $Idaemons: /home/cvs/rb/generator.rb,v 1.8 2001/10/03 08:54:32 knu Exp $
+# $RoughId: generator.rb,v 1.10 2003/10/14 19:36:58 knu Exp $
+# $Id: generator.rb,v 1.12 2005/12/31 02:56:46 ocean Exp $
+#++
+#
+# = generator.rb: convert an internal iterator to an external one
+#
+# Copyright (c) 2001,2003 Akinori MUSHA <knu@iDaemons.org>
+#
+# All rights reserved.  You can redistribute and/or modify it under
+# the same terms as Ruby.
+#
+# == Overview
+#
+# This library provides the Generator class, which converts an
+# internal iterator (i.e. an Enumerable object) to an external
+# iterator.  In that form, you can roll many iterators independently.
+#
+# The SyncEnumerator class, which is implemented using Generator,
+# makes it easy to roll many Enumerable objects synchronously.
+#
+# See the respective classes for examples of usage.
+
+module DFuzz
+
+  #
+  # Generator converts an internal iterator (i.e. an Enumerable object)
+  # to an external iterator.
+  #
+  # == Example
+  #
+  #   require 'generator'
+  #
+  #   # Generator from an Enumerable object
+  #   g = Generator.new(['A', 'B', 'C', 'Z'])
+  #
+  #   while g.next?
+  #     puts g.next
+  #   end
+  #
+  #   # Generator from a block
+  #   g = Generator.new { |g|
+  #     for i in 'A'..'C'
+  #       g.yield i
+  #     end
+  #
+  #     g.yield 'Z'
+  #   }
+  #
+  #   # The same result as above
+  #   while g.next?
+  #     puts g.next
+  #   end
+  #   
+  class Generator
+    include Enumerable
+
+    # Creates a new generator either from an Enumerable object or from a
+    # block.
+    #
+    # In the former, block is ignored even if given.
+    #
+    # In the latter, the given block is called with the generator
+    # itself, and expected to call the +yield+ method for each element.
+    def initialize(enum = nil, &block)
+      if enum
+        @block = proc{|g| enum.each{|value| g.yield value}}
+      else
+        @block = block
+      end
+      @index = 0
+      @queue = []
+      @main_thread = nil
+      @loop_thread.kill if defined?(@loop_thread)
+      @loop_thread = Thread.new do
+        Thread.stop
+        begin
+          @block.call(self)
+        rescue
+          @main_thread.raise $!
+        ensure
+          @main_thread.wakeup
+        end
+      end
+      Thread.pass until @loop_thread.stop?
+      self
+    end
+
+    # Yields an element to the generator.
+    def yield(value)
+      if Thread.current != @loop_thread
+        raise "should be called in Generator.new{|g| ... }"
+      end
+      Thread.critical = true
+      begin
+        @queue << value
+        @main_thread.wakeup
+        Thread.stop
+      ensure
+        Thread.critical = false
+      end
+      self
+    end
+
+    # Returns true if the generator has reached the end.
+    def end?
+      if @queue.empty?
+        if @main_thread
+          raise "should not be called in Generator.new{|g| ... }"
+        end
+        Thread.critical = true
+        begin
+          @main_thread = Thread.current
+          @loop_thread.wakeup
+          Thread.stop
+        rescue ThreadError
+          # ignore
+        ensure
+          @main_thread = nil
+          Thread.critical = false
+        end
+      end
+      @queue.empty?
+    end
+
+    # Returns true if the generator has not reached the end yet.
+    def next?
+      !end?
+    end
+
+    # Returns the current index (position) counting from zero.
+    def index
+      @index
+    end
+
+    # Returns the current index (position) counting from zero.
+    def pos
+      @index
+    end
+
+    # Returns the element at the current position and moves forward.
+    def next
+      raise EOFError.new("no more elements available") if end?
+      @index += 1
+      @queue.shift
+    end
+
+    # Returns the element at the current position.
+    def current
+      raise EOFError.new("no more elements available") if end?
+      @queue.first
+    end
+
+    # Rewinds the generator.
+    def rewind
+      initialize(nil, &@block) if @index.nonzero?
+      self
+    end
+
+    # Rewinds the generator and enumerates the elements.
+    def each
+      rewind
+      until end?
+        yield self.next
+      end
+      self
+    end
+  end
+
+  #
+  # SyncEnumerator creates an Enumerable object from multiple Enumerable
+  # objects and enumerates them synchronously.
+  #
+  # == Example
+  #
+  #   require 'generator'
+  #
+  #   s = SyncEnumerator.new([1,2,3], ['a', 'b', 'c'])
+  #
+  #   # Yields [1, 'a'], [2, 'b'], and [3,'c']
+  #   s.each { |row| puts row.join(', ') }
+  #
+  class SyncEnumerator
+    include Enumerable
+
+    # Creates a new SyncEnumerator which enumerates rows of given
+    # Enumerable objects.
+    def initialize(*enums)
+      @gens = enums.map { |e| Generator.new(e) }
+    end
+
+    # Returns the number of enumerated Enumerable objects, i.e. the size
+    # of each row.
+    def size
+      @gens.size
+    end
+
+    # Returns the number of enumerated Enumerable objects, i.e. the size
+    # of each row.
+    def length
+      @gens.length
+    end
+
+    # Returns true if the given nth Enumerable object has reached the
+    # end.  If no argument is given, returns true if any of the
+    # Enumerable objects has reached the end.
+    def end?(i = nil)
+      if i.nil?
+        @gens.detect { |g| g.end? } ? true : false
+      else
+        @gens[i].end?
+      end
+    end
+
+    # Enumerates rows of the Enumerable objects.
+    def each
+      @gens.each { |g| g.rewind }
+
+      loop do
+        count = 0
+
+        ret = @gens.map { |g|
+  	if g.end?
+  	  count += 1
+  	  nil
+  	else
+  	  g.next
+  	end
+        }
+
+        if count == @gens.size
+  	break
+        end
+
+        yield ret
+      end
+
+      self
+    end
+  end
+end
+
+if $0 == __FILE__
+  eval DATA.read, nil, $0, __LINE__+4
+end
+
+__END__
+
+require 'test/unit'
+
+class TC_Generator < Test::Unit::TestCase
+  def test_block1
+    g = Generator.new { |g|
+      # no yield's
+    }
+
+    assert_equal(0, g.pos)
+    assert_raises(EOFError) { g.current }
+  end
+
+  def test_block2
+    g = Generator.new { |g|
+      for i in 'A'..'C'
+        g.yield i
+      end
+
+      g.yield 'Z'
+    }
+
+    assert_equal(0, g.pos)
+    assert_equal('A', g.current)
+
+    assert_equal(true, g.next?)
+    assert_equal(0, g.pos)
+    assert_equal('A', g.current)
+    assert_equal(0, g.pos)
+    assert_equal('A', g.next)
+
+    assert_equal(1, g.pos)
+    assert_equal(true, g.next?)
+    assert_equal(1, g.pos)
+    assert_equal('B', g.current)
+    assert_equal(1, g.pos)
+    assert_equal('B', g.next)
+
+    assert_equal(g, g.rewind)
+
+    assert_equal(0, g.pos)
+    assert_equal('A', g.current)
+
+    assert_equal(true, g.next?)
+    assert_equal(0, g.pos)
+    assert_equal('A', g.current)
+    assert_equal(0, g.pos)
+    assert_equal('A', g.next)
+
+    assert_equal(1, g.pos)
+    assert_equal(true, g.next?)
+    assert_equal(1, g.pos)
+    assert_equal('B', g.current)
+    assert_equal(1, g.pos)
+    assert_equal('B', g.next)
+
+    assert_equal(2, g.pos)
+    assert_equal(true, g.next?)
+    assert_equal(2, g.pos)
+    assert_equal('C', g.current)
+    assert_equal(2, g.pos)
+    assert_equal('C', g.next)
+
+    assert_equal(3, g.pos)
+    assert_equal(true, g.next?)
+    assert_equal(3, g.pos)
+    assert_equal('Z', g.current)
+    assert_equal(3, g.pos)
+    assert_equal('Z', g.next)
+
+    assert_equal(4, g.pos)
+    assert_equal(false, g.next?)
+    assert_raises(EOFError) { g.next }
+  end
+
+  def test_each
+    a = [5, 6, 7, 8, 9]
+
+    g = Generator.new(a)
+
+    i = 0
+
+    g.each { |x|
+      assert_equal(a[i], x)
+
+      i += 1
+
+      break if i == 3
+    }
+
+    assert_equal(3, i)
+
+    i = 0
+
+    g.each { |x|
+      assert_equal(a[i], x)
+
+      i += 1
+    }
+
+    assert_equal(5, i)
+  end
+end
+
+class TC_SyncEnumerator < Test::Unit::TestCase
+  def test_each
+    r = ['a'..'f', 1..10, 10..20]
+    ra = r.map { |x| x.to_a }
+
+    a = (0...(ra.map {|x| x.size}.max)).map { |i| ra.map { |x| x[i] } }
+
+    s = SyncEnumerator.new(*r)
+
+    i = 0
+
+    s.each { |x|
+      assert_equal(a[i], x)
+
+      i += 1
+
+      break if i == 3
+    }
+
+    assert_equal(3, i)
+
+    i = 0
+
+    s.each { |x|
+      assert_equal(a[i], x)
+
+      i += 1
+    }
+
+    assert_equal(a.size, i)
+  end
+end

data/lib/dfuzz/integer.rb

@@ -0,0 +1,32 @@
+module DFuzz
+  class Integer < Fudge
+      def initialize(delta = 0x80)
+          super([0, 0x7FFF, 0xFFFF, 0x7FFFFFFF,
+                 0x7FFFFFFFFFFFFFFF], delta)
+      end
+  end
+
+  class Byte < Integer
+      def initialize(delta = 0x10)
+          super([0x00, 0x01, 0x7F, 0xFF], delta, 0xFF)
+      end
+  end
+
+  class Short < Integer
+      def initialize(delta = 0x80)
+          super([0x0000, 0x0001, 0x7FFF, 0xFFFF], delta, 0xFFFF)
+      end
+  end
+
+  class Long < Integer
+    def initialize(delta = 0x10000)
+      super([0x00000000, 0x0000001, 0x7FFFFFFF, 0xFFFFFFFF, 0x40000000, 0xC0000000], delta, 0xffffffff)
+    end
+  end
+
+  class LongLong < Integer
+    def initialize(delta = 100000000)
+      super([0x00000000, 0x0000001, 0x7FFFFFFFFFFFFFFF, 0xFFFFFFFF, 0x4000000000000000, 0xC000000000000000], delta, 0xffffffffffffffff)
+    end
+  end
+end

data/lib/dfuzz/sequential.rb

@@ -0,0 +1,26 @@
+module DFuzz
+  class Sequential < Generator
+    def initialize *generators
+      super() do |g|
+        generators.each do |gen|
+          gen.each do |val|
+            g.yield val
+          end
+        end
+      end
+    end
+
+    def next?
+      begin
+        self.peek
+        true
+      rescue StopIteration
+        false
+      end
+    end
+
+    def to_a; self; end
+    def shift; next? ? self.next : nil; end
+    def empty?; !self.next?; end
+  end
+end

data/lib/dfuzz/string.rb

@@ -0,0 +1,35 @@
+module DFuzz
+  class String < Generator
+    def initialize(lengths = nil, strings = nil, chars = nil)
+      super() { |g|
+        # Fuzz strings are each of CHARS repeated each of
+        # LENGTHS times and each of strings
+        lengths ||= [16, 32, 64, 100, 128, 192, 256, 384, 512, 768, 1024, 2048, 3072, 4096, 6000, 8192, 10000, 16000, 20000, 32000, 50000, 64000, 72000,  100000]
+        strings ||= [
+          "%n%n%n%n%n%n%n%n%n%n", "%252n%252n%252n%252n%252n",
+          "%x%x%x%x", "%252x%252x%252x%252x",
+          "../../../../../../../../../../../../../etc/passwd",
+          "../../../../../../../../../../../../../etc/passwd%00",
+          "../../../../../../../../../../../../../boot.ini",
+          "../../../../../../../../../../../../../boot.ini%00",
+          "..\\..\\..\\..\\..\\..\\..\\..\\..\\..\\boot.ini",
+          "..\\..\\..\\..\\..\\..\\..\\..\\..\\..\\boot.ini%00",
+          "<script>alert('XSS');</script>",
+          "A0`~!@#\$\%^&*()-_=+[]{}\\|;:',.<>/\""
+        ]
+        chars ||= Char.new()
+        while chars.next?
+          c = chars.next
+
+          lengths.each { |l|
+            g.yield(c * l)
+          }
+        end
+
+        strings.each { |s|
+          g.yield(s)
+        }
+      }
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'dfuzz'
+
+class Test::Unit::TestCase
+end

data/test/test_dfuzz.rb

@@ -0,0 +1,74 @@
+require 'helper'
+
+class TestDfuzz < Test::Unit::TestCase
+  def test_integers
+    i = 0
+    integers = DFuzz::Integer.new()
+    while integers.next?
+        integers.next
+        i += 1
+    end
+    assert_equal(1290, i)
+  end
+
+  def test_bytes
+    i = 0
+    bytes = DFuzz::Byte.new()
+    while bytes.next?
+        bytes.next
+        i += 1
+    end
+    assert_equal(136,i)
+  end
+
+  def test_shorts
+    i = 0
+    shorts = DFuzz::Short.new()
+    while shorts.next?
+        shorts.next
+        i += 1
+    end
+    assert_equal(1032, i)
+  end
+  
+  def test_longs
+    i = 0
+    longs = DFuzz::Long.new()
+    while longs.next?
+        longs.next
+        i += 1
+    end
+    assert_equal(3084, i)
+  end
+
+  def test_chars
+    i = 0
+    characters = DFuzz::Char.new()
+    while characters.next?
+        characters.next
+        i += 1
+    end
+    assert_equal(197, i)
+  end
+
+  def test_strings
+    i = 0
+    strings = DFuzz::String.new([1,2])
+    while strings.next?
+        strings.next
+        i += 1
+    end
+    assert_equal(406, i)
+  end
+  
+  def test_blocks
+    require 'pp'
+    b = DFuzz::Block.new(["FOO", "BAR"],
+                        [DFuzz::String.new([1]), DFuzz::String.new([2])])
+    i = 0
+    b.run() { |a, b|
+        i += 1
+    }
+    assert_equal(419, i)
+  end
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: dfuzz
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- tduehr
+- Dino Dai Zovi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-11-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.2
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.5
+description: Fuzzing payload generators for pentesting
+email: timur.duehr@nccgroup.trust
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+files:
+- ".document"
+- README.rdoc
+- Rakefile
+- VERSION
+- dfuzz.gemspec
+- lib/dfuzz.rb
+- lib/dfuzz/block.rb
+- lib/dfuzz/char.rb
+- lib/dfuzz/fudge.rb
+- lib/dfuzz/generator.rb
+- lib/dfuzz/generator18.rb
+- lib/dfuzz/integer.rb
+- lib/dfuzz/sequential.rb
+- lib/dfuzz/string.rb
+- test/helper.rb
+- test/test_dfuzz.rb
+homepage: http://github.com/tduehr/dfuzz
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Fuzz generators
+test_files: []