1 files changed, 192 insertions, 0 deletions

diff --git a/win32/isaac.c b/win32/isaac.c
new file mode 100644
index 000000000..19b96de94
--- /dev/null
+++ b/win32/isaac.c
@@ -0,0 +1,192 @@
+/*
+------------------------------------------------------------------------------
+readable.c: My random number generator, ISAAC.
+(c) Bob Jenkins, March 1996, Public Domain
+You may use this code in any way you wish, and it is free.  No warrantee.
+* May 2008 -- made it not depend on standard.h
+------------------------------------------------------------------------------
+
+  The original version of this file was downloaded from Bob Jenkins website:
+
+     http://burtleburtle.net/bob/rand/isaacafa.html
+
+  The isaac and randinit functions have been slightly modified to silence
+  warnings in modern compilers; the get_entropy and get_random_bytes have
+  been added.
+
+  These changes were made by R M Yorston and are also dedicated to the
+  public domain.
+*/
+#include "libbb.h"
+#include <ntsecapi.h>
+
+typedef struct {
+        /* external results */
+        uint32_t randrsl[256];
+
+        /* internal state */
+        uint32_t mm[256];
+        uint32_t aa, bb, cc;
+} isaac_t;
+
+
+static void isaac(isaac_t *t)
+{
+   register uint32_t i,x,y;
+
+   t->cc = t->cc + 1;    /* cc just gets incremented once per 256 results */
+   t->bb = t->bb + t->cc;   /* then combined with bb */
+
+   for (i=0; i<256; ++i)
+   {
+     x = t->mm[i];
+     switch (i%4)
+     {
+     case 0: t->aa = t->aa^(t->aa<<13); break;
+     case 1: t->aa = t->aa^(t->aa>>6); break;
+     case 2: t->aa = t->aa^(t->aa<<2); break;
+     case 3: t->aa = t->aa^(t->aa>>16); break;
+     }
+     t->aa              = t->mm[(i+128)%256] + t->aa;
+     t->mm[i]      = y  = t->mm[(x>>2)%256] + t->aa + t->bb;
+     t->randrsl[i] = t->bb = t->mm[(y>>10)%256] + x;
+
+     /* Note that bits 2..9 are chosen from x but 10..17 are chosen
+        from y.  The only important thing here is that 2..9 and 10..17
+        don't overlap.  2..9 and 10..17 were then chosen for speed in
+        the optimized version (rand.c) */
+     /* See http://burtleburtle.net/bob/rand/isaac.html
+        for further explanations and analysis. */
+   }
+}
+
+
+/* if (flag!=0), then use the contents of randrsl[] to initialize mm[]. */
+#define mix(a,b,c,d,e,f,g,h) \
+{ \
+   a^=b<<11; d+=a; b+=c; \
+   b^=c>>2;  e+=b; c+=d; \
+   c^=d<<8;  f+=c; d+=e; \
+   d^=e>>16; g+=d; e+=f; \
+   e^=f<<10; h+=e; f+=g; \
+   f^=g>>4;  a+=f; g+=h; \
+   g^=h<<8;  b+=g; h+=a; \
+   h^=a>>9;  c+=h; a+=b; \
+}
+
+static void randinit(isaac_t *t, int flag)
+{
+   int i;
+   uint32_t a,b,c,d,e,f,g,h;
+   t->aa = t->bb = t->cc = 0;
+   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);
+   }
+
+   for (i=0; i<256; i+=8)   /* fill in mm[] with messy stuff */
+   {
+     if (flag)                  /* use all the information in the seed */
+     {
+       a+=t->randrsl[i  ]; b+=t->randrsl[i+1]; c+=t->randrsl[i+2];
+       d+=t->randrsl[i+3]; e+=t->randrsl[i+4]; f+=t->randrsl[i+5];
+       g+=t->randrsl[i+6]; h+=t->randrsl[i+7];
+     }
+     mix(a,b,c,d,e,f,g,h);
+     t->mm[i  ]=a; t->mm[i+1]=b; t->mm[i+2]=c; t->mm[i+3]=d;
+     t->mm[i+4]=e; t->mm[i+5]=f; t->mm[i+6]=g; t->mm[i+7]=h;
+   }
+
+   if (flag)
+   {        /* do a second pass to make all of the seed affect all of mm */
+     for (i=0; i<256; i+=8)
+     {
+       a+=t->mm[i  ]; b+=t->mm[i+1]; c+=t->mm[i+2]; d+=t->mm[i+3];
+       e+=t->mm[i+4]; f+=t->mm[i+5]; g+=t->mm[i+6]; h+=t->mm[i+7];
+       mix(a,b,c,d,e,f,g,h);
+       t->mm[i  ]=a; t->mm[i+1]=b; t->mm[i+2]=c; t->mm[i+3]=d;
+       t->mm[i+4]=e; t->mm[i+5]=f; t->mm[i+6]=g; t->mm[i+7]=h;
+     }
+   }
+
+   isaac(t);            /* fill in the first set of results */
+}
+
+/*
+ * Stuff a few bytes of random-ish data into the generator state.
+ * This is unlikely to be very robust:  don't rely on it for
+ * anything that needs to be secure.
+ */
+static void get_entropy(isaac_t *t)
+{
+        if (!RtlGenRandom(t->randrsl, sizeof(uint32_t)*256))
+                GetSystemTimeAsFileTime((FILETIME *)t->randrsl);
+
+#if 0
+        {
+                unsigned char *p = (unsigned char *)t->randrsl;
+                int j;
+
+                for (j=0; j<256; ++j) {
+                        fprintf(stderr, "%02x", p[j]);
+                        if ((j&31) == 31) {
+                                fprintf(stderr, "\n");
+                        }
+                        else if ((j&3) == 3) {
+                                fprintf(stderr, " ");
+                        }
+                }
+                fprintf(stderr, "\n");
+        }
+#endif
+}
+
+#define RAND_BYTES sizeof(t->randrsl)
+#define RAND_WORDS (sizeof(t->randrsl)/sizeof(t->randrsl[0]))
+
+/*
+ * Place 'count' random bytes in the buffer 'buf'.  You're responsible
+ * for ensuring the buffer is big enough.
+ */
+ssize_t get_random_bytes(void *buf, ssize_t count)
+{
+        static isaac_t *t = NULL;
+        static int rand_index = 0;
+        ssize_t save_count = count;
+        unsigned char *ptr;
+
+        if (buf == NULL || count < 0) {
+                errno = EINVAL;
+                return -1;
+        }
+
+        if (!t) {
+                t = xzalloc(sizeof(isaac_t));
+
+                get_entropy(t);
+                randinit(t, 1);
+                isaac(t);
+                rand_index = 0;
+        }
+
+        ptr = (unsigned char *)t->randrsl;
+        while (count > 0) {
+                int bytes_left = RAND_BYTES - rand_index;
+                ssize_t delta = MIN(bytes_left, count);
+
+                memcpy(buf, ptr+rand_index, delta);
+                buf += delta;
+                count -= delta;
+                rand_index += delta;
+
+                if (rand_index >= RAND_BYTES) {
+                        /* generate more */
+                        isaac(t);
+                        rand_index = 0;
+                }
+        }
+
+        return save_count;
+}