| // SPDX-License-Identifier: GPL-2.0-only | |
| /* | |
| * Copyright 2021 Google LLC | |
| * Author: Ard Biesheuvel <ardb@google.com> | |
| * | |
| * This file is the core of fips140.ko, which contains various crypto algorithms | |
| * that are also built into vmlinux. At load time, this module overrides the | |
| * built-in implementations of these algorithms with its implementations. It | |
| * also runs self-tests on these algorithms and verifies the integrity of its | |
| * code and data. If either of these steps fails, the kernel will panic. | |
| * | |
| * This module is intended to be loaded at early boot time in order to meet | |
| * FIPS 140 and NIAP FPT_TST_EXT.1 requirements. It shouldn't be used if you | |
| * don't need to meet these requirements. | |
| */ | |
| /* | |
| * Since this .c file is the real entry point of fips140.ko, it needs to be | |
| * compiled normally, so undo the hacks that were done in fips140-defs.h. | |
| */ | |
| #define MODULE | |
| #undef KBUILD_MODFILE | |
| #undef __DISABLE_EXPORTS | |
| #include <linux/ctype.h> | |
| #include <linux/debugfs.h> | |
| #include <linux/module.h> | |
| #include <crypto/aead.h> | |
| #include <crypto/aes.h> | |
| #include <crypto/fips140-lib-overrides.h> | |
| #include <crypto/sha2.h> | |
| #include <crypto/skcipher.h> | |
| #include <crypto/rng.h> | |
| #include "fips140-module.h" | |
| #include "internal.h" | |
| /* | |
| * FIPS 140-2 prefers the use of HMAC with a public key over a plain hash. | |
| */ | |
| u8 __initdata fips140_integ_hmac_key[] = "The quick brown fox jumps over the lazy dog"; | |
| /* this is populated by the build tool */ | |
| u8 __initdata fips140_integ_hmac_digest[SHA256_DIGEST_SIZE]; | |
| const initcall_entry_t __fips140_initcalls_start __section(".initcalls._start"); | |
| const initcall_entry_t __fips140_initcalls_end __section(".initcalls._end"); | |
| const u8 __fips140_text_start __section(".text.._start"); | |
| const u8 __fips140_text_end __section(".text.._end"); | |
| const u8 __fips140_rodata_start __section(".rodata.._start"); | |
| const u8 __fips140_rodata_end __section(".rodata.._end"); | |
| /* | |
| * We need this little detour to prevent Clang from detecting out of bounds | |
| * accesses to the above *_start symbols, which exist only to delineate the | |
| * corresponding sections, and so their sizes are not relevant to us. | |
| */ | |
| const initcall_entry_t *fips140_initcalls_start = &__fips140_initcalls_start; | |
| const u8 *fips140_text_start = &__fips140_text_start; | |
| const u8 *fips140_rodata_start = &__fips140_rodata_start; | |
| /* | |
| * fips140_algs[] lists the algorithms that this module unregisters from the | |
| * kernel crypto API so that it can register its own implementation(s) of them. | |
| * | |
| * There are two reasons to do the unregistration, i.e. replace the kernel's | |
| * algorithms instead of just adding more algorithms. First, the kernel crypto | |
| * API doesn't allow algorithms with duplicate driver names. Second, for FIPS | |
| * approved algorithms we have to ensure that the FIPS copies are actually used. | |
| */ | |
| static struct fips140_alg { | |
| /* | |
| * Either cra_name or cra_driver_name is set. | |
| * | |
| * cra_name makes the entry match all software implementations of a | |
| * given algorithm. This is used when the module is meant to replace | |
| * *all* software implementations of the algorithm. This is required | |
| * for FIPS approved algorithms (approved=true). When using this style | |
| * of matching, it must be ensured that the module contains all the same | |
| * implementations of the algorithm as the kernel itself; otherwise the | |
| * kernel's functionality and/or performance could be impacted by the | |
| * insertion of the fips140 module. | |
| * | |
| * cra_driver_name makes the entry match a single implementation of an | |
| * algorithm. This is used for some specific non FIPS approved | |
| * algorithm implementations that get pulled in by being located in the | |
| * same source files as implementations of FIPS approved algorithms. | |
| */ | |
| const char *cra_name; | |
| const char *cra_driver_name; | |
| /* | |
| * approved is true if fips140_is_approved_service() should return that | |
| * the algorithm is approved. This requires cra_name != NULL. | |
| */ | |
| bool approved; | |
| /* | |
| * unregistered_inkern gets set to true at runtime if at least one | |
| * algorithm matching this entry was unregistered from the kernel. This | |
| * is used to detect unregistrations with no matching registration. | |
| */ | |
| bool unregistered_inkern; | |
| } fips140_algs[] = { | |
| /* Approved algorithms, all specified by cra_name */ | |
| { .cra_name = "aes", .approved = true }, | |
| { .cra_name = "cbc(aes)", .approved = true }, | |
| { .cra_name = "cmac(aes)", .approved = true }, | |
| { .cra_name = "ctr(aes)", .approved = true }, | |
| { .cra_name = "cts(cbc(aes))", .approved = true }, | |
| { .cra_name = "ecb(aes)", .approved = true }, | |
| { .cra_name = "hmac(sha224)", .approved = true }, | |
| { .cra_name = "hmac(sha256)", .approved = true }, | |
| { .cra_name = "hmac(sha384)", .approved = true }, | |
| { .cra_name = "hmac(sha512)", .approved = true }, | |
| { .cra_name = "sha224", .approved = true }, | |
| { .cra_name = "sha256", .approved = true }, | |
| { .cra_name = "sha384", .approved = true }, | |
| { .cra_name = "sha512", .approved = true }, | |
| { .cra_name = "sha3-224", .approved = true }, | |
| { .cra_name = "sha3-256", .approved = true }, | |
| { .cra_name = "sha3-384", .approved = true }, | |
| { .cra_name = "sha3-512", .approved = true }, | |
| { .cra_name = "stdrng", .approved = true }, | |
| { .cra_name = "xts(aes)", .approved = true }, | |
| /* | |
| * Non-approved algorithms specified by cra_name. | |
| * | |
| * Due to a quirk in the FIPS requirements, AES-GCM can't be FIPS | |
| * approved. But we treat it the same as approved algorithms in that we | |
| * ensure that a self-test and all needed implementations are included. | |
| * | |
| * The Jitter RNG is needed in the module as an entropy source for the | |
| * DRBG algorithms, but it's not considered to be approved itself. | |
| */ | |
| { .cra_name = "gcm(aes)" }, | |
| { .cra_name = "jitterentropy_rng" }, | |
| /* Non-approved algorithms specified by cra_driver_name */ | |
| { .cra_driver_name = "essiv-cbc-aes-sha256-ce" }, | |
| { .cra_driver_name = "essiv-cbc-aes-sha256-neon" }, | |
| { .cra_driver_name = "cbcmac-aes-ce" }, | |
| { .cra_driver_name = "cbcmac-aes-neon" }, | |
| { .cra_driver_name = "rfc4106-gcm-aes-ce" }, | |
| { .cra_driver_name = "xcbc-aes-ce" }, | |
| { .cra_driver_name = "xcbc-aes-neon" }, | |
| { .cra_driver_name = "xctr-aes-ce" }, | |
| { .cra_driver_name = "xctr-aes-neon" }, | |
| }; | |
| /* | |
| * Return true if the crypto API algorithm @calg is matched by the fips140 | |
| * module algorithm specification @falg. | |
| */ | |
| static bool __init fips140_alg_matches(const struct fips140_alg *falg, | |
| const struct crypto_alg *calg) | |
| { | |
| /* | |
| * All software algorithms are synchronous. Hardware algorithms must be | |
| * covered by their own FIPS 140 certification. | |
| */ | |
| if (calg->cra_flags & CRYPTO_ALG_ASYNC) | |
| return false; | |
| if (falg->cra_name != NULL && | |
| strcmp(falg->cra_name, calg->cra_name) == 0) | |
| return true; | |
| if (falg->cra_driver_name != NULL && | |
| strcmp(falg->cra_driver_name, calg->cra_driver_name) == 0) | |
| return true; | |
| return false; | |
| } | |
| /* Find the entry in fips140_algs[], if any, that @calg is matched by. */ | |
| static struct fips140_alg *__init | |
| fips140_find_matching_alg(const struct crypto_alg *calg) | |
| { | |
| size_t i; | |
| for (i = 0; i < ARRAY_SIZE(fips140_algs); i++) { | |
| if (fips140_alg_matches(&fips140_algs[i], calg)) | |
| return &fips140_algs[i]; | |
| } | |
| return NULL; | |
| } | |
| /* | |
| * FIPS 140-3 service indicators. FIPS 140-3 requires that all services | |
| * "provide an indicator when the service utilises an approved cryptographic | |
| * algorithm, security function or process in an approved manner". What this | |
| * means is very debatable, even with the help of the FIPS 140-3 Implementation | |
| * Guidance document. However, it was decided that a function that takes in an | |
| * algorithm name and returns whether that algorithm is approved or not will | |
| * meet this requirement. Note, this relies on some properties of the module: | |
| * | |
| * - The module doesn't distinguish between "services" and "algorithms"; its | |
| * services are simply its algorithms. | |
| * | |
| * - The status of an approved algorithm is never non-approved, since (a) the | |
| * module doesn't support operating in a non-approved mode, such as a mode | |
| * where the self-tests are skipped; (b) there are no cases where the module | |
| * supports non-approved settings for approved algorithms, e.g. | |
| * non-approved key sizes; and (c) this function isn't available to be | |
| * called until the module_init function has completed, so it's guaranteed | |
| * that the self-tests and integrity check have already passed. | |
| * | |
| * - The module does support some non-approved algorithms, so a single static | |
| * indicator ("return true;") would not be acceptable. | |
| */ | |
| bool fips140_is_approved_service(const char *name) | |
| { | |
| size_t i; | |
| for (i = 0; i < ARRAY_SIZE(fips140_algs); i++) { | |
| if (fips140_algs[i].approved && | |
| fips140_algs[i].cra_name != NULL && | |
| strcmp(name, fips140_algs[i].cra_name) == 0) | |
| return true; | |
| } | |
| return false; | |
| } | |
| EXPORT_SYMBOL_GPL(fips140_is_approved_service); | |
| /* | |
| * FIPS 140-3 requires that modules provide a "service" that outputs "the name | |
| * or module identifier and the versioning information that can be correlated | |
| * with a validation record". This function meets that requirement. | |
| * | |
| * Note: the module also prints this same information to the kernel log when it | |
| * is loaded. That might meet the requirement by itself. However, given the | |
| * vagueness of what counts as a "service", we provide this function too, just | |
| * in case the certification lab or CMVP is happier with an explicit function. | |
| * | |
| * Note: /sys/modules/fips140/scmversion also provides versioning information | |
| * about the module. However that file just shows the bare git commit ID, so it | |
| * probably isn't sufficient to meet the FIPS requirement, which seems to want | |
| * the "official" module name and version number used in the FIPS certificate. | |
| */ | |
| const char *fips140_module_version(void) | |
| { | |
| return FIPS140_MODULE_NAME " " FIPS140_MODULE_VERSION; | |
| } | |
| EXPORT_SYMBOL_GPL(fips140_module_version); | |
| static LIST_HEAD(existing_live_algos); | |
| /* | |
| * Release a list of algorithms which have been removed from crypto_alg_list. | |
| * | |
| * Note that even though the list is a private list, we have to hold | |
| * crypto_alg_sem while iterating through it because crypto_unregister_alg() may | |
| * run concurrently (as we haven't taken a reference to the algorithms on the | |
| * list), and crypto_unregister_alg() will remove the algorithm from whichever | |
| * list it happens to be on, while holding crypto_alg_sem. That's okay, since | |
| * in that case crypto_unregister_alg() will handle the crypto_alg_put(). | |
| */ | |
| static void fips140_remove_final(struct list_head *list) | |
| { | |
| struct crypto_alg *alg; | |
| struct crypto_alg *n; | |
| /* | |
| * We need to take crypto_alg_sem to safely traverse the list (see | |
| * comment above), but we have to drop it when doing each | |
| * crypto_alg_put() as that may take crypto_alg_sem again. | |
| */ | |
| down_write(&crypto_alg_sem); | |
| list_for_each_entry_safe(alg, n, list, cra_list) { | |
| list_del_init(&alg->cra_list); | |
| up_write(&crypto_alg_sem); | |
| crypto_alg_put(alg); | |
| down_write(&crypto_alg_sem); | |
| } | |
| up_write(&crypto_alg_sem); | |
| } | |
| static void __init unregister_existing_fips140_algos(void) | |
| { | |
| struct crypto_alg *calg, *tmp; | |
| LIST_HEAD(remove_list); | |
| LIST_HEAD(spawns); | |
| down_write(&crypto_alg_sem); | |
| /* | |
| * Find all registered algorithms that we care about, and move them to a | |
| * private list so that they are no longer exposed via the algo lookup | |
| * API. Subsequently, we will unregister them if they are not in active | |
| * use. If they are, we can't fully unregister them but we can ensure | |
| * that new users won't use them. | |
| */ | |
| list_for_each_entry_safe(calg, tmp, &crypto_alg_list, cra_list) { | |
| struct fips140_alg *falg = fips140_find_matching_alg(calg); | |
| if (!falg) | |
| continue; | |
| falg->unregistered_inkern = true; | |
| if (refcount_read(&calg->cra_refcnt) == 1) { | |
| /* | |
| * This algorithm is not currently in use, but there may | |
| * be template instances holding references to it via | |
| * spawns. So let's tear it down like | |
| * crypto_unregister_alg() would, but without releasing | |
| * the lock, to prevent races with concurrent TFM | |
| * allocations. | |
| */ | |
| calg->cra_flags |= CRYPTO_ALG_DEAD; | |
| list_move(&calg->cra_list, &remove_list); | |
| crypto_remove_spawns(calg, &spawns, NULL); | |
| } else { | |
| /* | |
| * This algorithm is live, i.e. it has TFMs allocated, | |
| * so we can't fully unregister it. It's not necessary | |
| * to dynamically redirect existing users to the FIPS | |
| * code, given that they can't be relying on FIPS | |
| * certified crypto in the first place. However, we do | |
| * need to ensure that new users will get the FIPS code. | |
| * | |
| * In most cases, setting calg->cra_priority to 0 | |
| * achieves this. However, that isn't enough for | |
| * algorithms like "hmac(sha256)" that need to be | |
| * instantiated from a template, since existing | |
| * algorithms always take priority over a template being | |
| * instantiated. Therefore, we move the algorithm to | |
| * a private list so that algorithm lookups won't find | |
| * it anymore. To further distinguish it from the FIPS | |
| * algorithms, we also append "+orig" to its name. | |
| */ | |
| pr_info("found already-live algorithm '%s' ('%s')\n", | |
| calg->cra_name, calg->cra_driver_name); | |
| calg->cra_priority = 0; | |
| strlcat(calg->cra_name, "+orig", CRYPTO_MAX_ALG_NAME); | |
| strlcat(calg->cra_driver_name, "+orig", | |
| CRYPTO_MAX_ALG_NAME); | |
| list_move(&calg->cra_list, &existing_live_algos); | |
| } | |
| } | |
| up_write(&crypto_alg_sem); | |
| fips140_remove_final(&remove_list); | |
| fips140_remove_final(&spawns); | |
| } | |
| /* | |
| * The algorithms unregistered by fips140.ko are determined by fips140_algs[], | |
| * but the algorithms registered by fips140.ko are determined by its initcalls. | |
| * There is a chance these get out of sync. Therefore, this function detects | |
| * cases where an algorithm was unregistered without a replacement being | |
| * registered. It returns true if things look ok or false if there's a problem. | |
| */ | |
| static bool __init fips140_verify_no_extra_unregistrations(void) | |
| { | |
| bool ok = true; | |
| size_t i; | |
| down_read(&crypto_alg_sem); | |
| for (i = 0; i < ARRAY_SIZE(fips140_algs); i++) { | |
| const struct fips140_alg *falg = &fips140_algs[i]; | |
| const struct crypto_alg *calg; | |
| bool registered = false; | |
| if (!falg->unregistered_inkern) | |
| continue; | |
| list_for_each_entry(calg, &crypto_alg_list, cra_list) { | |
| if (fips140_alg_matches(falg, calg)) { | |
| registered = true; | |
| break; | |
| } | |
| } | |
| if (!registered) { | |
| pr_err("This module unregistered %s but did not replace it!\n", | |
| falg->cra_name ?: falg->cra_driver_name); | |
| pr_err("Either remove it from fips140_algs[], or fix the module to include it.\n"); | |
| ok = false; | |
| } | |
| } | |
| up_read(&crypto_alg_sem); | |
| return ok; | |
| } | |
| static void __init unapply_text_relocations(void *section, int section_size, | |
| const Elf64_Rela *rela, int numrels) | |
| { | |
| while (numrels--) { | |
| u32 *place = (u32 *)(section + rela->r_offset); | |
| BUG_ON(rela->r_offset >= section_size); | |
| switch (ELF64_R_TYPE(rela->r_info)) { | |
| #ifdef CONFIG_ARM64 | |
| case R_AARCH64_ABS32: /* for KCFI */ | |
| *place = 0; | |
| break; | |
| case R_AARCH64_JUMP26: | |
| case R_AARCH64_CALL26: | |
| *place &= ~GENMASK(25, 0); | |
| break; | |
| case R_AARCH64_ADR_PREL_LO21: | |
| case R_AARCH64_ADR_PREL_PG_HI21: | |
| case R_AARCH64_ADR_PREL_PG_HI21_NC: | |
| *place &= ~(GENMASK(30, 29) | GENMASK(23, 5)); | |
| break; | |
| case R_AARCH64_ADD_ABS_LO12_NC: | |
| case R_AARCH64_LDST8_ABS_LO12_NC: | |
| case R_AARCH64_LDST16_ABS_LO12_NC: | |
| case R_AARCH64_LDST32_ABS_LO12_NC: | |
| case R_AARCH64_LDST64_ABS_LO12_NC: | |
| case R_AARCH64_LDST128_ABS_LO12_NC: | |
| *place &= ~GENMASK(21, 10); | |
| break; | |
| default: | |
| pr_err("unhandled relocation type %llu\n", | |
| ELF64_R_TYPE(rela->r_info)); | |
| BUG(); | |
| #else | |
| #error | |
| #endif | |
| } | |
| rela++; | |
| } | |
| } | |
| static void __init unapply_rodata_relocations(void *section, int section_size, | |
| const Elf64_Rela *rela, int numrels) | |
| { | |
| while (numrels--) { | |
| void *place = section + rela->r_offset; | |
| BUG_ON(rela->r_offset >= section_size); | |
| switch (ELF64_R_TYPE(rela->r_info)) { | |
| #ifdef CONFIG_ARM64 | |
| case R_AARCH64_ABS64: | |
| *(u64 *)place = 0; | |
| break; | |
| default: | |
| pr_err("unhandled relocation type %llu\n", | |
| ELF64_R_TYPE(rela->r_info)); | |
| BUG(); | |
| #else | |
| #error | |
| #endif | |
| } | |
| rela++; | |
| } | |
| } | |
| enum { | |
| PACIASP = 0xd503233f, | |
| AUTIASP = 0xd50323bf, | |
| SCS_PUSH = 0xf800865e, | |
| SCS_POP = 0xf85f8e5e, | |
| }; | |
| /* | |
| * To make the integrity check work with dynamic Shadow Call Stack (SCS), | |
| * replace all instructions that push or pop from the SCS with the Pointer | |
| * Authentication Code (PAC) instructions that were present originally. | |
| */ | |
| static void __init unapply_scs_patch(void *section, int section_size) | |
| { | |
| #if defined(CONFIG_ARM64) && defined(CONFIG_UNWIND_PATCH_PAC_INTO_SCS) | |
| u32 *insns = section; | |
| int i; | |
| for (i = 0; i < section_size / sizeof(insns[0]); i++) { | |
| if (insns[i] == SCS_PUSH) | |
| insns[i] = PACIASP; | |
| else if (insns[i] == SCS_POP) | |
| insns[i] = AUTIASP; | |
| } | |
| #endif | |
| } | |
| #ifdef CONFIG_CRYPTO_FIPS140_MOD_DEBUG_INTEGRITY_CHECK | |
| static struct { | |
| const void *text; | |
| int textsize; | |
| const void *rodata; | |
| int rodatasize; | |
| } saved_integrity_check_info; | |
| static ssize_t fips140_text_read(struct file *file, char __user *to, | |
| size_t count, loff_t *ppos) | |
| { | |
| return simple_read_from_buffer(to, count, ppos, | |
| saved_integrity_check_info.text, | |
| saved_integrity_check_info.textsize); | |
| } | |
| static ssize_t fips140_rodata_read(struct file *file, char __user *to, | |
| size_t count, loff_t *ppos) | |
| { | |
| return simple_read_from_buffer(to, count, ppos, | |
| saved_integrity_check_info.rodata, | |
| saved_integrity_check_info.rodatasize); | |
| } | |
| static const struct file_operations fips140_text_fops = { | |
| .read = fips140_text_read, | |
| }; | |
| static const struct file_operations fips140_rodata_fops = { | |
| .read = fips140_rodata_read, | |
| }; | |
| static void fips140_init_integrity_debug_files(const void *text, int textsize, | |
| const void *rodata, | |
| int rodatasize) | |
| { | |
| struct dentry *dir; | |
| dir = debugfs_create_dir("fips140", NULL); | |
| saved_integrity_check_info.text = kmemdup(text, textsize, GFP_KERNEL); | |
| saved_integrity_check_info.textsize = textsize; | |
| if (saved_integrity_check_info.text) | |
| debugfs_create_file("text", 0400, dir, NULL, | |
| &fips140_text_fops); | |
| saved_integrity_check_info.rodata = kmemdup(rodata, rodatasize, | |
| GFP_KERNEL); | |
| saved_integrity_check_info.rodatasize = rodatasize; | |
| if (saved_integrity_check_info.rodata) | |
| debugfs_create_file("rodata", 0400, dir, NULL, | |
| &fips140_rodata_fops); | |
| } | |
| #else /* CONFIG_CRYPTO_FIPS140_MOD_DEBUG_INTEGRITY_CHECK */ | |
| static void fips140_init_integrity_debug_files(const void *text, int textsize, | |
| const void *rodata, | |
| int rodatasize) | |
| { | |
| } | |
| #endif /* !CONFIG_CRYPTO_FIPS140_MOD_DEBUG_INTEGRITY_CHECK */ | |
| extern struct { | |
| u32 offset; | |
| u32 count; | |
| } fips140_rela_text, fips140_rela_rodata; | |
| static bool __init check_fips140_module_hmac(void) | |
| { | |
| struct hmac_sha256_ctx ctx; | |
| u8 digest[SHA256_DIGEST_SIZE]; | |
| void *textcopy, *rodatacopy; | |
| int textsize, rodatasize; | |
| bool ok = false; | |
| textsize = &__fips140_text_end - &__fips140_text_start; | |
| rodatasize = &__fips140_rodata_end - &__fips140_rodata_start; | |
| pr_info("text size : 0x%x\n", textsize); | |
| pr_info("rodata size: 0x%x\n", rodatasize); | |
| textcopy = kmalloc(textsize + rodatasize, GFP_KERNEL); | |
| if (!textcopy) { | |
| pr_err("Failed to allocate memory for copy of .text\n"); | |
| goto out; | |
| } | |
| rodatacopy = textcopy + textsize; | |
| memcpy(textcopy, fips140_text_start, textsize); | |
| memcpy(rodatacopy, fips140_rodata_start, rodatasize); | |
| // apply the relocations in reverse on the copies of .text and .rodata | |
| unapply_text_relocations(textcopy, textsize, | |
| offset_to_ptr(&fips140_rela_text.offset), | |
| fips140_rela_text.count); | |
| unapply_rodata_relocations(rodatacopy, rodatasize, | |
| offset_to_ptr(&fips140_rela_rodata.offset), | |
| fips140_rela_rodata.count); | |
| unapply_scs_patch(textcopy, textsize); | |
| fips140_init_integrity_debug_files(textcopy, textsize, | |
| rodatacopy, rodatasize); | |
| fips140_inject_integrity_failure(textcopy); | |
| hmac_sha256_init_usingrawkey(&ctx, fips140_integ_hmac_key, | |
| strlen(fips140_integ_hmac_key)); | |
| hmac_sha256_update(&ctx, textcopy, textsize); | |
| hmac_sha256_update(&ctx, rodatacopy, rodatasize); | |
| hmac_sha256_final(&ctx, digest); | |
| if (memcmp(digest, fips140_integ_hmac_digest, sizeof(digest))) { | |
| pr_err("provided_digest : %*phN\n", (int)sizeof(digest), | |
| fips140_integ_hmac_digest); | |
| pr_err("calculated digest: %*phN\n", (int)sizeof(digest), | |
| digest); | |
| goto out; | |
| } | |
| ok = true; | |
| out: | |
| /* | |
| * FIPS 140-3 requires that all "temporary value(s) generated during the | |
| * integrity test" be zeroized (ref: FIPS 140-3 IG 9.7.B). There is no | |
| * technical reason to do this given that these values are public | |
| * information, but this is the requirement so we follow it. | |
| */ | |
| memzero_explicit(digest, sizeof(digest)); | |
| kfree_sensitive(textcopy); | |
| return ok; | |
| } | |
| #define FUNC(func) .func = func | |
| static const struct fips140_lib_funcs lib_funcs = { | |
| /* lib/crypto/aes.c */ | |
| FUNC(aes_expandkey), | |
| FUNC(aes_encrypt), | |
| FUNC(aes_decrypt), | |
| /* lib/crypto/sha256.c */ | |
| FUNC(sha224_init), | |
| FUNC(sha256_init), | |
| FUNC(__sha256_update), | |
| FUNC(sha224_final), | |
| FUNC(sha256_final), | |
| FUNC(sha224), | |
| FUNC(sha256), | |
| FUNC(sha256_finup_2x), | |
| FUNC(sha256_finup_2x_is_optimized), | |
| FUNC(hmac_sha224_preparekey), | |
| FUNC(hmac_sha256_preparekey), | |
| FUNC(__hmac_sha256_init), | |
| FUNC(hmac_sha224_init_usingrawkey), | |
| FUNC(hmac_sha256_init_usingrawkey), | |
| FUNC(hmac_sha224_final), | |
| FUNC(hmac_sha256_final), | |
| FUNC(hmac_sha224), | |
| FUNC(hmac_sha256), | |
| FUNC(hmac_sha224_usingrawkey), | |
| FUNC(hmac_sha256_usingrawkey), | |
| /* lib/crypto/sha512.c */ | |
| FUNC(sha384_init), | |
| FUNC(sha512_init), | |
| FUNC(__sha512_update), | |
| FUNC(sha384_final), | |
| FUNC(sha512_final), | |
| FUNC(sha384), | |
| FUNC(sha512), | |
| FUNC(hmac_sha384_preparekey), | |
| FUNC(hmac_sha512_preparekey), | |
| FUNC(__hmac_sha512_init), | |
| FUNC(hmac_sha384_init_usingrawkey), | |
| FUNC(hmac_sha512_init_usingrawkey), | |
| FUNC(hmac_sha384_final), | |
| FUNC(hmac_sha512_final), | |
| FUNC(hmac_sha384), | |
| FUNC(hmac_sha512), | |
| FUNC(hmac_sha384_usingrawkey), | |
| FUNC(hmac_sha512_usingrawkey), | |
| }; | |
| #undef FUNC | |
| static bool update_fips140_library_routines(void) | |
| { | |
| void *const *p = (const void *)&lib_funcs; | |
| size_t num_funcs = sizeof(lib_funcs) / sizeof(p[0]); | |
| /* Ensure that every entry in fips140_lib_funcs is filled in. */ | |
| for (size_t i = 0; i < num_funcs; i++) { | |
| if (p[i] == NULL) | |
| panic("Missing entry in fips140_lib_funcs"); | |
| } | |
| register_fips140_lib_funcs(&lib_funcs); | |
| pr_info("registered %zu library functions\n", num_funcs); | |
| return true; | |
| } | |
| /* Initialize the FIPS 140 module */ | |
| static int __init fips140_init(void) | |
| { | |
| const initcall_entry_t *initcall; | |
| pr_info("loading " FIPS140_MODULE_NAME " " FIPS140_MODULE_VERSION "\n"); | |
| fips140_init_thread = current; | |
| unregister_existing_fips140_algos(); | |
| /* iterate over all init routines present in this module and call them */ | |
| for (initcall = fips140_initcalls_start + 1; | |
| initcall < &__fips140_initcalls_end; | |
| initcall++) { | |
| initcall_t init = offset_to_ptr(initcall); | |
| int err = init(); | |
| /* | |
| * ENODEV is expected from initcalls that only register | |
| * algorithms that depend on non-present CPU features. Besides | |
| * that, errors aren't expected here. | |
| */ | |
| if (err && err != -ENODEV) { | |
| pr_err("initcall %ps() failed: %d\n", init, err); | |
| goto panic; | |
| } | |
| } | |
| if (!fips140_run_selftests()) | |
| goto panic; | |
| if (!fips140_verify_no_extra_unregistrations()) | |
| goto panic; | |
| /* | |
| * It may seem backward to perform the integrity check last, but this | |
| * is intentional: the check itself uses hmac(sha256) which is one of | |
| * the algorithms that are replaced with versions from this module, and | |
| * the integrity check must use the replacement version. Also, to be | |
| * ready for FIPS 140-3, the integrity check algorithm must have already | |
| * been self-tested. | |
| */ | |
| if (!check_fips140_module_hmac()) { | |
| if (!IS_ENABLED(CONFIG_CRYPTO_FIPS140_MOD_DEBUG_INTEGRITY_CHECK)) { | |
| pr_crit("integrity check failed -- giving up!\n"); | |
| goto panic; | |
| } | |
| pr_crit("ignoring integrity check failure due to debug mode\n"); | |
| } else { | |
| pr_info("integrity check passed\n"); | |
| } | |
| complete_all(&fips140_tests_done); | |
| if (!update_fips140_library_routines()) | |
| goto panic; | |
| if (!fips140_eval_testing_init()) | |
| goto panic; | |
| pr_info("module successfully loaded\n"); | |
| return 0; | |
| panic: | |
| panic("FIPS 140 module load failure"); | |
| } | |
| module_init(fips140_init); | |
| MODULE_IMPORT_NS("CRYPTO_INTERNAL"); | |
| MODULE_LICENSE("GPL v2"); | |
| /* | |
| * Below are copies of some selected "crypto-related" helper functions that are | |
| * used by fips140.ko but are not already built into it, due to them being | |
| * defined in a file that cannot easily be built into fips140.ko (e.g., | |
| * crypto/algapi.c) instead of one that can (e.g., most files in lib/). | |
| * | |
| * There is no hard rule about what needs to be included here, as this is for | |
| * FIPS certifiability, not any technical reason. FIPS modules are supposed to | |
| * implement the "crypto" themselves, but to do so they are allowed to call | |
| * non-cryptographic helper functions from outside the module. Something like | |
| * memcpy() is "clearly" non-cryptographic. However, there is is ambiguity | |
| * about functions like crypto_inc() which aren't cryptographic by themselves, | |
| * but are more closely associated with cryptography than e.g. memcpy(). To err | |
| * on the side of caution, we define copies of some selected functions below so | |
| * that calls to them from within fips140.ko will remain in fips140.ko. | |
| */ | |
| static inline void crypto_inc_byte(u8 *a, unsigned int size) | |
| { | |
| u8 *b = (a + size); | |
| u8 c; | |
| for (; size; size--) { | |
| c = *--b + 1; | |
| *b = c; | |
| if (c) | |
| break; | |
| } | |
| } | |
| void crypto_inc(u8 *a, unsigned int size) | |
| { | |
| __be32 *b = (__be32 *)(a + size); | |
| u32 c; | |
| if (IS_ENABLED(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) || | |
| IS_ALIGNED((unsigned long)b, __alignof__(*b))) | |
| for (; size >= 4; size -= 4) { | |
| c = be32_to_cpu(*--b) + 1; | |
| *b = cpu_to_be32(c); | |
| if (likely(c)) | |
| return; | |
| } | |
| crypto_inc_byte(a, size); | |
| } |