random: only read from /dev/random after its pool has received 128 bits

commit eb9d1bf079bb438d1a066d72337092935fc770f6 upstream.

Immediately after boot, we allow reads from /dev/random before its
entropy pool has been fully initialized.  Fix this so that we don't
allow this until the blocking pool has received 128 bits.

We do this by repurposing the initialized flag in the entropy pool
struct, and use the initialized flag in the blocking pool to indicate
whether it is safe to pull from the blocking pool.

To do this, we needed to rework when we decide to push entropy from the
input pool to the blocking pool, since the initialized flag for the
input pool was used for this purpose.  To simplify things, we no
longer use the initialized flag for that purpose, nor do we use the
entropy_total field any more.

Signed-off-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/drivers/char/random.c b/drivers/char/random.c
index 7712b44740fcc6c1c8472142e7e7a3c908692e8e..f7cc1df8bdfdc77bbb2e62c8f3270e224b5692e9 100644 (file)
--- a/drivers/char/random.c
+++ b/drivers/char/random.c
@@ -471,7 +471,6 @@ struct entropy_store {
        unsigned short add_ptr;
        unsigned short input_rotate;
        int entropy_count;
-       int entropy_total;
        unsigned int initialized:1;
        unsigned int last_data_init:1;
        __u8 last_data[EXTRACT_SIZE];
@@ -644,7 +643,7 @@ static void process_random_ready_list(void)
  */
 static void credit_entropy_bits(struct entropy_store *r, int nbits)
 {
-       int entropy_count, orig;
+       int entropy_count, orig, has_initialized = 0;
        const int pool_size = r->poolinfo->poolfracbits;
        int nfrac = nbits << ENTROPY_SHIFT;
 
@@ -699,23 +698,25 @@ retry:
                entropy_count = 0;
        } else if (entropy_count > pool_size)
                entropy_count = pool_size;
+       if ((r == &blocking_pool) && !r->initialized &&
+           (entropy_count >> ENTROPY_SHIFT) > 128)
+               has_initialized = 1;
        if (cmpxchg(&r->entropy_count, orig, entropy_count) != orig)
                goto retry;
 
-       r->entropy_total += nbits;
-       if (!r->initialized && r->entropy_total > 128) {
+       if (has_initialized)
                r->initialized = 1;
-               r->entropy_total = 0;
-       }
 
        trace_credit_entropy_bits(r->name, nbits,
-                                 entropy_count >> ENTROPY_SHIFT,
-                                 r->entropy_total, _RET_IP_);
+                                 entropy_count >> ENTROPY_SHIFT, _RET_IP_);
 
        if (r == &input_pool) {
                int entropy_bits = entropy_count >> ENTROPY_SHIFT;
+               struct entropy_store *other = &blocking_pool;
 
-               if (crng_init < 2 && entropy_bits >= 128) {
+               if (crng_init < 2) {
+                       if (entropy_bits < 128)
+                               return;
                        crng_reseed(&primary_crng, r);
                        entropy_bits = r->entropy_count >> ENTROPY_SHIFT;
                }
@@ -726,20 +727,14 @@ retry:
                        wake_up_interruptible(&random_read_wait);
                        kill_fasync(&fasync, SIGIO, POLL_IN);
                }
-               /* If the input pool is getting full, send some
-                * entropy to the blocking pool until it is 75% full.
+               /* If the input pool is getting full, and the blocking
+                * pool has room, send some entropy to the blocking
+                * pool.
                 */
-               if (entropy_bits > random_write_wakeup_bits &&
-                   r->initialized &&
-                   r->entropy_total >= 2*random_read_wakeup_bits) {
-                       struct entropy_store *other = &blocking_pool;
-
-                       if (other->entropy_count <=
-                           3 * other->poolinfo->poolfracbits / 4) {
-                               schedule_work(&other->push_work);
-                               r->entropy_total = 0;
-                       }
-               }
+               if (!work_pending(&other->push_work) &&
+                   (ENTROPY_BITS(r) > 6 * r->poolinfo->poolbytes) &&
+                   (ENTROPY_BITS(other) <= 6 * other->poolinfo->poolbytes))
+                       schedule_work(&other->push_work);
        }
 }
 
@@ -1562,6 +1557,11 @@ static ssize_t extract_entropy_user(struct entropy_store *r, void __user *buf,
        int large_request = (nbytes > 256);
 
        trace_extract_entropy_user(r->name, nbytes, ENTROPY_BITS(r), _RET_IP_);
+       if (!r->initialized && r->pull) {
+               xfer_secondary_pool(r, ENTROPY_BITS(r->pull)/8);
+               if (!r->initialized)
+                       return 0;
+       }
        xfer_secondary_pool(r, nbytes);
        nbytes = account(r, nbytes, 0, 0);
 

diff --git a/include/trace/events/random.h b/include/trace/events/random.h
index 0560dfc33f1c34d5f789e09ae54d33ad13d5e0f5..32c10a515e2d5438e8d620a0c2313aab5f849b2b 100644 (file)
--- a/include/trace/events/random.h
+++ b/include/trace/events/random.h
@@ -62,15 +62,14 @@ DEFINE_EVENT(random__mix_pool_bytes, mix_pool_bytes_nolock,
 
 TRACE_EVENT(credit_entropy_bits,
        TP_PROTO(const char *pool_name, int bits, int entropy_count,
-                int entropy_total, unsigned long IP),
+                unsigned long IP),
 
-       TP_ARGS(pool_name, bits, entropy_count, entropy_total, IP),
+       TP_ARGS(pool_name, bits, entropy_count, IP),
 
        TP_STRUCT__entry(
                __field( const char *,  pool_name               )
                __field(          int,  bits                    )
                __field(          int,  entropy_count           )
-               __field(          int,  entropy_total           )
                __field(unsigned long,  IP                      )
        ),
 
@@ -78,14 +77,12 @@ TRACE_EVENT(credit_entropy_bits,
                __entry->pool_name      = pool_name;
                __entry->bits           = bits;
                __entry->entropy_count  = entropy_count;
-               __entry->entropy_total  = entropy_total;
                __entry->IP             = IP;
        ),
 
-       TP_printk("%s pool: bits %d entropy_count %d entropy_total %d "
-                 "caller %pS", __entry->pool_name, __entry->bits,
-                 __entry->entropy_count, __entry->entropy_total,
-                 (void *)__entry->IP)
+       TP_printk("%s pool: bits %d entropy_count %d caller %pS",
+                 __entry->pool_name, __entry->bits,
+                 __entry->entropy_count, (void *)__entry->IP)
 );
 
 TRACE_EVENT(push_to_pool,