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

Commit 7166e589 authored by Herbert Xu's avatar Herbert Xu
Browse files

crypto: tcrypt - Use skcipher 



This patch converts tcrypt to use the new skcipher interface as
opposed to ablkcipher/blkcipher.

Signed-off-by: default avatarHerbert Xu <herbert@gondor.apana.org.au>
parent 2495cf25

crypto/tcrypt.c

+44 −197
Original line number Diff line number Diff line
@@ -24,6 +24,7 @@ 


#include <crypto/aead.h>

#include <crypto/hash.h>

#include <crypto/skcipher.h>

#include <linux/err.h>

#include <linux/fips.h>

#include <linux/init.h>
@@ -92,76 +93,6 @@ static void tcrypt_complete(struct crypto_async_request *req, int err) 
	complete(&res->completion);

}



static int test_cipher_jiffies(struct blkcipher_desc *desc, int enc,

			       struct scatterlist *sg, int blen, int secs)

{

	unsigned long start, end;

	int bcount;

	int ret;



	for (start = jiffies, end = start + secs * HZ, bcount = 0;

	     time_before(jiffies, end); bcount++) {

		if (enc)

			ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);

		else

			ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);



		if (ret)

			return ret;

	}



	printk("%d operations in %d seconds (%ld bytes)\n",

	       bcount, secs, (long)bcount * blen);

	return 0;

}



static int test_cipher_cycles(struct blkcipher_desc *desc, int enc,

			      struct scatterlist *sg, int blen)

{

	unsigned long cycles = 0;

	int ret = 0;

	int i;



	local_irq_disable();



	/* Warm-up run. */

	for (i = 0; i < 4; i++) {

		if (enc)

			ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);

		else

			ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);



		if (ret)

			goto out;

	}



	/* The real thing. */

	for (i = 0; i < 8; i++) {

		cycles_t start, end;



		start = get_cycles();

		if (enc)

			ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);

		else

			ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);

		end = get_cycles();



		if (ret)

			goto out;



		cycles += end - start;

	}



out:

	local_irq_enable();



	if (ret == 0)

		printk("1 operation in %lu cycles (%d bytes)\n",

		       (cycles + 4) / 8, blen);



	return ret;

}



static inline int do_one_aead_op(struct aead_request *req, int ret)

{

	if (ret == -EINPROGRESS || ret == -EBUSY) {
@@ -455,106 +386,6 @@ static void test_aead_speed(const char *algo, int enc, unsigned int secs, 
	return;

}



static void test_cipher_speed(const char *algo, int enc, unsigned int secs,

			      struct cipher_speed_template *template,

			      unsigned int tcount, u8 *keysize)

{

	unsigned int ret, i, j, iv_len;

	const char *key;

	char iv[128];

	struct crypto_blkcipher *tfm;

	struct blkcipher_desc desc;

	const char *e;

	u32 *b_size;



	if (enc == ENCRYPT)

	        e = "encryption";

	else

		e = "decryption";



	tfm = crypto_alloc_blkcipher(algo, 0, CRYPTO_ALG_ASYNC);



	if (IS_ERR(tfm)) {

		printk("failed to load transform for %s: %ld\n", algo,

		       PTR_ERR(tfm));

		return;

	}

	desc.tfm = tfm;

	desc.flags = 0;



	printk(KERN_INFO "\ntesting speed of %s (%s) %s\n", algo,

			get_driver_name(crypto_blkcipher, tfm), e);



	i = 0;

	do {



		b_size = block_sizes;

		do {

			struct scatterlist sg[TVMEMSIZE];



			if ((*keysize + *b_size) > TVMEMSIZE * PAGE_SIZE) {

				printk("template (%u) too big for "

				       "tvmem (%lu)\n", *keysize + *b_size,

				       TVMEMSIZE * PAGE_SIZE);

				goto out;

			}



			printk("test %u (%d bit key, %d byte blocks): ", i,

					*keysize * 8, *b_size);



			memset(tvmem[0], 0xff, PAGE_SIZE);



			/* set key, plain text and IV */

			key = tvmem[0];

			for (j = 0; j < tcount; j++) {

				if (template[j].klen == *keysize) {

					key = template[j].key;

					break;

				}

			}



			ret = crypto_blkcipher_setkey(tfm, key, *keysize);

			if (ret) {

				printk("setkey() failed flags=%x\n",

						crypto_blkcipher_get_flags(tfm));

				goto out;

			}



			sg_init_table(sg, TVMEMSIZE);

			sg_set_buf(sg, tvmem[0] + *keysize,

				   PAGE_SIZE - *keysize);

			for (j = 1; j < TVMEMSIZE; j++) {

				sg_set_buf(sg + j, tvmem[j], PAGE_SIZE);

				memset (tvmem[j], 0xff, PAGE_SIZE);

			}



			iv_len = crypto_blkcipher_ivsize(tfm);

			if (iv_len) {

				memset(&iv, 0xff, iv_len);

				crypto_blkcipher_set_iv(tfm, iv, iv_len);

			}



			if (secs)

				ret = test_cipher_jiffies(&desc, enc, sg,

							  *b_size, secs);

			else

				ret = test_cipher_cycles(&desc, enc, sg,

							 *b_size);



			if (ret) {

				printk("%s() failed flags=%x\n", e, desc.flags);

				break;

			}

			b_size++;

			i++;

		} while (*b_size);

		keysize++;

	} while (*keysize);



out:

	crypto_free_blkcipher(tfm);

}



static void test_hash_sg_init(struct scatterlist *sg)

{

	int i;
@@ -932,7 +763,7 @@ static void test_hash_speed(const char *algo, unsigned int secs, 
	return test_ahash_speed_common(algo, secs, speed, CRYPTO_ALG_ASYNC);

}



static inline int do_one_acipher_op(struct ablkcipher_request *req, int ret)

static inline int do_one_acipher_op(struct skcipher_request *req, int ret)

{

	if (ret == -EINPROGRESS || ret == -EBUSY) {

		struct tcrypt_result *tr = req->base.data;
@@ -945,7 +776,7 @@ static inline int do_one_acipher_op(struct ablkcipher_request *req, int ret) 
	return ret;

}



static int test_acipher_jiffies(struct ablkcipher_request *req, int enc,

static int test_acipher_jiffies(struct skcipher_request *req, int enc,

				int blen, int secs)

{

	unsigned long start, end;
@@ -956,10 +787,10 @@ static int test_acipher_jiffies(struct ablkcipher_request *req, int enc, 
	     time_before(jiffies, end); bcount++) {

		if (enc)

			ret = do_one_acipher_op(req,

						crypto_ablkcipher_encrypt(req));

						crypto_skcipher_encrypt(req));

		else

			ret = do_one_acipher_op(req,

						crypto_ablkcipher_decrypt(req));

						crypto_skcipher_decrypt(req));



		if (ret)

			return ret;
@@ -970,7 +801,7 @@ static int test_acipher_jiffies(struct ablkcipher_request *req, int enc, 
	return 0;

}



static int test_acipher_cycles(struct ablkcipher_request *req, int enc,

static int test_acipher_cycles(struct skcipher_request *req, int enc,

			       int blen)

{

	unsigned long cycles = 0;
@@ -981,10 +812,10 @@ static int test_acipher_cycles(struct ablkcipher_request *req, int enc, 
	for (i = 0; i < 4; i++) {

		if (enc)

			ret = do_one_acipher_op(req,

						crypto_ablkcipher_encrypt(req));

						crypto_skcipher_encrypt(req));

		else

			ret = do_one_acipher_op(req,

						crypto_ablkcipher_decrypt(req));

						crypto_skcipher_decrypt(req));



		if (ret)

			goto out;
@@ -997,10 +828,10 @@ static int test_acipher_cycles(struct ablkcipher_request *req, int enc, 
		start = get_cycles();

		if (enc)

			ret = do_one_acipher_op(req,

						crypto_ablkcipher_encrypt(req));

						crypto_skcipher_encrypt(req));

		else

			ret = do_one_acipher_op(req,

						crypto_ablkcipher_decrypt(req));

						crypto_skcipher_decrypt(req));

		end = get_cycles();



		if (ret)
@@ -1017,16 +848,16 @@ static int test_acipher_cycles(struct ablkcipher_request *req, int enc, 
	return ret;

}



static void test_acipher_speed(const char *algo, int enc, unsigned int secs,

static void test_skcipher_speed(const char *algo, int enc, unsigned int secs,

				struct cipher_speed_template *template,

			       unsigned int tcount, u8 *keysize)

				unsigned int tcount, u8 *keysize, bool async)

{

	unsigned int ret, i, j, k, iv_len;

	struct tcrypt_result tresult;

	const char *key;

	char iv[128];

	struct ablkcipher_request *req;

	struct crypto_ablkcipher *tfm;

	struct skcipher_request *req;

	struct crypto_skcipher *tfm;

	const char *e;

	u32 *b_size;
@@ -1037,7 +868,7 @@ static void test_acipher_speed(const char *algo, int enc, unsigned int secs, 


	init_completion(&tresult.completion);



	tfm = crypto_alloc_ablkcipher(algo, 0, 0);

	tfm = crypto_alloc_skcipher(algo, 0, async ? 0 : CRYPTO_ALG_ASYNC);



	if (IS_ERR(tfm)) {

		pr_err("failed to load transform for %s: %ld\n", algo,
@@ -1046,16 +877,16 @@ static void test_acipher_speed(const char *algo, int enc, unsigned int secs, 
	}



	pr_info("\ntesting speed of async %s (%s) %s\n", algo,

			get_driver_name(crypto_ablkcipher, tfm), e);

			get_driver_name(crypto_skcipher, tfm), e);



	req = ablkcipher_request_alloc(tfm, GFP_KERNEL);

	req = skcipher_request_alloc(tfm, GFP_KERNEL);

	if (!req) {

		pr_err("tcrypt: skcipher: Failed to allocate request for %s\n",

		       algo);

		goto out;

	}



	ablkcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,

	skcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,

				      tcrypt_complete, &tresult);



	i = 0;
@@ -1086,12 +917,12 @@ static void test_acipher_speed(const char *algo, int enc, unsigned int secs, 
				}

			}



			crypto_ablkcipher_clear_flags(tfm, ~0);

			crypto_skcipher_clear_flags(tfm, ~0);



			ret = crypto_ablkcipher_setkey(tfm, key, *keysize);

			ret = crypto_skcipher_setkey(tfm, key, *keysize);

			if (ret) {

				pr_err("setkey() failed flags=%x\n",

					crypto_ablkcipher_get_flags(tfm));

					crypto_skcipher_get_flags(tfm));

				goto out_free_req;

			}
@@ -1115,11 +946,11 @@ static void test_acipher_speed(const char *algo, int enc, unsigned int secs, 
				sg_set_buf(sg, tvmem[0] + *keysize, *b_size);

			}



			iv_len = crypto_ablkcipher_ivsize(tfm);

			iv_len = crypto_skcipher_ivsize(tfm);

			if (iv_len)

				memset(&iv, 0xff, iv_len);



			ablkcipher_request_set_crypt(req, sg, sg, *b_size, iv);

			skcipher_request_set_crypt(req, sg, sg, *b_size, iv);



			if (secs)

				ret = test_acipher_jiffies(req, enc,
@@ -1130,7 +961,7 @@ static void test_acipher_speed(const char *algo, int enc, unsigned int secs, 


			if (ret) {

				pr_err("%s() failed flags=%x\n", e,

					crypto_ablkcipher_get_flags(tfm));

				       crypto_skcipher_get_flags(tfm));

				break;

			}

			b_size++;
@@ -1140,9 +971,25 @@ static void test_acipher_speed(const char *algo, int enc, unsigned int secs, 
	} while (*keysize);



out_free_req:

	ablkcipher_request_free(req);

	skcipher_request_free(req);

out:

	crypto_free_ablkcipher(tfm);

	crypto_free_skcipher(tfm);

}



static void test_acipher_speed(const char *algo, int enc, unsigned int secs,

			       struct cipher_speed_template *template,

			       unsigned int tcount, u8 *keysize)

{

	return test_skcipher_speed(algo, enc, secs, template, tcount, keysize,

				   true);

}



static void test_cipher_speed(const char *algo, int enc, unsigned int secs,

			      struct cipher_speed_template *template,

			      unsigned int tcount, u8 *keysize)

{

	return test_skcipher_speed(algo, enc, secs, template, tcount, keysize,

				   false);

}



static void test_available(void)