2008-07-31 17:08:25 +08:00
|
|
|
/*
|
|
|
|
* Algorithm testing framework and tests.
|
|
|
|
*
|
|
|
|
* Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
|
|
|
|
* Copyright (c) 2002 Jean-Francois Dive <jef@linuxbe.org>
|
|
|
|
* Copyright (c) 2007 Nokia Siemens Networks
|
|
|
|
* Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au>
|
|
|
|
*
|
2010-11-05 03:02:04 +08:00
|
|
|
* Updated RFC4106 AES-GCM testing.
|
|
|
|
* Authors: Aidan O'Mahony (aidan.o.mahony@intel.com)
|
|
|
|
* Adrian Hoban <adrian.hoban@intel.com>
|
|
|
|
* Gabriele Paoloni <gabriele.paoloni@intel.com>
|
|
|
|
* Tadeusz Struk (tadeusz.struk@intel.com)
|
|
|
|
* Copyright (c) 2010, Intel Corporation.
|
|
|
|
*
|
2008-07-31 17:08:25 +08:00
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2015-04-22 15:06:31 +08:00
|
|
|
#include <crypto/aead.h>
|
2008-07-31 17:08:25 +08:00
|
|
|
#include <crypto/hash.h>
|
2015-08-20 15:21:46 +08:00
|
|
|
#include <crypto/skcipher.h>
|
2008-07-31 17:08:25 +08:00
|
|
|
#include <linux/err.h>
|
2015-04-22 13:25:58 +08:00
|
|
|
#include <linux/fips.h>
|
2008-07-31 17:08:25 +08:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/scatterlist.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/string.h>
|
2009-05-04 19:44:50 +08:00
|
|
|
#include <crypto/rng.h>
|
2014-05-31 23:25:36 +08:00
|
|
|
#include <crypto/drbg.h>
|
2015-06-17 01:31:06 +08:00
|
|
|
#include <crypto/akcipher.h>
|
2016-06-23 00:49:14 +08:00
|
|
|
#include <crypto/kpp.h>
|
2016-10-21 20:19:54 +08:00
|
|
|
#include <crypto/acompress.h>
|
2008-07-31 17:08:25 +08:00
|
|
|
|
|
|
|
#include "internal.h"
|
2010-06-03 18:53:43 +08:00
|
|
|
|
2016-05-03 17:00:17 +08:00
|
|
|
static bool notests;
|
|
|
|
module_param(notests, bool, 0644);
|
|
|
|
MODULE_PARM_DESC(notests, "disable crypto self-tests");
|
|
|
|
|
2010-08-06 09:40:28 +08:00
|
|
|
#ifdef CONFIG_CRYPTO_MANAGER_DISABLE_TESTS
|
2010-06-03 18:53:43 +08:00
|
|
|
|
|
|
|
/* a perfect nop */
|
|
|
|
int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
2008-07-31 17:08:25 +08:00
|
|
|
#include "testmgr.h"
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Need slab memory for testing (size in number of pages).
|
|
|
|
*/
|
|
|
|
#define XBUFSIZE 8
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Indexes into the xbuf to simulate cross-page access.
|
|
|
|
*/
|
|
|
|
#define IDX1 32
|
|
|
|
#define IDX2 32400
|
2016-12-08 16:23:52 +08:00
|
|
|
#define IDX3 1511
|
2008-07-31 17:08:25 +08:00
|
|
|
#define IDX4 8193
|
|
|
|
#define IDX5 22222
|
|
|
|
#define IDX6 17101
|
|
|
|
#define IDX7 27333
|
|
|
|
#define IDX8 3000
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Used by test_cipher()
|
|
|
|
*/
|
|
|
|
#define ENCRYPT 1
|
|
|
|
#define DECRYPT 0
|
|
|
|
|
|
|
|
struct aead_test_suite {
|
|
|
|
struct {
|
2017-02-25 07:46:59 +08:00
|
|
|
const struct aead_testvec *vecs;
|
2008-07-31 17:08:25 +08:00
|
|
|
unsigned int count;
|
|
|
|
} enc, dec;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct cipher_test_suite {
|
|
|
|
struct {
|
2017-02-25 07:46:59 +08:00
|
|
|
const struct cipher_testvec *vecs;
|
2008-07-31 17:08:25 +08:00
|
|
|
unsigned int count;
|
|
|
|
} enc, dec;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct comp_test_suite {
|
|
|
|
struct {
|
2017-02-25 07:46:59 +08:00
|
|
|
const struct comp_testvec *vecs;
|
2008-07-31 17:08:25 +08:00
|
|
|
unsigned int count;
|
|
|
|
} comp, decomp;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct hash_test_suite {
|
2017-02-25 07:46:59 +08:00
|
|
|
const struct hash_testvec *vecs;
|
2008-07-31 17:08:25 +08:00
|
|
|
unsigned int count;
|
|
|
|
};
|
|
|
|
|
2009-05-04 19:44:50 +08:00
|
|
|
struct cprng_test_suite {
|
2017-02-25 07:46:59 +08:00
|
|
|
const struct cprng_testvec *vecs;
|
2009-05-04 19:44:50 +08:00
|
|
|
unsigned int count;
|
|
|
|
};
|
|
|
|
|
2014-05-31 23:25:36 +08:00
|
|
|
struct drbg_test_suite {
|
2017-02-25 07:46:59 +08:00
|
|
|
const struct drbg_testvec *vecs;
|
2014-05-31 23:25:36 +08:00
|
|
|
unsigned int count;
|
|
|
|
};
|
|
|
|
|
2015-06-17 01:31:06 +08:00
|
|
|
struct akcipher_test_suite {
|
2017-02-25 07:46:59 +08:00
|
|
|
const struct akcipher_testvec *vecs;
|
2015-06-17 01:31:06 +08:00
|
|
|
unsigned int count;
|
|
|
|
};
|
|
|
|
|
2016-06-23 00:49:14 +08:00
|
|
|
struct kpp_test_suite {
|
2017-02-25 07:46:59 +08:00
|
|
|
const struct kpp_testvec *vecs;
|
2016-06-23 00:49:14 +08:00
|
|
|
unsigned int count;
|
|
|
|
};
|
|
|
|
|
2008-07-31 17:08:25 +08:00
|
|
|
struct alg_test_desc {
|
|
|
|
const char *alg;
|
|
|
|
int (*test)(const struct alg_test_desc *desc, const char *driver,
|
|
|
|
u32 type, u32 mask);
|
2009-05-15 13:16:03 +08:00
|
|
|
int fips_allowed; /* set if alg is allowed in fips mode */
|
2008-07-31 17:08:25 +08:00
|
|
|
|
|
|
|
union {
|
|
|
|
struct aead_test_suite aead;
|
|
|
|
struct cipher_test_suite cipher;
|
|
|
|
struct comp_test_suite comp;
|
|
|
|
struct hash_test_suite hash;
|
2009-05-04 19:44:50 +08:00
|
|
|
struct cprng_test_suite cprng;
|
2014-05-31 23:25:36 +08:00
|
|
|
struct drbg_test_suite drbg;
|
2015-06-17 01:31:06 +08:00
|
|
|
struct akcipher_test_suite akcipher;
|
2016-06-23 00:49:14 +08:00
|
|
|
struct kpp_test_suite kpp;
|
2008-07-31 17:08:25 +08:00
|
|
|
} suite;
|
|
|
|
};
|
|
|
|
|
2017-02-25 07:46:59 +08:00
|
|
|
static const unsigned int IDX[8] = {
|
|
|
|
IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
|
2008-07-31 17:08:25 +08:00
|
|
|
|
|
|
|
static void hexdump(unsigned char *buf, unsigned int len)
|
|
|
|
{
|
|
|
|
print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET,
|
|
|
|
16, 1,
|
|
|
|
buf, len, false);
|
|
|
|
}
|
|
|
|
|
2009-05-06 14:15:47 +08:00
|
|
|
static int testmgr_alloc_buf(char *buf[XBUFSIZE])
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < XBUFSIZE; i++) {
|
|
|
|
buf[i] = (void *)__get_free_page(GFP_KERNEL);
|
|
|
|
if (!buf[i])
|
|
|
|
goto err_free_buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_free_buf:
|
|
|
|
while (i-- > 0)
|
|
|
|
free_page((unsigned long)buf[i]);
|
|
|
|
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void testmgr_free_buf(char *buf[XBUFSIZE])
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < XBUFSIZE; i++)
|
|
|
|
free_page((unsigned long)buf[i]);
|
|
|
|
}
|
|
|
|
|
2018-01-16 22:26:13 +08:00
|
|
|
static int ahash_guard_result(char *result, char c, int size)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < size; i++) {
|
|
|
|
if (result[i] != c)
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-02-03 18:26:57 +08:00
|
|
|
static int ahash_partial_update(struct ahash_request **preq,
|
2017-02-25 07:46:59 +08:00
|
|
|
struct crypto_ahash *tfm, const struct hash_testvec *template,
|
2016-02-03 18:26:57 +08:00
|
|
|
void *hash_buff, int k, int temp, struct scatterlist *sg,
|
2017-10-18 15:00:43 +08:00
|
|
|
const char *algo, char *result, struct crypto_wait *wait)
|
2016-02-03 18:26:57 +08:00
|
|
|
{
|
|
|
|
char *state;
|
|
|
|
struct ahash_request *req;
|
|
|
|
int statesize, ret = -EINVAL;
|
2018-01-02 04:40:14 +08:00
|
|
|
static const unsigned char guard[] = { 0x00, 0xba, 0xad, 0x00 };
|
2018-01-16 22:26:13 +08:00
|
|
|
int digestsize = crypto_ahash_digestsize(tfm);
|
2016-02-03 18:26:57 +08:00
|
|
|
|
|
|
|
req = *preq;
|
|
|
|
statesize = crypto_ahash_statesize(
|
|
|
|
crypto_ahash_reqtfm(req));
|
2016-09-28 22:38:37 +08:00
|
|
|
state = kmalloc(statesize + sizeof(guard), GFP_KERNEL);
|
2016-02-03 18:26:57 +08:00
|
|
|
if (!state) {
|
2017-06-05 13:33:43 +08:00
|
|
|
pr_err("alg: hash: Failed to alloc state for %s\n", algo);
|
2016-02-03 18:26:57 +08:00
|
|
|
goto out_nostate;
|
|
|
|
}
|
2016-09-28 22:38:37 +08:00
|
|
|
memcpy(state + statesize, guard, sizeof(guard));
|
2018-01-16 22:26:13 +08:00
|
|
|
memset(result, 1, digestsize);
|
2016-02-03 18:26:57 +08:00
|
|
|
ret = crypto_ahash_export(req, state);
|
2016-09-28 22:38:37 +08:00
|
|
|
WARN_ON(memcmp(state + statesize, guard, sizeof(guard)));
|
2016-02-03 18:26:57 +08:00
|
|
|
if (ret) {
|
2017-06-05 13:33:43 +08:00
|
|
|
pr_err("alg: hash: Failed to export() for %s\n", algo);
|
2016-02-03 18:26:57 +08:00
|
|
|
goto out;
|
|
|
|
}
|
2018-01-16 22:26:13 +08:00
|
|
|
ret = ahash_guard_result(result, 1, digestsize);
|
|
|
|
if (ret) {
|
|
|
|
pr_err("alg: hash: Failed, export used req->result for %s\n",
|
|
|
|
algo);
|
|
|
|
goto out;
|
|
|
|
}
|
2016-02-03 18:26:57 +08:00
|
|
|
ahash_request_free(req);
|
|
|
|
req = ahash_request_alloc(tfm, GFP_KERNEL);
|
|
|
|
if (!req) {
|
|
|
|
pr_err("alg: hash: Failed to alloc request for %s\n", algo);
|
|
|
|
goto out_noreq;
|
|
|
|
}
|
|
|
|
ahash_request_set_callback(req,
|
|
|
|
CRYPTO_TFM_REQ_MAY_BACKLOG,
|
2017-10-18 15:00:43 +08:00
|
|
|
crypto_req_done, wait);
|
2016-02-03 18:26:57 +08:00
|
|
|
|
|
|
|
memcpy(hash_buff, template->plaintext + temp,
|
|
|
|
template->tap[k]);
|
|
|
|
sg_init_one(&sg[0], hash_buff, template->tap[k]);
|
|
|
|
ahash_request_set_crypt(req, sg, result, template->tap[k]);
|
|
|
|
ret = crypto_ahash_import(req, state);
|
|
|
|
if (ret) {
|
|
|
|
pr_err("alg: hash: Failed to import() for %s\n", algo);
|
|
|
|
goto out;
|
|
|
|
}
|
2018-01-16 22:26:13 +08:00
|
|
|
ret = ahash_guard_result(result, 1, digestsize);
|
|
|
|
if (ret) {
|
|
|
|
pr_err("alg: hash: Failed, import used req->result for %s\n",
|
|
|
|
algo);
|
|
|
|
goto out;
|
|
|
|
}
|
2017-10-18 15:00:43 +08:00
|
|
|
ret = crypto_wait_req(crypto_ahash_update(req), wait);
|
2016-02-03 18:26:57 +08:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
*preq = req;
|
|
|
|
ret = 0;
|
|
|
|
goto out_noreq;
|
|
|
|
out:
|
|
|
|
ahash_request_free(req);
|
|
|
|
out_noreq:
|
|
|
|
kfree(state);
|
|
|
|
out_nostate:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-02-25 07:46:59 +08:00
|
|
|
static int __test_hash(struct crypto_ahash *tfm,
|
|
|
|
const struct hash_testvec *template, unsigned int tcount,
|
|
|
|
bool use_digest, const int align_offset)
|
2008-07-31 17:08:25 +08:00
|
|
|
{
|
|
|
|
const char *algo = crypto_tfm_alg_driver_name(crypto_ahash_tfm(tfm));
|
2017-01-11 07:24:46 +08:00
|
|
|
size_t digest_size = crypto_ahash_digestsize(tfm);
|
2008-07-31 17:08:25 +08:00
|
|
|
unsigned int i, j, k, temp;
|
|
|
|
struct scatterlist sg[8];
|
2014-07-23 16:59:38 +08:00
|
|
|
char *result;
|
|
|
|
char *key;
|
2008-07-31 17:08:25 +08:00
|
|
|
struct ahash_request *req;
|
2017-10-18 15:00:43 +08:00
|
|
|
struct crypto_wait wait;
|
2008-07-31 17:08:25 +08:00
|
|
|
void *hash_buff;
|
2009-05-06 14:15:47 +08:00
|
|
|
char *xbuf[XBUFSIZE];
|
|
|
|
int ret = -ENOMEM;
|
|
|
|
|
2017-01-11 07:24:46 +08:00
|
|
|
result = kmalloc(digest_size, GFP_KERNEL);
|
2014-07-23 16:59:38 +08:00
|
|
|
if (!result)
|
|
|
|
return ret;
|
|
|
|
key = kmalloc(MAX_KEYLEN, GFP_KERNEL);
|
|
|
|
if (!key)
|
|
|
|
goto out_nobuf;
|
2009-05-06 14:15:47 +08:00
|
|
|
if (testmgr_alloc_buf(xbuf))
|
|
|
|
goto out_nobuf;
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2017-10-18 15:00:43 +08:00
|
|
|
crypto_init_wait(&wait);
|
2008-07-31 17:08:25 +08:00
|
|
|
|
|
|
|
req = ahash_request_alloc(tfm, GFP_KERNEL);
|
|
|
|
if (!req) {
|
|
|
|
printk(KERN_ERR "alg: hash: Failed to allocate request for "
|
|
|
|
"%s\n", algo);
|
|
|
|
goto out_noreq;
|
|
|
|
}
|
|
|
|
ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
|
2017-10-18 15:00:43 +08:00
|
|
|
crypto_req_done, &wait);
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2009-05-29 14:23:12 +08:00
|
|
|
j = 0;
|
2008-07-31 17:08:25 +08:00
|
|
|
for (i = 0; i < tcount; i++) {
|
2009-05-29 14:23:12 +08:00
|
|
|
if (template[i].np)
|
|
|
|
continue;
|
|
|
|
|
2013-06-13 22:37:55 +08:00
|
|
|
ret = -EINVAL;
|
|
|
|
if (WARN_ON(align_offset + template[i].psize > PAGE_SIZE))
|
|
|
|
goto out;
|
|
|
|
|
2009-05-29 14:23:12 +08:00
|
|
|
j++;
|
2017-01-11 07:24:46 +08:00
|
|
|
memset(result, 0, digest_size);
|
2008-07-31 17:08:25 +08:00
|
|
|
|
|
|
|
hash_buff = xbuf[0];
|
2013-06-13 22:37:55 +08:00
|
|
|
hash_buff += align_offset;
|
2008-07-31 17:08:25 +08:00
|
|
|
|
|
|
|
memcpy(hash_buff, template[i].plaintext, template[i].psize);
|
|
|
|
sg_init_one(&sg[0], hash_buff, template[i].psize);
|
|
|
|
|
|
|
|
if (template[i].ksize) {
|
|
|
|
crypto_ahash_clear_flags(tfm, ~0);
|
2014-07-23 16:59:38 +08:00
|
|
|
if (template[i].ksize > MAX_KEYLEN) {
|
|
|
|
pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
|
|
|
|
j, algo, template[i].ksize, MAX_KEYLEN);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
memcpy(key, template[i].key, template[i].ksize);
|
|
|
|
ret = crypto_ahash_setkey(tfm, key, template[i].ksize);
|
2008-07-31 17:08:25 +08:00
|
|
|
if (ret) {
|
|
|
|
printk(KERN_ERR "alg: hash: setkey failed on "
|
2009-05-29 14:23:12 +08:00
|
|
|
"test %d for %s: ret=%d\n", j, algo,
|
2008-07-31 17:08:25 +08:00
|
|
|
-ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ahash_request_set_crypt(req, sg, result, template[i].psize);
|
2010-05-19 12:12:03 +08:00
|
|
|
if (use_digest) {
|
2017-10-18 15:00:43 +08:00
|
|
|
ret = crypto_wait_req(crypto_ahash_digest(req), &wait);
|
2010-05-19 12:12:03 +08:00
|
|
|
if (ret) {
|
|
|
|
pr_err("alg: hash: digest failed on test %d "
|
|
|
|
"for %s: ret=%d\n", j, algo, -ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
} else {
|
2018-01-16 22:26:13 +08:00
|
|
|
memset(result, 1, digest_size);
|
2017-10-18 15:00:43 +08:00
|
|
|
ret = crypto_wait_req(crypto_ahash_init(req), &wait);
|
2010-05-19 12:12:03 +08:00
|
|
|
if (ret) {
|
2017-06-05 13:33:43 +08:00
|
|
|
pr_err("alg: hash: init failed on test %d "
|
2010-05-19 12:12:03 +08:00
|
|
|
"for %s: ret=%d\n", j, algo, -ret);
|
|
|
|
goto out;
|
|
|
|
}
|
2018-01-16 22:26:13 +08:00
|
|
|
ret = ahash_guard_result(result, 1, digest_size);
|
|
|
|
if (ret) {
|
|
|
|
pr_err("alg: hash: init failed on test %d "
|
|
|
|
"for %s: used req->result\n", j, algo);
|
|
|
|
goto out;
|
|
|
|
}
|
2017-10-18 15:00:43 +08:00
|
|
|
ret = crypto_wait_req(crypto_ahash_update(req), &wait);
|
2010-05-19 12:12:03 +08:00
|
|
|
if (ret) {
|
2017-06-05 13:33:43 +08:00
|
|
|
pr_err("alg: hash: update failed on test %d "
|
2010-05-19 12:12:03 +08:00
|
|
|
"for %s: ret=%d\n", j, algo, -ret);
|
|
|
|
goto out;
|
|
|
|
}
|
2018-01-16 22:26:13 +08:00
|
|
|
ret = ahash_guard_result(result, 1, digest_size);
|
|
|
|
if (ret) {
|
|
|
|
pr_err("alg: hash: update failed on test %d "
|
|
|
|
"for %s: used req->result\n", j, algo);
|
|
|
|
goto out;
|
|
|
|
}
|
2017-10-18 15:00:43 +08:00
|
|
|
ret = crypto_wait_req(crypto_ahash_final(req), &wait);
|
2010-05-19 12:12:03 +08:00
|
|
|
if (ret) {
|
2017-06-05 13:33:43 +08:00
|
|
|
pr_err("alg: hash: final failed on test %d "
|
2010-05-19 12:12:03 +08:00
|
|
|
"for %s: ret=%d\n", j, algo, -ret);
|
|
|
|
goto out;
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (memcmp(result, template[i].digest,
|
|
|
|
crypto_ahash_digestsize(tfm))) {
|
|
|
|
printk(KERN_ERR "alg: hash: Test %d failed for %s\n",
|
2009-05-29 14:23:12 +08:00
|
|
|
j, algo);
|
2008-07-31 17:08:25 +08:00
|
|
|
hexdump(result, crypto_ahash_digestsize(tfm));
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
j = 0;
|
|
|
|
for (i = 0; i < tcount; i++) {
|
2013-06-13 22:37:55 +08:00
|
|
|
/* alignment tests are only done with continuous buffers */
|
|
|
|
if (align_offset != 0)
|
|
|
|
break;
|
|
|
|
|
2014-08-08 19:27:50 +08:00
|
|
|
if (!template[i].np)
|
|
|
|
continue;
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2014-08-08 19:27:50 +08:00
|
|
|
j++;
|
2017-01-11 07:24:46 +08:00
|
|
|
memset(result, 0, digest_size);
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2014-08-08 19:27:50 +08:00
|
|
|
temp = 0;
|
|
|
|
sg_init_table(sg, template[i].np);
|
|
|
|
ret = -EINVAL;
|
|
|
|
for (k = 0; k < template[i].np; k++) {
|
|
|
|
if (WARN_ON(offset_in_page(IDX[k]) +
|
|
|
|
template[i].tap[k] > PAGE_SIZE))
|
|
|
|
goto out;
|
|
|
|
sg_set_buf(&sg[k],
|
|
|
|
memcpy(xbuf[IDX[k] >> PAGE_SHIFT] +
|
|
|
|
offset_in_page(IDX[k]),
|
|
|
|
template[i].plaintext + temp,
|
|
|
|
template[i].tap[k]),
|
|
|
|
template[i].tap[k]);
|
|
|
|
temp += template[i].tap[k];
|
|
|
|
}
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2014-08-08 19:27:50 +08:00
|
|
|
if (template[i].ksize) {
|
|
|
|
if (template[i].ksize > MAX_KEYLEN) {
|
|
|
|
pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
|
|
|
|
j, algo, template[i].ksize, MAX_KEYLEN);
|
|
|
|
ret = -EINVAL;
|
2008-07-31 17:08:25 +08:00
|
|
|
goto out;
|
|
|
|
}
|
2014-08-08 19:27:50 +08:00
|
|
|
crypto_ahash_clear_flags(tfm, ~0);
|
|
|
|
memcpy(key, template[i].key, template[i].ksize);
|
|
|
|
ret = crypto_ahash_setkey(tfm, key, template[i].ksize);
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2014-08-08 19:27:50 +08:00
|
|
|
if (ret) {
|
|
|
|
printk(KERN_ERR "alg: hash: setkey "
|
|
|
|
"failed on chunking test %d "
|
|
|
|
"for %s: ret=%d\n", j, algo, -ret);
|
2008-07-31 17:08:25 +08:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
2014-08-08 19:27:50 +08:00
|
|
|
|
|
|
|
ahash_request_set_crypt(req, sg, result, template[i].psize);
|
2017-10-18 15:00:43 +08:00
|
|
|
ret = crypto_wait_req(crypto_ahash_digest(req), &wait);
|
|
|
|
if (ret) {
|
|
|
|
pr_err("alg: hash: digest failed on chunking test %d for %s: ret=%d\n",
|
|
|
|
j, algo, -ret);
|
2014-08-08 19:27:50 +08:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (memcmp(result, template[i].digest,
|
|
|
|
crypto_ahash_digestsize(tfm))) {
|
|
|
|
printk(KERN_ERR "alg: hash: Chunking test %d "
|
|
|
|
"failed for %s\n", j, algo);
|
|
|
|
hexdump(result, crypto_ahash_digestsize(tfm));
|
|
|
|
ret = -EINVAL;
|
2016-02-03 18:26:57 +08:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* partial update exercise */
|
|
|
|
j = 0;
|
|
|
|
for (i = 0; i < tcount; i++) {
|
|
|
|
/* alignment tests are only done with continuous buffers */
|
|
|
|
if (align_offset != 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (template[i].np < 2)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
j++;
|
2017-01-11 07:24:46 +08:00
|
|
|
memset(result, 0, digest_size);
|
2016-02-03 18:26:57 +08:00
|
|
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
hash_buff = xbuf[0];
|
|
|
|
memcpy(hash_buff, template[i].plaintext,
|
|
|
|
template[i].tap[0]);
|
|
|
|
sg_init_one(&sg[0], hash_buff, template[i].tap[0]);
|
|
|
|
|
|
|
|
if (template[i].ksize) {
|
|
|
|
crypto_ahash_clear_flags(tfm, ~0);
|
|
|
|
if (template[i].ksize > MAX_KEYLEN) {
|
|
|
|
pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
|
|
|
|
j, algo, template[i].ksize, MAX_KEYLEN);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
memcpy(key, template[i].key, template[i].ksize);
|
|
|
|
ret = crypto_ahash_setkey(tfm, key, template[i].ksize);
|
|
|
|
if (ret) {
|
|
|
|
pr_err("alg: hash: setkey failed on test %d for %s: ret=%d\n",
|
|
|
|
j, algo, -ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ahash_request_set_crypt(req, sg, result, template[i].tap[0]);
|
2017-10-18 15:00:43 +08:00
|
|
|
ret = crypto_wait_req(crypto_ahash_init(req), &wait);
|
2016-02-03 18:26:57 +08:00
|
|
|
if (ret) {
|
2017-06-05 13:33:43 +08:00
|
|
|
pr_err("alg: hash: init failed on test %d for %s: ret=%d\n",
|
2016-02-03 18:26:57 +08:00
|
|
|
j, algo, -ret);
|
|
|
|
goto out;
|
|
|
|
}
|
2017-10-18 15:00:43 +08:00
|
|
|
ret = crypto_wait_req(crypto_ahash_update(req), &wait);
|
2016-02-03 18:26:57 +08:00
|
|
|
if (ret) {
|
2017-06-05 13:33:43 +08:00
|
|
|
pr_err("alg: hash: update failed on test %d for %s: ret=%d\n",
|
2016-02-03 18:26:57 +08:00
|
|
|
j, algo, -ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
temp = template[i].tap[0];
|
|
|
|
for (k = 1; k < template[i].np; k++) {
|
|
|
|
ret = ahash_partial_update(&req, tfm, &template[i],
|
|
|
|
hash_buff, k, temp, &sg[0], algo, result,
|
2017-10-18 15:00:43 +08:00
|
|
|
&wait);
|
2016-02-03 18:26:57 +08:00
|
|
|
if (ret) {
|
2017-06-05 13:33:43 +08:00
|
|
|
pr_err("alg: hash: partial update failed on test %d for %s: ret=%d\n",
|
2016-02-03 18:26:57 +08:00
|
|
|
j, algo, -ret);
|
|
|
|
goto out_noreq;
|
|
|
|
}
|
|
|
|
temp += template[i].tap[k];
|
|
|
|
}
|
2017-10-18 15:00:43 +08:00
|
|
|
ret = crypto_wait_req(crypto_ahash_final(req), &wait);
|
2016-02-03 18:26:57 +08:00
|
|
|
if (ret) {
|
2017-06-05 13:33:43 +08:00
|
|
|
pr_err("alg: hash: final failed on test %d for %s: ret=%d\n",
|
2016-02-03 18:26:57 +08:00
|
|
|
j, algo, -ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (memcmp(result, template[i].digest,
|
|
|
|
crypto_ahash_digestsize(tfm))) {
|
|
|
|
pr_err("alg: hash: Partial Test %d failed for %s\n",
|
|
|
|
j, algo);
|
|
|
|
hexdump(result, crypto_ahash_digestsize(tfm));
|
|
|
|
ret = -EINVAL;
|
2014-08-08 19:27:50 +08:00
|
|
|
goto out;
|
|
|
|
}
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
out:
|
|
|
|
ahash_request_free(req);
|
|
|
|
out_noreq:
|
2009-05-06 14:15:47 +08:00
|
|
|
testmgr_free_buf(xbuf);
|
|
|
|
out_nobuf:
|
2014-07-23 16:59:38 +08:00
|
|
|
kfree(key);
|
|
|
|
kfree(result);
|
2008-07-31 17:08:25 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-02-25 07:46:59 +08:00
|
|
|
static int test_hash(struct crypto_ahash *tfm,
|
|
|
|
const struct hash_testvec *template,
|
2013-06-13 22:37:55 +08:00
|
|
|
unsigned int tcount, bool use_digest)
|
|
|
|
{
|
|
|
|
unsigned int alignmask;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = __test_hash(tfm, template, tcount, use_digest, 0);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
/* test unaligned buffers, check with one byte offset */
|
|
|
|
ret = __test_hash(tfm, template, tcount, use_digest, 1);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
alignmask = crypto_tfm_alg_alignmask(&tfm->base);
|
|
|
|
if (alignmask) {
|
|
|
|
/* Check if alignment mask for tfm is correctly set. */
|
|
|
|
ret = __test_hash(tfm, template, tcount, use_digest,
|
|
|
|
alignmask + 1);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-09-21 15:26:52 +08:00
|
|
|
static int __test_aead(struct crypto_aead *tfm, int enc,
|
2017-02-25 07:46:59 +08:00
|
|
|
const struct aead_testvec *template, unsigned int tcount,
|
2013-06-13 22:37:50 +08:00
|
|
|
const bool diff_dst, const int align_offset)
|
2008-07-31 17:08:25 +08:00
|
|
|
{
|
|
|
|
const char *algo = crypto_tfm_alg_driver_name(crypto_aead_tfm(tfm));
|
|
|
|
unsigned int i, j, k, n, temp;
|
2009-05-06 14:15:47 +08:00
|
|
|
int ret = -ENOMEM;
|
2008-07-31 17:08:25 +08:00
|
|
|
char *q;
|
|
|
|
char *key;
|
|
|
|
struct aead_request *req;
|
2012-09-21 15:26:52 +08:00
|
|
|
struct scatterlist *sg;
|
|
|
|
struct scatterlist *sgout;
|
|
|
|
const char *e, *d;
|
2017-10-18 15:00:43 +08:00
|
|
|
struct crypto_wait wait;
|
2015-01-28 17:03:05 +08:00
|
|
|
unsigned int authsize, iv_len;
|
2008-07-31 17:08:25 +08:00
|
|
|
void *input;
|
2012-09-21 15:26:52 +08:00
|
|
|
void *output;
|
2008-07-31 17:08:25 +08:00
|
|
|
void *assoc;
|
2014-05-20 00:51:33 +08:00
|
|
|
char *iv;
|
2009-05-06 14:15:47 +08:00
|
|
|
char *xbuf[XBUFSIZE];
|
2012-09-21 15:26:52 +08:00
|
|
|
char *xoutbuf[XBUFSIZE];
|
2009-05-06 14:15:47 +08:00
|
|
|
char *axbuf[XBUFSIZE];
|
|
|
|
|
2014-05-20 00:51:33 +08:00
|
|
|
iv = kzalloc(MAX_IVLEN, GFP_KERNEL);
|
|
|
|
if (!iv)
|
|
|
|
return ret;
|
2014-07-23 16:59:38 +08:00
|
|
|
key = kmalloc(MAX_KEYLEN, GFP_KERNEL);
|
|
|
|
if (!key)
|
|
|
|
goto out_noxbuf;
|
2009-05-06 14:15:47 +08:00
|
|
|
if (testmgr_alloc_buf(xbuf))
|
|
|
|
goto out_noxbuf;
|
|
|
|
if (testmgr_alloc_buf(axbuf))
|
|
|
|
goto out_noaxbuf;
|
2012-09-21 15:26:52 +08:00
|
|
|
if (diff_dst && testmgr_alloc_buf(xoutbuf))
|
|
|
|
goto out_nooutbuf;
|
|
|
|
|
|
|
|
/* avoid "the frame size is larger than 1024 bytes" compiler warning */
|
2015-05-27 16:03:43 +08:00
|
|
|
sg = kmalloc(sizeof(*sg) * 8 * (diff_dst ? 4 : 2), GFP_KERNEL);
|
2012-09-21 15:26:52 +08:00
|
|
|
if (!sg)
|
|
|
|
goto out_nosg;
|
2015-05-27 16:03:43 +08:00
|
|
|
sgout = &sg[16];
|
2012-09-21 15:26:52 +08:00
|
|
|
|
|
|
|
if (diff_dst)
|
|
|
|
d = "-ddst";
|
|
|
|
else
|
|
|
|
d = "";
|
|
|
|
|
2008-07-31 17:08:25 +08:00
|
|
|
if (enc == ENCRYPT)
|
|
|
|
e = "encryption";
|
|
|
|
else
|
|
|
|
e = "decryption";
|
|
|
|
|
2017-10-18 15:00:43 +08:00
|
|
|
crypto_init_wait(&wait);
|
2008-07-31 17:08:25 +08:00
|
|
|
|
|
|
|
req = aead_request_alloc(tfm, GFP_KERNEL);
|
|
|
|
if (!req) {
|
2012-09-21 15:26:52 +08:00
|
|
|
pr_err("alg: aead%s: Failed to allocate request for %s\n",
|
|
|
|
d, algo);
|
2008-07-31 17:08:25 +08:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
|
2017-10-18 15:00:43 +08:00
|
|
|
crypto_req_done, &wait);
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2016-02-03 20:58:12 +08:00
|
|
|
iv_len = crypto_aead_ivsize(tfm);
|
|
|
|
|
2008-07-31 17:08:25 +08:00
|
|
|
for (i = 0, j = 0; i < tcount; i++) {
|
2014-07-28 18:11:23 +08:00
|
|
|
if (template[i].np)
|
|
|
|
continue;
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2014-07-28 18:11:23 +08:00
|
|
|
j++;
|
2009-05-29 14:05:42 +08:00
|
|
|
|
2014-07-28 18:11:23 +08:00
|
|
|
/* some templates have no input data but they will
|
|
|
|
* touch input
|
|
|
|
*/
|
|
|
|
input = xbuf[0];
|
|
|
|
input += align_offset;
|
|
|
|
assoc = axbuf[0];
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2014-07-28 18:11:23 +08:00
|
|
|
ret = -EINVAL;
|
|
|
|
if (WARN_ON(align_offset + template[i].ilen >
|
|
|
|
PAGE_SIZE || template[i].alen > PAGE_SIZE))
|
|
|
|
goto out;
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2014-07-28 18:11:23 +08:00
|
|
|
memcpy(input, template[i].input, template[i].ilen);
|
|
|
|
memcpy(assoc, template[i].assoc, template[i].alen);
|
|
|
|
if (template[i].iv)
|
2015-01-28 17:03:05 +08:00
|
|
|
memcpy(iv, template[i].iv, iv_len);
|
2014-07-28 18:11:23 +08:00
|
|
|
else
|
2015-01-28 17:03:05 +08:00
|
|
|
memset(iv, 0, iv_len);
|
2014-07-28 18:11:23 +08:00
|
|
|
|
|
|
|
crypto_aead_clear_flags(tfm, ~0);
|
|
|
|
if (template[i].wk)
|
|
|
|
crypto_aead_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
|
|
|
|
|
|
|
|
if (template[i].klen > MAX_KEYLEN) {
|
|
|
|
pr_err("alg: aead%s: setkey failed on test %d for %s: key size %d > %d\n",
|
|
|
|
d, j, algo, template[i].klen,
|
|
|
|
MAX_KEYLEN);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
memcpy(key, template[i].key, template[i].klen);
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2014-07-28 18:11:23 +08:00
|
|
|
ret = crypto_aead_setkey(tfm, key, template[i].klen);
|
2016-07-29 16:32:09 +08:00
|
|
|
if (template[i].fail == !ret) {
|
2014-07-28 18:11:23 +08:00
|
|
|
pr_err("alg: aead%s: setkey failed on test %d for %s: flags=%x\n",
|
|
|
|
d, j, algo, crypto_aead_get_flags(tfm));
|
|
|
|
goto out;
|
|
|
|
} else if (ret)
|
|
|
|
continue;
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2014-07-28 18:11:23 +08:00
|
|
|
authsize = abs(template[i].rlen - template[i].ilen);
|
|
|
|
ret = crypto_aead_setauthsize(tfm, authsize);
|
|
|
|
if (ret) {
|
|
|
|
pr_err("alg: aead%s: Failed to set authsize to %u on test %d for %s\n",
|
|
|
|
d, authsize, j, algo);
|
|
|
|
goto out;
|
|
|
|
}
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2015-05-27 16:03:43 +08:00
|
|
|
k = !!template[i].alen;
|
|
|
|
sg_init_table(sg, k + 1);
|
|
|
|
sg_set_buf(&sg[0], assoc, template[i].alen);
|
|
|
|
sg_set_buf(&sg[k], input,
|
|
|
|
template[i].ilen + (enc ? authsize : 0));
|
|
|
|
output = input;
|
|
|
|
|
2014-07-28 18:11:23 +08:00
|
|
|
if (diff_dst) {
|
2015-05-27 16:03:43 +08:00
|
|
|
sg_init_table(sgout, k + 1);
|
|
|
|
sg_set_buf(&sgout[0], assoc, template[i].alen);
|
|
|
|
|
2014-07-28 18:11:23 +08:00
|
|
|
output = xoutbuf[0];
|
|
|
|
output += align_offset;
|
2015-05-27 16:03:43 +08:00
|
|
|
sg_set_buf(&sgout[k], output,
|
|
|
|
template[i].rlen + (enc ? 0 : authsize));
|
2014-07-28 18:11:23 +08:00
|
|
|
}
|
2012-09-21 15:26:52 +08:00
|
|
|
|
2014-07-28 18:11:23 +08:00
|
|
|
aead_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
|
|
|
|
template[i].ilen, iv);
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2015-05-27 16:03:43 +08:00
|
|
|
aead_request_set_ad(req, template[i].alen);
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2017-10-18 15:00:43 +08:00
|
|
|
ret = crypto_wait_req(enc ? crypto_aead_encrypt(req)
|
|
|
|
: crypto_aead_decrypt(req), &wait);
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2014-07-28 18:11:23 +08:00
|
|
|
switch (ret) {
|
|
|
|
case 0:
|
|
|
|
if (template[i].novrfy) {
|
|
|
|
/* verification was supposed to fail */
|
|
|
|
pr_err("alg: aead%s: %s failed on test %d for %s: ret was 0, expected -EBADMSG\n",
|
|
|
|
d, e, j, algo);
|
|
|
|
/* so really, we got a bad message */
|
|
|
|
ret = -EBADMSG;
|
2008-07-31 17:08:25 +08:00
|
|
|
goto out;
|
|
|
|
}
|
2014-07-28 18:11:23 +08:00
|
|
|
break;
|
|
|
|
case -EBADMSG:
|
|
|
|
if (template[i].novrfy)
|
|
|
|
/* verification failure was expected */
|
|
|
|
continue;
|
|
|
|
/* fall through */
|
|
|
|
default:
|
|
|
|
pr_err("alg: aead%s: %s failed on test %d for %s: ret=%d\n",
|
|
|
|
d, e, j, algo, -ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
q = output;
|
|
|
|
if (memcmp(q, template[i].result, template[i].rlen)) {
|
|
|
|
pr_err("alg: aead%s: Test %d failed on %s for %s\n",
|
|
|
|
d, j, e, algo);
|
|
|
|
hexdump(q, template[i].rlen);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0, j = 0; i < tcount; i++) {
|
2013-06-13 22:37:50 +08:00
|
|
|
/* alignment tests are only done with continuous buffers */
|
|
|
|
if (align_offset != 0)
|
|
|
|
break;
|
|
|
|
|
2014-07-28 18:11:23 +08:00
|
|
|
if (!template[i].np)
|
|
|
|
continue;
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2014-07-28 18:11:23 +08:00
|
|
|
j++;
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2014-07-28 18:11:23 +08:00
|
|
|
if (template[i].iv)
|
2016-02-03 20:58:12 +08:00
|
|
|
memcpy(iv, template[i].iv, iv_len);
|
2014-07-28 18:11:23 +08:00
|
|
|
else
|
|
|
|
memset(iv, 0, MAX_IVLEN);
|
|
|
|
|
|
|
|
crypto_aead_clear_flags(tfm, ~0);
|
|
|
|
if (template[i].wk)
|
|
|
|
crypto_aead_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
|
|
|
|
if (template[i].klen > MAX_KEYLEN) {
|
|
|
|
pr_err("alg: aead%s: setkey failed on test %d for %s: key size %d > %d\n",
|
|
|
|
d, j, algo, template[i].klen, MAX_KEYLEN);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
memcpy(key, template[i].key, template[i].klen);
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2014-07-28 18:11:23 +08:00
|
|
|
ret = crypto_aead_setkey(tfm, key, template[i].klen);
|
2016-07-29 16:32:09 +08:00
|
|
|
if (template[i].fail == !ret) {
|
2014-07-28 18:11:23 +08:00
|
|
|
pr_err("alg: aead%s: setkey failed on chunk test %d for %s: flags=%x\n",
|
|
|
|
d, j, algo, crypto_aead_get_flags(tfm));
|
|
|
|
goto out;
|
|
|
|
} else if (ret)
|
|
|
|
continue;
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2014-07-28 18:11:23 +08:00
|
|
|
authsize = abs(template[i].rlen - template[i].ilen);
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2014-07-28 18:11:23 +08:00
|
|
|
ret = -EINVAL;
|
2015-05-27 16:03:43 +08:00
|
|
|
sg_init_table(sg, template[i].anp + template[i].np);
|
2014-07-28 18:11:23 +08:00
|
|
|
if (diff_dst)
|
2015-05-27 16:03:43 +08:00
|
|
|
sg_init_table(sgout, template[i].anp + template[i].np);
|
|
|
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
for (k = 0, temp = 0; k < template[i].anp; k++) {
|
|
|
|
if (WARN_ON(offset_in_page(IDX[k]) +
|
|
|
|
template[i].atap[k] > PAGE_SIZE))
|
|
|
|
goto out;
|
|
|
|
sg_set_buf(&sg[k],
|
|
|
|
memcpy(axbuf[IDX[k] >> PAGE_SHIFT] +
|
|
|
|
offset_in_page(IDX[k]),
|
|
|
|
template[i].assoc + temp,
|
|
|
|
template[i].atap[k]),
|
|
|
|
template[i].atap[k]);
|
|
|
|
if (diff_dst)
|
|
|
|
sg_set_buf(&sgout[k],
|
|
|
|
axbuf[IDX[k] >> PAGE_SHIFT] +
|
|
|
|
offset_in_page(IDX[k]),
|
|
|
|
template[i].atap[k]);
|
|
|
|
temp += template[i].atap[k];
|
|
|
|
}
|
|
|
|
|
2014-07-28 18:11:23 +08:00
|
|
|
for (k = 0, temp = 0; k < template[i].np; k++) {
|
|
|
|
if (WARN_ON(offset_in_page(IDX[k]) +
|
|
|
|
template[i].tap[k] > PAGE_SIZE))
|
|
|
|
goto out;
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2014-07-28 18:11:23 +08:00
|
|
|
q = xbuf[IDX[k] >> PAGE_SHIFT] + offset_in_page(IDX[k]);
|
|
|
|
memcpy(q, template[i].input + temp, template[i].tap[k]);
|
2015-05-27 16:03:43 +08:00
|
|
|
sg_set_buf(&sg[template[i].anp + k],
|
|
|
|
q, template[i].tap[k]);
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2014-07-28 18:11:23 +08:00
|
|
|
if (diff_dst) {
|
|
|
|
q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
|
|
|
|
offset_in_page(IDX[k]);
|
2012-09-21 15:26:52 +08:00
|
|
|
|
2014-07-28 18:11:23 +08:00
|
|
|
memset(q, 0, template[i].tap[k]);
|
2012-09-21 15:26:52 +08:00
|
|
|
|
2015-05-27 16:03:43 +08:00
|
|
|
sg_set_buf(&sgout[template[i].anp + k],
|
|
|
|
q, template[i].tap[k]);
|
2014-07-28 18:11:23 +08:00
|
|
|
}
|
2012-09-21 15:26:52 +08:00
|
|
|
|
2014-07-28 18:11:23 +08:00
|
|
|
n = template[i].tap[k];
|
|
|
|
if (k == template[i].np - 1 && enc)
|
|
|
|
n += authsize;
|
|
|
|
if (offset_in_page(q) + n < PAGE_SIZE)
|
|
|
|
q[n] = 0;
|
2012-09-21 15:26:52 +08:00
|
|
|
|
2014-07-28 18:11:23 +08:00
|
|
|
temp += template[i].tap[k];
|
|
|
|
}
|
2013-11-28 21:11:18 +08:00
|
|
|
|
2014-07-28 18:11:23 +08:00
|
|
|
ret = crypto_aead_setauthsize(tfm, authsize);
|
|
|
|
if (ret) {
|
|
|
|
pr_err("alg: aead%s: Failed to set authsize to %u on chunk test %d for %s\n",
|
|
|
|
d, authsize, j, algo);
|
|
|
|
goto out;
|
|
|
|
}
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2014-07-28 18:11:23 +08:00
|
|
|
if (enc) {
|
2015-05-27 16:03:43 +08:00
|
|
|
if (WARN_ON(sg[template[i].anp + k - 1].offset +
|
|
|
|
sg[template[i].anp + k - 1].length +
|
|
|
|
authsize > PAGE_SIZE)) {
|
2014-07-28 18:11:23 +08:00
|
|
|
ret = -EINVAL;
|
2008-07-31 17:08:25 +08:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2014-07-28 18:11:23 +08:00
|
|
|
if (diff_dst)
|
2015-05-27 16:03:43 +08:00
|
|
|
sgout[template[i].anp + k - 1].length +=
|
|
|
|
authsize;
|
|
|
|
sg[template[i].anp + k - 1].length += authsize;
|
2014-07-28 18:11:23 +08:00
|
|
|
}
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2014-07-28 18:11:23 +08:00
|
|
|
aead_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
|
|
|
|
template[i].ilen,
|
|
|
|
iv);
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2015-05-27 16:03:43 +08:00
|
|
|
aead_request_set_ad(req, template[i].alen);
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2017-10-18 15:00:43 +08:00
|
|
|
ret = crypto_wait_req(enc ? crypto_aead_encrypt(req)
|
|
|
|
: crypto_aead_decrypt(req), &wait);
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2014-07-28 18:11:23 +08:00
|
|
|
switch (ret) {
|
|
|
|
case 0:
|
|
|
|
if (template[i].novrfy) {
|
|
|
|
/* verification was supposed to fail */
|
|
|
|
pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret was 0, expected -EBADMSG\n",
|
|
|
|
d, e, j, algo);
|
|
|
|
/* so really, we got a bad message */
|
|
|
|
ret = -EBADMSG;
|
2008-07-31 17:08:25 +08:00
|
|
|
goto out;
|
|
|
|
}
|
2014-07-28 18:11:23 +08:00
|
|
|
break;
|
|
|
|
case -EBADMSG:
|
|
|
|
if (template[i].novrfy)
|
|
|
|
/* verification failure was expected */
|
|
|
|
continue;
|
|
|
|
/* fall through */
|
|
|
|
default:
|
|
|
|
pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret=%d\n",
|
|
|
|
d, e, j, algo, -ret);
|
|
|
|
goto out;
|
|
|
|
}
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2014-07-28 18:11:23 +08:00
|
|
|
ret = -EINVAL;
|
|
|
|
for (k = 0, temp = 0; k < template[i].np; k++) {
|
|
|
|
if (diff_dst)
|
|
|
|
q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
|
|
|
|
offset_in_page(IDX[k]);
|
|
|
|
else
|
|
|
|
q = xbuf[IDX[k] >> PAGE_SHIFT] +
|
|
|
|
offset_in_page(IDX[k]);
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2014-07-28 18:11:23 +08:00
|
|
|
n = template[i].tap[k];
|
|
|
|
if (k == template[i].np - 1)
|
|
|
|
n += enc ? authsize : -authsize;
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2014-07-28 18:11:23 +08:00
|
|
|
if (memcmp(q, template[i].result + temp, n)) {
|
|
|
|
pr_err("alg: aead%s: Chunk test %d failed on %s at page %u for %s\n",
|
|
|
|
d, j, e, k, algo);
|
|
|
|
hexdump(q, n);
|
|
|
|
goto out;
|
|
|
|
}
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2014-07-28 18:11:23 +08:00
|
|
|
q += n;
|
|
|
|
if (k == template[i].np - 1 && !enc) {
|
|
|
|
if (!diff_dst &&
|
|
|
|
memcmp(q, template[i].input +
|
|
|
|
temp + n, authsize))
|
|
|
|
n = authsize;
|
|
|
|
else
|
|
|
|
n = 0;
|
|
|
|
} else {
|
|
|
|
for (n = 0; offset_in_page(q + n) && q[n]; n++)
|
|
|
|
;
|
|
|
|
}
|
|
|
|
if (n) {
|
|
|
|
pr_err("alg: aead%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n",
|
|
|
|
d, j, e, k, algo, n);
|
|
|
|
hexdump(q, n);
|
|
|
|
goto out;
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
2014-07-28 18:11:23 +08:00
|
|
|
|
|
|
|
temp += template[i].tap[k];
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
out:
|
|
|
|
aead_request_free(req);
|
2012-09-21 15:26:52 +08:00
|
|
|
kfree(sg);
|
|
|
|
out_nosg:
|
|
|
|
if (diff_dst)
|
|
|
|
testmgr_free_buf(xoutbuf);
|
|
|
|
out_nooutbuf:
|
2009-05-06 14:15:47 +08:00
|
|
|
testmgr_free_buf(axbuf);
|
|
|
|
out_noaxbuf:
|
|
|
|
testmgr_free_buf(xbuf);
|
|
|
|
out_noxbuf:
|
2014-07-23 16:59:38 +08:00
|
|
|
kfree(key);
|
2014-05-20 00:51:33 +08:00
|
|
|
kfree(iv);
|
2008-07-31 17:08:25 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-09-21 15:26:52 +08:00
|
|
|
static int test_aead(struct crypto_aead *tfm, int enc,
|
2017-02-25 07:46:59 +08:00
|
|
|
const struct aead_testvec *template, unsigned int tcount)
|
2012-09-21 15:26:52 +08:00
|
|
|
{
|
2013-06-13 22:37:50 +08:00
|
|
|
unsigned int alignmask;
|
2012-09-21 15:26:52 +08:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* test 'dst == src' case */
|
2013-06-13 22:37:50 +08:00
|
|
|
ret = __test_aead(tfm, enc, template, tcount, false, 0);
|
2012-09-21 15:26:52 +08:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
/* test 'dst != src' case */
|
2013-06-13 22:37:50 +08:00
|
|
|
ret = __test_aead(tfm, enc, template, tcount, true, 0);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
/* test unaligned buffers, check with one byte offset */
|
|
|
|
ret = __test_aead(tfm, enc, template, tcount, true, 1);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
alignmask = crypto_tfm_alg_alignmask(&tfm->base);
|
|
|
|
if (alignmask) {
|
|
|
|
/* Check if alignment mask for tfm is correctly set. */
|
|
|
|
ret = __test_aead(tfm, enc, template, tcount, true,
|
|
|
|
alignmask + 1);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
2012-09-21 15:26:52 +08:00
|
|
|
}
|
|
|
|
|
2008-08-17 15:01:56 +08:00
|
|
|
static int test_cipher(struct crypto_cipher *tfm, int enc,
|
2017-02-25 07:46:59 +08:00
|
|
|
const struct cipher_testvec *template,
|
|
|
|
unsigned int tcount)
|
2008-08-17 15:01:56 +08:00
|
|
|
{
|
|
|
|
const char *algo = crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm));
|
|
|
|
unsigned int i, j, k;
|
|
|
|
char *q;
|
|
|
|
const char *e;
|
|
|
|
void *data;
|
2009-05-06 14:15:47 +08:00
|
|
|
char *xbuf[XBUFSIZE];
|
|
|
|
int ret = -ENOMEM;
|
|
|
|
|
|
|
|
if (testmgr_alloc_buf(xbuf))
|
|
|
|
goto out_nobuf;
|
2008-08-17 15:01:56 +08:00
|
|
|
|
|
|
|
if (enc == ENCRYPT)
|
|
|
|
e = "encryption";
|
|
|
|
else
|
|
|
|
e = "decryption";
|
|
|
|
|
|
|
|
j = 0;
|
|
|
|
for (i = 0; i < tcount; i++) {
|
|
|
|
if (template[i].np)
|
|
|
|
continue;
|
|
|
|
|
2016-08-25 21:15:01 +08:00
|
|
|
if (fips_enabled && template[i].fips_skip)
|
|
|
|
continue;
|
|
|
|
|
2008-08-17 15:01:56 +08:00
|
|
|
j++;
|
|
|
|
|
2009-05-29 14:05:42 +08:00
|
|
|
ret = -EINVAL;
|
|
|
|
if (WARN_ON(template[i].ilen > PAGE_SIZE))
|
|
|
|
goto out;
|
|
|
|
|
2008-08-17 15:01:56 +08:00
|
|
|
data = xbuf[0];
|
|
|
|
memcpy(data, template[i].input, template[i].ilen);
|
|
|
|
|
|
|
|
crypto_cipher_clear_flags(tfm, ~0);
|
|
|
|
if (template[i].wk)
|
|
|
|
crypto_cipher_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
|
|
|
|
|
|
|
|
ret = crypto_cipher_setkey(tfm, template[i].key,
|
|
|
|
template[i].klen);
|
2016-07-29 16:32:09 +08:00
|
|
|
if (template[i].fail == !ret) {
|
2008-08-17 15:01:56 +08:00
|
|
|
printk(KERN_ERR "alg: cipher: setkey failed "
|
|
|
|
"on test %d for %s: flags=%x\n", j,
|
|
|
|
algo, crypto_cipher_get_flags(tfm));
|
|
|
|
goto out;
|
|
|
|
} else if (ret)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
for (k = 0; k < template[i].ilen;
|
|
|
|
k += crypto_cipher_blocksize(tfm)) {
|
|
|
|
if (enc)
|
|
|
|
crypto_cipher_encrypt_one(tfm, data + k,
|
|
|
|
data + k);
|
|
|
|
else
|
|
|
|
crypto_cipher_decrypt_one(tfm, data + k,
|
|
|
|
data + k);
|
|
|
|
}
|
|
|
|
|
|
|
|
q = data;
|
|
|
|
if (memcmp(q, template[i].result, template[i].rlen)) {
|
|
|
|
printk(KERN_ERR "alg: cipher: Test %d failed "
|
|
|
|
"on %s for %s\n", j, e, algo);
|
|
|
|
hexdump(q, template[i].rlen);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
out:
|
2009-05-06 14:15:47 +08:00
|
|
|
testmgr_free_buf(xbuf);
|
|
|
|
out_nobuf:
|
2008-08-17 15:01:56 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-08-20 15:21:46 +08:00
|
|
|
static int __test_skcipher(struct crypto_skcipher *tfm, int enc,
|
2017-02-25 07:46:59 +08:00
|
|
|
const struct cipher_testvec *template,
|
|
|
|
unsigned int tcount,
|
2013-06-13 22:37:45 +08:00
|
|
|
const bool diff_dst, const int align_offset)
|
2008-07-31 17:08:25 +08:00
|
|
|
{
|
|
|
|
const char *algo =
|
2015-08-20 15:21:46 +08:00
|
|
|
crypto_tfm_alg_driver_name(crypto_skcipher_tfm(tfm));
|
2008-07-31 17:08:25 +08:00
|
|
|
unsigned int i, j, k, n, temp;
|
|
|
|
char *q;
|
2015-08-20 15:21:46 +08:00
|
|
|
struct skcipher_request *req;
|
2008-07-31 17:08:25 +08:00
|
|
|
struct scatterlist sg[8];
|
2012-09-21 15:26:47 +08:00
|
|
|
struct scatterlist sgout[8];
|
|
|
|
const char *e, *d;
|
2017-10-18 15:00:43 +08:00
|
|
|
struct crypto_wait wait;
|
2008-07-31 17:08:25 +08:00
|
|
|
void *data;
|
|
|
|
char iv[MAX_IVLEN];
|
2009-05-06 14:15:47 +08:00
|
|
|
char *xbuf[XBUFSIZE];
|
2012-09-21 15:26:47 +08:00
|
|
|
char *xoutbuf[XBUFSIZE];
|
2009-05-06 14:15:47 +08:00
|
|
|
int ret = -ENOMEM;
|
2015-09-10 18:11:55 +08:00
|
|
|
unsigned int ivsize = crypto_skcipher_ivsize(tfm);
|
2009-05-06 14:15:47 +08:00
|
|
|
|
|
|
|
if (testmgr_alloc_buf(xbuf))
|
|
|
|
goto out_nobuf;
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2012-09-21 15:26:47 +08:00
|
|
|
if (diff_dst && testmgr_alloc_buf(xoutbuf))
|
|
|
|
goto out_nooutbuf;
|
|
|
|
|
|
|
|
if (diff_dst)
|
|
|
|
d = "-ddst";
|
|
|
|
else
|
|
|
|
d = "";
|
|
|
|
|
2008-07-31 17:08:25 +08:00
|
|
|
if (enc == ENCRYPT)
|
|
|
|
e = "encryption";
|
|
|
|
else
|
|
|
|
e = "decryption";
|
|
|
|
|
2017-10-18 15:00:43 +08:00
|
|
|
crypto_init_wait(&wait);
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2015-08-20 15:21:46 +08:00
|
|
|
req = skcipher_request_alloc(tfm, GFP_KERNEL);
|
2008-07-31 17:08:25 +08:00
|
|
|
if (!req) {
|
2012-09-21 15:26:47 +08:00
|
|
|
pr_err("alg: skcipher%s: Failed to allocate request for %s\n",
|
|
|
|
d, algo);
|
2008-07-31 17:08:25 +08:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2015-08-20 15:21:46 +08:00
|
|
|
skcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
|
2017-10-18 15:00:43 +08:00
|
|
|
crypto_req_done, &wait);
|
2008-07-31 17:08:25 +08:00
|
|
|
|
|
|
|
j = 0;
|
|
|
|
for (i = 0; i < tcount; i++) {
|
2014-08-08 19:27:52 +08:00
|
|
|
if (template[i].np && !template[i].also_non_np)
|
|
|
|
continue;
|
|
|
|
|
2016-08-25 21:15:01 +08:00
|
|
|
if (fips_enabled && template[i].fips_skip)
|
|
|
|
continue;
|
|
|
|
|
2008-07-31 17:08:25 +08:00
|
|
|
if (template[i].iv)
|
2015-09-10 18:11:55 +08:00
|
|
|
memcpy(iv, template[i].iv, ivsize);
|
2008-07-31 17:08:25 +08:00
|
|
|
else
|
|
|
|
memset(iv, 0, MAX_IVLEN);
|
|
|
|
|
2014-08-08 19:27:51 +08:00
|
|
|
j++;
|
|
|
|
ret = -EINVAL;
|
|
|
|
if (WARN_ON(align_offset + template[i].ilen > PAGE_SIZE))
|
|
|
|
goto out;
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2014-08-08 19:27:51 +08:00
|
|
|
data = xbuf[0];
|
|
|
|
data += align_offset;
|
|
|
|
memcpy(data, template[i].input, template[i].ilen);
|
|
|
|
|
2015-08-20 15:21:46 +08:00
|
|
|
crypto_skcipher_clear_flags(tfm, ~0);
|
2014-08-08 19:27:51 +08:00
|
|
|
if (template[i].wk)
|
2015-08-20 15:21:46 +08:00
|
|
|
crypto_skcipher_set_flags(tfm,
|
|
|
|
CRYPTO_TFM_REQ_WEAK_KEY);
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2015-08-20 15:21:46 +08:00
|
|
|
ret = crypto_skcipher_setkey(tfm, template[i].key,
|
|
|
|
template[i].klen);
|
2016-07-29 16:32:09 +08:00
|
|
|
if (template[i].fail == !ret) {
|
2014-08-08 19:27:51 +08:00
|
|
|
pr_err("alg: skcipher%s: setkey failed on test %d for %s: flags=%x\n",
|
2015-08-20 15:21:46 +08:00
|
|
|
d, j, algo, crypto_skcipher_get_flags(tfm));
|
2014-08-08 19:27:51 +08:00
|
|
|
goto out;
|
|
|
|
} else if (ret)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
sg_init_one(&sg[0], data, template[i].ilen);
|
|
|
|
if (diff_dst) {
|
|
|
|
data = xoutbuf[0];
|
|
|
|
data += align_offset;
|
|
|
|
sg_init_one(&sgout[0], data, template[i].ilen);
|
|
|
|
}
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2015-08-20 15:21:46 +08:00
|
|
|
skcipher_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
|
|
|
|
template[i].ilen, iv);
|
2017-10-18 15:00:43 +08:00
|
|
|
ret = crypto_wait_req(enc ? crypto_skcipher_encrypt(req) :
|
|
|
|
crypto_skcipher_decrypt(req), &wait);
|
2014-08-08 19:27:51 +08:00
|
|
|
|
2017-10-18 15:00:43 +08:00
|
|
|
if (ret) {
|
2014-08-08 19:27:51 +08:00
|
|
|
pr_err("alg: skcipher%s: %s failed on test %d for %s: ret=%d\n",
|
|
|
|
d, e, j, algo, -ret);
|
|
|
|
goto out;
|
|
|
|
}
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2014-08-08 19:27:51 +08:00
|
|
|
q = data;
|
|
|
|
if (memcmp(q, template[i].result, template[i].rlen)) {
|
2015-06-16 17:46:46 +08:00
|
|
|
pr_err("alg: skcipher%s: Test %d failed (invalid result) on %s for %s\n",
|
2014-08-08 19:27:51 +08:00
|
|
|
d, j, e, algo);
|
|
|
|
hexdump(q, template[i].rlen);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
2015-06-16 17:46:46 +08:00
|
|
|
|
|
|
|
if (template[i].iv_out &&
|
|
|
|
memcmp(iv, template[i].iv_out,
|
|
|
|
crypto_skcipher_ivsize(tfm))) {
|
|
|
|
pr_err("alg: skcipher%s: Test %d failed (invalid output IV) on %s for %s\n",
|
|
|
|
d, j, e, algo);
|
|
|
|
hexdump(iv, crypto_skcipher_ivsize(tfm));
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
j = 0;
|
|
|
|
for (i = 0; i < tcount; i++) {
|
2013-06-13 22:37:45 +08:00
|
|
|
/* alignment tests are only done with continuous buffers */
|
|
|
|
if (align_offset != 0)
|
|
|
|
break;
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2014-08-08 19:27:52 +08:00
|
|
|
if (!template[i].np)
|
|
|
|
continue;
|
|
|
|
|
2016-08-25 21:15:01 +08:00
|
|
|
if (fips_enabled && template[i].fips_skip)
|
|
|
|
continue;
|
|
|
|
|
2008-07-31 17:08:25 +08:00
|
|
|
if (template[i].iv)
|
2015-09-10 18:11:55 +08:00
|
|
|
memcpy(iv, template[i].iv, ivsize);
|
2008-07-31 17:08:25 +08:00
|
|
|
else
|
|
|
|
memset(iv, 0, MAX_IVLEN);
|
|
|
|
|
2014-08-08 19:27:51 +08:00
|
|
|
j++;
|
2015-08-20 15:21:46 +08:00
|
|
|
crypto_skcipher_clear_flags(tfm, ~0);
|
2014-08-08 19:27:51 +08:00
|
|
|
if (template[i].wk)
|
2015-08-20 15:21:46 +08:00
|
|
|
crypto_skcipher_set_flags(tfm,
|
|
|
|
CRYPTO_TFM_REQ_WEAK_KEY);
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2015-08-20 15:21:46 +08:00
|
|
|
ret = crypto_skcipher_setkey(tfm, template[i].key,
|
|
|
|
template[i].klen);
|
2016-07-29 16:32:09 +08:00
|
|
|
if (template[i].fail == !ret) {
|
2014-08-08 19:27:51 +08:00
|
|
|
pr_err("alg: skcipher%s: setkey failed on chunk test %d for %s: flags=%x\n",
|
2015-08-20 15:21:46 +08:00
|
|
|
d, j, algo, crypto_skcipher_get_flags(tfm));
|
2014-08-08 19:27:51 +08:00
|
|
|
goto out;
|
|
|
|
} else if (ret)
|
|
|
|
continue;
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2014-08-08 19:27:51 +08:00
|
|
|
temp = 0;
|
|
|
|
ret = -EINVAL;
|
|
|
|
sg_init_table(sg, template[i].np);
|
|
|
|
if (diff_dst)
|
|
|
|
sg_init_table(sgout, template[i].np);
|
|
|
|
for (k = 0; k < template[i].np; k++) {
|
|
|
|
if (WARN_ON(offset_in_page(IDX[k]) +
|
|
|
|
template[i].tap[k] > PAGE_SIZE))
|
2008-07-31 17:08:25 +08:00
|
|
|
goto out;
|
|
|
|
|
2014-08-08 19:27:51 +08:00
|
|
|
q = xbuf[IDX[k] >> PAGE_SHIFT] + offset_in_page(IDX[k]);
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2014-08-08 19:27:51 +08:00
|
|
|
memcpy(q, template[i].input + temp, template[i].tap[k]);
|
|
|
|
|
|
|
|
if (offset_in_page(q) + template[i].tap[k] < PAGE_SIZE)
|
|
|
|
q[template[i].tap[k]] = 0;
|
|
|
|
|
|
|
|
sg_set_buf(&sg[k], q, template[i].tap[k]);
|
|
|
|
if (diff_dst) {
|
|
|
|
q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
|
2008-07-31 17:08:25 +08:00
|
|
|
offset_in_page(IDX[k]);
|
|
|
|
|
2014-08-08 19:27:51 +08:00
|
|
|
sg_set_buf(&sgout[k], q, template[i].tap[k]);
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2014-08-08 19:27:51 +08:00
|
|
|
memset(q, 0, template[i].tap[k]);
|
|
|
|
if (offset_in_page(q) +
|
|
|
|
template[i].tap[k] < PAGE_SIZE)
|
2008-07-31 17:08:25 +08:00
|
|
|
q[template[i].tap[k]] = 0;
|
2014-08-08 19:27:51 +08:00
|
|
|
}
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2014-08-08 19:27:51 +08:00
|
|
|
temp += template[i].tap[k];
|
|
|
|
}
|
2012-09-21 15:26:47 +08:00
|
|
|
|
2015-08-20 15:21:46 +08:00
|
|
|
skcipher_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
|
|
|
|
template[i].ilen, iv);
|
2012-09-21 15:26:47 +08:00
|
|
|
|
2017-10-18 15:00:43 +08:00
|
|
|
ret = crypto_wait_req(enc ? crypto_skcipher_encrypt(req) :
|
|
|
|
crypto_skcipher_decrypt(req), &wait);
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2017-10-18 15:00:43 +08:00
|
|
|
if (ret) {
|
2014-08-08 19:27:51 +08:00
|
|
|
pr_err("alg: skcipher%s: %s failed on chunk test %d for %s: ret=%d\n",
|
|
|
|
d, e, j, algo, -ret);
|
|
|
|
goto out;
|
|
|
|
}
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2014-08-08 19:27:51 +08:00
|
|
|
temp = 0;
|
|
|
|
ret = -EINVAL;
|
|
|
|
for (k = 0; k < template[i].np; k++) {
|
|
|
|
if (diff_dst)
|
|
|
|
q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
|
|
|
|
offset_in_page(IDX[k]);
|
|
|
|
else
|
|
|
|
q = xbuf[IDX[k] >> PAGE_SHIFT] +
|
|
|
|
offset_in_page(IDX[k]);
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2014-08-08 19:27:51 +08:00
|
|
|
if (memcmp(q, template[i].result + temp,
|
|
|
|
template[i].tap[k])) {
|
|
|
|
pr_err("alg: skcipher%s: Chunk test %d failed on %s at page %u for %s\n",
|
|
|
|
d, j, e, k, algo);
|
|
|
|
hexdump(q, template[i].tap[k]);
|
2008-07-31 17:08:25 +08:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2014-08-08 19:27:51 +08:00
|
|
|
q += template[i].tap[k];
|
|
|
|
for (n = 0; offset_in_page(q + n) && q[n]; n++)
|
|
|
|
;
|
|
|
|
if (n) {
|
|
|
|
pr_err("alg: skcipher%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n",
|
|
|
|
d, j, e, k, algo, n);
|
|
|
|
hexdump(q, n);
|
|
|
|
goto out;
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
2014-08-08 19:27:51 +08:00
|
|
|
temp += template[i].tap[k];
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
out:
|
2015-08-20 15:21:46 +08:00
|
|
|
skcipher_request_free(req);
|
2012-09-21 15:26:47 +08:00
|
|
|
if (diff_dst)
|
|
|
|
testmgr_free_buf(xoutbuf);
|
|
|
|
out_nooutbuf:
|
2009-05-06 14:15:47 +08:00
|
|
|
testmgr_free_buf(xbuf);
|
|
|
|
out_nobuf:
|
2008-07-31 17:08:25 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-08-20 15:21:46 +08:00
|
|
|
static int test_skcipher(struct crypto_skcipher *tfm, int enc,
|
2017-02-25 07:46:59 +08:00
|
|
|
const struct cipher_testvec *template,
|
|
|
|
unsigned int tcount)
|
2012-09-21 15:26:47 +08:00
|
|
|
{
|
2013-06-13 22:37:45 +08:00
|
|
|
unsigned int alignmask;
|
2012-09-21 15:26:47 +08:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* test 'dst == src' case */
|
2013-06-13 22:37:45 +08:00
|
|
|
ret = __test_skcipher(tfm, enc, template, tcount, false, 0);
|
2012-09-21 15:26:47 +08:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
/* test 'dst != src' case */
|
2013-06-13 22:37:45 +08:00
|
|
|
ret = __test_skcipher(tfm, enc, template, tcount, true, 0);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
/* test unaligned buffers, check with one byte offset */
|
|
|
|
ret = __test_skcipher(tfm, enc, template, tcount, true, 1);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
alignmask = crypto_tfm_alg_alignmask(&tfm->base);
|
|
|
|
if (alignmask) {
|
|
|
|
/* Check if alignment mask for tfm is correctly set. */
|
|
|
|
ret = __test_skcipher(tfm, enc, template, tcount, true,
|
|
|
|
alignmask + 1);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
2012-09-21 15:26:47 +08:00
|
|
|
}
|
|
|
|
|
2017-02-25 07:46:59 +08:00
|
|
|
static int test_comp(struct crypto_comp *tfm,
|
|
|
|
const struct comp_testvec *ctemplate,
|
|
|
|
const struct comp_testvec *dtemplate,
|
|
|
|
int ctcount, int dtcount)
|
2008-07-31 17:08:25 +08:00
|
|
|
{
|
|
|
|
const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm));
|
2018-04-12 02:28:32 +08:00
|
|
|
char *output, *decomp_output;
|
2008-07-31 17:08:25 +08:00
|
|
|
unsigned int i;
|
|
|
|
int ret;
|
|
|
|
|
2018-04-12 02:28:32 +08:00
|
|
|
output = kmalloc(COMP_BUF_SIZE, GFP_KERNEL);
|
|
|
|
if (!output)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
decomp_output = kmalloc(COMP_BUF_SIZE, GFP_KERNEL);
|
|
|
|
if (!decomp_output) {
|
|
|
|
kfree(output);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2008-07-31 17:08:25 +08:00
|
|
|
for (i = 0; i < ctcount; i++) {
|
2009-03-29 15:44:19 +08:00
|
|
|
int ilen;
|
|
|
|
unsigned int dlen = COMP_BUF_SIZE;
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2018-04-12 02:28:32 +08:00
|
|
|
memset(output, 0, sizeof(COMP_BUF_SIZE));
|
|
|
|
memset(decomp_output, 0, sizeof(COMP_BUF_SIZE));
|
2008-07-31 17:08:25 +08:00
|
|
|
|
|
|
|
ilen = ctemplate[i].inlen;
|
|
|
|
ret = crypto_comp_compress(tfm, ctemplate[i].input,
|
2018-04-12 02:28:32 +08:00
|
|
|
ilen, output, &dlen);
|
2008-07-31 17:08:25 +08:00
|
|
|
if (ret) {
|
|
|
|
printk(KERN_ERR "alg: comp: compression failed "
|
|
|
|
"on test %d for %s: ret=%d\n", i + 1, algo,
|
|
|
|
-ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2018-04-12 02:28:32 +08:00
|
|
|
ilen = dlen;
|
|
|
|
dlen = COMP_BUF_SIZE;
|
|
|
|
ret = crypto_comp_decompress(tfm, output,
|
|
|
|
ilen, decomp_output, &dlen);
|
|
|
|
if (ret) {
|
|
|
|
pr_err("alg: comp: compression failed: decompress: on test %d for %s failed: ret=%d\n",
|
|
|
|
i + 1, algo, -ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dlen != ctemplate[i].inlen) {
|
2008-11-28 20:51:28 +08:00
|
|
|
printk(KERN_ERR "alg: comp: Compression test %d "
|
|
|
|
"failed for %s: output len = %d\n", i + 1, algo,
|
|
|
|
dlen);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2018-04-12 02:28:32 +08:00
|
|
|
if (memcmp(decomp_output, ctemplate[i].input,
|
|
|
|
ctemplate[i].inlen)) {
|
|
|
|
pr_err("alg: comp: compression failed: output differs: on test %d for %s\n",
|
|
|
|
i + 1, algo);
|
|
|
|
hexdump(decomp_output, dlen);
|
2008-07-31 17:08:25 +08:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < dtcount; i++) {
|
2009-03-29 15:44:19 +08:00
|
|
|
int ilen;
|
|
|
|
unsigned int dlen = COMP_BUF_SIZE;
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2018-04-12 02:28:32 +08:00
|
|
|
memset(decomp_output, 0, sizeof(COMP_BUF_SIZE));
|
2008-07-31 17:08:25 +08:00
|
|
|
|
|
|
|
ilen = dtemplate[i].inlen;
|
|
|
|
ret = crypto_comp_decompress(tfm, dtemplate[i].input,
|
2018-04-12 02:28:32 +08:00
|
|
|
ilen, decomp_output, &dlen);
|
2008-07-31 17:08:25 +08:00
|
|
|
if (ret) {
|
|
|
|
printk(KERN_ERR "alg: comp: decompression failed "
|
|
|
|
"on test %d for %s: ret=%d\n", i + 1, algo,
|
|
|
|
-ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2008-11-28 20:51:28 +08:00
|
|
|
if (dlen != dtemplate[i].outlen) {
|
|
|
|
printk(KERN_ERR "alg: comp: Decompression test %d "
|
|
|
|
"failed for %s: output len = %d\n", i + 1, algo,
|
|
|
|
dlen);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2018-04-12 02:28:32 +08:00
|
|
|
if (memcmp(decomp_output, dtemplate[i].output, dlen)) {
|
2008-07-31 17:08:25 +08:00
|
|
|
printk(KERN_ERR "alg: comp: Decompression test %d "
|
|
|
|
"failed for %s\n", i + 1, algo);
|
2018-04-12 02:28:32 +08:00
|
|
|
hexdump(decomp_output, dlen);
|
2008-07-31 17:08:25 +08:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
out:
|
2018-04-12 02:28:32 +08:00
|
|
|
kfree(decomp_output);
|
|
|
|
kfree(output);
|
2008-07-31 17:08:25 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-02-25 07:46:59 +08:00
|
|
|
static int test_acomp(struct crypto_acomp *tfm,
|
2018-04-12 02:28:32 +08:00
|
|
|
const struct comp_testvec *ctemplate,
|
2017-02-25 07:46:59 +08:00
|
|
|
const struct comp_testvec *dtemplate,
|
|
|
|
int ctcount, int dtcount)
|
2016-10-21 20:19:54 +08:00
|
|
|
{
|
|
|
|
const char *algo = crypto_tfm_alg_driver_name(crypto_acomp_tfm(tfm));
|
|
|
|
unsigned int i;
|
2017-04-19 21:27:18 +08:00
|
|
|
char *output, *decomp_out;
|
2016-10-21 20:19:54 +08:00
|
|
|
int ret;
|
|
|
|
struct scatterlist src, dst;
|
|
|
|
struct acomp_req *req;
|
2017-10-18 15:00:43 +08:00
|
|
|
struct crypto_wait wait;
|
2016-10-21 20:19:54 +08:00
|
|
|
|
2016-11-24 02:24:35 +08:00
|
|
|
output = kmalloc(COMP_BUF_SIZE, GFP_KERNEL);
|
|
|
|
if (!output)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2017-04-19 21:27:18 +08:00
|
|
|
decomp_out = kmalloc(COMP_BUF_SIZE, GFP_KERNEL);
|
|
|
|
if (!decomp_out) {
|
|
|
|
kfree(output);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2016-10-21 20:19:54 +08:00
|
|
|
for (i = 0; i < ctcount; i++) {
|
|
|
|
unsigned int dlen = COMP_BUF_SIZE;
|
|
|
|
int ilen = ctemplate[i].inlen;
|
2016-12-22 04:32:54 +08:00
|
|
|
void *input_vec;
|
2016-10-21 20:19:54 +08:00
|
|
|
|
2016-12-31 04:12:00 +08:00
|
|
|
input_vec = kmemdup(ctemplate[i].input, ilen, GFP_KERNEL);
|
2016-12-22 04:32:54 +08:00
|
|
|
if (!input_vec) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2016-11-24 02:24:35 +08:00
|
|
|
memset(output, 0, dlen);
|
2017-10-18 15:00:43 +08:00
|
|
|
crypto_init_wait(&wait);
|
2016-12-22 04:32:54 +08:00
|
|
|
sg_init_one(&src, input_vec, ilen);
|
2016-10-21 20:19:54 +08:00
|
|
|
sg_init_one(&dst, output, dlen);
|
|
|
|
|
|
|
|
req = acomp_request_alloc(tfm);
|
|
|
|
if (!req) {
|
|
|
|
pr_err("alg: acomp: request alloc failed for %s\n",
|
|
|
|
algo);
|
2016-12-22 04:32:54 +08:00
|
|
|
kfree(input_vec);
|
2016-10-21 20:19:54 +08:00
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
acomp_request_set_params(req, &src, &dst, ilen, dlen);
|
|
|
|
acomp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
|
2017-10-18 15:00:43 +08:00
|
|
|
crypto_req_done, &wait);
|
2016-10-21 20:19:54 +08:00
|
|
|
|
2017-10-18 15:00:43 +08:00
|
|
|
ret = crypto_wait_req(crypto_acomp_compress(req), &wait);
|
2016-10-21 20:19:54 +08:00
|
|
|
if (ret) {
|
|
|
|
pr_err("alg: acomp: compression failed on test %d for %s: ret=%d\n",
|
|
|
|
i + 1, algo, -ret);
|
2016-12-22 04:32:54 +08:00
|
|
|
kfree(input_vec);
|
2016-10-21 20:19:54 +08:00
|
|
|
acomp_request_free(req);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2017-04-19 21:27:18 +08:00
|
|
|
ilen = req->dlen;
|
|
|
|
dlen = COMP_BUF_SIZE;
|
|
|
|
sg_init_one(&src, output, ilen);
|
|
|
|
sg_init_one(&dst, decomp_out, dlen);
|
2017-10-18 15:00:43 +08:00
|
|
|
crypto_init_wait(&wait);
|
2017-04-19 21:27:18 +08:00
|
|
|
acomp_request_set_params(req, &src, &dst, ilen, dlen);
|
|
|
|
|
2017-10-18 15:00:43 +08:00
|
|
|
ret = crypto_wait_req(crypto_acomp_decompress(req), &wait);
|
2017-04-19 21:27:18 +08:00
|
|
|
if (ret) {
|
|
|
|
pr_err("alg: acomp: compression failed on test %d for %s: ret=%d\n",
|
|
|
|
i + 1, algo, -ret);
|
|
|
|
kfree(input_vec);
|
|
|
|
acomp_request_free(req);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (req->dlen != ctemplate[i].inlen) {
|
2016-10-21 20:19:54 +08:00
|
|
|
pr_err("alg: acomp: Compression test %d failed for %s: output len = %d\n",
|
|
|
|
i + 1, algo, req->dlen);
|
|
|
|
ret = -EINVAL;
|
2016-12-22 04:32:54 +08:00
|
|
|
kfree(input_vec);
|
2016-10-21 20:19:54 +08:00
|
|
|
acomp_request_free(req);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2017-04-19 21:27:18 +08:00
|
|
|
if (memcmp(input_vec, decomp_out, req->dlen)) {
|
2016-10-21 20:19:54 +08:00
|
|
|
pr_err("alg: acomp: Compression test %d failed for %s\n",
|
|
|
|
i + 1, algo);
|
|
|
|
hexdump(output, req->dlen);
|
|
|
|
ret = -EINVAL;
|
2016-12-22 04:32:54 +08:00
|
|
|
kfree(input_vec);
|
2016-10-21 20:19:54 +08:00
|
|
|
acomp_request_free(req);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2016-12-22 04:32:54 +08:00
|
|
|
kfree(input_vec);
|
2016-10-21 20:19:54 +08:00
|
|
|
acomp_request_free(req);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < dtcount; i++) {
|
|
|
|
unsigned int dlen = COMP_BUF_SIZE;
|
|
|
|
int ilen = dtemplate[i].inlen;
|
2016-12-22 04:32:54 +08:00
|
|
|
void *input_vec;
|
|
|
|
|
2016-12-31 04:12:00 +08:00
|
|
|
input_vec = kmemdup(dtemplate[i].input, ilen, GFP_KERNEL);
|
2016-12-22 04:32:54 +08:00
|
|
|
if (!input_vec) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
2016-10-21 20:19:54 +08:00
|
|
|
|
2016-11-24 02:24:35 +08:00
|
|
|
memset(output, 0, dlen);
|
2017-10-18 15:00:43 +08:00
|
|
|
crypto_init_wait(&wait);
|
2016-12-22 04:32:54 +08:00
|
|
|
sg_init_one(&src, input_vec, ilen);
|
2016-10-21 20:19:54 +08:00
|
|
|
sg_init_one(&dst, output, dlen);
|
|
|
|
|
|
|
|
req = acomp_request_alloc(tfm);
|
|
|
|
if (!req) {
|
|
|
|
pr_err("alg: acomp: request alloc failed for %s\n",
|
|
|
|
algo);
|
2016-12-22 04:32:54 +08:00
|
|
|
kfree(input_vec);
|
2016-10-21 20:19:54 +08:00
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
acomp_request_set_params(req, &src, &dst, ilen, dlen);
|
|
|
|
acomp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
|
2017-10-18 15:00:43 +08:00
|
|
|
crypto_req_done, &wait);
|
2016-10-21 20:19:54 +08:00
|
|
|
|
2017-10-18 15:00:43 +08:00
|
|
|
ret = crypto_wait_req(crypto_acomp_decompress(req), &wait);
|
2016-10-21 20:19:54 +08:00
|
|
|
if (ret) {
|
|
|
|
pr_err("alg: acomp: decompression failed on test %d for %s: ret=%d\n",
|
|
|
|
i + 1, algo, -ret);
|
2016-12-22 04:32:54 +08:00
|
|
|
kfree(input_vec);
|
2016-10-21 20:19:54 +08:00
|
|
|
acomp_request_free(req);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (req->dlen != dtemplate[i].outlen) {
|
|
|
|
pr_err("alg: acomp: Decompression test %d failed for %s: output len = %d\n",
|
|
|
|
i + 1, algo, req->dlen);
|
|
|
|
ret = -EINVAL;
|
2016-12-22 04:32:54 +08:00
|
|
|
kfree(input_vec);
|
2016-10-21 20:19:54 +08:00
|
|
|
acomp_request_free(req);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (memcmp(output, dtemplate[i].output, req->dlen)) {
|
|
|
|
pr_err("alg: acomp: Decompression test %d failed for %s\n",
|
|
|
|
i + 1, algo);
|
|
|
|
hexdump(output, req->dlen);
|
|
|
|
ret = -EINVAL;
|
2016-12-22 04:32:54 +08:00
|
|
|
kfree(input_vec);
|
2016-10-21 20:19:54 +08:00
|
|
|
acomp_request_free(req);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2016-12-22 04:32:54 +08:00
|
|
|
kfree(input_vec);
|
2016-10-21 20:19:54 +08:00
|
|
|
acomp_request_free(req);
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
out:
|
2017-04-19 21:27:18 +08:00
|
|
|
kfree(decomp_out);
|
2016-11-24 02:24:35 +08:00
|
|
|
kfree(output);
|
2016-10-21 20:19:54 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-02-25 07:46:59 +08:00
|
|
|
static int test_cprng(struct crypto_rng *tfm,
|
|
|
|
const struct cprng_testvec *template,
|
2009-05-04 19:44:50 +08:00
|
|
|
unsigned int tcount)
|
|
|
|
{
|
|
|
|
const char *algo = crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm));
|
2009-10-27 19:04:42 +08:00
|
|
|
int err = 0, i, j, seedsize;
|
2009-05-04 19:44:50 +08:00
|
|
|
u8 *seed;
|
|
|
|
char result[32];
|
|
|
|
|
|
|
|
seedsize = crypto_rng_seedsize(tfm);
|
|
|
|
|
|
|
|
seed = kmalloc(seedsize, GFP_KERNEL);
|
|
|
|
if (!seed) {
|
|
|
|
printk(KERN_ERR "alg: cprng: Failed to allocate seed space "
|
|
|
|
"for %s\n", algo);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < tcount; i++) {
|
|
|
|
memset(result, 0, 32);
|
|
|
|
|
|
|
|
memcpy(seed, template[i].v, template[i].vlen);
|
|
|
|
memcpy(seed + template[i].vlen, template[i].key,
|
|
|
|
template[i].klen);
|
|
|
|
memcpy(seed + template[i].vlen + template[i].klen,
|
|
|
|
template[i].dt, template[i].dtlen);
|
|
|
|
|
|
|
|
err = crypto_rng_reset(tfm, seed, seedsize);
|
|
|
|
if (err) {
|
|
|
|
printk(KERN_ERR "alg: cprng: Failed to reset rng "
|
|
|
|
"for %s\n", algo);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (j = 0; j < template[i].loops; j++) {
|
|
|
|
err = crypto_rng_get_bytes(tfm, result,
|
|
|
|
template[i].rlen);
|
2015-03-11 00:00:36 +08:00
|
|
|
if (err < 0) {
|
2009-05-04 19:44:50 +08:00
|
|
|
printk(KERN_ERR "alg: cprng: Failed to obtain "
|
|
|
|
"the correct amount of random data for "
|
2015-03-11 00:00:36 +08:00
|
|
|
"%s (requested %d)\n", algo,
|
|
|
|
template[i].rlen);
|
2009-05-04 19:44:50 +08:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
err = memcmp(result, template[i].result,
|
|
|
|
template[i].rlen);
|
|
|
|
if (err) {
|
|
|
|
printk(KERN_ERR "alg: cprng: Test %d failed for %s\n",
|
|
|
|
i, algo);
|
|
|
|
hexdump(result, template[i].rlen);
|
|
|
|
err = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
kfree(seed);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2008-07-31 17:08:25 +08:00
|
|
|
static int alg_test_aead(const struct alg_test_desc *desc, const char *driver,
|
|
|
|
u32 type, u32 mask)
|
|
|
|
{
|
|
|
|
struct crypto_aead *tfm;
|
|
|
|
int err = 0;
|
|
|
|
|
2016-11-22 20:08:31 +08:00
|
|
|
tfm = crypto_alloc_aead(driver, type, mask);
|
2008-07-31 17:08:25 +08:00
|
|
|
if (IS_ERR(tfm)) {
|
|
|
|
printk(KERN_ERR "alg: aead: Failed to load transform for %s: "
|
|
|
|
"%ld\n", driver, PTR_ERR(tfm));
|
|
|
|
return PTR_ERR(tfm);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (desc->suite.aead.enc.vecs) {
|
|
|
|
err = test_aead(tfm, ENCRYPT, desc->suite.aead.enc.vecs,
|
|
|
|
desc->suite.aead.enc.count);
|
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!err && desc->suite.aead.dec.vecs)
|
|
|
|
err = test_aead(tfm, DECRYPT, desc->suite.aead.dec.vecs,
|
|
|
|
desc->suite.aead.dec.count);
|
|
|
|
|
|
|
|
out:
|
|
|
|
crypto_free_aead(tfm);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int alg_test_cipher(const struct alg_test_desc *desc,
|
|
|
|
const char *driver, u32 type, u32 mask)
|
|
|
|
{
|
2008-08-17 15:01:56 +08:00
|
|
|
struct crypto_cipher *tfm;
|
2008-07-31 17:08:25 +08:00
|
|
|
int err = 0;
|
|
|
|
|
2016-11-22 20:08:31 +08:00
|
|
|
tfm = crypto_alloc_cipher(driver, type, mask);
|
2008-07-31 17:08:25 +08:00
|
|
|
if (IS_ERR(tfm)) {
|
|
|
|
printk(KERN_ERR "alg: cipher: Failed to load transform for "
|
|
|
|
"%s: %ld\n", driver, PTR_ERR(tfm));
|
|
|
|
return PTR_ERR(tfm);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (desc->suite.cipher.enc.vecs) {
|
|
|
|
err = test_cipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
|
|
|
|
desc->suite.cipher.enc.count);
|
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (desc->suite.cipher.dec.vecs)
|
|
|
|
err = test_cipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
|
|
|
|
desc->suite.cipher.dec.count);
|
|
|
|
|
2008-08-17 15:01:56 +08:00
|
|
|
out:
|
|
|
|
crypto_free_cipher(tfm);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int alg_test_skcipher(const struct alg_test_desc *desc,
|
|
|
|
const char *driver, u32 type, u32 mask)
|
|
|
|
{
|
2015-08-20 15:21:46 +08:00
|
|
|
struct crypto_skcipher *tfm;
|
2008-08-17 15:01:56 +08:00
|
|
|
int err = 0;
|
|
|
|
|
2016-11-22 20:08:31 +08:00
|
|
|
tfm = crypto_alloc_skcipher(driver, type, mask);
|
2008-08-17 15:01:56 +08:00
|
|
|
if (IS_ERR(tfm)) {
|
|
|
|
printk(KERN_ERR "alg: skcipher: Failed to load transform for "
|
|
|
|
"%s: %ld\n", driver, PTR_ERR(tfm));
|
|
|
|
return PTR_ERR(tfm);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (desc->suite.cipher.enc.vecs) {
|
|
|
|
err = test_skcipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
|
|
|
|
desc->suite.cipher.enc.count);
|
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (desc->suite.cipher.dec.vecs)
|
|
|
|
err = test_skcipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
|
|
|
|
desc->suite.cipher.dec.count);
|
|
|
|
|
2008-07-31 17:08:25 +08:00
|
|
|
out:
|
2015-08-20 15:21:46 +08:00
|
|
|
crypto_free_skcipher(tfm);
|
2008-07-31 17:08:25 +08:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int alg_test_comp(const struct alg_test_desc *desc, const char *driver,
|
|
|
|
u32 type, u32 mask)
|
|
|
|
{
|
2016-10-21 20:19:54 +08:00
|
|
|
struct crypto_comp *comp;
|
|
|
|
struct crypto_acomp *acomp;
|
2008-07-31 17:08:25 +08:00
|
|
|
int err;
|
2016-10-21 20:19:54 +08:00
|
|
|
u32 algo_type = type & CRYPTO_ALG_TYPE_ACOMPRESS_MASK;
|
|
|
|
|
|
|
|
if (algo_type == CRYPTO_ALG_TYPE_ACOMPRESS) {
|
|
|
|
acomp = crypto_alloc_acomp(driver, type, mask);
|
|
|
|
if (IS_ERR(acomp)) {
|
|
|
|
pr_err("alg: acomp: Failed to load transform for %s: %ld\n",
|
|
|
|
driver, PTR_ERR(acomp));
|
|
|
|
return PTR_ERR(acomp);
|
|
|
|
}
|
|
|
|
err = test_acomp(acomp, desc->suite.comp.comp.vecs,
|
|
|
|
desc->suite.comp.decomp.vecs,
|
|
|
|
desc->suite.comp.comp.count,
|
|
|
|
desc->suite.comp.decomp.count);
|
|
|
|
crypto_free_acomp(acomp);
|
|
|
|
} else {
|
|
|
|
comp = crypto_alloc_comp(driver, type, mask);
|
|
|
|
if (IS_ERR(comp)) {
|
|
|
|
pr_err("alg: comp: Failed to load transform for %s: %ld\n",
|
|
|
|
driver, PTR_ERR(comp));
|
|
|
|
return PTR_ERR(comp);
|
|
|
|
}
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2016-10-21 20:19:54 +08:00
|
|
|
err = test_comp(comp, desc->suite.comp.comp.vecs,
|
|
|
|
desc->suite.comp.decomp.vecs,
|
|
|
|
desc->suite.comp.comp.count,
|
|
|
|
desc->suite.comp.decomp.count);
|
2008-07-31 17:08:25 +08:00
|
|
|
|
2016-10-21 20:19:54 +08:00
|
|
|
crypto_free_comp(comp);
|
|
|
|
}
|
2008-07-31 17:08:25 +08:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int alg_test_hash(const struct alg_test_desc *desc, const char *driver,
|
|
|
|
u32 type, u32 mask)
|
|
|
|
{
|
|
|
|
struct crypto_ahash *tfm;
|
|
|
|
int err;
|
|
|
|
|
2016-11-22 20:08:31 +08:00
|
|
|
tfm = crypto_alloc_ahash(driver, type, mask);
|
2008-07-31 17:08:25 +08:00
|
|
|
if (IS_ERR(tfm)) {
|
|
|
|
printk(KERN_ERR "alg: hash: Failed to load transform for %s: "
|
|
|
|
"%ld\n", driver, PTR_ERR(tfm));
|
|
|
|
return PTR_ERR(tfm);
|
|
|
|
}
|
|
|
|
|
2010-05-19 12:12:03 +08:00
|
|
|
err = test_hash(tfm, desc->suite.hash.vecs,
|
|
|
|
desc->suite.hash.count, true);
|
|
|
|
if (!err)
|
|
|
|
err = test_hash(tfm, desc->suite.hash.vecs,
|
|
|
|
desc->suite.hash.count, false);
|
2008-07-31 17:08:25 +08:00
|
|
|
|
|
|
|
crypto_free_ahash(tfm);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2008-11-07 14:58:52 +08:00
|
|
|
static int alg_test_crc32c(const struct alg_test_desc *desc,
|
|
|
|
const char *driver, u32 type, u32 mask)
|
|
|
|
{
|
|
|
|
struct crypto_shash *tfm;
|
|
|
|
u32 val;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = alg_test_hash(desc, driver, type, mask);
|
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
|
2016-11-22 20:08:31 +08:00
|
|
|
tfm = crypto_alloc_shash(driver, type, mask);
|
2008-11-07 14:58:52 +08:00
|
|
|
if (IS_ERR(tfm)) {
|
|
|
|
printk(KERN_ERR "alg: crc32c: Failed to load transform for %s: "
|
|
|
|
"%ld\n", driver, PTR_ERR(tfm));
|
|
|
|
err = PTR_ERR(tfm);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
do {
|
2012-07-02 19:48:30 +08:00
|
|
|
SHASH_DESC_ON_STACK(shash, tfm);
|
|
|
|
u32 *ctx = (u32 *)shash_desc_ctx(shash);
|
2008-11-07 14:58:52 +08:00
|
|
|
|
2012-07-02 19:48:30 +08:00
|
|
|
shash->tfm = tfm;
|
|
|
|
shash->flags = 0;
|
2008-11-07 14:58:52 +08:00
|
|
|
|
2012-07-02 19:48:30 +08:00
|
|
|
*ctx = le32_to_cpu(420553207);
|
|
|
|
err = crypto_shash_final(shash, (u8 *)&val);
|
2008-11-07 14:58:52 +08:00
|
|
|
if (err) {
|
|
|
|
printk(KERN_ERR "alg: crc32c: Operation failed for "
|
|
|
|
"%s: %d\n", driver, err);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (val != ~420553207) {
|
|
|
|
printk(KERN_ERR "alg: crc32c: Test failed for %s: "
|
|
|
|
"%d\n", driver, val);
|
|
|
|
err = -EINVAL;
|
|
|
|
}
|
|
|
|
} while (0);
|
|
|
|
|
|
|
|
crypto_free_shash(tfm);
|
|
|
|
|
|
|
|
out:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2009-05-04 19:44:50 +08:00
|
|
|
static int alg_test_cprng(const struct alg_test_desc *desc, const char *driver,
|
|
|
|
u32 type, u32 mask)
|
|
|
|
{
|
|
|
|
struct crypto_rng *rng;
|
|
|
|
int err;
|
|
|
|
|
2016-11-22 20:08:31 +08:00
|
|
|
rng = crypto_alloc_rng(driver, type, mask);
|
2009-05-04 19:44:50 +08:00
|
|
|
if (IS_ERR(rng)) {
|
|
|
|
printk(KERN_ERR "alg: cprng: Failed to load transform for %s: "
|
|
|
|
"%ld\n", driver, PTR_ERR(rng));
|
|
|
|
return PTR_ERR(rng);
|
|
|
|
}
|
|
|
|
|
|
|
|
err = test_cprng(rng, desc->suite.cprng.vecs, desc->suite.cprng.count);
|
|
|
|
|
|
|
|
crypto_free_rng(rng);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2014-05-31 23:25:36 +08:00
|
|
|
|
2017-02-25 07:46:59 +08:00
|
|
|
static int drbg_cavs_test(const struct drbg_testvec *test, int pr,
|
2014-05-31 23:25:36 +08:00
|
|
|
const char *driver, u32 type, u32 mask)
|
|
|
|
{
|
|
|
|
int ret = -EAGAIN;
|
|
|
|
struct crypto_rng *drng;
|
|
|
|
struct drbg_test_data test_data;
|
|
|
|
struct drbg_string addtl, pers, testentropy;
|
|
|
|
unsigned char *buf = kzalloc(test->expectedlen, GFP_KERNEL);
|
|
|
|
|
|
|
|
if (!buf)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2016-11-22 20:08:31 +08:00
|
|
|
drng = crypto_alloc_rng(driver, type, mask);
|
2014-05-31 23:25:36 +08:00
|
|
|
if (IS_ERR(drng)) {
|
2014-07-30 03:47:56 +08:00
|
|
|
printk(KERN_ERR "alg: drbg: could not allocate DRNG handle for "
|
2014-05-31 23:25:36 +08:00
|
|
|
"%s\n", driver);
|
|
|
|
kzfree(buf);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
test_data.testentropy = &testentropy;
|
|
|
|
drbg_string_fill(&testentropy, test->entropy, test->entropylen);
|
|
|
|
drbg_string_fill(&pers, test->pers, test->perslen);
|
|
|
|
ret = crypto_drbg_reset_test(drng, &pers, &test_data);
|
|
|
|
if (ret) {
|
|
|
|
printk(KERN_ERR "alg: drbg: Failed to reset rng\n");
|
|
|
|
goto outbuf;
|
|
|
|
}
|
|
|
|
|
|
|
|
drbg_string_fill(&addtl, test->addtla, test->addtllen);
|
|
|
|
if (pr) {
|
|
|
|
drbg_string_fill(&testentropy, test->entpra, test->entprlen);
|
|
|
|
ret = crypto_drbg_get_bytes_addtl_test(drng,
|
|
|
|
buf, test->expectedlen, &addtl, &test_data);
|
|
|
|
} else {
|
|
|
|
ret = crypto_drbg_get_bytes_addtl(drng,
|
|
|
|
buf, test->expectedlen, &addtl);
|
|
|
|
}
|
2015-03-11 00:00:36 +08:00
|
|
|
if (ret < 0) {
|
2014-07-30 03:47:56 +08:00
|
|
|
printk(KERN_ERR "alg: drbg: could not obtain random data for "
|
2014-05-31 23:25:36 +08:00
|
|
|
"driver %s\n", driver);
|
|
|
|
goto outbuf;
|
|
|
|
}
|
|
|
|
|
|
|
|
drbg_string_fill(&addtl, test->addtlb, test->addtllen);
|
|
|
|
if (pr) {
|
|
|
|
drbg_string_fill(&testentropy, test->entprb, test->entprlen);
|
|
|
|
ret = crypto_drbg_get_bytes_addtl_test(drng,
|
|
|
|
buf, test->expectedlen, &addtl, &test_data);
|
|
|
|
} else {
|
|
|
|
ret = crypto_drbg_get_bytes_addtl(drng,
|
|
|
|
buf, test->expectedlen, &addtl);
|
|
|
|
}
|
2015-03-11 00:00:36 +08:00
|
|
|
if (ret < 0) {
|
2014-07-30 03:47:56 +08:00
|
|
|
printk(KERN_ERR "alg: drbg: could not obtain random data for "
|
2014-05-31 23:25:36 +08:00
|
|
|
"driver %s\n", driver);
|
|
|
|
goto outbuf;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = memcmp(test->expected, buf, test->expectedlen);
|
|
|
|
|
|
|
|
outbuf:
|
|
|
|
crypto_free_rng(drng);
|
|
|
|
kzfree(buf);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int alg_test_drbg(const struct alg_test_desc *desc, const char *driver,
|
|
|
|
u32 type, u32 mask)
|
|
|
|
{
|
|
|
|
int err = 0;
|
|
|
|
int pr = 0;
|
|
|
|
int i = 0;
|
2017-02-25 07:46:59 +08:00
|
|
|
const struct drbg_testvec *template = desc->suite.drbg.vecs;
|
2014-05-31 23:25:36 +08:00
|
|
|
unsigned int tcount = desc->suite.drbg.count;
|
|
|
|
|
|
|
|
if (0 == memcmp(driver, "drbg_pr_", 8))
|
|
|
|
pr = 1;
|
|
|
|
|
|
|
|
for (i = 0; i < tcount; i++) {
|
|
|
|
err = drbg_cavs_test(&template[i], pr, driver, type, mask);
|
|
|
|
if (err) {
|
|
|
|
printk(KERN_ERR "alg: drbg: Test %d failed for %s\n",
|
|
|
|
i, driver);
|
|
|
|
err = -EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return err;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2017-02-25 07:46:59 +08:00
|
|
|
static int do_test_kpp(struct crypto_kpp *tfm, const struct kpp_testvec *vec,
|
2016-06-23 00:49:14 +08:00
|
|
|
const char *alg)
|
|
|
|
{
|
|
|
|
struct kpp_request *req;
|
|
|
|
void *input_buf = NULL;
|
|
|
|
void *output_buf = NULL;
|
2017-05-30 22:52:49 +08:00
|
|
|
void *a_public = NULL;
|
|
|
|
void *a_ss = NULL;
|
|
|
|
void *shared_secret = NULL;
|
2017-10-18 15:00:43 +08:00
|
|
|
struct crypto_wait wait;
|
2016-06-23 00:49:14 +08:00
|
|
|
unsigned int out_len_max;
|
|
|
|
int err = -ENOMEM;
|
|
|
|
struct scatterlist src, dst;
|
|
|
|
|
|
|
|
req = kpp_request_alloc(tfm, GFP_KERNEL);
|
|
|
|
if (!req)
|
|
|
|
return err;
|
|
|
|
|
2017-10-18 15:00:43 +08:00
|
|
|
crypto_init_wait(&wait);
|
2016-06-23 00:49:14 +08:00
|
|
|
|
|
|
|
err = crypto_kpp_set_secret(tfm, vec->secret, vec->secret_size);
|
|
|
|
if (err < 0)
|
|
|
|
goto free_req;
|
|
|
|
|
|
|
|
out_len_max = crypto_kpp_maxsize(tfm);
|
|
|
|
output_buf = kzalloc(out_len_max, GFP_KERNEL);
|
|
|
|
if (!output_buf) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto free_req;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Use appropriate parameter as base */
|
|
|
|
kpp_request_set_input(req, NULL, 0);
|
|
|
|
sg_init_one(&dst, output_buf, out_len_max);
|
|
|
|
kpp_request_set_output(req, &dst, out_len_max);
|
|
|
|
kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
|
2017-10-18 15:00:43 +08:00
|
|
|
crypto_req_done, &wait);
|
2016-06-23 00:49:14 +08:00
|
|
|
|
2017-05-30 22:52:49 +08:00
|
|
|
/* Compute party A's public key */
|
2017-10-18 15:00:43 +08:00
|
|
|
err = crypto_wait_req(crypto_kpp_generate_public_key(req), &wait);
|
2016-06-23 00:49:14 +08:00
|
|
|
if (err) {
|
2017-05-30 22:52:49 +08:00
|
|
|
pr_err("alg: %s: Party A: generate public key test failed. err %d\n",
|
2016-06-23 00:49:14 +08:00
|
|
|
alg, err);
|
|
|
|
goto free_output;
|
|
|
|
}
|
2017-05-30 22:52:49 +08:00
|
|
|
|
|
|
|
if (vec->genkey) {
|
|
|
|
/* Save party A's public key */
|
|
|
|
a_public = kzalloc(out_len_max, GFP_KERNEL);
|
|
|
|
if (!a_public) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto free_output;
|
|
|
|
}
|
|
|
|
memcpy(a_public, sg_virt(req->dst), out_len_max);
|
|
|
|
} else {
|
|
|
|
/* Verify calculated public key */
|
|
|
|
if (memcmp(vec->expected_a_public, sg_virt(req->dst),
|
|
|
|
vec->expected_a_public_size)) {
|
|
|
|
pr_err("alg: %s: Party A: generate public key test failed. Invalid output\n",
|
|
|
|
alg);
|
|
|
|
err = -EINVAL;
|
|
|
|
goto free_output;
|
|
|
|
}
|
2016-06-23 00:49:14 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Calculate shared secret key by using counter part (b) public key. */
|
|
|
|
input_buf = kzalloc(vec->b_public_size, GFP_KERNEL);
|
|
|
|
if (!input_buf) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto free_output;
|
|
|
|
}
|
|
|
|
|
|
|
|
memcpy(input_buf, vec->b_public, vec->b_public_size);
|
|
|
|
sg_init_one(&src, input_buf, vec->b_public_size);
|
|
|
|
sg_init_one(&dst, output_buf, out_len_max);
|
|
|
|
kpp_request_set_input(req, &src, vec->b_public_size);
|
|
|
|
kpp_request_set_output(req, &dst, out_len_max);
|
|
|
|
kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
|
2017-10-18 15:00:43 +08:00
|
|
|
crypto_req_done, &wait);
|
|
|
|
err = crypto_wait_req(crypto_kpp_compute_shared_secret(req), &wait);
|
2016-06-23 00:49:14 +08:00
|
|
|
if (err) {
|
2017-05-30 22:52:49 +08:00
|
|
|
pr_err("alg: %s: Party A: compute shared secret test failed. err %d\n",
|
2016-06-23 00:49:14 +08:00
|
|
|
alg, err);
|
|
|
|
goto free_all;
|
|
|
|
}
|
2017-05-30 22:52:49 +08:00
|
|
|
|
|
|
|
if (vec->genkey) {
|
|
|
|
/* Save the shared secret obtained by party A */
|
|
|
|
a_ss = kzalloc(vec->expected_ss_size, GFP_KERNEL);
|
|
|
|
if (!a_ss) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto free_all;
|
|
|
|
}
|
|
|
|
memcpy(a_ss, sg_virt(req->dst), vec->expected_ss_size);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Calculate party B's shared secret by using party A's
|
|
|
|
* public key.
|
|
|
|
*/
|
|
|
|
err = crypto_kpp_set_secret(tfm, vec->b_secret,
|
|
|
|
vec->b_secret_size);
|
|
|
|
if (err < 0)
|
|
|
|
goto free_all;
|
|
|
|
|
|
|
|
sg_init_one(&src, a_public, vec->expected_a_public_size);
|
|
|
|
sg_init_one(&dst, output_buf, out_len_max);
|
|
|
|
kpp_request_set_input(req, &src, vec->expected_a_public_size);
|
|
|
|
kpp_request_set_output(req, &dst, out_len_max);
|
|
|
|
kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
|
2017-10-18 15:00:43 +08:00
|
|
|
crypto_req_done, &wait);
|
|
|
|
err = crypto_wait_req(crypto_kpp_compute_shared_secret(req),
|
|
|
|
&wait);
|
2017-05-30 22:52:49 +08:00
|
|
|
if (err) {
|
|
|
|
pr_err("alg: %s: Party B: compute shared secret failed. err %d\n",
|
|
|
|
alg, err);
|
|
|
|
goto free_all;
|
|
|
|
}
|
|
|
|
|
|
|
|
shared_secret = a_ss;
|
|
|
|
} else {
|
|
|
|
shared_secret = (void *)vec->expected_ss;
|
|
|
|
}
|
|
|
|
|
2016-06-23 00:49:14 +08:00
|
|
|
/*
|
|
|
|
* verify shared secret from which the user will derive
|
|
|
|
* secret key by executing whatever hash it has chosen
|
|
|
|
*/
|
2017-05-30 22:52:49 +08:00
|
|
|
if (memcmp(shared_secret, sg_virt(req->dst),
|
2016-06-23 00:49:14 +08:00
|
|
|
vec->expected_ss_size)) {
|
|
|
|
pr_err("alg: %s: compute shared secret test failed. Invalid output\n",
|
|
|
|
alg);
|
|
|
|
err = -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
free_all:
|
2017-05-30 22:52:49 +08:00
|
|
|
kfree(a_ss);
|
2016-06-23 00:49:14 +08:00
|
|
|
kfree(input_buf);
|
|
|
|
free_output:
|
2017-05-30 22:52:49 +08:00
|
|
|
kfree(a_public);
|
2016-06-23 00:49:14 +08:00
|
|
|
kfree(output_buf);
|
|
|
|
free_req:
|
|
|
|
kpp_request_free(req);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int test_kpp(struct crypto_kpp *tfm, const char *alg,
|
2017-02-25 07:46:59 +08:00
|
|
|
const struct kpp_testvec *vecs, unsigned int tcount)
|
2016-06-23 00:49:14 +08:00
|
|
|
{
|
|
|
|
int ret, i;
|
|
|
|
|
|
|
|
for (i = 0; i < tcount; i++) {
|
|
|
|
ret = do_test_kpp(tfm, vecs++, alg);
|
|
|
|
if (ret) {
|
|
|
|
pr_err("alg: %s: test failed on vector %d, err=%d\n",
|
|
|
|
alg, i + 1, ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int alg_test_kpp(const struct alg_test_desc *desc, const char *driver,
|
|
|
|
u32 type, u32 mask)
|
|
|
|
{
|
|
|
|
struct crypto_kpp *tfm;
|
|
|
|
int err = 0;
|
|
|
|
|
2016-11-22 20:08:31 +08:00
|
|
|
tfm = crypto_alloc_kpp(driver, type, mask);
|
2016-06-23 00:49:14 +08:00
|
|
|
if (IS_ERR(tfm)) {
|
|
|
|
pr_err("alg: kpp: Failed to load tfm for %s: %ld\n",
|
|
|
|
driver, PTR_ERR(tfm));
|
|
|
|
return PTR_ERR(tfm);
|
|
|
|
}
|
|
|
|
if (desc->suite.kpp.vecs)
|
|
|
|
err = test_kpp(tfm, desc->alg, desc->suite.kpp.vecs,
|
|
|
|
desc->suite.kpp.count);
|
|
|
|
|
|
|
|
crypto_free_kpp(tfm);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2016-06-29 19:32:20 +08:00
|
|
|
static int test_akcipher_one(struct crypto_akcipher *tfm,
|
2017-02-25 07:46:59 +08:00
|
|
|
const struct akcipher_testvec *vecs)
|
2015-06-17 01:31:06 +08:00
|
|
|
{
|
2016-05-05 16:42:49 +08:00
|
|
|
char *xbuf[XBUFSIZE];
|
2015-06-17 01:31:06 +08:00
|
|
|
struct akcipher_request *req;
|
|
|
|
void *outbuf_enc = NULL;
|
|
|
|
void *outbuf_dec = NULL;
|
2017-10-18 15:00:43 +08:00
|
|
|
struct crypto_wait wait;
|
2015-06-17 01:31:06 +08:00
|
|
|
unsigned int out_len_max, out_len = 0;
|
|
|
|
int err = -ENOMEM;
|
2015-10-09 00:26:55 +08:00
|
|
|
struct scatterlist src, dst, src_tab[2];
|
2015-06-17 01:31:06 +08:00
|
|
|
|
2016-05-05 16:42:49 +08:00
|
|
|
if (testmgr_alloc_buf(xbuf))
|
|
|
|
return err;
|
|
|
|
|
2015-06-17 01:31:06 +08:00
|
|
|
req = akcipher_request_alloc(tfm, GFP_KERNEL);
|
|
|
|
if (!req)
|
2016-05-05 16:42:49 +08:00
|
|
|
goto free_xbuf;
|
2015-06-17 01:31:06 +08:00
|
|
|
|
2017-10-18 15:00:43 +08:00
|
|
|
crypto_init_wait(&wait);
|
2015-06-17 01:31:06 +08:00
|
|
|
|
2015-10-09 00:26:55 +08:00
|
|
|
if (vecs->public_key_vec)
|
|
|
|
err = crypto_akcipher_set_pub_key(tfm, vecs->key,
|
|
|
|
vecs->key_len);
|
|
|
|
else
|
|
|
|
err = crypto_akcipher_set_priv_key(tfm, vecs->key,
|
|
|
|
vecs->key_len);
|
|
|
|
if (err)
|
2015-06-17 01:31:06 +08:00
|
|
|
goto free_req;
|
|
|
|
|
2016-07-04 17:52:34 +08:00
|
|
|
err = -ENOMEM;
|
2015-10-09 00:26:55 +08:00
|
|
|
out_len_max = crypto_akcipher_maxsize(tfm);
|
2015-06-17 01:31:06 +08:00
|
|
|
outbuf_enc = kzalloc(out_len_max, GFP_KERNEL);
|
|
|
|
if (!outbuf_enc)
|
|
|
|
goto free_req;
|
|
|
|
|
2016-05-05 16:42:49 +08:00
|
|
|
if (WARN_ON(vecs->m_size > PAGE_SIZE))
|
|
|
|
goto free_all;
|
|
|
|
|
|
|
|
memcpy(xbuf[0], vecs->m, vecs->m_size);
|
|
|
|
|
2015-10-09 00:26:55 +08:00
|
|
|
sg_init_table(src_tab, 2);
|
2016-05-05 16:42:49 +08:00
|
|
|
sg_set_buf(&src_tab[0], xbuf[0], 8);
|
|
|
|
sg_set_buf(&src_tab[1], xbuf[0] + 8, vecs->m_size - 8);
|
2015-10-09 00:26:55 +08:00
|
|
|
sg_init_one(&dst, outbuf_enc, out_len_max);
|
|
|
|
akcipher_request_set_crypt(req, src_tab, &dst, vecs->m_size,
|
|
|
|
out_len_max);
|
2015-06-17 01:31:06 +08:00
|
|
|
akcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
|
2017-10-18 15:00:43 +08:00
|
|
|
crypto_req_done, &wait);
|
2015-06-17 01:31:06 +08:00
|
|
|
|
2017-10-18 15:00:43 +08:00
|
|
|
err = crypto_wait_req(vecs->siggen_sigver_test ?
|
|
|
|
/* Run asymmetric signature generation */
|
|
|
|
crypto_akcipher_sign(req) :
|
|
|
|
/* Run asymmetric encrypt */
|
|
|
|
crypto_akcipher_encrypt(req), &wait);
|
2015-06-17 01:31:06 +08:00
|
|
|
if (err) {
|
2016-06-29 19:32:20 +08:00
|
|
|
pr_err("alg: akcipher: encrypt test failed. err %d\n", err);
|
2015-06-17 01:31:06 +08:00
|
|
|
goto free_all;
|
|
|
|
}
|
2015-10-09 00:26:55 +08:00
|
|
|
if (req->dst_len != vecs->c_size) {
|
2016-06-29 19:32:20 +08:00
|
|
|
pr_err("alg: akcipher: encrypt test failed. Invalid output len\n");
|
2015-06-17 01:31:06 +08:00
|
|
|
err = -EINVAL;
|
|
|
|
goto free_all;
|
|
|
|
}
|
|
|
|
/* verify that encrypted message is equal to expected */
|
2016-05-05 16:42:49 +08:00
|
|
|
if (memcmp(vecs->c, outbuf_enc, vecs->c_size)) {
|
2016-06-29 19:32:20 +08:00
|
|
|
pr_err("alg: akcipher: encrypt test failed. Invalid output\n");
|
|
|
|
hexdump(outbuf_enc, vecs->c_size);
|
2015-06-17 01:31:06 +08:00
|
|
|
err = -EINVAL;
|
|
|
|
goto free_all;
|
|
|
|
}
|
|
|
|
/* Don't invoke decrypt for vectors with public key */
|
|
|
|
if (vecs->public_key_vec) {
|
|
|
|
err = 0;
|
|
|
|
goto free_all;
|
|
|
|
}
|
|
|
|
outbuf_dec = kzalloc(out_len_max, GFP_KERNEL);
|
|
|
|
if (!outbuf_dec) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto free_all;
|
|
|
|
}
|
2016-05-05 16:42:49 +08:00
|
|
|
|
|
|
|
if (WARN_ON(vecs->c_size > PAGE_SIZE))
|
|
|
|
goto free_all;
|
|
|
|
|
|
|
|
memcpy(xbuf[0], vecs->c, vecs->c_size);
|
|
|
|
|
|
|
|
sg_init_one(&src, xbuf[0], vecs->c_size);
|
2015-10-09 00:26:55 +08:00
|
|
|
sg_init_one(&dst, outbuf_dec, out_len_max);
|
2017-10-18 15:00:43 +08:00
|
|
|
crypto_init_wait(&wait);
|
2015-10-09 00:26:55 +08:00
|
|
|
akcipher_request_set_crypt(req, &src, &dst, vecs->c_size, out_len_max);
|
2015-06-17 01:31:06 +08:00
|
|
|
|
2017-10-18 15:00:43 +08:00
|
|
|
err = crypto_wait_req(vecs->siggen_sigver_test ?
|
|
|
|
/* Run asymmetric signature verification */
|
|
|
|
crypto_akcipher_verify(req) :
|
|
|
|
/* Run asymmetric decrypt */
|
|
|
|
crypto_akcipher_decrypt(req), &wait);
|
2015-06-17 01:31:06 +08:00
|
|
|
if (err) {
|
2016-06-29 19:32:20 +08:00
|
|
|
pr_err("alg: akcipher: decrypt test failed. err %d\n", err);
|
2015-06-17 01:31:06 +08:00
|
|
|
goto free_all;
|
|
|
|
}
|
|
|
|
out_len = req->dst_len;
|
2016-06-29 19:32:20 +08:00
|
|
|
if (out_len < vecs->m_size) {
|
|
|
|
pr_err("alg: akcipher: decrypt test failed. "
|
|
|
|
"Invalid output len %u\n", out_len);
|
2015-06-17 01:31:06 +08:00
|
|
|
err = -EINVAL;
|
|
|
|
goto free_all;
|
|
|
|
}
|
|
|
|
/* verify that decrypted message is equal to the original msg */
|
2016-06-29 19:32:20 +08:00
|
|
|
if (memchr_inv(outbuf_dec, 0, out_len - vecs->m_size) ||
|
|
|
|
memcmp(vecs->m, outbuf_dec + out_len - vecs->m_size,
|
|
|
|
vecs->m_size)) {
|
|
|
|
pr_err("alg: akcipher: decrypt test failed. Invalid output\n");
|
|
|
|
hexdump(outbuf_dec, out_len);
|
2015-06-17 01:31:06 +08:00
|
|
|
err = -EINVAL;
|
|
|
|
}
|
|
|
|
free_all:
|
|
|
|
kfree(outbuf_dec);
|
|
|
|
kfree(outbuf_enc);
|
|
|
|
free_req:
|
|
|
|
akcipher_request_free(req);
|
2016-05-05 16:42:49 +08:00
|
|
|
free_xbuf:
|
|
|
|
testmgr_free_buf(xbuf);
|
2015-06-17 01:31:06 +08:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2016-06-29 19:32:20 +08:00
|
|
|
static int test_akcipher(struct crypto_akcipher *tfm, const char *alg,
|
2017-02-25 07:46:59 +08:00
|
|
|
const struct akcipher_testvec *vecs,
|
|
|
|
unsigned int tcount)
|
2015-06-17 01:31:06 +08:00
|
|
|
{
|
2016-07-18 18:20:10 +08:00
|
|
|
const char *algo =
|
|
|
|
crypto_tfm_alg_driver_name(crypto_akcipher_tfm(tfm));
|
2015-06-17 01:31:06 +08:00
|
|
|
int ret, i;
|
|
|
|
|
|
|
|
for (i = 0; i < tcount; i++) {
|
2016-06-29 19:32:20 +08:00
|
|
|
ret = test_akcipher_one(tfm, vecs++);
|
|
|
|
if (!ret)
|
|
|
|
continue;
|
2015-06-17 01:31:06 +08:00
|
|
|
|
2016-07-18 18:20:10 +08:00
|
|
|
pr_err("alg: akcipher: test %d failed for %s, err=%d\n",
|
|
|
|
i + 1, algo, ret);
|
2016-06-29 19:32:20 +08:00
|
|
|
return ret;
|
|
|
|
}
|
2015-06-17 01:31:06 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int alg_test_akcipher(const struct alg_test_desc *desc,
|
|
|
|
const char *driver, u32 type, u32 mask)
|
|
|
|
{
|
|
|
|
struct crypto_akcipher *tfm;
|
|
|
|
int err = 0;
|
|
|
|
|
2016-11-22 20:08:31 +08:00
|
|
|
tfm = crypto_alloc_akcipher(driver, type, mask);
|
2015-06-17 01:31:06 +08:00
|
|
|
if (IS_ERR(tfm)) {
|
|
|
|
pr_err("alg: akcipher: Failed to load tfm for %s: %ld\n",
|
|
|
|
driver, PTR_ERR(tfm));
|
|
|
|
return PTR_ERR(tfm);
|
|
|
|
}
|
|
|
|
if (desc->suite.akcipher.vecs)
|
|
|
|
err = test_akcipher(tfm, desc->alg, desc->suite.akcipher.vecs,
|
|
|
|
desc->suite.akcipher.count);
|
|
|
|
|
|
|
|
crypto_free_akcipher(tfm);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2009-12-23 19:45:20 +08:00
|
|
|
static int alg_test_null(const struct alg_test_desc *desc,
|
|
|
|
const char *driver, u32 type, u32 mask)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-01-12 21:40:39 +08:00
|
|
|
#define __VECS(tv) { .vecs = tv, .count = ARRAY_SIZE(tv) }
|
|
|
|
|
2008-07-31 17:08:25 +08:00
|
|
|
/* Please keep this list sorted by algorithm name. */
|
|
|
|
static const struct alg_test_desc alg_test_descs[] = {
|
|
|
|
{
|
2018-05-11 20:12:50 +08:00
|
|
|
.alg = "aegis128",
|
|
|
|
.test = alg_test_aead,
|
|
|
|
.suite = {
|
|
|
|
.aead = {
|
|
|
|
.enc = __VECS(aegis128_enc_tv_template),
|
|
|
|
.dec = __VECS(aegis128_dec_tv_template),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "aegis128l",
|
|
|
|
.test = alg_test_aead,
|
|
|
|
.suite = {
|
|
|
|
.aead = {
|
|
|
|
.enc = __VECS(aegis128l_enc_tv_template),
|
|
|
|
.dec = __VECS(aegis128l_dec_tv_template),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "aegis256",
|
|
|
|
.test = alg_test_aead,
|
|
|
|
.suite = {
|
|
|
|
.aead = {
|
|
|
|
.enc = __VECS(aegis256_enc_tv_template),
|
|
|
|
.dec = __VECS(aegis256_dec_tv_template),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}, {
|
2009-05-04 19:46:29 +08:00
|
|
|
.alg = "ansi_cprng",
|
|
|
|
.test = alg_test_cprng,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.cprng = __VECS(ansi_cprng_aes_tv_template)
|
2009-05-04 19:46:29 +08:00
|
|
|
}
|
2014-03-14 23:46:51 +08:00
|
|
|
}, {
|
|
|
|
.alg = "authenc(hmac(md5),ecb(cipher_null))",
|
|
|
|
.test = alg_test_aead,
|
|
|
|
.suite = {
|
|
|
|
.aead = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(hmac_md5_ecb_cipher_null_enc_tv_template),
|
|
|
|
.dec = __VECS(hmac_md5_ecb_cipher_null_dec_tv_template)
|
2014-03-14 23:46:51 +08:00
|
|
|
}
|
|
|
|
}
|
2012-07-04 00:16:54 +08:00
|
|
|
}, {
|
2015-07-30 17:53:23 +08:00
|
|
|
.alg = "authenc(hmac(sha1),cbc(aes))",
|
2012-07-04 00:16:54 +08:00
|
|
|
.test = alg_test_aead,
|
2017-06-28 19:09:07 +08:00
|
|
|
.fips_allowed = 1,
|
2012-07-04 00:16:54 +08:00
|
|
|
.suite = {
|
|
|
|
.aead = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(hmac_sha1_aes_cbc_enc_tv_temp)
|
crypto: testmgr - add aead cbc des, des3_ede tests
Test vectors were taken from existing test for
CBC(DES3_EDE). Associated data has been added to test vectors.
HMAC computed with Crypto++ has been used. Following algos have
been covered.
(a) "authenc(hmac(sha1),cbc(des))"
(b) "authenc(hmac(sha1),cbc(des3_ede))"
(c) "authenc(hmac(sha224),cbc(des))"
(d) "authenc(hmac(sha224),cbc(des3_ede))"
(e) "authenc(hmac(sha256),cbc(des))"
(f) "authenc(hmac(sha256),cbc(des3_ede))"
(g) "authenc(hmac(sha384),cbc(des))"
(h) "authenc(hmac(sha384),cbc(des3_ede))"
(i) "authenc(hmac(sha512),cbc(des))"
(j) "authenc(hmac(sha512),cbc(des3_ede))"
Signed-off-by: Vakul Garg <vakul@freescale.com>
[NiteshNarayanLal@freescale.com: added hooks for the missing algorithms test and tested the patch]
Signed-off-by: Nitesh Lal <NiteshNarayanLal@freescale.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2014-05-21 19:39:08 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}, {
|
2015-07-30 17:53:23 +08:00
|
|
|
.alg = "authenc(hmac(sha1),cbc(des))",
|
crypto: testmgr - add aead cbc des, des3_ede tests
Test vectors were taken from existing test for
CBC(DES3_EDE). Associated data has been added to test vectors.
HMAC computed with Crypto++ has been used. Following algos have
been covered.
(a) "authenc(hmac(sha1),cbc(des))"
(b) "authenc(hmac(sha1),cbc(des3_ede))"
(c) "authenc(hmac(sha224),cbc(des))"
(d) "authenc(hmac(sha224),cbc(des3_ede))"
(e) "authenc(hmac(sha256),cbc(des))"
(f) "authenc(hmac(sha256),cbc(des3_ede))"
(g) "authenc(hmac(sha384),cbc(des))"
(h) "authenc(hmac(sha384),cbc(des3_ede))"
(i) "authenc(hmac(sha512),cbc(des))"
(j) "authenc(hmac(sha512),cbc(des3_ede))"
Signed-off-by: Vakul Garg <vakul@freescale.com>
[NiteshNarayanLal@freescale.com: added hooks for the missing algorithms test and tested the patch]
Signed-off-by: Nitesh Lal <NiteshNarayanLal@freescale.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2014-05-21 19:39:08 +08:00
|
|
|
.test = alg_test_aead,
|
|
|
|
.suite = {
|
|
|
|
.aead = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(hmac_sha1_des_cbc_enc_tv_temp)
|
crypto: testmgr - add aead cbc des, des3_ede tests
Test vectors were taken from existing test for
CBC(DES3_EDE). Associated data has been added to test vectors.
HMAC computed with Crypto++ has been used. Following algos have
been covered.
(a) "authenc(hmac(sha1),cbc(des))"
(b) "authenc(hmac(sha1),cbc(des3_ede))"
(c) "authenc(hmac(sha224),cbc(des))"
(d) "authenc(hmac(sha224),cbc(des3_ede))"
(e) "authenc(hmac(sha256),cbc(des))"
(f) "authenc(hmac(sha256),cbc(des3_ede))"
(g) "authenc(hmac(sha384),cbc(des))"
(h) "authenc(hmac(sha384),cbc(des3_ede))"
(i) "authenc(hmac(sha512),cbc(des))"
(j) "authenc(hmac(sha512),cbc(des3_ede))"
Signed-off-by: Vakul Garg <vakul@freescale.com>
[NiteshNarayanLal@freescale.com: added hooks for the missing algorithms test and tested the patch]
Signed-off-by: Nitesh Lal <NiteshNarayanLal@freescale.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2014-05-21 19:39:08 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}, {
|
2015-07-30 17:53:23 +08:00
|
|
|
.alg = "authenc(hmac(sha1),cbc(des3_ede))",
|
crypto: testmgr - add aead cbc des, des3_ede tests
Test vectors were taken from existing test for
CBC(DES3_EDE). Associated data has been added to test vectors.
HMAC computed with Crypto++ has been used. Following algos have
been covered.
(a) "authenc(hmac(sha1),cbc(des))"
(b) "authenc(hmac(sha1),cbc(des3_ede))"
(c) "authenc(hmac(sha224),cbc(des))"
(d) "authenc(hmac(sha224),cbc(des3_ede))"
(e) "authenc(hmac(sha256),cbc(des))"
(f) "authenc(hmac(sha256),cbc(des3_ede))"
(g) "authenc(hmac(sha384),cbc(des))"
(h) "authenc(hmac(sha384),cbc(des3_ede))"
(i) "authenc(hmac(sha512),cbc(des))"
(j) "authenc(hmac(sha512),cbc(des3_ede))"
Signed-off-by: Vakul Garg <vakul@freescale.com>
[NiteshNarayanLal@freescale.com: added hooks for the missing algorithms test and tested the patch]
Signed-off-by: Nitesh Lal <NiteshNarayanLal@freescale.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2014-05-21 19:39:08 +08:00
|
|
|
.test = alg_test_aead,
|
2016-02-05 21:23:33 +08:00
|
|
|
.fips_allowed = 1,
|
crypto: testmgr - add aead cbc des, des3_ede tests
Test vectors were taken from existing test for
CBC(DES3_EDE). Associated data has been added to test vectors.
HMAC computed with Crypto++ has been used. Following algos have
been covered.
(a) "authenc(hmac(sha1),cbc(des))"
(b) "authenc(hmac(sha1),cbc(des3_ede))"
(c) "authenc(hmac(sha224),cbc(des))"
(d) "authenc(hmac(sha224),cbc(des3_ede))"
(e) "authenc(hmac(sha256),cbc(des))"
(f) "authenc(hmac(sha256),cbc(des3_ede))"
(g) "authenc(hmac(sha384),cbc(des))"
(h) "authenc(hmac(sha384),cbc(des3_ede))"
(i) "authenc(hmac(sha512),cbc(des))"
(j) "authenc(hmac(sha512),cbc(des3_ede))"
Signed-off-by: Vakul Garg <vakul@freescale.com>
[NiteshNarayanLal@freescale.com: added hooks for the missing algorithms test and tested the patch]
Signed-off-by: Nitesh Lal <NiteshNarayanLal@freescale.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2014-05-21 19:39:08 +08:00
|
|
|
.suite = {
|
|
|
|
.aead = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(hmac_sha1_des3_ede_cbc_enc_tv_temp)
|
2012-07-04 00:16:54 +08:00
|
|
|
}
|
|
|
|
}
|
2016-02-06 18:53:07 +08:00
|
|
|
}, {
|
|
|
|
.alg = "authenc(hmac(sha1),ctr(aes))",
|
|
|
|
.test = alg_test_null,
|
|
|
|
.fips_allowed = 1,
|
2014-03-14 23:46:51 +08:00
|
|
|
}, {
|
|
|
|
.alg = "authenc(hmac(sha1),ecb(cipher_null))",
|
|
|
|
.test = alg_test_aead,
|
|
|
|
.suite = {
|
|
|
|
.aead = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(hmac_sha1_ecb_cipher_null_enc_tv_temp),
|
|
|
|
.dec = __VECS(hmac_sha1_ecb_cipher_null_dec_tv_temp)
|
crypto: testmgr - add aead cbc des, des3_ede tests
Test vectors were taken from existing test for
CBC(DES3_EDE). Associated data has been added to test vectors.
HMAC computed with Crypto++ has been used. Following algos have
been covered.
(a) "authenc(hmac(sha1),cbc(des))"
(b) "authenc(hmac(sha1),cbc(des3_ede))"
(c) "authenc(hmac(sha224),cbc(des))"
(d) "authenc(hmac(sha224),cbc(des3_ede))"
(e) "authenc(hmac(sha256),cbc(des))"
(f) "authenc(hmac(sha256),cbc(des3_ede))"
(g) "authenc(hmac(sha384),cbc(des))"
(h) "authenc(hmac(sha384),cbc(des3_ede))"
(i) "authenc(hmac(sha512),cbc(des))"
(j) "authenc(hmac(sha512),cbc(des3_ede))"
Signed-off-by: Vakul Garg <vakul@freescale.com>
[NiteshNarayanLal@freescale.com: added hooks for the missing algorithms test and tested the patch]
Signed-off-by: Nitesh Lal <NiteshNarayanLal@freescale.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2014-05-21 19:39:08 +08:00
|
|
|
}
|
|
|
|
}
|
2016-02-19 20:34:28 +08:00
|
|
|
}, {
|
|
|
|
.alg = "authenc(hmac(sha1),rfc3686(ctr(aes)))",
|
|
|
|
.test = alg_test_null,
|
|
|
|
.fips_allowed = 1,
|
crypto: testmgr - add aead cbc des, des3_ede tests
Test vectors were taken from existing test for
CBC(DES3_EDE). Associated data has been added to test vectors.
HMAC computed with Crypto++ has been used. Following algos have
been covered.
(a) "authenc(hmac(sha1),cbc(des))"
(b) "authenc(hmac(sha1),cbc(des3_ede))"
(c) "authenc(hmac(sha224),cbc(des))"
(d) "authenc(hmac(sha224),cbc(des3_ede))"
(e) "authenc(hmac(sha256),cbc(des))"
(f) "authenc(hmac(sha256),cbc(des3_ede))"
(g) "authenc(hmac(sha384),cbc(des))"
(h) "authenc(hmac(sha384),cbc(des3_ede))"
(i) "authenc(hmac(sha512),cbc(des))"
(j) "authenc(hmac(sha512),cbc(des3_ede))"
Signed-off-by: Vakul Garg <vakul@freescale.com>
[NiteshNarayanLal@freescale.com: added hooks for the missing algorithms test and tested the patch]
Signed-off-by: Nitesh Lal <NiteshNarayanLal@freescale.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2014-05-21 19:39:08 +08:00
|
|
|
}, {
|
2015-07-30 17:53:23 +08:00
|
|
|
.alg = "authenc(hmac(sha224),cbc(des))",
|
crypto: testmgr - add aead cbc des, des3_ede tests
Test vectors were taken from existing test for
CBC(DES3_EDE). Associated data has been added to test vectors.
HMAC computed with Crypto++ has been used. Following algos have
been covered.
(a) "authenc(hmac(sha1),cbc(des))"
(b) "authenc(hmac(sha1),cbc(des3_ede))"
(c) "authenc(hmac(sha224),cbc(des))"
(d) "authenc(hmac(sha224),cbc(des3_ede))"
(e) "authenc(hmac(sha256),cbc(des))"
(f) "authenc(hmac(sha256),cbc(des3_ede))"
(g) "authenc(hmac(sha384),cbc(des))"
(h) "authenc(hmac(sha384),cbc(des3_ede))"
(i) "authenc(hmac(sha512),cbc(des))"
(j) "authenc(hmac(sha512),cbc(des3_ede))"
Signed-off-by: Vakul Garg <vakul@freescale.com>
[NiteshNarayanLal@freescale.com: added hooks for the missing algorithms test and tested the patch]
Signed-off-by: Nitesh Lal <NiteshNarayanLal@freescale.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2014-05-21 19:39:08 +08:00
|
|
|
.test = alg_test_aead,
|
|
|
|
.suite = {
|
|
|
|
.aead = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(hmac_sha224_des_cbc_enc_tv_temp)
|
crypto: testmgr - add aead cbc des, des3_ede tests
Test vectors were taken from existing test for
CBC(DES3_EDE). Associated data has been added to test vectors.
HMAC computed with Crypto++ has been used. Following algos have
been covered.
(a) "authenc(hmac(sha1),cbc(des))"
(b) "authenc(hmac(sha1),cbc(des3_ede))"
(c) "authenc(hmac(sha224),cbc(des))"
(d) "authenc(hmac(sha224),cbc(des3_ede))"
(e) "authenc(hmac(sha256),cbc(des))"
(f) "authenc(hmac(sha256),cbc(des3_ede))"
(g) "authenc(hmac(sha384),cbc(des))"
(h) "authenc(hmac(sha384),cbc(des3_ede))"
(i) "authenc(hmac(sha512),cbc(des))"
(j) "authenc(hmac(sha512),cbc(des3_ede))"
Signed-off-by: Vakul Garg <vakul@freescale.com>
[NiteshNarayanLal@freescale.com: added hooks for the missing algorithms test and tested the patch]
Signed-off-by: Nitesh Lal <NiteshNarayanLal@freescale.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2014-05-21 19:39:08 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}, {
|
2015-07-30 17:53:23 +08:00
|
|
|
.alg = "authenc(hmac(sha224),cbc(des3_ede))",
|
crypto: testmgr - add aead cbc des, des3_ede tests
Test vectors were taken from existing test for
CBC(DES3_EDE). Associated data has been added to test vectors.
HMAC computed with Crypto++ has been used. Following algos have
been covered.
(a) "authenc(hmac(sha1),cbc(des))"
(b) "authenc(hmac(sha1),cbc(des3_ede))"
(c) "authenc(hmac(sha224),cbc(des))"
(d) "authenc(hmac(sha224),cbc(des3_ede))"
(e) "authenc(hmac(sha256),cbc(des))"
(f) "authenc(hmac(sha256),cbc(des3_ede))"
(g) "authenc(hmac(sha384),cbc(des))"
(h) "authenc(hmac(sha384),cbc(des3_ede))"
(i) "authenc(hmac(sha512),cbc(des))"
(j) "authenc(hmac(sha512),cbc(des3_ede))"
Signed-off-by: Vakul Garg <vakul@freescale.com>
[NiteshNarayanLal@freescale.com: added hooks for the missing algorithms test and tested the patch]
Signed-off-by: Nitesh Lal <NiteshNarayanLal@freescale.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2014-05-21 19:39:08 +08:00
|
|
|
.test = alg_test_aead,
|
2016-02-05 21:23:33 +08:00
|
|
|
.fips_allowed = 1,
|
crypto: testmgr - add aead cbc des, des3_ede tests
Test vectors were taken from existing test for
CBC(DES3_EDE). Associated data has been added to test vectors.
HMAC computed with Crypto++ has been used. Following algos have
been covered.
(a) "authenc(hmac(sha1),cbc(des))"
(b) "authenc(hmac(sha1),cbc(des3_ede))"
(c) "authenc(hmac(sha224),cbc(des))"
(d) "authenc(hmac(sha224),cbc(des3_ede))"
(e) "authenc(hmac(sha256),cbc(des))"
(f) "authenc(hmac(sha256),cbc(des3_ede))"
(g) "authenc(hmac(sha384),cbc(des))"
(h) "authenc(hmac(sha384),cbc(des3_ede))"
(i) "authenc(hmac(sha512),cbc(des))"
(j) "authenc(hmac(sha512),cbc(des3_ede))"
Signed-off-by: Vakul Garg <vakul@freescale.com>
[NiteshNarayanLal@freescale.com: added hooks for the missing algorithms test and tested the patch]
Signed-off-by: Nitesh Lal <NiteshNarayanLal@freescale.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2014-05-21 19:39:08 +08:00
|
|
|
.suite = {
|
|
|
|
.aead = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(hmac_sha224_des3_ede_cbc_enc_tv_temp)
|
2014-03-14 23:46:51 +08:00
|
|
|
}
|
|
|
|
}
|
2012-07-04 00:16:54 +08:00
|
|
|
}, {
|
2015-07-30 17:53:23 +08:00
|
|
|
.alg = "authenc(hmac(sha256),cbc(aes))",
|
2012-07-04 00:16:54 +08:00
|
|
|
.test = alg_test_aead,
|
2016-02-05 21:23:33 +08:00
|
|
|
.fips_allowed = 1,
|
2012-07-04 00:16:54 +08:00
|
|
|
.suite = {
|
|
|
|
.aead = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(hmac_sha256_aes_cbc_enc_tv_temp)
|
crypto: testmgr - add aead cbc des, des3_ede tests
Test vectors were taken from existing test for
CBC(DES3_EDE). Associated data has been added to test vectors.
HMAC computed with Crypto++ has been used. Following algos have
been covered.
(a) "authenc(hmac(sha1),cbc(des))"
(b) "authenc(hmac(sha1),cbc(des3_ede))"
(c) "authenc(hmac(sha224),cbc(des))"
(d) "authenc(hmac(sha224),cbc(des3_ede))"
(e) "authenc(hmac(sha256),cbc(des))"
(f) "authenc(hmac(sha256),cbc(des3_ede))"
(g) "authenc(hmac(sha384),cbc(des))"
(h) "authenc(hmac(sha384),cbc(des3_ede))"
(i) "authenc(hmac(sha512),cbc(des))"
(j) "authenc(hmac(sha512),cbc(des3_ede))"
Signed-off-by: Vakul Garg <vakul@freescale.com>
[NiteshNarayanLal@freescale.com: added hooks for the missing algorithms test and tested the patch]
Signed-off-by: Nitesh Lal <NiteshNarayanLal@freescale.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2014-05-21 19:39:08 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}, {
|
2015-07-30 17:53:23 +08:00
|
|
|
.alg = "authenc(hmac(sha256),cbc(des))",
|
crypto: testmgr - add aead cbc des, des3_ede tests
Test vectors were taken from existing test for
CBC(DES3_EDE). Associated data has been added to test vectors.
HMAC computed with Crypto++ has been used. Following algos have
been covered.
(a) "authenc(hmac(sha1),cbc(des))"
(b) "authenc(hmac(sha1),cbc(des3_ede))"
(c) "authenc(hmac(sha224),cbc(des))"
(d) "authenc(hmac(sha224),cbc(des3_ede))"
(e) "authenc(hmac(sha256),cbc(des))"
(f) "authenc(hmac(sha256),cbc(des3_ede))"
(g) "authenc(hmac(sha384),cbc(des))"
(h) "authenc(hmac(sha384),cbc(des3_ede))"
(i) "authenc(hmac(sha512),cbc(des))"
(j) "authenc(hmac(sha512),cbc(des3_ede))"
Signed-off-by: Vakul Garg <vakul@freescale.com>
[NiteshNarayanLal@freescale.com: added hooks for the missing algorithms test and tested the patch]
Signed-off-by: Nitesh Lal <NiteshNarayanLal@freescale.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2014-05-21 19:39:08 +08:00
|
|
|
.test = alg_test_aead,
|
|
|
|
.suite = {
|
|
|
|
.aead = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(hmac_sha256_des_cbc_enc_tv_temp)
|
crypto: testmgr - add aead cbc des, des3_ede tests
Test vectors were taken from existing test for
CBC(DES3_EDE). Associated data has been added to test vectors.
HMAC computed with Crypto++ has been used. Following algos have
been covered.
(a) "authenc(hmac(sha1),cbc(des))"
(b) "authenc(hmac(sha1),cbc(des3_ede))"
(c) "authenc(hmac(sha224),cbc(des))"
(d) "authenc(hmac(sha224),cbc(des3_ede))"
(e) "authenc(hmac(sha256),cbc(des))"
(f) "authenc(hmac(sha256),cbc(des3_ede))"
(g) "authenc(hmac(sha384),cbc(des))"
(h) "authenc(hmac(sha384),cbc(des3_ede))"
(i) "authenc(hmac(sha512),cbc(des))"
(j) "authenc(hmac(sha512),cbc(des3_ede))"
Signed-off-by: Vakul Garg <vakul@freescale.com>
[NiteshNarayanLal@freescale.com: added hooks for the missing algorithms test and tested the patch]
Signed-off-by: Nitesh Lal <NiteshNarayanLal@freescale.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2014-05-21 19:39:08 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}, {
|
2015-07-30 17:53:23 +08:00
|
|
|
.alg = "authenc(hmac(sha256),cbc(des3_ede))",
|
crypto: testmgr - add aead cbc des, des3_ede tests
Test vectors were taken from existing test for
CBC(DES3_EDE). Associated data has been added to test vectors.
HMAC computed with Crypto++ has been used. Following algos have
been covered.
(a) "authenc(hmac(sha1),cbc(des))"
(b) "authenc(hmac(sha1),cbc(des3_ede))"
(c) "authenc(hmac(sha224),cbc(des))"
(d) "authenc(hmac(sha224),cbc(des3_ede))"
(e) "authenc(hmac(sha256),cbc(des))"
(f) "authenc(hmac(sha256),cbc(des3_ede))"
(g) "authenc(hmac(sha384),cbc(des))"
(h) "authenc(hmac(sha384),cbc(des3_ede))"
(i) "authenc(hmac(sha512),cbc(des))"
(j) "authenc(hmac(sha512),cbc(des3_ede))"
Signed-off-by: Vakul Garg <vakul@freescale.com>
[NiteshNarayanLal@freescale.com: added hooks for the missing algorithms test and tested the patch]
Signed-off-by: Nitesh Lal <NiteshNarayanLal@freescale.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2014-05-21 19:39:08 +08:00
|
|
|
.test = alg_test_aead,
|
2016-02-05 21:23:33 +08:00
|
|
|
.fips_allowed = 1,
|
crypto: testmgr - add aead cbc des, des3_ede tests
Test vectors were taken from existing test for
CBC(DES3_EDE). Associated data has been added to test vectors.
HMAC computed with Crypto++ has been used. Following algos have
been covered.
(a) "authenc(hmac(sha1),cbc(des))"
(b) "authenc(hmac(sha1),cbc(des3_ede))"
(c) "authenc(hmac(sha224),cbc(des))"
(d) "authenc(hmac(sha224),cbc(des3_ede))"
(e) "authenc(hmac(sha256),cbc(des))"
(f) "authenc(hmac(sha256),cbc(des3_ede))"
(g) "authenc(hmac(sha384),cbc(des))"
(h) "authenc(hmac(sha384),cbc(des3_ede))"
(i) "authenc(hmac(sha512),cbc(des))"
(j) "authenc(hmac(sha512),cbc(des3_ede))"
Signed-off-by: Vakul Garg <vakul@freescale.com>
[NiteshNarayanLal@freescale.com: added hooks for the missing algorithms test and tested the patch]
Signed-off-by: Nitesh Lal <NiteshNarayanLal@freescale.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2014-05-21 19:39:08 +08:00
|
|
|
.suite = {
|
|
|
|
.aead = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(hmac_sha256_des3_ede_cbc_enc_tv_temp)
|
crypto: testmgr - add aead cbc des, des3_ede tests
Test vectors were taken from existing test for
CBC(DES3_EDE). Associated data has been added to test vectors.
HMAC computed with Crypto++ has been used. Following algos have
been covered.
(a) "authenc(hmac(sha1),cbc(des))"
(b) "authenc(hmac(sha1),cbc(des3_ede))"
(c) "authenc(hmac(sha224),cbc(des))"
(d) "authenc(hmac(sha224),cbc(des3_ede))"
(e) "authenc(hmac(sha256),cbc(des))"
(f) "authenc(hmac(sha256),cbc(des3_ede))"
(g) "authenc(hmac(sha384),cbc(des))"
(h) "authenc(hmac(sha384),cbc(des3_ede))"
(i) "authenc(hmac(sha512),cbc(des))"
(j) "authenc(hmac(sha512),cbc(des3_ede))"
Signed-off-by: Vakul Garg <vakul@freescale.com>
[NiteshNarayanLal@freescale.com: added hooks for the missing algorithms test and tested the patch]
Signed-off-by: Nitesh Lal <NiteshNarayanLal@freescale.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2014-05-21 19:39:08 +08:00
|
|
|
}
|
|
|
|
}
|
2016-02-06 18:53:07 +08:00
|
|
|
}, {
|
|
|
|
.alg = "authenc(hmac(sha256),ctr(aes))",
|
|
|
|
.test = alg_test_null,
|
|
|
|
.fips_allowed = 1,
|
2016-02-19 20:34:28 +08:00
|
|
|
}, {
|
|
|
|
.alg = "authenc(hmac(sha256),rfc3686(ctr(aes)))",
|
|
|
|
.test = alg_test_null,
|
|
|
|
.fips_allowed = 1,
|
crypto: testmgr - add aead cbc des, des3_ede tests
Test vectors were taken from existing test for
CBC(DES3_EDE). Associated data has been added to test vectors.
HMAC computed with Crypto++ has been used. Following algos have
been covered.
(a) "authenc(hmac(sha1),cbc(des))"
(b) "authenc(hmac(sha1),cbc(des3_ede))"
(c) "authenc(hmac(sha224),cbc(des))"
(d) "authenc(hmac(sha224),cbc(des3_ede))"
(e) "authenc(hmac(sha256),cbc(des))"
(f) "authenc(hmac(sha256),cbc(des3_ede))"
(g) "authenc(hmac(sha384),cbc(des))"
(h) "authenc(hmac(sha384),cbc(des3_ede))"
(i) "authenc(hmac(sha512),cbc(des))"
(j) "authenc(hmac(sha512),cbc(des3_ede))"
Signed-off-by: Vakul Garg <vakul@freescale.com>
[NiteshNarayanLal@freescale.com: added hooks for the missing algorithms test and tested the patch]
Signed-off-by: Nitesh Lal <NiteshNarayanLal@freescale.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2014-05-21 19:39:08 +08:00
|
|
|
}, {
|
2015-07-30 17:53:23 +08:00
|
|
|
.alg = "authenc(hmac(sha384),cbc(des))",
|
crypto: testmgr - add aead cbc des, des3_ede tests
Test vectors were taken from existing test for
CBC(DES3_EDE). Associated data has been added to test vectors.
HMAC computed with Crypto++ has been used. Following algos have
been covered.
(a) "authenc(hmac(sha1),cbc(des))"
(b) "authenc(hmac(sha1),cbc(des3_ede))"
(c) "authenc(hmac(sha224),cbc(des))"
(d) "authenc(hmac(sha224),cbc(des3_ede))"
(e) "authenc(hmac(sha256),cbc(des))"
(f) "authenc(hmac(sha256),cbc(des3_ede))"
(g) "authenc(hmac(sha384),cbc(des))"
(h) "authenc(hmac(sha384),cbc(des3_ede))"
(i) "authenc(hmac(sha512),cbc(des))"
(j) "authenc(hmac(sha512),cbc(des3_ede))"
Signed-off-by: Vakul Garg <vakul@freescale.com>
[NiteshNarayanLal@freescale.com: added hooks for the missing algorithms test and tested the patch]
Signed-off-by: Nitesh Lal <NiteshNarayanLal@freescale.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2014-05-21 19:39:08 +08:00
|
|
|
.test = alg_test_aead,
|
|
|
|
.suite = {
|
|
|
|
.aead = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(hmac_sha384_des_cbc_enc_tv_temp)
|
crypto: testmgr - add aead cbc des, des3_ede tests
Test vectors were taken from existing test for
CBC(DES3_EDE). Associated data has been added to test vectors.
HMAC computed with Crypto++ has been used. Following algos have
been covered.
(a) "authenc(hmac(sha1),cbc(des))"
(b) "authenc(hmac(sha1),cbc(des3_ede))"
(c) "authenc(hmac(sha224),cbc(des))"
(d) "authenc(hmac(sha224),cbc(des3_ede))"
(e) "authenc(hmac(sha256),cbc(des))"
(f) "authenc(hmac(sha256),cbc(des3_ede))"
(g) "authenc(hmac(sha384),cbc(des))"
(h) "authenc(hmac(sha384),cbc(des3_ede))"
(i) "authenc(hmac(sha512),cbc(des))"
(j) "authenc(hmac(sha512),cbc(des3_ede))"
Signed-off-by: Vakul Garg <vakul@freescale.com>
[NiteshNarayanLal@freescale.com: added hooks for the missing algorithms test and tested the patch]
Signed-off-by: Nitesh Lal <NiteshNarayanLal@freescale.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2014-05-21 19:39:08 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}, {
|
2015-07-30 17:53:23 +08:00
|
|
|
.alg = "authenc(hmac(sha384),cbc(des3_ede))",
|
crypto: testmgr - add aead cbc des, des3_ede tests
Test vectors were taken from existing test for
CBC(DES3_EDE). Associated data has been added to test vectors.
HMAC computed with Crypto++ has been used. Following algos have
been covered.
(a) "authenc(hmac(sha1),cbc(des))"
(b) "authenc(hmac(sha1),cbc(des3_ede))"
(c) "authenc(hmac(sha224),cbc(des))"
(d) "authenc(hmac(sha224),cbc(des3_ede))"
(e) "authenc(hmac(sha256),cbc(des))"
(f) "authenc(hmac(sha256),cbc(des3_ede))"
(g) "authenc(hmac(sha384),cbc(des))"
(h) "authenc(hmac(sha384),cbc(des3_ede))"
(i) "authenc(hmac(sha512),cbc(des))"
(j) "authenc(hmac(sha512),cbc(des3_ede))"
Signed-off-by: Vakul Garg <vakul@freescale.com>
[NiteshNarayanLal@freescale.com: added hooks for the missing algorithms test and tested the patch]
Signed-off-by: Nitesh Lal <NiteshNarayanLal@freescale.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2014-05-21 19:39:08 +08:00
|
|
|
.test = alg_test_aead,
|
2016-02-05 21:23:33 +08:00
|
|
|
.fips_allowed = 1,
|
crypto: testmgr - add aead cbc des, des3_ede tests
Test vectors were taken from existing test for
CBC(DES3_EDE). Associated data has been added to test vectors.
HMAC computed with Crypto++ has been used. Following algos have
been covered.
(a) "authenc(hmac(sha1),cbc(des))"
(b) "authenc(hmac(sha1),cbc(des3_ede))"
(c) "authenc(hmac(sha224),cbc(des))"
(d) "authenc(hmac(sha224),cbc(des3_ede))"
(e) "authenc(hmac(sha256),cbc(des))"
(f) "authenc(hmac(sha256),cbc(des3_ede))"
(g) "authenc(hmac(sha384),cbc(des))"
(h) "authenc(hmac(sha384),cbc(des3_ede))"
(i) "authenc(hmac(sha512),cbc(des))"
(j) "authenc(hmac(sha512),cbc(des3_ede))"
Signed-off-by: Vakul Garg <vakul@freescale.com>
[NiteshNarayanLal@freescale.com: added hooks for the missing algorithms test and tested the patch]
Signed-off-by: Nitesh Lal <NiteshNarayanLal@freescale.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2014-05-21 19:39:08 +08:00
|
|
|
.suite = {
|
|
|
|
.aead = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(hmac_sha384_des3_ede_cbc_enc_tv_temp)
|
2012-07-04 00:16:54 +08:00
|
|
|
}
|
|
|
|
}
|
2016-02-06 18:53:07 +08:00
|
|
|
}, {
|
|
|
|
.alg = "authenc(hmac(sha384),ctr(aes))",
|
|
|
|
.test = alg_test_null,
|
|
|
|
.fips_allowed = 1,
|
2016-02-19 20:34:28 +08:00
|
|
|
}, {
|
|
|
|
.alg = "authenc(hmac(sha384),rfc3686(ctr(aes)))",
|
|
|
|
.test = alg_test_null,
|
|
|
|
.fips_allowed = 1,
|
2012-07-04 00:16:54 +08:00
|
|
|
}, {
|
2015-07-30 17:53:23 +08:00
|
|
|
.alg = "authenc(hmac(sha512),cbc(aes))",
|
2016-02-05 21:23:33 +08:00
|
|
|
.fips_allowed = 1,
|
2012-07-04 00:16:54 +08:00
|
|
|
.test = alg_test_aead,
|
|
|
|
.suite = {
|
|
|
|
.aead = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(hmac_sha512_aes_cbc_enc_tv_temp)
|
crypto: testmgr - add aead cbc des, des3_ede tests
Test vectors were taken from existing test for
CBC(DES3_EDE). Associated data has been added to test vectors.
HMAC computed with Crypto++ has been used. Following algos have
been covered.
(a) "authenc(hmac(sha1),cbc(des))"
(b) "authenc(hmac(sha1),cbc(des3_ede))"
(c) "authenc(hmac(sha224),cbc(des))"
(d) "authenc(hmac(sha224),cbc(des3_ede))"
(e) "authenc(hmac(sha256),cbc(des))"
(f) "authenc(hmac(sha256),cbc(des3_ede))"
(g) "authenc(hmac(sha384),cbc(des))"
(h) "authenc(hmac(sha384),cbc(des3_ede))"
(i) "authenc(hmac(sha512),cbc(des))"
(j) "authenc(hmac(sha512),cbc(des3_ede))"
Signed-off-by: Vakul Garg <vakul@freescale.com>
[NiteshNarayanLal@freescale.com: added hooks for the missing algorithms test and tested the patch]
Signed-off-by: Nitesh Lal <NiteshNarayanLal@freescale.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2014-05-21 19:39:08 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}, {
|
2015-07-30 17:53:23 +08:00
|
|
|
.alg = "authenc(hmac(sha512),cbc(des))",
|
crypto: testmgr - add aead cbc des, des3_ede tests
Test vectors were taken from existing test for
CBC(DES3_EDE). Associated data has been added to test vectors.
HMAC computed with Crypto++ has been used. Following algos have
been covered.
(a) "authenc(hmac(sha1),cbc(des))"
(b) "authenc(hmac(sha1),cbc(des3_ede))"
(c) "authenc(hmac(sha224),cbc(des))"
(d) "authenc(hmac(sha224),cbc(des3_ede))"
(e) "authenc(hmac(sha256),cbc(des))"
(f) "authenc(hmac(sha256),cbc(des3_ede))"
(g) "authenc(hmac(sha384),cbc(des))"
(h) "authenc(hmac(sha384),cbc(des3_ede))"
(i) "authenc(hmac(sha512),cbc(des))"
(j) "authenc(hmac(sha512),cbc(des3_ede))"
Signed-off-by: Vakul Garg <vakul@freescale.com>
[NiteshNarayanLal@freescale.com: added hooks for the missing algorithms test and tested the patch]
Signed-off-by: Nitesh Lal <NiteshNarayanLal@freescale.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2014-05-21 19:39:08 +08:00
|
|
|
.test = alg_test_aead,
|
|
|
|
.suite = {
|
|
|
|
.aead = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(hmac_sha512_des_cbc_enc_tv_temp)
|
crypto: testmgr - add aead cbc des, des3_ede tests
Test vectors were taken from existing test for
CBC(DES3_EDE). Associated data has been added to test vectors.
HMAC computed with Crypto++ has been used. Following algos have
been covered.
(a) "authenc(hmac(sha1),cbc(des))"
(b) "authenc(hmac(sha1),cbc(des3_ede))"
(c) "authenc(hmac(sha224),cbc(des))"
(d) "authenc(hmac(sha224),cbc(des3_ede))"
(e) "authenc(hmac(sha256),cbc(des))"
(f) "authenc(hmac(sha256),cbc(des3_ede))"
(g) "authenc(hmac(sha384),cbc(des))"
(h) "authenc(hmac(sha384),cbc(des3_ede))"
(i) "authenc(hmac(sha512),cbc(des))"
(j) "authenc(hmac(sha512),cbc(des3_ede))"
Signed-off-by: Vakul Garg <vakul@freescale.com>
[NiteshNarayanLal@freescale.com: added hooks for the missing algorithms test and tested the patch]
Signed-off-by: Nitesh Lal <NiteshNarayanLal@freescale.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2014-05-21 19:39:08 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}, {
|
2015-07-30 17:53:23 +08:00
|
|
|
.alg = "authenc(hmac(sha512),cbc(des3_ede))",
|
crypto: testmgr - add aead cbc des, des3_ede tests
Test vectors were taken from existing test for
CBC(DES3_EDE). Associated data has been added to test vectors.
HMAC computed with Crypto++ has been used. Following algos have
been covered.
(a) "authenc(hmac(sha1),cbc(des))"
(b) "authenc(hmac(sha1),cbc(des3_ede))"
(c) "authenc(hmac(sha224),cbc(des))"
(d) "authenc(hmac(sha224),cbc(des3_ede))"
(e) "authenc(hmac(sha256),cbc(des))"
(f) "authenc(hmac(sha256),cbc(des3_ede))"
(g) "authenc(hmac(sha384),cbc(des))"
(h) "authenc(hmac(sha384),cbc(des3_ede))"
(i) "authenc(hmac(sha512),cbc(des))"
(j) "authenc(hmac(sha512),cbc(des3_ede))"
Signed-off-by: Vakul Garg <vakul@freescale.com>
[NiteshNarayanLal@freescale.com: added hooks for the missing algorithms test and tested the patch]
Signed-off-by: Nitesh Lal <NiteshNarayanLal@freescale.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2014-05-21 19:39:08 +08:00
|
|
|
.test = alg_test_aead,
|
2016-02-05 21:23:33 +08:00
|
|
|
.fips_allowed = 1,
|
crypto: testmgr - add aead cbc des, des3_ede tests
Test vectors were taken from existing test for
CBC(DES3_EDE). Associated data has been added to test vectors.
HMAC computed with Crypto++ has been used. Following algos have
been covered.
(a) "authenc(hmac(sha1),cbc(des))"
(b) "authenc(hmac(sha1),cbc(des3_ede))"
(c) "authenc(hmac(sha224),cbc(des))"
(d) "authenc(hmac(sha224),cbc(des3_ede))"
(e) "authenc(hmac(sha256),cbc(des))"
(f) "authenc(hmac(sha256),cbc(des3_ede))"
(g) "authenc(hmac(sha384),cbc(des))"
(h) "authenc(hmac(sha384),cbc(des3_ede))"
(i) "authenc(hmac(sha512),cbc(des))"
(j) "authenc(hmac(sha512),cbc(des3_ede))"
Signed-off-by: Vakul Garg <vakul@freescale.com>
[NiteshNarayanLal@freescale.com: added hooks for the missing algorithms test and tested the patch]
Signed-off-by: Nitesh Lal <NiteshNarayanLal@freescale.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2014-05-21 19:39:08 +08:00
|
|
|
.suite = {
|
|
|
|
.aead = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(hmac_sha512_des3_ede_cbc_enc_tv_temp)
|
2012-07-04 00:16:54 +08:00
|
|
|
}
|
|
|
|
}
|
2016-02-06 18:53:07 +08:00
|
|
|
}, {
|
|
|
|
.alg = "authenc(hmac(sha512),ctr(aes))",
|
|
|
|
.test = alg_test_null,
|
|
|
|
.fips_allowed = 1,
|
2016-02-19 20:34:28 +08:00
|
|
|
}, {
|
|
|
|
.alg = "authenc(hmac(sha512),rfc3686(ctr(aes)))",
|
|
|
|
.test = alg_test_null,
|
|
|
|
.fips_allowed = 1,
|
2009-05-04 19:46:29 +08:00
|
|
|
}, {
|
2008-07-31 17:08:25 +08:00
|
|
|
.alg = "cbc(aes)",
|
2008-08-17 15:01:56 +08:00
|
|
|
.test = alg_test_skcipher,
|
2009-05-15 13:16:03 +08:00
|
|
|
.fips_allowed = 1,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(aes_cbc_enc_tv_template),
|
|
|
|
.dec = __VECS(aes_cbc_dec_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "cbc(anubis)",
|
2008-08-17 15:01:56 +08:00
|
|
|
.test = alg_test_skcipher,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(anubis_cbc_enc_tv_template),
|
|
|
|
.dec = __VECS(anubis_cbc_dec_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "cbc(blowfish)",
|
2008-08-17 15:01:56 +08:00
|
|
|
.test = alg_test_skcipher,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(bf_cbc_enc_tv_template),
|
|
|
|
.dec = __VECS(bf_cbc_dec_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "cbc(camellia)",
|
2008-08-17 15:01:56 +08:00
|
|
|
.test = alg_test_skcipher,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(camellia_cbc_enc_tv_template),
|
|
|
|
.dec = __VECS(camellia_cbc_dec_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}
|
2012-07-12 01:37:21 +08:00
|
|
|
}, {
|
|
|
|
.alg = "cbc(cast5)",
|
|
|
|
.test = alg_test_skcipher,
|
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(cast5_cbc_enc_tv_template),
|
|
|
|
.dec = __VECS(cast5_cbc_dec_tv_template)
|
2012-07-12 01:37:21 +08:00
|
|
|
}
|
|
|
|
}
|
2012-07-12 01:38:29 +08:00
|
|
|
}, {
|
|
|
|
.alg = "cbc(cast6)",
|
|
|
|
.test = alg_test_skcipher,
|
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(cast6_cbc_enc_tv_template),
|
|
|
|
.dec = __VECS(cast6_cbc_dec_tv_template)
|
2012-07-12 01:38:29 +08:00
|
|
|
}
|
|
|
|
}
|
2008-07-31 17:08:25 +08:00
|
|
|
}, {
|
|
|
|
.alg = "cbc(des)",
|
2008-08-17 15:01:56 +08:00
|
|
|
.test = alg_test_skcipher,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(des_cbc_enc_tv_template),
|
|
|
|
.dec = __VECS(des_cbc_dec_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "cbc(des3_ede)",
|
2008-08-17 15:01:56 +08:00
|
|
|
.test = alg_test_skcipher,
|
2009-05-15 13:16:03 +08:00
|
|
|
.fips_allowed = 1,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(des3_ede_cbc_enc_tv_template),
|
|
|
|
.dec = __VECS(des3_ede_cbc_dec_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}
|
2018-04-23 15:25:14 +08:00
|
|
|
}, {
|
|
|
|
/* Same as cbc(aes) except the key is stored in
|
|
|
|
* hardware secure memory which we reference by index
|
|
|
|
*/
|
|
|
|
.alg = "cbc(paes)",
|
|
|
|
.test = alg_test_null,
|
|
|
|
.fips_allowed = 1,
|
2011-10-18 05:02:53 +08:00
|
|
|
}, {
|
|
|
|
.alg = "cbc(serpent)",
|
|
|
|
.test = alg_test_skcipher,
|
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(serpent_cbc_enc_tv_template),
|
|
|
|
.dec = __VECS(serpent_cbc_dec_tv_template)
|
2011-10-18 05:02:53 +08:00
|
|
|
}
|
|
|
|
}
|
2008-07-31 17:08:25 +08:00
|
|
|
}, {
|
|
|
|
.alg = "cbc(twofish)",
|
2008-08-17 15:01:56 +08:00
|
|
|
.test = alg_test_skcipher,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(tf_cbc_enc_tv_template),
|
|
|
|
.dec = __VECS(tf_cbc_dec_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}
|
2017-02-03 22:49:35 +08:00
|
|
|
}, {
|
|
|
|
.alg = "cbcmac(aes)",
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.test = alg_test_hash,
|
|
|
|
.suite = {
|
|
|
|
.hash = __VECS(aes_cbcmac_tv_template)
|
|
|
|
}
|
2008-07-31 17:08:25 +08:00
|
|
|
}, {
|
|
|
|
.alg = "ccm(aes)",
|
|
|
|
.test = alg_test_aead,
|
2009-05-15 13:16:03 +08:00
|
|
|
.fips_allowed = 1,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
|
|
|
.aead = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(aes_ccm_enc_tv_template),
|
|
|
|
.dec = __VECS(aes_ccm_dec_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}
|
2015-06-01 19:43:57 +08:00
|
|
|
}, {
|
|
|
|
.alg = "chacha20",
|
|
|
|
.test = alg_test_skcipher,
|
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(chacha20_enc_tv_template),
|
|
|
|
.dec = __VECS(chacha20_enc_tv_template),
|
2015-06-01 19:43:57 +08:00
|
|
|
}
|
|
|
|
}
|
2013-04-08 15:48:44 +08:00
|
|
|
}, {
|
|
|
|
.alg = "cmac(aes)",
|
2015-08-19 14:42:07 +08:00
|
|
|
.fips_allowed = 1,
|
2013-04-08 15:48:44 +08:00
|
|
|
.test = alg_test_hash,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(aes_cmac128_tv_template)
|
2013-04-08 15:48:44 +08:00
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "cmac(des3_ede)",
|
2015-08-19 14:42:07 +08:00
|
|
|
.fips_allowed = 1,
|
2013-04-08 15:48:44 +08:00
|
|
|
.test = alg_test_hash,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(des3_ede_cmac64_tv_template)
|
2013-04-08 15:48:44 +08:00
|
|
|
}
|
2013-04-07 21:43:56 +08:00
|
|
|
}, {
|
|
|
|
.alg = "compress_null",
|
|
|
|
.test = alg_test_null,
|
2015-05-04 17:00:17 +08:00
|
|
|
}, {
|
|
|
|
.alg = "crc32",
|
|
|
|
.test = alg_test_hash,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(crc32_tv_template)
|
2015-05-04 17:00:17 +08:00
|
|
|
}
|
2008-07-31 17:08:25 +08:00
|
|
|
}, {
|
|
|
|
.alg = "crc32c",
|
2008-11-07 14:58:52 +08:00
|
|
|
.test = alg_test_crc32c,
|
2009-05-15 13:16:03 +08:00
|
|
|
.fips_allowed = 1,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(crc32c_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
2013-09-07 10:56:26 +08:00
|
|
|
}, {
|
|
|
|
.alg = "crct10dif",
|
|
|
|
.test = alg_test_hash,
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(crct10dif_tv_template)
|
2013-09-07 10:56:26 +08:00
|
|
|
}
|
2009-05-06 17:29:17 +08:00
|
|
|
}, {
|
|
|
|
.alg = "ctr(aes)",
|
|
|
|
.test = alg_test_skcipher,
|
2009-05-15 13:16:03 +08:00
|
|
|
.fips_allowed = 1,
|
2009-05-06 17:29:17 +08:00
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(aes_ctr_enc_tv_template),
|
|
|
|
.dec = __VECS(aes_ctr_dec_tv_template)
|
2009-05-06 17:29:17 +08:00
|
|
|
}
|
|
|
|
}
|
2011-10-11 04:03:03 +08:00
|
|
|
}, {
|
|
|
|
.alg = "ctr(blowfish)",
|
|
|
|
.test = alg_test_skcipher,
|
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(bf_ctr_enc_tv_template),
|
|
|
|
.dec = __VECS(bf_ctr_dec_tv_template)
|
2011-10-11 04:03:03 +08:00
|
|
|
}
|
|
|
|
}
|
2012-03-06 02:26:21 +08:00
|
|
|
}, {
|
|
|
|
.alg = "ctr(camellia)",
|
|
|
|
.test = alg_test_skcipher,
|
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(camellia_ctr_enc_tv_template),
|
|
|
|
.dec = __VECS(camellia_ctr_dec_tv_template)
|
2012-03-06 02:26:21 +08:00
|
|
|
}
|
|
|
|
}
|
2012-07-12 01:37:21 +08:00
|
|
|
}, {
|
|
|
|
.alg = "ctr(cast5)",
|
|
|
|
.test = alg_test_skcipher,
|
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(cast5_ctr_enc_tv_template),
|
|
|
|
.dec = __VECS(cast5_ctr_dec_tv_template)
|
2012-07-12 01:37:21 +08:00
|
|
|
}
|
|
|
|
}
|
2012-07-12 01:38:29 +08:00
|
|
|
}, {
|
|
|
|
.alg = "ctr(cast6)",
|
|
|
|
.test = alg_test_skcipher,
|
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(cast6_ctr_enc_tv_template),
|
|
|
|
.dec = __VECS(cast6_ctr_dec_tv_template)
|
2012-07-12 01:38:29 +08:00
|
|
|
}
|
|
|
|
}
|
2012-10-20 19:53:07 +08:00
|
|
|
}, {
|
|
|
|
.alg = "ctr(des)",
|
|
|
|
.test = alg_test_skcipher,
|
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(des_ctr_enc_tv_template),
|
|
|
|
.dec = __VECS(des_ctr_dec_tv_template)
|
2012-10-20 19:53:07 +08:00
|
|
|
}
|
|
|
|
}
|
2012-10-20 19:53:12 +08:00
|
|
|
}, {
|
|
|
|
.alg = "ctr(des3_ede)",
|
|
|
|
.test = alg_test_skcipher,
|
2017-03-21 04:28:05 +08:00
|
|
|
.fips_allowed = 1,
|
2012-10-20 19:53:12 +08:00
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(des3_ede_ctr_enc_tv_template),
|
|
|
|
.dec = __VECS(des3_ede_ctr_dec_tv_template)
|
2012-10-20 19:53:12 +08:00
|
|
|
}
|
|
|
|
}
|
2018-04-23 15:25:14 +08:00
|
|
|
}, {
|
|
|
|
/* Same as ctr(aes) except the key is stored in
|
|
|
|
* hardware secure memory which we reference by index
|
|
|
|
*/
|
|
|
|
.alg = "ctr(paes)",
|
|
|
|
.test = alg_test_null,
|
|
|
|
.fips_allowed = 1,
|
2011-10-18 05:02:53 +08:00
|
|
|
}, {
|
|
|
|
.alg = "ctr(serpent)",
|
|
|
|
.test = alg_test_skcipher,
|
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(serpent_ctr_enc_tv_template),
|
|
|
|
.dec = __VECS(serpent_ctr_dec_tv_template)
|
2011-10-18 05:02:53 +08:00
|
|
|
}
|
|
|
|
}
|
2011-10-11 04:03:12 +08:00
|
|
|
}, {
|
|
|
|
.alg = "ctr(twofish)",
|
|
|
|
.test = alg_test_skcipher,
|
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(tf_ctr_enc_tv_template),
|
|
|
|
.dec = __VECS(tf_ctr_dec_tv_template)
|
2011-10-11 04:03:12 +08:00
|
|
|
}
|
|
|
|
}
|
2008-07-31 17:08:25 +08:00
|
|
|
}, {
|
|
|
|
.alg = "cts(cbc(aes))",
|
2008-08-17 15:01:56 +08:00
|
|
|
.test = alg_test_skcipher,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(cts_mode_enc_tv_template),
|
|
|
|
.dec = __VECS(cts_mode_dec_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "deflate",
|
|
|
|
.test = alg_test_comp,
|
2012-12-06 17:16:28 +08:00
|
|
|
.fips_allowed = 1,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
|
|
|
.comp = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.comp = __VECS(deflate_comp_tv_template),
|
|
|
|
.decomp = __VECS(deflate_decomp_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}
|
2016-06-23 00:49:14 +08:00
|
|
|
}, {
|
|
|
|
.alg = "dh",
|
|
|
|
.test = alg_test_kpp,
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.kpp = __VECS(dh_tv_template)
|
2016-06-23 00:49:14 +08:00
|
|
|
}
|
2013-04-07 21:43:56 +08:00
|
|
|
}, {
|
|
|
|
.alg = "digest_null",
|
|
|
|
.test = alg_test_null,
|
2014-05-31 23:25:36 +08:00
|
|
|
}, {
|
|
|
|
.alg = "drbg_nopr_ctr_aes128",
|
|
|
|
.test = alg_test_drbg,
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.drbg = __VECS(drbg_nopr_ctr_aes128_tv_template)
|
2014-05-31 23:25:36 +08:00
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "drbg_nopr_ctr_aes192",
|
|
|
|
.test = alg_test_drbg,
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.drbg = __VECS(drbg_nopr_ctr_aes192_tv_template)
|
2014-05-31 23:25:36 +08:00
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "drbg_nopr_ctr_aes256",
|
|
|
|
.test = alg_test_drbg,
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.drbg = __VECS(drbg_nopr_ctr_aes256_tv_template)
|
2014-05-31 23:25:36 +08:00
|
|
|
}
|
|
|
|
}, {
|
|
|
|
/*
|
|
|
|
* There is no need to specifically test the DRBG with every
|
|
|
|
* backend cipher -- covered by drbg_nopr_hmac_sha256 test
|
|
|
|
*/
|
|
|
|
.alg = "drbg_nopr_hmac_sha1",
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.test = alg_test_null,
|
|
|
|
}, {
|
|
|
|
.alg = "drbg_nopr_hmac_sha256",
|
|
|
|
.test = alg_test_drbg,
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.drbg = __VECS(drbg_nopr_hmac_sha256_tv_template)
|
2014-05-31 23:25:36 +08:00
|
|
|
}
|
|
|
|
}, {
|
|
|
|
/* covered by drbg_nopr_hmac_sha256 test */
|
|
|
|
.alg = "drbg_nopr_hmac_sha384",
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.test = alg_test_null,
|
|
|
|
}, {
|
|
|
|
.alg = "drbg_nopr_hmac_sha512",
|
|
|
|
.test = alg_test_null,
|
|
|
|
.fips_allowed = 1,
|
|
|
|
}, {
|
|
|
|
.alg = "drbg_nopr_sha1",
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.test = alg_test_null,
|
|
|
|
}, {
|
|
|
|
.alg = "drbg_nopr_sha256",
|
|
|
|
.test = alg_test_drbg,
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.drbg = __VECS(drbg_nopr_sha256_tv_template)
|
2014-05-31 23:25:36 +08:00
|
|
|
}
|
|
|
|
}, {
|
|
|
|
/* covered by drbg_nopr_sha256 test */
|
|
|
|
.alg = "drbg_nopr_sha384",
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.test = alg_test_null,
|
|
|
|
}, {
|
|
|
|
.alg = "drbg_nopr_sha512",
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.test = alg_test_null,
|
|
|
|
}, {
|
|
|
|
.alg = "drbg_pr_ctr_aes128",
|
|
|
|
.test = alg_test_drbg,
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.drbg = __VECS(drbg_pr_ctr_aes128_tv_template)
|
2014-05-31 23:25:36 +08:00
|
|
|
}
|
|
|
|
}, {
|
|
|
|
/* covered by drbg_pr_ctr_aes128 test */
|
|
|
|
.alg = "drbg_pr_ctr_aes192",
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.test = alg_test_null,
|
|
|
|
}, {
|
|
|
|
.alg = "drbg_pr_ctr_aes256",
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.test = alg_test_null,
|
|
|
|
}, {
|
|
|
|
.alg = "drbg_pr_hmac_sha1",
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.test = alg_test_null,
|
|
|
|
}, {
|
|
|
|
.alg = "drbg_pr_hmac_sha256",
|
|
|
|
.test = alg_test_drbg,
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.drbg = __VECS(drbg_pr_hmac_sha256_tv_template)
|
2014-05-31 23:25:36 +08:00
|
|
|
}
|
|
|
|
}, {
|
|
|
|
/* covered by drbg_pr_hmac_sha256 test */
|
|
|
|
.alg = "drbg_pr_hmac_sha384",
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.test = alg_test_null,
|
|
|
|
}, {
|
|
|
|
.alg = "drbg_pr_hmac_sha512",
|
|
|
|
.test = alg_test_null,
|
|
|
|
.fips_allowed = 1,
|
|
|
|
}, {
|
|
|
|
.alg = "drbg_pr_sha1",
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.test = alg_test_null,
|
|
|
|
}, {
|
|
|
|
.alg = "drbg_pr_sha256",
|
|
|
|
.test = alg_test_drbg,
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.drbg = __VECS(drbg_pr_sha256_tv_template)
|
2014-05-31 23:25:36 +08:00
|
|
|
}
|
|
|
|
}, {
|
|
|
|
/* covered by drbg_pr_sha256 test */
|
|
|
|
.alg = "drbg_pr_sha384",
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.test = alg_test_null,
|
|
|
|
}, {
|
|
|
|
.alg = "drbg_pr_sha512",
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.test = alg_test_null,
|
2008-07-31 17:08:25 +08:00
|
|
|
}, {
|
|
|
|
.alg = "ecb(aes)",
|
2008-08-17 15:01:56 +08:00
|
|
|
.test = alg_test_skcipher,
|
2009-05-15 13:16:03 +08:00
|
|
|
.fips_allowed = 1,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(aes_enc_tv_template),
|
|
|
|
.dec = __VECS(aes_dec_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "ecb(anubis)",
|
2008-08-17 15:01:56 +08:00
|
|
|
.test = alg_test_skcipher,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(anubis_enc_tv_template),
|
|
|
|
.dec = __VECS(anubis_dec_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "ecb(arc4)",
|
2008-08-17 15:01:56 +08:00
|
|
|
.test = alg_test_skcipher,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(arc4_enc_tv_template),
|
|
|
|
.dec = __VECS(arc4_dec_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "ecb(blowfish)",
|
2008-08-17 15:01:56 +08:00
|
|
|
.test = alg_test_skcipher,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(bf_enc_tv_template),
|
|
|
|
.dec = __VECS(bf_dec_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "ecb(camellia)",
|
2008-08-17 15:01:56 +08:00
|
|
|
.test = alg_test_skcipher,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(camellia_enc_tv_template),
|
|
|
|
.dec = __VECS(camellia_dec_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "ecb(cast5)",
|
2008-08-17 15:01:56 +08:00
|
|
|
.test = alg_test_skcipher,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(cast5_enc_tv_template),
|
|
|
|
.dec = __VECS(cast5_dec_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "ecb(cast6)",
|
2008-08-17 15:01:56 +08:00
|
|
|
.test = alg_test_skcipher,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(cast6_enc_tv_template),
|
|
|
|
.dec = __VECS(cast6_dec_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}
|
2013-04-07 21:43:56 +08:00
|
|
|
}, {
|
|
|
|
.alg = "ecb(cipher_null)",
|
|
|
|
.test = alg_test_null,
|
2017-04-21 19:03:06 +08:00
|
|
|
.fips_allowed = 1,
|
2008-07-31 17:08:25 +08:00
|
|
|
}, {
|
|
|
|
.alg = "ecb(des)",
|
2008-08-17 15:01:56 +08:00
|
|
|
.test = alg_test_skcipher,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(des_enc_tv_template),
|
|
|
|
.dec = __VECS(des_dec_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "ecb(des3_ede)",
|
2008-08-17 15:01:56 +08:00
|
|
|
.test = alg_test_skcipher,
|
2009-05-15 13:16:03 +08:00
|
|
|
.fips_allowed = 1,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(des3_ede_enc_tv_template),
|
|
|
|
.dec = __VECS(des3_ede_dec_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}
|
2013-01-19 19:31:36 +08:00
|
|
|
}, {
|
|
|
|
.alg = "ecb(fcrypt)",
|
|
|
|
.test = alg_test_skcipher,
|
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
|
|
|
.enc = {
|
|
|
|
.vecs = fcrypt_pcbc_enc_tv_template,
|
|
|
|
.count = 1
|
|
|
|
},
|
|
|
|
.dec = {
|
|
|
|
.vecs = fcrypt_pcbc_dec_tv_template,
|
|
|
|
.count = 1
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2008-07-31 17:08:25 +08:00
|
|
|
}, {
|
|
|
|
.alg = "ecb(khazad)",
|
2008-08-17 15:01:56 +08:00
|
|
|
.test = alg_test_skcipher,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(khazad_enc_tv_template),
|
|
|
|
.dec = __VECS(khazad_dec_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}
|
2018-05-11 16:04:06 +08:00
|
|
|
}, {
|
|
|
|
/* Same as ecb(aes) except the key is stored in
|
|
|
|
* hardware secure memory which we reference by index
|
|
|
|
*/
|
|
|
|
.alg = "ecb(paes)",
|
|
|
|
.test = alg_test_null,
|
|
|
|
.fips_allowed = 1,
|
2008-07-31 17:08:25 +08:00
|
|
|
}, {
|
|
|
|
.alg = "ecb(seed)",
|
2008-08-17 15:01:56 +08:00
|
|
|
.test = alg_test_skcipher,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(seed_enc_tv_template),
|
|
|
|
.dec = __VECS(seed_dec_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "ecb(serpent)",
|
2008-08-17 15:01:56 +08:00
|
|
|
.test = alg_test_skcipher,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(serpent_enc_tv_template),
|
|
|
|
.dec = __VECS(serpent_dec_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}
|
2018-03-06 17:44:43 +08:00
|
|
|
}, {
|
|
|
|
.alg = "ecb(sm4)",
|
|
|
|
.test = alg_test_skcipher,
|
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
|
|
|
.enc = __VECS(sm4_enc_tv_template),
|
|
|
|
.dec = __VECS(sm4_dec_tv_template)
|
|
|
|
}
|
|
|
|
}
|
crypto: speck - add support for the Speck block cipher
Add a generic implementation of Speck, including the Speck128 and
Speck64 variants. Speck is a lightweight block cipher that can be much
faster than AES on processors that don't have AES instructions.
We are planning to offer Speck-XTS (probably Speck128/256-XTS) as an
option for dm-crypt and fscrypt on Android, for low-end mobile devices
with older CPUs such as ARMv7 which don't have the Cryptography
Extensions. Currently, such devices are unencrypted because AES is not
fast enough, even when the NEON bit-sliced implementation of AES is
used. Other AES alternatives such as Twofish, Threefish, Camellia,
CAST6, and Serpent aren't fast enough either; it seems that only a
modern ARX cipher can provide sufficient performance on these devices.
This is a replacement for our original proposal
(https://patchwork.kernel.org/patch/10101451/) which was to offer
ChaCha20 for these devices. However, the use of a stream cipher for
disk/file encryption with no space to store nonces would have been much
more insecure than we thought initially, given that it would be used on
top of flash storage as well as potentially on top of F2FS, neither of
which is guaranteed to overwrite data in-place.
Speck has been somewhat controversial due to its origin. Nevertheless,
it has a straightforward design (it's an ARX cipher), and it appears to
be the leading software-optimized lightweight block cipher currently,
with the most cryptanalysis. It's also easy to implement without side
channels, unlike AES. Moreover, we only intend Speck to be used when
the status quo is no encryption, due to AES not being fast enough.
We've also considered a novel length-preserving encryption mode based on
ChaCha20 and Poly1305. While theoretically attractive, such a mode
would be a brand new crypto construction and would be more complicated
and difficult to implement efficiently in comparison to Speck-XTS.
There is confusion about the byte and word orders of Speck, since the
original paper doesn't specify them. But we have implemented it using
the orders the authors recommended in a correspondence with them. The
test vectors are taken from the original paper but were mapped to byte
arrays using the recommended byte and word orders.
Signed-off-by: Eric Biggers <ebiggers@google.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2018-02-15 02:42:19 +08:00
|
|
|
}, {
|
|
|
|
.alg = "ecb(speck128)",
|
|
|
|
.test = alg_test_skcipher,
|
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
|
|
|
.enc = __VECS(speck128_enc_tv_template),
|
|
|
|
.dec = __VECS(speck128_dec_tv_template)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "ecb(speck64)",
|
|
|
|
.test = alg_test_skcipher,
|
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
|
|
|
.enc = __VECS(speck64_enc_tv_template),
|
|
|
|
.dec = __VECS(speck64_dec_tv_template)
|
|
|
|
}
|
|
|
|
}
|
2008-07-31 17:08:25 +08:00
|
|
|
}, {
|
|
|
|
.alg = "ecb(tea)",
|
2008-08-17 15:01:56 +08:00
|
|
|
.test = alg_test_skcipher,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(tea_enc_tv_template),
|
|
|
|
.dec = __VECS(tea_dec_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "ecb(tnepres)",
|
2008-08-17 15:01:56 +08:00
|
|
|
.test = alg_test_skcipher,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(tnepres_enc_tv_template),
|
|
|
|
.dec = __VECS(tnepres_dec_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "ecb(twofish)",
|
2008-08-17 15:01:56 +08:00
|
|
|
.test = alg_test_skcipher,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(tf_enc_tv_template),
|
|
|
|
.dec = __VECS(tf_dec_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "ecb(xeta)",
|
2008-08-17 15:01:56 +08:00
|
|
|
.test = alg_test_skcipher,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(xeta_enc_tv_template),
|
|
|
|
.dec = __VECS(xeta_dec_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "ecb(xtea)",
|
2008-08-17 15:01:56 +08:00
|
|
|
.test = alg_test_skcipher,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(xtea_enc_tv_template),
|
|
|
|
.dec = __VECS(xtea_dec_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}
|
2016-06-23 00:49:15 +08:00
|
|
|
}, {
|
|
|
|
.alg = "ecdh",
|
|
|
|
.test = alg_test_kpp,
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.kpp = __VECS(ecdh_tv_template)
|
2016-06-23 00:49:15 +08:00
|
|
|
}
|
2008-07-31 17:08:25 +08:00
|
|
|
}, {
|
|
|
|
.alg = "gcm(aes)",
|
|
|
|
.test = alg_test_aead,
|
2009-05-15 13:16:03 +08:00
|
|
|
.fips_allowed = 1,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
|
|
|
.aead = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(aes_gcm_enc_tv_template),
|
|
|
|
.dec = __VECS(aes_gcm_dec_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}
|
2009-11-23 20:23:04 +08:00
|
|
|
}, {
|
|
|
|
.alg = "ghash",
|
|
|
|
.test = alg_test_hash,
|
crypto: testmgr - mark ghash as fips_allowed
A self-test failure in fips mode means a panic. Well, gcm(aes)
self-tests currently fail in fips mode, as gcm is dependent on ghash,
which semi-recently got self-test vectors added, but wasn't marked as a
fips_allowed algorithm. Because of gcm's dependence on what is now seen
as a non-fips_allowed algorithm, its self-tests refuse to run.
Previously, ghash got a pass in fips mode, due to the lack of any test
vectors at all, and thus gcm self-tests were able to run. After this
patch, a 'modprobe tcrypt mode=35' no longer panics in fips mode, and
successful self-test of gcm(aes) is reported.
Signed-off-by: Jarod Wilson <jarod@redhat.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2011-01-29 12:14:35 +08:00
|
|
|
.fips_allowed = 1,
|
2009-11-23 20:23:04 +08:00
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(ghash_tv_template)
|
2009-11-23 20:23:04 +08:00
|
|
|
}
|
2012-05-25 17:54:13 +08:00
|
|
|
}, {
|
|
|
|
.alg = "hmac(crc32)",
|
|
|
|
.test = alg_test_hash,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(bfin_crc_tv_template)
|
2012-05-25 17:54:13 +08:00
|
|
|
}
|
2008-07-31 17:08:25 +08:00
|
|
|
}, {
|
|
|
|
.alg = "hmac(md5)",
|
|
|
|
.test = alg_test_hash,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(hmac_md5_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "hmac(rmd128)",
|
|
|
|
.test = alg_test_hash,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(hmac_rmd128_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "hmac(rmd160)",
|
|
|
|
.test = alg_test_hash,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(hmac_rmd160_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "hmac(sha1)",
|
|
|
|
.test = alg_test_hash,
|
2009-05-15 13:16:03 +08:00
|
|
|
.fips_allowed = 1,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(hmac_sha1_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "hmac(sha224)",
|
|
|
|
.test = alg_test_hash,
|
2009-05-15 13:16:03 +08:00
|
|
|
.fips_allowed = 1,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(hmac_sha224_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "hmac(sha256)",
|
|
|
|
.test = alg_test_hash,
|
2009-05-15 13:16:03 +08:00
|
|
|
.fips_allowed = 1,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(hmac_sha256_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
2016-07-01 13:46:54 +08:00
|
|
|
}, {
|
|
|
|
.alg = "hmac(sha3-224)",
|
|
|
|
.test = alg_test_hash,
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(hmac_sha3_224_tv_template)
|
2016-07-01 13:46:54 +08:00
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "hmac(sha3-256)",
|
|
|
|
.test = alg_test_hash,
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(hmac_sha3_256_tv_template)
|
2016-07-01 13:46:54 +08:00
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "hmac(sha3-384)",
|
|
|
|
.test = alg_test_hash,
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(hmac_sha3_384_tv_template)
|
2016-07-01 13:46:54 +08:00
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "hmac(sha3-512)",
|
|
|
|
.test = alg_test_hash,
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(hmac_sha3_512_tv_template)
|
2016-07-01 13:46:54 +08:00
|
|
|
}
|
2008-07-31 17:08:25 +08:00
|
|
|
}, {
|
|
|
|
.alg = "hmac(sha384)",
|
|
|
|
.test = alg_test_hash,
|
2009-05-15 13:16:03 +08:00
|
|
|
.fips_allowed = 1,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(hmac_sha384_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "hmac(sha512)",
|
|
|
|
.test = alg_test_hash,
|
2009-05-15 13:16:03 +08:00
|
|
|
.fips_allowed = 1,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(hmac_sha512_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
2015-05-25 21:10:20 +08:00
|
|
|
}, {
|
|
|
|
.alg = "jitterentropy_rng",
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.test = alg_test_null,
|
2015-09-22 02:59:56 +08:00
|
|
|
}, {
|
|
|
|
.alg = "kw(aes)",
|
|
|
|
.test = alg_test_skcipher,
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(aes_kw_enc_tv_template),
|
|
|
|
.dec = __VECS(aes_kw_dec_tv_template)
|
2015-09-22 02:59:56 +08:00
|
|
|
}
|
|
|
|
}
|
2008-07-31 17:08:25 +08:00
|
|
|
}, {
|
|
|
|
.alg = "lrw(aes)",
|
2008-08-17 15:01:56 +08:00
|
|
|
.test = alg_test_skcipher,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(aes_lrw_enc_tv_template),
|
|
|
|
.dec = __VECS(aes_lrw_dec_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}
|
2012-03-06 02:26:21 +08:00
|
|
|
}, {
|
|
|
|
.alg = "lrw(camellia)",
|
|
|
|
.test = alg_test_skcipher,
|
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(camellia_lrw_enc_tv_template),
|
|
|
|
.dec = __VECS(camellia_lrw_dec_tv_template)
|
2012-03-06 02:26:21 +08:00
|
|
|
}
|
|
|
|
}
|
2012-07-12 01:38:29 +08:00
|
|
|
}, {
|
|
|
|
.alg = "lrw(cast6)",
|
|
|
|
.test = alg_test_skcipher,
|
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(cast6_lrw_enc_tv_template),
|
|
|
|
.dec = __VECS(cast6_lrw_dec_tv_template)
|
2012-07-12 01:38:29 +08:00
|
|
|
}
|
|
|
|
}
|
2011-10-18 18:32:34 +08:00
|
|
|
}, {
|
|
|
|
.alg = "lrw(serpent)",
|
|
|
|
.test = alg_test_skcipher,
|
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(serpent_lrw_enc_tv_template),
|
|
|
|
.dec = __VECS(serpent_lrw_dec_tv_template)
|
2011-10-18 18:32:34 +08:00
|
|
|
}
|
|
|
|
}
|
2011-10-18 18:32:50 +08:00
|
|
|
}, {
|
|
|
|
.alg = "lrw(twofish)",
|
|
|
|
.test = alg_test_skcipher,
|
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(tf_lrw_enc_tv_template),
|
|
|
|
.dec = __VECS(tf_lrw_dec_tv_template)
|
2011-10-18 18:32:50 +08:00
|
|
|
}
|
|
|
|
}
|
2014-08-22 16:44:36 +08:00
|
|
|
}, {
|
|
|
|
.alg = "lz4",
|
|
|
|
.test = alg_test_comp,
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.suite = {
|
|
|
|
.comp = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.comp = __VECS(lz4_comp_tv_template),
|
|
|
|
.decomp = __VECS(lz4_decomp_tv_template)
|
2014-08-22 16:44:36 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "lz4hc",
|
|
|
|
.test = alg_test_comp,
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.suite = {
|
|
|
|
.comp = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.comp = __VECS(lz4hc_comp_tv_template),
|
|
|
|
.decomp = __VECS(lz4hc_decomp_tv_template)
|
2014-08-22 16:44:36 +08:00
|
|
|
}
|
|
|
|
}
|
2008-07-31 17:08:25 +08:00
|
|
|
}, {
|
|
|
|
.alg = "lzo",
|
|
|
|
.test = alg_test_comp,
|
2012-12-06 17:16:28 +08:00
|
|
|
.fips_allowed = 1,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
|
|
|
.comp = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.comp = __VECS(lzo_comp_tv_template),
|
|
|
|
.decomp = __VECS(lzo_decomp_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "md4",
|
|
|
|
.test = alg_test_hash,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(md4_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "md5",
|
|
|
|
.test = alg_test_hash,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(md5_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "michael_mic",
|
|
|
|
.test = alg_test_hash,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(michael_mic_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
2011-05-04 13:04:10 +08:00
|
|
|
}, {
|
|
|
|
.alg = "ofb(aes)",
|
|
|
|
.test = alg_test_skcipher,
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(aes_ofb_enc_tv_template),
|
|
|
|
.dec = __VECS(aes_ofb_dec_tv_template)
|
2011-05-04 13:04:10 +08:00
|
|
|
}
|
|
|
|
}
|
2018-04-23 15:25:14 +08:00
|
|
|
}, {
|
|
|
|
/* Same as ofb(aes) except the key is stored in
|
|
|
|
* hardware secure memory which we reference by index
|
|
|
|
*/
|
|
|
|
.alg = "ofb(paes)",
|
|
|
|
.test = alg_test_null,
|
|
|
|
.fips_allowed = 1,
|
2008-07-31 17:08:25 +08:00
|
|
|
}, {
|
|
|
|
.alg = "pcbc(fcrypt)",
|
2008-08-17 15:01:56 +08:00
|
|
|
.test = alg_test_skcipher,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(fcrypt_pcbc_enc_tv_template),
|
|
|
|
.dec = __VECS(fcrypt_pcbc_dec_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}
|
2017-06-13 05:27:51 +08:00
|
|
|
}, {
|
|
|
|
.alg = "pkcs1pad(rsa,sha224)",
|
|
|
|
.test = alg_test_null,
|
|
|
|
.fips_allowed = 1,
|
|
|
|
}, {
|
|
|
|
.alg = "pkcs1pad(rsa,sha256)",
|
|
|
|
.test = alg_test_akcipher,
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.suite = {
|
|
|
|
.akcipher = __VECS(pkcs1pad_rsa_tv_template)
|
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "pkcs1pad(rsa,sha384)",
|
|
|
|
.test = alg_test_null,
|
|
|
|
.fips_allowed = 1,
|
|
|
|
}, {
|
|
|
|
.alg = "pkcs1pad(rsa,sha512)",
|
|
|
|
.test = alg_test_null,
|
|
|
|
.fips_allowed = 1,
|
2015-06-01 19:43:59 +08:00
|
|
|
}, {
|
|
|
|
.alg = "poly1305",
|
|
|
|
.test = alg_test_hash,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(poly1305_tv_template)
|
2015-06-01 19:43:59 +08:00
|
|
|
}
|
2008-07-31 17:08:25 +08:00
|
|
|
}, {
|
|
|
|
.alg = "rfc3686(ctr(aes))",
|
2008-08-17 15:01:56 +08:00
|
|
|
.test = alg_test_skcipher,
|
2009-05-15 13:16:03 +08:00
|
|
|
.fips_allowed = 1,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(aes_ctr_rfc3686_enc_tv_template),
|
|
|
|
.dec = __VECS(aes_ctr_rfc3686_dec_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}
|
2009-05-04 19:23:40 +08:00
|
|
|
}, {
|
2015-07-09 07:17:34 +08:00
|
|
|
.alg = "rfc4106(gcm(aes))",
|
2010-11-05 03:02:04 +08:00
|
|
|
.test = alg_test_aead,
|
2015-01-24 01:42:15 +08:00
|
|
|
.fips_allowed = 1,
|
2010-11-05 03:02:04 +08:00
|
|
|
.suite = {
|
|
|
|
.aead = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(aes_gcm_rfc4106_enc_tv_template),
|
|
|
|
.dec = __VECS(aes_gcm_rfc4106_dec_tv_template)
|
2010-11-05 03:02:04 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}, {
|
2015-07-14 16:53:22 +08:00
|
|
|
.alg = "rfc4309(ccm(aes))",
|
2009-05-04 19:23:40 +08:00
|
|
|
.test = alg_test_aead,
|
2009-05-15 13:16:03 +08:00
|
|
|
.fips_allowed = 1,
|
2009-05-04 19:23:40 +08:00
|
|
|
.suite = {
|
|
|
|
.aead = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(aes_ccm_rfc4309_enc_tv_template),
|
|
|
|
.dec = __VECS(aes_ccm_rfc4309_dec_tv_template)
|
2009-05-04 19:23:40 +08:00
|
|
|
}
|
|
|
|
}
|
2013-04-07 21:43:51 +08:00
|
|
|
}, {
|
2015-06-16 13:54:24 +08:00
|
|
|
.alg = "rfc4543(gcm(aes))",
|
2013-04-07 21:43:51 +08:00
|
|
|
.test = alg_test_aead,
|
|
|
|
.suite = {
|
|
|
|
.aead = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(aes_gcm_rfc4543_enc_tv_template),
|
|
|
|
.dec = __VECS(aes_gcm_rfc4543_dec_tv_template),
|
2013-04-07 21:43:51 +08:00
|
|
|
}
|
|
|
|
}
|
2015-06-01 19:44:01 +08:00
|
|
|
}, {
|
|
|
|
.alg = "rfc7539(chacha20,poly1305)",
|
|
|
|
.test = alg_test_aead,
|
|
|
|
.suite = {
|
|
|
|
.aead = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(rfc7539_enc_tv_template),
|
|
|
|
.dec = __VECS(rfc7539_dec_tv_template),
|
2015-06-01 19:44:01 +08:00
|
|
|
}
|
|
|
|
}
|
2015-06-01 19:44:03 +08:00
|
|
|
}, {
|
|
|
|
.alg = "rfc7539esp(chacha20,poly1305)",
|
|
|
|
.test = alg_test_aead,
|
|
|
|
.suite = {
|
|
|
|
.aead = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(rfc7539esp_enc_tv_template),
|
|
|
|
.dec = __VECS(rfc7539esp_dec_tv_template),
|
2015-06-01 19:44:03 +08:00
|
|
|
}
|
|
|
|
}
|
2008-07-31 17:08:25 +08:00
|
|
|
}, {
|
|
|
|
.alg = "rmd128",
|
|
|
|
.test = alg_test_hash,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(rmd128_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "rmd160",
|
|
|
|
.test = alg_test_hash,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(rmd160_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "rmd256",
|
|
|
|
.test = alg_test_hash,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(rmd256_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "rmd320",
|
|
|
|
.test = alg_test_hash,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(rmd320_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
2015-06-17 01:31:06 +08:00
|
|
|
}, {
|
|
|
|
.alg = "rsa",
|
|
|
|
.test = alg_test_akcipher,
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.akcipher = __VECS(rsa_tv_template)
|
2015-06-17 01:31:06 +08:00
|
|
|
}
|
2008-07-31 17:08:25 +08:00
|
|
|
}, {
|
|
|
|
.alg = "salsa20",
|
2008-08-17 15:01:56 +08:00
|
|
|
.test = alg_test_skcipher,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(salsa20_stream_enc_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "sha1",
|
|
|
|
.test = alg_test_hash,
|
2009-05-15 13:16:03 +08:00
|
|
|
.fips_allowed = 1,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(sha1_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "sha224",
|
|
|
|
.test = alg_test_hash,
|
2009-05-15 13:16:03 +08:00
|
|
|
.fips_allowed = 1,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(sha224_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "sha256",
|
|
|
|
.test = alg_test_hash,
|
2009-05-15 13:16:03 +08:00
|
|
|
.fips_allowed = 1,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(sha256_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
2016-06-17 13:00:36 +08:00
|
|
|
}, {
|
|
|
|
.alg = "sha3-224",
|
|
|
|
.test = alg_test_hash,
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(sha3_224_tv_template)
|
2016-06-17 13:00:36 +08:00
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "sha3-256",
|
|
|
|
.test = alg_test_hash,
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(sha3_256_tv_template)
|
2016-06-17 13:00:36 +08:00
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "sha3-384",
|
|
|
|
.test = alg_test_hash,
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(sha3_384_tv_template)
|
2016-06-17 13:00:36 +08:00
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "sha3-512",
|
|
|
|
.test = alg_test_hash,
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(sha3_512_tv_template)
|
2016-06-17 13:00:36 +08:00
|
|
|
}
|
2008-07-31 17:08:25 +08:00
|
|
|
}, {
|
|
|
|
.alg = "sha384",
|
|
|
|
.test = alg_test_hash,
|
2009-05-15 13:16:03 +08:00
|
|
|
.fips_allowed = 1,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(sha384_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "sha512",
|
|
|
|
.test = alg_test_hash,
|
2009-05-15 13:16:03 +08:00
|
|
|
.fips_allowed = 1,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(sha512_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
2017-08-21 18:51:29 +08:00
|
|
|
}, {
|
|
|
|
.alg = "sm3",
|
|
|
|
.test = alg_test_hash,
|
|
|
|
.suite = {
|
|
|
|
.hash = __VECS(sm3_tv_template)
|
|
|
|
}
|
2008-07-31 17:08:25 +08:00
|
|
|
}, {
|
|
|
|
.alg = "tgr128",
|
|
|
|
.test = alg_test_hash,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(tgr128_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "tgr160",
|
|
|
|
.test = alg_test_hash,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(tgr160_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "tgr192",
|
|
|
|
.test = alg_test_hash,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(tgr192_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
2009-09-02 18:05:22 +08:00
|
|
|
}, {
|
|
|
|
.alg = "vmac(aes)",
|
|
|
|
.test = alg_test_hash,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(aes_vmac128_tv_template)
|
2009-09-02 18:05:22 +08:00
|
|
|
}
|
2008-07-31 17:08:25 +08:00
|
|
|
}, {
|
|
|
|
.alg = "wp256",
|
|
|
|
.test = alg_test_hash,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(wp256_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "wp384",
|
|
|
|
.test = alg_test_hash,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(wp384_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "wp512",
|
|
|
|
.test = alg_test_hash,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(wp512_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "xcbc(aes)",
|
|
|
|
.test = alg_test_hash,
|
|
|
|
.suite = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.hash = __VECS(aes_xcbc128_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}, {
|
|
|
|
.alg = "xts(aes)",
|
2008-08-17 15:01:56 +08:00
|
|
|
.test = alg_test_skcipher,
|
2011-01-29 12:14:01 +08:00
|
|
|
.fips_allowed = 1,
|
2008-07-31 17:08:25 +08:00
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(aes_xts_enc_tv_template),
|
|
|
|
.dec = __VECS(aes_xts_dec_tv_template)
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
}
|
2012-03-06 02:26:21 +08:00
|
|
|
}, {
|
|
|
|
.alg = "xts(camellia)",
|
|
|
|
.test = alg_test_skcipher,
|
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(camellia_xts_enc_tv_template),
|
|
|
|
.dec = __VECS(camellia_xts_dec_tv_template)
|
2012-03-06 02:26:21 +08:00
|
|
|
}
|
|
|
|
}
|
2012-07-12 01:38:29 +08:00
|
|
|
}, {
|
|
|
|
.alg = "xts(cast6)",
|
|
|
|
.test = alg_test_skcipher,
|
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(cast6_xts_enc_tv_template),
|
|
|
|
.dec = __VECS(cast6_xts_dec_tv_template)
|
2012-07-12 01:38:29 +08:00
|
|
|
}
|
|
|
|
}
|
2018-05-11 16:04:06 +08:00
|
|
|
}, {
|
|
|
|
/* Same as xts(aes) except the key is stored in
|
|
|
|
* hardware secure memory which we reference by index
|
|
|
|
*/
|
|
|
|
.alg = "xts(paes)",
|
|
|
|
.test = alg_test_null,
|
|
|
|
.fips_allowed = 1,
|
2011-10-18 18:33:17 +08:00
|
|
|
}, {
|
|
|
|
.alg = "xts(serpent)",
|
|
|
|
.test = alg_test_skcipher,
|
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(serpent_xts_enc_tv_template),
|
|
|
|
.dec = __VECS(serpent_xts_dec_tv_template)
|
2011-10-18 18:33:17 +08:00
|
|
|
}
|
|
|
|
}
|
2018-02-15 02:42:22 +08:00
|
|
|
}, {
|
|
|
|
.alg = "xts(speck128)",
|
|
|
|
.test = alg_test_skcipher,
|
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
|
|
|
.enc = __VECS(speck128_xts_enc_tv_template),
|
|
|
|
.dec = __VECS(speck128_xts_dec_tv_template)
|
|
|
|
}
|
|
|
|
}
|
2018-02-15 02:42:23 +08:00
|
|
|
}, {
|
|
|
|
.alg = "xts(speck64)",
|
|
|
|
.test = alg_test_skcipher,
|
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
|
|
|
.enc = __VECS(speck64_xts_enc_tv_template),
|
|
|
|
.dec = __VECS(speck64_xts_dec_tv_template)
|
|
|
|
}
|
|
|
|
}
|
2011-10-18 18:33:33 +08:00
|
|
|
}, {
|
|
|
|
.alg = "xts(twofish)",
|
|
|
|
.test = alg_test_skcipher,
|
|
|
|
.suite = {
|
|
|
|
.cipher = {
|
2017-01-12 21:40:39 +08:00
|
|
|
.enc = __VECS(tf_xts_enc_tv_template),
|
|
|
|
.dec = __VECS(tf_xts_dec_tv_template)
|
2011-10-18 18:33:33 +08:00
|
|
|
}
|
|
|
|
}
|
2018-05-11 16:04:06 +08:00
|
|
|
}, {
|
|
|
|
.alg = "xts4096(paes)",
|
|
|
|
.test = alg_test_null,
|
|
|
|
.fips_allowed = 1,
|
|
|
|
}, {
|
|
|
|
.alg = "xts512(paes)",
|
|
|
|
.test = alg_test_null,
|
|
|
|
.fips_allowed = 1,
|
2017-04-22 04:54:30 +08:00
|
|
|
}, {
|
|
|
|
.alg = "zlib-deflate",
|
|
|
|
.test = alg_test_comp,
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.suite = {
|
|
|
|
.comp = {
|
|
|
|
.comp = __VECS(zlib_deflate_comp_tv_template),
|
|
|
|
.decomp = __VECS(zlib_deflate_decomp_tv_template)
|
|
|
|
}
|
|
|
|
}
|
2018-03-31 03:14:53 +08:00
|
|
|
}, {
|
|
|
|
.alg = "zstd",
|
|
|
|
.test = alg_test_comp,
|
|
|
|
.fips_allowed = 1,
|
|
|
|
.suite = {
|
|
|
|
.comp = {
|
|
|
|
.comp = __VECS(zstd_comp_tv_template),
|
|
|
|
.decomp = __VECS(zstd_decomp_tv_template)
|
|
|
|
}
|
|
|
|
}
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2013-06-13 22:37:40 +08:00
|
|
|
static bool alg_test_descs_checked;
|
|
|
|
|
|
|
|
static void alg_test_descs_check_order(void)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* only check once */
|
|
|
|
if (alg_test_descs_checked)
|
|
|
|
return;
|
|
|
|
|
|
|
|
alg_test_descs_checked = true;
|
|
|
|
|
|
|
|
for (i = 1; i < ARRAY_SIZE(alg_test_descs); i++) {
|
|
|
|
int diff = strcmp(alg_test_descs[i - 1].alg,
|
|
|
|
alg_test_descs[i].alg);
|
|
|
|
|
|
|
|
if (WARN_ON(diff > 0)) {
|
|
|
|
pr_warn("testmgr: alg_test_descs entries in wrong order: '%s' before '%s'\n",
|
|
|
|
alg_test_descs[i - 1].alg,
|
|
|
|
alg_test_descs[i].alg);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (WARN_ON(diff == 0)) {
|
|
|
|
pr_warn("testmgr: duplicate alg_test_descs entry: '%s'\n",
|
|
|
|
alg_test_descs[i].alg);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-08-17 15:01:56 +08:00
|
|
|
static int alg_find_test(const char *alg)
|
2008-07-31 17:08:25 +08:00
|
|
|
{
|
|
|
|
int start = 0;
|
|
|
|
int end = ARRAY_SIZE(alg_test_descs);
|
|
|
|
|
|
|
|
while (start < end) {
|
|
|
|
int i = (start + end) / 2;
|
|
|
|
int diff = strcmp(alg_test_descs[i].alg, alg);
|
|
|
|
|
|
|
|
if (diff > 0) {
|
|
|
|
end = i;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (diff < 0) {
|
|
|
|
start = i + 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2008-08-17 15:01:56 +08:00
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
|
|
|
|
{
|
|
|
|
int i;
|
2009-07-02 16:32:12 +08:00
|
|
|
int j;
|
2008-10-12 20:36:51 +08:00
|
|
|
int rc;
|
2008-08-17 15:01:56 +08:00
|
|
|
|
2016-05-03 17:00:17 +08:00
|
|
|
if (!fips_enabled && notests) {
|
|
|
|
printk_once(KERN_INFO "alg: self-tests disabled\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-06-13 22:37:40 +08:00
|
|
|
alg_test_descs_check_order();
|
|
|
|
|
2008-08-17 15:01:56 +08:00
|
|
|
if ((type & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_CIPHER) {
|
|
|
|
char nalg[CRYPTO_MAX_ALG_NAME];
|
|
|
|
|
|
|
|
if (snprintf(nalg, sizeof(nalg), "ecb(%s)", alg) >=
|
|
|
|
sizeof(nalg))
|
|
|
|
return -ENAMETOOLONG;
|
|
|
|
|
|
|
|
i = alg_find_test(nalg);
|
|
|
|
if (i < 0)
|
|
|
|
goto notest;
|
|
|
|
|
2009-05-15 13:17:05 +08:00
|
|
|
if (fips_enabled && !alg_test_descs[i].fips_allowed)
|
|
|
|
goto non_fips_alg;
|
|
|
|
|
2009-05-04 19:49:23 +08:00
|
|
|
rc = alg_test_cipher(alg_test_descs + i, driver, type, mask);
|
|
|
|
goto test_done;
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
|
|
|
|
2008-08-17 15:01:56 +08:00
|
|
|
i = alg_find_test(alg);
|
2009-07-02 16:32:12 +08:00
|
|
|
j = alg_find_test(driver);
|
|
|
|
if (i < 0 && j < 0)
|
2008-08-17 15:01:56 +08:00
|
|
|
goto notest;
|
|
|
|
|
2009-07-02 16:32:12 +08:00
|
|
|
if (fips_enabled && ((i >= 0 && !alg_test_descs[i].fips_allowed) ||
|
|
|
|
(j >= 0 && !alg_test_descs[j].fips_allowed)))
|
2009-05-15 13:17:05 +08:00
|
|
|
goto non_fips_alg;
|
|
|
|
|
2009-07-02 16:32:12 +08:00
|
|
|
rc = 0;
|
|
|
|
if (i >= 0)
|
|
|
|
rc |= alg_test_descs[i].test(alg_test_descs + i, driver,
|
|
|
|
type, mask);
|
2013-07-18 23:57:07 +08:00
|
|
|
if (j >= 0 && j != i)
|
2009-07-02 16:32:12 +08:00
|
|
|
rc |= alg_test_descs[j].test(alg_test_descs + j, driver,
|
|
|
|
type, mask);
|
|
|
|
|
2009-05-04 19:49:23 +08:00
|
|
|
test_done:
|
2008-10-12 20:36:51 +08:00
|
|
|
if (fips_enabled && rc)
|
|
|
|
panic("%s: %s alg self test failed in fips mode!\n", driver, alg);
|
|
|
|
|
2009-05-04 19:51:17 +08:00
|
|
|
if (fips_enabled && !rc)
|
2014-10-06 23:37:54 +08:00
|
|
|
pr_info("alg: self-tests for %s (%s) passed\n", driver, alg);
|
2009-05-04 19:51:17 +08:00
|
|
|
|
2008-10-12 20:36:51 +08:00
|
|
|
return rc;
|
2008-08-17 15:01:56 +08:00
|
|
|
|
|
|
|
notest:
|
2008-07-31 17:08:25 +08:00
|
|
|
printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver);
|
|
|
|
return 0;
|
2009-05-15 13:17:05 +08:00
|
|
|
non_fips_alg:
|
|
|
|
return -EINVAL;
|
2008-07-31 17:08:25 +08:00
|
|
|
}
|
2010-06-03 18:53:43 +08:00
|
|
|
|
2010-08-06 09:40:28 +08:00
|
|
|
#endif /* CONFIG_CRYPTO_MANAGER_DISABLE_TESTS */
|
2010-06-03 18:53:43 +08:00
|
|
|
|
2008-07-31 17:08:25 +08:00
|
|
|
EXPORT_SYMBOL_GPL(alg_test);
|