crypt-isaac 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eeff4541c06d7907ba4eb56a0784cb908fd1c039
-  data.tar.gz: fc61b38f750e2e3a805580b424aafc057aff01bb
+  metadata.gz: 32721d59c293f47c17f554ec6d614a3dd6d9c223
+  data.tar.gz: 3b0bf2597824aa9e730ee2d314e96fbe028d489f
 SHA512:
-  metadata.gz: 7181904366b11ae6ce0be343a720e0e0e56f847579675e0ef00680888e9dce6413dadaff21e0d3cd297b4b591cc718dc77d00fdef4e41a135f8be816138b2610
-  data.tar.gz: b937c669132250c3cbc4d7fc4cfbadbfebfed56211f6a252fb4d0dbb088e94713f9f30c9bb6121318060dd72e6a3d567754f7e95fde6dff1d3f3bb55f43e6b23
+  metadata.gz: b43a59b1dffaf4f1326081fe7b4f935ad4ecb478c17e23d8f637d8e03f2d9a7166964f750eb93953e298ecb0d57754d0ad98d2524c316f0d20d09b2d0d66e7db
+  data.tar.gz: 9313d7ac00934839290713cef9b2c6a5cb13da38b1c21eaf7a0bfc5f4838860777516c8416f086fb7ec0d05c83d99c75f60cd27b3bd5319f47c11137f2d3b803

data/README.md

@@ -4,11 +4,25 @@ ISAAC is a cryptographically secure PRNG for generating high quality random numb
 
 http://burtleburtle.net/bob/rand/isaac.html
 
-This is a pure Ruby implementation of the algorithm, but it is reasonably fast.
+This library combines a pure Ruby implementation with a C implementation bound to ruby as an extension. The C extension implementation currently runs many times faster than the pure ruby implementation.
 
-When originally written, running on Ruby 1.8.2 under a venerable 800Mhz PIII Linux system, it could do 15000 to 16000 numbers per second. On Ruby 2.2.3, running on a basic Digital Ocean VM, it can generate almost a million random integers or floats per second.
+When originally written, running on Ruby 1.8.2 under a venerable 800Mhz PIII Linux system, it could do 15000 to 16000 numbers per second. On Ruby 2.3.1, testing via an Ubuntu shell session on a Windows 10 system running a 2.3Ghz Intel i5 processor, the library will generate over ten million floats per second, or almost nine million integers per second:
 
-Ruby uses the Mersenne Twister as its PRNG, and while this algorithm is a fast PRNG that produces highly random numbers with good stastical properties, it is not cryptographically strong. ISAAC is very fast, also has good statistical properties, and is cryptographically strong.
+```
+Benchmark integer prng generation
+       user     system      total        real
+   1.130000   0.000000   1.130000 (  1.138785)
+10000000 numbers generated in 1.1393164 seconds; 8777193 per second
+
+Benchmark float prng generation
+       user     system      total        real
+   0.950000   0.000000   0.950000 (  0.967220)
+10000000 numbers generated in 0.967398 seconds; 10337007 per second
+```
+
+Ruby uses the Mersenne Twister as its PRNG. This algorithm is used by many languages because it is relatively fast, and has a long period. It, however, is not cryptographically strong; observing a window of as few as 624 generated values is enough to establish the state of the generator and to predict all future numbers. Nor is it well suited to Monte Carlo type simulations unless the seeds are quite different (generators with similar keys tend to produce number sequences that are the same for quite a long time before diverging), and the generators are ran for a while to ensure strong divergence.
+
+ISAAC is very fast. This implementation is currently very comparable to Random's performance for both floats and for integers. ISAAC has strong statistical properties, like the Mersenne Twister, but it is also cryptographically strong, and different generators produce completely unique streams of numbers, even if seeded with similar seeds (though the seed size is substantial, so good seeding should make it difficult for two generators to be similarly seeded).
 
 ## Installation
 
@@ -31,9 +45,35 @@ Or install it yourself as:
 ```ruby
 require 'crypt/isaac'
 
-rng = Crypt::ISAAC.new # New ISAAC object, seeded using /dev/urandom or /dev/random, if available.
+rng = Crypt::ISAAC.new
+```
+ISAAC will seed itself, by default, using /dev/urandom, if the device exists on the system being used. This is the same as:
+
+```ruby
+rng = Crypt::ISAAC.new( true )
+```
+
+If one wants to use /dev/random instead (though there is really no reason to do so), pass false instead:
+
+```ruby
+rng = Crypt::ISAAC.new( false )
+```
+
+If /dev/urandom is not available, or nil is specifically passed, then Crypt::ISAAC will use Crypt::Xorshift, if it is installed, or a bundled microimplementation of Crypt::Xorshift64Star to generate a series of high quality pseudorandom numbers which will in turn be used to seed the ISAAC generator, as it produces better streams of numbers than the Mersenne Twister, in a very simple implementation.
+
+```ruby
+rng = Crypt::ISAAC.new( nil )
+```
+
+Finally, ISAAC may be seeded deterministically by passing an integer seed into it. Any ISAAC generator seeded with the same value will produce the same sequence of random numbers.
+
+```ruby
 rng = Crypt::ISAAC.new(17773845992) # New ISAAC object, seeded from a deterministic point.
+```
+
+TODO: One should be able to seed an ISAAC PRNG with an array of seed values, as well.
 
+```ruby
 r1 = rng.rand() # returns a floating point number between 0 and 1
 r2 = rng.rand(10.57) # returns a floating point number between 0 and 10.57
 r2 = rnd.rand(1000) # returns an integer between 0 and 999
@@ -43,6 +83,8 @@ noise = rng.bytes(1024) # return a 1k string of random bytes
 
 Crypt::ISAAC should provide the same API as the Ruby 2.2 version of Random.
 
+This implementation returns 32 bit values. TODO is to add support for the 64 bit version of ISAAC.
+
 Enjoy it.  Let me know if you find anything that can be improved or that
 needs to be fixed.
 

data/Rakefile

@@ -1,5 +1,14 @@
 require "bundler/gem_tasks"
 require "rake/testtask"
+require "rake/extensiontask"
+
+Rake::ExtensionTask.new "isaac" do |ext|
+  ext.lib_dir = "lib/crypt/"
+end
+
+Rake::ExtensionTask.new "xorshift" do |ext|
+  ext.lib_dir = "lib/crypt/xorshift"
+end
 
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"

data/crypt-isaac.gemspec

@@ -9,8 +9,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Kirk Haines"]
   spec.email         = ["wyhaines@gmail.com"]
 
-  spec.summary       = %q{An implementation of the ISAAC PRNG}
-  spec.description   = %q{ISAAC is a cryptgraphically secure pseudorandom number generator. This is a Ruby implementation of the algorithm.}
+  spec.summary       = %q{An implementation of the fast, cryptographically secure ISAAC PRNG}
+  spec.description   = %q{ISAAC is a fast, cryptographically secure pseudo random number generator with strong statistical properties. This gem provides both a pure Ruby and a C extension based implementation which conforms to the Ruby 2 api for Random, with some enhancements. So, you should be able to use it as a drop in replacement for Ruby's (Mersenne Twister based) PRNG. }
   spec.homepage      = "http://github.com/wyhaines/crypt-isaac"
   spec.license       = "MIT"
 
@@ -25,6 +25,7 @@ Gem::Specification.new do |spec|
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.extensions       = %w[ext/crypt/isaac/xorshift/extconf.rb ext/crypt/isaac/extconf.rb]
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler", "~> 1.10"

data/ext/crypt/isaac/Makefile

@@ -0,0 +1,260 @@
+
+SHELL = /bin/sh
+
+# V=0 quiet, V=1 verbose.  other values don't work.
+V = 0
+Q1 = $(V:1=)
+Q = $(Q1:0=@)
+ECHO1 = $(V:1=@:)
+ECHO = $(ECHO1:0=@echo)
+NULLCMD = :
+
+#### Start of system configuration section. ####
+
+srcdir = .
+topdir = /home/wyhaines/.rvm/rubies/ruby-2.3.1/include/ruby-2.3.0
+hdrdir = $(topdir)
+arch_hdrdir = /home/wyhaines/.rvm/rubies/ruby-2.3.1/include/ruby-2.3.0/x86_64-linux
+PATH_SEPARATOR = :
+VPATH = $(srcdir):$(arch_hdrdir)/ruby:$(hdrdir)/ruby
+prefix = $(DESTDIR)/home/wyhaines/.rvm/rubies/ruby-2.3.1
+rubysitearchprefix = $(rubylibprefix)/$(sitearch)
+rubyarchprefix = $(rubylibprefix)/$(arch)
+rubylibprefix = $(libdir)/$(RUBY_BASE_NAME)
+exec_prefix = $(prefix)
+vendorarchhdrdir = $(vendorhdrdir)/$(sitearch)
+sitearchhdrdir = $(sitehdrdir)/$(sitearch)
+rubyarchhdrdir = $(rubyhdrdir)/$(arch)
+vendorhdrdir = $(rubyhdrdir)/vendor_ruby
+sitehdrdir = $(rubyhdrdir)/site_ruby
+rubyhdrdir = $(includedir)/$(RUBY_VERSION_NAME)
+vendorarchdir = $(vendorlibdir)/$(sitearch)
+vendorlibdir = $(vendordir)/$(ruby_version)
+vendordir = $(rubylibprefix)/vendor_ruby
+sitearchdir = $(sitelibdir)/$(sitearch)
+sitelibdir = $(sitedir)/$(ruby_version)
+sitedir = $(rubylibprefix)/site_ruby
+rubyarchdir = $(rubylibdir)/$(arch)
+rubylibdir = $(rubylibprefix)/$(ruby_version)
+sitearchincludedir = $(includedir)/$(sitearch)
+archincludedir = $(includedir)/$(arch)
+sitearchlibdir = $(libdir)/$(sitearch)
+archlibdir = $(libdir)/$(arch)
+ridir = $(datarootdir)/$(RI_BASE_NAME)
+mandir = $(datarootdir)/man
+localedir = $(datarootdir)/locale
+libdir = $(exec_prefix)/lib
+psdir = $(docdir)
+pdfdir = $(docdir)
+dvidir = $(docdir)
+htmldir = $(docdir)
+infodir = $(datarootdir)/info
+docdir = $(datarootdir)/doc/$(PACKAGE)
+oldincludedir = $(DESTDIR)/usr/include
+includedir = $(prefix)/include
+localstatedir = $(prefix)/var
+sharedstatedir = $(prefix)/com
+sysconfdir = $(DESTDIR)/etc
+datadir = $(datarootdir)
+datarootdir = $(prefix)/share
+libexecdir = $(exec_prefix)/libexec
+sbindir = $(exec_prefix)/sbin
+bindir = $(exec_prefix)/bin
+archdir = $(rubyarchdir)
+
+
+CC = gcc
+CXX = g++
+LIBRUBY = $(LIBRUBY_SO)
+LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
+LIBRUBYARG_SHARED = -Wl,-rpath,'$${ORIGIN}/../lib' -Wl,-R'$${ORIGIN}/../lib' -l$(RUBY_SO_NAME)
+LIBRUBYARG_STATIC = -Wl,-rpath,'$${ORIGIN}/../lib' -Wl,-R'$${ORIGIN}/../lib' -l$(RUBY_SO_NAME)-static
+empty =
+OUTFLAG = -o $(empty)
+COUTFLAG = -o $(empty)
+
+RUBY_EXTCONF_H = 
+cflags   =  $(optflags) $(debugflags) $(warnflags)
+cxxflags =  $(optflags) $(debugflags) $(warnflags)
+optflags = -O3 -fno-fast-math
+debugflags = -ggdb3
+warnflags = -Wall -Wextra -Wno-unused-parameter -Wno-parentheses -Wno-long-long -Wno-missing-field-initializers -Wunused-variable -Wpointer-arith -Wwrite-strings -Wdeclaration-after-statement -Wimplicit-function-declaration -Wdeprecated-declarations -Wno-packed-bitfield-compat
+CCDLFLAGS = -fPIC
+CFLAGS   = $(CCDLFLAGS) $(cflags)  -fPIC $(ARCH_FLAG)
+INCFLAGS = -I. -I$(arch_hdrdir) -I$(hdrdir)/ruby/backward -I$(hdrdir) -I$(srcdir)
+DEFS     = 
+CPPFLAGS =   $(DEFS) $(cppflags)
+CXXFLAGS = $(CCDLFLAGS) $(cxxflags) $(ARCH_FLAG)
+ldflags  = -L. -fstack-protector -rdynamic -Wl,-export-dynamic
+dldflags =  
+ARCH_FLAG = 
+DLDFLAGS = $(ldflags) $(dldflags) $(ARCH_FLAG)
+LDSHARED = $(CC) -shared
+LDSHAREDXX = $(CXX) -shared
+AR = ar
+EXEEXT = 
+
+RUBY_INSTALL_NAME = $(RUBY_BASE_NAME)
+RUBY_SO_NAME = ruby
+RUBYW_INSTALL_NAME = 
+RUBY_VERSION_NAME = $(RUBY_BASE_NAME)-$(ruby_version)
+RUBYW_BASE_NAME = rubyw
+RUBY_BASE_NAME = ruby
+
+arch = x86_64-linux
+sitearch = $(arch)
+ruby_version = 2.3.0
+ruby = $(bindir)/$(RUBY_BASE_NAME)
+RUBY = $(ruby)
+ruby_headers = $(hdrdir)/ruby.h $(hdrdir)/ruby/ruby.h $(hdrdir)/ruby/defines.h $(hdrdir)/ruby/missing.h $(hdrdir)/ruby/intern.h $(hdrdir)/ruby/st.h $(hdrdir)/ruby/subst.h $(arch_hdrdir)/ruby/config.h
+
+RM = rm -f
+RM_RF = $(RUBY) -run -e rm -- -rf
+RMDIRS = rmdir --ignore-fail-on-non-empty -p
+MAKEDIRS = /bin/mkdir -p
+INSTALL = /usr/bin/install
+INSTALL_PROG = $(INSTALL) -m 0755
+INSTALL_DATA = $(INSTALL) -m 644
+COPY = cp
+TOUCH = exit >
+
+#### End of system configuration section. ####
+
+preload = 
+
+libpath = . $(libdir)
+LIBPATH =  -L. -L$(libdir) -Wl,-R$(libdir)
+DEFFILE = 
+
+CLEANFILES = mkmf.log
+DISTCLEANFILES = 
+DISTCLEANDIRS = 
+
+extout = 
+extout_prefix = 
+target_prefix = /crypt/isaac
+LOCAL_LIBS = 
+LIBS = $(LIBRUBYARG_SHARED)  -lpthread -ldl -lcrypt -lm   -lc
+ORIG_SRCS = isaac.c rand.c
+SRCS = $(ORIG_SRCS) 
+OBJS = isaac.o rand.o
+HDRS = $(srcdir)/rand.h $(srcdir)/standard.h
+TARGET = ext
+TARGET_NAME = ext
+TARGET_ENTRY = Init_$(TARGET_NAME)
+DLLIB = $(TARGET).so
+EXTSTATIC = 
+STATIC_LIB = 
+
+TIMESTAMP_DIR = .
+BINDIR        = $(bindir)
+RUBYCOMMONDIR = $(sitedir)$(target_prefix)
+RUBYLIBDIR    = $(sitelibdir)$(target_prefix)
+RUBYARCHDIR   = $(sitearchdir)$(target_prefix)
+HDRDIR        = $(rubyhdrdir)/ruby$(target_prefix)
+ARCHHDRDIR    = $(rubyhdrdir)/$(arch)/ruby$(target_prefix)
+
+TARGET_SO     = $(DLLIB)
+CLEANLIBS     = $(TARGET).so 
+CLEANOBJS     = *.o  *.bak
+
+all:    $(DLLIB)
+static: $(STATIC_LIB) install-rb
+.PHONY: all install static install-so install-rb
+.PHONY: clean clean-so clean-static clean-rb
+
+clean-static::
+clean-rb-default::
+clean-rb::
+clean-so::
+clean: clean-so clean-static clean-rb-default clean-rb
+		-$(Q)$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES) .*.time
+
+distclean-rb-default::
+distclean-rb::
+distclean-so::
+distclean-static::
+distclean: clean distclean-so distclean-static distclean-rb-default distclean-rb
+		-$(Q)$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log
+		-$(Q)$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES)
+		-$(Q)$(RMDIRS) $(DISTCLEANDIRS) 2> /dev/null || true
+
+realclean: distclean
+install: install-so install-rb
+
+install-so: $(DLLIB) $(TIMESTAMP_DIR)/.RUBYARCHDIR.-.crypt.-.isaac.time
+	$(INSTALL_PROG) $(DLLIB) $(RUBYARCHDIR)
+clean-static::
+	-$(Q)$(RM) $(STATIC_LIB)
+install-rb: pre-install-rb install-rb-default
+install-rb-default: pre-install-rb-default
+pre-install-rb: Makefile
+pre-install-rb-default: Makefile
+pre-install-rb-default:
+	@$(NULLCMD)
+$(TIMESTAMP_DIR)/.RUBYARCHDIR.-.crypt.-.isaac.time:
+	$(Q) $(MAKEDIRS) $(@D) $(RUBYARCHDIR)
+	$(Q) $(TOUCH) $@
+
+site-install: site-install-so site-install-rb
+site-install-so: install-so
+site-install-rb: install-rb
+
+.SUFFIXES: .c .m .cc .mm .cxx .cpp .o .S
+
+.cc.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.cc.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $<
+
+.mm.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.mm.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $<
+
+.cxx.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.cxx.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $<
+
+.cpp.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.cpp.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $<
+
+.c.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $<
+
+.c.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -S $<
+
+.m.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $<
+
+.m.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -S $<
+
+$(DLLIB): $(OBJS) Makefile
+	$(ECHO) linking shared-object crypt/isaac/$(DLLIB)
+	-$(Q)$(RM) $(@)
+	$(Q) $(LDSHARED) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS)
+
+
+
+$(OBJS): $(HDRS) $(ruby_headers)

data/ext/crypt/isaac/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+
+create_makefile("crypt/isaac/ext")

data/ext/crypt/isaac/isaac.c

@@ -0,0 +1,232 @@
+#include "ruby.h"
+#include "rand.h"
+
+static VALUE CryptModule;
+static VALUE ISAACClass;
+
+static void ISAAC_free( randctx* ctx ) {
+  if ( ctx ) {
+    xfree( ctx );
+  }
+}
+
+static VALUE ISAAC_alloc( VALUE klass ) {
+  randctx *ctx;
+
+  return Data_Make_Struct( klass, randctx, NULL, ISAAC_free, ctx );
+}
+
+static VALUE ISAAC_initialize( VALUE self, VALUE args ) {
+  VALUE _seed ;
+  long len = RARRAY_LEN( args );
+  if ( len == 0 ) {
+    _seed = Qtrue;
+  } else {
+    _seed = rb_ary_entry( args, 0 );
+  }
+
+  return rb_funcall( self, rb_intern( "srand" ), 1, _seed );
+}
+
+static VALUE ISAAC_srand( VALUE self, VALUE args ) {
+  FILE *fh;
+  uint32_t num = 0;
+  size_t nread;
+  VALUE _seed;
+  VALUE old_seed;
+  VALUE seed_prng;
+  VALUE random_argv[1];
+  VALUE rnd_source = Qnil;
+  int x;
+  long len = RARRAY_LEN( args );
+  randctx *ctx;
+
+  if ( len == 0 ) {
+    _seed = Qtrue;
+  } else {
+    _seed = rb_ary_entry( args, 0 );
+  }
+
+  if ( ( _seed == Qtrue ) || ( _seed == Qfalse ) ) {
+    rnd_source = ( _seed == Qtrue ) ? rb_str_new2("/dev/urandom") : rb_str_new2("/dev/random");
+  }
+
+  Data_Get_Struct( self, randctx, ctx );
+  MEMZERO( ctx, randctx, 1 );
+
+  if ( ( rnd_source != Qnil ) && ( rb_funcall( rb_mFileTest, rb_intern("exist?"), 1, rnd_source ) == Qtrue ) ) {
+    fh = fopen("/dev/urandom","r");
+    for ( x = RANDSIZ - 1; x >= 0; x-- ) {
+      nread = fread(&num, sizeof(uint32_t), 1, fh);
+      if ( nread == 0 ) {
+        x++;
+        continue;
+      }
+      ctx->randrsl[x] = num;
+    }
+    fclose(fh);
+  } else {
+    if ( rnd_source != Qnil ) {
+      _seed = Qnil;
+    }
+    if ( rb_funcall( _seed, rb_intern( "respond_to?" ), 1, rb_str_new2("rand") ) == Qtrue ) {
+      seed_prng = _seed;
+    } else {
+      random_argv[0] = _seed;
+      seed_prng = rb_class_new_instance( 1, random_argv, rb_const_get( rb_const_get( rb_cObject, rb_intern( "Crypt" ) ), rb_intern( "Xorshift64Star" ) ) );
+      _seed = rb_funcall( seed_prng, rb_intern( "seed" ), 0 );
+      rb_iv_set( self, "@seed_prng", seed_prng );
+    }
+    for ( x = RANDSIZ - 1; x >= 0; x-- ) {
+      ctx->randrsl[x] = FIX2ULONG( rb_funcall( seed_prng, rb_intern( "rand" ), 1, ULONG2NUM(4294967296) ) );
+    }
+  }
+  randinit(ctx, 1);
+
+  rb_iv_set( self, "@seed", ( ( rnd_source == Qtrue ) || ( rnd_source == Qfalse ) ) ? rnd_source : _seed );
+  old_seed = rb_iv_get( self, "@seed");
+
+  return old_seed;
+}
+
+static VALUE ISAAC_rand( VALUE self, VALUE args ) {
+  uint32_t limit;
+  long len = RARRAY_LEN( args );
+  VALUE arg;
+  short arg_is_a_range = 0;
+  ID id_min;
+  VALUE val_min = 0;
+  ID id_max;
+  randctx *ctx;
+
+  arg = rb_ary_entry( args, 0 );
+
+  if ( len == 0 ) {
+    limit = 0;
+  } else if ( rb_obj_class( arg ) == rb_cRange ) {
+    arg_is_a_range = 1;
+    id_min = rb_intern("min");
+    id_max = rb_intern("max");
+    val_min = rb_funcall( arg, id_min, 0 );
+    limit = NUM2ULONG( rb_funcall( arg, id_max, 0 ) ) - NUM2ULONG( val_min );
+  } else {
+    limit = NUM2ULONG( rb_ary_entry( args, 0 ) );
+  }
+
+  Data_Get_Struct( self, randctx, ctx );
+  if ( !ctx->randcnt-- ) {
+    isaac( ctx );
+    ctx->randcnt = RANDSIZ - 1;
+  }
+
+  if ( limit == 0 ) {
+    return rb_float_new( ctx->randrsl[ctx->randcnt] / 4294967296.0 );
+  } else if ( arg_is_a_range ) {
+    return ULONG2NUM( NUM2ULONG( val_min ) + ( ctx->randrsl[ctx->randcnt] % limit ) );
+  } else {
+    return ULONG2NUM( ctx->randrsl[ctx->randcnt] % limit );
+  }
+}
+
+static VALUE ISAAC_marshal_dump( VALUE self ) {
+  randctx *ctx;
+  int i;
+  int ary_size = sizeof( randctx ) / sizeof( ub4 );
+  VALUE ary;
+
+  Data_Get_Struct( self, randctx, ctx );
+    
+  ary = rb_ary_new2( ary_size );
+  for ( i = 0; i < ary_size; i++ ) {
+      rb_ary_push( ary, ULONG2NUM(((ub4 *)ctx)[i]));
+  }
+    
+  return ary;
+}
+
+static VALUE ISAAC_marshal_load( VALUE self, VALUE ary ) {
+  randctx *ctx;
+  int i;
+  int ary_size = sizeof( randctx ) / sizeof( ub4 );
+
+  Data_Get_Struct( self, randctx, ctx );
+
+  if ( RARRAY_LEN(ary) != ary_size )
+    rb_raise( rb_eArgError, "bad length in loaded ISAAC data" );
+
+  for ( i = 0; i < ary_size; i++ ) {
+    ((ub4 *)ctx)[i] = NUM2ULONG(RARRAY_PTR(ary)[i] );
+  }
+    
+  return self;
+}
+
+static VALUE ISAAC_seed( VALUE self ) {
+  return rb_iv_get( self, "@seed");
+}
+
+static VALUE ISAAC_new_seed( VALUE self ) {
+  return rb_funcall( rb_iv_get( self, "@seed_prng" ), rb_intern("new_seed"), 0 );
+}
+
+int compare_ctx( randctx* ctx1, randctx* ctx2 ) {
+  int x;
+  for ( x = RANDSIZ - 1; x >= 0; x-- ) {
+    if ( ctx1->randrsl[x] != ctx2->randrsl[x] ) return 0;
+  }
+
+  return 1;
+}
+
+static VALUE ISAAC_eq( VALUE self, VALUE v ) {
+  randctx* ctx1;
+  randctx* ctx2;
+
+  Data_Get_Struct( self, randctx, ctx1 );
+  Data_Get_Struct( v, randctx, ctx2 );
+
+  return ( ( rb_obj_classname( self ) == rb_obj_classname( v ) ) && ( compare_ctx( ctx1, ctx2 ) ) ) ? Qtrue : Qfalse ;
+}
+
+static VALUE ISAAC_bytes( VALUE self, VALUE count ) {
+  uint64_t bytes = NUM2ULL( count );
+  char buf[ bytes + 5 ]; 
+  uint64_t i = 0;
+  randctx* ctx;
+
+  Data_Get_Struct( self, randctx, ctx );
+  for( i = 0; i < bytes; i = i + 4 ) {
+
+    if ( !ctx->randcnt-- ) {
+      isaac( ctx );
+      ctx->randcnt = RANDSIZ - 1;
+    }
+
+    // snprintf( &buf[ i ], 5, "%lu", ctx->randrsl[ctx->randcnt] ); 
+    buf[ i ] = ctx->randrsl[ctx->randcnt];
+    buf[ i + 1 ] = ctx->randrsl[ctx->randcnt] >> 8;
+    buf[ i + 2 ] = ctx->randrsl[ctx->randcnt] >> 16;
+    buf[ i + 3 ] = ctx->randrsl[ctx->randcnt] >> 24;
+  }
+
+  return rb_str_new( buf, bytes );
+}
+
+void Init_ext() {
+  CryptModule = rb_define_module( "Crypt" );
+  ISAACClass = rb_define_class_under( CryptModule, "ISAAC", rb_cObject );
+        
+  rb_define_alloc_func( ISAACClass, ISAAC_alloc );
+  rb_define_method( ISAACClass, "initialize", ISAAC_initialize, -2 );
+  rb_define_method( ISAACClass, "srand", ISAAC_srand, -2 );
+  rb_define_method( ISAACClass, "rand", ISAAC_rand, -2 );
+  rb_define_method( ISAACClass, "seed", ISAAC_seed, 0 );
+  rb_define_method( ISAACClass, "new_seed", ISAAC_new_seed, 0 );
+  rb_define_method( ISAACClass, "==", ISAAC_eq, 1 );
+  rb_define_method( ISAACClass, "bytes", ISAAC_bytes, 1 );
+  rb_define_method( ISAACClass, "marshal_dump", ISAAC_marshal_dump, 0 );
+  rb_define_method( ISAACClass, "marshal_load", ISAAC_marshal_load, 1 );
+    
+  rb_const_set( ISAACClass, rb_intern("RANDSIZ"), ULONG2NUM(RANDSIZ) );
+  rb_require( "crypt/isaac/version.rb" );
+}