Commit d9b1d2e7 authored by Jussi Kivilinna's avatar Jussi Kivilinna Committed by Herbert Xu
Browse files

crypto: camellia - add AES-NI/AVX/x86_64 assembler implementation of camellia cipher 



This patch adds AES-NI/AVX/x86_64 assembler implementation of Camellia block
cipher. Implementation process data in sixteen block chunks, which are
byte-sliced and AES SubBytes is reused for Camellia s-box with help of pre-
and post-filtering.

Patch has been tested with tcrypt and automated filesystem tests.

tcrypt test results:

Intel Core i5-2450M:

camellia-aesni-avx vs camellia-asm-x86_64-2way:
128bit key:                                             (lrw:256bit)    (xts:256bit)
size    ecb-enc ecb-dec cbc-enc cbc-dec ctr-enc ctr-dec lrw-enc lrw-dec xts-enc xts-dec
16B     0.98x   0.96x   0.99x   0.96x   0.96x   0.95x   0.95x   0.94x   0.97x   0.98x
64B     0.99x   0.98x   1.00x   0.98x   0.98x   0.99x   0.98x   0.93x   0.99x   0.98x
256B    2.28x   2.28x   1.01x   2.29x   2.25x   2.24x   1.96x   1.97x   1.91x   1.90x
1024B   2.57x   2.56x   1.00x   2.57x   2.51x   2.53x   2.19x   2.17x   2.19x   2.22x
8192B   2.49x   2.49x   1.00x   2.53x   2.48x   2.49x   2.17x   2.17x   2.22x   2.22x

256bit key:                                             (lrw:384bit)    (xts:512bit)
size    ecb-enc ecb-dec cbc-enc cbc-dec ctr-enc ctr-dec lrw-enc lrw-dec xts-enc xts-dec
16B     0.97x   0.98x   0.99x   0.97x   0.97x   0.96x   0.97x   0.98x   0.98x   0.99x
64B     1.00x   1.00x   1.01x   0.99x   0.98x   0.99x   0.99x   0.99x   0.99x   0.99x
256B    2.37x   2.37x   1.01x   2.39x   2.35x   2.33x   2.10x   2.11x   1.99x   2.02x
1024B   2.58x   2.60x   1.00x   2.58x   2.56x   2.56x   2.28x   2.29x   2.28x   2.29x
8192B   2.50x   2.52x   1.00x   2.56x   2.51x   2.51x   2.24x   2.25x   2.26x   2.29x

Signed-off-by: default avatarJussi Kivilinna <jussi.kivilinna@mbnet.fi>
Acked-by: default avatarDavid S. Miller <davem@davemloft.net>
Signed-off-by: default avatarHerbert Xu <herbert@gondor.apana.org.au>
parent cf582cce

arch/x86/crypto/Makefile

+3 −0
Original line number Diff line number Diff line
@@ -12,6 +12,7 @@ obj-$(CONFIG_CRYPTO_SERPENT_SSE2_586) += serpent-sse2-i586.o 


obj-$(CONFIG_CRYPTO_AES_X86_64) += aes-x86_64.o

obj-$(CONFIG_CRYPTO_CAMELLIA_X86_64) += camellia-x86_64.o

obj-$(CONFIG_CRYPTO_CAMELLIA_AESNI_AVX_X86_64) += camellia-aesni-avx-x86_64.o

obj-$(CONFIG_CRYPTO_CAST5_AVX_X86_64) += cast5-avx-x86_64.o

obj-$(CONFIG_CRYPTO_CAST6_AVX_X86_64) += cast6-avx-x86_64.o

obj-$(CONFIG_CRYPTO_BLOWFISH_X86_64) += blowfish-x86_64.o
@@ -34,6 +35,8 @@ serpent-sse2-i586-y := serpent-sse2-i586-asm_32.o serpent_sse2_glue.o 


aes-x86_64-y := aes-x86_64-asm_64.o aes_glue.o

camellia-x86_64-y := camellia-x86_64-asm_64.o camellia_glue.o

camellia-aesni-avx-x86_64-y := camellia-aesni-avx-asm_64.o \

			       camellia_aesni_avx_glue.o

cast5-avx-x86_64-y := cast5-avx-x86_64-asm_64.o cast5_avx_glue.o

cast6-avx-x86_64-y := cast6-avx-x86_64-asm_64.o cast6_avx_glue.o

blowfish-x86_64-y := blowfish-x86_64-asm_64.o blowfish_glue.o

arch/x86/crypto/camellia-aesni-avx-asm_64.S

0 → 100644
+1102 −0

File added.

Preview size limit exceeded, changes collapsed.

arch/x86/crypto/camellia_aesni_avx_glue.c

0 → 100644
+558 −0
Original line number Diff line number Diff line 
/*

 * Glue Code for x86_64/AVX/AES-NI assembler optimized version of Camellia

 *

 * Copyright © 2012 Jussi Kivilinna <jussi.kivilinna@mbnet.fi>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 */



#include <linux/module.h>

#include <linux/types.h>

#include <linux/crypto.h>

#include <linux/err.h>

#include <crypto/algapi.h>

#include <crypto/ctr.h>

#include <crypto/lrw.h>

#include <crypto/xts.h>

#include <asm/xcr.h>

#include <asm/xsave.h>

#include <asm/crypto/camellia.h>

#include <asm/crypto/ablk_helper.h>

#include <asm/crypto/glue_helper.h>



#define CAMELLIA_AESNI_PARALLEL_BLOCKS 16



/* 16-way AES-NI parallel cipher functions */

asmlinkage void camellia_ecb_enc_16way(struct camellia_ctx *ctx, u8 *dst,

				       const u8 *src);

asmlinkage void camellia_ecb_dec_16way(struct camellia_ctx *ctx, u8 *dst,

				       const u8 *src);



asmlinkage void camellia_cbc_dec_16way(struct camellia_ctx *ctx, u8 *dst,

				       const u8 *src);

asmlinkage void camellia_ctr_16way(struct camellia_ctx *ctx, u8 *dst,

				   const u8 *src, le128 *iv);



static const struct common_glue_ctx camellia_enc = {

	.num_funcs = 3,

	.fpu_blocks_limit = CAMELLIA_AESNI_PARALLEL_BLOCKS,



	.funcs = { {

		.num_blocks = CAMELLIA_AESNI_PARALLEL_BLOCKS,

		.fn_u = { .ecb = GLUE_FUNC_CAST(camellia_ecb_enc_16way) }

	}, {

		.num_blocks = 2,

		.fn_u = { .ecb = GLUE_FUNC_CAST(camellia_enc_blk_2way) }

	}, {

		.num_blocks = 1,

		.fn_u = { .ecb = GLUE_FUNC_CAST(camellia_enc_blk) }

	} }

};



static const struct common_glue_ctx camellia_ctr = {

	.num_funcs = 3,

	.fpu_blocks_limit = CAMELLIA_AESNI_PARALLEL_BLOCKS,



	.funcs = { {

		.num_blocks = CAMELLIA_AESNI_PARALLEL_BLOCKS,

		.fn_u = { .ctr = GLUE_CTR_FUNC_CAST(camellia_ctr_16way) }

	}, {

		.num_blocks = 2,

		.fn_u = { .ctr = GLUE_CTR_FUNC_CAST(camellia_crypt_ctr_2way) }

	}, {

		.num_blocks = 1,

		.fn_u = { .ctr = GLUE_CTR_FUNC_CAST(camellia_crypt_ctr) }

	} }

};



static const struct common_glue_ctx camellia_dec = {

	.num_funcs = 3,

	.fpu_blocks_limit = CAMELLIA_AESNI_PARALLEL_BLOCKS,



	.funcs = { {

		.num_blocks = CAMELLIA_AESNI_PARALLEL_BLOCKS,

		.fn_u = { .ecb = GLUE_FUNC_CAST(camellia_ecb_dec_16way) }

	}, {

		.num_blocks = 2,

		.fn_u = { .ecb = GLUE_FUNC_CAST(camellia_dec_blk_2way) }

	}, {

		.num_blocks = 1,

		.fn_u = { .ecb = GLUE_FUNC_CAST(camellia_dec_blk) }

	} }

};



static const struct common_glue_ctx camellia_dec_cbc = {

	.num_funcs = 3,

	.fpu_blocks_limit = CAMELLIA_AESNI_PARALLEL_BLOCKS,



	.funcs = { {

		.num_blocks = CAMELLIA_AESNI_PARALLEL_BLOCKS,

		.fn_u = { .cbc = GLUE_CBC_FUNC_CAST(camellia_cbc_dec_16way) }

	}, {

		.num_blocks = 2,

		.fn_u = { .cbc = GLUE_CBC_FUNC_CAST(camellia_decrypt_cbc_2way) }

	}, {

		.num_blocks = 1,

		.fn_u = { .cbc = GLUE_CBC_FUNC_CAST(camellia_dec_blk) }

	} }

};



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

		       struct scatterlist *src, unsigned int nbytes)

{

	return glue_ecb_crypt_128bit(&camellia_enc, desc, dst, src, nbytes);

}



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

		       struct scatterlist *src, unsigned int nbytes)

{

	return glue_ecb_crypt_128bit(&camellia_dec, desc, dst, src, nbytes);

}



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

		       struct scatterlist *src, unsigned int nbytes)

{

	return glue_cbc_encrypt_128bit(GLUE_FUNC_CAST(camellia_enc_blk), desc,

				       dst, src, nbytes);

}



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

		       struct scatterlist *src, unsigned int nbytes)

{

	return glue_cbc_decrypt_128bit(&camellia_dec_cbc, desc, dst, src,

				       nbytes);

}



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

		     struct scatterlist *src, unsigned int nbytes)

{

	return glue_ctr_crypt_128bit(&camellia_ctr, desc, dst, src, nbytes);

}



static inline bool camellia_fpu_begin(bool fpu_enabled, unsigned int nbytes)

{

	return glue_fpu_begin(CAMELLIA_BLOCK_SIZE,

			      CAMELLIA_AESNI_PARALLEL_BLOCKS, NULL, fpu_enabled,

			      nbytes);

}



static inline void camellia_fpu_end(bool fpu_enabled)

{

	glue_fpu_end(fpu_enabled);

}



static int camellia_setkey(struct crypto_tfm *tfm, const u8 *in_key,

			   unsigned int key_len)

{

	return __camellia_setkey(crypto_tfm_ctx(tfm), in_key, key_len,

				 &tfm->crt_flags);

}



struct crypt_priv {

	struct camellia_ctx *ctx;

	bool fpu_enabled;

};



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

{

	const unsigned int bsize = CAMELLIA_BLOCK_SIZE;

	struct crypt_priv *ctx = priv;

	int i;



	ctx->fpu_enabled = camellia_fpu_begin(ctx->fpu_enabled, nbytes);



	if (nbytes >= CAMELLIA_AESNI_PARALLEL_BLOCKS * bsize) {

		camellia_ecb_enc_16way(ctx->ctx, srcdst, srcdst);

		srcdst += bsize * CAMELLIA_AESNI_PARALLEL_BLOCKS;

		nbytes -= bsize * CAMELLIA_AESNI_PARALLEL_BLOCKS;

	}



	while (nbytes >= CAMELLIA_PARALLEL_BLOCKS * bsize) {

		camellia_enc_blk_2way(ctx->ctx, srcdst, srcdst);

		srcdst += bsize * CAMELLIA_PARALLEL_BLOCKS;

		nbytes -= bsize * CAMELLIA_PARALLEL_BLOCKS;

	}



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

		camellia_enc_blk(ctx->ctx, srcdst, srcdst);

}



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

{

	const unsigned int bsize = CAMELLIA_BLOCK_SIZE;

	struct crypt_priv *ctx = priv;

	int i;



	ctx->fpu_enabled = camellia_fpu_begin(ctx->fpu_enabled, nbytes);



	if (nbytes >= CAMELLIA_AESNI_PARALLEL_BLOCKS * bsize) {

		camellia_ecb_dec_16way(ctx->ctx, srcdst, srcdst);

		srcdst += bsize * CAMELLIA_AESNI_PARALLEL_BLOCKS;

		nbytes -= bsize * CAMELLIA_AESNI_PARALLEL_BLOCKS;

	}



	while (nbytes >= CAMELLIA_PARALLEL_BLOCKS * bsize) {

		camellia_dec_blk_2way(ctx->ctx, srcdst, srcdst);

		srcdst += bsize * CAMELLIA_PARALLEL_BLOCKS;

		nbytes -= bsize * CAMELLIA_PARALLEL_BLOCKS;

	}



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

		camellia_dec_blk(ctx->ctx, srcdst, srcdst);

}



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

		       struct scatterlist *src, unsigned int nbytes)

{

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

	be128 buf[CAMELLIA_AESNI_PARALLEL_BLOCKS];

	struct crypt_priv crypt_ctx = {

		.ctx = &ctx->camellia_ctx,

		.fpu_enabled = false,

	};

	struct lrw_crypt_req req = {

		.tbuf = buf,

		.tbuflen = sizeof(buf),



		.table_ctx = &ctx->lrw_table,

		.crypt_ctx = &crypt_ctx,

		.crypt_fn = encrypt_callback,

	};

	int ret;



	desc->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP;

	ret = lrw_crypt(desc, dst, src, nbytes, &req);

	camellia_fpu_end(crypt_ctx.fpu_enabled);



	return ret;

}



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

		       struct scatterlist *src, unsigned int nbytes)

{

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

	be128 buf[CAMELLIA_AESNI_PARALLEL_BLOCKS];

	struct crypt_priv crypt_ctx = {

		.ctx = &ctx->camellia_ctx,

		.fpu_enabled = false,

	};

	struct lrw_crypt_req req = {

		.tbuf = buf,

		.tbuflen = sizeof(buf),



		.table_ctx = &ctx->lrw_table,

		.crypt_ctx = &crypt_ctx,

		.crypt_fn = decrypt_callback,

	};

	int ret;



	desc->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP;

	ret = lrw_crypt(desc, dst, src, nbytes, &req);

	camellia_fpu_end(crypt_ctx.fpu_enabled);



	return ret;

}



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);

	be128 buf[CAMELLIA_AESNI_PARALLEL_BLOCKS];

	struct crypt_priv crypt_ctx = {

		.ctx = &ctx->crypt_ctx,

		.fpu_enabled = false,

	};

	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 = &crypt_ctx,

		.crypt_fn = encrypt_callback,

	};

	int ret;



	desc->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP;

	ret = xts_crypt(desc, dst, src, nbytes, &req);

	camellia_fpu_end(crypt_ctx.fpu_enabled);



	return ret;

}



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);

	be128 buf[CAMELLIA_AESNI_PARALLEL_BLOCKS];

	struct crypt_priv crypt_ctx = {

		.ctx = &ctx->crypt_ctx,

		.fpu_enabled = false,

	};

	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 = &crypt_ctx,

		.crypt_fn = decrypt_callback,

	};

	int ret;



	desc->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP;

	ret = xts_crypt(desc, dst, src, nbytes, &req);

	camellia_fpu_end(crypt_ctx.fpu_enabled);



	return ret;

}



static struct crypto_alg cmll_algs[10] = { {

	.cra_name		= "__ecb-camellia-aesni",

	.cra_driver_name	= "__driver-ecb-camellia-aesni",

	.cra_priority		= 0,

	.cra_flags		= CRYPTO_ALG_TYPE_BLKCIPHER,

	.cra_blocksize		= CAMELLIA_BLOCK_SIZE,

	.cra_ctxsize		= sizeof(struct camellia_ctx),

	.cra_alignmask		= 0,

	.cra_type		= &crypto_blkcipher_type,

	.cra_module		= THIS_MODULE,

	.cra_u = {

		.blkcipher = {

			.min_keysize	= CAMELLIA_MIN_KEY_SIZE,

			.max_keysize	= CAMELLIA_MAX_KEY_SIZE,

			.setkey		= camellia_setkey,

			.encrypt	= ecb_encrypt,

			.decrypt	= ecb_decrypt,

		},

	},

}, {

	.cra_name		= "__cbc-camellia-aesni",

	.cra_driver_name	= "__driver-cbc-camellia-aesni",

	.cra_priority		= 0,

	.cra_flags		= CRYPTO_ALG_TYPE_BLKCIPHER,

	.cra_blocksize		= CAMELLIA_BLOCK_SIZE,

	.cra_ctxsize		= sizeof(struct camellia_ctx),

	.cra_alignmask		= 0,

	.cra_type		= &crypto_blkcipher_type,

	.cra_module		= THIS_MODULE,

	.cra_u = {

		.blkcipher = {

			.min_keysize	= CAMELLIA_MIN_KEY_SIZE,

			.max_keysize	= CAMELLIA_MAX_KEY_SIZE,

			.setkey		= camellia_setkey,

			.encrypt	= cbc_encrypt,

			.decrypt	= cbc_decrypt,

		},

	},

}, {

	.cra_name		= "__ctr-camellia-aesni",

	.cra_driver_name	= "__driver-ctr-camellia-aesni",

	.cra_priority		= 0,

	.cra_flags		= CRYPTO_ALG_TYPE_BLKCIPHER,

	.cra_blocksize		= 1,

	.cra_ctxsize		= sizeof(struct camellia_ctx),

	.cra_alignmask		= 0,

	.cra_type		= &crypto_blkcipher_type,

	.cra_module		= THIS_MODULE,

	.cra_u = {

		.blkcipher = {

			.min_keysize	= CAMELLIA_MIN_KEY_SIZE,

			.max_keysize	= CAMELLIA_MAX_KEY_SIZE,

			.ivsize		= CAMELLIA_BLOCK_SIZE,

			.setkey		= camellia_setkey,

			.encrypt	= ctr_crypt,

			.decrypt	= ctr_crypt,

		},

	},

}, {

	.cra_name		= "__lrw-camellia-aesni",

	.cra_driver_name	= "__driver-lrw-camellia-aesni",

	.cra_priority		= 0,

	.cra_flags		= CRYPTO_ALG_TYPE_BLKCIPHER,

	.cra_blocksize		= CAMELLIA_BLOCK_SIZE,

	.cra_ctxsize		= sizeof(struct camellia_lrw_ctx),

	.cra_alignmask		= 0,

	.cra_type		= &crypto_blkcipher_type,

	.cra_module		= THIS_MODULE,

	.cra_exit		= lrw_camellia_exit_tfm,

	.cra_u = {

		.blkcipher = {

			.min_keysize	= CAMELLIA_MIN_KEY_SIZE +

					  CAMELLIA_BLOCK_SIZE,

			.max_keysize	= CAMELLIA_MAX_KEY_SIZE +

					  CAMELLIA_BLOCK_SIZE,

			.ivsize		= CAMELLIA_BLOCK_SIZE,

			.setkey		= lrw_camellia_setkey,

			.encrypt	= lrw_encrypt,

			.decrypt	= lrw_decrypt,

		},

	},

}, {

	.cra_name		= "__xts-camellia-aesni",

	.cra_driver_name	= "__driver-xts-camellia-aesni",

	.cra_priority		= 0,

	.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,

		},

	},

}, {

	.cra_name		= "ecb(camellia)",

	.cra_driver_name	= "ecb-camellia-aesni",

	.cra_priority		= 400,

	.cra_flags		= CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,

	.cra_blocksize		= CAMELLIA_BLOCK_SIZE,

	.cra_ctxsize		= sizeof(struct async_helper_ctx),

	.cra_alignmask		= 0,

	.cra_type		= &crypto_ablkcipher_type,

	.cra_module		= THIS_MODULE,

	.cra_init		= ablk_init,

	.cra_exit		= ablk_exit,

	.cra_u = {

		.ablkcipher = {

			.min_keysize	= CAMELLIA_MIN_KEY_SIZE,

			.max_keysize	= CAMELLIA_MAX_KEY_SIZE,

			.setkey		= ablk_set_key,

			.encrypt	= ablk_encrypt,

			.decrypt	= ablk_decrypt,

		},

	},

}, {

	.cra_name		= "cbc(camellia)",

	.cra_driver_name	= "cbc-camellia-aesni",

	.cra_priority		= 400,

	.cra_flags		= CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,

	.cra_blocksize		= CAMELLIA_BLOCK_SIZE,

	.cra_ctxsize		= sizeof(struct async_helper_ctx),

	.cra_alignmask		= 0,

	.cra_type		= &crypto_ablkcipher_type,

	.cra_module		= THIS_MODULE,

	.cra_init		= ablk_init,

	.cra_exit		= ablk_exit,

	.cra_u = {

		.ablkcipher = {

			.min_keysize	= CAMELLIA_MIN_KEY_SIZE,

			.max_keysize	= CAMELLIA_MAX_KEY_SIZE,

			.ivsize		= CAMELLIA_BLOCK_SIZE,

			.setkey		= ablk_set_key,

			.encrypt	= __ablk_encrypt,

			.decrypt	= ablk_decrypt,

		},

	},

}, {

	.cra_name		= "ctr(camellia)",

	.cra_driver_name	= "ctr-camellia-aesni",

	.cra_priority		= 400,

	.cra_flags		= CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,

	.cra_blocksize		= 1,

	.cra_ctxsize		= sizeof(struct async_helper_ctx),

	.cra_alignmask		= 0,

	.cra_type		= &crypto_ablkcipher_type,

	.cra_module		= THIS_MODULE,

	.cra_init		= ablk_init,

	.cra_exit		= ablk_exit,

	.cra_u = {

		.ablkcipher = {

			.min_keysize	= CAMELLIA_MIN_KEY_SIZE,

			.max_keysize	= CAMELLIA_MAX_KEY_SIZE,

			.ivsize		= CAMELLIA_BLOCK_SIZE,

			.setkey		= ablk_set_key,

			.encrypt	= ablk_encrypt,

			.decrypt	= ablk_encrypt,

			.geniv		= "chainiv",

		},

	},

}, {

	.cra_name		= "lrw(camellia)",

	.cra_driver_name	= "lrw-camellia-aesni",

	.cra_priority		= 400,

	.cra_flags		= CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,

	.cra_blocksize		= CAMELLIA_BLOCK_SIZE,

	.cra_ctxsize		= sizeof(struct async_helper_ctx),

	.cra_alignmask		= 0,

	.cra_type		= &crypto_ablkcipher_type,

	.cra_module		= THIS_MODULE,

	.cra_init		= ablk_init,

	.cra_exit		= ablk_exit,

	.cra_u = {

		.ablkcipher = {

			.min_keysize	= CAMELLIA_MIN_KEY_SIZE +

					  CAMELLIA_BLOCK_SIZE,

			.max_keysize	= CAMELLIA_MAX_KEY_SIZE +

					  CAMELLIA_BLOCK_SIZE,

			.ivsize		= CAMELLIA_BLOCK_SIZE,

			.setkey		= ablk_set_key,

			.encrypt	= ablk_encrypt,

			.decrypt	= ablk_decrypt,

		},

	},

}, {

	.cra_name		= "xts(camellia)",

	.cra_driver_name	= "xts-camellia-aesni",

	.cra_priority		= 400,

	.cra_flags		= CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,

	.cra_blocksize		= CAMELLIA_BLOCK_SIZE,

	.cra_ctxsize		= sizeof(struct async_helper_ctx),

	.cra_alignmask		= 0,

	.cra_type		= &crypto_ablkcipher_type,

	.cra_module		= THIS_MODULE,

	.cra_init		= ablk_init,

	.cra_exit		= ablk_exit,

	.cra_u = {

		.ablkcipher = {

			.min_keysize	= CAMELLIA_MIN_KEY_SIZE * 2,

			.max_keysize	= CAMELLIA_MAX_KEY_SIZE * 2,

			.ivsize		= CAMELLIA_BLOCK_SIZE,

			.setkey		= ablk_set_key,

			.encrypt	= ablk_encrypt,

			.decrypt	= ablk_decrypt,

		},

	},

} };



static int __init camellia_aesni_init(void)

{

	u64 xcr0;



	if (!cpu_has_avx || !cpu_has_aes || !cpu_has_osxsave) {

		pr_info("AVX or AES-NI instructions are not detected.\n");

		return -ENODEV;

	}



	xcr0 = xgetbv(XCR_XFEATURE_ENABLED_MASK);

	if ((xcr0 & (XSTATE_SSE | XSTATE_YMM)) != (XSTATE_SSE | XSTATE_YMM)) {

		pr_info("AVX detected but unusable.\n");

		return -ENODEV;

	}



	return crypto_register_algs(cmll_algs, ARRAY_SIZE(cmll_algs));

}



static void __exit camellia_aesni_fini(void)

{

	crypto_unregister_algs(cmll_algs, ARRAY_SIZE(cmll_algs));

}



module_init(camellia_aesni_init);

module_exit(camellia_aesni_fini);



MODULE_LICENSE("GPL");

MODULE_DESCRIPTION("Camellia Cipher Algorithm, AES-NI/AVX optimized");

MODULE_ALIAS("camellia");

MODULE_ALIAS("camellia-asm");

crypto/Kconfig

+22 −0
Original line number Diff line number Diff line
@@ -803,6 +803,28 @@ config CRYPTO_CAMELLIA_X86_64 
	  See also:

	  <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>



config CRYPTO_CAMELLIA_AESNI_AVX_X86_64

	tristate "Camellia cipher algorithm (x86_64/AES-NI/AVX)"

	depends on X86 && 64BIT

	depends on CRYPTO

	select CRYPTO_ALGAPI

	select CRYPTO_CRYPTD

	select CRYPTO_ABLK_HELPER_X86

	select CRYPTO_GLUE_HELPER_X86

	select CRYPTO_CAMELLIA_X86_64

	select CRYPTO_LRW

	select CRYPTO_XTS

	help

	  Camellia cipher algorithm module (x86_64/AES-NI/AVX).



	  Camellia is a symmetric key block cipher developed jointly

	  at NTT and Mitsubishi Electric Corporation.



	  The Camellia specifies three key sizes: 128, 192 and 256 bits.



	  See also:

	  <https://info.isl.ntt.co.jp/crypt/eng/camellia/index_s.html>



config CRYPTO_CAMELLIA_SPARC64

	tristate "Camellia cipher algorithm (SPARC64)"

	depends on SPARC64

crypto/testmgr.c

+62 −0
Original line number Diff line number Diff line
@@ -1726,6 +1726,21 @@ static const struct alg_test_desc alg_test_descs[] = { 
				}

			}

		}

	}, {

		.alg = "__driver-cbc-camellia-aesni",

		.test = alg_test_null,

		.suite = {

			.cipher = {

				.enc = {

					.vecs = NULL,

					.count = 0

				},

				.dec = {

					.vecs = NULL,

					.count = 0

				}

			}

		}

	}, {

		.alg = "__driver-cbc-cast5-avx",

		.test = alg_test_null,
@@ -1817,6 +1832,21 @@ static const struct alg_test_desc alg_test_descs[] = { 
				}

			}

		}

	}, {

		.alg = "__driver-ecb-camellia-aesni",

		.test = alg_test_null,

		.suite = {

			.cipher = {

				.enc = {

					.vecs = NULL,

					.count = 0

				},

				.dec = {

					.vecs = NULL,

					.count = 0

				}

			}

		}

	}, {

		.alg = "__driver-ecb-cast5-avx",

		.test = alg_test_null,
@@ -2142,6 +2172,22 @@ static const struct alg_test_desc alg_test_descs[] = { 
				}

			}

		}

	}, {

		.alg = "cryptd(__driver-cbc-camellia-aesni)",

		.test = alg_test_null,

		.fips_allowed = 1,

		.suite = {

			.cipher = {

				.enc = {

					.vecs = NULL,

					.count = 0

				},

				.dec = {

					.vecs = NULL,

					.count = 0

				}

			}

		}

	}, {

		.alg = "cryptd(__driver-ecb-aes-aesni)",

		.test = alg_test_null,
@@ -2158,6 +2204,22 @@ static const struct alg_test_desc alg_test_descs[] = { 
				}

			}

		}

	}, {

		.alg = "cryptd(__driver-ecb-camellia-aesni)",

		.test = alg_test_null,

		.fips_allowed = 1,

		.suite = {

			.cipher = {

				.enc = {

					.vecs = NULL,

					.count = 0

				},

				.dec = {

					.vecs = NULL,

					.count = 0

				}

			}

		}

	}, {

		.alg = "cryptd(__driver-ecb-cast5-avx)",

		.test = alg_test_null,

CRA Git | Maintained and supported by SUSTech CRA and CCSE