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

crypto: sparc/des - convert to skcipher API 



Convert the glue code for the SPARC64 DES opcodes implementations of
DES-ECB, DES-CBC, 3DES-ECB, and 3DES-CBC from the deprecated "blkcipher"
API to the "skcipher" API.  This is needed in order for the blkcipher
API to be removed.

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

arch/sparc/crypto/des_glue.c

+227 −272
Original line number Diff line number Diff line
@@ -13,6 +13,7 @@ 
#include <linux/types.h>

#include <crypto/algapi.h>

#include <crypto/internal/des.h>

#include <crypto/internal/skcipher.h>



#include <asm/fpumacro.h>

#include <asm/pstate.h>
@@ -61,6 +62,12 @@ static int des_set_key(struct crypto_tfm *tfm, const u8 *key, 
	return 0;

}



static int des_set_key_skcipher(struct crypto_skcipher *tfm, const u8 *key,

				unsigned int keylen)

{

	return des_set_key(crypto_skcipher_tfm(tfm), key, keylen);

}



extern void des_sparc64_crypt(const u64 *key, const u64 *input,

			      u64 *output);
@@ -85,113 +92,90 @@ extern void des_sparc64_load_keys(const u64 *key); 
extern void des_sparc64_ecb_crypt(const u64 *input, u64 *output,

				  unsigned int len);



#define DES_BLOCK_MASK	(~(DES_BLOCK_SIZE - 1))



static int __ecb_crypt(struct blkcipher_desc *desc,

		       struct scatterlist *dst, struct scatterlist *src,

		       unsigned int nbytes, bool encrypt)

static int __ecb_crypt(struct skcipher_request *req, bool encrypt)

{

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

	struct blkcipher_walk walk;

	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);

	const struct des_sparc64_ctx *ctx = crypto_skcipher_ctx(tfm);

	struct skcipher_walk walk;

	unsigned int nbytes;

	int err;



	blkcipher_walk_init(&walk, dst, src, nbytes);

	err = blkcipher_walk_virt(desc, &walk);

	desc->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP;

	err = skcipher_walk_virt(&walk, req, true);

	if (err)

		return err;



	if (encrypt)

		des_sparc64_load_keys(&ctx->encrypt_expkey[0]);

	else

		des_sparc64_load_keys(&ctx->decrypt_expkey[0]);

	while ((nbytes = walk.nbytes)) {

		unsigned int block_len = nbytes & DES_BLOCK_MASK;



		if (likely(block_len)) {

			des_sparc64_ecb_crypt((const u64 *)walk.src.virt.addr,

					      (u64 *) walk.dst.virt.addr,

					      block_len);

		}

		nbytes &= DES_BLOCK_SIZE - 1;

		err = blkcipher_walk_done(desc, &walk, nbytes);

	while ((nbytes = walk.nbytes) != 0) {

		des_sparc64_ecb_crypt(walk.src.virt.addr, walk.dst.virt.addr,

				      round_down(nbytes, DES_BLOCK_SIZE));

		err = skcipher_walk_done(&walk, nbytes % DES_BLOCK_SIZE);

	}

	fprs_write(0);

	return err;

}



static int ecb_encrypt(struct blkcipher_desc *desc,

		       struct scatterlist *dst, struct scatterlist *src,

		       unsigned int nbytes)

static int ecb_encrypt(struct skcipher_request *req)

{

	return __ecb_crypt(desc, dst, src, nbytes, true);

	return __ecb_crypt(req, true);

}



static int ecb_decrypt(struct blkcipher_desc *desc,

		       struct scatterlist *dst, struct scatterlist *src,

		       unsigned int nbytes)

static int ecb_decrypt(struct skcipher_request *req)

{

	return __ecb_crypt(desc, dst, src, nbytes, false);

	return __ecb_crypt(req, false);

}



extern void des_sparc64_cbc_encrypt(const u64 *input, u64 *output,

				    unsigned int len, u64 *iv);



static int cbc_encrypt(struct blkcipher_desc *desc,

		       struct scatterlist *dst, struct scatterlist *src,

		       unsigned int nbytes)

extern void des_sparc64_cbc_decrypt(const u64 *input, u64 *output,

				    unsigned int len, u64 *iv);



static int __cbc_crypt(struct skcipher_request *req, bool encrypt)

{

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

	struct blkcipher_walk walk;

	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);

	const struct des_sparc64_ctx *ctx = crypto_skcipher_ctx(tfm);

	struct skcipher_walk walk;

	unsigned int nbytes;

	int err;



	blkcipher_walk_init(&walk, dst, src, nbytes);

	err = blkcipher_walk_virt(desc, &walk);

	desc->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP;

	err = skcipher_walk_virt(&walk, req, true);

	if (err)

		return err;



	if (encrypt)

		des_sparc64_load_keys(&ctx->encrypt_expkey[0]);

	while ((nbytes = walk.nbytes)) {

		unsigned int block_len = nbytes & DES_BLOCK_MASK;



		if (likely(block_len)) {

			des_sparc64_cbc_encrypt((const u64 *)walk.src.virt.addr,

						(u64 *) walk.dst.virt.addr,

						block_len, (u64 *) walk.iv);

		}

		nbytes &= DES_BLOCK_SIZE - 1;

		err = blkcipher_walk_done(desc, &walk, nbytes);

	else

		des_sparc64_load_keys(&ctx->decrypt_expkey[0]);

	while ((nbytes = walk.nbytes) != 0) {

		if (encrypt)

			des_sparc64_cbc_encrypt(walk.src.virt.addr,

						walk.dst.virt.addr,

						round_down(nbytes,

							   DES_BLOCK_SIZE),

						walk.iv);

		else

			des_sparc64_cbc_decrypt(walk.src.virt.addr,

						walk.dst.virt.addr,

						round_down(nbytes,

							   DES_BLOCK_SIZE),

						walk.iv);

		err = skcipher_walk_done(&walk, nbytes % DES_BLOCK_SIZE);

	}

	fprs_write(0);

	return err;

}



extern void des_sparc64_cbc_decrypt(const u64 *input, u64 *output,

				    unsigned int len, u64 *iv);



static int cbc_decrypt(struct blkcipher_desc *desc,

		       struct scatterlist *dst, struct scatterlist *src,

		       unsigned int nbytes)

static int cbc_encrypt(struct skcipher_request *req)

{

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

	struct blkcipher_walk walk;

	int err;



	blkcipher_walk_init(&walk, dst, src, nbytes);

	err = blkcipher_walk_virt(desc, &walk);

	desc->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP;



	des_sparc64_load_keys(&ctx->decrypt_expkey[0]);

	while ((nbytes = walk.nbytes)) {

		unsigned int block_len = nbytes & DES_BLOCK_MASK;



		if (likely(block_len)) {

			des_sparc64_cbc_decrypt((const u64 *)walk.src.virt.addr,

						(u64 *) walk.dst.virt.addr,

						block_len, (u64 *) walk.iv);

		}

		nbytes &= DES_BLOCK_SIZE - 1;

		err = blkcipher_walk_done(desc, &walk, nbytes);

	return __cbc_crypt(req, true);

}

	fprs_write(0);

	return err;



static int cbc_decrypt(struct skcipher_request *req)

{

	return __cbc_crypt(req, false);

}



static int des3_ede_set_key(struct crypto_tfm *tfm, const u8 *key,
@@ -227,6 +211,12 @@ static int des3_ede_set_key(struct crypto_tfm *tfm, const u8 *key, 
	return 0;

}



static int des3_ede_set_key_skcipher(struct crypto_skcipher *tfm, const u8 *key,

				     unsigned int keylen)

{

	return des3_ede_set_key(crypto_skcipher_tfm(tfm), key, keylen);

}



extern void des3_ede_sparc64_crypt(const u64 *key, const u64 *input,

				   u64 *output);
@@ -251,127 +241,101 @@ extern void des3_ede_sparc64_load_keys(const u64 *key); 
extern void des3_ede_sparc64_ecb_crypt(const u64 *expkey, const u64 *input,

				       u64 *output, unsigned int len);



static int __ecb3_crypt(struct blkcipher_desc *desc,

			struct scatterlist *dst, struct scatterlist *src,

			unsigned int nbytes, bool encrypt)

static int __ecb3_crypt(struct skcipher_request *req, bool encrypt)

{

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

	struct blkcipher_walk walk;

	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);

	const struct des3_ede_sparc64_ctx *ctx = crypto_skcipher_ctx(tfm);

	struct skcipher_walk walk;

	const u64 *K;

	unsigned int nbytes;

	int err;



	blkcipher_walk_init(&walk, dst, src, nbytes);

	err = blkcipher_walk_virt(desc, &walk);

	desc->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP;

	err = skcipher_walk_virt(&walk, req, true);

	if (err)

		return err;



	if (encrypt)

		K = &ctx->encrypt_expkey[0];

	else

		K = &ctx->decrypt_expkey[0];

	des3_ede_sparc64_load_keys(K);

	while ((nbytes = walk.nbytes)) {

		unsigned int block_len = nbytes & DES_BLOCK_MASK;



		if (likely(block_len)) {

			const u64 *src64 = (const u64 *)walk.src.virt.addr;

			des3_ede_sparc64_ecb_crypt(K, src64,

						   (u64 *) walk.dst.virt.addr,

						   block_len);

		}

		nbytes &= DES_BLOCK_SIZE - 1;

		err = blkcipher_walk_done(desc, &walk, nbytes);

	while ((nbytes = walk.nbytes) != 0) {

		des3_ede_sparc64_ecb_crypt(K, walk.src.virt.addr,

					   walk.dst.virt.addr,

					   round_down(nbytes, DES_BLOCK_SIZE));

		err = skcipher_walk_done(&walk, nbytes % DES_BLOCK_SIZE);

	}

	fprs_write(0);

	return err;

}



static int ecb3_encrypt(struct blkcipher_desc *desc,

		       struct scatterlist *dst, struct scatterlist *src,

		       unsigned int nbytes)

static int ecb3_encrypt(struct skcipher_request *req)

{

	return __ecb3_crypt(desc, dst, src, nbytes, true);

	return __ecb3_crypt(req, true);

}



static int ecb3_decrypt(struct blkcipher_desc *desc,

		       struct scatterlist *dst, struct scatterlist *src,

		       unsigned int nbytes)

static int ecb3_decrypt(struct skcipher_request *req)

{

	return __ecb3_crypt(desc, dst, src, nbytes, false);

	return __ecb3_crypt(req, false);

}



extern void des3_ede_sparc64_cbc_encrypt(const u64 *expkey, const u64 *input,

					 u64 *output, unsigned int len,

					 u64 *iv);



static int cbc3_encrypt(struct blkcipher_desc *desc,

			struct scatterlist *dst, struct scatterlist *src,

			unsigned int nbytes)

{

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

	struct blkcipher_walk walk;

	const u64 *K;

	int err;



	blkcipher_walk_init(&walk, dst, src, nbytes);

	err = blkcipher_walk_virt(desc, &walk);

	desc->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP;



	K = &ctx->encrypt_expkey[0];

	des3_ede_sparc64_load_keys(K);

	while ((nbytes = walk.nbytes)) {

		unsigned int block_len = nbytes & DES_BLOCK_MASK;



		if (likely(block_len)) {

			const u64 *src64 = (const u64 *)walk.src.virt.addr;

			des3_ede_sparc64_cbc_encrypt(K, src64,

						     (u64 *) walk.dst.virt.addr,

						     block_len,

						     (u64 *) walk.iv);

		}

		nbytes &= DES_BLOCK_SIZE - 1;

		err = blkcipher_walk_done(desc, &walk, nbytes);

	}

	fprs_write(0);

	return err;

}



extern void des3_ede_sparc64_cbc_decrypt(const u64 *expkey, const u64 *input,

					 u64 *output, unsigned int len,

					 u64 *iv);



static int cbc3_decrypt(struct blkcipher_desc *desc,

			struct scatterlist *dst, struct scatterlist *src,

			unsigned int nbytes)

static int __cbc3_crypt(struct skcipher_request *req, bool encrypt)

{

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

	struct blkcipher_walk walk;

	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);

	const struct des3_ede_sparc64_ctx *ctx = crypto_skcipher_ctx(tfm);

	struct skcipher_walk walk;

	const u64 *K;

	unsigned int nbytes;

	int err;



	blkcipher_walk_init(&walk, dst, src, nbytes);

	err = blkcipher_walk_virt(desc, &walk);

	desc->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP;

	err = skcipher_walk_virt(&walk, req, true);

	if (err)

		return err;



	if (encrypt)

		K = &ctx->encrypt_expkey[0];

	else

		K = &ctx->decrypt_expkey[0];

	des3_ede_sparc64_load_keys(K);

	while ((nbytes = walk.nbytes)) {

		unsigned int block_len = nbytes & DES_BLOCK_MASK;



		if (likely(block_len)) {

			const u64 *src64 = (const u64 *)walk.src.virt.addr;

			des3_ede_sparc64_cbc_decrypt(K, src64,

						     (u64 *) walk.dst.virt.addr,

						     block_len,

						     (u64 *) walk.iv);

		}

		nbytes &= DES_BLOCK_SIZE - 1;

		err = blkcipher_walk_done(desc, &walk, nbytes);

	while ((nbytes = walk.nbytes) != 0) {

		if (encrypt)

			des3_ede_sparc64_cbc_encrypt(K, walk.src.virt.addr,

						     walk.dst.virt.addr,

						     round_down(nbytes,

								DES_BLOCK_SIZE),

						     walk.iv);

		else

			des3_ede_sparc64_cbc_decrypt(K, walk.src.virt.addr,

						     walk.dst.virt.addr,

						     round_down(nbytes,

								DES_BLOCK_SIZE),

						     walk.iv);

		err = skcipher_walk_done(&walk, nbytes % DES_BLOCK_SIZE);

	}

	fprs_write(0);

	return err;

}



static struct crypto_alg algs[] = { {

static int cbc3_encrypt(struct skcipher_request *req)

{

	return __cbc3_crypt(req, true);

}



static int cbc3_decrypt(struct skcipher_request *req)

{

	return __cbc3_crypt(req, false);

}



static struct crypto_alg cipher_algs[] = {

	{

		.cra_name		= "des",

		.cra_driver_name	= "des-sparc64",

		.cra_priority		= SPARC_CR_OPCODE_PRIORITY,
@@ -389,45 +353,6 @@ static struct crypto_alg algs[] = { { 
				.cia_decrypt		= sparc_des_decrypt

			}

		}

}, {

	.cra_name		= "ecb(des)",

	.cra_driver_name	= "ecb-des-sparc64",

	.cra_priority		= SPARC_CR_OPCODE_PRIORITY,

	.cra_flags		= CRYPTO_ALG_TYPE_BLKCIPHER,

	.cra_blocksize		= DES_BLOCK_SIZE,

	.cra_ctxsize		= sizeof(struct des_sparc64_ctx),

	.cra_alignmask		= 7,

	.cra_type		= &crypto_blkcipher_type,

	.cra_module		= THIS_MODULE,

	.cra_u = {

		.blkcipher = {

			.min_keysize	= DES_KEY_SIZE,

			.max_keysize	= DES_KEY_SIZE,

			.setkey		= des_set_key,

			.encrypt	= ecb_encrypt,

			.decrypt	= ecb_decrypt,

		},

	},

}, {

	.cra_name		= "cbc(des)",

	.cra_driver_name	= "cbc-des-sparc64",

	.cra_priority		= SPARC_CR_OPCODE_PRIORITY,

	.cra_flags		= CRYPTO_ALG_TYPE_BLKCIPHER,

	.cra_blocksize		= DES_BLOCK_SIZE,

	.cra_ctxsize		= sizeof(struct des_sparc64_ctx),

	.cra_alignmask		= 7,

	.cra_type		= &crypto_blkcipher_type,

	.cra_module		= THIS_MODULE,

	.cra_u = {

		.blkcipher = {

			.min_keysize	= DES_KEY_SIZE,

			.max_keysize	= DES_KEY_SIZE,

			.ivsize		= DES_BLOCK_SIZE,

			.setkey		= des_set_key,

			.encrypt	= cbc_encrypt,

			.decrypt	= cbc_decrypt,

		},

	},

	}, {

		.cra_name		= "des3_ede",

		.cra_driver_name	= "des3_ede-sparc64",
@@ -446,46 +371,66 @@ static struct crypto_alg algs[] = { { 
				.cia_decrypt		= sparc_des3_ede_decrypt

			}

		}

	}

};



static struct skcipher_alg skcipher_algs[] = {

	{

		.base.cra_name		= "ecb(des)",

		.base.cra_driver_name	= "ecb-des-sparc64",

		.base.cra_priority	= SPARC_CR_OPCODE_PRIORITY,

		.base.cra_blocksize	= DES_BLOCK_SIZE,

		.base.cra_ctxsize	= sizeof(struct des_sparc64_ctx),

		.base.cra_alignmask	= 7,

		.base.cra_module	= THIS_MODULE,

		.min_keysize		= DES_KEY_SIZE,

		.max_keysize		= DES_KEY_SIZE,

		.setkey			= des_set_key_skcipher,

		.encrypt		= ecb_encrypt,

		.decrypt		= ecb_decrypt,

	}, {

	.cra_name		= "ecb(des3_ede)",

	.cra_driver_name	= "ecb-des3_ede-sparc64",

	.cra_priority		= SPARC_CR_OPCODE_PRIORITY,

	.cra_flags		= CRYPTO_ALG_TYPE_BLKCIPHER,

	.cra_blocksize		= DES3_EDE_BLOCK_SIZE,

	.cra_ctxsize		= sizeof(struct des3_ede_sparc64_ctx),

	.cra_alignmask		= 7,

	.cra_type		= &crypto_blkcipher_type,

	.cra_module		= THIS_MODULE,

	.cra_u = {

		.blkcipher = {

		.base.cra_name		= "cbc(des)",

		.base.cra_driver_name	= "cbc-des-sparc64",

		.base.cra_priority	= SPARC_CR_OPCODE_PRIORITY,

		.base.cra_blocksize	= DES_BLOCK_SIZE,

		.base.cra_ctxsize	= sizeof(struct des_sparc64_ctx),

		.base.cra_alignmask	= 7,

		.base.cra_module	= THIS_MODULE,

		.min_keysize		= DES_KEY_SIZE,

		.max_keysize		= DES_KEY_SIZE,

		.ivsize			= DES_BLOCK_SIZE,

		.setkey			= des_set_key_skcipher,

		.encrypt		= cbc_encrypt,

		.decrypt		= cbc_decrypt,

	}, {

		.base.cra_name		= "ecb(des3_ede)",

		.base.cra_driver_name	= "ecb-des3_ede-sparc64",

		.base.cra_priority	= SPARC_CR_OPCODE_PRIORITY,

		.base.cra_blocksize	= DES3_EDE_BLOCK_SIZE,

		.base.cra_ctxsize	= sizeof(struct des3_ede_sparc64_ctx),

		.base.cra_alignmask	= 7,

		.base.cra_module	= THIS_MODULE,

		.min_keysize		= DES3_EDE_KEY_SIZE,

		.max_keysize		= DES3_EDE_KEY_SIZE,

			.setkey		= des3_ede_set_key,

		.setkey			= des3_ede_set_key_skcipher,

		.encrypt		= ecb3_encrypt,

		.decrypt		= ecb3_decrypt,

		},

	},

	}, {

	.cra_name		= "cbc(des3_ede)",

	.cra_driver_name	= "cbc-des3_ede-sparc64",

	.cra_priority		= SPARC_CR_OPCODE_PRIORITY,

	.cra_flags		= CRYPTO_ALG_TYPE_BLKCIPHER,

	.cra_blocksize		= DES3_EDE_BLOCK_SIZE,

	.cra_ctxsize		= sizeof(struct des3_ede_sparc64_ctx),

	.cra_alignmask		= 7,

	.cra_type		= &crypto_blkcipher_type,

	.cra_module		= THIS_MODULE,

	.cra_u = {

		.blkcipher = {

		.base.cra_name		= "cbc(des3_ede)",

		.base.cra_driver_name	= "cbc-des3_ede-sparc64",

		.base.cra_priority	= SPARC_CR_OPCODE_PRIORITY,

		.base.cra_blocksize	= DES3_EDE_BLOCK_SIZE,

		.base.cra_ctxsize	= sizeof(struct des3_ede_sparc64_ctx),

		.base.cra_alignmask	= 7,

		.base.cra_module	= THIS_MODULE,

		.min_keysize		= DES3_EDE_KEY_SIZE,

		.max_keysize		= DES3_EDE_KEY_SIZE,

		.ivsize			= DES3_EDE_BLOCK_SIZE,

			.setkey		= des3_ede_set_key,

		.setkey			= des3_ede_set_key_skcipher,

		.encrypt		= cbc3_encrypt,

		.decrypt		= cbc3_decrypt,

		},

	},

} };

	}

};



static bool __init sparc64_has_des_opcode(void)

{
@@ -503,17 +448,27 @@ static bool __init sparc64_has_des_opcode(void) 


static int __init des_sparc64_mod_init(void)

{

	if (sparc64_has_des_opcode()) {

		pr_info("Using sparc64 des opcodes optimized DES implementation\n");

		return crypto_register_algs(algs, ARRAY_SIZE(algs));

	}

	int err;



	if (!sparc64_has_des_opcode()) {

		pr_info("sparc64 des opcodes not available.\n");

		return -ENODEV;

	}

	pr_info("Using sparc64 des opcodes optimized DES implementation\n");

	err = crypto_register_algs(cipher_algs, ARRAY_SIZE(cipher_algs));

	if (err)

		return err;

	err = crypto_register_skciphers(skcipher_algs,

					ARRAY_SIZE(skcipher_algs));

	if (err)

		crypto_unregister_algs(cipher_algs, ARRAY_SIZE(cipher_algs));

	return err;

}



static void __exit des_sparc64_mod_fini(void)

{

	crypto_unregister_algs(algs, ARRAY_SIZE(algs));

	crypto_unregister_algs(cipher_algs, ARRAY_SIZE(cipher_algs));

	crypto_unregister_skciphers(skcipher_algs, ARRAY_SIZE(skcipher_algs));

}



module_init(des_sparc64_mod_init);

crypto/Kconfig

+1 −0
Original line number Diff line number Diff line
@@ -1354,6 +1354,7 @@ config CRYPTO_DES_SPARC64 
	depends on SPARC64

	select CRYPTO_ALGAPI

	select CRYPTO_LIB_DES

	select CRYPTO_BLKCIPHER

	help

	  DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3),

	  optimized using SPARC64 crypto opcodes.

CRA Git | Maintained and supported by SUSTech CRA and CCSE