crypto: Standalone crypto module (Series 2/4): Arch-independent crypto
Subsystems (13)
cover crypto: Standalone crypto module (Series 2/4): Arch-independent crypto
This patch series is a follow up of Series 1/4:
https://lore.kernel.org/all/[email protected]/
This feature is organized into four patch series for submission to the mainline (up to the "Merge tag 'landlock-7.0-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/mic/linux"):
- Patch Series 1/4: "[PATCH v1 0...17] crypto: Standalone crypto module (Series 1/4): Core implementation"
- Patch Series 2/4: "[PATCH v1 0...106] crypto: Standalone crypto module (Series 2/4): Arch-independent crypto"
- Patch Series 3/4: "[PATCH v1 0...21] crypto: Standalone crypto module (Series 3/4): x86_64 crypto"
- Patch Series 4/4: "[PATCH v1 0...12] crypto: Standalone crypto module (Series 4/4): arm64 crypto"
The full source code is available at https://github.com/amazonlinux/linux/tree/fips-kernel-module.
Details on this feature and what each patch series covers can be found below.
## 1. Introduction
Amazon Linux is releasing a new kernel feature that converts the previously built-in kernel crypto subsystem into a standalone kernel module. This module becomes the carrier of the kernel crypto subsystem and can be loaded at early boot to provide the same functionality as the original built-in crypto. The primary motivation for this modularization is to streamline Federal Information Processing Standards (FIPS) validation, a critical cryptographic certification for cloud computing users doing business with the U.S. government.
In a bit more detail, previously, FIPS certification was tied to the entire kernel image, meaning non-crypto updates could potentially invalidate certification. With this feature, FIPS certification is tied only to the crypto module. Therefore, once the module is certified, loading this certified module on newer kernels automatically makes those kernels FIPS-certified. As a result, this approach can save re-certification costs and 12-18 months of waiting time by reducing the need for repeated FIPS re-certification cycles.
This feature is organized into four patch series:
- Patch Series 1 - Core feature implementation
- Patch Series 2 - Architecture-independent crypto: Modularize built-in crypto under crypto/
- Patch Series 3 - x86_64 crypto: Modularize built-in crypto under arch/x86/crypto/
- Patch Series 4 - arm64 crypto: Modularize built-in crypto under arch/arm64/crypto/
This document provides technical details on how this feature is designed and implemented for users or developers who are interested in developing upon it, and is organized as follows:
- Section 2 - Getting Started: Quick start on how to enable the feature
- Section 3 - Workflow Overview: Changes this feature brings to build and runtime
- Section 4 - Design Implementation Details: Technical deep-dive into each component
- Section 5 - Customizing and Extending Crypto Module: How to select crypto to be included and extend to new crypto/architectures
- Section 6 - Related Work and Comparison
- Section 7 - Summary
## 2. Getting Started
This section provides a quick start guide for developers on how to enable, compile and use the standalone cryptography module feature.
### 2.1 Basic Configuration
The feature is controlled by a single configuration option:
``` CONFIG_CRYPTO_FIPS140_EXTMOD=y ```
What it does: When enabled, automatically redirects a set of cryptographic algorithms from the main kernel into a standalone module crypto/fips140/fips140.ko. The cryptographic algorithms that are redirected need to satisfy all the following conditions, otherwise the cryptography will remain in its original form:
1. Must be configured as built-in (i.e., CONFIG_CRYPTO_*=y). This means cryptography already configured as modular (i.e., CONFIG_CRYPTO_*=m) are not redirected as they are already modularized.
2. Must be among a list, which can be customized by developers as described in Section 5.
When disabled, the kernel behaves as before.
### 2.2 Build Process
Once CONFIG_CRYPTO_FIPS140_EXTMOD=y is set, no additional steps are required. The standalone module will be built automatically as part of the standard kernel build process:
``` make -j$(nproc) # or make vmlinux ```
**What happens automatically (No user action required):**
1. Build the module as crypto/fips140/fips140.ko
2. The cryptography module will be loaded at boot time
3. All kernel cryptographic services will provide the same functionality as before (i.e., prior to introducing this new feature) once boot completes.
### 2.3 Advanced Configuration Options
**Using External Cryptography Module:**
``` CONFIG_CRYPTO_FIPS140_EXTMOD_SOURCE=y ```
By default, CONFIG_CRYPTO_FIPS140_EXTMOD_SOURCE is not set, meaning the freshly built cryptography module is used. Otherwise, the pre-built standalone cryptography module from fips140_build/crypto/fips140/fips140.ko and modular cryptography such as fips140_build/crypto/aes.ko (need to manually place pre-built modules in these locations before the build) are included in kernel packaging (e.g., during make modules_install) and are used at later boot time.
**Dual Version Support:**
``` CONFIG_CRYPTO_FIPS140_DUAL_VERSION=y ```
Encapsulate two versions of fips140.ko into kernel: one is freshly built for non-FIPS mode usage, another is pre-built specified by fips140_build/crypto/fips140/fips140.ko for FIPS mode usage. The appropriate version is selected and loaded at boot time based on boot time FIPS mode status.
### 2.4 Verification
To verify the feature is working, after install and boot with the new kernel:
``` # Check if fips140.ko module is loaded lsmod | grep fips140 ```
## 3. Workflow Overview
This section provides an overview without delving into deep technical details of the changes the standalone cryptography module feature introduces. When this feature is enabled, it introduces changes to both the kernel build and booting process.
3.1 Build-Time Changes
Kernel cryptography subsystem consists of both cryptography management infrastructure (e.g., crypto/api.c, crypto/algapi.c, etc), along with hundreds of different cryptography algorithms (e.g., crypto/arc4.c).
**Traditional Build Process:**
Traditionally, cryptography management infrastructure are always built-in to the kernel, while cryptographic algorithms can be configured to be built either as built-in (CONFIG_CRYPTO_*=y) or as separate modular (CONFIG_CRYPTO_*=m) .ko file depending on kernel configuration:
As a result, the builtin cryptography management infrastructure and cryptographic algorithms are statically linked into the kernel binary:
``` cryptographic algorithms source files → compiled as .o objfiles → linked into vmlinux → single kernel binary ``` **With Standalone Cryptography Module:** This feature automatically transforms the builtin cryptographic components into a standalone cryptography module, `fips140.ko`. To do so, it develops a new kernel build rule `crypto-objs-$(CONFIG_CRYPTO_*)` such that, once this build rule is applied to a cryptographic algorithm, such cryptographic algorithm will be automatically collected into the cryptography module if it is configured as built-in (i.e, `CONFIG_CRYPTO_*=y`), for example: ``` // in crypto/asymmetric_keys/Makefile - obj-$(CONFIG_ASYMMETRIC_KEY_TYPE) += asymmetric_keys.o + crypto-objs-$(CONFIG_ASYMMETRIC_KEY_TYPE) += asymmetric_keys.o ```
Such build change allows the modularization transformation to only affect selected cryptographic algorithms (i.e, where the crypto-objs-$(CONFIG_CRYPTO_*) is applied).
Then, after the fips140.ko is generated, it will be embedded back into main kernel vmlinux as a replacement part. The purpose of this embedding, instead of traditionally putting the fips140.ko into filesystem, is a preparation to allow the module to be loaded early enough even before the filesystem is ready.
The new build process is illustrated below.
``` cryptographic algorithms source files → compiled as .o objfiles → automatically collected and linked into fips140.ko → embedded fips140.ko into vmlinux as a replaceable binary ```
### 3.2 Runtime Changes
**Traditional Boot Process:**
The kernel initializes the cryptographic subsystem early during boot, executing each cryptographic initialization routine accordingly. These initialization routines may depend on other cryptographic components or other kernel subsystems, so their invocation follows a well-defined execution order to ensure they are initialized before their first use.
``` kernel starts → cryptography subsystem initialization → cryptography subsystem available → other components use cryptography ```
**With Standalone Cryptography Module:**
At the start of kernel boot, compared to a regular kernel, the first major change introduced by this feature is that no cryptography services are initially available — since the entire cryptography subsystem has been decoupled from the main kernel. To ensure that the cryptography subsystem becomes available early enough (before the first kernel component that requires cryptography services), the standalone cryptography kernel module must be loaded at a very early stage, even before the filesystem becomes available.
However, the regular module loading mechanism relies on placing kernel modules in the filesystem and loading them from there, which creates a chicken-and-egg problem — the cryptography module cannot be loaded until the filesystem is ready, yet some kernel components may require cryptography services even before that point.
To address this, the second change introduced by this feature is that the cryptography kernel module is loaded directly from memory, leveraging the earlier compilation changes that embed the module binary into the main kernel image. Afterward, the feature includes a “plug-in” mechanism that connects the decoupled cryptography subsystem back to the main kernel, ensuring that kernel cryptography users can correctly locate and invoke the cryptography routine entry points.
Finally, to ensure proper initialization, the feature guarantees that all cryptography algorithms and the cryptography management infra execute their initialization routines in the exact same order as they would if they were built-in.
The process described above is illustrated below.
``` kernel starts → no cryptography available → load fips140.ko from memory → plug cryptography back to kernel → module initialization → cryptographic services available → other components use cryptography ```
## 4. Design Implementation Details
While the earlier sections provide a holistic view of how this feature shapes the kernel, this section provides deeper design details on how these functionalities are realized. There are three key design components:
1. A specialized compile rule that automatically compiles and collects all built-in cryptographic algorithm object files to generate the final module binary under arbitrary kernel configurations, and then embeds the generated binary into the main kernel image for early loading.
2. A mechanism to convert interactions between the cryptography subsystem and the main kernel into a pluggable interface.
3. A module loading and initialization process that ensures the cryptography subsystem is properly initialized as if it were built-in.
### 4.1. Specialized Compilation System
**Automatic Collection and Linking of Built-in Cryptographic Algorithm Objects:**
The first step in generating the fips140.ko module is to compile and collect built-in cryptographic components (i.e., those specified by CONFIG_CRYPTO_*=y).
Traditionally, the existing module build process requires all module components (e.g., source files) to reside in a single directory. However, this approach is not suitable for our case, where hundreds of cryptographic algorithm source files are scattered across multiple directories.
A naïve approach would be to create a separate Makefile that duplicates the original build rules with adjusted paths.
However, this method is not scalable due to the large number of cryptographic build rules, many of which are highly customized and can vary under different Kconfig settings, making such a separate Makefile even more complex. Moreover, this approach cannot ensure that built-in cryptographic algorithms are completely removed from the main kernel, which would result in redundant cryptographic code being included in both the kernel and the module.
To tackle this challenge, we automated the object collection and linking process by introducing special build logic for the kernel cryptography subsystem. Specifically, to automatically collect cryptography object files while preserving their original compilation settings (such as flags, headers, and paths), we introduced a new compilation rule:
``` crypto-objs-y += *.o ``` This replaces the original `obj-y += *.o` rule in cryptography Makefiles later, for example: ``` // in crypto/asymmetric_keys/Makefile - obj-$(CONFIG_ASYMMETRIC_KEY_TYPE) += asymmetric_keys.o + crypto-objs-$(CONFIG_ASYMMETRIC_KEY_TYPE) += asymmetric_keys.o asymmetric_keys-y := \ asymmetric_type.o \ restrict.o \ signature.o ```
in the cryptography subsystem Makefiles, allowing most of the existing Makefile logic to be reused.
As a result, when the standalone cryptography module feature is enabled, any cryptographic algorithm configured as built-in (for example, crypto-objs-$(CONFIG_ASYMMETRIC_KEY_TYPE) += asymmetric_keys.o where CONFIG_ASYMMETRIC_KEY_TYPE=y) will be automatically collected and linked into a single final object binary, fips140.o. During this process, a special compilation flag (-DFIPS_MODULE=1) is applied to instruct each object file to be compiled in a module-specific manner. This flag will later be used to generate the pluggable interface on both the main kernel side and the module side from the same source code.
The implementation details are as follows: it follows a similar methodology used by the obj-y collection process for building vmlinux.o. The crypto-objs-y rule is placed in scripts/Makefile.build, which is executed by each directory Makefile to collect the corresponding crypto object files. Each directory then creates a crypto-module.a archive that contains all crypto-objs-y += <object>.o files under that directory. In the parent directories, these crypto-module.a archives are recursively included into the parent’s own crypto-module.a, and this process continues upward until the final fips140.o is generated.
**A Separate Module Generation Pipeline for Building the Final Kernel Module from Linked Cryptographic Algorithm Object:** With the linked cryptographic algorithm object (i.e., fips140.o), the next step is to generate the final kernel module, fips140.ko.
A direct approach would be to inject the fips140.ko module build into the existing modules generation pipeline (i.e., make modules) by providing our pre-generated fips140.o. However, we choose not to do this because it would create a circular make rule dependency (which is invalid in Makefiles and causes build failures), resulting in mutual dependencies between the modules and vmlinux targets (i.e., modules:vmlinux and vmlinux:modules at the same time). This happens for the following reasons:
1. Since we will later embed fips140.ko into the final kernel image (as described in the next section), we must make vmlinux depend on fips140.ko. In other words: vmlinux: fips140.ko.
2. When the kernel is built with CONFIG_DEBUG_INFO_BTF_MODULES=y, it requires: modules: vmlinux. This is because CONFIG_DEBUG_INFO_BTF_MODULES=y takes vmlinux as input to generate BTF info for the module, and inserts such info into the .ko module by default.
3. If we choose to inject fips140.ko into make modules, this would create a make rule dependency: fips140.ko: modules. Combined with items 1 and 2, this eventually creates an invalid circular dependency between vmlinux and modules.
Due to these reasons, the design choice is to use a separate make pipeline (defined as fips140-ready in the Makefile). This new pipeline reuses the same module generation scripts used by make modules but adds additional logic in scripts/Makefile.{modfinal|modinst|modpost} and scripts/mod/modpost.c to handle module symbol generation and verification correctly.
**A Seamless Process That Embeds the Generated Binary Into the Main Kernel Image for Early Loading:**
As mentioned earlier, in order to load the standalone cryptography module early in the boot process—before the filesystem is ready—the module binary must be embedded into the final kernel image (i.e., vmlinux) so that it can be loaded directly from memory. We intend for this embedding process to be completely seamless and automatically triggered whenever vmlinux is built (i.e., during make vmlinux).
To achieve this, the feature adds a Make dependency rule so that vmlinux depends on fips140.ko.
It also modifies the vmlinux link rules (i.e., arch/<arch>/kernel/vmlinux.lds.S, scripts/Makefile.vmlinux, and scripts/link-vmlinux.sh) so that the generated module binary is finally combined with vmlinux.o.
In addition, we allow multiple cryptography module binary versions (for example, a certified cryptography binary and a latest, up-to-date but uncertified one) to be embedded into the main kernel image to serve different user needs. This design allows regular (non-FIPS) users to benefit from the latest cryptographic updates, while FIPS-mode users continue to use the certified cryptography module.
To support this, we introduce an optional configuration, CONFIG_CRYPTO_FIPS140_DUAL_VERSION. When enabled, this option allows two cryptography module versions to be embedded within a single kernel build and ensures that the appropriate module is selected and loaded at boot time based on the system’s FIPS mode status.
### 4.2. Pluggable Interface Between the Built-in Cryptography Subsystem and the Main Kernel
Although the module binary (fips140.ko) has been embedded into the final kernel image (vmlinux) as described in the previous section, it is not linked to the kernel in any way. This is because fips140.ko is embedded in a data-only manner, so the main kernel cannot directly call any functions or access any data defined in the module binary.
Even worse, simply removing the built-in cryptographic algorithms without additional handling would cause the kernel to fail to compile, because traditionally, built-in cryptographic algorithms and the main kernel can interact only through functions and variables whose addresses they assume to know. As a result, even if they have been removed, kernel cryptography users still expect the symbol addresses of cryptographic routines and data to be available at compile time.
To address this, we introduce a pluggable interface between built-in cryptographic functions and variables by placing **address placeholders**. During runtime, once the cryptography kernel module is loaded, these placeholders are updated to the correct addresses. In the rest of this section, we first introduce this pluggable interface mechanism, and then explain how to apply it to the built-in cryptographic algorithms.
**The Pluggable Interface Mechanism:**
There are two types of address holders used to achieve this pluggable interface:
- Function addresses: We use the “static call” mechanism. Static calls are a Linux mechanism that converts an “indirect call” into something with performance equivalent to a “direct call,” while avoiding the introduction of additional security concerns, such as control-flow–hijacking attack gadgets. We implement this function-address placeholder as the DECLARE_STATIC_CALL() and DEFINE_CRYPTO_API_STUB() wrappers.
- Variable addresses (the remaining smaller portion): For these, we use a pointer of the corresponding data type. We implement this address placeholder as the DECLARE_CRYPTO_VAR() and DEFINE_CRYPTO_API_STUB() wrappers:
These wrappers are applied to each symbol-exported (i.e., EXPORT_SYMBOL()) cryptographic function and variable (details on how to apply them are described later). Once applied, the wrappers are compiled differently for the main kernel and for the built-in cryptographic algorithm source code—acting as the “outlet” and the “plug,” respectively—using different compilation flags (-DFIPS_MODULE) introduced by our customized build rules described earlier.
As a result, the kernel can successfully compile even when the built-in cryptographic algorithms are removed, thanks to these address placeholders. At boot time, the placeholders initially hold NULL, but since no cryptography users exist at that stage, the kernel can still start booting correctly. After the cryptography module is loaded, the placeholders are dynamically updated to the correct addresses later (by do_crypto_api() and do_crypto_var(), described in later section).
In addition to these address placeholders, there is another important interaction point between the cryptography subsystem and the main kernel—the cryptographic initialization routines. Therefore, we also add a mechanism to collect all cryptographic initialization functions (e.g., those defined using module_init()) into a dedicated ELF section. This serves as preparation for the later module and cryptography-subsystem initialization steps described in subsequent sections.
**Applying the Pluggable Interface Mechanism to Cryptographic Algorithms:**
To apply these pluggable interface wrappers to a cryptographic algorithm and make them take effect, we follow the steps below (using crypto/asymmetric_keys/asymmetric_type.c as an example):
1. **Apply crypto-objs-y compile rule to the cryptographic algorithm:**
``` // in crypto/asymmetric_keys/Makefile - obj-$(CONFIG_ASYMMETRIC_KEY_TYPE) += asymmetric_keys.o + crypto-objs-$(CONFIG_ASYMMETRIC_KEY_TYPE) += asymmetric_keys.o asymmetric_keys-y := \ asymmetric_type.o \ restrict.o \ signature.o ```
2. **Locate the communication point between the cryptographic algorithm and the main kernel:**
The cryptography subsystem is designed such that most interactions between the main kernel and cryptographic algorithms occur through exported symbols using EXPORT_SYMBOL() wrappers. This kernel design exists because most cryptographic algorithm implementations must support both built-in and modular modes.
Consequently, the cryptographic functions and variables exported by EXPORT_SYMBOL() are a well-defined and identifiable interface between the cryptography subsystem and the main kernel:
```
// in crypto/asymmetric_keys/asymmetric_type.c
//Exported cryptographic function:
bool asymmetric_key_id_same(const struct asymmetric_key_id *kid1,
const struct asymmetric_key_id *kid2) {...}
EXPORT_SYMBOL_GPL(asymmetric_key_id_same);
//Exported cryptographic variable:
struct key_type key_type_asymmetric = {...};
EXPORT_SYMBOL_GPL(key_type_asymmetric);
```
3. **Replace their declarations in the header file with the address-placeholder declaration wrappers:**
```
// in include/keys/asymmetric-type.h
// for exported cryptographic function:
- bool asymmetric_key_id_same const struct asymmetric_key_id *kid1, const struct asymmetric_key_id *kid2);
+ DECLARE_CRYPTO_API(CONFIG_ASYMMETRIC_KEY_TYPE, asymmetric_key_id_same, bool,
(const struct asymmetric_key_id *kid1, const struct asymmetric_key_id *kid2),
(kid1, kid2));
// for exported cryptographic variables:
- struct key_type key_type_asymmetric;
+ DECLARE_CRYPTO_VAR(CONFIG_ASYMMETRIC_KEY_TYPE, key_type_asymmetric, struct key_type, );
+ #if defined(CONFIG_CRYPTO_FIPS140_EXTMOD) && !defined(FIPS_MODULE) && IS_BUILTIN(CONFIG_ASYMMETRIC_KEY_TYPE)
+ #define key_type_asymmetric (*((struct key_type*)CRYPTO_VAR_NAME(key_type_asymmetric)))
+ #endif
```By replacing the original declarations with the address-placeholder declaration wrappers, we can automatically force all cryptography users to go through the placeholders, because those users already include the same header file. The wrapper also takes the cryptographic algorithm Kconfig symbol as a parameter, so that when a cryptographic algorithm is built as a module (for example, CONFIG_ASYMMETRIC_KEY_TYPE=m), the original function declarations remain unchanged and are not affected.
4. **Add the address-placeholder definition wrappers into a dedicated file fips140-api.c:**
This file will be compiled separately and acts as both the “outlet” and the “plug” for the main kernel and the cryptography module, respectively:
``` // in crypto/fips140/fips140-api.c + #if IS_BUILTIN(CONFIG_ASYMMETRIC_KEY_TYPE) + #include <keys/asymmetric-type.h> // for exported cryptographic function: + DEFINE_CRYPTO_API_STUB(asymmetric_key_id_same); // for exported cryptographic variables: + #undef key_type_asymmetric + DEFINE_CRYPTO_VAR_STUB(key_type_asymmetric); + #endif ```
5. **Lastly, collect the cryptographic initialization routines for later module and cryptography-subsystem initialization by wrapping the original cryptographic initialization functions:**
``` // in crypto/asymmetric_keys/asymmetric_type.c - module_init(asymmetric_key_init); - module_exit(asymmetric_key_cleanup); + crypto_module_init(asymmetric_key_init); + crypto_module_exit(asymmetric_key_cleanup); ```
We apply the above steps to both architecture-independent and architecture-specific cryptographic algorithms.
### 4.3. Initialization Synchronization
To ensure the embedded fips140.ko module binary provides the same cryptography functionality as the regular kernel, the kernel needs:
1. A module loader to load the module binary directly from memory,
2. A mechanism to plug the module back into the kernel by updating the address placeholders, and
3. Correct cryptography subsystem initialization, as if the cryptographic algorithms were still built-in.
**Directly Load Module Binary from Memory:**
Regular modules are loaded from the filesystem and undergo signature verification on the module binary, which relies on cryptographic operations. However, since we have already fully decoupled the cryptography subsystem, we must skip this step for this fips140.ko module. To achieve this, we add a new loader function load_crypto_module_mem() that can load the module binary directly from memory at the designed address without checking the signature. Since the module binary is embedded into main kernel in an ELF section, as specified in the linker script:
```
// in arch/<arch>/kernel/vmlinux.lds.S
.fips140_embedded : AT(ADDR(.fips140_embedded) - LOAD_OFFSET) {
. = ALIGN(8);
_binary_fips140_ko_start = .;
KEEP(*(.fips140_module_data))
_binary_fips140_ko_end = .;
}
```Therefore, the runtime memory address of the module can be accessed directly by the module loader to invoke the new loader function load_crypto_module_mem().
**Plug Back the Module by Updating Address Placeholder Values:**
To update the address placeholders in the main kernel to the correct addresses matching the loaded module, after compilation the placeholders are placed into dedicated ELF sections _crypto_api_keys and _crypto_var_keys. This can be seen from the definition of the placeholder-declaration wrappers:
```
#define DEFINE_CRYPTO_API_STUB(name) \ static struct crypto_api_key __##name##_key \ __used \ __section("__crypto_api_keys") // Place in a dedicated ELF Section
__aligned(__alignof__(struct crypto_api_key)) = \ { \ .key = &STATIC_CALL_KEY(crypto_##name##_key), \ .tramp = STATIC_CALL_TRAMP_ADDR(crypto_##name##_key), \ .func = &name, \ };
#define DEFINE_CRYPTO_VAR_STUB(name) \ static struct crypto_var_key __crypto_##name##_var_key \ __used \ __section("__crypto_var_keys") // Place in a dedicated ELF Section
__aligned(__alignof__(struct crypto_var_key)) = \ { \ .ptr = &CRYPTO_VAR_NAME(name), \ .var = (void*)&name, \ };
```The purpose of doing this is to allow the main kernel to quickly locate the placeholders and update them to the correct addresses. The update functions are defined as do_crypto_var() and do_crypto_api(), which are executed at module load.
As a result, all cryptography users in the main kernel can now call the cryptographic functions as if they were built-in.
**Initialize Cryptography Subsystem as if it Were Built-in:**
Cryptographic components must be properly initialized before use, and this initialization is typically achieved through dedicated initialization functions (e.g., module_init(crypto_init_func) or late_initcall(crypto_init_func)). These functions often have strict execution order requirements and must run during the appropriate boot phase.
Therefore, for our standalone cryptography module feature, we must ensure that these decoupled “built-in” cryptographic algorithms are properly initialized and that their initialization order is preserved as before because failure to follow the correct order can result in kernel panic.
To address this, we introduce a synchronization mechanism between the main kernel and the module to ensure all cryptographic algorithms are executed in the correct kernel boot phase. In more details, we spawn the module initialization process fips_loader_init() as an async thread fips140_sync_thread(), in which we call run_initcalls() to execute the initialization calls of each cryptographic algorithm. Then, we introduce synchronization helpers such as wait_until_fips140_level_sync(int level) to ensure the initialization order of all cryptographic algorithms is synchronized with the main kernel.
## 5. Customization and Extension of Cryptography Module
This section describes how developers can customize which cryptographic algorithms are included in the standalone cryptography module, as well as extend this feature to other cryptographic algorithms or hardware architectures.
### 5.1. Cryptography Selection Mechanism
The feature automatically includes cryptographic algorithms that meet specific criteria:
1. **Built-in Configuration**: Only cryptographic algorithms configured as CONFIG_CRYPTO_*=y are candidates for inclusion
2. **Explicit Inclusion**: Cryptographic algorithms must be explicitly converted using the crypto-objs-$(CONFIG__CRYPTO_*) build rule
### 5.2. Extend Support to New Cryptographic Algorithms
To extend support to a new cryptographic algorithm in the standalone module, follow these steps:
**Step 1: Update the Makefile**
``` # in crypto/[algorithm]/Makefile - obj-$(CONFIG_CRYPTO_ALGORITHM) += algorithm.o + crypto-objs-$(CONFIG_CRYPTO_ALGORITHM) += algorithm.o ```
For Architecture-Specific Cryptographic Algorithms:
- Apply the crypto-objs- rule in the appropriate arch/*/crypto/Makefile
**Step 2: Add Pluggable Interface Support**
If the cryptographic algorithm exports symbols via EXPORT_SYMBOL(), add the pluggable interface wrappers:
```
# Example: in include/crypto/algorithm.h
- extern int crypto_algorithm_transform(struct crypto_tfm *tfm, const u8 *src,
u8 *dst, unsigned int len, u32 flags);
+ DECLARE_CRYPTO_API(CONFIG_CRYPTO_ALGORITHM, crypto_algorithm_transform, int,
(struct crypto_tfm *tfm, const u8 *src, u8 *dst, unsigned int len, u32 flags),
(tfm, src, dst, len, flags));
```
Then, add the corresponding stubs in `crypto/fips140/fips140-api.c`:
```
#if IS_BUILTIN(CONFIG_CRYPTO_ALGORITHM)
#include <crypto/algorithm.h>
DEFINE_CRYPTO_API_STUB(crypto_algorithm_transform);
#endif
```
For Architecture-Specific Cryptographic Algorithms:
- Include architecture-specific stubs in `arch/*/crypto/fips140/fips140-api.c`:
```
# Example: in arch/arm64/crypto/fips140/fips140-api.c
#if IS_BUILTIN(CONFIG_CRYPTO_AES_ARM64_CE)
#include <arch/arm64/crypto/aes-ce-setkey.h>
DEFINE_CRYPTO_API_STUB(ce_aes_setkey);
DEFINE_CRYPTO_API_STUB(ce_aes_expandkey);
#endif
```
**Step 3: Update Initialization**
Replace module initialization calls:
```
# in crypto/algorithm/algorithm.c
- module_init(algorithm_init);
- module_exit(algorithm_exit);
+ crypto_module_init(algorithm_init);
+ crypto_module_exit(algorithm_exit);
```### 5.3. Architecture-Specific Extensions
**Extending to New Architectures:**
Currently supported architectures are x86_64 and ARM64. To extend this feature to additional architectures:
1. **Update Linker Scripts**: Add ELF sections in arch/[new-arch]/kernel/vmlinux.lds.S:
```
.fips140_embedded : AT(ADDR(.fips140_embedded) - LOAD_OFFSET) {
. = ALIGN(8);
_binary_fips140_ko_start = .;
KEEP(*(.fips140_module_data))
_binary_fips140_ko_end = .;
}
```2. **Create Architecture-Specific Files**: Set up arch/[new-arch]/crypto/fips140/ directory with Makefile and fips140-api.c following the pattern used in x86_64 and ARM64.
## 6. Related Work and Comparison
The idea of modularizing kernel cryptographic functionality has also attracted attention from other Linux distributions as well as Linux-kernel-based platforms that are not traditional distributions. Specifically, there are two related efforts: one from [Android's GKI kernel](https://source.android.com/docs/core/architecture/kernel/gki-fips140-module) and another from [Oracle Linux](https://git.kernel.org/pub/scm/linux/kernel/git/vegard/linux-fips140.git/log/?h=fips140). While Amazon Linux incorporated several valuable ideas from these efforts (and have acknowledged them in the patch commits—thank you again!), this section highlights the key differences between those approaches and this approach. The goal is to describe the trade-offs and design choices objectively, rather than to criticize other implementations.
### 6.1. Comparison with Android's GKI
Android's work is the earliest one on modularizing kernel cryptographic code, and it targets a non-intrusive approach to the core GKI kernel, with the goal of minimizing modifications to the kernel source. To achieve this, the crypto module relies on several interception or "hijacking" techniques that intervene in the core kernel execution path.
While this approach minimizes kernel code changes, we don't adopt such an approach for several reasons. First, these interception mechanisms tightly depend on internal kernel crypto subsystem behavior, making them fragile across major kernel updates thus less suitable to reuse the same module on newer major kernel versions. Second, this design requires substantial additional cryptographic code duplication, which impacts maintainability. Finally, the solution only supports a fixed set of cryptographic algorithms, making it non-general and difficult to extend.
In contrast, our design integrates directly into the Linux kernel source tree, avoids duplicated cryptographic implementations, supports arbitrary kernel configuration settings, and works with any chosen set of cryptographic algorithms.
### 6.2. Comparison with Oracle Linux
Oracle’s work was developed concurrently with this approach. The primary differences between Oracle’s approach and Amazon's lie in build integration, pluggable interface design, and module initialization.
**Build Integration:**
Oracle's module is implemented as an out-of-tree module with a separate Makefile. This introduces three major reasons we don't adopt such an approach:
*First*, the separate Makefile duplicates many kernel build rules, which increases maintenance cost, as upstream kernel build changes must be tracked and replicated. One concrete example can be seen below:
in Oracle's module makefile
``` fips140-y += crypto/skcipher.o fips140-y += crypto/lskcipher.o ``` However, in upstream, the corresponding build logic is more complex and configuration-dependent: ``` crypto_skcipher-y += lskcipher.o crypto_skcipher-y += skcipher.o obj-$(CONFIG_CRYPTO_SKCIPHER2) += crypto_skcipher.o ifeq ($(CONFIG_BPF_SYSCALL),y) obj-$(CONFIG_CRYPTO_SKCIPHER2) += bpf_crypto_skcipher.o endif ``` As shown above, when `CONFIG_BPF_SYSCALL` is enabled, `bpf_crypto_skcipher.o` must also be included. Tracking such dependencies is hard in the duplicated Makefile approach. In contrast, our approach integrates seamlessly into the kernel build system by introducing a customized build rule (`crypto-objs-*`) rather than relying on a duplicated Makefile, such that this is handled correctly by reusing the existing kernel build logic: ``` crypto_skcipher-y += lskcipher.o crypto_skcipher-y += skcipher.o - obj-$(CONFIG_CRYPTO_SKCIPHER2) += crypto_skcipher.o + crypto-objs-$(CONFIG_CRYPTO_SKCIPHER2) += crypto_skcipher.o ifeq ($(CONFIG_BPF_SYSCALL),y) - obj-$(CONFIG_CRYPTO_SKCIPHER2) += bpf_crypto_skcipher.o + crypto-objs-$(CONFIG_CRYPTO_SKCIPHER2) += bpf_crypto_skcipher.o endif ```
As a result, such a Makefile-duplication approach does not scale well across all kernel configurations and does not easily support arbitrary sets of cryptographic algorithms.
*Second*, since the module is to be embedded as part of the kernel image (i.e., vmlinux) as described earlier, the module build must be triggered automatically as part of the vmlinux build process to achieve a seamless build workflow. However, Oracle's module build is not tightly integrated into the kernel build framework and requires special build commands (e.g., first do make M=fips140/ specifically, then do some shell command and finally make).
In contrast, our approach improves this aspect by integrating the module build tightly into the regular kernel build, so the build process is seamless and automatic with regular build and packaging processes such as make or make vmlinux or make install.
**Pluggable Interface:**
There are several differences in the pluggable interface design.
*First*, we avoid duplicate crypto code so only keep one crypto code in kernel memory, while existing work keeps two crypto code even if these crypto code are from the same source code. This is due to the way Oracle defines pluggable interface macros in crypto/api, where its design requires some cryptographic code to remain compiled into the main kernel image in addition to the code inside the standalone cryptography module. Keeping two crypto code is ok if these code are different and designed to be used for different runtime modes (i.e., FIPS/non-FIPS mode), but will be unnecessary if both crypto code are the same.
In contrast, the approach we use can flexibly support both choices: keep one cryptography subsystem, or two different crypto subsystems. To do so, we introduce an option CRYPTO_FIPS140_DUAL_VERSION such that when it is disabled, we only keep one cryptographic subsystem in the cryptography module while completely removing it from the main kernel; and when it is enabled, we allow having two different modules carrying different cryptography for different kernel runtime modes (i.e., FIPS and non-FIPS mode).
*Second*, existing approach requires modifications to both the cryptographic implementation (.c) files and the declaration (.h) header files while our approach only requires modifying the header file, making the change less intrusive to the kernel codebase.
*Third*, prior approaches mainly support making cryptographic function calls pluggable, while our approach extends pluggability to cryptographic variables as well.
*Fourth*, prior approach requires all cryptographics that we care (for any purpose such as those within FIPS boundary) to be included within a single kernel module fips140.ko (e.g., when CONFIG_CRYPTO_AES=m, it cannot be aes.ko but must be within fips140.ko). However, this requirement limits the inherent benefit of a kernel module (i.e., on-demand loading for memory efficiency). In contrast, our approach allows the cryptographic we care remain its original modular if it is configured as being so (i.e., if CONFIG_CRYPTO_AES=m, the aes will still be as aes.ko but not forced to fips140.ko) up to the .config setting. One benefit of this design is that it does not impose strict requirements on .config setting (i.e., a cryptography .config can be set to both =y|m while existing work must be set as =y), preserving configuration flexibility.
To support so, for any cryptography within the interest (i.e., whose makerule has been replaced with crypto-objs-*) but configured as build-as-module (i.e., CONFIG_CRYPTO_*=m), its compiled .ko binary will be marked automatically, such that the loader will have a way to recognize to perform some interest-specific processing (e.g., registered as FIPS-required flag) if needed. And the pluggable interface can also adjust its coverage automatically based on different CONFIG_CRYPTO_*=y|=m settings. This is achieved by letting the pluggable interface macro to take CONFIG_CRYPTO_* option as a parameter to recognize the .config setting.
**Module Initialization:**
Oracle's initialization routine does not guarantee preservation of the original crypto initialization order (i.e., the order they should follow if they were originally built-in in the main kernel), which limits its ability to support arbitrary combinations of cryptographic algorithms. This is because the crypto initialization routine in the module is executed too early, such that all module crypto is initialized before the cryptography init in the main kernel. So if there is a crypto in the module (e.g., a crypto init defined as late_init()) that depends on a cryptography (whose init is defined as module_init()) in the main kernel, since the one in the main kernel should be executed earlier (but because the module init is too early, it makes the crypto in the main kernel executed too late), such a case will break the kernel boot process.
Our design, on the other hand, introduces explicit initialization synchronization mechanisms between cryptography's init routine in the module and in the main kernel that can preserve the original built-in initialization order. As a result, our module supports any chosen crypto set to be included in the module.
### 6.3. Comparison Summary
Overall, combined with differences in coding style and integration strategy, the proposed approach is more seamlessly integrated with the upstream Linux kernel, making it more generalizable across different kernel configuration settings, and the changed behavior more invisible to kernel users.
## 7. Summary
In this patch series, Amazon Linux proposes a new kernel feature that decouples the built-in crypto subsystem into a dedicated kernel module. To achieve this, several key mechanisms are designed, including specialized compile rules, a novel pluggable interface mechanism, and a module-loading initialization process. This feature is designed in an upstream-friendly manner so that it can support arbitrary kernel configuration settings and arbitrary chosen sets of cryptographic algorithms. It is planned to be officially launched with the Amazon Linux Kernel 6.18 and future kernels.
---
Written by Jay Wang <[email protected]>, Amazon Linux
Jay Wang (91):
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO and CONFIG_CRYPTO_ALGAPI2 crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_AES crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_AEAD2 crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_GENIV crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_SKCIPHER2 crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_HASH2 crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_AKCIPHER2 crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_SIG2 crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_KPP2 crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_RSA crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_ACOMP2 crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_MANAGER2 crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_MD5 crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_SHA3 crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_AUTHENC crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_LZO crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_RNG2 crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_ASYMMETRIC_KEY_TYPE crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_ASYMMETRIC_PUBLIC_KEY_SUBTYPE crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_X509_CERTIFICATE_PARSER crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_PKCS7_MESSAGE_PARSER crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_ENGINE crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_HKDF crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_DH crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_ECDSA and CONFIG_CRYPTO_ECC crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_USER crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_XCBC crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_NULL crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_MD4 crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_RMD160 crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_SHA1 crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_SM3_GENERIC crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_STREEBOG crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_WP512 crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_BLAKE2B crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_PCBC crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_CTS crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_LRW crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_XTS crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_XCTR and CONFIG_CRYPTO_HCTR2 crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_ADIANTUM crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_CHACHA20 crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_CHACHA20POLY1305 crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_AEGIS128 crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_CRYPTD crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_DES crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_FCRYPT crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_BLOWFISH and CONFIG_CRYPTO_BLOWFISH_COMMON crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_SM4 and CONFIG_CRYPTO_SM4_GENERIC crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_TWOFISH and CONFIG_CRYPTO_TWOFISH_COMMON crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_SERPENT crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_CAMELLIA crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_CAST_COMMON, CONFIG_CRYPTO_CAST5, CONFIG_CRYPTO_CAST6 crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_ARC4 crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_USER_API crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_USER_API_SKCIPHER crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_TEA crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_KHAZAD crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_ANUBIS crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_SEED crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_ARIA crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_DEFLATE crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_MICHAEL_MIC crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_CRC32C and CONFIG_CRYPTO_CRC32 crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_KRB5ENC crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_LZ4 and CONFIG_CRYPTO_LZ4HC crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_XXHASH crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_842 crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_BENCHMARK crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_USER_API_HASH crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_USER_API_RNG crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_USER_API_AEAD crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_ZSTD crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_ESSIV crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_ECDH crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_ECRDSA crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_XOR_BLOCKS crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_ASYNC_CORE crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_ASYNC_MEMCPY crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_ASYNC_XOR crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_ASYNC_PQ crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_ASYNC_RAID6_RECOV crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_KDF800108_CTR crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_KRB5 crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_FIPS_SIGNATURE_SELFTEST crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_PKCS8_PRIVATE_KEY_PARSER crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_PKCS7_TEST_KEY crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_SIGNED_PE_FILE_VERIFICATION crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_SIMD crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_ASYNC_RAID6_TEST crypto
Vegard Nossum (15):
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_SEQIV crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_ECHAINIV crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_CMAC crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_HMAC crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_SHA256 crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_SHA512 crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_ECB crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_CBC crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_CTR crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_GCM crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_CCM crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_DRBG crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_JITTERENTROPY crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_GHASH crypto
crypto: convert exported crypto symbol into pluggable interface for
CONFIG_CRYPTO_PCRYPT crypto
certs/system_keyring.c | 1 + crypto/842.c | 4 +- crypto/Makefile | 204 ++--- crypto/adiantum.c | 4 +- crypto/aegis128-core.c | 4 +- crypto/aes.c | 4 +- crypto/af_alg.c | 4 +- crypto/algapi.c | 4 +- crypto/algboss.c | 4 +- crypto/algif_aead.c | 4 +- crypto/algif_hash.c | 4 +- crypto/algif_rng.c | 4 +- crypto/algif_skcipher.c | 4 +- crypto/anubis.c | 4 +- crypto/arc4.c | 4 +- crypto/aria_generic.c | 4 +- crypto/asymmetric_keys/Makefile | 16 +- crypto/asymmetric_keys/asymmetric_type.c | 4 +- crypto/asymmetric_keys/pkcs7_key_type.c | 6 +- crypto/asymmetric_keys/pkcs8_parser.c | 4 +- crypto/asymmetric_keys/restrict.c | 3 +- crypto/asymmetric_keys/selftest.c | 2 +- crypto/asymmetric_keys/verify_pefile.c | 1 + crypto/asymmetric_keys/x509_parser.h | 15 +- crypto/asymmetric_keys/x509_public_key.c | 4 +- crypto/async_tx/Makefile | 12 +- crypto/async_tx/async_pq.c | 4 +- crypto/async_tx/async_tx.c | 4 +- crypto/async_tx/raid6test.c | 4 +- crypto/authenc.c | 4 +- crypto/authencesn.c | 4 +- crypto/blake2b.c | 4 +- crypto/blowfish_generic.c | 4 +- crypto/bpf_crypto_skcipher.c | 4 +- crypto/camellia_generic.c | 4 +- crypto/cast5_generic.c | 4 +- crypto/cast6_generic.c | 4 +- crypto/cbc.c | 4 +- crypto/ccm.c | 4 +- crypto/chacha.c | 4 +- crypto/chacha20poly1305.c | 4 +- crypto/cmac.c | 4 +- crypto/crc32.c | 4 +- crypto/crc32c.c | 4 +- crypto/cryptd.c | 4 +- crypto/crypto_null.c | 4 +- crypto/crypto_user.c | 4 +- crypto/ctr.c | 4 +- crypto/cts.c | 4 +- crypto/deflate.c | 4 +- crypto/des_generic.c | 4 +- crypto/dh.c | 4 +- crypto/drbg.c | 4 +- crypto/ecb.c | 4 +- crypto/ecdh.c | 4 +- crypto/ecdsa.c | 4 +- crypto/echainiv.c | 4 +- crypto/ecrdsa.c | 4 +- crypto/essiv.c | 4 +- crypto/fcrypt.c | 4 +- crypto/fips140/fips140-api.c | 934 ++++++++++++++++++++++- crypto/gcm.c | 4 +- crypto/ghash-generic.c | 4 +- crypto/hctr2.c | 4 +- crypto/hkdf.c | 4 +- crypto/hmac.c | 4 +- crypto/internal.h | 89 ++- crypto/jitterentropy-kcapi.c | 4 +- crypto/kdf_sp800108.c | 4 +- crypto/khazad.c | 4 +- crypto/krb5/Makefile | 2 +- crypto/krb5/krb5_api.c | 4 +- crypto/krb5enc.c | 4 +- crypto/lrw.c | 4 +- crypto/lz4.c | 4 +- crypto/lz4hc.c | 4 +- crypto/lzo-rle.c | 4 +- crypto/lzo.c | 4 +- crypto/md4.c | 4 +- crypto/md5.c | 4 +- crypto/michael_mic.c | 4 +- crypto/pcbc.c | 4 +- crypto/pcrypt.c | 4 +- crypto/rmd160.c | 4 +- crypto/rsa.c | 4 +- crypto/seed.c | 4 +- crypto/seqiv.c | 4 +- crypto/serpent_generic.c | 4 +- crypto/sha1.c | 4 +- crypto/sha256.c | 4 +- crypto/sha3.c | 4 +- crypto/sha512.c | 4 +- crypto/sm3_generic.c | 4 +- crypto/sm4_generic.c | 4 +- crypto/streebog_generic.c | 4 +- crypto/tcrypt.c | 4 +- crypto/tea.c | 4 +- crypto/twofish_generic.c | 4 +- crypto/wp512.c | 4 +- crypto/xcbc.c | 4 +- crypto/xctr.c | 4 +- crypto/xor.c | 4 +- crypto/xts.c | 4 +- crypto/xxhash_generic.c | 4 +- crypto/zstd.c | 4 +- include/crypto/acompress.h | 14 +- include/crypto/aead.h | 30 +- include/crypto/akcipher.h | 12 +- include/crypto/algapi.h | 125 ++- include/crypto/aria.h | 16 +- include/crypto/authenc.h | 12 +- include/crypto/blowfish.h | 6 +- include/crypto/cast5.h | 14 +- include/crypto/cast6.h | 19 +- include/crypto/cast_common.h | 17 +- include/crypto/cryptd.h | 56 +- include/crypto/dh.h | 14 +- include/crypto/ecc_curve.h | 9 +- include/crypto/ecdh.h | 14 +- include/crypto/engine.h | 140 ++-- include/crypto/hash.h | 53 +- include/crypto/hkdf.h | 13 +- include/crypto/if_alg.h | 84 +- include/crypto/internal/acompress.h | 27 +- include/crypto/internal/aead.h | 28 +- include/crypto/internal/akcipher.h | 12 +- include/crypto/internal/cipher.h | 20 +- include/crypto/internal/ecc.h | 91 ++- include/crypto/internal/geniv.h | 14 +- include/crypto/internal/hash.h | 59 +- include/crypto/internal/kpp.h | 12 +- include/crypto/internal/rng.h | 21 +- include/crypto/internal/rsa.h | 7 +- include/crypto/internal/scompress.h | 9 +- include/crypto/internal/sig.h | 12 +- include/crypto/internal/simd.h | 33 +- include/crypto/internal/skcipher.h | 91 ++- include/crypto/kdf_sp800108.h | 14 +- include/crypto/kpp.h | 5 +- include/crypto/krb5.h | 78 +- include/crypto/md5.h | 8 +- include/crypto/pkcs7.h | 31 +- include/crypto/public_key.h | 44 +- include/crypto/rng.h | 18 +- include/crypto/scatterwalk.h | 36 +- include/crypto/serpent.h | 20 +- include/crypto/sig.h | 3 +- include/crypto/skcipher.h | 56 +- include/crypto/sm4.h | 22 +- include/crypto/twofish.h | 11 +- include/keys/asymmetric-parser.h | 8 +- include/keys/asymmetric-type.h | 37 +- include/linux/async_tx.h | 76 +- include/linux/crypto.h | 22 +- include/linux/raid/xor.h | 7 +- include/linux/verification.h | 8 +- 156 files changed, 2302 insertions(+), 943 deletions(-)
Signature · 1 line
2.47.3
PATCH 1/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO and CONFIG_CRYPTO_ALGAPI2 crypto
Apply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO- and CONFIG_CRYPTO_ALGAPI2-related crypto to convert them into pluggable interface.
This patch is partially based on work by Vegard Nossum, with modifications. Unlike the original, we do not include DEFINE_CRYPTO_API since only one copy of the crypto symbols is kept, either in the crypto module or in the main kernel, and we ensure such wrapper do not have impact on crypto already chosen built as module.
--- crypto/Makefile | 4 +- crypto/algapi.c | 4 +- crypto/fips140/fips140-api.c | 109 +++++++++++++++++++++++++-- crypto/internal.h | 86 +++++++++++++-------- include/crypto/algapi.h | 125 +++++++++++++++++++++---------- include/crypto/internal/cipher.h | 20 +++-- include/crypto/scatterwalk.h | 36 +++++---- include/linux/crypto.h | 22 ++++-- 8 files changed, 302 insertions(+), 104 deletions(-)
crypto/Makefile +2 -2
@@ -5,7 +5,7 @@ CONTEXT_ANALYSIS := y -obj-$(CONFIG_CRYPTO) += crypto.o +crypto-objs-$(CONFIG_CRYPTO) += crypto.o crypto-y := api.o cipher.o obj-$(CONFIG_CRYPTO_ENGINE) += crypto_engine.o
@@ -13,7 +13,7 @@ obj-$(CONFIG_CRYPTO_FIPS) += fips.o crypto_algapi-$(CONFIG_PROC_FS) += proc.o crypto_algapi-y := algapi.o scatterwalk.o $(crypto_algapi-y) -obj-$(CONFIG_CRYPTO_ALGAPI2) += crypto_algapi.o +crypto-objs-$(CONFIG_CRYPTO_ALGAPI2) += crypto_algapi.o obj-$(CONFIG_CRYPTO_AEAD2) += aead.o obj-$(CONFIG_CRYPTO_GENIV) += geniv.o
crypto/algapi.c +2 -2
@@ -1123,8 +1123,8 @@ static void __exit crypto_algapi_exit(void)* We run this at late_initcall so that all the built-in algorithms * have had a chance to register themselves first. */ -late_initcall (crypto_algapi_init); -module_exit (crypto_algapi_exit); +crypto_late_initcall (crypto_algapi_init); +crypto_module_exit (crypto_algapi_exit);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("Cryptographic algorithms API" );
crypto/fips140/fips140-api.c +104 -5
113 lines not on this page · raw message
crypto/internal.h +56 -30
113 lines not on this page · raw message
include/crypto/algapi.h +87 -38
154 lines not on this page · raw message
include/crypto/internal/cipher.h +13 -7
@@ -11,6 +11,7 @@#ifndef _CRYPTO_INTERNAL_CIPHER_H#define _CRYPTO_INTERNAL_CIPHER_H +#include <crypto/api.h> #include <crypto/algapi.h> struct crypto_cipher {
@@ -149,8 +150,9 @@ static inline void crypto_cipher_clear_flags(struct crypto_cipher *tfm,* * Return: 0 if the setting of the key was successful; < 0 if an error occurred */ -int crypto_cipher_setkey (struct crypto_cipher *tfm, -const u8 *key,unsigned int keylen); +DECLARE_CRYPTO_API (CONFIG_CRYPTO , crypto_cipher_setkey, int, + (struct crypto_cipher *tfm, const u8 *key, unsigned int keylen), + (tfm, key, keylen));/** * crypto_cipher_encrypt_one() - encrypt one block of plaintext
@@ -161,8 +163,9 @@ int crypto_cipher_setkey(struct crypto_cipher *tfm,* Invoke the encryption operation of one block. The caller must ensure that * the plaintext and ciphertext buffers are at least one block in size. */ -void crypto_cipher_encrypt_one (struct crypto_cipher *tfm, -u8 *dst,const u8 *src); +DECLARE_CRYPTO_API (CONFIG_CRYPTO , crypto_cipher_encrypt_one, void, + (struct crypto_cipher *tfm, u8 *dst, const u8 *src), + (tfm, dst, src));/** * crypto_cipher_decrypt_one() - decrypt one block of ciphertext
@@ -173,10 +176,13 @@ void crypto_cipher_encrypt_one(struct crypto_cipher *tfm,* Invoke the decryption operation of one block. The caller must ensure that * the plaintext and ciphertext buffers are at least one block in size. */ -void crypto_cipher_decrypt_one (struct crypto_cipher *tfm, -u8 *dst,const u8 *src); +DECLARE_CRYPTO_API (CONFIG_CRYPTO , crypto_cipher_decrypt_one, void, + (struct crypto_cipher *tfm, u8 *dst, const u8 *src), + (tfm, dst, src)); -struct crypto_cipher *crypto_clone_cipher (struct crypto_cipher *cipher); +DECLARE_CRYPTO_API(CONFIG_CRYPTO, crypto_clone_cipher, struct crypto_cipher *, + (struct crypto_cipher *cipher), + (cipher));struct crypto_cipher_spawn {struct crypto_spawn base;
include/crypto/scatterwalk.h +22 -14
@@ -11,6 +11,7 @@#ifndef _CRYPTO_SCATTERWALK_H#define _CRYPTO_SCATTERWALK_H +#include <crypto/api.h> #include <crypto/algapi.h> #include <linux/highmem.h>
@@ -221,22 +222,29 @@ static inline void scatterwalk_done_dst(struct scatter_walk *walk,scatterwalk_advance (walk, nbytes); } -void scatterwalk_skip (struct scatter_walk *walk,unsigned int nbytes); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_ALGAPI2 , scatterwalk_skip, void, + (struct scatter_walk *walk, unsigned int nbytes), + (walk, nbytes)); -void memcpy_from_scatterwalk (void *buf,struct scatter_walk *walk, -unsigned int nbytes); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_ALGAPI2 , memcpy_from_scatterwalk, void, + (void *buf, struct scatter_walk *walk, unsigned int nbytes), + (buf, walk, nbytes)); -void memcpy_to_scatterwalk (struct scatter_walk *walk,const void *buf, -unsigned int nbytes); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_ALGAPI2 , memcpy_to_scatterwalk, void, + (struct scatter_walk *walk, const void *buf, unsigned int nbytes), + (walk, buf, nbytes)); -void memcpy_from_sglist (void *buf,struct scatterlist *sg, -unsigned int start,unsigned int nbytes); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_ALGAPI2 , memcpy_from_sglist, void, + (void *buf, struct scatterlist *sg, unsigned int start, unsigned int nbytes), + (buf, sg, start, nbytes)); -void memcpy_to_sglist (struct scatterlist *sg,unsigned int start, -const void *buf,unsigned int nbytes); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_ALGAPI2 , memcpy_to_sglist, void, + (struct scatterlist *sg, unsigned int start, const void *buf, unsigned int nbytes), + (sg, start, buf, nbytes)); -void memcpy_sglist (struct scatterlist *dst,struct scatterlist *src, -unsigned int nbytes); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_ALGAPI2 , memcpy_sglist, void, + (struct scatterlist *dst, struct scatterlist *src, unsigned int nbytes), + (dst, src, nbytes));/* In new code, please use memcpy_{from,to}_sglist() directly instead. */ static inline void scatterwalk_map_and_copy(void *buf, struct scatterlist *sg,
@@ -249,8 +257,8 @@ static inline void scatterwalk_map_and_copy(void *buf, struct scatterlist *sg,memcpy_from_sglist (buf, sg, start, nbytes); } -struct scatterlist *scatterwalk_ffwd (struct scatterlist dst[2 ], -struct scatterlist *src, -unsigned int len); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_ALGAPI2, scatterwalk_ffwd, struct scatterlist *, + (struct scatterlist dst[2], struct scatterlist *src, unsigned int len), + (dst, src, len));#endif /* _CRYPTO_SCATTERWALK_H */
include/linux/crypto.h +16 -6
@@ -12,6 +12,7 @@#ifndef _LINUX_CRYPTO_H#define _LINUX_CRYPTO_H +#include <crypto/api.h> #include <linux/completion.h> #include <linux/errno.h> #include <linux/refcount_types.h>
@@ -376,7 +377,9 @@ struct crypto_wait {/* * Async ops completion helper functioons */ -void crypto_req_done (void *req,int err); +DECLARE_CRYPTO_API (CONFIG_CRYPTO , crypto_req_done, void, + (void *req, int err), + (req, err));static inline int crypto_wait_req (int err,struct crypto_wait *wait) {
@@ -400,7 +403,9 @@ static inline void crypto_init_wait(struct crypto_wait *wait)/* * Algorithm query interface. */ -int crypto_has_alg (const char *name,u32 type,u32 mask); +DECLARE_CRYPTO_API (CONFIG_CRYPTO , crypto_has_alg, int, + (const char *name, u32 type, u32 mask), + (name, type, mask));/* * Transforms: user-instantiated objects which encapsulate algorithms
@@ -428,8 +433,12 @@ struct crypto_tfm {* Transform user interface. */ -struct crypto_tfm *crypto_alloc_base (const char *alg_name,u32 type,u32 mask); -void crypto_destroy_tfm (void *mem,struct crypto_tfm *tfm); +DECLARE_CRYPTO_API(CONFIG_CRYPTO, crypto_alloc_base, struct crypto_tfm *, + (const char *alg_name, u32 type, u32 mask), + (alg_name, type, mask)); +DECLARE_CRYPTO_API (CONFIG_CRYPTO , crypto_destroy_tfm, void, + (void *mem, struct crypto_tfm *tfm), + (mem, tfm));static inline void crypto_free_tfm (struct crypto_tfm *tfm) {
@@ -514,8 +523,9 @@ static inline void crypto_request_set_tfm(struct crypto_async_request *req, req->flags &= ~CRYPTO_TFM_REQ_ON_STACK ; } -struct crypto_async_request *crypto_request_clone ( -struct crypto_async_request *req,size_t total,gfp_t gfp); +DECLARE_CRYPTO_API(CONFIG_CRYPTO, crypto_request_clone, struct crypto_async_request *, + (struct crypto_async_request *req, size_t total, gfp_t gfp), + (req, total, gfp));static inline void crypto_stack_request_init (struct crypto_async_request *req,struct crypto_tfm *tfm)
Signature · 1 line
2.47.3
PATCH 2/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_AES crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_AES-related crypto to convert them into pluggable interface.
This patch is partially based on work by Vegard Nossum, with modifications. Unlike the original, we do not include DEFINE_CRYPTO_API since only one copy of the crypto symbols is kept, either in the crypto module or in the main kernel, and we ensure such wrapper do not have impact on crypto already chosen built as module.
--- crypto/Makefile | 2 +- crypto/aes.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -134,7 +134,7 @@ obj-$(CONFIG_CRYPTO_TWOFISH) += twofish_generic.o obj-$(CONFIG_CRYPTO_TWOFISH_COMMON) += twofish_common.o obj-$(CONFIG_CRYPTO_SERPENT) += serpent_generic.o CFLAGS_serpent_generic.o := $(call cc-option,-fsched-pressure) # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79149 -obj-$(CONFIG_CRYPTO_AES) += aes.o +crypto-objs-$(CONFIG_CRYPTO_AES) += aes.o obj-$(CONFIG_CRYPTO_SM4) += sm4.o obj-$(CONFIG_CRYPTO_SM4_GENERIC) += sm4_generic.o obj-$(CONFIG_CRYPTO_CAMELLIA) += camellia_generic.o
crypto/aes.c +2 -2
@@ -52,13 +52,13 @@ static int __init crypto_aes_mod_init(void) {return crypto_register_alg (&alg); } -module_init (crypto_aes_mod_init); +crypto_module_init (crypto_aes_mod_init); static void __exit crypto_aes_mod_exit(void) {crypto_unregister_alg (&alg); } -module_exit (crypto_aes_mod_exit); +crypto_module_exit (crypto_aes_mod_exit);MODULE_DESCRIPTION ("Crypto API support for AES block cipher" );MODULE_LICENSE ("GPL" );
Signature · 1 line
2.47.3
PATCH 3/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_AEAD2 crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_AEAD2-related crypto to convert them into pluggable interface.
This patch is partially based on work by Vegard Nossum, with modifications. Unlike the original, we do not include DEFINE_CRYPTO_API since only one copy of the crypto symbols is kept, either in the crypto module or in the main kernel, and we ensure such wrapper do not have impact on crypto already chosen built as module.
--- crypto/Makefile | 2 +- crypto/fips140/fips140-api.c | 26 ++++++++++++++++++++++++++ include/crypto/aead.h | 30 ++++++++++++++++++++++-------- include/crypto/internal/aead.h | 28 +++++++++++++++++++--------- 4 files changed, 68 insertions(+), 18 deletions(-)
crypto/Makefile +1 -1
@@ -15,7 +15,7 @@ crypto_algapi-$(CONFIG_PROC_FS) += proc.o crypto_algapi-y := algapi.o scatterwalk.o $(crypto_algapi-y) crypto-objs-$(CONFIG_CRYPTO_ALGAPI2) += crypto_algapi.o -obj-$(CONFIG_CRYPTO_AEAD2) += aead.o +crypto-objs-$(CONFIG_CRYPTO_AEAD2) += aead.o obj-$(CONFIG_CRYPTO_GENIV) += geniv.o crypto_skcipher-y += lskcipher.o
crypto/fips140/fips140-api.c +26 -0
@@ -103,4 +103,30 @@ DEFINE_CRYPTO_API_STUB(crypto_remove_final);DEFINE_CRYPTO_API_STUB (crypto_alg_extsize);DEFINE_CRYPTO_API_STUB (crypto_type_has_alg); +#endif + +/* +* crypto/aead.c +*/ +#if IS_BUILTIN (CONFIG_CRYPTO_AEAD2 ) + +#include <crypto/aead.h> + +DEFINE_CRYPTO_API_STUB (crypto_alloc_aead); +DEFINE_CRYPTO_API_STUB (crypto_alloc_sync_aead); +DEFINE_CRYPTO_API_STUB (crypto_has_aead); +DEFINE_CRYPTO_API_STUB (crypto_aead_setkey); +DEFINE_CRYPTO_API_STUB (crypto_aead_setauthsize); +DEFINE_CRYPTO_API_STUB (crypto_aead_encrypt); +DEFINE_CRYPTO_API_STUB (crypto_aead_decrypt); + +#include <crypto/internal/aead.h> + +DEFINE_CRYPTO_API_STUB (crypto_grab_aead); +DEFINE_CRYPTO_API_STUB (crypto_register_aead); +DEFINE_CRYPTO_API_STUB (crypto_unregister_aead); +DEFINE_CRYPTO_API_STUB (crypto_register_aeads); +DEFINE_CRYPTO_API_STUB (crypto_unregister_aeads); +DEFINE_CRYPTO_API_STUB (aead_register_instance); +#endif
include/crypto/aead.h +22 -8
@@ -8,6 +8,7 @@#ifndef _CRYPTO_AEAD_H#define _CRYPTO_AEAD_H +#include <crypto/api.h> #include <linux/atomic.h> #include <linux/container_of.h> #include <linux/crypto.h>
@@ -193,9 +194,13 @@ static inline struct crypto_aead *__crypto_aead_cast(struct crypto_tfm *tfm)* Return: allocated cipher handle in case of success; IS_ERR() is true in case * of an error, PTR_ERR() returns the error code. */ -struct crypto_aead *crypto_alloc_aead (const char *alg_name,u32 type,u32 mask); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_AEAD2, crypto_alloc_aead, struct crypto_aead *, + (const char *alg_name, u32 type, u32 mask), + (alg_name, type, mask)); -struct crypto_sync_aead *crypto_alloc_sync_aead (const char *alg_name,u32 type,u32 mask); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_AEAD2, crypto_alloc_sync_aead, struct crypto_sync_aead *, + (const char *alg_name, u32 type, u32 mask), + (alg_name, type, mask));static inline struct crypto_tfm *crypto_aead_tfm (struct crypto_aead *tfm) {
@@ -233,7 +238,9 @@ static inline void crypto_free_sync_aead(struct crypto_sync_aead *tfm)* Return: true when the aead is known to the kernel crypto API; false * otherwise */ -int crypto_has_aead (const char *alg_name,u32 type,u32 mask); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_AEAD2 , crypto_has_aead, int, + (const char *alg_name, u32 type, u32 mask), + (alg_name, type, mask));static inline const char *crypto_aead_driver_name (struct crypto_aead *tfm) {
@@ -378,8 +385,9 @@ static inline void crypto_sync_aead_clear_flags(struct crypto_sync_aead *tfm, u3* * Return: 0 if the setting of the key was successful; < 0 if an error occurred */ -int crypto_aead_setkey (struct crypto_aead *tfm, -const u8 *key,unsigned int keylen); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_AEAD2 , crypto_aead_setkey, int, + (struct crypto_aead *tfm, const u8 *key, unsigned int keylen), + (tfm, key, keylen));static inline int crypto_sync_aead_setkey (struct crypto_sync_aead *tfm,const u8 *key,unsigned int keylen)
@@ -397,7 +405,9 @@ static inline int crypto_sync_aead_setkey(struct crypto_sync_aead *tfm,* * Return: 0 if the setting of the key was successful; < 0 if an error occurred */ -int crypto_aead_setauthsize (struct crypto_aead *tfm,unsigned int authsize); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_AEAD2 , crypto_aead_setauthsize, int, + (struct crypto_aead *tfm, unsigned int authsize), + (tfm, authsize));static inline int crypto_sync_aead_setauthsize (struct crypto_sync_aead *tfm,unsigned int authsize)
@@ -436,7 +446,9 @@ static inline struct crypto_sync_aead *crypto_sync_aead_reqtfm(struct aead_reque* * Return: 0 if the cipher operation was successful; < 0 if an error occurred */ -int crypto_aead_encrypt (struct aead_request *req); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_AEAD2 , crypto_aead_encrypt, int, + (struct aead_request *req), + (req));/** * crypto_aead_decrypt() - decrypt ciphertext
@@ -460,7 +472,9 @@ int crypto_aead_encrypt(struct aead_request *req);* integrity of the ciphertext or the associated data was violated); * < 0 if an error occurred. */ -int crypto_aead_decrypt (struct aead_request *req); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_AEAD2 , crypto_aead_decrypt, int, + (struct aead_request *req), + (req));/** * DOC: Asynchronous AEAD Request Handle
include/crypto/internal/aead.h +19 -9
@@ -8,6 +8,7 @@#ifndef _CRYPTO_INTERNAL_AEAD_H#define _CRYPTO_INTERNAL_AEAD_H +#include <crypto/api.h> #include <crypto/aead.h> #include <crypto/algapi.h> #include <linux/stddef.h>
@@ -96,9 +97,9 @@ static inline struct aead_request *aead_request_cast( return container_of(req, struct aead_request, base); } -int crypto_grab_aead (struct crypto_aead_spawn *spawn, -struct crypto_instance *inst, -const char *name,u32 type,u32 mask); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_AEAD2 , crypto_grab_aead, int, + (struct crypto_aead_spawn *spawn, struct crypto_instance *inst, const char *name, u32 type, u32 mask), + (spawn, inst, name, type, mask));static inline void crypto_drop_aead (struct crypto_aead_spawn *spawn) {
@@ -157,12 +158,21 @@ static inline unsigned int crypto_aead_chunksize(struct crypto_aead *tfm)return crypto_aead_alg_chunksize (crypto_aead_alg (tfm)); } -int crypto_register_aead (struct aead_alg *alg); -void crypto_unregister_aead (struct aead_alg *alg); -int crypto_register_aeads (struct aead_alg *algs,int count); -void crypto_unregister_aeads (struct aead_alg *algs,int count); -int aead_register_instance (struct crypto_template *tmpl, -struct aead_instance *inst); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_AEAD2 , crypto_register_aead, int, + (struct aead_alg *alg), + (alg)); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_AEAD2 , crypto_unregister_aead, void, + (struct aead_alg *alg), + (alg)); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_AEAD2 , crypto_register_aeads, int, + (struct aead_alg *algs, int count), + (algs, count)); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_AEAD2 , crypto_unregister_aeads, void, + (struct aead_alg *algs, int count), + (algs, count)); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_AEAD2 , aead_register_instance, int, + (struct crypto_template *tmpl, struct aead_instance *inst), + (tmpl, inst));#endif /* _CRYPTO_INTERNAL_AEAD_H */
Signature · 1 line
2.47.3
PATCH 4/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_GENIV crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_GENIV-related crypto to convert them into pluggable interface.
This patch is partially based on work by Vegard Nossum, with modifications. Unlike the original, we do not include DEFINE_CRYPTO_API since only one copy of the crypto symbols is kept, either in the crypto module or in the main kernel, and we ensure such wrapper do not have impact on crypto already chosen built as module.
--- crypto/Makefile | 2 +- crypto/fips140/fips140-api.c | 13 +++++++++++++ include/crypto/internal/geniv.h | 14 ++++++++++---- 3 files changed, 24 insertions(+), 5 deletions(-)
crypto/Makefile +1 -1
@@ -16,7 +16,7 @@ crypto_algapi-y := algapi.o scatterwalk.o $(crypto_algapi-y) crypto-objs-$(CONFIG_CRYPTO_ALGAPI2) += crypto_algapi.o crypto-objs-$(CONFIG_CRYPTO_AEAD2) += aead.o -obj-$(CONFIG_CRYPTO_GENIV) += geniv.o +crypto-objs-$(CONFIG_CRYPTO_GENIV) += geniv.o crypto_skcipher-y += lskcipher.o crypto_skcipher-y += skcipher.o
crypto/fips140/fips140-api.c +13 -0
@@ -129,4 +129,17 @@ DEFINE_CRYPTO_API_STUB(crypto_register_aeads);DEFINE_CRYPTO_API_STUB (crypto_unregister_aeads);DEFINE_CRYPTO_API_STUB (aead_register_instance); +#endif + +/* +* crypto/geniv.c +*/ +#if IS_BUILTIN (CONFIG_CRYPTO_GENIV ) + +#include <crypto/internal/geniv.h> + +DEFINE_CRYPTO_API_STUB (aead_geniv_alloc); +DEFINE_CRYPTO_API_STUB (aead_init_geniv); +DEFINE_CRYPTO_API_STUB (aead_exit_geniv); +#endif
include/crypto/internal/geniv.h +10 -4
@@ -8,6 +8,7 @@#ifndef _CRYPTO_INTERNAL_GENIV_H#define _CRYPTO_INTERNAL_GENIV_H +#include <crypto/api.h> #include <crypto/internal/aead.h> #include <linux/spinlock.h> #include <linux/types.h>
@@ -18,9 +19,14 @@ struct aead_geniv_ctx { u8 salt[] __attribute__ ((aligned(__alignof__(u32)))); }; -struct aead_instance *aead_geniv_alloc (struct crypto_template *tmpl, -struct rtattr **tb); -int aead_init_geniv (struct crypto_aead *tfm); -void aead_exit_geniv (struct crypto_aead *tfm); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_GENIV, aead_geniv_alloc, struct aead_instance *, + (struct crypto_template *tmpl, struct rtattr **tb), + (tmpl, tb)); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_GENIV , aead_init_geniv, int, + (struct crypto_aead *tfm), + (tfm)); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_GENIV , aead_exit_geniv, void, + (struct crypto_aead *tfm), + (tfm));#endif /* _CRYPTO_INTERNAL_GENIV_H */
Signature · 1 line
2.47.3
PATCH 5/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_SKCIPHER2 crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_SKCIPHER2-related crypto to convert them into pluggable interface.
This patch is partially based on work by Vegard Nossum, with modifications. Unlike the original, we do not include DEFINE_CRYPTO_API since only one copy of the crypto symbols is kept, either in the crypto module or in the main kernel, and we ensure such wrapper do not have impact on crypto already chosen built as module.
--- crypto/Makefile | 4 +- crypto/bpf_crypto_skcipher.c | 4 +- crypto/fips140/fips140-api.c | 47 +++++++++++++++ include/crypto/internal/skcipher.h | 91 +++++++++++++++++++----------- include/crypto/skcipher.h | 56 +++++++++++------- 5 files changed, 145 insertions(+), 57 deletions(-)
crypto/Makefile +2 -2
@@ -21,9 +21,9 @@ crypto-objs-$(CONFIG_CRYPTO_GENIV) += geniv.o crypto_skcipher-y += lskcipher.o crypto_skcipher-y += skcipher.o -obj-$(CONFIG_CRYPTO_SKCIPHER2) += crypto_skcipher.o +crypto-objs-$(CONFIG_CRYPTO_SKCIPHER2) += crypto_skcipher.o ifeq ($(CONFIG_BPF_SYSCALL),y) -obj-$(CONFIG_CRYPTO_SKCIPHER2) += bpf_crypto_skcipher.o +crypto-objs-$(CONFIG_CRYPTO_SKCIPHER2) += bpf_crypto_skcipher.o endif obj-$(CONFIG_CRYPTO_SEQIV) += seqiv.o
crypto/bpf_crypto_skcipher.c +2 -2
@@ -77,7 +77,7 @@ static void __exit bpf_crypto_skcipher_exit(void)WARN_ON_ONCE (err); } -module_init (bpf_crypto_skcipher_init); -module_exit (bpf_crypto_skcipher_exit); +crypto_module_init (bpf_crypto_skcipher_init); +crypto_module_exit (bpf_crypto_skcipher_exit);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("Symmetric key cipher support for BPF" );
crypto/fips140/fips140-api.c +47 -0
52 lines not on this page · raw message
include/crypto/internal/skcipher.h +57 -34
122 lines not on this page · raw message
include/crypto/skcipher.h +37 -19
129 lines not on this page · raw message
Signature · 1 line
2.47.3
PATCH 6/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_SEQIV crypto
In reply to Jay WangFrom: Vegard Nossum <[email protected]>
Apply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_SEQIV-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/seqiv.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -26,7 +26,7 @@ ifeq ($(CONFIG_BPF_SYSCALL),y) crypto-objs-$(CONFIG_CRYPTO_SKCIPHER2) += bpf_crypto_skcipher.o endif -obj-$(CONFIG_CRYPTO_SEQIV) += seqiv.o +crypto-objs-$(CONFIG_CRYPTO_SEQIV) += seqiv.o obj-$(CONFIG_CRYPTO_ECHAINIV) += echainiv.o crypto_hash-y += ahash.o
crypto/seqiv.c +2 -2
@@ -170,8 +170,8 @@ static void __exit seqiv_module_exit(void)crypto_unregister_template (&seqiv_tmpl); } -module_init (seqiv_module_init); -module_exit (seqiv_module_exit); +crypto_module_init (seqiv_module_init); +crypto_module_exit (seqiv_module_exit);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("Sequence Number IV Generator" );
Signature · 1 line
2.47.3
PATCH 7/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_ECHAINIV crypto
In reply to Jay WangFrom: Vegard Nossum <[email protected]>
Apply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_ECHAINIV-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/echainiv.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -27,7 +27,7 @@ crypto-objs-$(CONFIG_CRYPTO_SKCIPHER2) += bpf_crypto_skcipher.o endif crypto-objs-$(CONFIG_CRYPTO_SEQIV) += seqiv.o -obj-$(CONFIG_CRYPTO_ECHAINIV) += echainiv.o +crypto-objs-$(CONFIG_CRYPTO_ECHAINIV) += echainiv.o crypto_hash-y += ahash.o crypto_hash-y += shash.o
crypto/echainiv.c +2 -2
@@ -145,8 +145,8 @@ static void __exit echainiv_module_exit(void)crypto_unregister_template (&echainiv_tmpl); } -module_init (echainiv_module_init); -module_exit (echainiv_module_exit); +crypto_module_init (echainiv_module_init); +crypto_module_exit (echainiv_module_exit);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("Encrypted Chain IV Generator" );
Signature · 1 line
2.47.3
PATCH 8/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_HASH2 crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_HASH2-related crypto to convert them into pluggable interface.
This patch is partially based on work by Vegard Nossum, with modifications. Unlike the original, we do not include DEFINE_CRYPTO_API since only one copy of the crypto symbols is kept, either in the crypto module or in the main kernel, and we ensure such wrapper do not have impact on crypto already chosen built as module.
--- crypto/Makefile | 2 +- crypto/fips140/fips140-api.c | 63 ++++++++++++++++++++++++++++++++++ include/crypto/hash.h | 53 +++++++++++++--------------- include/crypto/internal/hash.h | 59 ++++++++++++++----------------- 4 files changed, 113 insertions(+), 64 deletions(-)
crypto/Makefile +1 -1
@@ -31,7 +31,7 @@ crypto-objs-$(CONFIG_CRYPTO_ECHAINIV) += echainiv.o crypto_hash-y += ahash.o crypto_hash-y += shash.o -obj-$(CONFIG_CRYPTO_HASH2) += crypto_hash.o +crypto-objs-$(CONFIG_CRYPTO_HASH2) += crypto_hash.o obj-$(CONFIG_CRYPTO_AKCIPHER2) += akcipher.o obj-$(CONFIG_CRYPTO_SIG2) += sig.o
crypto/fips140/fips140-api.c +63 -0
68 lines not on this page · raw message
include/crypto/hash.h +23 -30
171 lines not on this page · raw message
include/crypto/internal/hash.h +26 -33
127 lines not on this page · raw message
Signature · 1 line
2.47.3
PATCH 9/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_AKCIPHER2 crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_AKCIPHER2-related crypto to convert them into pluggable interface.
This patch is partially based on work by Vegard Nossum, with modifications. Unlike the original, we do not include DEFINE_CRYPTO_API since only one copy of the crypto symbols is kept, either in the crypto module or in the main kernel, and we ensure such wrapper do not have impact on crypto already chosen built as module.
--- crypto/Makefile | 2 +- crypto/fips140/fips140-api.c | 18 ++++++++++++++++++ include/crypto/akcipher.h | 12 ++++-------- include/crypto/internal/akcipher.h | 12 +++++------- 4 files changed, 28 insertions(+), 16 deletions(-)
crypto/Makefile +1 -1
@@ -33,7 +33,7 @@ crypto_hash-y += ahash.o crypto_hash-y += shash.o crypto-objs-$(CONFIG_CRYPTO_HASH2) += crypto_hash.o -obj-$(CONFIG_CRYPTO_AKCIPHER2) += akcipher.o +crypto-objs-$(CONFIG_CRYPTO_AKCIPHER2) += akcipher.o obj-$(CONFIG_CRYPTO_SIG2) += sig.o obj-$(CONFIG_CRYPTO_KPP2) += kpp.o obj-$(CONFIG_CRYPTO_HKDF) += hkdf.o
crypto/fips140/fips140-api.c +18 -0
@@ -252,4 +252,22 @@ DEFINE_CRYPTO_API_STUB(crypto_unregister_shashes);DEFINE_CRYPTO_API_STUB (shash_register_instance);DEFINE_CRYPTO_API_STUB (shash_free_singlespawn_instance); +#endif + +/* +* crypto/akcipher.c +*/ +#if IS_BUILTIN (CONFIG_CRYPTO_AKCIPHER2 ) + +#include <crypto/akcipher.h> +#include <crypto/internal/akcipher.h> + +DEFINE_CRYPTO_API_STUB (crypto_grab_akcipher); +DEFINE_CRYPTO_API_STUB (crypto_alloc_akcipher); +DEFINE_CRYPTO_API_STUB (crypto_register_akcipher); +DEFINE_CRYPTO_API_STUB (crypto_unregister_akcipher); +DEFINE_CRYPTO_API_STUB (akcipher_register_instance); +DEFINE_CRYPTO_API_STUB (crypto_akcipher_sync_encrypt); +DEFINE_CRYPTO_API_STUB (crypto_akcipher_sync_decrypt); +#endif
include/crypto/akcipher.h +4 -8
@@ -8,6 +8,7 @@#ifndef _CRYPTO_AKCIPHER_H#define _CRYPTO_AKCIPHER_H +#include <crypto/api.h> #include <linux/atomic.h> #include <linux/crypto.h>
@@ -116,8 +117,7 @@ struct akcipher_alg {* Return: allocated handle in case of success; IS_ERR() is true in case * of an error, PTR_ERR() returns the error code. */ -struct crypto_akcipher *crypto_alloc_akcipher (const char *alg_name,u32 type, -u32 mask); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_AKCIPHER2, crypto_alloc_akcipher, struct crypto_akcipher *, (const char *alg_name, u32 type, u32 mask), (alg_name, type, mask));static inline struct crypto_tfm *crypto_akcipher_tfm (struct crypto_akcipher *tfm)
@@ -310,9 +310,7 @@ static inline int crypto_akcipher_decrypt(struct akcipher_request *req)* * Return: zero on success; error code in case of error */ -int crypto_akcipher_sync_encrypt (struct crypto_akcipher *tfm, -const void *src,unsigned int slen, -void *dst,unsigned int dlen); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_AKCIPHER2, crypto_akcipher_sync_encrypt, int, (struct crypto_akcipher *tfm, const void *src, unsigned int slen, void *dst, unsigned int dlen), (tfm, src, slen, dst, dlen));/** * crypto_akcipher_sync_decrypt() - Invoke public key decrypt operation
@@ -328,9 +326,7 @@ int crypto_akcipher_sync_encrypt(struct crypto_akcipher *tfm,* * Return: Output length on success; error code in case of error */ -int crypto_akcipher_sync_decrypt (struct crypto_akcipher *tfm, -const void *src,unsigned int slen, -void *dst,unsigned int dlen); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_AKCIPHER2, crypto_akcipher_sync_decrypt, int, (struct crypto_akcipher *tfm, const void *src, unsigned int slen, void *dst, unsigned int dlen), (tfm, src, slen, dst, dlen));/** * crypto_akcipher_set_pub_key() - Invoke set public key operation
include/crypto/internal/akcipher.h +5 -7
@@ -7,6 +7,7 @@*/ #ifndef _CRYPTO_AKCIPHER_INT_H#define _CRYPTO_AKCIPHER_INT_H +#include <crypto/api.h> #include <crypto/akcipher.h> #include <crypto/algapi.h>
@@ -100,9 +101,7 @@ static inline void *akcipher_instance_ctx(struct akcipher_instance *inst)return crypto_instance_ctx (akcipher_crypto_instance (inst)); } -int crypto_grab_akcipher (struct crypto_akcipher_spawn *spawn, -struct crypto_instance *inst, -const char *name,u32 type,u32 mask); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_AKCIPHER2, crypto_grab_akcipher, int, (struct crypto_akcipher_spawn *spawn, struct crypto_instance *inst, const char *name, u32 type, u32 mask), (spawn, inst, name, type, mask));static inline struct crypto_akcipher *crypto_spawn_akcipher (struct crypto_akcipher_spawn *spawn)
@@ -130,7 +129,7 @@ static inline struct akcipher_alg *crypto_spawn_akcipher_alg(* * Return: zero on success; error code in case of error */ -int crypto_register_akcipher (struct akcipher_alg *alg); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_AKCIPHER2, crypto_register_akcipher, int, (struct akcipher_alg *alg), (alg));/** * crypto_unregister_akcipher() -- Unregister public key algorithm
@@ -139,7 +138,7 @@ int crypto_register_akcipher(struct akcipher_alg *alg);* * @alg: algorithm definition */ -void crypto_unregister_akcipher (struct akcipher_alg *alg); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_AKCIPHER2, crypto_unregister_akcipher, void, (struct akcipher_alg *alg), (alg));/** * akcipher_register_instance() -- Unregister public key template instance
@@ -150,6 +149,5 @@ void crypto_unregister_akcipher(struct akcipher_alg *alg);* @tmpl: the template from which the algorithm was created * @inst: the template instance */ -int akcipher_register_instance (struct crypto_template *tmpl, -struct akcipher_instance *inst); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_AKCIPHER2, akcipher_register_instance, int, (struct crypto_template *tmpl, struct akcipher_instance *inst), (tmpl, inst));#endif
Signature · 1 line
2.47.3
PATCH 10/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_SIG2 crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_SIG2-related crypto to convert them into pluggable interface.
This patch is partially based on work by Vegard Nossum, with modifications. Unlike the original, we do not include DEFINE_CRYPTO_API since only one copy of the crypto symbols is kept, either in the crypto module or in the main kernel, and we ensure such wrapper do not have impact on crypto already chosen built as module.
--- crypto/Makefile | 2 +- crypto/fips140/fips140-api.c | 16 ++++++++++++++++ include/crypto/internal/sig.h | 12 +++++------- include/crypto/sig.h | 3 ++- 4 files changed, 24 insertions(+), 9 deletions(-)
crypto/Makefile +1 -1
@@ -34,7 +34,7 @@ crypto_hash-y += shash.o crypto-objs-$(CONFIG_CRYPTO_HASH2) += crypto_hash.o crypto-objs-$(CONFIG_CRYPTO_AKCIPHER2) += akcipher.o -obj-$(CONFIG_CRYPTO_SIG2) += sig.o +crypto-objs-$(CONFIG_CRYPTO_SIG2) += sig.o obj-$(CONFIG_CRYPTO_KPP2) += kpp.o obj-$(CONFIG_CRYPTO_HKDF) += hkdf.o
crypto/fips140/fips140-api.c +16 -0
@@ -270,4 +270,20 @@ DEFINE_CRYPTO_API_STUB(akcipher_register_instance);DEFINE_CRYPTO_API_STUB (crypto_akcipher_sync_encrypt);DEFINE_CRYPTO_API_STUB (crypto_akcipher_sync_decrypt); +#endif + +/* +* crypto/sig.c +*/ +#if IS_BUILTIN (CONFIG_CRYPTO_SIG2 ) + +#include <crypto/sig.h> +#include <crypto/internal/sig.h> + +DEFINE_CRYPTO_API_STUB (crypto_alloc_sig); +DEFINE_CRYPTO_API_STUB (crypto_register_sig); +DEFINE_CRYPTO_API_STUB (crypto_unregister_sig); +DEFINE_CRYPTO_API_STUB (sig_register_instance); +DEFINE_CRYPTO_API_STUB (crypto_grab_sig); +#endif
include/crypto/internal/sig.h +5 -7
@@ -7,6 +7,7 @@#ifndef _CRYPTO_INTERNAL_SIG_H#define _CRYPTO_INTERNAL_SIG_H +#include <crypto/api.h> #include <crypto/algapi.h> #include <crypto/sig.h>
@@ -39,7 +40,7 @@ static inline void *crypto_sig_ctx(struct crypto_sig *tfm)* * Return: zero on success; error code in case of error */ -int crypto_register_sig (struct sig_alg *alg); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_SIG2, crypto_register_sig, int, (struct sig_alg *alg), (alg));/** * crypto_unregister_sig() -- Unregister public key signature algorithm
@@ -48,10 +49,9 @@ int crypto_register_sig(struct sig_alg *alg);* * @alg: algorithm definition */ -void crypto_unregister_sig (struct sig_alg *alg); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_SIG2, crypto_unregister_sig, void, (struct sig_alg *alg), (alg)); -int sig_register_instance (struct crypto_template *tmpl, -struct sig_instance *inst); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_SIG2, sig_register_instance, int, (struct crypto_template *tmpl, struct sig_instance *inst), (tmpl, inst));static inline struct sig_instance *sig_instance (struct crypto_instance *inst) {
@@ -74,9 +74,7 @@ static inline void *sig_instance_ctx(struct sig_instance *inst)return crypto_instance_ctx (sig_crypto_instance (inst)); } -int crypto_grab_sig (struct crypto_sig_spawn *spawn, -struct crypto_instance *inst, -const char *name,u32 type,u32 mask); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_SIG2, crypto_grab_sig, int, (struct crypto_sig_spawn *spawn, struct crypto_instance *inst, const char *name, u32 type, u32 mask), (spawn, inst, name, type, mask));static inline struct crypto_sig *crypto_spawn_sig (struct crypto_sig_spawn *spawn)
include/crypto/sig.h +2 -1
@@ -7,6 +7,7 @@#ifndef _CRYPTO_SIG_H#define _CRYPTO_SIG_H +#include <crypto/api.h> #include <linux/crypto.h> /**
@@ -91,7 +92,7 @@ struct sig_alg {* Return: allocated handle in case of success; IS_ERR() is true in case * of an error, PTR_ERR() returns the error code. */ -struct crypto_sig *crypto_alloc_sig (const char *alg_name,u32 type,u32 mask); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_SIG2, crypto_alloc_sig, struct crypto_sig *, (const char *alg_name, u32 type, u32 mask), (alg_name, type, mask));static inline struct crypto_tfm *crypto_sig_tfm (struct crypto_sig *tfm) {
Signature · 1 line
2.47.3
PATCH 11/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_KPP2 crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_KPP2-related crypto to convert them into pluggable interface.
This patch is partially based on work by Vegard Nossum, with modifications. Unlike the original, we do not include DEFINE_CRYPTO_API since only one copy of the crypto symbols is kept, either in the crypto module or in the main kernel, and we ensure such wrapper do not have impact on crypto already chosen built as module.
--- crypto/Makefile | 2 +- crypto/fips140/fips140-api.c | 17 +++++++++++++++++ include/crypto/internal/kpp.h | 12 +++++------- include/crypto/kpp.h | 5 +++-- 4 files changed, 26 insertions(+), 10 deletions(-)
crypto/Makefile +1 -1
@@ -35,7 +35,7 @@ crypto-objs-$(CONFIG_CRYPTO_HASH2) += crypto_hash.o crypto-objs-$(CONFIG_CRYPTO_AKCIPHER2) += akcipher.o crypto-objs-$(CONFIG_CRYPTO_SIG2) += sig.o -obj-$(CONFIG_CRYPTO_KPP2) += kpp.o +crypto-objs-$(CONFIG_CRYPTO_KPP2) += kpp.o obj-$(CONFIG_CRYPTO_HKDF) += hkdf.o dh_generic-y := dh.o
crypto/fips140/fips140-api.c +17 -0
@@ -286,4 +286,21 @@ DEFINE_CRYPTO_API_STUB(crypto_unregister_sig);DEFINE_CRYPTO_API_STUB (sig_register_instance);DEFINE_CRYPTO_API_STUB (crypto_grab_sig); +#endif + +/* +* crypto/kpp.c +*/ +#if IS_BUILTIN (CONFIG_CRYPTO_KPP2 ) + +#include <crypto/kpp.h> +#include <crypto/internal/kpp.h> + +DEFINE_CRYPTO_API_STUB (crypto_alloc_kpp); +DEFINE_CRYPTO_API_STUB (crypto_grab_kpp); +DEFINE_CRYPTO_API_STUB (crypto_has_kpp); +DEFINE_CRYPTO_API_STUB (crypto_register_kpp); +DEFINE_CRYPTO_API_STUB (crypto_unregister_kpp); +DEFINE_CRYPTO_API_STUB (kpp_register_instance); +#endif
include/crypto/internal/kpp.h +5 -7
@@ -7,6 +7,7 @@*/ #ifndef _CRYPTO_KPP_INT_H#define _CRYPTO_KPP_INT_H +#include <crypto/api.h> #include <crypto/kpp.h> #include <crypto/algapi.h>
@@ -159,7 +160,7 @@ static inline void *kpp_instance_ctx(struct kpp_instance *inst)* * Return: zero on success; error code in case of error */ -int crypto_register_kpp (struct kpp_alg *alg); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_KPP2, crypto_register_kpp, int, (struct kpp_alg *alg), (alg));/** * crypto_unregister_kpp() -- Unregister key-agreement protocol primitive
@@ -170,7 +171,7 @@ int crypto_register_kpp(struct kpp_alg *alg);* * @alg: algorithm definition */ -void crypto_unregister_kpp (struct kpp_alg *alg); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_KPP2, crypto_unregister_kpp, void, (struct kpp_alg *alg), (alg));/** * kpp_register_instance() - Register a KPP template instance.
@@ -178,8 +179,7 @@ void crypto_unregister_kpp(struct kpp_alg *alg);* @inst: The KPP template instance to be registered. * Return: %0 on success, negative error code otherwise. */ -int kpp_register_instance (struct crypto_template *tmpl, -struct kpp_instance *inst); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_KPP2, kpp_register_instance, int, (struct crypto_template *tmpl, struct kpp_instance *inst), (tmpl, inst));/* * KPP spawn related functions.
@@ -193,9 +193,7 @@ int kpp_register_instance(struct crypto_template *tmpl,* @mask: The mask bismask to pass on to the lookup. * Return: %0 on success, a negative error code otherwise. */ -int crypto_grab_kpp (struct crypto_kpp_spawn *spawn, -struct crypto_instance *inst, -const char *name,u32 type,u32 mask); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_KPP2, crypto_grab_kpp, int, (struct crypto_kpp_spawn *spawn, struct crypto_instance *inst, const char *name, u32 type, u32 mask), (spawn, inst, name, type, mask));/** * crypto_drop_kpp() - Release a spawn previously bound via crypto_grab_kpp().
include/crypto/kpp.h +3 -2
@@ -9,6 +9,7 @@#ifndef _CRYPTO_KPP_#define _CRYPTO_KPP_ +#include <crypto/api.h> #include <linux/atomic.h> #include <linux/container_of.h> #include <linux/crypto.h>
@@ -107,9 +108,9 @@ struct kpp_alg {* Return: allocated handle in case of success; IS_ERR() is true in case of * an error, PTR_ERR() returns the error code. */ -struct crypto_kpp *crypto_alloc_kpp (const char *alg_name,u32 type,u32 mask); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_KPP2, crypto_alloc_kpp, struct crypto_kpp *, (const char *alg_name, u32 type, u32 mask), (alg_name, type, mask)); -int crypto_has_kpp (const char *alg_name,u32 type,u32 mask); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_KPP2, crypto_has_kpp, int, (const char *alg_name, u32 type, u32 mask), (alg_name, type, mask));static inline struct crypto_tfm *crypto_kpp_tfm (struct crypto_kpp *tfm) {
Signature · 1 line
2.47.3
PATCH 12/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_RSA crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_RSA-related crypto to convert them into pluggable interface.
This patch is partially based on work by Vegard Nossum, with modifications. Unlike the original, we do not include DEFINE_CRYPTO_API since only one copy of the crypto symbols is kept, either in the crypto module or in the main kernel, and we ensure such wrapper do not have impact on crypto already chosen built as module.
--- crypto/Makefile | 2 +- crypto/fips140/fips140-api.c | 12 ++++++++++++ crypto/rsa.c | 4 ++-- include/crypto/internal/rsa.h | 7 +++---- 4 files changed, 18 insertions(+), 7 deletions(-)
crypto/Makefile +1 -1
@@ -52,7 +52,7 @@ rsa_generic-y += rsa.o rsa_generic-y += rsa_helper.o rsa_generic-y += rsa-pkcs1pad.o rsa_generic-y += rsassa-pkcs1.o -obj-$(CONFIG_CRYPTO_RSA) += rsa_generic.o +crypto-objs-$(CONFIG_CRYPTO_RSA) += rsa_generic.o $(obj)/ecdsasignature.asn1.o: $(obj)/ecdsasignature.asn1.c $(obj)/ecdsasignature.asn1.h $(obj)/ecdsa-x962.o: $(obj)/ecdsasignature.asn1.h
crypto/fips140/fips140-api.c +12 -0
@@ -303,4 +303,16 @@ DEFINE_CRYPTO_API_STUB(crypto_register_kpp);DEFINE_CRYPTO_API_STUB (crypto_unregister_kpp);DEFINE_CRYPTO_API_STUB (kpp_register_instance); +#endif + +/* +* crypto/rsa_helper.c +*/ +#if IS_BUILTIN (CONFIG_CRYPTO_RSA ) + +#include <crypto/internal/rsa.h> + +DEFINE_CRYPTO_API_STUB (rsa_parse_pub_key); +DEFINE_CRYPTO_API_STUB (rsa_parse_priv_key); +#endif
crypto/rsa.c +2 -2
@@ -430,8 +430,8 @@ static void __exit rsa_exit(void)crypto_unregister_akcipher (&rsa); } -module_init (rsa_init); -module_exit (rsa_exit); +crypto_module_init (rsa_init); +crypto_module_exit (rsa_exit);MODULE_ALIAS_CRYPTO ("rsa" );MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("RSA generic algorithm" );
include/crypto/internal/rsa.h +3 -4
@@ -7,6 +7,7 @@*/ #ifndef _RSA_HELPER_#define _RSA_HELPER_ +#include <crypto/api.h> #include <linux/types.h> #include <crypto/akcipher.h>
@@ -48,11 +49,9 @@ struct rsa_key {size_t qinv_sz; }; -int rsa_parse_pub_key (struct rsa_key *rsa_key,const void *key, -unsigned int key_len); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_RSA, rsa_parse_pub_key, int, (struct rsa_key *rsa_key, const void *key, unsigned int key_len), (rsa_key, key, key_len)); -int rsa_parse_priv_key (struct rsa_key *rsa_key,const void *key, -unsigned int key_len); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_RSA, rsa_parse_priv_key, int, (struct rsa_key *rsa_key, const void *key, unsigned int key_len), (rsa_key, key, key_len));#define RSA_PUB (true)#define RSA_PRIV (false)
Signature · 1 line
2.47.3
PATCH 13/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_ACOMP2 crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_ACOMP2-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/fips140/fips140-api.c | 42 +++++++++++++++++++++++++++++ include/crypto/acompress.h | 14 +++++----- include/crypto/internal/acompress.h | 27 +++++++++---------- include/crypto/internal/scompress.h | 9 ++++--- 5 files changed, 67 insertions(+), 27 deletions(-)
crypto/Makefile +1 -1
@@ -66,7 +66,7 @@ obj-$(CONFIG_CRYPTO_MLDSA) += mldsa.o crypto_acompress-y := acompress.o crypto_acompress-y += scompress.o -obj-$(CONFIG_CRYPTO_ACOMP2) += crypto_acompress.o +crypto-objs-$(CONFIG_CRYPTO_ACOMP2) += crypto_acompress.o cryptomgr-y := algboss.o testmgr.o
crypto/fips140/fips140-api.c +42 -0
47 lines not on this page · raw message
include/crypto/acompress.h +6 -8
@@ -9,6 +9,7 @@#ifndef _CRYPTO_ACOMP_H#define _CRYPTO_ACOMP_H +#include <crypto/api.h> #include <linux/atomic.h> #include <linux/args.h> #include <linux/compiler_types.h>
@@ -143,8 +144,7 @@ struct comp_alg_common COMP_ALG_COMMON;* Return: allocated handle in case of success; IS_ERR() is true in case * of an error, PTR_ERR() returns the error code. */ -struct crypto_acomp *crypto_alloc_acomp (const char *alg_name,u32 type, -u32 mask); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_ACOMP2, crypto_alloc_acomp, struct crypto_acomp *, (const char *alg_name, u32 type, u32 mask), (alg_name, type, mask));/** * crypto_alloc_acomp_node() -- allocate ACOMPRESS tfm handle with desired NUMA node * @alg_name: is the cra_name / name or cra_driver_name / driver name of the
@@ -161,8 +161,7 @@ struct crypto_acomp *crypto_alloc_acomp(const char *alg_name, u32 type,* Return: allocated handle in case of success; IS_ERR() is true in case * of an error, PTR_ERR() returns the error code. */ -struct crypto_acomp *crypto_alloc_acomp_node (const char *alg_name,u32 type, -u32 mask,int node); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_ACOMP2, crypto_alloc_acomp_node, struct crypto_acomp *, (const char *alg_name, u32 type, u32 mask, int node), (alg_name, type, mask, node));static inline struct crypto_tfm *crypto_acomp_tfm (struct crypto_acomp *tfm) {
@@ -529,7 +528,7 @@ static inline void acomp_request_set_dst_folio(struct acomp_req *req,* * Return: zero on success; error code in case of error */ -int crypto_acomp_compress (struct acomp_req *req); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_ACOMP2, crypto_acomp_compress, int, (struct acomp_req *req), (req));/** * crypto_acomp_decompress() -- Invoke asynchronous decompress operation
@@ -540,7 +539,7 @@ int crypto_acomp_compress(struct acomp_req *req);* * Return: zero on success; error code in case of error */ -int crypto_acomp_decompress (struct acomp_req *req); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_ACOMP2, crypto_acomp_decompress, int, (struct acomp_req *req), (req));static inline struct acomp_req *acomp_request_on_stack_init (char *buf,struct crypto_acomp *tfm)
@@ -551,7 +550,6 @@ static inline struct acomp_req *acomp_request_on_stack_init(return req; } -struct acomp_req *acomp_request_clone (struct acomp_req *req, -size_t total,gfp_t gfp); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_ACOMP2, acomp_request_clone, struct acomp_req *, (struct acomp_req *req, size_t total, gfp_t gfp), (req, total, gfp));#endif
include/crypto/internal/acompress.h +13 -14
@@ -9,6 +9,7 @@#ifndef _CRYPTO_ACOMP_INT_H#define _CRYPTO_ACOMP_INT_H +#include <crypto/api.h> #include <crypto/acompress.h> #include <crypto/algapi.h> #include <crypto/scatterwalk.h>
@@ -130,7 +131,7 @@ static inline void acomp_request_complete(struct acomp_req *req,* * Return: zero on success; error code in case of error */ -int crypto_register_acomp (struct acomp_alg *alg); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_ACOMP2, crypto_register_acomp, int, (struct acomp_alg *alg), (alg));/** * crypto_unregister_acomp() -- Unregister asynchronous compression algorithm
@@ -140,10 +141,10 @@ int crypto_register_acomp(struct acomp_alg *alg);* * @alg: algorithm definition */ -void crypto_unregister_acomp (struct acomp_alg *alg); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_ACOMP2, crypto_unregister_acomp, void, (struct acomp_alg *alg), (alg)); -int crypto_register_acomps (struct acomp_alg *algs,int count); -void crypto_unregister_acomps (struct acomp_alg *algs,int count); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_ACOMP2, crypto_register_acomps, int, (struct acomp_alg *algs, int count), (algs, count)); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_ACOMP2, crypto_unregister_acomps, void, (struct acomp_alg *algs, int count), (algs, count));static inline bool acomp_request_issg (struct acomp_req *req) {
@@ -188,12 +189,11 @@ static inline bool crypto_acomp_req_virt(struct crypto_acomp *tfm)return crypto_tfm_req_virt (&tfm->base); } -void crypto_acomp_free_streams (struct crypto_acomp_streams *s); -int crypto_acomp_alloc_streams (struct crypto_acomp_streams *s); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_ACOMP2, crypto_acomp_free_streams, void, (struct crypto_acomp_streams *s), (s)); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_ACOMP2, crypto_acomp_alloc_streams, int, (struct crypto_acomp_streams *s), (s));#define crypto_acomp_lock_stream_bh (...) __acquire_ret(_crypto_acomp_lock_stream_bh(__VA_ARGS__), &__ret->lock); -struct crypto_acomp_stream *_crypto_acomp_lock_stream_bh ( -struct crypto_acomp_streams *s) __acquires_ret; +DECLARE_CRYPTO_API(CONFIG_CRYPTO_ACOMP2, _crypto_acomp_lock_stream_bh, struct crypto_acomp_stream *, (struct crypto_acomp_streams *s), (s)) __acquires_ret; static inline void crypto_acomp_unlock_stream_bh( struct crypto_acomp_stream *stream) __releases(&stream->lock)
@@ -201,12 +201,11 @@ static inline void crypto_acomp_unlock_stream_bh(spin_unlock_bh (&stream->lock); } -void acomp_walk_done_src (struct acomp_walk *walk,int used); -void acomp_walk_done_dst (struct acomp_walk *walk,int used); -int acomp_walk_next_src (struct acomp_walk *walk); -int acomp_walk_next_dst (struct acomp_walk *walk); -int acomp_walk_virt (struct acomp_walk *__restrict walk, -struct acomp_req *__restrict req,bool atomic); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_ACOMP2, acomp_walk_done_src, void, (struct acomp_walk *walk, int used), (walk, used)); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_ACOMP2, acomp_walk_done_dst, void, (struct acomp_walk *walk, int used), (walk, used)); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_ACOMP2, acomp_walk_next_src, int, (struct acomp_walk *walk), (walk)); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_ACOMP2, acomp_walk_next_dst, int, (struct acomp_walk *walk), (walk)); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_ACOMP2, acomp_walk_virt, int, (struct acomp_walk *walk, struct acomp_req *req, bool atomic), (walk, req, atomic));static inline bool acomp_walk_more_src (const struct acomp_walk *walk,int cur) {
include/crypto/internal/scompress.h +5 -4
@@ -9,6 +9,7 @@#ifndef _CRYPTO_SCOMP_INT_H#define _CRYPTO_SCOMP_INT_H +#include <crypto/api.h> #include <crypto/internal/acompress.h> struct crypto_scomp {
@@ -90,7 +91,7 @@ static inline int crypto_scomp_decompress(struct crypto_scomp *tfm,* * Return: zero on success; error code in case of error */ -int crypto_register_scomp (struct scomp_alg *alg); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_ACOMP2, crypto_register_scomp, int, (struct scomp_alg *alg), (alg));/** * crypto_unregister_scomp() -- Unregister synchronous compression algorithm
@@ -100,9 +101,9 @@ int crypto_register_scomp(struct scomp_alg *alg);* * @alg: algorithm definition */ -void crypto_unregister_scomp (struct scomp_alg *alg); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_ACOMP2, crypto_unregister_scomp, void, (struct scomp_alg *alg), (alg)); -int crypto_register_scomps (struct scomp_alg *algs,int count); -void crypto_unregister_scomps (struct scomp_alg *algs,int count); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_ACOMP2, crypto_register_scomps, int, (struct scomp_alg *algs, int count), (algs, count)); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_ACOMP2, crypto_unregister_scomps, void, (struct scomp_alg *algs, int count), (algs, count));#endif
Signature · 1 line
2.47.3
PATCH 14/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_MANAGER2 crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_MANAGER2-related crypto to convert them into pluggable interface.
This patch is partially based on work by Vegard Nossum, with modifications. Unlike the original, we do not include DEFINE_CRYPTO_API since only one copy of the crypto symbols is kept, either in the crypto module or in the main kernel, and we ensure such wrapper do not have impact on crypto already chosen built as module.
--- crypto/Makefile | 2 +- crypto/algboss.c | 4 ++-- crypto/fips140/fips140-api.c | 11 +++++++++++ crypto/internal.h | 3 ++- 4 files changed, 16 insertions(+), 4 deletions(-)
crypto/Makefile +1 -1
@@ -70,7 +70,7 @@ crypto-objs-$(CONFIG_CRYPTO_ACOMP2) += crypto_acompress.o cryptomgr-y := algboss.o testmgr.o -obj-$(CONFIG_CRYPTO_MANAGER2) += cryptomgr.o +crypto-objs-$(CONFIG_CRYPTO_MANAGER2) += cryptomgr.o obj-$(CONFIG_CRYPTO_USER) += crypto_user.o obj-$(CONFIG_CRYPTO_CMAC) += cmac.o obj-$(CONFIG_CRYPTO_HMAC) += hmac.o
crypto/algboss.c +2 -2
@@ -247,8 +247,8 @@ static void __exit cryptomgr_exit(void)BUG_ON (err); } -module_init (cryptomgr_init); -module_exit (cryptomgr_exit); +crypto_module_init (cryptomgr_init); +crypto_module_exit (cryptomgr_exit);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("Crypto Algorithm Manager" );
crypto/fips140/fips140-api.c +11 -0
@@ -357,4 +357,15 @@ DEFINE_CRYPTO_API_STUB(crypto_unregister_scomp);DEFINE_CRYPTO_API_STUB (crypto_register_scomps);DEFINE_CRYPTO_API_STUB (crypto_unregister_scomps); +#endif + +/* +* crypto/testmgr.c +*/ +#if IS_BUILTIN (CONFIG_CRYPTO_MANAGER2 ) + +#include <crypto/internal.h> + +DEFINE_CRYPTO_API_STUB (alg_test); +#endif
crypto/internal.h +2 -1
@@ -8,6 +8,7 @@#ifndef _CRYPTO_INTERNAL_H#define _CRYPTO_INTERNAL_H +#include <crypto/api.h> #include <crypto/algapi.h> #include <linux/completion.h> #include <linux/err.h>
@@ -65,7 +66,7 @@ extern struct rw_semaphore crypto_alg_sem; extern struct list_head crypto_alg_list __guarded_by(&crypto_alg_sem);extern struct blocking_notifier_head crypto_chain; -int alg_test (const char *driver,const char *alg,u32 type,u32 mask); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_MANAGER2, alg_test, int, (const char *driver, const char *alg, u32 type, u32 mask), (driver, alg, type, mask));#if !IS_BUILTIN (CONFIG_CRYPTO_ALGAPI ) || !IS_ENABLED (CONFIG_CRYPTO_SELFTESTS )static inline bool crypto_boot_test_finished (void )
Signature · 1 line
2.47.3
PATCH 15/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_CMAC crypto
In reply to Jay WangFrom: Vegard Nossum <[email protected]>
Apply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_CMAC-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/cmac.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -72,7 +72,7 @@ cryptomgr-y := algboss.o testmgr.o crypto-objs-$(CONFIG_CRYPTO_MANAGER2) += cryptomgr.o obj-$(CONFIG_CRYPTO_USER) += crypto_user.o -obj-$(CONFIG_CRYPTO_CMAC) += cmac.o +crypto-objs-$(CONFIG_CRYPTO_CMAC) += cmac.o obj-$(CONFIG_CRYPTO_HMAC) += hmac.o obj-$(CONFIG_CRYPTO_XCBC) += xcbc.o obj-$(CONFIG_CRYPTO_NULL) += crypto_null.o
crypto/cmac.c +2 -2
@@ -251,8 +251,8 @@ static void __exit crypto_cmac_module_exit(void)crypto_unregister_template (&crypto_cmac_tmpl); } -module_init (crypto_cmac_module_init); -module_exit (crypto_cmac_module_exit); +crypto_module_init (crypto_cmac_module_init); +crypto_module_exit (crypto_cmac_module_exit);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("CMAC keyed hash algorithm" );
Signature · 1 line
2.47.3
PATCH 16/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_HMAC crypto
In reply to Jay WangFrom: Vegard Nossum <[email protected]>
Apply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_HMAC-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/hmac.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -73,7 +73,7 @@ cryptomgr-y := algboss.o testmgr.o crypto-objs-$(CONFIG_CRYPTO_MANAGER2) += cryptomgr.o obj-$(CONFIG_CRYPTO_USER) += crypto_user.o crypto-objs-$(CONFIG_CRYPTO_CMAC) += cmac.o -obj-$(CONFIG_CRYPTO_HMAC) += hmac.o +crypto-objs-$(CONFIG_CRYPTO_HMAC) += hmac.o obj-$(CONFIG_CRYPTO_XCBC) += xcbc.o obj-$(CONFIG_CRYPTO_NULL) += crypto_null.o obj-$(CONFIG_CRYPTO_MD4) += md4.o
crypto/hmac.c +2 -2
@@ -573,8 +573,8 @@ static void __exit hmac_module_exit(void)crypto_unregister_templates (hmac_tmpls,ARRAY_SIZE (hmac_tmpls)); } -module_init (hmac_module_init); -module_exit (hmac_module_exit); +crypto_module_init (hmac_module_init); +crypto_module_exit (hmac_module_exit);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("HMAC hash algorithm" );
Signature · 1 line
2.47.3
PATCH 17/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_MD5 crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_MD5-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/fips140/fips140-api.c | 11 +++++++++++ crypto/md5.c | 4 ++-- include/crypto/md5.h | 8 +++++++- 4 files changed, 21 insertions(+), 4 deletions(-)
crypto/Makefile +1 -1
@@ -77,7 +77,7 @@ crypto-objs-$(CONFIG_CRYPTO_HMAC) += hmac.o obj-$(CONFIG_CRYPTO_XCBC) += xcbc.o obj-$(CONFIG_CRYPTO_NULL) += crypto_null.o obj-$(CONFIG_CRYPTO_MD4) += md4.o -obj-$(CONFIG_CRYPTO_MD5) += md5.o +crypto-objs-$(CONFIG_CRYPTO_MD5) += md5.o obj-$(CONFIG_CRYPTO_RMD160) += rmd160.o obj-$(CONFIG_CRYPTO_SHA1) += sha1.o obj-$(CONFIG_CRYPTO_SHA256) += sha256.o
crypto/fips140/fips140-api.c +11 -0
@@ -368,4 +368,15 @@ DEFINE_CRYPTO_API_STUB(crypto_unregister_scomps);DEFINE_CRYPTO_API_STUB (alg_test); +#endif + +/* +* crypto/md5.c +*/ +#if IS_BUILTIN (CONFIG_CRYPTO_MD5 ) + +#include <crypto/md5.h> + +#undef md5_zero_message_hash +DEFINE_CRYPTO_VAR_STUB (md5_zero_message_hash);#endif
crypto/md5.c +2 -2
@@ -219,13 +219,13 @@ static int __init crypto_md5_mod_init(void) {return crypto_register_shashes (algs,ARRAY_SIZE (algs)); } -module_init (crypto_md5_mod_init); +crypto_module_init (crypto_md5_mod_init); static void __exit crypto_md5_mod_exit(void) {crypto_unregister_shashes (algs,ARRAY_SIZE (algs)); } -module_exit (crypto_md5_mod_exit); +crypto_module_exit (crypto_md5_mod_exit);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("Crypto API support for MD5 and HMAC-MD5" );
include/crypto/md5.h +7 -1
@@ -2,6 +2,7 @@#ifndef _CRYPTO_MD5_H#define _CRYPTO_MD5_H +#include <crypto/api.h> #include <crypto/hash.h> #include <linux/types.h>
@@ -20,7 +21,12 @@#define CRYPTO_MD5_STATESIZE \ CRYPTO_HASH_STATESIZE(MD5_STATE_SIZE, MD5_HMAC_BLOCK_SIZE) -extern const u8 md5_zero_message_hash[MD5_DIGEST_SIZE ]; +DECLARE_CRYPTO_VAR(CONFIG_CRYPTO_MD5, md5_zero_message_hash, const u8, [MD5_DIGEST_SIZE]); + +#if defined(CONFIG_CRYPTO_FIPS140_EXTMOD ) && !defined(FIPS_MODULE ) &&IS_BUILTIN (CONFIG_CRYPTO_MD5 ) +#define md5_zero_message_hash (((const u8*)CRYPTO_VAR_NAME(md5_zero_message_hash))) +#endif +struct md5_state {u32 hash[MD5_HASH_WORDS ];
Signature · 1 line
2.47.3
PATCH 18/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_SHA256 crypto
In reply to Jay WangFrom: Vegard Nossum <[email protected]>
Apply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_SHA256-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/sha256.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -80,7 +80,7 @@ obj-$(CONFIG_CRYPTO_MD4) += md4.o crypto-objs-$(CONFIG_CRYPTO_MD5) += md5.o obj-$(CONFIG_CRYPTO_RMD160) += rmd160.o obj-$(CONFIG_CRYPTO_SHA1) += sha1.o -obj-$(CONFIG_CRYPTO_SHA256) += sha256.o +crypto-objs-$(CONFIG_CRYPTO_SHA256) += sha256.o obj-$(CONFIG_CRYPTO_SHA512) += sha512.o obj-$(CONFIG_CRYPTO_SHA3) += sha3.o obj-$(CONFIG_CRYPTO_SM3_GENERIC) += sm3_generic.o
crypto/sha256.c +2 -2
@@ -398,13 +398,13 @@ static int __init crypto_sha256_mod_init(void) {return crypto_register_shashes (algs,ARRAY_SIZE (algs)); } -module_init (crypto_sha256_mod_init); +crypto_module_init (crypto_sha256_mod_init); static void __exit crypto_sha256_mod_exit(void) {crypto_unregister_shashes (algs,ARRAY_SIZE (algs)); } -module_exit (crypto_sha256_mod_exit); +crypto_module_exit (crypto_sha256_mod_exit);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("Crypto API support for SHA-224, SHA-256, HMAC-SHA224, and HMAC-SHA256" );
Signature · 1 line
2.47.3
PATCH 19/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_SHA512 crypto
In reply to Jay WangFrom: Vegard Nossum <[email protected]>
Apply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_SHA512-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/sha512.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -81,7 +81,7 @@ crypto-objs-$(CONFIG_CRYPTO_MD5) += md5.o obj-$(CONFIG_CRYPTO_RMD160) += rmd160.o obj-$(CONFIG_CRYPTO_SHA1) += sha1.o crypto-objs-$(CONFIG_CRYPTO_SHA256) += sha256.o -obj-$(CONFIG_CRYPTO_SHA512) += sha512.o +crypto-objs-$(CONFIG_CRYPTO_SHA512) += sha512.o obj-$(CONFIG_CRYPTO_SHA3) += sha3.o obj-$(CONFIG_CRYPTO_SM3_GENERIC) += sm3_generic.o obj-$(CONFIG_CRYPTO_STREEBOG) += streebog_generic.o
crypto/sha512.c +2 -2
@@ -404,13 +404,13 @@ static int __init crypto_sha512_mod_init(void) {return crypto_register_shashes (algs,ARRAY_SIZE (algs)); } -module_init (crypto_sha512_mod_init); +crypto_module_init (crypto_sha512_mod_init); static void __exit crypto_sha512_mod_exit(void) {crypto_unregister_shashes (algs,ARRAY_SIZE (algs)); } -module_exit (crypto_sha512_mod_exit); +crypto_module_exit (crypto_sha512_mod_exit);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("Crypto API support for SHA-384, SHA-512, HMAC-SHA384, and HMAC-SHA512" );
Signature · 1 line
2.47.3
PATCH 20/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_SHA3 crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_SHA3-related crypto to convert them into pluggable interface.
This patch is partially based on work by Vegard Nossum, with modifications. Unlike the original, we do not include DEFINE_CRYPTO_API since only one copy of the crypto symbols is kept, either in the crypto module or in the main kernel, and we ensure such wrapper do not have impact on crypto already chosen built as module.
--- crypto/Makefile | 2 +- crypto/sha3.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -82,7 +82,7 @@ obj-$(CONFIG_CRYPTO_RMD160) += rmd160.o obj-$(CONFIG_CRYPTO_SHA1) += sha1.o crypto-objs-$(CONFIG_CRYPTO_SHA256) += sha256.o crypto-objs-$(CONFIG_CRYPTO_SHA512) += sha512.o -obj-$(CONFIG_CRYPTO_SHA3) += sha3.o +crypto-objs-$(CONFIG_CRYPTO_SHA3) += sha3.o obj-$(CONFIG_CRYPTO_SM3_GENERIC) += sm3_generic.o obj-$(CONFIG_CRYPTO_STREEBOG) += streebog_generic.o obj-$(CONFIG_CRYPTO_WP512) += wp512.o
crypto/sha3.c +2 -2
@@ -145,13 +145,13 @@ static int __init crypto_sha3_mod_init(void) {return crypto_register_shashes (algs,ARRAY_SIZE (algs)); } -module_init (crypto_sha3_mod_init); +crypto_module_init (crypto_sha3_mod_init); static void __exit crypto_sha3_mod_exit(void) {crypto_unregister_shashes (algs,ARRAY_SIZE (algs)); } -module_exit (crypto_sha3_mod_exit); +crypto_module_exit (crypto_sha3_mod_exit);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("Crypto API support for SHA-3" );
Signature · 1 line
2.47.3
PATCH 21/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_ECB crypto
In reply to Jay WangFrom: Vegard Nossum <[email protected]>
Apply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_ECB-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/ecb.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -88,7 +88,7 @@ obj-$(CONFIG_CRYPTO_STREEBOG) += streebog_generic.o obj-$(CONFIG_CRYPTO_WP512) += wp512.o CFLAGS_wp512.o := $(call cc-option,-fno-schedule-insns) # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79149 obj-$(CONFIG_CRYPTO_BLAKE2B) += blake2b.o -obj-$(CONFIG_CRYPTO_ECB) += ecb.o +crypto-objs-$(CONFIG_CRYPTO_ECB) += ecb.o obj-$(CONFIG_CRYPTO_CBC) += cbc.o obj-$(CONFIG_CRYPTO_PCBC) += pcbc.o obj-$(CONFIG_CRYPTO_CTS) += cts.o
crypto/ecb.c +2 -2
@@ -219,8 +219,8 @@ static void __exit crypto_ecb_module_exit(void)crypto_unregister_template (&crypto_ecb_tmpl); } -module_init (crypto_ecb_module_init); -module_exit (crypto_ecb_module_exit); +crypto_module_init (crypto_ecb_module_init); +crypto_module_exit (crypto_ecb_module_exit);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("ECB block cipher mode of operation" );
Signature · 1 line
2.47.3
PATCH 22/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_CBC crypto
In reply to Jay WangFrom: Vegard Nossum <[email protected]>
Apply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_CBC-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/cbc.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -89,7 +89,7 @@ obj-$(CONFIG_CRYPTO_WP512) += wp512.o CFLAGS_wp512.o := $(call cc-option,-fno-schedule-insns) # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79149 obj-$(CONFIG_CRYPTO_BLAKE2B) += blake2b.o crypto-objs-$(CONFIG_CRYPTO_ECB) += ecb.o -obj-$(CONFIG_CRYPTO_CBC) += cbc.o +crypto-objs-$(CONFIG_CRYPTO_CBC) += cbc.o obj-$(CONFIG_CRYPTO_PCBC) += pcbc.o obj-$(CONFIG_CRYPTO_CTS) += cts.o obj-$(CONFIG_CRYPTO_LRW) += lrw.o
crypto/cbc.c +2 -2
@@ -179,8 +179,8 @@ static void __exit crypto_cbc_module_exit(void)crypto_unregister_template (&crypto_cbc_tmpl); } -module_init (crypto_cbc_module_init); -module_exit (crypto_cbc_module_exit); +crypto_module_init (crypto_cbc_module_init); +crypto_module_exit (crypto_cbc_module_exit);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("CBC block cipher mode of operation" );
Signature · 1 line
2.47.3
PATCH 23/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_CTR crypto
In reply to Jay WangFrom: Vegard Nossum <[email protected]>
Apply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_CTR-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/ctr.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -94,7 +94,7 @@ obj-$(CONFIG_CRYPTO_PCBC) += pcbc.o obj-$(CONFIG_CRYPTO_CTS) += cts.o obj-$(CONFIG_CRYPTO_LRW) += lrw.o obj-$(CONFIG_CRYPTO_XTS) += xts.o -obj-$(CONFIG_CRYPTO_CTR) += ctr.o +crypto-objs-$(CONFIG_CRYPTO_CTR) += ctr.o obj-$(CONFIG_CRYPTO_XCTR) += xctr.o obj-$(CONFIG_CRYPTO_HCTR2) += hctr2.o obj-$(CONFIG_CRYPTO_ADIANTUM) += adiantum.o
crypto/ctr.c +2 -2
@@ -350,8 +350,8 @@ static void __exit crypto_ctr_module_exit(void) ARRAY_SIZE(crypto_ctr_tmpls)); } -module_init (crypto_ctr_module_init); -module_exit (crypto_ctr_module_exit); +crypto_module_init (crypto_ctr_module_init); +crypto_module_exit (crypto_ctr_module_exit);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("CTR block cipher mode of operation" );
Signature · 1 line
2.47.3
PATCH 24/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_GCM crypto
In reply to Jay WangFrom: Vegard Nossum <[email protected]>
Apply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_GCM-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/gcm.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -98,7 +98,7 @@ crypto-objs-$(CONFIG_CRYPTO_CTR) += ctr.o obj-$(CONFIG_CRYPTO_XCTR) += xctr.o obj-$(CONFIG_CRYPTO_HCTR2) += hctr2.o obj-$(CONFIG_CRYPTO_ADIANTUM) += adiantum.o -obj-$(CONFIG_CRYPTO_GCM) += gcm.o +crypto-objs-$(CONFIG_CRYPTO_GCM) += gcm.o obj-$(CONFIG_CRYPTO_CCM) += ccm.o obj-$(CONFIG_CRYPTO_CHACHA20POLY1305) += chacha20poly1305.o obj-$(CONFIG_CRYPTO_AEGIS128) += aegis128.o
crypto/gcm.c +2 -2
@@ -1119,8 +1119,8 @@ static void __exit crypto_gcm_module_exit(void) ARRAY_SIZE(crypto_gcm_tmpls)); } -module_init (crypto_gcm_module_init); -module_exit (crypto_gcm_module_exit); +crypto_module_init (crypto_gcm_module_init); +crypto_module_exit (crypto_gcm_module_exit);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("Galois/Counter Mode" );
Signature · 1 line
2.47.3
PATCH 25/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_CCM crypto
In reply to Jay WangFrom: Vegard Nossum <[email protected]>
Apply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_CCM-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/ccm.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -99,7 +99,7 @@ obj-$(CONFIG_CRYPTO_XCTR) += xctr.o obj-$(CONFIG_CRYPTO_HCTR2) += hctr2.o obj-$(CONFIG_CRYPTO_ADIANTUM) += adiantum.o crypto-objs-$(CONFIG_CRYPTO_GCM) += gcm.o -obj-$(CONFIG_CRYPTO_CCM) += ccm.o +crypto-objs-$(CONFIG_CRYPTO_CCM) += ccm.o obj-$(CONFIG_CRYPTO_CHACHA20POLY1305) += chacha20poly1305.o obj-$(CONFIG_CRYPTO_AEGIS128) += aegis128.o aegis128-y := aegis128-core.o
crypto/ccm.c +2 -2
@@ -929,8 +929,8 @@ static void __exit crypto_ccm_module_exit(void) ARRAY_SIZE(crypto_ccm_tmpls)); } -module_init (crypto_ccm_module_init); -module_exit (crypto_ccm_module_exit); +crypto_module_init (crypto_ccm_module_init); +crypto_module_exit (crypto_ccm_module_exit);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("Counter with CBC MAC" );
Signature · 1 line
2.47.3
PATCH 26/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_AUTHENC crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_AUTHENC-related crypto to convert them into pluggable interface.
This patch is partially based on work by Vegard Nossum, with modifications. Unlike the original, we do not include DEFINE_CRYPTO_API since only one copy of the crypto symbols is kept, either in the crypto module or in the main kernel, and we ensure such wrapper do not have impact on crypto already chosen built as module.
--- crypto/Makefile | 2 +- crypto/authenc.c | 4 ++-- crypto/authencesn.c | 4 ++-- crypto/fips140/fips140-api.c | 12 ++++++++++++ include/crypto/authenc.h | 6 ++++-- 5 files changed, 21 insertions(+), 7 deletions(-)
crypto/Makefile +1 -1
@@ -155,7 +155,7 @@ obj-$(CONFIG_CRYPTO_CRC32C) += crc32c-cryptoapi.o crc32c-cryptoapi-y := crc32c.o obj-$(CONFIG_CRYPTO_CRC32) += crc32-cryptoapi.o crc32-cryptoapi-y := crc32.o -obj-$(CONFIG_CRYPTO_AUTHENC) += authenc.o authencesn.o +crypto-objs-$(CONFIG_CRYPTO_AUTHENC) += authenc.o authencesn.o obj-$(CONFIG_CRYPTO_KRB5ENC) += krb5enc.o obj-$(CONFIG_CRYPTO_LZO) += lzo.o lzo-rle.o obj-$(CONFIG_CRYPTO_LZ4) += lz4.o
crypto/authenc.c +2 -2
@@ -446,8 +446,8 @@ static void __exit crypto_authenc_module_exit(void)crypto_unregister_template (&crypto_authenc_tmpl); } -module_init (crypto_authenc_module_init); -module_exit (crypto_authenc_module_exit); +crypto_module_init (crypto_authenc_module_init); +crypto_module_exit (crypto_authenc_module_exit);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("Simple AEAD wrapper for IPsec" );
crypto/authencesn.c +2 -2
@@ -439,8 +439,8 @@ static void __exit crypto_authenc_esn_module_exit(void)crypto_unregister_template (&crypto_authenc_esn_tmpl); } -module_init (crypto_authenc_esn_module_init); -module_exit (crypto_authenc_esn_module_exit); +crypto_module_init (crypto_authenc_esn_module_init); +crypto_module_exit (crypto_authenc_esn_module_exit);MODULE_LICENSE ("GPL" );MODULE_AUTHOR ("Steffen Klassert <[email protected]>" );
crypto/fips140/fips140-api.c +12 -0
@@ -379,4 +379,16 @@ DEFINE_CRYPTO_API_STUB(alg_test);#undef md5_zero_message_hashDEFINE_CRYPTO_VAR_STUB (md5_zero_message_hash); + +#endif + +/* +* crypto/authenc.c +*/ +#if IS_BUILTIN (CONFIG_CRYPTO_AUTHENC ) + +#include <crypto/authenc.h> + +DEFINE_CRYPTO_API_STUB (crypto_authenc_extractkeys); +#endif
include/crypto/authenc.h +4 -2
@@ -7,6 +7,7 @@#ifndef _CRYPTO_AUTHENC_H#define _CRYPTO_AUTHENC_H +#include <crypto/api.h> #include <linux/types.h> enum {
@@ -26,8 +27,9 @@ struct crypto_authenc_keys {unsigned int enckeylen; }; -int crypto_authenc_extractkeys (struct crypto_authenc_keys *keys,const u8 *key, -unsigned int keylen); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_AUTHENC , crypto_authenc_extractkeys, int, + (struct crypto_authenc_keys *keys, const u8 *key, unsigned int keylen), + (keys, key, keylen));int crypto_krb5enc_extractkeys (struct crypto_authenc_keys *keys,const u8 *key,unsigned int keylen);
Signature · 1 line
2.47.3
PATCH 27/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_LZO crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_LZO-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/lzo-rle.c | 4 ++-- crypto/lzo.c | 4 ++-- 3 files changed, 5 insertions(+), 5 deletions(-)
crypto/Makefile +1 -1
@@ -157,7 +157,7 @@ obj-$(CONFIG_CRYPTO_CRC32) += crc32-cryptoapi.o crc32-cryptoapi-y := crc32.o crypto-objs-$(CONFIG_CRYPTO_AUTHENC) += authenc.o authencesn.o obj-$(CONFIG_CRYPTO_KRB5ENC) += krb5enc.o -obj-$(CONFIG_CRYPTO_LZO) += lzo.o lzo-rle.o +crypto-objs-$(CONFIG_CRYPTO_LZO) += lzo.o lzo-rle.o obj-$(CONFIG_CRYPTO_LZ4) += lz4.o obj-$(CONFIG_CRYPTO_LZ4HC) += lz4hc.o obj-$(CONFIG_CRYPTO_XXHASH) += xxhash_generic.o
crypto/lzo-rle.c +2 -2
@@ -93,8 +93,8 @@ static void __exit lzorle_mod_fini(void)crypto_unregister_scomp (&scomp); } -module_init (lzorle_mod_init); -module_exit (lzorle_mod_fini); +crypto_module_init (lzorle_mod_init); +crypto_module_exit (lzorle_mod_fini);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("LZO-RLE Compression Algorithm" );
crypto/lzo.c +2 -2
@@ -93,8 +93,8 @@ static void __exit lzo_mod_fini(void)crypto_unregister_scomp (&scomp); } -module_init (lzo_mod_init); -module_exit (lzo_mod_fini); +crypto_module_init (lzo_mod_init); +crypto_module_exit (lzo_mod_fini);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("LZO Compression Algorithm" );
Signature · 1 line
2.47.3
PATCH 28/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_RNG2 crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_RNG2-related crypto to convert them into pluggable interface.
This patch is partially based on work by Vegard Nossum, with modifications. Unlike the original, we do not include DEFINE_CRYPTO_API since only one copy of the crypto symbols is kept, either in the crypto module or in the main kernel, and we ensure such wrapper do not have impact on crypto already chosen built as module.
--- crypto/Makefile | 2 +- crypto/fips140/fips140-api.c | 23 ++++++++++++++++++++++- include/crypto/internal/rng.h | 21 ++++++++++++++++----- include/crypto/rng.h | 18 +++++++++++++----- 4 files changed, 52 insertions(+), 12 deletions(-)
crypto/Makefile +1 -1
@@ -162,7 +162,7 @@ obj-$(CONFIG_CRYPTO_LZ4) += lz4.o obj-$(CONFIG_CRYPTO_LZ4HC) += lz4hc.o obj-$(CONFIG_CRYPTO_XXHASH) += xxhash_generic.o obj-$(CONFIG_CRYPTO_842) += 842.o -obj-$(CONFIG_CRYPTO_RNG2) += rng.o +crypto-objs-$(CONFIG_CRYPTO_RNG2) += rng.o obj-$(CONFIG_CRYPTO_DRBG) += drbg.o obj-$(CONFIG_CRYPTO_JITTERENTROPY) += jitterentropy_rng.o CFLAGS_jitterentropy.o = -O0
crypto/fips140/fips140-api.c +22 -1
@@ -391,4 +391,25 @@ DEFINE_CRYPTO_VAR_STUB(md5_zero_message_hash);DEFINE_CRYPTO_API_STUB (crypto_authenc_extractkeys); -#endif +#endif +/* +* crypto/rng.c +*/ +#if IS_BUILTIN (CONFIG_CRYPTO_RNG2 ) + +#include <crypto/rng.h> + +DEFINE_CRYPTO_API_STUB (crypto_get_default_rng); +DEFINE_CRYPTO_API_STUB (crypto_put_default_rng); +DEFINE_CRYPTO_API_STUB (crypto_alloc_rng); +DEFINE_CRYPTO_API_STUB (crypto_rng_reset); + +#include <crypto/internal/rng.h> + +DEFINE_CRYPTO_API_STUB (crypto_register_rng); +DEFINE_CRYPTO_API_STUB (crypto_unregister_rng); +DEFINE_CRYPTO_API_STUB (crypto_register_rngs); +DEFINE_CRYPTO_API_STUB (crypto_unregister_rngs); +DEFINE_CRYPTO_API_STUB (crypto_del_default_rng); + +#endif
include/crypto/internal/rng.h +16 -5
@@ -9,16 +9,27 @@ #ifndef _CRYPTO_INTERNAL_RNG_H #define _CRYPTO_INTERNAL_RNG_H +#include <crypto/api.h> #include <crypto/algapi.h> #include <crypto/rng.h> -int crypto_register_rng(struct rng_alg *alg); -void crypto_unregister_rng(struct rng_alg *alg); -int crypto_register_rngs(struct rng_alg *algs, int count); -void crypto_unregister_rngs(struct rng_alg *algs, int count); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_RNG2, crypto_register_rng, int, + (struct rng_alg *alg), + (alg)); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_RNG2, crypto_unregister_rng, void, + (struct rng_alg *alg), + (alg)); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_RNG2, crypto_register_rngs, int, + (struct rng_alg *algs, int count), + (algs, count)); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_RNG2, crypto_unregister_rngs, void, + (struct rng_alg *algs, int count), + (algs, count)); #if defined(CONFIG_CRYPTO_RNG) || defined(CONFIG_CRYPTO_RNG_MODULE) -int crypto_del_default_rng(void); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_RNG2, crypto_del_default_rng, int, + (void), + ()); #else static inline int crypto_del_default_rng(void) {
include/crypto/rng.h +13 -5
@@ -9,6 +9,7 @@#ifndef _CRYPTO_RNG_H#define _CRYPTO_RNG_H +#include <crypto/api.h> #include <linux/atomic.h> #include <linux/container_of.h> #include <linux/crypto.h>
@@ -59,8 +60,12 @@ struct crypto_rng {extern struct crypto_rng *crypto_default_rng; -int crypto_get_default_rng (void ); -void crypto_put_default_rng (void ); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_RNG2 , crypto_get_default_rng, int, + (void), + ()); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_RNG2 , crypto_put_default_rng, void, + (void), + ());/** * DOC: Random number generator API
@@ -89,7 +94,9 @@ void crypto_put_default_rng(void);* Return: allocated cipher handle in case of success; IS_ERR() is true in case * of an error, PTR_ERR() returns the error code. */ -struct crypto_rng *crypto_alloc_rng (const char *alg_name,u32 type,u32 mask); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_RNG2, crypto_alloc_rng, struct crypto_rng *, + (const char *alg_name, u32 type, u32 mask), + (alg_name, type, mask));static inline struct crypto_tfm *crypto_rng_tfm (struct crypto_rng *tfm) {
@@ -177,8 +184,9 @@ static inline int crypto_rng_get_bytes(struct crypto_rng *tfm,* * Return: 0 if the setting of the key was successful; < 0 if an error occurred */ -int crypto_rng_reset (struct crypto_rng *tfm,const u8 *seed, -unsigned int slen); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_RNG2 , crypto_rng_reset, int, + (struct crypto_rng *tfm, const u8 *seed, unsigned int slen), + (tfm, seed, slen));/** * crypto_rng_seedsize() - obtain seed size of RNG
Signature · 1 line
2.47.3
PATCH 29/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_DRBG crypto
In reply to Jay WangFrom: Vegard Nossum <[email protected]>
Apply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_DRBG-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/drbg.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -163,7 +163,7 @@ obj-$(CONFIG_CRYPTO_LZ4HC) += lz4hc.o obj-$(CONFIG_CRYPTO_XXHASH) += xxhash_generic.o obj-$(CONFIG_CRYPTO_842) += 842.o crypto-objs-$(CONFIG_CRYPTO_RNG2) += rng.o -obj-$(CONFIG_CRYPTO_DRBG) += drbg.o +crypto-objs-$(CONFIG_CRYPTO_DRBG) += drbg.o obj-$(CONFIG_CRYPTO_JITTERENTROPY) += jitterentropy_rng.o CFLAGS_jitterentropy.o = -O0 KASAN_SANITIZE_jitterentropy.o = n
crypto/drbg.c +2 -2
@@ -1882,8 +1882,8 @@ static void __exit drbg_exit(void)crypto_unregister_rngs (drbg_algs, (ARRAY_SIZE (drbg_cores) *2 )); } -module_init (drbg_init); -module_exit (drbg_exit); +crypto_module_init (drbg_init); +crypto_module_exit (drbg_exit);#ifndef CRYPTO_DRBG_HASH_STRING #define CRYPTO_DRBG_HASH_STRING ""#endif
Signature · 1 line
2.47.3
PATCH 30/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_JITTERENTROPY crypto
In reply to Jay WangFrom: Vegard Nossum <[email protected]>
Apply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_JITTERENTROPY-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/jitterentropy-kcapi.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -164,7 +164,7 @@ obj-$(CONFIG_CRYPTO_XXHASH) += xxhash_generic.o obj-$(CONFIG_CRYPTO_842) += 842.o crypto-objs-$(CONFIG_CRYPTO_RNG2) += rng.o crypto-objs-$(CONFIG_CRYPTO_DRBG) += drbg.o -obj-$(CONFIG_CRYPTO_JITTERENTROPY) += jitterentropy_rng.o +crypto-objs-$(CONFIG_CRYPTO_JITTERENTROPY) += jitterentropy_rng.o CFLAGS_jitterentropy.o = -O0 KASAN_SANITIZE_jitterentropy.o = n UBSAN_SANITIZE_jitterentropy.o = n
crypto/jitterentropy-kcapi.c +2 -2
@@ -361,8 +361,8 @@ static void __exit jent_mod_exit(void)crypto_unregister_rng (&jent_alg); } -module_init (jent_mod_init); -module_exit (jent_mod_exit); +crypto_module_init (jent_mod_init); +crypto_module_exit (jent_mod_exit);MODULE_LICENSE ("Dual BSD/GPL" );MODULE_AUTHOR ("Stephan Mueller <[email protected]>" );
Signature · 1 line
2.47.3
PATCH 31/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_GHASH crypto
In reply to Jay WangFrom: Vegard Nossum <[email protected]>
Apply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_GHASH-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/ghash-generic.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -171,7 +171,7 @@ UBSAN_SANITIZE_jitterentropy.o = n jitterentropy_rng-y := jitterentropy.o jitterentropy-kcapi.o obj-$(CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE) += jitterentropy-testing.o obj-$(CONFIG_CRYPTO_BENCHMARK) += tcrypt.o -obj-$(CONFIG_CRYPTO_GHASH) += ghash-generic.o +crypto-objs-$(CONFIG_CRYPTO_GHASH) += ghash-generic.o obj-$(CONFIG_CRYPTO_USER_API) += af_alg.o obj-$(CONFIG_CRYPTO_USER_API_HASH) += algif_hash.o obj-$(CONFIG_CRYPTO_USER_API_SKCIPHER) += algif_skcipher.o
crypto/ghash-generic.c +2 -2
@@ -153,8 +153,8 @@ static void __exit ghash_mod_exit(void)crypto_unregister_shash (&ghash_alg); } -module_init (ghash_mod_init); -module_exit (ghash_mod_exit); +crypto_module_init (ghash_mod_init); +crypto_module_exit (ghash_mod_exit);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("GHASH hash function" );
Signature · 1 line
2.47.3
PATCH 32/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_ASYMMETRIC_KEY_TYPE crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_ASYMMETRIC_KEY_TYPE-related crypto to convert them into pluggable interface.
--- certs/system_keyring.c | 1 + crypto/asymmetric_keys/Makefile | 2 +- crypto/asymmetric_keys/asymmetric_type.c | 4 +-- crypto/asymmetric_keys/restrict.c | 3 +- crypto/fips140/fips140-api.c | 44 ++++++++++++++++++++++++ include/crypto/public_key.h | 29 +++++++++------- include/keys/asymmetric-parser.h | 8 +++-- include/keys/asymmetric-type.h | 32 +++++++++-------- 8 files changed, 90 insertions(+), 33 deletions(-)
certs/system_keyring.c +1 -0
@@ -50,6 +50,7 @@ int restrict_link_by_builtin_trusted(struct key *dest_keyring,return restrict_link_by_signature (dest_keyring, type, payload, builtin_trusted_keys); } +EXPORT_SYMBOL_GPL (restrict_link_by_builtin_trusted);/** * restrict_link_by_digsig_builtin - Restrict digitalSignature key additions by the built-in keyring
crypto/asymmetric_keys/Makefile +1 -1
@@ -3,7 +3,7 @@ # Makefile for asymmetric cryptographic keys # -obj-$(CONFIG_ASYMMETRIC_KEY_TYPE) += asymmetric_keys.o +crypto-objs-$(CONFIG_ASYMMETRIC_KEY_TYPE) += asymmetric_keys.o asymmetric_keys-y := \ asymmetric_type.o \
crypto/asymmetric_keys/asymmetric_type.c +2 -2
@@ -677,5 +677,5 @@ static void __exit asymmetric_key_cleanup(void)unregister_key_type (&key_type_asymmetric); } -module_init (asymmetric_key_init); -module_exit (asymmetric_key_cleanup); +crypto_module_init (asymmetric_key_init); +crypto_module_exit (asymmetric_key_cleanup);
crypto/asymmetric_keys/restrict.c +2 -1
@@ -114,7 +114,7 @@ int restrict_link_by_signature(struct key *dest_keyring,key_put (key);return ret; } - +EXPORT_SYMBOL_GPL (restrict_link_by_signature);/** * restrict_link_by_ca - Restrict additions to a ring of CA keys * @dest_keyring: Keyring being linked to.
@@ -198,6 +198,7 @@ int restrict_link_by_digsig(struct key *dest_keyring,return restrict_link_by_signature (dest_keyring, type, payload, trust_keyring); } +EXPORT_SYMBOL_GPL (restrict_link_by_digsig);static bool match_either_id (const struct asymmetric_key_id **pair,const struct asymmetric_key_id *single)
crypto/fips140/fips140-api.c +44 -0
47 lines not on this page · raw message
include/crypto/public_key.h +16 -13
@@ -10,6 +10,7 @@#ifndef _LINUX_PUBLIC_KEY_H#define _LINUX_PUBLIC_KEY_H +#include <crypto/api.h> #include <linux/errno.h> #include <linux/keyctl.h> #include <linux/oid_registry.h>
@@ -53,7 +54,9 @@ struct public_key_signature {const char *encoding; }; -extern void public_key_signature_free (struct public_key_signature *sig); +DECLARE_CRYPTO_API (CONFIG_ASYMMETRIC_KEY_TYPE , public_key_signature_free, void, + (struct public_key_signature *sig), + (sig));extern struct asymmetric_key_subtype public_key_subtype;
@@ -61,10 +64,9 @@ struct key;struct key_type ;union key_payload ; -extern int restrict_link_by_signature (struct key *dest_keyring, -const struct key_type *type, -const union key_payload *payload, -struct key *trust_keyring); +DECLARE_CRYPTO_API (CONFIG_ASYMMETRIC_KEY_TYPE , restrict_link_by_signature, int, + (struct key *dest_keyring, const struct key_type *type, const union key_payload *payload, struct key *trust_keyring), + (dest_keyring, type, payload, trust_keyring)); extern int restrict_link_by_key_or_keyring(struct key *dest_keyring, const struct key_type *type,
@@ -81,10 +83,9 @@ extern int restrict_link_by_ca(struct key *dest_keyring,const struct key_type *type, const union key_payload *payload, struct key *trust_keyring); -int restrict_link_by_digsig (struct key *dest_keyring, -const struct key_type *type, -const union key_payload *payload, -struct key *trust_keyring); +DECLARE_CRYPTO_API (CONFIG_ASYMMETRIC_KEY_TYPE , restrict_link_by_digsig, int, + (struct key *dest_keyring, const struct key_type *type, const union key_payload *payload, struct key *trust_keyring), + (dest_keyring, type, payload, trust_keyring));#else static inline int restrict_link_by_ca(struct key *dest_keyring, const struct key_type *type,
@@ -103,11 +104,13 @@ static inline int restrict_link_by_digsig(struct key *dest_keyring, }#endif -extern int query_asymmetric_key (const struct kernel_pkey_params *, -struct kernel_pkey_query *); +DECLARE_CRYPTO_API (CONFIG_ASYMMETRIC_KEY_TYPE , query_asymmetric_key, int, + (const struct kernel_pkey_params *arg1, struct kernel_pkey_query *arg2), + (arg1, arg2)); -extern int verify_signature (const struct key *, -const struct public_key_signature *); +DECLARE_CRYPTO_API (CONFIG_ASYMMETRIC_KEY_TYPE , verify_signature, int, + (const struct key *arg1, const struct public_key_signature *arg2), + (arg1, arg2));#if IS_REACHABLE (CONFIG_ASYMMETRIC_PUBLIC_KEY_SUBTYPE ) int public_key_verify_signature(const struct public_key *pkey,
include/keys/asymmetric-parser.h +6 -2
@@ -29,7 +29,11 @@ struct asymmetric_key_parser {int (*parse)(struct key_preparsed_payload *prep); }; -extern int register_asymmetric_key_parser (struct asymmetric_key_parser *); -extern void unregister_asymmetric_key_parser (struct asymmetric_key_parser *); +DECLARE_CRYPTO_API (CONFIG_ASYMMETRIC_KEY_TYPE , register_asymmetric_key_parser, int, + (struct asymmetric_key_parser *parser), + (parser)); +DECLARE_CRYPTO_API (CONFIG_ASYMMETRIC_KEY_TYPE , unregister_asymmetric_key_parser, void, + (struct asymmetric_key_parser *parser), + (parser));#endif /* _KEYS_ASYMMETRIC_PARSER_H */
include/keys/asymmetric-type.h +18 -14
@@ -10,10 +10,15 @@#ifndef _KEYS_ASYMMETRIC_TYPE_H#define _KEYS_ASYMMETRIC_TYPE_H +#include <crypto/api.h> #include <linux/key-type.h> #include <linux/verification.h> -extern struct key_type key_type_asymmetric; +DECLARE_CRYPTO_VAR(CONFIG_ASYMMETRIC_KEY_TYPE, key_type_asymmetric, struct key_type, ); + +#if defined(CONFIG_CRYPTO_FIPS140_EXTMOD ) && !defined(FIPS_MODULE ) &&IS_BUILTIN (CONFIG_ASYMMETRIC_KEY_TYPE ) +#define key_type_asymmetric (*((struct key_type*)CRYPTO_VAR_NAME(key_type_asymmetric))) +#endif /* * The key payload is four words. The asymmetric-type key uses them as
@@ -56,16 +61,17 @@ struct asymmetric_key_ids {void *id[3 ]; }; -extern bool asymmetric_key_id_same (const struct asymmetric_key_id *kid1, -const struct asymmetric_key_id *kid2); +DECLARE_CRYPTO_API (CONFIG_ASYMMETRIC_KEY_TYPE , asymmetric_key_id_same, bool, + (const struct asymmetric_key_id *kid1, const struct asymmetric_key_id *kid2), + (kid1, kid2)); -extern bool asymmetric_key_id_partial (const struct asymmetric_key_id *kid1, -const struct asymmetric_key_id *kid2); +DECLARE_CRYPTO_API (CONFIG_ASYMMETRIC_KEY_TYPE , asymmetric_key_id_partial, bool, + (const struct asymmetric_key_id *kid1, const struct asymmetric_key_id *kid2), + (kid1, kid2)); -extern struct asymmetric_key_id *asymmetric_key_generate_id (const void *val_1, -size_t len_1, -const void *val_2, -size_t len_2); +DECLARE_CRYPTO_API(CONFIG_ASYMMETRIC_KEY_TYPE, asymmetric_key_generate_id, struct asymmetric_key_id *, + (const void *val_1, size_t len_1, const void *val_2, size_t len_2), + (val_1, len_1, val_2, len_2));static inline const struct asymmetric_key_ids *asymmetric_key_ids (const struct key *key) {
@@ -78,11 +84,9 @@ const struct public_key *asymmetric_key_public_key(const struct key *key)return key->payload.data[asym_crypto]; } -extern struct key *find_asymmetric_key (struct key *keyring, -const struct asymmetric_key_id *id_0, -const struct asymmetric_key_id *id_1, -const struct asymmetric_key_id *id_2, -bool partial); +DECLARE_CRYPTO_API(CONFIG_ASYMMETRIC_KEY_TYPE, find_asymmetric_key, struct key *, + (struct key *keyring, const struct asymmetric_key_id *id_0, const struct asymmetric_key_id *id_1, const struct asymmetric_key_id *id_2, bool partial), + (keyring, id_0, id_1, id_2, partial));int x509_load_certificate_list (const u8 cert_list[],const unsigned long list_size,const struct key *keyring);
Signature · 1 line
2.47.3
PATCH 33/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_ASYMMETRIC_PUBLIC_KEY_SUBTYPE crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_ASYMMETRIC_PUBLIC_KEY_SUBTYPE-related crypto to convert them into pluggable interface.
This patch is partially based on work by Vegard Nossum, with modifications. Unlike the original, we do not include DEFINE_CRYPTO_API since only one copy of the crypto symbols is kept, either in the crypto module or in the main kernel, and we ensure such wrapper do not have impact on crypto already chosen built as module.
--- crypto/asymmetric_keys/Makefile | 2 +- crypto/fips140/fips140-api.c | 14 ++++++++++++++ include/crypto/public_key.h | 15 +++++++++++---- 3 files changed, 26 insertions(+), 5 deletions(-)
crypto/asymmetric_keys/Makefile +1 -1
@@ -10,7 +10,7 @@ asymmetric_keys-y := \ restrict.o \ signature.o -obj-$(CONFIG_ASYMMETRIC_PUBLIC_KEY_SUBTYPE) += public_key.o +crypto-objs-$(CONFIG_ASYMMETRIC_PUBLIC_KEY_SUBTYPE) += public_key.o # # X.509 Certificate handling
crypto/fips140/fips140-api.c +14 -0
@@ -457,3 +457,17 @@ DEFINE_CRYPTO_API_STUB(restrict_link_by_signature);DEFINE_CRYPTO_API_STUB (restrict_link_by_digsig);#endif +/* +* crypto/asymmetric_keys/public_key.c +*/ +#if IS_BUILTIN (CONFIG_ASYMMETRIC_PUBLIC_KEY_SUBTYPE ) + +#include <crypto/public_key.h> + +DEFINE_CRYPTO_API_STUB (public_key_free); +DEFINE_CRYPTO_API_STUB (public_key_verify_signature); + +#undef public_key_subtype +DEFINE_CRYPTO_VAR_STUB (public_key_subtype); + +#endif
include/crypto/public_key.h +11 -4
@@ -36,7 +36,9 @@ struct public_key {#define KEY_EFLAG_KEYCERTSIGN 2/* set if the keyCertSign usage is set */ }; -extern void public_key_free (struct public_key *key); +DECLARE_CRYPTO_API (CONFIG_ASYMMETRIC_PUBLIC_KEY_SUBTYPE , public_key_free, void, + (struct public_key *key), + (key));/* * Public key cryptography signature data
@@ -58,7 +60,11 @@ DECLARE_CRYPTO_API(CONFIG_ASYMMETRIC_KEY_TYPE, public_key_signature_free, void, (struct public_key_signature *sig), (sig)); -extern struct asymmetric_key_subtype public_key_subtype; +DECLARE_CRYPTO_VAR(CONFIG_ASYMMETRIC_PUBLIC_KEY_SUBTYPE, public_key_subtype, struct asymmetric_key_subtype, ); + +#if defined(CONFIG_CRYPTO_FIPS140_EXTMOD ) && !defined(FIPS_MODULE ) &&IS_BUILTIN (CONFIG_ASYMMETRIC_PUBLIC_KEY_SUBTYPE ) +#define public_key_subtype (*((struct asymmetric_key_subtype*)CRYPTO_VAR_NAME(public_key_subtype))) +#endif struct key ;struct key_type ;
@@ -113,8 +119,9 @@ DECLARE_CRYPTO_API(CONFIG_ASYMMETRIC_KEY_TYPE, verify_signature, int, (arg1, arg2));#if IS_REACHABLE (CONFIG_ASYMMETRIC_PUBLIC_KEY_SUBTYPE ) -int public_key_verify_signature (const struct public_key *pkey, -const struct public_key_signature *sig); +DECLARE_CRYPTO_API (CONFIG_ASYMMETRIC_PUBLIC_KEY_SUBTYPE , public_key_verify_signature, int, + (const struct public_key *pkey, const struct public_key_signature *sig), + (pkey, sig));#else static inline int public_key_verify_signature(const struct public_key *pkey,
Signature · 1 line
2.47.3
PATCH 34/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_X509_CERTIFICATE_PARSER crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_X509_CERTIFICATE_PARSER-related crypto to convert them into pluggable interface.
This patch is partially based on work by Vegard Nossum, with modifications. Unlike the original, we do not include DEFINE_CRYPTO_API since only one copy of the crypto symbols is kept, either in the crypto module or in the main kernel, and we ensure such wrapper do not have impact on crypto already chosen built as module.
--- crypto/asymmetric_keys/Makefile | 2 +- crypto/asymmetric_keys/x509_parser.h | 15 ++++++++++----- crypto/asymmetric_keys/x509_public_key.c | 4 ++-- crypto/fips140/fips140-api.c | 22 ++++++++++++++++++++++ include/keys/asymmetric-type.h | 5 +++-- 5 files changed, 38 insertions(+), 10 deletions(-)
crypto/asymmetric_keys/Makefile +1 -1
@@ -15,7 +15,7 @@ crypto-objs-$(CONFIG_ASYMMETRIC_PUBLIC_KEY_SUBTYPE) += public_key.o # # X.509 Certificate handling # -obj-$(CONFIG_X509_CERTIFICATE_PARSER) += x509_key_parser.o +crypto-objs-$(CONFIG_X509_CERTIFICATE_PARSER) += x509_key_parser.o x509_key_parser-y := \ x509.asn1.o \ x509_akid.asn1.o \
crypto/asymmetric_keys/x509_parser.h +10 -5
@@ -5,6 +5,7 @@* Written by David Howells ([email protected]) */ +#include <crypto/api.h> #include <linux/cleanup.h> #include <linux/time.h> #include <crypto/public_key.h>
@@ -46,13 +47,17 @@ struct x509_certificate {/* * x509_cert_parser.c */ -extern void x509_free_certificate (struct x509_certificate *cert); +DECLARE_CRYPTO_API (CONFIG_X509_CERTIFICATE_PARSER , x509_free_certificate, void, + (struct x509_certificate *cert), + (cert)); DEFINE_FREE(x509_free_certificate, struct x509_certificate *, if (!IS_ERR(_T)) x509_free_certificate(_T)) -extern struct x509_certificate *x509_cert_parse (const void *data,size_t datalen); -extern int x509_decode_time (time64_t *_t,size_t hdrlen, -unsigned char tag, -const unsigned char *value,size_t vlen); +DECLARE_CRYPTO_API(CONFIG_X509_CERTIFICATE_PARSER, x509_cert_parse, struct x509_certificate *, + (const void *data, size_t datalen), + (data, datalen)); +DECLARE_CRYPTO_API (CONFIG_X509_CERTIFICATE_PARSER , x509_decode_time, int, + (time64_t *_t, size_t hdrlen, unsigned char tag, const unsigned char *value, size_t vlen), + (_t, hdrlen, tag, value, vlen));/* * x509_public_key.c
crypto/asymmetric_keys/x509_public_key.c +2 -2
@@ -258,8 +258,8 @@ static void __exit x509_key_exit(void)unregister_asymmetric_key_parser (&x509_key_parser); } -module_init (x509_key_init); -module_exit (x509_key_exit); +crypto_module_init (x509_key_init); +crypto_module_exit (x509_key_exit);MODULE_DESCRIPTION ("X.509 certificate parser" );MODULE_AUTHOR ("Red Hat, Inc." );
crypto/fips140/fips140-api.c +22 -0
@@ -471,3 +471,25 @@ DEFINE_CRYPTO_API_STUB(public_key_verify_signature);DEFINE_CRYPTO_VAR_STUB (public_key_subtype);#endif +/* +* crypto/asymmetric_keys/x509_cert_parser.c +*/ +#if IS_BUILTIN (CONFIG_X509_CERTIFICATE_PARSER ) + +#include <crypto/asymmetric_keys/x509_parser.h> + +DEFINE_CRYPTO_API_STUB (x509_free_certificate); +DEFINE_CRYPTO_API_STUB (x509_cert_parse); +DEFINE_CRYPTO_API_STUB (x509_decode_time); + +#endif +/* +* crypto/asymmetric_keys/x509_loader.c +*/ +#if IS_BUILTIN (CONFIG_X509_CERTIFICATE_PARSER ) + +#include <keys/asymmetric-type.h> + +DEFINE_CRYPTO_API_STUB (x509_load_certificate_list); + +#endif
include/keys/asymmetric-type.h +3 -2
@@ -88,8 +88,9 @@ DECLARE_CRYPTO_API(CONFIG_ASYMMETRIC_KEY_TYPE, find_asymmetric_key, struct key * (struct key *keyring, const struct asymmetric_key_id *id_0, const struct asymmetric_key_id *id_1, const struct asymmetric_key_id *id_2, bool partial), (keyring, id_0, id_1, id_2, partial)); -int x509_load_certificate_list (const u8 cert_list[],const unsigned long list_size, -const struct key *keyring); +DECLARE_CRYPTO_API (CONFIG_X509_CERTIFICATE_PARSER , x509_load_certificate_list, int, + (const u8 cert_list[], const unsigned long list_size, const struct key *keyring), + (cert_list, list_size, keyring));/* * The payload is at the discretion of the subtype.
Signature · 1 line
2.47.3
PATCH 35/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_PKCS7_MESSAGE_PARSER crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_PKCS7_MESSAGE_PARSER-related crypto to convert them into pluggable interface.
This patch is partially based on work by Vegard Nossum, with modifications. Unlike the original, we do not include DEFINE_CRYPTO_API since only one copy of the crypto symbols is kept, either in the crypto module or in the main kernel, and we ensure such wrapper do not have impact on crypto already chosen built as module.
--- crypto/asymmetric_keys/Makefile | 2 +- crypto/fips140/fips140-api.c | 33 +++++++++++++++++++++++++++++++++ include/crypto/pkcs7.h | 31 +++++++++++++++++++------------ 3 files changed, 53 insertions(+), 13 deletions(-)
crypto/asymmetric_keys/Makefile +1 -1
@@ -50,7 +50,7 @@ clean-files += pkcs8.asn1.c pkcs8.asn1.h # # PKCS#7 message handling # -obj-$(CONFIG_PKCS7_MESSAGE_PARSER) += pkcs7_message.o +crypto-objs-$(CONFIG_PKCS7_MESSAGE_PARSER) += pkcs7_message.o pkcs7_message-y := \ pkcs7.asn1.o \ pkcs7_parser.o \
crypto/fips140/fips140-api.c +33 -0
@@ -493,3 +493,36 @@ DEFINE_CRYPTO_API_STUB(x509_decode_time);DEFINE_CRYPTO_API_STUB (x509_load_certificate_list);#endif +/* +* crypto/asymmetric_keys/pkcs7_parser.c +*/ +#if IS_BUILTIN (CONFIG_PKCS7_MESSAGE_PARSER ) + +#include <crypto/pkcs7.h> + +DEFINE_CRYPTO_API_STUB (pkcs7_parse_message); +DEFINE_CRYPTO_API_STUB (pkcs7_free_message); +DEFINE_CRYPTO_API_STUB (pkcs7_get_content_data); + +#endif +/* +* crypto/asymmetric_keys/pkcs7_trust.c +*/ +#if IS_BUILTIN (CONFIG_PKCS7_MESSAGE_PARSER ) + +#include <crypto/pkcs7.h> + +DEFINE_CRYPTO_API_STUB (pkcs7_validate_trust); + +#endif +/* +* crypto/asymmetric_keys/pkcs7_verify.c +*/ +#if IS_BUILTIN (CONFIG_PKCS7_MESSAGE_PARSER ) + +#include <crypto/pkcs7.h> + +DEFINE_CRYPTO_API_STUB (pkcs7_verify); +DEFINE_CRYPTO_API_STUB (pkcs7_supply_detached_data); + +#endif
include/crypto/pkcs7.h +19 -12
@@ -8,6 +8,7 @@#ifndef _CRYPTO_PKCS7_H#define _CRYPTO_PKCS7_H +#include <crypto/api.h> #include <linux/verification.h> #include <linux/hash_info.h> #include <crypto/public_key.h>
@@ -18,28 +19,34 @@ struct pkcs7_message;/* * pkcs7_parser.c */ -extern struct pkcs7_message *pkcs7_parse_message (const void *data, -size_t datalen); -extern void pkcs7_free_message (struct pkcs7_message *pkcs7); +DECLARE_CRYPTO_API(CONFIG_PKCS7_MESSAGE_PARSER, pkcs7_parse_message, struct pkcs7_message *, + (const void *data, size_t datalen), + (data, datalen)); +DECLARE_CRYPTO_API (CONFIG_PKCS7_MESSAGE_PARSER , pkcs7_free_message, void, + (struct pkcs7_message *pkcs7), + (pkcs7)); -extern int pkcs7_get_content_data (const struct pkcs7_message *pkcs7, -const void **_data,size_t *_datalen, -size_t *_headerlen); +DECLARE_CRYPTO_API (CONFIG_PKCS7_MESSAGE_PARSER , pkcs7_get_content_data, int, + (const struct pkcs7_message *pkcs7, const void **_data, size_t *_datalen, size_t *_headerlen), + (pkcs7, _data, _datalen, _headerlen));/* * pkcs7_trust.c */ -extern int pkcs7_validate_trust (struct pkcs7_message *pkcs7, -struct key *trust_keyring); +DECLARE_CRYPTO_API (CONFIG_PKCS7_MESSAGE_PARSER , pkcs7_validate_trust, int, + (struct pkcs7_message *pkcs7, struct key *trust_keyring), + (pkcs7, trust_keyring));/* * pkcs7_verify.c */ -extern int pkcs7_verify (struct pkcs7_message *pkcs7, -enum key_being_used_for usage); +DECLARE_CRYPTO_API (CONFIG_PKCS7_MESSAGE_PARSER , pkcs7_verify, int, + (struct pkcs7_message *pkcs7, enum key_being_used_for usage), + (pkcs7, usage)); -extern int pkcs7_supply_detached_data (struct pkcs7_message *pkcs7, -const void *data,size_t datalen); +DECLARE_CRYPTO_API (CONFIG_PKCS7_MESSAGE_PARSER , pkcs7_supply_detached_data, int, + (struct pkcs7_message *pkcs7, const void *data, size_t datalen), + (pkcs7, data, datalen));extern int pkcs7_get_digest (struct pkcs7_message *pkcs7,const u8 **buf,u32 *len,enum hash_algo *hash_algo);
Signature · 1 line
2.47.3
PATCH 36/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_ENGINE crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_ENGINE-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/fips140/fips140-api.c | 40 ++++++++++ include/crypto/engine.h | 140 +++++++++++++++++++++++------------ 3 files changed, 135 insertions(+), 47 deletions(-)
crypto/Makefile +1 -1
@@ -8,7 +8,7 @@ CONTEXT_ANALYSIS := y crypto-objs-$(CONFIG_CRYPTO) += crypto.o crypto-y := api.o cipher.o -obj-$(CONFIG_CRYPTO_ENGINE) += crypto_engine.o +crypto-objs-$(CONFIG_CRYPTO_ENGINE) += crypto_engine.o obj-$(CONFIG_CRYPTO_FIPS) += fips.o crypto_algapi-$(CONFIG_PROC_FS) += proc.o
crypto/fips140/fips140-api.c +40 -0
@@ -526,3 +526,43 @@ DEFINE_CRYPTO_API_STUB(pkcs7_verify);DEFINE_CRYPTO_API_STUB (pkcs7_supply_detached_data);#endif +/* +* crypto/crypto_engine.c +*/ +#if IS_BUILTIN (CONFIG_CRYPTO_ENGINE ) + +#include <crypto/engine.h> + +DEFINE_CRYPTO_API_STUB (crypto_transfer_aead_request_to_engine); +DEFINE_CRYPTO_API_STUB (crypto_transfer_akcipher_request_to_engine); +DEFINE_CRYPTO_API_STUB (crypto_transfer_hash_request_to_engine); +DEFINE_CRYPTO_API_STUB (crypto_transfer_kpp_request_to_engine); +DEFINE_CRYPTO_API_STUB (crypto_transfer_skcipher_request_to_engine); +DEFINE_CRYPTO_API_STUB (crypto_finalize_aead_request); +DEFINE_CRYPTO_API_STUB (crypto_finalize_akcipher_request); +DEFINE_CRYPTO_API_STUB (crypto_finalize_hash_request); +DEFINE_CRYPTO_API_STUB (crypto_finalize_kpp_request); +DEFINE_CRYPTO_API_STUB (crypto_finalize_skcipher_request); +DEFINE_CRYPTO_API_STUB (crypto_engine_start); +DEFINE_CRYPTO_API_STUB (crypto_engine_stop); +DEFINE_CRYPTO_API_STUB (crypto_engine_alloc_init); +DEFINE_CRYPTO_API_STUB (crypto_engine_alloc_init_and_set); +DEFINE_CRYPTO_API_STUB (crypto_engine_exit); +DEFINE_CRYPTO_API_STUB (crypto_engine_register_aead); +DEFINE_CRYPTO_API_STUB (crypto_engine_unregister_aead); +DEFINE_CRYPTO_API_STUB (crypto_engine_register_aeads); +DEFINE_CRYPTO_API_STUB (crypto_engine_unregister_aeads); +DEFINE_CRYPTO_API_STUB (crypto_engine_register_ahash); +DEFINE_CRYPTO_API_STUB (crypto_engine_unregister_ahash); +DEFINE_CRYPTO_API_STUB (crypto_engine_register_ahashes); +DEFINE_CRYPTO_API_STUB (crypto_engine_unregister_ahashes); +DEFINE_CRYPTO_API_STUB (crypto_engine_register_akcipher); +DEFINE_CRYPTO_API_STUB (crypto_engine_unregister_akcipher); +DEFINE_CRYPTO_API_STUB (crypto_engine_register_kpp); +DEFINE_CRYPTO_API_STUB (crypto_engine_unregister_kpp); +DEFINE_CRYPTO_API_STUB (crypto_engine_register_skcipher); +DEFINE_CRYPTO_API_STUB (crypto_engine_unregister_skcipher); +DEFINE_CRYPTO_API_STUB (crypto_engine_register_skciphers); +DEFINE_CRYPTO_API_STUB (crypto_engine_unregister_skciphers); + +#endif
include/crypto/engine.h +94 -46
156 lines not on this page · raw message
Signature · 1 line
2.47.3
PATCH 37/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_HKDF crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_HKDF-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/fips140/fips140-api.c | 22 ++++++++++++++++++++++ crypto/hkdf.c | 4 ++-- include/crypto/hkdf.h | 13 +++++++------ 4 files changed, 32 insertions(+), 9 deletions(-)
crypto/Makefile +1 -1
@@ -36,7 +36,7 @@ crypto-objs-$(CONFIG_CRYPTO_HASH2) += crypto_hash.o crypto-objs-$(CONFIG_CRYPTO_AKCIPHER2) += akcipher.o crypto-objs-$(CONFIG_CRYPTO_SIG2) += sig.o crypto-objs-$(CONFIG_CRYPTO_KPP2) += kpp.o -obj-$(CONFIG_CRYPTO_HKDF) += hkdf.o +crypto-objs-$(CONFIG_CRYPTO_HKDF) += hkdf.o dh_generic-y := dh.o dh_generic-y += dh_helper.o
crypto/fips140/fips140-api.c +22 -0
@@ -565,4 +565,26 @@ DEFINE_CRYPTO_API_STUB(crypto_engine_unregister_skcipher);DEFINE_CRYPTO_API_STUB (crypto_engine_register_skciphers);DEFINE_CRYPTO_API_STUB (crypto_engine_unregister_skciphers); +#endif +/* +* crypto/hkdf.c +*/ +#if IS_BUILTIN (CONFIG_CRYPTO_HKDF ) + +#include <crypto/hkdf.h> + +DEFINE_CRYPTO_API_STUB (hkdf_extract); +DEFINE_CRYPTO_API_STUB (hkdf_expand); + +#endif +/* +* crypto/hkdf.c +*/ +#if IS_BUILTIN (CONFIG_CRYPTO_HKDF ) + +#include <crypto/hkdf.h> + +DEFINE_CRYPTO_API_STUB (hkdf_extract); +DEFINE_CRYPTO_API_STUB (hkdf_expand); +#endif
crypto/hkdf.c +2 -2
@@ -566,8 +566,8 @@ static int __init crypto_hkdf_module_init(void) static void __exit crypto_hkdf_module_exit(void) {} -late_initcall (crypto_hkdf_module_init); -module_exit (crypto_hkdf_module_exit); +crypto_late_initcall (crypto_hkdf_module_init); +crypto_module_exit (crypto_hkdf_module_exit);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("HMAC-based Key Derivation Function (HKDF)" );
include/crypto/hkdf.h +7 -6
@@ -9,12 +9,13 @@#ifndef _CRYPTO_HKDF_H#define _CRYPTO_HKDF_H +#include <crypto/api.h> #include <crypto/hash.h> -int hkdf_extract (struct crypto_shash *hmac_tfm,const u8 *ikm, -unsigned int ikmlen,const u8 *salt,unsigned int saltlen, -u8 *prk); -int hkdf_expand (struct crypto_shash *hmac_tfm, -const u8 *info,unsigned int infolen, -u8 *okm,unsigned int okmlen); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_HKDF , hkdf_extract, int, + (struct crypto_shash *hmac_tfm, const u8 *ikm, unsigned int ikmlen, const u8 *salt, unsigned int saltlen, u8 *prk), + (hmac_tfm, ikm, ikmlen, salt, saltlen, prk)); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_HKDF , hkdf_expand, int, + (struct crypto_shash *hmac_tfm, const u8 *info, unsigned int infolen, u8 *okm, unsigned int okmlen), + (hmac_tfm, info, infolen, okm, okmlen));#endif
Signature · 1 line
2.47.3
PATCH 38/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_DH crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_DH-related crypto to convert them into pluggable interface.
This patch is partially based on work by Vegard Nossum, with modifications. Unlike the original, we do not include DEFINE_CRYPTO_API since only one copy of the crypto symbols is kept, either in the crypto module or in the main kernel, and we ensure such wrapper do not have impact on crypto already chosen built as module.
--- crypto/Makefile | 2 +- crypto/dh.c | 4 ++-- crypto/fips140/fips140-api.c | 13 +++++++------ include/crypto/dh.h | 14 +++++++++++--- 4 files changed, 21 insertions(+), 12 deletions(-)
crypto/Makefile +1 -1
@@ -40,7 +40,7 @@ crypto-objs-$(CONFIG_CRYPTO_HKDF) += hkdf.o dh_generic-y := dh.o dh_generic-y += dh_helper.o -obj-$(CONFIG_CRYPTO_DH) += dh_generic.o +crypto-objs-$(CONFIG_CRYPTO_DH) += dh_generic.o $(obj)/rsapubkey.asn1.o: $(obj)/rsapubkey.asn1.c $(obj)/rsapubkey.asn1.h $(obj)/rsaprivkey.asn1.o: $(obj)/rsaprivkey.asn1.c $(obj)/rsaprivkey.asn1.h
crypto/dh.c +2 -2
@@ -920,8 +920,8 @@ static void __exit dh_exit(void)crypto_unregister_kpp (&dh); } -module_init (dh_init); -module_exit (dh_exit); +crypto_module_init (dh_init); +crypto_module_exit (dh_exit);MODULE_ALIAS_CRYPTO ("dh" );MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("DH generic algorithm" );
crypto/fips140/fips140-api.c +7 -6
@@ -578,13 +578,14 @@ DEFINE_CRYPTO_API_STUB(hkdf_expand);#endif /* -* crypto/hkdf.c +* crypto/dh_helper.c */ -#if IS_BUILTIN (CONFIG_CRYPTO_HKDF ) +#if IS_BUILTIN (CONFIG_CRYPTO_DH ) -#include <crypto/hkdf.h> +#include <crypto/dh.h> -DEFINE_CRYPTO_API_STUB (hkdf_extract); -DEFINE_CRYPTO_API_STUB (hkdf_expand); +DEFINE_CRYPTO_API_STUB (crypto_dh_key_len); +DEFINE_CRYPTO_API_STUB (crypto_dh_encode_key); +DEFINE_CRYPTO_API_STUB (crypto_dh_decode_key); -#endif +#endif
include/crypto/dh.h +11 -3
@@ -8,6 +8,8 @@#ifndef _CRYPTO_DH_#define _CRYPTO_DH_ +#include <crypto/api.h> +/** * DOC: DH Helper Functions *
@@ -48,7 +50,9 @@ struct dh {* * Return: size of the key in bytes */ -unsigned int crypto_dh_key_len (const struct dh *params); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_DH, crypto_dh_key_len, unsigned int, + (const struct dh *params), + (params));/** * crypto_dh_encode_key() - encode the private key
@@ -63,7 +67,9 @@ unsigned int crypto_dh_key_len(const struct dh *params);* * Return: -EINVAL if buffer has insufficient size, 0 on success */ -int crypto_dh_encode_key (char *buf,unsigned int len,const struct dh *params); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_DH , crypto_dh_encode_key, int, + (char *buf, unsigned int len, const struct dh *params), + (buf, len, params));/** * crypto_dh_decode_key() - decode a private key
@@ -77,7 +83,9 @@ int crypto_dh_encode_key(char *buf, unsigned int len, const struct dh *params);* * Return: -EINVAL if buffer has insufficient size, 0 on success */ -int crypto_dh_decode_key (const char *buf,unsigned int len,struct dh *params); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_DH , crypto_dh_decode_key, int, + (const char *buf, unsigned int len, struct dh *params), + (buf, len, params));/** * __crypto_dh_decode_key() - decode a private key without parameter checks
Signature · 1 line
2.47.3
PATCH 39/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_ECDSA and CONFIG_CRYPTO_ECC crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_ECDSA- and CONFIG_CRYPTO_ECC-related crypto to convert them into pluggable interface.
This patch is partially based on work by Vegard Nossum, with modifications. Unlike the original, we do not include DEFINE_CRYPTO_API since only one copy of the crypto symbols is kept, either in the crypto module or in the main kernel, and we ensure such wrapper do not have impact on crypto already chosen built as module.
--- crypto/Makefile | 4 +- crypto/ecdsa.c | 4 +- crypto/fips140/fips140-api.c | 33 +++++++++++++ include/crypto/ecc_curve.h | 9 +++- include/crypto/internal/ecc.h | 91 ++++++++++++++++++++++------------- 5 files changed, 102 insertions(+), 39 deletions(-)
crypto/Makefile +2 -2
@@ -60,7 +60,7 @@ ecdsa_generic-y += ecdsa.o ecdsa_generic-y += ecdsa-x962.o ecdsa_generic-y += ecdsa-p1363.o ecdsa_generic-y += ecdsasignature.asn1.o -obj-$(CONFIG_CRYPTO_ECDSA) += ecdsa_generic.o +crypto-objs-$(CONFIG_CRYPTO_ECDSA) += ecdsa_generic.o obj-$(CONFIG_CRYPTO_MLDSA) += mldsa.o
@@ -178,7 +178,7 @@ obj-$(CONFIG_CRYPTO_USER_API_SKCIPHER) += algif_skcipher.o obj-$(CONFIG_CRYPTO_USER_API_RNG) += algif_rng.o obj-$(CONFIG_CRYPTO_USER_API_AEAD) += algif_aead.o obj-$(CONFIG_CRYPTO_ZSTD) += zstd.o -obj-$(CONFIG_CRYPTO_ECC) += ecc.o +crypto-objs-$(CONFIG_CRYPTO_ECC) += ecc.o obj-$(CONFIG_CRYPTO_ESSIV) += essiv.o ecdh_generic-y += ecdh.o
crypto/ecdsa.c +2 -2
@@ -334,8 +334,8 @@ static void __exit ecdsa_exit(void)crypto_unregister_sig (&ecdsa_nist_p521); } -module_init (ecdsa_init); -module_exit (ecdsa_exit); +crypto_module_init (ecdsa_init); +crypto_module_exit (ecdsa_exit);MODULE_LICENSE ("GPL" );MODULE_AUTHOR ("Stefan Berger <[email protected]>" );
crypto/fips140/fips140-api.c +33 -0
@@ -589,3 +589,36 @@ DEFINE_CRYPTO_API_STUB(crypto_dh_encode_key);DEFINE_CRYPTO_API_STUB (crypto_dh_decode_key);#endif +/* +* crypto/ecc.c +*/ +#if IS_BUILTIN (CONFIG_CRYPTO_ECC ) + +#include <crypto/ecc_curve.h> + +DEFINE_CRYPTO_API_STUB (ecc_get_curve); +DEFINE_CRYPTO_API_STUB (ecc_get_curve25519); + +#include <crypto/internal/ecc.h> + +DEFINE_CRYPTO_API_STUB (ecc_digits_from_bytes); +DEFINE_CRYPTO_API_STUB (ecc_is_key_valid); +DEFINE_CRYPTO_API_STUB (ecc_gen_privkey); +DEFINE_CRYPTO_API_STUB (ecc_make_pub_key); +DEFINE_CRYPTO_API_STUB (crypto_ecdh_shared_secret); +DEFINE_CRYPTO_API_STUB (ecc_is_pubkey_valid_partial); +DEFINE_CRYPTO_API_STUB (ecc_is_pubkey_valid_full); +DEFINE_CRYPTO_API_STUB (vli_is_zero); +DEFINE_CRYPTO_API_STUB (vli_cmp); +DEFINE_CRYPTO_API_STUB (vli_sub); +DEFINE_CRYPTO_API_STUB (vli_from_be64); +DEFINE_CRYPTO_API_STUB (vli_from_le64); +DEFINE_CRYPTO_API_STUB (vli_mod_inv); +DEFINE_CRYPTO_API_STUB (vli_mod_mult_slow); +DEFINE_CRYPTO_API_STUB (vli_num_bits); +DEFINE_CRYPTO_API_STUB (ecc_alloc_point); +DEFINE_CRYPTO_API_STUB (ecc_free_point); +DEFINE_CRYPTO_API_STUB (ecc_point_is_zero); +DEFINE_CRYPTO_API_STUB (ecc_point_mult_shamir); + +#endif
include/crypto/ecc_curve.h +7 -2
@@ -4,6 +4,7 @@#ifndef _CRYTO_ECC_CURVE_H#define _CRYTO_ECC_CURVE_H +#include <crypto/api.h> #include <linux/types.h> /**
@@ -50,13 +51,17 @@ struct ecc_curve {* * Returns curve if get curve succssful, NULL otherwise */ -const struct ecc_curve *ecc_get_curve (unsigned int curve_id); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_ECC, ecc_get_curve, const struct ecc_curve *, + (unsigned int curve_id), + (curve_id));/** * ecc_get_curve25519() - get curve25519 curve; * * Returns curve25519 */ -const struct ecc_curve *ecc_get_curve25519 (void ); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_ECC, ecc_get_curve25519, const struct ecc_curve *, + (void), + ());#endif
include/crypto/internal/ecc.h +58 -33
211 lines not on this page · raw message
Signature · 1 line
2.47.3
PATCH 40/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_USER crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_USER-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/crypto_user.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -71,7 +71,7 @@ crypto-objs-$(CONFIG_CRYPTO_ACOMP2) += crypto_acompress.o cryptomgr-y := algboss.o testmgr.o crypto-objs-$(CONFIG_CRYPTO_MANAGER2) += cryptomgr.o -obj-$(CONFIG_CRYPTO_USER) += crypto_user.o +crypto-objs-$(CONFIG_CRYPTO_USER) += crypto_user.o crypto-objs-$(CONFIG_CRYPTO_CMAC) += cmac.o crypto-objs-$(CONFIG_CRYPTO_HMAC) += hmac.o obj-$(CONFIG_CRYPTO_XCBC) += xcbc.o
crypto/crypto_user.c +2 -2
@@ -498,8 +498,8 @@ static void __exit crypto_user_exit(void)unregister_pernet_subsys (&crypto_netlink_net_ops); } -module_init (crypto_user_init); -module_exit (crypto_user_exit); +crypto_module_init (crypto_user_init); +crypto_module_exit (crypto_user_exit);MODULE_LICENSE ("GPL" );MODULE_AUTHOR ("Steffen Klassert <[email protected]>" );MODULE_DESCRIPTION ("Crypto userspace configuration API" );
Signature · 1 line
2.47.3
PATCH 41/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_XCBC crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_XCBC-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/xcbc.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -74,7 +74,7 @@ crypto-objs-$(CONFIG_CRYPTO_MANAGER2) += cryptomgr.o crypto-objs-$(CONFIG_CRYPTO_USER) += crypto_user.o crypto-objs-$(CONFIG_CRYPTO_CMAC) += cmac.o crypto-objs-$(CONFIG_CRYPTO_HMAC) += hmac.o -obj-$(CONFIG_CRYPTO_XCBC) += xcbc.o +crypto-objs-$(CONFIG_CRYPTO_XCBC) += xcbc.o obj-$(CONFIG_CRYPTO_NULL) += crypto_null.o obj-$(CONFIG_CRYPTO_MD4) += md4.o crypto-objs-$(CONFIG_CRYPTO_MD5) += md5.o
crypto/xcbc.c +2 -2
@@ -199,8 +199,8 @@ static void __exit crypto_xcbc_module_exit(void)crypto_unregister_template (&crypto_xcbc_tmpl); } -module_init (crypto_xcbc_module_init); -module_exit (crypto_xcbc_module_exit); +crypto_module_init (crypto_xcbc_module_init); +crypto_module_exit (crypto_xcbc_module_exit);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("XCBC keyed hash algorithm" );
Signature · 1 line
2.47.3
PATCH 42/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_NULL crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_NULL-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/crypto_null.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -75,7 +75,7 @@ crypto-objs-$(CONFIG_CRYPTO_USER) += crypto_user.o crypto-objs-$(CONFIG_CRYPTO_CMAC) += cmac.o crypto-objs-$(CONFIG_CRYPTO_HMAC) += hmac.o crypto-objs-$(CONFIG_CRYPTO_XCBC) += xcbc.o -obj-$(CONFIG_CRYPTO_NULL) += crypto_null.o +crypto-objs-$(CONFIG_CRYPTO_NULL) += crypto_null.o obj-$(CONFIG_CRYPTO_MD4) += md4.o crypto-objs-$(CONFIG_CRYPTO_MD5) += md5.o obj-$(CONFIG_CRYPTO_RMD160) += rmd160.o
crypto/crypto_null.c +2 -2
@@ -148,8 +148,8 @@ static void __exit crypto_null_mod_fini(void)crypto_unregister_skcipher (&skcipher_null); } -module_init (crypto_null_mod_init); -module_exit (crypto_null_mod_fini); +crypto_module_init (crypto_null_mod_init); +crypto_module_exit (crypto_null_mod_fini);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("Null Cryptographic Algorithms" );
Signature · 1 line
2.47.3
PATCH 43/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_MD4 crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_MD4-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/md4.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -76,7 +76,7 @@ crypto-objs-$(CONFIG_CRYPTO_CMAC) += cmac.o crypto-objs-$(CONFIG_CRYPTO_HMAC) += hmac.o crypto-objs-$(CONFIG_CRYPTO_XCBC) += xcbc.o crypto-objs-$(CONFIG_CRYPTO_NULL) += crypto_null.o -obj-$(CONFIG_CRYPTO_MD4) += md4.o +crypto-objs-$(CONFIG_CRYPTO_MD4) += md4.o crypto-objs-$(CONFIG_CRYPTO_MD5) += md5.o obj-$(CONFIG_CRYPTO_RMD160) += rmd160.o obj-$(CONFIG_CRYPTO_SHA1) += sha1.o
crypto/md4.c +2 -2
@@ -233,8 +233,8 @@ static void __exit md4_mod_fini(void)crypto_unregister_shash (&alg); } -module_init (md4_mod_init); -module_exit (md4_mod_fini); +crypto_module_init (md4_mod_init); +crypto_module_exit (md4_mod_fini);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("MD4 Message Digest Algorithm" );
Signature · 1 line
2.47.3
PATCH 44/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_RMD160 crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_RMD160-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/rmd160.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -78,7 +78,7 @@ crypto-objs-$(CONFIG_CRYPTO_XCBC) += xcbc.o crypto-objs-$(CONFIG_CRYPTO_NULL) += crypto_null.o crypto-objs-$(CONFIG_CRYPTO_MD4) += md4.o crypto-objs-$(CONFIG_CRYPTO_MD5) += md5.o -obj-$(CONFIG_CRYPTO_RMD160) += rmd160.o +crypto-objs-$(CONFIG_CRYPTO_RMD160) += rmd160.o obj-$(CONFIG_CRYPTO_SHA1) += sha1.o crypto-objs-$(CONFIG_CRYPTO_SHA256) += sha256.o crypto-objs-$(CONFIG_CRYPTO_SHA512) += sha512.o
crypto/rmd160.c +2 -2
@@ -342,8 +342,8 @@ static void __exit rmd160_mod_fini(void)crypto_unregister_shash (&alg); } -module_init (rmd160_mod_init); -module_exit (rmd160_mod_fini); +crypto_module_init (rmd160_mod_init); +crypto_module_exit (rmd160_mod_fini);MODULE_LICENSE ("GPL" );MODULE_AUTHOR ("Adrian-Ken Rueegsegger <[email protected]>" );
Signature · 1 line
2.47.3
PATCH 45/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_SHA1 crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_SHA1-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/sha1.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -79,7 +79,7 @@ crypto-objs-$(CONFIG_CRYPTO_NULL) += crypto_null.o crypto-objs-$(CONFIG_CRYPTO_MD4) += md4.o crypto-objs-$(CONFIG_CRYPTO_MD5) += md5.o crypto-objs-$(CONFIG_CRYPTO_RMD160) += rmd160.o -obj-$(CONFIG_CRYPTO_SHA1) += sha1.o +crypto-objs-$(CONFIG_CRYPTO_SHA1) += sha1.o crypto-objs-$(CONFIG_CRYPTO_SHA256) += sha256.o crypto-objs-$(CONFIG_CRYPTO_SHA512) += sha512.o crypto-objs-$(CONFIG_CRYPTO_SHA3) += sha3.o
crypto/sha1.c +2 -2
@@ -223,13 +223,13 @@ static int __init crypto_sha1_mod_init(void) {return crypto_register_shashes (algs,ARRAY_SIZE (algs)); } -module_init (crypto_sha1_mod_init); +crypto_module_init (crypto_sha1_mod_init); static void __exit crypto_sha1_mod_exit(void) {crypto_unregister_shashes (algs,ARRAY_SIZE (algs)); } -module_exit (crypto_sha1_mod_exit); +crypto_module_exit (crypto_sha1_mod_exit);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("Crypto API support for SHA-1 and HMAC-SHA1" );
Signature · 1 line
2.47.3
PATCH 46/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_SM3_GENERIC crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_SM3_GENERIC-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/sm3_generic.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -83,7 +83,7 @@ crypto-objs-$(CONFIG_CRYPTO_SHA1) += sha1.o crypto-objs-$(CONFIG_CRYPTO_SHA256) += sha256.o crypto-objs-$(CONFIG_CRYPTO_SHA512) += sha512.o crypto-objs-$(CONFIG_CRYPTO_SHA3) += sha3.o -obj-$(CONFIG_CRYPTO_SM3_GENERIC) += sm3_generic.o +crypto-objs-$(CONFIG_CRYPTO_SM3_GENERIC) += sm3_generic.o obj-$(CONFIG_CRYPTO_STREEBOG) += streebog_generic.o obj-$(CONFIG_CRYPTO_WP512) += wp512.o CFLAGS_wp512.o := $(call cc-option,-fno-schedule-insns) # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79149
crypto/sm3_generic.c +2 -2
@@ -62,8 +62,8 @@ static void __exit sm3_generic_mod_fini(void)crypto_unregister_shash (&sm3_alg); } -module_init (sm3_generic_mod_init); -module_exit (sm3_generic_mod_fini); +crypto_module_init (sm3_generic_mod_init); +crypto_module_exit (sm3_generic_mod_fini);MODULE_LICENSE ("GPL v2" );MODULE_DESCRIPTION ("SM3 Secure Hash Algorithm" );
Signature · 1 line
2.47.3
PATCH 47/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_STREEBOG crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_STREEBOG-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/streebog_generic.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -84,7 +84,7 @@ crypto-objs-$(CONFIG_CRYPTO_SHA256) += sha256.o crypto-objs-$(CONFIG_CRYPTO_SHA512) += sha512.o crypto-objs-$(CONFIG_CRYPTO_SHA3) += sha3.o crypto-objs-$(CONFIG_CRYPTO_SM3_GENERIC) += sm3_generic.o -obj-$(CONFIG_CRYPTO_STREEBOG) += streebog_generic.o +crypto-objs-$(CONFIG_CRYPTO_STREEBOG) += streebog_generic.o obj-$(CONFIG_CRYPTO_WP512) += wp512.o CFLAGS_wp512.o := $(call cc-option,-fno-schedule-insns) # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79149 obj-$(CONFIG_CRYPTO_BLAKE2B) += blake2b.o
crypto/streebog_generic.c +2 -2
@@ -1061,8 +1061,8 @@ static void __exit streebog_mod_fini(void)crypto_unregister_shashes (algs,ARRAY_SIZE (algs)); } -module_init (streebog_mod_init); -module_exit (streebog_mod_fini); +crypto_module_init (streebog_mod_init); +crypto_module_exit (streebog_mod_fini);MODULE_LICENSE ("GPL" );MODULE_AUTHOR ("Vitaly Chikunov <[email protected]>" );
Signature · 1 line
2.47.3
PATCH 48/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_WP512 crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_WP512-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/wp512.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -85,7 +85,7 @@ crypto-objs-$(CONFIG_CRYPTO_SHA512) += sha512.o crypto-objs-$(CONFIG_CRYPTO_SHA3) += sha3.o crypto-objs-$(CONFIG_CRYPTO_SM3_GENERIC) += sm3_generic.o crypto-objs-$(CONFIG_CRYPTO_STREEBOG) += streebog_generic.o -obj-$(CONFIG_CRYPTO_WP512) += wp512.o +crypto-objs-$(CONFIG_CRYPTO_WP512) += wp512.o CFLAGS_wp512.o := $(call cc-option,-fno-schedule-insns) # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79149 obj-$(CONFIG_CRYPTO_BLAKE2B) += blake2b.o crypto-objs-$(CONFIG_CRYPTO_ECB) += ecb.o
crypto/wp512.c +2 -2
@@ -1138,8 +1138,8 @@ MODULE_ALIAS_CRYPTO("wp512");MODULE_ALIAS_CRYPTO ("wp384" );MODULE_ALIAS_CRYPTO ("wp256" ); -module_init (wp512_mod_init); -module_exit (wp512_mod_fini); +crypto_module_init (wp512_mod_init); +crypto_module_exit (wp512_mod_fini);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("Whirlpool Message Digest Algorithm" );
Signature · 1 line
2.47.3
PATCH 49/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_BLAKE2B crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_BLAKE2B-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/blake2b.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -87,7 +87,7 @@ crypto-objs-$(CONFIG_CRYPTO_SM3_GENERIC) += sm3_generic.o crypto-objs-$(CONFIG_CRYPTO_STREEBOG) += streebog_generic.o crypto-objs-$(CONFIG_CRYPTO_WP512) += wp512.o CFLAGS_wp512.o := $(call cc-option,-fno-schedule-insns) # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79149 -obj-$(CONFIG_CRYPTO_BLAKE2B) += blake2b.o +crypto-objs-$(CONFIG_CRYPTO_BLAKE2B) += blake2b.o crypto-objs-$(CONFIG_CRYPTO_ECB) += ecb.o crypto-objs-$(CONFIG_CRYPTO_CBC) += cbc.o obj-$(CONFIG_CRYPTO_PCBC) += pcbc.o
crypto/blake2b.c +2 -2
@@ -90,13 +90,13 @@ static int __init crypto_blake2b_mod_init(void) {return crypto_register_shashes (algs,ARRAY_SIZE (algs)); } -module_init (crypto_blake2b_mod_init); +crypto_module_init (crypto_blake2b_mod_init); static void __exit crypto_blake2b_mod_exit(void) {crypto_unregister_shashes (algs,ARRAY_SIZE (algs)); } -module_exit (crypto_blake2b_mod_exit); +crypto_module_exit (crypto_blake2b_mod_exit);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("Crypto API support for BLAKE2b" );
Signature · 1 line
2.47.3
PATCH 50/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_PCBC crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_PCBC-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/pcbc.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -90,7 +90,7 @@ CFLAGS_wp512.o := $(call cc-option,-fno-schedule-insns) # https://gcc.gnu.org/b crypto-objs-$(CONFIG_CRYPTO_BLAKE2B) += blake2b.o crypto-objs-$(CONFIG_CRYPTO_ECB) += ecb.o crypto-objs-$(CONFIG_CRYPTO_CBC) += cbc.o -obj-$(CONFIG_CRYPTO_PCBC) += pcbc.o +crypto-objs-$(CONFIG_CRYPTO_PCBC) += pcbc.o obj-$(CONFIG_CRYPTO_CTS) += cts.o obj-$(CONFIG_CRYPTO_LRW) += lrw.o obj-$(CONFIG_CRYPTO_XTS) += xts.o
crypto/pcbc.c +2 -2
@@ -186,8 +186,8 @@ static void __exit crypto_pcbc_module_exit(void)crypto_unregister_template (&crypto_pcbc_tmpl); } -module_init (crypto_pcbc_module_init); -module_exit (crypto_pcbc_module_exit); +crypto_module_init (crypto_pcbc_module_init); +crypto_module_exit (crypto_pcbc_module_exit);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("PCBC block cipher mode of operation" );
Signature · 1 line
2.47.3
PATCH 51/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_CTS crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_CTS-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/cts.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -91,7 +91,7 @@ crypto-objs-$(CONFIG_CRYPTO_BLAKE2B) += blake2b.o crypto-objs-$(CONFIG_CRYPTO_ECB) += ecb.o crypto-objs-$(CONFIG_CRYPTO_CBC) += cbc.o crypto-objs-$(CONFIG_CRYPTO_PCBC) += pcbc.o -obj-$(CONFIG_CRYPTO_CTS) += cts.o +crypto-objs-$(CONFIG_CRYPTO_CTS) += cts.o obj-$(CONFIG_CRYPTO_LRW) += lrw.o obj-$(CONFIG_CRYPTO_XTS) += xts.o crypto-objs-$(CONFIG_CRYPTO_CTR) += ctr.o
crypto/cts.c +2 -2
@@ -402,8 +402,8 @@ static void __exit crypto_cts_module_exit(void)crypto_unregister_template (&crypto_cts_tmpl); } -module_init (crypto_cts_module_init); -module_exit (crypto_cts_module_exit); +crypto_module_init (crypto_cts_module_init); +crypto_module_exit (crypto_cts_module_exit);MODULE_LICENSE ("Dual BSD/GPL" );MODULE_DESCRIPTION ("CTS-CBC CipherText Stealing for CBC" );
Signature · 1 line
2.47.3
PATCH 52/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_LRW crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_LRW-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/lrw.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -92,7 +92,7 @@ crypto-objs-$(CONFIG_CRYPTO_ECB) += ecb.o crypto-objs-$(CONFIG_CRYPTO_CBC) += cbc.o crypto-objs-$(CONFIG_CRYPTO_PCBC) += pcbc.o crypto-objs-$(CONFIG_CRYPTO_CTS) += cts.o -obj-$(CONFIG_CRYPTO_LRW) += lrw.o +crypto-objs-$(CONFIG_CRYPTO_LRW) += lrw.o obj-$(CONFIG_CRYPTO_XTS) += xts.o crypto-objs-$(CONFIG_CRYPTO_CTR) += ctr.o obj-$(CONFIG_CRYPTO_XCTR) += xctr.o
crypto/lrw.c +2 -2
@@ -420,8 +420,8 @@ static void __exit lrw_module_exit(void)crypto_unregister_template (&lrw_tmpl); } -module_init (lrw_module_init); -module_exit (lrw_module_exit); +crypto_module_init (lrw_module_init); +crypto_module_exit (lrw_module_exit);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("LRW block cipher mode" );
Signature · 1 line
2.47.3
PATCH 53/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_XTS crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_XTS-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/xts.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -93,7 +93,7 @@ crypto-objs-$(CONFIG_CRYPTO_CBC) += cbc.o crypto-objs-$(CONFIG_CRYPTO_PCBC) += pcbc.o crypto-objs-$(CONFIG_CRYPTO_CTS) += cts.o crypto-objs-$(CONFIG_CRYPTO_LRW) += lrw.o -obj-$(CONFIG_CRYPTO_XTS) += xts.o +crypto-objs-$(CONFIG_CRYPTO_XTS) += xts.o crypto-objs-$(CONFIG_CRYPTO_CTR) += ctr.o obj-$(CONFIG_CRYPTO_XCTR) += xctr.o obj-$(CONFIG_CRYPTO_HCTR2) += hctr2.o
crypto/xts.c +2 -2
@@ -466,8 +466,8 @@ static void __exit xts_module_exit(void)crypto_unregister_template (&xts_tmpl); } -module_init (xts_module_init); -module_exit (xts_module_exit); +crypto_module_init (xts_module_init); +crypto_module_exit (xts_module_exit);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("XTS block cipher mode" );
Signature · 1 line
2.47.3
PATCH 54/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_XCTR and CONFIG_CRYPTO_HCTR2 crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_XCTR- and CONFIG_CRYPTO_HCTR2-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 4 ++-- crypto/hctr2.c | 4 ++-- crypto/xctr.c | 4 ++-- 3 files changed, 6 insertions(+), 6 deletions(-)
crypto/Makefile +2 -2
@@ -95,8 +95,8 @@ crypto-objs-$(CONFIG_CRYPTO_CTS) += cts.o crypto-objs-$(CONFIG_CRYPTO_LRW) += lrw.o crypto-objs-$(CONFIG_CRYPTO_XTS) += xts.o crypto-objs-$(CONFIG_CRYPTO_CTR) += ctr.o -obj-$(CONFIG_CRYPTO_XCTR) += xctr.o -obj-$(CONFIG_CRYPTO_HCTR2) += hctr2.o +crypto-objs-$(CONFIG_CRYPTO_XCTR) += xctr.o +crypto-objs-$(CONFIG_CRYPTO_HCTR2) += hctr2.o obj-$(CONFIG_CRYPTO_ADIANTUM) += adiantum.o crypto-objs-$(CONFIG_CRYPTO_GCM) += gcm.o crypto-objs-$(CONFIG_CRYPTO_CCM) += ccm.o
crypto/hctr2.c +2 -2
@@ -472,8 +472,8 @@ static void __exit hctr2_module_exit(void) ARRAY_SIZE(hctr2_tmpls)); } -module_init (hctr2_module_init); -module_exit (hctr2_module_exit); +crypto_module_init (hctr2_module_init); +crypto_module_exit (hctr2_module_exit);MODULE_DESCRIPTION ("HCTR2 length-preserving encryption mode" );MODULE_LICENSE ("GPL v2" );
crypto/xctr.c +2 -2
@@ -182,8 +182,8 @@ static void __exit crypto_xctr_module_exit(void)crypto_unregister_template (&crypto_xctr_tmpl); } -module_init (crypto_xctr_module_init); -module_exit (crypto_xctr_module_exit); +crypto_module_init (crypto_xctr_module_init); +crypto_module_exit (crypto_xctr_module_exit);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("XCTR block cipher mode of operation" );
Signature · 1 line
2.47.3
PATCH 55/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_ADIANTUM crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_ADIANTUM-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/adiantum.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -97,7 +97,7 @@ crypto-objs-$(CONFIG_CRYPTO_XTS) += xts.o crypto-objs-$(CONFIG_CRYPTO_CTR) += ctr.o crypto-objs-$(CONFIG_CRYPTO_XCTR) += xctr.o crypto-objs-$(CONFIG_CRYPTO_HCTR2) += hctr2.o -obj-$(CONFIG_CRYPTO_ADIANTUM) += adiantum.o +crypto-objs-$(CONFIG_CRYPTO_ADIANTUM) += adiantum.o crypto-objs-$(CONFIG_CRYPTO_GCM) += gcm.o crypto-objs-$(CONFIG_CRYPTO_CCM) += ccm.o obj-$(CONFIG_CRYPTO_CHACHA20POLY1305) += chacha20poly1305.o
crypto/adiantum.c +2 -2
@@ -683,8 +683,8 @@ static void __exit adiantum_module_exit(void)crypto_unregister_template (&adiantum_tmpl); } -module_init (adiantum_module_init); -module_exit (adiantum_module_exit); +crypto_module_init (adiantum_module_init); +crypto_module_exit (adiantum_module_exit);MODULE_DESCRIPTION ("Adiantum length-preserving encryption mode" );MODULE_LICENSE ("GPL v2" );
Signature · 1 line
2.47.3
PATCH 56/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_CHACHA20 crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_CHACHA20-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/chacha.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -147,7 +147,7 @@ obj-$(CONFIG_CRYPTO_KHAZAD) += khazad.o obj-$(CONFIG_CRYPTO_ANUBIS) += anubis.o obj-$(CONFIG_CRYPTO_SEED) += seed.o obj-$(CONFIG_CRYPTO_ARIA) += aria_generic.o -obj-$(CONFIG_CRYPTO_CHACHA20) += chacha.o +crypto-objs-$(CONFIG_CRYPTO_CHACHA20) += chacha.o CFLAGS_chacha.o += -DARCH=$(ARCH) obj-$(CONFIG_CRYPTO_DEFLATE) += deflate.o obj-$(CONFIG_CRYPTO_MICHAEL_MIC) += michael_mic.o
crypto/chacha.c +2 -2
@@ -161,8 +161,8 @@ static void __exit crypto_chacha_mod_fini(void)crypto_unregister_skciphers (algs,ARRAY_SIZE (algs)); } -module_init (crypto_chacha_mod_init); -module_exit (crypto_chacha_mod_fini); +crypto_module_init (crypto_chacha_mod_init); +crypto_module_exit (crypto_chacha_mod_fini);MODULE_LICENSE ("GPL" );MODULE_AUTHOR ("Martin Willi <[email protected]>" );
Signature · 1 line
2.47.3
PATCH 57/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_CHACHA20POLY1305 crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_CHACHA20POLY1305-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/chacha20poly1305.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -100,7 +100,7 @@ crypto-objs-$(CONFIG_CRYPTO_HCTR2) += hctr2.o crypto-objs-$(CONFIG_CRYPTO_ADIANTUM) += adiantum.o crypto-objs-$(CONFIG_CRYPTO_GCM) += gcm.o crypto-objs-$(CONFIG_CRYPTO_CCM) += ccm.o -obj-$(CONFIG_CRYPTO_CHACHA20POLY1305) += chacha20poly1305.o +crypto-objs-$(CONFIG_CRYPTO_CHACHA20POLY1305) += chacha20poly1305.o obj-$(CONFIG_CRYPTO_AEGIS128) += aegis128.o aegis128-y := aegis128-core.o
crypto/chacha20poly1305.c +2 -2
@@ -476,8 +476,8 @@ static void __exit chacha20poly1305_module_exit(void) ARRAY_SIZE(rfc7539_tmpls)); } -module_init (chacha20poly1305_module_init); -module_exit (chacha20poly1305_module_exit); +crypto_module_init (chacha20poly1305_module_init); +crypto_module_exit (chacha20poly1305_module_exit);MODULE_LICENSE ("GPL" );MODULE_AUTHOR ("Martin Willi <[email protected]>" );
Signature · 1 line
2.47.3
PATCH 58/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_AEGIS128 crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_AEGIS128-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/aegis128-core.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -101,7 +101,7 @@ crypto-objs-$(CONFIG_CRYPTO_ADIANTUM) += adiantum.o crypto-objs-$(CONFIG_CRYPTO_GCM) += gcm.o crypto-objs-$(CONFIG_CRYPTO_CCM) += ccm.o crypto-objs-$(CONFIG_CRYPTO_CHACHA20POLY1305) += chacha20poly1305.o -obj-$(CONFIG_CRYPTO_AEGIS128) += aegis128.o +crypto-objs-$(CONFIG_CRYPTO_AEGIS128) += aegis128.o aegis128-y := aegis128-core.o ifeq ($(ARCH),arm)
crypto/aegis128-core.c +2 -2
@@ -566,8 +566,8 @@ static void __exit crypto_aegis128_module_exit(void)crypto_unregister_aead (&crypto_aegis128_alg_generic); } -module_init (crypto_aegis128_module_init); -module_exit (crypto_aegis128_module_exit); +crypto_module_init (crypto_aegis128_module_init); +crypto_module_exit (crypto_aegis128_module_exit);MODULE_LICENSE ("GPL" );MODULE_AUTHOR ("Ondrej Mosnacek <[email protected]>" );
Signature · 1 line
2.47.3
PATCH 59/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_PCRYPT crypto
In reply to Jay WangFrom: Vegard Nossum <[email protected]>
Apply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_PCRYPT-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/pcrypt.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -124,7 +124,7 @@ endif # Enable <arm_neon.h> CFLAGS_aegis128-neon-inner.o += -isystem $(shell $(CC) -print-file-name=include) -obj-$(CONFIG_CRYPTO_PCRYPT) += pcrypt.o +crypto-objs-$(CONFIG_CRYPTO_PCRYPT) += pcrypt.o obj-$(CONFIG_CRYPTO_CRYPTD) += cryptd.o obj-$(CONFIG_CRYPTO_DES) += des_generic.o obj-$(CONFIG_CRYPTO_FCRYPT) += fcrypt.o
crypto/pcrypt.c +2 -2
@@ -378,8 +378,8 @@ static void __exit pcrypt_exit(void)kset_unregister (pcrypt_kset); } -module_init (pcrypt_init); -module_exit (pcrypt_exit); +crypto_module_init (pcrypt_init); +crypto_module_exit (pcrypt_exit);MODULE_LICENSE ("GPL" );MODULE_AUTHOR ("Steffen Klassert <[email protected]>" );
Signature · 1 line
2.47.3
PATCH 60/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_CRYPTD crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_CRYPTD-related crypto to convert them into pluggable interface.
This patch is partially based on work by Vegard Nossum, with modifications. Unlike the original, we do not include DEFINE_CRYPTO_API since only one copy of the crypto symbols is kept, either in the crypto module or in the main kernel, and we ensure such wrapper do not have impact on crypto already chosen built as module.
--- crypto/Makefile | 2 +- crypto/cryptd.c | 4 +-- crypto/fips140/fips140-api.c | 22 ++++++++++++++ include/crypto/cryptd.h | 56 +++++++++++++++++++++++++----------- 4 files changed, 65 insertions(+), 19 deletions(-)
crypto/Makefile +1 -1
@@ -125,7 +125,7 @@ endif CFLAGS_aegis128-neon-inner.o += -isystem $(shell $(CC) -print-file-name=include) crypto-objs-$(CONFIG_CRYPTO_PCRYPT) += pcrypt.o -obj-$(CONFIG_CRYPTO_CRYPTD) += cryptd.o +crypto-objs-$(CONFIG_CRYPTO_CRYPTD) += cryptd.o obj-$(CONFIG_CRYPTO_DES) += des_generic.o obj-$(CONFIG_CRYPTO_FCRYPT) += fcrypt.o obj-$(CONFIG_CRYPTO_BLOWFISH) += blowfish_generic.o
crypto/cryptd.c +2 -2
@@ -1145,8 +1145,8 @@ static void __exit cryptd_exit(void)crypto_unregister_template (&cryptd_tmpl); } -module_init (cryptd_init); -module_exit (cryptd_exit); +crypto_module_init (cryptd_init); +crypto_module_exit (cryptd_exit);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("Software async crypto daemon" );
crypto/fips140/fips140-api.c +22 -0
@@ -622,3 +622,25 @@ DEFINE_CRYPTO_API_STUB(ecc_point_is_zero);DEFINE_CRYPTO_API_STUB (ecc_point_mult_shamir);#endif +/* +* crypto/cryptd.c +*/ +#if IS_BUILTIN (CONFIG_CRYPTO_CRYPTD ) + +#include <crypto/cryptd.h> + +DEFINE_CRYPTO_API_STUB (cryptd_alloc_skcipher); +DEFINE_CRYPTO_API_STUB (cryptd_skcipher_child); +DEFINE_CRYPTO_API_STUB (cryptd_skcipher_queued); +DEFINE_CRYPTO_API_STUB (cryptd_free_skcipher); +DEFINE_CRYPTO_API_STUB (cryptd_alloc_ahash); +DEFINE_CRYPTO_API_STUB (cryptd_ahash_child); +DEFINE_CRYPTO_API_STUB (cryptd_shash_desc); +DEFINE_CRYPTO_API_STUB (cryptd_ahash_queued); +DEFINE_CRYPTO_API_STUB (cryptd_free_ahash); +DEFINE_CRYPTO_API_STUB (cryptd_alloc_aead); +DEFINE_CRYPTO_API_STUB (cryptd_aead_child); +DEFINE_CRYPTO_API_STUB (cryptd_aead_queued); +DEFINE_CRYPTO_API_STUB (cryptd_free_aead); + +#endif
include/crypto/cryptd.h +40 -16
84 lines not on this page · raw message
Signature · 1 line
2.47.3
PATCH 61/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_DES crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_DES-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/des_generic.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -126,7 +126,7 @@ CFLAGS_aegis128-neon-inner.o += -isystem $(shell $(CC) -print-file-name=include) crypto-objs-$(CONFIG_CRYPTO_PCRYPT) += pcrypt.o crypto-objs-$(CONFIG_CRYPTO_CRYPTD) += cryptd.o -obj-$(CONFIG_CRYPTO_DES) += des_generic.o +crypto-objs-$(CONFIG_CRYPTO_DES) += des_generic.o obj-$(CONFIG_CRYPTO_FCRYPT) += fcrypt.o obj-$(CONFIG_CRYPTO_BLOWFISH) += blowfish_generic.o obj-$(CONFIG_CRYPTO_BLOWFISH_COMMON) += blowfish_common.o
crypto/des_generic.c +2 -2
@@ -122,8 +122,8 @@ static void __exit des_generic_mod_fini(void)crypto_unregister_algs (des_algs,ARRAY_SIZE (des_algs)); } -module_init (des_generic_mod_init); -module_exit (des_generic_mod_fini); +crypto_module_init (des_generic_mod_init); +crypto_module_exit (des_generic_mod_fini);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("DES & Triple DES EDE Cipher Algorithms" );
Signature · 1 line
2.47.3
PATCH 62/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_FCRYPT crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_FCRYPT-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/fcrypt.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -127,7 +127,7 @@ CFLAGS_aegis128-neon-inner.o += -isystem $(shell $(CC) -print-file-name=include) crypto-objs-$(CONFIG_CRYPTO_PCRYPT) += pcrypt.o crypto-objs-$(CONFIG_CRYPTO_CRYPTD) += cryptd.o crypto-objs-$(CONFIG_CRYPTO_DES) += des_generic.o -obj-$(CONFIG_CRYPTO_FCRYPT) += fcrypt.o +crypto-objs-$(CONFIG_CRYPTO_FCRYPT) += fcrypt.o obj-$(CONFIG_CRYPTO_BLOWFISH) += blowfish_generic.o obj-$(CONFIG_CRYPTO_BLOWFISH_COMMON) += blowfish_common.o obj-$(CONFIG_CRYPTO_TWOFISH) += twofish_generic.o
crypto/fcrypt.c +2 -2
@@ -411,8 +411,8 @@ static void __exit fcrypt_mod_fini(void)crypto_unregister_alg (&fcrypt_alg); } -module_init (fcrypt_mod_init); -module_exit (fcrypt_mod_fini); +crypto_module_init (fcrypt_mod_init); +crypto_module_exit (fcrypt_mod_fini);MODULE_LICENSE ("Dual BSD/GPL" );MODULE_DESCRIPTION ("FCrypt Cipher Algorithm" );
Signature · 1 line
2.47.3
PATCH 63/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_BLOWFISH and CONFIG_CRYPTO_BLOWFISH_COMMON crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_BLOWFISH- and CONFIG_CRYPTO_BLOWFISH_COMMON-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 4 ++-- crypto/blowfish_generic.c | 4 ++-- crypto/fips140/fips140-api.c | 10 ++++++++++ include/crypto/blowfish.h | 6 ++++-- 4 files changed, 18 insertions(+), 6 deletions(-)
crypto/Makefile +2 -2
@@ -128,8 +128,8 @@ crypto-objs-$(CONFIG_CRYPTO_PCRYPT) += pcrypt.o crypto-objs-$(CONFIG_CRYPTO_CRYPTD) += cryptd.o crypto-objs-$(CONFIG_CRYPTO_DES) += des_generic.o crypto-objs-$(CONFIG_CRYPTO_FCRYPT) += fcrypt.o -obj-$(CONFIG_CRYPTO_BLOWFISH) += blowfish_generic.o -obj-$(CONFIG_CRYPTO_BLOWFISH_COMMON) += blowfish_common.o +crypto-objs-$(CONFIG_CRYPTO_BLOWFISH) += blowfish_generic.o +crypto-objs-$(CONFIG_CRYPTO_BLOWFISH_COMMON) += blowfish_common.o obj-$(CONFIG_CRYPTO_TWOFISH) += twofish_generic.o obj-$(CONFIG_CRYPTO_TWOFISH_COMMON) += twofish_common.o obj-$(CONFIG_CRYPTO_SERPENT) += serpent_generic.o
crypto/blowfish_generic.c +2 -2
@@ -124,8 +124,8 @@ static void __exit blowfish_mod_fini(void)crypto_unregister_alg (&alg); } -module_init (blowfish_mod_init); -module_exit (blowfish_mod_fini); +crypto_module_init (blowfish_mod_init); +crypto_module_exit (blowfish_mod_fini);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("Blowfish Cipher Algorithm" );
crypto/fips140/fips140-api.c +10 -0
@@ -644,3 +644,13 @@ DEFINE_CRYPTO_API_STUB(cryptd_aead_queued);DEFINE_CRYPTO_API_STUB (cryptd_free_aead);#endif +/* +* crypto/blowfish_common.c +*/ +#if IS_BUILTIN (CONFIG_CRYPTO_BLOWFISH_COMMON ) + +#include <crypto/blowfish.h> + +DEFINE_CRYPTO_API_STUB (blowfish_setkey); + +#endif
include/crypto/blowfish.h +4 -2
@@ -6,6 +6,7 @@#ifndef _CRYPTO_BLOWFISH_H#define _CRYPTO_BLOWFISH_H +#include <crypto/api.h> #include <linux/types.h> #include <linux/crypto.h>
@@ -18,7 +19,8 @@ struct bf_ctx {u32 s[1024 ]; }; -int blowfish_setkey (struct crypto_tfm *tfm,const u8 *key, -unsigned int key_len); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_BLOWFISH_COMMON , blowfish_setkey, int, + (struct crypto_tfm *tfm, const u8 *key, unsigned int key_len), + (tfm, key, key_len));#endif
Signature · 1 line
2.47.3
PATCH 64/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_SM4 and CONFIG_CRYPTO_SM4_GENERIC crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_SM4- and CONFIG_CRYPTO_SM4_GENERIC-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 4 ++-- crypto/fips140/fips140-api.c | 18 ++++++++++++++++++ crypto/sm4_generic.c | 4 ++-- include/crypto/sm4.h | 22 ++++++++++++++++------ 4 files changed, 38 insertions(+), 10 deletions(-)
crypto/Makefile +2 -2
@@ -135,8 +135,8 @@ obj-$(CONFIG_CRYPTO_TWOFISH_COMMON) += twofish_common.o obj-$(CONFIG_CRYPTO_SERPENT) += serpent_generic.o CFLAGS_serpent_generic.o := $(call cc-option,-fsched-pressure) # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79149 crypto-objs-$(CONFIG_CRYPTO_AES) += aes.o -obj-$(CONFIG_CRYPTO_SM4) += sm4.o -obj-$(CONFIG_CRYPTO_SM4_GENERIC) += sm4_generic.o +crypto-objs-$(CONFIG_CRYPTO_SM4) += sm4.o +crypto-objs-$(CONFIG_CRYPTO_SM4_GENERIC) += sm4_generic.o obj-$(CONFIG_CRYPTO_CAMELLIA) += camellia_generic.o obj-$(CONFIG_CRYPTO_CAST_COMMON) += cast_common.o obj-$(CONFIG_CRYPTO_CAST5) += cast5_generic.o
crypto/fips140/fips140-api.c +18 -0
@@ -654,3 +654,21 @@ DEFINE_CRYPTO_API_STUB(cryptd_free_aead);DEFINE_CRYPTO_API_STUB (blowfish_setkey);#endif +/* +* crypto/sm4.c +*/ +#if IS_BUILTIN (CONFIG_CRYPTO_SM4 ) + +#include <crypto/sm4.h> + +#undef crypto_sm4_fk +#undef crypto_sm4_ck +#undef crypto_sm4_sbox +DEFINE_CRYPTO_VAR_STUB (crypto_sm4_fk); +DEFINE_CRYPTO_VAR_STUB (crypto_sm4_ck); +DEFINE_CRYPTO_VAR_STUB (crypto_sm4_sbox); + +DEFINE_CRYPTO_API_STUB (sm4_expandkey); +DEFINE_CRYPTO_API_STUB (sm4_crypt_block); + +#endif
crypto/sm4_generic.c +2 -2
@@ -83,8 +83,8 @@ static void __exit sm4_fini(void)crypto_unregister_alg (&sm4_alg); } -module_init (sm4_init); -module_exit (sm4_fini); +crypto_module_init (sm4_init); +crypto_module_exit (sm4_fini);MODULE_DESCRIPTION ("SM4 Cipher Algorithm" );MODULE_LICENSE ("GPL v2" );
include/crypto/sm4.h +16 -6
@@ -9,6 +9,7 @@#ifndef _CRYPTO_SM4_H#define _CRYPTO_SM4_H +#include <crypto/api.h> #include <linux/types.h> #include <linux/crypto.h>
@@ -21,9 +22,15 @@ struct sm4_ctx {u32 rkey_dec[SM4_RKEY_WORDS ]; }; -extern const u32 crypto_sm4_fk[]; -extern const u32 crypto_sm4_ck[]; -extern const u8 crypto_sm4_sbox[]; +DECLARE_CRYPTO_VAR(CONFIG_CRYPTO_SM4, crypto_sm4_fk, const u32, [4]); +DECLARE_CRYPTO_VAR(CONFIG_CRYPTO_SM4, crypto_sm4_ck, const u32, [32]); +DECLARE_CRYPTO_VAR(CONFIG_CRYPTO_SM4, crypto_sm4_sbox, const u8, [256]); + +#if defined(CONFIG_CRYPTO_FIPS140_EXTMOD ) && !defined(FIPS_MODULE ) &&IS_BUILTIN (CONFIG_CRYPTO_SM4 ) +#define crypto_sm4_fk (((const u32*)CRYPTO_VAR_NAME(crypto_sm4_fk))) +#define crypto_sm4_ck (((const u32*)CRYPTO_VAR_NAME(crypto_sm4_ck))) +#define crypto_sm4_sbox (((const u8*)CRYPTO_VAR_NAME(crypto_sm4_sbox))) +#endif /** * sm4_expandkey - Expands the SM4 key as described in GB/T 32907-2016
@@ -34,8 +41,9 @@ extern const u8 crypto_sm4_sbox[];* Returns 0 on success. The function fails only if an invalid key size (or * pointer) is supplied. */ -int sm4_expandkey (struct sm4_ctx *ctx,const u8 *in_key, -unsigned int key_len); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_SM4 , sm4_expandkey, int, + (struct sm4_ctx *ctx, const u8 *in_key, unsigned int key_len), + (ctx, in_key, key_len));/** * sm4_crypt_block - Encrypt or decrypt a single SM4 block
@@ -43,6 +51,8 @@ int sm4_expandkey(struct sm4_ctx *ctx, const u8 *in_key,* @out: Buffer to store output data * @in: Buffer containing the input data */ -void sm4_crypt_block (const u32 *rk,u8 *out,const u8 *in); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_SM4 , sm4_crypt_block, void, + (const u32 *rk, u8 *out, const u8 *in), + (rk, out, in));#endif
Signature · 1 line
2.47.3
PATCH 65/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_TWOFISH and CONFIG_CRYPTO_TWOFISH_COMMON crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_TWOFISH- and CONFIG_CRYPTO_TWOFISH_COMMON-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 4 ++-- crypto/fips140/fips140-api.c | 11 +++++++++++ crypto/twofish_generic.c | 4 ++-- include/crypto/twofish.h | 11 ++++++++--- 4 files changed, 23 insertions(+), 7 deletions(-)
crypto/Makefile +2 -2
@@ -130,8 +130,8 @@ crypto-objs-$(CONFIG_CRYPTO_DES) += des_generic.o crypto-objs-$(CONFIG_CRYPTO_FCRYPT) += fcrypt.o crypto-objs-$(CONFIG_CRYPTO_BLOWFISH) += blowfish_generic.o crypto-objs-$(CONFIG_CRYPTO_BLOWFISH_COMMON) += blowfish_common.o -obj-$(CONFIG_CRYPTO_TWOFISH) += twofish_generic.o -obj-$(CONFIG_CRYPTO_TWOFISH_COMMON) += twofish_common.o +crypto-objs-$(CONFIG_CRYPTO_TWOFISH) += twofish_generic.o +crypto-objs-$(CONFIG_CRYPTO_TWOFISH_COMMON) += twofish_common.o obj-$(CONFIG_CRYPTO_SERPENT) += serpent_generic.o CFLAGS_serpent_generic.o := $(call cc-option,-fsched-pressure) # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79149 crypto-objs-$(CONFIG_CRYPTO_AES) += aes.o
crypto/fips140/fips140-api.c +11 -0
@@ -672,3 +672,14 @@ DEFINE_CRYPTO_API_STUB(sm4_expandkey);DEFINE_CRYPTO_API_STUB (sm4_crypt_block);#endif +/* +* crypto/twofish_common.c +*/ +#if IS_BUILTIN (CONFIG_CRYPTO_TWOFISH_COMMON ) + +#include <crypto/twofish.h> + +DEFINE_CRYPTO_API_STUB (__twofish_setkey); +DEFINE_CRYPTO_API_STUB (twofish_setkey); + +#endif
crypto/twofish_generic.c +2 -2
@@ -187,8 +187,8 @@ static void __exit twofish_mod_fini(void)crypto_unregister_alg (&alg); } -module_init (twofish_mod_init); -module_exit (twofish_mod_fini); +crypto_module_init (twofish_mod_init); +crypto_module_exit (twofish_mod_fini);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("Twofish Cipher Algorithm" );
include/crypto/twofish.h +8 -3
@@ -2,6 +2,7 @@#ifndef _CRYPTO_TWOFISH_H#define _CRYPTO_TWOFISH_H +#include <crypto/api.h> #include <linux/types.h> #define TF_MIN_KEY_SIZE 16
@@ -18,8 +19,12 @@ struct twofish_ctx {u32 s[4 ][256 ], w[8 ], k[32 ]; }; -int __twofish_setkey (struct twofish_ctx *ctx,const u8 *key, -unsigned int key_len); -int twofish_setkey (struct crypto_tfm *tfm,const u8 *key,unsigned int key_len); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_TWOFISH_COMMON , __twofish_setkey, int, + (struct twofish_ctx *ctx, const u8 *key, unsigned int key_len), + (ctx, key, key_len)); + +DECLARE_CRYPTO_API (CONFIG_CRYPTO_TWOFISH_COMMON , twofish_setkey, int, + (struct crypto_tfm *tfm, const u8 *key, unsigned int key_len), + (tfm, key, key_len));#endif
Signature · 1 line
2.47.3
PATCH 66/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_SERPENT crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_SERPENT-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/fips140/fips140-api.c | 13 +++++++++++++ crypto/serpent_generic.c | 4 ++-- include/crypto/serpent.h | 20 +++++++++++++++----- 4 files changed, 31 insertions(+), 8 deletions(-)
crypto/Makefile +1 -1
@@ -132,7 +132,7 @@ crypto-objs-$(CONFIG_CRYPTO_BLOWFISH) += blowfish_generic.o crypto-objs-$(CONFIG_CRYPTO_BLOWFISH_COMMON) += blowfish_common.o crypto-objs-$(CONFIG_CRYPTO_TWOFISH) += twofish_generic.o crypto-objs-$(CONFIG_CRYPTO_TWOFISH_COMMON) += twofish_common.o -obj-$(CONFIG_CRYPTO_SERPENT) += serpent_generic.o +crypto-objs-$(CONFIG_CRYPTO_SERPENT) += serpent_generic.o CFLAGS_serpent_generic.o := $(call cc-option,-fsched-pressure) # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79149 crypto-objs-$(CONFIG_CRYPTO_AES) += aes.o crypto-objs-$(CONFIG_CRYPTO_SM4) += sm4.o
crypto/fips140/fips140-api.c +13 -0
@@ -683,3 +683,16 @@ DEFINE_CRYPTO_API_STUB(__twofish_setkey);DEFINE_CRYPTO_API_STUB (twofish_setkey);#endif +/* +* crypto/serpent_generic.c +*/ +#if IS_BUILTIN (CONFIG_CRYPTO_SERPENT ) + +#include <crypto/serpent.h> + +DEFINE_CRYPTO_API_STUB (__serpent_setkey); +DEFINE_CRYPTO_API_STUB (serpent_setkey); +DEFINE_CRYPTO_API_STUB (__serpent_encrypt); +DEFINE_CRYPTO_API_STUB (__serpent_decrypt); + +#endif
crypto/serpent_generic.c +2 -2
@@ -599,8 +599,8 @@ static void __exit serpent_mod_fini(void)crypto_unregister_alg (&srp_alg); } -module_init (serpent_mod_init); -module_exit (serpent_mod_fini); +crypto_module_init (serpent_mod_init); +crypto_module_exit (serpent_mod_fini);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("Serpent Cipher Algorithm" );
include/crypto/serpent.h +15 -5
@@ -6,6 +6,7 @@#ifndef _CRYPTO_SERPENT_H#define _CRYPTO_SERPENT_H +#include <crypto/api.h> #include <linux/types.h> #include <linux/crypto.h>
@@ -18,11 +19,20 @@ struct serpent_ctx {u32 expkey[SERPENT_EXPKEY_WORDS ]; }; -int __serpent_setkey (struct serpent_ctx *ctx,const u8 *key, -unsigned int keylen); -int serpent_setkey (struct crypto_tfm *tfm,const u8 *key,unsigned int keylen); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_SERPENT , __serpent_setkey, int, + (struct serpent_ctx *ctx, const u8 *key, unsigned int keylen), + (ctx, key, keylen)); -void __serpent_encrypt (const void *ctx,u8 *dst,const u8 *src); -void __serpent_decrypt (const void *ctx,u8 *dst,const u8 *src); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_SERPENT , serpent_setkey, int, + (struct crypto_tfm *tfm, const u8 *key, unsigned int keylen), + (tfm, key, keylen)); + +DECLARE_CRYPTO_API (CONFIG_CRYPTO_SERPENT , __serpent_encrypt, void, + (const void *ctx, u8 *dst, const u8 *src), + (ctx, dst, src)); + +DECLARE_CRYPTO_API (CONFIG_CRYPTO_SERPENT , __serpent_decrypt, void, + (const void *ctx, u8 *dst, const u8 *src), + (ctx, dst, src));#endif
Signature · 1 line
2.47.3
PATCH 67/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_CAMELLIA crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_CAMELLIA-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/camellia_generic.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -137,7 +137,7 @@ CFLAGS_serpent_generic.o := $(call cc-option,-fsched-pressure) # https://gcc.gn crypto-objs-$(CONFIG_CRYPTO_AES) += aes.o crypto-objs-$(CONFIG_CRYPTO_SM4) += sm4.o crypto-objs-$(CONFIG_CRYPTO_SM4_GENERIC) += sm4_generic.o -obj-$(CONFIG_CRYPTO_CAMELLIA) += camellia_generic.o +crypto-objs-$(CONFIG_CRYPTO_CAMELLIA) += camellia_generic.o obj-$(CONFIG_CRYPTO_CAST_COMMON) += cast_common.o obj-$(CONFIG_CRYPTO_CAST5) += cast5_generic.o obj-$(CONFIG_CRYPTO_CAST6) += cast6_generic.o
crypto/camellia_generic.c +2 -2
@@ -1064,8 +1064,8 @@ static void __exit camellia_fini(void)crypto_unregister_alg (&camellia_alg); } -module_init (camellia_init); -module_exit (camellia_fini); +crypto_module_init (camellia_init); +crypto_module_exit (camellia_fini);MODULE_DESCRIPTION ("Camellia Cipher Algorithm" );MODULE_LICENSE ("GPL" );
Signature · 1 line
2.47.3
PATCH 68/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_CAST_COMMON, CONFIG_CRYPTO_CAST5, CONFIG_CRYPTO_CAST6 crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_CAST_COMMON-, CONFIG_CRYPTO_CAST5-, and CONFIG_CRYPTO_CAST6-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 6 +++--- crypto/cast5_generic.c | 4 ++-- crypto/cast6_generic.c | 4 ++-- crypto/fips140/fips140-api.c | 42 ++++++++++++++++++++++++++++++++++++ include/crypto/cast5.h | 14 +++++++++--- include/crypto/cast6.h | 19 ++++++++++++---- include/crypto/cast_common.h | 17 +++++++++++---- 7 files changed, 88 insertions(+), 18 deletions(-)
crypto/Makefile +3 -3
@@ -138,9 +138,9 @@ crypto-objs-$(CONFIG_CRYPTO_AES) += aes.o crypto-objs-$(CONFIG_CRYPTO_SM4) += sm4.o crypto-objs-$(CONFIG_CRYPTO_SM4_GENERIC) += sm4_generic.o crypto-objs-$(CONFIG_CRYPTO_CAMELLIA) += camellia_generic.o -obj-$(CONFIG_CRYPTO_CAST_COMMON) += cast_common.o -obj-$(CONFIG_CRYPTO_CAST5) += cast5_generic.o -obj-$(CONFIG_CRYPTO_CAST6) += cast6_generic.o +crypto-objs-$(CONFIG_CRYPTO_CAST_COMMON) += cast_common.o +crypto-objs-$(CONFIG_CRYPTO_CAST5) += cast5_generic.o +crypto-objs-$(CONFIG_CRYPTO_CAST6) += cast6_generic.o obj-$(CONFIG_CRYPTO_ARC4) += arc4.o obj-$(CONFIG_CRYPTO_TEA) += tea.o obj-$(CONFIG_CRYPTO_KHAZAD) += khazad.o
crypto/cast5_generic.c +2 -2
@@ -531,8 +531,8 @@ static void __exit cast5_mod_fini(void)crypto_unregister_alg (&alg); } -module_init (cast5_mod_init); -module_exit (cast5_mod_fini); +crypto_module_init (cast5_mod_init); +crypto_module_exit (cast5_mod_fini);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("Cast5 Cipher Algorithm" );
crypto/cast6_generic.c +2 -2
@@ -271,8 +271,8 @@ static void __exit cast6_mod_fini(void)crypto_unregister_alg (&alg); } -module_init (cast6_mod_init); -module_exit (cast6_mod_fini); +crypto_module_init (cast6_mod_init); +crypto_module_exit (cast6_mod_fini);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("Cast6 Cipher Algorithm" );
crypto/fips140/fips140-api.c +42 -0
45 lines not on this page · raw message
include/crypto/cast5.h +11 -3
@@ -2,6 +2,7 @@#ifndef _CRYPTO_CAST5_H#define _CRYPTO_CAST5_H +#include <crypto/api.h> #include <linux/types.h> #include <linux/crypto.h> #include <crypto/cast_common.h>
@@ -16,9 +17,16 @@ struct cast5_ctx {int rr;/* rr ? rounds = 12 : rounds = 16; (rfc 2144) */ }; -int cast5_setkey (struct crypto_tfm *tfm,const u8 *key,unsigned int keylen); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_CAST5 , cast5_setkey, int, + (struct crypto_tfm *tfm, const u8 *key, unsigned int keylen), + (tfm, key, keylen)); -void __cast5_encrypt (struct cast5_ctx *ctx,u8 *dst,const u8 *src); -void __cast5_decrypt (struct cast5_ctx *ctx,u8 *dst,const u8 *src); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_CAST5 , __cast5_encrypt, void, + (struct cast5_ctx *ctx, u8 *dst, const u8 *src), + (ctx, dst, src)); + +DECLARE_CRYPTO_API (CONFIG_CRYPTO_CAST5 , __cast5_decrypt, void, + (struct cast5_ctx *ctx, u8 *dst, const u8 *src), + (ctx, dst, src));#endif
include/crypto/cast6.h +15 -4
@@ -2,6 +2,7 @@#ifndef _CRYPTO_CAST6_H#define _CRYPTO_CAST6_H +#include <crypto/api.h> #include <linux/types.h> #include <linux/crypto.h> #include <crypto/cast_common.h>
@@ -15,10 +16,20 @@ struct cast6_ctx {u8 Kr[12 ][4 ]; }; -int __cast6_setkey (struct cast6_ctx *ctx,const u8 *key,unsigned int keylen); -int cast6_setkey (struct crypto_tfm *tfm,const u8 *key,unsigned int keylen); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_CAST6 , __cast6_setkey, int, + (struct cast6_ctx *ctx, const u8 *key, unsigned int keylen), + (ctx, key, keylen)); -void __cast6_encrypt (const void *ctx,u8 *dst,const u8 *src); -void __cast6_decrypt (const void *ctx,u8 *dst,const u8 *src); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_CAST6 , cast6_setkey, int, + (struct crypto_tfm *tfm, const u8 *key, unsigned int keylen), + (tfm, key, keylen)); + +DECLARE_CRYPTO_API (CONFIG_CRYPTO_CAST6 , __cast6_encrypt, void, + (const void *ctx, u8 *dst, const u8 *src), + (ctx, dst, src)); + +DECLARE_CRYPTO_API (CONFIG_CRYPTO_CAST6 , __cast6_decrypt, void, + (const void *ctx, u8 *dst, const u8 *src), + (ctx, dst, src));#endif
include/crypto/cast_common.h +13 -4
@@ -2,9 +2,18 @@#ifndef _CRYPTO_CAST_COMMON_H#define _CRYPTO_CAST_COMMON_H -extern const u32 cast_s1[256 ]; -extern const u32 cast_s2[256 ]; -extern const u32 cast_s3[256 ]; -extern const u32 cast_s4[256 ]; +#include <crypto/api.h> + +DECLARE_CRYPTO_VAR(CONFIG_CRYPTO_CAST_COMMON, cast_s1, const u32, [256]); +DECLARE_CRYPTO_VAR(CONFIG_CRYPTO_CAST_COMMON, cast_s2, const u32, [256]); +DECLARE_CRYPTO_VAR(CONFIG_CRYPTO_CAST_COMMON, cast_s3, const u32, [256]); +DECLARE_CRYPTO_VAR(CONFIG_CRYPTO_CAST_COMMON, cast_s4, const u32, [256]); + +#if defined(CONFIG_CRYPTO_FIPS140_EXTMOD ) && !defined(FIPS_MODULE ) &&IS_BUILTIN (CONFIG_CRYPTO_CAST_COMMON ) +#define cast_s1 (((const u32*)CRYPTO_VAR_NAME(cast_s1))) +#define cast_s2 (((const u32*)CRYPTO_VAR_NAME(cast_s2))) +#define cast_s3 (((const u32*)CRYPTO_VAR_NAME(cast_s3))) +#define cast_s4 (((const u32*)CRYPTO_VAR_NAME(cast_s4))) +#endif #endif
Signature · 1 line
2.47.3
PATCH 69/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_ARC4 crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_ARC4-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/arc4.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -141,7 +141,7 @@ crypto-objs-$(CONFIG_CRYPTO_CAMELLIA) += camellia_generic.o crypto-objs-$(CONFIG_CRYPTO_CAST_COMMON) += cast_common.o crypto-objs-$(CONFIG_CRYPTO_CAST5) += cast5_generic.o crypto-objs-$(CONFIG_CRYPTO_CAST6) += cast6_generic.o -obj-$(CONFIG_CRYPTO_ARC4) += arc4.o +crypto-objs-$(CONFIG_CRYPTO_ARC4) += arc4.o obj-$(CONFIG_CRYPTO_TEA) += tea.o obj-$(CONFIG_CRYPTO_KHAZAD) += khazad.o obj-$(CONFIG_CRYPTO_ANUBIS) += anubis.o
crypto/arc4.c +2 -2
@@ -73,8 +73,8 @@ static void __exit arc4_exit(void)crypto_unregister_lskcipher (&arc4_alg); } -module_init (arc4_init); -module_exit (arc4_exit); +crypto_module_init (arc4_init); +crypto_module_exit (arc4_exit);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("ARC4 Cipher Algorithm" );
Signature · 1 line
2.47.3
PATCH 70/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_USER_API crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_USER_API-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/af_alg.c | 4 +- crypto/fips140/fips140-api.c | 25 +++++++++++ include/crypto/if_alg.h | 84 ++++++++++++++++++++++++++---------- 4 files changed, 89 insertions(+), 26 deletions(-)
crypto/Makefile +1 -1
@@ -172,7 +172,7 @@ jitterentropy_rng-y := jitterentropy.o jitterentropy-kcapi.o obj-$(CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE) += jitterentropy-testing.o obj-$(CONFIG_CRYPTO_BENCHMARK) += tcrypt.o crypto-objs-$(CONFIG_CRYPTO_GHASH) += ghash-generic.o -obj-$(CONFIG_CRYPTO_USER_API) += af_alg.o +crypto-objs-$(CONFIG_CRYPTO_USER_API) += af_alg.o obj-$(CONFIG_CRYPTO_USER_API_HASH) += algif_hash.o obj-$(CONFIG_CRYPTO_USER_API_SKCIPHER) += algif_skcipher.o obj-$(CONFIG_CRYPTO_USER_API_RNG) += algif_rng.o
crypto/af_alg.c +2 -2
@@ -1322,8 +1322,8 @@ static void __exit af_alg_exit(void)proto_unregister (&alg_proto); } -module_init (af_alg_init); -module_exit (af_alg_exit); +crypto_module_init (af_alg_init); +crypto_module_exit (af_alg_exit);MODULE_DESCRIPTION ("Crypto userspace interface" );MODULE_LICENSE ("GPL" );MODULE_ALIAS_NETPROTO (AF_ALG );
crypto/fips140/fips140-api.c +25 -0
@@ -738,3 +738,28 @@ DEFINE_CRYPTO_API_STUB(__cast6_encrypt);DEFINE_CRYPTO_API_STUB (__cast6_decrypt);#endif +/* +* crypto/af_alg.c +*/ +#if IS_BUILTIN (CONFIG_CRYPTO_USER_API ) + +#include <crypto/if_alg.h> + +DEFINE_CRYPTO_API_STUB (af_alg_register_type); +DEFINE_CRYPTO_API_STUB (af_alg_unregister_type); +DEFINE_CRYPTO_API_STUB (af_alg_release); +DEFINE_CRYPTO_API_STUB (af_alg_release_parent); +DEFINE_CRYPTO_API_STUB (af_alg_accept); +DEFINE_CRYPTO_API_STUB (af_alg_free_sg); +DEFINE_CRYPTO_API_STUB (af_alg_count_tsgl); +DEFINE_CRYPTO_API_STUB (af_alg_pull_tsgl); +DEFINE_CRYPTO_API_STUB (af_alg_wmem_wakeup); +DEFINE_CRYPTO_API_STUB (af_alg_wait_for_data); +DEFINE_CRYPTO_API_STUB (af_alg_sendmsg); +DEFINE_CRYPTO_API_STUB (af_alg_free_resources); +DEFINE_CRYPTO_API_STUB (af_alg_async_cb); +DEFINE_CRYPTO_API_STUB (af_alg_poll); +DEFINE_CRYPTO_API_STUB (af_alg_alloc_areq); +DEFINE_CRYPTO_API_STUB (af_alg_get_rsgl); + +#endif
include/crypto/if_alg.h +61 -23
103 lines not on this page · raw message
Signature · 1 line
2.47.3
PATCH 71/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_USER_API_SKCIPHER crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_USER_API_SKCIPHER-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/algif_skcipher.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -174,7 +174,7 @@ obj-$(CONFIG_CRYPTO_BENCHMARK) += tcrypt.o crypto-objs-$(CONFIG_CRYPTO_GHASH) += ghash-generic.o crypto-objs-$(CONFIG_CRYPTO_USER_API) += af_alg.o obj-$(CONFIG_CRYPTO_USER_API_HASH) += algif_hash.o -obj-$(CONFIG_CRYPTO_USER_API_SKCIPHER) += algif_skcipher.o +crypto-objs-$(CONFIG_CRYPTO_USER_API_SKCIPHER) += algif_skcipher.o obj-$(CONFIG_CRYPTO_USER_API_RNG) += algif_rng.o obj-$(CONFIG_CRYPTO_USER_API_AEAD) += algif_aead.o obj-$(CONFIG_CRYPTO_ZSTD) += zstd.o
crypto/algif_skcipher.c +2 -2
@@ -435,7 +435,7 @@ static void __exit algif_skcipher_exit(void)BUG_ON (err); } -module_init (algif_skcipher_init); -module_exit (algif_skcipher_exit); +crypto_module_init (algif_skcipher_init); +crypto_module_exit (algif_skcipher_exit);MODULE_DESCRIPTION ("Userspace interface for skcipher algorithms" );MODULE_LICENSE ("GPL" );
Signature · 1 line
2.47.3
PATCH 72/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_TEA crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_TEA-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/tea.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -142,7 +142,7 @@ crypto-objs-$(CONFIG_CRYPTO_CAST_COMMON) += cast_common.o crypto-objs-$(CONFIG_CRYPTO_CAST5) += cast5_generic.o crypto-objs-$(CONFIG_CRYPTO_CAST6) += cast6_generic.o crypto-objs-$(CONFIG_CRYPTO_ARC4) += arc4.o -obj-$(CONFIG_CRYPTO_TEA) += tea.o +crypto-objs-$(CONFIG_CRYPTO_TEA) += tea.o obj-$(CONFIG_CRYPTO_KHAZAD) += khazad.o obj-$(CONFIG_CRYPTO_ANUBIS) += anubis.o obj-$(CONFIG_CRYPTO_SEED) += seed.o
crypto/tea.c +2 -2
@@ -255,8 +255,8 @@ MODULE_ALIAS_CRYPTO("tea");MODULE_ALIAS_CRYPTO ("xtea" );MODULE_ALIAS_CRYPTO ("xeta" ); -module_init (tea_mod_init); -module_exit (tea_mod_fini); +crypto_module_init (tea_mod_init); +crypto_module_exit (tea_mod_fini);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("TEA, XTEA & XETA Cryptographic Algorithms" );
Signature · 1 line
2.47.3
PATCH 73/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_KHAZAD crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_KHAZAD-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/khazad.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -143,7 +143,7 @@ crypto-objs-$(CONFIG_CRYPTO_CAST5) += cast5_generic.o crypto-objs-$(CONFIG_CRYPTO_CAST6) += cast6_generic.o crypto-objs-$(CONFIG_CRYPTO_ARC4) += arc4.o crypto-objs-$(CONFIG_CRYPTO_TEA) += tea.o -obj-$(CONFIG_CRYPTO_KHAZAD) += khazad.o +crypto-objs-$(CONFIG_CRYPTO_KHAZAD) += khazad.o obj-$(CONFIG_CRYPTO_ANUBIS) += anubis.o obj-$(CONFIG_CRYPTO_SEED) += seed.o obj-$(CONFIG_CRYPTO_ARIA) += aria_generic.o
crypto/khazad.c +2 -2
@@ -868,8 +868,8 @@ static void __exit khazad_mod_fini(void) } -module_init (khazad_mod_init); -module_exit (khazad_mod_fini); +crypto_module_init (khazad_mod_init); +crypto_module_exit (khazad_mod_fini);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("Khazad Cryptographic Algorithm" );
Signature · 1 line
2.47.3
PATCH 74/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_ANUBIS crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_ANUBIS-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/anubis.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -144,7 +144,7 @@ crypto-objs-$(CONFIG_CRYPTO_CAST6) += cast6_generic.o crypto-objs-$(CONFIG_CRYPTO_ARC4) += arc4.o crypto-objs-$(CONFIG_CRYPTO_TEA) += tea.o crypto-objs-$(CONFIG_CRYPTO_KHAZAD) += khazad.o -obj-$(CONFIG_CRYPTO_ANUBIS) += anubis.o +crypto-objs-$(CONFIG_CRYPTO_ANUBIS) += anubis.o obj-$(CONFIG_CRYPTO_SEED) += seed.o obj-$(CONFIG_CRYPTO_ARIA) += aria_generic.o crypto-objs-$(CONFIG_CRYPTO_CHACHA20) += chacha.o
crypto/anubis.c +2 -2
@@ -691,8 +691,8 @@ static void __exit anubis_mod_fini(void)crypto_unregister_alg (&anubis_alg); } -module_init (anubis_mod_init); -module_exit (anubis_mod_fini); +crypto_module_init (anubis_mod_init); +crypto_module_exit (anubis_mod_fini);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("Anubis Cryptographic Algorithm" );
Signature · 1 line
2.47.3
PATCH 75/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_SEED crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_SEED-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/seed.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -145,7 +145,7 @@ crypto-objs-$(CONFIG_CRYPTO_ARC4) += arc4.o crypto-objs-$(CONFIG_CRYPTO_TEA) += tea.o crypto-objs-$(CONFIG_CRYPTO_KHAZAD) += khazad.o crypto-objs-$(CONFIG_CRYPTO_ANUBIS) += anubis.o -obj-$(CONFIG_CRYPTO_SEED) += seed.o +crypto-objs-$(CONFIG_CRYPTO_SEED) += seed.o obj-$(CONFIG_CRYPTO_ARIA) += aria_generic.o crypto-objs-$(CONFIG_CRYPTO_CHACHA20) += chacha.o CFLAGS_chacha.o += -DARCH=$(ARCH)
crypto/seed.c +2 -2
@@ -460,8 +460,8 @@ static void __exit seed_fini(void)crypto_unregister_alg (&seed_alg); } -module_init (seed_init); -module_exit (seed_fini); +crypto_module_init (seed_init); +crypto_module_exit (seed_fini);MODULE_DESCRIPTION ("SEED Cipher Algorithm" );MODULE_LICENSE ("GPL" );
Signature · 1 line
2.47.3
PATCH 76/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_ARIA crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_ARIA-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/aria_generic.c | 4 ++-- crypto/fips140/fips140-api.c | 12 ++++++++++++ include/crypto/aria.h | 16 ++++++++++++---- 4 files changed, 27 insertions(+), 7 deletions(-)
crypto/Makefile +1 -1
@@ -146,7 +146,7 @@ crypto-objs-$(CONFIG_CRYPTO_TEA) += tea.o crypto-objs-$(CONFIG_CRYPTO_KHAZAD) += khazad.o crypto-objs-$(CONFIG_CRYPTO_ANUBIS) += anubis.o crypto-objs-$(CONFIG_CRYPTO_SEED) += seed.o -obj-$(CONFIG_CRYPTO_ARIA) += aria_generic.o +crypto-objs-$(CONFIG_CRYPTO_ARIA) += aria_generic.o crypto-objs-$(CONFIG_CRYPTO_CHACHA20) += chacha.o CFLAGS_chacha.o += -DARCH=$(ARCH) obj-$(CONFIG_CRYPTO_DEFLATE) += deflate.o
crypto/aria_generic.c +2 -2
@@ -304,8 +304,8 @@ static void __exit aria_fini(void)crypto_unregister_alg (&aria_alg); } -module_init (aria_init); -module_exit (aria_fini); +crypto_module_init (aria_init); +crypto_module_exit (aria_fini);MODULE_DESCRIPTION ("ARIA Cipher Algorithm" );MODULE_LICENSE ("GPL" );
crypto/fips140/fips140-api.c +12 -0
@@ -763,3 +763,15 @@ DEFINE_CRYPTO_API_STUB(af_alg_alloc_areq);DEFINE_CRYPTO_API_STUB (af_alg_get_rsgl);#endif +/* +* crypto/aria_generic.c +*/ +#if IS_BUILTIN (CONFIG_CRYPTO_ARIA ) + +#include <crypto/aria.h> + +DEFINE_CRYPTO_API_STUB (aria_set_key); +DEFINE_CRYPTO_API_STUB (aria_encrypt); +DEFINE_CRYPTO_API_STUB (aria_decrypt); + +#endif
include/crypto/aria.h +12 -4
@@ -18,6 +18,7 @@#ifndef _CRYPTO_ARIA_H#define _CRYPTO_ARIA_H +#include <crypto/api.h> #include <crypto/algapi.h> #include <linux/module.h> #include <linux/init.h>
@@ -450,9 +451,16 @@ static inline void aria_gsrk(u32 *rk, u32 *x, u32 *y, u32 n) ((y[(q +2 ) %4 ]) << (32 - r)); } -void aria_encrypt (void *ctx,u8 *out,const u8 *in); -void aria_decrypt (void *ctx,u8 *out,const u8 *in); -int aria_set_key (struct crypto_tfm *tfm,const u8 *in_key, -unsigned int key_len); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_ARIA , aria_encrypt, void, + (void *ctx, u8 *out, const u8 *in), + (ctx, out, in)); + +DECLARE_CRYPTO_API (CONFIG_CRYPTO_ARIA , aria_decrypt, void, + (void *ctx, u8 *out, const u8 *in), + (ctx, out, in)); + +DECLARE_CRYPTO_API (CONFIG_CRYPTO_ARIA , aria_set_key, int, + (struct crypto_tfm *tfm, const u8 *in_key, unsigned int key_len), + (tfm, in_key, key_len));#endif
Signature · 1 line
2.47.3
PATCH 77/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_DEFLATE crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_DEFLATE-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/deflate.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -149,7 +149,7 @@ crypto-objs-$(CONFIG_CRYPTO_SEED) += seed.o crypto-objs-$(CONFIG_CRYPTO_ARIA) += aria_generic.o crypto-objs-$(CONFIG_CRYPTO_CHACHA20) += chacha.o CFLAGS_chacha.o += -DARCH=$(ARCH) -obj-$(CONFIG_CRYPTO_DEFLATE) += deflate.o +crypto-objs-$(CONFIG_CRYPTO_DEFLATE) += deflate.o obj-$(CONFIG_CRYPTO_MICHAEL_MIC) += michael_mic.o obj-$(CONFIG_CRYPTO_CRC32C) += crc32c-cryptoapi.o crc32c-cryptoapi-y := crc32c.o
crypto/deflate.c +2 -2
@@ -249,8 +249,8 @@ static void __exit deflate_mod_fini(void)crypto_acomp_free_streams (&deflate_streams); } -module_init (deflate_mod_init); -module_exit (deflate_mod_fini); +crypto_module_init (deflate_mod_init); +crypto_module_exit (deflate_mod_fini);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("Deflate Compression Algorithm for IPCOMP" );
Signature · 1 line
2.47.3
PATCH 78/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_MICHAEL_MIC crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_MICHAEL_MIC-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/michael_mic.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -150,7 +150,7 @@ crypto-objs-$(CONFIG_CRYPTO_ARIA) += aria_generic.o crypto-objs-$(CONFIG_CRYPTO_CHACHA20) += chacha.o CFLAGS_chacha.o += -DARCH=$(ARCH) crypto-objs-$(CONFIG_CRYPTO_DEFLATE) += deflate.o -obj-$(CONFIG_CRYPTO_MICHAEL_MIC) += michael_mic.o +crypto-objs-$(CONFIG_CRYPTO_MICHAEL_MIC) += michael_mic.o obj-$(CONFIG_CRYPTO_CRC32C) += crc32c-cryptoapi.o crc32c-cryptoapi-y := crc32c.o obj-$(CONFIG_CRYPTO_CRC32) += crc32-cryptoapi.o
crypto/michael_mic.c +2 -2
@@ -167,8 +167,8 @@ static void __exit michael_mic_exit(void) } -module_init (michael_mic_init); -module_exit (michael_mic_exit); +crypto_module_init (michael_mic_init); +crypto_module_exit (michael_mic_exit);MODULE_LICENSE ("GPL v2" );MODULE_DESCRIPTION ("Michael MIC" );
Signature · 1 line
2.47.3
PATCH 79/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_CRC32C and CONFIG_CRYPTO_CRC32 crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_CRC32C- and CONFIG_CRYPTO_CRC32-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 4 ++-- crypto/crc32.c | 4 ++-- crypto/crc32c.c | 4 ++-- 3 files changed, 6 insertions(+), 6 deletions(-)
crypto/Makefile +2 -2
@@ -151,9 +151,9 @@ crypto-objs-$(CONFIG_CRYPTO_CHACHA20) += chacha.o CFLAGS_chacha.o += -DARCH=$(ARCH) crypto-objs-$(CONFIG_CRYPTO_DEFLATE) += deflate.o crypto-objs-$(CONFIG_CRYPTO_MICHAEL_MIC) += michael_mic.o -obj-$(CONFIG_CRYPTO_CRC32C) += crc32c-cryptoapi.o +crypto-objs-$(CONFIG_CRYPTO_CRC32C) += crc32c-cryptoapi.o crc32c-cryptoapi-y := crc32c.o -obj-$(CONFIG_CRYPTO_CRC32) += crc32-cryptoapi.o +crypto-objs-$(CONFIG_CRYPTO_CRC32) += crc32-cryptoapi.o crc32-cryptoapi-y := crc32.o crypto-objs-$(CONFIG_CRYPTO_AUTHENC) += authenc.o authencesn.o obj-$(CONFIG_CRYPTO_KRB5ENC) += krb5enc.o
crypto/crc32.c +2 -2
@@ -120,8 +120,8 @@ static void __exit crc32_mod_fini(void)crypto_unregister_shash (&alg); } -module_init (crc32_mod_init); -module_exit (crc32_mod_fini); +crypto_module_init (crc32_mod_init); +crypto_module_exit (crc32_mod_fini);MODULE_AUTHOR ("Alexander Boyko <[email protected]>" );MODULE_DESCRIPTION ("CRC32 calculations wrapper for lib/crc32" );
crypto/crc32c.c +2 -2
@@ -157,8 +157,8 @@ static void __exit crc32c_mod_fini(void)crypto_unregister_shash (&alg); } -module_init (crc32c_mod_init); -module_exit (crc32c_mod_fini); +crypto_module_init (crc32c_mod_init); +crypto_module_exit (crc32c_mod_fini);MODULE_AUTHOR ("Clay Haapala <[email protected]>" );MODULE_DESCRIPTION ("CRC32c (Castagnoli) calculations wrapper for lib/crc32c" );
Signature · 1 line
2.47.3
PATCH 80/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_KRB5ENC crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_KRB5ENC-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/fips140/fips140-api.c | 10 ++++++++++ crypto/krb5enc.c | 4 ++-- include/crypto/authenc.h | 6 ++++-- 4 files changed, 17 insertions(+), 5 deletions(-)
crypto/Makefile +1 -1
@@ -156,7 +156,7 @@ crc32c-cryptoapi-y := crc32c.o crypto-objs-$(CONFIG_CRYPTO_CRC32) += crc32-cryptoapi.o crc32-cryptoapi-y := crc32.o crypto-objs-$(CONFIG_CRYPTO_AUTHENC) += authenc.o authencesn.o -obj-$(CONFIG_CRYPTO_KRB5ENC) += krb5enc.o +crypto-objs-$(CONFIG_CRYPTO_KRB5ENC) += krb5enc.o crypto-objs-$(CONFIG_CRYPTO_LZO) += lzo.o lzo-rle.o obj-$(CONFIG_CRYPTO_LZ4) += lz4.o obj-$(CONFIG_CRYPTO_LZ4HC) += lz4hc.o
crypto/fips140/fips140-api.c +10 -0
@@ -775,3 +775,13 @@ DEFINE_CRYPTO_API_STUB(aria_encrypt);DEFINE_CRYPTO_API_STUB (aria_decrypt);#endif +/* +* crypto/krb5enc.c +*/ +#if IS_BUILTIN (CONFIG_CRYPTO_KRB5ENC ) + +#include <crypto/authenc.h> + +DEFINE_CRYPTO_API_STUB (crypto_krb5enc_extractkeys); + +#endif
crypto/krb5enc.c +2 -2
@@ -496,8 +496,8 @@ static void __exit crypto_krb5enc_module_exit(void)crypto_unregister_template (&crypto_krb5enc_tmpl); } -module_init (crypto_krb5enc_module_init); -module_exit (crypto_krb5enc_module_exit); +crypto_module_init (crypto_krb5enc_module_init); +crypto_module_exit (crypto_krb5enc_module_exit);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("Simple AEAD wrapper for Kerberos 5 RFC3961" );
include/crypto/authenc.h +4 -2
@@ -30,7 +30,9 @@ struct crypto_authenc_keys {DECLARE_CRYPTO_API (CONFIG_CRYPTO_AUTHENC , crypto_authenc_extractkeys, int, (struct crypto_authenc_keys *keys, const u8 *key, unsigned int keylen), (keys, key, keylen)); -int crypto_krb5enc_extractkeys (struct crypto_authenc_keys *keys,const u8 *key, -unsigned int keylen); + +DECLARE_CRYPTO_API (CONFIG_CRYPTO_KRB5ENC , crypto_krb5enc_extractkeys, int, + (struct crypto_authenc_keys *keys, const u8 *key, unsigned int keylen), + (keys, key, keylen));#endif /* _CRYPTO_AUTHENC_H */
Signature · 1 line
2.47.3
PATCH 81/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_LZ4 and CONFIG_CRYPTO_LZ4HC crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_LZ4- and CONFIG_CRYPTO_LZ4HC-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 4 ++-- crypto/lz4.c | 4 ++-- crypto/lz4hc.c | 4 ++-- 3 files changed, 6 insertions(+), 6 deletions(-)
crypto/Makefile +2 -2
@@ -158,8 +158,8 @@ crc32-cryptoapi-y := crc32.o crypto-objs-$(CONFIG_CRYPTO_AUTHENC) += authenc.o authencesn.o crypto-objs-$(CONFIG_CRYPTO_KRB5ENC) += krb5enc.o crypto-objs-$(CONFIG_CRYPTO_LZO) += lzo.o lzo-rle.o -obj-$(CONFIG_CRYPTO_LZ4) += lz4.o -obj-$(CONFIG_CRYPTO_LZ4HC) += lz4hc.o +crypto-objs-$(CONFIG_CRYPTO_LZ4) += lz4.o +crypto-objs-$(CONFIG_CRYPTO_LZ4HC) += lz4hc.o obj-$(CONFIG_CRYPTO_XXHASH) += xxhash_generic.o obj-$(CONFIG_CRYPTO_842) += 842.o crypto-objs-$(CONFIG_CRYPTO_RNG2) += rng.o
crypto/lz4.c +2 -2
@@ -91,8 +91,8 @@ static void __exit lz4_mod_fini(void)crypto_unregister_scomp (&scomp); } -module_init (lz4_mod_init); -module_exit (lz4_mod_fini); +crypto_module_init (lz4_mod_init); +crypto_module_exit (lz4_mod_fini);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("LZ4 Compression Algorithm" );
crypto/lz4hc.c +2 -2
@@ -89,8 +89,8 @@ static void __exit lz4hc_mod_fini(void)crypto_unregister_scomp (&scomp); } -module_init (lz4hc_mod_init); -module_exit (lz4hc_mod_fini); +crypto_module_init (lz4hc_mod_init); +crypto_module_exit (lz4hc_mod_fini);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("LZ4HC Compression Algorithm" );
Signature · 1 line
2.47.3
PATCH 82/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_XXHASH crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_XXHASH-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/xxhash_generic.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -160,7 +160,7 @@ crypto-objs-$(CONFIG_CRYPTO_KRB5ENC) += krb5enc.o crypto-objs-$(CONFIG_CRYPTO_LZO) += lzo.o lzo-rle.o crypto-objs-$(CONFIG_CRYPTO_LZ4) += lz4.o crypto-objs-$(CONFIG_CRYPTO_LZ4HC) += lz4hc.o -obj-$(CONFIG_CRYPTO_XXHASH) += xxhash_generic.o +crypto-objs-$(CONFIG_CRYPTO_XXHASH) += xxhash_generic.o obj-$(CONFIG_CRYPTO_842) += 842.o crypto-objs-$(CONFIG_CRYPTO_RNG2) += rng.o crypto-objs-$(CONFIG_CRYPTO_DRBG) += drbg.o
crypto/xxhash_generic.c +2 -2
@@ -96,8 +96,8 @@ static void __exit xxhash_mod_fini(void)crypto_unregister_shash (&alg); } -module_init (xxhash_mod_init); -module_exit (xxhash_mod_fini); +crypto_module_init (xxhash_mod_init); +crypto_module_exit (xxhash_mod_fini);MODULE_AUTHOR ("Nikolay Borisov <[email protected]>" );MODULE_DESCRIPTION ("xxhash calculations wrapper for lib/xxhash.c" );
Signature · 1 line
2.47.3
PATCH 83/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_842 crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_842-related crypto to convert them into pluggable interface.
--- crypto/842.c | 4 ++-- crypto/Makefile | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/842.c +2 -2
@@ -72,13 +72,13 @@ static int __init crypto842_mod_init(void) {return crypto_register_scomp (&scomp); } -module_init (crypto842_mod_init); +crypto_module_init (crypto842_mod_init); static void __exit crypto842_mod_exit(void) {crypto_unregister_scomp (&scomp); } -module_exit (crypto842_mod_exit); +crypto_module_exit (crypto842_mod_exit);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("842 Software Compression Algorithm" );
crypto/Makefile +1 -1
@@ -161,7 +161,7 @@ crypto-objs-$(CONFIG_CRYPTO_LZO) += lzo.o lzo-rle.o crypto-objs-$(CONFIG_CRYPTO_LZ4) += lz4.o crypto-objs-$(CONFIG_CRYPTO_LZ4HC) += lz4hc.o crypto-objs-$(CONFIG_CRYPTO_XXHASH) += xxhash_generic.o -obj-$(CONFIG_CRYPTO_842) += 842.o +crypto-objs-$(CONFIG_CRYPTO_842) += 842.o crypto-objs-$(CONFIG_CRYPTO_RNG2) += rng.o crypto-objs-$(CONFIG_CRYPTO_DRBG) += drbg.o crypto-objs-$(CONFIG_CRYPTO_JITTERENTROPY) += jitterentropy_rng.o
Signature · 1 line
2.47.3
PATCH 84/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE crypto
In reply to Jay WangUnlike most patches, we do not add a DECLARE_CRYPTO_API() wrapper for the exported function in crypto/jitterentropy.h. This is because this header is used by both jitterentropy_rng.o and jitterentropy-testing.o, but the compilation flags for jitterentropy_rng.o do not support declaration of a static call key.
This is acceptable since the only user of this exported function is jitterentropy_rng.o itself. The jitterentropy-testing.o code will naturally either be included alongside jitterentropy_rng.o in the crypto kernel module, or it will be disabled.
--- crypto/Makefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
crypto/Makefile +1 -1
@@ -169,7 +169,7 @@ CFLAGS_jitterentropy.o = -O0 KASAN_SANITIZE_jitterentropy.o = n UBSAN_SANITIZE_jitterentropy.o = n jitterentropy_rng-y := jitterentropy.o jitterentropy-kcapi.o -obj-$(CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE) += jitterentropy-testing.o +crypto-objs-$(CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE) += jitterentropy-testing.o obj-$(CONFIG_CRYPTO_BENCHMARK) += tcrypt.o crypto-objs-$(CONFIG_CRYPTO_GHASH) += ghash-generic.o crypto-objs-$(CONFIG_CRYPTO_USER_API) += af_alg.o
Signature · 1 line
2.47.3
PATCH 85/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_BENCHMARK crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_BENCHMARK-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/tcrypt.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -170,7 +170,7 @@ KASAN_SANITIZE_jitterentropy.o = n UBSAN_SANITIZE_jitterentropy.o = n jitterentropy_rng-y := jitterentropy.o jitterentropy-kcapi.o crypto-objs-$(CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE) += jitterentropy-testing.o -obj-$(CONFIG_CRYPTO_BENCHMARK) += tcrypt.o +crypto-objs-$(CONFIG_CRYPTO_BENCHMARK) += tcrypt.o crypto-objs-$(CONFIG_CRYPTO_GHASH) += ghash-generic.o crypto-objs-$(CONFIG_CRYPTO_USER_API) += af_alg.o obj-$(CONFIG_CRYPTO_USER_API_HASH) += algif_hash.o
crypto/tcrypt.c +2 -2
@@ -2840,8 +2840,8 @@ static int __init tcrypt_mod_init(void)*/ static void __exit tcrypt_mod_fini(void) { } -late_initcall (tcrypt_mod_init); -module_exit (tcrypt_mod_fini); +crypto_late_initcall (tcrypt_mod_init); +crypto_module_exit (tcrypt_mod_fini);module_param (alg, charp,0 );module_param (type, uint,0 );
Signature · 1 line
2.47.3
PATCH 86/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_USER_API_HASH crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_USER_API_HASH-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/algif_hash.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -173,7 +173,7 @@ crypto-objs-$(CONFIG_CRYPTO_JITTERENTROPY_TESTINTERFACE) += jitterentropy-testin crypto-objs-$(CONFIG_CRYPTO_BENCHMARK) += tcrypt.o crypto-objs-$(CONFIG_CRYPTO_GHASH) += ghash-generic.o crypto-objs-$(CONFIG_CRYPTO_USER_API) += af_alg.o -obj-$(CONFIG_CRYPTO_USER_API_HASH) += algif_hash.o +crypto-objs-$(CONFIG_CRYPTO_USER_API_HASH) += algif_hash.o crypto-objs-$(CONFIG_CRYPTO_USER_API_SKCIPHER) += algif_skcipher.o obj-$(CONFIG_CRYPTO_USER_API_RNG) += algif_rng.o obj-$(CONFIG_CRYPTO_USER_API_AEAD) += algif_aead.o
crypto/algif_hash.c +2 -2
@@ -464,7 +464,7 @@ static void __exit algif_hash_exit(void)BUG_ON (err); } -module_init (algif_hash_init); -module_exit (algif_hash_exit); +crypto_module_init (algif_hash_init); +crypto_module_exit (algif_hash_exit);MODULE_DESCRIPTION ("Userspace interface for hash algorithms" );MODULE_LICENSE ("GPL" );
Signature · 1 line
2.47.3
PATCH 87/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_USER_API_RNG crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_USER_API_RNG-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/algif_rng.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -175,7 +175,7 @@ crypto-objs-$(CONFIG_CRYPTO_GHASH) += ghash-generic.o crypto-objs-$(CONFIG_CRYPTO_USER_API) += af_alg.o crypto-objs-$(CONFIG_CRYPTO_USER_API_HASH) += algif_hash.o crypto-objs-$(CONFIG_CRYPTO_USER_API_SKCIPHER) += algif_skcipher.o -obj-$(CONFIG_CRYPTO_USER_API_RNG) += algif_rng.o +crypto-objs-$(CONFIG_CRYPTO_USER_API_RNG) += algif_rng.o obj-$(CONFIG_CRYPTO_USER_API_AEAD) += algif_aead.o obj-$(CONFIG_CRYPTO_ZSTD) += zstd.o crypto-objs-$(CONFIG_CRYPTO_ECC) += ecc.o
crypto/algif_rng.c +2 -2
@@ -335,5 +335,5 @@ static void __exit rng_exit(void)BUG_ON (err); } -module_init (rng_init); -module_exit (rng_exit); +crypto_module_init (rng_init); +crypto_module_exit (rng_exit);
Signature · 1 line
2.47.3
PATCH 88/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_USER_API_AEAD crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_USER_API_AEAD-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/algif_aead.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -176,7 +176,7 @@ crypto-objs-$(CONFIG_CRYPTO_USER_API) += af_alg.o crypto-objs-$(CONFIG_CRYPTO_USER_API_HASH) += algif_hash.o crypto-objs-$(CONFIG_CRYPTO_USER_API_SKCIPHER) += algif_skcipher.o crypto-objs-$(CONFIG_CRYPTO_USER_API_RNG) += algif_rng.o -obj-$(CONFIG_CRYPTO_USER_API_AEAD) += algif_aead.o +crypto-objs-$(CONFIG_CRYPTO_USER_API_AEAD) += algif_aead.o obj-$(CONFIG_CRYPTO_ZSTD) += zstd.o crypto-objs-$(CONFIG_CRYPTO_ECC) += ecc.o obj-$(CONFIG_CRYPTO_ESSIV) += essiv.o
crypto/algif_aead.c +2 -2
@@ -521,8 +521,8 @@ static void __exit algif_aead_exit(void)BUG_ON (err); } -module_init (algif_aead_init); -module_exit (algif_aead_exit); +crypto_module_init (algif_aead_init); +crypto_module_exit (algif_aead_exit);MODULE_LICENSE ("GPL" );MODULE_AUTHOR ("Stephan Mueller <[email protected]>" );MODULE_DESCRIPTION ("AEAD kernel crypto API user space interface" );
Signature · 1 line
2.47.3
PATCH 89/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_ZSTD crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_ZSTD-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/zstd.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -177,7 +177,7 @@ crypto-objs-$(CONFIG_CRYPTO_USER_API_HASH) += algif_hash.o crypto-objs-$(CONFIG_CRYPTO_USER_API_SKCIPHER) += algif_skcipher.o crypto-objs-$(CONFIG_CRYPTO_USER_API_RNG) += algif_rng.o crypto-objs-$(CONFIG_CRYPTO_USER_API_AEAD) += algif_aead.o -obj-$(CONFIG_CRYPTO_ZSTD) += zstd.o +crypto-objs-$(CONFIG_CRYPTO_ZSTD) += zstd.o crypto-objs-$(CONFIG_CRYPTO_ECC) += ecc.o obj-$(CONFIG_CRYPTO_ESSIV) += essiv.o
crypto/zstd.c +2 -2
@@ -307,8 +307,8 @@ static void __exit zstd_mod_fini(void)crypto_acomp_free_streams (&zstd_streams); } -module_init (zstd_mod_init); -module_exit (zstd_mod_fini); +crypto_module_init (zstd_mod_init); +crypto_module_exit (zstd_mod_fini);MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("Zstd Compression Algorithm" );
Signature · 1 line
2.47.3
PATCH 90/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_ESSIV crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_ESSIV-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/essiv.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -179,7 +179,7 @@ crypto-objs-$(CONFIG_CRYPTO_USER_API_RNG) += algif_rng.o crypto-objs-$(CONFIG_CRYPTO_USER_API_AEAD) += algif_aead.o crypto-objs-$(CONFIG_CRYPTO_ZSTD) += zstd.o crypto-objs-$(CONFIG_CRYPTO_ECC) += ecc.o -obj-$(CONFIG_CRYPTO_ESSIV) += essiv.o +crypto-objs-$(CONFIG_CRYPTO_ESSIV) += essiv.o ecdh_generic-y += ecdh.o ecdh_generic-y += ecdh_helper.o
crypto/essiv.c +2 -2
@@ -639,8 +639,8 @@ static void __exit essiv_module_exit(void)crypto_unregister_template (&essiv_tmpl); } -module_init (essiv_module_init); -module_exit (essiv_module_exit); +crypto_module_init (essiv_module_init); +crypto_module_exit (essiv_module_exit);MODULE_DESCRIPTION ("ESSIV skcipher/aead wrapper for block encryption" );MODULE_LICENSE ("GPL v2" );
Signature · 1 line
2.47.3
PATCH 91/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_ECDH crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_ECDH-related crypto to convert them into pluggable interface.
This patch is partially based on work by Vegard Nossum, with modifications. Unlike the original, we do not include DEFINE_CRYPTO_API since only one copy of the crypto symbols is kept, either in the crypto module or in the main kernel, and we ensure such wrapper do not have impact on crypto already chosen built as module.
--- crypto/Makefile | 2 +- crypto/ecdh.c | 4 ++-- crypto/fips140/fips140-api.c | 12 ++++++++++++ include/crypto/ecdh.h | 14 +++++++++++--- 4 files changed, 26 insertions(+), 6 deletions(-)
crypto/Makefile +1 -1
@@ -183,7 +183,7 @@ crypto-objs-$(CONFIG_CRYPTO_ESSIV) += essiv.o ecdh_generic-y += ecdh.o ecdh_generic-y += ecdh_helper.o -obj-$(CONFIG_CRYPTO_ECDH) += ecdh_generic.o +crypto-objs-$(CONFIG_CRYPTO_ECDH) += ecdh_generic.o $(obj)/ecrdsa_params.asn1.o: $(obj)/ecrdsa_params.asn1.c $(obj)/ecrdsa_params.asn1.h $(obj)/ecrdsa_pub_key.asn1.o: $(obj)/ecrdsa_pub_key.asn1.c $(obj)/ecrdsa_pub_key.asn1.h
crypto/ecdh.c +2 -2
@@ -240,8 +240,8 @@ static void __exit ecdh_exit(void)crypto_unregister_kpp (&ecdh_nist_p384); } -module_init (ecdh_init); -module_exit (ecdh_exit); +crypto_module_init (ecdh_init); +crypto_module_exit (ecdh_exit);MODULE_ALIAS_CRYPTO ("ecdh" );MODULE_LICENSE ("GPL" );MODULE_DESCRIPTION ("ECDH generic algorithm" );
crypto/fips140/fips140-api.c +12 -0
@@ -785,3 +785,15 @@ DEFINE_CRYPTO_API_STUB(aria_decrypt);DEFINE_CRYPTO_API_STUB (crypto_krb5enc_extractkeys);#endif +/* +* crypto/ecdh_helper.c +*/ +#if IS_BUILTIN (CONFIG_CRYPTO_ECDH ) + +#include <crypto/ecdh.h> + +DEFINE_CRYPTO_API_STUB (crypto_ecdh_key_len); +DEFINE_CRYPTO_API_STUB (crypto_ecdh_encode_key); +DEFINE_CRYPTO_API_STUB (crypto_ecdh_decode_key); + +#endif
include/crypto/ecdh.h +11 -3
@@ -8,6 +8,8 @@#ifndef _CRYPTO_ECDH_#define _CRYPTO_ECDH_ +#include <crypto/api.h> +/** * DOC: ECDH Helper Functions *
@@ -49,7 +51,9 @@ struct ecdh {* * Return: size of the key in bytes */ -unsigned int crypto_ecdh_key_len (const struct ecdh *params); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_ECDH, crypto_ecdh_key_len, unsigned int, + (const struct ecdh *params), + (params));/** * crypto_ecdh_encode_key() - encode the private key
@@ -64,7 +68,9 @@ unsigned int crypto_ecdh_key_len(const struct ecdh *params);* * Return: -EINVAL if buffer has insufficient size, 0 on success */ -int crypto_ecdh_encode_key (char *buf,unsigned int len,const struct ecdh *p); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_ECDH , crypto_ecdh_encode_key, int, + (char *buf, unsigned int len, const struct ecdh *p), + (buf, len, p));/** * crypto_ecdh_decode_key() - decode a private key
@@ -78,6 +84,8 @@ int crypto_ecdh_encode_key(char *buf, unsigned int len, const struct ecdh *p);* * Return: -EINVAL if buffer has insufficient size, 0 on success */ -int crypto_ecdh_decode_key (const char *buf,unsigned int len,struct ecdh *p); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_ECDH , crypto_ecdh_decode_key, int, + (const char *buf, unsigned int len, struct ecdh *p), + (buf, len, p));#endif
Signature · 1 line
2.47.3
PATCH 92/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_ECRDSA crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_ECRDSA-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/ecrdsa.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/Makefile +1 -1
@@ -191,7 +191,7 @@ $(obj)/ecrdsa.o: $(obj)/ecrdsa_params.asn1.h $(obj)/ecrdsa_pub_key.asn1.h ecrdsa_generic-y += ecrdsa.o ecrdsa_generic-y += ecrdsa_params.asn1.o ecrdsa_generic-y += ecrdsa_pub_key.asn1.o -obj-$(CONFIG_CRYPTO_ECRDSA) += ecrdsa_generic.o +crypto-objs-$(CONFIG_CRYPTO_ECRDSA) += ecrdsa_generic.o # # generic algorithms and the async_tx api
crypto/ecrdsa.c +2 -2
@@ -288,8 +288,8 @@ static void __exit ecrdsa_mod_fini(void)crypto_unregister_sig (&ecrdsa_alg); } -module_init (ecrdsa_mod_init); -module_exit (ecrdsa_mod_fini); +crypto_module_init (ecrdsa_mod_init); +crypto_module_exit (ecrdsa_mod_fini);MODULE_LICENSE ("GPL" );MODULE_AUTHOR ("Vitaly Chikunov <[email protected]>" );
Signature · 1 line
2.47.3
PATCH 93/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_XOR_BLOCKS crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_XOR_BLOCKS-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/fips140/fips140-api.c | 10 ++++++++++ crypto/xor.c | 4 ++-- include/linux/raid/xor.h | 7 +++++-- 4 files changed, 18 insertions(+), 5 deletions(-)
crypto/Makefile +1 -1
@@ -196,7 +196,7 @@ crypto-objs-$(CONFIG_CRYPTO_ECRDSA) += ecrdsa_generic.o # # generic algorithms and the async_tx api # -obj-$(CONFIG_XOR_BLOCKS) += xor.o +crypto-objs-$(CONFIG_XOR_BLOCKS) += xor.o obj-$(CONFIG_ASYNC_CORE) += async_tx/ obj-$(CONFIG_ASYMMETRIC_KEY_TYPE) += asymmetric_keys/ crypto_simd-y := simd.o
crypto/fips140/fips140-api.c +10 -0
@@ -784,6 +784,16 @@ DEFINE_CRYPTO_API_STUB(aria_decrypt);DEFINE_CRYPTO_API_STUB (crypto_krb5enc_extractkeys); +#endif +/* +* crypto/xor.c +*/ +#if IS_BUILTIN (CONFIG_XOR_BLOCKS ) + +#include <linux/raid/xor.h> + +DEFINE_CRYPTO_API_STUB (xor_blocks); +#endif /* * crypto/ecdh_helper.c
crypto/xor.c +2 -2
@@ -170,5 +170,5 @@ MODULE_LICENSE("GPL");core_initcall (register_xor_blocks);#endif -module_init (calibrate_xor_blocks); -module_exit (xor_exit); +crypto_module_init (calibrate_xor_blocks); +crypto_module_exit (xor_exit);
include/linux/raid/xor.h +5 -2
@@ -2,10 +2,13 @@ #ifndef _XOR_H #define _XOR_H +#include <crypto/api.h> + #define MAX_XOR_BLOCKS 4 -extern void xor_blocks(unsigned int count, unsigned int bytes, - void *dest, void **srcs); +DECLARE_CRYPTO_API(CONFIG_XOR_BLOCKS, xor_blocks, void, + (unsigned int count, unsigned int bytes, void *dest, void **srcs), + (count, bytes, dest, srcs)); struct xor_block_template { struct xor_block_template *next;
Signature · 1 line
2.47.3
PATCH 94/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_ASYNC_CORE crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_ASYNC_CORE-related crypto to convert them into pluggable interface.
--- crypto/async_tx/Makefile | 2 +- crypto/async_tx/async_tx.c | 4 ++-- crypto/fips140/fips140-api.c | 15 +++++++++++++++ include/linux/async_tx.h | 21 ++++++++++++++------- 4 files changed, 32 insertions(+), 10 deletions(-)
crypto/async_tx/Makefile +1 -1
@@ -1,5 +1,5 @@ # SPDX-License-Identifier: GPL-2.0 -obj-$(CONFIG_ASYNC_CORE) += async_tx.o +crypto-objs-$(CONFIG_ASYNC_CORE) += async_tx.o obj-$(CONFIG_ASYNC_MEMCPY) += async_memcpy.o obj-$(CONFIG_ASYNC_XOR) += async_xor.o obj-$(CONFIG_ASYNC_PQ) += async_pq.o
crypto/async_tx/async_tx.c +2 -2
@@ -30,8 +30,8 @@ static void __exit async_tx_exit(void)async_dmaengine_put (); } -module_init (async_tx_init); -module_exit (async_tx_exit); +crypto_module_init (async_tx_init); +crypto_module_exit (async_tx_exit);/** * __async_tx_find_channel - find a channel to carry out the operation or let
crypto/fips140/fips140-api.c +15 -0
@@ -794,6 +794,21 @@ DEFINE_CRYPTO_API_STUB(crypto_krb5enc_extractkeys);DEFINE_CRYPTO_API_STUB (xor_blocks); +#endif +/* +* crypto/async_tx/async_tx.c +*/ +#if IS_BUILTIN (CONFIG_ASYNC_CORE ) + +#include <linux/async_tx.h> + +#ifdef CONFIG_DMA_ENGINE +DEFINE_CRYPTO_API_STUB (__async_tx_find_channel); +#endif +DEFINE_CRYPTO_API_STUB (async_tx_submit); +DEFINE_CRYPTO_API_STUB (async_trigger_callback); +DEFINE_CRYPTO_API_STUB (async_tx_quiesce); +#endif /* * crypto/ecdh_helper.c
include/linux/async_tx.h +14 -7
@@ -4,6 +4,8 @@*/ #ifndef _ASYNC_TX_H_#define _ASYNC_TX_H_ + +#include <crypto/api.h> #include <linux/dmaengine.h> #include <linux/spinlock.h> #include <linux/interrupt.h>
@@ -99,9 +101,9 @@ static inline void async_tx_issue_pending(struct dma_async_tx_descriptor *tx)#else #define async_tx_find_channel (dep, type, dst, dst_count, src, src_count, len) \ __async_tx_find_channel(dep, type) -struct dma_chan * -__async_tx_find_channel (struct async_submit_ctl *submit, -enum dma_transaction_type tx_type); +DECLARE_CRYPTO_API(CONFIG_ASYNC_CORE, __async_tx_find_channel, struct dma_chan *, + (struct async_submit_ctl *submit, enum dma_transaction_type tx_type), + (submit, tx_type));#endif /* CONFIG_ARCH_HAS_ASYNC_TX_FIND_CHANNEL */ #else static inline void async_tx_issue_pending_all (void )
@@ -155,8 +157,9 @@ init_async_submit(struct async_submit_ctl *args, enum async_tx_flags flags, args->scribble = scribble; } -void async_tx_submit (struct dma_chan *chan,struct dma_async_tx_descriptor *tx, -struct async_submit_ctl *submit); +DECLARE_CRYPTO_API (CONFIG_ASYNC_CORE , async_tx_submit, void, + (struct dma_chan *chan, struct dma_async_tx_descriptor *tx, struct async_submit_ctl *submit), + (chan, tx, submit));struct dma_async_tx_descriptor * async_xor(struct page *dest, struct page **src_list, unsigned int offset,
@@ -178,7 +181,9 @@ async_memcpy(struct page *dest, struct page *src, unsigned int dest_offset, unsigned int src_offset, size_t len, struct async_submit_ctl *submit); -struct dma_async_tx_descriptor *async_trigger_callback (struct async_submit_ctl *submit); +DECLARE_CRYPTO_API(CONFIG_ASYNC_CORE, async_trigger_callback, struct dma_async_tx_descriptor *, + (struct async_submit_ctl *submit), + (submit));struct dma_async_tx_descriptor * async_gen_syndrome(struct page **blocks, unsigned int *offsets, int src_cnt,
@@ -199,5 +204,7 @@ async_raid6_datap_recov(int src_num, size_t bytes, int faila, struct page **ptrs, unsigned int *offs, struct async_submit_ctl *submit); -void async_tx_quiesce (struct dma_async_tx_descriptor **tx); +DECLARE_CRYPTO_API (CONFIG_ASYNC_CORE , async_tx_quiesce, void, + (struct dma_async_tx_descriptor **tx), + (tx));#endif /* _ASYNC_TX_H_ */
Signature · 1 line
2.47.3
PATCH 95/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_ASYNC_MEMCPY crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_ASYNC_MEMCPY-related crypto to convert them into pluggable interface.
--- crypto/async_tx/Makefile | 2 +- crypto/fips140/fips140-api.c | 10 ++++++++++ include/linux/async_tx.h | 7 +++---- 3 files changed, 14 insertions(+), 5 deletions(-)
crypto/async_tx/Makefile +1 -1
@@ -1,6 +1,6 @@ # SPDX-License-Identifier: GPL-2.0 crypto-objs-$(CONFIG_ASYNC_CORE) += async_tx.o -obj-$(CONFIG_ASYNC_MEMCPY) += async_memcpy.o +crypto-objs-$(CONFIG_ASYNC_MEMCPY) += async_memcpy.o obj-$(CONFIG_ASYNC_XOR) += async_xor.o obj-$(CONFIG_ASYNC_PQ) += async_pq.o obj-$(CONFIG_ASYNC_RAID6_RECOV) += async_raid6_recov.o
crypto/fips140/fips140-api.c +10 -0
@@ -809,6 +809,16 @@ DEFINE_CRYPTO_API_STUB(async_tx_submit);DEFINE_CRYPTO_API_STUB (async_trigger_callback);DEFINE_CRYPTO_API_STUB (async_tx_quiesce); +#endif +/* +* crypto/async_tx/async_memcpy.c +*/ +#if IS_BUILTIN (CONFIG_ASYNC_MEMCPY ) + +#include <linux/async_tx.h> + +DEFINE_CRYPTO_API_STUB (async_memcpy); +#endif /* * crypto/ecdh_helper.c
include/linux/async_tx.h +3 -4
@@ -176,10 +176,9 @@ async_xor_val_offs(struct page *dest, unsigned int offset, int src_cnt, size_t len, enum sum_check_flags *result, struct async_submit_ctl *submit); -struct dma_async_tx_descriptor * -async_memcpy (struct page *dest,struct page *src,unsigned int dest_offset, -unsigned int src_offset,size_t len, -struct async_submit_ctl *submit); +DECLARE_CRYPTO_API(CONFIG_ASYNC_MEMCPY, async_memcpy, struct dma_async_tx_descriptor *, + (struct page *dest, struct page *src, unsigned int dest_offset, unsigned int src_offset, size_t len, struct async_submit_ctl *submit), + (dest, src, dest_offset, src_offset, len, submit)); DECLARE_CRYPTO_API(CONFIG_ASYNC_CORE, async_trigger_callback, struct dma_async_tx_descriptor *, (struct async_submit_ctl *submit),
Signature · 1 line
2.47.3
PATCH 96/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_ASYNC_XOR crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_ASYNC_XOR-related crypto to convert them into pluggable interface.
--- crypto/async_tx/Makefile | 2 +- crypto/fips140/fips140-api.c | 12 ++++++++++++ include/linux/async_tx.h | 21 +++++++++------------ 3 files changed, 22 insertions(+), 13 deletions(-)
crypto/async_tx/Makefile +1 -1
@@ -1,7 +1,7 @@ # SPDX-License-Identifier: GPL-2.0 crypto-objs-$(CONFIG_ASYNC_CORE) += async_tx.o crypto-objs-$(CONFIG_ASYNC_MEMCPY) += async_memcpy.o -obj-$(CONFIG_ASYNC_XOR) += async_xor.o +crypto-objs-$(CONFIG_ASYNC_XOR) += async_xor.o obj-$(CONFIG_ASYNC_PQ) += async_pq.o obj-$(CONFIG_ASYNC_RAID6_RECOV) += async_raid6_recov.o obj-$(CONFIG_ASYNC_RAID6_TEST) += raid6test.o
crypto/fips140/fips140-api.c +12 -0
@@ -819,6 +819,18 @@ DEFINE_CRYPTO_API_STUB(async_tx_quiesce);DEFINE_CRYPTO_API_STUB (async_memcpy); +#endif +/* +* crypto/async_tx/async_xor.c +*/ +#if IS_BUILTIN (CONFIG_ASYNC_XOR ) + +#include <linux/async_tx.h> + +DEFINE_CRYPTO_API_STUB (async_xor); +DEFINE_CRYPTO_API_STUB (async_xor_offs); +DEFINE_CRYPTO_API_STUB (async_xor_val_offs); +#endif /* * crypto/ecdh_helper.c
include/linux/async_tx.h +9 -12
@@ -161,20 +161,17 @@ DECLARE_CRYPTO_API(CONFIG_ASYNC_CORE, async_tx_submit, void, (struct dma_chan *chan, struct dma_async_tx_descriptor *tx, struct async_submit_ctl *submit), (chan, tx, submit)); -struct dma_async_tx_descriptor * -async_xor (struct page *dest,struct page **src_list,unsigned int offset, -int src_cnt,size_t len,struct async_submit_ctl *submit); +DECLARE_CRYPTO_API(CONFIG_ASYNC_XOR, async_xor, struct dma_async_tx_descriptor *, + (struct page *dest, struct page **src_list, unsigned int offset, int src_cnt, size_t len, struct async_submit_ctl *submit), + (dest, src_list, offset, src_cnt, len, submit)); -struct dma_async_tx_descriptor * -async_xor_offs (struct page *dest,unsigned int offset, -struct page **src_list,unsigned int *src_offset, -int src_cnt,size_t len,struct async_submit_ctl *submit); +DECLARE_CRYPTO_API(CONFIG_ASYNC_XOR, async_xor_offs, struct dma_async_tx_descriptor *, + (struct page *dest, unsigned int offset, struct page **src_list, unsigned int *src_offset, int src_cnt, size_t len, struct async_submit_ctl *submit), + (dest, offset, src_list, src_offset, src_cnt, len, submit)); -struct dma_async_tx_descriptor * -async_xor_val_offs (struct page *dest,unsigned int offset, -struct page **src_list,unsigned int *src_offset, -int src_cnt,size_t len,enum sum_check_flags *result, -struct async_submit_ctl *submit); +DECLARE_CRYPTO_API(CONFIG_ASYNC_XOR, async_xor_val_offs, struct dma_async_tx_descriptor *, + (struct page *dest, unsigned int offset, struct page **src_list, unsigned int *src_offset, int src_cnt, size_t len, enum sum_check_flags *result, struct async_submit_ctl *submit), + (dest, offset, src_list, src_offset, src_cnt, len, result, submit)); DECLARE_CRYPTO_API(CONFIG_ASYNC_MEMCPY, async_memcpy, struct dma_async_tx_descriptor *, (struct page *dest, struct page *src, unsigned int dest_offset, unsigned int src_offset, size_t len, struct async_submit_ctl *submit),
Signature · 1 line
2.47.3
PATCH 97/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_ASYNC_PQ crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_ASYNC_PQ-related crypto to convert them into pluggable interface.
--- crypto/async_tx/Makefile | 2 +- crypto/async_tx/async_pq.c | 4 ++-- crypto/fips140/fips140-api.c | 11 +++++++++++ include/linux/async_tx.h | 13 ++++++------- 4 files changed, 20 insertions(+), 10 deletions(-)
crypto/async_tx/Makefile +1 -1
@@ -2,6 +2,6 @@ crypto-objs-$(CONFIG_ASYNC_CORE) += async_tx.o crypto-objs-$(CONFIG_ASYNC_MEMCPY) += async_memcpy.o crypto-objs-$(CONFIG_ASYNC_XOR) += async_xor.o -obj-$(CONFIG_ASYNC_PQ) += async_pq.o +crypto-objs-$(CONFIG_ASYNC_PQ) += async_pq.o obj-$(CONFIG_ASYNC_RAID6_RECOV) += async_raid6_recov.o obj-$(CONFIG_ASYNC_RAID6_TEST) += raid6test.o
crypto/async_tx/async_pq.c +2 -2
@@ -456,8 +456,8 @@ static void __exit async_pq_exit(void)__free_page (pq_scribble_page); } -module_init (async_pq_init); -module_exit (async_pq_exit); +crypto_module_init (async_pq_init); +crypto_module_exit (async_pq_exit);MODULE_DESCRIPTION ("asynchronous raid6 syndrome generation/validation" );MODULE_LICENSE ("GPL" );
crypto/fips140/fips140-api.c +11 -0
@@ -831,6 +831,17 @@ DEFINE_CRYPTO_API_STUB(async_xor);DEFINE_CRYPTO_API_STUB (async_xor_offs);DEFINE_CRYPTO_API_STUB (async_xor_val_offs); +#endif +/* +* crypto/async_tx/async_pq.c +*/ +#if IS_BUILTIN (CONFIG_ASYNC_PQ ) + +#include <linux/async_tx.h> + +DEFINE_CRYPTO_API_STUB (async_gen_syndrome); +DEFINE_CRYPTO_API_STUB (async_syndrome_val); +#endif /* * crypto/ecdh_helper.c
include/linux/async_tx.h +6 -7
@@ -181,14 +181,13 @@ DECLARE_CRYPTO_API(CONFIG_ASYNC_CORE, async_trigger_callback, struct dma_async_t (struct async_submit_ctl *submit), (submit)); -struct dma_async_tx_descriptor * -async_gen_syndrome (struct page **blocks,unsigned int *offsets,int src_cnt, -size_t len,struct async_submit_ctl *submit); +DECLARE_CRYPTO_API(CONFIG_ASYNC_PQ, async_gen_syndrome, struct dma_async_tx_descriptor *, + (struct page **blocks, unsigned int *offsets, int src_cnt, size_t len, struct async_submit_ctl *submit), + (blocks, offsets, src_cnt, len, submit)); -struct dma_async_tx_descriptor * -async_syndrome_val (struct page **blocks,unsigned int *offsets,int src_cnt, -size_t len,enum sum_check_flags *pqres,struct page *spare, -unsigned int s_off,struct async_submit_ctl *submit); +DECLARE_CRYPTO_API(CONFIG_ASYNC_PQ, async_syndrome_val, struct dma_async_tx_descriptor *, + (struct page **blocks, unsigned int *offsets, int src_cnt, size_t len, enum sum_check_flags *pqres, struct page *spare, unsigned int s_off, struct async_submit_ctl *submit), + (blocks, offsets, src_cnt, len, pqres, spare, s_off, submit));struct dma_async_tx_descriptor * async_raid6_2data_recov(int src_num, size_t bytes, int faila, int failb,
Signature · 1 line
2.47.3
PATCH 98/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_ASYNC_RAID6_RECOV crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_ASYNC_RAID6_RECOV-related crypto to convert them into pluggable interface.
--- crypto/async_tx/Makefile | 2 +- crypto/fips140/fips140-api.c | 11 +++++++++++ include/linux/async_tx.h | 16 +++++++--------- 3 files changed, 19 insertions(+), 10 deletions(-)
crypto/async_tx/Makefile +1 -1
@@ -3,5 +3,5 @@ crypto-objs-$(CONFIG_ASYNC_CORE) += async_tx.o crypto-objs-$(CONFIG_ASYNC_MEMCPY) += async_memcpy.o crypto-objs-$(CONFIG_ASYNC_XOR) += async_xor.o crypto-objs-$(CONFIG_ASYNC_PQ) += async_pq.o -obj-$(CONFIG_ASYNC_RAID6_RECOV) += async_raid6_recov.o +crypto-objs-$(CONFIG_ASYNC_RAID6_RECOV) += async_raid6_recov.o obj-$(CONFIG_ASYNC_RAID6_TEST) += raid6test.o
crypto/fips140/fips140-api.c +11 -0
@@ -842,6 +842,17 @@ DEFINE_CRYPTO_API_STUB(async_xor_val_offs);DEFINE_CRYPTO_API_STUB (async_gen_syndrome);DEFINE_CRYPTO_API_STUB (async_syndrome_val); +#endif +/* +* crypto/async_tx/async_raid6_recov.c +*/ +#if IS_BUILTIN (CONFIG_ASYNC_RAID6_RECOV ) + +#include <linux/async_tx.h> + +DEFINE_CRYPTO_API_STUB (async_raid6_2data_recov); +DEFINE_CRYPTO_API_STUB (async_raid6_datap_recov); +#endif /* * crypto/ecdh_helper.c
include/linux/async_tx.h +7 -9
@@ -189,15 +189,13 @@ DECLARE_CRYPTO_API(CONFIG_ASYNC_PQ, async_syndrome_val, struct dma_async_tx_desc (struct page **blocks, unsigned int *offsets, int src_cnt, size_t len, enum sum_check_flags *pqres, struct page *spare, unsigned int s_off, struct async_submit_ctl *submit), (blocks, offsets, src_cnt, len, pqres, spare, s_off, submit)); -struct dma_async_tx_descriptor * -async_raid6_2data_recov (int src_num,size_t bytes,int faila,int failb, -struct page **ptrs,unsigned int *offs, -struct async_submit_ctl *submit); - -struct dma_async_tx_descriptor * -async_raid6_datap_recov (int src_num,size_t bytes,int faila, -struct page **ptrs,unsigned int *offs, -struct async_submit_ctl *submit); +DECLARE_CRYPTO_API(CONFIG_ASYNC_RAID6_RECOV, async_raid6_2data_recov, struct dma_async_tx_descriptor *, + (int src_num, size_t bytes, int faila, int failb, struct page **ptrs, unsigned int *offs, struct async_submit_ctl *submit), + (src_num, bytes, faila, failb, ptrs, offs, submit)); + +DECLARE_CRYPTO_API(CONFIG_ASYNC_RAID6_RECOV, async_raid6_datap_recov, struct dma_async_tx_descriptor *, + (int src_num, size_t bytes, int faila, struct page **ptrs, unsigned int *offs, struct async_submit_ctl *submit), + (src_num, bytes, faila, ptrs, offs, submit)); DECLARE_CRYPTO_API(CONFIG_ASYNC_CORE, async_tx_quiesce, void, (struct dma_async_tx_descriptor **tx),
Signature · 1 line
2.47.3
PATCH 99/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_KDF800108_CTR crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_KDF800108_CTR-related crypto to convert them into pluggable interface.
--- crypto/Makefile | 2 +- crypto/fips140/fips140-api.c | 11 +++++++++++ crypto/kdf_sp800108.c | 4 ++-- include/crypto/kdf_sp800108.h | 14 ++++++++------ 4 files changed, 22 insertions(+), 9 deletions(-)
crypto/Makefile +1 -1
@@ -205,7 +205,7 @@ obj-$(CONFIG_CRYPTO_SIMD) += crypto_simd.o # # Key derivation function # -obj-$(CONFIG_CRYPTO_KDF800108_CTR) += kdf_sp800108.o +crypto-objs-$(CONFIG_CRYPTO_KDF800108_CTR) += kdf_sp800108.o obj-$(CONFIG_CRYPTO_DF80090A) += df_sp80090a.o
crypto/fips140/fips140-api.c +11 -0
@@ -853,6 +853,17 @@ DEFINE_CRYPTO_API_STUB(async_syndrome_val);DEFINE_CRYPTO_API_STUB (async_raid6_2data_recov);DEFINE_CRYPTO_API_STUB (async_raid6_datap_recov); +#endif +/* +* crypto/kdf_sp800108.c +*/ +#if IS_BUILTIN (CONFIG_CRYPTO_KDF800108_CTR ) + +#include <crypto/kdf_sp800108.h> + +DEFINE_CRYPTO_API_STUB (crypto_kdf108_ctr_generate); +DEFINE_CRYPTO_API_STUB (crypto_kdf108_setkey); +#endif /* * crypto/ecdh_helper.c
crypto/kdf_sp800108.c +2 -2
@@ -149,8 +149,8 @@ static int __init crypto_kdf108_init(void) static void __exit crypto_kdf108_exit(void) { } -module_init (crypto_kdf108_init); -module_exit (crypto_kdf108_exit); +crypto_module_init (crypto_kdf108_init); +crypto_module_exit (crypto_kdf108_exit);MODULE_LICENSE ("GPL v2" );MODULE_AUTHOR ("Stephan Mueller <[email protected]>" );
include/crypto/kdf_sp800108.h +8 -6
@@ -7,6 +7,8 @@#ifndef _CRYPTO_KDF108_H#define _CRYPTO_KDF108_H +#include <crypto/api.h> +#include <crypto/hash.h> #include <linux/uio.h>
@@ -28,9 +30,9 @@* * @return 0 on success, < 0 on error */ -int crypto_kdf108_ctr_generate (struct crypto_shash *kmd, -const struct kvec *info,unsigned int info_nvec, -u8 *dst,unsigned int dlen); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_KDF800108_CTR , crypto_kdf108_ctr_generate, int, + (struct crypto_shash *kmd, const struct kvec *info, unsigned int info_nvec, u8 *dst, unsigned int dlen), + (kmd, info, info_nvec, dst, dlen));/** * Counter KDF setkey operation
@@ -54,8 +56,8 @@ int crypto_kdf108_ctr_generate(struct crypto_shash *kmd,* * @return 0 on success, < 0 on error */ -int crypto_kdf108_setkey (struct crypto_shash *kmd, -const u8 *key,size_t keylen, -const u8 *ikm,size_t ikmlen); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_KDF800108_CTR , crypto_kdf108_setkey, int, + (struct crypto_shash *kmd, const u8 *key, size_t keylen, const u8 *ikm, size_t ikmlen), + (kmd, key, keylen, ikm, ikmlen));#endif /* _CRYPTO_KDF108_H */
Signature · 1 line
2.47.3
PATCH 100/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_KRB5 crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_KRB5-related crypto to convert them into pluggable interface.
--- crypto/fips140/fips140-api.c | 27 +++++++++++++ crypto/krb5/Makefile | 2 +- crypto/krb5/krb5_api.c | 4 +- include/crypto/krb5.h | 78 ++++++++++++++++-------------------- 4 files changed, 65 insertions(+), 46 deletions(-)
crypto/fips140/fips140-api.c +27 -0
@@ -864,6 +864,33 @@ DEFINE_CRYPTO_API_STUB(async_raid6_datap_recov);DEFINE_CRYPTO_API_STUB (crypto_kdf108_ctr_generate);DEFINE_CRYPTO_API_STUB (crypto_kdf108_setkey); +#endif +/* +* crypto/krb5/krb5.o +*/ +#if IS_BUILTIN (CONFIG_CRYPTO_KRB5 ) + +#include <crypto/krb5.h> + +/* +* crypto/krb5/krb5_kdf.c +*/ +DEFINE_CRYPTO_API_STUB (crypto_krb5_calc_PRFplus); + +/* +* crypto/krb5/krb5_api.c +*/ +DEFINE_CRYPTO_API_STUB (crypto_krb5_find_enctype); +DEFINE_CRYPTO_API_STUB (crypto_krb5_how_much_buffer); +DEFINE_CRYPTO_API_STUB (crypto_krb5_how_much_data); +DEFINE_CRYPTO_API_STUB (crypto_krb5_where_is_the_data); +DEFINE_CRYPTO_API_STUB (crypto_krb5_prepare_encryption); +DEFINE_CRYPTO_API_STUB (crypto_krb5_prepare_checksum); +DEFINE_CRYPTO_API_STUB (crypto_krb5_encrypt); +DEFINE_CRYPTO_API_STUB (crypto_krb5_decrypt); +DEFINE_CRYPTO_API_STUB (crypto_krb5_get_mic); +DEFINE_CRYPTO_API_STUB (crypto_krb5_verify_mic); +#endif /* * crypto/ecdh_helper.c
crypto/krb5/Makefile +1 -1
@@ -15,4 +15,4 @@ krb5-$(CONFIG_CRYPTO_KRB5_SELFTESTS) += \ selftest.o \ selftest_data.o -obj-$(CONFIG_CRYPTO_KRB5) += krb5.o +crypto-objs-$(CONFIG_CRYPTO_KRB5) += krb5.o
crypto/krb5/krb5_api.c +2 -2
@@ -444,9 +444,9 @@ static int __init crypto_krb5_init(void) {return krb5_selftest (); } -module_init (crypto_krb5_init); +crypto_module_init (crypto_krb5_init); static void __exit crypto_krb5_exit(void) { } -module_exit (crypto_krb5_exit); +crypto_module_exit (crypto_krb5_exit);
include/crypto/krb5.h +35 -43
93 lines not on this page · raw message
Signature · 1 line
2.47.3
PATCH 101/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_FIPS_SIGNATURE_SELFTEST crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_FIPS_SIGNATURE_SELFTEST-related crypto to convert them into pluggable interface.
--- crypto/asymmetric_keys/Makefile | 2 +- crypto/asymmetric_keys/selftest.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-)
crypto/asymmetric_keys/Makefile +1 -1
@@ -22,7 +22,7 @@ x509_key_parser-y := \ x509_cert_parser.o \ x509_loader.o \ x509_public_key.o -obj-$(CONFIG_FIPS_SIGNATURE_SELFTEST) += x509_selftest.o +crypto-objs-$(CONFIG_FIPS_SIGNATURE_SELFTEST) += x509_selftest.o x509_selftest-y += selftest.o x509_selftest-$(CONFIG_FIPS_SIGNATURE_SELFTEST_RSA) += selftest_rsa.o x509_selftest-$(CONFIG_FIPS_SIGNATURE_SELFTEST_ECDSA) += selftest_ecdsa.o
crypto/asymmetric_keys/selftest.c +1 -1
@@ -65,7 +65,7 @@ static int __init fips_signature_selftest_init(void)return 0 ; } -late_initcall (fips_signature_selftest_init); +crypto_late_initcall (fips_signature_selftest_init);MODULE_DESCRIPTION ("X.509 self tests" );MODULE_AUTHOR ("Red Hat, Inc." );
Signature · 1 line
2.47.3
PATCH 102/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_PKCS8_PRIVATE_KEY_PARSER crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_PKCS8_PRIVATE_KEY_PARSER-related crypto to convert them into pluggable interface.
--- crypto/asymmetric_keys/Makefile | 2 +- crypto/asymmetric_keys/pkcs8_parser.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/asymmetric_keys/Makefile +1 -1
@@ -37,7 +37,7 @@ $(obj)/x509_akid.asn1.o: $(obj)/x509_akid.asn1.c $(obj)/x509_akid.asn1.h # # PKCS#8 private key handling # -obj-$(CONFIG_PKCS8_PRIVATE_KEY_PARSER) += pkcs8_key_parser.o +crypto-objs-$(CONFIG_PKCS8_PRIVATE_KEY_PARSER) += pkcs8_key_parser.o pkcs8_key_parser-y := \ pkcs8.asn1.o \ pkcs8_parser.o
crypto/asymmetric_keys/pkcs8_parser.c +2 -2
@@ -173,8 +173,8 @@ static void __exit pkcs8_key_exit(void)unregister_asymmetric_key_parser (&pkcs8_key_parser); } -module_init (pkcs8_key_init); -module_exit (pkcs8_key_exit); +crypto_module_init (pkcs8_key_init); +crypto_module_exit (pkcs8_key_exit);MODULE_DESCRIPTION ("PKCS#8 certificate parser" );MODULE_LICENSE ("GPL" );
Signature · 1 line
2.47.3
PATCH 103/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_PKCS7_TEST_KEY crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_PKCS7_TEST_KEY-related crypto to convert them into pluggable interface.
--- crypto/asymmetric_keys/Makefile | 2 +- crypto/asymmetric_keys/pkcs7_key_type.c | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-)
crypto/asymmetric_keys/Makefile +1 -1
@@ -63,7 +63,7 @@ $(obj)/pkcs7.asn1.o: $(obj)/pkcs7.asn1.c $(obj)/pkcs7.asn1.h # # PKCS#7 parser testing key # -obj-$(CONFIG_PKCS7_TEST_KEY) += pkcs7_test_key.o +crypto-objs-$(CONFIG_PKCS7_TEST_KEY) += pkcs7_test_key.o pkcs7_test_key-y := \ pkcs7_key_type.o
crypto/asymmetric_keys/pkcs7_key_type.c +3 -3
@@ -4,8 +4,8 @@* Copyright (C) 2014 Red Hat, Inc. All Rights Reserved. * Written by David Howells ([email protected]) */ -#define pr_fmt (fmt) "PKCS7key: "fmt +#include <crypto/api.h> #include <linux/key.h> #include <linux/err.h> #include <linux/module.h>
@@ -91,5 +91,5 @@ static void __exit pkcs7_key_cleanup(void)unregister_key_type (&key_type_pkcs7); } -module_init (pkcs7_key_init); -module_exit (pkcs7_key_cleanup); +crypto_module_init (pkcs7_key_init); +crypto_module_exit (pkcs7_key_cleanup);
Signature · 1 line
2.47.3
PATCH 104/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_SIGNED_PE_FILE_VERIFICATION crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_SIGNED_PE_FILE_VERIFICATION-related crypto to convert them into pluggable interface.
--- crypto/asymmetric_keys/Makefile | 2 +- crypto/asymmetric_keys/verify_pefile.c | 1 + crypto/fips140/fips140-api.c | 10 ++++++++++ include/linux/verification.h | 8 +++++--- 4 files changed, 17 insertions(+), 4 deletions(-)
crypto/asymmetric_keys/Makefile +1 -1
@@ -70,7 +70,7 @@ pkcs7_test_key-y := \ # # Signed PE binary-wrapped key handling # -obj-$(CONFIG_SIGNED_PE_FILE_VERIFICATION) += verify_signed_pefile.o +crypto-objs-$(CONFIG_SIGNED_PE_FILE_VERIFICATION) += verify_signed_pefile.o verify_signed_pefile-y := \ verify_pefile.o \
crypto/asymmetric_keys/verify_pefile.c +1 -0
@@ -454,3 +454,4 @@ int verify_pefile_signature(const void *pebuf, unsigned pelen,kfree_sensitive (ctx.digest);return ret; } +EXPORT_SYMBOL (verify_pefile_signature);
crypto/fips140/fips140-api.c +10 -0
@@ -903,4 +903,14 @@ DEFINE_CRYPTO_API_STUB(crypto_ecdh_key_len);DEFINE_CRYPTO_API_STUB (crypto_ecdh_encode_key);DEFINE_CRYPTO_API_STUB (crypto_ecdh_decode_key); +#endif +/* +* crypto/asymmetric_keys/verify_pefile.c +*/ +#if IS_BUILTIN (CONFIG_SIGNED_PE_FILE_VERIFICATION ) + +#include <linux/verification.h> + +DEFINE_CRYPTO_API_STUB (verify_pefile_signature); +#endif
include/linux/verification.h +5 -3
@@ -8,6 +8,8 @@#ifndef _LINUX_VERIFICATION_H#define _LINUX_VERIFICATION_H +#include <crypto/api.h> +#include <linux/errno.h> #include <linux/types.h>
@@ -63,9 +65,9 @@ extern int verify_pkcs7_message_sig(const void *data, size_t len, void *ctx);#ifdef CONFIG_SIGNED_PE_FILE_VERIFICATION -extern int verify_pefile_signature (const void *pebuf,unsigned pelen, -struct key *trusted_keys, -enum key_being_used_for usage); +DECLARE_CRYPTO_API (CONFIG_SIGNED_PE_FILE_VERIFICATION , verify_pefile_signature, int, + (const void *pebuf, unsigned pelen, struct key *trusted_keys, enum key_being_used_for usage), + (pebuf, pelen, trusted_keys, usage));#endif #endif /* CONFIG_SYSTEM_DATA_VERIFICATION */
Signature · 1 line
2.47.3
PATCH 105/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_CRYPTO_SIMD crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_CRYPTO_SIMD-related crypto to convert them into pluggable interface.
This patch is partially based on work by Vegard Nossum, with modifications. Unlike the original, we do not include DEFINE_CRYPTO_API since only one copy of the crypto symbols is kept, either in the crypto module or in the main kernel, and we ensure such wrapper do not have impact on crypto already chosen built as module.
--- crypto/Makefile | 2 +- crypto/fips140/fips140-api.c | 15 +++++++++++++++ include/crypto/internal/simd.h | 33 ++++++++++++++++++++------------- 3 files changed, 36 insertions(+), 14 deletions(-)
crypto/Makefile +1 -1
@@ -200,7 +200,7 @@ crypto-objs-$(CONFIG_XOR_BLOCKS) += xor.o obj-$(CONFIG_ASYNC_CORE) += async_tx/ obj-$(CONFIG_ASYMMETRIC_KEY_TYPE) += asymmetric_keys/ crypto_simd-y := simd.o -obj-$(CONFIG_CRYPTO_SIMD) += crypto_simd.o +crypto-objs-$(CONFIG_CRYPTO_SIMD) += crypto_simd.o # # Key derivation function
crypto/fips140/fips140-api.c +15 -0
@@ -913,4 +913,19 @@ DEFINE_CRYPTO_API_STUB(crypto_ecdh_decode_key);DEFINE_CRYPTO_API_STUB (verify_pefile_signature); +#endif +/* +* crypto/simd.c +*/ +#if IS_BUILTIN (CONFIG_CRYPTO_SIMD ) + +#include <crypto/internal/simd.h> + +DEFINE_CRYPTO_API_STUB (simd_skcipher_create_compat); +DEFINE_CRYPTO_API_STUB (simd_skcipher_free); +DEFINE_CRYPTO_API_STUB (simd_register_skciphers_compat); +DEFINE_CRYPTO_API_STUB (simd_unregister_skciphers); +DEFINE_CRYPTO_API_STUB (simd_register_aeads_compat); +DEFINE_CRYPTO_API_STUB (simd_unregister_aeads); +#endif
include/crypto/internal/simd.h +20 -13
@@ -6,6 +6,8 @@#ifndef _CRYPTO_INTERNAL_SIMD_H#define _CRYPTO_INTERNAL_SIMD_H +#include <crypto/api.h> +#include <asm/simd.h> #include <linux/percpu.h> #include <linux/types.h>
@@ -15,28 +17,33 @@struct simd_skcipher_alg ;struct skcipher_alg ; -struct simd_skcipher_alg *simd_skcipher_create_compat (struct skcipher_alg *ialg, -const char *algname, -const char *drvname, -const char *basename); -void simd_skcipher_free (struct simd_skcipher_alg *alg); +DECLARE_CRYPTO_API(CONFIG_CRYPTO_SIMD, simd_skcipher_create_compat, struct simd_skcipher_alg *, + (struct skcipher_alg *ialg, const char *algname, const char *drvname, const char *basename), + (ialg, algname, drvname, basename)); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_SIMD , simd_skcipher_free, void, + (struct simd_skcipher_alg *alg), + (alg)); -int simd_register_skciphers_compat (struct skcipher_alg *algs,int count, -struct simd_skcipher_alg **simd_algs); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_SIMD , simd_register_skciphers_compat, int, + (struct skcipher_alg *algs, int count, struct simd_skcipher_alg **simd_algs), + (algs, count, simd_algs)); -void simd_unregister_skciphers (struct skcipher_alg *algs,int count, -struct simd_skcipher_alg **simd_algs); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_SIMD , simd_unregister_skciphers, void, + (struct skcipher_alg *algs, int count, struct simd_skcipher_alg **simd_algs), + (algs, count, simd_algs));/* AEAD support */ struct simd_aead_alg ;struct aead_alg ; -int simd_register_aeads_compat (struct aead_alg *algs,int count, -struct simd_aead_alg **simd_algs); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_SIMD , simd_register_aeads_compat, int, + (struct aead_alg *algs, int count, struct simd_aead_alg **simd_algs), + (algs, count, simd_algs)); -void simd_unregister_aeads (struct aead_alg *algs,int count, -struct simd_aead_alg **simd_algs); +DECLARE_CRYPTO_API (CONFIG_CRYPTO_SIMD , simd_unregister_aeads, void, + (struct aead_alg *algs, int count, struct simd_aead_alg **simd_algs), + (algs, count, simd_algs));/* * crypto_simd_usable() - is it allowed at this time to use SIMD instructions or
Signature · 1 line
2.47.3
PATCH 106/106 crypto: convert exported crypto symbol into pluggable interface for CONFIG_ASYNC_RAID6_TEST crypto
In reply to Jay WangApply Crypto API wrappers to the exported crypto symbol in CONFIG_ASYNC_RAID6_TEST-related crypto to convert them into pluggable interface.
--- crypto/async_tx/Makefile | 2 +- crypto/async_tx/raid6test.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
crypto/async_tx/Makefile +1 -1
@@ -4,4 +4,4 @@ crypto-objs-$(CONFIG_ASYNC_MEMCPY) += async_memcpy.o crypto-objs-$(CONFIG_ASYNC_XOR) += async_xor.o crypto-objs-$(CONFIG_ASYNC_PQ) += async_pq.o crypto-objs-$(CONFIG_ASYNC_RAID6_RECOV) += async_raid6_recov.o -obj-$(CONFIG_ASYNC_RAID6_TEST) += raid6test.o +crypto-objs-$(CONFIG_ASYNC_RAID6_TEST) += raid6test.o
crypto/async_tx/raid6test.c +2 -2
@@ -243,8 +243,8 @@ static void __exit raid6_test_exit(void)/* when compiled-in wait for drivers to load first (assumes dma drivers * are also compiled-in) */ -late_initcall (raid6_test); -module_exit (raid6_test_exit); +crypto_late_initcall (raid6_test); +crypto_module_exit (raid6_test_exit);MODULE_AUTHOR ("Dan Williams <[email protected]>" );MODULE_DESCRIPTION ("asynchronous RAID-6 recovery self tests" );MODULE_LICENSE ("GPL" );
Signature · 1 line
2.47.3