summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--sys/conf/files1
-rw-r--r--sys/dev/random/harvest.c81
-rw-r--r--sys/dev/random/randomdev.c62
-rw-r--r--sys/dev/random/yarrow.c288
-rw-r--r--sys/dev/random/yarrow.h55
-rw-r--r--sys/dev/randomdev/harvest.c81
-rw-r--r--sys/dev/randomdev/randomdev.c62
-rw-r--r--sys/dev/randomdev/yarrow.c288
-rw-r--r--sys/dev/randomdev/yarrow.h55
-rw-r--r--sys/modules/random/Makefile2
-rw-r--r--sys/modules/randomdev/Makefile2
11 files changed, 731 insertions, 246 deletions
diff --git a/sys/conf/files b/sys/conf/files
index a4f9d21..a38e7f9 100644
--- a/sys/conf/files
+++ b/sys/conf/files
@@ -225,6 +225,7 @@ dev/ppbus/ppi.c optional ppi
dev/ppbus/pps.c optional pps
dev/ppbus/vpo.c optional vpo
dev/ppbus/vpoio.c optional vpo
+dev/randomdev/harvest.c standard
dev/randomdev/randomdev.c optional randomdev
dev/randomdev/yarrow.c optional randomdev
crypto/blowfish/bf_cbc.c optional randomdev
diff --git a/sys/dev/random/harvest.c b/sys/dev/random/harvest.c
new file mode 100644
index 0000000..ceb9f9f
--- /dev/null
+++ b/sys/dev/random/harvest.c
@@ -0,0 +1,81 @@
+/*-
+ * Copyright (c) 2000 Mark R V Murray
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer
+ * in this position and unchanged.
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/types.h>
+#include <sys/queue.h>
+#include <sys/linker.h>
+#include <sys/libkern.h>
+#include <sys/mbuf.h>
+#include <sys/random.h>
+#include <sys/time.h>
+#include <crypto/blowfish/blowfish.h>
+
+#include <dev/randomdev/yarrow.h>
+
+/* hold the address of the routine which is actually called if */
+/* the ramdomdev is loaded */
+static void (*reap)(struct timespec *, u_int64_t, u_int, u_int, u_int) = NULL;
+
+/* Initialise the harvester at load time */
+void
+random_init_harvester(void (*reaper)(struct timespec *, u_int64_t, u_int, u_int, u_int))
+{
+ intrmask_t mask;
+
+ mask = splhigh();
+ reap = reaper;
+ splx(mask);
+}
+
+/* Deinitialise the harvester at unload time */
+void
+random_deinit_harvester(void)
+{
+ intrmask_t mask;
+
+ mask = splhigh();
+ reap = NULL;
+ splx(mask);
+}
+
+/* Entropy harvesting routine. This is supposed to be fast; do */
+/* not do anything slow in here! */
+/* Implemented as in indirect call to allow non-inclusion of */
+/* the entropy device. */
+void
+random_harvest(u_int64_t entropy, u_int bits, u_int frac, u_int source)
+{
+ struct timespec nanotime;
+
+ if (reap) {
+ getnanotime(&nanotime);
+ (*reap)(&nanotime, entropy, bits, frac, source);
+ }
+}
diff --git a/sys/dev/random/randomdev.c b/sys/dev/random/randomdev.c
index 2ef9e9d..161ca57 100644
--- a/sys/dev/random/randomdev.c
+++ b/sys/dev/random/randomdev.c
@@ -1,5 +1,5 @@
/*-
- * Copyright (c) 2000 Mark Murray
+ * Copyright (c) 2000 Mark R V Murray
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -27,12 +27,12 @@
*/
#include <sys/param.h>
+#include <sys/queue.h>
#include <sys/systm.h>
#include <sys/conf.h>
#include <sys/fcntl.h>
#include <sys/uio.h>
#include <sys/kernel.h>
-#include <sys/kobj.h>
#include <sys/malloc.h>
#include <sys/module.h>
#include <sys/bus.h>
@@ -46,8 +46,8 @@
#include <dev/randomdev/yarrow.h>
-static d_read_t randomread;
-static d_write_t randomwrite;
+static d_read_t random_read;
+static d_write_t random_write;
#define CDEV_MAJOR 2
#define RANDOM_MINOR 3
@@ -56,8 +56,8 @@ static d_write_t randomwrite;
static struct cdevsw random_cdevsw = {
/* open */ (d_open_t *)nullop,
/* close */ (d_close_t *)nullop,
- /* read */ randomread,
- /* write */ randomwrite,
+ /* read */ random_read,
+ /* write */ random_write,
/* ioctl */ noioctl,
/* poll */ nopoll,
/* mmap */ nommap,
@@ -71,52 +71,51 @@ static struct cdevsw random_cdevsw = {
};
/* For use with make_dev(9)/destroy_dev(9). */
-static dev_t randomdev;
-static dev_t urandomdev;
+static dev_t random_dev;
+static dev_t urandom_dev;
-static void *buf;
+/* Buffer used by uiomove(9) */
+static void *random_buf;
-extern void randominit(void);
-
-extern struct state state;
-
-/* This is mostly academic at the moment; as Yarrow gets extended, it will
- become more relevant */
SYSCTL_NODE(_kern, OID_AUTO, random, CTLFLAG_RW, 0, "Random Number Generator");
SYSCTL_NODE(_kern_random, OID_AUTO, yarrow, CTLFLAG_RW, 0, "Yarrow Parameters");
-SYSCTL_INT(_kern_random_yarrow, OID_AUTO, gengateinterval, CTLFLAG_RW, &state.gengateinterval, 10, "Generator Gate Interval");
+SYSCTL_INT(_kern_random_yarrow, OID_AUTO, gengateinterval, CTLFLAG_RW, &random_state.gengateinterval, 10, "Generator Gate Interval");
+SYSCTL_INT(_kern_random_yarrow, OID_AUTO, bins, CTLFLAG_RW, &random_state.bins, 10, "Execution time tuner");
+SYSCTL_INT(_kern_random_yarrow, OID_AUTO, fastthresh, CTLFLAG_RW, &random_state.pool[0].thresh, 100, "Fast pool reseed threshhold");
+SYSCTL_INT(_kern_random_yarrow, OID_AUTO, slowthresh, CTLFLAG_RW, &random_state.pool[1].thresh, 100, "Slow pool reseed threshhold");
+SYSCTL_INT(_kern_random_yarrow, OID_AUTO, slowoverthresh, CTLFLAG_RW, &random_state.slowoverthresh, 2, "Slow pool over-threshhold reseed count");
static int
-randomread(dev_t dev, struct uio *uio, int flag)
+random_read(dev_t dev, struct uio *uio, int flag)
{
u_int c, ret;
int error = 0;
c = min(uio->uio_resid, PAGE_SIZE);
- buf = (void *)malloc(c, M_TEMP, M_WAITOK);
+ random_buf = (void *)malloc(c, M_TEMP, M_WAITOK);
while (uio->uio_resid > 0 && error == 0) {
- ret = read_random(buf, c);
- error = uiomove(buf, ret, uio);
+ ret = read_random(random_buf, c);
+ error = uiomove(random_buf, ret, uio);
}
- free(buf, M_TEMP);
+ free(random_buf, M_TEMP);
return error;
}
static int
-randomwrite(dev_t dev, struct uio *uio, int flag)
+random_write(dev_t dev, struct uio *uio, int flag)
{
u_int c;
int error = 0;
- buf = (void *)malloc(PAGE_SIZE, M_TEMP, M_WAITOK);
+ random_buf = (void *)malloc(PAGE_SIZE, M_TEMP, M_WAITOK);
while (uio->uio_resid > 0) {
c = min(uio->uio_resid, PAGE_SIZE);
- error = uiomove(buf, c, uio);
+ error = uiomove(random_buf, c, uio);
if (error)
break;
- /* write_random(buf, c); */
+ /* write_random(random_buf, c); */
}
- free(buf, M_TEMP);
+ free(random_buf, M_TEMP);
return error;
}
@@ -127,16 +126,17 @@ random_modevent(module_t mod, int type, void *data)
case MOD_LOAD:
if (bootverbose)
printf("random: <entropy source>\n");
- randomdev = make_dev(&random_cdevsw, RANDOM_MINOR, UID_ROOT,
+ random_dev = make_dev(&random_cdevsw, RANDOM_MINOR, UID_ROOT,
GID_WHEEL, 0666, "random");
- urandomdev = make_dev(&random_cdevsw, URANDOM_MINOR, UID_ROOT,
+ urandom_dev = make_dev(&random_cdevsw, URANDOM_MINOR, UID_ROOT,
GID_WHEEL, 0666, "urandom");
- randominit();
+ random_init();
return 0;
case MOD_UNLOAD:
- destroy_dev(randomdev);
- destroy_dev(urandomdev);
+ random_deinit();
+ destroy_dev(random_dev);
+ destroy_dev(urandom_dev);
return 0;
case MOD_SHUTDOWN:
diff --git a/sys/dev/random/yarrow.c b/sys/dev/random/yarrow.c
index b54951b..ab4a69c 100644
--- a/sys/dev/random/yarrow.c
+++ b/sys/dev/random/yarrow.c
@@ -1,5 +1,5 @@
/*-
- * Copyright (c) 2000 Mark Murray
+ * Copyright (c) 2000 Mark R V Murray
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -32,103 +32,166 @@
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/queue.h>
+#include <sys/taskqueue.h>
#include <sys/linker.h>
#include <sys/libkern.h>
#include <sys/mbuf.h>
#include <sys/random.h>
+#include <sys/time.h>
#include <sys/types.h>
#include <crypto/blowfish/blowfish.h>
#include <dev/randomdev/yarrow.h>
-void generator_gate(void);
-void reseed(void);
-void randominit(void);
+/* #define DEBUG */
-/* This is the beastie that needs protecting. It contains all of the
- * state that we are excited about.
- */
-struct state state;
+static void generator_gate(void);
+static void reseed(int);
+static void random_harvest_internal(struct timespec *nanotime, u_int64_t entropy, u_int bits, u_int frac, u_int source);
+
+/* Structure holding the entropy state */
+struct random_state random_state;
+
+/* When enough entropy has been harvested, asynchronously "stir" it in */
+static struct task regate_task;
+
+static struct context {
+ u_int pool;
+} context = { 0 };
+
+static void
+regate(void *context, int pending)
+{
+#ifdef DEBUG
+ printf("Regate task\n");
+#endif
+ reseed(((struct context *)context)->pool);
+}
void
-randominit(void)
+random_init(void)
{
- /* XXX much more to come */
- state.gengateinterval = 10;
+#ifdef DEBUG
+ printf("Random init\n");
+#endif
+ random_state.gengateinterval = 10;
+ random_state.bins = 10;
+ random_state.pool[0].thresh = 100;
+ random_state.pool[1].thresh = 160;
+ random_state.slowoverthresh = 2;
+ random_state.which = FAST;
+ TASK_INIT(&regate_task, 0, &regate, (void *)&context);
+ random_init_harvester(random_harvest_internal);
}
void
-reseed(void)
+random_deinit(void)
{
- unsigned char v[BINS][KEYSIZE]; /* v[i] */
- unsigned char hash[KEYSIZE]; /* h' */
+#ifdef DEBUG
+ printf("Random deinit\n");
+#endif
+ random_deinit_harvester();
+}
+
+static void
+reseed(int fastslow)
+{
+ unsigned char v[TIMEBIN][KEYSIZE]; /* v[i] */
+ unsigned char hash[KEYSIZE]; /* h' */
BF_KEY hashkey;
unsigned char ivec[8];
unsigned char temp[KEYSIZE];
+ struct entropy *bucket;
int i, j;
+#ifdef DEBUG
+ printf("Reseed type %d\n", fastslow);
+#endif
+
/* 1. Hash the accumulated entropy into v[0] */
- /* XXX to be done properly */
bzero((void *)&v[0], KEYSIZE);
- for (j = 0; j < sizeof(state.randomstuff); j += KEYSIZE) {
- BF_set_key(&hashkey, KEYSIZE, &state.randomstuff[j]);
- BF_cbc_encrypt(v[0], temp, KEYSIZE, &hashkey,
- ivec, BF_ENCRYPT);
- memcpy(&v[0], temp, KEYSIZE);
+ if (fastslow == SLOW) {
+ /* Feed a hash of the slow pool into the fast pool */
+ for (i = 0; i < ENTROPYSOURCE; i++) {
+ for (j = 0; j < ENTROPYBIN; j++) {
+ bucket = &random_state.pool[SLOW].source[i].entropy[j];
+ if(bucket->nanotime.tv_sec || bucket->nanotime.tv_nsec) {
+ BF_set_key(&hashkey, sizeof(struct entropy),
+ (void *)bucket);
+ BF_cbc_encrypt(v[0], temp, KEYSIZE, &hashkey, ivec,
+ BF_ENCRYPT);
+ memcpy(&v[0], temp, KEYSIZE);
+ bucket->nanotime.tv_sec = 0;
+ bucket->nanotime.tv_nsec = 0;
+ }
+ }
+ }
+ }
+
+ for (i = 0; i < ENTROPYSOURCE; i++) {
+ for (j = 0; j < ENTROPYBIN; j++) {
+ bucket = &random_state.pool[FAST].source[i].entropy[j];
+ if(bucket->nanotime.tv_sec || bucket->nanotime.tv_nsec) {
+ BF_set_key(&hashkey, sizeof(struct entropy), (void *)bucket);
+ BF_cbc_encrypt(v[0], temp, KEYSIZE, &hashkey, ivec, BF_ENCRYPT);
+ memcpy(&v[0], temp, KEYSIZE);
+ bucket->nanotime.tv_sec = 0;
+ bucket->nanotime.tv_nsec = 0;
+ }
+ }
}
/* 2. Compute hash values for all v. _Supposed_ to be computationally */
/* intensive. */
- for (i = 1; i < BINS; i++) {
+ if (random_state.bins > TIMEBIN)
+ random_state.bins = TIMEBIN;
+ for (i = 1; i < random_state.bins; i++) {
bzero((void *)&v[i], KEYSIZE);
- for (j = 0; j < sizeof(state.randomstuff); j += KEYSIZE) {
- /* v[i] #= h(v[i-1]) */
- BF_set_key(&hashkey, KEYSIZE, v[i - 1]);
- BF_cbc_encrypt(v[i], temp, KEYSIZE, &hashkey,
- ivec, BF_ENCRYPT);
- memcpy(&v[i], temp, KEYSIZE);
- /* v[i] #= h(v[0]) */
- BF_set_key(&hashkey, KEYSIZE, v[0]);
- BF_cbc_encrypt(v[i], temp, KEYSIZE, &hashkey,
- ivec, BF_ENCRYPT);
- memcpy(&v[i], temp, KEYSIZE);
- /* v[i] #= h(i) */
- BF_set_key(&hashkey, sizeof(int), (unsigned char *)&i);
- BF_cbc_encrypt(v[i], temp, KEYSIZE, &hashkey,
- ivec, BF_ENCRYPT);
- memcpy(&v[i], temp, KEYSIZE);
- }
+ /* v[i] #= h(v[i-1]) */
+ BF_set_key(&hashkey, KEYSIZE, v[i - 1]);
+ BF_cbc_encrypt(v[i], temp, KEYSIZE, &hashkey, ivec, BF_ENCRYPT);
+ memcpy(&v[i], temp, KEYSIZE);
+ /* v[i] #= h(v[0]) */
+ BF_set_key(&hashkey, KEYSIZE, v[0]);
+ BF_cbc_encrypt(v[i], temp, KEYSIZE, &hashkey, ivec, BF_ENCRYPT);
+ memcpy(&v[i], temp, KEYSIZE);
+ /* v[i] #= h(i) */
+ BF_set_key(&hashkey, sizeof(int), (unsigned char *)&i);
+ BF_cbc_encrypt(v[i], temp, KEYSIZE, &hashkey, ivec, BF_ENCRYPT);
+ memcpy(&v[i], temp, KEYSIZE);
}
/* 3. Compute a new Key. */
bzero((void *)hash, KEYSIZE);
- BF_set_key(&hashkey, KEYSIZE, (unsigned char *)&state.key);
- BF_cbc_encrypt(hash, temp, KEYSIZE, &hashkey,
- ivec, BF_ENCRYPT);
+ BF_set_key(&hashkey, KEYSIZE, (unsigned char *)&random_state.key);
+ BF_cbc_encrypt(hash, temp, KEYSIZE, &hashkey, ivec, BF_ENCRYPT);
memcpy(hash, temp, KEYSIZE);
- for (i = 1; i < BINS; i++) {
+ for (i = 1; i < random_state.bins; i++) {
BF_set_key(&hashkey, KEYSIZE, v[i]);
- BF_cbc_encrypt(hash, temp, KEYSIZE, &hashkey,
- ivec, BF_ENCRYPT);
+ BF_cbc_encrypt(hash, temp, KEYSIZE, &hashkey, ivec, BF_ENCRYPT);
memcpy(hash, temp, KEYSIZE);
}
-
- BF_set_key(&state.key, KEYSIZE, hash);
+ BF_set_key(&random_state.key, KEYSIZE, hash);
/* 4. Recompute the counter */
- state.counter = 0;
- BF_cbc_encrypt((unsigned char *)&state.counter, temp,
- sizeof(state.counter), &state.key, state.ivec,
- BF_ENCRYPT);
- memcpy(&state.counter, temp, state.counter);
+ random_state.counter = 0;
+ BF_cbc_encrypt((unsigned char *)&random_state.counter, temp,
+ sizeof(random_state.counter), &random_state.key,
+ random_state.ivec, BF_ENCRYPT);
+ memcpy(&random_state.counter, temp, random_state.counter);
- /* 5. Reset all entropy estimate accumulators to zero */
+ /* 5. Reset entropy estimate accumulators to zero */
- bzero((void *)state.randomstuff, sizeof(state.randomstuff));
+ for (i = 0; i <= fastslow; i++) {
+ for (j = 0; j < ENTROPYSOURCE; j++) {
+ random_state.pool[i].source[j].bits = 0;
+ random_state.pool[i].source[j].frac = 0;
+ }
+ }
/* 6. Wipe memory of intermediate values */
@@ -151,43 +214,46 @@ read_random(char *buf, u_int count)
if (gate) {
generator_gate();
- state.outputblocks = 0;
+ random_state.outputblocks = 0;
gate = 0;
}
- if (count >= sizeof(state.counter)) {
+ if (count >= sizeof(random_state.counter)) {
retval = 0;
- for (i = 0; i < count; i += sizeof(state.counter)) {
- state.counter++;
- BF_cbc_encrypt((unsigned char *)&state.counter,
- (unsigned char *)&genval, sizeof(state.counter),
- &state.key, state.ivec, BF_ENCRYPT);
- memcpy(&buf[i], &genval, sizeof(state.counter));
- if (++state.outputblocks >= state.gengateinterval) {
+ for (i = 0; i < count; i += sizeof(random_state.counter)) {
+ random_state.counter++;
+ BF_cbc_encrypt((unsigned char *)&random_state.counter,
+ (unsigned char *)&genval,
+ sizeof(random_state.counter),
+ &random_state.key, random_state.ivec, BF_ENCRYPT);
+ memcpy(&buf[i], &genval, sizeof(random_state.counter));
+ if (++random_state.outputblocks >= random_state.gengateinterval) {
generator_gate();
- state.outputblocks = 0;
+ random_state.outputblocks = 0;
}
- retval += sizeof(state.counter);
+ retval += sizeof(random_state.counter);
}
}
else {
if (!cur) {
- state.counter++;
- BF_cbc_encrypt((unsigned char *)&state.counter,
- (unsigned char *)&genval, sizeof(state.counter),
- &state.key, state.ivec, BF_ENCRYPT);
+ random_state.counter++;
+ BF_cbc_encrypt((unsigned char *)&random_state.counter,
+ (unsigned char *)&genval,
+ sizeof(random_state.counter),
+ &random_state.key, random_state.ivec,
+ BF_ENCRYPT);
memcpy(buf, &genval, count);
- cur = sizeof(state.counter) - count;
- if (++state.outputblocks >= state.gengateinterval) {
+ cur = sizeof(random_state.counter) - count;
+ if (++random_state.outputblocks >= random_state.gengateinterval) {
generator_gate();
- state.outputblocks = 0;
+ random_state.outputblocks = 0;
}
retval = count;
}
else {
retval = cur < count ? cur : count;
memcpy(buf,
- (char *)&state.counter +
- (sizeof(state.counter) - retval),
+ (char *)&random_state.counter +
+ (sizeof(random_state.counter) - retval),
retval);
cur -= retval;
}
@@ -195,19 +261,81 @@ read_random(char *buf, u_int count)
return retval;
}
-void
+static void
generator_gate(void)
{
int i;
unsigned char temp[KEYSIZE];
- for (i = 0; i < KEYSIZE; i += sizeof(state.counter)) {
- state.counter++;
- BF_cbc_encrypt((unsigned char *)&state.counter, &temp[i],
- sizeof(state.counter), &state.key, state.ivec,
- BF_ENCRYPT);
+#ifdef DEBUG
+ /* printf("Generator gate\n"); */
+#endif
+ for (i = 0; i < KEYSIZE; i += sizeof(random_state.counter)) {
+ random_state.counter++;
+ BF_cbc_encrypt((unsigned char *)&random_state.counter,
+ &(temp[i]), sizeof(random_state.counter),
+ &random_state.key, random_state.ivec, BF_ENCRYPT);
}
- BF_set_key(&state.key, KEYSIZE, temp);
+ BF_set_key(&random_state.key, KEYSIZE, temp);
bzero((void *)temp, KEYSIZE);
}
+
+/* Entropy harvesting routine. This is supposed to be fast; do */
+/* not do anything slow in here! */
+
+static void
+random_harvest_internal(struct timespec *nanotime, u_int64_t entropy,
+ u_int bits, u_int frac, u_int origin)
+{
+ u_int insert;
+ int which; /* fast or slow */
+ struct entropy *bucket;
+ struct source *source;
+ struct pool *pool;
+
+#ifdef DEBUG
+ printf("Random harvest\n");
+#endif
+ if (origin < ENTROPYSOURCE) {
+
+ which = random_state.which;
+ pool = &random_state.pool[which];
+ source = &pool->source[origin];
+
+ insert = source->current + 1;
+ if (insert >= ENTROPYBIN)
+ insert = 0;
+
+ bucket = &source->entropy[insert];
+
+ if (!bucket->nanotime.tv_sec && !bucket->nanotime.tv_nsec) {
+
+ /* nanotime provides clock jitter */
+ bucket->nanotime = *nanotime;
+
+ /* the harvested entropy */
+ bucket->data = entropy;
+
+ /* update the estimates - including "fractional bits" */
+ source->bits += bits;
+ source->frac += frac;
+ if (source->frac >= 1024) {
+ source->bits += source->frac / 1024;
+ source->frac %= 1024;
+ }
+ context.pool = which;
+ if (source->bits >= pool->thresh) {
+ /* XXX Needs to be multiply queued? */
+ taskqueue_enqueue(taskqueue_swi, &regate_task);
+ }
+
+ /* bump the insertion point */
+ source->current = insert;
+
+ /* toggle the pool for next time */
+ random_state.which = !random_state.which;
+
+ }
+ }
+}
diff --git a/sys/dev/random/yarrow.h b/sys/dev/random/yarrow.h
index 6fb557e..2b6afcf 100644
--- a/sys/dev/random/yarrow.h
+++ b/sys/dev/random/yarrow.h
@@ -1,5 +1,5 @@
/*-
- * Copyright (c) 2000 Mark Murray
+ * Copyright (c) 2000 Mark R V Murray
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -26,17 +26,52 @@
* $FreeBSD$
*/
-#define BINS 10 /* t */
-#define KEYSIZE 32 /* 32 bytes == 256 bits */
+#define ENTROPYBIN 256 /* buckets to harvest entropy events */
+#define ENTROPYSOURCE 2 /* entropy sources (actually classes) */
+ /* The entropy classes will as follows: */
+ /* 0 - Keyboard */
+ /* 1 - Mouse */
+ /* to start with. More will be added */
+
+#define TIMEBIN 16 /* max value for Pt/t */
+#define KEYSIZE 32 /* 32 bytes == 256 bits */
+
+#define FAST 0
+#define SLOW 1
+
+void random_init(void);
+void random_deinit(void);
+void random_init_harvester(void (*)(struct timespec *, u_int64_t, u_int, u_int, u_int));
+void random_deinit_harvester(void);
/* This is the beasite that needs protecting. It contains all of the
* state that we are excited about.
+ * This is a biiig structure. It may move over to a malloc(9)ed
+ * replacement.
*/
-struct state {
- u_int64_t counter; /* C */
- BF_KEY key; /* K */
- unsigned char ivec[8]; /* Blowfish internal */
- int gengateinterval; /* Pg */
- int outputblocks;
- unsigned char randomstuff[1024]; /* XXX to be done properly */
+struct random_state {
+ u_int64_t counter; /* C */
+ BF_KEY key; /* K */
+ int gengateinterval; /* Pg */
+ int bins; /* Pt/t */
+ u_char ivec[8]; /* Blowfish internal */
+ int outputblocks; /* count output blocks for gates */
+ u_int slowoverthresh; /* slow pool overthreshhold reseed count */
+ struct pool {
+ struct source {
+ struct entropy {
+ struct timespec nanotime;
+ u_int64_t data;
+ } entropy[ENTROPYBIN]; /* entropy units - must each
+ be <= KEYSIZE */
+ u_int bits; /* estimated bits of entropy */
+ u_int frac; /* fractional bits of entropy
+ (given as 1024/n) */
+ u_int current; /* next insertion point */
+ } source[ENTROPYSOURCE];
+ u_int thresh; /* pool reseed threshhold */
+ } pool[2]; /* pool[0] is fast, pool[1] is slow */
+ int which; /* toggle - shows the current insertion pool */
};
+
+extern struct random_state random_state;
diff --git a/sys/dev/randomdev/harvest.c b/sys/dev/randomdev/harvest.c
new file mode 100644
index 0000000..ceb9f9f
--- /dev/null
+++ b/sys/dev/randomdev/harvest.c
@@ -0,0 +1,81 @@
+/*-
+ * Copyright (c) 2000 Mark R V Murray
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer
+ * in this position and unchanged.
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/types.h>
+#include <sys/queue.h>
+#include <sys/linker.h>
+#include <sys/libkern.h>
+#include <sys/mbuf.h>
+#include <sys/random.h>
+#include <sys/time.h>
+#include <crypto/blowfish/blowfish.h>
+
+#include <dev/randomdev/yarrow.h>
+
+/* hold the address of the routine which is actually called if */
+/* the ramdomdev is loaded */
+static void (*reap)(struct timespec *, u_int64_t, u_int, u_int, u_int) = NULL;
+
+/* Initialise the harvester at load time */
+void
+random_init_harvester(void (*reaper)(struct timespec *, u_int64_t, u_int, u_int, u_int))
+{
+ intrmask_t mask;
+
+ mask = splhigh();
+ reap = reaper;
+ splx(mask);
+}
+
+/* Deinitialise the harvester at unload time */
+void
+random_deinit_harvester(void)
+{
+ intrmask_t mask;
+
+ mask = splhigh();
+ reap = NULL;
+ splx(mask);
+}
+
+/* Entropy harvesting routine. This is supposed to be fast; do */
+/* not do anything slow in here! */
+/* Implemented as in indirect call to allow non-inclusion of */
+/* the entropy device. */
+void
+random_harvest(u_int64_t entropy, u_int bits, u_int frac, u_int source)
+{
+ struct timespec nanotime;
+
+ if (reap) {
+ getnanotime(&nanotime);
+ (*reap)(&nanotime, entropy, bits, frac, source);
+ }
+}
diff --git a/sys/dev/randomdev/randomdev.c b/sys/dev/randomdev/randomdev.c
index 2ef9e9d..161ca57 100644
--- a/sys/dev/randomdev/randomdev.c
+++ b/sys/dev/randomdev/randomdev.c
@@ -1,5 +1,5 @@
/*-
- * Copyright (c) 2000 Mark Murray
+ * Copyright (c) 2000 Mark R V Murray
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -27,12 +27,12 @@
*/
#include <sys/param.h>
+#include <sys/queue.h>
#include <sys/systm.h>
#include <sys/conf.h>
#include <sys/fcntl.h>
#include <sys/uio.h>
#include <sys/kernel.h>
-#include <sys/kobj.h>
#include <sys/malloc.h>
#include <sys/module.h>
#include <sys/bus.h>
@@ -46,8 +46,8 @@
#include <dev/randomdev/yarrow.h>
-static d_read_t randomread;
-static d_write_t randomwrite;
+static d_read_t random_read;
+static d_write_t random_write;
#define CDEV_MAJOR 2
#define RANDOM_MINOR 3
@@ -56,8 +56,8 @@ static d_write_t randomwrite;
static struct cdevsw random_cdevsw = {
/* open */ (d_open_t *)nullop,
/* close */ (d_close_t *)nullop,
- /* read */ randomread,
- /* write */ randomwrite,
+ /* read */ random_read,
+ /* write */ random_write,
/* ioctl */ noioctl,
/* poll */ nopoll,
/* mmap */ nommap,
@@ -71,52 +71,51 @@ static struct cdevsw random_cdevsw = {
};
/* For use with make_dev(9)/destroy_dev(9). */
-static dev_t randomdev;
-static dev_t urandomdev;
+static dev_t random_dev;
+static dev_t urandom_dev;
-static void *buf;
+/* Buffer used by uiomove(9) */
+static void *random_buf;
-extern void randominit(void);
-
-extern struct state state;
-
-/* This is mostly academic at the moment; as Yarrow gets extended, it will
- become more relevant */
SYSCTL_NODE(_kern, OID_AUTO, random, CTLFLAG_RW, 0, "Random Number Generator");
SYSCTL_NODE(_kern_random, OID_AUTO, yarrow, CTLFLAG_RW, 0, "Yarrow Parameters");
-SYSCTL_INT(_kern_random_yarrow, OID_AUTO, gengateinterval, CTLFLAG_RW, &state.gengateinterval, 10, "Generator Gate Interval");
+SYSCTL_INT(_kern_random_yarrow, OID_AUTO, gengateinterval, CTLFLAG_RW, &random_state.gengateinterval, 10, "Generator Gate Interval");
+SYSCTL_INT(_kern_random_yarrow, OID_AUTO, bins, CTLFLAG_RW, &random_state.bins, 10, "Execution time tuner");
+SYSCTL_INT(_kern_random_yarrow, OID_AUTO, fastthresh, CTLFLAG_RW, &random_state.pool[0].thresh, 100, "Fast pool reseed threshhold");
+SYSCTL_INT(_kern_random_yarrow, OID_AUTO, slowthresh, CTLFLAG_RW, &random_state.pool[1].thresh, 100, "Slow pool reseed threshhold");
+SYSCTL_INT(_kern_random_yarrow, OID_AUTO, slowoverthresh, CTLFLAG_RW, &random_state.slowoverthresh, 2, "Slow pool over-threshhold reseed count");
static int
-randomread(dev_t dev, struct uio *uio, int flag)
+random_read(dev_t dev, struct uio *uio, int flag)
{
u_int c, ret;
int error = 0;
c = min(uio->uio_resid, PAGE_SIZE);
- buf = (void *)malloc(c, M_TEMP, M_WAITOK);
+ random_buf = (void *)malloc(c, M_TEMP, M_WAITOK);
while (uio->uio_resid > 0 && error == 0) {
- ret = read_random(buf, c);
- error = uiomove(buf, ret, uio);
+ ret = read_random(random_buf, c);
+ error = uiomove(random_buf, ret, uio);
}
- free(buf, M_TEMP);
+ free(random_buf, M_TEMP);
return error;
}
static int
-randomwrite(dev_t dev, struct uio *uio, int flag)
+random_write(dev_t dev, struct uio *uio, int flag)
{
u_int c;
int error = 0;
- buf = (void *)malloc(PAGE_SIZE, M_TEMP, M_WAITOK);
+ random_buf = (void *)malloc(PAGE_SIZE, M_TEMP, M_WAITOK);
while (uio->uio_resid > 0) {
c = min(uio->uio_resid, PAGE_SIZE);
- error = uiomove(buf, c, uio);
+ error = uiomove(random_buf, c, uio);
if (error)
break;
- /* write_random(buf, c); */
+ /* write_random(random_buf, c); */
}
- free(buf, M_TEMP);
+ free(random_buf, M_TEMP);
return error;
}
@@ -127,16 +126,17 @@ random_modevent(module_t mod, int type, void *data)
case MOD_LOAD:
if (bootverbose)
printf("random: <entropy source>\n");
- randomdev = make_dev(&random_cdevsw, RANDOM_MINOR, UID_ROOT,
+ random_dev = make_dev(&random_cdevsw, RANDOM_MINOR, UID_ROOT,
GID_WHEEL, 0666, "random");
- urandomdev = make_dev(&random_cdevsw, URANDOM_MINOR, UID_ROOT,
+ urandom_dev = make_dev(&random_cdevsw, URANDOM_MINOR, UID_ROOT,
GID_WHEEL, 0666, "urandom");
- randominit();
+ random_init();
return 0;
case MOD_UNLOAD:
- destroy_dev(randomdev);
- destroy_dev(urandomdev);
+ random_deinit();
+ destroy_dev(random_dev);
+ destroy_dev(urandom_dev);
return 0;
case MOD_SHUTDOWN:
diff --git a/sys/dev/randomdev/yarrow.c b/sys/dev/randomdev/yarrow.c
index b54951b..ab4a69c 100644
--- a/sys/dev/randomdev/yarrow.c
+++ b/sys/dev/randomdev/yarrow.c
@@ -1,5 +1,5 @@
/*-
- * Copyright (c) 2000 Mark Murray
+ * Copyright (c) 2000 Mark R V Murray
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -32,103 +32,166 @@
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/queue.h>
+#include <sys/taskqueue.h>
#include <sys/linker.h>
#include <sys/libkern.h>
#include <sys/mbuf.h>
#include <sys/random.h>
+#include <sys/time.h>
#include <sys/types.h>
#include <crypto/blowfish/blowfish.h>
#include <dev/randomdev/yarrow.h>
-void generator_gate(void);
-void reseed(void);
-void randominit(void);
+/* #define DEBUG */
-/* This is the beastie that needs protecting. It contains all of the
- * state that we are excited about.
- */
-struct state state;
+static void generator_gate(void);
+static void reseed(int);
+static void random_harvest_internal(struct timespec *nanotime, u_int64_t entropy, u_int bits, u_int frac, u_int source);
+
+/* Structure holding the entropy state */
+struct random_state random_state;
+
+/* When enough entropy has been harvested, asynchronously "stir" it in */
+static struct task regate_task;
+
+static struct context {
+ u_int pool;
+} context = { 0 };
+
+static void
+regate(void *context, int pending)
+{
+#ifdef DEBUG
+ printf("Regate task\n");
+#endif
+ reseed(((struct context *)context)->pool);
+}
void
-randominit(void)
+random_init(void)
{
- /* XXX much more to come */
- state.gengateinterval = 10;
+#ifdef DEBUG
+ printf("Random init\n");
+#endif
+ random_state.gengateinterval = 10;
+ random_state.bins = 10;
+ random_state.pool[0].thresh = 100;
+ random_state.pool[1].thresh = 160;
+ random_state.slowoverthresh = 2;
+ random_state.which = FAST;
+ TASK_INIT(&regate_task, 0, &regate, (void *)&context);
+ random_init_harvester(random_harvest_internal);
}
void
-reseed(void)
+random_deinit(void)
{
- unsigned char v[BINS][KEYSIZE]; /* v[i] */
- unsigned char hash[KEYSIZE]; /* h' */
+#ifdef DEBUG
+ printf("Random deinit\n");
+#endif
+ random_deinit_harvester();
+}
+
+static void
+reseed(int fastslow)
+{
+ unsigned char v[TIMEBIN][KEYSIZE]; /* v[i] */
+ unsigned char hash[KEYSIZE]; /* h' */
BF_KEY hashkey;
unsigned char ivec[8];
unsigned char temp[KEYSIZE];
+ struct entropy *bucket;
int i, j;
+#ifdef DEBUG
+ printf("Reseed type %d\n", fastslow);
+#endif
+
/* 1. Hash the accumulated entropy into v[0] */
- /* XXX to be done properly */
bzero((void *)&v[0], KEYSIZE);
- for (j = 0; j < sizeof(state.randomstuff); j += KEYSIZE) {
- BF_set_key(&hashkey, KEYSIZE, &state.randomstuff[j]);
- BF_cbc_encrypt(v[0], temp, KEYSIZE, &hashkey,
- ivec, BF_ENCRYPT);
- memcpy(&v[0], temp, KEYSIZE);
+ if (fastslow == SLOW) {
+ /* Feed a hash of the slow pool into the fast pool */
+ for (i = 0; i < ENTROPYSOURCE; i++) {
+ for (j = 0; j < ENTROPYBIN; j++) {
+ bucket = &random_state.pool[SLOW].source[i].entropy[j];
+ if(bucket->nanotime.tv_sec || bucket->nanotime.tv_nsec) {
+ BF_set_key(&hashkey, sizeof(struct entropy),
+ (void *)bucket);
+ BF_cbc_encrypt(v[0], temp, KEYSIZE, &hashkey, ivec,
+ BF_ENCRYPT);
+ memcpy(&v[0], temp, KEYSIZE);
+ bucket->nanotime.tv_sec = 0;
+ bucket->nanotime.tv_nsec = 0;
+ }
+ }
+ }
+ }
+
+ for (i = 0; i < ENTROPYSOURCE; i++) {
+ for (j = 0; j < ENTROPYBIN; j++) {
+ bucket = &random_state.pool[FAST].source[i].entropy[j];
+ if(bucket->nanotime.tv_sec || bucket->nanotime.tv_nsec) {
+ BF_set_key(&hashkey, sizeof(struct entropy), (void *)bucket);
+ BF_cbc_encrypt(v[0], temp, KEYSIZE, &hashkey, ivec, BF_ENCRYPT);
+ memcpy(&v[0], temp, KEYSIZE);
+ bucket->nanotime.tv_sec = 0;
+ bucket->nanotime.tv_nsec = 0;
+ }
+ }
}
/* 2. Compute hash values for all v. _Supposed_ to be computationally */
/* intensive. */
- for (i = 1; i < BINS; i++) {
+ if (random_state.bins > TIMEBIN)
+ random_state.bins = TIMEBIN;
+ for (i = 1; i < random_state.bins; i++) {
bzero((void *)&v[i], KEYSIZE);
- for (j = 0; j < sizeof(state.randomstuff); j += KEYSIZE) {
- /* v[i] #= h(v[i-1]) */
- BF_set_key(&hashkey, KEYSIZE, v[i - 1]);
- BF_cbc_encrypt(v[i], temp, KEYSIZE, &hashkey,
- ivec, BF_ENCRYPT);
- memcpy(&v[i], temp, KEYSIZE);
- /* v[i] #= h(v[0]) */
- BF_set_key(&hashkey, KEYSIZE, v[0]);
- BF_cbc_encrypt(v[i], temp, KEYSIZE, &hashkey,
- ivec, BF_ENCRYPT);
- memcpy(&v[i], temp, KEYSIZE);
- /* v[i] #= h(i) */
- BF_set_key(&hashkey, sizeof(int), (unsigned char *)&i);
- BF_cbc_encrypt(v[i], temp, KEYSIZE, &hashkey,
- ivec, BF_ENCRYPT);
- memcpy(&v[i], temp, KEYSIZE);
- }
+ /* v[i] #= h(v[i-1]) */
+ BF_set_key(&hashkey, KEYSIZE, v[i - 1]);
+ BF_cbc_encrypt(v[i], temp, KEYSIZE, &hashkey, ivec, BF_ENCRYPT);
+ memcpy(&v[i], temp, KEYSIZE);
+ /* v[i] #= h(v[0]) */
+ BF_set_key(&hashkey, KEYSIZE, v[0]);
+ BF_cbc_encrypt(v[i], temp, KEYSIZE, &hashkey, ivec, BF_ENCRYPT);
+ memcpy(&v[i], temp, KEYSIZE);
+ /* v[i] #= h(i) */
+ BF_set_key(&hashkey, sizeof(int), (unsigned char *)&i);
+ BF_cbc_encrypt(v[i], temp, KEYSIZE, &hashkey, ivec, BF_ENCRYPT);
+ memcpy(&v[i], temp, KEYSIZE);
}
/* 3. Compute a new Key. */
bzero((void *)hash, KEYSIZE);
- BF_set_key(&hashkey, KEYSIZE, (unsigned char *)&state.key);
- BF_cbc_encrypt(hash, temp, KEYSIZE, &hashkey,
- ivec, BF_ENCRYPT);
+ BF_set_key(&hashkey, KEYSIZE, (unsigned char *)&random_state.key);
+ BF_cbc_encrypt(hash, temp, KEYSIZE, &hashkey, ivec, BF_ENCRYPT);
memcpy(hash, temp, KEYSIZE);
- for (i = 1; i < BINS; i++) {
+ for (i = 1; i < random_state.bins; i++) {
BF_set_key(&hashkey, KEYSIZE, v[i]);
- BF_cbc_encrypt(hash, temp, KEYSIZE, &hashkey,
- ivec, BF_ENCRYPT);
+ BF_cbc_encrypt(hash, temp, KEYSIZE, &hashkey, ivec, BF_ENCRYPT);
memcpy(hash, temp, KEYSIZE);
}
-
- BF_set_key(&state.key, KEYSIZE, hash);
+ BF_set_key(&random_state.key, KEYSIZE, hash);
/* 4. Recompute the counter */
- state.counter = 0;
- BF_cbc_encrypt((unsigned char *)&state.counter, temp,
- sizeof(state.counter), &state.key, state.ivec,
- BF_ENCRYPT);
- memcpy(&state.counter, temp, state.counter);
+ random_state.counter = 0;
+ BF_cbc_encrypt((unsigned char *)&random_state.counter, temp,
+ sizeof(random_state.counter), &random_state.key,
+ random_state.ivec, BF_ENCRYPT);
+ memcpy(&random_state.counter, temp, random_state.counter);
- /* 5. Reset all entropy estimate accumulators to zero */
+ /* 5. Reset entropy estimate accumulators to zero */
- bzero((void *)state.randomstuff, sizeof(state.randomstuff));
+ for (i = 0; i <= fastslow; i++) {
+ for (j = 0; j < ENTROPYSOURCE; j++) {
+ random_state.pool[i].source[j].bits = 0;
+ random_state.pool[i].source[j].frac = 0;
+ }
+ }
/* 6. Wipe memory of intermediate values */
@@ -151,43 +214,46 @@ read_random(char *buf, u_int count)
if (gate) {
generator_gate();
- state.outputblocks = 0;
+ random_state.outputblocks = 0;
gate = 0;
}
- if (count >= sizeof(state.counter)) {
+ if (count >= sizeof(random_state.counter)) {
retval = 0;
- for (i = 0; i < count; i += sizeof(state.counter)) {
- state.counter++;
- BF_cbc_encrypt((unsigned char *)&state.counter,
- (unsigned char *)&genval, sizeof(state.counter),
- &state.key, state.ivec, BF_ENCRYPT);
- memcpy(&buf[i], &genval, sizeof(state.counter));
- if (++state.outputblocks >= state.gengateinterval) {
+ for (i = 0; i < count; i += sizeof(random_state.counter)) {
+ random_state.counter++;
+ BF_cbc_encrypt((unsigned char *)&random_state.counter,
+ (unsigned char *)&genval,
+ sizeof(random_state.counter),
+ &random_state.key, random_state.ivec, BF_ENCRYPT);
+ memcpy(&buf[i], &genval, sizeof(random_state.counter));
+ if (++random_state.outputblocks >= random_state.gengateinterval) {
generator_gate();
- state.outputblocks = 0;
+ random_state.outputblocks = 0;
}
- retval += sizeof(state.counter);
+ retval += sizeof(random_state.counter);
}
}
else {
if (!cur) {
- state.counter++;
- BF_cbc_encrypt((unsigned char *)&state.counter,
- (unsigned char *)&genval, sizeof(state.counter),
- &state.key, state.ivec, BF_ENCRYPT);
+ random_state.counter++;
+ BF_cbc_encrypt((unsigned char *)&random_state.counter,
+ (unsigned char *)&genval,
+ sizeof(random_state.counter),
+ &random_state.key, random_state.ivec,
+ BF_ENCRYPT);
memcpy(buf, &genval, count);
- cur = sizeof(state.counter) - count;
- if (++state.outputblocks >= state.gengateinterval) {
+ cur = sizeof(random_state.counter) - count;
+ if (++random_state.outputblocks >= random_state.gengateinterval) {
generator_gate();
- state.outputblocks = 0;
+ random_state.outputblocks = 0;
}
retval = count;
}
else {
retval = cur < count ? cur : count;
memcpy(buf,
- (char *)&state.counter +
- (sizeof(state.counter) - retval),
+ (char *)&random_state.counter +
+ (sizeof(random_state.counter) - retval),
retval);
cur -= retval;
}
@@ -195,19 +261,81 @@ read_random(char *buf, u_int count)
return retval;
}
-void
+static void
generator_gate(void)
{
int i;
unsigned char temp[KEYSIZE];
- for (i = 0; i < KEYSIZE; i += sizeof(state.counter)) {
- state.counter++;
- BF_cbc_encrypt((unsigned char *)&state.counter, &temp[i],
- sizeof(state.counter), &state.key, state.ivec,
- BF_ENCRYPT);
+#ifdef DEBUG
+ /* printf("Generator gate\n"); */
+#endif
+ for (i = 0; i < KEYSIZE; i += sizeof(random_state.counter)) {
+ random_state.counter++;
+ BF_cbc_encrypt((unsigned char *)&random_state.counter,
+ &(temp[i]), sizeof(random_state.counter),
+ &random_state.key, random_state.ivec, BF_ENCRYPT);
}
- BF_set_key(&state.key, KEYSIZE, temp);
+ BF_set_key(&random_state.key, KEYSIZE, temp);
bzero((void *)temp, KEYSIZE);
}
+
+/* Entropy harvesting routine. This is supposed to be fast; do */
+/* not do anything slow in here! */
+
+static void
+random_harvest_internal(struct timespec *nanotime, u_int64_t entropy,
+ u_int bits, u_int frac, u_int origin)
+{
+ u_int insert;
+ int which; /* fast or slow */
+ struct entropy *bucket;
+ struct source *source;
+ struct pool *pool;
+
+#ifdef DEBUG
+ printf("Random harvest\n");
+#endif
+ if (origin < ENTROPYSOURCE) {
+
+ which = random_state.which;
+ pool = &random_state.pool[which];
+ source = &pool->source[origin];
+
+ insert = source->current + 1;
+ if (insert >= ENTROPYBIN)
+ insert = 0;
+
+ bucket = &source->entropy[insert];
+
+ if (!bucket->nanotime.tv_sec && !bucket->nanotime.tv_nsec) {
+
+ /* nanotime provides clock jitter */
+ bucket->nanotime = *nanotime;
+
+ /* the harvested entropy */
+ bucket->data = entropy;
+
+ /* update the estimates - including "fractional bits" */
+ source->bits += bits;
+ source->frac += frac;
+ if (source->frac >= 1024) {
+ source->bits += source->frac / 1024;
+ source->frac %= 1024;
+ }
+ context.pool = which;
+ if (source->bits >= pool->thresh) {
+ /* XXX Needs to be multiply queued? */
+ taskqueue_enqueue(taskqueue_swi, &regate_task);
+ }
+
+ /* bump the insertion point */
+ source->current = insert;
+
+ /* toggle the pool for next time */
+ random_state.which = !random_state.which;
+
+ }
+ }
+}
diff --git a/sys/dev/randomdev/yarrow.h b/sys/dev/randomdev/yarrow.h
index 6fb557e..2b6afcf 100644
--- a/sys/dev/randomdev/yarrow.h
+++ b/sys/dev/randomdev/yarrow.h
@@ -1,5 +1,5 @@
/*-
- * Copyright (c) 2000 Mark Murray
+ * Copyright (c) 2000 Mark R V Murray
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -26,17 +26,52 @@
* $FreeBSD$
*/
-#define BINS 10 /* t */
-#define KEYSIZE 32 /* 32 bytes == 256 bits */
+#define ENTROPYBIN 256 /* buckets to harvest entropy events */
+#define ENTROPYSOURCE 2 /* entropy sources (actually classes) */
+ /* The entropy classes will as follows: */
+ /* 0 - Keyboard */
+ /* 1 - Mouse */
+ /* to start with. More will be added */
+
+#define TIMEBIN 16 /* max value for Pt/t */
+#define KEYSIZE 32 /* 32 bytes == 256 bits */
+
+#define FAST 0
+#define SLOW 1
+
+void random_init(void);
+void random_deinit(void);
+void random_init_harvester(void (*)(struct timespec *, u_int64_t, u_int, u_int, u_int));
+void random_deinit_harvester(void);
/* This is the beasite that needs protecting. It contains all of the
* state that we are excited about.
+ * This is a biiig structure. It may move over to a malloc(9)ed
+ * replacement.
*/
-struct state {
- u_int64_t counter; /* C */
- BF_KEY key; /* K */
- unsigned char ivec[8]; /* Blowfish internal */
- int gengateinterval; /* Pg */
- int outputblocks;
- unsigned char randomstuff[1024]; /* XXX to be done properly */
+struct random_state {
+ u_int64_t counter; /* C */
+ BF_KEY key; /* K */
+ int gengateinterval; /* Pg */
+ int bins; /* Pt/t */
+ u_char ivec[8]; /* Blowfish internal */
+ int outputblocks; /* count output blocks for gates */
+ u_int slowoverthresh; /* slow pool overthreshhold reseed count */
+ struct pool {
+ struct source {
+ struct entropy {
+ struct timespec nanotime;
+ u_int64_t data;
+ } entropy[ENTROPYBIN]; /* entropy units - must each
+ be <= KEYSIZE */
+ u_int bits; /* estimated bits of entropy */
+ u_int frac; /* fractional bits of entropy
+ (given as 1024/n) */
+ u_int current; /* next insertion point */
+ } source[ENTROPYSOURCE];
+ u_int thresh; /* pool reseed threshhold */
+ } pool[2]; /* pool[0] is fast, pool[1] is slow */
+ int which; /* toggle - shows the current insertion pool */
};
+
+extern struct random_state random_state;
diff --git a/sys/modules/random/Makefile b/sys/modules/random/Makefile
index 274a368..e8980fa 100644
--- a/sys/modules/random/Makefile
+++ b/sys/modules/random/Makefile
@@ -2,12 +2,10 @@
.PATH: ${.CURDIR}/../../dev/randomdev
.PATH: ${.CURDIR}/../../crypto/blowfish
-#.PATH: ${.CURDIR}/../../crypto/des
KMOD = randomdev
SRCS = bus_if.h device_if.h randomdev.c yarrow.c
SRCS += bf_cbc.c bf_skey.c bf_enc.c
CFLAGS += -I${.CURDIR}/../..
-#SRCS += sha1.c des_setkey.c des_ecb.c
NOMAN = yes
.include <bsd.kmod.mk>
diff --git a/sys/modules/randomdev/Makefile b/sys/modules/randomdev/Makefile
index 274a368..e8980fa 100644
--- a/sys/modules/randomdev/Makefile
+++ b/sys/modules/randomdev/Makefile
@@ -2,12 +2,10 @@
.PATH: ${.CURDIR}/../../dev/randomdev
.PATH: ${.CURDIR}/../../crypto/blowfish
-#.PATH: ${.CURDIR}/../../crypto/des
KMOD = randomdev
SRCS = bus_if.h device_if.h randomdev.c yarrow.c
SRCS += bf_cbc.c bf_skey.c bf_enc.c
CFLAGS += -I${.CURDIR}/../..
-#SRCS += sha1.c des_setkey.c des_ecb.c
NOMAN = yes
.include <bsd.kmod.mk>
OpenPOWER on IntegriCloud