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

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

crypto: x86/blowfish: convert to skcipher interface 



Convert the x86 asm implementation of Blowfish from the (deprecated)
blkcipher interface over to the skcipher interface.

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

arch/x86/crypto/blowfish_glue.c

+113 −117
Original line number Diff line number Diff line
@@ -25,13 +25,13 @@ 
 *

 */



#include <asm/processor.h>

#include <crypto/algapi.h>

#include <crypto/blowfish.h>

#include <crypto/internal/skcipher.h>

#include <linux/crypto.h>

#include <linux/init.h>

#include <linux/module.h>

#include <linux/types.h>

#include <crypto/algapi.h>



/* regular block cipher functions */

asmlinkage void __blowfish_enc_blk(struct bf_ctx *ctx, u8 *dst, const u8 *src,
@@ -77,20 +77,28 @@ static void blowfish_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) 
	blowfish_dec_blk(crypto_tfm_ctx(tfm), dst, src);

}



static int ecb_crypt(struct blkcipher_desc *desc, struct blkcipher_walk *walk,

static int blowfish_setkey_skcipher(struct crypto_skcipher *tfm,

				    const u8 *key, unsigned int keylen)

{

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

}



static int ecb_crypt(struct skcipher_request *req,

		     void (*fn)(struct bf_ctx *, u8 *, const u8 *),

		     void (*fn_4way)(struct bf_ctx *, u8 *, const u8 *))

{

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

	unsigned int bsize = BF_BLOCK_SIZE;

	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);

	struct bf_ctx *ctx = crypto_skcipher_ctx(tfm);

	struct skcipher_walk walk;

	unsigned int nbytes;

	int err;



	err = blkcipher_walk_virt(desc, walk);

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



	while ((nbytes = walk->nbytes)) {

		u8 *wsrc = walk->src.virt.addr;

		u8 *wdst = walk->dst.virt.addr;

	while ((nbytes = walk.nbytes)) {

		u8 *wsrc = walk.src.virt.addr;

		u8 *wdst = walk.dst.virt.addr;



		/* Process four block batch */

		if (nbytes >= bsize * 4) {
@@ -116,34 +124,25 @@ static int ecb_crypt(struct blkcipher_desc *desc, struct blkcipher_walk *walk, 
		} while (nbytes >= bsize);



done:

		err = blkcipher_walk_done(desc, walk, nbytes);

		err = skcipher_walk_done(&walk, nbytes);

	}



	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)

{

	struct blkcipher_walk walk;



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

	return ecb_crypt(desc, &walk, blowfish_enc_blk, blowfish_enc_blk_4way);

	return ecb_crypt(req, blowfish_enc_blk, blowfish_enc_blk_4way);

}



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)

{

	struct blkcipher_walk walk;



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

	return ecb_crypt(desc, &walk, blowfish_dec_blk, blowfish_dec_blk_4way);

	return ecb_crypt(req, blowfish_dec_blk, blowfish_dec_blk_4way);

}



static unsigned int __cbc_encrypt(struct blkcipher_desc *desc,

				  struct blkcipher_walk *walk)

static unsigned int __cbc_encrypt(struct bf_ctx *ctx,

				  struct skcipher_walk *walk)

{

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

	unsigned int bsize = BF_BLOCK_SIZE;

	unsigned int nbytes = walk->nbytes;

	u64 *src = (u64 *)walk->src.virt.addr;
@@ -164,27 +163,27 @@ static unsigned int __cbc_encrypt(struct blkcipher_desc *desc, 
	return nbytes;

}



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

		       struct scatterlist *src, unsigned int nbytes)

static int cbc_encrypt(struct skcipher_request *req)

{

	struct blkcipher_walk walk;

	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);

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

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



	while ((nbytes = walk.nbytes)) {

		nbytes = __cbc_encrypt(desc, &walk);

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

		nbytes = __cbc_encrypt(ctx, &walk);

		err = skcipher_walk_done(&walk, nbytes);

	}



	return err;

}



static unsigned int __cbc_decrypt(struct blkcipher_desc *desc,

				  struct blkcipher_walk *walk)

static unsigned int __cbc_decrypt(struct bf_ctx *ctx,

				  struct skcipher_walk *walk)

{

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

	unsigned int bsize = BF_BLOCK_SIZE;

	unsigned int nbytes = walk->nbytes;

	u64 *src = (u64 *)walk->src.virt.addr;
@@ -245,24 +244,25 @@ static unsigned int __cbc_decrypt(struct blkcipher_desc *desc, 
	return nbytes;

}



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

		       struct scatterlist *src, unsigned int nbytes)

static int cbc_decrypt(struct skcipher_request *req)

{

	struct blkcipher_walk walk;

	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);

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

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



	while ((nbytes = walk.nbytes)) {

		nbytes = __cbc_decrypt(desc, &walk);

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

		nbytes = __cbc_decrypt(ctx, &walk);

		err = skcipher_walk_done(&walk, nbytes);

	}



	return err;

}



static void ctr_crypt_final(struct bf_ctx *ctx, struct blkcipher_walk *walk)

static void ctr_crypt_final(struct bf_ctx *ctx, struct skcipher_walk *walk)

{

	u8 *ctrblk = walk->iv;

	u8 keystream[BF_BLOCK_SIZE];
@@ -276,10 +276,8 @@ static void ctr_crypt_final(struct bf_ctx *ctx, struct blkcipher_walk *walk) 
	crypto_inc(ctrblk, BF_BLOCK_SIZE);

}



static unsigned int __ctr_crypt(struct blkcipher_desc *desc,

				struct blkcipher_walk *walk)

static unsigned int __ctr_crypt(struct bf_ctx *ctx, struct skcipher_walk *walk)

{

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

	unsigned int bsize = BF_BLOCK_SIZE;

	unsigned int nbytes = walk->nbytes;

	u64 *src = (u64 *)walk->src.virt.addr;
@@ -332,29 +330,30 @@ static unsigned int __ctr_crypt(struct blkcipher_desc *desc, 
	return nbytes;

}



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

		     struct scatterlist *src, unsigned int nbytes)

static int ctr_crypt(struct skcipher_request *req)

{

	struct blkcipher_walk walk;

	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);

	struct bf_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_block(desc, &walk, BF_BLOCK_SIZE);

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



	while ((nbytes = walk.nbytes) >= BF_BLOCK_SIZE) {

		nbytes = __ctr_crypt(desc, &walk);

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

		nbytes = __ctr_crypt(ctx, &walk);

		err = skcipher_walk_done(&walk, nbytes);

	}



	if (walk.nbytes) {

		ctr_crypt_final(crypto_blkcipher_ctx(desc->tfm), &walk);

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

	if (nbytes) {

		ctr_crypt_final(ctx, &walk);

		err = skcipher_walk_done(&walk, 0);

	}



	return err;

}



static struct crypto_alg bf_algs[4] = { {

static struct crypto_alg bf_cipher_alg = {

	.cra_name		= "blowfish",

	.cra_driver_name	= "blowfish-asm",

	.cra_priority		= 200,
@@ -372,66 +371,50 @@ static struct crypto_alg bf_algs[4] = { { 
			.cia_decrypt		= blowfish_decrypt,

		}

	}

}, {

	.cra_name		= "ecb(blowfish)",

	.cra_driver_name	= "ecb-blowfish-asm",

	.cra_priority		= 300,

	.cra_flags		= CRYPTO_ALG_TYPE_BLKCIPHER,

	.cra_blocksize		= BF_BLOCK_SIZE,

	.cra_ctxsize		= sizeof(struct bf_ctx),

	.cra_alignmask		= 0,

	.cra_type		= &crypto_blkcipher_type,

	.cra_module		= THIS_MODULE,

	.cra_u = {

		.blkcipher = {

};



static struct skcipher_alg bf_skcipher_algs[] = {

	{

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

		.base.cra_driver_name	= "ecb-blowfish-asm",

		.base.cra_priority	= 300,

		.base.cra_blocksize	= BF_BLOCK_SIZE,

		.base.cra_ctxsize	= sizeof(struct bf_ctx),

		.base.cra_module	= THIS_MODULE,

		.min_keysize		= BF_MIN_KEY_SIZE,

		.max_keysize		= BF_MAX_KEY_SIZE,

			.setkey		= blowfish_setkey,

		.setkey			= blowfish_setkey_skcipher,

		.encrypt		= ecb_encrypt,

		.decrypt		= ecb_decrypt,

		},

	},

	}, {

	.cra_name		= "cbc(blowfish)",

	.cra_driver_name	= "cbc-blowfish-asm",

	.cra_priority		= 300,

	.cra_flags		= CRYPTO_ALG_TYPE_BLKCIPHER,

	.cra_blocksize		= BF_BLOCK_SIZE,

	.cra_ctxsize		= sizeof(struct bf_ctx),

	.cra_alignmask		= 0,

	.cra_type		= &crypto_blkcipher_type,

	.cra_module		= THIS_MODULE,

	.cra_u = {

		.blkcipher = {

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

		.base.cra_driver_name	= "cbc-blowfish-asm",

		.base.cra_priority	= 300,

		.base.cra_blocksize	= BF_BLOCK_SIZE,

		.base.cra_ctxsize	= sizeof(struct bf_ctx),

		.base.cra_module	= THIS_MODULE,

		.min_keysize		= BF_MIN_KEY_SIZE,

		.max_keysize		= BF_MAX_KEY_SIZE,

		.ivsize			= BF_BLOCK_SIZE,

			.setkey		= blowfish_setkey,

		.setkey			= blowfish_setkey_skcipher,

		.encrypt		= cbc_encrypt,

		.decrypt		= cbc_decrypt,

		},

	},

	}, {

	.cra_name		= "ctr(blowfish)",

	.cra_driver_name	= "ctr-blowfish-asm",

	.cra_priority		= 300,

	.cra_flags		= CRYPTO_ALG_TYPE_BLKCIPHER,

	.cra_blocksize		= 1,

	.cra_ctxsize		= sizeof(struct bf_ctx),

	.cra_alignmask		= 0,

	.cra_type		= &crypto_blkcipher_type,

	.cra_module		= THIS_MODULE,

	.cra_u = {

		.blkcipher = {

		.base.cra_name		= "ctr(blowfish)",

		.base.cra_driver_name	= "ctr-blowfish-asm",

		.base.cra_priority	= 300,

		.base.cra_blocksize	= 1,

		.base.cra_ctxsize	= sizeof(struct bf_ctx),

		.base.cra_module	= THIS_MODULE,

		.min_keysize		= BF_MIN_KEY_SIZE,

		.max_keysize		= BF_MAX_KEY_SIZE,

		.ivsize			= BF_BLOCK_SIZE,

			.setkey		= blowfish_setkey,

		.chunksize		= BF_BLOCK_SIZE,

		.setkey			= blowfish_setkey_skcipher,

		.encrypt		= ctr_crypt,

		.decrypt		= ctr_crypt,

	},

	},

} };

};



static bool is_blacklisted_cpu(void)

{
@@ -456,6 +439,8 @@ MODULE_PARM_DESC(force, "Force module load, ignore CPU blacklist"); 


static int __init init(void)

{

	int err;



	if (!force && is_blacklisted_cpu()) {

		printk(KERN_INFO

			"blowfish-x86_64: performance on this CPU "
@@ -464,12 +449,23 @@ static int __init init(void) 
		return -ENODEV;

	}



	return crypto_register_algs(bf_algs, ARRAY_SIZE(bf_algs));

	err = crypto_register_alg(&bf_cipher_alg);

	if (err)

		return err;



	err = crypto_register_skciphers(bf_skcipher_algs,

					ARRAY_SIZE(bf_skcipher_algs));

	if (err)

		crypto_unregister_alg(&bf_cipher_alg);



	return err;

}



static void __exit fini(void)

{

	crypto_unregister_algs(bf_algs, ARRAY_SIZE(bf_algs));

	crypto_unregister_alg(&bf_cipher_alg);

	crypto_unregister_skciphers(bf_skcipher_algs,

				    ARRAY_SIZE(bf_skcipher_algs));

}



module_init(init);

crypto/Kconfig

+1 −1
Original line number Diff line number Diff line
@@ -1114,7 +1114,7 @@ config CRYPTO_BLOWFISH_COMMON 
config CRYPTO_BLOWFISH_X86_64

	tristate "Blowfish cipher algorithm (x86_64)"

	depends on X86 && 64BIT

	select CRYPTO_ALGAPI

	select CRYPTO_BLKCIPHER

	select CRYPTO_BLOWFISH_COMMON

	help

	  Blowfish cipher algorithm (x86_64), by Bruce Schneier.