Commit 7bcb2c99 authored by Eric Biggers's avatar Eric Biggers Committed by Herbert Xu
Browse files

crypto: algapi - use common mechanism for inheriting flags 

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 <mpatocka@redhat.com>
(https://lore.kernel.org/r/alpine.LRH.2.02.2006301414580.30526@file01.intranet.prod.int.rdu2.redhat.com

).

Signed-off-by: default avatarEric Biggers <ebiggers@google.com>
Signed-off-by: default avatarHerbert Xu <herbert@gondor.apana.org.au>
parent 4688111e

crypto/adiantum.c

+3 −11
Original line number Diff line number Diff line
@@ -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
Original line number Diff line number Diff line
@@ -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
Original line number Diff line number Diff line
@@ -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
Original line number Diff line number Diff line
@@ -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
Original line number Diff line number Diff line
@@ -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);

CRA Git | Maintained and supported by SUSTech CRA and CCSE