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

Commit 892b1f54 authored by Kees Cook's avatar Kees Cook Committed by Hridya Valsaraju
Browse files

UPSTREAM: crypto: skcipher - Introduce crypto_sync_skcipher 



In preparation for removal of VLAs due to skcipher requests on the stack
via SKCIPHER_REQUEST_ON_STACK() usage, this introduces the infrastructure
for the "sync skcipher" tfm, which is for handling the on-stack cases of
skcipher, which are always non-ASYNC and have a known limited request
size.

The crypto API additions:

	struct crypto_sync_skcipher (wrapper for struct crypto_skcipher)
	crypto_alloc_sync_skcipher()
	crypto_free_sync_skcipher()
	crypto_sync_skcipher_setkey()
	crypto_sync_skcipher_get_flags()
	crypto_sync_skcipher_set_flags()
	crypto_sync_skcipher_clear_flags()
	crypto_sync_skcipher_blocksize()
	crypto_sync_skcipher_ivsize()
	crypto_sync_skcipher_reqtfm()
	skcipher_request_set_sync_tfm()
	SYNC_SKCIPHER_REQUEST_ON_STACK() (with tfm type check)

Signed-off-by: default avatarKees Cook <keescook@chromium.org>
Reviewed-by: default avatarArd Biesheuvel <ard.biesheuvel@linaro.org>
Signed-off-by: default avatarHerbert Xu <herbert@gondor.apana.org.au>

Bug: 150811495
Test: make
Change-Id: I5d002a7af64509a293cd4d685b97d2cd2c4d10e1
(cherry picked from commit b350bee5ea0f4db75d4c6191a2e95db16f40c278)
Signed-off-by: default avatarHridya Valsaraju <hridya@google.com>
parent cf8be8db

crypto/skcipher.c

+24 −0
Original line number Diff line number Diff line
@@ -967,6 +967,30 @@ struct crypto_skcipher *crypto_alloc_skcipher(const char *alg_name, 
}

EXPORT_SYMBOL_GPL(crypto_alloc_skcipher);



struct crypto_sync_skcipher *crypto_alloc_sync_skcipher(

				const char *alg_name, u32 type, u32 mask)

{

	struct crypto_skcipher *tfm;



	/* Only sync algorithms allowed. */

	mask |= CRYPTO_ALG_ASYNC;



	tfm = crypto_alloc_tfm(alg_name, &crypto_skcipher_type2, type, mask);



	/*

	 * Make sure we do not allocate something that might get used with

	 * an on-stack request: check the request size.

	 */

	if (!IS_ERR(tfm) && WARN_ON(crypto_skcipher_reqsize(tfm) >

				    MAX_SYNC_SKCIPHER_REQSIZE)) {

		crypto_free_skcipher(tfm);

		return ERR_PTR(-EINVAL);

	}



	return (struct crypto_sync_skcipher *)tfm;

}

EXPORT_SYMBOL_GPL(crypto_alloc_sync_skcipher);



int crypto_has_skcipher2(const char *alg_name, u32 type, u32 mask)

{

	return crypto_type_has_alg(alg_name, &crypto_skcipher_type2,

include/crypto/skcipher.h

+75 −0
Original line number Diff line number Diff line
@@ -65,6 +65,10 @@ struct crypto_skcipher { 
	struct crypto_tfm base;

};



struct crypto_sync_skcipher {

	struct crypto_skcipher base;

};



/**

 * struct skcipher_alg - symmetric key cipher definition

 * @min_keysize: Minimum key size supported by the transformation. This is the
@@ -139,6 +143,19 @@ struct skcipher_alg { 
	struct crypto_alg base;

};



#define MAX_SYNC_SKCIPHER_REQSIZE      384

/*

 * This performs a type-check against the "tfm" argument to make sure

 * all users have the correct skcipher tfm for doing on-stack requests.

 */

#define SYNC_SKCIPHER_REQUEST_ON_STACK(name, tfm) \

	char __##name##_desc[sizeof(struct skcipher_request) + \

			     MAX_SYNC_SKCIPHER_REQSIZE + \

			     (!(sizeof((struct crypto_sync_skcipher *)1 == \

				       (typeof(tfm))1))) \

			    ] CRYPTO_MINALIGN_ATTR; \

	struct skcipher_request *name = (void *)__##name##_desc



#define SKCIPHER_REQUEST_ON_STACK(name, tfm) \

	char __##name##_desc[sizeof(struct skcipher_request) + \

		crypto_skcipher_reqsize(tfm)] CRYPTO_MINALIGN_ATTR; \
@@ -197,6 +214,9 @@ static inline struct crypto_skcipher *__crypto_skcipher_cast( 
struct crypto_skcipher *crypto_alloc_skcipher(const char *alg_name,

					      u32 type, u32 mask);



struct crypto_sync_skcipher *crypto_alloc_sync_skcipher(const char *alg_name,

					      u32 type, u32 mask);



static inline struct crypto_tfm *crypto_skcipher_tfm(

	struct crypto_skcipher *tfm)

{
@@ -212,6 +232,11 @@ static inline void crypto_free_skcipher(struct crypto_skcipher *tfm) 
	crypto_destroy_tfm(tfm, crypto_skcipher_tfm(tfm));

}



static inline void crypto_free_sync_skcipher(struct crypto_sync_skcipher *tfm)

{

	crypto_free_skcipher(&tfm->base);

}



/**

 * crypto_has_skcipher() - Search for the availability of an skcipher.

 * @alg_name: is the cra_name / name or cra_driver_name / driver name of the
@@ -280,6 +305,12 @@ static inline unsigned int crypto_skcipher_ivsize(struct crypto_skcipher *tfm) 
	return tfm->ivsize;

}



static inline unsigned int crypto_sync_skcipher_ivsize(

	struct crypto_sync_skcipher *tfm)

{

	return crypto_skcipher_ivsize(&tfm->base);

}



static inline unsigned int crypto_skcipher_alg_chunksize(

	struct skcipher_alg *alg)

{
@@ -356,6 +387,12 @@ static inline unsigned int crypto_skcipher_blocksize( 
	return crypto_tfm_alg_blocksize(crypto_skcipher_tfm(tfm));

}



static inline unsigned int crypto_sync_skcipher_blocksize(

	struct crypto_sync_skcipher *tfm)

{

	return crypto_skcipher_blocksize(&tfm->base);

}



static inline unsigned int crypto_skcipher_alignmask(

	struct crypto_skcipher *tfm)

{
@@ -379,6 +416,24 @@ static inline void crypto_skcipher_clear_flags(struct crypto_skcipher *tfm, 
	crypto_tfm_clear_flags(crypto_skcipher_tfm(tfm), flags);

}



static inline u32 crypto_sync_skcipher_get_flags(

	struct crypto_sync_skcipher *tfm)

{

	return crypto_skcipher_get_flags(&tfm->base);

}



static inline void crypto_sync_skcipher_set_flags(

	struct crypto_sync_skcipher *tfm, u32 flags)

{

	crypto_skcipher_set_flags(&tfm->base, flags);

}



static inline void crypto_sync_skcipher_clear_flags(

	struct crypto_sync_skcipher *tfm, u32 flags)

{

	crypto_skcipher_clear_flags(&tfm->base, flags);

}



/**

 * crypto_skcipher_setkey() - set key for cipher

 * @tfm: cipher handle
@@ -401,6 +456,12 @@ static inline int crypto_skcipher_setkey(struct crypto_skcipher *tfm, 
	return tfm->setkey(tfm, key, keylen);

}



static inline int crypto_sync_skcipher_setkey(struct crypto_sync_skcipher *tfm,

					 const u8 *key, unsigned int keylen)

{

	return crypto_skcipher_setkey(&tfm->base, key, keylen);

}



static inline unsigned int crypto_skcipher_default_keysize(

	struct crypto_skcipher *tfm)

{
@@ -422,6 +483,14 @@ static inline struct crypto_skcipher *crypto_skcipher_reqtfm( 
	return __crypto_skcipher_cast(req->base.tfm);

}



static inline struct crypto_sync_skcipher *crypto_sync_skcipher_reqtfm(

	struct skcipher_request *req)

{

	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);



	return container_of(tfm, struct crypto_sync_skcipher, base);

}



/**

 * crypto_skcipher_encrypt() - encrypt plaintext

 * @req: reference to the skcipher_request handle that holds all information
@@ -500,6 +569,12 @@ static inline void skcipher_request_set_tfm(struct skcipher_request *req, 
	req->base.tfm = crypto_skcipher_tfm(tfm);

}



static inline void skcipher_request_set_sync_tfm(struct skcipher_request *req,

					    struct crypto_sync_skcipher *tfm)

{

	skcipher_request_set_tfm(req, &tfm->base);

}



static inline struct skcipher_request *skcipher_request_cast(

	struct crypto_async_request *req)

{