From 1eb0f801a5127c05562301bb35624a5cff5f45f7 Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Mon, 14 Jul 2025 14:20:39 -0700 Subject: [PATCH 01/26] crypto: ecdh - implement FIPS PCT commit - commit-source https://build.opensuse.org/public/source/SUSE:SLE-15-SP6:GA/kernel-source/patches.suse.tar.bz2 commit-patch-path patches.suse/crypto-ecdh-implement-FIPS-PCT.patch SP800-56Arev3, 5.6.2.1.4 ("Owner Assurance of Pair-wise Consistency") requires that a pair-wise consistency check needs to be conducted on a keypair. A pair-wise consistency test (PCT) is meant to ensure that a some provided public key is indeed associated with the given private one. As the kernel's ECDH implementation always computes the public key from the private one, this is guaranteed already as per the API. However, in the course of the certification process, there had been a lengthy discussion regarding this topic, with the result that a PCT is nonetheless mandatory. As the only user of the in-kernel ECDH is bluetooth, performance certainly isn't super critical. Simply implement a PCT for ECDH and move on. As mandated by SP800-56Arev3, 5.6.2.1.4, the PCT involves recomputing the public key and comparing it against the one under test. Signed-off-by: Nicolai Stange Signed-off-by: Jeremy Allison --- crypto/ecdh.c | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) diff --git a/crypto/ecdh.c b/crypto/ecdh.c index 72cfd15901563..e069c7bb51164 100644 --- a/crypto/ecdh.c +++ b/crypto/ecdh.c @@ -11,6 +11,7 @@ #include #include #include +#include struct ecdh_ctx { unsigned int curve_id; @@ -99,6 +100,36 @@ static int ecdh_compute_value(struct kpp_request *req) ctx->private_key, public_key); buf = public_key; nbytes = public_key_sz; + + /* + * SP800-56Arev3, 5.6.2.1.4: ("Owner Assurance of + * Pair-wise Consistency"): recompute the public key + * and check if the results match. + */ + if (fips_enabled) { + u64 *public_key_pct; + + if (ret < 0) + goto free_all; + + public_key_pct = kmalloc(public_key_sz, GFP_KERNEL); + if (!public_key_pct) { + ret = -ENOMEM; + goto free_all; + } + + ret = ecc_make_pub_key(ctx->curve_id, ctx->ndigits, + ctx->private_key, + public_key_pct); + if (ret < 0) { + kfree(public_key_pct); + goto free_all; + } + + if (memcmp(public_key, public_key_pct, public_key_sz)) + panic("ECDH PCT failed in FIPS mode"); + kfree(public_key_pct); + } } if (ret < 0) From 2830aab76b220d311d1e94fcbf8305a22c216a09 Mon Sep 17 00:00:00 2001 From: Jason Rodriguez Date: Mon, 30 Sep 2024 12:57:14 -0400 Subject: [PATCH 02/26] crypto: essiv - Zeroize keys on exit in essiv_aead_setkey() In essiv_aead_setkey(), use the same logic as crypto_authenc_esn_setkey() to zeroize keys on exit. [Sultan: touched up commit message] Signed-off-by: Jason Rodriguez --- crypto/essiv.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/crypto/essiv.c b/crypto/essiv.c index 1c00c3324058c..b715ec33e3eaf 100644 --- a/crypto/essiv.c +++ b/crypto/essiv.c @@ -114,13 +114,16 @@ static int essiv_aead_setkey(struct crypto_aead *tfm, const u8 *key, crypto_shash_update(desc, keys.enckey, keys.enckeylen) ?: crypto_shash_finup(desc, keys.authkey, keys.authkeylen, salt); if (err) - return err; + goto out; crypto_cipher_clear_flags(tctx->essiv_cipher, CRYPTO_TFM_REQ_MASK); crypto_cipher_set_flags(tctx->essiv_cipher, crypto_aead_get_flags(tfm) & CRYPTO_TFM_REQ_MASK); - return crypto_cipher_setkey(tctx->essiv_cipher, salt, + err = crypto_cipher_setkey(tctx->essiv_cipher, salt, crypto_shash_digestsize(tctx->hash)); +out: + memzero_explicit(&keys, sizeof(keys)); + return err; } static int essiv_aead_setauthsize(struct crypto_aead *tfm, From fb885bb69083a856711b11863e42af417f9ced9c Mon Sep 17 00:00:00 2001 From: Sultan Alsawaf Date: Wed, 11 Jun 2025 14:16:35 -0700 Subject: [PATCH 03/26] crypto: drbg - Align buffers to at least a cache line None of the ciphers used by the DRBG have an alignment requirement; thus, they all return 0 from .crypto_init, resulting in inconsistent alignment across all buffers. Align all buffers to at least a cache line to improve performance. This is especially useful when multiple DRBG instances are used, since it prevents false sharing of cache lines between the different instances. Signed-off-by: Sultan Alsawaf --- crypto/drbg.c | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/crypto/drbg.c b/crypto/drbg.c index 20321c8140e0d..250afd830b898 100644 --- a/crypto/drbg.c +++ b/crypto/drbg.c @@ -1292,6 +1292,12 @@ static inline int drbg_alloc_state(struct drbg_state *drbg) if (ret < 0) goto err; + /* + * Align to at least a cache line for better performance. This also + * prevents false sharing of cache lines between different instances. + */ + ret = max(ret, L1_CACHE_BYTES - 1); + drbg->Vbuf = kmalloc(drbg_statelen(drbg) + ret, GFP_KERNEL); if (!drbg->Vbuf) { ret = -ENOMEM; From d170483488b2ca169c9c72d0cfaaa576c25fd40a Mon Sep 17 00:00:00 2001 From: Sultan Alsawaf Date: Wed, 18 Jun 2025 23:42:08 -0700 Subject: [PATCH 04/26] mm/gup: introduce pin_user_pages_fast_only() Like pin_user_pages_fast(), but with the internal-only FOLL_FAST_ONLY flag. This complements the get_user_pages*() API, which already has get_user_pages_fast_only(). Signed-off-by: Sultan Alsawaf --- include/linux/mm.h | 2 ++ mm/gup.c | 28 ++++++++++++++++++++++++++++ 2 files changed, 30 insertions(+) diff --git a/include/linux/mm.h b/include/linux/mm.h index d2acffe4c8009..501f0212ac0e7 100644 --- a/include/linux/mm.h +++ b/include/linux/mm.h @@ -2616,6 +2616,8 @@ int get_user_pages_fast(unsigned long start, int nr_pages, unsigned int gup_flags, struct page **pages); int pin_user_pages_fast(unsigned long start, int nr_pages, unsigned int gup_flags, struct page **pages); +int pin_user_pages_fast_only(unsigned long start, int nr_pages, + unsigned int gup_flags, struct page **pages); void folio_add_pin(struct folio *folio); int account_locked_vm(struct mm_struct *mm, unsigned long pages, bool inc); diff --git a/mm/gup.c b/mm/gup.c index 960e4401320aa..737eceda0c6bf 100644 --- a/mm/gup.c +++ b/mm/gup.c @@ -3539,6 +3539,34 @@ int pin_user_pages_fast(unsigned long start, int nr_pages, } EXPORT_SYMBOL_GPL(pin_user_pages_fast); +/** + * pin_user_pages_fast_only() - pin user pages in memory + * @start: starting user address + * @nr_pages: number of pages from start to pin + * @gup_flags: flags modifying pin behaviour + * @pages: array that receives pointers to the pages pinned. + * Should be at least nr_pages long. + * + * Like pin_user_pages_fast() except it's IRQ-safe in that it won't fall back to + * the regular GUP. + * + * If the architecture does not support this function, simply return with no + * pages pinned. + * + * Careful, careful! COW breaking can go either way, so a non-write + * access can get ambiguous page results. If you call this function without + * 'write' set, you'd better be sure that you're ok with that ambiguity. + */ +int pin_user_pages_fast_only(unsigned long start, int nr_pages, + unsigned int gup_flags, struct page **pages) +{ + if (!is_valid_gup_args(pages, NULL, &gup_flags, + FOLL_PIN | FOLL_FAST_ONLY)) + return -EINVAL; + return gup_fast_fallback(start, nr_pages, gup_flags, pages); +} +EXPORT_SYMBOL_GPL(pin_user_pages_fast_only); + /** * pin_user_pages_remote() - pin pages of a remote process * From bce559a7a9de7110d49a2b1d811cffe9b26c5f9e Mon Sep 17 00:00:00 2001 From: Sultan Alsawaf Date: Tue, 24 Jun 2025 15:16:34 -0700 Subject: [PATCH 05/26] crypto: rng - Convert crypto_default_rng_refcnt into an unsigned int There is no reason this refcount should be a signed int. Convert it to an unsigned int, thereby also making it less likely to ever overflow. Signed-off-by: Sultan Alsawaf --- crypto/rng.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/crypto/rng.c b/crypto/rng.c index 3c9b158ac2b07..d90e07f6c966f 100644 --- a/crypto/rng.c +++ b/crypto/rng.c @@ -31,7 +31,7 @@ static struct crypto_rng *crypto_reseed_rng; static ____cacheline_aligned_in_smp DEFINE_MUTEX(crypto_default_rng_lock); struct crypto_rng *crypto_default_rng; EXPORT_SYMBOL_GPL(crypto_default_rng); -static int crypto_default_rng_refcnt; +static unsigned int crypto_default_rng_refcnt; int crypto_rng_reset(struct crypto_rng *tfm, const u8 *seed, unsigned int slen) { @@ -157,7 +157,7 @@ void crypto_put_default_rng(void) EXPORT_SYMBOL_GPL(crypto_put_default_rng); #if defined(CONFIG_CRYPTO_RNG) || defined(CONFIG_CRYPTO_RNG_MODULE) -static int crypto_del_rng(struct crypto_rng **rngp, int *refcntp, +static int crypto_del_rng(struct crypto_rng **rngp, unsigned int *refcntp, struct mutex *lock) { int err = -EBUSY; From 207ebdbb37f43e951dadb40e5a1ea1a4091b62dd Mon Sep 17 00:00:00 2001 From: Sultan Alsawaf Date: Tue, 24 Jun 2025 15:31:00 -0700 Subject: [PATCH 06/26] crypto: rng - Fix priority inversions due to mutex locks Since crypto_devrandom_read_iter() is invoked directly by user tasks and is accessible by every task in the system, there are glaring priority inversions on crypto_reseed_rng_lock and crypto_default_rng_lock. Tasks of arbitrary scheduling priority access crypto_devrandom_read_iter(). When a low-priority task owns one of the mutex locks, higher-priority tasks waiting on that mutex lock are stalled until the low-priority task is done. Fix the priority inversions by converting the mutex locks into rt_mutex locks which have PI support. Signed-off-by: Sultan Alsawaf --- crypto/rng.c | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/crypto/rng.c b/crypto/rng.c index d90e07f6c966f..41aeae0e6bf90 100644 --- a/crypto/rng.c +++ b/crypto/rng.c @@ -15,7 +15,7 @@ #include #include #include -#include +#include #include #include #include @@ -26,9 +26,9 @@ #include "internal.h" -static ____cacheline_aligned_in_smp DEFINE_MUTEX(crypto_reseed_rng_lock); +static ____cacheline_aligned_in_smp DEFINE_RT_MUTEX(crypto_reseed_rng_lock); static struct crypto_rng *crypto_reseed_rng; -static ____cacheline_aligned_in_smp DEFINE_MUTEX(crypto_default_rng_lock); +static ____cacheline_aligned_in_smp DEFINE_RT_MUTEX(crypto_default_rng_lock); struct crypto_rng *crypto_default_rng; EXPORT_SYMBOL_GPL(crypto_default_rng); static unsigned int crypto_default_rng_refcnt; @@ -138,11 +138,11 @@ int crypto_get_default_rng(void) { int err; - mutex_lock(&crypto_default_rng_lock); + rt_mutex_lock(&crypto_default_rng_lock); err = crypto_get_rng(&crypto_default_rng); if (!err) crypto_default_rng_refcnt++; - mutex_unlock(&crypto_default_rng_lock); + rt_mutex_unlock(&crypto_default_rng_lock); return err; } @@ -150,19 +150,19 @@ EXPORT_SYMBOL_GPL(crypto_get_default_rng); void crypto_put_default_rng(void) { - mutex_lock(&crypto_default_rng_lock); + rt_mutex_lock(&crypto_default_rng_lock); crypto_default_rng_refcnt--; - mutex_unlock(&crypto_default_rng_lock); + rt_mutex_unlock(&crypto_default_rng_lock); } EXPORT_SYMBOL_GPL(crypto_put_default_rng); #if defined(CONFIG_CRYPTO_RNG) || defined(CONFIG_CRYPTO_RNG_MODULE) static int crypto_del_rng(struct crypto_rng **rngp, unsigned int *refcntp, - struct mutex *lock) + struct rt_mutex *lock) { int err = -EBUSY; - mutex_lock(lock); + rt_mutex_lock(lock); if (refcntp && *refcntp) goto out; @@ -172,7 +172,7 @@ static int crypto_del_rng(struct crypto_rng **rngp, unsigned int *refcntp, err = 0; out: - mutex_unlock(lock); + rt_mutex_unlock(lock); return err; } @@ -257,7 +257,7 @@ static ssize_t crypto_devrandom_read_iter(struct iov_iter *iter, bool reseed) * a separate mutex (drbg->drbg_mutex) around the * reseed-and-generate operation. */ - mutex_lock(&crypto_reseed_rng_lock); + rt_mutex_lock(&crypto_reseed_rng_lock); /* If crypto_default_rng is not set, it will be seeded * at creation in __crypto_get_default_rng and thus no @@ -268,7 +268,7 @@ static ssize_t crypto_devrandom_read_iter(struct iov_iter *iter, bool reseed) ret = crypto_get_rng(&crypto_reseed_rng); if (ret) { - mutex_unlock(&crypto_reseed_rng_lock); + rt_mutex_unlock(&crypto_reseed_rng_lock); return ret; } @@ -307,7 +307,7 @@ static ssize_t crypto_devrandom_read_iter(struct iov_iter *iter, bool reseed) } if (reseed) - mutex_unlock(&crypto_reseed_rng_lock); + rt_mutex_unlock(&crypto_reseed_rng_lock); else crypto_put_default_rng(); memzero_explicit(tmp, sizeof(tmp)); From ed937bc74d0bc09d2cc547ec82d36f5dec9fd2b9 Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Fri, 21 Aug 2026 11:17:39 -0700 Subject: [PATCH 07/26] crypto: sha1 - Add FIPS known answer test for lib/crypto path The kernel has two SHA-1 code paths: the crypto API (crypto/sha1_generic.c), which is covered by testmgr's FIPS self-tests at algorithm registration time, and the library implementation (lib/crypto/sha1.c), which provides sha1_init() and sha1_transform() directly to in-kernel callers that bypass the crypto API entirely. When booting with fips=1, the library path was not independently validated, meaning any corruption or miscompilation of the lib/crypto SHA-1 code would go undetected. This is a gap in FIPS 140 coverage since several subsystems use the library functions directly. Add a known answer test that runs at subsys_initcall time when CONFIG_CRYPTO_FIPS is enabled and fips_enabled is set. The test computes SHA-1 over the NIST one-block test message "abc" (pre-padded to a full 64-byte SHA-1 input block) using the library's own sha1_init() and sha1_transform() functions, and compares the result against the known digest a9993e364706816aba3e25717850c26c9cd0d89d. On mismatch the kernel panics, consistent with FIPS 140 self-test failure handling elsewhere in the tree (e.g. the 6.18 HMAC-SHA-1 KAT in the same file and DRBG self-tests in crypto/). The test vector data and expected digest are marked __initconst so they are freed after boot, and the workspace buffer is scrubbed with memzero_explicit() after use. No header, Kconfig, or Makefile changes are required: SHA1_BLOCK_SIZE, SHA1_DIGEST_WORDS, and SHA1_WORKSPACE_WORDS are already provided by include/crypto/sha1.h, and CONFIG_CRYPTO_FIPS already exists in crypto/Kconfig. Co-Authored-By: Claude Opus 4.6 (1M context) --- lib/crypto/sha1.c | 46 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 46 insertions(+) diff --git a/lib/crypto/sha1.c b/lib/crypto/sha1.c index ebb60519ae939..955617749e71a 100644 --- a/lib/crypto/sha1.c +++ b/lib/crypto/sha1.c @@ -137,5 +137,51 @@ void sha1_init(__u32 *buf) } EXPORT_SYMBOL(sha1_init); +#if defined(CONFIG_CRYPTO_FIPS) && !defined(__DISABLE_EXPORTS) +#include +#include + +static int __init sha1_mod_init(void) +{ + if (fips_enabled) { + /* + * FIPS known answer test for SHA-1. + * Input: NIST one-block message "abc" (pre-padded). + * Expected digest: a9993e36 4706816a ba3e2571 7850c26c 9cd0d89d + */ + static const u8 fips_input[SHA1_BLOCK_SIZE] __initconst = { + 0x61, 0x62, 0x63, 0x80, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, + }; + static const __u32 fips_digest[SHA1_DIGEST_WORDS] __initconst = { + 0xa9993e36, 0x4706816a, 0xba3e2571, + 0x7850c26c, 0x9cd0d89d, + }; + __u32 digest[SHA1_DIGEST_WORDS]; + __u32 workspace[SHA1_WORKSPACE_WORDS]; + + sha1_init(digest); + sha1_transform(digest, (const char *)fips_input, workspace); + memzero_explicit(workspace, sizeof(workspace)); + + if (memcmp(digest, fips_digest, sizeof(digest)) != 0) + panic("sha1: FIPS self-test failed\n"); + } + return 0; +} +subsys_initcall(sha1_mod_init); + +static void __exit sha1_mod_exit(void) +{ +} +module_exit(sha1_mod_exit); +#endif + MODULE_DESCRIPTION("SHA-1 Algorithm"); MODULE_LICENSE("GPL"); From 6992a02f11f2595de204279bb5f452ff21028235 Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Fri, 21 Aug 2026 11:28:06 -0700 Subject: [PATCH 08/26] crypto: sha256 - Add FIPS known answer test for lib/crypto path The kernel has two SHA-256 code paths: the crypto API (crypto/sha256_generic.c), which is covered by testmgr's FIPS self-tests at algorithm registration time, and the library implementation (lib/crypto/sha256.c), which provides sha256_init(), sha256_update(), sha256_final(), and the sha256() one-shot function directly to in-kernel callers that bypass the crypto API entirely. When booting with fips=1, the library path was not independently validated, meaning any corruption or miscompilation of the lib/crypto SHA-256 code would go undetected. This is a gap in FIPS 140 coverage since several subsystems use the library functions directly. Add a known answer test that runs at subsys_initcall time when CONFIG_CRYPTO_FIPS is enabled and fips_enabled is set. The test uses the sha256() one-shot function to hash the NIST one-block test message "abc", exercising the full sha256_init/update/final path including the underlying sha256_transform compression function. The result is compared against the known digest ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad. On mismatch the kernel panics, consistent with FIPS 140 self-test failure handling elsewhere in the tree. Unlike the SHA-1 library KAT (which could only test the raw transform since the 6.12 lib/crypto/sha1.c lacks update/final), this test covers the complete hash pipeline including padding and finalization logic. The test vector data and expected digest are marked __initconst so they are freed after boot. No header, Kconfig, or Makefile changes are required. Co-Authored-By: Claude Opus 4.6 (1M context) --- lib/crypto/sha256.c | 38 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) diff --git a/lib/crypto/sha256.c b/lib/crypto/sha256.c index 04c1f2557e6c2..58490a67be245 100644 --- a/lib/crypto/sha256.c +++ b/lib/crypto/sha256.c @@ -165,5 +165,43 @@ void sha256(const u8 *data, unsigned int len, u8 *out) } EXPORT_SYMBOL(sha256); +#if defined(CONFIG_CRYPTO_FIPS) && !defined(__DISABLE_EXPORTS) +#include +#include + +static int __init sha256_mod_init(void) +{ + if (fips_enabled) { + /* + * FIPS known answer test for SHA-256. + * Input: NIST one-block message "abc". + * Expected digest: + * ba7816bf 8f01cfea 414140de 5dae2223 + * b00361a3 96177a9c b410ff61 f20015ad + */ + static const u8 fips_input[] __initconst = { 'a', 'b', 'c' }; + static const u8 fips_digest[SHA256_DIGEST_SIZE] __initconst = { + 0xba, 0x78, 0x16, 0xbf, 0x8f, 0x01, 0xcf, 0xea, + 0x41, 0x41, 0x40, 0xde, 0x5d, 0xae, 0x22, 0x23, + 0xb0, 0x03, 0x61, 0xa3, 0x96, 0x17, 0x7a, 0x9c, + 0xb4, 0x10, 0xff, 0x61, 0xf2, 0x00, 0x15, 0xad, + }; + u8 out[SHA256_DIGEST_SIZE]; + + sha256(fips_input, sizeof(fips_input), out); + + if (memcmp(out, fips_digest, sizeof(out)) != 0) + panic("sha256: FIPS self-test failed\n"); + } + return 0; +} +subsys_initcall(sha256_mod_init); + +static void __exit sha256_mod_exit(void) +{ +} +module_exit(sha256_mod_exit); +#endif + MODULE_DESCRIPTION("SHA-256 Algorithm"); MODULE_LICENSE("GPL"); From 8f43ea415f41fd70c21e5fd027806ce4e076e37b Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Wed, 8 Apr 2026 11:48:27 -0700 Subject: [PATCH 09/26] crypto: testmgr - block Crypto API xxhash64 in FIPS mode commit-author Joachim Vandersmissen commit - commit-source https://lore.kernel.org/linux-crypto/20260303060509.246038-1-git@jvdsn.com/ xxhash64 is not a cryptographic hash algorithm, but is offered in the same API (shash) as actual cryptographic hash algorithms such as SHA-256. The Cryptographic Module Validation Program (CMVP), managing FIPS certification, believes that this could cause confusion. xxhash64 must therefore be blocked in FIPS mode. The only usage of xxhash64 in the kernel is btrfs. Commit fe11ac191ce0 ("btrfs: switch to library APIs for checksums") recently modified the btrfs code to use the lib/crypto API, avoiding the Kernel Cryptographic API. Consequently, the removal of xxhash64 from the Crypto API in FIPS mode should now have no impact on btrfs usage. Signed-off-by: Joachim Vandersmissen Signed-off-by: Jeremy Allison --- crypto/testmgr.c | 1 - 1 file changed, 1 deletion(-) diff --git a/crypto/testmgr.c b/crypto/testmgr.c index de1c9bc8551d7..75d74d4eaa41d 100644 --- a/crypto/testmgr.c +++ b/crypto/testmgr.c @@ -5786,7 +5786,6 @@ static const struct alg_test_desc alg_test_descs[] = { #endif .alg = "xxhash64", .test = alg_test_hash, - .fips_allowed = 1, .suite = { .hash = __VECS(xxhash64_tv_template) } From b009a9fa503112acd315304ba054025676b5be79 Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Thu, 16 Apr 2026 17:23:45 -0700 Subject: [PATCH 10/26] When in fips mode, self-test errors must panic. Requested by the lab. Signed-off-by: Jeremy Allison --- lib/crypto/aesgcm.c | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/lib/crypto/aesgcm.c b/lib/crypto/aesgcm.c index 6bba6473fdf34..1aa5b325935b9 100644 --- a/lib/crypto/aesgcm.c +++ b/lib/crypto/aesgcm.c @@ -12,6 +12,7 @@ #include #include +#include static void aesgcm_encrypt_block(const struct crypto_aes_ctx *ctx, void *dst, const void *src) @@ -702,6 +703,8 @@ static int __init libaesgcm_init(void) if (aesgcm_expandkey(&ctx, aesgcm_tv[i].key, aesgcm_tv[i].klen, aesgcm_tv[i].clen - plen)) { pr_err("aesgcm_expandkey() failed on vector %d\n", i); + if (fips_enabled) + panic("aesgcm_expandkey() failed on vector %d\n", i); return -ENODEV; } @@ -710,6 +713,8 @@ static int __init libaesgcm_init(void) aesgcm_tv[i].iv, aesgcm_tv[i].ctext + plen) || memcmp(buf, aesgcm_tv[i].ptext, plen)) { pr_err("aesgcm_decrypt() #1 failed on vector %d\n", i); + if (fips_enabled) + panic("aesgcm_decrypt() #1 failed on vector %d\n", i); return -ENODEV; } @@ -718,6 +723,8 @@ static int __init libaesgcm_init(void) aesgcm_tv[i].alen, aesgcm_tv[i].iv, tagbuf); if (memcmp(buf, aesgcm_tv[i].ctext, plen)) { pr_err("aesgcm_encrypt() failed on vector %d\n", i); + if (fips_enabled) + panic("aesgcm_encrypt() failed on vector %d\n", i); return -ENODEV; } @@ -726,6 +733,8 @@ static int __init libaesgcm_init(void) aesgcm_tv[i].alen, aesgcm_tv[i].iv, tagbuf) || memcmp(buf, aesgcm_tv[i].ptext, plen)) { pr_err("aesgcm_decrypt() #2 failed on vector %d\n", i); + if (fips_enabled) + panic("aesgcm_decrypt() #2 failed on vector %d\n", i); return -ENODEV; } } From 454dc7f40051bdafa63791d3aad3ea8278b40d0a Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Thu, 16 Apr 2026 17:24:36 -0700 Subject: [PATCH 11/26] When in fips mode, self-test errors must panic. Requested by the lab. Signed-off-by: Jeremy Allison --- lib/crypto/aescfb.c | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/lib/crypto/aescfb.c b/lib/crypto/aescfb.c index 749dc1258a44b..3072750c39080 100644 --- a/lib/crypto/aescfb.c +++ b/lib/crypto/aescfb.c @@ -11,6 +11,7 @@ #include #include +#include static void aescfb_encrypt_block(const struct crypto_aes_ctx *ctx, void *dst, const void *src) @@ -220,6 +221,8 @@ static int __init libaescfb_init(void) if (aes_expandkey(&ctx, aescfb_tv[i].key, aescfb_tv[i].klen)) { pr_err("aes_expandkey() failed on vector %d\n", i); + if (fips_enabled) + panic("aes_expandkey() failed on vector %d\n", i); return -ENODEV; } @@ -227,6 +230,8 @@ static int __init libaescfb_init(void) aescfb_tv[i].iv); if (memcmp(buf, aescfb_tv[i].ctext, aescfb_tv[i].len)) { pr_err("aescfb_encrypt() #1 failed on vector %d\n", i); + if (fips_enabled) + panic("aescfb_encrypt() #1 failed on vector %d\n", i); return -ENODEV; } @@ -234,6 +239,8 @@ static int __init libaescfb_init(void) aescfb_decrypt(&ctx, buf, buf, aescfb_tv[i].len, aescfb_tv[i].iv); if (memcmp(buf, aescfb_tv[i].ptext, aescfb_tv[i].len)) { pr_err("aescfb_decrypt() failed on vector %d\n", i); + if (fips_enabled) + panic("aescfb_decrypt() failed on vector %d\n", i); return -ENODEV; } @@ -241,6 +248,8 @@ static int __init libaescfb_init(void) aescfb_encrypt(&ctx, buf, buf, aescfb_tv[i].len, aescfb_tv[i].iv); if (memcmp(buf, aescfb_tv[i].ctext, aescfb_tv[i].len)) { pr_err("aescfb_encrypt() #2 failed on vector %d\n", i); + if (fips_enabled) + panic("aescfb_encrypt() #2 failed on vector %d\n", i); return -ENODEV; } From 2a8d7f9969b802c02f8d1c7090e2a6284096b3d7 Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Thu, 16 Apr 2026 20:05:57 -0700 Subject: [PATCH 12/26] In crypto_kdf108_ctr_generate() there is no minimum length check for the digest to be generated - it must be at least 112 bits. Requested by the lab. Signed-off-by: Jeremy Allison --- crypto/kdf_sp800108.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/crypto/kdf_sp800108.c b/crypto/kdf_sp800108.c index c3f9938e1ad27..50f90a16d7ddd 100644 --- a/crypto/kdf_sp800108.c +++ b/crypto/kdf_sp800108.c @@ -25,6 +25,10 @@ int crypto_kdf108_ctr_generate(struct crypto_shash *kmd, int err = 0; u8 *dst_orig = dst; + /* SP800-131Arev2: minimum 112-bit output length */ + if (fips_enabled && dlen < 112 / 8) + return -EINVAL; + desc->tfm = kmd; while (dlen) { From 08455aeb0dc9a4b6fe4516aad8d275dbbffd3626 Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Mon, 24 Aug 2026 13:41:53 -0700 Subject: [PATCH 13/26] crypto: Kconfig - Make CRYPTO_FIPS depend on the DRBG being built-in When FIPS mode is enabled (via fips=1), there is an absolute need for the DRBG to be available. This is at odds with the fact that the DRBG can be built as a module when in FIPS mode, leaving critical RNG functionality at the whims of userspace. Userspace could simply rmmod the DRBG module, or not provide it at all and thus a different stdrng algorithm could be used without anyone noticing. Additionally, when running a FIPS-enabled userspace, modprobe itself may perform a getrandom() syscall _before_ loading a given module. As a result, there's a possible deadlock scenario where the RNG core (crypto/rng.c) initializes _before_ the DRBG, thereby installing its getrandom() override without having an stdrng algorithm available. Then, when userspace calls getrandom() which redirects to the override in crypto/rng.c, crypto_alloc_rng("stdrng") invokes the UMH (modprobe) to load the DRBG (which is aliased to stdrng). And *then* that modprobe invocation gets stuck at getrandom() because there's no stdrng algorithm available! There are too many risks that come with allowing the DRBG and RNG core to be modular for FIPS mode. Therefore, make CRYPTO_FIPS require the DRBG to be built-in, which in turn makes the DRBG require the RNG core to be built-in. That way, it's guaranteed for these drivers to be built-in when running in FIPS mode. Also clean up the CRYPTO_FIPS option name and remove the CRYPTO_ANSI_CPRNG dependency since it's obsolete for FIPS now. Signed-off-by: Sultan Alsawaf Signed-off-by: Jonathan Maple Signed-off-by: Jeremy Allison --- crypto/Kconfig | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/crypto/Kconfig b/crypto/Kconfig index f6f2cd8c9d1c1..2f2246c9c5242 100644 --- a/crypto/Kconfig +++ b/crypto/Kconfig @@ -24,12 +24,12 @@ if CRYPTO menu "Crypto core or helper" config CRYPTO_FIPS - bool "FIPS 200 compliance" - depends on (CRYPTO_ANSI_CPRNG || CRYPTO_DRBG) && !CRYPTO_MANAGER_DISABLE_TESTS + bool "FIPS compliance" + depends on CRYPTO_DRBG=y && !CRYPTO_MANAGER_DISABLE_TESTS depends on (MODULE_SIG || !MODULES) help This option enables the fips boot option which is - required if you want the system to operate in a FIPS 200 + required if you want the system to operate in a FIPS certification. You should say no unless you know what this is. From 9bcfc9fbf09ae0b71c7809857e615e0456cfa42d Mon Sep 17 00:00:00 2001 From: Herbert Xu Date: Thu, 2 Oct 2025 17:45:39 +0800 Subject: [PATCH 14/26] crypto: rng - Ensure set_ent is always present commit c0d36727bf39bb16ef0a67ed608e279535ebf0da upstream. Ensure that set_ent is always set since only drbg provides it. Fixes: 77ebdabe8de7 ("crypto: af_alg - add extra parameters for DRBG interface") Reported-by: Yiqi Sun Signed-off-by: Herbert Xu Signed-off-by: Greg Kroah-Hartman --- crypto/rng.c | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/crypto/rng.c b/crypto/rng.c index 41aeae0e6bf90..e8e9e2bfdf03d 100644 --- a/crypto/rng.c +++ b/crypto/rng.c @@ -187,6 +187,11 @@ int crypto_del_default_rng(void) EXPORT_SYMBOL_GPL(crypto_del_default_rng); #endif +static void rng_default_set_ent(struct crypto_rng *tfm, const u8 *data, + unsigned int len) +{ +} + int crypto_register_rng(struct rng_alg *alg) { struct crypto_alg *base = &alg->base; @@ -198,6 +203,9 @@ int crypto_register_rng(struct rng_alg *alg) base->cra_flags &= ~CRYPTO_ALG_TYPE_MASK; base->cra_flags |= CRYPTO_ALG_TYPE_RNG; + if (!alg->set_ent) + alg->set_ent = rng_default_set_ent; + return crypto_register_alg(base); } EXPORT_SYMBOL_GPL(crypto_register_rng); From 9ea284ee34b5cb5507a4f4f2f31498a90c200da3 Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Thu, 5 Mar 2026 11:19:36 -0800 Subject: [PATCH 15/26] crypto: rng - Override drivers/char/random in FIPS mode commit-author Herbert Xu commit 8b0beca705b3877e24cccdd672422c66bbd75635 commit-source https://gitlab.com/cki-project/kernel-ark Upstream Status: RHEL only Restore the changes to use the crypto RNG in drivers/char/random which were reverted after 5.18. This reverts commit 297bcb88233101e8d5062729ff3a5f989bad1c3b. This also brings the code up-to-date with respect to centos-stream commit 9de3a7339793d3c516b9305a8854267156f90c53 so that changes that were made after the kernel-ark revert have been brought in. Signed-off-by: Herbert Xu Signed-off-by: Jeremy Allison --- include/linux/crypto.h | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/include/linux/crypto.h b/include/linux/crypto.h index cd78d16ee5d65..8c7f5331ba4fa 100644 --- a/include/linux/crypto.h +++ b/include/linux/crypto.h @@ -133,7 +133,8 @@ #define CRYPTO_TFM_REQ_FORBID_WEAK_KEYS 0x00000100 #define CRYPTO_TFM_REQ_MAY_SLEEP 0x00000200 #define CRYPTO_TFM_REQ_MAY_BACKLOG 0x00000400 -#define CRYPTO_TFM_REQ_NEED_RESEED 0x00000800 +#define CRYPTO_TFM_REQ_ON_STACK 0x00000800 +#define CRYPTO_TFM_REQ_NEED_RESEED 0x00001000 #define CRYPTO_TFM_FIPS_COMPLIANCE 0x80000000 From 84ce8364180b5f372d489dbe2c4a0549e406f85b Mon Sep 17 00:00:00 2001 From: Sultan Alsawaf Date: Fri, 27 Jun 2025 19:06:18 -0700 Subject: [PATCH 16/26] crypto: rng - Implement fast per-CPU DRBG instances When the kernel is booted with fips=1, the RNG exposed to userspace is hijacked away from the CRNG and redirects to crypto_devrandom_read_iter(), which utilizes the DRBG. Notably, crypto_devrandom_read_iter() maintains just two global DRBG instances _for the entire system_, and the two instances serve separate request types: one instance for GRND_RANDOM requests (crypto_reseed_rng), and one instance for non-GRND_RANDOM requests (crypto_default_rng). So in essence, for requests of a single type, there is just one global RNG for all CPUs in the entire system, which scales _very_ poorly. To make matters worse, the temporary buffer used to ferry data between the DRBG and userspace is woefully small at only 256 bytes, which doesn't do a good job of maximizing throughput from the DRBG. This results in lost performance when userspace requests >256 bytes; it is observed that DRBG throughput improves by 70% on an i9-13900H when the buffer size is increased to 4096 bytes (one page). Going beyond the size of one page up to the DRBG maximum request limit of 65536 bytes produces diminishing returns of only 3% improved throughput in comparison. And going below the size of one page produces progressively less throughput at each power of 2: there's a 5% loss going from 4096 bytes to 2048 bytes and a 9% loss going from 2048 bytes to 1024 bytes. Thus, this implements per-CPU DRBG instances utilizing a page-sized buffer for each CPU to utilize the DRBG itself more effectively. On top of that, for non-GRND_RANDOM requests, the DRBG's operations now occur under a local lock that disables preemption on non-PREEMPT_RT kernels, which not only keeps each CPU's DRBG instance isolated from another, but also improves temporal cache locality while the DRBG actively generates a new string of random bytes. Prefaulting one user destination page at a time is also employed to prevent a DRBG instance from getting blocked on page faults, thereby maximizing the use of the DRBG so that the only bottleneck is the DRBG itself. Signed-off-by: Sultan Alsawaf --- crypto/rng.c | 523 +++++++++++++++++++++++++++++++++++++++++++-------- 1 file changed, 442 insertions(+), 81 deletions(-) diff --git a/crypto/rng.c b/crypto/rng.c index e8e9e2bfdf03d..84ddb1531d67b 100644 --- a/crypto/rng.c +++ b/crypto/rng.c @@ -6,6 +6,9 @@ * * Copyright (c) 2008 Neil Horman * Copyright (c) 2015 Herbert Xu + * + * Copyright (C) 2025 Ctrl IQ, Inc. + * Author: Sultan Alsawaf */ #include @@ -26,13 +29,39 @@ #include "internal.h" -static ____cacheline_aligned_in_smp DEFINE_RT_MUTEX(crypto_reseed_rng_lock); -static struct crypto_rng *crypto_reseed_rng; static ____cacheline_aligned_in_smp DEFINE_RT_MUTEX(crypto_default_rng_lock); struct crypto_rng *crypto_default_rng; EXPORT_SYMBOL_GPL(crypto_default_rng); static unsigned int crypto_default_rng_refcnt; +/* + * Per-CPU RNG instances are only used by crypto_devrandom_rng. The global RNG, + * crypto_default_rng, is only used directly by other drivers. + * + * Per-CPU instances of the DRBG are efficient because the DRBG itself supports + * an arbitrary number of instances and can be seeded on a per-CPU basis. + * + * Specifically, the DRBG is seeded by the CRNG and the Jitter RNG. The CRNG is + * globally accessible and is already per-CPU. And while the Jitter RNG _isn't_ + * per-CPU, creating a DRBG instance also creates a Jitter RNG instance; + * therefore, per-CPU DRBG instances implies per-CPU Jitter RNG instances. + */ +struct cpu_rng_inst { + local_lock_t lock; + struct rt_mutex mlock; + struct crypto_rng *rng; + void *page; +}; + +static DEFINE_PER_CPU_ALIGNED(struct cpu_rng_inst, pcpu_default_rng) = { + .lock = INIT_LOCAL_LOCK(pcpu_default_rng.lock), + .mlock = __RT_MUTEX_INITIALIZER(pcpu_default_rng.mlock) +}; +static DEFINE_PER_CPU_ALIGNED(struct cpu_rng_inst, pcpu_reseed_rng) = { + /* The reseed instances don't use the local lock */ + .mlock = __RT_MUTEX_INITIALIZER(pcpu_reseed_rng.mlock) +}; + int crypto_rng_reset(struct crypto_rng *tfm, const u8 *seed, unsigned int slen) { u8 *buf = NULL; @@ -157,34 +186,54 @@ void crypto_put_default_rng(void) EXPORT_SYMBOL_GPL(crypto_put_default_rng); #if defined(CONFIG_CRYPTO_RNG) || defined(CONFIG_CRYPTO_RNG_MODULE) -static int crypto_del_rng(struct crypto_rng **rngp, unsigned int *refcntp, - struct rt_mutex *lock) -{ - int err = -EBUSY; +#define down_read_del_pcpu_rwsem() down_read(&del_pcpu_rwsem) +#define up_read_del_pcpu_rwsem() up_read(&del_pcpu_rwsem) +static DECLARE_RWSEM(del_pcpu_rwsem); - rt_mutex_lock(lock); - if (refcntp && *refcntp) - goto out; - - crypto_free_rng(*rngp); - *rngp = NULL; +static void crypto_del_pcpu_rng(struct cpu_rng_inst __percpu *pcri) +{ + int cpu; - err = 0; + for_each_possible_cpu(cpu) { + struct cpu_rng_inst *cri = per_cpu_ptr(pcri, cpu); -out: - rt_mutex_unlock(lock); - - return err; + if (cri->rng) { + crypto_free_rng(cri->rng); + cri->rng = NULL; + } + } } int crypto_del_default_rng(void) { - return crypto_del_rng(&crypto_default_rng, &crypto_default_rng_refcnt, - &crypto_default_rng_lock) ?: - crypto_del_rng(&crypto_reseed_rng, NULL, - &crypto_reseed_rng_lock); + bool busy; + + rt_mutex_lock(&crypto_default_rng_lock); + if (!(busy = crypto_default_rng_refcnt)) { + crypto_free_rng(crypto_default_rng); + crypto_default_rng = NULL; + } + rt_mutex_unlock(&crypto_default_rng_lock); + if (busy) + return -EBUSY; + + if (!down_write_trylock(&del_pcpu_rwsem)) + return -EBUSY; + + crypto_del_pcpu_rng(&pcpu_default_rng); + crypto_del_pcpu_rng(&pcpu_reseed_rng); + up_write(&del_pcpu_rwsem); + + return 0; } EXPORT_SYMBOL_GPL(crypto_del_default_rng); +#else +static inline void down_read_del_pcpu_rwsem(void) +{ +} +static inline void up_read_del_pcpu_rwsem(void) +{ +} #endif static void rng_default_set_ent(struct crypto_rng *tfm, const u8 *data, @@ -245,81 +294,345 @@ void crypto_unregister_rngs(struct rng_alg *algs, int count) } EXPORT_SYMBOL_GPL(crypto_unregister_rngs); -static ssize_t crypto_devrandom_read_iter(struct iov_iter *iter, bool reseed) +/* + * On non-PREEMPT_RT kernels, local locks disable preemption. When there's no + * rng allocated, one must be allocated by calling crypto_get_rng(), which can + * sleep. Therefore, crypto_get_rng() cannot be called under local_lock(), so if + * our CPU's RNG instance doesn't have an rng allocated, we drop the local lock + * and take a mutex lock instead. After the local lock is dropped, the current + * task can be freely migrated to another CPU, which means that calling + * local_lock() again might not result in the same instance getting locked as + * before. That's why this function exists: to loop on calling local_lock() and + * allocating an rng as needed with crypto_get_rng() until the current CPU's + * instance is found to have an rng allocated. If crypto_get_rng() ever fails, + * this function returns an error even if there are instances for other CPUs + * which _do_ have an rng allocated. + */ +static __always_inline struct cpu_rng_inst * +lock_default_rng(struct crypto_rng **rng) __acquires(&cri->lock) { - struct crypto_rng *rng; - u8 tmp[256]; - ssize_t ret; + struct cpu_rng_inst __percpu *pcri = &pcpu_default_rng; + struct cpu_rng_inst *cri; + int ret; + + while (1) { + local_lock(&pcri->lock); + cri = this_cpu_ptr(pcri); + /* + * cri->rng may have transitioned from non-NULL to NULL, but + * underneath down_read_del_pcpu_rwsem() it can only transition + * from NULL to non-NULL. This may occur on a different CPU, + * thus cri->rng must be read atomically to prevent data races; + * this elides mlock by pairing with the WRITE_ONCE() in the + * slow path below. + * + * + * And if cri->rng is non-NULL, then it is good to go. To avoid + * data races due to load speculation on torn cri->rng loads + * _after_ the NULL check, one of the following is required: + * 1. smp_acquire__after_ctrl_dep() in the if-statement + * 2. All cri->rng reads are performed with READ_ONCE() + * 3. cri->rng is never read again outside this function + * + * Option #3 yields the best performance, so this function + * provides the rng pointer as an output for the caller to use. + */ + *rng = READ_ONCE(cri->rng); + if (likely(*rng)) + return cri; + + /* + * Slow path: there's no rng currently allocated to this instance. + * Release the local lock and acquire this instance's mlock to + * perform the allocation. + * + * Note that this task may be migrated to a different CPU now! + */ + local_unlock(&cri->lock); + rt_mutex_lock(&cri->mlock); + if (!cri->rng) { + struct crypto_rng *new_rng = NULL; + + ret = crypto_get_rng(&new_rng); + if (ret) { + rt_mutex_unlock(&cri->mlock); + break; + } - if (unlikely(!iov_iter_count(iter))) - return 0; + /* + * Pairs with READ_ONCE() above, because we might not be + * on the same CPU anymore as when we first got `cri`. + */ + WRITE_ONCE(cri->rng, new_rng); + } + rt_mutex_unlock(&cri->mlock); + } - if (reseed) { - u32 flags = 0; + /* + * Even if this task got migrated to another CPU that _does_ have an rng + * allocated, just bail out if crypto_get_rng() ever fails in order to + * avoid looping forever. + */ + return ERR_PTR(ret); +} - /* If reseeding is requested, acquire a lock on - * crypto_reseed_rng so it is not swapped out until - * the initial random bytes are generated. - * - * The algorithm implementation is also protected with - * a separate mutex (drbg->drbg_mutex) around the - * reseed-and-generate operation. +static __always_inline struct cpu_rng_inst * +lock_reseed_rng(struct crypto_rng **rng) __acquires(&cri->mlock) +{ + struct cpu_rng_inst __percpu *pcri = &pcpu_reseed_rng; + struct cpu_rng_inst *cri; + int ret; + + /* + * Use whichever CPU this task is currently running on, knowing full + * well that the task can freely migrate to other CPUs. The reseed RNG + * requires holding a lock across the entire devrandom read, so that + * another task cannot extract entropy from the same seed. In other + * words, when reseeding is requested, reseeding must be done every time + * every time mlock is acquired. + */ + cri = raw_cpu_ptr(pcri); + rt_mutex_lock(&cri->mlock); + if (likely(cri->rng)) { + /* + * Since this rng instance wasn't just allocated, it needs to be + * explicitly reseeded. New rng instances are seeded on creation + * in crypto_get_rng() and thus don't need explicit reseeding. */ - rt_mutex_lock(&crypto_reseed_rng_lock); + crypto_tfm_set_flags(crypto_rng_tfm(cri->rng), + CRYPTO_TFM_REQ_NEED_RESEED); + } else { + ret = crypto_get_rng(&cri->rng); + if (ret) { + rt_mutex_unlock(&cri->mlock); + return ERR_PTR(ret); + } + } - /* If crypto_default_rng is not set, it will be seeded - * at creation in __crypto_get_default_rng and thus no - * reseeding is needed. - */ - if (crypto_reseed_rng) - flags |= CRYPTO_TFM_REQ_NEED_RESEED; + *rng = cri->rng; + return cri; +} - ret = crypto_get_rng(&crypto_reseed_rng); - if (ret) { - rt_mutex_unlock(&crypto_reseed_rng_lock); - return ret; +#define lock_local_rng(rng, reseed) \ + ({ (reseed) ? lock_reseed_rng(rng) : lock_default_rng(rng); }) + +#define unlock_local_rng(cri, reseed) \ +do { \ + if (reseed) \ + rt_mutex_unlock(&(cri)->mlock); \ + else \ + local_unlock(&(cri)->lock); \ +} while (0) + +static __always_inline void +clear_rng_page(struct cpu_rng_inst *cri, size_t count) +{ + /* For zeroing a whole page, clear_page() is faster than memset() */ + count < PAGE_SIZE ? memset(cri->page, 0, count) : clear_page(cri->page); +} + +static ssize_t crypto_devrandom_read_iter(struct iov_iter *iter, bool reseed) +{ + /* lock_local_rng() puts us in atomic context for !reseed on non-RT */ + const bool atomic = !reseed && !IS_ENABLED(CONFIG_PREEMPT_RT); + const bool user_no_reseed = !reseed && user_backed_iter(iter); + size_t ulen, page_dirty_len = 0; + struct cpu_rng_inst *cri; + struct crypto_rng *rng; + void __user *uaddr; + struct page *upage; + ssize_t ret = 0; + + if (unlikely(!iov_iter_count(iter))) + return 0; + + /* Set up the starting user destination address and length */ + if (user_no_reseed) { + if (iter_is_ubuf(iter)) { + uaddr = iter->ubuf + iter->iov_offset; + ulen = iov_iter_count(iter); + } else if (iter_is_iovec(iter)) { + uaddr = iter_iov_addr(iter); + ulen = iter_iov_len(iter); + } else { + /* + * ITER_UBUF and ITER_IOVEC are the only user-backed + * iters. Bug out if a new user-backed iter appears. + */ + BUG(); } + } - rng = crypto_reseed_rng; - crypto_tfm_set_flags(crypto_rng_tfm(rng), flags); - } else { - ret = crypto_get_default_rng(); - if (ret) - return ret; - rng = crypto_default_rng; + /* Prevent rngs from getting deleted from per-CPU RNG instances */ + down_read_del_pcpu_rwsem(); +restart: + /* + * Pin the user page backing the current user destination address, + * potentially prefaulting to allocate a page for the destination. By + * prefaulting without the RNG lock held, the DRBG won't be blocked by + * time spent on page faults for this task, and thus the DRBG can still + * be used by other tasks. + */ + if (user_no_reseed && pin_user_pages_fast((unsigned long)uaddr, 1, + FOLL_WRITE, &upage) != 1) + goto up_rwsem; + + cri = lock_local_rng(&rng, reseed); + if (IS_ERR(cri)) { + if (!ret) + ret = PTR_ERR(cri); + goto unpin_upage; } - for (;;) { - size_t i, copied; + while (1) { + size_t copied, i = min(iov_iter_count(iter), PAGE_SIZE); + bool resched_without_lock = false; int err; - i = min_t(size_t, iov_iter_count(iter), sizeof(tmp)); - err = crypto_rng_get_bytes(rng, tmp, i); + /* + * Generate up to one page at a time, and align to a page + * boundary so we only need to pin one user page at a time. + */ + if (user_no_reseed) + i = min3(i, PAGE_SIZE - offset_in_page(uaddr), ulen); + + /* + * On non-PREEMPT_RT kernels, local locks disable preemption. + * The DRBG's generate() function has a mutex lock, which could + * mean that we'll schedule while atomic if the mutex lock + * sleeps. However, that will never happen if we ensure that + * there's never any contention on the DRBG's mutex lock while + * we're atomic! Our local lock ensures calls to the DRBG are + * always serialized, so there's no contention from here. And + * the DRBG only uses its mutex lock from one other path, when + * an instance of the DRBG is freshly allocated, which we only + * do from crypto_get_rng(). So the DRBG's mutex lock is + * guaranteed to not have contention when we call generate() and + * thus it'll never sleep here. And of course, nothing else in + * generate() ever sleeps. + */ + err = crypto_rng_get_bytes(rng, cri->page, i); if (err) { - ret = ret ?: err; + if (!ret) + ret = err; break; } - copied = copy_to_iter(tmp, i, iter); - ret += copied; + /* + * Record the number of bytes used in cri->page and either copy + * directly to the user address without faulting, or copy to the + * iter which is always backed by kernel memory when !reseed && + * !user_backed_iter(). When reseed == true, the iter may be + * backed by user memory, but we copy to it with the possibility + * of page faults anyway because we need to hold the lock across + * the entire call; this is why a mutex is used instead of a + * local lock for the reseed RNG, to permit sleeping without + * yielding the DRBG instance. + */ + page_dirty_len = max(i, page_dirty_len); + if (user_no_reseed) { + err = copy_to_user_nofault(uaddr, cri->page, i); + if (err >= 0) { + iov_iter_advance(iter, i - err); + ret += i - err; + } + if (err) + break; + } else { + /* + * We know that copying from cri->page is safe, so use + * _copy_to_iter() directly to skip check_copy_size(). + */ + copied = _copy_to_iter(cri->page, i, iter); + ret += copied; + if (copied != i) + break; + } - if (!iov_iter_count(iter) || copied != i) + /* + * Quit when either the requested number of bytes have been + * generated or there is a pending signal. + */ + if (!iov_iter_count(iter) || signal_pending(current)) break; - BUILD_BUG_ON(PAGE_SIZE % sizeof(tmp) != 0); - if (ret % PAGE_SIZE == 0) { - if (signal_pending(current)) - break; - cond_resched(); + /* Compute the next user destination address and length */ + if (user_no_reseed) { + ulen -= i; + if (likely(ulen)) { + uaddr += i; + } else { + /* + * This path is only reachable by ITER_IOVEC + * because ulen is initialized to the request + * size for ITER_UBUF, and therefore ITER_UBUF + * will always quit at the iov_iter_count() + * check above before ulen can become zero. + * + * iter->iov_offset is guaranteed to be zero + * here, so iter_iov_{addr|len}() isn't needed. + */ + uaddr = iter_iov(iter)->iov_base; + ulen = iter_iov(iter)->iov_len; + } + + unpin_user_page(upage); } + + /* + * Reschedule right now if needed and we're not atomic. If we're + * atomic, then we must first drop the lock to reschedule. + */ + if (need_resched()) { + if (atomic) + resched_without_lock = true; + else + cond_resched(); + } + + /* + * Optimistically try to pin the next user page without + * faulting, so we don't need to clear cri->page and drop the + * lock on every iteration. If this fails, we fall back to + * pinning with the option to prefault. + */ + if (user_no_reseed && !resched_without_lock && + pin_user_pages_fast_only((unsigned long)uaddr, 1, + FOLL_WRITE, &upage) == 1) + continue; + + /* + * Restart if either rescheduling is needed (and requires + * dropping the lock since we're atomic) or the optimistic page + * pinning attempt failed. + * + * This always implies `reseed == false`, so unlock_local_rng() + * can just be passed `false` for reseed to eliminate a branch. + */ + if (resched_without_lock || user_no_reseed) { + /* + * Clear the buffer of our latest random bytes before + * unlocking and potentially migrating CPUs, in which + * case we wouldn't have the same `cri` anymore. + */ + clear_rng_page(cri, page_dirty_len); + unlock_local_rng(cri, false); + page_dirty_len = 0; + if (resched_without_lock) + cond_resched(); + goto restart; + } } - if (reseed) - rt_mutex_unlock(&crypto_reseed_rng_lock); - else - crypto_put_default_rng(); - memzero_explicit(tmp, sizeof(tmp)); - return ret ? ret : -EFAULT; + if (page_dirty_len) + clear_rng_page(cri, page_dirty_len); + unlock_local_rng(cri, reseed); +unpin_upage: + if (user_no_reseed) + unpin_user_page(upage); +up_rwsem: + up_read_del_pcpu_rwsem(); + return ret ? ret : -EFAULT; } static const struct random_extrng crypto_devrandom_rng = { @@ -327,23 +640,71 @@ static const struct random_extrng crypto_devrandom_rng = { .owner = THIS_MODULE, }; -static int __init crypto_rng_init(void) +static void free_pcpu_inst(struct cpu_rng_inst __percpu *pcri) { - int err; + int cpu; - if (fips_enabled) { - err = crypto_get_default_rng(); - if (err) - return err; - crypto_put_default_rng(); - random_register_extrng(&crypto_devrandom_rng); + for_each_possible_cpu(cpu) { + struct cpu_rng_inst *cri = per_cpu_ptr(pcri, cpu); + + if (cri->rng) + crypto_free_rng(cri->rng); + + free_page((unsigned long)cri->page); + } +} + +static int __init alloc_pcpu_inst(struct cpu_rng_inst __percpu *pcri) +{ + int cpu; + + for_each_possible_cpu(cpu) { + struct cpu_rng_inst *cri = per_cpu_ptr(pcri, cpu); + + cri->page = (void *)__get_free_page(GFP_KERNEL); + if (!cri->page) + goto err_page_alloc; + + local_lock_init(&cri->lock); } + return 0; + +err_page_alloc: + while (cpu--) + free_page((unsigned long)per_cpu_ptr(pcri, cpu)->page); + return -ENOMEM; +} + +static int __init crypto_rng_init(void) +{ + int ret; + + if (!fips_enabled) + return 0; + + ret = alloc_pcpu_inst(&pcpu_default_rng); + if (ret) + return ret; + + ret = alloc_pcpu_inst(&pcpu_reseed_rng); + if (ret) + goto free_pcpu_default; + + random_register_extrng(&crypto_devrandom_rng); + return 0; + +free_pcpu_default: + free_pcpu_inst(&pcpu_default_rng); + return ret; } static void __exit crypto_rng_exit(void) { random_unregister_extrng(); + + free_pcpu_inst(&pcpu_default_rng); + free_pcpu_inst(&pcpu_reseed_rng); } late_initcall(crypto_rng_init); From 5604cfc4b6e5a22bd4cc27d4215781d08c717306 Mon Sep 17 00:00:00 2001 From: Sultan Alsawaf Date: Fri, 1 Aug 2025 15:19:15 -0700 Subject: [PATCH 17/26] random: Restrict extrng registration to init time It is technically a risk to permit extrng registration by modules after kernel init completes. Since there is only one user of the extrng interface and it is imperative that it is the _only_ registered extrng for FIPS compliance, restrict the extrng registration interface to only permit registration during kernel init and only from built-in drivers. This also eliminates the risks associated with the extrng interface itself being designed to solely accommodate a single registration, which would therefore permit the registered extrng to be overridden or even removed by an unrelated module. Signed-off-by: Sultan Alsawaf Signed-off-by: Jonathan Maple --- crypto/rng.c | 12 +------- drivers/char/random.c | 70 ++++++++---------------------------------- include/linux/random.h | 17 +++++----- 3 files changed, 20 insertions(+), 79 deletions(-) diff --git a/crypto/rng.c b/crypto/rng.c index 84ddb1531d67b..551236f4278c5 100644 --- a/crypto/rng.c +++ b/crypto/rng.c @@ -636,8 +636,7 @@ static ssize_t crypto_devrandom_read_iter(struct iov_iter *iter, bool reseed) } static const struct random_extrng crypto_devrandom_rng = { - .extrng_read_iter = crypto_devrandom_read_iter, - .owner = THIS_MODULE, + .extrng_read_iter = crypto_devrandom_read_iter }; static void free_pcpu_inst(struct cpu_rng_inst __percpu *pcri) @@ -699,16 +698,7 @@ static int __init crypto_rng_init(void) return ret; } -static void __exit crypto_rng_exit(void) -{ - random_unregister_extrng(); - - free_pcpu_inst(&pcpu_default_rng); - free_pcpu_inst(&pcpu_reseed_rng); -} - late_initcall(crypto_rng_init); -module_exit(crypto_rng_exit); MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("Random Number Generator"); diff --git a/drivers/char/random.c b/drivers/char/random.c index 5c09d6b360623..cb5a4205e16e6 100644 --- a/drivers/char/random.c +++ b/drivers/char/random.c @@ -51,7 +51,6 @@ #include #include #include -#include #include #include #include @@ -341,7 +340,7 @@ static void crng_fast_key_erasure(u8 key[CHACHA_KEY_SIZE], /* * Hook for external RNG. */ -static const struct random_extrng __rcu *extrng; +static const struct random_extrng *extrng __ro_after_init; /* * This function returns a ChaCha state that you may use for generating @@ -999,18 +998,12 @@ void __init add_bootloader_randomness(const void *buf, size_t len) credit_init_bits(len * 8); } -void random_register_extrng(const struct random_extrng *rng) +void __init random_register_extrng(const struct random_extrng *rng) { - rcu_assign_pointer(extrng, rng); + /* Don't allow the registered extrng to be overridden */ + BUG_ON(extrng); + extrng = rng; } -EXPORT_SYMBOL_GPL(random_register_extrng); - -void random_unregister_extrng(void) -{ - RCU_INIT_POINTER(extrng, NULL); - synchronize_rcu(); -} -EXPORT_SYMBOL_GPL(random_unregister_extrng); #if IS_ENABLED(CONFIG_VMGENID) static BLOCKING_NOTIFIER_HEAD(vmfork_chain); @@ -1421,7 +1414,6 @@ SYSCALL_DEFINE3(getrandom, char __user *, ubuf, size_t, len, unsigned int, flags { struct iov_iter iter; int ret; - const struct random_extrng *rng; if (flags & ~(GRND_NONBLOCK | GRND_RANDOM | GRND_INSECURE)) return -EINVAL; @@ -1433,19 +1425,11 @@ SYSCALL_DEFINE3(getrandom, char __user *, ubuf, size_t, len, unsigned int, flags if ((flags & (GRND_INSECURE | GRND_RANDOM)) == (GRND_INSECURE | GRND_RANDOM)) return -EINVAL; - rcu_read_lock(); - rng = rcu_dereference(extrng); - if (rng && !try_module_get(rng->owner)) - rng = NULL; - rcu_read_unlock(); - - if (rng) { + if (extrng) { ret = import_ubuf(ITER_DEST, ubuf, len, &iter); if (unlikely(ret)) return ret; - ret = rng->extrng_read_iter(&iter, !!(flags & GRND_RANDOM)); - module_put(rng->owner); - return ret; + return extrng->extrng_read_iter(&iter, !!(flags & GRND_RANDOM)); } if (!crng_ready() && !(flags & GRND_INSECURE)) { @@ -1616,52 +1600,24 @@ static int random_fasync(int fd, struct file *filp, int on) static int random_open(struct inode *inode, struct file *filp) { - const struct random_extrng *rng; - - rcu_read_lock(); - rng = rcu_dereference(extrng); - if (rng && !try_module_get(rng->owner)) - rng = NULL; - rcu_read_unlock(); - - if (!rng) - return 0; - - filp->f_op = &extrng_random_fops; - filp->private_data = rng->owner; + if (extrng) + filp->f_op = &extrng_random_fops; return 0; } static int urandom_open(struct inode *inode, struct file *filp) { - const struct random_extrng *rng; + if (extrng) + filp->f_op = &extrng_urandom_fops; - rcu_read_lock(); - rng = rcu_dereference(extrng); - if (rng && !try_module_get(rng->owner)) - rng = NULL; - rcu_read_unlock(); - - if (!rng) - return 0; - - filp->f_op = &extrng_urandom_fops; - filp->private_data = rng->owner; - - return 0; -} - -static int extrng_release(struct inode *inode, struct file *filp) -{ - module_put(filp->private_data); return 0; } static ssize_t extrng_read_iter(struct kiocb *kiocb, struct iov_iter *iter) { - return rcu_dereference_raw(extrng)->extrng_read_iter(iter, false); + return extrng->extrng_read_iter(iter, false); } const struct file_operations random_fops = { @@ -1698,7 +1654,6 @@ static const struct file_operations extrng_random_fops = { .compat_ioctl = compat_ptr_ioctl, .fasync = random_fasync, .llseek = noop_llseek, - .release = extrng_release, .splice_read = copy_splice_read, .splice_write = iter_file_splice_write, }; @@ -1711,7 +1666,6 @@ static const struct file_operations extrng_urandom_fops = { .compat_ioctl = compat_ptr_ioctl, .fasync = random_fasync, .llseek = noop_llseek, - .release = extrng_release, .splice_read = copy_splice_read, .splice_write = iter_file_splice_write, }; diff --git a/include/linux/random.h b/include/linux/random.h index 8a52424fd0d50..53b79b68a9546 100644 --- a/include/linux/random.h +++ b/include/linux/random.h @@ -9,13 +9,6 @@ #include -struct iov_iter; - -struct random_extrng { - ssize_t (*extrng_read_iter)(struct iov_iter *iter, bool reseed); - struct module *owner; -}; - struct notifier_block; void add_device_randomness(const void *buf, size_t len); @@ -164,11 +157,15 @@ int random_prepare_cpu(unsigned int cpu); int random_online_cpu(unsigned int cpu); #endif -void random_register_extrng(const struct random_extrng *rng); -void random_unregister_extrng(void); - #ifndef MODULE extern const struct file_operations random_fops, urandom_fops; + +struct iov_iter; +struct random_extrng { + ssize_t (*extrng_read_iter)(struct iov_iter *iter, bool reseed); +}; + +void __init random_register_extrng(const struct random_extrng *rng); #endif #endif /* _LINUX_RANDOM_H */ From 670c8be2fea31532c3b56780239c6f172f7df0f4 Mon Sep 17 00:00:00 2001 From: Sultan Alsawaf Date: Fri, 25 Jul 2025 14:32:37 -0700 Subject: [PATCH 18/26] crypto: rng - Only allow the DRBG to register as "stdrng" in FIPS mode In FIPS mode, the DRBG must take precedence over all stdrng algorithms. The only problem standing in the way of this is that a different stdrng algorithm could get registered and utilized before the DRBG is registered, and since crypto_alloc_rng() only allocates an stdrng algorithm when there's no existing allocation, this means that it's possible for the wrong stdrng algorithm to remain in use indefinitely. This issue is also often impossible to observe from userspace; an RNG other than the DRBG could be used somewhere in the kernel and userspace would be none the wiser. To ensure this can never happen, only allow stdrng instances from the DRBG to be registered when running in FIPS mode. This works since the previous commit forces the DRBG to be built into the kernel when CONFIG_CRYPTO_FIPS is enabled, so the DRBG's presence is guaranteed when fips_enabled is true. Signed-off-by: Sultan Alsawaf Signed-off-by: Jonathan Maple --- crypto/rng.c | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/crypto/rng.c b/crypto/rng.c index 551236f4278c5..5e601af94ca3f 100644 --- a/crypto/rng.c +++ b/crypto/rng.c @@ -33,6 +33,7 @@ static ____cacheline_aligned_in_smp DEFINE_RT_MUTEX(crypto_default_rng_lock); struct crypto_rng *crypto_default_rng; EXPORT_SYMBOL_GPL(crypto_default_rng); static unsigned int crypto_default_rng_refcnt; +static bool drbg_registered __ro_after_init; /* * Per-CPU RNG instances are only used by crypto_devrandom_rng. The global RNG, @@ -248,6 +249,19 @@ int crypto_register_rng(struct rng_alg *alg) if (alg->seedsize > PAGE_SIZE / 8) return -EINVAL; + /* + * In FIPS mode, the DRBG must take precedence over all other "stdrng" + * algorithms. Therefore, forbid registration of a non-DRBG stdrng in + * FIPS mode. All of the DRBG's driver names are prefixed with "drbg_". + * This also stops new stdrng instances from getting registered after it + * is known that the DRBG is registered, so a new module can't come in + * and pretend to be the DRBG. And when CONFIG_CRYPTO_FIPS is enabled, + * the DRBG is built into the kernel directly; it can't be a module. + */ + if (fips_enabled && !strcmp(base->cra_name, "stdrng") && + (drbg_registered || strncmp(base->cra_driver_name, "drbg_", 5))) + return -EINVAL; + base->cra_type = &crypto_rng_type; base->cra_flags &= ~CRYPTO_ALG_TYPE_MASK; base->cra_flags |= CRYPTO_ALG_TYPE_RNG; @@ -275,6 +289,18 @@ int crypto_register_rngs(struct rng_alg *algs, int count) goto err; } + /* + * Track when the DRBG is registered in FIPS mode. The DRBG calls + * crypto_register_rngs() to register its stdrng instances, and since + * crypto_register_rng() only allows stdrng instances from the DRBG in + * FIPS mode, a successful stdrng registration means it was the DRBG. + * Just check the first alg in the array to see if it's called "stdrng", + * since all of the DRBG's algorithms are named "stdrng". Once + * drbg_registered is set to true, this if-statement is always false. + */ + if (fips_enabled && !strcmp(algs->base.cra_name, "stdrng")) + drbg_registered = true; + return 0; err: From 6367294d5a5781a95d3c2ef7368302e4ab638b5f Mon Sep 17 00:00:00 2001 From: Sultan Alsawaf Date: Tue, 23 Jun 2026 13:41:31 -0700 Subject: [PATCH 19/26] crypto: rng - Fix tabs vs spaces in the per-CPU DRBG code The 6.18.y version of "crypto: rng - Implement fast per-CPU DRBG instances" picked up a few spots that use spaces where the ciqlts9_6 tree's version [1] uses tabs: the lock_default_rng() comment's numbered list, the line continuations in the unlock_local_rng() macro, and a brace in crypto_devrandom_read_iter(). A nearby block comment was also missing the space before its '*'. Fix them up. [1] https://github.com/ctrliq/kernel-src-tree/commit/b0c560a37518cad09488bab031e1c6e817d65cb8 Assisted-by: Claude:claude-opus-4-8 Signed-off-by: Sultan Alsawaf --- crypto/rng.c | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/crypto/rng.c b/crypto/rng.c index 5e601af94ca3f..5fa9b680e3257 100644 --- a/crypto/rng.c +++ b/crypto/rng.c @@ -356,9 +356,9 @@ lock_default_rng(struct crypto_rng **rng) __acquires(&cri->lock) * And if cri->rng is non-NULL, then it is good to go. To avoid * data races due to load speculation on torn cri->rng loads * _after_ the NULL check, one of the following is required: - * 1. smp_acquire__after_ctrl_dep() in the if-statement - * 2. All cri->rng reads are performed with READ_ONCE() - * 3. cri->rng is never read again outside this function + * 1. smp_acquire__after_ctrl_dep() in the if-statement + * 2. All cri->rng reads are performed with READ_ONCE() + * 3. cri->rng is never read again outside this function * * Option #3 yields the best performance, so this function * provides the rng pointer as an output for the caller to use. @@ -443,11 +443,11 @@ lock_reseed_rng(struct crypto_rng **rng) __acquires(&cri->mlock) ({ (reseed) ? lock_reseed_rng(rng) : lock_default_rng(rng); }) #define unlock_local_rng(cri, reseed) \ -do { \ - if (reseed) \ - rt_mutex_unlock(&(cri)->mlock); \ - else \ - local_unlock(&(cri)->lock); \ +do { \ + if (reseed) \ + rt_mutex_unlock(&(cri)->mlock); \ + else \ + local_unlock(&(cri)->lock); \ } while (0) static __always_inline void @@ -482,9 +482,9 @@ static ssize_t crypto_devrandom_read_iter(struct iov_iter *iter, bool reseed) ulen = iter_iov_len(iter); } else { /* - * ITER_UBUF and ITER_IOVEC are the only user-backed - * iters. Bug out if a new user-backed iter appears. - */ + * ITER_UBUF and ITER_IOVEC are the only user-backed + * iters. Bug out if a new user-backed iter appears. + */ BUG(); } } @@ -647,7 +647,7 @@ static ssize_t crypto_devrandom_read_iter(struct iov_iter *iter, bool reseed) if (resched_without_lock) cond_resched(); goto restart; - } + } } if (page_dirty_len) From 4aa4e027168f7ef066f1d7dccd43594acf477246 Mon Sep 17 00:00:00 2001 From: Sultan Alsawaf Date: Tue, 23 Jun 2026 13:09:41 -0700 Subject: [PATCH 20/26] crypto: rng - Make the per-CPU DRBG instances permanent The per-CPU DRBG instances used to be torn down by crypto_del_default_rng() under del_pcpu_rwsem, and the read path took that rwsem as a reader to keep an instance from being freed out from under it. That machinery only made sense back when the extrng override could be unregistered and the DRBG could be built as a module. That's no longer the case. extrng registration is now restricted to init time from built-in drivers, and FIPS mode requires the DRBG to be built-in, so the registered DRBG can't be unregistered or swapped out. As such, the per-CPU instances are never torn down, and the deletion rwsem just adds a lock to the hot read path for no reason. Drop the deletion rwsem and crypto_del_pcpu_rng(), and stop freeing the per-CPU instances in crypto_del_default_rng(). Since the instances are permanent now, allocate their pages once at init time with __GFP_NOFAIL and ditch free_pcpu_inst() along with the failure paths in crypto_rng_init(); failing to install the RNG override in FIPS mode would be catastrophic, so the setup isn't allowed to fail anyway. This brings the per-CPU DRBG implementation in line with the ciqlts9_6 tree's version of "crypto: rng - Implement fast per-CPU DRBG instances" [1]. [1] https://github.com/ctrliq/kernel-src-tree/commit/b0c560a37518cad09488bab031e1c6e817d65cb8 Assisted-by: Claude:claude-opus-4-8 Signed-off-by: Sultan Alsawaf --- crypto/rng.c | 106 +++++++++------------------------------------------ 1 file changed, 18 insertions(+), 88 deletions(-) diff --git a/crypto/rng.c b/crypto/rng.c index 5fa9b680e3257..da4d179116121 100644 --- a/crypto/rng.c +++ b/crypto/rng.c @@ -187,24 +187,6 @@ void crypto_put_default_rng(void) EXPORT_SYMBOL_GPL(crypto_put_default_rng); #if defined(CONFIG_CRYPTO_RNG) || defined(CONFIG_CRYPTO_RNG_MODULE) -#define down_read_del_pcpu_rwsem() down_read(&del_pcpu_rwsem) -#define up_read_del_pcpu_rwsem() up_read(&del_pcpu_rwsem) -static DECLARE_RWSEM(del_pcpu_rwsem); - -static void crypto_del_pcpu_rng(struct cpu_rng_inst __percpu *pcri) -{ - int cpu; - - for_each_possible_cpu(cpu) { - struct cpu_rng_inst *cri = per_cpu_ptr(pcri, cpu); - - if (cri->rng) { - crypto_free_rng(cri->rng); - cri->rng = NULL; - } - } -} - int crypto_del_default_rng(void) { bool busy; @@ -215,26 +197,10 @@ int crypto_del_default_rng(void) crypto_default_rng = NULL; } rt_mutex_unlock(&crypto_default_rng_lock); - if (busy) - return -EBUSY; - if (!down_write_trylock(&del_pcpu_rwsem)) - return -EBUSY; - - crypto_del_pcpu_rng(&pcpu_default_rng); - crypto_del_pcpu_rng(&pcpu_reseed_rng); - up_write(&del_pcpu_rwsem); - - return 0; + return busy ? -EBUSY : 0; } EXPORT_SYMBOL_GPL(crypto_del_default_rng); -#else -static inline void down_read_del_pcpu_rwsem(void) -{ -} -static inline void up_read_del_pcpu_rwsem(void) -{ -} #endif static void rng_default_set_ent(struct crypto_rng *tfm, const u8 *data, @@ -345,13 +311,10 @@ lock_default_rng(struct crypto_rng **rng) __acquires(&cri->lock) local_lock(&pcri->lock); cri = this_cpu_ptr(pcri); /* - * cri->rng may have transitioned from non-NULL to NULL, but - * underneath down_read_del_pcpu_rwsem() it can only transition - * from NULL to non-NULL. This may occur on a different CPU, - * thus cri->rng must be read atomically to prevent data races; - * this elides mlock by pairing with the WRITE_ONCE() in the - * slow path below. - * + * cri->rng can only transition from NULL to non-NULL. This may + * occur on a different CPU, thus cri->rng must be read + * atomically to prevent data races; this elides mlock by + * pairing with the WRITE_ONCE() in the slow path below. * * And if cri->rng is non-NULL, then it is good to go. To avoid * data races due to load speculation on torn cri->rng loads @@ -489,8 +452,6 @@ static ssize_t crypto_devrandom_read_iter(struct iov_iter *iter, bool reseed) } } - /* Prevent rngs from getting deleted from per-CPU RNG instances */ - down_read_del_pcpu_rwsem(); restart: /* * Pin the user page backing the current user destination address, @@ -501,7 +462,7 @@ static ssize_t crypto_devrandom_read_iter(struct iov_iter *iter, bool reseed) */ if (user_no_reseed && pin_user_pages_fast((unsigned long)uaddr, 1, FOLL_WRITE, &upage) != 1) - goto up_rwsem; + goto exit; cri = lock_local_rng(&rng, reseed); if (IS_ERR(cri)) { @@ -656,72 +617,41 @@ static ssize_t crypto_devrandom_read_iter(struct iov_iter *iter, bool reseed) unpin_upage: if (user_no_reseed) unpin_user_page(upage); -up_rwsem: - up_read_del_pcpu_rwsem(); - return ret ? ret : -EFAULT; +exit: + return ret ? ret : -EFAULT; } static const struct random_extrng crypto_devrandom_rng = { .extrng_read_iter = crypto_devrandom_read_iter }; -static void free_pcpu_inst(struct cpu_rng_inst __percpu *pcri) +static void __init alloc_pcpu_inst(struct cpu_rng_inst __percpu *pcri) { int cpu; for_each_possible_cpu(cpu) { struct cpu_rng_inst *cri = per_cpu_ptr(pcri, cpu); - if (cri->rng) - crypto_free_rng(cri->rng); - - free_page((unsigned long)cri->page); - } -} - -static int __init alloc_pcpu_inst(struct cpu_rng_inst __percpu *pcri) -{ - int cpu; - - for_each_possible_cpu(cpu) { - struct cpu_rng_inst *cri = per_cpu_ptr(pcri, cpu); - - cri->page = (void *)__get_free_page(GFP_KERNEL); - if (!cri->page) - goto err_page_alloc; - + cri->page = (void *)__get_free_page(GFP_KERNEL | __GFP_NOFAIL); local_lock_init(&cri->lock); } - - return 0; - -err_page_alloc: - while (cpu--) - free_page((unsigned long)per_cpu_ptr(pcri, cpu)->page); - return -ENOMEM; } static int __init crypto_rng_init(void) { - int ret; - if (!fips_enabled) return 0; - ret = alloc_pcpu_inst(&pcpu_default_rng); - if (ret) - return ret; - - ret = alloc_pcpu_inst(&pcpu_reseed_rng); - if (ret) - goto free_pcpu_default; - + /* + * Never fail to register the RNG override in FIPS mode because failure + * would result in the system quietly booting without the FIPS-mandated + * RNG installed. This would be catastrophic for FIPS compliance, hence + * the RNG override setup is *not* allowed to fail. + */ + alloc_pcpu_inst(&pcpu_default_rng); + alloc_pcpu_inst(&pcpu_reseed_rng); random_register_extrng(&crypto_devrandom_rng); return 0; - -free_pcpu_default: - free_pcpu_inst(&pcpu_default_rng); - return ret; } late_initcall(crypto_rng_init); From 8d22437d5298c3dd1bd76c7d27309bd836ff32ba Mon Sep 17 00:00:00 2001 From: Sultan Alsawaf Date: Mon, 22 Jun 2026 18:40:11 -0700 Subject: [PATCH 21/26] crypto: rng - Skip leading zero-length iovec segments The fast per-CPU DRBG path computes its initial user destination address straight from the iov_iter. For an ITER_IOVEC iter it reads iter_iov_addr() and iter_iov_len() of the current segment, but when the iovec leads with one or more zero-length segments, the current segment is one of those empty entries. iter_iov_addr() then hands back the base of an empty segment, which is whatever userspace put there: its base can be NULL or some other unwritable address, since a zero-length segment is never actually touched. Right after the setup, that address is prefaulted, and on a bogus base it fails. A failed prefault on the very first address is treated as fatal, so the whole read bails out to -EFAULT even though there are perfectly good non-empty segments later in the iovec. This is reachable with something as simple as readv() on /dev/urandom where the first iovec entry is {NULL, 0}. Fix it by advancing the iterator by zero before reading the first address. The iovec advance loop walks past every leading empty segment and stops at the first non-empty one, and there's guaranteed to be such a segment because iov_iter_count() is nonzero at this point. Empty segments that crop up mid-stream are already skipped by the per-copy advance, so this only needs to run once during setup. Assisted-by: Claude:claude-opus-4-8 Signed-off-by: Sultan Alsawaf --- crypto/rng.c | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/crypto/rng.c b/crypto/rng.c index da4d179116121..acdd761ab2a00 100644 --- a/crypto/rng.c +++ b/crypto/rng.c @@ -441,6 +441,16 @@ static ssize_t crypto_devrandom_read_iter(struct iov_iter *iter, bool reseed) uaddr = iter->ubuf + iter->iov_offset; ulen = iov_iter_count(iter); } else if (iter_is_iovec(iter)) { + /* + * Skip any leading zero-length segments first, since + * uaddr would otherwise point at an empty segment's + * base (which may be NULL or unwritable). Advancing by + * zero walks past every leading empty segment (the + * iovec advance loop stops at the first non-empty one), + * and there's guaranteed to be a non-empty one because + * iov_iter_count() is nonzero above. + */ + iov_iter_advance(iter, 0); uaddr = iter_iov_addr(iter); ulen = iter_iov_len(iter); } else { From dc845a8d7bb73bb29d6c49a6fef8956bb4f6b771 Mon Sep 17 00:00:00 2001 From: Sultan Alsawaf Date: Mon, 22 Jun 2026 23:47:14 -0700 Subject: [PATCH 22/26] crypto: rng - Fix spurious EFAULT when the destination PTE is zapped While GUP pinning makes it possible to pin the page _backing_ a user address, it *doesn't* pin the page table entry (PTE) for that mapping. This means the pinned physical page can be separated from the user address it was backing, and even back a _different_ user address within the same process. PTE zapping naturally happens during memory reclaim when memory pressure is elevated, and can even be done directly by userspace via madvise(MADV_DONTNEED). Since the optimized per-CPU DRBG loop assumes copy_to_user_nofault() will always succeed on a GUP-pinned page, it immediately bails out when the nofault copy actually *does* fail for the reasons described above. This results in either fewer than requested random bytes copied or, more seriously, a spurious EFAULT returned to userspace when no random bytes were copied. As it turns out, there's no way to pin a PTE. That means it's not possible to guarantee a 100% success rate for the copy_to_user_nofault() attempt. Fix this by handling copy_to_user_nofault() errors correctly with a fall back to a faultable copy attempt outside of the RNG lock. In order to guarantee forward progress for the caller, an on-stack bounce buffer is used to copy up to 256 bytes of the generated random bytes whenever this happens rather than discarding the whole thing. There's no need to use GUP pinning anymore since there's no use for having a page pinned without pinning a PTE to go along with that page, hence the page pinning is eliminated which saves a software page table walk that was performed for _at least_ every destination page. Reported-by: Kun Yi Signed-off-by: Sultan Alsawaf --- crypto/rng.c | 146 +++++++++++++++++++++++++++++++++------------------ 1 file changed, 95 insertions(+), 51 deletions(-) diff --git a/crypto/rng.c b/crypto/rng.c index acdd761ab2a00..aed8221c0f09d 100644 --- a/crypto/rng.c +++ b/crypto/rng.c @@ -420,16 +420,30 @@ clear_rng_page(struct cpu_rng_inst *cri, size_t count) count < PAGE_SIZE ? memset(cri->page, 0, count) : clear_page(cri->page); } +static __always_inline void +no_reseed_clear_unlock(struct cpu_rng_inst *cri, size_t *page_dirty_len) +{ + /* + * Clear the buffer of our latest random bytes before unlocking and + * potentially migrating CPUs, in which case we wouldn't have the same + * `cri` anymore. + */ + clear_rng_page(cri, *page_dirty_len); + unlock_local_rng(cri, false); + *page_dirty_len = 0; +} + static ssize_t crypto_devrandom_read_iter(struct iov_iter *iter, bool reseed) { /* lock_local_rng() puts us in atomic context for !reseed on non-RT */ const bool atomic = !reseed && !IS_ENABLED(CONFIG_PREEMPT_RT); const bool user_no_reseed = !reseed && user_backed_iter(iter); + /* Align the bounce buffer to a word to prevent alignment traps */ + u8 bounce[SZ_256] __aligned(sizeof(long)); size_t ulen, page_dirty_len = 0; struct cpu_rng_inst *cri; struct crypto_rng *rng; - void __user *uaddr; - struct page *upage; + u8 __user *uaddr; ssize_t ret = 0; if (unlikely(!iov_iter_count(iter))) @@ -464,21 +478,39 @@ static ssize_t crypto_devrandom_read_iter(struct iov_iter *iter, bool reseed) restart: /* - * Pin the user page backing the current user destination address, - * potentially prefaulting to allocate a page for the destination. By - * prefaulting without the RNG lock held, the DRBG won't be blocked by - * time spent on page faults for this task, and thus the DRBG can still - * be used by other tasks. + * Prefault the current user destination address in case the page for + * that virtual address is not resident. This is done by simply writing + * a single zero byte to the destination, which forces a COW if the page + * isn't resident, leaving us with a writable mapping. By prefaulting + * without the RNG lock held, the DRBG won't be blocked by time spent on + * page faults for this task, and thus the DRBG can still be used by + * other tasks. + * + * Notably, this doesn't keep the page from getting evicted later on; + * it's just an optimistic prefault under the assumption that the page + * won't be evicted before we copy random bytes into it, which is often + * but _not always_ the case. + * + * While GUP pinning makes it possible to pin the page _backing_ a user + * address, it *doesn't* pin the page table entry (PTE) for that + * mapping. This means the pinned physical page can be separated from + * the user address it was backing, and even back a _different_ user + * address within the same process. PTE zapping naturally happens during + * memory reclaim when memory pressure is elevated, and can even be done + * directly by userspace via madvise(MADV_DONTNEED). Since there's no + * way to pin a PTE, that means it's not possible to guarantee a page + * will be resident when copy_to_user_nofault() runs under the RNG lock + * below; in other words, there's no way to guarantee a 100% success + * rate for the copy_to_user_nofault() attempt. */ - if (user_no_reseed && pin_user_pages_fast((unsigned long)uaddr, 1, - FOLL_WRITE, &upage) != 1) + if (user_no_reseed && put_user((u8)0, uaddr)) goto exit; cri = lock_local_rng(&rng, reseed); if (IS_ERR(cri)) { if (!ret) ret = PTR_ERR(cri); - goto unpin_upage; + goto exit; } while (1) { @@ -488,7 +520,7 @@ static ssize_t crypto_devrandom_read_iter(struct iov_iter *iter, bool reseed) /* * Generate up to one page at a time, and align to a page - * boundary so we only need to pin one user page at a time. + * boundary to track page residence one page at a time. */ if (user_no_reseed) i = min3(i, PAGE_SIZE - offset_in_page(uaddr), ulen); @@ -525,33 +557,56 @@ static ssize_t crypto_devrandom_read_iter(struct iov_iter *iter, bool reseed) * the entire call; this is why a mutex is used instead of a * local lock for the reseed RNG, to permit sleeping without * yielding the DRBG instance. + * + * From this point on, err != 0 means the nofault copy failed. */ page_dirty_len = max(i, page_dirty_len); - if (user_no_reseed) { - err = copy_to_user_nofault(uaddr, cri->page, i); - if (err >= 0) { - iov_iter_advance(iter, i - err); - ret += i - err; - } - if (err) - break; + if (user_no_reseed && + !(err = copy_to_user_nofault(uaddr, cri->page, i))) { + iov_iter_advance(iter, i); + copied = i; } else { + const void *src = cri->page; + /* - * We know that copying from cri->page is safe, so use - * _copy_to_iter() directly to skip check_copy_size(). + * Fall back to a faultable copy attempt when the + * non-faulting attempt failed, likely because the PTE + * was zapped. To ensure forward progress, some of the + * generated bytes are retained in an on-stack bounce + * buffer and copied out rather than just discarding all + * of it and going back to `restart`. */ - copied = _copy_to_iter(cri->page, i, iter); - ret += copied; - if (copied != i) - break; + if (unlikely(err)) { + i = min(i, sizeof(bounce)); + memcpy(bounce, cri->page, i); + no_reseed_clear_unlock(cri, &page_dirty_len); + src = bounce; + } + + /* + * We know that copying from cri->page (or the bounce + * buffer) is safe, so use _copy_to_iter() directly to + * skip check_copy_size(). + */ + copied = _copy_to_iter(src, i, iter); + + /* Sanitize the on-stack bounce buffer if it was used */ + if (err) + memzero_explicit(bounce, i); } + ret += copied; /* - * Quit when either the requested number of bytes have been - * generated or there is a pending signal. + * Quit when the copy fell short, the requested number of bytes + * have been generated, or there is a pending signal. */ - if (!iov_iter_count(iter) || signal_pending(current)) + if (copied != i || !iov_iter_count(iter) || + signal_pending(current)) { + /* Skip the unlock when already unlocked */ + if (unlikely(err)) + goto exit; break; + } /* Compute the next user destination address and length */ if (user_no_reseed) { @@ -572,8 +627,6 @@ static ssize_t crypto_devrandom_read_iter(struct iov_iter *iter, bool reseed) uaddr = iter_iov(iter)->iov_base; ulen = iter_iov(iter)->iov_len; } - - unpin_user_page(upage); } /* @@ -588,33 +641,27 @@ static ssize_t crypto_devrandom_read_iter(struct iov_iter *iter, bool reseed) } /* - * Optimistically try to pin the next user page without - * faulting, so we don't need to clear cri->page and drop the - * lock on every iteration. If this fails, we fall back to - * pinning with the option to prefault. + * Optimistically check if the next user page is resident and + * writable with a dummy copy_to_user_nofault() attempt to write + * a single zero byte. If this fails, fall back to prefaulting + * outside of the lock. */ - if (user_no_reseed && !resched_without_lock && - pin_user_pages_fast_only((unsigned long)uaddr, 1, - FOLL_WRITE, &upage) == 1) + if (!err && user_no_reseed && !resched_without_lock && + !copy_to_user_nofault(uaddr, &(u8){ 0 }, 1)) continue; /* * Restart if either rescheduling is needed (and requires - * dropping the lock since we're atomic) or the optimistic page - * pinning attempt failed. + * dropping the lock since we're atomic) or the destination page + * wasn't resident when copy_to_user_nofault() was attempted. * * This always implies `reseed == false`, so unlock_local_rng() - * can just be passed `false` for reseed to eliminate a branch. + * can just be passed `false` for reseed to eliminate a branch, + * hence using no_reseed_clear_unlock(). */ if (resched_without_lock || user_no_reseed) { - /* - * Clear the buffer of our latest random bytes before - * unlocking and potentially migrating CPUs, in which - * case we wouldn't have the same `cri` anymore. - */ - clear_rng_page(cri, page_dirty_len); - unlock_local_rng(cri, false); - page_dirty_len = 0; + if (!err) + no_reseed_clear_unlock(cri, &page_dirty_len); if (resched_without_lock) cond_resched(); goto restart; @@ -624,9 +671,6 @@ static ssize_t crypto_devrandom_read_iter(struct iov_iter *iter, bool reseed) if (page_dirty_len) clear_rng_page(cri, page_dirty_len); unlock_local_rng(cri, reseed); -unpin_upage: - if (user_no_reseed) - unpin_user_page(upage); exit: return ret ? ret : -EFAULT; } From 1b6fdf91316816db5b951a3e139a296e30462d50 Mon Sep 17 00:00:00 2001 From: Sultan Alsawaf Date: Tue, 23 Jun 2026 11:33:01 -0700 Subject: [PATCH 23/26] Revert "mm/gup: reintroduce pin_user_pages_fast_only()" This reverts commit ef467f3c43338f72f4173c98b15bc8021f79c3a1. This helper is no longer used by the FIPS-mode RNG, which was the motivation for reintroducing it. Remove it. Signed-off-by: Sultan Alsawaf --- include/linux/mm.h | 2 -- mm/gup.c | 28 ---------------------------- 2 files changed, 30 deletions(-) diff --git a/include/linux/mm.h b/include/linux/mm.h index 501f0212ac0e7..d2acffe4c8009 100644 --- a/include/linux/mm.h +++ b/include/linux/mm.h @@ -2616,8 +2616,6 @@ int get_user_pages_fast(unsigned long start, int nr_pages, unsigned int gup_flags, struct page **pages); int pin_user_pages_fast(unsigned long start, int nr_pages, unsigned int gup_flags, struct page **pages); -int pin_user_pages_fast_only(unsigned long start, int nr_pages, - unsigned int gup_flags, struct page **pages); void folio_add_pin(struct folio *folio); int account_locked_vm(struct mm_struct *mm, unsigned long pages, bool inc); diff --git a/mm/gup.c b/mm/gup.c index 737eceda0c6bf..960e4401320aa 100644 --- a/mm/gup.c +++ b/mm/gup.c @@ -3539,34 +3539,6 @@ int pin_user_pages_fast(unsigned long start, int nr_pages, } EXPORT_SYMBOL_GPL(pin_user_pages_fast); -/** - * pin_user_pages_fast_only() - pin user pages in memory - * @start: starting user address - * @nr_pages: number of pages from start to pin - * @gup_flags: flags modifying pin behaviour - * @pages: array that receives pointers to the pages pinned. - * Should be at least nr_pages long. - * - * Like pin_user_pages_fast() except it's IRQ-safe in that it won't fall back to - * the regular GUP. - * - * If the architecture does not support this function, simply return with no - * pages pinned. - * - * Careful, careful! COW breaking can go either way, so a non-write - * access can get ambiguous page results. If you call this function without - * 'write' set, you'd better be sure that you're ok with that ambiguity. - */ -int pin_user_pages_fast_only(unsigned long start, int nr_pages, - unsigned int gup_flags, struct page **pages) -{ - if (!is_valid_gup_args(pages, NULL, &gup_flags, - FOLL_PIN | FOLL_FAST_ONLY)) - return -EINVAL; - return gup_fast_fallback(start, nr_pages, gup_flags, pages); -} -EXPORT_SYMBOL_GPL(pin_user_pages_fast_only); - /** * pin_user_pages_remote() - pin pages of a remote process * From 19cabdd26726d91c4c406c9bf7e6c0a734e9ad1f Mon Sep 17 00:00:00 2001 From: Sultan Alsawaf Date: Wed, 12 Aug 2026 16:24:24 -0700 Subject: [PATCH 24/26] crypto: rng - Fix double percpu offset in local_unlock() calls local_unlock() is supposed to take a percpu pointer, which it then offsets for the current CPU. The problem is that the per-CPU DRBG code passes local_unlock() a pointer that has *already been offset for the current CPU*, so the percpu offset gets added twice. `pcri` is the percpu pointer and `cri` is the offset `pcri` pointer for the current CPU; passing `cri` to local_unlock() results in the current CPU's offset getting added again and thus the resulting pointer is garbage. This went unnoticed at runtime because local_unlock() only dereferences that pointer on PREEMPT_RT or CONFIG_DEBUG_LOCK_ALLOC=y kernels. The pointer is never actually used otherwise. This also went unnoticed at compile time because, for x86_64, __percpu only expands to something on GCC 14+; __percpu is otherwise an empty macro. So there's no pointer type mismatch detected at compile time on older GCC versions. On GCC 14+, the following compile error occurs: ../crypto/rng.c: In function 'lock_default_rng': ../include/linux/percpu-defs.h:221:45: error: initialization from pointer to non-enclosed address space Fix it by using __local_unlock() instead, which eliminates the duplicate per-CPU offset addition. While using local_unlock() with `pcri` also works, using `cri` with __local_unlock() is leaner because it doesn't need to redo the offset addition, saving an instruction on kernels that actually use the pointer. Signed-off-by: Sultan Alsawaf --- crypto/rng.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/crypto/rng.c b/crypto/rng.c index aed8221c0f09d..f757195dcd634 100644 --- a/crypto/rng.c +++ b/crypto/rng.c @@ -337,7 +337,7 @@ lock_default_rng(struct crypto_rng **rng) __acquires(&cri->lock) * * Note that this task may be migrated to a different CPU now! */ - local_unlock(&cri->lock); + __local_unlock(&cri->lock); rt_mutex_lock(&cri->mlock); if (!cri->rng) { struct crypto_rng *new_rng = NULL; @@ -410,7 +410,7 @@ do { \ if (reseed) \ rt_mutex_unlock(&(cri)->mlock); \ else \ - local_unlock(&(cri)->lock); \ + __local_unlock(&(cri)->lock); \ } while (0) static __always_inline void From deb56da0fa156a30e43fda05532473ddae431fcb Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Wed, 26 Aug 2026 14:24:56 -0700 Subject: [PATCH 25/26] Add CONFIG_CRYPTO_FIPS_CUSTOM_VERSION=y, CONFIG_CRYPTO_FIPS_VERSION="ciq.6.12.20260826" Requested by lab. Signed-off-by: Jeremy Allison --- configs/kernel-6.12.0-aarch64-64k-debug.config | 3 ++- configs/kernel-6.12.0-aarch64-64k.config | 3 ++- configs/kernel-6.12.0-aarch64-debug.config | 3 ++- configs/kernel-6.12.0-aarch64-rt-64k-debug.config | 3 ++- configs/kernel-6.12.0-aarch64-rt-64k.config | 3 ++- configs/kernel-6.12.0-aarch64-rt-debug.config | 3 ++- configs/kernel-6.12.0-aarch64-rt.config | 3 ++- configs/kernel-6.12.0-aarch64.config | 3 ++- configs/kernel-6.12.0-ppc64le-debug.config | 3 ++- configs/kernel-6.12.0-ppc64le.config | 3 ++- configs/kernel-6.12.0-s390x-debug.config | 3 ++- configs/kernel-6.12.0-s390x-zfcpdump.config | 3 ++- configs/kernel-6.12.0-s390x.config | 3 ++- configs/kernel-6.12.0-x86_64-debug.config | 3 ++- configs/kernel-6.12.0-x86_64-rt-debug.config | 3 ++- configs/kernel-6.12.0-x86_64-rt.config | 3 ++- configs/kernel-6.12.0-x86_64.config | 3 ++- configs/kernel-aarch64-64k-debug-rhel.config | 3 ++- configs/kernel-aarch64-64k-rhel.config | 3 ++- configs/kernel-aarch64-debug-rhel.config | 3 ++- configs/kernel-aarch64-rhel.config | 3 ++- configs/kernel-aarch64-rt-64k-debug-rhel.config | 3 ++- configs/kernel-aarch64-rt-64k-rhel.config | 3 ++- configs/kernel-aarch64-rt-debug-rhel.config | 3 ++- configs/kernel-aarch64-rt-rhel.config | 3 ++- configs/kernel-ppc64le-debug-rhel.config | 3 ++- configs/kernel-ppc64le-rhel.config | 3 ++- configs/kernel-s390x-debug-rhel.config | 3 ++- configs/kernel-s390x-rhel.config | 3 ++- configs/kernel-s390x-zfcpdump-rhel.config | 3 ++- configs/kernel-x86_64-debug-rhel.config | 3 ++- configs/kernel-x86_64-rhel.config | 3 ++- configs/kernel-x86_64-rt-debug-rhel.config | 3 ++- configs/kernel-x86_64-rt-rhel.config | 3 ++- 34 files changed, 68 insertions(+), 34 deletions(-) diff --git a/configs/kernel-6.12.0-aarch64-64k-debug.config b/configs/kernel-6.12.0-aarch64-64k-debug.config index b8d4f2cf0f945..cf895c09f496e 100644 --- a/configs/kernel-6.12.0-aarch64-64k-debug.config +++ b/configs/kernel-6.12.0-aarch64-64k-debug.config @@ -8301,7 +8301,8 @@ CONFIG_CRYPTO=y # CONFIG_CRYPTO_FIPS=y CONFIG_CRYPTO_FIPS_NAME="Rocky Linux 9 - Kernel Cryptographic API" -# CONFIG_CRYPTO_FIPS_CUSTOM_VERSION is not set +CONFIG_CRYPTO_FIPS_CUSTOM_VERSION=y +CONFIG_CRYPTO_FIPS_VERSION="ciq.6.12.20260826" CONFIG_CRYPTO_ALGAPI=y CONFIG_CRYPTO_ALGAPI2=y CONFIG_CRYPTO_AEAD=y diff --git a/configs/kernel-6.12.0-aarch64-64k.config b/configs/kernel-6.12.0-aarch64-64k.config index c083e0a8fbc80..9677e40261fa4 100644 --- a/configs/kernel-6.12.0-aarch64-64k.config +++ b/configs/kernel-6.12.0-aarch64-64k.config @@ -8278,7 +8278,8 @@ CONFIG_CRYPTO=y # CONFIG_CRYPTO_FIPS=y CONFIG_CRYPTO_FIPS_NAME="Rocky Linux 9 - Kernel Cryptographic API" -# CONFIG_CRYPTO_FIPS_CUSTOM_VERSION is not set +CONFIG_CRYPTO_FIPS_CUSTOM_VERSION=y +CONFIG_CRYPTO_FIPS_VERSION="ciq.6.12.20260826" CONFIG_CRYPTO_ALGAPI=y CONFIG_CRYPTO_ALGAPI2=y CONFIG_CRYPTO_AEAD=y diff --git a/configs/kernel-6.12.0-aarch64-debug.config b/configs/kernel-6.12.0-aarch64-debug.config index 4dc20c3f928f3..d10b16e93edfd 100644 --- a/configs/kernel-6.12.0-aarch64-debug.config +++ b/configs/kernel-6.12.0-aarch64-debug.config @@ -8309,7 +8309,8 @@ CONFIG_CRYPTO=y # CONFIG_CRYPTO_FIPS=y CONFIG_CRYPTO_FIPS_NAME="Rocky Linux 9 - Kernel Cryptographic API" -# CONFIG_CRYPTO_FIPS_CUSTOM_VERSION is not set +CONFIG_CRYPTO_FIPS_CUSTOM_VERSION=y +CONFIG_CRYPTO_FIPS_VERSION="ciq.6.12.20260826" CONFIG_CRYPTO_ALGAPI=y CONFIG_CRYPTO_ALGAPI2=y CONFIG_CRYPTO_AEAD=y diff --git a/configs/kernel-6.12.0-aarch64-rt-64k-debug.config b/configs/kernel-6.12.0-aarch64-rt-64k-debug.config index ec1466fbc184c..082a039dbcf16 100644 --- a/configs/kernel-6.12.0-aarch64-rt-64k-debug.config +++ b/configs/kernel-6.12.0-aarch64-rt-64k-debug.config @@ -8283,7 +8283,8 @@ CONFIG_CRYPTO=y # CONFIG_CRYPTO_FIPS=y CONFIG_CRYPTO_FIPS_NAME="Rocky Linux 9 - Kernel Cryptographic API" -# CONFIG_CRYPTO_FIPS_CUSTOM_VERSION is not set +CONFIG_CRYPTO_FIPS_CUSTOM_VERSION=y +CONFIG_CRYPTO_FIPS_VERSION="ciq.6.12.20260826" CONFIG_CRYPTO_ALGAPI=y CONFIG_CRYPTO_ALGAPI2=y CONFIG_CRYPTO_AEAD=y diff --git a/configs/kernel-6.12.0-aarch64-rt-64k.config b/configs/kernel-6.12.0-aarch64-rt-64k.config index 460387de20820..51d16a92060e6 100644 --- a/configs/kernel-6.12.0-aarch64-rt-64k.config +++ b/configs/kernel-6.12.0-aarch64-rt-64k.config @@ -8260,7 +8260,8 @@ CONFIG_CRYPTO=y # CONFIG_CRYPTO_FIPS=y CONFIG_CRYPTO_FIPS_NAME="Rocky Linux 9 - Kernel Cryptographic API" -# CONFIG_CRYPTO_FIPS_CUSTOM_VERSION is not set +CONFIG_CRYPTO_FIPS_CUSTOM_VERSION=y +CONFIG_CRYPTO_FIPS_VERSION="ciq.6.12.20260826" CONFIG_CRYPTO_ALGAPI=y CONFIG_CRYPTO_ALGAPI2=y CONFIG_CRYPTO_AEAD=y diff --git a/configs/kernel-6.12.0-aarch64-rt-debug.config b/configs/kernel-6.12.0-aarch64-rt-debug.config index ab33c97877886..e0745eda47f90 100644 --- a/configs/kernel-6.12.0-aarch64-rt-debug.config +++ b/configs/kernel-6.12.0-aarch64-rt-debug.config @@ -8290,7 +8290,8 @@ CONFIG_CRYPTO=y # CONFIG_CRYPTO_FIPS=y CONFIG_CRYPTO_FIPS_NAME="Rocky Linux 9 - Kernel Cryptographic API" -# CONFIG_CRYPTO_FIPS_CUSTOM_VERSION is not set +CONFIG_CRYPTO_FIPS_CUSTOM_VERSION=y +CONFIG_CRYPTO_FIPS_VERSION="ciq.6.12.20260826" CONFIG_CRYPTO_ALGAPI=y CONFIG_CRYPTO_ALGAPI2=y CONFIG_CRYPTO_AEAD=y diff --git a/configs/kernel-6.12.0-aarch64-rt.config b/configs/kernel-6.12.0-aarch64-rt.config index 48865f922c6ee..2cba53b93c60c 100644 --- a/configs/kernel-6.12.0-aarch64-rt.config +++ b/configs/kernel-6.12.0-aarch64-rt.config @@ -8267,7 +8267,8 @@ CONFIG_CRYPTO=y # CONFIG_CRYPTO_FIPS=y CONFIG_CRYPTO_FIPS_NAME="Rocky Linux 9 - Kernel Cryptographic API" -# CONFIG_CRYPTO_FIPS_CUSTOM_VERSION is not set +CONFIG_CRYPTO_FIPS_CUSTOM_VERSION=y +CONFIG_CRYPTO_FIPS_VERSION="ciq.6.12.20260826" CONFIG_CRYPTO_ALGAPI=y CONFIG_CRYPTO_ALGAPI2=y CONFIG_CRYPTO_AEAD=y diff --git a/configs/kernel-6.12.0-aarch64.config b/configs/kernel-6.12.0-aarch64.config index 179ed84aa2c68..49ee0a69b3712 100644 --- a/configs/kernel-6.12.0-aarch64.config +++ b/configs/kernel-6.12.0-aarch64.config @@ -8286,7 +8286,8 @@ CONFIG_CRYPTO=y # CONFIG_CRYPTO_FIPS=y CONFIG_CRYPTO_FIPS_NAME="Rocky Linux 9 - Kernel Cryptographic API" -# CONFIG_CRYPTO_FIPS_CUSTOM_VERSION is not set +CONFIG_CRYPTO_FIPS_CUSTOM_VERSION=y +CONFIG_CRYPTO_FIPS_VERSION="ciq.6.12.20260826" CONFIG_CRYPTO_ALGAPI=y CONFIG_CRYPTO_ALGAPI2=y CONFIG_CRYPTO_AEAD=y diff --git a/configs/kernel-6.12.0-ppc64le-debug.config b/configs/kernel-6.12.0-ppc64le-debug.config index 686ae654d4ea0..c1fdd9f61bb63 100644 --- a/configs/kernel-6.12.0-ppc64le-debug.config +++ b/configs/kernel-6.12.0-ppc64le-debug.config @@ -6516,7 +6516,8 @@ CONFIG_CRYPTO=y # CONFIG_CRYPTO_FIPS=y CONFIG_CRYPTO_FIPS_NAME="Rocky Linux 9 - Kernel Cryptographic API" -# CONFIG_CRYPTO_FIPS_CUSTOM_VERSION is not set +CONFIG_CRYPTO_FIPS_CUSTOM_VERSION=y +CONFIG_CRYPTO_FIPS_VERSION="ciq.6.12.20260826" CONFIG_CRYPTO_ALGAPI=y CONFIG_CRYPTO_ALGAPI2=y CONFIG_CRYPTO_AEAD=y diff --git a/configs/kernel-6.12.0-ppc64le.config b/configs/kernel-6.12.0-ppc64le.config index 309eccd65e8d7..a8d1f2bcc9cc6 100644 --- a/configs/kernel-6.12.0-ppc64le.config +++ b/configs/kernel-6.12.0-ppc64le.config @@ -6517,7 +6517,8 @@ CONFIG_CRYPTO=y # CONFIG_CRYPTO_FIPS=y CONFIG_CRYPTO_FIPS_NAME="Rocky Linux 9 - Kernel Cryptographic API" -# CONFIG_CRYPTO_FIPS_CUSTOM_VERSION is not set +CONFIG_CRYPTO_FIPS_CUSTOM_VERSION=y +CONFIG_CRYPTO_FIPS_VERSION="ciq.6.12.20260826" CONFIG_CRYPTO_ALGAPI=y CONFIG_CRYPTO_ALGAPI2=y CONFIG_CRYPTO_AEAD=y diff --git a/configs/kernel-6.12.0-s390x-debug.config b/configs/kernel-6.12.0-s390x-debug.config index f3527ddd5fb61..1af53b6ef21f3 100644 --- a/configs/kernel-6.12.0-s390x-debug.config +++ b/configs/kernel-6.12.0-s390x-debug.config @@ -3638,7 +3638,8 @@ CONFIG_CRYPTO=y # CONFIG_CRYPTO_FIPS=y CONFIG_CRYPTO_FIPS_NAME="Rocky Linux 9 - Kernel Cryptographic API" -# CONFIG_CRYPTO_FIPS_CUSTOM_VERSION is not set +CONFIG_CRYPTO_FIPS_CUSTOM_VERSION=y +CONFIG_CRYPTO_FIPS_VERSION="ciq.6.12.20260826" CONFIG_CRYPTO_ALGAPI=y CONFIG_CRYPTO_ALGAPI2=y CONFIG_CRYPTO_AEAD=y diff --git a/configs/kernel-6.12.0-s390x-zfcpdump.config b/configs/kernel-6.12.0-s390x-zfcpdump.config index 680dd7a554826..a987a036509c4 100644 --- a/configs/kernel-6.12.0-s390x-zfcpdump.config +++ b/configs/kernel-6.12.0-s390x-zfcpdump.config @@ -1460,7 +1460,8 @@ CONFIG_CRYPTO=y # CONFIG_CRYPTO_FIPS=y CONFIG_CRYPTO_FIPS_NAME="Rocky Linux 9 - Kernel Cryptographic API" -# CONFIG_CRYPTO_FIPS_CUSTOM_VERSION is not set +CONFIG_CRYPTO_FIPS_CUSTOM_VERSION=y +CONFIG_CRYPTO_FIPS_VERSION="ciq.6.12.20260826" CONFIG_CRYPTO_ALGAPI=y CONFIG_CRYPTO_ALGAPI2=y CONFIG_CRYPTO_AEAD=y diff --git a/configs/kernel-6.12.0-s390x.config b/configs/kernel-6.12.0-s390x.config index 697d57c94524b..f81f0515fa186 100644 --- a/configs/kernel-6.12.0-s390x.config +++ b/configs/kernel-6.12.0-s390x.config @@ -3668,7 +3668,8 @@ CONFIG_CRYPTO=y # CONFIG_CRYPTO_FIPS=y CONFIG_CRYPTO_FIPS_NAME="Rocky Linux 9 - Kernel Cryptographic API" -# CONFIG_CRYPTO_FIPS_CUSTOM_VERSION is not set +CONFIG_CRYPTO_FIPS_CUSTOM_VERSION=y +CONFIG_CRYPTO_FIPS_VERSION="ciq.6.12.20260826" CONFIG_CRYPTO_ALGAPI=y CONFIG_CRYPTO_ALGAPI2=y CONFIG_CRYPTO_AEAD=y diff --git a/configs/kernel-6.12.0-x86_64-debug.config b/configs/kernel-6.12.0-x86_64-debug.config index b9d2e30a6e0e2..0fa3fa0331672 100644 --- a/configs/kernel-6.12.0-x86_64-debug.config +++ b/configs/kernel-6.12.0-x86_64-debug.config @@ -9203,7 +9203,8 @@ CONFIG_CRYPTO=y # CONFIG_CRYPTO_FIPS=y CONFIG_CRYPTO_FIPS_NAME="Rocky Linux 9 - Kernel Cryptographic API" -# CONFIG_CRYPTO_FIPS_CUSTOM_VERSION is not set +CONFIG_CRYPTO_FIPS_CUSTOM_VERSION=y +CONFIG_CRYPTO_FIPS_VERSION="ciq.6.12.20260826" CONFIG_CRYPTO_ALGAPI=y CONFIG_CRYPTO_ALGAPI2=y CONFIG_CRYPTO_AEAD=y diff --git a/configs/kernel-6.12.0-x86_64-rt-debug.config b/configs/kernel-6.12.0-x86_64-rt-debug.config index 62a3d5613a072..f98f4ca84666e 100644 --- a/configs/kernel-6.12.0-x86_64-rt-debug.config +++ b/configs/kernel-6.12.0-x86_64-rt-debug.config @@ -9184,7 +9184,8 @@ CONFIG_CRYPTO=y # CONFIG_CRYPTO_FIPS=y CONFIG_CRYPTO_FIPS_NAME="Rocky Linux 9 - Kernel Cryptographic API" -# CONFIG_CRYPTO_FIPS_CUSTOM_VERSION is not set +CONFIG_CRYPTO_FIPS_CUSTOM_VERSION=y +CONFIG_CRYPTO_FIPS_VERSION="ciq.6.12.20260826" CONFIG_CRYPTO_ALGAPI=y CONFIG_CRYPTO_ALGAPI2=y CONFIG_CRYPTO_AEAD=y diff --git a/configs/kernel-6.12.0-x86_64-rt.config b/configs/kernel-6.12.0-x86_64-rt.config index 023cdea7ec8e7..5ff666d1e788a 100644 --- a/configs/kernel-6.12.0-x86_64-rt.config +++ b/configs/kernel-6.12.0-x86_64-rt.config @@ -9155,7 +9155,8 @@ CONFIG_CRYPTO=y # CONFIG_CRYPTO_FIPS=y CONFIG_CRYPTO_FIPS_NAME="Rocky Linux 9 - Kernel Cryptographic API" -# CONFIG_CRYPTO_FIPS_CUSTOM_VERSION is not set +CONFIG_CRYPTO_FIPS_CUSTOM_VERSION=y +CONFIG_CRYPTO_FIPS_VERSION="ciq.6.12.20260826" CONFIG_CRYPTO_ALGAPI=y CONFIG_CRYPTO_ALGAPI2=y CONFIG_CRYPTO_AEAD=y diff --git a/configs/kernel-6.12.0-x86_64.config b/configs/kernel-6.12.0-x86_64.config index 9c2ab4cad277d..c68aaf662d236 100644 --- a/configs/kernel-6.12.0-x86_64.config +++ b/configs/kernel-6.12.0-x86_64.config @@ -9179,7 +9179,8 @@ CONFIG_CRYPTO=y # CONFIG_CRYPTO_FIPS=y CONFIG_CRYPTO_FIPS_NAME="Rocky Linux 9 - Kernel Cryptographic API" -# CONFIG_CRYPTO_FIPS_CUSTOM_VERSION is not set +CONFIG_CRYPTO_FIPS_CUSTOM_VERSION=y +CONFIG_CRYPTO_FIPS_VERSION="ciq.6.12.20260826" CONFIG_CRYPTO_ALGAPI=y CONFIG_CRYPTO_ALGAPI2=y CONFIG_CRYPTO_AEAD=y diff --git a/configs/kernel-aarch64-64k-debug-rhel.config b/configs/kernel-aarch64-64k-debug-rhel.config index 8c954151d3f05..1616147b96d5c 100644 --- a/configs/kernel-aarch64-64k-debug-rhel.config +++ b/configs/kernel-aarch64-64k-debug-rhel.config @@ -1284,7 +1284,8 @@ CONFIG_CRYPTO_ECHAINIV=m # CONFIG_CRYPTO_ECRDSA is not set CONFIG_CRYPTO_ESSIV=m CONFIG_CRYPTO_FCRYPT=m -# CONFIG_CRYPTO_FIPS_CUSTOM_VERSION is not set +CONFIG_CRYPTO_FIPS_CUSTOM_VERSION=y +CONFIG_CRYPTO_FIPS_VERSION="ciq.6.12.20260826" CONFIG_CRYPTO_FIPS_NAME="Linux Kernel Cryptographic API" CONFIG_CRYPTO_FIPS=y CONFIG_CRYPTO_GCM=y diff --git a/configs/kernel-aarch64-64k-rhel.config b/configs/kernel-aarch64-64k-rhel.config index d7184d179d8a2..3bd7c55041bc8 100644 --- a/configs/kernel-aarch64-64k-rhel.config +++ b/configs/kernel-aarch64-64k-rhel.config @@ -1284,7 +1284,8 @@ CONFIG_CRYPTO_ECHAINIV=m # CONFIG_CRYPTO_ECRDSA is not set CONFIG_CRYPTO_ESSIV=m CONFIG_CRYPTO_FCRYPT=m -# CONFIG_CRYPTO_FIPS_CUSTOM_VERSION is not set +CONFIG_CRYPTO_FIPS_CUSTOM_VERSION=y +CONFIG_CRYPTO_FIPS_VERSION="ciq.6.12.20260826" CONFIG_CRYPTO_FIPS_NAME="Linux Kernel Cryptographic API" CONFIG_CRYPTO_FIPS=y CONFIG_CRYPTO_GCM=y diff --git a/configs/kernel-aarch64-debug-rhel.config b/configs/kernel-aarch64-debug-rhel.config index c728fb0f15ace..fdf26f2edd3ab 100644 --- a/configs/kernel-aarch64-debug-rhel.config +++ b/configs/kernel-aarch64-debug-rhel.config @@ -1282,7 +1282,8 @@ CONFIG_CRYPTO_ECHAINIV=m # CONFIG_CRYPTO_ECRDSA is not set CONFIG_CRYPTO_ESSIV=m CONFIG_CRYPTO_FCRYPT=m -# CONFIG_CRYPTO_FIPS_CUSTOM_VERSION is not set +CONFIG_CRYPTO_FIPS_CUSTOM_VERSION=y +CONFIG_CRYPTO_FIPS_VERSION="ciq.6.12.20260826" CONFIG_CRYPTO_FIPS_NAME="Linux Kernel Cryptographic API" CONFIG_CRYPTO_FIPS=y CONFIG_CRYPTO_GCM=y diff --git a/configs/kernel-aarch64-rhel.config b/configs/kernel-aarch64-rhel.config index 7a7f317b61f37..0d89d460d7c65 100644 --- a/configs/kernel-aarch64-rhel.config +++ b/configs/kernel-aarch64-rhel.config @@ -1282,7 +1282,8 @@ CONFIG_CRYPTO_ECHAINIV=m # CONFIG_CRYPTO_ECRDSA is not set CONFIG_CRYPTO_ESSIV=m CONFIG_CRYPTO_FCRYPT=m -# CONFIG_CRYPTO_FIPS_CUSTOM_VERSION is not set +CONFIG_CRYPTO_FIPS_CUSTOM_VERSION=y +CONFIG_CRYPTO_FIPS_VERSION="ciq.6.12.20260826" CONFIG_CRYPTO_FIPS_NAME="Linux Kernel Cryptographic API" CONFIG_CRYPTO_FIPS=y CONFIG_CRYPTO_GCM=y diff --git a/configs/kernel-aarch64-rt-64k-debug-rhel.config b/configs/kernel-aarch64-rt-64k-debug-rhel.config index fe4a1928f05bd..7a158712b1128 100644 --- a/configs/kernel-aarch64-rt-64k-debug-rhel.config +++ b/configs/kernel-aarch64-rt-64k-debug-rhel.config @@ -1285,7 +1285,8 @@ CONFIG_CRYPTO_ECHAINIV=m # CONFIG_CRYPTO_ECRDSA is not set CONFIG_CRYPTO_ESSIV=m CONFIG_CRYPTO_FCRYPT=m -# CONFIG_CRYPTO_FIPS_CUSTOM_VERSION is not set +CONFIG_CRYPTO_FIPS_CUSTOM_VERSION=y +CONFIG_CRYPTO_FIPS_VERSION="ciq.6.12.20260826" CONFIG_CRYPTO_FIPS_NAME="Linux Kernel Cryptographic API" CONFIG_CRYPTO_FIPS=y CONFIG_CRYPTO_GCM=y diff --git a/configs/kernel-aarch64-rt-64k-rhel.config b/configs/kernel-aarch64-rt-64k-rhel.config index c15f4ee5a01c6..bcf1bb15c32bb 100644 --- a/configs/kernel-aarch64-rt-64k-rhel.config +++ b/configs/kernel-aarch64-rt-64k-rhel.config @@ -1285,7 +1285,8 @@ CONFIG_CRYPTO_ECHAINIV=m # CONFIG_CRYPTO_ECRDSA is not set CONFIG_CRYPTO_ESSIV=m CONFIG_CRYPTO_FCRYPT=m -# CONFIG_CRYPTO_FIPS_CUSTOM_VERSION is not set +CONFIG_CRYPTO_FIPS_CUSTOM_VERSION=y +CONFIG_CRYPTO_FIPS_VERSION="ciq.6.12.20260826" CONFIG_CRYPTO_FIPS_NAME="Linux Kernel Cryptographic API" CONFIG_CRYPTO_FIPS=y CONFIG_CRYPTO_GCM=y diff --git a/configs/kernel-aarch64-rt-debug-rhel.config b/configs/kernel-aarch64-rt-debug-rhel.config index 2bb35d529aafa..31a53e23779e0 100644 --- a/configs/kernel-aarch64-rt-debug-rhel.config +++ b/configs/kernel-aarch64-rt-debug-rhel.config @@ -1283,7 +1283,8 @@ CONFIG_CRYPTO_ECHAINIV=m # CONFIG_CRYPTO_ECRDSA is not set CONFIG_CRYPTO_ESSIV=m CONFIG_CRYPTO_FCRYPT=m -# CONFIG_CRYPTO_FIPS_CUSTOM_VERSION is not set +CONFIG_CRYPTO_FIPS_CUSTOM_VERSION=y +CONFIG_CRYPTO_FIPS_VERSION="ciq.6.12.20260826" CONFIG_CRYPTO_FIPS_NAME="Linux Kernel Cryptographic API" CONFIG_CRYPTO_FIPS=y CONFIG_CRYPTO_GCM=y diff --git a/configs/kernel-aarch64-rt-rhel.config b/configs/kernel-aarch64-rt-rhel.config index 39be57f9d2ea8..1ac328a2f2863 100644 --- a/configs/kernel-aarch64-rt-rhel.config +++ b/configs/kernel-aarch64-rt-rhel.config @@ -1283,7 +1283,8 @@ CONFIG_CRYPTO_ECHAINIV=m # CONFIG_CRYPTO_ECRDSA is not set CONFIG_CRYPTO_ESSIV=m CONFIG_CRYPTO_FCRYPT=m -# CONFIG_CRYPTO_FIPS_CUSTOM_VERSION is not set +CONFIG_CRYPTO_FIPS_CUSTOM_VERSION=y +CONFIG_CRYPTO_FIPS_VERSION="ciq.6.12.20260826" CONFIG_CRYPTO_FIPS_NAME="Linux Kernel Cryptographic API" CONFIG_CRYPTO_FIPS=y CONFIG_CRYPTO_GCM=y diff --git a/configs/kernel-ppc64le-debug-rhel.config b/configs/kernel-ppc64le-debug-rhel.config index 13e50f79c0117..24c7b6cdf2605 100644 --- a/configs/kernel-ppc64le-debug-rhel.config +++ b/configs/kernel-ppc64le-debug-rhel.config @@ -1045,7 +1045,8 @@ CONFIG_CRYPTO_ECHAINIV=m # CONFIG_CRYPTO_ECRDSA is not set CONFIG_CRYPTO_ESSIV=m CONFIG_CRYPTO_FCRYPT=m -# CONFIG_CRYPTO_FIPS_CUSTOM_VERSION is not set +CONFIG_CRYPTO_FIPS_CUSTOM_VERSION=y +CONFIG_CRYPTO_FIPS_VERSION="ciq.6.12.20260826" CONFIG_CRYPTO_FIPS_NAME="Linux Kernel Cryptographic API" CONFIG_CRYPTO_FIPS=y CONFIG_CRYPTO_GCM=y diff --git a/configs/kernel-ppc64le-rhel.config b/configs/kernel-ppc64le-rhel.config index c14817c4b65b8..355bf6a015b75 100644 --- a/configs/kernel-ppc64le-rhel.config +++ b/configs/kernel-ppc64le-rhel.config @@ -1045,7 +1045,8 @@ CONFIG_CRYPTO_ECHAINIV=m # CONFIG_CRYPTO_ECRDSA is not set CONFIG_CRYPTO_ESSIV=m CONFIG_CRYPTO_FCRYPT=m -# CONFIG_CRYPTO_FIPS_CUSTOM_VERSION is not set +CONFIG_CRYPTO_FIPS_CUSTOM_VERSION=y +CONFIG_CRYPTO_FIPS_VERSION="ciq.6.12.20260826" CONFIG_CRYPTO_FIPS_NAME="Linux Kernel Cryptographic API" CONFIG_CRYPTO_FIPS=y CONFIG_CRYPTO_GCM=y diff --git a/configs/kernel-s390x-debug-rhel.config b/configs/kernel-s390x-debug-rhel.config index 4612cb7922f4d..e45def33f6ba9 100644 --- a/configs/kernel-s390x-debug-rhel.config +++ b/configs/kernel-s390x-debug-rhel.config @@ -1041,7 +1041,8 @@ CONFIG_CRYPTO_ECHAINIV=m # CONFIG_CRYPTO_ECRDSA is not set CONFIG_CRYPTO_ESSIV=m CONFIG_CRYPTO_FCRYPT=m -# CONFIG_CRYPTO_FIPS_CUSTOM_VERSION is not set +CONFIG_CRYPTO_FIPS_CUSTOM_VERSION=y +CONFIG_CRYPTO_FIPS_VERSION="ciq.6.12.20260826" CONFIG_CRYPTO_FIPS_NAME="Linux Kernel Cryptographic API" CONFIG_CRYPTO_FIPS=y CONFIG_CRYPTO_GCM=y diff --git a/configs/kernel-s390x-rhel.config b/configs/kernel-s390x-rhel.config index 40a2b54fc955e..959a8db8b34f8 100644 --- a/configs/kernel-s390x-rhel.config +++ b/configs/kernel-s390x-rhel.config @@ -1041,7 +1041,8 @@ CONFIG_CRYPTO_ECHAINIV=m # CONFIG_CRYPTO_ECRDSA is not set CONFIG_CRYPTO_ESSIV=m CONFIG_CRYPTO_FCRYPT=m -# CONFIG_CRYPTO_FIPS_CUSTOM_VERSION is not set +CONFIG_CRYPTO_FIPS_CUSTOM_VERSION=y +CONFIG_CRYPTO_FIPS_VERSION="ciq.6.12.20260826" CONFIG_CRYPTO_FIPS_NAME="Linux Kernel Cryptographic API" CONFIG_CRYPTO_FIPS=y CONFIG_CRYPTO_GCM=y diff --git a/configs/kernel-s390x-zfcpdump-rhel.config b/configs/kernel-s390x-zfcpdump-rhel.config index 990151517043b..e9a45b30b5f8d 100644 --- a/configs/kernel-s390x-zfcpdump-rhel.config +++ b/configs/kernel-s390x-zfcpdump-rhel.config @@ -1042,7 +1042,8 @@ CONFIG_CRYPTO_ECHAINIV=y # CONFIG_CRYPTO_ECRDSA is not set # CONFIG_CRYPTO_ESSIV is not set CONFIG_CRYPTO_FCRYPT=y -# CONFIG_CRYPTO_FIPS_CUSTOM_VERSION is not set +CONFIG_CRYPTO_FIPS_CUSTOM_VERSION=y +CONFIG_CRYPTO_FIPS_VERSION="ciq.6.12.20260826" CONFIG_CRYPTO_FIPS_NAME="Linux Kernel Cryptographic API" CONFIG_CRYPTO_FIPS=y CONFIG_CRYPTO_GCM=y diff --git a/configs/kernel-x86_64-debug-rhel.config b/configs/kernel-x86_64-debug-rhel.config index 2985ba5f55986..33fb59ac0c05c 100644 --- a/configs/kernel-x86_64-debug-rhel.config +++ b/configs/kernel-x86_64-debug-rhel.config @@ -1099,7 +1099,8 @@ CONFIG_CRYPTO_ECHAINIV=m # CONFIG_CRYPTO_ECRDSA is not set CONFIG_CRYPTO_ESSIV=m CONFIG_CRYPTO_FCRYPT=m -# CONFIG_CRYPTO_FIPS_CUSTOM_VERSION is not set +CONFIG_CRYPTO_FIPS_CUSTOM_VERSION=y +CONFIG_CRYPTO_FIPS_VERSION="ciq.6.12.20260826" CONFIG_CRYPTO_FIPS_NAME="Linux Kernel Cryptographic API" CONFIG_CRYPTO_FIPS=y CONFIG_CRYPTO_GCM=y diff --git a/configs/kernel-x86_64-rhel.config b/configs/kernel-x86_64-rhel.config index b390068c4142a..f0f57e80f13b6 100644 --- a/configs/kernel-x86_64-rhel.config +++ b/configs/kernel-x86_64-rhel.config @@ -1099,7 +1099,8 @@ CONFIG_CRYPTO_ECHAINIV=m # CONFIG_CRYPTO_ECRDSA is not set CONFIG_CRYPTO_ESSIV=m CONFIG_CRYPTO_FCRYPT=m -# CONFIG_CRYPTO_FIPS_CUSTOM_VERSION is not set +CONFIG_CRYPTO_FIPS_CUSTOM_VERSION=y +CONFIG_CRYPTO_FIPS_VERSION="ciq.6.12.20260826" CONFIG_CRYPTO_FIPS_NAME="Linux Kernel Cryptographic API" CONFIG_CRYPTO_FIPS=y CONFIG_CRYPTO_GCM=y diff --git a/configs/kernel-x86_64-rt-debug-rhel.config b/configs/kernel-x86_64-rt-debug-rhel.config index 8b1a48730fb57..f4e55a3ef0c6b 100644 --- a/configs/kernel-x86_64-rt-debug-rhel.config +++ b/configs/kernel-x86_64-rt-debug-rhel.config @@ -1100,7 +1100,8 @@ CONFIG_CRYPTO_ECHAINIV=m # CONFIG_CRYPTO_ECRDSA is not set CONFIG_CRYPTO_ESSIV=m CONFIG_CRYPTO_FCRYPT=m -# CONFIG_CRYPTO_FIPS_CUSTOM_VERSION is not set +CONFIG_CRYPTO_FIPS_CUSTOM_VERSION=y +CONFIG_CRYPTO_FIPS_VERSION="ciq.6.12.20260826" CONFIG_CRYPTO_FIPS_NAME="Linux Kernel Cryptographic API" CONFIG_CRYPTO_FIPS=y CONFIG_CRYPTO_GCM=y diff --git a/configs/kernel-x86_64-rt-rhel.config b/configs/kernel-x86_64-rt-rhel.config index 6823de63e269a..0f3db2307a5da 100644 --- a/configs/kernel-x86_64-rt-rhel.config +++ b/configs/kernel-x86_64-rt-rhel.config @@ -1100,7 +1100,8 @@ CONFIG_CRYPTO_ECHAINIV=m # CONFIG_CRYPTO_ECRDSA is not set CONFIG_CRYPTO_ESSIV=m CONFIG_CRYPTO_FCRYPT=m -# CONFIG_CRYPTO_FIPS_CUSTOM_VERSION is not set +CONFIG_CRYPTO_FIPS_CUSTOM_VERSION=y +CONFIG_CRYPTO_FIPS_VERSION="ciq.6.12.20260826" CONFIG_CRYPTO_FIPS_NAME="Linux Kernel Cryptographic API" CONFIG_CRYPTO_FIPS=y CONFIG_CRYPTO_GCM=y From 6072e6f16ff2a900c985976a30617b9958745416 Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Wed, 26 Aug 2026 18:40:32 -0700 Subject: [PATCH 26/26] Unset CRYPTO_JITTERENTROPY_MEMSIZE_2, set CRYPTO_JITTERENTROPY_MEMSIZE_128. CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKS=512 CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE=256 Requested by lab. Signed-off-by: Jeremy Allison --- configs/kernel-6.12.0-aarch64-64k-debug.config | 8 ++++---- configs/kernel-6.12.0-aarch64-64k.config | 8 ++++---- configs/kernel-6.12.0-aarch64-debug.config | 8 ++++---- configs/kernel-6.12.0-aarch64-rt-64k-debug.config | 8 ++++---- configs/kernel-6.12.0-aarch64-rt-64k.config | 8 ++++---- configs/kernel-6.12.0-aarch64-rt-debug.config | 8 ++++---- configs/kernel-6.12.0-aarch64-rt.config | 8 ++++---- configs/kernel-6.12.0-aarch64.config | 8 ++++---- configs/kernel-6.12.0-ppc64le-debug.config | 8 ++++---- configs/kernel-6.12.0-ppc64le.config | 10 +++++----- configs/kernel-6.12.0-s390x-debug.config | 8 ++++---- configs/kernel-6.12.0-s390x-zfcpdump.config | 8 ++++---- configs/kernel-6.12.0-s390x.config | 8 ++++---- configs/kernel-6.12.0-x86_64-debug.config | 8 ++++---- configs/kernel-6.12.0-x86_64-rt-debug.config | 8 ++++---- configs/kernel-6.12.0-x86_64-rt.config | 8 ++++---- configs/kernel-6.12.0-x86_64.config | 8 ++++---- configs/kernel-aarch64-64k-debug-rhel.config | 4 ++-- configs/kernel-aarch64-64k-rhel.config | 4 ++-- configs/kernel-aarch64-debug-rhel.config | 4 ++-- configs/kernel-aarch64-rhel.config | 4 ++-- configs/kernel-aarch64-rt-64k-debug-rhel.config | 4 ++-- configs/kernel-aarch64-rt-64k-rhel.config | 4 ++-- configs/kernel-aarch64-rt-debug-rhel.config | 4 ++-- configs/kernel-aarch64-rt-rhel.config | 4 ++-- configs/kernel-ppc64le-debug-rhel.config | 4 ++-- configs/kernel-ppc64le-rhel.config | 4 ++-- configs/kernel-s390x-debug-rhel.config | 4 ++-- configs/kernel-s390x-rhel.config | 4 ++-- configs/kernel-s390x-zfcpdump-rhel.config | 4 ++-- configs/kernel-x86_64-debug-rhel.config | 4 ++-- configs/kernel-x86_64-rhel.config | 4 ++-- configs/kernel-x86_64-rt-debug-rhel.config | 4 ++-- configs/kernel-x86_64-rt-rhel.config | 4 ++-- 34 files changed, 103 insertions(+), 103 deletions(-) diff --git a/configs/kernel-6.12.0-aarch64-64k-debug.config b/configs/kernel-6.12.0-aarch64-64k-debug.config index cf895c09f496e..000b54c82d590 100644 --- a/configs/kernel-6.12.0-aarch64-64k-debug.config +++ b/configs/kernel-6.12.0-aarch64-64k-debug.config @@ -8454,12 +8454,12 @@ CONFIG_CRYPTO_DRBG_HASH=y CONFIG_CRYPTO_DRBG_CTR=y CONFIG_CRYPTO_DRBG=y CONFIG_CRYPTO_JITTERENTROPY=y -CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2=y -# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128 is not set +# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2 is not set +CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128=y # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_1024 is not set # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_8192 is not set -CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKS=64 -CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE=32 +CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKS=512 +CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE=256 CONFIG_CRYPTO_JITTERENTROPY_OSR=3 # CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE is not set CONFIG_CRYPTO_KDF800108_CTR=y diff --git a/configs/kernel-6.12.0-aarch64-64k.config b/configs/kernel-6.12.0-aarch64-64k.config index 9677e40261fa4..be74d14f9e199 100644 --- a/configs/kernel-6.12.0-aarch64-64k.config +++ b/configs/kernel-6.12.0-aarch64-64k.config @@ -8431,12 +8431,12 @@ CONFIG_CRYPTO_DRBG_HASH=y CONFIG_CRYPTO_DRBG_CTR=y CONFIG_CRYPTO_DRBG=y CONFIG_CRYPTO_JITTERENTROPY=y -CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2=y -# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128 is not set +# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2 is not set +CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128=y # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_1024 is not set # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_8192 is not set -CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKS=64 -CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE=32 +CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKS=512 +CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE=256 CONFIG_CRYPTO_JITTERENTROPY_OSR=3 # CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE is not set CONFIG_CRYPTO_KDF800108_CTR=y diff --git a/configs/kernel-6.12.0-aarch64-debug.config b/configs/kernel-6.12.0-aarch64-debug.config index d10b16e93edfd..32985c015e861 100644 --- a/configs/kernel-6.12.0-aarch64-debug.config +++ b/configs/kernel-6.12.0-aarch64-debug.config @@ -8462,12 +8462,12 @@ CONFIG_CRYPTO_DRBG_HASH=y CONFIG_CRYPTO_DRBG_CTR=y CONFIG_CRYPTO_DRBG=y CONFIG_CRYPTO_JITTERENTROPY=y -CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2=y -# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128 is not set +# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2 is not set +CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128=y # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_1024 is not set # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_8192 is not set -CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKS=64 -CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE=32 +CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKS=512 +CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE=256 CONFIG_CRYPTO_JITTERENTROPY_OSR=3 # CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE is not set CONFIG_CRYPTO_KDF800108_CTR=y diff --git a/configs/kernel-6.12.0-aarch64-rt-64k-debug.config b/configs/kernel-6.12.0-aarch64-rt-64k-debug.config index 082a039dbcf16..60a440c609916 100644 --- a/configs/kernel-6.12.0-aarch64-rt-64k-debug.config +++ b/configs/kernel-6.12.0-aarch64-rt-64k-debug.config @@ -8436,12 +8436,12 @@ CONFIG_CRYPTO_DRBG_HASH=y CONFIG_CRYPTO_DRBG_CTR=y CONFIG_CRYPTO_DRBG=y CONFIG_CRYPTO_JITTERENTROPY=y -CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2=y -# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128 is not set +# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2 is not set +CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128=y # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_1024 is not set # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_8192 is not set -CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKS=64 -CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE=32 +CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKS=512 +CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE=256 CONFIG_CRYPTO_JITTERENTROPY_OSR=3 # CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE is not set CONFIG_CRYPTO_KDF800108_CTR=y diff --git a/configs/kernel-6.12.0-aarch64-rt-64k.config b/configs/kernel-6.12.0-aarch64-rt-64k.config index 51d16a92060e6..0472e14c250d1 100644 --- a/configs/kernel-6.12.0-aarch64-rt-64k.config +++ b/configs/kernel-6.12.0-aarch64-rt-64k.config @@ -8413,12 +8413,12 @@ CONFIG_CRYPTO_DRBG_HASH=y CONFIG_CRYPTO_DRBG_CTR=y CONFIG_CRYPTO_DRBG=y CONFIG_CRYPTO_JITTERENTROPY=y -CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2=y -# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128 is not set +# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2 is not set +CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128=y # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_1024 is not set # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_8192 is not set -CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKS=64 -CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE=32 +CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKS=512 +CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE=256 CONFIG_CRYPTO_JITTERENTROPY_OSR=3 # CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE is not set CONFIG_CRYPTO_KDF800108_CTR=y diff --git a/configs/kernel-6.12.0-aarch64-rt-debug.config b/configs/kernel-6.12.0-aarch64-rt-debug.config index e0745eda47f90..54b374fed797b 100644 --- a/configs/kernel-6.12.0-aarch64-rt-debug.config +++ b/configs/kernel-6.12.0-aarch64-rt-debug.config @@ -8443,12 +8443,12 @@ CONFIG_CRYPTO_DRBG_HASH=y CONFIG_CRYPTO_DRBG_CTR=y CONFIG_CRYPTO_DRBG=y CONFIG_CRYPTO_JITTERENTROPY=y -CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2=y -# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128 is not set +# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2 is not set +CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128=y # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_1024 is not set # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_8192 is not set -CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKS=64 -CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE=32 +CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKS=512 +CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE=256 CONFIG_CRYPTO_JITTERENTROPY_OSR=3 # CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE is not set CONFIG_CRYPTO_KDF800108_CTR=y diff --git a/configs/kernel-6.12.0-aarch64-rt.config b/configs/kernel-6.12.0-aarch64-rt.config index 2cba53b93c60c..201e57ff8bb3e 100644 --- a/configs/kernel-6.12.0-aarch64-rt.config +++ b/configs/kernel-6.12.0-aarch64-rt.config @@ -8420,12 +8420,12 @@ CONFIG_CRYPTO_DRBG_HASH=y CONFIG_CRYPTO_DRBG_CTR=y CONFIG_CRYPTO_DRBG=y CONFIG_CRYPTO_JITTERENTROPY=y -CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2=y -# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128 is not set +# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2 is not set +CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128=y # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_1024 is not set # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_8192 is not set -CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKS=64 -CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE=32 +CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKS=512 +CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE=256 CONFIG_CRYPTO_JITTERENTROPY_OSR=3 # CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE is not set CONFIG_CRYPTO_KDF800108_CTR=y diff --git a/configs/kernel-6.12.0-aarch64.config b/configs/kernel-6.12.0-aarch64.config index 49ee0a69b3712..85fa178eb562e 100644 --- a/configs/kernel-6.12.0-aarch64.config +++ b/configs/kernel-6.12.0-aarch64.config @@ -8439,12 +8439,12 @@ CONFIG_CRYPTO_DRBG_HASH=y CONFIG_CRYPTO_DRBG_CTR=y CONFIG_CRYPTO_DRBG=y CONFIG_CRYPTO_JITTERENTROPY=y -CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2=y -# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128 is not set +# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2 is not set +CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128=y # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_1024 is not set # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_8192 is not set -CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKS=64 -CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE=32 +CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKS=512 +CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE=256 CONFIG_CRYPTO_JITTERENTROPY_OSR=3 # CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE is not set CONFIG_CRYPTO_KDF800108_CTR=y diff --git a/configs/kernel-6.12.0-ppc64le-debug.config b/configs/kernel-6.12.0-ppc64le-debug.config index c1fdd9f61bb63..f8d30845b7799 100644 --- a/configs/kernel-6.12.0-ppc64le-debug.config +++ b/configs/kernel-6.12.0-ppc64le-debug.config @@ -6669,12 +6669,12 @@ CONFIG_CRYPTO_DRBG_HASH=y CONFIG_CRYPTO_DRBG_CTR=y CONFIG_CRYPTO_DRBG=y CONFIG_CRYPTO_JITTERENTROPY=y -CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2=y -# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128 is not set +# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2 is not set +CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128=y # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_1024 is not set # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_8192 is not set -CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKS=64 -CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE=32 +CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKS=512 +CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE=256 CONFIG_CRYPTO_JITTERENTROPY_OSR=3 # CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE is not set CONFIG_CRYPTO_KDF800108_CTR=y diff --git a/configs/kernel-6.12.0-ppc64le.config b/configs/kernel-6.12.0-ppc64le.config index a8d1f2bcc9cc6..413a031cc907f 100644 --- a/configs/kernel-6.12.0-ppc64le.config +++ b/configs/kernel-6.12.0-ppc64le.config @@ -1,4 +1,4 @@ -# powerpc +#256 powerpc # # Automatically generated file; DO NOT EDIT. # Linux/powerpc 6.12.0 Kernel Configuration @@ -6670,12 +6670,12 @@ CONFIG_CRYPTO_DRBG_HASH=y CONFIG_CRYPTO_DRBG_CTR=y CONFIG_CRYPTO_DRBG=y CONFIG_CRYPTO_JITTERENTROPY=y -CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2=y -# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128 is not set +# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2 is not set +CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128=y # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_1024 is not set # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_8192 is not set -CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKS=64 -CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE=32 +CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKS=512 +CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE=256 CONFIG_CRYPTO_JITTERENTROPY_OSR=3 # CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE is not set CONFIG_CRYPTO_KDF800108_CTR=y diff --git a/configs/kernel-6.12.0-s390x-debug.config b/configs/kernel-6.12.0-s390x-debug.config index 1af53b6ef21f3..44f2925fa6ada 100644 --- a/configs/kernel-6.12.0-s390x-debug.config +++ b/configs/kernel-6.12.0-s390x-debug.config @@ -3790,12 +3790,12 @@ CONFIG_CRYPTO_DRBG_HASH=y CONFIG_CRYPTO_DRBG_CTR=y CONFIG_CRYPTO_DRBG=y CONFIG_CRYPTO_JITTERENTROPY=y -CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2=y -# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128 is not set +# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2 is not set +CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128=y # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_1024 is not set # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_8192 is not set -CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKS=64 -CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE=32 +CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKS=512 +CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE=256 CONFIG_CRYPTO_JITTERENTROPY_OSR=3 # CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE is not set CONFIG_CRYPTO_KDF800108_CTR=y diff --git a/configs/kernel-6.12.0-s390x-zfcpdump.config b/configs/kernel-6.12.0-s390x-zfcpdump.config index a987a036509c4..fe1ab276ad383 100644 --- a/configs/kernel-6.12.0-s390x-zfcpdump.config +++ b/configs/kernel-6.12.0-s390x-zfcpdump.config @@ -1610,12 +1610,12 @@ CONFIG_CRYPTO_DRBG_HASH=y CONFIG_CRYPTO_DRBG_CTR=y CONFIG_CRYPTO_DRBG=y CONFIG_CRYPTO_JITTERENTROPY=y -CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2=y -# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128 is not set +# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2 is not set +CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128=y # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_1024 is not set # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_8192 is not set -CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKS=64 -CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE=32 +CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKS=512 +CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE=256 CONFIG_CRYPTO_JITTERENTROPY_OSR=3 # CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE is not set # end of Random number generation diff --git a/configs/kernel-6.12.0-s390x.config b/configs/kernel-6.12.0-s390x.config index f81f0515fa186..ddcbef48775e8 100644 --- a/configs/kernel-6.12.0-s390x.config +++ b/configs/kernel-6.12.0-s390x.config @@ -3820,12 +3820,12 @@ CONFIG_CRYPTO_DRBG_HASH=y CONFIG_CRYPTO_DRBG_CTR=y CONFIG_CRYPTO_DRBG=y CONFIG_CRYPTO_JITTERENTROPY=y -CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2=y -# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128 is not set +# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2 is not set +CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128=y # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_1024 is not set # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_8192 is not set -CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKS=64 -CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE=32 +CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKS=512 +CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE=256 CONFIG_CRYPTO_JITTERENTROPY_OSR=3 # CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE is not set CONFIG_CRYPTO_KDF800108_CTR=y diff --git a/configs/kernel-6.12.0-x86_64-debug.config b/configs/kernel-6.12.0-x86_64-debug.config index 0fa3fa0331672..579fa0b4715f3 100644 --- a/configs/kernel-6.12.0-x86_64-debug.config +++ b/configs/kernel-6.12.0-x86_64-debug.config @@ -9356,12 +9356,12 @@ CONFIG_CRYPTO_DRBG_HASH=y CONFIG_CRYPTO_DRBG_CTR=y CONFIG_CRYPTO_DRBG=y CONFIG_CRYPTO_JITTERENTROPY=y -CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2=y -# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128 is not set +# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2 is not set +CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128=y # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_1024 is not set # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_8192 is not set -CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKS=64 -CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE=32 +CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKS=512 +CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE=256 CONFIG_CRYPTO_JITTERENTROPY_OSR=3 # CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE is not set CONFIG_CRYPTO_KDF800108_CTR=y diff --git a/configs/kernel-6.12.0-x86_64-rt-debug.config b/configs/kernel-6.12.0-x86_64-rt-debug.config index f98f4ca84666e..d02a91331bd25 100644 --- a/configs/kernel-6.12.0-x86_64-rt-debug.config +++ b/configs/kernel-6.12.0-x86_64-rt-debug.config @@ -9337,12 +9337,12 @@ CONFIG_CRYPTO_DRBG_HASH=y CONFIG_CRYPTO_DRBG_CTR=y CONFIG_CRYPTO_DRBG=y CONFIG_CRYPTO_JITTERENTROPY=y -CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2=y -# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128 is not set +# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2 is not set +CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128=y # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_1024 is not set # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_8192 is not set -CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKS=64 -CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE=32 +CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKS=512 +CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE=256 CONFIG_CRYPTO_JITTERENTROPY_OSR=3 # CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE is not set CONFIG_CRYPTO_KDF800108_CTR=y diff --git a/configs/kernel-6.12.0-x86_64-rt.config b/configs/kernel-6.12.0-x86_64-rt.config index 5ff666d1e788a..82a00f08ca0c5 100644 --- a/configs/kernel-6.12.0-x86_64-rt.config +++ b/configs/kernel-6.12.0-x86_64-rt.config @@ -9308,12 +9308,12 @@ CONFIG_CRYPTO_DRBG_HASH=y CONFIG_CRYPTO_DRBG_CTR=y CONFIG_CRYPTO_DRBG=y CONFIG_CRYPTO_JITTERENTROPY=y -CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2=y -# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128 is not set +# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2 is not set +CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128=y # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_1024 is not set # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_8192 is not set -CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKS=64 -CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE=32 +CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKS=512 +CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE=256 CONFIG_CRYPTO_JITTERENTROPY_OSR=3 # CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE is not set CONFIG_CRYPTO_KDF800108_CTR=y diff --git a/configs/kernel-6.12.0-x86_64.config b/configs/kernel-6.12.0-x86_64.config index c68aaf662d236..14b339a392eab 100644 --- a/configs/kernel-6.12.0-x86_64.config +++ b/configs/kernel-6.12.0-x86_64.config @@ -9332,12 +9332,12 @@ CONFIG_CRYPTO_DRBG_HASH=y CONFIG_CRYPTO_DRBG_CTR=y CONFIG_CRYPTO_DRBG=y CONFIG_CRYPTO_JITTERENTROPY=y -CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2=y -# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128 is not set +# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2 is not set +CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128=y # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_1024 is not set # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_8192 is not set -CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKS=64 -CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE=32 +CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKS=512 +CONFIG_CRYPTO_JITTERENTROPY_MEMORY_BLOCKSIZE=256 CONFIG_CRYPTO_JITTERENTROPY_OSR=3 # CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE is not set CONFIG_CRYPTO_KDF800108_CTR=y diff --git a/configs/kernel-aarch64-64k-debug-rhel.config b/configs/kernel-aarch64-64k-debug-rhel.config index 1616147b96d5c..6310f7acdf012 100644 --- a/configs/kernel-aarch64-64k-debug-rhel.config +++ b/configs/kernel-aarch64-64k-debug-rhel.config @@ -1295,8 +1295,8 @@ CONFIG_CRYPTO_GHASH=y CONFIG_CRYPTO_HMAC=y CONFIG_CRYPTO_HW=y # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_1024 is not set -# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128 is not set -CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2=y +CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128=y +# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2 is not set # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_8192 is not set CONFIG_CRYPTO_JITTERENTROPY_OSR=3 # CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE is not set diff --git a/configs/kernel-aarch64-64k-rhel.config b/configs/kernel-aarch64-64k-rhel.config index 3bd7c55041bc8..67c8ba8cd773c 100644 --- a/configs/kernel-aarch64-64k-rhel.config +++ b/configs/kernel-aarch64-64k-rhel.config @@ -1295,8 +1295,8 @@ CONFIG_CRYPTO_GHASH=y CONFIG_CRYPTO_HMAC=y CONFIG_CRYPTO_HW=y # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_1024 is not set -# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128 is not set -CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2=y +CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128=y +# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2 is not set # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_8192 is not set CONFIG_CRYPTO_JITTERENTROPY_OSR=3 # CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE is not set diff --git a/configs/kernel-aarch64-debug-rhel.config b/configs/kernel-aarch64-debug-rhel.config index fdf26f2edd3ab..c7db8a101fc56 100644 --- a/configs/kernel-aarch64-debug-rhel.config +++ b/configs/kernel-aarch64-debug-rhel.config @@ -1293,8 +1293,8 @@ CONFIG_CRYPTO_GHASH=y CONFIG_CRYPTO_HMAC=y CONFIG_CRYPTO_HW=y # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_1024 is not set -# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128 is not set -CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2=y +CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128=y +# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2 is not set # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_8192 is not set CONFIG_CRYPTO_JITTERENTROPY_OSR=3 # CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE is not set diff --git a/configs/kernel-aarch64-rhel.config b/configs/kernel-aarch64-rhel.config index 0d89d460d7c65..c90a021e6892d 100644 --- a/configs/kernel-aarch64-rhel.config +++ b/configs/kernel-aarch64-rhel.config @@ -1293,8 +1293,8 @@ CONFIG_CRYPTO_GHASH=y CONFIG_CRYPTO_HMAC=y CONFIG_CRYPTO_HW=y # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_1024 is not set -# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128 is not set -CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2=y +CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128=y +# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2 is not set # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_8192 is not set CONFIG_CRYPTO_JITTERENTROPY_OSR=3 # CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE is not set diff --git a/configs/kernel-aarch64-rt-64k-debug-rhel.config b/configs/kernel-aarch64-rt-64k-debug-rhel.config index 7a158712b1128..abd840b65f668 100644 --- a/configs/kernel-aarch64-rt-64k-debug-rhel.config +++ b/configs/kernel-aarch64-rt-64k-debug-rhel.config @@ -1296,8 +1296,8 @@ CONFIG_CRYPTO_GHASH=y CONFIG_CRYPTO_HMAC=y CONFIG_CRYPTO_HW=y # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_1024 is not set -# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128 is not set -CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2=y +CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128=y +# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_y is not set # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_8192 is not set CONFIG_CRYPTO_JITTERENTROPY_OSR=3 # CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE is not set diff --git a/configs/kernel-aarch64-rt-64k-rhel.config b/configs/kernel-aarch64-rt-64k-rhel.config index bcf1bb15c32bb..7fbc4402dbf17 100644 --- a/configs/kernel-aarch64-rt-64k-rhel.config +++ b/configs/kernel-aarch64-rt-64k-rhel.config @@ -1296,8 +1296,8 @@ CONFIG_CRYPTO_GHASH=y CONFIG_CRYPTO_HMAC=y CONFIG_CRYPTO_HW=y # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_1024 is not set -# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128 is not set -CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2=y +CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128=y +# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2 is not set # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_8192 is not set CONFIG_CRYPTO_JITTERENTROPY_OSR=3 # CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE is not set diff --git a/configs/kernel-aarch64-rt-debug-rhel.config b/configs/kernel-aarch64-rt-debug-rhel.config index 31a53e23779e0..ae2a0c749f221 100644 --- a/configs/kernel-aarch64-rt-debug-rhel.config +++ b/configs/kernel-aarch64-rt-debug-rhel.config @@ -1294,8 +1294,8 @@ CONFIG_CRYPTO_GHASH=y CONFIG_CRYPTO_HMAC=y CONFIG_CRYPTO_HW=y # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_1024 is not set -# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128 is not set -CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2=y +CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128=y +# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2 is not set # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_8192 is not set CONFIG_CRYPTO_JITTERENTROPY_OSR=3 # CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE is not set diff --git a/configs/kernel-aarch64-rt-rhel.config b/configs/kernel-aarch64-rt-rhel.config index 1ac328a2f2863..5def750be8fcb 100644 --- a/configs/kernel-aarch64-rt-rhel.config +++ b/configs/kernel-aarch64-rt-rhel.config @@ -1294,8 +1294,8 @@ CONFIG_CRYPTO_GHASH=y CONFIG_CRYPTO_HMAC=y CONFIG_CRYPTO_HW=y # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_1024 is not set -# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128 is not set -CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2=y +CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128=y +# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2 is not set # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_8192 is not set CONFIG_CRYPTO_JITTERENTROPY_OSR=3 # CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE is not set diff --git a/configs/kernel-ppc64le-debug-rhel.config b/configs/kernel-ppc64le-debug-rhel.config index 24c7b6cdf2605..6cdcd62d166b6 100644 --- a/configs/kernel-ppc64le-debug-rhel.config +++ b/configs/kernel-ppc64le-debug-rhel.config @@ -1055,8 +1055,8 @@ CONFIG_CRYPTO_GHASH=y CONFIG_CRYPTO_HMAC=y CONFIG_CRYPTO_HW=y # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_1024 is not set -# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128 is not set -CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2=y +CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128=y +# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2 is not set # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_8192 is not set CONFIG_CRYPTO_JITTERENTROPY_OSR=3 # CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE is not set diff --git a/configs/kernel-ppc64le-rhel.config b/configs/kernel-ppc64le-rhel.config index 355bf6a015b75..e0217bb0c91a3 100644 --- a/configs/kernel-ppc64le-rhel.config +++ b/configs/kernel-ppc64le-rhel.config @@ -1055,8 +1055,8 @@ CONFIG_CRYPTO_GHASH=y CONFIG_CRYPTO_HMAC=y CONFIG_CRYPTO_HW=y # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_1024 is not set -# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128 is not set -CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2=y +CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128=y +# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2 is not set # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_8192 is not set CONFIG_CRYPTO_JITTERENTROPY_OSR=3 # CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE is not set diff --git a/configs/kernel-s390x-debug-rhel.config b/configs/kernel-s390x-debug-rhel.config index e45def33f6ba9..e8b2bb7e40b42 100644 --- a/configs/kernel-s390x-debug-rhel.config +++ b/configs/kernel-s390x-debug-rhel.config @@ -1053,8 +1053,8 @@ CONFIG_CRYPTO_HMAC_S390=y CONFIG_CRYPTO_HMAC=y CONFIG_CRYPTO_HW=y # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_1024 is not set -# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128 is not set -CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2=y +CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128=y +# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2 is not set # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_8192 is not set CONFIG_CRYPTO_JITTERENTROPY_OSR=3 # CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE is not set diff --git a/configs/kernel-s390x-rhel.config b/configs/kernel-s390x-rhel.config index 959a8db8b34f8..a67c0c78c90b9 100644 --- a/configs/kernel-s390x-rhel.config +++ b/configs/kernel-s390x-rhel.config @@ -1053,8 +1053,8 @@ CONFIG_CRYPTO_HMAC_S390=y CONFIG_CRYPTO_HMAC=y CONFIG_CRYPTO_HW=y # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_1024 is not set -# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128 is not set -CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2=y +CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128=y +# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2 is not set # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_8192 is not set CONFIG_CRYPTO_JITTERENTROPY_OSR=3 # CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE is not set diff --git a/configs/kernel-s390x-zfcpdump-rhel.config b/configs/kernel-s390x-zfcpdump-rhel.config index e9a45b30b5f8d..61bd6210098a0 100644 --- a/configs/kernel-s390x-zfcpdump-rhel.config +++ b/configs/kernel-s390x-zfcpdump-rhel.config @@ -1054,8 +1054,8 @@ CONFIG_CRYPTO_GHASH=y CONFIG_CRYPTO_HMAC=y CONFIG_CRYPTO_HW=y # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_1024 is not set -# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128 is not set -CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2=y +CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128=y +# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2 is not set # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_8192 is not set CONFIG_CRYPTO_JITTERENTROPY_OSR=3 # CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE is not set diff --git a/configs/kernel-x86_64-debug-rhel.config b/configs/kernel-x86_64-debug-rhel.config index 33fb59ac0c05c..e7691899a3111 100644 --- a/configs/kernel-x86_64-debug-rhel.config +++ b/configs/kernel-x86_64-debug-rhel.config @@ -1110,8 +1110,8 @@ CONFIG_CRYPTO_GHASH=y CONFIG_CRYPTO_HMAC=y CONFIG_CRYPTO_HW=y # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_1024 is not set -# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128 is not set -CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2=y +CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128=y +# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2 is not set # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_8192 is not set CONFIG_CRYPTO_JITTERENTROPY_OSR=3 # CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE is not set diff --git a/configs/kernel-x86_64-rhel.config b/configs/kernel-x86_64-rhel.config index f0f57e80f13b6..dc7d9469bdd02 100644 --- a/configs/kernel-x86_64-rhel.config +++ b/configs/kernel-x86_64-rhel.config @@ -1110,8 +1110,8 @@ CONFIG_CRYPTO_GHASH=y CONFIG_CRYPTO_HMAC=y CONFIG_CRYPTO_HW=y # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_1024 is not set -# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128 is not set -CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2=y +CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128=y +# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2 is not set # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_8192 is not set CONFIG_CRYPTO_JITTERENTROPY_OSR=3 # CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE is not set diff --git a/configs/kernel-x86_64-rt-debug-rhel.config b/configs/kernel-x86_64-rt-debug-rhel.config index f4e55a3ef0c6b..6f0d51728f893 100644 --- a/configs/kernel-x86_64-rt-debug-rhel.config +++ b/configs/kernel-x86_64-rt-debug-rhel.config @@ -1111,8 +1111,8 @@ CONFIG_CRYPTO_GHASH=y CONFIG_CRYPTO_HMAC=y CONFIG_CRYPTO_HW=y # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_1024 is not set -# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128 is not set -CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2=y +CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128=y +# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2 is not set # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_8192 is not set CONFIG_CRYPTO_JITTERENTROPY_OSR=3 # CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE is not set diff --git a/configs/kernel-x86_64-rt-rhel.config b/configs/kernel-x86_64-rt-rhel.config index 0f3db2307a5da..87002f918c440 100644 --- a/configs/kernel-x86_64-rt-rhel.config +++ b/configs/kernel-x86_64-rt-rhel.config @@ -1111,8 +1111,8 @@ CONFIG_CRYPTO_GHASH=y CONFIG_CRYPTO_HMAC=y CONFIG_CRYPTO_HW=y # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_1024 is not set -# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128 is not set -CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2=y +CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_128=y +# CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_2 is not set # CONFIG_CRYPTO_JITTERENTROPY_MEMSIZE_8192 is not set CONFIG_CRYPTO_JITTERENTROPY_OSR=3 # CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE is not set