crypto: add CRYPTO_ALG_ALLOCATES_MEMORY
Subsystems (19)
v2 cover crypto: add CRYPTO_ALG_ALLOCATES_MEMORY
This series introduces a flag that algorithms can set to indicate that they allocate memory during processing of typical inputs, and thus shouldn't be used in cases like dm-crypt where memory allocation failures aren't acceptable.
Compared to Mikulas's patches, I've made the following improvements:
- Tried to clearly document the semantics of CRYPTO_ALG_ALLOCATES_MEMORY. This includes documenting the usage constraints, since there are actually lots of cases that were overlooked where algorithms can still allocate memory in some edge cases where inputs are misaligned, fragemented, etc. E.g. see crypto/skcipher.c and crypto/ahash.c. Mikulas, please let me know if there are any concerns for dm-crypt.
- Moved the common mechanism for inheriting flags to its own patch.
- crypto_grab_spawn() now handles propagating CRYPTO_ALG_INHERITED_FLAGS to the new template instance.
- Inherit the flags in various places that were missed.
- Other cleanups.
Additional changes v1 => v2:
- Made crypto_check_attr_type() return the mask.
- Added patch that adds NEED_FALLBACK to INHERITED_FLAGS.
- Added patch that removes seqiv_create().
Eric Biggers (5):
crypto: geniv - remove unneeded arguments from aead_geniv_alloc()
crypto: seqiv - remove seqiv_create()
crypto: algapi - use common mechanism for inheriting flags
crypto: algapi - add NEED_FALLBACK to INHERITED_FLAGS
crypto: algapi - introduce the flag CRYPTO_ALG_ALLOCATES_MEMORY
Mikulas Patocka (2):
crypto: drivers - set the flag CRYPTO_ALG_ALLOCATES_MEMORY
dm-crypt: don't use drivers that have CRYPTO_ALG_ALLOCATES_MEMORY
crypto/adiantum.c | 14 +-- crypto/algapi.c | 21 +++- crypto/authenc.c | 14 +-- crypto/authencesn.c | 14 +-- crypto/ccm.c | 33 ++--- crypto/chacha20poly1305.c | 14 +-- crypto/cmac.c | 5 +- crypto/cryptd.c | 59 ++++----- crypto/ctr.c | 17 +-- crypto/cts.c | 13 +- crypto/echainiv.c | 2 +- crypto/essiv.c | 11 +- crypto/gcm.c | 40 ++---- crypto/geniv.c | 19 +-- crypto/hmac.c | 5 +- crypto/lrw.c | 13 +- crypto/pcrypt.c | 14 +-- crypto/rsa-pkcs1pad.c | 13 +- crypto/seqiv.c | 18 +-- crypto/simd.c | 6 +- crypto/skcipher.c | 13 +- crypto/vmac.c | 5 +- crypto/xcbc.c | 5 +- crypto/xts.c | 15 +-- .../crypto/allwinner/sun8i-ce/sun8i-ce-core.c | 12 +- .../crypto/allwinner/sun8i-ss/sun8i-ss-core.c | 12 +- drivers/crypto/amlogic/amlogic-gxl-core.c | 6 +- drivers/crypto/axis/artpec6_crypto.c | 20 ++- drivers/crypto/bcm/cipher.c | 72 ++++++++--- drivers/crypto/caam/caamalg.c | 6 +- drivers/crypto/caam/caamalg_qi.c | 6 +- drivers/crypto/caam/caamalg_qi2.c | 8 +- drivers/crypto/caam/caamhash.c | 2 +- drivers/crypto/cavium/cpt/cptvf_algs.c | 18 ++- drivers/crypto/cavium/nitrox/nitrox_aead.c | 4 +- .../crypto/cavium/nitrox/nitrox_skcipher.c | 16 +-- drivers/crypto/ccp/ccp-crypto-aes-cmac.c | 1 + drivers/crypto/ccp/ccp-crypto-aes-galois.c | 1 + drivers/crypto/ccp/ccp-crypto-aes-xts.c | 1 + drivers/crypto/ccp/ccp-crypto-aes.c | 2 + drivers/crypto/ccp/ccp-crypto-des3.c | 1 + drivers/crypto/ccp/ccp-crypto-sha.c | 1 + drivers/crypto/chelsio/chcr_algo.c | 7 +- drivers/crypto/hisilicon/sec/sec_algs.c | 24 ++-- drivers/crypto/hisilicon/sec2/sec_crypto.c | 4 +- .../crypto/inside-secure/safexcel_cipher.c | 47 +++++++ drivers/crypto/inside-secure/safexcel_hash.c | 18 +++ drivers/crypto/ixp4xx_crypto.c | 6 +- drivers/crypto/marvell/cesa/cipher.c | 18 ++- drivers/crypto/marvell/cesa/hash.c | 6 + .../crypto/marvell/octeontx/otx_cptvf_algs.c | 30 ++--- drivers/crypto/n2_core.c | 3 +- drivers/crypto/picoxcell_crypto.c | 17 ++- drivers/crypto/qat/qat_common/qat_algs.c | 13 +- drivers/crypto/qce/skcipher.c | 1 + drivers/crypto/talitos.c | 117 ++++++++++++------ drivers/crypto/virtio/virtio_crypto_algs.c | 3 +- drivers/crypto/xilinx/zynqmp-aes-gcm.c | 1 + drivers/md/dm-crypt.c | 17 ++- include/crypto/algapi.h | 25 ++-- include/crypto/internal/geniv.h | 2 +- include/linux/crypto.h | 36 +++++- 62 files changed, 562 insertions(+), 405 deletions(-)
base-commit: 3d2df84548ed88dc3344392d4e5afb8884d05360
Signature · 1 line
2.27.0
PATCH v2 1/7 crypto: geniv - remove unneeded arguments from aead_geniv_alloc()
From: Eric Biggers <[email protected]>
The type and mask arguments to aead_geniv_alloc() are always 0, so remove them.
--- crypto/echainiv.c | 2 +- crypto/geniv.c | 7 ++++--- crypto/seqiv.c | 2 +- include/crypto/internal/geniv.h | 2 +- 4 files changed, 7 insertions(+), 6 deletions(-)
crypto/echainiv.c +1 -1
@@ -115,7 +115,7 @@ static int echainiv_aead_create(struct crypto_template *tmpl,struct aead_instance *inst;int err; - inst =aead_geniv_alloc (tmpl, tb,0 ,0 ); + inst =aead_geniv_alloc (tmpl, tb);if (IS_ERR (inst))return PTR_ERR (inst);
crypto/geniv.c +4 -3
@@ -39,7 +39,7 @@ static void aead_geniv_free(struct aead_instance *inst) }struct aead_instance *aead_geniv_alloc (struct crypto_template *tmpl, -struct rtattr **tb,u32 type,u32 mask) +struct rtattr **tb) {struct crypto_aead_spawn *spawn;struct crypto_attr_type *algt;
@@ -47,6 +47,7 @@ struct aead_instance *aead_geniv_alloc(struct crypto_template *tmpl,struct aead_alg *alg;unsigned int ivsize;unsigned int maxauthsize; +u32 mask;int err; algt =crypto_get_attr_type (tb);
@@ -63,10 +64,10 @@ struct aead_instance *aead_geniv_alloc(struct crypto_template *tmpl, spawn =aead_instance_ctx (inst);/* Ignore async algorithms if necessary. */ - mask |=crypto_requires_sync (algt->type, algt->mask); + mask =crypto_requires_sync (algt->type, algt->mask); err =crypto_grab_aead (spawn,aead_crypto_instance (inst), -crypto_attr_alg_name (tb[1 ]), type, mask); +crypto_attr_alg_name (tb[1 ]),0 , mask);if (err) goto err_free_inst;
crypto/seqiv.c +1 -1
@@ -138,7 +138,7 @@ static int seqiv_aead_create(struct crypto_template *tmpl, struct rtattr **tb)struct aead_instance *inst;int err; - inst =aead_geniv_alloc (tmpl, tb,0 ,0 ); + inst =aead_geniv_alloc (tmpl, tb);if (IS_ERR (inst))return PTR_ERR (inst);
include/crypto/internal/geniv.h +1 -1
@@ -20,7 +20,7 @@ struct aead_geniv_ctx { };struct aead_instance *aead_geniv_alloc (struct crypto_template *tmpl, -struct rtattr **tb,u32 type,u32 mask); +struct rtattr **tb);int aead_init_geniv (struct crypto_aead *tfm);void aead_exit_geniv (struct crypto_aead *tfm);
Signature · 1 line
2.27.0
PATCH v2 2/7 crypto: seqiv - remove seqiv_create()
In reply to Eric BiggersFrom: Eric Biggers <[email protected]>
seqiv_create() is pointless because it just checks that the template is being instantiated as an AEAD, then calls seqiv_aead_create(). But seqiv_aead_create() does the exact same check, via aead_geniv_alloc().
Just remove seqiv_create() and use seqiv_aead_create() directly.
--- crypto/seqiv.c | 16 +--------------- 1 file changed, 1 insertion(+), 15 deletions(-)
crypto/seqiv.c +1 -15
@@ -164,23 +164,9 @@ static int seqiv_aead_create(struct crypto_template *tmpl, struct rtattr **tb)return err; } -static int seqiv_create (struct crypto_template *tmpl,struct rtattr **tb) -{ -struct crypto_attr_type *algt; - - algt =crypto_get_attr_type (tb); -if (IS_ERR (algt)) -return PTR_ERR (algt); - -if ((algt->type ^CRYPTO_ALG_TYPE_AEAD ) &CRYPTO_ALG_TYPE_MASK ) -return -EINVAL ; - -return seqiv_aead_create (tmpl, tb); -} -static struct crypto_template seqiv_tmpl = { .name ="seqiv" , - .create = seqiv_create, + .create = seqiv_aead_create, .module =THIS_MODULE , };
Signature · 1 line
2.27.0
PATCH v2 3/7 crypto: algapi - use common mechanism for inheriting flags
In reply to Eric BiggersFrom: Eric Biggers <[email protected]>
The flag CRYPTO_ALG_ASYNC is "inherited" in the sense that when a template is instantiated, the template will have CRYPTO_ALG_ASYNC set if any of the algorithms it uses has CRYPTO_ALG_ASYNC set.
We'd like to add a second flag (CRYPTO_ALG_ALLOCATES_MEMORY) that gets "inherited" in the same way. This is difficult because the handling of CRYPTO_ALG_ASYNC is hardcoded everywhere. Address this by:
- Add CRYPTO_ALG_INHERITED_FLAGS, which contains the set of flags that have these inheritance semantics.
- Add crypto_algt_inherited_mask(), for use by template ->create() methods. It returns any of these flags that the user asked to be unset and thus must be passed in the 'mask' to crypto_grab_*().
- Also modify crypto_check_attr_type() to handle computing the 'mask' so that most templates can just use this.
- Make crypto_grab_*() propagate these flags to the template instance being created so that templates don't have to do this themselves.
Make crypto/simd.c propagate these flags too, since it "wraps" another algorithm, similar to a template.
Based on a patch by Mikulas Patocka <[email protected]>
(https://lore.kernel.org/r/alpine.LRH.2.02.2006301414580.30526@file01.intranet.prod.int.rdu2.redhat.com).
--- crypto/adiantum.c | 14 ++-------- crypto/algapi.c | 21 +++++++++++++- crypto/authenc.c | 14 ++-------- crypto/authencesn.c | 14 ++-------- crypto/ccm.c | 33 +++++++--------------- crypto/chacha20poly1305.c | 14 ++-------- crypto/cmac.c | 5 ++-- crypto/cryptd.c | 59 ++++++++++++++++++++------------------- crypto/ctr.c | 19 ++++--------- crypto/cts.c | 13 ++------- crypto/essiv.c | 11 ++++++-- crypto/gcm.c | 40 ++++++-------------------- crypto/geniv.c | 14 ++-------- crypto/hmac.c | 5 ++-- crypto/lrw.c | 13 ++------- crypto/pcrypt.c | 14 ++++------ crypto/rsa-pkcs1pad.c | 13 ++------- crypto/simd.c | 6 ++-- crypto/skcipher.c | 15 ++++------ crypto/vmac.c | 5 ++-- crypto/xcbc.c | 5 ++-- crypto/xts.c | 17 ++++------- include/crypto/algapi.h | 23 ++++++++++----- 23 files changed, 153 insertions(+), 234 deletions(-)
crypto/adiantum.c +3 -11
@@ -490,7 +490,6 @@ static bool adiantum_supported_algorithms(struct skcipher_alg *streamcipher_alg,static int adiantum_create (struct crypto_template *tmpl,struct rtattr **tb) { -struct crypto_attr_type *algt;u32 mask;const char *nhpoly1305_name;struct skcipher_instance *inst;
@@ -500,14 +499,9 @@ static int adiantum_create(struct crypto_template *tmpl, struct rtattr **tb)struct shash_alg *hash_alg;int err; - algt =crypto_get_attr_type (tb); -if (IS_ERR (algt)) -return PTR_ERR (algt); - -if ((algt->type ^CRYPTO_ALG_TYPE_SKCIPHER ) & algt->mask) -return -EINVAL ; - - mask =crypto_requires_sync (algt->type, algt->mask); + err =crypto_check_attr_type (tb,CRYPTO_ALG_TYPE_SKCIPHER , &mask); +if (err) +return err; inst =kzalloc (sizeof (*inst) +sizeof (*ictx),GFP_KERNEL );if (!inst)
@@ -565,8 +559,6 @@ static int adiantum_create(struct crypto_template *tmpl, struct rtattr **tb) hash_alg->base.cra_driver_name) >= CRYPTO_MAX_ALG_NAME) goto err_free_inst; - inst->alg.base.cra_flags = streamcipher_alg->base.cra_flags & -CRYPTO_ALG_ASYNC ; inst->alg.base.cra_blocksize =BLOCKCIPHER_BLOCK_SIZE ; inst->alg.base.cra_ctxsize =sizeof (struct adiantum_tfm_ctx ); inst->alg.base.cra_alignmask = streamcipher_alg->base.cra_alignmask |
crypto/algapi.c +20 -1
@@ -690,6 +690,8 @@ int crypto_grab_spawn(struct crypto_spawn *spawn, struct crypto_instance *inst, spawn->mask = mask; spawn->next = inst->spawns; inst->spawns = spawn; + inst->alg.cra_flags |= + (alg->cra_flags &CRYPTO_ALG_INHERITED_FLAGS ); err =0 ; }up_write (&crypto_alg_sem);
@@ -816,7 +818,23 @@ struct crypto_attr_type *crypto_get_attr_type(struct rtattr **tb) }EXPORT_SYMBOL_GPL (crypto_get_attr_type); -int crypto_check_attr_type (struct rtattr **tb,u32 type) +/** +* crypto_check_attr_type() - check algorithm type and compute inherited mask +* @tb: the template parameters +* @type: the algorithm type the template would be instantiated as +* @mask_ret: (output) the mask that should be passed to crypto_grab_*() +* to restrict the flags of any inner algorithms +* +* Validate that the algorithm type the user requested is compatible with the +* one the template would actually be instantiated as. E.g., if the user is +* doing crypto_alloc_shash("cbc(aes)", ...), this would return an error because +* the "cbc" template creates an "skcipher" algorithm, not an "shash" algorithm. +* +* Also compute the mask to use to restrict the flags of any inner algorithms. +* +* Return: 0 on success; -errno on failure +*/ +int crypto_check_attr_type (struct rtattr **tb,u32 type,u32 *mask_ret) {struct crypto_attr_type *algt;
@@ -827,6 +845,7 @@ int crypto_check_attr_type(struct rtattr **tb, u32 type)if ((algt->type ^ type) & algt->mask)return -EINVAL ; + *mask_ret =crypto_algt_inherited_mask (algt);return 0 ; }EXPORT_SYMBOL_GPL (crypto_check_attr_type);
crypto/authenc.c +3 -11
@@ -372,7 +372,6 @@ static void crypto_authenc_free(struct aead_instance *inst)static int crypto_authenc_create (struct crypto_template *tmpl,struct rtattr **tb) { -struct crypto_attr_type *algt;u32 mask;struct aead_instance *inst;struct authenc_instance_ctx *ctx;
@@ -381,14 +380,9 @@ static int crypto_authenc_create(struct crypto_template *tmpl,struct skcipher_alg *enc;int err; - algt =crypto_get_attr_type (tb); -if (IS_ERR (algt)) -return PTR_ERR (algt); - -if ((algt->type ^CRYPTO_ALG_TYPE_AEAD ) & algt->mask) -return -EINVAL ; - - mask =crypto_requires_sync (algt->type, algt->mask); + err =crypto_check_attr_type (tb,CRYPTO_ALG_TYPE_AEAD , &mask); +if (err) +return err; inst =kzalloc (sizeof (*inst) +sizeof (*ctx),GFP_KERNEL );if (!inst)
@@ -423,8 +417,6 @@ static int crypto_authenc_create(struct crypto_template *tmpl, enc->base.cra_driver_name) >= CRYPTO_MAX_ALG_NAME) goto err_free_inst; - inst->alg.base.cra_flags = (auth_base->cra_flags | - enc->base.cra_flags) &CRYPTO_ALG_ASYNC ; inst->alg.base.cra_priority = enc->base.cra_priority *10 + auth_base->cra_priority; inst->alg.base.cra_blocksize = enc->base.cra_blocksize;
crypto/authencesn.c +3 -11
@@ -390,7 +390,6 @@ static void crypto_authenc_esn_free(struct aead_instance *inst)static int crypto_authenc_esn_create (struct crypto_template *tmpl,struct rtattr **tb) { -struct crypto_attr_type *algt;u32 mask;struct aead_instance *inst;struct authenc_esn_instance_ctx *ctx;
@@ -399,14 +398,9 @@ static int crypto_authenc_esn_create(struct crypto_template *tmpl,struct skcipher_alg *enc;int err; - algt =crypto_get_attr_type (tb); -if (IS_ERR (algt)) -return PTR_ERR (algt); - -if ((algt->type ^CRYPTO_ALG_TYPE_AEAD ) & algt->mask) -return -EINVAL ; - - mask =crypto_requires_sync (algt->type, algt->mask); + err =crypto_check_attr_type (tb,CRYPTO_ALG_TYPE_AEAD , &mask); +if (err) +return err; inst =kzalloc (sizeof (*inst) +sizeof (*ctx),GFP_KERNEL );if (!inst)
@@ -437,8 +431,6 @@ static int crypto_authenc_esn_create(struct crypto_template *tmpl, enc->base.cra_driver_name) >= CRYPTO_MAX_ALG_NAME) goto err_free_inst; - inst->alg.base.cra_flags = (auth_base->cra_flags | - enc->base.cra_flags) &CRYPTO_ALG_ASYNC ; inst->alg.base.cra_priority = enc->base.cra_priority *10 + auth_base->cra_priority; inst->alg.base.cra_blocksize = enc->base.cra_blocksize;
crypto/ccm.c +10 -23
@@ -447,7 +447,6 @@ static int crypto_ccm_create_common(struct crypto_template *tmpl,const char *ctr_name, const char *mac_name) { - struct crypto_attr_type *algt; u32 mask;struct aead_instance *inst;struct ccm_instance_ctx *ictx;
@@ -455,14 +454,9 @@ static int crypto_ccm_create_common(struct crypto_template *tmpl,struct hash_alg_common *mac;int err; - algt =crypto_get_attr_type (tb); -if (IS_ERR (algt)) -return PTR_ERR (algt); - -if ((algt->type ^CRYPTO_ALG_TYPE_AEAD ) & algt->mask) -return -EINVAL ; - - mask =crypto_requires_sync (algt->type, algt->mask); + err =crypto_check_attr_type (tb,CRYPTO_ALG_TYPE_AEAD , &mask); +if (err) +return err; inst =kzalloc (sizeof (*inst) +sizeof (*ictx),GFP_KERNEL );if (!inst)
@@ -470,7 +464,7 @@ static int crypto_ccm_create_common(struct crypto_template *tmpl, ictx =aead_instance_ctx (inst); err =crypto_grab_ahash (&ictx->mac,aead_crypto_instance (inst), - mac_name,0 ,CRYPTO_ALG_ASYNC ); + mac_name,0 , mask |CRYPTO_ALG_ASYNC );if (err) goto err_free_inst; mac =crypto_spawn_ahash_alg (&ictx->mac);
@@ -507,7 +501,6 @@ static int crypto_ccm_create_common(struct crypto_template *tmpl, mac->base.cra_driver_name) >= CRYPTO_MAX_ALG_NAME) goto err_free_inst; - inst->alg.base.cra_flags = ctr->base.cra_flags &CRYPTO_ALG_ASYNC ; inst->alg.base.cra_priority = (mac->base.cra_priority + ctr->base.cra_priority) /2 ; inst->alg.base.cra_blocksize =1 ;
@@ -712,21 +705,15 @@ static void crypto_rfc4309_free(struct aead_instance *inst)static int crypto_rfc4309_create (struct crypto_template *tmpl,struct rtattr **tb) { -struct crypto_attr_type *algt;u32 mask;struct aead_instance *inst;struct crypto_aead_spawn *spawn;struct aead_alg *alg;int err; - algt =crypto_get_attr_type (tb); -if (IS_ERR (algt)) -return PTR_ERR (algt); - -if ((algt->type ^CRYPTO_ALG_TYPE_AEAD ) & algt->mask) -return -EINVAL ; - - mask =crypto_requires_sync (algt->type, algt->mask); + err =crypto_check_attr_type (tb,CRYPTO_ALG_TYPE_AEAD , &mask); +if (err) +return err; inst =kzalloc (sizeof (*inst) +sizeof (*spawn),GFP_KERNEL );if (!inst)
@@ -759,7 +746,6 @@ static int crypto_rfc4309_create(struct crypto_template *tmpl, CRYPTO_MAX_ALG_NAME) goto err_free_inst; - inst->alg.base.cra_flags = alg->base.cra_flags &CRYPTO_ALG_ASYNC ; inst->alg.base.cra_priority = alg->base.cra_priority; inst->alg.base.cra_blocksize =1 ; inst->alg.base.cra_alignmask = alg->base.cra_alignmask;
@@ -878,9 +864,10 @@ static int cbcmac_create(struct crypto_template *tmpl, struct rtattr **tb)struct shash_instance *inst;struct crypto_cipher_spawn *spawn;struct crypto_alg *alg; +u32 mask;int err; - err =crypto_check_attr_type (tb,CRYPTO_ALG_TYPE_SHASH ); + err =crypto_check_attr_type (tb,CRYPTO_ALG_TYPE_SHASH , &mask);if (err)return err;
@@ -890,7 +877,7 @@ static int cbcmac_create(struct crypto_template *tmpl, struct rtattr **tb) spawn =shash_instance_ctx (inst); err =crypto_grab_cipher (spawn,shash_crypto_instance (inst), -crypto_attr_alg_name (tb[1 ]),0 ,0 ); +crypto_attr_alg_name (tb[1 ]),0 , mask);if (err) goto err_free_inst; alg =crypto_spawn_cipher_alg (spawn);
crypto/chacha20poly1305.c +3 -11
@@ -555,7 +555,6 @@ static void chachapoly_free(struct aead_instance *inst)static int chachapoly_create (struct crypto_template *tmpl,struct rtattr **tb,const char *name,unsigned int ivsize) { -struct crypto_attr_type *algt;u32 mask;struct aead_instance *inst;struct chachapoly_instance_ctx *ctx;
@@ -566,14 +565,9 @@ static int chachapoly_create(struct crypto_template *tmpl, struct rtattr **tb,if (ivsize >CHACHAPOLY_IV_SIZE )return -EINVAL ; - algt =crypto_get_attr_type (tb); -if (IS_ERR (algt)) -return PTR_ERR (algt); - -if ((algt->type ^CRYPTO_ALG_TYPE_AEAD ) & algt->mask) -return -EINVAL ; - - mask =crypto_requires_sync (algt->type, algt->mask); + err =crypto_check_attr_type (tb,CRYPTO_ALG_TYPE_AEAD , &mask); +if (err) +return err; inst =kzalloc (sizeof (*inst) +sizeof (*ctx),GFP_KERNEL );if (!inst)
@@ -613,8 +607,6 @@ static int chachapoly_create(struct crypto_template *tmpl, struct rtattr **tb, poly->base.cra_driver_name) >= CRYPTO_MAX_ALG_NAME) goto err_free_inst; - inst->alg.base.cra_flags = (chacha->base.cra_flags | - poly->base.cra_flags) &CRYPTO_ALG_ASYNC ; inst->alg.base.cra_priority = (chacha->base.cra_priority + poly->base.cra_priority) /2 ; inst->alg.base.cra_blocksize =1 ;
crypto/cmac.c +3 -2
@@ -225,9 +225,10 @@ static int cmac_create(struct crypto_template *tmpl, struct rtattr **tb)struct crypto_cipher_spawn *spawn;struct crypto_alg *alg;unsigned long alignmask; +u32 mask;int err; - err =crypto_check_attr_type (tb,CRYPTO_ALG_TYPE_SHASH ); + err =crypto_check_attr_type (tb,CRYPTO_ALG_TYPE_SHASH , &mask);if (err)return err;
@@ -237,7 +238,7 @@ static int cmac_create(struct crypto_template *tmpl, struct rtattr **tb) spawn =shash_instance_ctx (inst); err =crypto_grab_cipher (spawn,shash_crypto_instance (inst), -crypto_attr_alg_name (tb[1 ]),0 ,0 ); +crypto_attr_alg_name (tb[1 ]),0 , mask);if (err) goto err_free_inst; alg =crypto_spawn_cipher_alg (spawn);
crypto/cryptd.c +30 -29
133 lines not on this page · raw message
crypto/ctr.c +5 -14
@@ -256,29 +256,22 @@ static void crypto_rfc3686_free(struct skcipher_instance *inst)static int crypto_rfc3686_create (struct crypto_template *tmpl,struct rtattr **tb) { -struct crypto_attr_type *algt;struct skcipher_instance *inst;struct skcipher_alg *alg;struct crypto_skcipher_spawn *spawn;u32 mask; -int err; - algt =crypto_get_attr_type (tb); -if (IS_ERR (algt)) -return PTR_ERR (algt); - -if ((algt->type ^CRYPTO_ALG_TYPE_SKCIPHER ) & algt->mask) -return -EINVAL ; + err =crypto_check_attr_type (tb,CRYPTO_ALG_TYPE_SKCIPHER , &mask); +if (err) +return err; + mask |=crypto_requires_off (crypto_get_attr_type (tb), +CRYPTO_ALG_NEED_FALLBACK ); inst =kzalloc (sizeof (*inst) +sizeof (*spawn),GFP_KERNEL );if (!inst)return -ENOMEM ; - mask =crypto_requires_sync (algt->type, algt->mask) | -crypto_requires_off (algt->type, algt->mask, -CRYPTO_ALG_NEED_FALLBACK ); - spawn =skcipher_instance_ctx (inst); err = crypto_grab_skcipher(spawn, skcipher_crypto_instance(inst),
@@ -310,8 +303,6 @@ static int crypto_rfc3686_create(struct crypto_template *tmpl, inst->alg.base.cra_blocksize =1 ; inst->alg.base.cra_alignmask = alg->base.cra_alignmask; - inst->alg.base.cra_flags = alg->base.cra_flags &CRYPTO_ALG_ASYNC ; - inst->alg.ivsize =CTR_RFC3686_IV_SIZE ; inst->alg.chunksize =crypto_skcipher_alg_chunksize (alg); inst->alg.min_keysize = crypto_skcipher_alg_min_keysize(alg) +
crypto/cts.c +3 -10
@@ -325,19 +325,13 @@ static int crypto_cts_create(struct crypto_template *tmpl, struct rtattr **tb) {struct crypto_skcipher_spawn *spawn;struct skcipher_instance *inst; -struct crypto_attr_type *algt;struct skcipher_alg *alg;u32 mask;int err; - algt =crypto_get_attr_type (tb); -if (IS_ERR (algt)) -return PTR_ERR (algt); - -if ((algt->type ^CRYPTO_ALG_TYPE_SKCIPHER ) & algt->mask) -return -EINVAL ; - - mask =crypto_requires_sync (algt->type, algt->mask); + err =crypto_check_attr_type (tb,CRYPTO_ALG_TYPE_SKCIPHER , &mask); +if (err) +return err; inst =kzalloc (sizeof (*inst) +sizeof (*spawn),GFP_KERNEL );if (!inst)
@@ -364,7 +358,6 @@ static int crypto_cts_create(struct crypto_template *tmpl, struct rtattr **tb)if (err) goto err_free_inst; - inst->alg.base.cra_flags = alg->base.cra_flags &CRYPTO_ALG_ASYNC ; inst->alg.base.cra_priority = alg->base.cra_priority; inst->alg.base.cra_blocksize = alg->base.cra_blocksize; inst->alg.base.cra_alignmask = alg->base.cra_alignmask;
crypto/essiv.c +8 -3
@@ -466,7 +466,7 @@ static int essiv_create(struct crypto_template *tmpl, struct rtattr **tb)return PTR_ERR (shash_name); type = algt->type & algt->mask; - mask =crypto_requires_sync (algt->type, algt->mask); + mask =crypto_algt_inherited_mask (algt);switch (type) {case CRYPTO_ALG_TYPE_SKCIPHER :
@@ -525,7 +525,7 @@ static int essiv_create(struct crypto_template *tmpl, struct rtattr **tb)/* Synchronous hash, e.g., "sha256" */ _hash_alg =crypto_alg_mod_lookup (shash_name,CRYPTO_ALG_TYPE_SHASH , -CRYPTO_ALG_TYPE_MASK ); +CRYPTO_ALG_TYPE_MASK | mask);if (IS_ERR (_hash_alg)) { err =PTR_ERR (_hash_alg); goto out_drop_skcipher;
@@ -557,7 +557,12 @@ static int essiv_create(struct crypto_template *tmpl, struct rtattr **tb) hash_alg->base.cra_driver_name) >= CRYPTO_MAX_ALG_NAME) goto out_free_hash; - base->cra_flags = block_base->cra_flags &CRYPTO_ALG_ASYNC ; +/* +* hash_alg wasn't gotten via crypto_grab*(), so we need to inherit its +* flags manually. +*/ + base->cra_flags |= (hash_alg->base.cra_flags & +CRYPTO_ALG_INHERITED_FLAGS ); base->cra_blocksize = block_base->cra_blocksize; base->cra_ctxsize =sizeof (struct essiv_tfm_ctx ); base->cra_alignmask = block_base->cra_alignmask;
crypto/gcm.c +9 -31
@@ -578,7 +578,6 @@ static int crypto_gcm_create_common(struct crypto_template *tmpl,const char *ctr_name, const char *ghash_name) { - struct crypto_attr_type *algt; u32 mask;struct aead_instance *inst;struct gcm_instance_ctx *ctx;
@@ -586,14 +585,9 @@ static int crypto_gcm_create_common(struct crypto_template *tmpl,struct hash_alg_common *ghash;int err; - algt =crypto_get_attr_type (tb); -if (IS_ERR (algt)) -return PTR_ERR (algt); - -if ((algt->type ^CRYPTO_ALG_TYPE_AEAD ) & algt->mask) -return -EINVAL ; - - mask =crypto_requires_sync (algt->type, algt->mask); + err =crypto_check_attr_type (tb,CRYPTO_ALG_TYPE_AEAD , &mask); +if (err) +return err; inst =kzalloc (sizeof (*inst) +sizeof (*ctx),GFP_KERNEL );if (!inst)
@@ -635,8 +629,6 @@ static int crypto_gcm_create_common(struct crypto_template *tmpl, CRYPTO_MAX_ALG_NAME) goto err_free_inst; - inst->alg.base.cra_flags = (ghash->base.cra_flags | - ctr->base.cra_flags) &CRYPTO_ALG_ASYNC ; inst->alg.base.cra_priority = (ghash->base.cra_priority + ctr->base.cra_priority) /2 ; inst->alg.base.cra_blocksize =1 ;
@@ -835,21 +827,15 @@ static void crypto_rfc4106_free(struct aead_instance *inst)static int crypto_rfc4106_create (struct crypto_template *tmpl,struct rtattr **tb) { -struct crypto_attr_type *algt;u32 mask;struct aead_instance *inst;struct crypto_aead_spawn *spawn;struct aead_alg *alg;int err; - algt =crypto_get_attr_type (tb); -if (IS_ERR (algt)) -return PTR_ERR (algt); - -if ((algt->type ^CRYPTO_ALG_TYPE_AEAD ) & algt->mask) -return -EINVAL ; - - mask =crypto_requires_sync (algt->type, algt->mask); + err =crypto_check_attr_type (tb,CRYPTO_ALG_TYPE_AEAD , &mask); +if (err) +return err; inst =kzalloc (sizeof (*inst) +sizeof (*spawn),GFP_KERNEL );if (!inst)
@@ -882,7 +868,6 @@ static int crypto_rfc4106_create(struct crypto_template *tmpl, CRYPTO_MAX_ALG_NAME) goto err_free_inst; - inst->alg.base.cra_flags = alg->base.cra_flags &CRYPTO_ALG_ASYNC ; inst->alg.base.cra_priority = alg->base.cra_priority; inst->alg.base.cra_blocksize =1 ; inst->alg.base.cra_alignmask = alg->base.cra_alignmask;
@@ -1057,21 +1042,15 @@ static void crypto_rfc4543_free(struct aead_instance *inst)static int crypto_rfc4543_create (struct crypto_template *tmpl,struct rtattr **tb) { -struct crypto_attr_type *algt;u32 mask;struct aead_instance *inst;struct aead_alg *alg;struct crypto_rfc4543_instance_ctx *ctx;int err; - algt =crypto_get_attr_type (tb); -if (IS_ERR (algt)) -return PTR_ERR (algt); - -if ((algt->type ^CRYPTO_ALG_TYPE_AEAD ) & algt->mask) -return -EINVAL ; - - mask =crypto_requires_sync (algt->type, algt->mask); + err =crypto_check_attr_type (tb,CRYPTO_ALG_TYPE_AEAD , &mask); +if (err) +return err; inst =kzalloc (sizeof (*inst) +sizeof (*ctx),GFP_KERNEL );if (!inst)
@@ -1104,7 +1083,6 @@ static int crypto_rfc4543_create(struct crypto_template *tmpl, CRYPTO_MAX_ALG_NAME) goto err_free_inst; - inst->alg.base.cra_flags = alg->base.cra_flags &CRYPTO_ALG_ASYNC ; inst->alg.base.cra_priority = alg->base.cra_priority; inst->alg.base.cra_blocksize =1 ; inst->alg.base.cra_alignmask = alg->base.cra_alignmask;
crypto/geniv.c +3 -11
@@ -42,7 +42,6 @@ struct aead_instance *aead_geniv_alloc(struct crypto_template *tmpl, struct rtattr **tb) {struct crypto_aead_spawn *spawn; -struct crypto_attr_type *algt;struct aead_instance *inst;struct aead_alg *alg;unsigned int ivsize;
@@ -50,12 +49,9 @@ struct aead_instance *aead_geniv_alloc(struct crypto_template *tmpl,u32 mask;int err; - algt =crypto_get_attr_type (tb); -if (IS_ERR (algt)) -return ERR_CAST (algt); - -if ((algt->type ^CRYPTO_ALG_TYPE_AEAD ) & algt->mask) -return ERR_PTR (-EINVAL ); + err =crypto_check_attr_type (tb,CRYPTO_ALG_TYPE_AEAD , &mask); +if (err) +return ERR_PTR (err); inst =kzalloc (sizeof (*inst) +sizeof (*spawn),GFP_KERNEL );if (!inst)
@@ -63,9 +59,6 @@ struct aead_instance *aead_geniv_alloc(struct crypto_template *tmpl, spawn =aead_instance_ctx (inst); -/* Ignore async algorithms if necessary. */ - mask =crypto_requires_sync (algt->type, algt->mask); - err =crypto_grab_aead (spawn,aead_crypto_instance (inst),crypto_attr_alg_name (tb[1 ]),0 , mask);if (err)
@@ -90,7 +83,6 @@ struct aead_instance *aead_geniv_alloc(struct crypto_template *tmpl, CRYPTO_MAX_ALG_NAME) goto err_free_inst; - inst->alg.base.cra_flags = alg->base.cra_flags &CRYPTO_ALG_ASYNC ; inst->alg.base.cra_priority = alg->base.cra_priority; inst->alg.base.cra_blocksize = alg->base.cra_blocksize; inst->alg.base.cra_alignmask = alg->base.cra_alignmask;
crypto/hmac.c +3 -2
@@ -168,11 +168,12 @@ static int hmac_create(struct crypto_template *tmpl, struct rtattr **tb)struct crypto_shash_spawn *spawn;struct crypto_alg *alg;struct shash_alg *salg; +u32 mask;int err;int ds;int ss; - err =crypto_check_attr_type (tb,CRYPTO_ALG_TYPE_SHASH ); + err =crypto_check_attr_type (tb,CRYPTO_ALG_TYPE_SHASH , &mask);if (err)return err;
@@ -182,7 +183,7 @@ static int hmac_create(struct crypto_template *tmpl, struct rtattr **tb) spawn =shash_instance_ctx (inst); err =crypto_grab_shash (spawn,shash_crypto_instance (inst), -crypto_attr_alg_name (tb[1 ]),0 ,0 ); +crypto_attr_alg_name (tb[1 ]),0 , mask);if (err) goto err_free_inst; salg =crypto_spawn_shash_alg (spawn);
crypto/lrw.c +3 -10
@@ -297,21 +297,15 @@ static int create(struct crypto_template *tmpl, struct rtattr **tb) {struct crypto_skcipher_spawn *spawn;struct skcipher_instance *inst; -struct crypto_attr_type *algt;struct skcipher_alg *alg;const char *cipher_name;char ecb_name[CRYPTO_MAX_ALG_NAME ];u32 mask;int err; - algt =crypto_get_attr_type (tb); -if (IS_ERR (algt)) -return PTR_ERR (algt); - -if ((algt->type ^CRYPTO_ALG_TYPE_SKCIPHER ) & algt->mask) -return -EINVAL ; - - mask =crypto_requires_sync (algt->type, algt->mask); + err =crypto_check_attr_type (tb,CRYPTO_ALG_TYPE_SKCIPHER , &mask); +if (err) +return err; cipher_name =crypto_attr_alg_name (tb[1 ]);if (IS_ERR (cipher_name))
@@ -379,7 +373,6 @@ static int create(struct crypto_template *tmpl, struct rtattr **tb) }else goto err_free_inst; - inst->alg.base.cra_flags = alg->base.cra_flags &CRYPTO_ALG_ASYNC ; inst->alg.base.cra_priority = alg->base.cra_priority; inst->alg.base.cra_blocksize =LRW_BLOCK_SIZE ; inst->alg.base.cra_alignmask = alg->base.cra_alignmask |
crypto/pcrypt.c +5 -9
@@ -226,18 +226,14 @@ static int pcrypt_init_instance(struct crypto_instance *inst, }static int pcrypt_create_aead (struct crypto_template *tmpl,struct rtattr **tb, -u32 type,u32 mask) +struct crypto_attr_type *algt) {struct pcrypt_instance_ctx *ctx; -struct crypto_attr_type *algt;struct aead_instance *inst;struct aead_alg *alg; +u32 mask =crypto_algt_inherited_mask (algt);int err; - algt =crypto_get_attr_type (tb); -if (IS_ERR (algt)) -return PTR_ERR (algt); - inst =kzalloc (sizeof (*inst) +sizeof (*ctx),GFP_KERNEL );if (!inst)return -ENOMEM ;
@@ -254,7 +250,7 @@ static int pcrypt_create_aead(struct crypto_template *tmpl, struct rtattr **tb, goto err_free_inst; err =crypto_grab_aead (&ctx->spawn,aead_crypto_instance (inst), -crypto_attr_alg_name (tb[1 ]),0 ,0 ); +crypto_attr_alg_name (tb[1 ]),0 , mask);if (err) goto err_free_inst;
@@ -263,7 +259,7 @@ static int pcrypt_create_aead(struct crypto_template *tmpl, struct rtattr **tb,if (err) goto err_free_inst; - inst->alg.base.cra_flags =CRYPTO_ALG_ASYNC ; + inst->alg.base.cra_flags |=CRYPTO_ALG_ASYNC ; inst->alg.ivsize =crypto_aead_alg_ivsize (alg); inst->alg.maxauthsize =crypto_aead_alg_maxauthsize (alg);
@@ -298,7 +294,7 @@ static int pcrypt_create(struct crypto_template *tmpl, struct rtattr **tb)switch (algt->type & algt->mask &CRYPTO_ALG_TYPE_MASK ) {case CRYPTO_ALG_TYPE_AEAD : -return pcrypt_create_aead (tmpl, tb, algt->type, algt->mask); +return pcrypt_create_aead (tmpl, tb, algt); }return -EINVAL ;
crypto/rsa-pkcs1pad.c +3 -10
@@ -596,7 +596,6 @@ static void pkcs1pad_free(struct akcipher_instance *inst)static int pkcs1pad_create (struct crypto_template *tmpl,struct rtattr **tb) { -struct crypto_attr_type *algt;u32 mask;struct akcipher_instance *inst;struct pkcs1pad_inst_ctx *ctx;
@@ -604,14 +603,9 @@ static int pkcs1pad_create(struct crypto_template *tmpl, struct rtattr **tb)const char *hash_name;int err; - algt =crypto_get_attr_type (tb); -if (IS_ERR (algt)) -return PTR_ERR (algt); - -if ((algt->type ^CRYPTO_ALG_TYPE_AKCIPHER ) & algt->mask) -return -EINVAL ; - - mask =crypto_requires_sync (algt->type, algt->mask); + err =crypto_check_attr_type (tb,CRYPTO_ALG_TYPE_AKCIPHER , &mask); +if (err) +return err; inst =kzalloc (sizeof (*inst) +sizeof (*ctx),GFP_KERNEL );if (!inst)
@@ -658,7 +652,6 @@ static int pkcs1pad_create(struct crypto_template *tmpl, struct rtattr **tb) goto err_free_inst; } - inst->alg.base.cra_flags = rsa_alg->base.cra_flags &CRYPTO_ALG_ASYNC ; inst->alg.base.cra_priority = rsa_alg->base.cra_priority; inst->alg.base.cra_ctxsize =sizeof (struct pkcs1pad_ctx );
crypto/simd.c +4 -2
@@ -171,7 +171,8 @@ struct simd_skcipher_alg *simd_skcipher_create_compat(const char *algname, drvname) >= CRYPTO_MAX_ALG_NAME) goto out_free_salg; - alg->base.cra_flags =CRYPTO_ALG_ASYNC ; + alg->base.cra_flags =CRYPTO_ALG_ASYNC | + (ialg->base.cra_flags &CRYPTO_ALG_INHERITED_FLAGS ); alg->base.cra_priority = ialg->base.cra_priority; alg->base.cra_blocksize = ialg->base.cra_blocksize; alg->base.cra_alignmask = ialg->base.cra_alignmask;
@@ -417,7 +418,8 @@ struct simd_aead_alg *simd_aead_create_compat(const char *algname, drvname) >= CRYPTO_MAX_ALG_NAME) goto out_free_salg; - alg->base.cra_flags =CRYPTO_ALG_ASYNC ; + alg->base.cra_flags =CRYPTO_ALG_ASYNC | + (ialg->base.cra_flags &CRYPTO_ALG_INHERITED_FLAGS ); alg->base.cra_priority = ialg->base.cra_priority; alg->base.cra_blocksize = ialg->base.cra_blocksize; alg->base.cra_alignmask = ialg->base.cra_alignmask;
crypto/skcipher.c +5 -10
@@ -934,22 +934,17 @@ static void skcipher_free_instance_simple(struct skcipher_instance *inst)struct skcipher_instance *skcipher_alloc_instance_simple (struct crypto_template *tmpl,struct rtattr **tb) { -struct crypto_attr_type *algt;u32 mask;struct skcipher_instance *inst;struct crypto_cipher_spawn *spawn;struct crypto_alg *cipher_alg;int err; - algt =crypto_get_attr_type (tb); -if (IS_ERR (algt)) -return ERR_CAST (algt); - -if ((algt->type ^CRYPTO_ALG_TYPE_SKCIPHER ) & algt->mask) -return ERR_PTR (-EINVAL ); - - mask =crypto_requires_off (algt->type, algt->mask, -CRYPTO_ALG_NEED_FALLBACK ); + err =crypto_check_attr_type (tb,CRYPTO_ALG_TYPE_SKCIPHER , &mask); +if (err) +return ERR_PTR (err); + mask |=crypto_requires_off (crypto_get_attr_type (tb), +CRYPTO_ALG_NEED_FALLBACK ); inst =kzalloc (sizeof (*inst) +sizeof (*spawn),GFP_KERNEL );if (!inst)
crypto/vmac.c +3 -2
@@ -620,9 +620,10 @@ static int vmac_create(struct crypto_template *tmpl, struct rtattr **tb)struct shash_instance *inst;struct crypto_cipher_spawn *spawn;struct crypto_alg *alg; +u32 mask;int err; - err =crypto_check_attr_type (tb,CRYPTO_ALG_TYPE_SHASH ); + err =crypto_check_attr_type (tb,CRYPTO_ALG_TYPE_SHASH , &mask);if (err)return err;
@@ -632,7 +633,7 @@ static int vmac_create(struct crypto_template *tmpl, struct rtattr **tb) spawn =shash_instance_ctx (inst); err =crypto_grab_cipher (spawn,shash_crypto_instance (inst), -crypto_attr_alg_name (tb[1 ]),0 ,0 ); +crypto_attr_alg_name (tb[1 ]),0 , mask);if (err) goto err_free_inst; alg =crypto_spawn_cipher_alg (spawn);
crypto/xcbc.c +3 -2
@@ -191,9 +191,10 @@ static int xcbc_create(struct crypto_template *tmpl, struct rtattr **tb)struct crypto_cipher_spawn *spawn;struct crypto_alg *alg;unsigned long alignmask; +u32 mask;int err; - err =crypto_check_attr_type (tb,CRYPTO_ALG_TYPE_SHASH ); + err =crypto_check_attr_type (tb,CRYPTO_ALG_TYPE_SHASH , &mask);if (err)return err;
@@ -203,7 +204,7 @@ static int xcbc_create(struct crypto_template *tmpl, struct rtattr **tb) spawn =shash_instance_ctx (inst); err =crypto_grab_cipher (spawn,shash_crypto_instance (inst), -crypto_attr_alg_name (tb[1 ]),0 ,0 ); +crypto_attr_alg_name (tb[1 ]),0 , mask);if (err) goto err_free_inst; alg =crypto_spawn_cipher_alg (spawn);
crypto/xts.c +5 -12
@@ -331,19 +331,17 @@ static void crypto_xts_free(struct skcipher_instance *inst)static int create (struct crypto_template *tmpl,struct rtattr **tb) {struct skcipher_instance *inst; -struct crypto_attr_type *algt;struct xts_instance_ctx *ctx;struct skcipher_alg *alg;const char *cipher_name;u32 mask;int err; - algt =crypto_get_attr_type (tb); -if (IS_ERR (algt)) -return PTR_ERR (algt); - -if ((algt->type ^CRYPTO_ALG_TYPE_SKCIPHER ) & algt->mask) -return -EINVAL ; + err =crypto_check_attr_type (tb,CRYPTO_ALG_TYPE_SKCIPHER , &mask); +if (err) +return err; + mask |=crypto_requires_off (crypto_get_attr_type (tb), +CRYPTO_ALG_NEED_FALLBACK ); cipher_name =crypto_attr_alg_name (tb[1 ]);if (IS_ERR (cipher_name))
@@ -355,10 +353,6 @@ static int create(struct crypto_template *tmpl, struct rtattr **tb) ctx =skcipher_instance_ctx (inst); - mask =crypto_requires_off (algt->type, algt->mask, -CRYPTO_ALG_NEED_FALLBACK | -CRYPTO_ALG_ASYNC ); - err =crypto_grab_skcipher (&ctx->spawn,skcipher_crypto_instance (inst), cipher_name,0 , mask);if (err == -ENOENT ) {
@@ -415,7 +409,6 @@ static int create(struct crypto_template *tmpl, struct rtattr **tb) }else goto err_free_inst; - inst->alg.base.cra_flags = alg->base.cra_flags &CRYPTO_ALG_ASYNC ; inst->alg.base.cra_priority = alg->base.cra_priority; inst->alg.base.cra_blocksize =XTS_BLOCK_SIZE ; inst->alg.base.cra_alignmask = alg->base.cra_alignmask |
include/crypto/algapi.h +16 -7
@@ -116,7 +116,7 @@ struct crypto_tfm *crypto_spawn_tfm(struct crypto_spawn *spawn, u32 type,void *crypto_spawn_tfm2 (struct crypto_spawn *spawn);struct crypto_attr_type *crypto_get_attr_type (struct rtattr **tb); -int crypto_check_attr_type (struct rtattr **tb,u32 type); +int crypto_check_attr_type (struct rtattr **tb,u32 type,u32 *mask_ret);const char *crypto_attr_alg_name (struct rtattr *rta);int crypto_attr_u32 (struct rtattr *rta,u32 *num); int crypto_inst_setname(struct crypto_instance *inst, const char *name,
@@ -235,18 +235,27 @@ static inline struct crypto_async_request *crypto_get_backlog( container_of(queue->backlog, struct crypto_async_request, list); } -static inline int crypto_requires_off (u32 type,u32 mask,u32 off) +static inline u32 crypto_requires_off (struct crypto_attr_type *algt,u32 off) { -return (type ^ off) & mask & off; +return (algt->type ^ off) & algt->mask & off; }/* -* Returns CRYPTO_ALG_ASYNC if type/mask requires the use of sync algorithms. -* Otherwise returns zero. +* When an algorithm uses another algorithm (e.g., if it's an instance of a +* template), these are the flags that should always be set on the "outer" +* algorithm if any "inner" algorithm has them set. */ -static inline int crypto_requires_sync (u32 type,u32 mask) +#define CRYPTO_ALG_INHERITED_FLAGS CRYPTO_ALG_ASYNC + +/* +* Given the type and mask that specify the flags restrictions on a template +* instance being created, return the mask that should be passed to +* crypto_grab_*() (along with type=0) to honor any request the user made to +* have any of the CRYPTO_ALG_INHERITED_FLAGS clear. +*/ +static inline u32 crypto_algt_inherited_mask (struct crypto_attr_type *algt) { -return crypto_requires_off (type, mask,CRYPTO_ALG_ASYNC ); +return crypto_requires_off (algt,CRYPTO_ALG_INHERITED_FLAGS ); }noinline unsigned long __crypto_memneq (const void *a,const void *b,size_t size);
Signature · 1 line
2.27.0
PATCH v2 4/7 crypto: algapi - add NEED_FALLBACK to INHERITED_FLAGS
In reply to Eric BiggersFrom: Eric Biggers <[email protected]>
CRYPTO_ALG_NEED_FALLBACK is handled inconsistently. When it's requested to be clear, some templates propagate that request to child algorithms, while others don't.
It's apparently desired for NEED_FALLBACK to be propagated, to avoid deadlocks where a module tries to load itself while it's being initialized, and to avoid unnecessarily complex fallback chains where we have e.g. cbc-aes-$driver falling back to cbc(aes-$driver) where aes-$driver itself falls back to aes-generic, instead of cbc-aes-$driver simply falling back to cbc(aes-generic). There have been a number of fixes to this effect:
commit 89027579bc6c ("crypto: xts - Propagate NEED_FALLBACK bit") commit d2c2a85cfe82 ("crypto: ctr - Propagate NEED_FALLBACK bit") commit e6c2e65c70a6 ("crypto: cbc - Propagate NEED_FALLBACK bit")
But it seems that other templates can have the same problems too.
To avoid this whack-a-mole, just add NEED_FALLBACK to INHERITED_FLAGS so that it's always inherited.
--- crypto/ctr.c | 2 -- crypto/skcipher.c | 2 -- crypto/xts.c | 2 -- include/crypto/algapi.h | 3 ++- include/linux/crypto.h | 4 ++-- 5 files changed, 4 insertions(+), 9 deletions(-)
crypto/ctr.c +0 -2
@@ -265,8 +265,6 @@ static int crypto_rfc3686_create(struct crypto_template *tmpl, err =crypto_check_attr_type (tb,CRYPTO_ALG_TYPE_SKCIPHER , &mask);if (err)return err; - mask |=crypto_requires_off (crypto_get_attr_type (tb), -CRYPTO_ALG_NEED_FALLBACK ); inst =kzalloc (sizeof (*inst) +sizeof (*spawn),GFP_KERNEL );if (!inst)
crypto/skcipher.c +0 -2
@@ -943,8 +943,6 @@ struct skcipher_instance *skcipher_alloc_instance_simple( err =crypto_check_attr_type (tb,CRYPTO_ALG_TYPE_SKCIPHER , &mask);if (err)return ERR_PTR (err); - mask |=crypto_requires_off (crypto_get_attr_type (tb), -CRYPTO_ALG_NEED_FALLBACK ); inst =kzalloc (sizeof (*inst) +sizeof (*spawn),GFP_KERNEL );if (!inst)
crypto/xts.c +0 -2
@@ -340,8 +340,6 @@ static int create(struct crypto_template *tmpl, struct rtattr **tb) err =crypto_check_attr_type (tb,CRYPTO_ALG_TYPE_SKCIPHER , &mask);if (err)return err; - mask |=crypto_requires_off (crypto_get_attr_type (tb), -CRYPTO_ALG_NEED_FALLBACK ); cipher_name =crypto_attr_alg_name (tb[1 ]);if (IS_ERR (cipher_name))
include/crypto/algapi.h +2 -1
@@ -245,7 +245,8 @@ static inline u32 crypto_requires_off(struct crypto_attr_type *algt, u32 off)* template), these are the flags that should always be set on the "outer" * algorithm if any "inner" algorithm has them set. */ -#define CRYPTO_ALG_INHERITED_FLAGS CRYPTO_ALG_ASYNC +#define CRYPTO_ALG_INHERITED_FLAGS \ + (CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK)/* * Given the type and mask that specify the flags restrictions on a template
include/linux/crypto.h +2 -2
@@ -60,8 +60,8 @@#define CRYPTO_ALG_ASYNC 0x00000080/* -* Set this bit if and only if the algorithm requires another algorithm of -* the same type to handle corner cases. +* Set if the algorithm (or an algorithm which it uses) requires another +* algorithm of the same type to handle corner cases. */ #define CRYPTO_ALG_NEED_FALLBACK 0x00000100
Signature · 1 line
2.27.0
PATCH v2 5/7 crypto: algapi - introduce the flag CRYPTO_ALG_ALLOCATES_MEMORY
In reply to Eric BiggersFrom: Eric Biggers <[email protected]>
Introduce a new algorithm flag CRYPTO_ALG_ALLOCATES_MEMORY. If this flag is set, then the driver allocates memory in its request routine. Such drivers are not suitable for disk encryption because GFP_ATOMIC allocation can fail anytime (causing random I/O errors) and GFP_KERNEL allocation can recurse into the block layer, causing a deadlock.
For now, this flag is only implemented for some algorithm types. We also assume some usage constraints for it to be meaningful, since there are lots of edge cases the crypto API allows (e.g., misaligned or fragmented scatterlists) that mean that nearly any crypto algorithm can allocate memory in some case. See the comment for details.
Also add this flag to CRYPTO_ALG_INHERITED_FLAGS so that when a template is instantiated, this flag is set on the template instance if it is set on any algorithm the instance uses.
Based on a patch by Mikulas Patocka <[email protected]>
(https://lore.kernel.org/r/alpine.LRH.2.02.2006301414580.30526@file01.intranet.prod.int.rdu2.redhat.com).
--- include/crypto/algapi.h | 3 ++- include/linux/crypto.h | 32 ++++++++++++++++++++++++++++++++ 2 files changed, 34 insertions(+), 1 deletion(-)
include/crypto/algapi.h +2 -1
@@ -246,7 +246,8 @@ static inline u32 crypto_requires_off(struct crypto_attr_type *algt, u32 off)* algorithm if any "inner" algorithm has them set. */ #define CRYPTO_ALG_INHERITED_FLAGS \ - (CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK) + (CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK | \ + CRYPTO_ALG_ALLOCATES_MEMORY)/* * Given the type and mask that specify the flags restrictions on a template
include/linux/crypto.h +32 -0
@@ -100,6 +100,38 @@*/ #define CRYPTO_NOLOAD 0x00008000 +/* +* 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 +/* * Transform masks and values (for crt_flags). */
Signature · 1 line
2.27.0
PATCH v2 6/7 crypto: drivers - set the flag CRYPTO_ALG_ALLOCATES_MEMORY
In reply to Eric BiggersFrom: Mikulas Patocka <[email protected]>
Set the flag CRYPTO_ALG_ALLOCATES_MEMORY in the crypto drivers that allocate memory.
drivers/crypto/allwinner/sun8i-ce/sun8i-ce-core.c: sun8i_ce_cipher drivers/crypto/allwinner/sun8i-ss/sun8i-ss-core.c: sun8i_ss_cipher drivers/crypto/amlogic/amlogic-gxl-core.c: meson_cipher drivers/crypto/axis/artpec6_crypto.c: artpec6_crypto_common_init drivers/crypto/bcm/cipher.c: spu_skcipher_rx_sg_create drivers/crypto/caam/caamalg.c: aead_edesc_alloc drivers/crypto/caam/caamalg_qi.c: aead_edesc_alloc drivers/crypto/caam/caamalg_qi2.c: aead_edesc_alloc drivers/crypto/caam/caamhash.c: hash_digest_key drivers/crypto/cavium/cpt/cptvf_algs.c: process_request drivers/crypto/cavium/nitrox/nitrox_aead.c: nitrox_process_se_request drivers/crypto/cavium/nitrox/nitrox_skcipher.c: nitrox_process_se_request drivers/crypto/ccp/ccp-crypto-aes-cmac.c: ccp_do_cmac_update drivers/crypto/ccp/ccp-crypto-aes-galois.c: ccp_crypto_enqueue_request drivers/crypto/ccp/ccp-crypto-aes-xts.c: ccp_crypto_enqueue_request drivers/crypto/ccp/ccp-crypto-aes.c: ccp_crypto_enqueue_request drivers/crypto/ccp/ccp-crypto-des3.c: ccp_crypto_enqueue_request drivers/crypto/ccp/ccp-crypto-sha.c: ccp_crypto_enqueue_request drivers/crypto/chelsio/chcr_algo.c: create_cipher_wr drivers/crypto/hisilicon/sec/sec_algs.c: sec_alloc_and_fill_hw_sgl drivers/crypto/hisilicon/sec2/sec_crypto.c: sec_alloc_req_id drivers/crypto/inside-secure/safexcel_cipher.c: safexcel_queue_req drivers/crypto/inside-secure/safexcel_hash.c: safexcel_ahash_enqueue drivers/crypto/ixp4xx_crypto.c: ablk_perform drivers/crypto/marvell/cesa/cipher.c: mv_cesa_skcipher_dma_req_init drivers/crypto/marvell/cesa/hash.c: mv_cesa_ahash_dma_req_init drivers/crypto/marvell/octeontx/otx_cptvf_algs.c: create_ctx_hdr drivers/crypto/n2_core.c: n2_compute_chunks drivers/crypto/picoxcell_crypto.c: spacc_sg_to_ddt drivers/crypto/qat/qat_common/qat_algs.c: qat_alg_skcipher_encrypt drivers/crypto/qce/skcipher.c: qce_skcipher_async_req_handle drivers/crypto/talitos.c : talitos_edesc_alloc drivers/crypto/virtio/virtio_crypto_algs.c: __virtio_crypto_skcipher_do_req drivers/crypto/xilinx/zynqmp-aes-gcm.c: zynqmp_aes_aead_cipher
--- .../crypto/allwinner/sun8i-ce/sun8i-ce-core.c | 12 +- .../crypto/allwinner/sun8i-ss/sun8i-ss-core.c | 12 +- drivers/crypto/amlogic/amlogic-gxl-core.c | 6 +- drivers/crypto/axis/artpec6_crypto.c | 20 ++- drivers/crypto/bcm/cipher.c | 72 ++++++++--- drivers/crypto/caam/caamalg.c | 6 +- drivers/crypto/caam/caamalg_qi.c | 6 +- drivers/crypto/caam/caamalg_qi2.c | 8 +- drivers/crypto/caam/caamhash.c | 2 +- drivers/crypto/cavium/cpt/cptvf_algs.c | 18 ++- drivers/crypto/cavium/nitrox/nitrox_aead.c | 4 +- .../crypto/cavium/nitrox/nitrox_skcipher.c | 16 +-- drivers/crypto/ccp/ccp-crypto-aes-cmac.c | 1 + drivers/crypto/ccp/ccp-crypto-aes-galois.c | 1 + drivers/crypto/ccp/ccp-crypto-aes-xts.c | 1 + drivers/crypto/ccp/ccp-crypto-aes.c | 2 + drivers/crypto/ccp/ccp-crypto-des3.c | 1 + drivers/crypto/ccp/ccp-crypto-sha.c | 1 + drivers/crypto/chelsio/chcr_algo.c | 7 +- drivers/crypto/hisilicon/sec/sec_algs.c | 24 ++-- drivers/crypto/hisilicon/sec2/sec_crypto.c | 4 +- .../crypto/inside-secure/safexcel_cipher.c | 47 +++++++ drivers/crypto/inside-secure/safexcel_hash.c | 18 +++ drivers/crypto/ixp4xx_crypto.c | 6 +- drivers/crypto/marvell/cesa/cipher.c | 18 ++- drivers/crypto/marvell/cesa/hash.c | 6 + .../crypto/marvell/octeontx/otx_cptvf_algs.c | 30 ++--- drivers/crypto/n2_core.c | 3 +- drivers/crypto/picoxcell_crypto.c | 17 ++- drivers/crypto/qat/qat_common/qat_algs.c | 13 +- drivers/crypto/qce/skcipher.c | 1 + drivers/crypto/talitos.c | 117 ++++++++++++------ drivers/crypto/virtio/virtio_crypto_algs.c | 3 +- drivers/crypto/xilinx/zynqmp-aes-gcm.c | 1 + 34 files changed, 361 insertions(+), 143 deletions(-)
drivers/crypto/allwinner/sun8i-ce/sun8i-ce-core.c +8 -4
@@ -185,7 +185,8 @@ static struct sun8i_ce_alg_template ce_algs[] = { .cra_priority = 400, .cra_blocksize = AES_BLOCK_SIZE, .cra_flags =CRYPTO_ALG_TYPE_SKCIPHER | - CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK, +CRYPTO_ALG_ASYNC |CRYPTO_ALG_ALLOCATES_MEMORY | + CRYPTO_ALG_NEED_FALLBACK, .cra_ctxsize = sizeof(struct sun8i_cipher_tfm_ctx), .cra_module = THIS_MODULE, .cra_alignmask = 0xf,
@@ -211,7 +212,8 @@ static struct sun8i_ce_alg_template ce_algs[] = { .cra_priority = 400, .cra_blocksize = AES_BLOCK_SIZE, .cra_flags =CRYPTO_ALG_TYPE_SKCIPHER | - CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK, +CRYPTO_ALG_ASYNC |CRYPTO_ALG_ALLOCATES_MEMORY | + CRYPTO_ALG_NEED_FALLBACK, .cra_ctxsize = sizeof(struct sun8i_cipher_tfm_ctx), .cra_module = THIS_MODULE, .cra_alignmask = 0xf,
@@ -236,7 +238,8 @@ static struct sun8i_ce_alg_template ce_algs[] = { .cra_priority = 400, .cra_blocksize = DES3_EDE_BLOCK_SIZE, .cra_flags =CRYPTO_ALG_TYPE_SKCIPHER | - CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK, +CRYPTO_ALG_ASYNC |CRYPTO_ALG_ALLOCATES_MEMORY | + CRYPTO_ALG_NEED_FALLBACK, .cra_ctxsize = sizeof(struct sun8i_cipher_tfm_ctx), .cra_module = THIS_MODULE, .cra_alignmask = 0xf,
@@ -262,7 +265,8 @@ static struct sun8i_ce_alg_template ce_algs[] = { .cra_priority = 400, .cra_blocksize = DES3_EDE_BLOCK_SIZE, .cra_flags =CRYPTO_ALG_TYPE_SKCIPHER | - CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK, +CRYPTO_ALG_ASYNC |CRYPTO_ALG_ALLOCATES_MEMORY | + CRYPTO_ALG_NEED_FALLBACK, .cra_ctxsize = sizeof(struct sun8i_cipher_tfm_ctx), .cra_module = THIS_MODULE, .cra_alignmask = 0xf,
drivers/crypto/allwinner/sun8i-ss/sun8i-ss-core.c +8 -4
@@ -169,7 +169,8 @@ static struct sun8i_ss_alg_template ss_algs[] = { .cra_priority = 400, .cra_blocksize = AES_BLOCK_SIZE, .cra_flags =CRYPTO_ALG_TYPE_SKCIPHER | - CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK, +CRYPTO_ALG_ASYNC |CRYPTO_ALG_ALLOCATES_MEMORY | + CRYPTO_ALG_NEED_FALLBACK, .cra_ctxsize = sizeof(struct sun8i_cipher_tfm_ctx), .cra_module = THIS_MODULE, .cra_alignmask = 0xf,
@@ -195,7 +196,8 @@ static struct sun8i_ss_alg_template ss_algs[] = { .cra_priority = 400, .cra_blocksize = AES_BLOCK_SIZE, .cra_flags =CRYPTO_ALG_TYPE_SKCIPHER | - CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK, +CRYPTO_ALG_ASYNC |CRYPTO_ALG_ALLOCATES_MEMORY | + CRYPTO_ALG_NEED_FALLBACK, .cra_ctxsize = sizeof(struct sun8i_cipher_tfm_ctx), .cra_module = THIS_MODULE, .cra_alignmask = 0xf,
@@ -220,7 +222,8 @@ static struct sun8i_ss_alg_template ss_algs[] = { .cra_priority = 400, .cra_blocksize = DES3_EDE_BLOCK_SIZE, .cra_flags =CRYPTO_ALG_TYPE_SKCIPHER | - CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK, +CRYPTO_ALG_ASYNC |CRYPTO_ALG_ALLOCATES_MEMORY | + CRYPTO_ALG_NEED_FALLBACK, .cra_ctxsize = sizeof(struct sun8i_cipher_tfm_ctx), .cra_module = THIS_MODULE, .cra_alignmask = 0xf,
@@ -246,7 +249,8 @@ static struct sun8i_ss_alg_template ss_algs[] = { .cra_priority = 400, .cra_blocksize = DES3_EDE_BLOCK_SIZE, .cra_flags =CRYPTO_ALG_TYPE_SKCIPHER | - CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK, +CRYPTO_ALG_ASYNC |CRYPTO_ALG_ALLOCATES_MEMORY | + CRYPTO_ALG_NEED_FALLBACK, .cra_ctxsize = sizeof(struct sun8i_cipher_tfm_ctx), .cra_module = THIS_MODULE, .cra_alignmask = 0xf,
drivers/crypto/amlogic/amlogic-gxl-core.c +4 -2
@@ -54,7 +54,8 @@ static struct meson_alg_template mc_algs[] = { .cra_priority = 400, .cra_blocksize = AES_BLOCK_SIZE, .cra_flags =CRYPTO_ALG_TYPE_SKCIPHER | - CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK, +CRYPTO_ALG_ASYNC |CRYPTO_ALG_ALLOCATES_MEMORY | + CRYPTO_ALG_NEED_FALLBACK, .cra_ctxsize = sizeof(struct meson_cipher_tfm_ctx), .cra_module = THIS_MODULE, .cra_alignmask = 0xf,
@@ -79,7 +80,8 @@ static struct meson_alg_template mc_algs[] = { .cra_priority = 400, .cra_blocksize = AES_BLOCK_SIZE, .cra_flags =CRYPTO_ALG_TYPE_SKCIPHER | - CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK, +CRYPTO_ALG_ASYNC |CRYPTO_ALG_ALLOCATES_MEMORY | + CRYPTO_ALG_NEED_FALLBACK, .cra_ctxsize = sizeof(struct meson_cipher_tfm_ctx), .cra_module = THIS_MODULE, .cra_alignmask = 0xf,
drivers/crypto/axis/artpec6_crypto.c +14 -6
@@ -2630,7 +2630,8 @@ static struct ahash_alg hash_algos[] = { .cra_name = "sha1", .cra_driver_name = "artpec-sha1", .cra_priority = 300, - .cra_flags = CRYPTO_ALG_ASYNC, + .cra_flags =CRYPTO_ALG_ASYNC | + CRYPTO_ALG_ALLOCATES_MEMORY, .cra_blocksize = SHA1_BLOCK_SIZE, .cra_ctxsize = sizeof(struct artpec6_hashalg_context), .cra_alignmask = 3,
@@ -2653,7 +2654,8 @@ static struct ahash_alg hash_algos[] = { .cra_name = "sha256", .cra_driver_name = "artpec-sha256", .cra_priority = 300, - .cra_flags = CRYPTO_ALG_ASYNC, + .cra_flags =CRYPTO_ALG_ASYNC | + CRYPTO_ALG_ALLOCATES_MEMORY, .cra_blocksize = SHA256_BLOCK_SIZE, .cra_ctxsize = sizeof(struct artpec6_hashalg_context), .cra_alignmask = 3,
@@ -2677,7 +2679,8 @@ static struct ahash_alg hash_algos[] = { .cra_name = "hmac(sha256)", .cra_driver_name = "artpec-hmac-sha256", .cra_priority = 300, - .cra_flags = CRYPTO_ALG_ASYNC, + .cra_flags =CRYPTO_ALG_ASYNC | + CRYPTO_ALG_ALLOCATES_MEMORY, .cra_blocksize = SHA256_BLOCK_SIZE, .cra_ctxsize = sizeof(struct artpec6_hashalg_context), .cra_alignmask = 3,
@@ -2696,7 +2699,8 @@ static struct skcipher_alg crypto_algos[] = { .cra_name = "ecb(aes)", .cra_driver_name = "artpec6-ecb-aes", .cra_priority = 300, - .cra_flags = CRYPTO_ALG_ASYNC, + .cra_flags =CRYPTO_ALG_ASYNC | + CRYPTO_ALG_ALLOCATES_MEMORY, .cra_blocksize = AES_BLOCK_SIZE, .cra_ctxsize = sizeof(struct artpec6_cryptotfm_context), .cra_alignmask = 3,
@@ -2717,6 +2721,7 @@ static struct skcipher_alg crypto_algos[] = { .cra_driver_name = "artpec6-ctr-aes", .cra_priority = 300, .cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY | CRYPTO_ALG_NEED_FALLBACK, .cra_blocksize = 1, .cra_ctxsize = sizeof(struct artpec6_cryptotfm_context),
@@ -2738,7 +2743,8 @@ static struct skcipher_alg crypto_algos[] = { .cra_name = "cbc(aes)", .cra_driver_name = "artpec6-cbc-aes", .cra_priority = 300, - .cra_flags = CRYPTO_ALG_ASYNC, + .cra_flags =CRYPTO_ALG_ASYNC | + CRYPTO_ALG_ALLOCATES_MEMORY, .cra_blocksize = AES_BLOCK_SIZE, .cra_ctxsize = sizeof(struct artpec6_cryptotfm_context), .cra_alignmask = 3,
@@ -2759,7 +2765,8 @@ static struct skcipher_alg crypto_algos[] = { .cra_name = "xts(aes)", .cra_driver_name = "artpec6-xts-aes", .cra_priority = 300, - .cra_flags = CRYPTO_ALG_ASYNC, + .cra_flags =CRYPTO_ALG_ASYNC | + CRYPTO_ALG_ALLOCATES_MEMORY, .cra_blocksize = 1, .cra_ctxsize = sizeof(struct artpec6_cryptotfm_context), .cra_alignmask = 3,
@@ -2790,6 +2797,7 @@ static struct aead_alg aead_algos[] = { .cra_driver_name = "artpec-gcm-aes", .cra_priority = 300, .cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY | CRYPTO_ALG_KERN_DRIVER_ONLY, .cra_blocksize = 1, .cra_ctxsize = sizeof(struct artpec6_cryptotfm_context),
drivers/crypto/bcm/cipher.c +53 -19
186 lines not on this page · raw message
drivers/crypto/caam/caamalg.c +4 -2
@@ -3433,7 +3433,8 @@ static void caam_skcipher_alg_init(struct caam_skcipher_alg *t_alg) alg->base.cra_module =THIS_MODULE ; alg->base.cra_priority =CAAM_CRA_PRIORITY ; alg->base.cra_ctxsize =sizeof (struct caam_ctx ); - alg->base.cra_flags =CRYPTO_ALG_ASYNC |CRYPTO_ALG_KERN_DRIVER_ONLY ; + alg->base.cra_flags =CRYPTO_ALG_ASYNC |CRYPTO_ALG_ALLOCATES_MEMORY | +CRYPTO_ALG_KERN_DRIVER_ONLY ; alg->init = caam_cra_init; alg->exit = caam_cra_exit;
@@ -3446,7 +3447,8 @@ static void caam_aead_alg_init(struct caam_aead_alg *t_alg) alg->base.cra_module =THIS_MODULE ; alg->base.cra_priority =CAAM_CRA_PRIORITY ; alg->base.cra_ctxsize =sizeof (struct caam_ctx ); - alg->base.cra_flags =CRYPTO_ALG_ASYNC |CRYPTO_ALG_KERN_DRIVER_ONLY ; + alg->base.cra_flags =CRYPTO_ALG_ASYNC |CRYPTO_ALG_ALLOCATES_MEMORY | +CRYPTO_ALG_KERN_DRIVER_ONLY ; alg->init = caam_aead_init; alg->exit = caam_aead_exit;
drivers/crypto/caam/caamalg_qi.c +4 -2
@@ -2502,7 +2502,8 @@ static void caam_skcipher_alg_init(struct caam_skcipher_alg *t_alg) alg->base.cra_module =THIS_MODULE ; alg->base.cra_priority =CAAM_CRA_PRIORITY ; alg->base.cra_ctxsize =sizeof (struct caam_ctx ); - alg->base.cra_flags =CRYPTO_ALG_ASYNC |CRYPTO_ALG_KERN_DRIVER_ONLY ; + alg->base.cra_flags =CRYPTO_ALG_ASYNC |CRYPTO_ALG_ALLOCATES_MEMORY | +CRYPTO_ALG_KERN_DRIVER_ONLY ; alg->init = caam_cra_init; alg->exit = caam_cra_exit;
@@ -2515,7 +2516,8 @@ static void caam_aead_alg_init(struct caam_aead_alg *t_alg) alg->base.cra_module =THIS_MODULE ; alg->base.cra_priority =CAAM_CRA_PRIORITY ; alg->base.cra_ctxsize =sizeof (struct caam_ctx ); - alg->base.cra_flags =CRYPTO_ALG_ASYNC |CRYPTO_ALG_KERN_DRIVER_ONLY ; + alg->base.cra_flags =CRYPTO_ALG_ASYNC |CRYPTO_ALG_ALLOCATES_MEMORY | +CRYPTO_ALG_KERN_DRIVER_ONLY ; alg->init = caam_aead_init; alg->exit = caam_aead_exit;
drivers/crypto/caam/caamalg_qi2.c +5 -3
@@ -2912,7 +2912,8 @@ static void caam_skcipher_alg_init(struct caam_skcipher_alg *t_alg) alg->base.cra_module =THIS_MODULE ; alg->base.cra_priority =CAAM_CRA_PRIORITY ; alg->base.cra_ctxsize =sizeof (struct caam_ctx ); - alg->base.cra_flags =CRYPTO_ALG_ASYNC |CRYPTO_ALG_KERN_DRIVER_ONLY ; + alg->base.cra_flags =CRYPTO_ALG_ASYNC |CRYPTO_ALG_ALLOCATES_MEMORY | +CRYPTO_ALG_KERN_DRIVER_ONLY ; alg->init = caam_cra_init_skcipher; alg->exit = caam_cra_exit;
@@ -2925,7 +2926,8 @@ static void caam_aead_alg_init(struct caam_aead_alg *t_alg) alg->base.cra_module =THIS_MODULE ; alg->base.cra_priority =CAAM_CRA_PRIORITY ; alg->base.cra_ctxsize =sizeof (struct caam_ctx ); - alg->base.cra_flags =CRYPTO_ALG_ASYNC |CRYPTO_ALG_KERN_DRIVER_ONLY ; + alg->base.cra_flags =CRYPTO_ALG_ASYNC |CRYPTO_ALG_ALLOCATES_MEMORY | +CRYPTO_ALG_KERN_DRIVER_ONLY ; alg->init = caam_cra_init_aead; alg->exit = caam_cra_exit_aead;
@@ -4547,7 +4549,7 @@ static struct caam_hash_alg *caam_hash_alloc(struct device *dev, alg->cra_priority =CAAM_CRA_PRIORITY ; alg->cra_blocksize = template->blocksize; alg->cra_alignmask =0 ; - alg->cra_flags =CRYPTO_ALG_ASYNC ; + alg->cra_flags =CRYPTO_ALG_ASYNC |CRYPTO_ALG_ALLOCATES_MEMORY ; t_alg->alg_type = template->alg_type; t_alg->dev = dev;
drivers/crypto/caam/caamhash.c +1 -1
@@ -1927,7 +1927,7 @@ caam_hash_alloc(struct caam_hash_template *template, alg->cra_priority =CAAM_CRA_PRIORITY ; alg->cra_blocksize = template->blocksize; alg->cra_alignmask =0 ; - alg->cra_flags =CRYPTO_ALG_ASYNC ; + alg->cra_flags =CRYPTO_ALG_ASYNC |CRYPTO_ALG_ALLOCATES_MEMORY ; t_alg->alg_type = template->alg_type;
drivers/crypto/cavium/cpt/cptvf_algs.c +12 -6
@@ -341,7 +341,8 @@ static int cvm_enc_dec_init(struct crypto_skcipher *tfm) }static struct skcipher_alg algs[] = { { - .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY , .base.cra_blocksize =AES_BLOCK_SIZE , .base.cra_ctxsize =sizeof (struct cvm_enc_ctx ), .base.cra_alignmask =7 ,
@@ -358,7 +359,8 @@ static struct skcipher_alg algs[] = { { .decrypt = cvm_decrypt, .init = cvm_enc_dec_init, }, { - .base.cra_flags = CRYPTO_ALG_ASYNC, + .base.cra_flags = CRYPTO_ALG_ASYNC | + CRYPTO_ALG_ALLOCATES_MEMORY, .base.cra_blocksize = AES_BLOCK_SIZE, .base.cra_ctxsize = sizeof(struct cvm_enc_ctx), .base.cra_alignmask = 7,
@@ -375,7 +377,8 @@ static struct skcipher_alg algs[] = { { .decrypt = cvm_decrypt, .init = cvm_enc_dec_init, }, { - .base.cra_flags = CRYPTO_ALG_ASYNC, + .base.cra_flags = CRYPTO_ALG_ASYNC | + CRYPTO_ALG_ALLOCATES_MEMORY, .base.cra_blocksize = AES_BLOCK_SIZE, .base.cra_ctxsize = sizeof(struct cvm_enc_ctx), .base.cra_alignmask = 7,
@@ -391,7 +394,8 @@ static struct skcipher_alg algs[] = { { .decrypt = cvm_decrypt, .init = cvm_enc_dec_init, }, { - .base.cra_flags = CRYPTO_ALG_ASYNC, + .base.cra_flags = CRYPTO_ALG_ASYNC | + CRYPTO_ALG_ALLOCATES_MEMORY, .base.cra_blocksize = AES_BLOCK_SIZE, .base.cra_ctxsize = sizeof(struct cvm_enc_ctx), .base.cra_alignmask = 7,
@@ -408,7 +412,8 @@ static struct skcipher_alg algs[] = { { .decrypt = cvm_decrypt, .init = cvm_enc_dec_init, }, { - .base.cra_flags = CRYPTO_ALG_ASYNC, + .base.cra_flags = CRYPTO_ALG_ASYNC | + CRYPTO_ALG_ALLOCATES_MEMORY, .base.cra_blocksize = DES3_EDE_BLOCK_SIZE, .base.cra_ctxsize = sizeof(struct cvm_des3_ctx), .base.cra_alignmask = 7,
@@ -425,7 +430,8 @@ static struct skcipher_alg algs[] = { { .decrypt = cvm_decrypt, .init = cvm_enc_dec_init, }, { - .base.cra_flags = CRYPTO_ALG_ASYNC, + .base.cra_flags = CRYPTO_ALG_ASYNC | + CRYPTO_ALG_ALLOCATES_MEMORY, .base.cra_blocksize = DES3_EDE_BLOCK_SIZE, .base.cra_ctxsize = sizeof(struct cvm_des3_ctx), .base.cra_alignmask = 7,
drivers/crypto/cavium/nitrox/nitrox_aead.c +2 -2
@@ -522,7 +522,7 @@ static struct aead_alg nitrox_aeads[] = { { .cra_name = "gcm(aes)", .cra_driver_name = "n5_aes_gcm", .cra_priority = PRIO, - .cra_flags = CRYPTO_ALG_ASYNC, + .cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, .cra_blocksize = 1, .cra_ctxsize = sizeof(struct nitrox_crypto_ctx), .cra_alignmask = 0,
@@ -541,7 +541,7 @@ static struct aead_alg nitrox_aeads[] = { { .cra_name = "rfc4106(gcm(aes))", .cra_driver_name = "n5_rfc4106", .cra_priority = PRIO, - .cra_flags = CRYPTO_ALG_ASYNC, + .cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, .cra_blocksize = 1, .cra_ctxsize = sizeof(struct nitrox_crypto_ctx), .cra_alignmask = 0,
drivers/crypto/cavium/nitrox/nitrox_skcipher.c +8 -8
@@ -388,7 +388,7 @@ static struct skcipher_alg nitrox_skciphers[] = { { .cra_name = "cbc(aes)", .cra_driver_name = "n5_cbc(aes)", .cra_priority = PRIO, - .cra_flags = CRYPTO_ALG_ASYNC, + .cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, .cra_blocksize = AES_BLOCK_SIZE, .cra_ctxsize = sizeof(struct nitrox_crypto_ctx), .cra_alignmask = 0,
@@ -407,7 +407,7 @@ static struct skcipher_alg nitrox_skciphers[] = { { .cra_name = "ecb(aes)", .cra_driver_name = "n5_ecb(aes)", .cra_priority = PRIO, - .cra_flags = CRYPTO_ALG_ASYNC, + .cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, .cra_blocksize = AES_BLOCK_SIZE, .cra_ctxsize = sizeof(struct nitrox_crypto_ctx), .cra_alignmask = 0,
@@ -426,7 +426,7 @@ static struct skcipher_alg nitrox_skciphers[] = { { .cra_name = "cfb(aes)", .cra_driver_name = "n5_cfb(aes)", .cra_priority = PRIO, - .cra_flags = CRYPTO_ALG_ASYNC, + .cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, .cra_blocksize = AES_BLOCK_SIZE, .cra_ctxsize = sizeof(struct nitrox_crypto_ctx), .cra_alignmask = 0,
@@ -445,7 +445,7 @@ static struct skcipher_alg nitrox_skciphers[] = { { .cra_name = "xts(aes)", .cra_driver_name = "n5_xts(aes)", .cra_priority = PRIO, - .cra_flags = CRYPTO_ALG_ASYNC, + .cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, .cra_blocksize = AES_BLOCK_SIZE, .cra_ctxsize = sizeof(struct nitrox_crypto_ctx), .cra_alignmask = 0,
@@ -464,7 +464,7 @@ static struct skcipher_alg nitrox_skciphers[] = { { .cra_name = "rfc3686(ctr(aes))", .cra_driver_name = "n5_rfc3686(ctr(aes))", .cra_priority = PRIO, - .cra_flags = CRYPTO_ALG_ASYNC, + .cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, .cra_blocksize = 1, .cra_ctxsize = sizeof(struct nitrox_crypto_ctx), .cra_alignmask = 0,
@@ -483,7 +483,7 @@ static struct skcipher_alg nitrox_skciphers[] = { { .cra_name = "cts(cbc(aes))", .cra_driver_name = "n5_cts(cbc(aes))", .cra_priority = PRIO, - .cra_flags = CRYPTO_ALG_ASYNC, + .cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, .cra_blocksize = AES_BLOCK_SIZE, .cra_ctxsize = sizeof(struct nitrox_crypto_ctx), .cra_alignmask = 0,
@@ -502,7 +502,7 @@ static struct skcipher_alg nitrox_skciphers[] = { { .cra_name = "cbc(des3_ede)", .cra_driver_name = "n5_cbc(des3_ede)", .cra_priority = PRIO, - .cra_flags = CRYPTO_ALG_ASYNC, + .cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, .cra_blocksize = DES3_EDE_BLOCK_SIZE, .cra_ctxsize = sizeof(struct nitrox_crypto_ctx), .cra_alignmask = 0,
@@ -521,7 +521,7 @@ static struct skcipher_alg nitrox_skciphers[] = { { .cra_name = "ecb(des3_ede)", .cra_driver_name = "n5_ecb(des3_ede)", .cra_priority = PRIO, - .cra_flags = CRYPTO_ALG_ASYNC, + .cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, .cra_blocksize = DES3_EDE_BLOCK_SIZE, .cra_ctxsize = sizeof(struct nitrox_crypto_ctx), .cra_alignmask = 0,
drivers/crypto/ccp/ccp-crypto-aes-cmac.c +1 -0
@@ -378,6 +378,7 @@ int ccp_register_aes_cmac_algs(struct list_head *head)snprintf (base->cra_name,CRYPTO_MAX_ALG_NAME ,"cmac(aes)" );snprintf (base->cra_driver_name,CRYPTO_MAX_ALG_NAME ,"cmac-aes-ccp" ); base->cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY |CRYPTO_ALG_KERN_DRIVER_ONLY |CRYPTO_ALG_NEED_FALLBACK ; base->cra_blocksize =AES_BLOCK_SIZE ;
drivers/crypto/ccp/ccp-crypto-aes-galois.c +1 -0
@@ -172,6 +172,7 @@ static struct aead_alg ccp_aes_gcm_defaults = { .maxauthsize = AES_BLOCK_SIZE, .base = { .cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY |CRYPTO_ALG_KERN_DRIVER_ONLY | CRYPTO_ALG_NEED_FALLBACK, .cra_blocksize = AES_BLOCK_SIZE,
drivers/crypto/ccp/ccp-crypto-aes-xts.c +1 -0
@@ -243,6 +243,7 @@ static int ccp_register_aes_xts_alg(struct list_head *head,snprintf (alg->base.cra_driver_name,CRYPTO_MAX_ALG_NAME ,"%s" , def->drv_name); alg->base.cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY |CRYPTO_ALG_KERN_DRIVER_ONLY |CRYPTO_ALG_NEED_FALLBACK ; alg->base.cra_blocksize =AES_BLOCK_SIZE ;
drivers/crypto/ccp/ccp-crypto-aes.c +2 -0
@@ -212,6 +212,7 @@ static const struct skcipher_alg ccp_aes_defaults = { .init = ccp_aes_init_tfm, .base.cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY |CRYPTO_ALG_KERN_DRIVER_ONLY | CRYPTO_ALG_NEED_FALLBACK, .base.cra_blocksize = AES_BLOCK_SIZE,
@@ -229,6 +230,7 @@ static const struct skcipher_alg ccp_aes_rfc3686_defaults = { .init = ccp_aes_rfc3686_init_tfm, .base.cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY |CRYPTO_ALG_KERN_DRIVER_ONLY | CRYPTO_ALG_NEED_FALLBACK, .base.cra_blocksize = CTR_RFC3686_BLOCK_SIZE,
drivers/crypto/ccp/ccp-crypto-des3.c +1 -0
@@ -136,6 +136,7 @@ static const struct skcipher_alg ccp_des3_defaults = { .init = ccp_des3_init_tfm, .base.cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY |CRYPTO_ALG_KERN_DRIVER_ONLY | CRYPTO_ALG_NEED_FALLBACK, .base.cra_blocksize = DES3_EDE_BLOCK_SIZE,
drivers/crypto/ccp/ccp-crypto-sha.c +1 -0
@@ -486,6 +486,7 @@ static int ccp_register_sha_alg(struct list_head *head,snprintf (base->cra_driver_name,CRYPTO_MAX_ALG_NAME ,"%s" , def->drv_name); base->cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY |CRYPTO_ALG_KERN_DRIVER_ONLY |CRYPTO_ALG_NEED_FALLBACK ; base->cra_blocksize = def->block_size;
drivers/crypto/chelsio/chcr_algo.c +5 -2
@@ -4445,6 +4445,7 @@ static int chcr_register_alg(void) driver_algs[i].alg.skcipher.base.cra_module =THIS_MODULE ; driver_algs[i].alg.skcipher.base.cra_flags =CRYPTO_ALG_TYPE_SKCIPHER |CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY |CRYPTO_ALG_NEED_FALLBACK ; driver_algs[i].alg.skcipher.base.cra_ctxsize = sizeof(struct chcr_context) +
@@ -4456,7 +4457,8 @@ static int chcr_register_alg(void)break ;case CRYPTO_ALG_TYPE_AEAD : driver_algs[i].alg.aead.base.cra_flags = -CRYPTO_ALG_ASYNC |CRYPTO_ALG_NEED_FALLBACK ; +CRYPTO_ALG_ASYNC |CRYPTO_ALG_NEED_FALLBACK | +CRYPTO_ALG_ALLOCATES_MEMORY ; driver_algs[i].alg.aead.encrypt = chcr_aead_encrypt; driver_algs[i].alg.aead.decrypt = chcr_aead_decrypt; driver_algs[i].alg.aead.init = chcr_aead_cra_init;
@@ -4476,7 +4478,8 @@ static int chcr_register_alg(void) a_hash->halg.statesize =SZ_AHASH_REQ_CTX ; a_hash->halg.base.cra_priority =CHCR_CRA_PRIORITY ; a_hash->halg.base.cra_module =THIS_MODULE ; - a_hash->halg.base.cra_flags =CRYPTO_ALG_ASYNC ; + a_hash->halg.base.cra_flags = +CRYPTO_ALG_ASYNC |CRYPTO_ALG_ALLOCATES_MEMORY ; a_hash->halg.base.cra_alignmask =0 ; a_hash->halg.base.cra_exit =NULL ;
drivers/crypto/hisilicon/sec/sec_algs.c +16 -8
@@ -934,7 +934,8 @@ static struct skcipher_alg sec_algs[] = { .cra_name = "ecb(aes)", .cra_driver_name = "hisi_sec_aes_ecb", .cra_priority = 4001, - .cra_flags = CRYPTO_ALG_ASYNC, + .cra_flags =CRYPTO_ALG_ASYNC | + CRYPTO_ALG_ALLOCATES_MEMORY, .cra_blocksize = AES_BLOCK_SIZE, .cra_ctxsize = sizeof(struct sec_alg_tfm_ctx), .cra_alignmask = 0,
@@ -953,7 +954,8 @@ static struct skcipher_alg sec_algs[] = { .cra_name = "cbc(aes)", .cra_driver_name = "hisi_sec_aes_cbc", .cra_priority = 4001, - .cra_flags = CRYPTO_ALG_ASYNC, + .cra_flags =CRYPTO_ALG_ASYNC | + CRYPTO_ALG_ALLOCATES_MEMORY, .cra_blocksize = AES_BLOCK_SIZE, .cra_ctxsize = sizeof(struct sec_alg_tfm_ctx), .cra_alignmask = 0,
@@ -972,7 +974,8 @@ static struct skcipher_alg sec_algs[] = { .cra_name = "ctr(aes)", .cra_driver_name = "hisi_sec_aes_ctr", .cra_priority = 4001, - .cra_flags = CRYPTO_ALG_ASYNC, + .cra_flags =CRYPTO_ALG_ASYNC | + CRYPTO_ALG_ALLOCATES_MEMORY, .cra_blocksize = AES_BLOCK_SIZE, .cra_ctxsize = sizeof(struct sec_alg_tfm_ctx), .cra_alignmask = 0,
@@ -991,7 +994,8 @@ static struct skcipher_alg sec_algs[] = { .cra_name = "xts(aes)", .cra_driver_name = "hisi_sec_aes_xts", .cra_priority = 4001, - .cra_flags = CRYPTO_ALG_ASYNC, + .cra_flags =CRYPTO_ALG_ASYNC | + CRYPTO_ALG_ALLOCATES_MEMORY, .cra_blocksize = AES_BLOCK_SIZE, .cra_ctxsize = sizeof(struct sec_alg_tfm_ctx), .cra_alignmask = 0,
@@ -1011,7 +1015,8 @@ static struct skcipher_alg sec_algs[] = { .cra_name = "ecb(des)", .cra_driver_name = "hisi_sec_des_ecb", .cra_priority = 4001, - .cra_flags = CRYPTO_ALG_ASYNC, + .cra_flags =CRYPTO_ALG_ASYNC | + CRYPTO_ALG_ALLOCATES_MEMORY, .cra_blocksize = DES_BLOCK_SIZE, .cra_ctxsize = sizeof(struct sec_alg_tfm_ctx), .cra_alignmask = 0,
@@ -1030,7 +1035,8 @@ static struct skcipher_alg sec_algs[] = { .cra_name = "cbc(des)", .cra_driver_name = "hisi_sec_des_cbc", .cra_priority = 4001, - .cra_flags = CRYPTO_ALG_ASYNC, + .cra_flags =CRYPTO_ALG_ASYNC | + CRYPTO_ALG_ALLOCATES_MEMORY, .cra_blocksize = DES_BLOCK_SIZE, .cra_ctxsize = sizeof(struct sec_alg_tfm_ctx), .cra_alignmask = 0,
@@ -1049,7 +1055,8 @@ static struct skcipher_alg sec_algs[] = { .cra_name = "cbc(des3_ede)", .cra_driver_name = "hisi_sec_3des_cbc", .cra_priority = 4001, - .cra_flags = CRYPTO_ALG_ASYNC, + .cra_flags =CRYPTO_ALG_ASYNC | + CRYPTO_ALG_ALLOCATES_MEMORY, .cra_blocksize = DES3_EDE_BLOCK_SIZE, .cra_ctxsize = sizeof(struct sec_alg_tfm_ctx), .cra_alignmask = 0,
@@ -1068,7 +1075,8 @@ static struct skcipher_alg sec_algs[] = { .cra_name = "ecb(des3_ede)", .cra_driver_name = "hisi_sec_3des_ecb", .cra_priority = 4001, - .cra_flags = CRYPTO_ALG_ASYNC, + .cra_flags =CRYPTO_ALG_ASYNC | + CRYPTO_ALG_ALLOCATES_MEMORY, .cra_blocksize = DES3_EDE_BLOCK_SIZE, .cra_ctxsize = sizeof(struct sec_alg_tfm_ctx), .cra_alignmask = 0,
drivers/crypto/hisilicon/sec2/sec_crypto.c +2 -2
@@ -1435,7 +1435,7 @@ static int sec_skcipher_decrypt(struct skcipher_request *sk_req) .cra_name = sec_cra_name,\ .cra_driver_name = "hisi_sec_"sec_cra_name,\ .cra_priority = SEC_PRIORITY,\ - .cra_flags = CRYPTO_ALG_ASYNC,\ + .cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY,\ .cra_blocksize = blk_size,\ .cra_ctxsize = sizeof(struct sec_ctx),\ .cra_module = THIS_MODULE,\
@@ -1558,7 +1558,7 @@ static int sec_aead_decrypt(struct aead_request *a_req) .cra_name = sec_cra_name,\ .cra_driver_name = "hisi_sec_"sec_cra_name,\ .cra_priority = SEC_PRIORITY,\ - .cra_flags = CRYPTO_ALG_ASYNC,\ + .cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY,\ .cra_blocksize = blk_size,\ .cra_ctxsize = sizeof(struct sec_ctx),\ .cra_module = THIS_MODULE,\
drivers/crypto/inside-secure/safexcel_cipher.c +47 -0
329 lines not on this page · raw message
drivers/crypto/inside-secure/safexcel_hash.c +18 -0
@@ -992,6 +992,7 @@ struct safexcel_alg_template safexcel_alg_sha1 = { .cra_driver_name = "safexcel-sha1", .cra_priority = SAFEXCEL_CRA_PRIORITY, .cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY | CRYPTO_ALG_KERN_DRIVER_ONLY, .cra_blocksize = SHA1_BLOCK_SIZE, .cra_ctxsize = sizeof(struct safexcel_ahash_ctx),
@@ -1235,6 +1236,7 @@ struct safexcel_alg_template safexcel_alg_hmac_sha1 = { .cra_driver_name = "safexcel-hmac-sha1", .cra_priority = SAFEXCEL_CRA_PRIORITY, .cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY | CRYPTO_ALG_KERN_DRIVER_ONLY, .cra_blocksize = SHA1_BLOCK_SIZE, .cra_ctxsize = sizeof(struct safexcel_ahash_ctx),
@@ -1291,6 +1293,7 @@ struct safexcel_alg_template safexcel_alg_sha256 = { .cra_driver_name = "safexcel-sha256", .cra_priority = SAFEXCEL_CRA_PRIORITY, .cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY | CRYPTO_ALG_KERN_DRIVER_ONLY, .cra_blocksize = SHA256_BLOCK_SIZE, .cra_ctxsize = sizeof(struct safexcel_ahash_ctx),
@@ -1347,6 +1350,7 @@ struct safexcel_alg_template safexcel_alg_sha224 = { .cra_driver_name = "safexcel-sha224", .cra_priority = SAFEXCEL_CRA_PRIORITY, .cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY | CRYPTO_ALG_KERN_DRIVER_ONLY, .cra_blocksize = SHA224_BLOCK_SIZE, .cra_ctxsize = sizeof(struct safexcel_ahash_ctx),
@@ -1418,6 +1422,7 @@ struct safexcel_alg_template safexcel_alg_hmac_sha224 = { .cra_driver_name = "safexcel-hmac-sha224", .cra_priority = SAFEXCEL_CRA_PRIORITY, .cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY | CRYPTO_ALG_KERN_DRIVER_ONLY, .cra_blocksize = SHA224_BLOCK_SIZE, .cra_ctxsize = sizeof(struct safexcel_ahash_ctx),
@@ -1489,6 +1494,7 @@ struct safexcel_alg_template safexcel_alg_hmac_sha256 = { .cra_driver_name = "safexcel-hmac-sha256", .cra_priority = SAFEXCEL_CRA_PRIORITY, .cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY | CRYPTO_ALG_KERN_DRIVER_ONLY, .cra_blocksize = SHA256_BLOCK_SIZE, .cra_ctxsize = sizeof(struct safexcel_ahash_ctx),
@@ -1545,6 +1551,7 @@ struct safexcel_alg_template safexcel_alg_sha512 = { .cra_driver_name = "safexcel-sha512", .cra_priority = SAFEXCEL_CRA_PRIORITY, .cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY | CRYPTO_ALG_KERN_DRIVER_ONLY, .cra_blocksize = SHA512_BLOCK_SIZE, .cra_ctxsize = sizeof(struct safexcel_ahash_ctx),
@@ -1601,6 +1608,7 @@ struct safexcel_alg_template safexcel_alg_sha384 = { .cra_driver_name = "safexcel-sha384", .cra_priority = SAFEXCEL_CRA_PRIORITY, .cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY | CRYPTO_ALG_KERN_DRIVER_ONLY, .cra_blocksize = SHA384_BLOCK_SIZE, .cra_ctxsize = sizeof(struct safexcel_ahash_ctx),
@@ -1672,6 +1680,7 @@ struct safexcel_alg_template safexcel_alg_hmac_sha512 = { .cra_driver_name = "safexcel-hmac-sha512", .cra_priority = SAFEXCEL_CRA_PRIORITY, .cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY | CRYPTO_ALG_KERN_DRIVER_ONLY, .cra_blocksize = SHA512_BLOCK_SIZE, .cra_ctxsize = sizeof(struct safexcel_ahash_ctx),
@@ -1743,6 +1752,7 @@ struct safexcel_alg_template safexcel_alg_hmac_sha384 = { .cra_driver_name = "safexcel-hmac-sha384", .cra_priority = SAFEXCEL_CRA_PRIORITY, .cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY | CRYPTO_ALG_KERN_DRIVER_ONLY, .cra_blocksize = SHA384_BLOCK_SIZE, .cra_ctxsize = sizeof(struct safexcel_ahash_ctx),
@@ -1799,6 +1809,7 @@ struct safexcel_alg_template safexcel_alg_md5 = { .cra_driver_name = "safexcel-md5", .cra_priority = SAFEXCEL_CRA_PRIORITY, .cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY | CRYPTO_ALG_KERN_DRIVER_ONLY, .cra_blocksize = MD5_HMAC_BLOCK_SIZE, .cra_ctxsize = sizeof(struct safexcel_ahash_ctx),
@@ -1871,6 +1882,7 @@ struct safexcel_alg_template safexcel_alg_hmac_md5 = { .cra_driver_name = "safexcel-hmac-md5", .cra_priority = SAFEXCEL_CRA_PRIORITY, .cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY | CRYPTO_ALG_KERN_DRIVER_ONLY, .cra_blocksize = MD5_HMAC_BLOCK_SIZE, .cra_ctxsize = sizeof(struct safexcel_ahash_ctx),
@@ -1952,6 +1964,7 @@ struct safexcel_alg_template safexcel_alg_crc32 = { .cra_priority = SAFEXCEL_CRA_PRIORITY, .cra_flags =CRYPTO_ALG_OPTIONAL_KEY |CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY | CRYPTO_ALG_KERN_DRIVER_ONLY, .cra_blocksize = 1, .cra_ctxsize = sizeof(struct safexcel_ahash_ctx),
@@ -2041,6 +2054,7 @@ struct safexcel_alg_template safexcel_alg_cbcmac = { .cra_driver_name = "safexcel-cbcmac-aes", .cra_priority = SAFEXCEL_CRA_PRIORITY, .cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY | CRYPTO_ALG_KERN_DRIVER_ONLY, .cra_blocksize = 1, .cra_ctxsize = sizeof(struct safexcel_ahash_ctx),
@@ -2136,6 +2150,7 @@ struct safexcel_alg_template safexcel_alg_xcbcmac = { .cra_driver_name = "safexcel-xcbc-aes", .cra_priority = SAFEXCEL_CRA_PRIORITY, .cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY | CRYPTO_ALG_KERN_DRIVER_ONLY, .cra_blocksize = AES_BLOCK_SIZE, .cra_ctxsize = sizeof(struct safexcel_ahash_ctx),
@@ -2232,6 +2247,7 @@ struct safexcel_alg_template safexcel_alg_cmac = { .cra_driver_name = "safexcel-cmac-aes", .cra_priority = SAFEXCEL_CRA_PRIORITY, .cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY | CRYPTO_ALG_KERN_DRIVER_ONLY, .cra_blocksize = AES_BLOCK_SIZE, .cra_ctxsize = sizeof(struct safexcel_ahash_ctx),
@@ -2288,6 +2304,7 @@ struct safexcel_alg_template safexcel_alg_sm3 = { .cra_driver_name = "safexcel-sm3", .cra_priority = SAFEXCEL_CRA_PRIORITY, .cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY | CRYPTO_ALG_KERN_DRIVER_ONLY, .cra_blocksize = SM3_BLOCK_SIZE, .cra_ctxsize = sizeof(struct safexcel_ahash_ctx),
@@ -2359,6 +2376,7 @@ struct safexcel_alg_template safexcel_alg_hmac_sm3 = { .cra_driver_name = "safexcel-hmac-sm3", .cra_priority = SAFEXCEL_CRA_PRIORITY, .cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY | CRYPTO_ALG_KERN_DRIVER_ONLY, .cra_blocksize = SM3_BLOCK_SIZE, .cra_ctxsize = sizeof(struct safexcel_ahash_ctx),
drivers/crypto/ixp4xx_crypto.c +4 -2
@@ -1402,7 +1402,8 @@ static int __init ixp_module_init(void)/* block ciphers */ cra->base.cra_flags =CRYPTO_ALG_KERN_DRIVER_ONLY | -CRYPTO_ALG_ASYNC ; +CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY ;if (!cra->setkey) cra->setkey = ablk_setkey;if (!cra->encrypt)
@@ -1435,7 +1436,8 @@ static int __init ixp_module_init(void)/* authenc */ cra->base.cra_flags =CRYPTO_ALG_KERN_DRIVER_ONLY | -CRYPTO_ALG_ASYNC ; +CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY ; cra->setkey = cra->setkey ?: aead_setkey; cra->setauthsize = aead_setauthsize; cra->encrypt = aead_encrypt;
drivers/crypto/marvell/cesa/cipher.c +12 -6
@@ -508,7 +508,8 @@ struct skcipher_alg mv_cesa_ecb_des_alg = { .cra_name = "ecb(des)", .cra_driver_name = "mv-ecb-des", .cra_priority = 300, - .cra_flags = CRYPTO_ALG_KERN_DRIVER_ONLY | CRYPTO_ALG_ASYNC, + .cra_flags =CRYPTO_ALG_KERN_DRIVER_ONLY |CRYPTO_ALG_ASYNC | + CRYPTO_ALG_ALLOCATES_MEMORY, .cra_blocksize = DES_BLOCK_SIZE, .cra_ctxsize = sizeof(struct mv_cesa_des_ctx), .cra_alignmask = 0,
@@ -558,7 +559,8 @@ struct skcipher_alg mv_cesa_cbc_des_alg = { .cra_name = "cbc(des)", .cra_driver_name = "mv-cbc-des", .cra_priority = 300, - .cra_flags = CRYPTO_ALG_KERN_DRIVER_ONLY | CRYPTO_ALG_ASYNC, + .cra_flags =CRYPTO_ALG_KERN_DRIVER_ONLY |CRYPTO_ALG_ASYNC | + CRYPTO_ALG_ALLOCATES_MEMORY, .cra_blocksize = DES_BLOCK_SIZE, .cra_ctxsize = sizeof(struct mv_cesa_des_ctx), .cra_alignmask = 0,
@@ -616,7 +618,8 @@ struct skcipher_alg mv_cesa_ecb_des3_ede_alg = { .cra_name = "ecb(des3_ede)", .cra_driver_name = "mv-ecb-des3-ede", .cra_priority = 300, - .cra_flags = CRYPTO_ALG_KERN_DRIVER_ONLY | CRYPTO_ALG_ASYNC, + .cra_flags =CRYPTO_ALG_KERN_DRIVER_ONLY |CRYPTO_ALG_ASYNC | + CRYPTO_ALG_ALLOCATES_MEMORY, .cra_blocksize = DES3_EDE_BLOCK_SIZE, .cra_ctxsize = sizeof(struct mv_cesa_des3_ctx), .cra_alignmask = 0,
@@ -669,7 +672,8 @@ struct skcipher_alg mv_cesa_cbc_des3_ede_alg = { .cra_name = "cbc(des3_ede)", .cra_driver_name = "mv-cbc-des3-ede", .cra_priority = 300, - .cra_flags = CRYPTO_ALG_KERN_DRIVER_ONLY | CRYPTO_ALG_ASYNC, + .cra_flags =CRYPTO_ALG_KERN_DRIVER_ONLY |CRYPTO_ALG_ASYNC | + CRYPTO_ALG_ALLOCATES_MEMORY, .cra_blocksize = DES3_EDE_BLOCK_SIZE, .cra_ctxsize = sizeof(struct mv_cesa_des3_ctx), .cra_alignmask = 0,
@@ -741,7 +745,8 @@ struct skcipher_alg mv_cesa_ecb_aes_alg = { .cra_name = "ecb(aes)", .cra_driver_name = "mv-ecb-aes", .cra_priority = 300, - .cra_flags = CRYPTO_ALG_KERN_DRIVER_ONLY | CRYPTO_ALG_ASYNC, + .cra_flags =CRYPTO_ALG_KERN_DRIVER_ONLY |CRYPTO_ALG_ASYNC | + CRYPTO_ALG_ALLOCATES_MEMORY, .cra_blocksize = AES_BLOCK_SIZE, .cra_ctxsize = sizeof(struct mv_cesa_aes_ctx), .cra_alignmask = 0,
@@ -790,7 +795,8 @@ struct skcipher_alg mv_cesa_cbc_aes_alg = { .cra_name = "cbc(aes)", .cra_driver_name = "mv-cbc-aes", .cra_priority = 300, - .cra_flags = CRYPTO_ALG_KERN_DRIVER_ONLY | CRYPTO_ALG_ASYNC, + .cra_flags =CRYPTO_ALG_KERN_DRIVER_ONLY |CRYPTO_ALG_ASYNC | + CRYPTO_ALG_ALLOCATES_MEMORY, .cra_blocksize = AES_BLOCK_SIZE, .cra_ctxsize = sizeof(struct mv_cesa_aes_ctx), .cra_alignmask = 0,
drivers/crypto/marvell/cesa/hash.c +6 -0
@@ -921,6 +921,7 @@ struct ahash_alg mv_md5_alg = { .cra_driver_name = "mv-md5", .cra_priority = 300, .cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY | CRYPTO_ALG_KERN_DRIVER_ONLY, .cra_blocksize = MD5_HMAC_BLOCK_SIZE, .cra_ctxsize = sizeof(struct mv_cesa_hash_ctx),
@@ -991,6 +992,7 @@ struct ahash_alg mv_sha1_alg = { .cra_driver_name = "mv-sha1", .cra_priority = 300, .cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY | CRYPTO_ALG_KERN_DRIVER_ONLY, .cra_blocksize = SHA1_BLOCK_SIZE, .cra_ctxsize = sizeof(struct mv_cesa_hash_ctx),
@@ -1064,6 +1066,7 @@ struct ahash_alg mv_sha256_alg = { .cra_driver_name = "mv-sha256", .cra_priority = 300, .cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY | CRYPTO_ALG_KERN_DRIVER_ONLY, .cra_blocksize = SHA256_BLOCK_SIZE, .cra_ctxsize = sizeof(struct mv_cesa_hash_ctx),
@@ -1298,6 +1301,7 @@ struct ahash_alg mv_ahmac_md5_alg = { .cra_driver_name = "mv-hmac-md5", .cra_priority = 300, .cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY | CRYPTO_ALG_KERN_DRIVER_ONLY, .cra_blocksize = MD5_HMAC_BLOCK_SIZE, .cra_ctxsize = sizeof(struct mv_cesa_hmac_ctx),
@@ -1368,6 +1372,7 @@ struct ahash_alg mv_ahmac_sha1_alg = { .cra_driver_name = "mv-hmac-sha1", .cra_priority = 300, .cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY | CRYPTO_ALG_KERN_DRIVER_ONLY, .cra_blocksize = SHA1_BLOCK_SIZE, .cra_ctxsize = sizeof(struct mv_cesa_hmac_ctx),
@@ -1438,6 +1443,7 @@ struct ahash_alg mv_ahmac_sha256_alg = { .cra_driver_name = "mv-hmac-sha256", .cra_priority = 300, .cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY | CRYPTO_ALG_KERN_DRIVER_ONLY, .cra_blocksize = SHA256_BLOCK_SIZE, .cra_ctxsize = sizeof(struct mv_cesa_hmac_ctx),
drivers/crypto/marvell/octeontx/otx_cptvf_algs.c +15 -15
@@ -1301,7 +1301,7 @@ static int otx_cpt_aead_null_decrypt(struct aead_request *req)static struct skcipher_alg otx_cpt_skciphers[] = { { .base.cra_name ="xts(aes)" , .base.cra_driver_name ="cpt_xts_aes" , - .base.cra_flags =CRYPTO_ALG_ASYNC , + .base.cra_flags =CRYPTO_ALG_ASYNC |CRYPTO_ALG_ALLOCATES_MEMORY , .base.cra_blocksize =AES_BLOCK_SIZE , .base.cra_ctxsize =sizeof (struct otx_cpt_enc_ctx ), .base.cra_alignmask =7 ,
@@ -1318,7 +1318,7 @@ static struct skcipher_alg otx_cpt_skciphers[] = { { }, { .base.cra_name = "cbc(aes)", .base.cra_driver_name = "cpt_cbc_aes", - .base.cra_flags = CRYPTO_ALG_ASYNC, + .base.cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, .base.cra_blocksize = AES_BLOCK_SIZE, .base.cra_ctxsize = sizeof(struct otx_cpt_enc_ctx), .base.cra_alignmask = 7,
@@ -1335,7 +1335,7 @@ static struct skcipher_alg otx_cpt_skciphers[] = { { }, { .base.cra_name = "ecb(aes)", .base.cra_driver_name = "cpt_ecb_aes", - .base.cra_flags = CRYPTO_ALG_ASYNC, + .base.cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, .base.cra_blocksize = AES_BLOCK_SIZE, .base.cra_ctxsize = sizeof(struct otx_cpt_enc_ctx), .base.cra_alignmask = 7,
@@ -1352,7 +1352,7 @@ static struct skcipher_alg otx_cpt_skciphers[] = { { }, { .base.cra_name = "cfb(aes)", .base.cra_driver_name = "cpt_cfb_aes", - .base.cra_flags = CRYPTO_ALG_ASYNC, + .base.cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, .base.cra_blocksize = AES_BLOCK_SIZE, .base.cra_ctxsize = sizeof(struct otx_cpt_enc_ctx), .base.cra_alignmask = 7,
@@ -1369,7 +1369,7 @@ static struct skcipher_alg otx_cpt_skciphers[] = { { }, { .base.cra_name = "cbc(des3_ede)", .base.cra_driver_name = "cpt_cbc_des3_ede", - .base.cra_flags = CRYPTO_ALG_ASYNC, + .base.cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, .base.cra_blocksize = DES3_EDE_BLOCK_SIZE, .base.cra_ctxsize = sizeof(struct otx_cpt_des3_ctx), .base.cra_alignmask = 7,
@@ -1386,7 +1386,7 @@ static struct skcipher_alg otx_cpt_skciphers[] = { { }, { .base.cra_name = "ecb(des3_ede)", .base.cra_driver_name = "cpt_ecb_des3_ede", - .base.cra_flags = CRYPTO_ALG_ASYNC, + .base.cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, .base.cra_blocksize = DES3_EDE_BLOCK_SIZE, .base.cra_ctxsize = sizeof(struct otx_cpt_des3_ctx), .base.cra_alignmask = 7,
@@ -1407,7 +1407,7 @@ static struct aead_alg otx_cpt_aeads[] = { { .cra_name = "authenc(hmac(sha1),cbc(aes))", .cra_driver_name = "cpt_hmac_sha1_cbc_aes", .cra_blocksize = AES_BLOCK_SIZE, - .cra_flags = CRYPTO_ALG_ASYNC, + .cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, .cra_ctxsize = sizeof(struct otx_cpt_aead_ctx), .cra_priority = 4001, .cra_alignmask = 0,
@@ -1426,7 +1426,7 @@ static struct aead_alg otx_cpt_aeads[] = { { .cra_name = "authenc(hmac(sha256),cbc(aes))", .cra_driver_name = "cpt_hmac_sha256_cbc_aes", .cra_blocksize = AES_BLOCK_SIZE, - .cra_flags = CRYPTO_ALG_ASYNC, + .cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, .cra_ctxsize = sizeof(struct otx_cpt_aead_ctx), .cra_priority = 4001, .cra_alignmask = 0,
@@ -1445,7 +1445,7 @@ static struct aead_alg otx_cpt_aeads[] = { { .cra_name = "authenc(hmac(sha384),cbc(aes))", .cra_driver_name = "cpt_hmac_sha384_cbc_aes", .cra_blocksize = AES_BLOCK_SIZE, - .cra_flags = CRYPTO_ALG_ASYNC, + .cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, .cra_ctxsize = sizeof(struct otx_cpt_aead_ctx), .cra_priority = 4001, .cra_alignmask = 0,
@@ -1464,7 +1464,7 @@ static struct aead_alg otx_cpt_aeads[] = { { .cra_name = "authenc(hmac(sha512),cbc(aes))", .cra_driver_name = "cpt_hmac_sha512_cbc_aes", .cra_blocksize = AES_BLOCK_SIZE, - .cra_flags = CRYPTO_ALG_ASYNC, + .cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, .cra_ctxsize = sizeof(struct otx_cpt_aead_ctx), .cra_priority = 4001, .cra_alignmask = 0,
@@ -1483,7 +1483,7 @@ static struct aead_alg otx_cpt_aeads[] = { { .cra_name = "authenc(hmac(sha1),ecb(cipher_null))", .cra_driver_name = "cpt_hmac_sha1_ecb_null", .cra_blocksize = 1, - .cra_flags = CRYPTO_ALG_ASYNC, + .cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, .cra_ctxsize = sizeof(struct otx_cpt_aead_ctx), .cra_priority = 4001, .cra_alignmask = 0,
@@ -1502,7 +1502,7 @@ static struct aead_alg otx_cpt_aeads[] = { { .cra_name = "authenc(hmac(sha256),ecb(cipher_null))", .cra_driver_name = "cpt_hmac_sha256_ecb_null", .cra_blocksize = 1, - .cra_flags = CRYPTO_ALG_ASYNC, + .cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, .cra_ctxsize = sizeof(struct otx_cpt_aead_ctx), .cra_priority = 4001, .cra_alignmask = 0,
@@ -1521,7 +1521,7 @@ static struct aead_alg otx_cpt_aeads[] = { { .cra_name = "authenc(hmac(sha384),ecb(cipher_null))", .cra_driver_name = "cpt_hmac_sha384_ecb_null", .cra_blocksize = 1, - .cra_flags = CRYPTO_ALG_ASYNC, + .cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, .cra_ctxsize = sizeof(struct otx_cpt_aead_ctx), .cra_priority = 4001, .cra_alignmask = 0,
@@ -1540,7 +1540,7 @@ static struct aead_alg otx_cpt_aeads[] = { { .cra_name = "authenc(hmac(sha512),ecb(cipher_null))", .cra_driver_name = "cpt_hmac_sha512_ecb_null", .cra_blocksize = 1, - .cra_flags = CRYPTO_ALG_ASYNC, + .cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, .cra_ctxsize = sizeof(struct otx_cpt_aead_ctx), .cra_priority = 4001, .cra_alignmask = 0,
@@ -1559,7 +1559,7 @@ static struct aead_alg otx_cpt_aeads[] = { { .cra_name = "rfc4106(gcm(aes))", .cra_driver_name = "cpt_rfc4106_gcm_aes", .cra_blocksize = 1, - .cra_flags = CRYPTO_ALG_ASYNC, + .cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, .cra_ctxsize = sizeof(struct otx_cpt_aead_ctx), .cra_priority = 4001, .cra_alignmask = 0,
drivers/crypto/n2_core.c +2 -1
@@ -1382,7 +1382,8 @@ static int __n2_register_one_skcipher(const struct n2_skcipher_tmpl *tmpl)snprintf (alg->base.cra_name,CRYPTO_MAX_ALG_NAME ,"%s" , tmpl->name);snprintf (alg->base.cra_driver_name,CRYPTO_MAX_ALG_NAME ,"%s-n2" , tmpl->drv_name); alg->base.cra_priority =N2_CRA_PRIORITY ; - alg->base.cra_flags =CRYPTO_ALG_KERN_DRIVER_ONLY |CRYPTO_ALG_ASYNC ; + alg->base.cra_flags =CRYPTO_ALG_KERN_DRIVER_ONLY |CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY ; alg->base.cra_blocksize = tmpl->block_size; p->enc_type = tmpl->enc_type; alg->base.cra_ctxsize =sizeof (struct n2_skcipher_context );
drivers/crypto/picoxcell_crypto.c +15 -2
@@ -1226,6 +1226,7 @@ static struct spacc_alg ipsec_engine_algs[] = { .base.cra_priority = SPACC_CRYPTO_ALG_PRIORITY, .base.cra_flags =CRYPTO_ALG_KERN_DRIVER_ONLY |CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY | CRYPTO_ALG_NEED_FALLBACK, .base.cra_blocksize = AES_BLOCK_SIZE, .base.cra_ctxsize = sizeof(struct spacc_ablk_ctx),
@@ -1251,6 +1252,7 @@ static struct spacc_alg ipsec_engine_algs[] = { .base.cra_priority = SPACC_CRYPTO_ALG_PRIORITY, .base.cra_flags =CRYPTO_ALG_KERN_DRIVER_ONLY |CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY | CRYPTO_ALG_NEED_FALLBACK, .base.cra_blocksize = AES_BLOCK_SIZE, .base.cra_ctxsize = sizeof(struct spacc_ablk_ctx),
@@ -1274,7 +1276,8 @@ static struct spacc_alg ipsec_engine_algs[] = { .base.cra_driver_name = "cbc-des-picoxcell", .base.cra_priority = SPACC_CRYPTO_ALG_PRIORITY, .base.cra_flags =CRYPTO_ALG_KERN_DRIVER_ONLY | - CRYPTO_ALG_ASYNC, +CRYPTO_ALG_ASYNC | + CRYPTO_ALG_ALLOCATES_MEMORY, .base.cra_blocksize = DES_BLOCK_SIZE, .base.cra_ctxsize = sizeof(struct spacc_ablk_ctx), .base.cra_module = THIS_MODULE,
@@ -1298,7 +1301,8 @@ static struct spacc_alg ipsec_engine_algs[] = { .base.cra_driver_name = "ecb-des-picoxcell", .base.cra_priority = SPACC_CRYPTO_ALG_PRIORITY, .base.cra_flags =CRYPTO_ALG_KERN_DRIVER_ONLY | - CRYPTO_ALG_ASYNC, +CRYPTO_ALG_ASYNC | + CRYPTO_ALG_ALLOCATES_MEMORY, .base.cra_blocksize = DES_BLOCK_SIZE, .base.cra_ctxsize = sizeof(struct spacc_ablk_ctx), .base.cra_module = THIS_MODULE,
@@ -1321,6 +1325,7 @@ static struct spacc_alg ipsec_engine_algs[] = { .base.cra_driver_name = "cbc-des3-ede-picoxcell", .base.cra_priority = SPACC_CRYPTO_ALG_PRIORITY, .base.cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY | CRYPTO_ALG_KERN_DRIVER_ONLY, .base.cra_blocksize = DES3_EDE_BLOCK_SIZE, .base.cra_ctxsize = sizeof(struct spacc_ablk_ctx),
@@ -1345,6 +1350,7 @@ static struct spacc_alg ipsec_engine_algs[] = { .base.cra_driver_name = "ecb-des3-ede-picoxcell", .base.cra_priority = SPACC_CRYPTO_ALG_PRIORITY, .base.cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY | CRYPTO_ALG_KERN_DRIVER_ONLY, .base.cra_blocksize = DES3_EDE_BLOCK_SIZE, .base.cra_ctxsize = sizeof(struct spacc_ablk_ctx),
@@ -1376,6 +1382,7 @@ static struct spacc_aead ipsec_engine_aeads[] = { "cbc-aes-picoxcell", .cra_priority = SPACC_CRYPTO_ALG_PRIORITY, .cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY |CRYPTO_ALG_NEED_FALLBACK | CRYPTO_ALG_KERN_DRIVER_ONLY, .cra_blocksize = AES_BLOCK_SIZE,
@@ -1406,6 +1413,7 @@ static struct spacc_aead ipsec_engine_aeads[] = { "cbc-aes-picoxcell", .cra_priority = SPACC_CRYPTO_ALG_PRIORITY, .cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY |CRYPTO_ALG_NEED_FALLBACK | CRYPTO_ALG_KERN_DRIVER_ONLY, .cra_blocksize = AES_BLOCK_SIZE,
@@ -1436,6 +1444,7 @@ static struct spacc_aead ipsec_engine_aeads[] = { "cbc-aes-picoxcell", .cra_priority = SPACC_CRYPTO_ALG_PRIORITY, .cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY |CRYPTO_ALG_NEED_FALLBACK | CRYPTO_ALG_KERN_DRIVER_ONLY, .cra_blocksize = AES_BLOCK_SIZE,
@@ -1466,6 +1475,7 @@ static struct spacc_aead ipsec_engine_aeads[] = { "cbc-3des-picoxcell", .cra_priority = SPACC_CRYPTO_ALG_PRIORITY, .cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY |CRYPTO_ALG_NEED_FALLBACK | CRYPTO_ALG_KERN_DRIVER_ONLY, .cra_blocksize = DES3_EDE_BLOCK_SIZE,
@@ -1497,6 +1507,7 @@ static struct spacc_aead ipsec_engine_aeads[] = { "cbc-3des-picoxcell", .cra_priority = SPACC_CRYPTO_ALG_PRIORITY, .cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY |CRYPTO_ALG_NEED_FALLBACK | CRYPTO_ALG_KERN_DRIVER_ONLY, .cra_blocksize = DES3_EDE_BLOCK_SIZE,
@@ -1527,6 +1538,7 @@ static struct spacc_aead ipsec_engine_aeads[] = { "cbc-3des-picoxcell", .cra_priority = SPACC_CRYPTO_ALG_PRIORITY, .cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY |CRYPTO_ALG_NEED_FALLBACK | CRYPTO_ALG_KERN_DRIVER_ONLY, .cra_blocksize = DES3_EDE_BLOCK_SIZE,
@@ -1556,6 +1568,7 @@ static struct spacc_alg l2_engine_algs[] = { .base.cra_driver_name = "f8-kasumi-picoxcell", .base.cra_priority = SPACC_CRYPTO_ALG_PRIORITY, .base.cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY | CRYPTO_ALG_KERN_DRIVER_ONLY, .base.cra_blocksize = 8, .base.cra_ctxsize = sizeof(struct spacc_ablk_ctx),
drivers/crypto/qat/qat_common/qat_algs.c +7 -6
@@ -1295,7 +1295,7 @@ static struct aead_alg qat_aeads[] = { { .cra_name = "authenc(hmac(sha1),cbc(aes))", .cra_driver_name = "qat_aes_cbc_hmac_sha1", .cra_priority = 4001, - .cra_flags = CRYPTO_ALG_ASYNC, + .cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, .cra_blocksize = AES_BLOCK_SIZE, .cra_ctxsize = sizeof(struct qat_alg_aead_ctx), .cra_module = THIS_MODULE,
@@ -1312,7 +1312,7 @@ static struct aead_alg qat_aeads[] = { { .cra_name = "authenc(hmac(sha256),cbc(aes))", .cra_driver_name = "qat_aes_cbc_hmac_sha256", .cra_priority = 4001, - .cra_flags = CRYPTO_ALG_ASYNC, + .cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, .cra_blocksize = AES_BLOCK_SIZE, .cra_ctxsize = sizeof(struct qat_alg_aead_ctx), .cra_module = THIS_MODULE,
@@ -1329,7 +1329,7 @@ static struct aead_alg qat_aeads[] = { { .cra_name = "authenc(hmac(sha512),cbc(aes))", .cra_driver_name = "qat_aes_cbc_hmac_sha512", .cra_priority = 4001, - .cra_flags = CRYPTO_ALG_ASYNC, + .cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, .cra_blocksize = AES_BLOCK_SIZE, .cra_ctxsize = sizeof(struct qat_alg_aead_ctx), .cra_module = THIS_MODULE,
@@ -1347,7 +1347,7 @@ static struct skcipher_alg qat_skciphers[] = { { .base.cra_name = "cbc(aes)", .base.cra_driver_name = "qat_aes_cbc", .base.cra_priority = 4001, - .base.cra_flags = CRYPTO_ALG_ASYNC, + .base.cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, .base.cra_blocksize = AES_BLOCK_SIZE, .base.cra_ctxsize = sizeof(struct qat_alg_skcipher_ctx), .base.cra_alignmask = 0,
@@ -1365,7 +1365,7 @@ static struct skcipher_alg qat_skciphers[] = { { .base.cra_name = "ctr(aes)", .base.cra_driver_name = "qat_aes_ctr", .base.cra_priority = 4001, - .base.cra_flags = CRYPTO_ALG_ASYNC, + .base.cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_ALLOCATES_MEMORY, .base.cra_blocksize = 1, .base.cra_ctxsize = sizeof(struct qat_alg_skcipher_ctx), .base.cra_alignmask = 0,
@@ -1383,7 +1383,8 @@ static struct skcipher_alg qat_skciphers[] = { { .base.cra_name = "xts(aes)", .base.cra_driver_name = "qat_aes_xts", .base.cra_priority = 4001, - .base.cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK, + .base.cra_flags =CRYPTO_ALG_ASYNC |CRYPTO_ALG_NEED_FALLBACK | + CRYPTO_ALG_ALLOCATES_MEMORY, .base.cra_blocksize = AES_BLOCK_SIZE, .base.cra_ctxsize = sizeof(struct qat_alg_skcipher_ctx), .base.cra_alignmask = 0,
drivers/crypto/qce/skcipher.c +1 -0
@@ -404,6 +404,7 @@ static int qce_skcipher_register_one(const struct qce_skcipher_def *def, alg->base.cra_priority =300 ; alg->base.cra_flags =CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY |CRYPTO_ALG_KERN_DRIVER_ONLY ; alg->base.cra_ctxsize =sizeof (struct qce_cipher_ctx ); alg->base.cra_alignmask =0 ;
drivers/crypto/talitos.c +78 -39
351 lines not on this page · raw message
drivers/crypto/virtio/virtio_crypto_algs.c +2 -1
@@ -597,7 +597,8 @@ static struct virtio_crypto_algo virtio_crypto_algs[] = { { .base.cra_name = "cbc(aes)", .base.cra_driver_name = "virtio_crypto_aes_cbc", .base.cra_priority = 150, - .base.cra_flags = CRYPTO_ALG_ASYNC, + .base.cra_flags =CRYPTO_ALG_ASYNC | + CRYPTO_ALG_ALLOCATES_MEMORY, .base.cra_blocksize = AES_BLOCK_SIZE, .base.cra_ctxsize = sizeof(struct virtio_crypto_skcipher_ctx), .base.cra_module = THIS_MODULE,
drivers/crypto/xilinx/zynqmp-aes-gcm.c +1 -0
@@ -364,6 +364,7 @@ static struct zynqmp_aead_drv_ctx aes_drv_ctx = { .cra_priority = 200, .cra_flags =CRYPTO_ALG_TYPE_AEAD |CRYPTO_ALG_ASYNC | +CRYPTO_ALG_ALLOCATES_MEMORY |CRYPTO_ALG_KERN_DRIVER_ONLY | CRYPTO_ALG_NEED_FALLBACK, .cra_blocksize = ZYNQMP_AES_BLK_SIZE,
Signature · 1 line
2.27.0
PATCH v2 7/7 dm-crypt: don't use drivers that have CRYPTO_ALG_ALLOCATES_MEMORY
In reply to Eric BiggersFrom: Mikulas Patocka <[email protected]>
Don't use crypto drivers that have the flag CRYPTO_ALG_ALLOCATES_MEMORY set. These drivers allocate memory and thus they are unsuitable for block I/O processing.
--- drivers/md/dm-crypt.c | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-)
drivers/md/dm-crypt.c +11 -6
@@ -421,7 +421,8 @@ static int crypt_iv_lmk_ctr(struct crypt_config *cc, struct dm_target *ti,return -EINVAL ; } - lmk->hash_tfm =crypto_alloc_shash ("md5" ,0 ,0 ); + lmk->hash_tfm =crypto_alloc_shash ("md5" ,0 , +CRYPTO_ALG_ALLOCATES_MEMORY );if (IS_ERR (lmk->hash_tfm)) { ti->error ="Error initializing LMK hash" ;return PTR_ERR (lmk->hash_tfm);
@@ -583,7 +584,8 @@ static int crypt_iv_tcw_ctr(struct crypt_config *cc, struct dm_target *ti,return -EINVAL ; } - tcw->crc32_tfm =crypto_alloc_shash ("crc32" ,0 ,0 ); + tcw->crc32_tfm =crypto_alloc_shash ("crc32" ,0 , +CRYPTO_ALG_ALLOCATES_MEMORY );if (IS_ERR (tcw->crc32_tfm)) { ti->error ="Error initializing CRC32 in TCW" ;return PTR_ERR (tcw->crc32_tfm);
@@ -770,7 +772,8 @@ static int crypt_iv_elephant_ctr(struct crypt_config *cc, struct dm_target *ti,struct iv_elephant_private *elephant = &cc->iv_gen_private.elephant;int r; - elephant->tfm =crypto_alloc_skcipher ("ecb(aes)" ,0 ,0 ); + elephant->tfm =crypto_alloc_skcipher ("ecb(aes)" ,0 , +CRYPTO_ALG_ALLOCATES_MEMORY );if (IS_ERR (elephant->tfm)) { r =PTR_ERR (elephant->tfm); elephant->tfm =NULL ;
@@ -2090,7 +2093,8 @@ static int crypt_alloc_tfms_skcipher(struct crypt_config *cc, char *ciphermode)return -ENOMEM ;for (i =0 ; i < cc->tfms_count; i++) { - cc->cipher_tfm.tfms[i] =crypto_alloc_skcipher (ciphermode,0 ,0 ); + cc->cipher_tfm.tfms[i] =crypto_alloc_skcipher (ciphermode,0 , +CRYPTO_ALG_ALLOCATES_MEMORY );if (IS_ERR (cc->cipher_tfm.tfms[i])) { err =PTR_ERR (cc->cipher_tfm.tfms[i]);crypt_free_tfms (cc);
@@ -2116,7 +2120,8 @@ static int crypt_alloc_tfms_aead(struct crypt_config *cc, char *ciphermode)if (!cc->cipher_tfm.tfms)return -ENOMEM ; - cc->cipher_tfm.tfms_aead[0 ] =crypto_alloc_aead (ciphermode,0 ,0 ); + cc->cipher_tfm.tfms_aead[0 ] =crypto_alloc_aead (ciphermode,0 , +CRYPTO_ALG_ALLOCATES_MEMORY );if (IS_ERR (cc->cipher_tfm.tfms_aead[0 ])) { err =PTR_ERR (cc->cipher_tfm.tfms_aead[0 ]);crypt_free_tfms (cc);
@@ -2603,7 +2608,7 @@ static int crypt_ctr_auth_cipher(struct crypt_config *cc, char *cipher_api)return -ENOMEM ;strncpy (mac_alg, start, end - start); - mac =crypto_alloc_ahash (mac_alg,0 ,0 ); + mac =crypto_alloc_ahash (mac_alg,0 ,CRYPTO_ALG_ALLOCATES_MEMORY );kfree (mac_alg);if (IS_ERR (mac))
Signature · 1 line
2.27.0
Herbert Xu
maintainerQuoted 98 lines · Eric Biggers
This series introduces a flag that algorithms can set to indicate that they allocate memory during processing of typical inputs, and thus shouldn't be used in cases like dm-crypt where memory allocation failures aren't acceptable.
Compared to Mikulas's patches, I've made the following improvements:
- Tried to clearly document the semantics of
CRYPTO_ALG_ALLOCATES_MEMORY. This includes documenting the usage constraints, since there are actually lots of cases that were overlooked where algorithms can still allocate memory in some edge cases where inputs are misaligned, fragemented, etc. E.g. seecrypto/skcipher.candcrypto/ahash.c. Mikulas, please let me know if there are any concerns for dm-crypt.- Moved the common mechanism for inheriting flags to its own patch.
-
crypto_grab_spawn()now handles propagatingCRYPTO_ALG_INHERITED_FLAGSto the new template instance.- Inherit the flags in various places that were missed.
- Other cleanups.
Additional changes v1 => v2:
- Made
crypto_check_attr_type()return the mask.- Added patch that adds
NEED_FALLBACKtoINHERITED_FLAGS.- Added patch that removes
seqiv_create().Eric Biggers (5):
crypto: geniv - remove unneeded arguments fromaead_geniv_alloc()
crypto: seqiv - removeseqiv_create()
crypto: algapi - use common mechanism for inheriting flags
crypto: algapi - addNEED_FALLBACKtoINHERITED_FLAGS
crypto: algapi - introduce the flagCRYPTO_ALG_ALLOCATES_MEMORYMikulas Patocka (2):
crypto: drivers - set the flagCRYPTO_ALG_ALLOCATES_MEMORY
dm-crypt: don't use drivers that haveCRYPTO_ALG_ALLOCATES_MEMORYcrypto/adiantum.c | 14 +-- crypto/algapi.c | 21 +++- crypto/authenc.c | 14 +-- crypto/authencesn.c | 14 +-- crypto/ccm.c | 33 ++--- crypto/chacha20poly1305.c | 14 +-- crypto/cmac.c | 5 +- crypto/cryptd.c | 59 ++++----- crypto/ctr.c | 17 +-- crypto/cts.c | 13 +- crypto/echainiv.c | 2 +- crypto/essiv.c | 11 +- crypto/gcm.c | 40 ++---- crypto/geniv.c | 19 +-- crypto/hmac.c | 5 +- crypto/lrw.c | 13 +- crypto/pcrypt.c | 14 +-- crypto/rsa-pkcs1pad.c | 13 +- crypto/seqiv.c | 18 +-- crypto/simd.c | 6 +- crypto/skcipher.c | 13 +- crypto/vmac.c | 5 +- crypto/xcbc.c | 5 +- crypto/xts.c | 15 +-- .../crypto/allwinner/sun8i-ce/sun8i-ce-core.c | 12 +- .../crypto/allwinner/sun8i-ss/sun8i-ss-core.c | 12 +- drivers/crypto/amlogic/amlogic-gxl-core.c | 6 +- drivers/crypto/axis/artpec6_crypto.c | 20 ++- drivers/crypto/bcm/cipher.c | 72 ++++++++--- drivers/crypto/caam/caamalg.c | 6 +- drivers/crypto/caam/caamalg_qi.c | 6 +- drivers/crypto/caam/caamalg_qi2.c | 8 +- drivers/crypto/caam/caamhash.c | 2 +- drivers/crypto/cavium/cpt/cptvf_algs.c | 18 ++- drivers/crypto/cavium/nitrox/nitrox_aead.c | 4 +- .../crypto/cavium/nitrox/nitrox_skcipher.c | 16 +-- drivers/crypto/ccp/ccp-crypto-aes-cmac.c | 1 + drivers/crypto/ccp/ccp-crypto-aes-galois.c | 1 + drivers/crypto/ccp/ccp-crypto-aes-xts.c | 1 + drivers/crypto/ccp/ccp-crypto-aes.c | 2 + drivers/crypto/ccp/ccp-crypto-des3.c | 1 + drivers/crypto/ccp/ccp-crypto-sha.c | 1 + drivers/crypto/chelsio/chcr_algo.c | 7 +- drivers/crypto/hisilicon/sec/sec_algs.c | 24 ++-- drivers/crypto/hisilicon/sec2/sec_crypto.c | 4 +- .../crypto/inside-secure/safexcel_cipher.c | 47 +++++++ drivers/crypto/inside-secure/safexcel_hash.c | 18 +++ drivers/crypto/ixp4xx_crypto.c | 6 +- drivers/crypto/marvell/cesa/cipher.c | 18 ++- drivers/crypto/marvell/cesa/hash.c | 6 + .../crypto/marvell/octeontx/otx_cptvf_algs.c | 30 ++--- drivers/crypto/n2_core.c | 3 +- drivers/crypto/picoxcell_crypto.c | 17 ++- drivers/crypto/qat/qat_common/qat_algs.c | 13 +- drivers/crypto/qce/skcipher.c | 1 +
Quoted 8 lines
drivers/crypto/talitos.c | 117 ++++++++++++------ drivers/crypto/virtio/virtio_crypto_algs.c | 3 +- drivers/crypto/xilinx/zynqmp-aes-gcm.c | 1 + drivers/md/dm-crypt.c | 17 ++- include/crypto/algapi.h | 25 ++-- include/crypto/internal/geniv.h | 2 +- include/linux/crypto.h | 36 +++++- 62 files changed, 562 insertions(+), 405 deletions(-)
Patches 1-6 applied. Thanks.
Signature · 3 lines
Email: Herbert Xu <[email protected]> Home Page: http://gondor.apana.org.au/~herbert/ PGP Key: http://gondor.apana.org.au/~herbert/pubkey.txt
Horia Geantă
maintainerQuoted 108 lines · Herbert Xu
Quoted 98 lines · Eric Biggers
This series introduces a flag that algorithms can set to indicate that they allocate memory during processing of typical inputs, and thus shouldn't be used in cases like dm-crypt where memory allocation failures aren't acceptable.
Compared to Mikulas's patches, I've made the following improvements:
- Tried to clearly document the semantics of
CRYPTO_ALG_ALLOCATES_MEMORY. This includes documenting the usage constraints, since there are actually lots of cases that were overlooked where algorithms can still allocate memory in some edge cases where inputs are misaligned, fragemented, etc. E.g. seecrypto/skcipher.candcrypto/ahash.c. Mikulas, please let me know if there are any concerns for dm-crypt.- Moved the common mechanism for inheriting flags to its own patch.
-
crypto_grab_spawn()now handles propagatingCRYPTO_ALG_INHERITED_FLAGSto the new template instance.- Inherit the flags in various places that were missed.
- Other cleanups.
Additional changes v1 => v2:
- Made
crypto_check_attr_type()return the mask.- Added patch that adds
NEED_FALLBACKtoINHERITED_FLAGS.- Added patch that removes
seqiv_create().Eric Biggers (5):
crypto: geniv - remove unneeded arguments fromaead_geniv_alloc()
crypto: seqiv - removeseqiv_create()
crypto: algapi - use common mechanism for inheriting flags
crypto: algapi - addNEED_FALLBACKtoINHERITED_FLAGS
crypto: algapi - introduce the flagCRYPTO_ALG_ALLOCATES_MEMORYMikulas Patocka (2):
crypto: drivers - set the flagCRYPTO_ALG_ALLOCATES_MEMORY
dm-crypt: don't use drivers that haveCRYPTO_ALG_ALLOCATES_MEMORYcrypto/adiantum.c | 14 +-- crypto/algapi.c | 21 +++- crypto/authenc.c | 14 +-- crypto/authencesn.c | 14 +-- crypto/ccm.c | 33 ++--- crypto/chacha20poly1305.c | 14 +-- crypto/cmac.c | 5 +- crypto/cryptd.c | 59 ++++----- crypto/ctr.c | 17 +-- crypto/cts.c | 13 +- crypto/echainiv.c | 2 +- crypto/essiv.c | 11 +- crypto/gcm.c | 40 ++---- crypto/geniv.c | 19 +-- crypto/hmac.c | 5 +- crypto/lrw.c | 13 +- crypto/pcrypt.c | 14 +-- crypto/rsa-pkcs1pad.c | 13 +- crypto/seqiv.c | 18 +-- crypto/simd.c | 6 +- crypto/skcipher.c | 13 +- crypto/vmac.c | 5 +- crypto/xcbc.c | 5 +- crypto/xts.c | 15 +-- .../crypto/allwinner/sun8i-ce/sun8i-ce-core.c | 12 +- .../crypto/allwinner/sun8i-ss/sun8i-ss-core.c | 12 +- drivers/crypto/amlogic/amlogic-gxl-core.c | 6 +- drivers/crypto/axis/artpec6_crypto.c | 20 ++- drivers/crypto/bcm/cipher.c | 72 ++++++++--- drivers/crypto/caam/caamalg.c | 6 +- drivers/crypto/caam/caamalg_qi.c | 6 +- drivers/crypto/caam/caamalg_qi2.c | 8 +- drivers/crypto/caam/caamhash.c | 2 +- drivers/crypto/cavium/cpt/cptvf_algs.c | 18 ++- drivers/crypto/cavium/nitrox/nitrox_aead.c | 4 +- .../crypto/cavium/nitrox/nitrox_skcipher.c | 16 +-- drivers/crypto/ccp/ccp-crypto-aes-cmac.c | 1 + drivers/crypto/ccp/ccp-crypto-aes-galois.c | 1 + drivers/crypto/ccp/ccp-crypto-aes-xts.c | 1 + drivers/crypto/ccp/ccp-crypto-aes.c | 2 + drivers/crypto/ccp/ccp-crypto-des3.c | 1 + drivers/crypto/ccp/ccp-crypto-sha.c | 1 + drivers/crypto/chelsio/chcr_algo.c | 7 +- drivers/crypto/hisilicon/sec/sec_algs.c | 24 ++-- drivers/crypto/hisilicon/sec2/sec_crypto.c | 4 +- .../crypto/inside-secure/safexcel_cipher.c | 47 +++++++ drivers/crypto/inside-secure/safexcel_hash.c | 18 +++ drivers/crypto/ixp4xx_crypto.c | 6 +- drivers/crypto/marvell/cesa/cipher.c | 18 ++- drivers/crypto/marvell/cesa/hash.c | 6 + .../crypto/marvell/octeontx/otx_cptvf_algs.c | 30 ++--- drivers/crypto/n2_core.c | 3 +- drivers/crypto/picoxcell_crypto.c | 17 ++- drivers/crypto/qat/qat_common/qat_algs.c | 13 +- drivers/crypto/qce/skcipher.c | 1 +Quoted 8 lines
drivers/crypto/talitos.c | 117 ++++++++++++------ drivers/crypto/virtio/virtio_crypto_algs.c | 3 +- drivers/crypto/xilinx/zynqmp-aes-gcm.c | 1 + drivers/md/dm-crypt.c | 17 ++- include/crypto/algapi.h | 25 ++-- include/crypto/internal/geniv.h | 2 +- include/linux/crypto.h | 36 +++++- 62 files changed, 562 insertions(+), 405 deletions(-)
Quoted 2 lines
Patches 1-6 applied. Thanks.
Looks like there's no mention of a limit on src, dst scatterlists size that crypto implementations could use when pre-allocating memory and crypto users needing CRYPTO_ALG_ALLOCATES_MEMORY should be aware of (for the contract to be honoured):
https://lore.kernel.org/linux-crypto/[email protected]
Another thing I would like to clarify, if possible.
Before forcing all crypto drivers to pre-allocate memory, shouldn't alternatives have been investigated?
The discussion below mentions one, which IIUC was not explored / discussed.
https://lore.kernel.org/linux-crypto/alpine.LRH.2.02.2006100756270.27811@file01.intranet.prod.int.rdu2.redhat.com
Another possibility - I was thinking about setting CRYPTO_TFM_REQ_MAY_SLEEP in dm-crypt and calling the crypto function under memalloc_noio_save. But there are some drivers that do GFP_ATOMIC allocation regardless of CRYPTO_TFM_REQ_MAY_SLEEP.
Thanks,
Horia
Herbert Xu
maintainerQuoted 6 lines · Horia Geantă
Looks like there's no mention of a limit on src, dst scatterlists size that crypto implementations could use when pre-allocating memory and crypto users needing
CRYPTO_ALG_ALLOCATES_MEMORYshould be aware of (for the contract to be honoured):
https://lore.kernel.org/linux-crypto/[email protected]
Good point. I think we should limit this flag only to the cases applicable to dm-crypt, which seems to be 4 entries maximum.
Anything else should be allowed to allocate extra memory as needed.
Thanks,
Signature · 3 lines
Email: Herbert Xu <[email protected]> Home Page: http://gondor.apana.org.au/~herbert/ PGP Key: http://gondor.apana.org.au/~herbert/pubkey.txt
Hi Herbert,
Quoted 8 lines · Herbert Xu
Quoted 6 lines · Horia Geantă
Looks like there's no mention of a limit on src, dst scatterlists size that crypto implementations could use when pre-allocating memory and crypto users needing
CRYPTO_ALG_ALLOCATES_MEMORYshould be aware of (for the contract to be honoured):
https://eur01.safelinks.protection.outlook.com/?url=https%3A%2F%2Flore.kernel.org%2Flinux-crypto%2F780cb500-2241-61bc-eb44-6f872ad567d3%40nxp.com&data=02%7C01%7Ciuliana.prodan%40nxp.com%7Ca077782ce45c4ad3458b08d82e1100ac%7C686ea1d3bc2b4c6fa92cd99c5c301635%7C0%7C1%7C637309997855351100&sdata=T9RLjA%2B4l3zpxUSkFUGTxGQFu4kWfghQAKGyfUco%2Fb8%3D&reserved=0
Quoted 4 lines
Good point. I think we should limit this flag only to the cases applicable to dm-crypt, which seems to be 4 entries maximum.
Anything else should be allowed to allocate extra memory as needed.
I'm working on removing the CRYPTO_ALG_ALLOCATES_MEMORY flag from CAAM.
For memory allocation I want to use the crypto request object and set the size needed in reqsize (as suggested by you https://lore.kernel.org/linux-crypto/[email protected]/).
But CAAM needs DMA-able memory and the current mechanism doesn't allow it.
I want to use Horia's solution from a couple of years ago (https://lore.kernel.org/linux-crypto/[email protected]/), but modify request object allocation only in Crypto API.
What do you think?
Thanks,
Iulia