mirror of
https://github.com/edk2-porting/linux-next.git
synced 2024-12-12 23:33:55 +08:00
Merge git://git.kernel.org/pub/scm/linux/kernel/git/herbert/crypto-2.6
Pull crypto update from Herbert Xu: - The crypto API is now documented :) - Disallow arbitrary module loading through crypto API. - Allow get request with empty driver name through crypto_user. - Allow speed testing of arbitrary hash functions. - Add caam support for ctr(aes), gcm(aes) and their derivatives. - nx now supports concurrent hashing properly. - Add sahara support for SHA1/256. - Add ARM64 version of CRC32. - Misc fixes. * git://git.kernel.org/pub/scm/linux/kernel/git/herbert/crypto-2.6: (77 commits) crypto: tcrypt - Allow speed testing of arbitrary hash functions crypto: af_alg - add user space interface for AEAD crypto: qat - fix problem with coalescing enable logic crypto: sahara - add support for SHA1/256 crypto: sahara - replace tasklets with kthread crypto: sahara - add support for i.MX53 crypto: sahara - fix spinlock initialization crypto: arm - replace memset by memzero_explicit crypto: powerpc - replace memset by memzero_explicit crypto: sha - replace memset by memzero_explicit crypto: sparc - replace memset by memzero_explicit crypto: algif_skcipher - initialize upon init request crypto: algif_skcipher - removed unneeded code crypto: algif_skcipher - Fixed blocking recvmsg crypto: drbg - use memzero_explicit() for clearing sensitive data crypto: drbg - use MODULE_ALIAS_CRYPTO crypto: include crypto- module prefix in template crypto: user - add MODULE_ALIAS crypto: sha-mb - remove a bogus NULL check crytpo: qat - Fix 64 bytes requests ...
This commit is contained in:
commit
e3aa91a7cb
Documentation
DocBook
crypto
devicetree/bindings
arch
arm
arm64/crypto
powerpc/crypto
s390/crypto
sparc/crypto
x86/crypto
aes_glue.caesni-intel_glue.cblowfish_glue.ccamellia_aesni_avx2_glue.ccamellia_aesni_avx_glue.ccamellia_glue.ccast5_avx_glue.ccast6_avx_glue.ccrc32-pclmul_glue.ccrc32c-intel_glue.ccrct10dif-pclmul_glue.cdes3_ede_glue.cfpu.cghash-clmulni-intel_glue.csalsa20_glue.cserpent_avx2_glue.cserpent_avx_glue.cserpent_sse2_glue.c
sha-mb
sha1_ssse3_glue.csha256_ssse3_glue.csha512_ssse3_glue.ctwofish_avx_glue.ctwofish_glue.ctwofish_glue_3way.ccrypto
842.caes_generic.caf_alg.calgapi.calgif_hash.calgif_skcipher.cansi_cprng.canubis.capi.carc4.cauthenc.cauthencesn.cblowfish_generic.ccamellia_generic.ccast5_generic.ccast6_generic.ccbc.cccm.cchainiv.ccmac.ccrc32.ccrc32c_generic.ccrct10dif_generic.ccryptd.ccrypto_null.ccrypto_user.cctr.ccts.cdeflate.cdes_generic.cdrbg.cecb.ceseqiv.cfcrypt.cgcm.cghash-generic.chmac.ckhazad.ckrng.clrw.clz4.clz4hc.clzo.cmcryptd.cmd4.c
@ -15,7 +15,7 @@ DOCBOOKS := z8530book.xml device-drivers.xml \
|
||||
80211.xml debugobjects.xml sh.xml regulator.xml \
|
||||
alsa-driver-api.xml writing-an-alsa-driver.xml \
|
||||
tracepoint.xml drm.xml media_api.xml w1.xml \
|
||||
writing_musb_glue_layer.xml
|
||||
writing_musb_glue_layer.xml crypto-API.xml
|
||||
|
||||
include Documentation/DocBook/media/Makefile
|
||||
|
||||
|
1253
Documentation/DocBook/crypto-API.tmpl
Normal file
1253
Documentation/DocBook/crypto-API.tmpl
Normal file
File diff suppressed because it is too large
Load Diff
205
Documentation/crypto/crypto-API-userspace.txt
Normal file
205
Documentation/crypto/crypto-API-userspace.txt
Normal file
@ -0,0 +1,205 @@
|
||||
Introduction
|
||||
============
|
||||
|
||||
The concepts of the kernel crypto API visible to kernel space is fully
|
||||
applicable to the user space interface as well. Therefore, the kernel crypto API
|
||||
high level discussion for the in-kernel use cases applies here as well.
|
||||
|
||||
The major difference, however, is that user space can only act as a consumer
|
||||
and never as a provider of a transformation or cipher algorithm.
|
||||
|
||||
The following covers the user space interface exported by the kernel crypto
|
||||
API. A working example of this description is libkcapi that can be obtained from
|
||||
[1]. That library can be used by user space applications that require
|
||||
cryptographic services from the kernel.
|
||||
|
||||
Some details of the in-kernel kernel crypto API aspects do not
|
||||
apply to user space, however. This includes the difference between synchronous
|
||||
and asynchronous invocations. The user space API call is fully synchronous.
|
||||
In addition, only a subset of all cipher types are available as documented
|
||||
below.
|
||||
|
||||
|
||||
User space API general remarks
|
||||
==============================
|
||||
|
||||
The kernel crypto API is accessible from user space. Currently, the following
|
||||
ciphers are accessible:
|
||||
|
||||
* Message digest including keyed message digest (HMAC, CMAC)
|
||||
|
||||
* Symmetric ciphers
|
||||
|
||||
Note, AEAD ciphers are currently not supported via the symmetric cipher
|
||||
interface.
|
||||
|
||||
The interface is provided via Netlink using the type AF_ALG. In addition, the
|
||||
setsockopt option type is SOL_ALG. In case the user space header files do not
|
||||
export these flags yet, use the following macros:
|
||||
|
||||
#ifndef AF_ALG
|
||||
#define AF_ALG 38
|
||||
#endif
|
||||
#ifndef SOL_ALG
|
||||
#define SOL_ALG 279
|
||||
#endif
|
||||
|
||||
A cipher is accessed with the same name as done for the in-kernel API calls.
|
||||
This includes the generic vs. unique naming schema for ciphers as well as the
|
||||
enforcement of priorities for generic names.
|
||||
|
||||
To interact with the kernel crypto API, a Netlink socket must be created by
|
||||
the user space application. User space invokes the cipher operation with the
|
||||
send/write system call family. The result of the cipher operation is obtained
|
||||
with the read/recv system call family.
|
||||
|
||||
The following API calls assume that the Netlink socket descriptor is already
|
||||
opened by the user space application and discusses only the kernel crypto API
|
||||
specific invocations.
|
||||
|
||||
To initialize a Netlink interface, the following sequence has to be performed
|
||||
by the consumer:
|
||||
|
||||
1. Create a socket of type AF_ALG with the struct sockaddr_alg parameter
|
||||
specified below for the different cipher types.
|
||||
|
||||
2. Invoke bind with the socket descriptor
|
||||
|
||||
3. Invoke accept with the socket descriptor. The accept system call
|
||||
returns a new file descriptor that is to be used to interact with
|
||||
the particular cipher instance. When invoking send/write or recv/read
|
||||
system calls to send data to the kernel or obtain data from the
|
||||
kernel, the file descriptor returned by accept must be used.
|
||||
|
||||
In-place cipher operation
|
||||
=========================
|
||||
|
||||
Just like the in-kernel operation of the kernel crypto API, the user space
|
||||
interface allows the cipher operation in-place. That means that the input buffer
|
||||
used for the send/write system call and the output buffer used by the read/recv
|
||||
system call may be one and the same. This is of particular interest for
|
||||
symmetric cipher operations where a copying of the output data to its final
|
||||
destination can be avoided.
|
||||
|
||||
If a consumer on the other hand wants to maintain the plaintext and the
|
||||
ciphertext in different memory locations, all a consumer needs to do is to
|
||||
provide different memory pointers for the encryption and decryption operation.
|
||||
|
||||
Message digest API
|
||||
==================
|
||||
|
||||
The message digest type to be used for the cipher operation is selected when
|
||||
invoking the bind syscall. bind requires the caller to provide a filled
|
||||
struct sockaddr data structure. This data structure must be filled as follows:
|
||||
|
||||
struct sockaddr_alg sa = {
|
||||
.salg_family = AF_ALG,
|
||||
.salg_type = "hash", /* this selects the hash logic in the kernel */
|
||||
.salg_name = "sha1" /* this is the cipher name */
|
||||
};
|
||||
|
||||
The salg_type value "hash" applies to message digests and keyed message digests.
|
||||
Though, a keyed message digest is referenced by the appropriate salg_name.
|
||||
Please see below for the setsockopt interface that explains how the key can be
|
||||
set for a keyed message digest.
|
||||
|
||||
Using the send() system call, the application provides the data that should be
|
||||
processed with the message digest. The send system call allows the following
|
||||
flags to be specified:
|
||||
|
||||
* MSG_MORE: If this flag is set, the send system call acts like a
|
||||
message digest update function where the final hash is not
|
||||
yet calculated. If the flag is not set, the send system call
|
||||
calculates the final message digest immediately.
|
||||
|
||||
With the recv() system call, the application can read the message digest from
|
||||
the kernel crypto API. If the buffer is too small for the message digest, the
|
||||
flag MSG_TRUNC is set by the kernel.
|
||||
|
||||
In order to set a message digest key, the calling application must use the
|
||||
setsockopt() option of ALG_SET_KEY. If the key is not set the HMAC operation is
|
||||
performed without the initial HMAC state change caused by the key.
|
||||
|
||||
|
||||
Symmetric cipher API
|
||||
====================
|
||||
|
||||
The operation is very similar to the message digest discussion. During
|
||||
initialization, the struct sockaddr data structure must be filled as follows:
|
||||
|
||||
struct sockaddr_alg sa = {
|
||||
.salg_family = AF_ALG,
|
||||
.salg_type = "skcipher", /* this selects the symmetric cipher */
|
||||
.salg_name = "cbc(aes)" /* this is the cipher name */
|
||||
};
|
||||
|
||||
Before data can be sent to the kernel using the write/send system call family,
|
||||
the consumer must set the key. The key setting is described with the setsockopt
|
||||
invocation below.
|
||||
|
||||
Using the sendmsg() system call, the application provides the data that should
|
||||
be processed for encryption or decryption. In addition, the IV is specified
|
||||
with the data structure provided by the sendmsg() system call.
|
||||
|
||||
The sendmsg system call parameter of struct msghdr is embedded into the
|
||||
struct cmsghdr data structure. See recv(2) and cmsg(3) for more information
|
||||
on how the cmsghdr data structure is used together with the send/recv system
|
||||
call family. That cmsghdr data structure holds the following information
|
||||
specified with a separate header instances:
|
||||
|
||||
* specification of the cipher operation type with one of these flags:
|
||||
ALG_OP_ENCRYPT - encryption of data
|
||||
ALG_OP_DECRYPT - decryption of data
|
||||
|
||||
* specification of the IV information marked with the flag ALG_SET_IV
|
||||
|
||||
The send system call family allows the following flag to be specified:
|
||||
|
||||
* MSG_MORE: If this flag is set, the send system call acts like a
|
||||
cipher update function where more input data is expected
|
||||
with a subsequent invocation of the send system call.
|
||||
|
||||
Note: The kernel reports -EINVAL for any unexpected data. The caller must
|
||||
make sure that all data matches the constraints given in /proc/crypto for the
|
||||
selected cipher.
|
||||
|
||||
With the recv() system call, the application can read the result of the
|
||||
cipher operation from the kernel crypto API. The output buffer must be at least
|
||||
as large as to hold all blocks of the encrypted or decrypted data. If the output
|
||||
data size is smaller, only as many blocks are returned that fit into that
|
||||
output buffer size.
|
||||
|
||||
Setsockopt interface
|
||||
====================
|
||||
|
||||
In addition to the read/recv and send/write system call handling to send and
|
||||
retrieve data subject to the cipher operation, a consumer also needs to set
|
||||
the additional information for the cipher operation. This additional information
|
||||
is set using the setsockopt system call that must be invoked with the file
|
||||
descriptor of the open cipher (i.e. the file descriptor returned by the
|
||||
accept system call).
|
||||
|
||||
Each setsockopt invocation must use the level SOL_ALG.
|
||||
|
||||
The setsockopt interface allows setting the following data using the mentioned
|
||||
optname:
|
||||
|
||||
* ALG_SET_KEY -- Setting the key. Key setting is applicable to:
|
||||
|
||||
- the skcipher cipher type (symmetric ciphers)
|
||||
|
||||
- the hash cipher type (keyed message digests)
|
||||
|
||||
User space API example
|
||||
======================
|
||||
|
||||
Please see [1] for libkcapi which provides an easy-to-use wrapper around the
|
||||
aforementioned Netlink kernel interface. [1] also contains a test application
|
||||
that invokes all libkcapi API calls.
|
||||
|
||||
[1] http://www.chronox.de/libkcapi.html
|
||||
|
||||
Author
|
||||
======
|
||||
|
||||
Stephan Mueller <smueller@chronox.de>
|
@ -1,5 +1,5 @@
|
||||
Freescale SAHARA Cryptographic Accelerator included in some i.MX chips.
|
||||
Currently only i.MX27 is supported.
|
||||
Currently only i.MX27 and i.MX53 are supported.
|
||||
|
||||
Required properties:
|
||||
- compatible : Should be "fsl,<soc>-sahara"
|
||||
|
16
Documentation/devicetree/bindings/hwrng/atmel-trng.txt
Normal file
16
Documentation/devicetree/bindings/hwrng/atmel-trng.txt
Normal file
@ -0,0 +1,16 @@
|
||||
Atmel TRNG (True Random Number Generator) block
|
||||
|
||||
Required properties:
|
||||
- compatible : Should be "atmel,at91sam9g45-trng"
|
||||
- reg : Offset and length of the register set of this block
|
||||
- interrupts : the interrupt number for the TRNG block
|
||||
- clocks: should contain the TRNG clk source
|
||||
|
||||
Example:
|
||||
|
||||
trng@fffcc000 {
|
||||
compatible = "atmel,at91sam9g45-trng";
|
||||
reg = <0xfffcc000 0x4000>;
|
||||
interrupts = <6 IRQ_TYPE_LEVEL_HIGH 0>;
|
||||
clocks = <&trng_clk>;
|
||||
};
|
@ -940,6 +940,13 @@
|
||||
status = "disabled";
|
||||
};
|
||||
|
||||
trng@fffcc000 {
|
||||
compatible = "atmel,at91sam9g45-trng";
|
||||
reg = <0xfffcc000 0x4000>;
|
||||
interrupts = <6 IRQ_TYPE_LEVEL_HIGH 0>;
|
||||
clocks = <&trng_clk>;
|
||||
};
|
||||
|
||||
i2c0: i2c@fff84000 {
|
||||
compatible = "atmel,at91sam9g10-i2c";
|
||||
reg = <0xfff84000 0x100>;
|
||||
|
@ -93,6 +93,6 @@ module_exit(aes_fini);
|
||||
|
||||
MODULE_DESCRIPTION("Rijndael (AES) Cipher Algorithm (ASM)");
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_ALIAS("aes");
|
||||
MODULE_ALIAS("aes-asm");
|
||||
MODULE_ALIAS_CRYPTO("aes");
|
||||
MODULE_ALIAS_CRYPTO("aes-asm");
|
||||
MODULE_AUTHOR("David McCullough <ucdevel@gmail.com>");
|
||||
|
@ -171,5 +171,5 @@ module_exit(sha1_mod_fini);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("SHA1 Secure Hash Algorithm (ARM)");
|
||||
MODULE_ALIAS("sha1");
|
||||
MODULE_ALIAS_CRYPTO("sha1");
|
||||
MODULE_AUTHOR("David McCullough <ucdevel@gmail.com>");
|
||||
|
@ -194,4 +194,4 @@ module_exit(sha1_neon_mod_fini);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("SHA1 Secure Hash Algorithm, NEON accelerated");
|
||||
MODULE_ALIAS("sha1");
|
||||
MODULE_ALIAS_CRYPTO("sha1");
|
||||
|
@ -241,7 +241,7 @@ static int sha384_neon_final(struct shash_desc *desc, u8 *hash)
|
||||
sha512_neon_final(desc, D);
|
||||
|
||||
memcpy(hash, D, SHA384_DIGEST_SIZE);
|
||||
memset(D, 0, SHA512_DIGEST_SIZE);
|
||||
memzero_explicit(D, SHA512_DIGEST_SIZE);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -301,5 +301,5 @@ module_exit(sha512_neon_mod_fini);
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("SHA512 Secure Hash Algorithm, NEON accelerated");
|
||||
|
||||
MODULE_ALIAS("sha512");
|
||||
MODULE_ALIAS("sha384");
|
||||
MODULE_ALIAS_CRYPTO("sha512");
|
||||
MODULE_ALIAS_CRYPTO("sha384");
|
||||
|
@ -49,4 +49,8 @@ config CRYPTO_AES_ARM64_NEON_BLK
|
||||
select CRYPTO_AES
|
||||
select CRYPTO_ABLK_HELPER
|
||||
|
||||
config CRYPTO_CRC32_ARM64
|
||||
tristate "CRC32 and CRC32C using optional ARMv8 instructions"
|
||||
depends on ARM64
|
||||
select CRYPTO_HASH
|
||||
endif
|
||||
|
@ -34,5 +34,9 @@ AFLAGS_aes-neon.o := -DINTERLEAVE=4
|
||||
|
||||
CFLAGS_aes-glue-ce.o := -DUSE_V8_CRYPTO_EXTENSIONS
|
||||
|
||||
obj-$(CONFIG_CRYPTO_CRC32_ARM64) += crc32-arm64.o
|
||||
|
||||
CFLAGS_crc32-arm64.o := -mcpu=generic+crc
|
||||
|
||||
$(obj)/aes-glue-%.o: $(src)/aes-glue.c FORCE
|
||||
$(call if_changed_rule,cc_o_c)
|
||||
|
@ -296,4 +296,4 @@ module_exit(aes_mod_exit);
|
||||
MODULE_DESCRIPTION("Synchronous AES in CCM mode using ARMv8 Crypto Extensions");
|
||||
MODULE_AUTHOR("Ard Biesheuvel <ard.biesheuvel@linaro.org>");
|
||||
MODULE_LICENSE("GPL v2");
|
||||
MODULE_ALIAS("ccm(aes)");
|
||||
MODULE_ALIAS_CRYPTO("ccm(aes)");
|
||||
|
@ -44,10 +44,10 @@ MODULE_DESCRIPTION("AES-ECB/CBC/CTR/XTS using ARMv8 Crypto Extensions");
|
||||
#define aes_xts_encrypt neon_aes_xts_encrypt
|
||||
#define aes_xts_decrypt neon_aes_xts_decrypt
|
||||
MODULE_DESCRIPTION("AES-ECB/CBC/CTR/XTS using ARMv8 NEON");
|
||||
MODULE_ALIAS("ecb(aes)");
|
||||
MODULE_ALIAS("cbc(aes)");
|
||||
MODULE_ALIAS("ctr(aes)");
|
||||
MODULE_ALIAS("xts(aes)");
|
||||
MODULE_ALIAS_CRYPTO("ecb(aes)");
|
||||
MODULE_ALIAS_CRYPTO("cbc(aes)");
|
||||
MODULE_ALIAS_CRYPTO("ctr(aes)");
|
||||
MODULE_ALIAS_CRYPTO("xts(aes)");
|
||||
#endif
|
||||
|
||||
MODULE_AUTHOR("Ard Biesheuvel <ard.biesheuvel@linaro.org>");
|
||||
|
274
arch/arm64/crypto/crc32-arm64.c
Normal file
274
arch/arm64/crypto/crc32-arm64.c
Normal file
@ -0,0 +1,274 @@
|
||||
/*
|
||||
* crc32-arm64.c - CRC32 and CRC32C using optional ARMv8 instructions
|
||||
*
|
||||
* Module based on crypto/crc32c_generic.c
|
||||
*
|
||||
* CRC32 loop taken from Ed Nevill's Hadoop CRC patch
|
||||
* http://mail-archives.apache.org/mod_mbox/hadoop-common-dev/201406.mbox/%3C1403687030.3355.19.camel%40localhost.localdomain%3E
|
||||
*
|
||||
* Using inline assembly instead of intrinsics in order to be backwards
|
||||
* compatible with older compilers.
|
||||
*
|
||||
* Copyright (C) 2014 Linaro Ltd <yazen.ghannam@linaro.org>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License version 2 as
|
||||
* published by the Free Software Foundation.
|
||||
*/
|
||||
|
||||
#include <linux/unaligned/access_ok.h>
|
||||
#include <linux/cpufeature.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/string.h>
|
||||
|
||||
#include <crypto/internal/hash.h>
|
||||
|
||||
MODULE_AUTHOR("Yazen Ghannam <yazen.ghannam@linaro.org>");
|
||||
MODULE_DESCRIPTION("CRC32 and CRC32C using optional ARMv8 instructions");
|
||||
MODULE_LICENSE("GPL v2");
|
||||
|
||||
#define CRC32X(crc, value) __asm__("crc32x %w[c], %w[c], %x[v]":[c]"+r"(crc):[v]"r"(value))
|
||||
#define CRC32W(crc, value) __asm__("crc32w %w[c], %w[c], %w[v]":[c]"+r"(crc):[v]"r"(value))
|
||||
#define CRC32H(crc, value) __asm__("crc32h %w[c], %w[c], %w[v]":[c]"+r"(crc):[v]"r"(value))
|
||||
#define CRC32B(crc, value) __asm__("crc32b %w[c], %w[c], %w[v]":[c]"+r"(crc):[v]"r"(value))
|
||||
#define CRC32CX(crc, value) __asm__("crc32cx %w[c], %w[c], %x[v]":[c]"+r"(crc):[v]"r"(value))
|
||||
#define CRC32CW(crc, value) __asm__("crc32cw %w[c], %w[c], %w[v]":[c]"+r"(crc):[v]"r"(value))
|
||||
#define CRC32CH(crc, value) __asm__("crc32ch %w[c], %w[c], %w[v]":[c]"+r"(crc):[v]"r"(value))
|
||||
#define CRC32CB(crc, value) __asm__("crc32cb %w[c], %w[c], %w[v]":[c]"+r"(crc):[v]"r"(value))
|
||||
|
||||
static u32 crc32_arm64_le_hw(u32 crc, const u8 *p, unsigned int len)
|
||||
{
|
||||
s64 length = len;
|
||||
|
||||
while ((length -= sizeof(u64)) >= 0) {
|
||||
CRC32X(crc, get_unaligned_le64(p));
|
||||
p += sizeof(u64);
|
||||
}
|
||||
|
||||
/* The following is more efficient than the straight loop */
|
||||
if (length & sizeof(u32)) {
|
||||
CRC32W(crc, get_unaligned_le32(p));
|
||||
p += sizeof(u32);
|
||||
}
|
||||
if (length & sizeof(u16)) {
|
||||
CRC32H(crc, get_unaligned_le16(p));
|
||||
p += sizeof(u16);
|
||||
}
|
||||
if (length & sizeof(u8))
|
||||
CRC32B(crc, *p);
|
||||
|
||||
return crc;
|
||||
}
|
||||
|
||||
static u32 crc32c_arm64_le_hw(u32 crc, const u8 *p, unsigned int len)
|
||||
{
|
||||
s64 length = len;
|
||||
|
||||
while ((length -= sizeof(u64)) >= 0) {
|
||||
CRC32CX(crc, get_unaligned_le64(p));
|
||||
p += sizeof(u64);
|
||||
}
|
||||
|
||||
/* The following is more efficient than the straight loop */
|
||||
if (length & sizeof(u32)) {
|
||||
CRC32CW(crc, get_unaligned_le32(p));
|
||||
p += sizeof(u32);
|
||||
}
|
||||
if (length & sizeof(u16)) {
|
||||
CRC32CH(crc, get_unaligned_le16(p));
|
||||
p += sizeof(u16);
|
||||
}
|
||||
if (length & sizeof(u8))
|
||||
CRC32CB(crc, *p);
|
||||
|
||||
return crc;
|
||||
}
|
||||
|
||||
#define CHKSUM_BLOCK_SIZE 1
|
||||
#define CHKSUM_DIGEST_SIZE 4
|
||||
|
||||
struct chksum_ctx {
|
||||
u32 key;
|
||||
};
|
||||
|
||||
struct chksum_desc_ctx {
|
||||
u32 crc;
|
||||
};
|
||||
|
||||
static int chksum_init(struct shash_desc *desc)
|
||||
{
|
||||
struct chksum_ctx *mctx = crypto_shash_ctx(desc->tfm);
|
||||
struct chksum_desc_ctx *ctx = shash_desc_ctx(desc);
|
||||
|
||||
ctx->crc = mctx->key;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Setting the seed allows arbitrary accumulators and flexible XOR policy
|
||||
* If your algorithm starts with ~0, then XOR with ~0 before you set
|
||||
* the seed.
|
||||
*/
|
||||
static int chksum_setkey(struct crypto_shash *tfm, const u8 *key,
|
||||
unsigned int keylen)
|
||||
{
|
||||
struct chksum_ctx *mctx = crypto_shash_ctx(tfm);
|
||||
|
||||
if (keylen != sizeof(mctx->key)) {
|
||||
crypto_shash_set_flags(tfm, CRYPTO_TFM_RES_BAD_KEY_LEN);
|
||||
return -EINVAL;
|
||||
}
|
||||
mctx->key = get_unaligned_le32(key);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int chksum_update(struct shash_desc *desc, const u8 *data,
|
||||
unsigned int length)
|
||||
{
|
||||
struct chksum_desc_ctx *ctx = shash_desc_ctx(desc);
|
||||
|
||||
ctx->crc = crc32_arm64_le_hw(ctx->crc, data, length);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int chksumc_update(struct shash_desc *desc, const u8 *data,
|
||||
unsigned int length)
|
||||
{
|
||||
struct chksum_desc_ctx *ctx = shash_desc_ctx(desc);
|
||||
|
||||
ctx->crc = crc32c_arm64_le_hw(ctx->crc, data, length);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int chksum_final(struct shash_desc *desc, u8 *out)
|
||||
{
|
||||
struct chksum_desc_ctx *ctx = shash_desc_ctx(desc);
|
||||
|
||||
put_unaligned_le32(~ctx->crc, out);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int __chksum_finup(u32 crc, const u8 *data, unsigned int len, u8 *out)
|
||||
{
|
||||
put_unaligned_le32(~crc32_arm64_le_hw(crc, data, len), out);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int __chksumc_finup(u32 crc, const u8 *data, unsigned int len, u8 *out)
|
||||
{
|
||||
put_unaligned_le32(~crc32c_arm64_le_hw(crc, data, len), out);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int chksum_finup(struct shash_desc *desc, const u8 *data,
|
||||
unsigned int len, u8 *out)
|
||||
{
|
||||
struct chksum_desc_ctx *ctx = shash_desc_ctx(desc);
|
||||
|
||||
return __chksum_finup(ctx->crc, data, len, out);
|
||||
}
|
||||
|
||||
static int chksumc_finup(struct shash_desc *desc, const u8 *data,
|
||||
unsigned int len, u8 *out)
|
||||
{
|
||||
struct chksum_desc_ctx *ctx = shash_desc_ctx(desc);
|
||||
|
||||
return __chksumc_finup(ctx->crc, data, len, out);
|
||||
}
|
||||
|
||||
static int chksum_digest(struct shash_desc *desc, const u8 *data,
|
||||
unsigned int length, u8 *out)
|
||||
{
|
||||
struct chksum_ctx *mctx = crypto_shash_ctx(desc->tfm);
|
||||
|
||||
return __chksum_finup(mctx->key, data, length, out);
|
||||
}
|
||||
|
||||
static int chksumc_digest(struct shash_desc *desc, const u8 *data,
|
||||
unsigned int length, u8 *out)
|
||||
{
|
||||
struct chksum_ctx *mctx = crypto_shash_ctx(desc->tfm);
|
||||
|
||||
return __chksumc_finup(mctx->key, data, length, out);
|
||||
}
|
||||
|
||||
static int crc32_cra_init(struct crypto_tfm *tfm)
|
||||
{
|
||||
struct chksum_ctx *mctx = crypto_tfm_ctx(tfm);
|
||||
|
||||
mctx->key = ~0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct shash_alg crc32_alg = {
|
||||
.digestsize = CHKSUM_DIGEST_SIZE,
|
||||
.setkey = chksum_setkey,
|
||||
.init = chksum_init,
|
||||
.update = chksum_update,
|
||||
.final = chksum_final,
|
||||
.finup = chksum_finup,
|
||||
.digest = chksum_digest,
|
||||
.descsize = sizeof(struct chksum_desc_ctx),
|
||||
.base = {
|
||||
.cra_name = "crc32",
|
||||
.cra_driver_name = "crc32-arm64-hw",
|
||||
.cra_priority = 300,
|
||||
.cra_blocksize = CHKSUM_BLOCK_SIZE,
|
||||
.cra_alignmask = 0,
|
||||
.cra_ctxsize = sizeof(struct chksum_ctx),
|
||||
.cra_module = THIS_MODULE,
|
||||
.cra_init = crc32_cra_init,
|
||||
}
|
||||
};
|
||||
|
||||
static struct shash_alg crc32c_alg = {
|
||||
.digestsize = CHKSUM_DIGEST_SIZE,
|
||||
.setkey = chksum_setkey,
|
||||
.init = chksum_init,
|
||||
.update = chksumc_update,
|
||||
.final = chksum_final,
|
||||
.finup = chksumc_finup,
|
||||
.digest = chksumc_digest,
|
||||
.descsize = sizeof(struct chksum_desc_ctx),
|
||||
.base = {
|
||||
.cra_name = "crc32c",
|
||||
.cra_driver_name = "crc32c-arm64-hw",
|
||||
.cra_priority = 300,
|
||||
.cra_blocksize = CHKSUM_BLOCK_SIZE,
|
||||
.cra_alignmask = 0,
|
||||
.cra_ctxsize = sizeof(struct chksum_ctx),
|
||||
.cra_module = THIS_MODULE,
|
||||
.cra_init = crc32_cra_init,
|
||||
}
|
||||
};
|
||||
|
||||
static int __init crc32_mod_init(void)
|
||||
{
|
||||
int err;
|
||||
|
||||
err = crypto_register_shash(&crc32_alg);
|
||||
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
err = crypto_register_shash(&crc32c_alg);
|
||||
|
||||
if (err) {
|
||||
crypto_unregister_shash(&crc32_alg);
|
||||
return err;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void __exit crc32_mod_exit(void)
|
||||
{
|
||||
crypto_unregister_shash(&crc32_alg);
|
||||
crypto_unregister_shash(&crc32c_alg);
|
||||
}
|
||||
|
||||
module_cpu_feature_match(CRC32, crc32_mod_init);
|
||||
module_exit(crc32_mod_exit);
|
@ -66,7 +66,7 @@ static int sha1_update(struct shash_desc *desc, const u8 *data,
|
||||
src = data + done;
|
||||
} while (done + 63 < len);
|
||||
|
||||
memset(temp, 0, sizeof(temp));
|
||||
memzero_explicit(temp, sizeof(temp));
|
||||
partial = 0;
|
||||
}
|
||||
memcpy(sctx->buffer + partial, src, len - done);
|
||||
@ -154,4 +154,4 @@ module_exit(sha1_powerpc_mod_fini);
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("SHA1 Secure Hash Algorithm");
|
||||
|
||||
MODULE_ALIAS("sha1-powerpc");
|
||||
MODULE_ALIAS_CRYPTO("sha1-powerpc");
|
||||
|
@ -979,7 +979,7 @@ static void __exit aes_s390_fini(void)
|
||||
module_init(aes_s390_init);
|
||||
module_exit(aes_s390_fini);
|
||||
|
||||
MODULE_ALIAS("aes-all");
|
||||
MODULE_ALIAS_CRYPTO("aes-all");
|
||||
|
||||
MODULE_DESCRIPTION("Rijndael (AES) Cipher Algorithm");
|
||||
MODULE_LICENSE("GPL");
|
||||
|
@ -619,8 +619,8 @@ static void __exit des_s390_exit(void)
|
||||
module_init(des_s390_init);
|
||||
module_exit(des_s390_exit);
|
||||
|
||||
MODULE_ALIAS("des");
|
||||
MODULE_ALIAS("des3_ede");
|
||||
MODULE_ALIAS_CRYPTO("des");
|
||||
MODULE_ALIAS_CRYPTO("des3_ede");
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("DES & Triple DES EDE Cipher Algorithms");
|
||||
|
@ -160,7 +160,7 @@ static void __exit ghash_mod_exit(void)
|
||||
module_init(ghash_mod_init);
|
||||
module_exit(ghash_mod_exit);
|
||||
|
||||
MODULE_ALIAS("ghash");
|
||||
MODULE_ALIAS_CRYPTO("ghash");
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("GHASH Message Digest Algorithm, s390 implementation");
|
||||
|
@ -103,6 +103,6 @@ static void __exit sha1_s390_fini(void)
|
||||
module_init(sha1_s390_init);
|
||||
module_exit(sha1_s390_fini);
|
||||
|
||||
MODULE_ALIAS("sha1");
|
||||
MODULE_ALIAS_CRYPTO("sha1");
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("SHA1 Secure Hash Algorithm");
|
||||
|
@ -143,7 +143,7 @@ static void __exit sha256_s390_fini(void)
|
||||
module_init(sha256_s390_init);
|
||||
module_exit(sha256_s390_fini);
|
||||
|
||||
MODULE_ALIAS("sha256");
|
||||
MODULE_ALIAS("sha224");
|
||||
MODULE_ALIAS_CRYPTO("sha256");
|
||||
MODULE_ALIAS_CRYPTO("sha224");
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("SHA256 and SHA224 Secure Hash Algorithm");
|
||||
|
@ -86,7 +86,7 @@ static struct shash_alg sha512_alg = {
|
||||
}
|
||||
};
|
||||
|
||||
MODULE_ALIAS("sha512");
|
||||
MODULE_ALIAS_CRYPTO("sha512");
|
||||
|
||||
static int sha384_init(struct shash_desc *desc)
|
||||
{
|
||||
@ -126,7 +126,7 @@ static struct shash_alg sha384_alg = {
|
||||
}
|
||||
};
|
||||
|
||||
MODULE_ALIAS("sha384");
|
||||
MODULE_ALIAS_CRYPTO("sha384");
|
||||
|
||||
static int __init init(void)
|
||||
{
|
||||
|
@ -499,6 +499,6 @@ module_exit(aes_sparc64_mod_fini);
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("AES Secure Hash Algorithm, sparc64 aes opcode accelerated");
|
||||
|
||||
MODULE_ALIAS("aes");
|
||||
MODULE_ALIAS_CRYPTO("aes");
|
||||
|
||||
#include "crop_devid.c"
|
||||
|
@ -322,6 +322,6 @@ module_exit(camellia_sparc64_mod_fini);
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("Camellia Cipher Algorithm, sparc64 camellia opcode accelerated");
|
||||
|
||||
MODULE_ALIAS("aes");
|
||||
MODULE_ALIAS_CRYPTO("aes");
|
||||
|
||||
#include "crop_devid.c"
|
||||
|
@ -176,6 +176,6 @@ module_exit(crc32c_sparc64_mod_fini);
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("CRC32c (Castagnoli), sparc64 crc32c opcode accelerated");
|
||||
|
||||
MODULE_ALIAS("crc32c");
|
||||
MODULE_ALIAS_CRYPTO("crc32c");
|
||||
|
||||
#include "crop_devid.c"
|
||||
|
@ -532,6 +532,6 @@ module_exit(des_sparc64_mod_fini);
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("DES & Triple DES EDE Cipher Algorithms, sparc64 des opcode accelerated");
|
||||
|
||||
MODULE_ALIAS("des");
|
||||
MODULE_ALIAS_CRYPTO("des");
|
||||
|
||||
#include "crop_devid.c"
|
||||
|
@ -185,6 +185,6 @@ module_exit(md5_sparc64_mod_fini);
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("MD5 Secure Hash Algorithm, sparc64 md5 opcode accelerated");
|
||||
|
||||
MODULE_ALIAS("md5");
|
||||
MODULE_ALIAS_CRYPTO("md5");
|
||||
|
||||
#include "crop_devid.c"
|
||||
|
@ -180,6 +180,6 @@ module_exit(sha1_sparc64_mod_fini);
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("SHA1 Secure Hash Algorithm, sparc64 sha1 opcode accelerated");
|
||||
|
||||
MODULE_ALIAS("sha1");
|
||||
MODULE_ALIAS_CRYPTO("sha1");
|
||||
|
||||
#include "crop_devid.c"
|
||||
|
@ -135,7 +135,7 @@ static int sha224_sparc64_final(struct shash_desc *desc, u8 *hash)
|
||||
sha256_sparc64_final(desc, D);
|
||||
|
||||
memcpy(hash, D, SHA224_DIGEST_SIZE);
|
||||
memset(D, 0, SHA256_DIGEST_SIZE);
|
||||
memzero_explicit(D, SHA256_DIGEST_SIZE);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -237,7 +237,7 @@ module_exit(sha256_sparc64_mod_fini);
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("SHA-224 and SHA-256 Secure Hash Algorithm, sparc64 sha256 opcode accelerated");
|
||||
|
||||
MODULE_ALIAS("sha224");
|
||||
MODULE_ALIAS("sha256");
|
||||
MODULE_ALIAS_CRYPTO("sha224");
|
||||
MODULE_ALIAS_CRYPTO("sha256");
|
||||
|
||||
#include "crop_devid.c"
|
||||
|
@ -139,7 +139,7 @@ static int sha384_sparc64_final(struct shash_desc *desc, u8 *hash)
|
||||
sha512_sparc64_final(desc, D);
|
||||
|
||||
memcpy(hash, D, 48);
|
||||
memset(D, 0, 64);
|
||||
memzero_explicit(D, 64);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -222,7 +222,7 @@ module_exit(sha512_sparc64_mod_fini);
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("SHA-384 and SHA-512 Secure Hash Algorithm, sparc64 sha512 opcode accelerated");
|
||||
|
||||
MODULE_ALIAS("sha384");
|
||||
MODULE_ALIAS("sha512");
|
||||
MODULE_ALIAS_CRYPTO("sha384");
|
||||
MODULE_ALIAS_CRYPTO("sha512");
|
||||
|
||||
#include "crop_devid.c"
|
||||
|
@ -66,5 +66,5 @@ module_exit(aes_fini);
|
||||
|
||||
MODULE_DESCRIPTION("Rijndael (AES) Cipher Algorithm, asm optimized");
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_ALIAS("aes");
|
||||
MODULE_ALIAS("aes-asm");
|
||||
MODULE_ALIAS_CRYPTO("aes");
|
||||
MODULE_ALIAS_CRYPTO("aes-asm");
|
||||
|
@ -43,10 +43,6 @@
|
||||
#include <asm/crypto/glue_helper.h>
|
||||
#endif
|
||||
|
||||
#if defined(CONFIG_CRYPTO_PCBC) || defined(CONFIG_CRYPTO_PCBC_MODULE)
|
||||
#define HAS_PCBC
|
||||
#endif
|
||||
|
||||
/* This data is stored at the end of the crypto_tfm struct.
|
||||
* It's a type of per "session" data storage location.
|
||||
* This needs to be 16 byte aligned.
|
||||
@ -547,7 +543,7 @@ static int ablk_ctr_init(struct crypto_tfm *tfm)
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef HAS_PCBC
|
||||
#if IS_ENABLED(CONFIG_CRYPTO_PCBC)
|
||||
static int ablk_pcbc_init(struct crypto_tfm *tfm)
|
||||
{
|
||||
return ablk_init_common(tfm, "fpu(pcbc(__driver-aes-aesni))");
|
||||
@ -1377,7 +1373,7 @@ static struct crypto_alg aesni_algs[] = { {
|
||||
},
|
||||
},
|
||||
#endif
|
||||
#ifdef HAS_PCBC
|
||||
#if IS_ENABLED(CONFIG_CRYPTO_PCBC)
|
||||
}, {
|
||||
.cra_name = "pcbc(aes)",
|
||||
.cra_driver_name = "pcbc-aes-aesni",
|
||||
@ -1550,4 +1546,4 @@ module_exit(aesni_exit);
|
||||
|
||||
MODULE_DESCRIPTION("Rijndael (AES) Cipher Algorithm, Intel AES-NI instructions optimized");
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_ALIAS("aes");
|
||||
MODULE_ALIAS_CRYPTO("aes");
|
||||
|
@ -478,5 +478,5 @@ module_exit(fini);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("Blowfish Cipher Algorithm, asm optimized");
|
||||
MODULE_ALIAS("blowfish");
|
||||
MODULE_ALIAS("blowfish-asm");
|
||||
MODULE_ALIAS_CRYPTO("blowfish");
|
||||
MODULE_ALIAS_CRYPTO("blowfish-asm");
|
||||
|
@ -582,5 +582,5 @@ module_exit(camellia_aesni_fini);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("Camellia Cipher Algorithm, AES-NI/AVX2 optimized");
|
||||
MODULE_ALIAS("camellia");
|
||||
MODULE_ALIAS("camellia-asm");
|
||||
MODULE_ALIAS_CRYPTO("camellia");
|
||||
MODULE_ALIAS_CRYPTO("camellia-asm");
|
||||
|
@ -574,5 +574,5 @@ module_exit(camellia_aesni_fini);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("Camellia Cipher Algorithm, AES-NI/AVX optimized");
|
||||
MODULE_ALIAS("camellia");
|
||||
MODULE_ALIAS("camellia-asm");
|
||||
MODULE_ALIAS_CRYPTO("camellia");
|
||||
MODULE_ALIAS_CRYPTO("camellia-asm");
|
||||
|
@ -1725,5 +1725,5 @@ module_exit(fini);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("Camellia Cipher Algorithm, asm optimized");
|
||||
MODULE_ALIAS("camellia");
|
||||
MODULE_ALIAS("camellia-asm");
|
||||
MODULE_ALIAS_CRYPTO("camellia");
|
||||
MODULE_ALIAS_CRYPTO("camellia-asm");
|
||||
|
@ -491,4 +491,4 @@ module_exit(cast5_exit);
|
||||
|
||||
MODULE_DESCRIPTION("Cast5 Cipher Algorithm, AVX optimized");
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_ALIAS("cast5");
|
||||
MODULE_ALIAS_CRYPTO("cast5");
|
||||
|
@ -611,4 +611,4 @@ module_exit(cast6_exit);
|
||||
|
||||
MODULE_DESCRIPTION("Cast6 Cipher Algorithm, AVX optimized");
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_ALIAS("cast6");
|
||||
MODULE_ALIAS_CRYPTO("cast6");
|
||||
|
@ -197,5 +197,5 @@ module_exit(crc32_pclmul_mod_fini);
|
||||
MODULE_AUTHOR("Alexander Boyko <alexander_boyko@xyratex.com>");
|
||||
MODULE_LICENSE("GPL");
|
||||
|
||||
MODULE_ALIAS("crc32");
|
||||
MODULE_ALIAS("crc32-pclmul");
|
||||
MODULE_ALIAS_CRYPTO("crc32");
|
||||
MODULE_ALIAS_CRYPTO("crc32-pclmul");
|
||||
|
@ -280,5 +280,5 @@ MODULE_AUTHOR("Austin Zhang <austin.zhang@intel.com>, Kent Liu <kent.liu@intel.c
|
||||
MODULE_DESCRIPTION("CRC32c (Castagnoli) optimization using Intel Hardware.");
|
||||
MODULE_LICENSE("GPL");
|
||||
|
||||
MODULE_ALIAS("crc32c");
|
||||
MODULE_ALIAS("crc32c-intel");
|
||||
MODULE_ALIAS_CRYPTO("crc32c");
|
||||
MODULE_ALIAS_CRYPTO("crc32c-intel");
|
||||
|
@ -147,5 +147,5 @@ MODULE_AUTHOR("Tim Chen <tim.c.chen@linux.intel.com>");
|
||||
MODULE_DESCRIPTION("T10 DIF CRC calculation accelerated with PCLMULQDQ.");
|
||||
MODULE_LICENSE("GPL");
|
||||
|
||||
MODULE_ALIAS("crct10dif");
|
||||
MODULE_ALIAS("crct10dif-pclmul");
|
||||
MODULE_ALIAS_CRYPTO("crct10dif");
|
||||
MODULE_ALIAS_CRYPTO("crct10dif-pclmul");
|
||||
|
@ -502,8 +502,8 @@ module_exit(des3_ede_x86_fini);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("Triple DES EDE Cipher Algorithm, asm optimized");
|
||||
MODULE_ALIAS("des3_ede");
|
||||
MODULE_ALIAS("des3_ede-asm");
|
||||
MODULE_ALIAS("des");
|
||||
MODULE_ALIAS("des-asm");
|
||||
MODULE_ALIAS_CRYPTO("des3_ede");
|
||||
MODULE_ALIAS_CRYPTO("des3_ede-asm");
|
||||
MODULE_ALIAS_CRYPTO("des");
|
||||
MODULE_ALIAS_CRYPTO("des-asm");
|
||||
MODULE_AUTHOR("Jussi Kivilinna <jussi.kivilinna@iki.fi>");
|
||||
|
@ -17,6 +17,7 @@
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/crypto.h>
|
||||
#include <asm/i387.h>
|
||||
|
||||
struct crypto_fpu_ctx {
|
||||
@ -159,3 +160,5 @@ void __exit crypto_fpu_exit(void)
|
||||
{
|
||||
crypto_unregister_template(&crypto_fpu_tmpl);
|
||||
}
|
||||
|
||||
MODULE_ALIAS_CRYPTO("fpu");
|
||||
|
@ -341,4 +341,4 @@ module_exit(ghash_pclmulqdqni_mod_exit);
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("GHASH Message Digest Algorithm, "
|
||||
"acclerated by PCLMULQDQ-NI");
|
||||
MODULE_ALIAS("ghash");
|
||||
MODULE_ALIAS_CRYPTO("ghash");
|
||||
|
@ -119,5 +119,5 @@ module_exit(fini);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION ("Salsa20 stream cipher algorithm (optimized assembly version)");
|
||||
MODULE_ALIAS("salsa20");
|
||||
MODULE_ALIAS("salsa20-asm");
|
||||
MODULE_ALIAS_CRYPTO("salsa20");
|
||||
MODULE_ALIAS_CRYPTO("salsa20-asm");
|
||||
|
@ -558,5 +558,5 @@ module_exit(fini);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("Serpent Cipher Algorithm, AVX2 optimized");
|
||||
MODULE_ALIAS("serpent");
|
||||
MODULE_ALIAS("serpent-asm");
|
||||
MODULE_ALIAS_CRYPTO("serpent");
|
||||
MODULE_ALIAS_CRYPTO("serpent-asm");
|
||||
|
@ -617,4 +617,4 @@ module_exit(serpent_exit);
|
||||
|
||||
MODULE_DESCRIPTION("Serpent Cipher Algorithm, AVX optimized");
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_ALIAS("serpent");
|
||||
MODULE_ALIAS_CRYPTO("serpent");
|
||||
|
@ -618,4 +618,4 @@ module_exit(serpent_sse2_exit);
|
||||
|
||||
MODULE_DESCRIPTION("Serpent Cipher Algorithm, SSE2 optimized");
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_ALIAS("serpent");
|
||||
MODULE_ALIAS_CRYPTO("serpent");
|
||||
|
@ -204,8 +204,7 @@ static struct sha1_hash_ctx *sha1_ctx_mgr_resubmit(struct sha1_ctx_mgr *mgr, str
|
||||
continue;
|
||||
}
|
||||
|
||||
if (ctx)
|
||||
ctx->status = HASH_CTX_STS_IDLE;
|
||||
ctx->status = HASH_CTX_STS_IDLE;
|
||||
return ctx;
|
||||
}
|
||||
|
||||
|
@ -278,4 +278,4 @@ module_exit(sha1_ssse3_mod_fini);
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("SHA1 Secure Hash Algorithm, Supplemental SSE3 accelerated");
|
||||
|
||||
MODULE_ALIAS("sha1");
|
||||
MODULE_ALIAS_CRYPTO("sha1");
|
||||
|
@ -211,7 +211,7 @@ static int sha224_ssse3_final(struct shash_desc *desc, u8 *hash)
|
||||
sha256_ssse3_final(desc, D);
|
||||
|
||||
memcpy(hash, D, SHA224_DIGEST_SIZE);
|
||||
memset(D, 0, SHA256_DIGEST_SIZE);
|
||||
memzero_explicit(D, SHA256_DIGEST_SIZE);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -318,5 +318,5 @@ module_exit(sha256_ssse3_mod_fini);
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("SHA256 Secure Hash Algorithm, Supplemental SSE3 accelerated");
|
||||
|
||||
MODULE_ALIAS("sha256");
|
||||
MODULE_ALIAS("sha224");
|
||||
MODULE_ALIAS_CRYPTO("sha256");
|
||||
MODULE_ALIAS_CRYPTO("sha224");
|
||||
|
@ -219,7 +219,7 @@ static int sha384_ssse3_final(struct shash_desc *desc, u8 *hash)
|
||||
sha512_ssse3_final(desc, D);
|
||||
|
||||
memcpy(hash, D, SHA384_DIGEST_SIZE);
|
||||
memset(D, 0, SHA512_DIGEST_SIZE);
|
||||
memzero_explicit(D, SHA512_DIGEST_SIZE);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -326,5 +326,5 @@ module_exit(sha512_ssse3_mod_fini);
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("SHA512 Secure Hash Algorithm, Supplemental SSE3 accelerated");
|
||||
|
||||
MODULE_ALIAS("sha512");
|
||||
MODULE_ALIAS("sha384");
|
||||
MODULE_ALIAS_CRYPTO("sha512");
|
||||
MODULE_ALIAS_CRYPTO("sha384");
|
||||
|
@ -579,4 +579,4 @@ module_exit(twofish_exit);
|
||||
|
||||
MODULE_DESCRIPTION("Twofish Cipher Algorithm, AVX optimized");
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_ALIAS("twofish");
|
||||
MODULE_ALIAS_CRYPTO("twofish");
|
||||
|
@ -96,5 +96,5 @@ module_exit(fini);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION ("Twofish Cipher Algorithm, asm optimized");
|
||||
MODULE_ALIAS("twofish");
|
||||
MODULE_ALIAS("twofish-asm");
|
||||
MODULE_ALIAS_CRYPTO("twofish");
|
||||
MODULE_ALIAS_CRYPTO("twofish-asm");
|
||||
|
@ -495,5 +495,5 @@ module_exit(fini);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("Twofish Cipher Algorithm, 3-way parallel asm optimized");
|
||||
MODULE_ALIAS("twofish");
|
||||
MODULE_ALIAS("twofish-asm");
|
||||
MODULE_ALIAS_CRYPTO("twofish");
|
||||
MODULE_ALIAS_CRYPTO("twofish-asm");
|
||||
|
@ -180,3 +180,4 @@ module_exit(nx842_mod_exit);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("842 Compression Algorithm");
|
||||
MODULE_ALIAS_CRYPTO("842");
|
||||
|
@ -1474,4 +1474,4 @@ module_exit(aes_fini);
|
||||
|
||||
MODULE_DESCRIPTION("Rijndael (AES) Cipher Algorithm");
|
||||
MODULE_LICENSE("Dual BSD/GPL");
|
||||
MODULE_ALIAS("aes");
|
||||
MODULE_ALIAS_CRYPTO("aes");
|
||||
|
@ -421,6 +421,12 @@ int af_alg_cmsg_send(struct msghdr *msg, struct af_alg_control *con)
|
||||
con->op = *(u32 *)CMSG_DATA(cmsg);
|
||||
break;
|
||||
|
||||
case ALG_SET_AEAD_ASSOCLEN:
|
||||
if (cmsg->cmsg_len < CMSG_LEN(sizeof(u32)))
|
||||
return -EINVAL;
|
||||
con->aead_assoclen = *(u32 *)CMSG_DATA(cmsg);
|
||||
break;
|
||||
|
||||
default:
|
||||
return -EINVAL;
|
||||
}
|
||||
|
@ -509,8 +509,8 @@ static struct crypto_template *__crypto_lookup_template(const char *name)
|
||||
|
||||
struct crypto_template *crypto_lookup_template(const char *name)
|
||||
{
|
||||
return try_then_request_module(__crypto_lookup_template(name), "%s",
|
||||
name);
|
||||
return try_then_request_module(__crypto_lookup_template(name),
|
||||
"crypto-%s", name);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(crypto_lookup_template);
|
||||
|
||||
|
@ -258,8 +258,8 @@ static void hash_sock_destruct(struct sock *sk)
|
||||
struct alg_sock *ask = alg_sk(sk);
|
||||
struct hash_ctx *ctx = ask->private;
|
||||
|
||||
sock_kfree_s(sk, ctx->result,
|
||||
crypto_ahash_digestsize(crypto_ahash_reqtfm(&ctx->req)));
|
||||
sock_kzfree_s(sk, ctx->result,
|
||||
crypto_ahash_digestsize(crypto_ahash_reqtfm(&ctx->req)));
|
||||
sock_kfree_s(sk, ctx, ctx->len);
|
||||
af_alg_release_parent(sk);
|
||||
}
|
||||
|
@ -251,6 +251,7 @@ static int skcipher_sendmsg(struct kiocb *unused, struct socket *sock,
|
||||
struct af_alg_control con = {};
|
||||
long copied = 0;
|
||||
bool enc = 0;
|
||||
bool init = 0;
|
||||
int err;
|
||||
int i;
|
||||
|
||||
@ -259,6 +260,7 @@ static int skcipher_sendmsg(struct kiocb *unused, struct socket *sock,
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
init = 1;
|
||||
switch (con.op) {
|
||||
case ALG_OP_ENCRYPT:
|
||||
enc = 1;
|
||||
@ -280,7 +282,7 @@ static int skcipher_sendmsg(struct kiocb *unused, struct socket *sock,
|
||||
if (!ctx->more && ctx->used)
|
||||
goto unlock;
|
||||
|
||||
if (!ctx->used) {
|
||||
if (init) {
|
||||
ctx->enc = enc;
|
||||
if (con.iv)
|
||||
memcpy(ctx->iv, con.iv->iv, ivsize);
|
||||
@ -359,8 +361,6 @@ static int skcipher_sendmsg(struct kiocb *unused, struct socket *sock,
|
||||
err = 0;
|
||||
|
||||
ctx->more = msg->msg_flags & MSG_MORE;
|
||||
if (!ctx->more && !list_empty(&ctx->tsgl))
|
||||
sgl = list_entry(ctx->tsgl.prev, struct skcipher_sg_list, list);
|
||||
|
||||
unlock:
|
||||
skcipher_data_wakeup(sk);
|
||||
@ -408,8 +408,6 @@ static ssize_t skcipher_sendpage(struct socket *sock, struct page *page,
|
||||
|
||||
done:
|
||||
ctx->more = flags & MSG_MORE;
|
||||
if (!ctx->more && !list_empty(&ctx->tsgl))
|
||||
sgl = list_entry(ctx->tsgl.prev, struct skcipher_sg_list, list);
|
||||
|
||||
unlock:
|
||||
skcipher_data_wakeup(sk);
|
||||
@ -448,14 +446,13 @@ static int skcipher_recvmsg(struct kiocb *unused, struct socket *sock,
|
||||
while (!sg->length)
|
||||
sg++;
|
||||
|
||||
used = ctx->used;
|
||||
if (!used) {
|
||||
if (!ctx->used) {
|
||||
err = skcipher_wait_for_data(sk, flags);
|
||||
if (err)
|
||||
goto unlock;
|
||||
}
|
||||
|
||||
used = min_t(unsigned long, used, seglen);
|
||||
used = min_t(unsigned long, ctx->used, seglen);
|
||||
|
||||
used = af_alg_make_sg(&ctx->rsgl, from, used, 1);
|
||||
err = used;
|
||||
@ -566,7 +563,7 @@ static void skcipher_sock_destruct(struct sock *sk)
|
||||
struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(&ctx->req);
|
||||
|
||||
skcipher_free_sgl(sk);
|
||||
sock_kfree_s(sk, ctx->iv, crypto_ablkcipher_ivsize(tfm));
|
||||
sock_kzfree_s(sk, ctx->iv, crypto_ablkcipher_ivsize(tfm));
|
||||
sock_kfree_s(sk, ctx, ctx->len);
|
||||
af_alg_release_parent(sk);
|
||||
}
|
||||
|
@ -476,4 +476,4 @@ module_param(dbg, int, 0);
|
||||
MODULE_PARM_DESC(dbg, "Boolean to enable debugging (0/1 == off/on)");
|
||||
module_init(prng_mod_init);
|
||||
module_exit(prng_mod_fini);
|
||||
MODULE_ALIAS("stdrng");
|
||||
MODULE_ALIAS_CRYPTO("stdrng");
|
||||
|
@ -704,3 +704,4 @@ module_exit(anubis_mod_fini);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("Anubis Cryptographic Algorithm");
|
||||
MODULE_ALIAS_CRYPTO("anubis");
|
||||
|
@ -216,11 +216,11 @@ struct crypto_alg *crypto_larval_lookup(const char *name, u32 type, u32 mask)
|
||||
|
||||
alg = crypto_alg_lookup(name, type, mask);
|
||||
if (!alg) {
|
||||
request_module("%s", name);
|
||||
request_module("crypto-%s", name);
|
||||
|
||||
if (!((type ^ CRYPTO_ALG_NEED_FALLBACK) & mask &
|
||||
CRYPTO_ALG_NEED_FALLBACK))
|
||||
request_module("%s-all", name);
|
||||
request_module("crypto-%s-all", name);
|
||||
|
||||
alg = crypto_alg_lookup(name, type, mask);
|
||||
}
|
||||
|
@ -166,3 +166,4 @@ module_exit(arc4_exit);
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("ARC4 Cipher Algorithm");
|
||||
MODULE_AUTHOR("Jon Oberheide <jon@oberheide.org>");
|
||||
MODULE_ALIAS_CRYPTO("arc4");
|
||||
|
@ -721,3 +721,4 @@ module_exit(crypto_authenc_module_exit);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("Simple AEAD wrapper for IPsec");
|
||||
MODULE_ALIAS_CRYPTO("authenc");
|
||||
|
@ -814,3 +814,4 @@ module_exit(crypto_authenc_esn_module_exit);
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_AUTHOR("Steffen Klassert <steffen.klassert@secunet.com>");
|
||||
MODULE_DESCRIPTION("AEAD wrapper for IPsec with extended sequence numbers");
|
||||
MODULE_ALIAS_CRYPTO("authencesn");
|
||||
|
@ -138,4 +138,4 @@ module_exit(blowfish_mod_fini);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("Blowfish Cipher Algorithm");
|
||||
MODULE_ALIAS("blowfish");
|
||||
MODULE_ALIAS_CRYPTO("blowfish");
|
||||
|
@ -1098,4 +1098,4 @@ module_exit(camellia_fini);
|
||||
|
||||
MODULE_DESCRIPTION("Camellia Cipher Algorithm");
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_ALIAS("camellia");
|
||||
MODULE_ALIAS_CRYPTO("camellia");
|
||||
|
@ -549,4 +549,4 @@ module_exit(cast5_mod_fini);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("Cast5 Cipher Algorithm");
|
||||
MODULE_ALIAS("cast5");
|
||||
MODULE_ALIAS_CRYPTO("cast5");
|
||||
|
@ -291,4 +291,4 @@ module_exit(cast6_mod_fini);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("Cast6 Cipher Algorithm");
|
||||
MODULE_ALIAS("cast6");
|
||||
MODULE_ALIAS_CRYPTO("cast6");
|
||||
|
@ -289,3 +289,4 @@ module_exit(crypto_cbc_module_exit);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("CBC block cipher algorithm");
|
||||
MODULE_ALIAS_CRYPTO("cbc");
|
||||
|
@ -879,5 +879,6 @@ module_exit(crypto_ccm_module_exit);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("Counter with CBC MAC");
|
||||
MODULE_ALIAS("ccm_base");
|
||||
MODULE_ALIAS("rfc4309");
|
||||
MODULE_ALIAS_CRYPTO("ccm_base");
|
||||
MODULE_ALIAS_CRYPTO("rfc4309");
|
||||
MODULE_ALIAS_CRYPTO("ccm");
|
||||
|
@ -359,3 +359,4 @@ module_exit(chainiv_module_exit);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("Chain IV Generator");
|
||||
MODULE_ALIAS_CRYPTO("chainiv");
|
||||
|
@ -313,3 +313,4 @@ module_exit(crypto_cmac_module_exit);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("CMAC keyed hash algorithm");
|
||||
MODULE_ALIAS_CRYPTO("cmac");
|
||||
|
@ -156,3 +156,4 @@ module_exit(crc32_mod_fini);
|
||||
MODULE_AUTHOR("Alexander Boyko <alexander_boyko@xyratex.com>");
|
||||
MODULE_DESCRIPTION("CRC32 calculations wrapper for lib/crc32");
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_ALIAS_CRYPTO("crc32");
|
||||
|
@ -170,5 +170,5 @@ module_exit(crc32c_mod_fini);
|
||||
MODULE_AUTHOR("Clay Haapala <chaapala@cisco.com>");
|
||||
MODULE_DESCRIPTION("CRC32c (Castagnoli) calculations wrapper for lib/crc32c");
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_ALIAS("crc32c");
|
||||
MODULE_ALIAS_CRYPTO("crc32c");
|
||||
MODULE_SOFTDEP("pre: crc32c");
|
||||
|
@ -124,4 +124,4 @@ module_exit(crct10dif_mod_fini);
|
||||
MODULE_AUTHOR("Tim Chen <tim.c.chen@linux.intel.com>");
|
||||
MODULE_DESCRIPTION("T10 DIF CRC calculation.");
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_ALIAS("crct10dif");
|
||||
MODULE_ALIAS_CRYPTO("crct10dif");
|
||||
|
@ -955,3 +955,4 @@ module_exit(cryptd_exit);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("Software async crypto daemon");
|
||||
MODULE_ALIAS_CRYPTO("cryptd");
|
||||
|
@ -145,9 +145,9 @@ static struct crypto_alg null_algs[3] = { {
|
||||
.coa_decompress = null_compress } }
|
||||
} };
|
||||
|
||||
MODULE_ALIAS("compress_null");
|
||||
MODULE_ALIAS("digest_null");
|
||||
MODULE_ALIAS("cipher_null");
|
||||
MODULE_ALIAS_CRYPTO("compress_null");
|
||||
MODULE_ALIAS_CRYPTO("digest_null");
|
||||
MODULE_ALIAS_CRYPTO("cipher_null");
|
||||
|
||||
static int __init crypto_null_mod_init(void)
|
||||
{
|
||||
|
@ -201,10 +201,7 @@ static int crypto_report(struct sk_buff *in_skb, struct nlmsghdr *in_nlh,
|
||||
if (!null_terminated(p->cru_name) || !null_terminated(p->cru_driver_name))
|
||||
return -EINVAL;
|
||||
|
||||
if (!p->cru_driver_name[0])
|
||||
return -EINVAL;
|
||||
|
||||
alg = crypto_alg_match(p, 1);
|
||||
alg = crypto_alg_match(p, 0);
|
||||
if (!alg)
|
||||
return -ENOENT;
|
||||
|
||||
@ -537,3 +534,4 @@ module_exit(crypto_user_exit);
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_AUTHOR("Steffen Klassert <steffen.klassert@secunet.com>");
|
||||
MODULE_DESCRIPTION("Crypto userspace configuration API");
|
||||
MODULE_ALIAS("net-pf-16-proto-21");
|
||||
|
@ -466,4 +466,5 @@ module_exit(crypto_ctr_module_exit);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("CTR Counter block mode");
|
||||
MODULE_ALIAS("rfc3686");
|
||||
MODULE_ALIAS_CRYPTO("rfc3686");
|
||||
MODULE_ALIAS_CRYPTO("ctr");
|
||||
|
@ -351,3 +351,4 @@ module_exit(crypto_cts_module_exit);
|
||||
|
||||
MODULE_LICENSE("Dual BSD/GPL");
|
||||
MODULE_DESCRIPTION("CTS-CBC CipherText Stealing for CBC");
|
||||
MODULE_ALIAS_CRYPTO("cts");
|
||||
|
@ -222,4 +222,4 @@ module_exit(deflate_mod_fini);
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("Deflate Compression Algorithm for IPCOMP");
|
||||
MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");
|
||||
|
||||
MODULE_ALIAS_CRYPTO("deflate");
|
||||
|
@ -983,7 +983,7 @@ static struct crypto_alg des_algs[2] = { {
|
||||
.cia_decrypt = des3_ede_decrypt } }
|
||||
} };
|
||||
|
||||
MODULE_ALIAS("des3_ede");
|
||||
MODULE_ALIAS_CRYPTO("des3_ede");
|
||||
|
||||
static int __init des_generic_mod_init(void)
|
||||
{
|
||||
|
127
crypto/drbg.c
127
crypto/drbg.c
@ -98,6 +98,7 @@
|
||||
*/
|
||||
|
||||
#include <crypto/drbg.h>
|
||||
#include <linux/string.h>
|
||||
|
||||
/***************************************************************
|
||||
* Backend cipher definitions available to DRBG
|
||||
@ -283,38 +284,6 @@ static inline void drbg_cpu_to_be32(__u32 val, unsigned char *buf)
|
||||
|
||||
conversion->conv = cpu_to_be32(val);
|
||||
}
|
||||
|
||||
/*
|
||||
* Increment buffer
|
||||
*
|
||||
* @dst buffer to increment
|
||||
* @add value to add
|
||||
*/
|
||||
static inline void drbg_add_buf(unsigned char *dst, size_t dstlen,
|
||||
const unsigned char *add, size_t addlen)
|
||||
{
|
||||
/* implied: dstlen > addlen */
|
||||
unsigned char *dstptr;
|
||||
const unsigned char *addptr;
|
||||
unsigned int remainder = 0;
|
||||
size_t len = addlen;
|
||||
|
||||
dstptr = dst + (dstlen-1);
|
||||
addptr = add + (addlen-1);
|
||||
while (len) {
|
||||
remainder += *dstptr + *addptr;
|
||||
*dstptr = remainder & 0xff;
|
||||
remainder >>= 8;
|
||||
len--; dstptr--; addptr--;
|
||||
}
|
||||
len = dstlen - addlen;
|
||||
while (len && remainder > 0) {
|
||||
remainder = *dstptr + 1;
|
||||
*dstptr = remainder & 0xff;
|
||||
remainder >>= 8;
|
||||
len--; dstptr--;
|
||||
}
|
||||
}
|
||||
#endif /* defined(CONFIG_CRYPTO_DRBG_HASH) || defined(CONFIG_CRYPTO_DRBG_CTR) */
|
||||
|
||||
/******************************************************************
|
||||
@ -323,6 +292,13 @@ static inline void drbg_add_buf(unsigned char *dst, size_t dstlen,
|
||||
|
||||
#ifdef CONFIG_CRYPTO_DRBG_CTR
|
||||
#define CRYPTO_DRBG_CTR_STRING "CTR "
|
||||
MODULE_ALIAS_CRYPTO("drbg_pr_ctr_aes256");
|
||||
MODULE_ALIAS_CRYPTO("drbg_nopr_ctr_aes256");
|
||||
MODULE_ALIAS_CRYPTO("drbg_pr_ctr_aes192");
|
||||
MODULE_ALIAS_CRYPTO("drbg_nopr_ctr_aes192");
|
||||
MODULE_ALIAS_CRYPTO("drbg_pr_ctr_aes128");
|
||||
MODULE_ALIAS_CRYPTO("drbg_nopr_ctr_aes128");
|
||||
|
||||
static int drbg_kcapi_sym(struct drbg_state *drbg, const unsigned char *key,
|
||||
unsigned char *outval, const struct drbg_string *in);
|
||||
static int drbg_init_sym_kernel(struct drbg_state *drbg);
|
||||
@ -522,9 +498,9 @@ static int drbg_ctr_df(struct drbg_state *drbg,
|
||||
ret = 0;
|
||||
|
||||
out:
|
||||
memset(iv, 0, drbg_blocklen(drbg));
|
||||
memset(temp, 0, drbg_statelen(drbg));
|
||||
memset(pad, 0, drbg_blocklen(drbg));
|
||||
memzero_explicit(iv, drbg_blocklen(drbg));
|
||||
memzero_explicit(temp, drbg_statelen(drbg));
|
||||
memzero_explicit(pad, drbg_blocklen(drbg));
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -554,7 +530,6 @@ static int drbg_ctr_update(struct drbg_state *drbg, struct list_head *seed,
|
||||
unsigned char *temp_p, *df_data_p; /* pointer to iterate over buffers */
|
||||
unsigned int len = 0;
|
||||
struct drbg_string cipherin;
|
||||
unsigned char prefix = DRBG_PREFIX1;
|
||||
|
||||
memset(temp, 0, drbg_statelen(drbg) + drbg_blocklen(drbg));
|
||||
if (3 > reseed)
|
||||
@ -574,7 +549,7 @@ static int drbg_ctr_update(struct drbg_state *drbg, struct list_head *seed,
|
||||
*/
|
||||
while (len < (drbg_statelen(drbg))) {
|
||||
/* 10.2.1.2 step 2.1 */
|
||||
drbg_add_buf(drbg->V, drbg_blocklen(drbg), &prefix, 1);
|
||||
crypto_inc(drbg->V, drbg_blocklen(drbg));
|
||||
/*
|
||||
* 10.2.1.2 step 2.2 */
|
||||
ret = drbg_kcapi_sym(drbg, drbg->C, temp + len, &cipherin);
|
||||
@ -599,9 +574,9 @@ static int drbg_ctr_update(struct drbg_state *drbg, struct list_head *seed,
|
||||
ret = 0;
|
||||
|
||||
out:
|
||||
memset(temp, 0, drbg_statelen(drbg) + drbg_blocklen(drbg));
|
||||
memzero_explicit(temp, drbg_statelen(drbg) + drbg_blocklen(drbg));
|
||||
if (2 != reseed)
|
||||
memset(df_data, 0, drbg_statelen(drbg));
|
||||
memzero_explicit(df_data, drbg_statelen(drbg));
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -617,7 +592,6 @@ static int drbg_ctr_generate(struct drbg_state *drbg,
|
||||
int len = 0;
|
||||
int ret = 0;
|
||||
struct drbg_string data;
|
||||
unsigned char prefix = DRBG_PREFIX1;
|
||||
|
||||
memset(drbg->scratchpad, 0, drbg_blocklen(drbg));
|
||||
|
||||
@ -629,7 +603,7 @@ static int drbg_ctr_generate(struct drbg_state *drbg,
|
||||
}
|
||||
|
||||
/* 10.2.1.5.2 step 4.1 */
|
||||
drbg_add_buf(drbg->V, drbg_blocklen(drbg), &prefix, 1);
|
||||
crypto_inc(drbg->V, drbg_blocklen(drbg));
|
||||
drbg_string_fill(&data, drbg->V, drbg_blocklen(drbg));
|
||||
while (len < buflen) {
|
||||
int outlen = 0;
|
||||
@ -643,7 +617,7 @@ static int drbg_ctr_generate(struct drbg_state *drbg,
|
||||
drbg_blocklen(drbg) : (buflen - len);
|
||||
if (!drbg_fips_continuous_test(drbg, drbg->scratchpad)) {
|
||||
/* 10.2.1.5.2 step 6 */
|
||||
drbg_add_buf(drbg->V, drbg_blocklen(drbg), &prefix, 1);
|
||||
crypto_inc(drbg->V, drbg_blocklen(drbg));
|
||||
continue;
|
||||
}
|
||||
/* 10.2.1.5.2 step 4.3 */
|
||||
@ -651,7 +625,7 @@ static int drbg_ctr_generate(struct drbg_state *drbg,
|
||||
len += outlen;
|
||||
/* 10.2.1.5.2 step 6 */
|
||||
if (len < buflen)
|
||||
drbg_add_buf(drbg->V, drbg_blocklen(drbg), &prefix, 1);
|
||||
crypto_inc(drbg->V, drbg_blocklen(drbg));
|
||||
}
|
||||
|
||||
/* 10.2.1.5.2 step 6 */
|
||||
@ -660,7 +634,7 @@ static int drbg_ctr_generate(struct drbg_state *drbg,
|
||||
len = ret;
|
||||
|
||||
out:
|
||||
memset(drbg->scratchpad, 0, drbg_blocklen(drbg));
|
||||
memzero_explicit(drbg->scratchpad, drbg_blocklen(drbg));
|
||||
return len;
|
||||
}
|
||||
|
||||
@ -685,6 +659,15 @@ static int drbg_fini_hash_kernel(struct drbg_state *drbg);
|
||||
|
||||
#ifdef CONFIG_CRYPTO_DRBG_HMAC
|
||||
#define CRYPTO_DRBG_HMAC_STRING "HMAC "
|
||||
MODULE_ALIAS_CRYPTO("drbg_pr_hmac_sha512");
|
||||
MODULE_ALIAS_CRYPTO("drbg_nopr_hmac_sha512");
|
||||
MODULE_ALIAS_CRYPTO("drbg_pr_hmac_sha384");
|
||||
MODULE_ALIAS_CRYPTO("drbg_nopr_hmac_sha384");
|
||||
MODULE_ALIAS_CRYPTO("drbg_pr_hmac_sha256");
|
||||
MODULE_ALIAS_CRYPTO("drbg_nopr_hmac_sha256");
|
||||
MODULE_ALIAS_CRYPTO("drbg_pr_hmac_sha1");
|
||||
MODULE_ALIAS_CRYPTO("drbg_nopr_hmac_sha1");
|
||||
|
||||
/* update function of HMAC DRBG as defined in 10.1.2.2 */
|
||||
static int drbg_hmac_update(struct drbg_state *drbg, struct list_head *seed,
|
||||
int reseed)
|
||||
@ -796,6 +779,47 @@ static struct drbg_state_ops drbg_hmac_ops = {
|
||||
|
||||
#ifdef CONFIG_CRYPTO_DRBG_HASH
|
||||
#define CRYPTO_DRBG_HASH_STRING "HASH "
|
||||
MODULE_ALIAS_CRYPTO("drbg_pr_sha512");
|
||||
MODULE_ALIAS_CRYPTO("drbg_nopr_sha512");
|
||||
MODULE_ALIAS_CRYPTO("drbg_pr_sha384");
|
||||
MODULE_ALIAS_CRYPTO("drbg_nopr_sha384");
|
||||
MODULE_ALIAS_CRYPTO("drbg_pr_sha256");
|
||||
MODULE_ALIAS_CRYPTO("drbg_nopr_sha256");
|
||||
MODULE_ALIAS_CRYPTO("drbg_pr_sha1");
|
||||
MODULE_ALIAS_CRYPTO("drbg_nopr_sha1");
|
||||
|
||||
/*
|
||||
* Increment buffer
|
||||
*
|
||||
* @dst buffer to increment
|
||||
* @add value to add
|
||||
*/
|
||||
static inline void drbg_add_buf(unsigned char *dst, size_t dstlen,
|
||||
const unsigned char *add, size_t addlen)
|
||||
{
|
||||
/* implied: dstlen > addlen */
|
||||
unsigned char *dstptr;
|
||||
const unsigned char *addptr;
|
||||
unsigned int remainder = 0;
|
||||
size_t len = addlen;
|
||||
|
||||
dstptr = dst + (dstlen-1);
|
||||
addptr = add + (addlen-1);
|
||||
while (len) {
|
||||
remainder += *dstptr + *addptr;
|
||||
*dstptr = remainder & 0xff;
|
||||
remainder >>= 8;
|
||||
len--; dstptr--; addptr--;
|
||||
}
|
||||
len = dstlen - addlen;
|
||||
while (len && remainder > 0) {
|
||||
remainder = *dstptr + 1;
|
||||
*dstptr = remainder & 0xff;
|
||||
remainder >>= 8;
|
||||
len--; dstptr--;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* scratchpad usage: as drbg_hash_update and drbg_hash_df are used
|
||||
* interlinked, the scratchpad is used as follows:
|
||||
@ -848,7 +872,7 @@ static int drbg_hash_df(struct drbg_state *drbg,
|
||||
}
|
||||
|
||||
out:
|
||||
memset(tmp, 0, drbg_blocklen(drbg));
|
||||
memzero_explicit(tmp, drbg_blocklen(drbg));
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -892,7 +916,7 @@ static int drbg_hash_update(struct drbg_state *drbg, struct list_head *seed,
|
||||
ret = drbg_hash_df(drbg, drbg->C, drbg_statelen(drbg), &datalist2);
|
||||
|
||||
out:
|
||||
memset(drbg->scratchpad, 0, drbg_statelen(drbg));
|
||||
memzero_explicit(drbg->scratchpad, drbg_statelen(drbg));
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -927,7 +951,7 @@ static int drbg_hash_process_addtl(struct drbg_state *drbg,
|
||||
drbg->scratchpad, drbg_blocklen(drbg));
|
||||
|
||||
out:
|
||||
memset(drbg->scratchpad, 0, drbg_blocklen(drbg));
|
||||
memzero_explicit(drbg->scratchpad, drbg_blocklen(drbg));
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -942,7 +966,6 @@ static int drbg_hash_hashgen(struct drbg_state *drbg,
|
||||
unsigned char *dst = drbg->scratchpad + drbg_statelen(drbg);
|
||||
struct drbg_string data;
|
||||
LIST_HEAD(datalist);
|
||||
unsigned char prefix = DRBG_PREFIX1;
|
||||
|
||||
memset(src, 0, drbg_statelen(drbg));
|
||||
memset(dst, 0, drbg_blocklen(drbg));
|
||||
@ -963,7 +986,7 @@ static int drbg_hash_hashgen(struct drbg_state *drbg,
|
||||
outlen = (drbg_blocklen(drbg) < (buflen - len)) ?
|
||||
drbg_blocklen(drbg) : (buflen - len);
|
||||
if (!drbg_fips_continuous_test(drbg, dst)) {
|
||||
drbg_add_buf(src, drbg_statelen(drbg), &prefix, 1);
|
||||
crypto_inc(src, drbg_statelen(drbg));
|
||||
continue;
|
||||
}
|
||||
/* 10.1.1.4 step hashgen 4.2 */
|
||||
@ -971,11 +994,11 @@ static int drbg_hash_hashgen(struct drbg_state *drbg,
|
||||
len += outlen;
|
||||
/* 10.1.1.4 hashgen step 4.3 */
|
||||
if (len < buflen)
|
||||
drbg_add_buf(src, drbg_statelen(drbg), &prefix, 1);
|
||||
crypto_inc(src, drbg_statelen(drbg));
|
||||
}
|
||||
|
||||
out:
|
||||
memset(drbg->scratchpad, 0,
|
||||
memzero_explicit(drbg->scratchpad,
|
||||
(drbg_statelen(drbg) + drbg_blocklen(drbg)));
|
||||
return len;
|
||||
}
|
||||
@ -1024,7 +1047,7 @@ static int drbg_hash_generate(struct drbg_state *drbg,
|
||||
drbg_add_buf(drbg->V, drbg_statelen(drbg), u.req, 8);
|
||||
|
||||
out:
|
||||
memset(drbg->scratchpad, 0, drbg_blocklen(drbg));
|
||||
memzero_explicit(drbg->scratchpad, drbg_blocklen(drbg));
|
||||
return len;
|
||||
}
|
||||
|
||||
|
@ -185,3 +185,4 @@ module_exit(crypto_ecb_module_exit);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("ECB block cipher algorithm");
|
||||
MODULE_ALIAS_CRYPTO("ecb");
|
||||
|
@ -267,3 +267,4 @@ module_exit(eseqiv_module_exit);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("Encrypted Sequence Number IV Generator");
|
||||
MODULE_ALIAS_CRYPTO("eseqiv");
|
||||
|
@ -420,3 +420,4 @@ module_exit(fcrypt_mod_fini);
|
||||
MODULE_LICENSE("Dual BSD/GPL");
|
||||
MODULE_DESCRIPTION("FCrypt Cipher Algorithm");
|
||||
MODULE_AUTHOR("David Howells <dhowells@redhat.com>");
|
||||
MODULE_ALIAS_CRYPTO("fcrypt");
|
||||
|
@ -1441,6 +1441,7 @@ module_exit(crypto_gcm_module_exit);
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("Galois/Counter Mode");
|
||||
MODULE_AUTHOR("Mikko Herranen <mh1@iki.fi>");
|
||||
MODULE_ALIAS("gcm_base");
|
||||
MODULE_ALIAS("rfc4106");
|
||||
MODULE_ALIAS("rfc4543");
|
||||
MODULE_ALIAS_CRYPTO("gcm_base");
|
||||
MODULE_ALIAS_CRYPTO("rfc4106");
|
||||
MODULE_ALIAS_CRYPTO("rfc4543");
|
||||
MODULE_ALIAS_CRYPTO("gcm");
|
||||
|
@ -172,4 +172,4 @@ module_exit(ghash_mod_exit);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("GHASH Message Digest Algorithm");
|
||||
MODULE_ALIAS("ghash");
|
||||
MODULE_ALIAS_CRYPTO("ghash");
|
||||
|
@ -268,3 +268,4 @@ module_exit(hmac_module_exit);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("HMAC hash algorithm");
|
||||
MODULE_ALIAS_CRYPTO("hmac");
|
||||
|
@ -880,3 +880,4 @@ module_exit(khazad_mod_fini);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("Khazad Cryptographic Algorithm");
|
||||
MODULE_ALIAS_CRYPTO("khazad");
|
||||
|
@ -62,4 +62,4 @@ module_exit(krng_mod_fini);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("Kernel Random Number Generator");
|
||||
MODULE_ALIAS("stdrng");
|
||||
MODULE_ALIAS_CRYPTO("stdrng");
|
||||
|
@ -400,3 +400,4 @@ module_exit(crypto_module_exit);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("LRW block cipher mode");
|
||||
MODULE_ALIAS_CRYPTO("lrw");
|
||||
|
@ -104,3 +104,4 @@ module_exit(lz4_mod_fini);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("LZ4 Compression Algorithm");
|
||||
MODULE_ALIAS_CRYPTO("lz4");
|
||||
|
@ -104,3 +104,4 @@ module_exit(lz4hc_mod_fini);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("LZ4HC Compression Algorithm");
|
||||
MODULE_ALIAS_CRYPTO("lz4hc");
|
||||
|
@ -107,3 +107,4 @@ module_exit(lzo_mod_fini);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("LZO Compression Algorithm");
|
||||
MODULE_ALIAS_CRYPTO("lzo");
|
||||
|
@ -703,3 +703,4 @@ module_exit(mcryptd_exit);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("Software async multibuffer crypto daemon");
|
||||
MODULE_ALIAS_CRYPTO("mcryptd");
|
||||
|
@ -255,4 +255,4 @@ module_exit(md4_mod_fini);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("MD4 Message Digest Algorithm");
|
||||
|
||||
MODULE_ALIAS_CRYPTO("md4");
|
||||
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user