rfuzz 0.6

data/examples/amazon_headers.rb

@@ -0,0 +1,38 @@
+require 'rubygems'
+require 'rfuzz/session'
+require 'hpricot'
+
+include RFuzz
+agent = "Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.8.0.4) Gecko/20060608 Ubuntu/dapper-security Firefox/1.5.0.4"
+
+amazon = HttpClient.new("www.amazon.com", 80, :head => {"User-Agent" => agent}, :redirect => 10)
+
+r = amazon.get("/")
+
+puts "## AMAZON'S WACKY HEADERS:"
+puts r.inspect
+
+puts "\n\n## AMAZON'S LAME EASTER EGG:"
+puts r.http_body.split("\n").last
+
+a9 = {}
+doc = Hpricot(r.http_body)
+(doc/:form).collect {|f|
+  if /a9.amazon.com/ === f.attributes["action"]
+    a9["action"] = f.attributes["action"]
+    a9["method"] = f.attributes["method"]
+    (f/:input).each {|i| a9[i.attributes["name"]] = i.attributes }
+  end
+}
+
+puts "A9 FORM: #{a9.inspect}"
+http://pastie.caboo.se/4810
+# do a search
+_, host, uri = a9["action"].split(/http:\/\/([a-z0-9\.]*)/)
+
+a9client = HttpClient.new(host, 80, :head => {"User-Agent" => agent}, :redirect => 10)
+r = a9client.get(uri, :query => {"q" => "test"})
+
+puts "\n\n## RESULTS"
+puts r.http_body
+

data/examples/hpricot_pudding.rb

@@ -0,0 +1,22 @@
+require 'rubygems'
+require 'hpricot'
+require 'rfuzz/session'
+include RFuzz
+
+agent = "Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.8.0.4) Gecko/20060608 Ubuntu/dapper-security Firefox/1.5.0.4"
+
+google = HttpClient.new("www.google.com", 80)
+r = google.get("/search", :head => {"User-Agent" => agent}, :query => {
+               "q" => ARGV[0], "hl" => "en", "btnG" => "Google Search"})
+
+if r.http_status != "200"
+  puts "Wrong Status: #{r.http_status}, did you forget to search for something?"
+else
+  doc = Hpricot(r.http_body)
+  (doc/:a).each do |link|
+    if link.attributes["class"] == "l"
+      puts link.attributes["href"]
+      puts " -- " + link.children.join
+    end
+  end
+end

data/examples/kill_routes.rb

@@ -0,0 +1,26 @@
+# An example of handing tons of nasty URLs to Rails to see what it does.
+
+require 'rfuzz/session'
+
+include RFuzz
+
+s = Session.new :host => "localhost", :port => 3000
+s.run 10, :save_as => ["runs.csv","counts.csv"] do |c,r|
+  len = r.num(90) + 1
+  s.count :len, len
+  uris = r.uris(ARGV[0].to_i,len)
+
+  uris.each do |u| 
+    s.count_errors(:legal) do
+      # first sample for legal uris
+      resp = c.get(u)
+      s.count resp.http_status
+    end
+
+    # next sample for illegal uris
+    s.count_errors(:illegal) do
+      resp = c.get(u * 512)
+      s.count resp.http_status
+    end
+  end
+end

data/examples/mongrel_test_suite/lib/gen.rb

@@ -0,0 +1,24 @@
+
+def sub_rant(name)
+  return <<-END
+desc "Behavior for #{name}"
+task :all do
+  sys "spec", sys["*.rb"]
+end
+END
+end
+
+def spec_file(context)
+  return <<-END
+require 'rfuzz/session'
+
+context "#{context}" do
+  setup do
+  end
+
+  specify "#{context} spec" do
+  end
+end
+END
+end
+

data/examples/mongrel_test_suite/test/camping/static_files.rb

@@ -0,0 +1,9 @@
+require 'rfuzz/session'
+
+context "static_files" do
+  setup do
+  end
+
+  specify "static_files spec" do
+  end
+end

data/examples/mongrel_test_suite/test/camping/upload_file.rb

@@ -0,0 +1,9 @@
+require 'rfuzz/session'
+
+context "upload_file" do
+  setup do
+  end
+
+  specify "upload_file spec" do
+  end
+end

data/examples/mongrel_test_suite/test/camping/upload_progress.rb

@@ -0,0 +1,9 @@
+require 'rfuzz/session'
+
+context "upload_progress" do
+  setup do
+  end
+
+  specify "upload_progress spec" do
+  end
+end

data/examples/mongrel_test_suite/test/http/base_protocol.rb

@@ -0,0 +1,23 @@
+require 'rfuzz/session'
+
+context "Base HTTP Protocol" do
+  setup do
+    @sess = RFuzz::Session.new :host => "localhost", :port => 3000
+  end
+
+  specify "Blocks Long URIs" do
+    @sess.run(10) do |c,r|
+      len = r.num(90) + 1
+      uris = r.uris(50,len)
+
+      uris.each do |u| 
+        # next sample for illegal uris
+        @sess.count_errors(:illegal) do
+          resp = c.get(u * 512)
+          @sess.count resp.http_status
+        end
+      end
+    end
+  end
+
+end

data/examples/mongrel_test_suite/test/nitro/upload_file.rb

@@ -0,0 +1,9 @@
+require 'rfuzz/session'
+
+context "upload_file" do
+  setup do
+  end
+
+  specify "upload_file spec" do
+  end
+end

data/examples/mongrel_test_suite/test/nitro/upload_progress.rb

@@ -0,0 +1,9 @@
+require 'rfuzz/session'
+
+context "upload_progress" do
+  setup do
+  end
+
+  specify "upload_progress spec" do
+  end
+end

data/examples/mongrel_test_suite/test/rails/static_files.rb

@@ -0,0 +1,9 @@
+require 'rfuzz/session'
+
+context "static_files" do
+  setup do
+  end
+
+  specify "static_files spec" do
+  end
+end

data/examples/mongrel_test_suite/test/rails/upload_file.rb

@@ -0,0 +1,9 @@
+require 'rfuzz/session'
+
+context "upload_file" do
+  setup do
+  end
+
+  specify "upload_file spec" do
+  end
+end

data/examples/mongrel_test_suite/test/rails/upload_progress.rb

@@ -0,0 +1,9 @@
+require 'rfuzz/session'
+
+context "upload_progress" do
+  setup do
+  end
+
+  specify "upload_progress spec" do
+  end
+end

data/examples/perftest.rb

@@ -0,0 +1,30 @@
+# Simple script that hits a host port and URI with a bunch of connections
+# and measures the timings.
+
+require 'rfuzz/client'
+require 'rfuzz/stats'
+include RFuzz
+
+
+
+if ARGV.length != 4
+  STDERR.puts "usage:  ruby perftest.rb host port uri count"
+  exit 1
+end
+
+host, port, uri, count = ARGV[0], ARGV[1], ARGV[2], ARGV[3].to_i
+
+codes = {}
+cl = HttpClient.new(host, port, :notifier => StatsTracker.new)
+count.times do
+  begin
+    resp = cl.get(uri)
+    code = resp.http_status.to_i
+    codes[code] ||= 0
+    codes[code] += 1
+  rescue Object
+  end
+end
+
+puts cl.notifier.to_s
+puts "Status Codes: #{codes.inspect}"

data/ext/fuzzrnd/ext_help.h

@@ -0,0 +1,14 @@
+#ifndef ext_help_h
+#define ext_help_h
+
+#define RAISE_NOT_NULL(T) if(T == NULL) rb_raise(rb_eArgError, "NULL found for " # T " when shouldn't be.");
+#define DATA_GET(from,type,name) Data_Get_Struct(from,type,name); RAISE_NOT_NULL(name);
+#define REQUIRE_TYPE(V, T) if(TYPE(V) != T) rb_raise(rb_eTypeError, "Wrong argument type for " # V " required " # T);
+
+#ifdef DEBUG
+#define TRACE()  fprintf(stderr, "> %s:%d:%s\n", __FILE__, __LINE__, __FUNCTION__)
+#else
+#define TRACE() 
+#endif
+
+#endif

data/ext/fuzzrnd/extconf.rb

@@ -0,0 +1,6 @@
+require 'mkmf'
+
+dir_config("fuzzrnd")
+have_library("c", "main")
+
+create_makefile("fuzzrnd")

data/ext/fuzzrnd/fuzzrnd.c

@@ -0,0 +1,149 @@
+/**
+ * Copyright (c) 2005 Zed A. Shaw
+ * You can redistribute it and/or modify it under the same terms as Ruby.
+ */
+
+#include "ruby.h"
+#include "ext_help.h"
+#include <assert.h>
+#include <string.h>
+#include <ctype.h>
+#include <inttypes.h>
+
+static VALUE mRFuzz;
+static VALUE cFuzzRnd;
+static VALUE eFuzzRndError;
+
+
+/**
+ * We use one source of ArcFour data for now.  This means that things aren't
+ * thread safe yet, but since the ArcFour is just for the current weaker implementation
+ * I'm not investing any more time making it thread safe.
+ */
+static struct
+{
+  unsigned char  i,j;                        /* ArcFour variables */
+  unsigned char  sbox[256];                  /* ArcFour s-box */
+} ArcFour;
+
+
+/** 
+ * call-seq:
+ *    rnd.seed -> rnd
+ *
+ * Returns a String of random bytes of length that you can use 
+ * for generating randomness.  It uses the ArcFour cipher to 
+ * make the randomness, so the same seeds produce the same 
+ * random bits, and the randomness is reasonably high quality.
+ *
+ * Don't use this for secure random generation.  It probably would
+ * work if you seeded from a /dev/random that worked, but don't
+ * blame me if you get hacked.
+ *
+ * The main motiviation for using ArcFour without automated reseed
+ * is to produce lots of random bytes quickly, make them high enough
+ * quality for good random tests, and to make sure that we can replay
+ * possible sequences if there's a sequence that we want to test.
+ */
+VALUE FuzzRnd_data(VALUE self, VALUE length)
+{
+
+  uint32_t n;
+  unsigned char a,b;
+  size_t len = 0;
+  VALUE data;
+  char *p = NULL;
+
+  REQUIRE_TYPE(length, T_FIXNUM);
+
+  len = FIX2INT(length);
+  data = rb_str_buf_new(len);
+  p = RSTRING(data)->ptr;
+  rb_str_resize(data, len);
+
+  for (n=0;n<len;n++)             /* run the ArcFour algorithm as long as it needs */
+  {
+    ArcFour.i++;
+    a     =         ArcFour.sbox[ArcFour.i];
+    ArcFour.j = (unsigned char) (ArcFour.j + a);     /* avoid MSVC picky compiler warning */
+    b     =         ArcFour.sbox[ArcFour.j];
+    ArcFour.sbox[ArcFour.i] = b;
+    ArcFour.sbox[ArcFour.j] = a;
+    p[n]  = ArcFour.sbox[(a+b) & 0xFF];
+  }
+
+  return data;
+}
+
+
+/** 
+ * call-seq:
+ *    rnd.seed -> rnd
+ *
+ * Seeds the global ArcFour random generator with the given seed.  The same seeds
+ * should produce the exact same stream of random data so that you can get 
+ * large amounts of randomness but replay possible interactions using just 
+ * an initial key.
+ *
+ * This function also doubles as the FuzzRnd.initialize method since they
+ * do nearly the same thing.
+ *
+ * Taken from http://www.mozilla.org/projects/security/pki/nss/draft-kaukonen-cipher-arcfour-03.txt
+ * sample code, but compared with the output of the ArcFour implementation in
+ * the Phelix test code to make sure it is the same initialization.  The main
+ * difference is that this init takes an arbitrary keysize while the original
+ * Phelix ArcFour only took a 32bit key.
+ *
+ * Returns itself so you can seed and then get data easily.
+ */
+VALUE FuzzRnd_seed(VALUE self, VALUE data) {
+
+  unsigned int t, u;
+  unsigned int keyindex;
+  unsigned int stateindex;
+  unsigned char *state;
+  unsigned int counter;
+  char *key = NULL;
+  size_t key_len = 0;
+
+  REQUIRE_TYPE(data, T_STRING);
+
+  key = RSTRING(data)->ptr;
+  key_len = RSTRING(data)->len;
+
+  state = ArcFour.sbox;
+  ArcFour.i = 0;
+  ArcFour.j = 0;
+
+  for (counter = 0; counter < 256; counter++)
+    state[counter] = counter;
+
+  keyindex = 0;
+  stateindex = 0;
+  for (counter = 0; counter < 256; counter++)
+  {
+    t = state[counter];
+    stateindex = (stateindex + key[keyindex] + t) & 0xff;
+    u = state[stateindex];
+    state[stateindex] = t;
+    state[counter] = u;
+    if (++keyindex >= key_len)
+      keyindex = 0;
+  }
+
+  return self;
+}
+
+void Init_fuzzrnd()
+{
+  mRFuzz = rb_define_module("RFuzz");
+
+  eFuzzRndError = rb_define_class_under(mRFuzz, "FuzzRndError", rb_eIOError);
+
+  cFuzzRnd = rb_define_class_under(mRFuzz, "FuzzRnd", rb_cObject);
+  rb_define_method(cFuzzRnd, "initialize", FuzzRnd_seed, 1);
+  rb_define_method(cFuzzRnd, "seed", FuzzRnd_seed,1);
+  rb_define_method(cFuzzRnd, "data", FuzzRnd_data,1);
+}
+
+

data/ext/http11_client/ext_help.h

@@ -0,0 +1,14 @@
+#ifndef ext_help_h
+#define ext_help_h
+
+#define RAISE_NOT_NULL(T) if(T == NULL) rb_raise(rb_eArgError, "NULL found for " # T " when shouldn't be.");
+#define DATA_GET(from,type,name) Data_Get_Struct(from,type,name); RAISE_NOT_NULL(name);
+#define REQUIRE_TYPE(V, T) if(TYPE(V) != T) rb_raise(rb_eTypeError, "Wrong argument type for " # V " required " # T);
+
+#ifdef DEBUG
+#define TRACE()  fprintf(stderr, "> %s:%d:%s\n", __FILE__, __LINE__, __FUNCTION__)
+#else
+#define TRACE() 
+#endif
+
+#endif