gcc-plugins: latent_entropy: use /dev/urandom
PATCH 1/1 gcc-plugins: latent_entropy: use /dev/urandom
commit c40160f2998c897231f8454bf797558d30a20375 upstream.
While the latent entropy plugin mostly doesn't derive entropy from get_random_const() for measuring the call graph, when __latent_entropy is applied to a constant, then it's initialized statically to output from get_random_const(). In that case, this data is derived from a 64-bit seed, which means a buffer of 512 bits doesn't really have that amount of compile-time entropy.
This patch fixes that shortcoming by just buffering chunks of /dev/urandom output and doling it out as requested.
At the same time, it's important that we don't break the use of -frandom-seed, for people who want the runtime benefits of the latent entropy plugin, while still having compile-time determinism. In that case, we detect whether gcc's set_random_seed() has been called by making a call to get_random_seed(noinit=true) in the plugin init function, which is called after set_random_seed() is called but before anything that calls get_random_seed(noinit=false), and seeing if it's zero or not. If it's not zero, we're in deterministic mode, and so we just generate numbers with a basic xorshift prng.
Note that we don't detect if -frandom-seed is being used using the documented local_tick variable, because it's assigned via:
local_tick = (unsigned) tv.tv_sec * 1000 + tv.tv_usec / 1000;
which may well overflow and become -1 on its own, and so isn't
reliable: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105171
[kees: The 256 byte rnd_buf size was chosen based on average (250),
median (64), and std deviation (575) bytes of used entropy for a defconfig x86_64 build]
--- scripts/gcc-plugins/latent_entropy_plugin.c | 44 +++++++++++++-------- 1 file changed, 27 insertions(+), 17 deletions(-)
scripts/gcc-plugins/latent_entropy_plugin.c +27 -17
@@ -86,25 +86,31 @@ static struct plugin_info latent_entropy_plugin_info = { .help = "disable\tturn off latent entropy instrumentation\n", }; -static unsigned HOST_WIDE_INT seed; -/* -* get_random_seed() (this is a GCC function) generates the seed. -* This is a simple random generator without any cryptographic security because -* the entropy doesn't come from here. -*/ +static unsigned HOST_WIDE_INT deterministic_seed; +static unsigned HOST_WIDE_INT rnd_buf[32 ]; +static size_t rnd_idx =ARRAY_SIZE (rnd_buf); +static int urandom_fd =-1 ; +static unsigned HOST_WIDE_INT get_random_const (void ) { -unsigned int i; -unsigned HOST_WIDE_INT ret =0 ; - -for (i =0 ; i <8 *sizeof (ret); i++) { - ret = (ret <<1 ) | (seed &1 ); - seed >>=1 ; -if (ret &1 ) - seed ^=0xD800000000000000ULL ; +if (deterministic_seed) { +unsigned HOST_WIDE_INT w = deterministic_seed; + w ^= w <<13 ; + w ^= w >>7 ; + w ^= w <<17 ; + deterministic_seed = w; +return deterministic_seed; } -return ret; +if (urandom_fd <0 ) { + urandom_fd =open ("/dev/urandom" ,O_RDONLY ); +gcc_assert (urandom_fd >=0 ); + } +if (rnd_idx >=ARRAY_SIZE (rnd_buf)) { +gcc_assert (read (urandom_fd, rnd_buf,sizeof (rnd_buf)) ==sizeof (rnd_buf)); + rnd_idx =0 ; + } +return rnd_buf[rnd_idx++]; }static tree tree_get_random_const (tree type)
@@ -556,8 +562,6 @@ static void latent_entropy_start_unit(void *gcc_data __unused,tree type, id;int quals; - seed =get_random_seed (false); -if (in_lto_p)return ;
@@ -594,6 +598,12 @@ __visible int plugin_init(struct plugin_name_args *plugin_info,struct register_pass_info latent_entropy_pass_info; +/* +* Call get_random_seed() with noinit=true, so that this returns +* 0 in the case where no seed has been passed via -frandom-seed. +*/ + deterministic_seed =get_random_seed (true); + latent_entropy_pass_info.pass =make_latent_entropy_pass (); latent_entropy_pass_info.reference_pass_name ="optimized" ; latent_entropy_pass_info.ref_pass_instance_number =1 ;
Signature · 1 line
2.35.1
Quoted 39 lines · Jason A. Donenfeld
commit
c40160f2998c897231f8454bf797558d30a20375upstream.While the latent entropy plugin mostly doesn't derive entropy from
get_random_const()for measuring the call graph, when__latent_entropyis applied to a constant, then it's initialized statically to output fromget_random_const(). In that case, this data is derived from a 64-bit seed, which means a buffer of 512 bits doesn't really have that amount of compile-time entropy.This patch fixes that shortcoming by just buffering chunks of
/dev/urandomoutput and doling it out as requested.At the same time, it's important that we don't break the use of -frandom-seed, for people who want the runtime benefits of the latent entropy plugin, while still having compile-time determinism. In that case, we detect whether gcc's
set_random_seed()has been called by making a call toget_random_seed(noinit=true)in the plugin init function, which is called afterset_random_seed()is called but before anything that callsget_random_seed(noinit=false), and seeing if it's zero or not. If it's not zero, we're in deterministic mode, and so we just generate numbers with a basic xorshift prng.Note that we don't detect if -frandom-seed is being used using the documented
local_tickvariable, because it's assigned via:local_tick = (unsigned) tv.tv_sec * 1000 + tv.tv_usec / 1000;which may well overflow and become -1 on its own, and so isn't
reliable: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105171[kees: The 256 byte
rnd_bufsize was chosen based on average (250),
median (64), and std deviation (575) bytes of used entropy for a defconfigx86_64build]Fixes 38addce8b600 ("gcc-plugins: Add latent_entropy plugin")Cc PaX Team <[email protected]>Signed-off-by Jason A. Donenfeld <[email protected]>Signed-off-by Kees Cook <[email protected]>Signed-off-by Jason A. Donenfeld <[email protected]>
Quoted 3 lines
--- scripts/gcc-plugins/latent_entropy_plugin.c | 44 +++++++++++++-------- 1 file changed, 27 insertions(+), 17 deletions(-)
Queued this one up now instead, thanks for the backport!
greg k-h