openkylin
/
linux
mirror of https://gitee.com/openkylin/linux.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

crypto: tcrypt - Use skcipher 

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

Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
This commit is contained in:
Herbert Xu 2016-06-29 18:03:50 +08:00
parent 2495cf25f6
commit 7166e589da
1 changed files with 44 additions and 197 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

237
crypto/tcrypt.c
View File

@ -24,6 +24,7 @@
#include <crypto/aead.h> #include <crypto/aead.h>
#include <crypto/hash.h> #include <crypto/hash.h>
#include <crypto/skcipher.h>
#include <linux/err.h> #include <linux/err.h>
#include <linux/fips.h> #include <linux/fips.h>
#include <linux/init.h> #include <linux/init.h>
@ -92,76 +93,6 @@ static void tcrypt_complete(struct crypto_async_request *req, int err)
complete(&res->completion); 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) static inline int do_one_aead_op(struct aead_request *req, int ret)
{ {
if (ret == -EINPROGRESS || ret == -EBUSY) { if (ret == -EINPROGRESS || ret == -EBUSY) {
@ -455,106 +386,6 @@ static void test_aead_speed(const char *algo, int enc, unsigned int secs,
return; 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) static void test_hash_sg_init(struct scatterlist *sg)
{ {
int i; 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); 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) { if (ret == -EINPROGRESS || ret == -EBUSY) {
struct tcrypt_result *tr = req->base.data; 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; 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) int blen, int secs)
{ {
unsigned long start, end; unsigned long start, end;
@ -956,10 +787,10 @@ static int test_acipher_jiffies(struct ablkcipher_request *req, int enc,
time_before(jiffies, end); bcount++) { time_before(jiffies, end); bcount++) {
if (enc) if (enc)
ret = do_one_acipher_op(req, ret = do_one_acipher_op(req,
crypto_ablkcipher_encrypt(req)); crypto_skcipher_encrypt(req));
else else
ret = do_one_acipher_op(req, ret = do_one_acipher_op(req,
crypto_ablkcipher_decrypt(req)); crypto_skcipher_decrypt(req));
if (ret) if (ret)
return ret; return ret;
@ -970,7 +801,7 @@ static int test_acipher_jiffies(struct ablkcipher_request *req, int enc,
return 0; 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) int blen)
{ {
unsigned long cycles = 0; 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++) { for (i = 0; i < 4; i++) {
if (enc) if (enc)
ret = do_one_acipher_op(req, ret = do_one_acipher_op(req,
crypto_ablkcipher_encrypt(req)); crypto_skcipher_encrypt(req));
else else
ret = do_one_acipher_op(req, ret = do_one_acipher_op(req,
crypto_ablkcipher_decrypt(req)); crypto_skcipher_decrypt(req));
if (ret) if (ret)
goto out; goto out;
@ -997,10 +828,10 @@ static int test_acipher_cycles(struct ablkcipher_request *req, int enc,
start = get_cycles(); start = get_cycles();
if (enc) if (enc)
ret = do_one_acipher_op(req, ret = do_one_acipher_op(req,
crypto_ablkcipher_encrypt(req)); crypto_skcipher_encrypt(req));
else else
ret = do_one_acipher_op(req, ret = do_one_acipher_op(req,
crypto_ablkcipher_decrypt(req)); crypto_skcipher_decrypt(req));
end = get_cycles(); end = get_cycles();
if (ret) if (ret)
@ -1017,16 +848,16 @@ static int test_acipher_cycles(struct ablkcipher_request *req, int enc,
return ret; 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, 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; unsigned int ret, i, j, k, iv_len;
struct tcrypt_result tresult; struct tcrypt_result tresult;
const char *key; const char *key;
char iv[128]; char iv[128];
struct ablkcipher_request *req; struct skcipher_request *req;
struct crypto_ablkcipher *tfm; struct crypto_skcipher *tfm;
const char *e; const char *e;
u32 *b_size; u32 *b_size;
@ -1037,7 +868,7 @@ static void test_acipher_speed(const char *algo, int enc, unsigned int secs,
init_completion(&tresult.completion); 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)) { if (IS_ERR(tfm)) {
pr_err("failed to load transform for %s: %ld\n", algo, 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, 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) { if (!req) {
pr_err("tcrypt: skcipher: Failed to allocate request for %s\n", pr_err("tcrypt: skcipher: Failed to allocate request for %s\n",
algo); algo);
goto out; 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); tcrypt_complete, &tresult);
i = 0; 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) { if (ret) {
pr_err("setkey() failed flags=%x\n", pr_err("setkey() failed flags=%x\n",
crypto_ablkcipher_get_flags(tfm)); crypto_skcipher_get_flags(tfm));
goto out_free_req; 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); sg_set_buf(sg, tvmem[0] + *keysize, *b_size);
} }
iv_len = crypto_ablkcipher_ivsize(tfm); iv_len = crypto_skcipher_ivsize(tfm);
if (iv_len) if (iv_len)
memset(&iv, 0xff, 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) if (secs)
ret = test_acipher_jiffies(req, enc, 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) { if (ret) {
pr_err("%s() failed flags=%x\n", e, pr_err("%s() failed flags=%x\n", e,
crypto_ablkcipher_get_flags(tfm)); crypto_skcipher_get_flags(tfm));
break; break;
} }
b_size++; b_size++;
@ -1140,9 +971,25 @@ static void test_acipher_speed(const char *algo, int enc, unsigned int secs,
} while (*keysize); } while (*keysize);
out_free_req: out_free_req:
ablkcipher_request_free(req); skcipher_request_free(req);
out: 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) static void test_available(void)