crypto: DRBG - add FIPS 140-2 CTRNG for noise source
PATCH 1/1 crypto: DRBG - add FIPS 140-2 CTRNG for noise source
FIPS 140-2 section 4.9.2 requires a continuous self test of the noise source. Up to kernel 4.8 drivers/char/random.c provided this continuous self test. Afterwards it was moved to a location that is inconsistent with the FIPS 140-2 requirements.
Thus, the FIPS 140-2 CTRNG is added to the DRBG when it obtains the seed. This patch resurrects the function drbg_fips_continous_test that existed some time ago and applies it to the noise sources.
The Jitter RNG implements its own FIPS 140-2 self test and thus does not need to be subjected to the test in the DRBG.
The patch contains a tiny fix to ensure proper zeroization in case of an error during the Jitter RNG data gathering.
--- crypto/drbg.c | 83 +++++++++++++++++++++++++++++++++++++++++-- include/crypto/drbg.h | 4 +++ 2 files changed, 84 insertions(+), 3 deletions(-)
crypto/drbg.c +80 -3
@@ -219,6 +219,57 @@ static inline unsigned short drbg_sec_strength(drbg_flag_t flags) } } +/* +* FIPS 140-2 continuous self test for the noise source +* The test is performed on the noise source input data. Thus, the function +* implicitly knows the size of the buffer to be equal to the security +* strength. +* +* Note, this function disregards the nonce trailing the entropy data during +* initial seeding. +* +* drbg->drbg_mutex must have been taken. +* +* @drbg DRBG handle +* @entropy buffer of seed data to be checked +* +* return: +* 0 on success +* -EAGAIN on when the CTRNG is not yet primed +* < 0 on error +*/ +static int drbg_fips_continuous_test (struct drbg_state *drbg, +const unsigned char *entropy) +{ +#ifdef CONFIG_CRYPTO_FIPS +unsigned short entropylen =drbg_sec_strength (drbg->core->flags); +int ret =0 ; + +/* skip test if we test the overall system */ +if (list_empty (&drbg->test_data.list)) +return true; +/* only perform test in FIPS mode */ +if (!fips_enabled) +return true; + +if (!drbg->fips_primed) { +/* Priming of FIPS test */ +memcpy (drbg->prev, entropy, entropylen); + drbg->fips_primed = true; +/* return false due to priming, i.e. another round is needed */ +return -EAGAIN ; + } + ret =memcmp (drbg->prev, entropy, entropylen); +if (!ret) +panic ("DRBG continuous self test failed\n" ); +memcpy (drbg->prev, entropy, entropylen); +/* the test shall pass when the two compared values are not equal */ +return (ret !=0 ) ?0 : -EFAULT ; +#else +return true; +#endif /* CONFIG_CRYPTO_FIPS */ +} +/* * Convert an integer into a byte representation of this integer. * The byte representation is big-endian
@@ -1006,16 +1057,23 @@ static void drbg_async_seed(struct work_struct *work) seed_work);unsigned int entropylen =drbg_sec_strength (drbg->core->flags);unsigned char entropy[32 ]; +int ret;BUG_ON (!entropylen);BUG_ON (entropylen >sizeof (entropy)); -get_random_bytes (entropy, entropylen);drbg_string_fill (&data, entropy, entropylen);list_add_tail (&data.list, &seedlist);mutex_lock (&drbg->drbg_mutex); +do { +get_random_bytes (entropy, entropylen); + ret =drbg_fips_continuous_test (drbg, entropy); +if (ret && ret != -EAGAIN ) + goto unlock; + }while (ret); +/* If nonblocking pool is initialized, deactivate Jitter RNG */ crypto_free_rng (drbg->jent); drbg->jent =NULL ;
@@ -1030,6 +1088,7 @@ static void drbg_async_seed(struct work_struct *work)if (drbg->seeded) drbg->reseed_threshold =drbg_max_requests (drbg); +unlock:mutex_unlock (&drbg->drbg_mutex);memzero_explicit (entropy, entropylen);
@@ -1081,7 +1140,12 @@ static int drbg_seed(struct drbg_state *drbg, struct drbg_string *pers,BUG_ON ((entropylen *2 ) >sizeof (entropy));/* Get seed from in-kernel /dev/urandom */ -get_random_bytes (entropy, entropylen); +do { +get_random_bytes (entropy, entropylen); + ret =drbg_fips_continuous_test (drbg, entropy); +if (ret && ret != -EAGAIN ) + goto out; + }while (ret);if (!drbg->jent) {drbg_string_fill (&data1, entropy, entropylen);
@@ -1094,7 +1158,7 @@ static int drbg_seed(struct drbg_state *drbg, struct drbg_string *pers, entropylen);if (ret) {pr_devel ("DRBG: jent failed with %d\n" , ret); -return ret; + goto out; }drbg_string_fill (&data1, entropy, entropylen *2 );
@@ -1121,6 +1185,7 @@ static int drbg_seed(struct drbg_state *drbg, struct drbg_string *pers, ret =__drbg_seed (drbg, &seedlist, reseed); +out:memzero_explicit (entropy, entropylen *2 );return ret;
@@ -1142,6 +1207,11 @@ static inline void drbg_dealloc_state(struct drbg_state *drbg) drbg->reseed_ctr =0 ; drbg->d_ops =NULL ; drbg->core =NULL ; +#ifdef CONFIG_CRYPTO_FIPS +kzfree (drbg->prev); + drbg->prev =NULL ; + drbg->fips_primed = false; +#endif }/*
@@ -1211,6 +1281,13 @@ static inline int drbg_alloc_state(struct drbg_state *drbg) drbg->scratchpad =PTR_ALIGN (drbg->scratchpadbuf, ret +1 ); } +#ifdef CONFIG_CRYPTO_FIPS + drbg->prev =kzalloc (drbg_sec_strength (drbg->core->flags),GFP_KERNEL ); +if (!drbg->prev) + goto fini; + drbg->fips_primed = false; +#endif +return 0 ; fini:
include/crypto/drbg.h +4 -0
@@ -129,6 +129,10 @@ struct drbg_state {bool seeded;/* DRBG fully seeded? */ bool pr;/* Prediction resistance enabled? */ +#ifdef CONFIG_CRYPTO_FIPS +bool fips_primed;/* Continuous test primed? */ +unsigned char *prev;/* FIPS 140-2 continuous test value */ +#endif struct work_struct seed_work;/* asynchronous seeding support */ struct crypto_rng *jent;const struct drbg_state_ops *d_ops;
Signature · 1 line
2.21.0
Herbert Xu
maintainerHi Stephan:
crypto/drbg.c static inline unsigned short drbg_sec_strength(drbg_flag_t flags) · line 244
Quoted 5 lines · Stephan Müller
crypto/drbg.c +4
-0+static int drbg_fips_continuous_test (struct drbg_state *drbg, +const unsigned char *entropy) +{ +#ifdef CONFIG_CRYPTO_FIPS
Please use the IS_ENABLED macro from linux/kconfig.h so that all of the code gets compiler coverage.
Thanks,
Signature · 3 lines
Email: Herbert Xu <[email protected]> Home Page: http://gondor.apana.org.au/~herbert/ PGP Key: http://gondor.apana.org.au/~herbert/pubkey.txt
Am Donnerstag, 2. Mai 2019, 14:48:11 CEST schrieb Herbert Xu:
Hi Herbert,
Quoted 10 lines
Hi Stephan:
crypto/drbg.c static inline unsigned short drbg_sec_strength(drbg_flag_t flags) · line 244
Quoted 4 lines · Stephan Müller
crypto/drbg.c +4
-0+static int drbg_fips_continuous_test (struct drbg_state *drbg, +const unsigned char *entropy) +{ +#ifdef CONFIG_CRYPTO_FIPS Please use the
IS_ENABLEDmacro fromlinux/kconfig.hso that all of the code gets compiler coverage.
Will do.
Quoted 2 lines
Thanks,
Ciao
Stephan
PATCH v2 1/1 crypto: DRBG - add FIPS 140-2 CTRNG for noise source
In reply to Herbert XuChanges v2:
* use IS_ENABLED macro
* small fix in comment
---8<---
FIPS 140-2 section 4.9.2 requires a continuous self test of the noise source. Up to kernel 4.8 drivers/char/random.c provided this continuous self test. Afterwards it was moved to a location that is inconsistent with the FIPS 140-2 requirements.
Thus, the FIPS 140-2 CTRNG is added to the DRBG when it obtains the seed. This patch resurrects the function drbg_fips_continous_test that existed some time ago and applies it to the noise sources.
The Jitter RNG implements its own FIPS 140-2 self test and thus does not need to be subjected to the test in the DRBG.
The patch contains a tiny fix to ensure proper zeroization in case of an error during the Jitter RNG data gathering.
--- crypto/drbg.c | 84 +++++++++++++++++++++++++++++++++++++++++-- include/crypto/drbg.h | 4 +++ 2 files changed, 85 insertions(+), 3 deletions(-)
crypto/drbg.c +81 -3
@@ -219,6 +219,57 @@ static inline unsigned short drbg_sec_strength(drbg_flag_t flags) } } +/* +* FIPS 140-2 continuous self test for the noise source +* The test is performed on the noise source input data. Thus, the function +* implicitly knows the size of the buffer to be equal to the security +* strength. +* +* Note, this function disregards the nonce trailing the entropy data during +* initial seeding. +* +* drbg->drbg_mutex must have been taken. +* +* @drbg DRBG handle +* @entropy buffer of seed data to be checked +* +* return: +* 0 on success +* -EAGAIN on when the CTRNG is not yet primed +* < 0 on error +*/ +static int drbg_fips_continuous_test (struct drbg_state *drbg, +const unsigned char *entropy) +{ +#if IS_ENABLED (CONFIG_CRYPTO_FIPS ) +unsigned short entropylen =drbg_sec_strength (drbg->core->flags); +int ret =0 ; + +/* skip test if we test the overall system */ +if (list_empty (&drbg->test_data.list)) +return true; +/* only perform test in FIPS mode */ +if (!fips_enabled) +return true; + +if (!drbg->fips_primed) { +/* Priming of FIPS test */ +memcpy (drbg->prev, entropy, entropylen); + drbg->fips_primed = true; +/* priming: another round is needed */ +return -EAGAIN ; + } + ret =memcmp (drbg->prev, entropy, entropylen); +if (!ret) +panic ("DRBG continuous self test failed\n" ); +memcpy (drbg->prev, entropy, entropylen); +/* the test shall pass when the two values are not equal */ +return (ret !=0 ) ?0 : -EFAULT ; +#else +return true; +#endif /* CONFIG_CRYPTO_FIPS */ +} +/* * Convert an integer into a byte representation of this integer. * The byte representation is big-endian
@@ -1006,16 +1057,23 @@ static void drbg_async_seed(struct work_struct *work) seed_work);unsigned int entropylen =drbg_sec_strength (drbg->core->flags);unsigned char entropy[32 ]; +int ret;BUG_ON (!entropylen);BUG_ON (entropylen >sizeof (entropy)); -get_random_bytes (entropy, entropylen);drbg_string_fill (&data, entropy, entropylen);list_add_tail (&data.list, &seedlist);mutex_lock (&drbg->drbg_mutex); +do { +get_random_bytes (entropy, entropylen); + ret =drbg_fips_continuous_test (drbg, entropy); +if (ret && ret != -EAGAIN ) + goto unlock; + }while (ret); +/* If nonblocking pool is initialized, deactivate Jitter RNG */ crypto_free_rng (drbg->jent); drbg->jent =NULL ;
@@ -1030,6 +1088,7 @@ static void drbg_async_seed(struct work_struct *work)if (drbg->seeded) drbg->reseed_threshold =drbg_max_requests (drbg); +unlock:mutex_unlock (&drbg->drbg_mutex);memzero_explicit (entropy, entropylen);
@@ -1081,7 +1140,12 @@ static int drbg_seed(struct drbg_state *drbg, struct drbg_string *pers,BUG_ON ((entropylen *2 ) >sizeof (entropy));/* Get seed from in-kernel /dev/urandom */ -get_random_bytes (entropy, entropylen); +do { +get_random_bytes (entropy, entropylen); + ret =drbg_fips_continuous_test (drbg, entropy); +if (ret && ret != -EAGAIN ) + goto out; + }while (ret);if (!drbg->jent) {drbg_string_fill (&data1, entropy, entropylen);
@@ -1094,7 +1158,7 @@ static int drbg_seed(struct drbg_state *drbg, struct drbg_string *pers, entropylen);if (ret) {pr_devel ("DRBG: jent failed with %d\n" , ret); -return ret; + goto out; }drbg_string_fill (&data1, entropy, entropylen *2 );
@@ -1121,6 +1185,7 @@ static int drbg_seed(struct drbg_state *drbg, struct drbg_string *pers, ret =__drbg_seed (drbg, &seedlist, reseed); +out:memzero_explicit (entropy, entropylen *2 );return ret;
@@ -1142,6 +1207,11 @@ static inline void drbg_dealloc_state(struct drbg_state *drbg) drbg->reseed_ctr =0 ; drbg->d_ops =NULL ; drbg->core =NULL ; +#if IS_ENABLED (CONFIG_CRYPTO_FIPS ) +kzfree (drbg->prev); + drbg->prev =NULL ; + drbg->fips_primed = false; +#endif }/*
@@ -1211,6 +1281,14 @@ static inline int drbg_alloc_state(struct drbg_state *drbg) drbg->scratchpad =PTR_ALIGN (drbg->scratchpadbuf, ret +1 ); } +#if IS_ENABLED (CONFIG_CRYPTO_FIPS ) + drbg->prev =kzalloc (drbg_sec_strength (drbg->core->flags), +GFP_KERNEL ); +if (!drbg->prev) + goto fini; + drbg->fips_primed = false; +#endif +return 0 ; fini:
include/crypto/drbg.h +4 -0
@@ -129,6 +129,10 @@ struct drbg_state {bool seeded;/* DRBG fully seeded? */ bool pr;/* Prediction resistance enabled? */ +#if IS_ENABLED (CONFIG_CRYPTO_FIPS ) +bool fips_primed;/* Continuous test primed? */ +unsigned char *prev;/* FIPS 140-2 continuous test value */ +#endif struct work_struct seed_work;/* asynchronous seeding support */ struct crypto_rng *jent;const struct drbg_state_ops *d_ops;
Signature · 1 line
2.21.0
PATCH v3 1/1 crypto: DRBG - add FIPS 140-2 CTRNG for noise source
Changes v3:
* fix return code of drbg_fips_continuous_test in non-FIPS mode
---8<---
FIPS 140-2 section 4.9.2 requires a continuous self test of the noise source. Up to kernel 4.8 drivers/char/random.c provided this continuous self test. Afterwards it was moved to a location that is inconsistent with the FIPS 140-2 requirements.
Thus, the FIPS 140-2 CTRNG is added to the DRBG when it obtains the seed. This patch resurrects the function drbg_fips_continous_test that existed some time ago and applies it to the noise sources.
The Jitter RNG implements its own FIPS 140-2 self test and thus does not need to be subjected to the test in the DRBG.
The patch contains a tiny fix to ensure proper zeroization in case of an error during the Jitter RNG data gathering.
--- crypto/drbg.c | 84 +++++++++++++++++++++++++++++++++++++++++-- include/crypto/drbg.h | 4 +++ 2 files changed, 85 insertions(+), 3 deletions(-)
crypto/drbg.c +81 -3
@@ -219,6 +219,57 @@ static inline unsigned short drbg_sec_strength(drbg_flag_t flags) } } +/* +* FIPS 140-2 continuous self test for the noise source +* The test is performed on the noise source input data. Thus, the function +* implicitly knows the size of the buffer to be equal to the security +* strength. +* +* Note, this function disregards the nonce trailing the entropy data during +* initial seeding. +* +* drbg->drbg_mutex must have been taken. +* +* @drbg DRBG handle +* @entropy buffer of seed data to be checked +* +* return: +* 0 on success +* -EAGAIN on when the CTRNG is not yet primed +* < 0 on error +*/ +static int drbg_fips_continuous_test (struct drbg_state *drbg, +const unsigned char *entropy) +{ +#if IS_ENABLED (CONFIG_CRYPTO_FIPS ) +unsigned short entropylen =drbg_sec_strength (drbg->core->flags); +int ret =0 ; + +/* skip test if we test the overall system */ +if (list_empty (&drbg->test_data.list)) +return 0 ; +/* only perform test in FIPS mode */ +if (!fips_enabled) +return 0 ; + +if (!drbg->fips_primed) { +/* Priming of FIPS test */ +memcpy (drbg->prev, entropy, entropylen); + drbg->fips_primed = true; +/* priming: another round is needed */ +return -EAGAIN ; + } + ret =memcmp (drbg->prev, entropy, entropylen); +if (!ret) +panic ("DRBG continuous self test failed\n" ); +memcpy (drbg->prev, entropy, entropylen); +/* the test shall pass when the two values are not equal */ +return (ret !=0 ) ?0 : -EFAULT ; +#else +return true; +#endif /* CONFIG_CRYPTO_FIPS */ +} +/* * Convert an integer into a byte representation of this integer. * The byte representation is big-endian
@@ -1006,16 +1057,23 @@ static void drbg_async_seed(struct work_struct *work) seed_work);unsigned int entropylen =drbg_sec_strength (drbg->core->flags);unsigned char entropy[32 ]; +int ret;BUG_ON (!entropylen);BUG_ON (entropylen >sizeof (entropy)); -get_random_bytes (entropy, entropylen);drbg_string_fill (&data, entropy, entropylen);list_add_tail (&data.list, &seedlist);mutex_lock (&drbg->drbg_mutex); +do { +get_random_bytes (entropy, entropylen); + ret =drbg_fips_continuous_test (drbg, entropy); +if (ret && ret != -EAGAIN ) + goto unlock; + }while (ret); +/* If nonblocking pool is initialized, deactivate Jitter RNG */ crypto_free_rng (drbg->jent); drbg->jent =NULL ;
@@ -1030,6 +1088,7 @@ static void drbg_async_seed(struct work_struct *work)if (drbg->seeded) drbg->reseed_threshold =drbg_max_requests (drbg); +unlock:mutex_unlock (&drbg->drbg_mutex);memzero_explicit (entropy, entropylen);
@@ -1081,7 +1140,12 @@ static int drbg_seed(struct drbg_state *drbg, struct drbg_string *pers,BUG_ON ((entropylen *2 ) >sizeof (entropy));/* Get seed from in-kernel /dev/urandom */ -get_random_bytes (entropy, entropylen); +do { +get_random_bytes (entropy, entropylen); + ret =drbg_fips_continuous_test (drbg, entropy); +if (ret && ret != -EAGAIN ) + goto out; + }while (ret);if (!drbg->jent) {drbg_string_fill (&data1, entropy, entropylen);
@@ -1094,7 +1158,7 @@ static int drbg_seed(struct drbg_state *drbg, struct drbg_string *pers, entropylen);if (ret) {pr_devel ("DRBG: jent failed with %d\n" , ret); -return ret; + goto out; }drbg_string_fill (&data1, entropy, entropylen *2 );
@@ -1121,6 +1185,7 @@ static int drbg_seed(struct drbg_state *drbg, struct drbg_string *pers, ret =__drbg_seed (drbg, &seedlist, reseed); +out:memzero_explicit (entropy, entropylen *2 );return ret;
@@ -1142,6 +1207,11 @@ static inline void drbg_dealloc_state(struct drbg_state *drbg) drbg->reseed_ctr =0 ; drbg->d_ops =NULL ; drbg->core =NULL ; +#if IS_ENABLED (CONFIG_CRYPTO_FIPS ) +kzfree (drbg->prev); + drbg->prev =NULL ; + drbg->fips_primed = false; +#endif }/*
@@ -1211,6 +1281,14 @@ static inline int drbg_alloc_state(struct drbg_state *drbg) drbg->scratchpad =PTR_ALIGN (drbg->scratchpadbuf, ret +1 ); } +#if IS_ENABLED (CONFIG_CRYPTO_FIPS ) + drbg->prev =kzalloc (drbg_sec_strength (drbg->core->flags), +GFP_KERNEL ); +if (!drbg->prev) + goto fini; + drbg->fips_primed = false; +#endif +return 0 ; fini:
include/crypto/drbg.h +4 -0
@@ -129,6 +129,10 @@ struct drbg_state {bool seeded;/* DRBG fully seeded? */ bool pr;/* Prediction resistance enabled? */ +#if IS_ENABLED (CONFIG_CRYPTO_FIPS ) +bool fips_primed;/* Continuous test primed? */ +unsigned char *prev;/* FIPS 140-2 continuous test value */ +#endif struct work_struct seed_work;/* asynchronous seeding support */ struct crypto_rng *jent;const struct drbg_state_ops *d_ops;
Signature · 1 line
2.21.0
Herbert Xu
maintainercrypto/drbg.c static inline unsigned short drbg_sec_strength(drbg_flag_t flags) · line 244
Quoted 4 lines · Stephan Müller
crypto/drbg.c +4
-0+static int drbg_fips_continuous_test (struct drbg_state *drbg, +const unsigned char *entropy) +{ +#if IS_ENABLED (CONFIG_CRYPTO_FIPS )
This should look like
if (IS_ENABLED(CONFIG_CRYPTO_FIPS)) {
...
} else {
...
}This way the compiler will see everything regardless of whether FIPS is enabled or not.
include/crypto/drbg.h struct drbg_state { · line 135
Quoted 12 lines
include/crypto/drbg.h +4
-0@@ -129,6 +129,10 @@ struct drbg_state {bool seeded;/* DRBG fully seeded? */ bool pr;/* Prediction resistance enabled? */ +#if IS_ENABLED (CONFIG_CRYPTO_FIPS ) +bool fips_primed;/* Continuous test primed? */ +unsigned char *prev;/* FIPS 140-2 continuous test value */ +#endif
You can still use #ifdef here.
Cheers,
Signature · 3 lines
Email: Herbert Xu <[email protected]> Home Page: http://gondor.apana.org.au/~herbert/ PGP Key: http://gondor.apana.org.au/~herbert/pubkey.txt
Am Freitag, 3. Mai 2019, 03:42:41 CEST schrieb Herbert Xu:
Hi Herbert,
Quoted 26 lines · Stephan Müller
crypto/drbg.c static inline unsigned short drbg_sec_strength(drbg_flag_t flags) · line 244
Quoted 4 lines
crypto/drbg.c +4
-0+static int drbg_fips_continuous_test (struct drbg_state *drbg, +const unsigned char *entropy) +{ +#if IS_ENABLED (CONFIG_CRYPTO_FIPS )This should look like
if (IS_ENABLED(CONFIG_CRYPTO_FIPS)) { ... } else { ... }This way the compiler will see everything regardless of whether FIPS is enabled or not.
Quoted 9 lines
include/crypto/drbg.h +0
-0@@ -129,6 +129,10 @@ struct drbg_state {bool seeded;/* DRBG fully seeded? */ bool pr;/* Prediction resistance enabled? */
Quoted 6 lines
include/crypto/drbg.h struct drbg_state { · line 135
Quoted 4 lines
include/crypto/drbg.h +4
-0+#if IS_ENABLED (CONFIG_CRYPTO_FIPS ) +bool fips_primed;/* Continuous test primed? */ +unsigned char *prev;/* FIPS 140-2 continuous test value */ +#endif You can still use #ifdef here.
The variables would need to be defined unconditionally if we use a runtime check in the C code. Is that what you want me to do?
Ciao
Stephan
Herbert Xu
maintainerQuoted 17 lines · Stephan Mueller
Quoted 10 lines
Quoted 10 lines
include/crypto/drbg.h +0
-0@@ -129,6 +129,10 @@ struct drbg_state {bool seeded;/* DRBG fully seeded? */ bool pr;/* Prediction resistance enabled? */ Quoted 6 lines
include/crypto/drbg.h struct drbg_state { · line 135
Quoted 4 lines
include/crypto/drbg.h +4
-0+#if IS_ENABLED (CONFIG_CRYPTO_FIPS ) +bool fips_primed;/* Continuous test primed? */ +unsigned char *prev;/* FIPS 140-2 continuous test value */ +#endif You can still use #ifdef here.
Quoted 2 lines
The variables would need to be defined unconditionally if we use a runtime check in the C code. Is that what you want me to do?
Yes please do that. If we wanted to we can get around this by using accessor functions to hide them but DRBG without FIPS doesn't make much sense anyway so let's just include them unconditionally.
Cheers,
Signature · 3 lines
Email: Herbert Xu <[email protected]> Home Page: http://gondor.apana.org.au/~herbert/ PGP Key: http://gondor.apana.org.au/~herbert/pubkey.txt
PATCH v4 1/1 crypto: DRBG - add FIPS 140-2 CTRNG for noise source
In reply to Herbert XuChanges v4:
* use if (IS_ENABLED(CONFIG_CRYPTO_FIPS)) and compile CTRNG variables unconditionally
---8<---
FIPS 140-2 section 4.9.2 requires a continuous self test of the noise source. Up to kernel 4.8 drivers/char/random.c provided this continuous self test. Afterwards it was moved to a location that is inconsistent with the FIPS 140-2 requirements.
Thus, the FIPS 140-2 CTRNG is added to the DRBG when it obtains the seed. This patch resurrects the function drbg_fips_continous_test that existed some time ago and applies it to the noise sources.
The Jitter RNG implements its own FIPS 140-2 self test and thus does not need to be subjected to the test in the DRBG.
The patch contains a tiny fix to ensure proper zeroization in case of an error during the Jitter RNG data gathering.
--- crypto/drbg.c | 84 +++++++++++++++++++++++++++++++++++++++++-- include/crypto/drbg.h | 2 ++ 2 files changed, 83 insertions(+), 3 deletions(-)
crypto/drbg.c +81 -3
@@ -219,6 +219,57 @@ static inline unsigned short drbg_sec_strength(drbg_flag_t flags) } } +/* +* FIPS 140-2 continuous self test for the noise source +* The test is performed on the noise source input data. Thus, the function +* implicitly knows the size of the buffer to be equal to the security +* strength. +* +* Note, this function disregards the nonce trailing the entropy data during +* initial seeding. +* +* drbg->drbg_mutex must have been taken. +* +* @drbg DRBG handle +* @entropy buffer of seed data to be checked +* +* return: +* 0 on success +* -EAGAIN on when the CTRNG is not yet primed +* < 0 on error +*/ +static int drbg_fips_continuous_test (struct drbg_state *drbg, +const unsigned char *entropy) +{ +if (IS_ENABLED (CONFIG_CRYPTO_FIPS )) { +unsigned short entropylen =drbg_sec_strength (drbg->core->flags); +int ret =0 ; + +/* skip test if we test the overall system */ +if (list_empty (&drbg->test_data.list)) +return 0 ; +/* only perform test in FIPS mode */ +if (!fips_enabled) +return 0 ; + +if (!drbg->fips_primed) { +/* Priming of FIPS test */ +memcpy (drbg->prev, entropy, entropylen); + drbg->fips_primed = true; +/* priming: another round is needed */ +return -EAGAIN ; + } + ret =memcmp (drbg->prev, entropy, entropylen); +if (!ret) +panic ("DRBG continuous self test failed\n" ); +memcpy (drbg->prev, entropy, entropylen); +/* the test shall pass when the two values are not equal */ +return (ret !=0 ) ?0 : -EFAULT ; + }else { +return 0 ; + } +} +/* * Convert an integer into a byte representation of this integer. * The byte representation is big-endian
@@ -1006,16 +1057,23 @@ static void drbg_async_seed(struct work_struct *work) seed_work);unsigned int entropylen =drbg_sec_strength (drbg->core->flags);unsigned char entropy[32 ]; +int ret;BUG_ON (!entropylen);BUG_ON (entropylen >sizeof (entropy)); -get_random_bytes (entropy, entropylen);drbg_string_fill (&data, entropy, entropylen);list_add_tail (&data.list, &seedlist);mutex_lock (&drbg->drbg_mutex); +do { +get_random_bytes (entropy, entropylen); + ret =drbg_fips_continuous_test (drbg, entropy); +if (ret && ret != -EAGAIN ) + goto unlock; + }while (ret); +/* If nonblocking pool is initialized, deactivate Jitter RNG */ crypto_free_rng (drbg->jent); drbg->jent =NULL ;
@@ -1030,6 +1088,7 @@ static void drbg_async_seed(struct work_struct *work)if (drbg->seeded) drbg->reseed_threshold =drbg_max_requests (drbg); +unlock:mutex_unlock (&drbg->drbg_mutex);memzero_explicit (entropy, entropylen);
@@ -1081,7 +1140,12 @@ static int drbg_seed(struct drbg_state *drbg, struct drbg_string *pers,BUG_ON ((entropylen *2 ) >sizeof (entropy));/* Get seed from in-kernel /dev/urandom */ -get_random_bytes (entropy, entropylen); +do { +get_random_bytes (entropy, entropylen); + ret =drbg_fips_continuous_test (drbg, entropy); +if (ret && ret != -EAGAIN ) + goto out; + }while (ret);if (!drbg->jent) {drbg_string_fill (&data1, entropy, entropylen);
@@ -1094,7 +1158,7 @@ static int drbg_seed(struct drbg_state *drbg, struct drbg_string *pers, entropylen);if (ret) {pr_devel ("DRBG: jent failed with %d\n" , ret); -return ret; + goto out; }drbg_string_fill (&data1, entropy, entropylen *2 );
@@ -1121,6 +1185,7 @@ static int drbg_seed(struct drbg_state *drbg, struct drbg_string *pers, ret =__drbg_seed (drbg, &seedlist, reseed); +out:memzero_explicit (entropy, entropylen *2 );return ret;
@@ -1142,6 +1207,11 @@ static inline void drbg_dealloc_state(struct drbg_state *drbg) drbg->reseed_ctr =0 ; drbg->d_ops =NULL ; drbg->core =NULL ; +if (IS_ENABLED (CONFIG_CRYPTO_FIPS )) { +kzfree (drbg->prev); + drbg->prev =NULL ; + drbg->fips_primed = false; + } }/*
@@ -1211,6 +1281,14 @@ static inline int drbg_alloc_state(struct drbg_state *drbg) drbg->scratchpad =PTR_ALIGN (drbg->scratchpadbuf, ret +1 ); } +if (IS_ENABLED (CONFIG_CRYPTO_FIPS )) { + drbg->prev =kzalloc (drbg_sec_strength (drbg->core->flags), +GFP_KERNEL ); +if (!drbg->prev) + goto fini; + drbg->fips_primed = false; + } +return 0 ; fini:
include/crypto/drbg.h +2 -0
@@ -129,6 +129,8 @@ struct drbg_state {bool seeded;/* DRBG fully seeded? */ bool pr;/* Prediction resistance enabled? */ +bool fips_primed;/* Continuous test primed? */ +unsigned char *prev;/* FIPS 140-2 continuous test value */ struct work_struct seed_work;/* asynchronous seeding support */ struct crypto_rng *jent;const struct drbg_state_ops *d_ops;
Signature · 1 line
2.21.0
Hi
Quoted 6 lines · Stephan Müller
FIPS 140-2 section 4.9.2 requires a continuous self test of the noise source. Up to kernel 4.8
drivers/char/random.cprovided this continuous self test. Afterwards it was moved to a location that is inconsistent with the FIPS 140-2 requirements.
Could you list the commit that move the self test and add that information in the commit message.
Quoted 4 lines
Thus, the FIPS 140-2 CTRNG is added to the DRBG when it obtains the seed. This patch resurrects the function
drbg_fips_continous_testthat existed some time ago and applies it to the noise sources.
Please identify the commit it was resurrected from, for traceability purpose.
Regards.
Signature · 2 lines
Yann Droneaud OPTEYA
PATCH v5 1/1 crypto: DRBG - add FIPS 140-2 CTRNG for noise source
FIPS 140-2 section 4.9.2 requires a continuous self test of the noise source. Up to kernel 4.8 drivers/char/random.c provided this continuous self test. Afterwards it was moved to a location that is inconsistent with the FIPS 140-2 requirements. The relevant patch was e192be9d9a30555aae2ca1dc3aad37cba484cd4a .
Thus, the FIPS 140-2 CTRNG is added to the DRBG when it obtains the seed. This patch resurrects the function drbg_fips_continous_test that existed some time ago and applies it to the noise sources. The patch that removed the drbg_fips_continous_test was b3614763059b82c26bdd02ffcb1c016c1132aad0 .
The Jitter RNG implements its own FIPS 140-2 self test and thus does not need to be subjected to the test in the DRBG.
The patch contains a tiny fix to ensure proper zeroization in case of an error during the Jitter RNG data gathering.
--- crypto/drbg.c | 84 +++++++++++++++++++++++++++++++++++++++++-- include/crypto/drbg.h | 2 ++ 2 files changed, 83 insertions(+), 3 deletions(-)
crypto/drbg.c +81 -3
@@ -219,6 +219,57 @@ static inline unsigned short drbg_sec_strength(drbg_flag_t flags) } } +/* +* FIPS 140-2 continuous self test for the noise source +* The test is performed on the noise source input data. Thus, the function +* implicitly knows the size of the buffer to be equal to the security +* strength. +* +* Note, this function disregards the nonce trailing the entropy data during +* initial seeding. +* +* drbg->drbg_mutex must have been taken. +* +* @drbg DRBG handle +* @entropy buffer of seed data to be checked +* +* return: +* 0 on success +* -EAGAIN on when the CTRNG is not yet primed +* < 0 on error +*/ +static int drbg_fips_continuous_test (struct drbg_state *drbg, +const unsigned char *entropy) +{ +if (IS_ENABLED (CONFIG_CRYPTO_FIPS )) { +unsigned short entropylen =drbg_sec_strength (drbg->core->flags); +int ret =0 ; + +/* skip test if we test the overall system */ +if (list_empty (&drbg->test_data.list)) +return 0 ; +/* only perform test in FIPS mode */ +if (!fips_enabled) +return 0 ; + +if (!drbg->fips_primed) { +/* Priming of FIPS test */ +memcpy (drbg->prev, entropy, entropylen); + drbg->fips_primed = true; +/* priming: another round is needed */ +return -EAGAIN ; + } + ret =memcmp (drbg->prev, entropy, entropylen); +if (!ret) +panic ("DRBG continuous self test failed\n" ); +memcpy (drbg->prev, entropy, entropylen); +/* the test shall pass when the two values are not equal */ +return (ret !=0 ) ?0 : -EFAULT ; + }else { +return 0 ; + } +} +/* * Convert an integer into a byte representation of this integer. * The byte representation is big-endian
@@ -1006,16 +1057,23 @@ static void drbg_async_seed(struct work_struct *work) seed_work);unsigned int entropylen =drbg_sec_strength (drbg->core->flags);unsigned char entropy[32 ]; +int ret;BUG_ON (!entropylen);BUG_ON (entropylen >sizeof (entropy)); -get_random_bytes (entropy, entropylen);drbg_string_fill (&data, entropy, entropylen);list_add_tail (&data.list, &seedlist);mutex_lock (&drbg->drbg_mutex); +do { +get_random_bytes (entropy, entropylen); + ret =drbg_fips_continuous_test (drbg, entropy); +if (ret && ret != -EAGAIN ) + goto unlock; + }while (ret); +/* If nonblocking pool is initialized, deactivate Jitter RNG */ crypto_free_rng (drbg->jent); drbg->jent =NULL ;
@@ -1030,6 +1088,7 @@ static void drbg_async_seed(struct work_struct *work)if (drbg->seeded) drbg->reseed_threshold =drbg_max_requests (drbg); +unlock:mutex_unlock (&drbg->drbg_mutex);memzero_explicit (entropy, entropylen);
@@ -1081,7 +1140,12 @@ static int drbg_seed(struct drbg_state *drbg, struct drbg_string *pers,BUG_ON ((entropylen *2 ) >sizeof (entropy));/* Get seed from in-kernel /dev/urandom */ -get_random_bytes (entropy, entropylen); +do { +get_random_bytes (entropy, entropylen); + ret =drbg_fips_continuous_test (drbg, entropy); +if (ret && ret != -EAGAIN ) + goto out; + }while (ret);if (!drbg->jent) {drbg_string_fill (&data1, entropy, entropylen);
@@ -1094,7 +1158,7 @@ static int drbg_seed(struct drbg_state *drbg, struct drbg_string *pers, entropylen);if (ret) {pr_devel ("DRBG: jent failed with %d\n" , ret); -return ret; + goto out; }drbg_string_fill (&data1, entropy, entropylen *2 );
@@ -1121,6 +1185,7 @@ static int drbg_seed(struct drbg_state *drbg, struct drbg_string *pers, ret =__drbg_seed (drbg, &seedlist, reseed); +out:memzero_explicit (entropy, entropylen *2 );return ret;
@@ -1142,6 +1207,11 @@ static inline void drbg_dealloc_state(struct drbg_state *drbg) drbg->reseed_ctr =0 ; drbg->d_ops =NULL ; drbg->core =NULL ; +if (IS_ENABLED (CONFIG_CRYPTO_FIPS )) { +kzfree (drbg->prev); + drbg->prev =NULL ; + drbg->fips_primed = false; + } }/*
@@ -1211,6 +1281,14 @@ static inline int drbg_alloc_state(struct drbg_state *drbg) drbg->scratchpad =PTR_ALIGN (drbg->scratchpadbuf, ret +1 ); } +if (IS_ENABLED (CONFIG_CRYPTO_FIPS )) { + drbg->prev =kzalloc (drbg_sec_strength (drbg->core->flags), +GFP_KERNEL ); +if (!drbg->prev) + goto fini; + drbg->fips_primed = false; + } +return 0 ; fini:
include/crypto/drbg.h +2 -0
@@ -129,6 +129,8 @@ struct drbg_state {bool seeded;/* DRBG fully seeded? */ bool pr;/* Prediction resistance enabled? */ +bool fips_primed;/* Continuous test primed? */ +unsigned char *prev;/* FIPS 140-2 continuous test value */ struct work_struct seed_work;/* asynchronous seeding support */ struct crypto_rng *jent;const struct drbg_state_ops *d_ops;
Signature · 1 line
2.21.0
Hi,
Quoted 6 lines · Stephan Müller
FIPS 140-2 section 4.9.2 requires a continuous self test of the noise source. Up to kernel 4.8
drivers/char/random.cprovided this continuous self test. Afterwards it was moved to a location that is inconsistent with the FIPS 140-2 requirements. The relevant patch wase192be9d9a30555aae2ca1dc3aad37cba484cd4a.
Please elaborate: in commit e192be9d9a30 ("random: replace non-blocking pool with a Chacha20-based CRNG") the "self test" code was moved from extract_entropy() to _extract_entropy(), which is used by extract_entropy().
Only crng_initialize() call _extract_entropy() with fips = 0, regarless of fips_enabled.
Is this the issue ?
Could crng_initialize() pass fips_enabled to _extract_entropy() instead of 0 ?
Quoted 6 lines
Thus, the FIPS 140-2 CTRNG is added to the DRBG when it obtains the seed. This patch resurrects the function
drbg_fips_continous_testthat existed some time ago and applies it to the noise sources. The patch that removed thedrbg_fips_continous_testwasb3614763059b82c26bdd02ffcb1c016c1132aad0.
Thanks for the commit.
Quoted 33 lines
The Jitter RNG implements its own FIPS 140-2 self test and thus does not need to be subjected to the test in the DRBG.
The patch contains a tiny fix to ensure proper zeroization in case of an error during the Jitter RNG data gathering.
Signed-off-by Stephan Mueller <[email protected]>--- crypto/drbg.c | 84 +++++++++++++++++++++++++++++++++++++++++-- include/crypto/drbg.h | 2 ++ 2 files changed, 83 insertions(+), 3 deletions(-)crypto/drbg.c +13
-0@@ -219,6 +219,57 @@ static inline unsigned short drbg_sec_strength(drbg_flag_t flags) } } +/* +* FIPS 140-2 continuous self test for the noise source +* The test is performed on the noise source input data. Thus, the function +* implicitly knows the size of the buffer to be equal to the security +* strength. +* +* Note, this function disregards the nonce trailing the entropy data during +* initial seeding. +* +* drbg->drbg_mutex must have been taken. +* +* @drbg DRBG handle +* @entropy buffer of seed data to be checked
crypto/drbg.c static inline unsigned short drbg_sec_strength(drbg_flag_t flags) · line 244
Quoted 10 lines
crypto/drbg.c +10
-0+* +* return: +* 0 on success +* -EAGAIN on when the CTRNG is not yet primed +* < 0 on error +*/ +static int drbg_fips_continuous_test (struct drbg_state *drbg, +const unsigned char *entropy) +{ +if (IS_ENABLED (CONFIG_CRYPTO_FIPS )) {
if (!IS_ENABLED(CONFIG_CRYPTO_FIPS)) return 0;
Quoted 10 lines
crypto/drbg.c +10
-0+unsigned short entropylen =drbg_sec_strength (drbg->core->flags); +int ret =0 ; + +/* skip test if we test the overall system */ +if (list_empty (&drbg->test_data.list)) +return 0 ; +/* only perform test in FIPS mode */ +if (!fips_enabled) +return 0 ; +
crypto/drbg.c static inline unsigned short drbg_sec_strength(drbg_flag_t flags) · line 264
Quoted 10 lines
crypto/drbg.c +10
-0+if (!drbg->fips_primed) { +/* Priming of FIPS test */ +memcpy (drbg->prev, entropy, entropylen); + drbg->fips_primed = true; +/* priming: another round is needed */ +return -EAGAIN ; + } + ret =memcmp (drbg->prev, entropy, entropylen); +if (!ret) +panic ("DRBG continuous self test failed\n" );
Previous version from commit b3614763059b ("crypto: drbg - remove FIPS 140-2 continuous test") already has it, and so does the "self test" in drivers/char/random.c, but do we really want to panic() in the unlikely, but still possible, event of a duplicated output from the PRNG ? The longer the system is up, the likelier this can happen ... if one can wait for the end of the universe :)
crypto/drbg.c static inline unsigned short drbg_sec_strength(drbg_flag_t flags) · line 267
Quoted 3 lines
crypto/drbg.c +3
-0+memcpy (drbg->prev, entropy, entropylen); +/* the test shall pass when the two values are not equal */ +return (ret !=0 ) ?0 : -EFAULT ;
Here, it's not possible to have ret == 0, since that would panic(), so -EFAULT cannot be returned.
Quoted 20 lines
crypto/drbg.c +6
-1+ }else { +return 0 ; + } +} +/* * Convert an integer into a byte representation of this integer. * The byte representation is big-endian @@ -1006,16 +1057,23 @@ static void drbg_async_seed(struct work_struct *work) seed_work);unsigned int entropylen =drbg_sec_strength (drbg->core->flags);unsigned char entropy[32 ]; +int ret;BUG_ON (!entropylen);BUG_ON (entropylen >sizeof (entropy)); -get_random_bytes (entropy, entropylen);drbg_string_fill (&data, entropy, entropylen);list_add_tail (&data.list, &seedlist);
crypto/drbg.c static void drbg_async_seed(struct work_struct *work) · line 1076
Quoted 10 lines
crypto/drbg.c +7
-0mutex_lock (&drbg->drbg_mutex); +do { +get_random_bytes (entropy, entropylen); + ret =drbg_fips_continuous_test (drbg, entropy); +if (ret && ret != -EAGAIN ) + goto unlock; + }while (ret); +
A function doing get_random_bytes() and continous_test() would be useful to both sync and async seed function.
Quoted 74 lines
crypto/drbg.c +22
-2/* If nonblocking pool is initialized, deactivate Jitter RNG */ crypto_free_rng (drbg->jent); drbg->jent =NULL ;@@ -1030,6 +1088,7 @@ static void drbg_async_seed(struct work_struct *work)if (drbg->seeded) drbg->reseed_threshold =drbg_max_requests (drbg); +unlock:mutex_unlock (&drbg->drbg_mutex);memzero_explicit (entropy, entropylen);@@ -1081,7 +1140,12 @@ static int drbg_seed(struct drbg_state *drbg, struct drbg_string *pers,BUG_ON ((entropylen *2 ) >sizeof (entropy));/* Get seed from in-kernel /dev/urandom */ -get_random_bytes (entropy, entropylen); +do { +get_random_bytes (entropy, entropylen); + ret =drbg_fips_continuous_test (drbg, entropy); +if (ret && ret != -EAGAIN ) + goto out; + }while (ret);if (!drbg->jent) {drbg_string_fill (&data1, entropy, entropylen);@@ -1094,7 +1158,7 @@ static int drbg_seed(struct drbg_state *drbg, struct drbg_string *pers, entropylen);if (ret) {pr_devel ("DRBG: jent failed with %d\n" , ret); -return ret; + goto out; }drbg_string_fill (&data1, entropy, entropylen *2 );@@ -1121,6 +1185,7 @@ static int drbg_seed(struct drbg_state *drbg, struct drbg_string *pers, ret =__drbg_seed (drbg, &seedlist, reseed); +out:memzero_explicit (entropy, entropylen *2 );return ret;@@ -1142,6 +1207,11 @@ static inline void drbg_dealloc_state(struct drbg_state *drbg) drbg->reseed_ctr =0 ; drbg->d_ops =NULL ; drbg->core =NULL ; +if (IS_ENABLED (CONFIG_CRYPTO_FIPS )) { +kzfree (drbg->prev); + drbg->prev =NULL ; + drbg->fips_primed = false; + } }/* @@ -1211,6 +1281,14 @@ static inline int drbg_alloc_state(struct drbg_state *drbg) drbg->scratchpad =PTR_ALIGN (drbg->scratchpadbuf, ret +1 ); } +if (IS_ENABLED (CONFIG_CRYPTO_FIPS )) { + drbg->prev =kzalloc (drbg_sec_strength (drbg->core->flags), +GFP_KERNEL ); +if (!drbg->prev) + goto fini; + drbg->fips_primed = false; + } +return 0 ; fini:include/crypto/drbg.h +0
-0
include/crypto/drbg.h struct drbg_state { · line 136
Quoted 8 lines
include/crypto/drbg.h +2
-0@@ -129,6 +129,8 @@ struct drbg_state {bool seeded;/* DRBG fully seeded? */ bool pr;/* Prediction resistance enabled? */ +bool fips_primed;/* Continuous test primed? */ +unsigned char *prev;/* FIPS 140-2 continuous test value */ struct work_struct seed_work;/* asynchronous seeding support */ struct crypto_rng *jent;const struct drbg_state_ops *d_ops;
Regards.
Signature · 2 lines
Yann Droneaud OPTEYA
Am Dienstag, 7. Mai 2019, 15:10:38 CEST schrieb Yann Droneaud:
Hi Yann,
Quoted 14 lines
Hi,
Quoted 5 lines · Stephan Müller
FIPS 140-2 section 4.9.2 requires a continuous self test of the noise source. Up to kernel 4.8
drivers/char/random.cprovided this continuous self test. Afterwards it was moved to a location that is inconsistent with the FIPS 140-2 requirements. The relevant patch wase192be9d9a30555aae2ca1dc3aad37cba484cd4a.Please elaborate: in commit
e192be9d9a30("random: replace non-blocking pool with a Chacha20-based CRNG") the "self test" code was moved fromextract_entropy()to_extract_entropy(), which is used byextract_entropy().
Quoted 4 lines
Only
crng_initialize()call_extract_entropy()with fips = 0, regarless offips_enabled.Is this the issue ?
The issue is that _extract_entropy is invoked with the input_pool from the ChaCha20 RNG during its initialization or reseed. So, this function is called to extract data from the input_pool and inject it into the ChaCha20 RNG.
However, we need the test to be applied at the output of the ChaCha20 RNG (or /dev/random).
Quoted 3 lines
Could
crng_initialize()passfips_enabledto_extract_entropy()instead of 0 ?
This small change does not fix it. At the time the change to ChaCha20 was applied, I provided a patch that moved the continuous test back to the locations were we need it. But it was ignored.
Ciao
Stephan
Am Dienstag, 7. Mai 2019, 15:10:38 CEST schrieb Yann Droneaud:
Hi Yann,
Quoted 4 lines
Review
Quoted 1 line
(quoted diff) +1
-0+ if (IS_ENABLED(CONFIG_CRYPTO_FIPS)) {if (!IS_ENABLED(CONFIG_CRYPTO_FIPS)) return 0;
Changed
Quoted 21 lines
Review
Quoted 2 lines
(quoted diff) +1
-0+ unsigned short entropylen = drbg_sec_strength(drbg->core-flags);
Quoted 18 lines
crypto/drbg.c +18
-0+int ret =0 ; + +/* skip test if we test the overall system */ +if (list_empty (&drbg->test_data.list)) +return 0 ; +/* only perform test in FIPS mode */ +if (!fips_enabled) +return 0 ; + +if (!drbg->fips_primed) { +/* Priming of FIPS test */ +memcpy (drbg->prev, entropy, entropylen); + drbg->fips_primed = true; +/* priming: another round is needed */ +return -EAGAIN ; + } + ret =memcmp (drbg->prev, entropy, entropylen); +if (!ret)
Quoted 8 lines
crypto/drbg.c static inline unsigned short drbg_sec_strength(drbg_flag_t flags) · line 264
Quoted 1 line
crypto/drbg.c +1
-0+panic ("DRBG continuous self test failed\n" );Previous version from commit
b3614763059b("crypto: drbg - remove FIPS 140-2 continuous test") already has it, and so does the "self test" indrivers/char/random.c, but do we really want topanic()in the unlikely, but still possible, event of a duplicated output from the PRNG ? The longer the system is up, the likelier this can happen ... if one can wait for the end of the universe :)
Yes, we want that in FIPS mode.
The requirement is that the "crypto module" (i.e. the kernel crypto API) must become unavailable if that issue happens.
Commonly this can only be achieved in two ways: either we have a kind of global flag that effectively deactivates the kernel crypto API or we terminate the kernel.
Quoted 7 lines
crypto/drbg.c static inline unsigned short drbg_sec_strength(drbg_flag_t flags) · line 267
Quoted 4 lines
crypto/drbg.c +3
-0+memcpy (drbg->prev, entropy, entropylen); +/* the test shall pass when the two values are not equal */ +return (ret !=0 ) ?0 : -EFAULT ;Here, it's not possible to have ret == 0, since that would
panic(), so-EFAULTcannot be returned.
Agreed.
Quoted 31 lines
Quoted 31 lines
crypto/drbg.c +6
-1+ }else { +return 0 ; + } +} +/* * Convert an integer into a byte representation of this integer. * The byte representation is big-endian @@ -1006,16 +1057,23 @@ static void drbg_async_seed(struct work_struct *work)> seed_work);unsigned int entropylen =drbg_sec_strength (drbg->core->flags);unsigned char entropy[32 ]; +int ret;BUG_ON (!entropylen);BUG_ON (entropylen >sizeof (entropy)); -get_random_bytes (entropy, entropylen);drbg_string_fill (&data, entropy, entropylen);list_add_tail (&data.list, &seedlist);mutex_lock (&drbg->drbg_mutex);
Quoted 10 lines
crypto/drbg.c static void drbg_async_seed(struct work_struct *work) · line 1076
Quoted 7 lines
crypto/drbg.c +7
-0+do { +get_random_bytes (entropy, entropylen); + ret =drbg_fips_continuous_test (drbg, entropy); +if (ret && ret != -EAGAIN ) + goto unlock; + }while (ret); +A function doing
get_random_bytes()andcontinous_test()would be useful to both sync and async seed function.
Changed
Thanks.
Ciao
Stephan
PATCH v6 1/1 crypto: DRBG - add FIPS 140-2 CTRNG for noise source
In reply to Yann DroneaudFIPS 140-2 section 4.9.2 requires a continuous self test of the noise source. Up to kernel 4.8 drivers/char/random.c provided this continuous self test. Afterwards it was moved to a location that is inconsistent with the FIPS 140-2 requirements. The relevant patch was e192be9d9a30555aae2ca1dc3aad37cba484cd4a .
Thus, the FIPS 140-2 CTRNG is added to the DRBG when it obtains the seed. This patch resurrects the function drbg_fips_continous_test that existed some time ago and applies it to the noise sources. The patch that removed the drbg_fips_continous_test was b3614763059b82c26bdd02ffcb1c016c1132aad0 .
The Jitter RNG implements its own FIPS 140-2 self test and thus does not need to be subjected to the test in the DRBG.
The patch contains a tiny fix to ensure proper zeroization in case of an error during the Jitter RNG data gathering.
--- crypto/drbg.c | 94 +++++++++++++++++++++++++++++++++++++++++-- include/crypto/drbg.h | 2 + 2 files changed, 93 insertions(+), 3 deletions(-)
crypto/drbg.c +91 -3
@@ -219,6 +219,57 @@ static inline unsigned short drbg_sec_strength(drbg_flag_t flags) } } +/* +* FIPS 140-2 continuous self test for the noise source +* The test is performed on the noise source input data. Thus, the function +* implicitly knows the size of the buffer to be equal to the security +* strength. +* +* Note, this function disregards the nonce trailing the entropy data during +* initial seeding. +* +* drbg->drbg_mutex must have been taken. +* +* @drbg DRBG handle +* @entropy buffer of seed data to be checked +* +* return: +* 0 on success +* -EAGAIN on when the CTRNG is not yet primed +* < 0 on error +*/ +static int drbg_fips_continuous_test (struct drbg_state *drbg, +const unsigned char *entropy) +{ +unsigned short entropylen =drbg_sec_strength (drbg->core->flags); +int ret =0 ; + +if (!IS_ENABLED (CONFIG_CRYPTO_FIPS )) +return 0 ; + +/* skip test if we test the overall system */ +if (list_empty (&drbg->test_data.list)) +return 0 ; +/* only perform test in FIPS mode */ +if (!fips_enabled) +return 0 ; + +if (!drbg->fips_primed) { +/* Priming of FIPS test */ +memcpy (drbg->prev, entropy, entropylen); + drbg->fips_primed = true; +/* priming: another round is needed */ +return -EAGAIN ; + } + ret =memcmp (drbg->prev, entropy, entropylen); +if (!ret) +panic ("DRBG continuous self test failed\n" ); +memcpy (drbg->prev, entropy, entropylen); + +/* the test shall pass when the two values are not equal */ +return 0 ; +} +/* * Convert an integer into a byte representation of this integer. * The byte representation is big-endian
@@ -998,6 +1049,22 @@ static inline int __drbg_seed(struct drbg_state *drbg, struct list_head *seed,return ret; } +static inline int drbg_get_random_bytes (struct drbg_state *drbg, +unsigned char *entropy, +unsigned int entropylen) +{ +int ret; + +do { +get_random_bytes (entropy, entropylen); + ret =drbg_fips_continuous_test (drbg, entropy); +if (ret && ret != -EAGAIN ) +return ret; + }while (ret); + +return 0 ; +} +static void drbg_async_seed (struct work_struct *work) {struct drbg_string data;
@@ -1006,16 +1073,20 @@ static void drbg_async_seed(struct work_struct *work) seed_work);unsigned int entropylen =drbg_sec_strength (drbg->core->flags);unsigned char entropy[32 ]; +int ret;BUG_ON (!entropylen);BUG_ON (entropylen >sizeof (entropy)); -get_random_bytes (entropy, entropylen);drbg_string_fill (&data, entropy, entropylen);list_add_tail (&data.list, &seedlist);mutex_lock (&drbg->drbg_mutex); + ret =drbg_get_random_bytes (drbg, entropy, entropylen); +if (ret) + goto unlock; +/* If nonblocking pool is initialized, deactivate Jitter RNG */ crypto_free_rng (drbg->jent); drbg->jent =NULL ;
@@ -1030,6 +1101,7 @@ static void drbg_async_seed(struct work_struct *work)if (drbg->seeded) drbg->reseed_threshold =drbg_max_requests (drbg); +unlock:mutex_unlock (&drbg->drbg_mutex);memzero_explicit (entropy, entropylen);
@@ -1081,7 +1153,9 @@ static int drbg_seed(struct drbg_state *drbg, struct drbg_string *pers,BUG_ON ((entropylen *2 ) >sizeof (entropy));/* Get seed from in-kernel /dev/urandom */ -get_random_bytes (entropy, entropylen); + ret =drbg_get_random_bytes (drbg, entropy, entropylen); +if (ret) + goto out;if (!drbg->jent) {drbg_string_fill (&data1, entropy, entropylen);
@@ -1094,7 +1168,7 @@ static int drbg_seed(struct drbg_state *drbg, struct drbg_string *pers, entropylen);if (ret) {pr_devel ("DRBG: jent failed with %d\n" , ret); -return ret; + goto out; }drbg_string_fill (&data1, entropy, entropylen *2 );
@@ -1121,6 +1195,7 @@ static int drbg_seed(struct drbg_state *drbg, struct drbg_string *pers, ret =__drbg_seed (drbg, &seedlist, reseed); +out:memzero_explicit (entropy, entropylen *2 );return ret;
@@ -1142,6 +1217,11 @@ static inline void drbg_dealloc_state(struct drbg_state *drbg) drbg->reseed_ctr =0 ; drbg->d_ops =NULL ; drbg->core =NULL ; +if (IS_ENABLED (CONFIG_CRYPTO_FIPS )) { +kzfree (drbg->prev); + drbg->prev =NULL ; + drbg->fips_primed = false; + } }/*
@@ -1211,6 +1291,14 @@ static inline int drbg_alloc_state(struct drbg_state *drbg) drbg->scratchpad =PTR_ALIGN (drbg->scratchpadbuf, ret +1 ); } +if (IS_ENABLED (CONFIG_CRYPTO_FIPS )) { + drbg->prev =kzalloc (drbg_sec_strength (drbg->core->flags), +GFP_KERNEL ); +if (!drbg->prev) + goto fini; + drbg->fips_primed = false; + } +return 0 ; fini:
include/crypto/drbg.h +2 -0
@@ -129,6 +129,8 @@ struct drbg_state {bool seeded;/* DRBG fully seeded? */ bool pr;/* Prediction resistance enabled? */ +bool fips_primed;/* Continuous test primed? */ +unsigned char *prev;/* FIPS 140-2 continuous test value */ struct work_struct seed_work;/* asynchronous seeding support */ struct crypto_rng *jent;const struct drbg_state_ops *d_ops;
Signature · 1 line
2.21.0
Hi,
Quoted 199 lines · Stephan Mueller
FIPS 140-2 section 4.9.2 requires a continuous self test of the noise source. Up to kernel 4.8
drivers/char/random.cprovided this continuous self test. Afterwards it was moved to a location that is inconsistent with the FIPS 140-2 requirements. The relevant patch wase192be9d9a30555aae2ca1dc3aad37cba484cd4a.Thus, the FIPS 140-2 CTRNG is added to the DRBG when it obtains the seed. This patch resurrects the function
drbg_fips_continous_testthat existed some time ago and applies it to the noise sources. The patch that removed thedrbg_fips_continous_testwasb3614763059b82c26bdd02ffcb1c016c1132aad0.The Jitter RNG implements its own FIPS 140-2 self test and thus does not need to be subjected to the test in the DRBG.
The patch contains a tiny fix to ensure proper zeroization in case of an error during the Jitter RNG data gathering.
Signed-off-by Stephan Mueller <[email protected]>--- crypto/drbg.c | 94 +++++++++++++++++++++++++++++++++++++++++-- include/crypto/drbg.h | 2 + 2 files changed, 93 insertions(+), 3 deletions(-)crypto/drbg.c +91
-3@@ -219,6 +219,57 @@ static inline unsigned short drbg_sec_strength(drbg_flag_t flags) } } +/* +* FIPS 140-2 continuous self test for the noise source +* The test is performed on the noise source input data. Thus, the function +* implicitly knows the size of the buffer to be equal to the security +* strength. +* +* Note, this function disregards the nonce trailing the entropy data during +* initial seeding. +* +* drbg->drbg_mutex must have been taken. +* +* @drbg DRBG handle +* @entropy buffer of seed data to be checked +* +* return: +* 0 on success +* -EAGAIN on when the CTRNG is not yet primed +* < 0 on error +*/ +static int drbg_fips_continuous_test (struct drbg_state *drbg, +const unsigned char *entropy) +{ +unsigned short entropylen =drbg_sec_strength (drbg->core->flags); +int ret =0 ; + +if (!IS_ENABLED (CONFIG_CRYPTO_FIPS )) +return 0 ; + +/* skip test if we test the overall system */ +if (list_empty (&drbg->test_data.list)) +return 0 ; +/* only perform test in FIPS mode */ +if (!fips_enabled) +return 0 ; + +if (!drbg->fips_primed) { +/* Priming of FIPS test */ +memcpy (drbg->prev, entropy, entropylen); + drbg->fips_primed = true; +/* priming: another round is needed */ +return -EAGAIN ; + } + ret =memcmp (drbg->prev, entropy, entropylen); +if (!ret) +panic ("DRBG continuous self test failed\n" ); +memcpy (drbg->prev, entropy, entropylen); + +/* the test shall pass when the two values are not equal */ +return 0 ; +} +/* * Convert an integer into a byte representation of this integer. * The byte representation is big-endian @@ -998,6 +1049,22 @@ static inline int __drbg_seed(struct drbg_state *drbg, struct list_head *seed,return ret; } +static inline int drbg_get_random_bytes (struct drbg_state *drbg, +unsigned char *entropy, +unsigned int entropylen) +{ +int ret; + +do { +get_random_bytes (entropy, entropylen); + ret =drbg_fips_continuous_test (drbg, entropy); +if (ret && ret != -EAGAIN ) +return ret; + }while (ret); + +return 0 ; +} +static void drbg_async_seed (struct work_struct *work) {struct drbg_string data;@@ -1006,16 +1073,20 @@ static void drbg_async_seed(struct work_struct *work) seed_work);unsigned int entropylen =drbg_sec_strength (drbg->core->flags);unsigned char entropy[32 ]; +int ret;BUG_ON (!entropylen);BUG_ON (entropylen >sizeof (entropy)); -get_random_bytes (entropy, entropylen);drbg_string_fill (&data, entropy, entropylen);list_add_tail (&data.list, &seedlist);mutex_lock (&drbg->drbg_mutex); + ret =drbg_get_random_bytes (drbg, entropy, entropylen); +if (ret) + goto unlock; +/* If nonblocking pool is initialized, deactivate Jitter RNG */ crypto_free_rng (drbg->jent); drbg->jent =NULL ;@@ -1030,6 +1101,7 @@ static void drbg_async_seed(struct work_struct *work)if (drbg->seeded) drbg->reseed_threshold =drbg_max_requests (drbg); +unlock:mutex_unlock (&drbg->drbg_mutex);memzero_explicit (entropy, entropylen);@@ -1081,7 +1153,9 @@ static int drbg_seed(struct drbg_state *drbg, struct drbg_string *pers,BUG_ON ((entropylen *2 ) >sizeof (entropy));/* Get seed from in-kernel /dev/urandom */ -get_random_bytes (entropy, entropylen); + ret =drbg_get_random_bytes (drbg, entropy, entropylen); +if (ret) + goto out;if (!drbg->jent) {drbg_string_fill (&data1, entropy, entropylen);@@ -1094,7 +1168,7 @@ static int drbg_seed(struct drbg_state *drbg, struct drbg_string *pers, entropylen);if (ret) {pr_devel ("DRBG: jent failed with %d\n" , ret); -return ret; + goto out; }drbg_string_fill (&data1, entropy, entropylen *2 );@@ -1121,6 +1195,7 @@ static int drbg_seed(struct drbg_state *drbg, struct drbg_string *pers, ret =__drbg_seed (drbg, &seedlist, reseed); +out:memzero_explicit (entropy, entropylen *2 );return ret;@@ -1142,6 +1217,11 @@ static inline void drbg_dealloc_state(struct drbg_state *drbg) drbg->reseed_ctr =0 ; drbg->d_ops =NULL ; drbg->core =NULL ; +if (IS_ENABLED (CONFIG_CRYPTO_FIPS )) { +kzfree (drbg->prev); + drbg->prev =NULL ; + drbg->fips_primed = false; + } }/* @@ -1211,6 +1291,14 @@ static inline int drbg_alloc_state(struct drbg_state *drbg) drbg->scratchpad =PTR_ALIGN (drbg->scratchpadbuf, ret +1 ); } +if (IS_ENABLED (CONFIG_CRYPTO_FIPS )) { + drbg->prev =kzalloc (drbg_sec_strength (drbg->core->flags), +GFP_KERNEL ); +if (!drbg->prev) + goto fini; + drbg->fips_primed = false; + } +return 0 ; fini:include/crypto/drbg.h +0
-0
include/crypto/drbg.h struct drbg_state { · line 136
Quoted 8 lines
include/crypto/drbg.h +2
-0@@ -129,6 +129,8 @@ struct drbg_state {bool seeded;/* DRBG fully seeded? */ bool pr;/* Prediction resistance enabled? */ +bool fips_primed;/* Continuous test primed? */ +unsigned char *prev;/* FIPS 140-2 continuous test value */ struct work_struct seed_work;/* asynchronous seeding support */ struct crypto_rng *jent;const struct drbg_state_ops *d_ops;
Thanks.
Signature · 2 lines
Yann Droneaud OPTEYA
Herbert Xu
maintainerQuoted 15 lines · Stephan Mueller
FIPS 140-2 section 4.9.2 requires a continuous self test of the noise source. Up to kernel 4.8
drivers/char/random.cprovided this continuous self test. Afterwards it was moved to a location that is inconsistent with the FIPS 140-2 requirements. The relevant patch wase192be9d9a30555aae2ca1dc3aad37cba484cd4a.Thus, the FIPS 140-2 CTRNG is added to the DRBG when it obtains the seed. This patch resurrects the function
drbg_fips_continous_testthat existed some time ago and applies it to the noise sources. The patch that removed thedrbg_fips_continous_testwasb3614763059b82c26bdd02ffcb1c016c1132aad0.The Jitter RNG implements its own FIPS 140-2 self test and thus does not need to be subjected to the test in the DRBG.
Quoted 8 lines
The patch contains a tiny fix to ensure proper zeroization in case of an error during the Jitter RNG data gathering.
Signed-off-by Stephan Mueller <[email protected]>--- crypto/drbg.c | 94 +++++++++++++++++++++++++++++++++++++++++-- include/crypto/drbg.h | 2 + 2 files changed, 93 insertions(+), 3 deletions(-)
Patch applied. Thanks.
Signature · 3 lines
Email: Herbert Xu <[email protected]> Home Page: http://gondor.apana.org.au/~herbert/ PGP Key: http://gondor.apana.org.au/~herbert/pubkey.txt