Skip to content

Commit

Permalink
crypto: drbg - Use callback API for random readiness
Browse files Browse the repository at this point in the history 
The get_blocking_random_bytes API is broken because the wait can
be arbitrarily long (potentially forever) so there is no safe way
of calling it from within the kernel.

This patch replaces it with the new callback API which does not
have this problem.

The patch also removes the entropy buffer registered with the DRBG
handle in favor of stack variables to hold the seed data.

Signed-off-by: Stephan Mueller <[email protected]>
Signed-off-by: Herbert Xu <[email protected]>
  • Loading branch information
@smuellerDD @herbertx
smuellerDD authored and herbertx committed Jun 10, 2015
1 parent 205a525 commit 57225e6
Show file tree
Hide file tree
Showing 2 changed files with 127 additions and 93 deletions.
217 changes: 126 additions & 91 deletions crypto/drbg.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -98,6 +98,7 @@
*/

#include <crypto/drbg.h>
#include <linux/kernel.h>

/***************************************************************
* Backend cipher definitions available to DRBG
Expand Down Expand Up @@ -190,6 +191,8 @@ static const struct drbg_core drbg_cores[] = {
#endif /* CONFIG_CRYPTO_DRBG_HMAC */
};

static int drbg_uninstantiate(struct drbg_state *drbg);

/******************************************************************
* Generic helper functions
******************************************************************/
Expand Down Expand Up @@ -1062,20 +1065,32 @@ static void drbg_async_seed(struct work_struct *work)
LIST_HEAD(seedlist);
struct drbg_state *drbg = container_of(work, struct drbg_state,
seed_work);
int ret;
unsigned int entropylen = drbg_sec_strength(drbg->core->flags);
unsigned char entropy[32];

get_blocking_random_bytes(drbg->seed_buf, drbg->seed_buf_len);
BUG_ON(!entropylen);
BUG_ON(entropylen > sizeof(entropy));
get_random_bytes(entropy, entropylen);

drbg_string_fill(&data, drbg->seed_buf, drbg->seed_buf_len);
drbg_string_fill(&data, entropy, entropylen);
list_add_tail(&data.list, &seedlist);

mutex_lock(&drbg->drbg_mutex);
ret = __drbg_seed(drbg, &seedlist, true);
if (!ret && drbg->jent) {
crypto_free_rng(drbg->jent);
drbg->jent = NULL;
}
memzero_explicit(drbg->seed_buf, drbg->seed_buf_len);

/* If nonblocking pool is initialized, deactivate Jitter RNG */
crypto_free_rng(drbg->jent);
drbg->jent = NULL;

/* Set seeded to false so that if __drbg_seed fails the
* next generate call will trigger a reseed.
*/
drbg->seeded = false;

__drbg_seed(drbg, &seedlist, true);

mutex_unlock(&drbg->drbg_mutex);

memzero_explicit(entropy, entropylen);
}

/*
Expand All @@ -1092,7 +1107,9 @@ static void drbg_async_seed(struct work_struct *work)
static int drbg_seed(struct drbg_state *drbg, struct drbg_string *pers,
bool reseed)
{
int ret = 0;
int ret;
unsigned char entropy[((32 + 16) * 2)];
unsigned int entropylen = drbg_sec_strength(drbg->core->flags);
struct drbg_string data1;
LIST_HEAD(seedlist);

Expand All @@ -1108,23 +1125,39 @@ static int drbg_seed(struct drbg_state *drbg, struct drbg_string *pers,
drbg->test_data.len);
pr_devel("DRBG: using test entropy\n");
} else {
/*
* Gather entropy equal to the security strength of the DRBG.
* With a derivation function, a nonce is required in addition
* to the entropy. A nonce must be at least 1/2 of the security
* strength of the DRBG in size. Thus, entropy + nonce is 3/2
* of the strength. The consideration of a nonce is only
* applicable during initial seeding.
*/
BUG_ON(!entropylen);
if (!reseed)
entropylen = ((entropylen + 1) / 2) * 3;
BUG_ON((entropylen * 2) > sizeof(entropy));

/* Get seed from in-kernel /dev/urandom */
get_random_bytes(drbg->seed_buf, drbg->seed_buf_len);

/* Get seed from Jitter RNG */
if (!drbg->jent ||
crypto_rng_get_bytes(drbg->jent,
drbg->seed_buf + drbg->seed_buf_len,
drbg->seed_buf_len)) {
drbg_string_fill(&data1, drbg->seed_buf,
drbg->seed_buf_len);
pr_devel("DRBG: (re)seeding with %zu bytes of entropy\n",
drbg->seed_buf_len);
get_random_bytes(entropy, entropylen);

if (!drbg->jent) {
drbg_string_fill(&data1, entropy, entropylen);
pr_devel("DRBG: (re)seeding with %u bytes of entropy\n",
entropylen);
} else {
drbg_string_fill(&data1, drbg->seed_buf,
drbg->seed_buf_len * 2);
pr_devel("DRBG: (re)seeding with %zu bytes of entropy\n",
drbg->seed_buf_len * 2);
/* Get seed from Jitter RNG */
ret = crypto_rng_get_bytes(drbg->jent,
entropy + entropylen,
entropylen);
if (ret) {
pr_devel("DRBG: jent failed with %d\n", ret);
return ret;
}

drbg_string_fill(&data1, entropy, entropylen * 2);
pr_devel("DRBG: (re)seeding with %u bytes of entropy\n",
entropylen * 2);
}
}
list_add_tail(&data1.list, &seedlist);
Expand All @@ -1146,26 +1179,8 @@ static int drbg_seed(struct drbg_state *drbg, struct drbg_string *pers,

ret = __drbg_seed(drbg, &seedlist, reseed);

/*
* Clear the initial entropy buffer as the async call may not overwrite
* that buffer for quite some time.
*/
memzero_explicit(drbg->seed_buf, drbg->seed_buf_len * 2);
if (ret)
goto out;
/*
* For all subsequent seeding calls, we only need the seed buffer
* equal to the security strength of the DRBG. We undo the calculation
* in drbg_alloc_state.
*/
if (!reseed)
drbg->seed_buf_len = drbg->seed_buf_len / 3 * 2;

/* Invoke asynchronous seeding unless DRBG is in test mode. */
if (!list_empty(&drbg->test_data.list) && !reseed)
schedule_work(&drbg->seed_work);
memzero_explicit(entropy, entropylen * 2);

out:
return ret;
}

Expand All @@ -1188,12 +1203,6 @@ static inline void drbg_dealloc_state(struct drbg_state *drbg)
drbg->prev = NULL;
drbg->fips_primed = false;
#endif
kzfree(drbg->seed_buf);
drbg->seed_buf = NULL;
if (drbg->jent) {
crypto_free_rng(drbg->jent);
drbg->jent = NULL;
}
}

/*
Expand Down Expand Up @@ -1256,42 +1265,6 @@ static inline int drbg_alloc_state(struct drbg_state *drbg)
goto err;
}

/*
* Gather entropy equal to the security strength of the DRBG.
* With a derivation function, a nonce is required in addition
* to the entropy. A nonce must be at least 1/2 of the security
* strength of the DRBG in size. Thus, entropy * nonce is 3/2
* of the strength. The consideration of a nonce is only
* applicable during initial seeding.
*/
drbg->seed_buf_len = drbg_sec_strength(drbg->core->flags);
if (!drbg->seed_buf_len) {
ret = -EFAULT;
goto err;
}
/*
* Ensure we have sufficient buffer space for initial seed which
* consists of the seed from get_random_bytes and the Jitter RNG.
*/
drbg->seed_buf_len = ((drbg->seed_buf_len + 1) / 2) * 3;
drbg->seed_buf = kzalloc(drbg->seed_buf_len * 2, GFP_KERNEL);
if (!drbg->seed_buf)
goto err;

INIT_WORK(&drbg->seed_work, drbg_async_seed);

drbg->jent = crypto_alloc_rng("jitterentropy_rng", 0, 0);
if(IS_ERR(drbg->jent))
{
pr_info("DRBG: could not allocate Jitter RNG handle for seeding\n");
/*
* As the Jitter RNG is a module that may not be present, we
* continue with the operation and do not fully tie the DRBG
* to the Jitter RNG.
*/
drbg->jent = NULL;
}

return 0;

err:
Expand Down Expand Up @@ -1467,6 +1440,47 @@ static int drbg_generate_long(struct drbg_state *drbg,
return 0;
}

static void drbg_schedule_async_seed(struct random_ready_callback *rdy)
{
struct drbg_state *drbg = container_of(rdy, struct drbg_state,
random_ready);

schedule_work(&drbg->seed_work);
}

static int drbg_prepare_hrng(struct drbg_state *drbg)
{
int err;

/* We do not need an HRNG in test mode. */
if (list_empty(&drbg->test_data.list))
return 0;

INIT_WORK(&drbg->seed_work, drbg_async_seed);

drbg->random_ready.owner = THIS_MODULE;
drbg->random_ready.func = drbg_schedule_async_seed;

err = add_random_ready_callback(&drbg->random_ready);

switch (err) {
case 0:
break;

case -EALREADY:
err = 0;
/* fall through */

default:
drbg->random_ready.func = NULL;
return err;
}

drbg->jent = crypto_alloc_rng("jitterentropy_rng", 0, 0);

return err;
}

/*
* DRBG instantiation function as required by SP800-90A - this function
* sets up the DRBG handle, performs the initial seeding and all sanity
Expand Down Expand Up @@ -1517,15 +1531,25 @@ static int drbg_instantiate(struct drbg_state *drbg, struct drbg_string *pers,
if (drbg->d_ops->crypto_init(drbg))
goto err;

ret = drbg_prepare_hrng(drbg);
if (ret)
goto free_everything;

if (IS_ERR(drbg->jent)) {
ret = PTR_ERR(drbg->jent);
drbg->jent = NULL;
if (fips_enabled || ret != -ENOENT)
goto free_everything;
pr_info("DRBG: Continuing without Jitter RNG\n");
}

reseed = false;
}

ret = drbg_seed(drbg, pers, reseed);

if (ret && !reseed) {
drbg->d_ops->crypto_fini(drbg);
goto err;
}
if (ret && !reseed)
goto free_everything;

mutex_unlock(&drbg->drbg_mutex);
return ret;
Expand All @@ -1535,6 +1559,11 @@ static int drbg_instantiate(struct drbg_state *drbg, struct drbg_string *pers,
unlock:
mutex_unlock(&drbg->drbg_mutex);
return ret;

free_everything:
mutex_unlock(&drbg->drbg_mutex);
drbg_uninstantiate(drbg);
return ret;
}

/*
Expand All @@ -1548,7 +1577,13 @@ static int drbg_instantiate(struct drbg_state *drbg, struct drbg_string *pers,
*/
static int drbg_uninstantiate(struct drbg_state *drbg)
{
cancel_work_sync(&drbg->seed_work);
if (drbg->random_ready.func) {
del_random_ready_callback(&drbg->random_ready);
cancel_work_sync(&drbg->seed_work);
crypto_free_rng(drbg->jent);
drbg->jent = NULL;
}

if (drbg->d_ops)
drbg->d_ops->crypto_fini(drbg);
drbg_dealloc_state(drbg);
Expand Down
3 changes: 1 addition & 2 deletions include/crypto/drbg.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -121,12 +121,11 @@ struct drbg_state {
unsigned char *prev; /* FIPS 140-2 continuous test value */
#endif
struct work_struct seed_work; /* asynchronous seeding support */
u8 *seed_buf; /* buffer holding the seed */
size_t seed_buf_len;
struct crypto_rng *jent;
const struct drbg_state_ops *d_ops;
const struct drbg_core *core;
struct drbg_string test_data;
struct random_ready_callback random_ready;
};

static inline __u8 drbg_statelen(struct drbg_state *drbg)
Expand Down

0 comments on commit 57225e6

Please sign in to comment.