1128059Smarkm/*- 2255362Smarkm * Copyright (c) 2000-2013 Mark R V Murray 3136338Srwatson * Copyright (c) 2004 Robert N. M. Watson 4128059Smarkm * All rights reserved. 5128059Smarkm * 6128059Smarkm * Redistribution and use in source and binary forms, with or without 7128059Smarkm * modification, are permitted provided that the following conditions 8128059Smarkm * are met: 9128059Smarkm * 1. Redistributions of source code must retain the above copyright 10128059Smarkm * notice, this list of conditions and the following disclaimer 11128059Smarkm * in this position and unchanged. 12128059Smarkm * 2. Redistributions in binary form must reproduce the above copyright 13128059Smarkm * notice, this list of conditions and the following disclaimer in the 14128059Smarkm * documentation and/or other materials provided with the distribution. 15128059Smarkm * 16128059Smarkm * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 17128059Smarkm * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 18128059Smarkm * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 19128059Smarkm * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 20128059Smarkm * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 21128059Smarkm * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 22128059Smarkm * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 23128059Smarkm * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24128059Smarkm * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 25128059Smarkm * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26128059Smarkm * 27128059Smarkm */ 28128059Smarkm 29256381Smarkm#include "opt_random.h" 30256381Smarkm 31256381Smarkm#if !defined(RANDOM_YARROW) && !defined(RANDOM_FORTUNA) 32256381Smarkm#define RANDOM_YARROW 33256381Smarkm#elif defined(RANDOM_YARROW) && defined(RANDOM_FORTUNA) 34256381Smarkm#error "Must define either RANDOM_YARROW or RANDOM_FORTUNA" 35255362Smarkm#endif 36256381Smarkm#if defined(RANDOM_FORTUNA) 37256381Smarkm#error "Fortuna is not yet implemented" 38256381Smarkm#endif 39255362Smarkm 40128059Smarkm#include <sys/cdefs.h> 41128059Smarkm__FBSDID("$FreeBSD$"); 42128059Smarkm 43128059Smarkm#include <sys/param.h> 44128059Smarkm#include <sys/systm.h> 45128059Smarkm#include <sys/fcntl.h> 46128059Smarkm#include <sys/kernel.h> 47128059Smarkm#include <sys/lock.h> 48128059Smarkm#include <sys/malloc.h> 49254147Sobrien#include <sys/module.h> 50128059Smarkm#include <sys/mutex.h> 51128059Smarkm#include <sys/poll.h> 52128059Smarkm#include <sys/random.h> 53128059Smarkm#include <sys/selinfo.h> 54128059Smarkm#include <sys/sysctl.h> 55128059Smarkm#include <sys/uio.h> 56128059Smarkm#include <sys/unistd.h> 57128059Smarkm 58128059Smarkm#include <machine/bus.h> 59128059Smarkm#include <machine/cpu.h> 60128059Smarkm 61128059Smarkm#include <dev/random/randomdev.h> 62128059Smarkm#include <dev/random/randomdev_soft.h> 63256381Smarkm#include <dev/random/random_harvestq.h> 64256381Smarkm#include <dev/random/random_adaptors.h> 65256381Smarkm#if defined(RANDOM_YARROW) 66255362Smarkm#include <dev/random/yarrow.h> 67255362Smarkm#endif 68256381Smarkm#if defined(RANDOM_FORTUNA) 69255362Smarkm#include <dev/random/fortuna.h> 70255362Smarkm#endif 71128059Smarkm 72128059Smarkm 73255362Smarkmstatic int randomdev_poll(int event, struct thread *td); 74255362Smarkmstatic int randomdev_block(int flag); 75255362Smarkmstatic void randomdev_flush_reseed(void); 76128059Smarkm 77256381Smarkm#if defined(RANDOM_YARROW) 78255362Smarkmstatic struct random_adaptor random_context = { 79128059Smarkm .ident = "Software, Yarrow", 80255362Smarkm .init = randomdev_init, 81255362Smarkm .deinit = randomdev_deinit, 82255362Smarkm .block = randomdev_block, 83128059Smarkm .read = random_yarrow_read, 84255362Smarkm .poll = randomdev_poll, 85255362Smarkm .reseed = randomdev_flush_reseed, 86256381Smarkm .seeded = 0, /* This will be seeded during entropy processing */ 87256414Smarkm .priority = 90, /* High priority, so top of the list. Fortuna may still win. */ 88128059Smarkm}; 89255362Smarkm#define RANDOM_MODULE_NAME yarrow 90255362Smarkm#define RANDOM_CSPRNG_NAME "yarrow" 91255362Smarkm#endif 92128059Smarkm 93256381Smarkm#if defined(RANDOM_FORTUNA) 94255362Smarkmstatic struct random_adaptor random_context = { 95255362Smarkm .ident = "Software, Fortuna", 96255362Smarkm .init = randomdev_init, 97255362Smarkm .deinit = randomdev_deinit, 98255362Smarkm .block = randomdev_block, 99255362Smarkm .read = random_fortuna_read, 100255362Smarkm .poll = randomdev_poll, 101255362Smarkm .reseed = randomdev_flush_reseed, 102256381Smarkm .seeded = 0, /* This will be excplicitly seeded at startup when secured */ 103256414Smarkm .priority = 100, /* High priority, so top of the list. Beat Yarrow. */ 104128059Smarkm}; 105255362Smarkm#define RANDOM_MODULE_NAME fortuna 106255362Smarkm#define RANDOM_CSPRNG_NAME "fortuna" 107255362Smarkm#endif 108128059Smarkm 109256381SmarkmTUNABLE_INT("kern.random.sys.seeded", &random_context.seeded); 110256381Smarkm 111128059Smarkm/* List for the dynamic sysctls */ 112254147Sobrienstatic struct sysctl_ctx_list random_clist; 113128059Smarkm 114128059Smarkm/* ARGSUSED */ 115128059Smarkmstatic int 116128059Smarkmrandom_check_boolean(SYSCTL_HANDLER_ARGS) 117128059Smarkm{ 118128059Smarkm if (oidp->oid_arg1 != NULL && *(u_int *)(oidp->oid_arg1) != 0) 119128059Smarkm *(u_int *)(oidp->oid_arg1) = 1; 120256381Smarkm return (sysctl_handle_int(oidp, oidp->oid_arg1, oidp->oid_arg2, req)); 121128059Smarkm} 122128059Smarkm 123128059Smarkmvoid 124255362Smarkmrandomdev_init(void) 125128059Smarkm{ 126254147Sobrien struct sysctl_oid *random_sys_o, *random_sys_harvest_o; 127128059Smarkm 128256381Smarkm#if defined(RANDOM_YARROW) 129254147Sobrien random_yarrow_init_alg(&random_clist); 130255362Smarkm#endif 131256381Smarkm#if defined(RANDOM_FORTUNA) 132255362Smarkm random_fortuna_init_alg(&random_clist); 133255362Smarkm#endif 134128059Smarkm 135170067Srwatson random_sys_o = SYSCTL_ADD_NODE(&random_clist, 136254147Sobrien SYSCTL_STATIC_CHILDREN(_kern_random), 137128059Smarkm OID_AUTO, "sys", CTLFLAG_RW, 0, 138128059Smarkm "Entropy Device Parameters"); 139128059Smarkm 140170067Srwatson SYSCTL_ADD_PROC(&random_clist, 141128059Smarkm SYSCTL_CHILDREN(random_sys_o), 142128059Smarkm OID_AUTO, "seeded", CTLTYPE_INT | CTLFLAG_RW, 143256381Smarkm &random_context.seeded, 0, random_check_boolean, "I", 144128059Smarkm "Seeded State"); 145128059Smarkm 146170067Srwatson random_sys_harvest_o = SYSCTL_ADD_NODE(&random_clist, 147128059Smarkm SYSCTL_CHILDREN(random_sys_o), 148128059Smarkm OID_AUTO, "harvest", CTLFLAG_RW, 0, 149128059Smarkm "Entropy Sources"); 150128059Smarkm 151170067Srwatson SYSCTL_ADD_PROC(&random_clist, 152128059Smarkm SYSCTL_CHILDREN(random_sys_harvest_o), 153128059Smarkm OID_AUTO, "ethernet", CTLTYPE_INT | CTLFLAG_RW, 154128320Smarkm &harvest.ethernet, 1, random_check_boolean, "I", 155128059Smarkm "Harvest NIC entropy"); 156170067Srwatson SYSCTL_ADD_PROC(&random_clist, 157128059Smarkm SYSCTL_CHILDREN(random_sys_harvest_o), 158128059Smarkm OID_AUTO, "point_to_point", CTLTYPE_INT | CTLFLAG_RW, 159128320Smarkm &harvest.point_to_point, 1, random_check_boolean, "I", 160128059Smarkm "Harvest serial net entropy"); 161170067Srwatson SYSCTL_ADD_PROC(&random_clist, 162128059Smarkm SYSCTL_CHILDREN(random_sys_harvest_o), 163128059Smarkm OID_AUTO, "interrupt", CTLTYPE_INT | CTLFLAG_RW, 164256381Smarkm &harvest.interrupt, 1, random_check_boolean, "I", 165128059Smarkm "Harvest IRQ entropy"); 166170067Srwatson SYSCTL_ADD_PROC(&random_clist, 167128059Smarkm SYSCTL_CHILDREN(random_sys_harvest_o), 168128059Smarkm OID_AUTO, "swi", CTLTYPE_INT | CTLFLAG_RW, 169256381Smarkm &harvest.swi, 1, random_check_boolean, "I", 170128059Smarkm "Harvest SWI entropy"); 171128059Smarkm 172255362Smarkm random_harvestq_init(random_process_event); 173128059Smarkm 174128059Smarkm /* Register the randomness harvesting routine */ 175255362Smarkm randomdev_init_harvester(random_harvestq_internal, 176255362Smarkm random_context.read); 177128059Smarkm} 178128059Smarkm 179128059Smarkmvoid 180255362Smarkmrandomdev_deinit(void) 181128059Smarkm{ 182128059Smarkm /* Deregister the randomness harvesting routine */ 183255362Smarkm randomdev_deinit_harvester(); 184128059Smarkm 185128059Smarkm /* 186128059Smarkm * Command the hash/reseed thread to end and wait for it to finish 187128059Smarkm */ 188128059Smarkm random_kthread_control = -1; 189157815Sjhb tsleep((void *)&random_kthread_control, 0, "term", 0); 190128059Smarkm 191256381Smarkm#if defined(RANDOM_YARROW) 192128059Smarkm random_yarrow_deinit_alg(); 193255362Smarkm#endif 194256381Smarkm#if defined(RANDOM_FORTUNA) 195255362Smarkm random_fortuna_deinit_alg(); 196255362Smarkm#endif 197128059Smarkm 198128059Smarkm sysctl_ctx_free(&random_clist); 199128059Smarkm} 200128059Smarkm 201128059Smarkmvoid 202255362Smarkmrandomdev_unblock(void) 203128059Smarkm{ 204255362Smarkm if (!random_context.seeded) { 205255362Smarkm selwakeuppri(&random_context.rsel, PUSER); 206255362Smarkm wakeup(&random_context); 207256381Smarkm printf("random: unblocking device.\n"); 208256381Smarkm random_context.seeded = 1; 209128059Smarkm } 210256381Smarkm /* Do arc4random(9) a favour while we are about it. */ 211249631Sache (void)atomic_cmpset_int(&arc4rand_iniseed_state, ARC4_ENTR_NONE, 212249631Sache ARC4_ENTR_HAVE); 213128059Smarkm} 214153575Sps 215153575Spsstatic int 216255362Smarkmrandomdev_poll(int events, struct thread *td) 217153575Sps{ 218153575Sps int revents = 0; 219256381Smarkm 220153575Sps mtx_lock(&random_reseed_mtx); 221153575Sps 222255362Smarkm if (random_context.seeded) 223153575Sps revents = events & (POLLIN | POLLRDNORM); 224153575Sps else 225255362Smarkm selrecord(td, &random_context.rsel); 226192774Smarkm 227153575Sps mtx_unlock(&random_reseed_mtx); 228256381Smarkm return (revents); 229153575Sps} 230153575Sps 231153575Spsstatic int 232255362Smarkmrandomdev_block(int flag) 233153575Sps{ 234153575Sps int error = 0; 235153575Sps 236153575Sps mtx_lock(&random_reseed_mtx); 237153575Sps 238153575Sps /* Blocking logic */ 239255362Smarkm while (!random_context.seeded && !error) { 240153575Sps if (flag & O_NONBLOCK) 241153575Sps error = EWOULDBLOCK; 242153575Sps else { 243256381Smarkm printf("random: blocking on read.\n"); 244255362Smarkm error = msleep(&random_context, 245153575Sps &random_reseed_mtx, 246153575Sps PUSER | PCATCH, "block", 0); 247153575Sps } 248153575Sps } 249153575Sps mtx_unlock(&random_reseed_mtx); 250153575Sps 251256381Smarkm return (error); 252192774Smarkm} 253185254Scperciva 254185254Scperciva/* Helper routine to perform explicit reseeds */ 255185254Scpercivastatic void 256255362Smarkmrandomdev_flush_reseed(void) 257185254Scperciva{ 258185254Scperciva /* Command a entropy queue flush and wait for it to finish */ 259185254Scperciva random_kthread_control = 1; 260185254Scperciva while (random_kthread_control) 261185254Scperciva pause("-", hz / 10); 262185254Scperciva 263256381Smarkm#if defined(RANDOM_YARROW) 264256381Smarkm /* This ultimately calls randomdev_unblock() */ 265185254Scperciva random_yarrow_reseed(); 266255362Smarkm#endif 267256381Smarkm#if defined(RANDOM_FORTUNA) 268256381Smarkm /* This ultimately calls randomdev_unblock() */ 269255362Smarkm random_fortuna_reseed(); 270255362Smarkm#endif 271185254Scperciva} 272254147Sobrien 273254147Sobrienstatic int 274256381Smarkmrandomdev_modevent(module_t mod __unused, int type, void *unused __unused) 275254147Sobrien{ 276254147Sobrien 277254147Sobrien switch (type) { 278254147Sobrien case MOD_LOAD: 279255362Smarkm random_adaptor_register(RANDOM_CSPRNG_NAME, &random_context); 280254147Sobrien /* 281254147Sobrien * For statically built kernels that contain both device 282254147Sobrien * random and options PADLOCK_RNG/RDRAND_RNG/etc.., 283254147Sobrien * this event handler will do nothing, since the random 284254147Sobrien * driver-specific handlers are loaded after these HW 285254147Sobrien * consumers, and hence hasn't yet registered for this event. 286254147Sobrien * 287254147Sobrien * In case where both the random driver and RNG's are built 288254147Sobrien * as seperate modules, random.ko is loaded prior to *_rng.ko's 289254147Sobrien * (by dependency). This event handler is there to delay 290254147Sobrien * creation of /dev/{u,}random and attachment of this *_rng.ko. 291254147Sobrien */ 292255362Smarkm EVENTHANDLER_INVOKE(random_adaptor_attach, &random_context); 293254147Sobrien return (0); 294254147Sobrien } 295254147Sobrien 296254147Sobrien return (EINVAL); 297254147Sobrien} 298254147Sobrien 299255362SmarkmRANDOM_ADAPTOR_MODULE(RANDOM_MODULE_NAME, randomdev_modevent, 1); 300