1 files changed, 107 insertions, 41 deletions

diff --git a/src/lib/libc/stdlib/random.c b/src/lib/libc/stdlib/random.c
index 469b6d976a..4807d2f27d 100644
--- a/src/lib/libc/stdlib/random.c
+++ b/src/lib/libc/stdlib/random.c
@@ -10,11 +10,7 @@
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *      This product includes software developed by the University of
- *      California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
+ * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
  *
@@ -32,12 +28,16 @@
  */
 
 #if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)random.c     5.9 (Berkeley) 2/23/91";*/
-static char *rcsid = "$Id: random.c,v 1.1.1.1 1995/10/18 08:42:19 deraadt Exp $";
+static char *rcsid = "$OpenBSD: random.c,v 1.12 2003/06/02 20:18:38 millert Exp $";
 #endif /* LIBC_SCCS and not lint */
 
+#include <sys/param.h>
+#include <sys/sysctl.h>
+#include <sys/time.h>
+#include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <unistd.h>
 
 /*
  * random.c:
@@ -55,10 +55,10 @@ static char *rcsid = "$Id: random.c,v 1.1.1.1 1995/10/18 08:42:19 deraadt Exp $"
  * congruential generator.  If the amount of state information is less than
  * 32 bytes, a simple linear congruential R.N.G. is used.
  *
- * Internally, the state information is treated as an array of longs; the
+ * Internally, the state information is treated as an array of int32_t; the
  * zeroeth element of the array is the type of R.N.G. being used (small
  * integer); the remainder of the array is the state information for the
- * R.N.G.  Thus, 32 bytes of state information will give 7 longs worth of
+ * R.N.G.  Thus, 32 bytes of state information will give 7 int32_ts worth of
  * state information, which will allow a degree seven polynomial.  (Note:
  * the zeroeth word of state information also has some other information
  * stored in it -- see setstate() for details).
@@ -134,14 +134,14 @@ static int seps [MAX_TYPES] =	{ SEP_0, SEP_1, SEP_2, SEP_3, SEP_4 };
  *      MAX_TYPES * (rptr - state) + TYPE_3 == TYPE_3.
  */
 
-static long randtbl[DEG_3 + 1] = {
+static int32_t randtbl[DEG_3 + 1] = {
         TYPE_3,
-        0x9a319039, 0x32d9c024, 0x9b663182, 0x5da1f342, 0xde3b81e0, 0xdf0a6fb5,
-        0xf103bc02, 0x48f340fb, 0x7449e56b, 0xbeb1dbb0, 0xab5c5918, 0x946554fd,
-        0x8c2e680f, 0xeb3d799f, 0xb11ee0b7, 0x2d436b86, 0xda672e2a, 0x1588ca88,
-        0xe369735d, 0x904f35f7, 0xd7158fd6, 0x6fa6f051, 0x616e6b96, 0xac94efdc,
-        0x36413f93, 0xc622c298, 0xf5a42ab8, 0x8a88d77b, 0xf5ad9d0e, 0x8999220b,
-        0x27fb47b9,
+        0x991539b1, 0x16a5bce3, 0x6774a4cd, 0x3e01511e, 0x4e508aaa, 0x61048c05, 
+        0xf5500617, 0x846b7115, 0x6a19892c, 0x896a97af, 0xdb48f936, 0x14898454, 
+        0x37ffd106, 0xb58bff9c, 0x59e17104, 0xcf918a49, 0x09378c83, 0x52c7a471, 
+        0x8d293ea9, 0x1f4fc301, 0xc3db71be, 0x39b44e1c, 0xf8a44ef9, 0x4c8b80b1, 
+        0x19edc328, 0x87bf4bdd, 0xc9b240e5, 0xe9ee4b1b, 0x4382aee7, 0x535b6b41, 
+        0xf3bec5da,
 };
 
 /*
@@ -158,8 +158,8 @@ static long randtbl[DEG_3 + 1] = {
  * in the initialization of randtbl) because the state table pointer is set
  * to point to randtbl[1] (as explained below).
  */
-static long *fptr = &randtbl[SEP_3 + 1];
-static long *rptr = &randtbl[1];
+static int32_t *fptr = &randtbl[SEP_3 + 1];
+static int32_t *rptr = &randtbl[1];
 
 /*
  * The following things are the pointer to the state information table, the
@@ -171,11 +171,11 @@ static long *rptr = &randtbl[1];
  * this is more efficient than indexing every time to find the address of
  * the last element to see if the front and rear pointers have wrapped.
  */
-static long *state = &randtbl[1];
+static int32_t *state = &randtbl[1];
+static int32_t *end_ptr = &randtbl[DEG_3 + 1];
 static int rand_type = TYPE_3;
 static int rand_deg = DEG_3;
 static int rand_sep = SEP_3;
-static long *end_ptr = &randtbl[DEG_3 + 1];
 
 /*
  * srandom:
@@ -191,17 +191,28 @@ static long *end_ptr = &randtbl[DEG_3 + 1];
  */
 void
 srandom(x)
-        u_int x;
+        unsigned int x;
 {
-        register int i, j;
+        int i;
+        int32_t test;
+        div_t val;
 
         if (rand_type == TYPE_0)
                 state[0] = x;
         else {
-                j = 1;
                 state[0] = x;
-                for (i = 1; i < rand_deg; i++)
-                        state[i] = 1103515245 * state[i - 1] + 12345;
+                for (i = 1; i < rand_deg; i++) {
+                        /*
+                         * Implement the following, without overflowing 31 bits:
+                         *
+                         *      state[i] = (16807 * state[i - 1]) % 2147483647;
+                         *
+                         *      2^31-1 (prime) = 2147483647 = 127773*16807+2836
+                         */
+                        val = div(state[i-1], 127773);
+                        test = 16807 * val.rem - 2836 * val.quot;
+                        state[i] = test + (test < 0 ? 2147483647 : 0);
+                }
                 fptr = &state[rand_sep];
                 rptr = &state[0];
                 for (i = 0; i < 10 * rand_deg; i++)
@@ -210,6 +221,65 @@ srandom(x)
 }
 
 /*
+ * srandomdev:
+ *
+ * Many programs choose the seed value in a totally predictable manner.
+ * This often causes problems.  We seed the generator using the much more
+ * secure arandom(4) interface.  Note that this particular seeding
+ * procedure can generate states which are impossible to reproduce by
+ * calling srandom() with any value, since the succeeding terms in the
+ * state buffer are no longer derived from the LC algorithm applied to
+ * a fixed seed.
+ */
+void
+srandomdev()
+{
+        int fd, i, mib[2], n;
+        size_t len;
+
+        if (rand_type == TYPE_0)
+                len = sizeof(state[0]);
+        else
+                len = rand_deg * sizeof(state[0]);
+
+        /*
+         * To get seed data, first try reading from /dev/arandom.
+         * If that fails, try the KERN_ARND sysctl() (one int at a time).
+         * As a last resort, call srandom().
+         */
+        if ((fd = open("/dev/arandom", O_RDONLY, 0)) != -1 &&
+            read(fd, (void *) state, len) == (ssize_t) len) {
+                close(fd);
+        } else {
+                if (fd != -1)
+                        close(fd);
+                mib[0] = CTL_KERN;
+                mib[1] = KERN_ARND;
+                n = len / sizeof(int);
+                len = sizeof(int);
+                for (i = 0; i < n; i++) {
+                        if (sysctl(mib, 2, (char *)((int *)state + i), &len,
+                            NULL, 0) == -1)
+                                break;
+                }
+                if (i != n) {
+                        struct timeval tv;
+                        u_int junk;
+
+                        /* XXX - this could be better */
+                        gettimeofday(&tv, NULL);
+                        srandom(getpid() ^ tv.tv_sec ^ tv.tv_usec ^ junk);
+                        return;
+                }
+        }
+
+        if (rand_type != TYPE_0) {
+                fptr = &state[rand_sep];
+                rptr = &state[0];
+        }
+}
+
+/*
  * initstate:
  *
  * Initialize the state information in the given array of n bytes for future
@@ -232,19 +302,16 @@ char *
 initstate(seed, arg_state, n)
         u_int seed;                     /* seed for R.N.G. */
         char *arg_state;                /* pointer to state array */
-        int n;                          /* # bytes of state info */
+        size_t n;                       /* # bytes of state info */
 {
-        register char *ostate = (char *)(&state[-1]);
+        char *ostate = (char *)(&state[-1]);
 
         if (rand_type == TYPE_0)
                 state[-1] = rand_type;
         else
                 state[-1] = MAX_TYPES * (rptr - state) + rand_type;
-        if (n < BREAK_0) {
-                (void)fprintf(stderr,
-                    "random: not enough state (%d bytes); ignored.\n", n);
-                return(0);
-        }
+        if (n < BREAK_0)
+                return(NULL);
         if (n < BREAK_1) {
                 rand_type = TYPE_0;
                 rand_deg = DEG_0;
@@ -266,7 +333,7 @@ initstate(seed, arg_state, n)
                 rand_deg = DEG_4;
                 rand_sep = SEP_4;
         }
-        state = &(((long *)arg_state)[1]);      /* first location */
+        state = &(((int32_t *)arg_state)[1]);   /* first location */
         end_ptr = &state[rand_deg];     /* must set end_ptr before srandom */
         srandom(seed);
         if (rand_type == TYPE_0)
@@ -293,11 +360,11 @@ initstate(seed, arg_state, n)
  */
 char *
 setstate(arg_state)
-        char *arg_state;
+        const char *arg_state;
 {
-        register long *new_state = (long *)arg_state;
-        register int type = new_state[0] % MAX_TYPES;
-        register int rear = new_state[0] / MAX_TYPES;
+        int32_t *new_state = (int32_t *)arg_state;
+        int32_t type = new_state[0] % MAX_TYPES;
+        int32_t rear = new_state[0] / MAX_TYPES;
         char *ostate = (char *)(&state[-1]);
 
         if (rand_type == TYPE_0)
@@ -315,8 +382,7 @@ setstate(arg_state)
                 rand_sep = seps[type];
                 break;
         default:
-                (void)fprintf(stderr,
-                    "random: state info corrupted; not changed.\n");
+                return(NULL);
         }
         state = &new_state[1];
         if (rand_type != TYPE_0) {
@@ -347,7 +413,7 @@ setstate(arg_state)
 long
 random()
 {
-        long i;
+        int32_t i;
 
         if (rand_type == TYPE_0)
                 i = state[0] = (state[0] * 1103515245 + 12345) & 0x7fffffff;
@@ -360,5 +426,5 @@ random()
                 } else if (++rptr >= end_ptr)
                         rptr = state;
         }
-        return(i);
+        return((long)i);
 }