random: use chacha20 for get_random_int/long
Jason A. Donenfeld
maintainerPATCH 1/2 random: use chacha20 for get_random_int/long
Now that our crng uses chacha20, we can rely on its speedy characteristics for replacing MD5, while simultaneously achieving a higher security guarantee. Before the idea was to use these functions if you wanted random integers that aren't stupidly insecure but aren't necessarily secure either, a vague gray zone, that hopefully was "good enough" for its users. With chacha20, we can strengthen this claim, since either we're using an rdrand-like instruction, or we're using the same crng as /dev/urandom. And it's faster than what was before.
We could have chosen to replace this with a SipHash-derived function, which might be slightly faster, but at the cost of having yet another RNG construction in the kernel. By moving to chacha20, we have a single RNG to analyze and verify, and we also already get good performance improvements on all platforms.
Implementation-wise, rather than use a generic buffer for both get_random_int/long and memcpy based on the size needs, we use a specific buffer for 32-bit reads and for 64-bit reads. This way, we're guaranteed to always have aligned accesses on all platforms. While slightly more verbose in C, the assembly this generates is a lot simpler than otherwise.
Finally, on 32-bit platforms where longs and ints are the same size, we simply alias get_random_int to get_random_long.
--- drivers/char/random.c | 84 ++++++++++++++++++++++++++------------------------ include/linux/random.h | 1 - init/main.c | 1 - 3 files changed, 43 insertions(+), 43 deletions(-)
drivers/char/random.c +43 -41
@@ -2042,63 +2042,65 @@ struct ctl_table random_table[] = { };#endif /* CONFIG_SYSCTL */ -static u32 random_int_secret[MD5_MESSAGE_BYTES /4 ]____cacheline_aligned ; - -int random_int_secret_init (void ) -{ -get_random_bytes (random_int_secret,sizeof (random_int_secret)); -return 0 ; -} - -static DEFINE_PER_CPU(__u32 [MD5_DIGEST_WORDS], get_random_int_hash) -__aligned(sizeof(unsigned long)) ; +struct batched_entropy { +union { +unsigned long entropy_long[CHACHA20_BLOCK_SIZE /sizeof (unsigned long )]; +unsigned int entropy_int[CHACHA20_BLOCK_SIZE /sizeof (unsigned int )]; + }; +unsigned int position; +};/* -* Get a random word for internal kernel use only. Similar to urandom but -* with the goal of minimal entropy pool depletion. As a result, the random -* value is not cryptographically secure but for several uses the cost of -* depleting entropy is too high +* Get a random word for internal kernel use only. The quality of the random +* number is either as good as RDRAND or as good as /dev/urandom, with the +* goal of being quite fast and not depleting entropy. */ -unsigned int get_random_int (void ) +static DEFINE_PER_CPU(struct batched_entropy, batched_entropy_long); +unsigned long get_random_long (void ) { -__u32 *hash; -unsigned int ret; +unsigned long ret; +struct batched_entropy *batch; -if (arch_get_random_int (&ret)) +if (arch_get_random_long (&ret))return ret; - hash =get_cpu_var (get_random_int_hash); - - hash[0 ] += current->pid + jiffies +random_get_entropy (); -md5_transform (hash, random_int_secret); - ret = hash[0 ]; -put_cpu_var (get_random_int_hash); - + batch = &get_cpu_var (batched_entropy_long); +if (batch->position %ARRAY_SIZE (batch->entropy_long) ==0 ) { +extract_crng ((u8 *)batch->entropy_long); + batch->position =0 ; + } + ret = batch->entropy_long[batch->position++]; +put_cpu_var (batched_entropy_long);return ret; } -EXPORT_SYMBOL (get_random_int); +EXPORT_SYMBOL (get_random_long); -/* -* Same as get_random_int(), but returns unsigned long. -*/ -unsigned long get_random_long (void ) +#if BITS_PER_LONG ==32 +unsigned int get_random_int (void ) { -__u32 *hash; -unsigned long ret; +return get_random_long (); +} +#else +static DEFINE_PER_CPU(struct batched_entropy, batched_entropy_int); +unsigned int get_random_int (void ) +{ +unsigned int ret; +struct batched_entropy *batch; -if (arch_get_random_long (&ret)) +if (arch_get_random_int (&ret))return ret; - hash =get_cpu_var (get_random_int_hash); - - hash[0 ] += current->pid + jiffies +random_get_entropy (); -md5_transform (hash, random_int_secret); - ret = *(unsigned long *)hash; -put_cpu_var (get_random_int_hash); - + batch = &get_cpu_var (batched_entropy_int); +if (batch->position %ARRAY_SIZE (batch->entropy_int) ==0 ) { +extract_crng ((u8 *)batch->entropy_int); + batch->position =0 ; + } + ret = batch->entropy_int[batch->position++]; +put_cpu_var (batched_entropy_int);return ret; } -EXPORT_SYMBOL (get_random_long); +#endif +EXPORT_SYMBOL (get_random_int);/** * randomize_page - Generate a random, page aligned address
include/linux/random.h +0 -1
@@ -37,7 +37,6 @@ extern void get_random_bytes(void *buf, int nbytes);extern int add_random_ready_callback (struct random_ready_callback *rdy);extern void del_random_ready_callback (struct random_ready_callback *rdy);extern void get_random_bytes_arch (void *buf,int nbytes); -extern int random_int_secret_init (void );#ifndef MODULE extern const struct file_operations random_fops, urandom_fops;
init/main.c +0 -1
@@ -880,7 +880,6 @@ static void __init do_basic_setup(void)do_ctors ();usermodehelper_enable ();do_initcalls (); -random_int_secret_init (); }static void __init do_pre_smp_initcalls (void )
Signature · 1 line
2.11.0
Jason A. Donenfeld
maintainerPATCH 2/2 random: convert get_random_int/long into get_random_u32/u64
Many times, when a user wants a random number, he wants a random number of a guaranteed size. So, thinking of get_random_int and get_random_long in terms of get_random_u32 and get_random_u64 makes it much easier to achieve this. It also makes the code simpler.
On 32-bit platforms, get_random_int and get_random_long are both aliased to get_random_u32. On 64-bit platforms, int->u32 and long->u64.
---
I personally would find this extremely useful in my own code, where I currently wind up doing something ugly like:
(u64)get_random_int() << 32 | get_random_int()
But if you have some aversion, don't hesitate to just take 1/2 without this 2/2. But hopefully you'll like this 2/2.
drivers/char/random.c | 55 +++++++++++++++++++++++++------------------------- include/linux/random.h | 17 ++++++++++++++-- 2 files changed, 42 insertions(+), 30 deletions(-)
drivers/char/random.c +27 -28
@@ -2044,8 +2044,8 @@ struct ctl_table random_table[] = {struct batched_entropy {union { -unsigned long entropy_long[CHACHA20_BLOCK_SIZE /sizeof (unsigned long )]; -unsigned int entropy_int[CHACHA20_BLOCK_SIZE /sizeof (unsigned int )]; +u64 entropy_u64[CHACHA20_BLOCK_SIZE /sizeof (u64)]; +u32 entropy_u32[CHACHA20_BLOCK_SIZE /sizeof (u32)]; };unsigned int position; };
@@ -2055,52 +2055,51 @@ struct batched_entropy {* number is either as good as RDRAND or as good as /dev/urandom, with the * goal of being quite fast and not depleting entropy. */ -static DEFINE_PER_CPU(struct batched_entropy, batched_entropy_long); -unsigned long get_random_long (void ) +static DEFINE_PER_CPU(struct batched_entropy, batched_entropy_u64); +u64 get_random_u64 (void ) { -unsigned long ret; +u64 ret;struct batched_entropy *batch; -if (arch_get_random_long (&ret)) +#if BITS_PER_LONG ==64 +if (arch_get_random_long ((unsigned long *)&ret))return ret; +#else +if (arch_get_random_long ((unsigned long *)&ret) && +arch_get_random_long ((unsigned long *)&ret +1 )) +return ret; +#endif - batch = &get_cpu_var (batched_entropy_long); -if (batch->position %ARRAY_SIZE (batch->entropy_long) ==0 ) { -extract_crng ((u8 *)batch->entropy_long); + batch = &get_cpu_var (batched_entropy_u64); +if (batch->position %ARRAY_SIZE (batch->entropy_u64) ==0 ) { +extract_crng ((u8 *)batch->entropy_u64); batch->position =0 ; } - ret = batch->entropy_long[batch->position++]; -put_cpu_var (batched_entropy_long); + ret = batch->entropy_u64[batch->position++]; +put_cpu_var (batched_entropy_u64);return ret; } -EXPORT_SYMBOL (get_random_long); +EXPORT_SYMBOL (get_random_u64); -#if BITS_PER_LONG ==32 -unsigned int get_random_int (void ) -{ -return get_random_long (); -} -#else -static DEFINE_PER_CPU(struct batched_entropy, batched_entropy_int); -unsigned int get_random_int (void ) +static DEFINE_PER_CPU(struct batched_entropy, batched_entropy_u32); +u32 get_random_u32 (void ) { -unsigned int ret; +u32 ret;struct batched_entropy *batch;if (arch_get_random_int (&ret))return ret; - batch = &get_cpu_var (batched_entropy_int); -if (batch->position %ARRAY_SIZE (batch->entropy_int) ==0 ) { -extract_crng ((u8 *)batch->entropy_int); + batch = &get_cpu_var (batched_entropy_u32); +if (batch->position %ARRAY_SIZE (batch->entropy_u32) ==0 ) { +extract_crng ((u8 *)batch->entropy_u32); batch->position =0 ; } - ret = batch->entropy_int[batch->position++]; -put_cpu_var (batched_entropy_int); + ret = batch->entropy_u32[batch->position++]; +put_cpu_var (batched_entropy_u32);return ret; } -#endif -EXPORT_SYMBOL (get_random_int); +EXPORT_SYMBOL (get_random_u32);/** * randomize_page - Generate a random, page aligned address
include/linux/random.h +15 -2
@@ -42,8 +42,21 @@ extern void get_random_bytes_arch(void *buf, int nbytes);extern const struct file_operations random_fops, urandom_fops;#endif -unsigned int get_random_int (void ); -unsigned long get_random_long (void ); +u32 get_random_u32 (void ); +u64 get_random_u64 (void ); +static inline unsigned int get_random_int (void ) +{ +return get_random_u32 (); +} +static inline unsigned long get_random_long (void ) +{ +#if BITS_PER_LONG ==64 +return get_random_u64 (); +#else +return get_random_u32 (); +#endif +} +unsigned long randomize_page (unsigned long start,unsigned long range);u32 prandom_u32 (void );
Signature · 1 line
2.11.0