Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 332f8840 authored by Herbert Xu's avatar Herbert Xu
Browse files

[CRYPTO] ablkcipher: Add distinct ABLKCIPHER type 



Up until now we have ablkcipher algorithms have been identified as
type BLKCIPHER with the ASYNC bit set.  This is suboptimal because
ablkcipher refers to two things.  On the one hand it refers to the
top-level ablkcipher interface with requests.  On the other hand it
refers to and algorithm type underneath.

As it is you cannot request a synchronous block cipher algorithm
with the ablkcipher interface on top.  This is a problem because
we want to be able to eventually phase out the blkcipher top-level
interface.

This patch fixes this by making ABLKCIPHER its own type, just as
we have distinct types for HASH and DIGEST.  The type it associated
with the algorithm implementation only.

Which top-level interface is used for synchronous block ciphers is
then determined by the mask that's used.  If it's a specific mask
then the old blkcipher interface is given, otherwise we go with the
new ablkcipher interface.

Signed-off-by: default avatarHerbert Xu <herbert@gondor.apana.org.au>
parent 86f578de

crypto/authenc.c

+1 −1
Original line number Diff line number Diff line
@@ -292,7 +292,7 @@ static struct crypto_instance *crypto_authenc_alloc(struct rtattr **tb) 
		goto out_put_auth;



	enc = crypto_attr_alg(tb[3], CRYPTO_ALG_TYPE_BLKCIPHER,

			      CRYPTO_ALG_TYPE_MASK);

			      CRYPTO_ALG_TYPE_BLKCIPHER_MASK);

	inst = ERR_PTR(PTR_ERR(enc));

	if (IS_ERR(enc))

		goto out_put_auth;

crypto/blkcipher.c

+3 −6
Original line number Diff line number Diff line
@@ -433,9 +433,8 @@ static unsigned int crypto_blkcipher_ctxsize(struct crypto_alg *alg, u32 type, 
	struct blkcipher_alg *cipher = &alg->cra_blkcipher;

	unsigned int len = alg->cra_ctxsize;



	type ^= CRYPTO_ALG_ASYNC;

	mask &= CRYPTO_ALG_ASYNC;

	if ((type & mask) && cipher->ivsize) {

	if ((mask & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_MASK &&

	    cipher->ivsize) {

		len = ALIGN(len, (unsigned long)alg->cra_alignmask + 1);

		len += cipher->ivsize;

	}
@@ -482,9 +481,7 @@ static int crypto_init_blkcipher_ops(struct crypto_tfm *tfm, u32 type, u32 mask) 
	if (alg->ivsize > PAGE_SIZE / 8)

		return -EINVAL;



	type ^= CRYPTO_ALG_ASYNC;

	mask &= CRYPTO_ALG_ASYNC;

	if (type & mask)

	if ((mask & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_MASK)

		return crypto_init_blkcipher_ops_sync(tfm);

	else

		return crypto_init_blkcipher_ops_async(tfm);

crypto/cryptd.c

+2 −2
Original line number Diff line number Diff line
@@ -228,7 +228,7 @@ static struct crypto_instance *cryptd_alloc_blkcipher( 
	struct crypto_alg *alg;



	alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_BLKCIPHER,

				  CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_ASYNC);

				  CRYPTO_ALG_TYPE_MASK);

	if (IS_ERR(alg))

		return ERR_PTR(PTR_ERR(alg));
@@ -236,7 +236,7 @@ static struct crypto_instance *cryptd_alloc_blkcipher( 
	if (IS_ERR(inst))

		goto out_put_alg;



	inst->alg.cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER | CRYPTO_ALG_ASYNC;

	inst->alg.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC;

	inst->alg.cra_type = &crypto_ablkcipher_type;



	inst->alg.cra_ablkcipher.ivsize = alg->cra_blkcipher.ivsize;

drivers/crypto/hifn_795x.c

+1 −1
Original line number Diff line number Diff line
@@ -2361,7 +2361,7 @@ static int hifn_alg_alloc(struct hifn_device *dev, struct hifn_alg_template *t) 
	snprintf(alg->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s", t->drv_name);



	alg->alg.cra_priority = 300;

	alg->alg.cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER | CRYPTO_ALG_ASYNC;

	alg->alg.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC;

	alg->alg.cra_blocksize = t->bsize;

	alg->alg.cra_ctxsize = sizeof(struct hifn_context);

	alg->alg.cra_alignmask = 15;

include/crypto/algapi.h

+2 −2
Original line number Diff line number Diff line
@@ -191,7 +191,7 @@ static inline struct crypto_ablkcipher *crypto_spawn_ablkcipher( 
	struct crypto_spawn *spawn)

{

	u32 type = CRYPTO_ALG_TYPE_BLKCIPHER;

	u32 mask = CRYPTO_ALG_TYPE_MASK;

	u32 mask = CRYPTO_ALG_TYPE_BLKCIPHER_MASK;



	return __crypto_ablkcipher_cast(crypto_spawn_tfm(spawn, type, mask));

}
@@ -200,7 +200,7 @@ static inline struct crypto_blkcipher *crypto_spawn_blkcipher( 
	struct crypto_spawn *spawn)

{

	u32 type = CRYPTO_ALG_TYPE_BLKCIPHER;

	u32 mask = CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_ASYNC;

	u32 mask = CRYPTO_ALG_TYPE_MASK;



	return __crypto_blkcipher_cast(crypto_spawn_tfm(spawn, type, mask));

}