1/*-
2 * Copyright (c) 2013 Arthur Mesh <arthurmesh@gmail.com>
3 * Copyright (c) 2013 David E. O'Brien <obrien@NUXI.org>
4 * Copyright (c) 2013 Mark R V Murray
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer
12 *    in this position and unchanged.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 *    notice, this list of conditions and the following disclaimer in the
15 *    documentation and/or other materials provided with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29#include <sys/param.h>
30__FBSDID("$FreeBSD$");
31
32#include <sys/systm.h>
33#include <sys/kernel.h>
34#include <sys/kthread.h>
35#include <sys/libkern.h>
36#include <sys/lock.h>
37#include <sys/malloc.h>
38#include <sys/queue.h>
39#include <sys/random.h>
40#include <sys/selinfo.h>
41#include <sys/sx.h>
42#include <sys/sysctl.h>
43#include <sys/unistd.h>
44
45#include <dev/random/randomdev.h>
46#include <dev/random/randomdev_soft.h>
47#include <dev/random/random_adaptors.h>
48
49LIST_HEAD(adaptors_head, random_adaptors);
50static struct adaptors_head adaptors = LIST_HEAD_INITIALIZER(adaptors);
51static struct sx adaptors_lock; /* need a sleepable lock */
52
53/* List for the dynamic sysctls */
54static struct sysctl_ctx_list random_clist;
55
56struct random_adaptor *random_adaptor;
57
58MALLOC_DEFINE(M_ENTROPY, "entropy", "Entropy harvesting buffers and data structures");
59
60int
61random_adaptor_register(const char *name, struct random_adaptor *rsp)
62{
63	struct random_adaptors *rpp;
64
65	KASSERT(name != NULL && rsp != NULL, ("invalid input to %s", __func__));
66
67	rpp = malloc(sizeof(struct random_adaptors), M_ENTROPY, M_WAITOK);
68	rpp->name = name;
69	rpp->rsp = rsp;
70
71	sx_xlock(&adaptors_lock);
72	LIST_INSERT_HEAD(&adaptors, rpp, entries);
73	sx_xunlock(&adaptors_lock);
74
75	return (0);
76}
77
78struct random_adaptor *
79random_adaptor_get(const char *name)
80{
81	struct random_adaptors	*rpp;
82	struct random_adaptor	*rsp;
83
84	rsp = NULL;
85
86	sx_slock(&adaptors_lock);
87
88	LIST_FOREACH(rpp, &adaptors, entries)
89		if (strcmp(rpp->name, name) == 0)
90			rsp = rpp->rsp;
91
92	sx_sunlock(&adaptors_lock);
93
94	return (rsp);
95}
96
97/*
98 * Walk a list of registered random(4) adaptors and pick the last non-selected
99 * one.
100 *
101 * If none are selected, use yarrow if available.
102 */
103void
104random_adaptor_choose(struct random_adaptor **adaptor)
105{
106	char			 rngs[128], *token, *cp;
107	struct random_adaptors	*rppi, *ramax;
108	unsigned		 primax;
109
110	KASSERT(adaptor != NULL, ("pre-conditions failed"));
111
112	*adaptor = NULL;
113	if (TUNABLE_STR_FETCH("kern.random.active_adaptor", rngs, sizeof(rngs))) {
114		cp = rngs;
115
116		while ((token = strsep(&cp, ",")) != NULL)
117			if ((*adaptor = random_adaptor_get(token)) != NULL)
118				break;
119			else if (bootverbose)
120				printf("%s random adaptor is not available,"
121				    " skipping\n", token);
122	}
123
124	primax = 0U;
125	if (*adaptor == NULL) {
126		/*
127		 * Fall back to the highest priority item on the available
128		 * RNG list.
129		 */
130		sx_slock(&adaptors_lock);
131
132		ramax = NULL;
133		LIST_FOREACH(rppi, &adaptors, entries) {
134			if (rppi->rsp->priority >= primax) {
135				ramax = rppi;
136				primax = rppi->rsp->priority;
137			}
138		}
139		if (ramax != NULL)
140			*adaptor = ramax->rsp;
141
142		sx_sunlock(&adaptors_lock);
143
144		if (bootverbose && *adaptor)
145			printf("Falling back to <%s> random adaptor\n",
146			    (*adaptor)->ident);
147	}
148}
149
150static void
151random_adaptors_deinit(void *unused)
152{
153
154	sx_destroy(&adaptors_lock);
155	sysctl_ctx_free(&random_clist);
156}
157
158static int
159random_sysctl_adaptors_handler(SYSCTL_HANDLER_ARGS)
160{
161	struct random_adaptors	*rpp;
162	int error, count;
163
164	count = error = 0;
165
166	sx_slock(&adaptors_lock);
167
168	if (LIST_EMPTY(&adaptors))
169		error = SYSCTL_OUT(req, "", 0);
170	else {
171		LIST_FOREACH(rpp, &adaptors, entries) {
172
173			error = SYSCTL_OUT(req, ",", count++ ? 1 : 0);
174			if (error)
175				break;
176
177			error = SYSCTL_OUT(req, rpp->name, strlen(rpp->name));
178			if (error)
179				break;
180		}
181	}
182
183	sx_sunlock(&adaptors_lock);
184
185	return (error);
186}
187
188static int
189random_sysctl_active_adaptor_handler(SYSCTL_HANDLER_ARGS)
190{
191	struct random_adaptor	*rsp;
192	struct random_adaptors	*rpp;
193	const char		*name;
194	int error;
195
196	name = NULL;
197	rsp = random_adaptor;
198
199	if (rsp != NULL) {
200		sx_slock(&adaptors_lock);
201
202		LIST_FOREACH(rpp, &adaptors, entries)
203			if (rpp->rsp == rsp)
204				name = rpp->name;
205
206		sx_sunlock(&adaptors_lock);
207	}
208
209	if (rsp == NULL || name == NULL)
210		error = SYSCTL_OUT(req, "", 0);
211	else
212		error = SYSCTL_OUT(req, name, strlen(name));
213
214	return (error);
215}
216
217static void
218random_adaptors_init(void *unused)
219{
220
221	SYSCTL_PROC(_kern_random, OID_AUTO, adaptors,
222	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE,
223	    NULL, 0, random_sysctl_adaptors_handler, "",
224	    "Random Number Generator adaptors");
225
226	SYSCTL_PROC(_kern_random, OID_AUTO, active_adaptor,
227	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE,
228	    NULL, 0, random_sysctl_active_adaptor_handler, "",
229	    "Active Random Number Generator Adaptor");
230
231	sx_init(&adaptors_lock, "random_adaptors");
232}
233
234SYSCTL_NODE(_kern, OID_AUTO, random, CTLFLAG_RW, 0, "Random Number Generator");
235
236SYSINIT(random_adaptors, SI_SUB_DRIVERS, SI_ORDER_FIRST, random_adaptors_init,
237    NULL);
238SYSUNINIT(random_adaptors, SI_SUB_DRIVERS, SI_ORDER_FIRST,
239    random_adaptors_deinit, NULL);
240
241static void
242random_adaptors_reseed(void *unused)
243{
244
245	(void)unused;
246	if (random_adaptor != NULL)
247		(*random_adaptor->reseed)();
248	arc4rand(NULL, 0, 1);
249}
250SYSINIT(random_reseed, SI_SUB_INTRINSIC_POST, SI_ORDER_SECOND,
251    random_adaptors_reseed, NULL);
252