win32: allow use of shell's PRNG for /dev/urandom

Allow either ISAAC or the shell's built-in pseudo-random number
generator to be used for /dev/urandom.  The latter is smaller so
it's the default.

6 files changed, 130 insertions, 17 deletions

diff --git a/Config.in b/Config.in
index dc3a6e09a..a18d26720 100644
--- a/Config.in
+++ b/Config.in
@@ -122,18 +122,6 @@ config LFS
         programs that can benefit from large file support include dd, gzip,
         cp, mount, tar.
 
-config GLOBBING
-        bool "Allow busybox.exe to expand wildcards"
-        default n
-        depends on PLATFORM_MINGW32
-        help
-          In Microsoft Windows expansion of wildcards on the command line
-          ('globbing') is handled by the C runtime while the BusyBox shell
-          does its own wildcard expansion.  For best results when using the
-          shell globbing by the C runtime should be turned off. If you want
-          the BusyBox binary to handle wildcard expansion using the C runtime
-          set this to 'Y'.
-
 config PAM
         bool "Support PAM (Pluggable Authentication Modules)"
         default n
@@ -380,6 +368,39 @@ config PLATFORM_LINUX
         #This is automatically selected if any applet or feature requires
         #Linux-specific interfaces. You do not need to select it manually.
 
+config GLOBBING
+        bool "Allow busybox.exe to expand wildcards"
+        default n
+        depends on PLATFORM_MINGW32
+        help
+          In Microsoft Windows expansion of wildcards on the command line
+          ('globbing') is handled by the C runtime while the BusyBox shell
+          does its own wildcard expansion.  For best results when using the
+          shell globbing by the C runtime should be turned off. If you want
+          the BusyBox binary to handle wildcard expansion using the C runtime
+          set this to 'Y'.
+
+choice
+        prompt "Random number generator"
+        default FEATURE_PRNG_SHELL
+        depends on PLATFORM_MINGW32
+        help
+        BusyBox on Microsoft Windows uses a pseudo-random number
+        generator to emulate the Linux /dev/urandom device.  There
+        are two options:
+        - The shell's built-in PRNG.
+        - Bob Jenkins' ISAAC.  This is intended to be a secure PRNG.  It's
+        slightly faster than the shell's PRNG but is larger both in terms
+        of code and runtime memory.
+
+config FEATURE_PRNG_SHELL
+        bool "Use shell PRNG"
+
+config FEATURE_PRNG_ISAAC
+        bool "Use ISAAC PRNG"
+
+endchoice
+
 comment 'Build Options'
 
 config STATIC
diff --git a/shell/Kbuild.src b/shell/Kbuild.src
index 6bba4989f..a287fce4e 100644
--- a/shell/Kbuild.src
+++ b/shell/Kbuild.src
@@ -9,3 +9,4 @@ lib-y:=
 INSERT
 
 lib-$(CONFIG_FEATURE_SH_MATH) += math.o
+lib-$(CONFIG_FEATURE_PRNG_SHELL) += random.o
diff --git a/shell/random.c b/shell/random.c
index 5d3620516..614172279 100644
--- a/shell/random.c
+++ b/shell/random.c
@@ -19,6 +19,17 @@
 # include "random.h"
 # define RAND_BASH_MASK 0x7fff
 
+# if ENABLE_FEATURE_PRNG_SHELL
+uint32_t FAST_FUNC
+next_random(random_t *rnd)
+{
+        return full_random(rnd) & RAND_BASH_MASK;
+}
+#  undef RAND_BASH_MASK
+#  define RAND_BASH_MASK 0xffffffff
+#  define next_random full_random
+# endif
+
 #else
 # include <stdint.h>
 # include <unistd.h>
diff --git a/shell/random.h b/shell/random.h
index c4eb44c13..75fe0f69f 100644
--- a/shell/random.h
+++ b/shell/random.h
@@ -35,6 +35,9 @@ typedef struct random_t {
         ((rnd)->galois_LFSR = 0)
 
 uint32_t next_random(random_t *rnd) FAST_FUNC;
+#if ENABLE_FEATURE_PRNG_SHELL
+uint32_t full_random(random_t *rnd) FAST_FUNC;
+#endif
 
 POP_SAVED_FUNCTION_VISIBILITY
 
diff --git a/win32/Kbuild b/win32/Kbuild
index 00950e0f7..f8c8fb5af 100644
--- a/win32/Kbuild
+++ b/win32/Kbuild
@@ -7,18 +7,19 @@ lib-y:=
 lib-$(CONFIG_PLATFORM_MINGW32) += env.o
 lib-$(CONFIG_PLATFORM_MINGW32) += fnmatch.o
 lib-$(CONFIG_PLATFORM_MINGW32) += fsync.o
+lib-$(CONFIG_PLATFORM_MINGW32) += inet_pton.o
 lib-$(CONFIG_PLATFORM_MINGW32) += ioctl.o
-lib-$(CONFIG_PLATFORM_MINGW32) += isaac.o
+lib-$(CONFIG_FEATURE_PRNG_ISAAC) += isaac.o
 lib-$(CONFIG_PLATFORM_MINGW32) += mingw.o
 lib-$(CONFIG_PLATFORM_MINGW32) += process.o
-lib-$(CONFIG_PLATFORM_MINGW32) += regex.o
+lib-$(CONFIG_PLATFORM_MINGW32) += mntent.o
 lib-$(CONFIG_PLATFORM_MINGW32) += net.o
-lib-$(CONFIG_PLATFORM_MINGW32) += inet_pton.o
 lib-$(CONFIG_PLATFORM_MINGW32) += poll.o
-lib-$(CONFIG_PLATFORM_MINGW32) += select.o
 lib-$(CONFIG_PLATFORM_MINGW32) += popen.o
+lib-$(CONFIG_PLATFORM_MINGW32) += regex.o
+lib-$(CONFIG_PLATFORM_MINGW32) += select.o
+lib-$(CONFIG_FEATURE_PRNG_SHELL) += sh_random.o
 lib-$(CONFIG_PLATFORM_MINGW32) += statfs.o
-lib-$(CONFIG_PLATFORM_MINGW32) += mntent.o
 lib-$(CONFIG_PLATFORM_MINGW32) += strptime.o
 lib-$(CONFIG_PLATFORM_MINGW32) += system.o
 lib-$(CONFIG_PLATFORM_MINGW32) += termios.o
diff --git a/win32/sh_random.c b/win32/sh_random.c
new file mode 100644
index 000000000..2948e4a55
--- /dev/null
+++ b/win32/sh_random.c
@@ -0,0 +1,76 @@
+#include "libbb.h"
+#include "../shell/random.h"
+
+/* call 'fn' to put data in 'dt' then copy it to generator state */
+#define GET_DATA(fn, dt) \
+        fn(&dt); \
+        u = (uint32_t *)&dt; \
+        for (j=0; j<sizeof(dt)/sizeof(uint32_t); ++j) { \
+                state[i++%2] ^= *u++; \
+        }
+
+/*
+ * Obtain a few bytes of random-ish data to initialise the generator.
+ * This is unlikely to be very robust:  don't rely on it for
+ * anything that needs to be secure.
+ */
+static void get_entropy(uint32_t state[2])
+{
+        int i, j;
+        SYSTEMTIME tm;
+        MEMORYSTATUS ms;
+        SYSTEM_INFO si;
+        LARGE_INTEGER pc;
+        uint32_t *u;
+
+        i = 0;
+        state[i++%2] ^= (uint32_t)GetCurrentProcessId();
+        state[i++%2] ^= (uint32_t)GetCurrentThreadId();
+        state[i++%2] ^= (uint32_t)GetTickCount();
+
+        GET_DATA(GetLocalTime, tm)
+        GET_DATA(GlobalMemoryStatus, ms)
+        GET_DATA(GetSystemInfo, si)
+        GET_DATA(QueryPerformanceCounter, pc)
+
+#if 0
+        {
+                unsigned char *p = (unsigned char *)state;
+
+                for (j=0; j<8; ++j) {
+                        fprintf(stderr, "%02x", *p++);
+                        if ((j&3) == 3) {
+                                fprintf(stderr, " ");
+                        }
+                }
+                fprintf(stderr, "\n");
+        }
+#endif
+}
+
+ssize_t get_random_bytes(void *buf, ssize_t count)
+{
+        static random_t rnd;
+        ssize_t save_count = count;
+        uint32_t value;
+        unsigned char *ptr = (unsigned char *)&value;
+
+        if (buf == NULL || count < 0) {
+                errno = EINVAL;
+                return -1;
+        }
+
+        if (UNINITED_RANDOM_T(&rnd)) {
+                uint32_t state[2] = {0, 0};
+
+                get_entropy(state);
+                INIT_RANDOM_T(&rnd, state[0] ? state[0] : 1, state[1]);
+        }
+
+        for (;count > 0; buf+=4, count-=4) {
+                value = full_random(&rnd);
+                memcpy(buf, ptr, count >= 4 ? 4 : count);
+        }
+
+        return save_count;
+}