mirror/freebsd
1
0
Fork 0
mirror of https://git.FreeBSD.org/src.git synced 2025-01-15 15:06:42 +00:00
Code Issues Releases Activity

Reorganise the entropy device so that high-yield entropy sources

Browse Source 
can more easily be used INSTEAD OF the hard-working Yarrow.
The only hardware source used at this point is the one inside
the VIA C3 Nehemiah (Stepping 3 and above) CPU. More sources will
be added in due course. Contributions welcome!
This commit is contained in:
Mark Murray 2004-04-09 15:47:10 +00:00
parent cd8b53ed2d
commit e7806b4c0e
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/head/; revision=128059
14 changed files with 794 additions and 422 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
sys/conf/files
View File

@ -608,6 +608,9 @@ dev/puc/puc_sbus.c optional puc sbus
dev/puc/pucdata.c optional puc pci
dev/random/harvest.c standard
dev/random/randomdev.c optional random
dev/random/randomdev_soft.c optional random
dev/random/nehemiah.c optional random
dev/random/probe.c optional random
dev/random/yarrow.c optional random
dev/random/hash.c optional random
crypto/rijndael/rijndael-alg-fst.c optional random

26
sys/dev/random/harvest.c
View File

@ -1,5 +1,5 @@
/*-
* Copyright (c) 2000, 2001, 2002, 2003 Mark R V Murray
* Copyright (c) 2000-2004 Mark R V Murray
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@ -37,29 +37,29 @@ __FBSDID("$FreeBSD$");
#include <sys/queue.h>
#include <sys/random.h>
#include <sys/selinfo.h>
#include <sys/sysctl.h>
#include <sys/systm.h>
#include <sys/sysctl.h>
#include <machine/cpu.h>
#include <dev/random/randomdev.h>
#include <dev/random/randomdev_soft.h>
static int read_random_phony(void *, int);
/* Structure holding the desired entropy sources */
struct harvest_select harvest = { 0, 0, 0 };
struct harvest_select harvest = { 0, 0, 0, 0 };
/* hold the address of the routine which is actually called if
* the randomdev is loaded
*/
static void (*reap_func)(u_int64_t, void *, u_int, u_int, u_int, enum esource)
= NULL;
static void (*reap_func)(u_int64_t, const void *, u_int, u_int, u_int,
enum esource) = NULL;
static int (*read_func)(void *, int) = read_random_phony;
/* Initialise the harvester at load time */
void
random_init_harvester(void (*reaper)(u_int64_t, void *, u_int, u_int, u_int,
enum esource), int (*reader)(void *, int))
random_yarrow_init_harvester(void (*reaper)(u_int64_t, const void *, u_int,
u_int, u_int, enum esource), int (*reader)(void *, int))
{
reap_func = reaper;
read_func = reader;
@ -67,7 +67,7 @@ random_init_harvester(void (*reaper)(u_int64_t, void *, u_int, u_int, u_int,
/* Deinitialise the harvester at unload time */
void
random_deinit_harvester(void)
random_yarrow_deinit_harvester(void)
{
reap_func = NULL;
read_func = read_random_phony;
@ -91,7 +91,7 @@ random_harvest(void *entropy, u_int count, u_int bits, u_int frac,
int
read_random(void *buf, int count)
{
return (*read_func)(buf, count);
return ((*read_func)(buf, count));
}
/* If the entropy device is not loaded, make a token effort to
@ -109,13 +109,11 @@ read_random_phony(void *buf, int count)
/* Fill buf[] with random(9) output */
for (i = 0; i < count; i+= (int)sizeof(u_long)) {
randval = random();
size = (count - i) < (int)sizeof(u_long)
? (count - i)
: sizeof(u_long);
size = MIN(count - i, sizeof(u_long));
memcpy(&((char *)buf)[i], &randval, (size_t)size);
}
return count;
return (count);
}
/* Helper routine to enable kthread_exit() to work while the module is

2
sys/dev/random/hash.c
View File

@ -1,5 +1,5 @@
/*-
* Copyright (c) 2000, 2001, 2002, 2003 Mark R V Murray
* Copyright (c) 2000-2004 Mark R V Murray
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without

2
sys/dev/random/hash.h
View File

@ -1,5 +1,5 @@
/*-
* Copyright (c) 2000 Mark R V Murray
* Copyright (c) 2000-2004 Mark R V Murray
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without

66
sys/dev/random/nehemiah.c Normal file
View File

@ -0,0 +1,66 @@
/*-
* Copyright (c) 2004 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.
*
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <sys/types.h>
#include <sys/time.h>
#include <sys/lock.h>
#include <sys/mutex.h>
#include <sys/selinfo.h>
#include <dev/random/randomdev.h>
static int random_nehemiah_read(void *, int);
struct random_systat random_nehemiah = {
.ident = "Hardware, VIA Nehemiah",
.init = (random_init_func_t *)random_null_func,
.deinit = (random_deinit_func_t *)random_null_func,
.read = random_nehemiah_read,
.write = (random_write_func_t *)random_null_func,
.reseed = (random_reseed_func_t *)random_null_func,
.seeded = 1,
};
/* ARGSUSED */
static int
random_nehemiah_read(void *buf, int c)
{
#if (defined(__GNUC__) || defined(__INTEL_COMPILER)) && defined(__i386__)
int count = c;
int rate = 0;
/* VIA C3 Nehemiah "rep; xstore" */
__asm __volatile("rep; .byte 0x0f, 0xa7, 0xc0"
: "+D" (buf), "+c" (count), "=d" (rate)
:
: "memory");
#endif
return (c);
}

29
sys/dev/random/nehemiah.h Normal file
View File

@ -0,0 +1,29 @@
/*-
* Copyright (c) 2000-2004 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$
*/
extern struct random_systat random_nehemiah;

68
sys/dev/random/probe.c Normal file
View File

@ -0,0 +1,68 @@
/*-
* Copyright (c) 2004 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.
*
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <sys/types.h>
#include <sys/malloc.h>
#include <sys/random.h>
#include <sys/selinfo.h>
#include <sys/stdint.h>
#include <sys/sysctl.h>
#if defined(__i386__)
#include <machine/cpufunc.h>
#endif
#include <dev/random/randomdev.h>
#include <dev/random/randomdev_soft.h>
#include <dev/random/nehemiah.h>
void
random_ident_hardware(struct random_systat *systat)
{
#if defined(__i386__)
u_int regs[4];
#endif
/* Set default to software */
*systat = random_yarrow;
/* Then go looking for hardware */
#if defined(__i386__)
do_cpuid(1, regs);
if ((regs[0] & 0xf) >= 3) {
do_cpuid(0xc0000000, regs);
if (regs[0] == 0xc0000001) {
do_cpuid(0xc0000001, regs);
if ((regs[3] & 0x0c) == 0x0c)
*systat = random_nehemiah;
}
}
#endif
}

406
sys/dev/random/randomdev.c
View File

@ -1,5 +1,5 @@
/*-
* Copyright (c) 2000, 2001, 2002, 2003 Mark R V Murray
* Copyright (c) 2000-2004 Mark R V Murray
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@ -41,9 +41,7 @@ __FBSDID("$FreeBSD$");
#include <sys/mutex.h>
#include <sys/poll.h>
#include <sys/proc.h>
#include <sys/random.h>
#include <sys/selinfo.h>
#include <sys/sysctl.h>
#include <sys/uio.h>
#include <sys/unistd.h>
#include <sys/vnode.h>
@ -53,150 +51,96 @@ __FBSDID("$FreeBSD$");
#include <dev/random/randomdev.h>
static d_close_t random_close;
static d_read_t random_read;
static d_write_t random_write;
static d_ioctl_t random_ioctl;
static d_poll_t random_poll;
#define RANDOM_MINOR 0
#define RANDOM_FIFO_MAX 256 /* How many events to queue up */
static d_close_t random_close;
static d_read_t random_read;
static d_write_t random_write;
static d_ioctl_t random_ioctl;
static d_poll_t random_poll;
static struct cdevsw random_cdevsw = {
.d_version = D_VERSION,
.d_flags = D_NEEDGIANT,
.d_close = random_close,
.d_read = random_read,
.d_write = random_write,
.d_ioctl = random_ioctl,
.d_poll = random_poll,
.d_name = "random",
.d_version = D_VERSION,
.d_close = random_close,
.d_read = random_read,
.d_write = random_write,
.d_ioctl = random_ioctl,
.d_poll = random_poll,
.d_name = "random",
};
static void random_kthread(void *);
static void random_harvest_internal(u_int64_t, void *, u_int, u_int, u_int, enum esource);
static void random_write_internal(void *, int);
static void *random_buf;
MALLOC_DEFINE(M_ENTROPY, "entropy", "Entropy harvesting buffers");
/* Lockable FIFO queue holding entropy buffers */
struct entropyfifo {
struct mtx lock;
int count;
STAILQ_HEAD(harvestlist, harvest) head;
};
/* Empty entropy buffers */
static struct entropyfifo emptyfifo;
#define EMPTYBUFFERS 1024
/* Harvested entropy */
static struct entropyfifo harvestfifo[ENTROPYSOURCE];
static struct random_systat {
u_int seeded; /* 0 causes blocking 1 allows normal output */
struct selinfo rsel; /* For poll(2) */
} random_systat;
/* <0 to end the kthread, 0 to let it run */
static int random_kthread_control = 0;
static struct proc *random_kthread_proc;
struct random_systat random_systat;
/* For use with make_dev(9)/destroy_dev(9). */
static dev_t random_dev;
static dev_t random_dev;
/* ARGSUSED */
static int
random_check_boolean(SYSCTL_HANDLER_ARGS)
/* Used to fake out unused random calls in random_systat */
void
random_null_func(void)
{
if (oidp->oid_arg1 != NULL && *(u_int *)(oidp->oid_arg1) != 0)
*(u_int *)(oidp->oid_arg1) = 1;
return sysctl_handle_int(oidp, oidp->oid_arg1, oidp->oid_arg2, req);
}
SYSCTL_NODE(_kern, OID_AUTO, random, CTLFLAG_RW,
0, "Random Number Generator");
SYSCTL_NODE(_kern_random, OID_AUTO, sys, CTLFLAG_RW,
0, "Entropy Device Parameters");
SYSCTL_PROC(_kern_random_sys, OID_AUTO, seeded,
CTLTYPE_INT|CTLFLAG_RW, &random_systat.seeded, 1,
random_check_boolean, "I", "Seeded State");
SYSCTL_NODE(_kern_random_sys, OID_AUTO, harvest, CTLFLAG_RW,
0, "Entropy Sources");
SYSCTL_PROC(_kern_random_sys_harvest, OID_AUTO, ethernet,
CTLTYPE_INT|CTLFLAG_RW, &harvest.ethernet, 0,
random_check_boolean, "I", "Harvest NIC entropy");
SYSCTL_PROC(_kern_random_sys_harvest, OID_AUTO, point_to_point,
CTLTYPE_INT|CTLFLAG_RW, &harvest.point_to_point, 0,
random_check_boolean, "I", "Harvest serial net entropy");
SYSCTL_PROC(_kern_random_sys_harvest, OID_AUTO, interrupt,
CTLTYPE_INT|CTLFLAG_RW, &harvest.interrupt, 0,
random_check_boolean, "I", "Harvest IRQ entropy");
SYSCTL_PROC(_kern_random_sys_harvest, OID_AUTO, swi,
CTLTYPE_INT|CTLFLAG_RW, &harvest.swi, 0,
random_check_boolean, "I", "Harvest SWI entropy");
/* ARGSUSED */
static int
random_close(dev_t dev __unused, int flags, int fmt __unused, struct thread *td)
random_close(dev_t dev __unused, int flags, int fmt __unused,
struct thread *td)
{
if (flags & FWRITE) {
if (suser(td) == 0 && securelevel_gt(td->td_ucred, 0) == 0)
random_reseed();
if ((flags & FWRITE) && (suser(td) == 0)
&& (securelevel_gt(td->td_ucred, 0) == 0)) {
mtx_lock(&random_systat.lock);
(*random_systat.reseed)();
random_systat.seeded = 1;
mtx_unlock(&random_systat.lock);
}
return 0;
return (0);
}
/* ARGSUSED */
static int
random_read(dev_t dev __unused, struct uio *uio, int flag)
{
int c, ret;
int error = 0;
void *random_buf;
int c, error = 0;
while (!random_systat.seeded) {
/* Blocking logic */
while (!random_systat.seeded && !error) {
if (flag & IO_NDELAY)
error = EWOULDBLOCK;
error = EWOULDBLOCK;
else
error = tsleep(&random_systat, PUSER|PCATCH,
"block", 0);
if (error != 0)
return error;
error = tsleep(&random_systat,
PUSER | PCATCH, "block", 0);
}
c = uio->uio_resid < PAGE_SIZE ? uio->uio_resid : PAGE_SIZE;
random_buf = (void *)malloc((u_long)c, M_TEMP, M_WAITOK);
while (uio->uio_resid > 0 && error == 0) {
ret = read_random_real(random_buf, c);
error = uiomove(random_buf, ret, uio);
/* The actual read */
if (!error) {
mtx_lock(&random_systat.lock);
while (uio->uio_resid > 0 && !error) {
c = MIN(uio->uio_resid, PAGE_SIZE);
c = (*random_systat.read)(random_buf, c);
error = uiomove(random_buf, c, uio);
}
mtx_unlock(&random_systat.lock);
}
free(random_buf, M_TEMP);
return error;
return (error);
}
/* ARGSUSED */
static int
random_write(dev_t dev __unused, struct uio *uio, int flag __unused)
{
int c;
int error;
void *random_buf;
int c, error = 0;
error = 0;
random_buf = (void *)malloc(PAGE_SIZE, M_TEMP, M_WAITOK);
mtx_lock(&random_systat.lock);
while (uio->uio_resid > 0) {
c = (int)(uio->uio_resid < PAGE_SIZE
? uio->uio_resid
: PAGE_SIZE);
c = MIN((int)uio->uio_resid, PAGE_SIZE);
error = uiomove(random_buf, c, uio);
if (error)
break;
random_write_internal(random_buf, c);
(*random_systat.write)(random_buf, c);
}
free(random_buf, M_TEMP);
return error;
mtx_unlock(&random_systat.lock);
return (error);
}
/* ARGSUSED */
@ -204,264 +148,70 @@ static int
random_ioctl(dev_t dev __unused, u_long cmd, caddr_t addr __unused,
int flags __unused, struct thread *td __unused)
{
int error = 0;
switch (cmd) {
/* Really handled in upper layer */
/* Really handled in upper layer */
case FIOASYNC:
case FIONBIO:
return 0;
break;
default:
return ENOTTY;
error = ENOTTY;
}
return (error);
}
/* ARGSUSED */
static int
random_poll(dev_t dev __unused, int events, struct thread *td)
{
int revents;
int revents = 0;
revents = 0;
if (events & (POLLIN | POLLRDNORM)) {
if (random_systat.seeded)
revents = events & (POLLIN | POLLRDNORM);
else
selrecord(td, &random_systat.rsel);
}
return revents;
return (revents);
}
/* ARGSUSED */
static int
random_modevent(module_t mod __unused, int type, void *data __unused)
{
int error, i;
struct harvest *np;
int error = 0;
switch(type) {
switch (type) {
case MOD_LOAD:
random_init();
random_buf = (void *)malloc(PAGE_SIZE, M_TEMP, M_WAITOK);
random_ident_hardware(&random_systat);
mtx_init(&random_systat.lock, "entropy device lock",
NULL, MTX_DEF);
(*random_systat.init)();
/* This can be turned off by the very paranoid
* a reseed will turn it back on.
*/
random_systat.seeded = 1;
printf("random: <entropy source, %s>\n", random_systat.ident);
/* Initialise the harvest fifos */
STAILQ_INIT(&emptyfifo.head);
emptyfifo.count = 0;
mtx_init(&emptyfifo.lock, "entropy harvest buffers", NULL,
MTX_SPIN);
for (i = 0; i < EMPTYBUFFERS; i++) {
np = malloc(sizeof(struct harvest), M_ENTROPY,
M_WAITOK);
STAILQ_INSERT_TAIL(&emptyfifo.head, np, next);
}
for (i = 0; i < ENTROPYSOURCE; i++) {
STAILQ_INIT(&harvestfifo[i].head);
harvestfifo[i].count = 0;
mtx_init(&harvestfifo[i].lock, "entropy harvest", NULL,
MTX_SPIN);
}
random_dev = make_dev(&random_cdevsw, RANDOM_MINOR,
UID_ROOT, GID_WHEEL, 0666, "random");
make_dev_alias(random_dev, "urandom"); /* XXX Deprecated */
if (bootverbose)
printf("random: <entropy source>\n");
random_dev = make_dev(&random_cdevsw, RANDOM_MINOR, UID_ROOT,
GID_WHEEL, 0666, "random");
make_dev_alias(random_dev, "urandom");
/* Start the hash/reseed thread */
error = kthread_create(random_kthread, NULL,
&random_kthread_proc, RFHIGHPID, 0, "random");
if (error != 0)
return error;
/* Register the randomness harvesting routine */
random_init_harvester(random_harvest_internal,
read_random_real);
return 0;
break;
case MOD_UNLOAD:
/* Deregister the randomness harvesting routine */
random_deinit_harvester();
/* Command the hash/reseed thread to end and
* wait for it to finish
*/
random_kthread_control = -1;
tsleep((void *)&random_kthread_control, PUSER, "term", 0);
/* Destroy the harvest fifos */
while (!STAILQ_EMPTY(&emptyfifo.head)) {
np = STAILQ_FIRST(&emptyfifo.head);
STAILQ_REMOVE_HEAD(&emptyfifo.head, next);
free(np, M_ENTROPY);
}
mtx_destroy(&emptyfifo.lock);
for (i = 0; i < ENTROPYSOURCE; i++) {
while (!STAILQ_EMPTY(&harvestfifo[i].head)) {
np = STAILQ_FIRST(&harvestfifo[i].head);
STAILQ_REMOVE_HEAD(&harvestfifo[i].head, next);
free(np, M_ENTROPY);
}
mtx_destroy(&harvestfifo[i].lock);
}
random_deinit();
(*random_systat.deinit)();
free(random_buf, M_TEMP);
mtx_destroy(&random_systat.lock);
destroy_dev(random_dev);
return 0;
break;
case MOD_SHUTDOWN:
return 0;
break;
default:
return EOPNOTSUPP;
}
return (error);
}
DEV_MODULE(random, random_modevent, NULL);
/* ARGSUSED */
static void
random_kthread(void *arg __unused)
{
struct harvest *event = NULL;
int found, active;
enum esource source;
/* Process until told to stop */
for (; random_kthread_control == 0;) {
active = 0;
/* Cycle through all the entropy sources */
for (source = 0; source < ENTROPYSOURCE; source++) {
found = 0;
/* Lock up queue draining */
mtx_lock_spin(&harvestfifo[source].lock);
if (!STAILQ_EMPTY(&harvestfifo[source].head)) {
/* Get a harvested entropy event */
harvestfifo[source].count--;
event = STAILQ_FIRST(&harvestfifo[source].head);
STAILQ_REMOVE_HEAD(&harvestfifo[source].head,
next);
active = found = 1;
}
/* Unlock the queue */
mtx_unlock_spin(&harvestfifo[source].lock);
/* Deal with the event and dispose of it */
if (found) {
random_process_event(event);
/* Lock the empty event buffer fifo */
mtx_lock_spin(&emptyfifo.lock);
STAILQ_INSERT_TAIL(&emptyfifo.head, event, next);
mtx_unlock_spin(&emptyfifo.lock);
}
}
/* Found nothing, so don't belabour the issue */
if (!active)
tsleep(&harvestfifo, PUSER, "-", hz/10);
}
random_set_wakeup_exit(&random_kthread_control);
/* NOTREACHED */
}
/* Entropy harvesting routine. This is supposed to be fast; do
* not do anything slow in here!
*/
static void
random_harvest_internal(u_int64_t somecounter, void *entropy, u_int count,
u_int bits, u_int frac, enum esource origin)
{
struct harvest *event;
/* Lock the particular fifo */
mtx_lock_spin(&harvestfifo[origin].lock);
/* Don't make the harvest queues too big - help to prevent
* low-grade entropy swamping
*/
if (harvestfifo[origin].count < RANDOM_FIFO_MAX) {
/* Lock the empty event buffer fifo */
mtx_lock_spin(&emptyfifo.lock);
if (!STAILQ_EMPTY(&emptyfifo.head)) {
event = STAILQ_FIRST(&emptyfifo.head);
STAILQ_REMOVE_HEAD(&emptyfifo.head, next);
}
else
event = NULL;
mtx_unlock_spin(&emptyfifo.lock);
/* If we didn't obtain a buffer, tough */
if (event) {
/* Add the harvested data to the fifo */
harvestfifo[origin].count++;
event->somecounter = somecounter;
event->size = count;
event->bits = bits;
event->frac = frac;
event->source = origin;
/* XXXX Come back and make this dynamic! */
count = count > HARVESTSIZE ? HARVESTSIZE : count;
memcpy(event->entropy, entropy, count);
STAILQ_INSERT_TAIL(&harvestfifo[origin].head, event, next);
}
}
mtx_unlock_spin(&harvestfifo[origin].lock);
}
static void
random_write_internal(void *buf, int count)
{
int i;
u_int chunk;
/* Break the input up into HARVESTSIZE chunks.
* The writer has too much control here, so "estimate" the
* the entropy as zero.
*/
for (i = 0; i < count; i += HARVESTSIZE) {
chunk = HARVESTSIZE;
if (i + chunk >= count)
chunk = (u_int)(count - i);
random_harvest_internal(get_cyclecount(), (char *)buf + i,
chunk, 0, 0, RANDOM_WRITE);
}
}
void
random_unblock(void)
{
if (!random_systat.seeded) {
random_systat.seeded = 1;
selwakeuppri(&random_systat.rsel, PUSER);
wakeup(&random_systat);
}
}

70
sys/dev/random/randomdev.h
View File

@ -1,5 +1,5 @@
/*-
* Copyright (c) 2001 Mark R V Murray
* Copyright (c) 2000-2004 Mark R V Murray
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@ -30,57 +30,25 @@
* and non algorithm-specific for the entropy processor
*/
/* #define ENTROPYSOURCE nn entropy sources (actually classes)
* This is properly defined in
* an enum in sys/random.h
*/
typedef void random_init_func_t(void);
typedef void random_deinit_func_t(void);
typedef int random_read_func_t(void *, int);
typedef void random_write_func_t(void *, int);
typedef void random_reseed_func_t(void);
/* Cryptographic block size in bits */
#define BLOCKSIZE 256
/* The ring size _MUST_ be a power of 2 */
#define HARVEST_RING_SIZE 1024 /* harvest ring buffer size */
#define HARVEST_RING_MASK (HARVEST_RING_SIZE - 1)
#define HARVESTSIZE 16 /* max size of each harvested entropy unit */
SYSCTL_DECL(_kern_random);
MALLOC_DECLARE(M_ENTROPY);
/* These are used to queue harvested packets of entropy. The entropy
* buffer size is pretty arbitrary.
*/
struct harvest {
uintmax_t somecounter; /* fast counter for clock jitter */
u_char entropy[HARVESTSIZE]; /* the harvested entropy */
u_int size, bits, frac; /* stats about the entropy */
enum esource source; /* stats about the entropy */
STAILQ_ENTRY(harvest) next; /* next item on the list */
struct random_systat {
struct selinfo rsel;
const char *ident;
int seeded;
random_init_func_t *init;
random_deinit_func_t *deinit;
random_read_func_t *read;
random_write_func_t *write;
random_reseed_func_t *reseed;
struct mtx lock;
};
void random_init(void);
void random_deinit(void);
void random_init_harvester(void (*)(u_int64_t, void *, u_int, u_int, u_int, enum esource), int (*)(void *, int));
void random_deinit_harvester(void);
void random_set_wakeup_exit(void *);
void random_process_event(struct harvest *event);
void random_reseed(void);
void random_unblock(void);
extern struct random_systat random_systat;
int read_random_real(void *, int);
/* If this was c++, this would be a template */
#define RANDOM_CHECK_UINT(name, min, max) \
static int \
random_check_uint_##name(SYSCTL_HANDLER_ARGS) \
{ \
if (oidp->oid_arg1 != NULL) { \
if (*(u_int *)(oidp->oid_arg1) <= (min)) \
*(u_int *)(oidp->oid_arg1) = (min); \
else if (*(u_int *)(oidp->oid_arg1) > (max)) \
*(u_int *)(oidp->oid_arg1) = (max); \
} \
return sysctl_handle_int(oidp, oidp->oid_arg1, oidp->oid_arg2, \
req); \
}
extern void random_ident_hardware(struct random_systat *);
extern void random_null_func(void);

369
sys/dev/random/randomdev_soft.c Normal file
View File

@ -0,0 +1,369 @@
/*-
* Copyright (c) 2000-2004 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.
*
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/bus.h>
#include <sys/conf.h>
#include <sys/fcntl.h>
#include <sys/kernel.h>
#include <sys/kthread.h>
#include <sys/lock.h>
#include <sys/malloc.h>
#include <sys/mutex.h>
#include <sys/poll.h>
#include <sys/proc.h>
#include <sys/random.h>
#include <sys/selinfo.h>
#include <sys/sysctl.h>
#include <sys/uio.h>
#include <sys/unistd.h>
#include <sys/vnode.h>
#include <machine/bus.h>
#include <machine/cpu.h>
#include <dev/random/randomdev.h>
#include <dev/random/randomdev_soft.h>
#define RANDOM_FIFO_MAX 256 /* How many events to queue up */
static void random_kthread(void *);
static void
random_harvest_internal(u_int64_t, const void *, u_int,
u_int, u_int, enum esource);
struct random_systat random_yarrow = {
.ident = "Software, Yarrow",
.init = random_yarrow_init,
.deinit = random_yarrow_deinit,
.read = random_yarrow_read,
.write = random_yarrow_write,
.reseed = random_yarrow_reseed,
.seeded = 0,
};
MALLOC_DEFINE(M_ENTROPY, "entropy", "Entropy harvesting buffers");
/* Lockable FIFO queue holding entropy buffers */
struct entropyfifo {
struct mtx lock;
int count;
STAILQ_HEAD(harvestlist, harvest) head;
};
/* Empty entropy buffers */
static struct entropyfifo emptyfifo;
#define EMPTYBUFFERS 1024
/* Harvested entropy */
static struct entropyfifo harvestfifo[ENTROPYSOURCE];
/* <0 to end the kthread, 0 to let it run */
static int random_kthread_control = 0;
static struct proc *random_kthread_proc;
/* List for the dynamic sysctls */
struct sysctl_ctx_list random_clist;
/* ARGSUSED */
static int
random_check_boolean(SYSCTL_HANDLER_ARGS)
{
if (oidp->oid_arg1 != NULL && *(u_int *)(oidp->oid_arg1) != 0)
*(u_int *)(oidp->oid_arg1) = 1;
return sysctl_handle_int(oidp, oidp->oid_arg1, oidp->oid_arg2, req);
}
/* ARGSUSED */
void
random_yarrow_init(void)
{
int error, i;
struct harvest *np;
struct sysctl_oid *o, *random_o, *random_sys_o, *random_sys_harvest_o;
enum esource e;
o = SYSCTL_ADD_NODE(&random_clist,
SYSCTL_STATIC_CHILDREN(_kern),
OID_AUTO, "random", CTLFLAG_RW, 0,
"Software Random Number Generator");
random_o = o;
random_yarrow_init_alg(&random_clist, random_o);
o = SYSCTL_ADD_NODE(&random_clist,
SYSCTL_CHILDREN(random_o),
OID_AUTO, "sys", CTLFLAG_RW, 0,
"Entropy Device Parameters");
random_sys_o = o;
o = SYSCTL_ADD_PROC(&random_clist,
SYSCTL_CHILDREN(random_sys_o),
OID_AUTO, "seeded", CTLTYPE_INT | CTLFLAG_RW,
&random_systat.seeded, 0, random_check_boolean, "I",
"Seeded State");
o = SYSCTL_ADD_NODE(&random_clist,
SYSCTL_CHILDREN(random_sys_o),
OID_AUTO, "harvest", CTLFLAG_RW, 0,
"Entropy Sources");
random_sys_harvest_o = o;
o = SYSCTL_ADD_PROC(&random_clist,
SYSCTL_CHILDREN(random_sys_harvest_o),
OID_AUTO, "ethernet", CTLTYPE_INT | CTLFLAG_RW,
&harvest.ethernet, 0, random_check_boolean, "I",
"Harvest NIC entropy");
o = SYSCTL_ADD_PROC(&random_clist,
SYSCTL_CHILDREN(random_sys_harvest_o),
OID_AUTO, "point_to_point", CTLTYPE_INT | CTLFLAG_RW,
&harvest.point_to_point, 0, random_check_boolean, "I",
"Harvest serial net entropy");
o = SYSCTL_ADD_PROC(&random_clist,
SYSCTL_CHILDREN(random_sys_harvest_o),
OID_AUTO, "interrupt", CTLTYPE_INT | CTLFLAG_RW,
&harvest.interrupt, 0, random_check_boolean, "I",
"Harvest IRQ entropy");
o = SYSCTL_ADD_PROC(&random_clist,
SYSCTL_CHILDREN(random_sys_harvest_o),
OID_AUTO, "swi", CTLTYPE_INT | CTLFLAG_RW,
&harvest.swi, 0, random_check_boolean, "I",
"Harvest SWI entropy");
/* Initialise the harvest fifos */
STAILQ_INIT(&emptyfifo.head);
emptyfifo.count = 0;
mtx_init(&emptyfifo.lock, "entropy harvest buffers", NULL, MTX_SPIN);
for (i = 0; i < EMPTYBUFFERS; i++) {
np = malloc(sizeof(struct harvest), M_ENTROPY, M_WAITOK);
STAILQ_INSERT_TAIL(&emptyfifo.head, np, next);
}
for (e = RANDOM_START; e < ENTROPYSOURCE; e++) {
STAILQ_INIT(&harvestfifo[e].head);
harvestfifo[e].count = 0;
mtx_init(&harvestfifo[e].lock, "entropy harvest", NULL,
MTX_SPIN);
}
/* Start the hash/reseed thread */
error = kthread_create(random_kthread, NULL,
&random_kthread_proc, RFHIGHPID, 0, "yarrow");
if (error != 0)
panic("Cannot create entropy maintenance thread.");
/* Register the randomness harvesting routine */
random_yarrow_init_harvester(random_harvest_internal,
random_yarrow_read);
}
/* ARGSUSED */
void
random_yarrow_deinit(void)
{
struct harvest *np;
enum esource e;
/* Deregister the randomness harvesting routine */
random_yarrow_deinit_harvester();
/*
* Command the hash/reseed thread to end and wait for it to finish
*/
random_kthread_control = -1;
tsleep((void *)&random_kthread_control, PUSER, "term", 0);
/* Destroy the harvest fifos */
while (!STAILQ_EMPTY(&emptyfifo.head)) {
np = STAILQ_FIRST(&emptyfifo.head);
STAILQ_REMOVE_HEAD(&emptyfifo.head, next);
free(np, M_ENTROPY);
}
mtx_destroy(&emptyfifo.lock);
for (e = RANDOM_START; e < ENTROPYSOURCE; e++) {
while (!STAILQ_EMPTY(&harvestfifo[e].head)) {
np = STAILQ_FIRST(&harvestfifo[e].head);
STAILQ_REMOVE_HEAD(&harvestfifo[e].head, next);
free(np, M_ENTROPY);
}
mtx_destroy(&harvestfifo[e].lock);
}
random_yarrow_deinit_alg();
sysctl_ctx_free(&random_clist);
}
/* ARGSUSED */
static void
random_kthread(void *arg __unused)
{
struct harvest *event = NULL;
int found, active;
enum esource source;
/* Process until told to stop */
for (; random_kthread_control == 0;) {
active = 0;
/* Cycle through all the entropy sources */
for (source = RANDOM_START; source < ENTROPYSOURCE; source++) {
found = 0;
/* Lock up queue draining */
mtx_lock_spin(&harvestfifo[source].lock);
if (!STAILQ_EMPTY(&harvestfifo[source].head)) {
/* Get a harvested entropy event */
harvestfifo[source].count--;
event = STAILQ_FIRST(&harvestfifo[source].head);
STAILQ_REMOVE_HEAD(&harvestfifo[source].head,
next);
active = found = 1;
}
/* Unlock the queue */
mtx_unlock_spin(&harvestfifo[source].lock);
/* Deal with the event and dispose of it */
if (found) {
random_process_event(event);
/* Lock the empty event buffer fifo */
mtx_lock_spin(&emptyfifo.lock);
STAILQ_INSERT_TAIL(&emptyfifo.head, event,
next);
mtx_unlock_spin(&emptyfifo.lock);
}
}
/* Found nothing, so don't belabour the issue */
if (!active)
tsleep(&harvestfifo, PUSER, "-", hz / 10);
}
random_set_wakeup_exit(&random_kthread_control);
/* NOTREACHED */
}
/* Entropy harvesting routine. This is supposed to be fast; do
* not do anything slow in here!
*/
static void
random_harvest_internal(u_int64_t somecounter, const void *entropy,
u_int count, u_int bits, u_int frac, enum esource origin)
{
struct harvest *event;
/* Lock the particular fifo */
mtx_lock_spin(&harvestfifo[origin].lock);
/*
* Don't make the harvest queues too big - help to prevent low-grade
* entropy swamping
*/
if (harvestfifo[origin].count < RANDOM_FIFO_MAX) {
/* Lock the empty event buffer fifo */
mtx_lock_spin(&emptyfifo.lock);
if (!STAILQ_EMPTY(&emptyfifo.head)) {
event = STAILQ_FIRST(&emptyfifo.head);
STAILQ_REMOVE_HEAD(&emptyfifo.head, next);
} else
event = NULL;
mtx_unlock_spin(&emptyfifo.lock);
/* If we didn't obtain a buffer, tough */
if (event) {
/* Add the harvested data to the fifo */
harvestfifo[origin].count++;
event->somecounter = somecounter;
event->size = count;
event->bits = bits;
event->frac = frac;
event->source = origin;
/* XXXX Come back and make this dynamic! */
count = MIN(count, HARVESTSIZE);
memcpy(event->entropy, entropy, count);
STAILQ_INSERT_TAIL(&harvestfifo[origin].head,
event, next);
}
}
mtx_unlock_spin(&harvestfifo[origin].lock);
}
void
random_yarrow_write(void *buf, int count)
{
int i;
u_int chunk;
/*
* Break the input up into HARVESTSIZE chunks. The writer has too
* much control here, so "estimate" the the entropy as zero.
*/
for (i = 0; i < count; i += HARVESTSIZE) {
chunk = HARVESTSIZE;
if (i + chunk >= count)
chunk = (u_int)(count - i);
random_harvest_internal(get_cyclecount(), (char *)buf + i,
chunk, 0, 0, RANDOM_WRITE);
}
}
void
random_yarrow_unblock(void)
{
if (!random_systat.seeded) {
random_systat.seeded = 1;
selwakeuppri(&random_systat.rsel, PUSER);
wakeup(&random_systat);
}
}

93
sys/dev/random/randomdev_soft.h Normal file
View File

@ -0,0 +1,93 @@
/*-
* Copyright (c) 2000-2004 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$
*/
/* This header contains only those definitions that are global
* and harvester-specific for the entropy processor
*/
/* #define ENTROPYSOURCE nn entropy sources (actually classes)
* This is properly defined in
* an enum in sys/random.h
*/
/* Cryptographic block size in bits */
#define BLOCKSIZE 256
/* The ring size _MUST_ be a power of 2 */
#define HARVEST_RING_SIZE 1024 /* harvest ring buffer size */
#define HARVEST_RING_MASK (HARVEST_RING_SIZE - 1)
#define HARVESTSIZE 16 /* max size of each harvested entropy unit */
MALLOC_DECLARE(M_ENTROPY);
/* These are used to queue harvested packets of entropy. The entropy
* buffer size is pretty arbitrary.
*/
struct harvest {
uintmax_t somecounter; /* fast counter for clock jitter */
u_char entropy[HARVESTSIZE]; /* the harvested entropy */
u_int size, bits, frac; /* stats about the entropy */
enum esource source; /* stats about the entropy */
STAILQ_ENTRY(harvest) next; /* next item on the list */
};
void random_yarrow_init(void);
void random_yarrow_deinit(void);
int random_yarrow_read(void *, int);
void random_yarrow_write(void *, int);
void random_yarrow_init_harvester(void (*)(u_int64_t, const void *, u_int,
u_int, u_int, enum esource), int (*)(void *, int));
void random_yarrow_deinit_harvester(void);
void random_set_wakeup_exit(void *);
void random_process_event(struct harvest *event);
void random_yarrow_reseed(void);
void random_yarrow_unblock(void);
void random_yarrow_init_alg(struct sysctl_ctx_list *, struct sysctl_oid *);
void random_yarrow_deinit_alg(void);
extern struct random_systat random_yarrow;
/* If this was c++, this would be a template */
#define RANDOM_CHECK_UINT(name, min, max) \
static int \
random_check_uint_##name(SYSCTL_HANDLER_ARGS) \
{ \
if (oidp->oid_arg1 != NULL) { \
if (*(u_int *)(oidp->oid_arg1) <= (min)) \
*(u_int *)(oidp->oid_arg1) = (min); \
else if (*(u_int *)(oidp->oid_arg1) > (max)) \
*(u_int *)(oidp->oid_arg1) = (max); \
} \
return sysctl_handle_int(oidp, oidp->oid_arg1, oidp->oid_arg2, \
req); \
}

76
sys/dev/random/yarrow.c
View File

@ -1,5 +1,5 @@
/*-
* Copyright (c) 2000, 2001, 2002, 2003 Mark R V Murray
* Copyright (c) 2000-2004 Mark R V Murray
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@ -41,7 +41,7 @@ __FBSDID("$FreeBSD$");
#include <crypto/sha2/sha2.h>
#include <dev/random/hash.h>
#include <dev/random/randomdev.h>
#include <dev/random/randomdev_soft.h>
#include <dev/random/yarrow.h>
RANDOM_CHECK_UINT(gengateinterval, 4, 64);
@ -53,23 +53,6 @@ RANDOM_CHECK_UINT(slowoverthresh, 1, 5);
/* Structure holding the entropy state */
static struct random_state random_state;
SYSCTL_NODE(_kern_random, OID_AUTO, yarrow, CTLFLAG_RW, 0, "Yarrow Parameters");
SYSCTL_PROC(_kern_random_yarrow, OID_AUTO, gengateinterval,
CTLTYPE_INT|CTLFLAG_RW, &random_state.gengateinterval, 10,
random_check_uint_gengateinterval, "I", "Generator Gate Interval");
SYSCTL_PROC(_kern_random_yarrow, OID_AUTO, bins,
CTLTYPE_INT|CTLFLAG_RW, &random_state.bins, 10,
random_check_uint_bins, "I", "Execution time tuner");
SYSCTL_PROC(_kern_random_yarrow, OID_AUTO, fastthresh,
CTLTYPE_INT|CTLFLAG_RW, &random_state.pool[0].thresh, (3*BLOCKSIZE)/4,
random_check_uint_fastthresh, "I", "Fast reseed threshold");
SYSCTL_PROC(_kern_random_yarrow, OID_AUTO, slowthresh,
CTLTYPE_INT|CTLFLAG_RW, &random_state.pool[1].thresh, BLOCKSIZE,
random_check_uint_slowthresh, "I", "Slow reseed threshold");
SYSCTL_PROC(_kern_random_yarrow, OID_AUTO, slowoverthresh,
CTLTYPE_INT|CTLFLAG_RW, &random_state.slowoverthresh, 2,
random_check_uint_slowoverthresh, "I", "Slow over-threshold reseed");
static void generator_gate(void);
static void reseed(u_int);
@ -118,13 +101,56 @@ random_process_event(struct harvest *event)
}
void
random_init(void)
random_yarrow_init_alg(struct sysctl_ctx_list *clist, struct sysctl_oid *in_o)
{
int i;
struct sysctl_oid *o, *random_yarrow_o;
/* Yarrow parameters. Do not adjust these unless you have
* have a very good clue about what they do!
*/
o = SYSCTL_ADD_NODE(clist,
SYSCTL_CHILDREN(in_o),
OID_AUTO, "yarrow", CTLFLAG_RW, 0,
"Yarrow Parameters");
random_yarrow_o = o;
o = SYSCTL_ADD_PROC(clist,
SYSCTL_CHILDREN(random_yarrow_o), OID_AUTO,
"gengateinterval", CTLTYPE_INT|CTLFLAG_RW,
&random_state.gengateinterval, 10,
random_check_uint_gengateinterval, "I",
"Generation gate interval");
o = SYSCTL_ADD_PROC(clist,
SYSCTL_CHILDREN(random_yarrow_o), OID_AUTO,
"bins", CTLTYPE_INT|CTLFLAG_RW,
&random_state.bins, 10,
random_check_uint_bins, "I",
"Execution time tuner");
o = SYSCTL_ADD_PROC(clist,
SYSCTL_CHILDREN(random_yarrow_o), OID_AUTO,
"fastthresh", CTLTYPE_INT|CTLFLAG_RW,
&random_state.pool[0].thresh, (3*BLOCKSIZE)/4,
random_check_uint_fastthresh, "I",
"Fast reseed threshold");
o = SYSCTL_ADD_PROC(clist,
SYSCTL_CHILDREN(random_yarrow_o), OID_AUTO,
"slowthresh", CTLTYPE_INT|CTLFLAG_RW,
&random_state.pool[1].thresh, BLOCKSIZE,
random_check_uint_slowthresh, "I",
"Slow reseed threshold");
o = SYSCTL_ADD_PROC(clist,
SYSCTL_CHILDREN(random_yarrow_o), OID_AUTO,
"slowoverthresh", CTLTYPE_INT|CTLFLAG_RW,
&random_state.slowoverthresh, 2,
random_check_uint_slowoverthresh, "I",
"Slow over-threshold reseed");
random_state.gengateinterval = 10;
random_state.bins = 10;
random_state.pool[0].thresh = (3*BLOCKSIZE)/4;
@ -145,7 +171,7 @@ random_init(void)
}
void
random_deinit(void)
random_yarrow_deinit_alg(void)
{
mtx_destroy(&random_reseed_mtx);
}
@ -236,12 +262,12 @@ reseed(u_int fastslow)
mtx_unlock(&random_reseed_mtx);
/* Unblock the device if it was blocked due to being unseeded */
random_unblock();
random_yarrow_unblock();
}
/* Internal function to return processed entropy from the PRNG */
int
read_random_real(void *buf, int count)
random_yarrow_read(void *buf, int count)
{
static int cur = 0;
static int gate = 1;
@ -289,7 +315,7 @@ read_random_real(void *buf, int count)
retval = count;
}
else {
retval = cur < count ? cur : count;
retval = MIN(cur, count);
memcpy(buf,
&genval[(int)sizeof(random_state.counter) - cur],
(size_t)retval);
@ -319,7 +345,7 @@ generator_gate(void)
/* Helper routine to perform explicit reseeds */
void
random_reseed(void)
random_yarrow_reseed(void)
{
reseed(SLOW);
}

2
sys/dev/random/yarrow.h
View File

@ -1,5 +1,5 @@
/*-
* Copyright (c) 2000 Mark R V Murray
* Copyright (c) 2000-2004 Mark R V Murray
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without

4
sys/modules/random/Makefile
View File

@ -5,7 +5,9 @@
.PATH: ${.CURDIR}/../../crypto/sha2
KMOD= random
SRCS= randomdev.c yarrow.c hash.c
SRCS= randomdev.c probe.c
SRCS+= nehemiah.c
SRCS+= randomdev_soft.c yarrow.c hash.c
SRCS+= rijndael-alg-fst.c rijndael-api-fst.c sha2.c
SRCS+= bus_if.h device_if.h vnode_if.h