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

Commit 451cc493 authored by Eric Biggers's avatar Eric Biggers Committed by Herbert Xu
Browse files

crypto: x86/camellia - remove XTS algorithm 



The XTS template now wraps an ECB mode algorithm rather than the block
cipher directly.  Therefore it is now redundant for crypto modules to
wrap their ECB code with generic XTS code themselves via xts_crypt().

Remove the xts-camellia-asm algorithm which did this.  Users who request
xts(camellia) and previously would have gotten xts-camellia-asm will now
get xts(ecb-camellia-asm) instead, which is just as fast.

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

arch/x86/crypto/camellia_aesni_avx_glue.c

+22 −0
Original line number Diff line number Diff line
@@ -192,6 +192,28 @@ static int camellia_setkey(struct crypto_tfm *tfm, const u8 *in_key, 
				 &tfm->crt_flags);

}



int xts_camellia_setkey(struct crypto_tfm *tfm, const u8 *key,

			unsigned int keylen)

{

	struct camellia_xts_ctx *ctx = crypto_tfm_ctx(tfm);

	u32 *flags = &tfm->crt_flags;

	int err;



	err = xts_check_key(tfm, key, keylen);

	if (err)

		return err;



	/* first half of xts-key is for crypt */

	err = __camellia_setkey(&ctx->crypt_ctx, key, keylen / 2, flags);

	if (err)

		return err;



	/* second half of xts-key is for tweak */

	return __camellia_setkey(&ctx->tweak_ctx, key + keylen / 2, keylen / 2,

				flags);

}

EXPORT_SYMBOL_GPL(xts_camellia_setkey);



static int xts_encrypt(struct blkcipher_desc *desc, struct scatterlist *dst,

		       struct scatterlist *src, unsigned int nbytes)

{

arch/x86/crypto/camellia_glue.c

+0 −111
Original line number Diff line number Diff line
@@ -30,7 +30,6 @@ 
#include <linux/module.h>

#include <linux/types.h>

#include <crypto/algapi.h>

#include <crypto/xts.h>

#include <asm/crypto/camellia.h>

#include <asm/crypto/glue_helper.h>
@@ -1404,96 +1403,6 @@ static int ctr_crypt(struct blkcipher_desc *desc, struct scatterlist *dst, 
	return glue_ctr_crypt_128bit(&camellia_ctr, desc, dst, src, nbytes);

}



static void encrypt_callback(void *priv, u8 *srcdst, unsigned int nbytes)

{

	const unsigned int bsize = CAMELLIA_BLOCK_SIZE;

	struct camellia_ctx *ctx = priv;

	int i;



	while (nbytes >= 2 * bsize) {

		camellia_enc_blk_2way(ctx, srcdst, srcdst);

		srcdst += bsize * 2;

		nbytes -= bsize * 2;

	}



	for (i = 0; i < nbytes / bsize; i++, srcdst += bsize)

		camellia_enc_blk(ctx, srcdst, srcdst);

}



static void decrypt_callback(void *priv, u8 *srcdst, unsigned int nbytes)

{

	const unsigned int bsize = CAMELLIA_BLOCK_SIZE;

	struct camellia_ctx *ctx = priv;

	int i;



	while (nbytes >= 2 * bsize) {

		camellia_dec_blk_2way(ctx, srcdst, srcdst);

		srcdst += bsize * 2;

		nbytes -= bsize * 2;

	}



	for (i = 0; i < nbytes / bsize; i++, srcdst += bsize)

		camellia_dec_blk(ctx, srcdst, srcdst);

}



int xts_camellia_setkey(struct crypto_tfm *tfm, const u8 *key,

			unsigned int keylen)

{

	struct camellia_xts_ctx *ctx = crypto_tfm_ctx(tfm);

	u32 *flags = &tfm->crt_flags;

	int err;



	err = xts_check_key(tfm, key, keylen);

	if (err)

		return err;



	/* first half of xts-key is for crypt */

	err = __camellia_setkey(&ctx->crypt_ctx, key, keylen / 2, flags);

	if (err)

		return err;



	/* second half of xts-key is for tweak */

	return __camellia_setkey(&ctx->tweak_ctx, key + keylen / 2, keylen / 2,

				flags);

}

EXPORT_SYMBOL_GPL(xts_camellia_setkey);



static int xts_encrypt(struct blkcipher_desc *desc, struct scatterlist *dst,

		       struct scatterlist *src, unsigned int nbytes)

{

	struct camellia_xts_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);

	le128 buf[2 * 4];

	struct xts_crypt_req req = {

		.tbuf = buf,

		.tbuflen = sizeof(buf),



		.tweak_ctx = &ctx->tweak_ctx,

		.tweak_fn = XTS_TWEAK_CAST(camellia_enc_blk),

		.crypt_ctx = &ctx->crypt_ctx,

		.crypt_fn = encrypt_callback,

	};



	return xts_crypt(desc, dst, src, nbytes, &req);

}



static int xts_decrypt(struct blkcipher_desc *desc, struct scatterlist *dst,

		       struct scatterlist *src, unsigned int nbytes)

{

	struct camellia_xts_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);

	le128 buf[2 * 4];

	struct xts_crypt_req req = {

		.tbuf = buf,

		.tbuflen = sizeof(buf),



		.tweak_ctx = &ctx->tweak_ctx,

		.tweak_fn = XTS_TWEAK_CAST(camellia_enc_blk),

		.crypt_ctx = &ctx->crypt_ctx,

		.crypt_fn = decrypt_callback,

	};



	return xts_crypt(desc, dst, src, nbytes, &req);

}



static struct crypto_alg camellia_algs[] = { {

	.cra_name		= "camellia",

	.cra_driver_name	= "camellia-asm",
@@ -1571,26 +1480,6 @@ static struct crypto_alg camellia_algs[] = { { 
			.decrypt	= ctr_crypt,

		},

	},

}, {

	.cra_name		= "xts(camellia)",

	.cra_driver_name	= "xts-camellia-asm",

	.cra_priority		= 300,

	.cra_flags		= CRYPTO_ALG_TYPE_BLKCIPHER,

	.cra_blocksize		= CAMELLIA_BLOCK_SIZE,

	.cra_ctxsize		= sizeof(struct camellia_xts_ctx),

	.cra_alignmask		= 0,

	.cra_type		= &crypto_blkcipher_type,

	.cra_module		= THIS_MODULE,

	.cra_u = {

		.blkcipher = {

			.min_keysize	= CAMELLIA_MIN_KEY_SIZE * 2,

			.max_keysize	= CAMELLIA_MAX_KEY_SIZE * 2,

			.ivsize		= CAMELLIA_BLOCK_SIZE,

			.setkey		= xts_camellia_setkey,

			.encrypt	= xts_encrypt,

			.decrypt	= xts_decrypt,

		},

	},

} };



static bool is_blacklisted_cpu(void)

arch/x86/include/asm/crypto/camellia.h

+2 −1
Original line number Diff line number Diff line
@@ -2,8 +2,9 @@ 
#ifndef ASM_X86_CAMELLIA_H

#define ASM_X86_CAMELLIA_H



#include <linux/kernel.h>

#include <crypto/b128ops.h>

#include <linux/crypto.h>

#include <linux/kernel.h>



#define CAMELLIA_MIN_KEY_SIZE	16

#define CAMELLIA_MAX_KEY_SIZE	32

crypto/Kconfig

+0 −1
Original line number Diff line number Diff line
@@ -1147,7 +1147,6 @@ config CRYPTO_CAMELLIA_X86_64 
	depends on CRYPTO

	select CRYPTO_ALGAPI

	select CRYPTO_GLUE_HELPER_X86

	select CRYPTO_XTS

	help

	  Camellia cipher algorithm module (x86_64).