mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-27 19:29:37 +00:00
![Jason A. Donenfeld](/assets/img/avatar_default.png)
Most hw_random devices return entropy which is assumed to be of full quality, but driver authors don't bother setting the quality knob. Some hw_random devices return less than full quality entropy, and then driver authors set the quality knob. Therefore, the entropy crediting should be opt-out rather than opt-in per-driver, to reflect the actual reality on the ground. For example, the two Raspberry Pi RNG drivers produce full entropy randomness, and both EDK2 and U-Boot's drivers for these treat them as such. The result is that EFI then uses these numbers and passes the to Linux, and Linux credits them as boot, thereby initializing the RNG. Yet, in Linux, the quality knob was never set to anything, and so on the chance that Linux is booted without EFI, nothing is ever credited. That's annoying. The same pattern appears to repeat itself throughout various drivers. In fact, very very few drivers have bothered setting quality=1024. Looking at the git history of existing drivers and corresponding mailing list discussion, this conclusion tracks. There's been a decent amount of discussion about drivers that set quality < 1024 -- somebody read and interepreted a datasheet, or made some back of the envelope calculation somehow. But there's been very little, if any, discussion about most drivers where the quality is just set to 1024 or unset (or set to 1000 when the authors misunderstood the API and assumed it was base-10 rather than base-2); in both cases the intent was fairly clear of, "this is a hardware random device; it's fine." So let's invert this logic. A hw_random struct's quality knob now controls the maximum quality a driver can produce, or 0 to specify 1024. Then, the module-wide switch called "default_quality" is changed to represent the maximum quality of any driver. By default it's 1024, and the quality of any particular driver is then given by: min(default_quality, rng->quality ?: 1024); This way, the user can still turn this off for weird reasons (and we can replace whatever driver-specific disabling hacks existed in the past), yet we get proper crediting for relevant RNGs. Cc: Dominik Brodowski <linux@dominikbrodowski.net> Cc: Ard Biesheuvel <ardb@kernel.org> Cc: Herbert Xu <herbert@gondor.apana.org.au> Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com> Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
121 lines
2.5 KiB
C
121 lines
2.5 KiB
C
/* Copyright (C) 2005 - 2008 Jeff Dike <jdike@{linux.intel,addtoit}.com> */
|
|
|
|
/* Much of this ripped from drivers/char/hw_random.c, see there for other
|
|
* copyright.
|
|
*
|
|
* This software may be used and distributed according to the terms
|
|
* of the GNU General Public License, incorporated herein by reference.
|
|
*/
|
|
#include <linux/sched/signal.h>
|
|
#include <linux/module.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/miscdevice.h>
|
|
#include <linux/hw_random.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/uaccess.h>
|
|
#include <init.h>
|
|
#include <irq_kern.h>
|
|
#include <os.h>
|
|
|
|
/*
|
|
* core module information
|
|
*/
|
|
#define RNG_MODULE_NAME "hw_random"
|
|
|
|
/* Changed at init time, in the non-modular case, and at module load
|
|
* time, in the module case. Presumably, the module subsystem
|
|
* protects against a module being loaded twice at the same time.
|
|
*/
|
|
static int random_fd = -1;
|
|
static struct hwrng hwrng;
|
|
static DECLARE_COMPLETION(have_data);
|
|
|
|
static int rng_dev_read(struct hwrng *rng, void *buf, size_t max, bool block)
|
|
{
|
|
int ret;
|
|
|
|
for (;;) {
|
|
ret = os_read_file(random_fd, buf, max);
|
|
if (block && ret == -EAGAIN) {
|
|
add_sigio_fd(random_fd);
|
|
|
|
ret = wait_for_completion_killable(&have_data);
|
|
|
|
ignore_sigio_fd(random_fd);
|
|
deactivate_fd(random_fd, RANDOM_IRQ);
|
|
|
|
if (ret < 0)
|
|
break;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
return ret != -EAGAIN ? ret : 0;
|
|
}
|
|
|
|
static irqreturn_t random_interrupt(int irq, void *data)
|
|
{
|
|
complete(&have_data);
|
|
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
/*
|
|
* rng_init - initialize RNG module
|
|
*/
|
|
static int __init rng_init (void)
|
|
{
|
|
int err;
|
|
|
|
err = os_open_file("/dev/random", of_read(OPENFLAGS()), 0);
|
|
if (err < 0)
|
|
goto out;
|
|
|
|
random_fd = err;
|
|
err = um_request_irq(RANDOM_IRQ, random_fd, IRQ_READ, random_interrupt,
|
|
0, "random", NULL);
|
|
if (err < 0)
|
|
goto err_out_cleanup_hw;
|
|
|
|
sigio_broken(random_fd);
|
|
hwrng.name = RNG_MODULE_NAME;
|
|
hwrng.read = rng_dev_read;
|
|
|
|
err = hwrng_register(&hwrng);
|
|
if (err) {
|
|
pr_err(RNG_MODULE_NAME " registering failed (%d)\n", err);
|
|
goto err_out_cleanup_hw;
|
|
}
|
|
out:
|
|
return err;
|
|
|
|
err_out_cleanup_hw:
|
|
os_close_file(random_fd);
|
|
random_fd = -1;
|
|
goto out;
|
|
}
|
|
|
|
/*
|
|
* rng_cleanup - shutdown RNG module
|
|
*/
|
|
|
|
static void cleanup(void)
|
|
{
|
|
free_irq_by_fd(random_fd);
|
|
os_close_file(random_fd);
|
|
}
|
|
|
|
static void __exit rng_cleanup(void)
|
|
{
|
|
hwrng_unregister(&hwrng);
|
|
os_close_file(random_fd);
|
|
}
|
|
|
|
module_init (rng_init);
|
|
module_exit (rng_cleanup);
|
|
__uml_exitcall(cleanup);
|
|
|
|
MODULE_DESCRIPTION("UML Host Random Number Generator (RNG) driver");
|
|
MODULE_LICENSE("GPL");
|