crypt-isaac 1.0.0 → 1.1.0

data/ext/crypt/isaac/rand.c

@@ -0,0 +1,142 @@
+/*
+------------------------------------------------------------------------------
+rand.c: By Bob Jenkins.  My random number generator, ISAAC.  Public Domain
+MODIFIED:
+  960327: Creation (addition of randinit, really)
+  970719: use context, not global variables, for internal state
+  980324: make a portable version
+  010626: Note this is public domain
+  100725: Mask on use of >32 bits, not on assignment: from Paul Eggert
+------------------------------------------------------------------------------
+*/
+#ifndef STANDARD
+#include "standard.h"
+#endif
+#ifndef RAND
+#include "rand.h"
+#endif
+
+
+#define ind(mm,x)  ((mm)[(x>>2)&(RANDSIZ-1)])
+#define rngstep(mix,a,b,mm,m,m2,r,x) \
+{ \
+  x = *m;  \
+  a = ((a^(mix)) + *(m2++)); \
+  *(m++) = y = (ind(mm,x) + a + b); \
+  *(r++) = b = (ind(mm,y>>RANDSIZL) + x) & 0xffffffff; \
+}
+
+void     isaac(ctx)
+randctx *ctx;
+{
+   ub4 a,b,x,y,*m,*mm,*m2,*r,*mend;
+   mm=ctx->randmem; r=ctx->randrsl;
+   a = ctx->randa; b = ctx->randb + (++ctx->randc);
+   for (m = mm, mend = m2 = m+(RANDSIZ/2); m<mend; )
+   {
+      rngstep( a<<13, a, b, mm, m, m2, r, x);
+      rngstep( (a & 0xffffffff) >>6 , a, b, mm, m, m2, r, x);
+      rngstep( a<<2 , a, b, mm, m, m2, r, x);
+      rngstep( (a & 0xffffffff) >>16, a, b, mm, m, m2, r, x);
+   }
+   for (m2 = mm; m2<mend; )
+   {
+      rngstep( a<<13, a, b, mm, m, m2, r, x);
+      rngstep( (a & 0xffffffff) >>6 , a, b, mm, m, m2, r, x);
+      rngstep( a<<2 , a, b, mm, m, m2, r, x);
+      rngstep( (a & 0xffffffff) >>16, a, b, mm, m, m2, r, x);
+   }
+   ctx->randb = b; ctx->randa = a;
+}
+
+
+#define mix(a,b,c,d,e,f,g,h) \
+{ \
+   a^=b<<11;              d+=a; b+=c; \
+   b^=(c&0xffffffff)>>2;  e+=b; c+=d; \
+   c^=d<<8;               f+=c; d+=e; \
+   d^=(e&0xffffffff)>>16; g+=d; e+=f; \
+   e^=f<<10;              h+=e; f+=g; \
+   f^=(g&0xffffffff)>>4;  a+=f; g+=h; \
+   g^=h<<8;               b+=g; h+=a; \
+   h^=(a&0xffffffff)>>9;  c+=h; a+=b; \
+}
+
+/* if (flag==TRUE), then use the contents of randrsl[] to initialize mm[]. */
+void randinit(ctx, flag)
+randctx *ctx;
+word     flag;
+{
+   word i;
+   ub4 a,b,c,d,e,f,g,h;
+   ub4 *m,*r;
+   ctx->randa = ctx->randb = ctx->randc = 0;
+   m=ctx->randmem;
+   r=ctx->randrsl;
+   a=b=c=d=e=f=g=h=0x9e3779b9;  /* the golden ratio */
+
+   for (i=0; i<4; ++i)          /* scramble it */
+   {
+     mix(a,b,c,d,e,f,g,h);
+   }
+
+   if (flag) 
+   {
+     /* initialize using the contents of r[] as the seed */
+     for (i=0; i<RANDSIZ; i+=8)
+     {
+       a+=r[i  ]; b+=r[i+1];
+       c+=r[i+2]; d+=r[i+3];
+       e+=r[i+4]; f+=r[i+5];
+       g+=r[i+6]; h+=r[i+7];
+       mix(a,b,c,d,e,f,g,h);
+       m[i  ]=a; m[i+1]=b; m[i+2]=c; m[i+3]=d;
+       m[i+4]=e; m[i+5]=f; m[i+6]=g; m[i+7]=h;
+     }
+     /* do a second pass to make all of the seed affect all of m */
+     for (i=0; i<RANDSIZ; i+=8)
+     {
+       a+=m[i  ]; b+=m[i+1];
+       c+=m[i+2]; d+=m[i+3];
+       e+=m[i+4]; f+=m[i+5];
+       g+=m[i+6]; h+=m[i+7];
+       mix(a,b,c,d,e,f,g,h);
+       m[i  ]=a; m[i+1]=b; m[i+2]=c; m[i+3]=d;
+       m[i+4]=e; m[i+5]=f; m[i+6]=g; m[i+7]=h;
+     }
+   }
+   else
+   {
+     for (i=0; i<RANDSIZ; i+=8)
+     {
+       /* fill in mm[] with messy stuff */
+       mix(a,b,c,d,e,f,g,h);
+       m[i  ]=a; m[i+1]=b; m[i+2]=c; m[i+3]=d;
+       m[i+4]=e; m[i+5]=f; m[i+6]=g; m[i+7]=h;
+     }
+   }
+
+   isaac(ctx);            /* fill in the first set of results */
+   ctx->randcnt=RANDSIZ;  /* prepare to use the first set of results */
+}
+
+
+#ifdef NEVER
+int main()
+{
+  ub4 i,j;
+  randctx ctx;
+  ctx.randa=ctx.randb=ctx.randc=(ub4)0;
+  for (i=0; i<256; ++i) ctx.randrsl[i]=(ub4)0;
+  randinit(&ctx, TRUE);
+  for (i=0; i<2; ++i)
+  {
+    isaac(&ctx);
+    for (j=0; j<256; ++j)
+    {
+      printf("%.8lx",ctx.randrsl[j]);
+      if ((j&7)==7) printf("\n");
+    }
+  }
+}
+#endif

data/ext/crypt/isaac/rand.h

@@ -0,0 +1,56 @@
+/*
+------------------------------------------------------------------------------
+rand.h: definitions for a random number generator
+By Bob Jenkins, 1996, Public Domain
+MODIFIED:
+  960327: Creation (addition of randinit, really)
+  970719: use context, not global variables, for internal state
+  980324: renamed seed to flag
+  980605: recommend RANDSIZL=4 for noncryptography.
+  010626: note this is public domain
+------------------------------------------------------------------------------
+*/
+#ifndef STANDARD
+#include "standard.h"
+#endif
+
+#ifndef RAND
+#define RAND
+#define RANDSIZL   (8)
+#define RANDSIZ    (1<<RANDSIZL)
+
+/* context of random number generator */
+struct randctx
+{
+  ub4 randcnt;
+  ub4 randrsl[RANDSIZ];
+  ub4 randmem[RANDSIZ];
+  ub4 randa;
+  ub4 randb;
+  ub4 randc;
+};
+typedef  struct randctx  randctx;
+
+/*
+------------------------------------------------------------------------------
+ If (flag==TRUE), then use the contents of randrsl[0..RANDSIZ-1] as the seed.
+------------------------------------------------------------------------------
+*/
+void randinit( randctx *r, word flag );
+
+void isaac( randctx *r );
+
+
+/*
+------------------------------------------------------------------------------
+ Call rand(/o_ randctx *r _o/) to retrieve a single 32-bit random value
+------------------------------------------------------------------------------
+*/
+#define rand(r) \
+   (!(r)->randcnt-- ? \
+     (isaac(r), (r)->randcnt=RANDSIZ-1, (r)->randrsl[(r)->randcnt]) : \
+     (r)->randrsl[(r)->randcnt])
+
+#endif  /* RAND */
+
+

data/ext/crypt/isaac/standard.h

@@ -0,0 +1,57 @@
+/*
+------------------------------------------------------------------------------
+Standard definitions and types, Bob Jenkins
+------------------------------------------------------------------------------
+*/
+#ifndef STANDARD
+# define STANDARD
+# ifndef STDIO
+#  include <stdio.h>
+#  define STDIO
+# endif
+# ifndef STDDEF
+#  include <stddef.h>
+#  define STDDEF
+# endif
+typedef  unsigned long long  ub8;
+#define UB8MAXVAL 0xffffffffffffffffLL
+#define UB8BITS 64
+typedef    signed long long  sb8;
+#define SB8MAXVAL 0x7fffffffffffffffLL
+typedef  unsigned long  int  ub4;   /* unsigned 4-byte quantities */
+#define UB4MAXVAL 0xffffffff
+typedef    signed long  int  sb4;
+#define UB4BITS 32
+#define SB4MAXVAL 0x7fffffff
+typedef  unsigned short int  ub2;
+#define UB2MAXVAL 0xffff
+#define UB2BITS 16
+typedef    signed short int  sb2;
+#define SB2MAXVAL 0x7fff
+typedef  unsigned       char ub1;
+#define UB1MAXVAL 0xff
+#define UB1BITS 8
+typedef    signed       char sb1;   /* signed 1-byte quantities */
+#define SB1MAXVAL 0x7f
+typedef                 int  word;  /* fastest type available */
+
+#define bis(target,mask)  ((target) |=  (mask))
+#define bic(target,mask)  ((target) &= ~(mask))
+#define bit(target,mask)  ((target) &   (mask))
+#ifndef min
+# define min(a,b) (((a)<(b)) ? (a) : (b))
+#endif /* min */
+#ifndef max
+# define max(a,b) (((a)<(b)) ? (b) : (a))
+#endif /* max */
+#ifndef align
+# define align(a) (((ub4)a+(sizeof(void *)-1))&(~(sizeof(void *)-1)))
+#endif /* align */
+#ifndef abs
+# define abs(a)   (((a)>0) ? (a) : -(a))
+#endif
+#define TRUE  1
+#define FALSE 0
+#define SUCCESS 0  /* 1 on VAX */
+
+#endif /* STANDARD */

data/ext/crypt/isaac/xorshift/extconf.rb

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

data/ext/crypt/isaac/xorshift/xorshift.c

@@ -0,0 +1,121 @@
+#include "ruby.h"
+#include <sys/types.h>
+#include <unistd.h>
+
+static VALUE CryptModule;
+static VALUE Xorshift64StarClass;
+static int16_t seed_counter = 0;
+
+static void Xorshift64Star_free( uint64_t* seed ) {
+  if ( seed ) {
+    xfree( seed );
+  }
+}
+
+static VALUE Xorshift64Star_alloc( VALUE klass ) {
+  uint64_t* seed;
+
+  return Data_Make_Struct( klass, uint64_t, NULL, Xorshift64Star_free, seed );
+}
+
+static VALUE Xorshift64Star_initialize( VALUE self, VALUE args ) {
+  VALUE _seed ;
+  long len = RARRAY_LEN( args );
+
+  if ( len == 0 ) {
+    _seed = rb_funcall( self, rb_intern( "srand" ), 0 );
+  } else {
+    _seed = rb_funcall( self, rb_intern( "srand" ), 1, rb_ary_entry( args, 0 ) );
+  }
+
+  _seed = rb_funcall( self, rb_intern( "srand" ), 1, _seed );
+  rb_iv_set( self, "@old_seed", _seed );
+  return _seed;
+}
+
+static VALUE to_hex_block( VALUE arg, VALUE data, int argc, VALUE* argv ) {
+  return rb_funcall( arg, rb_intern( "to_s" ), 1, INT2FIX( 16 ) );
+}
+
+static VALUE Xorshift64Star_new_seed( VALUE self ) {
+  VALUE now;
+  VALUE ary;
+  now  = rb_funcall( rb_cTime, rb_intern( "now" ), 0 );
+  ary = rb_ary_new();
+  seed_counter++;
+
+  rb_ary_push( ary, rb_funcall( rb_funcall( now, rb_intern( "usec" ), 0 ), rb_intern( "%" ), 1, INT2FIX( 65536 ) ) );
+  rb_ary_push( ary, rb_funcall( rb_funcall( now, rb_intern( "to_i" ), 0 ), rb_intern( "%" ), 1, INT2FIX( 65536 ) ) );
+  rb_ary_push( ary, rb_funcall( INT2FIX( getpid() ), rb_intern( "%" ), 1, INT2FIX( 65536 ) ) );
+  rb_ary_push( ary, INT2FIX( seed_counter ) );
+  return rb_funcall( rb_funcall(
+                       rb_block_call( ary, rb_intern( "collect" ), 0, 0, to_hex_block, Qnil ),
+                       rb_intern( "join" ),
+                       0
+                     ), rb_intern( "to_i" ), 1, INT2FIX( 16 ) );
+}
+
+static VALUE Xorshift64Star_srand( VALUE self, VALUE args ) {
+  uint64_t *seed;
+  long len = RARRAY_LEN( args );
+  VALUE _seed ;
+
+  Data_Get_Struct( self, uint64_t, seed);
+
+  if ( ( len == 0 ) || ( ( len == 1 ) && ( rb_ary_entry( args, 0 ) == Qnil ) ) ) {
+    _seed = rb_funcall( self, rb_intern( "new_seed" ), 0 );
+  } else {
+    _seed = rb_ary_entry( args, 0 );
+  }
+
+  rb_iv_set( self, "@old_seed", ULL2NUM( (*seed) ) );
+
+  (*seed) = NUM2ULL(_seed);
+  return _seed;
+}
+
+static VALUE Xorshift64Star_rand( VALUE self, VALUE args ) {
+  long len = RARRAY_LEN( args );
+  uint64_t *seed;
+  uint64_t limit;
+  uint64_t random;
+  Data_Get_Struct( self, uint64_t, seed );
+
+  if ( len == 0 ) {
+    limit = 0;
+  } else {
+    limit = NUM2ULL( rb_ary_entry( args, 0 ) );
+  }
+
+  *seed ^= *seed >> 12;
+  *seed ^= *seed << 25;
+  *seed ^= *seed >> 27;
+  random = *seed * UINT64_C(2685821657736338717);
+
+  if ( limit == 0 ) {
+    return DBL2NUM( (double)( random / 2 ) / 9223372036854775807 );
+  } else {
+    return ULL2NUM( random % limit );
+  }
+}
+
+static VALUE Xorshift64Star_seed(VALUE self) {
+  return rb_iv_get( self, "@old_seed" );
+}
+
+static VALUE Xorshift64Star_eq(VALUE self, VALUE v) {
+      return ( ( rb_obj_classname( self ) == rb_obj_classname( v ) ) && ( rb_iv_get( self, "@old_seed" ) == rb_funcall( v, rb_intern( "seed" ), 0 ) ) ) ? Qtrue : Qfalse ;
+}
+
+void Init_ext() {
+  CryptModule = rb_define_module( "Crypt" );
+  Xorshift64StarClass = rb_define_class_under( CryptModule, "Xorshift64Star", rb_cObject );
+        
+  rb_define_alloc_func( Xorshift64StarClass, Xorshift64Star_alloc );
+  rb_define_method( Xorshift64StarClass, "initialize", Xorshift64Star_initialize, -2 );
+  rb_define_method( Xorshift64StarClass, "srand", Xorshift64Star_srand, -2 );
+  rb_define_method( Xorshift64StarClass, "rand", Xorshift64Star_rand, -2 );
+  rb_define_method( Xorshift64StarClass, "new_seed", Xorshift64Star_new_seed, 0 );
+  rb_define_method( Xorshift64StarClass, "seed", Xorshift64Star_seed, 0 );
+  rb_define_method( Xorshift64StarClass, "==", Xorshift64Star_eq, 1 );
+}

data/lib/crypt/isaac.rb

@@ -1,213 +1,16 @@
-module Crypt
-
-  # ISAAC is a fast, strong random number generator.  Details on the
-  # algorithm can be found here: http://burtleburtle.net/bob/rand/isaac.html
-  # This provides a consistent and capable algorithm for producing
-  # independent streams of quality random numbers.
-
-  class ISAAC
-
-    attr_accessor :randrsl, :randcnt
-    attr_accessor :mm, :aa, :bb, :cc
-
-    # When a Crypt::ISAAC object is created, it needs to be seeded for
-    # random number generation.  If the system has a /dev/urandom file,
-    # that will be used to do the seeding by default.  If false is explictly
-    # passed when creating the object, it will instead use /dev/random to
-    # generate its seeds.  Be warned that this may make for SLOW
-    # initialization.
-    # If the requested source (/dev/urandom or /dev/random) do not exist,
-    # the system will fall back to a simplistic initialization mechanism
-    # using the builtin Mersenne Twister PRNG.
-
-    def initialize(seed = true)
-      @mm = []
-
-      if Integer === seed || Random === seed
-        self.srand(seed)
-      else
-        @seed = seed
-        rnd_source = ( ( seed == true ) || ( seed == false ) ) ?
-          ( seed ? '/dev/urandom' : '/dev/random' ) :
-          seed
-        if (FileTest.exist? rnd_source)
-          @randrsl = []
-          File.open(rnd_source,'r') do |r|
-            256.times do |t|
-              z = r.read(4)
-              x = z.unpack('V')[0]
-              @randrsl[t] = x
-            end
-          end
-          randinit(true)
-        else
-          raise "Entropy source (#{rnd_source}) doesn't exist. The ISAAC algorithm can not be seeded."
-        end
-      end
-    end
-
-    # If seeded with an integer, use that to seed a standard Ruby Mersenne Twister
-    # PRNG, and then use that to generate seed value for ISAAC. This is mostly useful
-    # for producing repeated, deterministic results, which may be needed for testing.
-    def srand(seed)
-      @seed = seed
-      @randrsl = []
-      seed_prng = ( Random === seed ) ? seed : Random.new(seed)
-      256.times do |t|
-        @randrsl[t] = seed_prng.rand(4294967295)
-      end
-      randinit(true)
-    end
-
-    # Works just like the standard rand() function.  If called with an
-    # integer argument, rand() will return positive random number in
-    # the range of 0 to (argument - 1).  If called without an integer
-    # argument, rand() returns a positive floating point number less than 1.
-    # If called with a Range, returns a number that is in the range.
-  
-    def rand(arg = nil)
-      if (@randcnt == 1)
-        isaac
-        @randcnt = 256
-      end
-      @randcnt -= 1
-      if arg.nil?
-        ( @randrsl[@randcnt] / 536870912.0 ) % 1
-      elsif Integer === arg || Float === arg
-        @randrsl[@randcnt] % arg
-      elsif Range === arg
-        arg.min + @randrsl[@randcnt] % (arg.max - arg.min)
-      else
-        @randrsl[@randcnt] % Integer(arg)
-      end
-    end
-
-    def seed
-      Random === @seed ? @seed.seed : @seed
-    end
-
-    def state
-      @randrsl + [@randcnt]
-    end
-
-    def ==(gen)
-      self.state == gen.state
-    end
-
-    def bytes(size)
-      buffer = ""
-      ( size / 4 ).times { buffer << [rand(4294967295)].pack("L").unpack("aaaa").join }
-
-      if size % 4 != 0
-        buffer << [rand(4294967295)].pack("L").unpack("aaaa")[0..(size % 4 - 1)].join
-      end
-
-      buffer
-    end
-
-    def isaac
-      i = 0
-      x = 0
-      y = 0
-
-      @cc += 1
-      @bb += @cc
-      @bb & 0xffffffff
-
-      while (i < 256) do 
-        x = @mm[i]
-        @aa = (@mm[(i + 128) & 255] + (@aa^(@aa << 13)) ) & 0xffffffff
-        @mm[i] = y = (@mm[(x>>2)&255] + @aa + @bb ) & 0xffffffff
-        @randrsl[i] = @bb = (@mm[(y>>10)&255] + x ) & 0xffffffff
-        i += 1
-
-        x = @mm[i]
-        @aa = (@mm[(i+128)&255] + (@aa^(0x03ffffff & (@aa >> 6))) ) & 0xffffffff
-        @mm[i] = y = (@mm[(x>>2)&255] + @aa + @bb ) & 0xffffffff
-        @randrsl[i] = @bb = (@mm[(y>>10)&255] + x ) & 0xffffffff
-        i += 1
-
-        x = @mm[i]
-        @aa = (@mm[(i + 128)&255] + (@aa^(@aa << 2)) ) & 0xffffffff
-        @mm[i] = y = (@mm[(x>>2)&255] + @aa + @bb ) & 0xffffffff
-        @randrsl[i] = @bb = (@mm[(y>>10)&255] + x ) & 0xffffffff
-        i += 1
-
-        x = @mm[i]
-        @aa = (@mm[(i+128)&255] + (@aa^(0x0000ffff & (@aa >> 16))) ) & 0xffffffff
-        @mm[i] = y = (@mm[(x>>2)&255] + @aa + @bb ) & 0xffffffff
-        @randrsl[i] = @bb = (@mm[(y>>10)&255] + x ) & 0xffffffff
-        i += 1
-      end
-    end
-
-    def randinit(flag)
-      i = 0
-      a = 0
-      b = 0
-      c = 0
-      d = 0
-      e = 0
-      f = 0
-      g = 0
-      @aa = @bb = @cc = 0
-      a = b = c = d = e = f = g = h = 0x9e3779b9
-
-      while (i < 4) do
-        a ^= b<<1; d += a; b += c
-        b ^= 0x3fffffff & (c>>2); e += b; c += d
-        c ^= d << 8; f += c; d += e
-        d ^= 0x0000ffff & (e >> 16); g += d; e += f
-        e ^= f << 10; h += e; f += g
-        f ^= 0x0fffffff & (g >> 4); a += f; g += h
-        g ^= h << 8; b += g; h += a
-        h ^= 0x007fffff & (a >> 9); c += h; a += b
-        i += 1
-      end
-
-      i = 0
-      while (i < 256) do
-        if (flag)
-          a+=@randrsl[i  ].to_i; b+=@randrsl[i+1].to_i;
-          c+=@randrsl[i+2]; d+=@randrsl[i+3];
-          e+=@randrsl[i+4]; f+=@randrsl[i+5];
-          g+=@randrsl[i+6]; h+=@randrsl[i+7];
-        end
-
-        a^=b<<11; d+=a; b+=c;
-        b^=0x3fffffff & (c>>2);  e+=b; c+=d;
-        c^=d<<8;  f+=c; d+=e;
-        d^=0x0000ffff & (e>>16); g+=d; e+=f;
-        e^=f<<10; h+=e; f+=g;
-        f^=0x0fffffff & (g>>4);  a+=f; g+=h;
-        g^=h<<8;  b+=g; h+=a;
-        h^=0x007fffff & (a>>9);  c+=h; a+=b;
-        @mm[i]=a;@mm[i+1]=b; @mm[i+2]=c; @mm[i+3]=d;
-        @mm[i+4]=e; @mm[i+5]=f; @mm[i+6]=g; @mm[i+7]=h;
-        i += 8
-      end
-
-      if flag
-        i = 0
-        while (i < 256)
-          a+=@mm[i  ]; b+=@mm[i+1]; c+=@mm[i+2]; d+=@mm[i+3];
-          e+=@mm[i+4]; f+=@mm[i+5]; g+=@mm[i+6]; h+=@mm[i+7];
-          a^=b<<11; d+=a; b+=c;
-          b^=0x3fffffff & (c>>2);  e+=b; c+=d;
-          c^=d<<8;  f+=c; d+=e;
-          d^=0x0000ffff & (e>>16); g+=d; e+=f;
-          e^=f<<10; h+=e; f+=g;
-          f^=0x0fffffff & (g>>4);  a+=f; g+=h;
-          g^=h<<8;  b+=g; h+=a;
-          h^=0x007fffff & (a>>9);  c+=h; a+=b;
-          @mm[i  ]=a; @mm[i+1]=b; @mm[i+2]=c; @mm[i+3]=d;
-          @mm[i+4]=e; @mm[i+5]=f; @mm[i+6]=g; @mm[i+7]=h;
-          i += 8
-        end
-      end
+begin
+  require 'crypt/isaac/ext'
+rescue LoadError
+  require 'crypt/isaac/pure'
+end
 
-      isaac()
-      @randcnt=256;        # /* prepare to use the first set of results */
-    end
-  end
+begin
+  # Use a non-cryptographic alternative to the Mersenne Twister for an internal
+  # pseudo-random source of numbers if the library is required to seed itself.
+  # https://en.wikipedia.org/wiki/Xorshift
+  require 'crypt-xorshift'
+rescue LoadError
+  # Fallback on an internal micro-implementation.
+  require 'crypt/isaac/xorshift'
 end
+