2019-05-27 00:55:01 -06:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0-or-later */
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Scatterlist Cryptographic API.
|
|
|
|
*
|
|
|
|
* Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
|
|
|
|
* Copyright (c) 2002 David S. Miller (davem@redhat.com)
|
2005-11-04 22:58:14 -07:00
|
|
|
* Copyright (c) 2005 Herbert Xu <herbert@gondor.apana.org.au>
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* Portions derived from Cryptoapi, by Alexander Kjeldaas <astor@fast.no>
|
2007-10-19 15:07:36 -06:00
|
|
|
* and Nettle, by Niels Möller.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
#ifndef _LINUX_CRYPTO_H
|
|
|
|
#define _LINUX_CRYPTO_H
|
|
|
|
|
2011-07-26 17:09:06 -06:00
|
|
|
#include <linux/atomic.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/list.h>
|
2011-11-23 18:12:59 -07:00
|
|
|
#include <linux/bug.h>
|
2020-06-18 01:00:22 -06:00
|
|
|
#include <linux/refcount.h>
|
2006-08-21 05:03:52 -06:00
|
|
|
#include <linux/slab.h>
|
2017-10-18 01:00:38 -06:00
|
|
|
#include <linux/completion.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-11-20 18:05:53 -07:00
|
|
|
/*
|
|
|
|
* Autoloaded crypto modules should only use a prefixed name to avoid allowing
|
|
|
|
* arbitrary modules to be loaded. Loading from userspace may still need the
|
|
|
|
* unprefixed names, so retains those aliases as well.
|
|
|
|
* This uses __MODULE_INFO directly instead of MODULE_ALIAS because pre-4.3
|
|
|
|
* gcc (e.g. avr32 toolchain) uses __LINE__ for uniqueness, and this macro
|
|
|
|
* expands twice on the same line. Instead, use a separate base name for the
|
|
|
|
* alias.
|
|
|
|
*/
|
|
|
|
#define MODULE_ALIAS_CRYPTO(name) \
|
|
|
|
__MODULE_INFO(alias, alias_userspace, name); \
|
|
|
|
__MODULE_INFO(alias, alias_crypto, "crypto-" name)
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Algorithm masks and types.
|
|
|
|
*/
|
2006-08-06 05:23:26 -06:00
|
|
|
#define CRYPTO_ALG_TYPE_MASK 0x0000000f
|
2005-04-16 16:20:36 -06:00
|
|
|
#define CRYPTO_ALG_TYPE_CIPHER 0x00000001
|
2008-05-14 06:41:47 -06:00
|
|
|
#define CRYPTO_ALG_TYPE_COMPRESS 0x00000002
|
|
|
|
#define CRYPTO_ALG_TYPE_AEAD 0x00000003
|
2016-07-11 23:17:31 -06:00
|
|
|
#define CRYPTO_ALG_TYPE_SKCIPHER 0x00000005
|
2016-06-22 10:49:13 -06:00
|
|
|
#define CRYPTO_ALG_TYPE_KPP 0x00000008
|
2016-10-21 06:19:47 -06:00
|
|
|
#define CRYPTO_ALG_TYPE_ACOMPRESS 0x0000000a
|
2016-10-21 06:19:48 -06:00
|
|
|
#define CRYPTO_ALG_TYPE_SCOMPRESS 0x0000000b
|
2008-08-14 06:15:52 -06:00
|
|
|
#define CRYPTO_ALG_TYPE_RNG 0x0000000c
|
2015-06-16 11:30:55 -06:00
|
|
|
#define CRYPTO_ALG_TYPE_AKCIPHER 0x0000000d
|
2016-06-02 06:28:55 -06:00
|
|
|
#define CRYPTO_ALG_TYPE_HASH 0x0000000e
|
|
|
|
#define CRYPTO_ALG_TYPE_SHASH 0x0000000e
|
|
|
|
#define CRYPTO_ALG_TYPE_AHASH 0x0000000f
|
2006-08-19 06:24:23 -06:00
|
|
|
|
|
|
|
#define CRYPTO_ALG_TYPE_HASH_MASK 0x0000000e
|
2016-06-02 06:28:55 -06:00
|
|
|
#define CRYPTO_ALG_TYPE_AHASH_MASK 0x0000000e
|
2016-10-21 06:19:48 -06:00
|
|
|
#define CRYPTO_ALG_TYPE_ACOMPRESS_MASK 0x0000000e
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-08-06 05:23:26 -06:00
|
|
|
#define CRYPTO_ALG_LARVAL 0x00000010
|
2006-09-20 19:39:29 -06:00
|
|
|
#define CRYPTO_ALG_DEAD 0x00000020
|
|
|
|
#define CRYPTO_ALG_DYING 0x00000040
|
2006-08-06 07:12:59 -06:00
|
|
|
#define CRYPTO_ALG_ASYNC 0x00000080
|
2006-08-06 05:23:26 -06:00
|
|
|
|
2006-08-26 02:34:10 -06:00
|
|
|
/*
|
2020-07-10 00:20:39 -06:00
|
|
|
* Set if the algorithm (or an algorithm which it uses) requires another
|
|
|
|
* algorithm of the same type to handle corner cases.
|
2006-08-26 02:34:10 -06:00
|
|
|
*/
|
|
|
|
#define CRYPTO_ALG_NEED_FALLBACK 0x00000100
|
|
|
|
|
2008-08-03 07:15:23 -06:00
|
|
|
/*
|
|
|
|
* Set if the algorithm has passed automated run-time testing. Note that
|
|
|
|
* if there is no run-time testing for a given algorithm it is considered
|
|
|
|
* to have passed.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define CRYPTO_ALG_TESTED 0x00000400
|
|
|
|
|
2011-09-26 23:21:26 -06:00
|
|
|
/*
|
2016-11-30 06:16:08 -07:00
|
|
|
* Set if the algorithm is an instance that is built from templates.
|
2011-09-26 23:21:26 -06:00
|
|
|
*/
|
|
|
|
#define CRYPTO_ALG_INSTANCE 0x00000800
|
|
|
|
|
2011-11-01 06:39:56 -06:00
|
|
|
/* Set this bit if the algorithm provided is hardware accelerated but
|
|
|
|
* not available to userspace via instruction set or so.
|
|
|
|
*/
|
|
|
|
#define CRYPTO_ALG_KERN_DRIVER_ONLY 0x00001000
|
|
|
|
|
2015-03-30 13:55:52 -06:00
|
|
|
/*
|
|
|
|
* Mark a cipher as a service implementation only usable by another
|
|
|
|
* cipher and never by a normal user of the kernel crypto API
|
|
|
|
*/
|
|
|
|
#define CRYPTO_ALG_INTERNAL 0x00002000
|
|
|
|
|
2018-01-03 12:16:26 -07:00
|
|
|
/*
|
|
|
|
* Set if the algorithm has a ->setkey() method but can be used without
|
|
|
|
* calling it first, i.e. there is a default key.
|
|
|
|
*/
|
|
|
|
#define CRYPTO_ALG_OPTIONAL_KEY 0x00004000
|
|
|
|
|
2018-06-08 15:57:42 -06:00
|
|
|
/*
|
|
|
|
* Don't trigger module loading
|
|
|
|
*/
|
|
|
|
#define CRYPTO_NOLOAD 0x00008000
|
|
|
|
|
2020-07-10 00:20:40 -06:00
|
|
|
/*
|
|
|
|
* The algorithm may allocate memory during request processing, i.e. during
|
|
|
|
* encryption, decryption, or hashing. Users can request an algorithm with this
|
|
|
|
* flag unset if they can't handle memory allocation failures.
|
|
|
|
*
|
|
|
|
* This flag is currently only implemented for algorithms of type "skcipher",
|
|
|
|
* "aead", "ahash", "shash", and "cipher". Algorithms of other types might not
|
|
|
|
* have this flag set even if they allocate memory.
|
|
|
|
*
|
|
|
|
* In some edge cases, algorithms can allocate memory regardless of this flag.
|
|
|
|
* To avoid these cases, users must obey the following usage constraints:
|
|
|
|
* skcipher:
|
|
|
|
* - The IV buffer and all scatterlist elements must be aligned to the
|
|
|
|
* algorithm's alignmask.
|
|
|
|
* - If the data were to be divided into chunks of size
|
|
|
|
* crypto_skcipher_walksize() (with any remainder going at the end), no
|
|
|
|
* chunk can cross a page boundary or a scatterlist element boundary.
|
|
|
|
* aead:
|
|
|
|
* - The IV buffer and all scatterlist elements must be aligned to the
|
|
|
|
* algorithm's alignmask.
|
|
|
|
* - The first scatterlist element must contain all the associated data,
|
|
|
|
* and its pages must be !PageHighMem.
|
|
|
|
* - If the plaintext/ciphertext were to be divided into chunks of size
|
|
|
|
* crypto_aead_walksize() (with the remainder going at the end), no chunk
|
|
|
|
* can cross a page boundary or a scatterlist element boundary.
|
|
|
|
* ahash:
|
|
|
|
* - The result buffer must be aligned to the algorithm's alignmask.
|
|
|
|
* - crypto_ahash_finup() must not be used unless the algorithm implements
|
|
|
|
* ->finup() natively.
|
|
|
|
*/
|
|
|
|
#define CRYPTO_ALG_ALLOCATES_MEMORY 0x00010000
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Transform masks and values (for crt_flags).
|
|
|
|
*/
|
crypto: hash - prevent using keyed hashes without setting key
Currently, almost none of the keyed hash algorithms check whether a key
has been set before proceeding. Some algorithms are okay with this and
will effectively just use a key of all 0's or some other bogus default.
However, others will severely break, as demonstrated using
"hmac(sha3-512-generic)", the unkeyed use of which causes a kernel crash
via a (potentially exploitable) stack buffer overflow.
A while ago, this problem was solved for AF_ALG by pairing each hash
transform with a 'has_key' bool. However, there are still other places
in the kernel where userspace can specify an arbitrary hash algorithm by
name, and the kernel uses it as unkeyed hash without checking whether it
is really unkeyed. Examples of this include:
- KEYCTL_DH_COMPUTE, via the KDF extension
- dm-verity
- dm-crypt, via the ESSIV support
- dm-integrity, via the "internal hash" mode with no key given
- drbd (Distributed Replicated Block Device)
This bug is especially bad for KEYCTL_DH_COMPUTE as that requires no
privileges to call.
Fix the bug for all users by adding a flag CRYPTO_TFM_NEED_KEY to the
->crt_flags of each hash transform that indicates whether the transform
still needs to be keyed or not. Then, make the hash init, import, and
digest functions return -ENOKEY if the key is still needed.
The new flag also replaces the 'has_key' bool which algif_hash was
previously using, thereby simplifying the algif_hash implementation.
Reported-by: syzbot <syzkaller@googlegroups.com>
Cc: stable@vger.kernel.org
Signed-off-by: Eric Biggers <ebiggers@google.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2018-01-03 12:16:27 -07:00
|
|
|
#define CRYPTO_TFM_NEED_KEY 0x00000001
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#define CRYPTO_TFM_REQ_MASK 0x000fff00
|
2019-01-18 23:48:00 -07:00
|
|
|
#define CRYPTO_TFM_REQ_FORBID_WEAK_KEYS 0x00000100
|
2005-09-01 18:43:05 -06:00
|
|
|
#define CRYPTO_TFM_REQ_MAY_SLEEP 0x00000200
|
2007-03-23 21:35:34 -06:00
|
|
|
#define CRYPTO_TFM_REQ_MAY_BACKLOG 0x00000400
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Miscellaneous stuff.
|
|
|
|
*/
|
2017-04-06 02:16:11 -06:00
|
|
|
#define CRYPTO_MAX_ALG_NAME 128
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-08-21 05:03:52 -06:00
|
|
|
/*
|
|
|
|
* The macro CRYPTO_MINALIGN_ATTR (along with the void * type in the actual
|
|
|
|
* declaration) is used to ensure that the crypto_tfm context structure is
|
|
|
|
* aligned correctly for the given architecture so that there are no alignment
|
|
|
|
* faults for C data types. In particular, this is required on platforms such
|
|
|
|
* as arm where pointers are 32-bit aligned but there are data types such as
|
|
|
|
* u64 which require 64-bit alignment.
|
|
|
|
*/
|
|
|
|
#define CRYPTO_MINALIGN ARCH_KMALLOC_MINALIGN
|
|
|
|
|
|
|
|
#define CRYPTO_MINALIGN_ATTR __attribute__ ((__aligned__(CRYPTO_MINALIGN)))
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
struct scatterlist;
|
2007-03-23 21:35:34 -06:00
|
|
|
struct crypto_async_request;
|
2005-07-06 14:51:52 -06:00
|
|
|
struct crypto_tfm;
|
2006-08-21 08:06:54 -06:00
|
|
|
struct crypto_type;
|
2005-07-06 14:51:52 -06:00
|
|
|
|
2007-03-23 21:35:34 -06:00
|
|
|
typedef void (*crypto_completion_t)(struct crypto_async_request *req, int err);
|
|
|
|
|
2014-11-11 21:27:49 -07:00
|
|
|
/**
|
|
|
|
* DOC: Block Cipher Context Data Structures
|
|
|
|
*
|
|
|
|
* These data structures define the operating context for each block cipher
|
|
|
|
* type.
|
|
|
|
*/
|
|
|
|
|
2007-03-23 21:35:34 -06:00
|
|
|
struct crypto_async_request {
|
|
|
|
struct list_head list;
|
|
|
|
crypto_completion_t complete;
|
|
|
|
void *data;
|
|
|
|
struct crypto_tfm *tfm;
|
|
|
|
|
|
|
|
u32 flags;
|
|
|
|
};
|
|
|
|
|
2014-11-11 21:27:49 -07:00
|
|
|
/**
|
|
|
|
* DOC: Block Cipher Algorithm Definitions
|
|
|
|
*
|
|
|
|
* These data structures define modular crypto algorithm implementations,
|
|
|
|
* managed via crypto_register_alg() and crypto_unregister_alg().
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct cipher_alg - single-block symmetric ciphers definition
|
|
|
|
* @cia_min_keysize: Minimum key size supported by the transformation. This is
|
|
|
|
* the smallest key length supported by this transformation
|
|
|
|
* algorithm. This must be set to one of the pre-defined
|
|
|
|
* values as this is not hardware specific. Possible values
|
|
|
|
* for this field can be found via git grep "_MIN_KEY_SIZE"
|
|
|
|
* include/crypto/
|
|
|
|
* @cia_max_keysize: Maximum key size supported by the transformation. This is
|
|
|
|
* the largest key length supported by this transformation
|
|
|
|
* algorithm. This must be set to one of the pre-defined values
|
|
|
|
* as this is not hardware specific. Possible values for this
|
|
|
|
* field can be found via git grep "_MAX_KEY_SIZE"
|
|
|
|
* include/crypto/
|
|
|
|
* @cia_setkey: Set key for the transformation. This function is used to either
|
|
|
|
* program a supplied key into the hardware or store the key in the
|
|
|
|
* transformation context for programming it later. Note that this
|
|
|
|
* function does modify the transformation context. This function
|
|
|
|
* can be called multiple times during the existence of the
|
|
|
|
* transformation object, so one must make sure the key is properly
|
|
|
|
* reprogrammed into the hardware. This function is also
|
|
|
|
* responsible for checking the key length for validity.
|
|
|
|
* @cia_encrypt: Encrypt a single block. This function is used to encrypt a
|
|
|
|
* single block of data, which must be @cra_blocksize big. This
|
|
|
|
* always operates on a full @cra_blocksize and it is not possible
|
|
|
|
* to encrypt a block of smaller size. The supplied buffers must
|
|
|
|
* therefore also be at least of @cra_blocksize size. Both the
|
|
|
|
* input and output buffers are always aligned to @cra_alignmask.
|
|
|
|
* In case either of the input or output buffer supplied by user
|
|
|
|
* of the crypto API is not aligned to @cra_alignmask, the crypto
|
|
|
|
* API will re-align the buffers. The re-alignment means that a
|
|
|
|
* new buffer will be allocated, the data will be copied into the
|
|
|
|
* new buffer, then the processing will happen on the new buffer,
|
|
|
|
* then the data will be copied back into the original buffer and
|
|
|
|
* finally the new buffer will be freed. In case a software
|
|
|
|
* fallback was put in place in the @cra_init call, this function
|
|
|
|
* might need to use the fallback if the algorithm doesn't support
|
|
|
|
* all of the key sizes. In case the key was stored in
|
|
|
|
* transformation context, the key might need to be re-programmed
|
|
|
|
* into the hardware in this function. This function shall not
|
|
|
|
* modify the transformation context, as this function may be
|
|
|
|
* called in parallel with the same transformation object.
|
|
|
|
* @cia_decrypt: Decrypt a single block. This is a reverse counterpart to
|
|
|
|
* @cia_encrypt, and the conditions are exactly the same.
|
|
|
|
*
|
|
|
|
* All fields are mandatory and must be filled.
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
struct cipher_alg {
|
|
|
|
unsigned int cia_min_keysize;
|
|
|
|
unsigned int cia_max_keysize;
|
2006-05-16 06:09:29 -06:00
|
|
|
int (*cia_setkey)(struct crypto_tfm *tfm, const u8 *key,
|
2006-08-12 22:16:39 -06:00
|
|
|
unsigned int keylen);
|
2006-05-16 06:09:29 -06:00
|
|
|
void (*cia_encrypt)(struct crypto_tfm *tfm, u8 *dst, const u8 *src);
|
|
|
|
void (*cia_decrypt)(struct crypto_tfm *tfm, u8 *dst, const u8 *src);
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2019-06-25 17:43:43 -06:00
|
|
|
/**
|
|
|
|
* struct compress_alg - compression/decompression algorithm
|
|
|
|
* @coa_compress: Compress a buffer of specified length, storing the resulting
|
|
|
|
* data in the specified buffer. Return the length of the
|
|
|
|
* compressed data in dlen.
|
|
|
|
* @coa_decompress: Decompress the source buffer, storing the uncompressed
|
|
|
|
* data in the specified buffer. The length of the data is
|
|
|
|
* returned in dlen.
|
|
|
|
*
|
|
|
|
* All fields are mandatory.
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
struct compress_alg {
|
2006-05-16 06:09:29 -06:00
|
|
|
int (*coa_compress)(struct crypto_tfm *tfm, const u8 *src,
|
|
|
|
unsigned int slen, u8 *dst, unsigned int *dlen);
|
|
|
|
int (*coa_decompress)(struct crypto_tfm *tfm, const u8 *src,
|
|
|
|
unsigned int slen, u8 *dst, unsigned int *dlen);
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2018-11-29 07:42:24 -07:00
|
|
|
#ifdef CONFIG_CRYPTO_STATS
|
|
|
|
/*
|
|
|
|
* struct crypto_istat_aead - statistics for AEAD algorithm
|
|
|
|
* @encrypt_cnt: number of encrypt requests
|
|
|
|
* @encrypt_tlen: total data size handled by encrypt requests
|
|
|
|
* @decrypt_cnt: number of decrypt requests
|
|
|
|
* @decrypt_tlen: total data size handled by decrypt requests
|
2018-11-29 07:42:25 -07:00
|
|
|
* @err_cnt: number of error for AEAD requests
|
2018-11-29 07:42:24 -07:00
|
|
|
*/
|
|
|
|
struct crypto_istat_aead {
|
|
|
|
atomic64_t encrypt_cnt;
|
|
|
|
atomic64_t encrypt_tlen;
|
|
|
|
atomic64_t decrypt_cnt;
|
|
|
|
atomic64_t decrypt_tlen;
|
2018-11-29 07:42:25 -07:00
|
|
|
atomic64_t err_cnt;
|
2018-11-29 07:42:24 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* struct crypto_istat_akcipher - statistics for akcipher algorithm
|
|
|
|
* @encrypt_cnt: number of encrypt requests
|
|
|
|
* @encrypt_tlen: total data size handled by encrypt requests
|
|
|
|
* @decrypt_cnt: number of decrypt requests
|
|
|
|
* @decrypt_tlen: total data size handled by decrypt requests
|
|
|
|
* @verify_cnt: number of verify operation
|
|
|
|
* @sign_cnt: number of sign requests
|
2018-11-29 07:42:25 -07:00
|
|
|
* @err_cnt: number of error for akcipher requests
|
2018-11-29 07:42:24 -07:00
|
|
|
*/
|
|
|
|
struct crypto_istat_akcipher {
|
|
|
|
atomic64_t encrypt_cnt;
|
|
|
|
atomic64_t encrypt_tlen;
|
|
|
|
atomic64_t decrypt_cnt;
|
|
|
|
atomic64_t decrypt_tlen;
|
|
|
|
atomic64_t verify_cnt;
|
|
|
|
atomic64_t sign_cnt;
|
2018-11-29 07:42:25 -07:00
|
|
|
atomic64_t err_cnt;
|
2018-11-29 07:42:24 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* struct crypto_istat_cipher - statistics for cipher algorithm
|
|
|
|
* @encrypt_cnt: number of encrypt requests
|
|
|
|
* @encrypt_tlen: total data size handled by encrypt requests
|
|
|
|
* @decrypt_cnt: number of decrypt requests
|
|
|
|
* @decrypt_tlen: total data size handled by decrypt requests
|
2018-11-29 07:42:25 -07:00
|
|
|
* @err_cnt: number of error for cipher requests
|
2018-11-29 07:42:24 -07:00
|
|
|
*/
|
|
|
|
struct crypto_istat_cipher {
|
|
|
|
atomic64_t encrypt_cnt;
|
|
|
|
atomic64_t encrypt_tlen;
|
|
|
|
atomic64_t decrypt_cnt;
|
|
|
|
atomic64_t decrypt_tlen;
|
2018-11-29 07:42:25 -07:00
|
|
|
atomic64_t err_cnt;
|
2018-11-29 07:42:24 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* struct crypto_istat_compress - statistics for compress algorithm
|
|
|
|
* @compress_cnt: number of compress requests
|
|
|
|
* @compress_tlen: total data size handled by compress requests
|
|
|
|
* @decompress_cnt: number of decompress requests
|
|
|
|
* @decompress_tlen: total data size handled by decompress requests
|
2018-11-29 07:42:25 -07:00
|
|
|
* @err_cnt: number of error for compress requests
|
2018-11-29 07:42:24 -07:00
|
|
|
*/
|
|
|
|
struct crypto_istat_compress {
|
|
|
|
atomic64_t compress_cnt;
|
|
|
|
atomic64_t compress_tlen;
|
|
|
|
atomic64_t decompress_cnt;
|
|
|
|
atomic64_t decompress_tlen;
|
2018-11-29 07:42:25 -07:00
|
|
|
atomic64_t err_cnt;
|
2018-11-29 07:42:24 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* struct crypto_istat_hash - statistics for has algorithm
|
|
|
|
* @hash_cnt: number of hash requests
|
|
|
|
* @hash_tlen: total data size hashed
|
2018-11-29 07:42:25 -07:00
|
|
|
* @err_cnt: number of error for hash requests
|
2018-11-29 07:42:24 -07:00
|
|
|
*/
|
|
|
|
struct crypto_istat_hash {
|
|
|
|
atomic64_t hash_cnt;
|
|
|
|
atomic64_t hash_tlen;
|
2018-11-29 07:42:25 -07:00
|
|
|
atomic64_t err_cnt;
|
2018-11-29 07:42:24 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* struct crypto_istat_kpp - statistics for KPP algorithm
|
|
|
|
* @setsecret_cnt: number of setsecrey operation
|
|
|
|
* @generate_public_key_cnt: number of generate_public_key operation
|
|
|
|
* @compute_shared_secret_cnt: number of compute_shared_secret operation
|
2018-11-29 07:42:25 -07:00
|
|
|
* @err_cnt: number of error for KPP requests
|
2018-11-29 07:42:24 -07:00
|
|
|
*/
|
|
|
|
struct crypto_istat_kpp {
|
|
|
|
atomic64_t setsecret_cnt;
|
|
|
|
atomic64_t generate_public_key_cnt;
|
|
|
|
atomic64_t compute_shared_secret_cnt;
|
2018-11-29 07:42:25 -07:00
|
|
|
atomic64_t err_cnt;
|
2018-11-29 07:42:24 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* struct crypto_istat_rng: statistics for RNG algorithm
|
|
|
|
* @generate_cnt: number of RNG generate requests
|
|
|
|
* @generate_tlen: total data size of generated data by the RNG
|
|
|
|
* @seed_cnt: number of times the RNG was seeded
|
2018-11-29 07:42:25 -07:00
|
|
|
* @err_cnt: number of error for RNG requests
|
2018-11-29 07:42:24 -07:00
|
|
|
*/
|
|
|
|
struct crypto_istat_rng {
|
|
|
|
atomic64_t generate_cnt;
|
|
|
|
atomic64_t generate_tlen;
|
|
|
|
atomic64_t seed_cnt;
|
2018-11-29 07:42:25 -07:00
|
|
|
atomic64_t err_cnt;
|
2018-11-29 07:42:24 -07:00
|
|
|
};
|
|
|
|
#endif /* CONFIG_CRYPTO_STATS */
|
2008-08-14 06:15:52 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#define cra_cipher cra_u.cipher
|
|
|
|
#define cra_compress cra_u.compress
|
|
|
|
|
2014-11-11 21:27:49 -07:00
|
|
|
/**
|
|
|
|
* struct crypto_alg - definition of a cryptograpic cipher algorithm
|
|
|
|
* @cra_flags: Flags describing this transformation. See include/linux/crypto.h
|
|
|
|
* CRYPTO_ALG_* flags for the flags which go in here. Those are
|
|
|
|
* used for fine-tuning the description of the transformation
|
|
|
|
* algorithm.
|
|
|
|
* @cra_blocksize: Minimum block size of this transformation. The size in bytes
|
|
|
|
* of the smallest possible unit which can be transformed with
|
|
|
|
* this algorithm. The users must respect this value.
|
|
|
|
* In case of HASH transformation, it is possible for a smaller
|
|
|
|
* block than @cra_blocksize to be passed to the crypto API for
|
|
|
|
* transformation, in case of any other transformation type, an
|
|
|
|
* error will be returned upon any attempt to transform smaller
|
|
|
|
* than @cra_blocksize chunks.
|
|
|
|
* @cra_ctxsize: Size of the operational context of the transformation. This
|
|
|
|
* value informs the kernel crypto API about the memory size
|
|
|
|
* needed to be allocated for the transformation context.
|
|
|
|
* @cra_alignmask: Alignment mask for the input and output data buffer. The data
|
|
|
|
* buffer containing the input data for the algorithm must be
|
|
|
|
* aligned to this alignment mask. The data buffer for the
|
|
|
|
* output data must be aligned to this alignment mask. Note that
|
|
|
|
* the Crypto API will do the re-alignment in software, but
|
|
|
|
* only under special conditions and there is a performance hit.
|
|
|
|
* The re-alignment happens at these occasions for different
|
|
|
|
* @cra_u types: cipher -- For both input data and output data
|
|
|
|
* buffer; ahash -- For output hash destination buf; shash --
|
|
|
|
* For output hash destination buf.
|
|
|
|
* This is needed on hardware which is flawed by design and
|
|
|
|
* cannot pick data from arbitrary addresses.
|
|
|
|
* @cra_priority: Priority of this transformation implementation. In case
|
|
|
|
* multiple transformations with same @cra_name are available to
|
|
|
|
* the Crypto API, the kernel will use the one with highest
|
|
|
|
* @cra_priority.
|
|
|
|
* @cra_name: Generic name (usable by multiple implementations) of the
|
|
|
|
* transformation algorithm. This is the name of the transformation
|
|
|
|
* itself. This field is used by the kernel when looking up the
|
|
|
|
* providers of particular transformation.
|
|
|
|
* @cra_driver_name: Unique name of the transformation provider. This is the
|
|
|
|
* name of the provider of the transformation. This can be any
|
|
|
|
* arbitrary value, but in the usual case, this contains the
|
|
|
|
* name of the chip or provider and the name of the
|
|
|
|
* transformation algorithm.
|
|
|
|
* @cra_type: Type of the cryptographic transformation. This is a pointer to
|
|
|
|
* struct crypto_type, which implements callbacks common for all
|
crypto: skcipher - remove the "blkcipher" algorithm type
Now that all "blkcipher" algorithms have been converted to "skcipher",
remove the blkcipher algorithm type.
The skcipher (symmetric key cipher) algorithm type was introduced a few
years ago to replace both blkcipher and ablkcipher (synchronous and
asynchronous block cipher). The advantages of skcipher include:
- A much less confusing name, since none of these algorithm types have
ever actually been for raw block ciphers, but rather for all
length-preserving encryption modes including block cipher modes of
operation, stream ciphers, and other length-preserving modes.
- It unified blkcipher and ablkcipher into a single algorithm type
which supports both synchronous and asynchronous implementations.
Note, blkcipher already operated only on scatterlists, so the fact
that skcipher does too isn't a regression in functionality.
- Better type safety by using struct skcipher_alg, struct
crypto_skcipher, etc. instead of crypto_alg, crypto_tfm, etc.
- It sometimes simplifies the implementations of algorithms.
Also, the blkcipher API was no longer being tested.
Signed-off-by: Eric Biggers <ebiggers@google.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2019-10-25 13:41:12 -06:00
|
|
|
* transformation types. There are multiple options, such as
|
|
|
|
* &crypto_skcipher_type, &crypto_ahash_type, &crypto_rng_type.
|
2014-11-11 21:27:49 -07:00
|
|
|
* This field might be empty. In that case, there are no common
|
|
|
|
* callbacks. This is the case for: cipher, compress, shash.
|
|
|
|
* @cra_u: Callbacks implementing the transformation. This is a union of
|
|
|
|
* multiple structures. Depending on the type of transformation selected
|
|
|
|
* by @cra_type and @cra_flags above, the associated structure must be
|
|
|
|
* filled with callbacks. This field might be empty. This is the case
|
|
|
|
* for ahash, shash.
|
|
|
|
* @cra_init: Initialize the cryptographic transformation object. This function
|
|
|
|
* is used to initialize the cryptographic transformation object.
|
|
|
|
* This function is called only once at the instantiation time, right
|
|
|
|
* after the transformation context was allocated. In case the
|
|
|
|
* cryptographic hardware has some special requirements which need to
|
|
|
|
* be handled by software, this function shall check for the precise
|
|
|
|
* requirement of the transformation and put any software fallbacks
|
|
|
|
* in place.
|
|
|
|
* @cra_exit: Deinitialize the cryptographic transformation object. This is a
|
|
|
|
* counterpart to @cra_init, used to remove various changes set in
|
|
|
|
* @cra_init.
|
2018-03-14 16:15:52 -06:00
|
|
|
* @cra_u.cipher: Union member which contains a single-block symmetric cipher
|
|
|
|
* definition. See @struct @cipher_alg.
|
|
|
|
* @cra_u.compress: Union member which contains a (de)compression algorithm.
|
|
|
|
* See @struct @compress_alg.
|
2014-11-11 21:27:49 -07:00
|
|
|
* @cra_module: Owner of this transformation implementation. Set to THIS_MODULE
|
|
|
|
* @cra_list: internally used
|
|
|
|
* @cra_users: internally used
|
|
|
|
* @cra_refcnt: internally used
|
|
|
|
* @cra_destroy: internally used
|
|
|
|
*
|
2018-11-29 07:42:24 -07:00
|
|
|
* @stats: union of all possible crypto_istat_xxx structures
|
2018-12-13 01:36:38 -07:00
|
|
|
* @stats.aead: statistics for AEAD algorithm
|
|
|
|
* @stats.akcipher: statistics for akcipher algorithm
|
|
|
|
* @stats.cipher: statistics for cipher algorithm
|
|
|
|
* @stats.compress: statistics for compress algorithm
|
|
|
|
* @stats.hash: statistics for hash algorithm
|
|
|
|
* @stats.rng: statistics for rng algorithm
|
|
|
|
* @stats.kpp: statistics for KPP algorithm
|
2018-09-19 04:10:54 -06:00
|
|
|
*
|
2014-11-11 21:27:49 -07:00
|
|
|
* The struct crypto_alg describes a generic Crypto API algorithm and is common
|
|
|
|
* for all of the transformations. Any variable not documented here shall not
|
|
|
|
* be used by a cipher implementation as it is internal to the Crypto API.
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
struct crypto_alg {
|
|
|
|
struct list_head cra_list;
|
2006-09-20 19:39:29 -06:00
|
|
|
struct list_head cra_users;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
u32 cra_flags;
|
|
|
|
unsigned int cra_blocksize;
|
|
|
|
unsigned int cra_ctxsize;
|
2005-07-06 14:52:09 -06:00
|
|
|
unsigned int cra_alignmask;
|
2005-11-04 22:58:14 -07:00
|
|
|
|
|
|
|
int cra_priority;
|
2017-12-29 09:00:46 -07:00
|
|
|
refcount_t cra_refcnt;
|
2005-11-04 22:58:14 -07:00
|
|
|
|
2006-05-20 16:45:26 -06:00
|
|
|
char cra_name[CRYPTO_MAX_ALG_NAME];
|
|
|
|
char cra_driver_name[CRYPTO_MAX_ALG_NAME];
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-08-21 08:06:54 -06:00
|
|
|
const struct crypto_type *cra_type;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
union {
|
|
|
|
struct cipher_alg cipher;
|
|
|
|
struct compress_alg compress;
|
|
|
|
} cra_u;
|
2006-05-23 21:02:26 -06:00
|
|
|
|
|
|
|
int (*cra_init)(struct crypto_tfm *tfm);
|
|
|
|
void (*cra_exit)(struct crypto_tfm *tfm);
|
2006-08-06 04:28:44 -06:00
|
|
|
void (*cra_destroy)(struct crypto_alg *alg);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
struct module *cra_module;
|
2018-09-19 04:10:54 -06:00
|
|
|
|
2018-11-29 07:42:16 -07:00
|
|
|
#ifdef CONFIG_CRYPTO_STATS
|
2018-09-19 04:10:54 -06:00
|
|
|
union {
|
2018-11-29 07:42:24 -07:00
|
|
|
struct crypto_istat_aead aead;
|
|
|
|
struct crypto_istat_akcipher akcipher;
|
|
|
|
struct crypto_istat_cipher cipher;
|
|
|
|
struct crypto_istat_compress compress;
|
|
|
|
struct crypto_istat_hash hash;
|
|
|
|
struct crypto_istat_rng rng;
|
|
|
|
struct crypto_istat_kpp kpp;
|
|
|
|
} stats;
|
2018-11-29 07:42:16 -07:00
|
|
|
#endif /* CONFIG_CRYPTO_STATS */
|
2018-09-19 04:10:54 -06:00
|
|
|
|
2015-06-18 00:00:48 -06:00
|
|
|
} CRYPTO_MINALIGN_ATTR;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2018-11-29 07:42:21 -07:00
|
|
|
#ifdef CONFIG_CRYPTO_STATS
|
2018-11-29 07:42:26 -07:00
|
|
|
void crypto_stats_init(struct crypto_alg *alg);
|
2018-11-29 07:42:21 -07:00
|
|
|
void crypto_stats_get(struct crypto_alg *alg);
|
|
|
|
void crypto_stats_aead_encrypt(unsigned int cryptlen, struct crypto_alg *alg, int ret);
|
|
|
|
void crypto_stats_aead_decrypt(unsigned int cryptlen, struct crypto_alg *alg, int ret);
|
|
|
|
void crypto_stats_ahash_update(unsigned int nbytes, int ret, struct crypto_alg *alg);
|
|
|
|
void crypto_stats_ahash_final(unsigned int nbytes, int ret, struct crypto_alg *alg);
|
|
|
|
void crypto_stats_akcipher_encrypt(unsigned int src_len, int ret, struct crypto_alg *alg);
|
|
|
|
void crypto_stats_akcipher_decrypt(unsigned int src_len, int ret, struct crypto_alg *alg);
|
|
|
|
void crypto_stats_akcipher_sign(int ret, struct crypto_alg *alg);
|
|
|
|
void crypto_stats_akcipher_verify(int ret, struct crypto_alg *alg);
|
|
|
|
void crypto_stats_compress(unsigned int slen, int ret, struct crypto_alg *alg);
|
|
|
|
void crypto_stats_decompress(unsigned int slen, int ret, struct crypto_alg *alg);
|
|
|
|
void crypto_stats_kpp_set_secret(struct crypto_alg *alg, int ret);
|
|
|
|
void crypto_stats_kpp_generate_public_key(struct crypto_alg *alg, int ret);
|
|
|
|
void crypto_stats_kpp_compute_shared_secret(struct crypto_alg *alg, int ret);
|
|
|
|
void crypto_stats_rng_seed(struct crypto_alg *alg, int ret);
|
|
|
|
void crypto_stats_rng_generate(struct crypto_alg *alg, unsigned int dlen, int ret);
|
|
|
|
void crypto_stats_skcipher_encrypt(unsigned int cryptlen, int ret, struct crypto_alg *alg);
|
|
|
|
void crypto_stats_skcipher_decrypt(unsigned int cryptlen, int ret, struct crypto_alg *alg);
|
|
|
|
#else
|
2018-11-29 07:42:26 -07:00
|
|
|
static inline void crypto_stats_init(struct crypto_alg *alg)
|
|
|
|
{}
|
2018-11-29 07:42:21 -07:00
|
|
|
static inline void crypto_stats_get(struct crypto_alg *alg)
|
|
|
|
{}
|
|
|
|
static inline void crypto_stats_aead_encrypt(unsigned int cryptlen, struct crypto_alg *alg, int ret)
|
|
|
|
{}
|
|
|
|
static inline void crypto_stats_aead_decrypt(unsigned int cryptlen, struct crypto_alg *alg, int ret)
|
|
|
|
{}
|
|
|
|
static inline void crypto_stats_ahash_update(unsigned int nbytes, int ret, struct crypto_alg *alg)
|
|
|
|
{}
|
|
|
|
static inline void crypto_stats_ahash_final(unsigned int nbytes, int ret, struct crypto_alg *alg)
|
|
|
|
{}
|
|
|
|
static inline void crypto_stats_akcipher_encrypt(unsigned int src_len, int ret, struct crypto_alg *alg)
|
|
|
|
{}
|
|
|
|
static inline void crypto_stats_akcipher_decrypt(unsigned int src_len, int ret, struct crypto_alg *alg)
|
|
|
|
{}
|
|
|
|
static inline void crypto_stats_akcipher_sign(int ret, struct crypto_alg *alg)
|
|
|
|
{}
|
|
|
|
static inline void crypto_stats_akcipher_verify(int ret, struct crypto_alg *alg)
|
|
|
|
{}
|
|
|
|
static inline void crypto_stats_compress(unsigned int slen, int ret, struct crypto_alg *alg)
|
|
|
|
{}
|
|
|
|
static inline void crypto_stats_decompress(unsigned int slen, int ret, struct crypto_alg *alg)
|
|
|
|
{}
|
|
|
|
static inline void crypto_stats_kpp_set_secret(struct crypto_alg *alg, int ret)
|
|
|
|
{}
|
|
|
|
static inline void crypto_stats_kpp_generate_public_key(struct crypto_alg *alg, int ret)
|
|
|
|
{}
|
|
|
|
static inline void crypto_stats_kpp_compute_shared_secret(struct crypto_alg *alg, int ret)
|
|
|
|
{}
|
|
|
|
static inline void crypto_stats_rng_seed(struct crypto_alg *alg, int ret)
|
|
|
|
{}
|
|
|
|
static inline void crypto_stats_rng_generate(struct crypto_alg *alg, unsigned int dlen, int ret)
|
|
|
|
{}
|
|
|
|
static inline void crypto_stats_skcipher_encrypt(unsigned int cryptlen, int ret, struct crypto_alg *alg)
|
|
|
|
{}
|
|
|
|
static inline void crypto_stats_skcipher_decrypt(unsigned int cryptlen, int ret, struct crypto_alg *alg)
|
|
|
|
{}
|
|
|
|
#endif
|
2017-10-18 01:00:38 -06:00
|
|
|
/*
|
|
|
|
* A helper struct for waiting for completion of async crypto ops
|
|
|
|
*/
|
|
|
|
struct crypto_wait {
|
|
|
|
struct completion completion;
|
|
|
|
int err;
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Macro for declaring a crypto op async wait object on stack
|
|
|
|
*/
|
|
|
|
#define DECLARE_CRYPTO_WAIT(_wait) \
|
|
|
|
struct crypto_wait _wait = { \
|
|
|
|
COMPLETION_INITIALIZER_ONSTACK((_wait).completion), 0 }
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Async ops completion helper functioons
|
|
|
|
*/
|
|
|
|
void crypto_req_done(struct crypto_async_request *req, int err);
|
|
|
|
|
|
|
|
static inline int crypto_wait_req(int err, struct crypto_wait *wait)
|
|
|
|
{
|
|
|
|
switch (err) {
|
|
|
|
case -EINPROGRESS:
|
|
|
|
case -EBUSY:
|
|
|
|
wait_for_completion(&wait->completion);
|
|
|
|
reinit_completion(&wait->completion);
|
|
|
|
err = wait->err;
|
|
|
|
break;
|
2019-12-16 03:58:48 -07:00
|
|
|
}
|
2017-10-18 01:00:38 -06:00
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void crypto_init_wait(struct crypto_wait *wait)
|
|
|
|
{
|
|
|
|
init_completion(&wait->completion);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Algorithm registration interface.
|
|
|
|
*/
|
|
|
|
int crypto_register_alg(struct crypto_alg *alg);
|
2019-12-15 16:51:19 -07:00
|
|
|
void crypto_unregister_alg(struct crypto_alg *alg);
|
2012-01-17 16:34:26 -07:00
|
|
|
int crypto_register_algs(struct crypto_alg *algs, int count);
|
2019-12-15 16:51:19 -07:00
|
|
|
void crypto_unregister_algs(struct crypto_alg *algs, int count);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Algorithm query interface.
|
|
|
|
*/
|
2006-08-26 01:35:45 -06:00
|
|
|
int crypto_has_alg(const char *name, u32 type, u32 mask);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Transforms: user-instantiated objects which encapsulate algorithms
|
2006-07-29 19:53:01 -06:00
|
|
|
* and core processing logic. Managed via crypto_alloc_*() and
|
|
|
|
* crypto_free_*(), as well as the various helpers below.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
|
|
|
struct crypto_tfm {
|
|
|
|
|
|
|
|
u32 crt_flags;
|
2020-07-05 03:18:58 -06:00
|
|
|
|
|
|
|
int node;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-09-13 19:19:03 -06:00
|
|
|
void (*exit)(struct crypto_tfm *tfm);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
struct crypto_alg *__crt_alg;
|
2006-01-25 04:34:01 -07:00
|
|
|
|
2006-08-21 05:03:52 -06:00
|
|
|
void *__crt_ctx[] CRYPTO_MINALIGN_ATTR;
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2006-12-23 16:02:00 -07:00
|
|
|
struct crypto_cipher {
|
|
|
|
struct crypto_tfm base;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct crypto_comp {
|
|
|
|
struct crypto_tfm base;
|
|
|
|
};
|
|
|
|
|
2006-09-20 19:31:44 -06:00
|
|
|
enum {
|
|
|
|
CRYPTOA_UNSPEC,
|
|
|
|
CRYPTOA_ALG,
|
2007-01-01 00:37:02 -07:00
|
|
|
CRYPTOA_TYPE,
|
2007-08-29 05:27:26 -06:00
|
|
|
CRYPTOA_U32,
|
2007-01-01 00:37:02 -07:00
|
|
|
__CRYPTOA_MAX,
|
2006-09-20 19:31:44 -06:00
|
|
|
};
|
|
|
|
|
2007-01-01 00:37:02 -07:00
|
|
|
#define CRYPTOA_MAX (__CRYPTOA_MAX - 1)
|
|
|
|
|
2007-08-29 05:27:26 -06:00
|
|
|
/* Maximum number of (rtattr) parameters for each template. */
|
|
|
|
#define CRYPTO_MAX_ATTRS 32
|
|
|
|
|
2006-09-20 19:31:44 -06:00
|
|
|
struct crypto_attr_alg {
|
|
|
|
char name[CRYPTO_MAX_ALG_NAME];
|
|
|
|
};
|
|
|
|
|
2007-01-01 00:37:02 -07:00
|
|
|
struct crypto_attr_type {
|
|
|
|
u32 type;
|
|
|
|
u32 mask;
|
|
|
|
};
|
|
|
|
|
2007-08-29 05:27:26 -06:00
|
|
|
struct crypto_attr_u32 {
|
|
|
|
u32 num;
|
|
|
|
};
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Transform user interface.
|
|
|
|
*/
|
|
|
|
|
2006-07-29 19:53:01 -06:00
|
|
|
struct crypto_tfm *crypto_alloc_base(const char *alg_name, u32 type, u32 mask);
|
2009-02-04 22:48:24 -07:00
|
|
|
void crypto_destroy_tfm(void *mem, struct crypto_tfm *tfm);
|
|
|
|
|
|
|
|
static inline void crypto_free_tfm(struct crypto_tfm *tfm)
|
|
|
|
{
|
|
|
|
return crypto_destroy_tfm(tfm, tfm);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-07-31 03:08:25 -06:00
|
|
|
int alg_test(const char *driver, const char *alg, u32 type, u32 mask);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Transform helpers which query the underlying algorithm.
|
|
|
|
*/
|
|
|
|
static inline const char *crypto_tfm_alg_name(struct crypto_tfm *tfm)
|
|
|
|
{
|
|
|
|
return tfm->__crt_alg->cra_name;
|
|
|
|
}
|
|
|
|
|
2006-07-08 17:02:24 -06:00
|
|
|
static inline const char *crypto_tfm_alg_driver_name(struct crypto_tfm *tfm)
|
|
|
|
{
|
|
|
|
return tfm->__crt_alg->cra_driver_name;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int crypto_tfm_alg_priority(struct crypto_tfm *tfm)
|
|
|
|
{
|
|
|
|
return tfm->__crt_alg->cra_priority;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static inline u32 crypto_tfm_alg_type(struct crypto_tfm *tfm)
|
|
|
|
{
|
|
|
|
return tfm->__crt_alg->cra_flags & CRYPTO_ALG_TYPE_MASK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned int crypto_tfm_alg_blocksize(struct crypto_tfm *tfm)
|
|
|
|
{
|
|
|
|
return tfm->__crt_alg->cra_blocksize;
|
|
|
|
}
|
|
|
|
|
2005-07-06 14:53:29 -06:00
|
|
|
static inline unsigned int crypto_tfm_alg_alignmask(struct crypto_tfm *tfm)
|
|
|
|
{
|
|
|
|
return tfm->__crt_alg->cra_alignmask;
|
|
|
|
}
|
|
|
|
|
2006-08-13 04:58:18 -06:00
|
|
|
static inline u32 crypto_tfm_get_flags(struct crypto_tfm *tfm)
|
|
|
|
{
|
|
|
|
return tfm->crt_flags;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void crypto_tfm_set_flags(struct crypto_tfm *tfm, u32 flags)
|
|
|
|
{
|
|
|
|
tfm->crt_flags |= flags;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void crypto_tfm_clear_flags(struct crypto_tfm *tfm, u32 flags)
|
|
|
|
{
|
|
|
|
tfm->crt_flags &= ~flags;
|
|
|
|
}
|
|
|
|
|
2005-07-06 14:51:52 -06:00
|
|
|
static inline void *crypto_tfm_ctx(struct crypto_tfm *tfm)
|
|
|
|
{
|
2006-01-25 04:34:01 -07:00
|
|
|
return tfm->__crt_ctx;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned int crypto_tfm_ctx_alignment(void)
|
|
|
|
{
|
|
|
|
struct crypto_tfm *tfm;
|
|
|
|
return __alignof__(tfm->__crt_ctx);
|
2005-07-06 14:51:52 -06:00
|
|
|
}
|
|
|
|
|
2014-11-11 21:30:06 -07:00
|
|
|
/**
|
|
|
|
* DOC: Single Block Cipher API
|
|
|
|
*
|
|
|
|
* The single block cipher API is used with the ciphers of type
|
|
|
|
* CRYPTO_ALG_TYPE_CIPHER (listed as type "cipher" in /proc/crypto).
|
|
|
|
*
|
|
|
|
* Using the single block cipher API calls, operations with the basic cipher
|
|
|
|
* primitive can be implemented. These cipher primitives exclude any block
|
|
|
|
* chaining operations including IV handling.
|
|
|
|
*
|
|
|
|
* The purpose of this single block cipher API is to support the implementation
|
|
|
|
* of templates or other concepts that only need to perform the cipher operation
|
|
|
|
* on one block at a time. Templates invoke the underlying cipher primitive
|
|
|
|
* block-wise and process either the input or the output data of these cipher
|
|
|
|
* operations.
|
|
|
|
*/
|
|
|
|
|
2006-08-13 04:58:18 -06:00
|
|
|
static inline struct crypto_cipher *__crypto_cipher_cast(struct crypto_tfm *tfm)
|
|
|
|
{
|
|
|
|
return (struct crypto_cipher *)tfm;
|
|
|
|
}
|
|
|
|
|
2014-11-11 21:30:06 -07:00
|
|
|
/**
|
|
|
|
* crypto_alloc_cipher() - allocate single block cipher handle
|
|
|
|
* @alg_name: is the cra_name / name or cra_driver_name / driver name of the
|
|
|
|
* single block cipher
|
|
|
|
* @type: specifies the type of the cipher
|
|
|
|
* @mask: specifies the mask for the cipher
|
|
|
|
*
|
|
|
|
* Allocate a cipher handle for a single block cipher. The returned struct
|
|
|
|
* crypto_cipher is the cipher handle that is required for any subsequent API
|
|
|
|
* invocation for that single block cipher.
|
|
|
|
*
|
|
|
|
* Return: allocated cipher handle in case of success; IS_ERR() is true in case
|
|
|
|
* of an error, PTR_ERR() returns the error code.
|
|
|
|
*/
|
2006-08-13 04:58:18 -06:00
|
|
|
static inline struct crypto_cipher *crypto_alloc_cipher(const char *alg_name,
|
|
|
|
u32 type, u32 mask)
|
|
|
|
{
|
|
|
|
type &= ~CRYPTO_ALG_TYPE_MASK;
|
|
|
|
type |= CRYPTO_ALG_TYPE_CIPHER;
|
|
|
|
mask |= CRYPTO_ALG_TYPE_MASK;
|
|
|
|
|
|
|
|
return __crypto_cipher_cast(crypto_alloc_base(alg_name, type, mask));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct crypto_tfm *crypto_cipher_tfm(struct crypto_cipher *tfm)
|
|
|
|
{
|
2006-12-23 16:02:00 -07:00
|
|
|
return &tfm->base;
|
2006-08-13 04:58:18 -06:00
|
|
|
}
|
|
|
|
|
2014-11-11 21:30:06 -07:00
|
|
|
/**
|
|
|
|
* crypto_free_cipher() - zeroize and free the single block cipher handle
|
|
|
|
* @tfm: cipher handle to be freed
|
|
|
|
*/
|
2006-08-13 04:58:18 -06:00
|
|
|
static inline void crypto_free_cipher(struct crypto_cipher *tfm)
|
|
|
|
{
|
|
|
|
crypto_free_tfm(crypto_cipher_tfm(tfm));
|
|
|
|
}
|
|
|
|
|
2014-11-11 21:30:06 -07:00
|
|
|
/**
|
|
|
|
* crypto_has_cipher() - Search for the availability of a single block cipher
|
|
|
|
* @alg_name: is the cra_name / name or cra_driver_name / driver name of the
|
|
|
|
* single block cipher
|
|
|
|
* @type: specifies the type of the cipher
|
|
|
|
* @mask: specifies the mask for the cipher
|
|
|
|
*
|
|
|
|
* Return: true when the single block cipher is known to the kernel crypto API;
|
|
|
|
* false otherwise
|
|
|
|
*/
|
2006-08-26 01:35:45 -06:00
|
|
|
static inline int crypto_has_cipher(const char *alg_name, u32 type, u32 mask)
|
|
|
|
{
|
|
|
|
type &= ~CRYPTO_ALG_TYPE_MASK;
|
|
|
|
type |= CRYPTO_ALG_TYPE_CIPHER;
|
|
|
|
mask |= CRYPTO_ALG_TYPE_MASK;
|
|
|
|
|
|
|
|
return crypto_has_alg(alg_name, type, mask);
|
|
|
|
}
|
|
|
|
|
2014-11-11 21:30:06 -07:00
|
|
|
/**
|
|
|
|
* crypto_cipher_blocksize() - obtain block size for cipher
|
|
|
|
* @tfm: cipher handle
|
|
|
|
*
|
|
|
|
* The block size for the single block cipher referenced with the cipher handle
|
|
|
|
* tfm is returned. The caller may use that information to allocate appropriate
|
|
|
|
* memory for the data returned by the encryption or decryption operation
|
|
|
|
*
|
|
|
|
* Return: block size of cipher
|
|
|
|
*/
|
2006-08-13 04:58:18 -06:00
|
|
|
static inline unsigned int crypto_cipher_blocksize(struct crypto_cipher *tfm)
|
|
|
|
{
|
|
|
|
return crypto_tfm_alg_blocksize(crypto_cipher_tfm(tfm));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned int crypto_cipher_alignmask(struct crypto_cipher *tfm)
|
|
|
|
{
|
|
|
|
return crypto_tfm_alg_alignmask(crypto_cipher_tfm(tfm));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u32 crypto_cipher_get_flags(struct crypto_cipher *tfm)
|
|
|
|
{
|
|
|
|
return crypto_tfm_get_flags(crypto_cipher_tfm(tfm));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void crypto_cipher_set_flags(struct crypto_cipher *tfm,
|
|
|
|
u32 flags)
|
|
|
|
{
|
|
|
|
crypto_tfm_set_flags(crypto_cipher_tfm(tfm), flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void crypto_cipher_clear_flags(struct crypto_cipher *tfm,
|
|
|
|
u32 flags)
|
|
|
|
{
|
|
|
|
crypto_tfm_clear_flags(crypto_cipher_tfm(tfm), flags);
|
|
|
|
}
|
|
|
|
|
2014-11-11 21:30:06 -07:00
|
|
|
/**
|
|
|
|
* crypto_cipher_setkey() - set key for cipher
|
|
|
|
* @tfm: cipher handle
|
|
|
|
* @key: buffer holding the key
|
|
|
|
* @keylen: length of the key in bytes
|
|
|
|
*
|
|
|
|
* The caller provided key is set for the single block cipher referenced by the
|
|
|
|
* cipher handle.
|
|
|
|
*
|
|
|
|
* Note, the key length determines the cipher type. Many block ciphers implement
|
|
|
|
* different cipher modes depending on the key size, such as AES-128 vs AES-192
|
|
|
|
* vs. AES-256. When providing a 16 byte key for an AES cipher handle, AES-128
|
|
|
|
* is performed.
|
|
|
|
*
|
|
|
|
* Return: 0 if the setting of the key was successful; < 0 if an error occurred
|
|
|
|
*/
|
crypto: cipher - remove crt_u.cipher (struct cipher_tfm)
Of the three fields in crt_u.cipher (struct cipher_tfm), ->cit_setkey()
is pointless because it always points to setkey() in crypto/cipher.c.
->cit_decrypt_one() and ->cit_encrypt_one() are slightly less pointless,
since if the algorithm doesn't have an alignmask, they are set directly
to ->cia_encrypt() and ->cia_decrypt(). However, this "optimization"
isn't worthwhile because:
- The "cipher" algorithm type is the only algorithm still using crt_u,
so it's bloating every struct crypto_tfm for every algorithm type.
- If the algorithm has an alignmask, this "optimization" actually makes
things slower, as it causes 2 indirect calls per block rather than 1.
- It adds extra code complexity.
- Some templates already call ->cia_encrypt()/->cia_decrypt() directly
instead of going through ->cit_encrypt_one()/->cit_decrypt_one().
- The "cipher" algorithm type never gives optimal performance anyway.
For that, a higher-level type such as skcipher needs to be used.
Therefore, just remove the extra indirection, and make
crypto_cipher_setkey(), crypto_cipher_encrypt_one(), and
crypto_cipher_decrypt_one() be direct calls into crypto/cipher.c.
Also remove the unused function crypto_cipher_cast().
Signed-off-by: Eric Biggers <ebiggers@google.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2019-12-02 14:42:30 -07:00
|
|
|
int crypto_cipher_setkey(struct crypto_cipher *tfm,
|
|
|
|
const u8 *key, unsigned int keylen);
|
2006-08-21 05:40:49 -06:00
|
|
|
|
2014-11-11 21:30:06 -07:00
|
|
|
/**
|
|
|
|
* crypto_cipher_encrypt_one() - encrypt one block of plaintext
|
|
|
|
* @tfm: cipher handle
|
|
|
|
* @dst: points to the buffer that will be filled with the ciphertext
|
|
|
|
* @src: buffer holding the plaintext to be encrypted
|
|
|
|
*
|
|
|
|
* Invoke the encryption operation of one block. The caller must ensure that
|
|
|
|
* the plaintext and ciphertext buffers are at least one block in size.
|
|
|
|
*/
|
crypto: cipher - remove crt_u.cipher (struct cipher_tfm)
Of the three fields in crt_u.cipher (struct cipher_tfm), ->cit_setkey()
is pointless because it always points to setkey() in crypto/cipher.c.
->cit_decrypt_one() and ->cit_encrypt_one() are slightly less pointless,
since if the algorithm doesn't have an alignmask, they are set directly
to ->cia_encrypt() and ->cia_decrypt(). However, this "optimization"
isn't worthwhile because:
- The "cipher" algorithm type is the only algorithm still using crt_u,
so it's bloating every struct crypto_tfm for every algorithm type.
- If the algorithm has an alignmask, this "optimization" actually makes
things slower, as it causes 2 indirect calls per block rather than 1.
- It adds extra code complexity.
- Some templates already call ->cia_encrypt()/->cia_decrypt() directly
instead of going through ->cit_encrypt_one()/->cit_decrypt_one().
- The "cipher" algorithm type never gives optimal performance anyway.
For that, a higher-level type such as skcipher needs to be used.
Therefore, just remove the extra indirection, and make
crypto_cipher_setkey(), crypto_cipher_encrypt_one(), and
crypto_cipher_decrypt_one() be direct calls into crypto/cipher.c.
Also remove the unused function crypto_cipher_cast().
Signed-off-by: Eric Biggers <ebiggers@google.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2019-12-02 14:42:30 -07:00
|
|
|
void crypto_cipher_encrypt_one(struct crypto_cipher *tfm,
|
|
|
|
u8 *dst, const u8 *src);
|
2006-08-13 04:58:18 -06:00
|
|
|
|
2014-11-11 21:30:06 -07:00
|
|
|
/**
|
|
|
|
* crypto_cipher_decrypt_one() - decrypt one block of ciphertext
|
|
|
|
* @tfm: cipher handle
|
|
|
|
* @dst: points to the buffer that will be filled with the plaintext
|
|
|
|
* @src: buffer holding the ciphertext to be decrypted
|
|
|
|
*
|
|
|
|
* Invoke the decryption operation of one block. The caller must ensure that
|
|
|
|
* the plaintext and ciphertext buffers are at least one block in size.
|
|
|
|
*/
|
crypto: cipher - remove crt_u.cipher (struct cipher_tfm)
Of the three fields in crt_u.cipher (struct cipher_tfm), ->cit_setkey()
is pointless because it always points to setkey() in crypto/cipher.c.
->cit_decrypt_one() and ->cit_encrypt_one() are slightly less pointless,
since if the algorithm doesn't have an alignmask, they are set directly
to ->cia_encrypt() and ->cia_decrypt(). However, this "optimization"
isn't worthwhile because:
- The "cipher" algorithm type is the only algorithm still using crt_u,
so it's bloating every struct crypto_tfm for every algorithm type.
- If the algorithm has an alignmask, this "optimization" actually makes
things slower, as it causes 2 indirect calls per block rather than 1.
- It adds extra code complexity.
- Some templates already call ->cia_encrypt()/->cia_decrypt() directly
instead of going through ->cit_encrypt_one()/->cit_decrypt_one().
- The "cipher" algorithm type never gives optimal performance anyway.
For that, a higher-level type such as skcipher needs to be used.
Therefore, just remove the extra indirection, and make
crypto_cipher_setkey(), crypto_cipher_encrypt_one(), and
crypto_cipher_decrypt_one() be direct calls into crypto/cipher.c.
Also remove the unused function crypto_cipher_cast().
Signed-off-by: Eric Biggers <ebiggers@google.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2019-12-02 14:42:30 -07:00
|
|
|
void crypto_cipher_decrypt_one(struct crypto_cipher *tfm,
|
|
|
|
u8 *dst, const u8 *src);
|
2006-08-13 04:58:18 -06:00
|
|
|
|
2006-08-26 01:35:45 -06:00
|
|
|
static inline struct crypto_comp *__crypto_comp_cast(struct crypto_tfm *tfm)
|
|
|
|
{
|
|
|
|
return (struct crypto_comp *)tfm;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct crypto_comp *crypto_alloc_comp(const char *alg_name,
|
|
|
|
u32 type, u32 mask)
|
|
|
|
{
|
|
|
|
type &= ~CRYPTO_ALG_TYPE_MASK;
|
|
|
|
type |= CRYPTO_ALG_TYPE_COMPRESS;
|
|
|
|
mask |= CRYPTO_ALG_TYPE_MASK;
|
|
|
|
|
|
|
|
return __crypto_comp_cast(crypto_alloc_base(alg_name, type, mask));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct crypto_tfm *crypto_comp_tfm(struct crypto_comp *tfm)
|
|
|
|
{
|
2006-12-23 16:02:00 -07:00
|
|
|
return &tfm->base;
|
2006-08-26 01:35:45 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void crypto_free_comp(struct crypto_comp *tfm)
|
|
|
|
{
|
|
|
|
crypto_free_tfm(crypto_comp_tfm(tfm));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int crypto_has_comp(const char *alg_name, u32 type, u32 mask)
|
|
|
|
{
|
|
|
|
type &= ~CRYPTO_ALG_TYPE_MASK;
|
|
|
|
type |= CRYPTO_ALG_TYPE_COMPRESS;
|
|
|
|
mask |= CRYPTO_ALG_TYPE_MASK;
|
|
|
|
|
|
|
|
return crypto_has_alg(alg_name, type, mask);
|
|
|
|
}
|
|
|
|
|
2006-08-26 02:12:40 -06:00
|
|
|
static inline const char *crypto_comp_name(struct crypto_comp *tfm)
|
|
|
|
{
|
|
|
|
return crypto_tfm_alg_name(crypto_comp_tfm(tfm));
|
|
|
|
}
|
|
|
|
|
2019-12-02 14:42:29 -07:00
|
|
|
int crypto_comp_compress(struct crypto_comp *tfm,
|
|
|
|
const u8 *src, unsigned int slen,
|
|
|
|
u8 *dst, unsigned int *dlen);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2019-12-02 14:42:29 -07:00
|
|
|
int crypto_comp_decompress(struct crypto_comp *tfm,
|
|
|
|
const u8 *src, unsigned int slen,
|
|
|
|
u8 *dst, unsigned int *dlen);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#endif /* _LINUX_CRYPTO_H */
|
|
|
|
|