mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-25 10:19:47 +00:00
![Herbert Xu](/assets/img/avatar_default.png)
The combination of sha1 and aes was disabled in FIPS Mode
accidentally. This patch reenables it.
Fixes: 284a0f6e87
("crypto: testmgr - Disable fips-allowed for...")
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
Acked-by: Stephan Müller <smueller@chronox.de>
3729 lines
84 KiB
C
3729 lines
84 KiB
C
/*
|
|
* 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>
|
|
*
|
|
* 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.
|
|
*
|
|
* 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.
|
|
*
|
|
*/
|
|
|
|
#include <crypto/aead.h>
|
|
#include <crypto/hash.h>
|
|
#include <crypto/skcipher.h>
|
|
#include <linux/err.h>
|
|
#include <linux/fips.h>
|
|
#include <linux/module.h>
|
|
#include <linux/scatterlist.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/string.h>
|
|
#include <crypto/rng.h>
|
|
#include <crypto/drbg.h>
|
|
#include <crypto/akcipher.h>
|
|
#include <crypto/kpp.h>
|
|
#include <crypto/acompress.h>
|
|
|
|
#include "internal.h"
|
|
|
|
static bool notests;
|
|
module_param(notests, bool, 0644);
|
|
MODULE_PARM_DESC(notests, "disable crypto self-tests");
|
|
|
|
#ifdef CONFIG_CRYPTO_MANAGER_DISABLE_TESTS
|
|
|
|
/* a perfect nop */
|
|
int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
#else
|
|
|
|
#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
|
|
#define IDX3 1511
|
|
#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 tcrypt_result {
|
|
struct completion completion;
|
|
int err;
|
|
};
|
|
|
|
struct aead_test_suite {
|
|
struct {
|
|
const struct aead_testvec *vecs;
|
|
unsigned int count;
|
|
} enc, dec;
|
|
};
|
|
|
|
struct cipher_test_suite {
|
|
struct {
|
|
const struct cipher_testvec *vecs;
|
|
unsigned int count;
|
|
} enc, dec;
|
|
};
|
|
|
|
struct comp_test_suite {
|
|
struct {
|
|
const struct comp_testvec *vecs;
|
|
unsigned int count;
|
|
} comp, decomp;
|
|
};
|
|
|
|
struct hash_test_suite {
|
|
const struct hash_testvec *vecs;
|
|
unsigned int count;
|
|
};
|
|
|
|
struct cprng_test_suite {
|
|
const struct cprng_testvec *vecs;
|
|
unsigned int count;
|
|
};
|
|
|
|
struct drbg_test_suite {
|
|
const struct drbg_testvec *vecs;
|
|
unsigned int count;
|
|
};
|
|
|
|
struct akcipher_test_suite {
|
|
const struct akcipher_testvec *vecs;
|
|
unsigned int count;
|
|
};
|
|
|
|
struct kpp_test_suite {
|
|
const struct kpp_testvec *vecs;
|
|
unsigned int count;
|
|
};
|
|
|
|
struct alg_test_desc {
|
|
const char *alg;
|
|
int (*test)(const struct alg_test_desc *desc, const char *driver,
|
|
u32 type, u32 mask);
|
|
int fips_allowed; /* set if alg is allowed in fips mode */
|
|
|
|
union {
|
|
struct aead_test_suite aead;
|
|
struct cipher_test_suite cipher;
|
|
struct comp_test_suite comp;
|
|
struct hash_test_suite hash;
|
|
struct cprng_test_suite cprng;
|
|
struct drbg_test_suite drbg;
|
|
struct akcipher_test_suite akcipher;
|
|
struct kpp_test_suite kpp;
|
|
} suite;
|
|
};
|
|
|
|
static const unsigned int IDX[8] = {
|
|
IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
|
|
|
|
static void hexdump(unsigned char *buf, unsigned int len)
|
|
{
|
|
print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET,
|
|
16, 1,
|
|
buf, len, false);
|
|
}
|
|
|
|
static void tcrypt_complete(struct crypto_async_request *req, int err)
|
|
{
|
|
struct tcrypt_result *res = req->data;
|
|
|
|
if (err == -EINPROGRESS)
|
|
return;
|
|
|
|
res->err = err;
|
|
complete(&res->completion);
|
|
}
|
|
|
|
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]);
|
|
}
|
|
|
|
static int wait_async_op(struct tcrypt_result *tr, int ret)
|
|
{
|
|
if (ret == -EINPROGRESS || ret == -EBUSY) {
|
|
wait_for_completion(&tr->completion);
|
|
reinit_completion(&tr->completion);
|
|
ret = tr->err;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int ahash_partial_update(struct ahash_request **preq,
|
|
struct crypto_ahash *tfm, const struct hash_testvec *template,
|
|
void *hash_buff, int k, int temp, struct scatterlist *sg,
|
|
const char *algo, char *result, struct tcrypt_result *tresult)
|
|
{
|
|
char *state;
|
|
struct ahash_request *req;
|
|
int statesize, ret = -EINVAL;
|
|
const char guard[] = { 0x00, 0xba, 0xad, 0x00 };
|
|
|
|
req = *preq;
|
|
statesize = crypto_ahash_statesize(
|
|
crypto_ahash_reqtfm(req));
|
|
state = kmalloc(statesize + sizeof(guard), GFP_KERNEL);
|
|
if (!state) {
|
|
pr_err("alg: hash: Failed to alloc state for %s\n", algo);
|
|
goto out_nostate;
|
|
}
|
|
memcpy(state + statesize, guard, sizeof(guard));
|
|
ret = crypto_ahash_export(req, state);
|
|
WARN_ON(memcmp(state + statesize, guard, sizeof(guard)));
|
|
if (ret) {
|
|
pr_err("alg: hash: Failed to export() for %s\n", algo);
|
|
goto out;
|
|
}
|
|
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,
|
|
tcrypt_complete, tresult);
|
|
|
|
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;
|
|
}
|
|
ret = wait_async_op(tresult, crypto_ahash_update(req));
|
|
if (ret)
|
|
goto out;
|
|
*preq = req;
|
|
ret = 0;
|
|
goto out_noreq;
|
|
out:
|
|
ahash_request_free(req);
|
|
out_noreq:
|
|
kfree(state);
|
|
out_nostate:
|
|
return ret;
|
|
}
|
|
|
|
static int __test_hash(struct crypto_ahash *tfm,
|
|
const struct hash_testvec *template, unsigned int tcount,
|
|
bool use_digest, const int align_offset)
|
|
{
|
|
const char *algo = crypto_tfm_alg_driver_name(crypto_ahash_tfm(tfm));
|
|
size_t digest_size = crypto_ahash_digestsize(tfm);
|
|
unsigned int i, j, k, temp;
|
|
struct scatterlist sg[8];
|
|
char *result;
|
|
char *key;
|
|
struct ahash_request *req;
|
|
struct tcrypt_result tresult;
|
|
void *hash_buff;
|
|
char *xbuf[XBUFSIZE];
|
|
int ret = -ENOMEM;
|
|
|
|
result = kmalloc(digest_size, GFP_KERNEL);
|
|
if (!result)
|
|
return ret;
|
|
key = kmalloc(MAX_KEYLEN, GFP_KERNEL);
|
|
if (!key)
|
|
goto out_nobuf;
|
|
if (testmgr_alloc_buf(xbuf))
|
|
goto out_nobuf;
|
|
|
|
init_completion(&tresult.completion);
|
|
|
|
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,
|
|
tcrypt_complete, &tresult);
|
|
|
|
j = 0;
|
|
for (i = 0; i < tcount; i++) {
|
|
if (template[i].np)
|
|
continue;
|
|
|
|
ret = -EINVAL;
|
|
if (WARN_ON(align_offset + template[i].psize > PAGE_SIZE))
|
|
goto out;
|
|
|
|
j++;
|
|
memset(result, 0, digest_size);
|
|
|
|
hash_buff = xbuf[0];
|
|
hash_buff += align_offset;
|
|
|
|
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);
|
|
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) {
|
|
printk(KERN_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].psize);
|
|
if (use_digest) {
|
|
ret = wait_async_op(&tresult, crypto_ahash_digest(req));
|
|
if (ret) {
|
|
pr_err("alg: hash: digest failed on test %d "
|
|
"for %s: ret=%d\n", j, algo, -ret);
|
|
goto out;
|
|
}
|
|
} else {
|
|
ret = wait_async_op(&tresult, crypto_ahash_init(req));
|
|
if (ret) {
|
|
pr_err("alg: hash: init failed on test %d "
|
|
"for %s: ret=%d\n", j, algo, -ret);
|
|
goto out;
|
|
}
|
|
ret = wait_async_op(&tresult, crypto_ahash_update(req));
|
|
if (ret) {
|
|
pr_err("alg: hash: update failed on test %d "
|
|
"for %s: ret=%d\n", j, algo, -ret);
|
|
goto out;
|
|
}
|
|
ret = wait_async_op(&tresult, crypto_ahash_final(req));
|
|
if (ret) {
|
|
pr_err("alg: hash: final failed on test %d "
|
|
"for %s: ret=%d\n", j, algo, -ret);
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
if (memcmp(result, template[i].digest,
|
|
crypto_ahash_digestsize(tfm))) {
|
|
printk(KERN_ERR "alg: hash: Test %d failed for %s\n",
|
|
j, algo);
|
|
hexdump(result, crypto_ahash_digestsize(tfm));
|
|
ret = -EINVAL;
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
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)
|
|
continue;
|
|
|
|
j++;
|
|
memset(result, 0, digest_size);
|
|
|
|
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];
|
|
}
|
|
|
|
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;
|
|
goto out;
|
|
}
|
|
crypto_ahash_clear_flags(tfm, ~0);
|
|
memcpy(key, template[i].key, template[i].ksize);
|
|
ret = crypto_ahash_setkey(tfm, key, template[i].ksize);
|
|
|
|
if (ret) {
|
|
printk(KERN_ERR "alg: hash: setkey "
|
|
"failed on chunking test %d "
|
|
"for %s: ret=%d\n", j, algo, -ret);
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
ahash_request_set_crypt(req, sg, result, template[i].psize);
|
|
ret = crypto_ahash_digest(req);
|
|
switch (ret) {
|
|
case 0:
|
|
break;
|
|
case -EINPROGRESS:
|
|
case -EBUSY:
|
|
wait_for_completion(&tresult.completion);
|
|
reinit_completion(&tresult.completion);
|
|
ret = tresult.err;
|
|
if (!ret)
|
|
break;
|
|
/* fall through */
|
|
default:
|
|
printk(KERN_ERR "alg: hash: digest failed "
|
|
"on chunking test %d for %s: "
|
|
"ret=%d\n", j, algo, -ret);
|
|
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;
|
|
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++;
|
|
memset(result, 0, digest_size);
|
|
|
|
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]);
|
|
ret = wait_async_op(&tresult, crypto_ahash_init(req));
|
|
if (ret) {
|
|
pr_err("alg: hash: init failed on test %d for %s: ret=%d\n",
|
|
j, algo, -ret);
|
|
goto out;
|
|
}
|
|
ret = wait_async_op(&tresult, crypto_ahash_update(req));
|
|
if (ret) {
|
|
pr_err("alg: hash: update failed on test %d for %s: ret=%d\n",
|
|
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,
|
|
&tresult);
|
|
if (ret) {
|
|
pr_err("alg: hash: partial update failed on test %d for %s: ret=%d\n",
|
|
j, algo, -ret);
|
|
goto out_noreq;
|
|
}
|
|
temp += template[i].tap[k];
|
|
}
|
|
ret = wait_async_op(&tresult, crypto_ahash_final(req));
|
|
if (ret) {
|
|
pr_err("alg: hash: final failed on test %d for %s: ret=%d\n",
|
|
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;
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
ret = 0;
|
|
|
|
out:
|
|
ahash_request_free(req);
|
|
out_noreq:
|
|
testmgr_free_buf(xbuf);
|
|
out_nobuf:
|
|
kfree(key);
|
|
kfree(result);
|
|
return ret;
|
|
}
|
|
|
|
static int test_hash(struct crypto_ahash *tfm,
|
|
const struct hash_testvec *template,
|
|
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;
|
|
}
|
|
|
|
static int __test_aead(struct crypto_aead *tfm, int enc,
|
|
const struct aead_testvec *template, unsigned int tcount,
|
|
const bool diff_dst, const int align_offset)
|
|
{
|
|
const char *algo = crypto_tfm_alg_driver_name(crypto_aead_tfm(tfm));
|
|
unsigned int i, j, k, n, temp;
|
|
int ret = -ENOMEM;
|
|
char *q;
|
|
char *key;
|
|
struct aead_request *req;
|
|
struct scatterlist *sg;
|
|
struct scatterlist *sgout;
|
|
const char *e, *d;
|
|
struct tcrypt_result result;
|
|
unsigned int authsize, iv_len;
|
|
void *input;
|
|
void *output;
|
|
void *assoc;
|
|
char *iv;
|
|
char *xbuf[XBUFSIZE];
|
|
char *xoutbuf[XBUFSIZE];
|
|
char *axbuf[XBUFSIZE];
|
|
|
|
iv = kzalloc(MAX_IVLEN, GFP_KERNEL);
|
|
if (!iv)
|
|
return ret;
|
|
key = kmalloc(MAX_KEYLEN, GFP_KERNEL);
|
|
if (!key)
|
|
goto out_noxbuf;
|
|
if (testmgr_alloc_buf(xbuf))
|
|
goto out_noxbuf;
|
|
if (testmgr_alloc_buf(axbuf))
|
|
goto out_noaxbuf;
|
|
if (diff_dst && testmgr_alloc_buf(xoutbuf))
|
|
goto out_nooutbuf;
|
|
|
|
/* avoid "the frame size is larger than 1024 bytes" compiler warning */
|
|
sg = kmalloc(sizeof(*sg) * 8 * (diff_dst ? 4 : 2), GFP_KERNEL);
|
|
if (!sg)
|
|
goto out_nosg;
|
|
sgout = &sg[16];
|
|
|
|
if (diff_dst)
|
|
d = "-ddst";
|
|
else
|
|
d = "";
|
|
|
|
if (enc == ENCRYPT)
|
|
e = "encryption";
|
|
else
|
|
e = "decryption";
|
|
|
|
init_completion(&result.completion);
|
|
|
|
req = aead_request_alloc(tfm, GFP_KERNEL);
|
|
if (!req) {
|
|
pr_err("alg: aead%s: Failed to allocate request for %s\n",
|
|
d, algo);
|
|
goto out;
|
|
}
|
|
|
|
aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
|
|
tcrypt_complete, &result);
|
|
|
|
iv_len = crypto_aead_ivsize(tfm);
|
|
|
|
for (i = 0, j = 0; i < tcount; i++) {
|
|
if (template[i].np)
|
|
continue;
|
|
|
|
j++;
|
|
|
|
/* some templates have no input data but they will
|
|
* touch input
|
|
*/
|
|
input = xbuf[0];
|
|
input += align_offset;
|
|
assoc = axbuf[0];
|
|
|
|
ret = -EINVAL;
|
|
if (WARN_ON(align_offset + template[i].ilen >
|
|
PAGE_SIZE || template[i].alen > PAGE_SIZE))
|
|
goto out;
|
|
|
|
memcpy(input, template[i].input, template[i].ilen);
|
|
memcpy(assoc, template[i].assoc, template[i].alen);
|
|
if (template[i].iv)
|
|
memcpy(iv, template[i].iv, iv_len);
|
|
else
|
|
memset(iv, 0, iv_len);
|
|
|
|
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);
|
|
|
|
ret = crypto_aead_setkey(tfm, key, template[i].klen);
|
|
if (template[i].fail == !ret) {
|
|
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;
|
|
|
|
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;
|
|
}
|
|
|
|
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;
|
|
|
|
if (diff_dst) {
|
|
sg_init_table(sgout, k + 1);
|
|
sg_set_buf(&sgout[0], assoc, template[i].alen);
|
|
|
|
output = xoutbuf[0];
|
|
output += align_offset;
|
|
sg_set_buf(&sgout[k], output,
|
|
template[i].rlen + (enc ? 0 : authsize));
|
|
}
|
|
|
|
aead_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
|
|
template[i].ilen, iv);
|
|
|
|
aead_request_set_ad(req, template[i].alen);
|
|
|
|
ret = enc ? crypto_aead_encrypt(req) : crypto_aead_decrypt(req);
|
|
|
|
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;
|
|
goto out;
|
|
}
|
|
break;
|
|
case -EINPROGRESS:
|
|
case -EBUSY:
|
|
wait_for_completion(&result.completion);
|
|
reinit_completion(&result.completion);
|
|
ret = result.err;
|
|
if (!ret)
|
|
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;
|
|
}
|
|
}
|
|
|
|
for (i = 0, j = 0; i < tcount; i++) {
|
|
/* alignment tests are only done with continuous buffers */
|
|
if (align_offset != 0)
|
|
break;
|
|
|
|
if (!template[i].np)
|
|
continue;
|
|
|
|
j++;
|
|
|
|
if (template[i].iv)
|
|
memcpy(iv, template[i].iv, iv_len);
|
|
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);
|
|
|
|
ret = crypto_aead_setkey(tfm, key, template[i].klen);
|
|
if (template[i].fail == !ret) {
|
|
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;
|
|
|
|
authsize = abs(template[i].rlen - template[i].ilen);
|
|
|
|
ret = -EINVAL;
|
|
sg_init_table(sg, template[i].anp + template[i].np);
|
|
if (diff_dst)
|
|
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];
|
|
}
|
|
|
|
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;
|
|
|
|
q = xbuf[IDX[k] >> PAGE_SHIFT] + offset_in_page(IDX[k]);
|
|
memcpy(q, template[i].input + temp, template[i].tap[k]);
|
|
sg_set_buf(&sg[template[i].anp + k],
|
|
q, template[i].tap[k]);
|
|
|
|
if (diff_dst) {
|
|
q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
|
|
offset_in_page(IDX[k]);
|
|
|
|
memset(q, 0, template[i].tap[k]);
|
|
|
|
sg_set_buf(&sgout[template[i].anp + k],
|
|
q, template[i].tap[k]);
|
|
}
|
|
|
|
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;
|
|
|
|
temp += template[i].tap[k];
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
if (enc) {
|
|
if (WARN_ON(sg[template[i].anp + k - 1].offset +
|
|
sg[template[i].anp + k - 1].length +
|
|
authsize > PAGE_SIZE)) {
|
|
ret = -EINVAL;
|
|
goto out;
|
|
}
|
|
|
|
if (diff_dst)
|
|
sgout[template[i].anp + k - 1].length +=
|
|
authsize;
|
|
sg[template[i].anp + k - 1].length += authsize;
|
|
}
|
|
|
|
aead_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
|
|
template[i].ilen,
|
|
iv);
|
|
|
|
aead_request_set_ad(req, template[i].alen);
|
|
|
|
ret = enc ? crypto_aead_encrypt(req) : crypto_aead_decrypt(req);
|
|
|
|
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;
|
|
goto out;
|
|
}
|
|
break;
|
|
case -EINPROGRESS:
|
|
case -EBUSY:
|
|
wait_for_completion(&result.completion);
|
|
reinit_completion(&result.completion);
|
|
ret = result.err;
|
|
if (!ret)
|
|
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;
|
|
}
|
|
|
|
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]);
|
|
|
|
n = template[i].tap[k];
|
|
if (k == template[i].np - 1)
|
|
n += enc ? authsize : -authsize;
|
|
|
|
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;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
temp += template[i].tap[k];
|
|
}
|
|
}
|
|
|
|
ret = 0;
|
|
|
|
out:
|
|
aead_request_free(req);
|
|
kfree(sg);
|
|
out_nosg:
|
|
if (diff_dst)
|
|
testmgr_free_buf(xoutbuf);
|
|
out_nooutbuf:
|
|
testmgr_free_buf(axbuf);
|
|
out_noaxbuf:
|
|
testmgr_free_buf(xbuf);
|
|
out_noxbuf:
|
|
kfree(key);
|
|
kfree(iv);
|
|
return ret;
|
|
}
|
|
|
|
static int test_aead(struct crypto_aead *tfm, int enc,
|
|
const struct aead_testvec *template, unsigned int tcount)
|
|
{
|
|
unsigned int alignmask;
|
|
int ret;
|
|
|
|
/* test 'dst == src' case */
|
|
ret = __test_aead(tfm, enc, template, tcount, false, 0);
|
|
if (ret)
|
|
return ret;
|
|
|
|
/* test 'dst != src' case */
|
|
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;
|
|
}
|
|
|
|
static int test_cipher(struct crypto_cipher *tfm, int enc,
|
|
const struct cipher_testvec *template,
|
|
unsigned int tcount)
|
|
{
|
|
const char *algo = crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm));
|
|
unsigned int i, j, k;
|
|
char *q;
|
|
const char *e;
|
|
void *data;
|
|
char *xbuf[XBUFSIZE];
|
|
int ret = -ENOMEM;
|
|
|
|
if (testmgr_alloc_buf(xbuf))
|
|
goto out_nobuf;
|
|
|
|
if (enc == ENCRYPT)
|
|
e = "encryption";
|
|
else
|
|
e = "decryption";
|
|
|
|
j = 0;
|
|
for (i = 0; i < tcount; i++) {
|
|
if (template[i].np)
|
|
continue;
|
|
|
|
if (fips_enabled && template[i].fips_skip)
|
|
continue;
|
|
|
|
j++;
|
|
|
|
ret = -EINVAL;
|
|
if (WARN_ON(template[i].ilen > PAGE_SIZE))
|
|
goto out;
|
|
|
|
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);
|
|
if (template[i].fail == !ret) {
|
|
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:
|
|
testmgr_free_buf(xbuf);
|
|
out_nobuf:
|
|
return ret;
|
|
}
|
|
|
|
static int __test_skcipher(struct crypto_skcipher *tfm, int enc,
|
|
const struct cipher_testvec *template,
|
|
unsigned int tcount,
|
|
const bool diff_dst, const int align_offset)
|
|
{
|
|
const char *algo =
|
|
crypto_tfm_alg_driver_name(crypto_skcipher_tfm(tfm));
|
|
unsigned int i, j, k, n, temp;
|
|
char *q;
|
|
struct skcipher_request *req;
|
|
struct scatterlist sg[8];
|
|
struct scatterlist sgout[8];
|
|
const char *e, *d;
|
|
struct tcrypt_result result;
|
|
void *data;
|
|
char iv[MAX_IVLEN];
|
|
char *xbuf[XBUFSIZE];
|
|
char *xoutbuf[XBUFSIZE];
|
|
int ret = -ENOMEM;
|
|
unsigned int ivsize = crypto_skcipher_ivsize(tfm);
|
|
|
|
if (testmgr_alloc_buf(xbuf))
|
|
goto out_nobuf;
|
|
|
|
if (diff_dst && testmgr_alloc_buf(xoutbuf))
|
|
goto out_nooutbuf;
|
|
|
|
if (diff_dst)
|
|
d = "-ddst";
|
|
else
|
|
d = "";
|
|
|
|
if (enc == ENCRYPT)
|
|
e = "encryption";
|
|
else
|
|
e = "decryption";
|
|
|
|
init_completion(&result.completion);
|
|
|
|
req = skcipher_request_alloc(tfm, GFP_KERNEL);
|
|
if (!req) {
|
|
pr_err("alg: skcipher%s: Failed to allocate request for %s\n",
|
|
d, algo);
|
|
goto out;
|
|
}
|
|
|
|
skcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
|
|
tcrypt_complete, &result);
|
|
|
|
j = 0;
|
|
for (i = 0; i < tcount; i++) {
|
|
if (template[i].np && !template[i].also_non_np)
|
|
continue;
|
|
|
|
if (fips_enabled && template[i].fips_skip)
|
|
continue;
|
|
|
|
if (template[i].iv)
|
|
memcpy(iv, template[i].iv, ivsize);
|
|
else
|
|
memset(iv, 0, MAX_IVLEN);
|
|
|
|
j++;
|
|
ret = -EINVAL;
|
|
if (WARN_ON(align_offset + template[i].ilen > PAGE_SIZE))
|
|
goto out;
|
|
|
|
data = xbuf[0];
|
|
data += align_offset;
|
|
memcpy(data, template[i].input, template[i].ilen);
|
|
|
|
crypto_skcipher_clear_flags(tfm, ~0);
|
|
if (template[i].wk)
|
|
crypto_skcipher_set_flags(tfm,
|
|
CRYPTO_TFM_REQ_WEAK_KEY);
|
|
|
|
ret = crypto_skcipher_setkey(tfm, template[i].key,
|
|
template[i].klen);
|
|
if (template[i].fail == !ret) {
|
|
pr_err("alg: skcipher%s: setkey failed on test %d for %s: flags=%x\n",
|
|
d, j, algo, crypto_skcipher_get_flags(tfm));
|
|
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);
|
|
}
|
|
|
|
skcipher_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
|
|
template[i].ilen, iv);
|
|
ret = enc ? crypto_skcipher_encrypt(req) :
|
|
crypto_skcipher_decrypt(req);
|
|
|
|
switch (ret) {
|
|
case 0:
|
|
break;
|
|
case -EINPROGRESS:
|
|
case -EBUSY:
|
|
wait_for_completion(&result.completion);
|
|
reinit_completion(&result.completion);
|
|
ret = result.err;
|
|
if (!ret)
|
|
break;
|
|
/* fall through */
|
|
default:
|
|
pr_err("alg: skcipher%s: %s failed on test %d for %s: ret=%d\n",
|
|
d, e, j, algo, -ret);
|
|
goto out;
|
|
}
|
|
|
|
q = data;
|
|
if (memcmp(q, template[i].result, template[i].rlen)) {
|
|
pr_err("alg: skcipher%s: Test %d failed (invalid result) on %s for %s\n",
|
|
d, j, e, algo);
|
|
hexdump(q, template[i].rlen);
|
|
ret = -EINVAL;
|
|
goto out;
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
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)
|
|
continue;
|
|
|
|
if (fips_enabled && template[i].fips_skip)
|
|
continue;
|
|
|
|
if (template[i].iv)
|
|
memcpy(iv, template[i].iv, ivsize);
|
|
else
|
|
memset(iv, 0, MAX_IVLEN);
|
|
|
|
j++;
|
|
crypto_skcipher_clear_flags(tfm, ~0);
|
|
if (template[i].wk)
|
|
crypto_skcipher_set_flags(tfm,
|
|
CRYPTO_TFM_REQ_WEAK_KEY);
|
|
|
|
ret = crypto_skcipher_setkey(tfm, template[i].key,
|
|
template[i].klen);
|
|
if (template[i].fail == !ret) {
|
|
pr_err("alg: skcipher%s: setkey failed on chunk test %d for %s: flags=%x\n",
|
|
d, j, algo, crypto_skcipher_get_flags(tfm));
|
|
goto out;
|
|
} else if (ret)
|
|
continue;
|
|
|
|
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))
|
|
goto out;
|
|
|
|
q = xbuf[IDX[k] >> PAGE_SHIFT] + offset_in_page(IDX[k]);
|
|
|
|
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] +
|
|
offset_in_page(IDX[k]);
|
|
|
|
sg_set_buf(&sgout[k], q, template[i].tap[k]);
|
|
|
|
memset(q, 0, template[i].tap[k]);
|
|
if (offset_in_page(q) +
|
|
template[i].tap[k] < PAGE_SIZE)
|
|
q[template[i].tap[k]] = 0;
|
|
}
|
|
|
|
temp += template[i].tap[k];
|
|
}
|
|
|
|
skcipher_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
|
|
template[i].ilen, iv);
|
|
|
|
ret = enc ? crypto_skcipher_encrypt(req) :
|
|
crypto_skcipher_decrypt(req);
|
|
|
|
switch (ret) {
|
|
case 0:
|
|
break;
|
|
case -EINPROGRESS:
|
|
case -EBUSY:
|
|
wait_for_completion(&result.completion);
|
|
reinit_completion(&result.completion);
|
|
ret = result.err;
|
|
if (!ret)
|
|
break;
|
|
/* fall through */
|
|
default:
|
|
pr_err("alg: skcipher%s: %s failed on chunk test %d for %s: ret=%d\n",
|
|
d, e, j, algo, -ret);
|
|
goto out;
|
|
}
|
|
|
|
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]);
|
|
|
|
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]);
|
|
goto out;
|
|
}
|
|
|
|
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;
|
|
}
|
|
temp += template[i].tap[k];
|
|
}
|
|
}
|
|
|
|
ret = 0;
|
|
|
|
out:
|
|
skcipher_request_free(req);
|
|
if (diff_dst)
|
|
testmgr_free_buf(xoutbuf);
|
|
out_nooutbuf:
|
|
testmgr_free_buf(xbuf);
|
|
out_nobuf:
|
|
return ret;
|
|
}
|
|
|
|
static int test_skcipher(struct crypto_skcipher *tfm, int enc,
|
|
const struct cipher_testvec *template,
|
|
unsigned int tcount)
|
|
{
|
|
unsigned int alignmask;
|
|
int ret;
|
|
|
|
/* test 'dst == src' case */
|
|
ret = __test_skcipher(tfm, enc, template, tcount, false, 0);
|
|
if (ret)
|
|
return ret;
|
|
|
|
/* test 'dst != src' case */
|
|
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;
|
|
}
|
|
|
|
static int test_comp(struct crypto_comp *tfm,
|
|
const struct comp_testvec *ctemplate,
|
|
const struct comp_testvec *dtemplate,
|
|
int ctcount, int dtcount)
|
|
{
|
|
const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm));
|
|
unsigned int i;
|
|
char result[COMP_BUF_SIZE];
|
|
int ret;
|
|
|
|
for (i = 0; i < ctcount; i++) {
|
|
int ilen;
|
|
unsigned int dlen = COMP_BUF_SIZE;
|
|
|
|
memset(result, 0, sizeof (result));
|
|
|
|
ilen = ctemplate[i].inlen;
|
|
ret = crypto_comp_compress(tfm, ctemplate[i].input,
|
|
ilen, result, &dlen);
|
|
if (ret) {
|
|
printk(KERN_ERR "alg: comp: compression failed "
|
|
"on test %d for %s: ret=%d\n", i + 1, algo,
|
|
-ret);
|
|
goto out;
|
|
}
|
|
|
|
if (dlen != ctemplate[i].outlen) {
|
|
printk(KERN_ERR "alg: comp: Compression test %d "
|
|
"failed for %s: output len = %d\n", i + 1, algo,
|
|
dlen);
|
|
ret = -EINVAL;
|
|
goto out;
|
|
}
|
|
|
|
if (memcmp(result, ctemplate[i].output, dlen)) {
|
|
printk(KERN_ERR "alg: comp: Compression test %d "
|
|
"failed for %s\n", i + 1, algo);
|
|
hexdump(result, dlen);
|
|
ret = -EINVAL;
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < dtcount; i++) {
|
|
int ilen;
|
|
unsigned int dlen = COMP_BUF_SIZE;
|
|
|
|
memset(result, 0, sizeof (result));
|
|
|
|
ilen = dtemplate[i].inlen;
|
|
ret = crypto_comp_decompress(tfm, dtemplate[i].input,
|
|
ilen, result, &dlen);
|
|
if (ret) {
|
|
printk(KERN_ERR "alg: comp: decompression failed "
|
|
"on test %d for %s: ret=%d\n", i + 1, algo,
|
|
-ret);
|
|
goto out;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
if (memcmp(result, dtemplate[i].output, dlen)) {
|
|
printk(KERN_ERR "alg: comp: Decompression test %d "
|
|
"failed for %s\n", i + 1, algo);
|
|
hexdump(result, dlen);
|
|
ret = -EINVAL;
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
ret = 0;
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
|
|
static int test_acomp(struct crypto_acomp *tfm,
|
|
const struct comp_testvec *ctemplate,
|
|
const struct comp_testvec *dtemplate,
|
|
int ctcount, int dtcount)
|
|
{
|
|
const char *algo = crypto_tfm_alg_driver_name(crypto_acomp_tfm(tfm));
|
|
unsigned int i;
|
|
char *output, *decomp_out;
|
|
int ret;
|
|
struct scatterlist src, dst;
|
|
struct acomp_req *req;
|
|
struct tcrypt_result result;
|
|
|
|
output = kmalloc(COMP_BUF_SIZE, GFP_KERNEL);
|
|
if (!output)
|
|
return -ENOMEM;
|
|
|
|
decomp_out = kmalloc(COMP_BUF_SIZE, GFP_KERNEL);
|
|
if (!decomp_out) {
|
|
kfree(output);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
for (i = 0; i < ctcount; i++) {
|
|
unsigned int dlen = COMP_BUF_SIZE;
|
|
int ilen = ctemplate[i].inlen;
|
|
void *input_vec;
|
|
|
|
input_vec = kmemdup(ctemplate[i].input, ilen, GFP_KERNEL);
|
|
if (!input_vec) {
|
|
ret = -ENOMEM;
|
|
goto out;
|
|
}
|
|
|
|
memset(output, 0, dlen);
|
|
init_completion(&result.completion);
|
|
sg_init_one(&src, input_vec, ilen);
|
|
sg_init_one(&dst, output, dlen);
|
|
|
|
req = acomp_request_alloc(tfm);
|
|
if (!req) {
|
|
pr_err("alg: acomp: request alloc failed for %s\n",
|
|
algo);
|
|
kfree(input_vec);
|
|
ret = -ENOMEM;
|
|
goto out;
|
|
}
|
|
|
|
acomp_request_set_params(req, &src, &dst, ilen, dlen);
|
|
acomp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
|
|
tcrypt_complete, &result);
|
|
|
|
ret = wait_async_op(&result, crypto_acomp_compress(req));
|
|
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;
|
|
}
|
|
|
|
ilen = req->dlen;
|
|
dlen = COMP_BUF_SIZE;
|
|
sg_init_one(&src, output, ilen);
|
|
sg_init_one(&dst, decomp_out, dlen);
|
|
init_completion(&result.completion);
|
|
acomp_request_set_params(req, &src, &dst, ilen, dlen);
|
|
|
|
ret = wait_async_op(&result, crypto_acomp_decompress(req));
|
|
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) {
|
|
pr_err("alg: acomp: Compression test %d failed for %s: output len = %d\n",
|
|
i + 1, algo, req->dlen);
|
|
ret = -EINVAL;
|
|
kfree(input_vec);
|
|
acomp_request_free(req);
|
|
goto out;
|
|
}
|
|
|
|
if (memcmp(input_vec, decomp_out, req->dlen)) {
|
|
pr_err("alg: acomp: Compression test %d failed for %s\n",
|
|
i + 1, algo);
|
|
hexdump(output, req->dlen);
|
|
ret = -EINVAL;
|
|
kfree(input_vec);
|
|
acomp_request_free(req);
|
|
goto out;
|
|
}
|
|
|
|
kfree(input_vec);
|
|
acomp_request_free(req);
|
|
}
|
|
|
|
for (i = 0; i < dtcount; i++) {
|
|
unsigned int dlen = COMP_BUF_SIZE;
|
|
int ilen = dtemplate[i].inlen;
|
|
void *input_vec;
|
|
|
|
input_vec = kmemdup(dtemplate[i].input, ilen, GFP_KERNEL);
|
|
if (!input_vec) {
|
|
ret = -ENOMEM;
|
|
goto out;
|
|
}
|
|
|
|
memset(output, 0, dlen);
|
|
init_completion(&result.completion);
|
|
sg_init_one(&src, input_vec, ilen);
|
|
sg_init_one(&dst, output, dlen);
|
|
|
|
req = acomp_request_alloc(tfm);
|
|
if (!req) {
|
|
pr_err("alg: acomp: request alloc failed for %s\n",
|
|
algo);
|
|
kfree(input_vec);
|
|
ret = -ENOMEM;
|
|
goto out;
|
|
}
|
|
|
|
acomp_request_set_params(req, &src, &dst, ilen, dlen);
|
|
acomp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
|
|
tcrypt_complete, &result);
|
|
|
|
ret = wait_async_op(&result, crypto_acomp_decompress(req));
|
|
if (ret) {
|
|
pr_err("alg: acomp: decompression 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 != dtemplate[i].outlen) {
|
|
pr_err("alg: acomp: Decompression test %d failed for %s: output len = %d\n",
|
|
i + 1, algo, req->dlen);
|
|
ret = -EINVAL;
|
|
kfree(input_vec);
|
|
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;
|
|
kfree(input_vec);
|
|
acomp_request_free(req);
|
|
goto out;
|
|
}
|
|
|
|
kfree(input_vec);
|
|
acomp_request_free(req);
|
|
}
|
|
|
|
ret = 0;
|
|
|
|
out:
|
|
kfree(decomp_out);
|
|
kfree(output);
|
|
return ret;
|
|
}
|
|
|
|
static int test_cprng(struct crypto_rng *tfm,
|
|
const struct cprng_testvec *template,
|
|
unsigned int tcount)
|
|
{
|
|
const char *algo = crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm));
|
|
int err = 0, i, j, seedsize;
|
|
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);
|
|
if (err < 0) {
|
|
printk(KERN_ERR "alg: cprng: Failed to obtain "
|
|
"the correct amount of random data for "
|
|
"%s (requested %d)\n", algo,
|
|
template[i].rlen);
|
|
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;
|
|
}
|
|
|
|
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;
|
|
|
|
tfm = crypto_alloc_aead(driver, type, mask);
|
|
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)
|
|
{
|
|
struct crypto_cipher *tfm;
|
|
int err = 0;
|
|
|
|
tfm = crypto_alloc_cipher(driver, type, mask);
|
|
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);
|
|
|
|
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)
|
|
{
|
|
struct crypto_skcipher *tfm;
|
|
int err = 0;
|
|
|
|
tfm = crypto_alloc_skcipher(driver, type, mask);
|
|
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);
|
|
|
|
out:
|
|
crypto_free_skcipher(tfm);
|
|
return err;
|
|
}
|
|
|
|
static int alg_test_comp(const struct alg_test_desc *desc, const char *driver,
|
|
u32 type, u32 mask)
|
|
{
|
|
struct crypto_comp *comp;
|
|
struct crypto_acomp *acomp;
|
|
int err;
|
|
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);
|
|
}
|
|
|
|
err = test_comp(comp, desc->suite.comp.comp.vecs,
|
|
desc->suite.comp.decomp.vecs,
|
|
desc->suite.comp.comp.count,
|
|
desc->suite.comp.decomp.count);
|
|
|
|
crypto_free_comp(comp);
|
|
}
|
|
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;
|
|
|
|
tfm = crypto_alloc_ahash(driver, type, mask);
|
|
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);
|
|
}
|
|
|
|
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);
|
|
|
|
crypto_free_ahash(tfm);
|
|
return err;
|
|
}
|
|
|
|
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;
|
|
|
|
tfm = crypto_alloc_shash(driver, type, mask);
|
|
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 {
|
|
SHASH_DESC_ON_STACK(shash, tfm);
|
|
u32 *ctx = (u32 *)shash_desc_ctx(shash);
|
|
|
|
shash->tfm = tfm;
|
|
shash->flags = 0;
|
|
|
|
*ctx = le32_to_cpu(420553207);
|
|
err = crypto_shash_final(shash, (u8 *)&val);
|
|
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;
|
|
}
|
|
|
|
static int alg_test_cprng(const struct alg_test_desc *desc, const char *driver,
|
|
u32 type, u32 mask)
|
|
{
|
|
struct crypto_rng *rng;
|
|
int err;
|
|
|
|
rng = crypto_alloc_rng(driver, type, mask);
|
|
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;
|
|
}
|
|
|
|
|
|
static int drbg_cavs_test(const struct drbg_testvec *test, int pr,
|
|
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;
|
|
|
|
drng = crypto_alloc_rng(driver, type, mask);
|
|
if (IS_ERR(drng)) {
|
|
printk(KERN_ERR "alg: drbg: could not allocate DRNG handle for "
|
|
"%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);
|
|
}
|
|
if (ret < 0) {
|
|
printk(KERN_ERR "alg: drbg: could not obtain random data for "
|
|
"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);
|
|
}
|
|
if (ret < 0) {
|
|
printk(KERN_ERR "alg: drbg: could not obtain random data for "
|
|
"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;
|
|
const struct drbg_testvec *template = desc->suite.drbg.vecs;
|
|
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;
|
|
|
|
}
|
|
|
|
static int do_test_kpp(struct crypto_kpp *tfm, const struct kpp_testvec *vec,
|
|
const char *alg)
|
|
{
|
|
struct kpp_request *req;
|
|
void *input_buf = NULL;
|
|
void *output_buf = NULL;
|
|
void *a_public = NULL;
|
|
void *a_ss = NULL;
|
|
void *shared_secret = NULL;
|
|
struct tcrypt_result result;
|
|
unsigned int out_len_max;
|
|
int err = -ENOMEM;
|
|
struct scatterlist src, dst;
|
|
|
|
req = kpp_request_alloc(tfm, GFP_KERNEL);
|
|
if (!req)
|
|
return err;
|
|
|
|
init_completion(&result.completion);
|
|
|
|
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,
|
|
tcrypt_complete, &result);
|
|
|
|
/* Compute party A's public key */
|
|
err = wait_async_op(&result, crypto_kpp_generate_public_key(req));
|
|
if (err) {
|
|
pr_err("alg: %s: Party A: generate public key test failed. err %d\n",
|
|
alg, err);
|
|
goto free_output;
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
/* 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,
|
|
tcrypt_complete, &result);
|
|
err = wait_async_op(&result, crypto_kpp_compute_shared_secret(req));
|
|
if (err) {
|
|
pr_err("alg: %s: Party A: compute shared secret test failed. err %d\n",
|
|
alg, err);
|
|
goto free_all;
|
|
}
|
|
|
|
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,
|
|
tcrypt_complete, &result);
|
|
err = wait_async_op(&result,
|
|
crypto_kpp_compute_shared_secret(req));
|
|
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;
|
|
}
|
|
|
|
/*
|
|
* verify shared secret from which the user will derive
|
|
* secret key by executing whatever hash it has chosen
|
|
*/
|
|
if (memcmp(shared_secret, sg_virt(req->dst),
|
|
vec->expected_ss_size)) {
|
|
pr_err("alg: %s: compute shared secret test failed. Invalid output\n",
|
|
alg);
|
|
err = -EINVAL;
|
|
}
|
|
|
|
free_all:
|
|
kfree(a_ss);
|
|
kfree(input_buf);
|
|
free_output:
|
|
kfree(a_public);
|
|
kfree(output_buf);
|
|
free_req:
|
|
kpp_request_free(req);
|
|
return err;
|
|
}
|
|
|
|
static int test_kpp(struct crypto_kpp *tfm, const char *alg,
|
|
const struct kpp_testvec *vecs, unsigned int tcount)
|
|
{
|
|
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;
|
|
|
|
tfm = crypto_alloc_kpp(driver, type, mask);
|
|
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;
|
|
}
|
|
|
|
static int test_akcipher_one(struct crypto_akcipher *tfm,
|
|
const struct akcipher_testvec *vecs)
|
|
{
|
|
char *xbuf[XBUFSIZE];
|
|
struct akcipher_request *req;
|
|
void *outbuf_enc = NULL;
|
|
void *outbuf_dec = NULL;
|
|
struct tcrypt_result result;
|
|
unsigned int out_len_max, out_len = 0;
|
|
int err = -ENOMEM;
|
|
struct scatterlist src, dst, src_tab[2];
|
|
|
|
if (testmgr_alloc_buf(xbuf))
|
|
return err;
|
|
|
|
req = akcipher_request_alloc(tfm, GFP_KERNEL);
|
|
if (!req)
|
|
goto free_xbuf;
|
|
|
|
init_completion(&result.completion);
|
|
|
|
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)
|
|
goto free_req;
|
|
|
|
err = -ENOMEM;
|
|
out_len_max = crypto_akcipher_maxsize(tfm);
|
|
outbuf_enc = kzalloc(out_len_max, GFP_KERNEL);
|
|
if (!outbuf_enc)
|
|
goto free_req;
|
|
|
|
if (WARN_ON(vecs->m_size > PAGE_SIZE))
|
|
goto free_all;
|
|
|
|
memcpy(xbuf[0], vecs->m, vecs->m_size);
|
|
|
|
sg_init_table(src_tab, 2);
|
|
sg_set_buf(&src_tab[0], xbuf[0], 8);
|
|
sg_set_buf(&src_tab[1], xbuf[0] + 8, vecs->m_size - 8);
|
|
sg_init_one(&dst, outbuf_enc, out_len_max);
|
|
akcipher_request_set_crypt(req, src_tab, &dst, vecs->m_size,
|
|
out_len_max);
|
|
akcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
|
|
tcrypt_complete, &result);
|
|
|
|
err = wait_async_op(&result, vecs->siggen_sigver_test ?
|
|
/* Run asymmetric signature generation */
|
|
crypto_akcipher_sign(req) :
|
|
/* Run asymmetric encrypt */
|
|
crypto_akcipher_encrypt(req));
|
|
if (err) {
|
|
pr_err("alg: akcipher: encrypt test failed. err %d\n", err);
|
|
goto free_all;
|
|
}
|
|
if (req->dst_len != vecs->c_size) {
|
|
pr_err("alg: akcipher: encrypt test failed. Invalid output len\n");
|
|
err = -EINVAL;
|
|
goto free_all;
|
|
}
|
|
/* verify that encrypted message is equal to expected */
|
|
if (memcmp(vecs->c, outbuf_enc, vecs->c_size)) {
|
|
pr_err("alg: akcipher: encrypt test failed. Invalid output\n");
|
|
hexdump(outbuf_enc, vecs->c_size);
|
|
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;
|
|
}
|
|
|
|
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);
|
|
sg_init_one(&dst, outbuf_dec, out_len_max);
|
|
init_completion(&result.completion);
|
|
akcipher_request_set_crypt(req, &src, &dst, vecs->c_size, out_len_max);
|
|
|
|
err = wait_async_op(&result, vecs->siggen_sigver_test ?
|
|
/* Run asymmetric signature verification */
|
|
crypto_akcipher_verify(req) :
|
|
/* Run asymmetric decrypt */
|
|
crypto_akcipher_decrypt(req));
|
|
if (err) {
|
|
pr_err("alg: akcipher: decrypt test failed. err %d\n", err);
|
|
goto free_all;
|
|
}
|
|
out_len = req->dst_len;
|
|
if (out_len < vecs->m_size) {
|
|
pr_err("alg: akcipher: decrypt test failed. "
|
|
"Invalid output len %u\n", out_len);
|
|
err = -EINVAL;
|
|
goto free_all;
|
|
}
|
|
/* verify that decrypted message is equal to the original msg */
|
|
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);
|
|
err = -EINVAL;
|
|
}
|
|
free_all:
|
|
kfree(outbuf_dec);
|
|
kfree(outbuf_enc);
|
|
free_req:
|
|
akcipher_request_free(req);
|
|
free_xbuf:
|
|
testmgr_free_buf(xbuf);
|
|
return err;
|
|
}
|
|
|
|
static int test_akcipher(struct crypto_akcipher *tfm, const char *alg,
|
|
const struct akcipher_testvec *vecs,
|
|
unsigned int tcount)
|
|
{
|
|
const char *algo =
|
|
crypto_tfm_alg_driver_name(crypto_akcipher_tfm(tfm));
|
|
int ret, i;
|
|
|
|
for (i = 0; i < tcount; i++) {
|
|
ret = test_akcipher_one(tfm, vecs++);
|
|
if (!ret)
|
|
continue;
|
|
|
|
pr_err("alg: akcipher: test %d failed for %s, err=%d\n",
|
|
i + 1, algo, ret);
|
|
return ret;
|
|
}
|
|
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;
|
|
|
|
tfm = crypto_alloc_akcipher(driver, type, mask);
|
|
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;
|
|
}
|
|
|
|
static int alg_test_null(const struct alg_test_desc *desc,
|
|
const char *driver, u32 type, u32 mask)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
#define __VECS(tv) { .vecs = tv, .count = ARRAY_SIZE(tv) }
|
|
|
|
/* Please keep this list sorted by algorithm name. */
|
|
static const struct alg_test_desc alg_test_descs[] = {
|
|
{
|
|
.alg = "ansi_cprng",
|
|
.test = alg_test_cprng,
|
|
.suite = {
|
|
.cprng = __VECS(ansi_cprng_aes_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "authenc(hmac(md5),ecb(cipher_null))",
|
|
.test = alg_test_aead,
|
|
.suite = {
|
|
.aead = {
|
|
.enc = __VECS(hmac_md5_ecb_cipher_null_enc_tv_template),
|
|
.dec = __VECS(hmac_md5_ecb_cipher_null_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "authenc(hmac(sha1),cbc(aes))",
|
|
.test = alg_test_aead,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.aead = {
|
|
.enc = __VECS(hmac_sha1_aes_cbc_enc_tv_temp)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "authenc(hmac(sha1),cbc(des))",
|
|
.test = alg_test_aead,
|
|
.suite = {
|
|
.aead = {
|
|
.enc = __VECS(hmac_sha1_des_cbc_enc_tv_temp)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "authenc(hmac(sha1),cbc(des3_ede))",
|
|
.test = alg_test_aead,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.aead = {
|
|
.enc = __VECS(hmac_sha1_des3_ede_cbc_enc_tv_temp)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "authenc(hmac(sha1),ctr(aes))",
|
|
.test = alg_test_null,
|
|
.fips_allowed = 1,
|
|
}, {
|
|
.alg = "authenc(hmac(sha1),ecb(cipher_null))",
|
|
.test = alg_test_aead,
|
|
.suite = {
|
|
.aead = {
|
|
.enc = __VECS(hmac_sha1_ecb_cipher_null_enc_tv_temp),
|
|
.dec = __VECS(hmac_sha1_ecb_cipher_null_dec_tv_temp)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "authenc(hmac(sha1),rfc3686(ctr(aes)))",
|
|
.test = alg_test_null,
|
|
.fips_allowed = 1,
|
|
}, {
|
|
.alg = "authenc(hmac(sha224),cbc(des))",
|
|
.test = alg_test_aead,
|
|
.suite = {
|
|
.aead = {
|
|
.enc = __VECS(hmac_sha224_des_cbc_enc_tv_temp)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "authenc(hmac(sha224),cbc(des3_ede))",
|
|
.test = alg_test_aead,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.aead = {
|
|
.enc = __VECS(hmac_sha224_des3_ede_cbc_enc_tv_temp)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "authenc(hmac(sha256),cbc(aes))",
|
|
.test = alg_test_aead,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.aead = {
|
|
.enc = __VECS(hmac_sha256_aes_cbc_enc_tv_temp)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "authenc(hmac(sha256),cbc(des))",
|
|
.test = alg_test_aead,
|
|
.suite = {
|
|
.aead = {
|
|
.enc = __VECS(hmac_sha256_des_cbc_enc_tv_temp)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "authenc(hmac(sha256),cbc(des3_ede))",
|
|
.test = alg_test_aead,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.aead = {
|
|
.enc = __VECS(hmac_sha256_des3_ede_cbc_enc_tv_temp)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "authenc(hmac(sha256),ctr(aes))",
|
|
.test = alg_test_null,
|
|
.fips_allowed = 1,
|
|
}, {
|
|
.alg = "authenc(hmac(sha256),rfc3686(ctr(aes)))",
|
|
.test = alg_test_null,
|
|
.fips_allowed = 1,
|
|
}, {
|
|
.alg = "authenc(hmac(sha384),cbc(des))",
|
|
.test = alg_test_aead,
|
|
.suite = {
|
|
.aead = {
|
|
.enc = __VECS(hmac_sha384_des_cbc_enc_tv_temp)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "authenc(hmac(sha384),cbc(des3_ede))",
|
|
.test = alg_test_aead,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.aead = {
|
|
.enc = __VECS(hmac_sha384_des3_ede_cbc_enc_tv_temp)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "authenc(hmac(sha384),ctr(aes))",
|
|
.test = alg_test_null,
|
|
.fips_allowed = 1,
|
|
}, {
|
|
.alg = "authenc(hmac(sha384),rfc3686(ctr(aes)))",
|
|
.test = alg_test_null,
|
|
.fips_allowed = 1,
|
|
}, {
|
|
.alg = "authenc(hmac(sha512),cbc(aes))",
|
|
.fips_allowed = 1,
|
|
.test = alg_test_aead,
|
|
.suite = {
|
|
.aead = {
|
|
.enc = __VECS(hmac_sha512_aes_cbc_enc_tv_temp)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "authenc(hmac(sha512),cbc(des))",
|
|
.test = alg_test_aead,
|
|
.suite = {
|
|
.aead = {
|
|
.enc = __VECS(hmac_sha512_des_cbc_enc_tv_temp)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "authenc(hmac(sha512),cbc(des3_ede))",
|
|
.test = alg_test_aead,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.aead = {
|
|
.enc = __VECS(hmac_sha512_des3_ede_cbc_enc_tv_temp)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "authenc(hmac(sha512),ctr(aes))",
|
|
.test = alg_test_null,
|
|
.fips_allowed = 1,
|
|
}, {
|
|
.alg = "authenc(hmac(sha512),rfc3686(ctr(aes)))",
|
|
.test = alg_test_null,
|
|
.fips_allowed = 1,
|
|
}, {
|
|
.alg = "cbc(aes)",
|
|
.test = alg_test_skcipher,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(aes_cbc_enc_tv_template),
|
|
.dec = __VECS(aes_cbc_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "cbc(anubis)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(anubis_cbc_enc_tv_template),
|
|
.dec = __VECS(anubis_cbc_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "cbc(blowfish)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(bf_cbc_enc_tv_template),
|
|
.dec = __VECS(bf_cbc_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "cbc(camellia)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(camellia_cbc_enc_tv_template),
|
|
.dec = __VECS(camellia_cbc_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "cbc(cast5)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(cast5_cbc_enc_tv_template),
|
|
.dec = __VECS(cast5_cbc_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "cbc(cast6)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(cast6_cbc_enc_tv_template),
|
|
.dec = __VECS(cast6_cbc_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "cbc(des)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(des_cbc_enc_tv_template),
|
|
.dec = __VECS(des_cbc_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "cbc(des3_ede)",
|
|
.test = alg_test_skcipher,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(des3_ede_cbc_enc_tv_template),
|
|
.dec = __VECS(des3_ede_cbc_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "cbc(serpent)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(serpent_cbc_enc_tv_template),
|
|
.dec = __VECS(serpent_cbc_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "cbc(twofish)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(tf_cbc_enc_tv_template),
|
|
.dec = __VECS(tf_cbc_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "cbcmac(aes)",
|
|
.fips_allowed = 1,
|
|
.test = alg_test_hash,
|
|
.suite = {
|
|
.hash = __VECS(aes_cbcmac_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "ccm(aes)",
|
|
.test = alg_test_aead,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.aead = {
|
|
.enc = __VECS(aes_ccm_enc_tv_template),
|
|
.dec = __VECS(aes_ccm_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "chacha20",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(chacha20_enc_tv_template),
|
|
.dec = __VECS(chacha20_enc_tv_template),
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "cmac(aes)",
|
|
.fips_allowed = 1,
|
|
.test = alg_test_hash,
|
|
.suite = {
|
|
.hash = __VECS(aes_cmac128_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "cmac(des3_ede)",
|
|
.fips_allowed = 1,
|
|
.test = alg_test_hash,
|
|
.suite = {
|
|
.hash = __VECS(des3_ede_cmac64_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "compress_null",
|
|
.test = alg_test_null,
|
|
}, {
|
|
.alg = "crc32",
|
|
.test = alg_test_hash,
|
|
.suite = {
|
|
.hash = __VECS(crc32_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "crc32c",
|
|
.test = alg_test_crc32c,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.hash = __VECS(crc32c_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "crct10dif",
|
|
.test = alg_test_hash,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.hash = __VECS(crct10dif_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "ctr(aes)",
|
|
.test = alg_test_skcipher,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(aes_ctr_enc_tv_template),
|
|
.dec = __VECS(aes_ctr_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "ctr(blowfish)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(bf_ctr_enc_tv_template),
|
|
.dec = __VECS(bf_ctr_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "ctr(camellia)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(camellia_ctr_enc_tv_template),
|
|
.dec = __VECS(camellia_ctr_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "ctr(cast5)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(cast5_ctr_enc_tv_template),
|
|
.dec = __VECS(cast5_ctr_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "ctr(cast6)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(cast6_ctr_enc_tv_template),
|
|
.dec = __VECS(cast6_ctr_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "ctr(des)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(des_ctr_enc_tv_template),
|
|
.dec = __VECS(des_ctr_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "ctr(des3_ede)",
|
|
.test = alg_test_skcipher,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(des3_ede_ctr_enc_tv_template),
|
|
.dec = __VECS(des3_ede_ctr_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "ctr(serpent)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(serpent_ctr_enc_tv_template),
|
|
.dec = __VECS(serpent_ctr_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "ctr(twofish)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(tf_ctr_enc_tv_template),
|
|
.dec = __VECS(tf_ctr_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "cts(cbc(aes))",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(cts_mode_enc_tv_template),
|
|
.dec = __VECS(cts_mode_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "deflate",
|
|
.test = alg_test_comp,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.comp = {
|
|
.comp = __VECS(deflate_comp_tv_template),
|
|
.decomp = __VECS(deflate_decomp_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "dh",
|
|
.test = alg_test_kpp,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.kpp = __VECS(dh_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "digest_null",
|
|
.test = alg_test_null,
|
|
}, {
|
|
.alg = "drbg_nopr_ctr_aes128",
|
|
.test = alg_test_drbg,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.drbg = __VECS(drbg_nopr_ctr_aes128_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "drbg_nopr_ctr_aes192",
|
|
.test = alg_test_drbg,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.drbg = __VECS(drbg_nopr_ctr_aes192_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "drbg_nopr_ctr_aes256",
|
|
.test = alg_test_drbg,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.drbg = __VECS(drbg_nopr_ctr_aes256_tv_template)
|
|
}
|
|
}, {
|
|
/*
|
|
* 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 = {
|
|
.drbg = __VECS(drbg_nopr_hmac_sha256_tv_template)
|
|
}
|
|
}, {
|
|
/* 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 = {
|
|
.drbg = __VECS(drbg_nopr_sha256_tv_template)
|
|
}
|
|
}, {
|
|
/* 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 = {
|
|
.drbg = __VECS(drbg_pr_ctr_aes128_tv_template)
|
|
}
|
|
}, {
|
|
/* 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 = {
|
|
.drbg = __VECS(drbg_pr_hmac_sha256_tv_template)
|
|
}
|
|
}, {
|
|
/* 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 = {
|
|
.drbg = __VECS(drbg_pr_sha256_tv_template)
|
|
}
|
|
}, {
|
|
/* 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,
|
|
}, {
|
|
.alg = "ecb(aes)",
|
|
.test = alg_test_skcipher,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(aes_enc_tv_template),
|
|
.dec = __VECS(aes_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "ecb(anubis)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(anubis_enc_tv_template),
|
|
.dec = __VECS(anubis_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "ecb(arc4)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(arc4_enc_tv_template),
|
|
.dec = __VECS(arc4_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "ecb(blowfish)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(bf_enc_tv_template),
|
|
.dec = __VECS(bf_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "ecb(camellia)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(camellia_enc_tv_template),
|
|
.dec = __VECS(camellia_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "ecb(cast5)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(cast5_enc_tv_template),
|
|
.dec = __VECS(cast5_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "ecb(cast6)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(cast6_enc_tv_template),
|
|
.dec = __VECS(cast6_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "ecb(cipher_null)",
|
|
.test = alg_test_null,
|
|
.fips_allowed = 1,
|
|
}, {
|
|
.alg = "ecb(des)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(des_enc_tv_template),
|
|
.dec = __VECS(des_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "ecb(des3_ede)",
|
|
.test = alg_test_skcipher,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(des3_ede_enc_tv_template),
|
|
.dec = __VECS(des3_ede_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.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
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "ecb(khazad)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(khazad_enc_tv_template),
|
|
.dec = __VECS(khazad_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "ecb(seed)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(seed_enc_tv_template),
|
|
.dec = __VECS(seed_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "ecb(serpent)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(serpent_enc_tv_template),
|
|
.dec = __VECS(serpent_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "ecb(tea)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(tea_enc_tv_template),
|
|
.dec = __VECS(tea_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "ecb(tnepres)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(tnepres_enc_tv_template),
|
|
.dec = __VECS(tnepres_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "ecb(twofish)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(tf_enc_tv_template),
|
|
.dec = __VECS(tf_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "ecb(xeta)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(xeta_enc_tv_template),
|
|
.dec = __VECS(xeta_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "ecb(xtea)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(xtea_enc_tv_template),
|
|
.dec = __VECS(xtea_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "ecdh",
|
|
.test = alg_test_kpp,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.kpp = __VECS(ecdh_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "gcm(aes)",
|
|
.test = alg_test_aead,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.aead = {
|
|
.enc = __VECS(aes_gcm_enc_tv_template),
|
|
.dec = __VECS(aes_gcm_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "ghash",
|
|
.test = alg_test_hash,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.hash = __VECS(ghash_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "hmac(crc32)",
|
|
.test = alg_test_hash,
|
|
.suite = {
|
|
.hash = __VECS(bfin_crc_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "hmac(md5)",
|
|
.test = alg_test_hash,
|
|
.suite = {
|
|
.hash = __VECS(hmac_md5_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "hmac(rmd128)",
|
|
.test = alg_test_hash,
|
|
.suite = {
|
|
.hash = __VECS(hmac_rmd128_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "hmac(rmd160)",
|
|
.test = alg_test_hash,
|
|
.suite = {
|
|
.hash = __VECS(hmac_rmd160_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "hmac(sha1)",
|
|
.test = alg_test_hash,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.hash = __VECS(hmac_sha1_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "hmac(sha224)",
|
|
.test = alg_test_hash,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.hash = __VECS(hmac_sha224_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "hmac(sha256)",
|
|
.test = alg_test_hash,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.hash = __VECS(hmac_sha256_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "hmac(sha3-224)",
|
|
.test = alg_test_hash,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.hash = __VECS(hmac_sha3_224_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "hmac(sha3-256)",
|
|
.test = alg_test_hash,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.hash = __VECS(hmac_sha3_256_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "hmac(sha3-384)",
|
|
.test = alg_test_hash,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.hash = __VECS(hmac_sha3_384_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "hmac(sha3-512)",
|
|
.test = alg_test_hash,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.hash = __VECS(hmac_sha3_512_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "hmac(sha384)",
|
|
.test = alg_test_hash,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.hash = __VECS(hmac_sha384_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "hmac(sha512)",
|
|
.test = alg_test_hash,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.hash = __VECS(hmac_sha512_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "jitterentropy_rng",
|
|
.fips_allowed = 1,
|
|
.test = alg_test_null,
|
|
}, {
|
|
.alg = "kw(aes)",
|
|
.test = alg_test_skcipher,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(aes_kw_enc_tv_template),
|
|
.dec = __VECS(aes_kw_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "lrw(aes)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(aes_lrw_enc_tv_template),
|
|
.dec = __VECS(aes_lrw_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "lrw(camellia)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(camellia_lrw_enc_tv_template),
|
|
.dec = __VECS(camellia_lrw_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "lrw(cast6)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(cast6_lrw_enc_tv_template),
|
|
.dec = __VECS(cast6_lrw_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "lrw(serpent)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(serpent_lrw_enc_tv_template),
|
|
.dec = __VECS(serpent_lrw_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "lrw(twofish)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(tf_lrw_enc_tv_template),
|
|
.dec = __VECS(tf_lrw_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "lz4",
|
|
.test = alg_test_comp,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.comp = {
|
|
.comp = __VECS(lz4_comp_tv_template),
|
|
.decomp = __VECS(lz4_decomp_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "lz4hc",
|
|
.test = alg_test_comp,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.comp = {
|
|
.comp = __VECS(lz4hc_comp_tv_template),
|
|
.decomp = __VECS(lz4hc_decomp_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "lzo",
|
|
.test = alg_test_comp,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.comp = {
|
|
.comp = __VECS(lzo_comp_tv_template),
|
|
.decomp = __VECS(lzo_decomp_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "md4",
|
|
.test = alg_test_hash,
|
|
.suite = {
|
|
.hash = __VECS(md4_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "md5",
|
|
.test = alg_test_hash,
|
|
.suite = {
|
|
.hash = __VECS(md5_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "michael_mic",
|
|
.test = alg_test_hash,
|
|
.suite = {
|
|
.hash = __VECS(michael_mic_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "ofb(aes)",
|
|
.test = alg_test_skcipher,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(aes_ofb_enc_tv_template),
|
|
.dec = __VECS(aes_ofb_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "pcbc(fcrypt)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(fcrypt_pcbc_enc_tv_template),
|
|
.dec = __VECS(fcrypt_pcbc_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.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,
|
|
}, {
|
|
.alg = "poly1305",
|
|
.test = alg_test_hash,
|
|
.suite = {
|
|
.hash = __VECS(poly1305_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "rfc3686(ctr(aes))",
|
|
.test = alg_test_skcipher,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(aes_ctr_rfc3686_enc_tv_template),
|
|
.dec = __VECS(aes_ctr_rfc3686_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "rfc4106(gcm(aes))",
|
|
.test = alg_test_aead,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.aead = {
|
|
.enc = __VECS(aes_gcm_rfc4106_enc_tv_template),
|
|
.dec = __VECS(aes_gcm_rfc4106_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "rfc4309(ccm(aes))",
|
|
.test = alg_test_aead,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.aead = {
|
|
.enc = __VECS(aes_ccm_rfc4309_enc_tv_template),
|
|
.dec = __VECS(aes_ccm_rfc4309_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "rfc4543(gcm(aes))",
|
|
.test = alg_test_aead,
|
|
.suite = {
|
|
.aead = {
|
|
.enc = __VECS(aes_gcm_rfc4543_enc_tv_template),
|
|
.dec = __VECS(aes_gcm_rfc4543_dec_tv_template),
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "rfc7539(chacha20,poly1305)",
|
|
.test = alg_test_aead,
|
|
.suite = {
|
|
.aead = {
|
|
.enc = __VECS(rfc7539_enc_tv_template),
|
|
.dec = __VECS(rfc7539_dec_tv_template),
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "rfc7539esp(chacha20,poly1305)",
|
|
.test = alg_test_aead,
|
|
.suite = {
|
|
.aead = {
|
|
.enc = __VECS(rfc7539esp_enc_tv_template),
|
|
.dec = __VECS(rfc7539esp_dec_tv_template),
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "rmd128",
|
|
.test = alg_test_hash,
|
|
.suite = {
|
|
.hash = __VECS(rmd128_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "rmd160",
|
|
.test = alg_test_hash,
|
|
.suite = {
|
|
.hash = __VECS(rmd160_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "rmd256",
|
|
.test = alg_test_hash,
|
|
.suite = {
|
|
.hash = __VECS(rmd256_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "rmd320",
|
|
.test = alg_test_hash,
|
|
.suite = {
|
|
.hash = __VECS(rmd320_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "rsa",
|
|
.test = alg_test_akcipher,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.akcipher = __VECS(rsa_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "salsa20",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(salsa20_stream_enc_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "sha1",
|
|
.test = alg_test_hash,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.hash = __VECS(sha1_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "sha224",
|
|
.test = alg_test_hash,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.hash = __VECS(sha224_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "sha256",
|
|
.test = alg_test_hash,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.hash = __VECS(sha256_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "sha3-224",
|
|
.test = alg_test_hash,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.hash = __VECS(sha3_224_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "sha3-256",
|
|
.test = alg_test_hash,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.hash = __VECS(sha3_256_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "sha3-384",
|
|
.test = alg_test_hash,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.hash = __VECS(sha3_384_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "sha3-512",
|
|
.test = alg_test_hash,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.hash = __VECS(sha3_512_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "sha384",
|
|
.test = alg_test_hash,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.hash = __VECS(sha384_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "sha512",
|
|
.test = alg_test_hash,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.hash = __VECS(sha512_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "tgr128",
|
|
.test = alg_test_hash,
|
|
.suite = {
|
|
.hash = __VECS(tgr128_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "tgr160",
|
|
.test = alg_test_hash,
|
|
.suite = {
|
|
.hash = __VECS(tgr160_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "tgr192",
|
|
.test = alg_test_hash,
|
|
.suite = {
|
|
.hash = __VECS(tgr192_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "vmac(aes)",
|
|
.test = alg_test_hash,
|
|
.suite = {
|
|
.hash = __VECS(aes_vmac128_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "wp256",
|
|
.test = alg_test_hash,
|
|
.suite = {
|
|
.hash = __VECS(wp256_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "wp384",
|
|
.test = alg_test_hash,
|
|
.suite = {
|
|
.hash = __VECS(wp384_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "wp512",
|
|
.test = alg_test_hash,
|
|
.suite = {
|
|
.hash = __VECS(wp512_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "xcbc(aes)",
|
|
.test = alg_test_hash,
|
|
.suite = {
|
|
.hash = __VECS(aes_xcbc128_tv_template)
|
|
}
|
|
}, {
|
|
.alg = "xts(aes)",
|
|
.test = alg_test_skcipher,
|
|
.fips_allowed = 1,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(aes_xts_enc_tv_template),
|
|
.dec = __VECS(aes_xts_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "xts(camellia)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(camellia_xts_enc_tv_template),
|
|
.dec = __VECS(camellia_xts_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "xts(cast6)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(cast6_xts_enc_tv_template),
|
|
.dec = __VECS(cast6_xts_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "xts(serpent)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(serpent_xts_enc_tv_template),
|
|
.dec = __VECS(serpent_xts_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.alg = "xts(twofish)",
|
|
.test = alg_test_skcipher,
|
|
.suite = {
|
|
.cipher = {
|
|
.enc = __VECS(tf_xts_enc_tv_template),
|
|
.dec = __VECS(tf_xts_dec_tv_template)
|
|
}
|
|
}
|
|
}, {
|
|
.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)
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
|
|
static int alg_find_test(const char *alg)
|
|
{
|
|
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;
|
|
}
|
|
|
|
return i;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
|
|
{
|
|
int i;
|
|
int j;
|
|
int rc;
|
|
|
|
if (!fips_enabled && notests) {
|
|
printk_once(KERN_INFO "alg: self-tests disabled\n");
|
|
return 0;
|
|
}
|
|
|
|
alg_test_descs_check_order();
|
|
|
|
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;
|
|
|
|
if (fips_enabled && !alg_test_descs[i].fips_allowed)
|
|
goto non_fips_alg;
|
|
|
|
rc = alg_test_cipher(alg_test_descs + i, driver, type, mask);
|
|
goto test_done;
|
|
}
|
|
|
|
i = alg_find_test(alg);
|
|
j = alg_find_test(driver);
|
|
if (i < 0 && j < 0)
|
|
goto notest;
|
|
|
|
if (fips_enabled && ((i >= 0 && !alg_test_descs[i].fips_allowed) ||
|
|
(j >= 0 && !alg_test_descs[j].fips_allowed)))
|
|
goto non_fips_alg;
|
|
|
|
rc = 0;
|
|
if (i >= 0)
|
|
rc |= alg_test_descs[i].test(alg_test_descs + i, driver,
|
|
type, mask);
|
|
if (j >= 0 && j != i)
|
|
rc |= alg_test_descs[j].test(alg_test_descs + j, driver,
|
|
type, mask);
|
|
|
|
test_done:
|
|
if (fips_enabled && rc)
|
|
panic("%s: %s alg self test failed in fips mode!\n", driver, alg);
|
|
|
|
if (fips_enabled && !rc)
|
|
pr_info("alg: self-tests for %s (%s) passed\n", driver, alg);
|
|
|
|
return rc;
|
|
|
|
notest:
|
|
printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver);
|
|
return 0;
|
|
non_fips_alg:
|
|
return -EINVAL;
|
|
}
|
|
|
|
#endif /* CONFIG_CRYPTO_MANAGER_DISABLE_TESTS */
|
|
|
|
EXPORT_SYMBOL_GPL(alg_test);
|