xref: /freebsd/sys/dev/random/randomdev.c (revision 817420dc8eac7df799c78f5309b75092b7f7cd40)
1 /*-
2  * Copyright (c) 2000 Mark R V Murray
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer
10  *    in this position and unchanged.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  *
26  * $FreeBSD$
27  */
28 
29 #include <sys/param.h>
30 #include <sys/queue.h>
31 #include <sys/systm.h>
32 #include <sys/conf.h>
33 #include <sys/fcntl.h>
34 #include <sys/uio.h>
35 #include <sys/kernel.h>
36 #include <sys/malloc.h>
37 #include <sys/module.h>
38 #include <sys/bus.h>
39 #include <sys/poll.h>
40 #include <sys/select.h>
41 #include <sys/random.h>
42 #include <sys/vnode.h>
43 #include <machine/bus.h>
44 #include <machine/resource.h>
45 #include <sys/sysctl.h>
46 #include <crypto/blowfish/blowfish.h>
47 
48 #include <dev/random/hash.h>
49 #include <dev/random/yarrow.h>
50 
51 #include "opt_noblockrandom.h"
52 
53 static d_open_t random_open;
54 static d_read_t random_read;
55 static d_write_t random_write;
56 static d_ioctl_t random_ioctl;
57 static d_poll_t random_poll;
58 
59 #define CDEV_MAJOR	2
60 #define RANDOM_MINOR	3
61 #define URANDOM_MINOR	4
62 
63 static struct cdevsw random_cdevsw = {
64 	/* open */	random_open,
65 	/* close */	(d_close_t *)nullop,
66 	/* read */	random_read,
67 	/* write */	random_write,
68 	/* ioctl */	random_ioctl,
69 	/* poll */	random_poll,
70 	/* mmap */	nommap,
71 	/* strategy */	nostrategy,
72 	/* name */	"random",
73 	/* maj */	CDEV_MAJOR,
74 	/* dump */	nodump,
75 	/* psize */	nopsize,
76 	/* flags */	0,
77 	/* bmaj */	-1
78 };
79 
80 /* For use with make_dev(9)/destroy_dev(9). */
81 static dev_t random_dev;
82 static dev_t urandom_dev; /* XXX Temporary */
83 
84 SYSCTL_NODE(_kern, OID_AUTO, random, CTLFLAG_RW, 0, "Random Number Generator");
85 SYSCTL_NODE(_kern_random, OID_AUTO, yarrow, CTLFLAG_RW, 0, "Yarrow Parameters");
86 SYSCTL_INT(_kern_random_yarrow, OID_AUTO, gengateinterval, CTLFLAG_RW,
87 	&random_state.gengateinterval, 10, "Generator Gate Interval");
88 SYSCTL_INT(_kern_random_yarrow, OID_AUTO, bins, CTLFLAG_RW,
89 	&random_state.bins, 10, "Execution time tuner");
90 SYSCTL_INT(_kern_random_yarrow, OID_AUTO, fastthresh, CTLFLAG_RW,
91 	&random_state.pool[0].thresh, 100, "Fast pool reseed threshhold");
92 SYSCTL_INT(_kern_random_yarrow, OID_AUTO, slowthresh, CTLFLAG_RW,
93 	&random_state.pool[1].thresh, 160, "Slow pool reseed threshhold");
94 SYSCTL_INT(_kern_random_yarrow, OID_AUTO, slowoverthresh, CTLFLAG_RW,
95 	&random_state.slowoverthresh, 2, "Slow pool over-threshhold reseed");
96 
97 static int
98 random_open(dev_t dev, int flags, int fmt, struct proc *p)
99 {
100 	if ((flags & FWRITE) && (securelevel > 0 || suser(p)))
101 		return EPERM;
102 	else
103 		return 0;
104 }
105 
106 static int
107 random_read(dev_t dev, struct uio *uio, int flag)
108 {
109 	u_int c, ret;
110 	int error = 0;
111 	void *random_buf;
112 
113 /* XXX Temporary ifndef to allow users to have a nonblocking device */
114 #ifndef NOBLOCKRANDOM
115 	while (!random_state.seeded) {
116 		if (flag & IO_NDELAY)
117 			error =  EWOULDBLOCK;
118 		else
119 			error = tsleep(&random_state, PUSER|PCATCH, "rndblk", 0);
120 		if (error != 0)
121 			return error;
122 	}
123 #endif
124 	c = min(uio->uio_resid, PAGE_SIZE);
125 	random_buf = (void *)malloc(c, M_TEMP, M_WAITOK);
126 	while (uio->uio_resid > 0 && error == 0) {
127 		ret = read_random_real(random_buf, c);
128 		error = uiomove(random_buf, ret, uio);
129 	}
130 	free(random_buf, M_TEMP);
131 	return error;
132 }
133 
134 static int
135 random_write(dev_t dev, struct uio *uio, int flag)
136 {
137 	u_int c;
138 	int error = 0;
139 	void *random_buf;
140 
141 	random_buf = (void *)malloc(PAGE_SIZE, M_TEMP, M_WAITOK);
142 	while (uio->uio_resid > 0) {
143 		c = min(uio->uio_resid, PAGE_SIZE);
144 		error = uiomove(random_buf, c, uio);
145 		if (error)
146 			break;
147 		write_random(random_buf, c);
148 	}
149 	free(random_buf, M_TEMP);
150 	return error;
151 }
152 
153 static int
154 random_ioctl(dev_t dev, u_long cmd, caddr_t addr, int flags, struct proc *p)
155 {
156 	return ENOTTY;
157 }
158 
159 static int
160 random_poll(dev_t dev, int events, struct proc *p)
161 {
162 	int revents;
163 
164 	revents = 0;
165 	if (events & (POLLIN | POLLRDNORM)) {
166 		if (random_state.seeded)
167 			revents = events & (POLLIN | POLLRDNORM);
168 		else
169 			selrecord(p, &random_state.rsel);
170 	}
171 	return revents;
172 }
173 
174 static int
175 random_modevent(module_t mod, int type, void *data)
176 {
177 	int error;
178 
179 	switch(type) {
180 	case MOD_LOAD:
181 		error = random_init();
182 		if (error != 0)
183 			return error;
184 		if (bootverbose)
185 			printf("random: <entropy source>\n");
186 		random_dev = make_dev(&random_cdevsw, RANDOM_MINOR, UID_ROOT,
187 			GID_WHEEL, 0666, "random");
188 		urandom_dev = make_dev(&random_cdevsw, URANDOM_MINOR, UID_ROOT,
189 			GID_WHEEL, 0666, "urandom"); /* XXX Temporary */
190 		return 0;
191 
192 	case MOD_UNLOAD:
193 		random_deinit();
194 		destroy_dev(random_dev);
195 		destroy_dev(urandom_dev); /* XXX Temporary */
196 		return 0;
197 
198 	case MOD_SHUTDOWN:
199 		return 0;
200 
201 	default:
202 		return EOPNOTSUPP;
203 	}
204 }
205 
206 DEV_MODULE(random, random_modevent, NULL);
207