[prev in list] [next in list] [prev in thread] [next in thread] 

List:       freewrt-commits
Subject:    [FreeWRT-commits] r3909 - in trunk/freewrt: package/uclibc
From:       tg () freewrt ! org
Date:       2009-11-29 18:43:31
Message-ID: 20091129184331.770401C006 () frozenfish ! freewrt ! org
[Download RAW message or body]

Author: tg
Date: 2009-11-29 19:43:30 +0100 (Sun, 29 Nov 2009)
New Revision: 3909

Modified:
   trunk/freewrt/package/uclibc/Makefile.inc
   trunk/freewrt/toolchain/uClibc/files/arc4random.c
   trunk/freewrt/toolchain/uClibc/patches/patch-libc_stdlib_Makefile
Log:
sync arc4random.c from MirBSD and enable opportunistic pushb
(since almost everything on FreeWRT is run as root anyway)

gives us arc4random_pushb(3) for mksh, as well as
arc4random_buf(3) and arc4random_uniform(3) – see
http://www.mirbsd.org/man3/arc4random to RTFM


Modified: trunk/freewrt/package/uclibc/Makefile.inc
===================================================================
--- trunk/freewrt/package/uclibc/Makefile.inc	2009-11-28 21:17:29 UTC (rev 3908)
+++ trunk/freewrt/package/uclibc/Makefile.inc	2009-11-29 18:43:30 UTC (rev 3909)
@@ -6,5 +6,5 @@
 
 PKG_NAME:=		uClibc
 PKG_VERSION:=		0.9.28
-PKG_RELEASE:=		2
+PKG_RELEASE:=		3
 PKG_MD5SUM:=		1ada58d919a82561061e4741fb6abd29

Modified: trunk/freewrt/toolchain/uClibc/files/arc4random.c
===================================================================
--- trunk/freewrt/toolchain/uClibc/files/arc4random.c	2009-11-28 21:17:29 UTC (rev \
                3908)
+++ trunk/freewrt/toolchain/uClibc/files/arc4random.c	2009-11-29 18:43:30 UTC (rev \
3909) @@ -1,5 +1,5 @@
 static const char __vcsid[] = "@(#) MirOS contributed arc4random.c (old)"
-    "\n	@(#)rcsid_master: $MirOS: contrib/code/Snippets/arc4random.c,v 1.19 \
2009/09/27 10:45:56 tg Exp $" +    "\n	@(#)rcsid_master: $MirOS: \
contrib/code/Snippets/arc4random.c,v 1.24 2009/11/29 18:24:21 tg Exp $"  ;
 
 /*-
@@ -116,7 +116,7 @@
 static const char __randomdev[] = _PATH_URANDOM;
 
 static uint8_t arc4_getbyte(void);
-static void stir_finish(int);
+static void stir_finish(uint8_t);
 static void arc4_atexit(void);
 static char arc4_writeback(uint8_t *, size_t, char);
 
@@ -124,11 +124,23 @@
 u_int32_t arc4random(void);
 void arc4random_addrandom(u_char *, int);
 void arc4random_stir(void);
-#ifdef USE_MS_CRYPTOAPI
+#if defined(USE_MS_CRYPTOAPI) || defined(OPPORTUNISTIC_ROOT_PUSHB)
 uint32_t arc4random_pushb(const void *, size_t);
 #endif
 #endif
 
+#define NEED_UNIFORM_BUF_PROTO
+#if defined(__OpenBSD__) && defined(OpenBSD) && (OpenBSD > 200805)
+#undef NEED_UNIFORM_BUF_PROTO
+#elif defined(__MirBSD__) && defined(MirBSD) && (MirBSD > 0x0AA4)
+#undef NEED_UNIFORM_BUF_PROTO
+#endif
+
+#ifdef NEED_UNIFORM_BUF_PROTO
+u_int32_t arc4random_uniform(u_int32_t);
+void arc4random_buf(void *, size_t);
+#endif
+
 static void
 arc4_init(void)
 {
@@ -141,22 +153,38 @@
 }
 
 static void
-arc4_addrandom(u_char *dat, int datlen)
+arc4_addrandom(const u_char *dat, size_t datlen)
 {
-	int n;
+	size_t n = 0;
 	uint8_t si;
 
 	arc4_ctx.i--;
-	for (n = 0; n < 256; n++) {
+	while (n < 256) {
 		arc4_ctx.i++;
 		si = arc4_ctx.s[arc4_ctx.i];
-		arc4_ctx.j = (uint8_t)(arc4_ctx.j + si + dat[n % datlen]);
+		arc4_ctx.j = (uint8_t)(arc4_ctx.j + si + dat[n++ % datlen]);
 		arc4_ctx.s[arc4_ctx.i] = arc4_ctx.s[arc4_ctx.j];
 		arc4_ctx.s[arc4_ctx.j] = si;
 	}
 	arc4_ctx.j = arc4_ctx.i;
 }
 
+#if defined(USE_MS_CRYPTOAPI)
+#define RNDEV_BYTES	128
+#elif defined(__INTERIX)
+#define RNDEV_BYTES	4	/* slow /dev/urandom */
+#elif defined(__OpenBSD__)
+#define RNDEV_BYTES	(256 - (sizeof(struct timeval) + sizeof(pid_t)))
+#elif defined(__CYGWIN__)
+#define RNDEV_BYTES	64	/* /dev/urandom probably CryptoAPI */
+#elif defined(__FreeBSD__)
+#define RNDEV_BYTES	16	/* Yarrow has few state */
+#elif defined(__GLIBC__)
+#define RNDEV_BYTES	16	/* requested by maintainers */
+#else
+#define RNDEV_BYTES	8	/* unknown OS? */
+#endif
+
 static void
 arc4_stir(void)
 {
@@ -164,7 +192,7 @@
 	struct {
 		struct timeval tv;
 		pid_t pid;
-		u_int rnd[(128 - (sizeof(struct timeval) + sizeof(pid_t))) / sizeof(u_int)];
+		u_int rnd[(RNDEV_BYTES + sizeof(u_int) - 1) / sizeof(u_int)];
 	} rdat;
 	size_t sz = 0;
 
@@ -232,7 +260,7 @@
 }
 
 static void
-stir_finish(int av)
+stir_finish(uint8_t av)
 {
 	size_t n;
 	uint8_t tb[16];
@@ -245,18 +273,17 @@
 	 * We discard 256 words. A long word is 4 bytes.
 	 * We also discard a randomly fuzzed amount.
 	 */
-	n = 256 * 4 + (arc4_getbyte() & 0x0FU);
-	while (av) {
-		n += (av & 0x0F);
-		av >>= 4;
-	}
+	n = 256 * 4 + (arc4_getbyte() & 0x0FU) + (av & 0xF0U);
+	av &= 0x0FU;
 	while (n--)
 		arc4_getbyte();
 	while (n < sizeof(tb))
 		tb[n++] = arc4_getbyte();
 	if (arc4_writeback(tb, sizeof(tb), 0))
 		arc4_getbyte();
-	arc4_count = 400000;
+	while (av--)
+		arc4_getbyte();
+	arc4_count = 1600000;
 }
 
 static uint8_t
@@ -306,7 +333,8 @@
 u_int32_t
 arc4random(void)
 {
-	if (--arc4_count == 0 || !rs_initialized || arc4_stir_pid != getpid())
+	arc4_count -= 4;
+	if (arc4_count <= 0 || !rs_initialized || arc4_stir_pid != getpid())
 		arc4random_stir();
 	return arc4_getword();
 }
@@ -453,17 +481,22 @@
 #endif
 }
 
-#if defined(USE_MS_CRYPTOAPI) || defined(arc4random_pushk)
+#if defined(USE_MS_CRYPTOAPI) || defined(arc4random_pushk) || \
+    defined(OPPORTUNISTIC_ROOT_PUSHB)
 uint32_t
 arc4random_pushb(const void *src, size_t len)
 {
 	size_t rlen;
 	union {
 		uint8_t buf[256];
-		struct timeval tv;
+		struct {
+			struct timeval tv;
+			const void *sp, *dp;
+			size_t sz;
+			uint32_t vu;
+		} s;
 		uint32_t xbuf;
 	} idat;
-	const uint8_t *cbuf = (const uint8_t *)src;
 	uint32_t res = 1;
 
 	if (!rs_initialized) {
@@ -471,19 +504,29 @@
 		rs_initialized = 1;
 	}
 
-	gettimeofday(&idat.tv, NULL);
-	for (rlen = 0; rlen < len; ++rlen)
-		idat.buf[rlen % sizeof(idat)] ^= cbuf[rlen];
-	rlen = MIN(sizeof(idat), MAX(sizeof(struct timeval), len));
+	idat.s.sp = &idat;
+	idat.s.dp = src;
+	idat.s.sz = len;
+	idat.s.vu = arc4_getword();
+	gettimeofday(&idat.s.tv, NULL);
 
-	if (arc4_writeback(&idat.buf[0], rlen, 1))
+	rlen = MAX(sizeof(idat.s), len);
+	while (rlen--)
+		idat.buf[rlen % sizeof(idat.buf)] ^=
+		    ((const uint8_t *)src)[rlen % len];
+	rlen = MIN(sizeof(idat), MAX(sizeof(idat.s), len));
+
+	if (arc4_writeback((void *)&idat, rlen, 1))
 		res = 0;
-	arc4_addrandom(&idat.buf[0], rlen);
+	arc4_addrandom((void *)&idat, rlen);
+	rlen = arc4_getbyte() & 1;
 	if (res)
 		res = idat.xbuf;
 	else
 		/* we got entropy from the kernel, so consider us stirred */
 		stir_finish(idat.buf[5]);
+	if (rlen)
+		(void)arc4_getbyte();
 	return (res ^ arc4_getword());
 }
 #endif
@@ -505,3 +548,72 @@
 
 	arc4_writeback((uint8_t *)&buf, sizeof(buf), 0);
 }
+
+void
+arc4random_buf(void *_buf, size_t n)
+{
+	uint8_t *buf = (uint8_t *)_buf;
+
+	if (!rs_initialized || arc4_stir_pid != getpid())
+		arc4random_stir();
+	buf[0] = arc4_getbyte() % 3;
+	while (buf[0]--)
+		(void)arc4_getbyte();
+	while (n--) {
+		if (--arc4_count <= 0)
+			arc4_stir();
+		buf[n] = arc4_getbyte();
+	}
+}
+
+/*
+ * Calculate a uniformly distributed random number less than upper_bound
+ * avoiding "modulo bias".
+ *
+ * Uniformity is achieved by generating new random numbers until the one
+ * returned is outside the range [0, 2**32 % upper_bound).  This
+ * guarantees the selected random number will be inside
+ * [2**32 % upper_bound, 2**32) which maps back to [0, upper_bound)
+ * after reduction modulo upper_bound.
+ */
+u_int32_t
+arc4random_uniform(u_int32_t upper_bound)
+{
+	u_int32_t r, min;
+
+	if (upper_bound < 2)
+		return (0);
+
+#if defined(ULONG_MAX) && (ULONG_MAX > 0xffffffffUL)
+	min = 0x100000000UL % upper_bound;
+#else
+	/* Calculate (2**32 % upper_bound) avoiding 64-bit math */
+	if (upper_bound > 0x80000000)
+		min = 1 + ~upper_bound;		/* 2**32 - upper_bound */
+	else {
+		/* (2**32 - (x * 2)) % x == 2**32 % x when x <= 2**31 */
+		min = ((0xffffffff - (upper_bound * 2)) + 1) % upper_bound;
+	}
+#endif
+
+	/*
+	 * This could theoretically loop forever but each retry has
+	 * p > 0.5 (worst case, usually far better) of selecting a
+	 * number inside the range we need, so it should rarely need
+	 * to re-roll.
+	 */
+	if (!rs_initialized || arc4_stir_pid != getpid())
+		arc4random_stir();
+	if (arc4_getbyte() & 1)
+		(void)arc4_getbyte();
+	for (;;) {
+		arc4_count -= 4;
+		if (arc4_count <= 0)
+			arc4random_stir();
+		r = arc4_getword();
+		if (r >= min)
+			break;
+	}
+
+	return (r % upper_bound);
+}

Modified: trunk/freewrt/toolchain/uClibc/patches/patch-libc_stdlib_Makefile
===================================================================
--- trunk/freewrt/toolchain/uClibc/patches/patch-libc_stdlib_Makefile	2009-11-28 \
                21:17:29 UTC (rev 3908)
+++ trunk/freewrt/toolchain/uClibc/patches/patch-libc_stdlib_Makefile	2009-11-29 \
18:43:30 UTC (rev 3909) @@ -15,7 +15,7 @@
  	$(STRIPTOOL) -x -R .note -R .comment $*.o
  
 +arc4random.o: arc4random.c
-+	$(CC) $(CFLAGS) -DHAVE_STDINT_H -c $< -o $@
++	$(CC) $(CFLAGS) -DHAVE_STDINT_H -DOPPORTUNISTIC_ROOT_PUSHB -c $< -o $@
 +	$(STRIPTOOL) -x -R .note -R .comment $*.o
 +
  $(OBJ): Makefile

_______________________________________________
freewrt-commits mailing list
freewrt-commits@freewrt.org
https://www.freewrt.org/lists/listinfo/freewrt-commits


[prev in list] [next in list] [prev in thread] [next in thread]