add rand.stir, which polls system entropy in the most robust way possible, because OpenSSL only knows how to use /dev/urandom

1 files changed, 207 insertions, 20 deletions

diff --git a/src/openssl.c b/src/openssl.c
index 432c683..967665f 100644
--- a/src/openssl.c
+++ b/src/openssl.c
@@ -26,23 +26,32 @@
 #ifndef LUAOSSL_H
 #define LUAOSSL_H
 
-#include <limits.h>	/* INT_MAX INT_MIN */
-#include <string.h>	/* memset(3) */
-#include <strings.h>	/* strcasecmp(3) */
-#include <math.h>	/* INFINITY fabs(3) floor(3) frexp(3) fmod(3) round(3) isfinite(3) */
-#include <time.h>	/* struct tm time_t strptime(3) */
-#include <ctype.h>      /* tolower(3) */
+#include <limits.h>       /* INT_MAX INT_MIN */
+#include <string.h>       /* memset(3) strerror_r(3) */
+#include <strings.h>      /* strcasecmp(3) */
+#include <math.h>         /* INFINITY fabs(3) floor(3) frexp(3) fmod(3) round(3) isfinite(3) */
+#include <time.h>         /* struct tm time_t strptime(3) */
+#include <ctype.h>        /* tolower(3) */
+#include <errno.h>        /* errno */
 
-#include <sys/types.h>
-#include <sys/stat.h>	/* struct stat stat(2) */
-#include <sys/socket.h>	/* AF_INET AF_INET6 */
+#include <sys/types.h>    /* ssize_t pid_t */
+#include <sys/sysctl.h>   /* CTL_KERN KERN_RANDOM RANDOM_UUID KERN_URND KERN_ARND sysctl(2) */
+#include <sys/time.h>     /* struct timeval gettimeofday(2) */
+#include <sys/stat.h>     /* struct stat stat(2) */
+#include <sys/socket.h>   /* AF_INET AF_INET6 */
+#include <sys/resource.h> /* RUSAGE_SELF struct rusage getrusage(2) */
+#include <sys/utsname.h>  /* struct utsname uname(3) */
 
-#include <netinet/in.h>	/* struct in_addr struct in6_addr */
-#include <arpa/inet.h>	/* inet_pton(3) */
+#include <fcntl.h>        /* O_RDONLY O_CLOEXEC open(2) */
 
-#include <pthread.h>    /* pthread_mutex_init(3) pthread_mutex_lock(3) pthread_mutex_unlock(3) */
+#include <unistd.h>       /* close(2) getpid(2) */
 
-#include <dlfcn.h>      /* dladdr(3) dlopen(3) */
+#include <netinet/in.h>   /* struct in_addr struct in6_addr */
+#include <arpa/inet.h>    /* inet_pton(3) */
+
+#include <pthread.h>      /* pthread_mutex_init(3) pthread_mutex_lock(3) pthread_mutex_unlock(3) */
+
+#include <dlfcn.h>        /* dladdr(3) dlopen(3) */
 
 #include <openssl/err.h>
 #include <openssl/bn.h>
@@ -107,6 +116,56 @@
 #define HAI SAY("hai")
 
 
+#define xitoa_putc(c) do { if (p < lim) dst[p] = (c); p++; } while (0)
+
+static const char *xitoa(char *dst, size_t lim, long i) {
+	size_t p = 0;
+	unsigned long d = 1000000000UL, n = 0, r;
+
+	if (i < 0) {
+		xitoa_putc('-');
+		i *= -1;
+	}
+
+	if ((i = MIN(2147483647L, i))) {
+		do {
+			if ((r = i / d) || n) {
+				i -= r * d;
+				n++;
+				xitoa_putc('0' + r);
+			}
+		} while (d /= 10);
+	} else {
+		xitoa_putc('0');
+	}
+
+	if (lim)
+		dst[MIN(p, lim - 1)] = '\0';
+
+	return dst;
+} /* xitoa() */
+
+
+#define xstrerror(error) xstrerror_r((error), (char[256]){ 0 }, 256)
+
+static const char *xstrerror_r(int error, char *dst, size_t lim) {
+	static const char unknown[] = "Unknown error: ";
+	size_t n;
+
+	if (0 == strerror_r(error, dst, lim) && *dst != '\0')
+		return dst;
+
+	/*
+	 * glibc snprintf can fail on memory pressure, so format our number
+	 * manually.
+	 */
+	n = MIN(sizeof unknown - 1, lim);
+	memcpy(dst, unknown, n);
+
+	return xitoa(&dst[n], lim - n, error);
+} /* xstrerror_r() */
+
+
 static void *prepudata(lua_State *L, size_t size, const char *tname, int (*gc)(lua_State *)) {
 	void *p = memset(lua_newuserdata(L, size), 0, size);
 
@@ -3017,7 +3076,7 @@ static int xs_add(lua_State *L) {
 			int ok;
 
 			if (0 != stat(path, &st))
-				return luaL_error(L, "%s: %s", path, strerror(errno));
+				return luaL_error(L, "%s: %s", path, xstrerror(errno));
 
 			if (S_ISDIR(st.st_mode))
 				ok = X509_STORE_load_locations(store, NULL, path);
@@ -3919,6 +3978,137 @@ int luaopen__openssl_cipher(lua_State *L) {
  *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
+#ifndef HAVE_RANDOM_UUID
+#define HAVE_RANDOM_UUID (defined __linux) /* RANDOM_UUID is an enum, not macro */
+#endif
+
+#ifndef HAVE_KERN_URND
+#define HAVE_KERN_URND (defined KERN_URND)
+#endif
+
+#ifndef HAVE_KERN_ARND
+#define HAVE_KERN_ARND (defined KERN_ARND)
+#endif
+
+static int stir(unsigned rqstd) {
+	unsigned count = 0;
+	int error;
+	unsigned char data[256];
+#if HAVE_RANDOM_UUID || HAVE_KERN_URND || HAVE_KERN_ARND
+#if HAVE_RANDOM_UUID
+	int mib[] = { CTL_KERN, KERN_RANDOM, RANDOM_UUID };
+#elif HAVE_KERN_URND
+	int mib[] = { CTL_KERN, KERN_URND };
+#else
+	int mib[] = { CTL_KERN, KERN_ARND };
+#endif
+
+	while (count < rqstd) {
+		size_t n = MIN(rqstd - count, sizeof data);
+
+		if (0 != sysctl(mib, countof(mib), data, &n, (void *)0, 0))
+			break;
+
+		RAND_add(data, n, n);
+
+		count += n;
+	}
+#endif
+
+	if (count < rqstd) {
+#if defined O_CLOEXEC
+		int fd = open("/dev/urandom", O_RDONLY|O_CLOEXEC);
+#else
+		int fd = open("/dev/urandom", O_RDONLY);
+#endif
+
+		if (fd == -1)
+			goto syserr;
+
+		while (count < rqstd) {
+			ssize_t n = read(fd, data, MIN(rqstd - count, sizeof data));
+
+			switch (n) {
+			case 0:
+				errno = EIO;
+
+				/* FALL THROUGH */
+			case -1:
+				if (errno == EINTR)
+					continue;
+
+				error = errno;
+
+				close(fd);
+
+				goto error;
+			default:
+				RAND_add(data, n, n);
+
+				count += n;
+			}
+		}
+
+		close(fd);
+	}
+
+	return 0;
+syserr:
+	error = errno;
+error:;
+	struct {
+		struct timeval tv;
+		pid_t pid;
+		struct rusage ru;
+		struct utsname un;
+		int (*fn)();
+	} junk;
+
+	gettimeofday(&junk.tv, NULL);
+	junk.pid = getpid();
+	getrusage(RUSAGE_SELF, &junk.ru);
+	uname(&junk.un);
+	junk.fn = &stir;
+
+	RAND_add(&junk, sizeof junk, 0.1);
+
+	return error;
+} /* stir() */
+
+
+static int rand_stir(lua_State *L) {
+	int error = stir(luaL_optunsigned(L, 1, 16));
+
+	if (error) {
+		lua_pushboolean(L, 0);
+		lua_pushstring(L, xstrerror(error));
+		lua_pushinteger(L, error);
+
+		return 3;
+	} else {
+		lua_pushboolean(L, 1);
+
+		return 1;
+	}
+} /* rand_stir() */
+
+
+static int rand_add(lua_State *L) {
+	const void *buf;
+	size_t len;
+	lua_Number entropy;
+
+	buf = luaL_checklstring(L, 1, &len);
+	entropy = luaL_optnumber(L, 2, len);
+
+	RAND_add(buf, len, entropy);
+
+	lua_pushboolean(L, 1);
+
+	return 1;
+} /* rand_add() */
+
+
 static int rand_bytes(lua_State *L) {
 	int size = luaL_checkint(L, 1);
 	luaL_Buffer B;
@@ -4060,6 +4250,8 @@ static int rand_uniform(lua_State *L) {
 
 
 static const luaL_Reg rand_globals[] = {
+	{ "stir",    &rand_stir },
+	{ "add",     &rand_add },
 	{ "bytes",   &rand_bytes },
 	{ "ready",   &rand_ready },
 	{ "uniform", &rand_uniform },
@@ -4194,12 +4386,7 @@ static void initall(lua_State *L) {
 		if (error == -1) {
 			luaL_error(L, "openssl.init: %s", dlerror());
 		} else {
-			char why[256];
-
-			if (0 != strerror_r(error, why, sizeof why) || *why == '\0')
-				luaL_error(L, "openssl.init: Unknown error: %d", error);
-
-			luaL_error(L, "openssl.init: %s", why);
+			luaL_error(L, "openssl.init: %s", xstrerror(error));
 		}
 	}