Commit 81e397d9 authored by Tadeusz Struk's avatar Tadeusz Struk Committed by Herbert Xu
Browse files

crypto: aesni - make driver-gcm-aes-aesni helper a proper aead alg 



Changed the __driver-gcm-aes-aesni to be a proper aead algorithm.
This required a valid setkey and setauthsize functions to be added and also
some changes to make sure that math context is not corrupted when the alg is
used directly.
Note that the __driver-gcm-aes-aesni should not be used directly by modules
that can use it in interrupt context as we don't have a good fallback mechanism
in this case.

Signed-off-by: default avatarAdrian Hoban <adrian.hoban@intel.com>
Signed-off-by: default avatarTadeusz Struk <tadeusz.struk@intel.com>
Signed-off-by: default avatarHerbert Xu <herbert@gondor.apana.org.au>
parent d2e3ae6f

arch/x86/crypto/aesni-intel_glue.c

+110 −54
Original line number Diff line number Diff line
@@ -890,15 +890,12 @@ out_free_ablkcipher: 
	return ret;

}



static int rfc4106_set_key(struct crypto_aead *parent, const u8 *key,

static int common_rfc4106_set_key(struct crypto_aead *aead, const u8 *key,

				  unsigned int key_len)

{

	int ret = 0;

	struct crypto_tfm *tfm = crypto_aead_tfm(parent);

	struct aesni_rfc4106_gcm_ctx *ctx = aesni_rfc4106_gcm_ctx_get(parent);

	struct crypto_aead *cryptd_child = cryptd_aead_child(ctx->cryptd_tfm);

	struct aesni_rfc4106_gcm_ctx *child_ctx =

                                 aesni_rfc4106_gcm_ctx_get(cryptd_child);

	struct crypto_tfm *tfm = crypto_aead_tfm(aead);

	struct aesni_rfc4106_gcm_ctx *ctx = aesni_rfc4106_gcm_ctx_get(aead);

	u8 *new_key_align, *new_key_mem = NULL;



	if (key_len < 4) {
@@ -943,20 +940,31 @@ static int rfc4106_set_key(struct crypto_aead *parent, const u8 *key, 
		goto exit;

	}

	ret = rfc4106_set_hash_subkey(ctx->hash_subkey, key, key_len);

	memcpy(child_ctx, ctx, sizeof(*ctx));

exit:

	kfree(new_key_mem);

	return ret;

}



/* This is the Integrity Check Value (aka the authentication tag length and can

 * be 8, 12 or 16 bytes long. */

static int rfc4106_set_authsize(struct crypto_aead *parent,

				unsigned int authsize)

static int rfc4106_set_key(struct crypto_aead *parent, const u8 *key,

			   unsigned int key_len)

{

	struct aesni_rfc4106_gcm_ctx *ctx = aesni_rfc4106_gcm_ctx_get(parent);

	struct crypto_aead *cryptd_child = cryptd_aead_child(ctx->cryptd_tfm);

	struct crypto_aead *child = cryptd_aead_child(ctx->cryptd_tfm);

	struct aesni_rfc4106_gcm_ctx *c_ctx = aesni_rfc4106_gcm_ctx_get(child);

	struct cryptd_aead *cryptd_tfm = ctx->cryptd_tfm;

	int ret;



	ret = crypto_aead_setkey(child, key, key_len);

	if (!ret) {

		memcpy(ctx, c_ctx, sizeof(*ctx));

		ctx->cryptd_tfm = cryptd_tfm;

	}

	return ret;

}



static int common_rfc4106_set_authsize(struct crypto_aead *aead,

				       unsigned int authsize)

{

	switch (authsize) {

	case 8:

	case 12:
@@ -965,52 +973,24 @@ static int rfc4106_set_authsize(struct crypto_aead *parent, 
	default:

		return -EINVAL;

	}

	crypto_aead_crt(parent)->authsize = authsize;

	crypto_aead_crt(cryptd_child)->authsize = authsize;

	crypto_aead_crt(aead)->authsize = authsize;

	return 0;

}



static int rfc4106_encrypt(struct aead_request *req)

{

	int ret;

	struct crypto_aead *tfm = crypto_aead_reqtfm(req);

	struct aesni_rfc4106_gcm_ctx *ctx = aesni_rfc4106_gcm_ctx_get(tfm);



	if (!irq_fpu_usable()) {

		struct aead_request *cryptd_req =

			(struct aead_request *) aead_request_ctx(req);

		memcpy(cryptd_req, req, sizeof(*req));

		aead_request_set_tfm(cryptd_req, &ctx->cryptd_tfm->base);

		return crypto_aead_encrypt(cryptd_req);

	} else {

		struct crypto_aead *cryptd_child = cryptd_aead_child(ctx->cryptd_tfm);

		kernel_fpu_begin();

		ret = cryptd_child->base.crt_aead.encrypt(req);

		kernel_fpu_end();

		return ret;

	}

}



static int rfc4106_decrypt(struct aead_request *req)

/* This is the Integrity Check Value (aka the authentication tag length and can

 * be 8, 12 or 16 bytes long. */

static int rfc4106_set_authsize(struct crypto_aead *parent,

				unsigned int authsize)

{

	struct aesni_rfc4106_gcm_ctx *ctx = aesni_rfc4106_gcm_ctx_get(parent);

	struct crypto_aead *child = cryptd_aead_child(ctx->cryptd_tfm);

	int ret;

	struct crypto_aead *tfm = crypto_aead_reqtfm(req);

	struct aesni_rfc4106_gcm_ctx *ctx = aesni_rfc4106_gcm_ctx_get(tfm);



	if (!irq_fpu_usable()) {

		struct aead_request *cryptd_req =

			(struct aead_request *) aead_request_ctx(req);

		memcpy(cryptd_req, req, sizeof(*req));

		aead_request_set_tfm(cryptd_req, &ctx->cryptd_tfm->base);

		return crypto_aead_decrypt(cryptd_req);

	} else {

		struct crypto_aead *cryptd_child = cryptd_aead_child(ctx->cryptd_tfm);

		kernel_fpu_begin();

		ret = cryptd_child->base.crt_aead.decrypt(req);

		kernel_fpu_end();

	ret = crypto_aead_setauthsize(child, authsize);

	if (!ret)

		crypto_aead_crt(parent)->authsize = authsize;

	return ret;

}

}



static int __driver_rfc4106_encrypt(struct aead_request *req)

{
@@ -1185,6 +1165,78 @@ static int __driver_rfc4106_decrypt(struct aead_request *req) 
	}

	return retval;

}



static int rfc4106_encrypt(struct aead_request *req)

{

	int ret;

	struct crypto_aead *tfm = crypto_aead_reqtfm(req);

	struct aesni_rfc4106_gcm_ctx *ctx = aesni_rfc4106_gcm_ctx_get(tfm);



	if (!irq_fpu_usable()) {

		struct aead_request *cryptd_req =

			(struct aead_request *) aead_request_ctx(req);



		memcpy(cryptd_req, req, sizeof(*req));

		aead_request_set_tfm(cryptd_req, &ctx->cryptd_tfm->base);

		ret = crypto_aead_encrypt(cryptd_req);

	} else {

		kernel_fpu_begin();

		ret = __driver_rfc4106_encrypt(req);

		kernel_fpu_end();

	}

	return ret;

}



static int rfc4106_decrypt(struct aead_request *req)

{

	int ret;

	struct crypto_aead *tfm = crypto_aead_reqtfm(req);

	struct aesni_rfc4106_gcm_ctx *ctx = aesni_rfc4106_gcm_ctx_get(tfm);



	if (!irq_fpu_usable()) {

		struct aead_request *cryptd_req =

			(struct aead_request *) aead_request_ctx(req);



		memcpy(cryptd_req, req, sizeof(*req));

		aead_request_set_tfm(cryptd_req, &ctx->cryptd_tfm->base);

		ret = crypto_aead_decrypt(cryptd_req);

	} else {

		kernel_fpu_begin();

		ret = __driver_rfc4106_decrypt(req);

		kernel_fpu_end();

	}

	return ret;

}



static int helper_rfc4106_encrypt(struct aead_request *req)

{

	int ret;



	if (unlikely(!irq_fpu_usable())) {

		WARN_ONCE(1, "__gcm-aes-aesni alg used in invalid context");

		ret = -EINVAL;

	} else {

		kernel_fpu_begin();

		ret = __driver_rfc4106_encrypt(req);

		kernel_fpu_end();

	}

	return ret;

}



static int helper_rfc4106_decrypt(struct aead_request *req)

{

	int ret;



	if (unlikely(!irq_fpu_usable())) {

		WARN_ONCE(1, "__gcm-aes-aesni alg used in invalid context");

		ret = -EINVAL;

	} else {

		kernel_fpu_begin();

		ret = __driver_rfc4106_decrypt(req);

		kernel_fpu_end();

	}

	return ret;

}

#endif



static struct crypto_alg aesni_algs[] = { {
@@ -1366,8 +1418,12 @@ static struct crypto_alg aesni_algs[] = { { 
	.cra_module		= THIS_MODULE,

	.cra_u = {

		.aead = {

			.encrypt	= __driver_rfc4106_encrypt,

			.decrypt	= __driver_rfc4106_decrypt,

			.setkey		= common_rfc4106_set_key,

			.setauthsize	= common_rfc4106_set_authsize,

			.encrypt	= helper_rfc4106_encrypt,

			.decrypt	= helper_rfc4106_decrypt,

			.ivsize		= 8,

			.maxauthsize	= 16,

		},

	},

}, {

CRA Git | Maintained and supported by SUSTech CRA and CCSE