blob: f9c378af39078c2ad9f8fce0c02d1d4faf432f9f [file] [log] [blame]
Herbert Xuda7f0332008-07-31 17:08:25 +08001/*
2 * Algorithm testing framework and tests.
3 *
4 * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
5 * Copyright (c) 2002 Jean-Francois Dive <jef@linuxbe.org>
6 * Copyright (c) 2007 Nokia Siemens Networks
7 * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au>
8 *
Adrian Hoban69435b92010-11-04 15:02:04 -04009 * Updated RFC4106 AES-GCM testing.
10 * Authors: Aidan O'Mahony (aidan.o.mahony@intel.com)
11 * Adrian Hoban <adrian.hoban@intel.com>
12 * Gabriele Paoloni <gabriele.paoloni@intel.com>
13 * Tadeusz Struk (tadeusz.struk@intel.com)
14 * Copyright (c) 2010, Intel Corporation.
15 *
Herbert Xuda7f0332008-07-31 17:08:25 +080016 * This program is free software; you can redistribute it and/or modify it
17 * under the terms of the GNU General Public License as published by the Free
18 * Software Foundation; either version 2 of the License, or (at your option)
19 * any later version.
20 *
21 */
22
Herbert Xu1ce33112015-04-22 15:06:31 +080023#include <crypto/aead.h>
Herbert Xuda7f0332008-07-31 17:08:25 +080024#include <crypto/hash.h>
Herbert Xu12773d92015-08-20 15:21:46 +080025#include <crypto/skcipher.h>
Herbert Xuda7f0332008-07-31 17:08:25 +080026#include <linux/err.h>
Herbert Xu1c41b882015-04-22 13:25:58 +080027#include <linux/fips.h>
Herbert Xuda7f0332008-07-31 17:08:25 +080028#include <linux/module.h>
29#include <linux/scatterlist.h>
30#include <linux/slab.h>
31#include <linux/string.h>
Jarod Wilson7647d6c2009-05-04 19:44:50 +080032#include <crypto/rng.h>
Stephan Mueller64d1cdf2014-05-31 17:25:36 +020033#include <crypto/drbg.h>
Tadeusz Struk946cc462015-06-16 10:31:06 -070034#include <crypto/akcipher.h>
Salvatore Benedetto802c7f12016-06-22 17:49:14 +010035#include <crypto/kpp.h>
Giovanni Cabiddud7db7a82016-10-21 13:19:54 +010036#include <crypto/acompress.h>
Herbert Xuda7f0332008-07-31 17:08:25 +080037
38#include "internal.h"
Alexander Shishkin0b767f92010-06-03 20:53:43 +100039
Richard W.M. Jones9e5c9fe2016-05-03 10:00:17 +010040static bool notests;
41module_param(notests, bool, 0644);
42MODULE_PARM_DESC(notests, "disable crypto self-tests");
43
Herbert Xu326a6342010-08-06 09:40:28 +080044#ifdef CONFIG_CRYPTO_MANAGER_DISABLE_TESTS
Alexander Shishkin0b767f92010-06-03 20:53:43 +100045
46/* a perfect nop */
47int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
48{
49 return 0;
50}
51
52#else
53
Herbert Xuda7f0332008-07-31 17:08:25 +080054#include "testmgr.h"
55
56/*
57 * Need slab memory for testing (size in number of pages).
58 */
59#define XBUFSIZE 8
60
61/*
62 * Indexes into the xbuf to simulate cross-page access.
63 */
64#define IDX1 32
65#define IDX2 32400
Ard Biesheuvel04b46fb2016-12-08 08:23:52 +000066#define IDX3 1511
Herbert Xuda7f0332008-07-31 17:08:25 +080067#define IDX4 8193
68#define IDX5 22222
69#define IDX6 17101
70#define IDX7 27333
71#define IDX8 3000
72
73/*
74* Used by test_cipher()
75*/
76#define ENCRYPT 1
77#define DECRYPT 0
78
79struct tcrypt_result {
80 struct completion completion;
81 int err;
82};
83
84struct aead_test_suite {
85 struct {
86 struct aead_testvec *vecs;
87 unsigned int count;
88 } enc, dec;
89};
90
91struct cipher_test_suite {
92 struct {
93 struct cipher_testvec *vecs;
94 unsigned int count;
95 } enc, dec;
96};
97
98struct comp_test_suite {
99 struct {
100 struct comp_testvec *vecs;
101 unsigned int count;
102 } comp, decomp;
103};
104
105struct hash_test_suite {
106 struct hash_testvec *vecs;
107 unsigned int count;
108};
109
Jarod Wilson7647d6c2009-05-04 19:44:50 +0800110struct cprng_test_suite {
111 struct cprng_testvec *vecs;
112 unsigned int count;
113};
114
Stephan Mueller64d1cdf2014-05-31 17:25:36 +0200115struct drbg_test_suite {
116 struct drbg_testvec *vecs;
117 unsigned int count;
118};
119
Tadeusz Struk946cc462015-06-16 10:31:06 -0700120struct akcipher_test_suite {
121 struct akcipher_testvec *vecs;
122 unsigned int count;
123};
124
Salvatore Benedetto802c7f12016-06-22 17:49:14 +0100125struct kpp_test_suite {
126 struct kpp_testvec *vecs;
127 unsigned int count;
128};
129
Herbert Xuda7f0332008-07-31 17:08:25 +0800130struct alg_test_desc {
131 const char *alg;
132 int (*test)(const struct alg_test_desc *desc, const char *driver,
133 u32 type, u32 mask);
Jarod Wilsona1915d52009-05-15 15:16:03 +1000134 int fips_allowed; /* set if alg is allowed in fips mode */
Herbert Xuda7f0332008-07-31 17:08:25 +0800135
136 union {
137 struct aead_test_suite aead;
138 struct cipher_test_suite cipher;
139 struct comp_test_suite comp;
140 struct hash_test_suite hash;
Jarod Wilson7647d6c2009-05-04 19:44:50 +0800141 struct cprng_test_suite cprng;
Stephan Mueller64d1cdf2014-05-31 17:25:36 +0200142 struct drbg_test_suite drbg;
Tadeusz Struk946cc462015-06-16 10:31:06 -0700143 struct akcipher_test_suite akcipher;
Salvatore Benedetto802c7f12016-06-22 17:49:14 +0100144 struct kpp_test_suite kpp;
Herbert Xuda7f0332008-07-31 17:08:25 +0800145 } suite;
146};
147
148static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
149
Herbert Xuda7f0332008-07-31 17:08:25 +0800150static void hexdump(unsigned char *buf, unsigned int len)
151{
152 print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET,
153 16, 1,
154 buf, len, false);
155}
156
157static void tcrypt_complete(struct crypto_async_request *req, int err)
158{
159 struct tcrypt_result *res = req->data;
160
161 if (err == -EINPROGRESS)
162 return;
163
164 res->err = err;
165 complete(&res->completion);
166}
167
Herbert Xuf8b0d4d2009-05-06 14:15:47 +0800168static int testmgr_alloc_buf(char *buf[XBUFSIZE])
169{
170 int i;
171
172 for (i = 0; i < XBUFSIZE; i++) {
173 buf[i] = (void *)__get_free_page(GFP_KERNEL);
174 if (!buf[i])
175 goto err_free_buf;
176 }
177
178 return 0;
179
180err_free_buf:
181 while (i-- > 0)
182 free_page((unsigned long)buf[i]);
183
184 return -ENOMEM;
185}
186
187static void testmgr_free_buf(char *buf[XBUFSIZE])
188{
189 int i;
190
191 for (i = 0; i < XBUFSIZE; i++)
192 free_page((unsigned long)buf[i]);
193}
194
Cristian Stoicad4c85f92014-08-08 12:30:04 +0300195static int wait_async_op(struct tcrypt_result *tr, int ret)
David S. Millera8f1a052010-05-19 14:12:03 +1000196{
197 if (ret == -EINPROGRESS || ret == -EBUSY) {
Rabin Vincent8a45ac12015-01-09 16:25:28 +0100198 wait_for_completion(&tr->completion);
Wolfram Sang16735d02013-11-14 14:32:02 -0800199 reinit_completion(&tr->completion);
Rabin Vincent8a45ac12015-01-09 16:25:28 +0100200 ret = tr->err;
David S. Millera8f1a052010-05-19 14:12:03 +1000201 }
202 return ret;
203}
204
Wang, Rui Y018ba952016-02-03 18:26:57 +0800205static int ahash_partial_update(struct ahash_request **preq,
206 struct crypto_ahash *tfm, struct hash_testvec *template,
207 void *hash_buff, int k, int temp, struct scatterlist *sg,
208 const char *algo, char *result, struct tcrypt_result *tresult)
209{
210 char *state;
211 struct ahash_request *req;
212 int statesize, ret = -EINVAL;
Jan Stancek7bcb87b2016-09-28 16:38:37 +0200213 const char guard[] = { 0x00, 0xba, 0xad, 0x00 };
Wang, Rui Y018ba952016-02-03 18:26:57 +0800214
215 req = *preq;
216 statesize = crypto_ahash_statesize(
217 crypto_ahash_reqtfm(req));
Jan Stancek7bcb87b2016-09-28 16:38:37 +0200218 state = kmalloc(statesize + sizeof(guard), GFP_KERNEL);
Wang, Rui Y018ba952016-02-03 18:26:57 +0800219 if (!state) {
220 pr_err("alt: hash: Failed to alloc state for %s\n", algo);
221 goto out_nostate;
222 }
Jan Stancek7bcb87b2016-09-28 16:38:37 +0200223 memcpy(state + statesize, guard, sizeof(guard));
Wang, Rui Y018ba952016-02-03 18:26:57 +0800224 ret = crypto_ahash_export(req, state);
Jan Stancek7bcb87b2016-09-28 16:38:37 +0200225 WARN_ON(memcmp(state + statesize, guard, sizeof(guard)));
Wang, Rui Y018ba952016-02-03 18:26:57 +0800226 if (ret) {
227 pr_err("alt: hash: Failed to export() for %s\n", algo);
228 goto out;
229 }
230 ahash_request_free(req);
231 req = ahash_request_alloc(tfm, GFP_KERNEL);
232 if (!req) {
233 pr_err("alg: hash: Failed to alloc request for %s\n", algo);
234 goto out_noreq;
235 }
236 ahash_request_set_callback(req,
237 CRYPTO_TFM_REQ_MAY_BACKLOG,
238 tcrypt_complete, tresult);
239
240 memcpy(hash_buff, template->plaintext + temp,
241 template->tap[k]);
242 sg_init_one(&sg[0], hash_buff, template->tap[k]);
243 ahash_request_set_crypt(req, sg, result, template->tap[k]);
244 ret = crypto_ahash_import(req, state);
245 if (ret) {
246 pr_err("alg: hash: Failed to import() for %s\n", algo);
247 goto out;
248 }
249 ret = wait_async_op(tresult, crypto_ahash_update(req));
250 if (ret)
251 goto out;
252 *preq = req;
253 ret = 0;
254 goto out_noreq;
255out:
256 ahash_request_free(req);
257out_noreq:
258 kfree(state);
259out_nostate:
260 return ret;
261}
262
Jussi Kivilinnada5ffe12013-06-13 17:37:55 +0300263static int __test_hash(struct crypto_ahash *tfm, struct hash_testvec *template,
264 unsigned int tcount, bool use_digest,
265 const int align_offset)
Herbert Xuda7f0332008-07-31 17:08:25 +0800266{
267 const char *algo = crypto_tfm_alg_driver_name(crypto_ahash_tfm(tfm));
Andrew Lutomirskie93acd62017-01-10 15:24:46 -0800268 size_t digest_size = crypto_ahash_digestsize(tfm);
Herbert Xuda7f0332008-07-31 17:08:25 +0800269 unsigned int i, j, k, temp;
270 struct scatterlist sg[8];
Horia Geanta29b77e52014-07-23 11:59:38 +0300271 char *result;
272 char *key;
Herbert Xuda7f0332008-07-31 17:08:25 +0800273 struct ahash_request *req;
274 struct tcrypt_result tresult;
Herbert Xuda7f0332008-07-31 17:08:25 +0800275 void *hash_buff;
Herbert Xuf8b0d4d2009-05-06 14:15:47 +0800276 char *xbuf[XBUFSIZE];
277 int ret = -ENOMEM;
278
Andrew Lutomirskie93acd62017-01-10 15:24:46 -0800279 result = kmalloc(digest_size, GFP_KERNEL);
Horia Geanta29b77e52014-07-23 11:59:38 +0300280 if (!result)
281 return ret;
282 key = kmalloc(MAX_KEYLEN, GFP_KERNEL);
283 if (!key)
284 goto out_nobuf;
Herbert Xuf8b0d4d2009-05-06 14:15:47 +0800285 if (testmgr_alloc_buf(xbuf))
286 goto out_nobuf;
Herbert Xuda7f0332008-07-31 17:08:25 +0800287
288 init_completion(&tresult.completion);
289
290 req = ahash_request_alloc(tfm, GFP_KERNEL);
291 if (!req) {
292 printk(KERN_ERR "alg: hash: Failed to allocate request for "
293 "%s\n", algo);
Herbert Xuda7f0332008-07-31 17:08:25 +0800294 goto out_noreq;
295 }
296 ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
297 tcrypt_complete, &tresult);
298
Herbert Xua0cfae52009-05-29 16:23:12 +1000299 j = 0;
Herbert Xuda7f0332008-07-31 17:08:25 +0800300 for (i = 0; i < tcount; i++) {
Herbert Xua0cfae52009-05-29 16:23:12 +1000301 if (template[i].np)
302 continue;
303
Jussi Kivilinnada5ffe12013-06-13 17:37:55 +0300304 ret = -EINVAL;
305 if (WARN_ON(align_offset + template[i].psize > PAGE_SIZE))
306 goto out;
307
Herbert Xua0cfae52009-05-29 16:23:12 +1000308 j++;
Andrew Lutomirskie93acd62017-01-10 15:24:46 -0800309 memset(result, 0, digest_size);
Herbert Xuda7f0332008-07-31 17:08:25 +0800310
311 hash_buff = xbuf[0];
Jussi Kivilinnada5ffe12013-06-13 17:37:55 +0300312 hash_buff += align_offset;
Herbert Xuda7f0332008-07-31 17:08:25 +0800313
314 memcpy(hash_buff, template[i].plaintext, template[i].psize);
315 sg_init_one(&sg[0], hash_buff, template[i].psize);
316
317 if (template[i].ksize) {
318 crypto_ahash_clear_flags(tfm, ~0);
Horia Geanta29b77e52014-07-23 11:59:38 +0300319 if (template[i].ksize > MAX_KEYLEN) {
320 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
321 j, algo, template[i].ksize, MAX_KEYLEN);
322 ret = -EINVAL;
323 goto out;
324 }
325 memcpy(key, template[i].key, template[i].ksize);
326 ret = crypto_ahash_setkey(tfm, key, template[i].ksize);
Herbert Xuda7f0332008-07-31 17:08:25 +0800327 if (ret) {
328 printk(KERN_ERR "alg: hash: setkey failed on "
Herbert Xua0cfae52009-05-29 16:23:12 +1000329 "test %d for %s: ret=%d\n", j, algo,
Herbert Xuda7f0332008-07-31 17:08:25 +0800330 -ret);
331 goto out;
332 }
333 }
334
335 ahash_request_set_crypt(req, sg, result, template[i].psize);
David S. Millera8f1a052010-05-19 14:12:03 +1000336 if (use_digest) {
Cristian Stoicad4c85f92014-08-08 12:30:04 +0300337 ret = wait_async_op(&tresult, crypto_ahash_digest(req));
David S. Millera8f1a052010-05-19 14:12:03 +1000338 if (ret) {
339 pr_err("alg: hash: digest failed on test %d "
340 "for %s: ret=%d\n", j, algo, -ret);
341 goto out;
Herbert Xuda7f0332008-07-31 17:08:25 +0800342 }
David S. Millera8f1a052010-05-19 14:12:03 +1000343 } else {
Cristian Stoicad4c85f92014-08-08 12:30:04 +0300344 ret = wait_async_op(&tresult, crypto_ahash_init(req));
David S. Millera8f1a052010-05-19 14:12:03 +1000345 if (ret) {
346 pr_err("alt: hash: init failed on test %d "
347 "for %s: ret=%d\n", j, algo, -ret);
348 goto out;
349 }
Cristian Stoicad4c85f92014-08-08 12:30:04 +0300350 ret = wait_async_op(&tresult, crypto_ahash_update(req));
David S. Millera8f1a052010-05-19 14:12:03 +1000351 if (ret) {
352 pr_err("alt: hash: update failed on test %d "
353 "for %s: ret=%d\n", j, algo, -ret);
354 goto out;
355 }
Cristian Stoicad4c85f92014-08-08 12:30:04 +0300356 ret = wait_async_op(&tresult, crypto_ahash_final(req));
David S. Millera8f1a052010-05-19 14:12:03 +1000357 if (ret) {
358 pr_err("alt: hash: final failed on test %d "
359 "for %s: ret=%d\n", j, algo, -ret);
360 goto out;
361 }
Herbert Xuda7f0332008-07-31 17:08:25 +0800362 }
363
364 if (memcmp(result, template[i].digest,
365 crypto_ahash_digestsize(tfm))) {
366 printk(KERN_ERR "alg: hash: Test %d failed for %s\n",
Herbert Xua0cfae52009-05-29 16:23:12 +1000367 j, algo);
Herbert Xuda7f0332008-07-31 17:08:25 +0800368 hexdump(result, crypto_ahash_digestsize(tfm));
369 ret = -EINVAL;
370 goto out;
371 }
372 }
373
374 j = 0;
375 for (i = 0; i < tcount; i++) {
Jussi Kivilinnada5ffe12013-06-13 17:37:55 +0300376 /* alignment tests are only done with continuous buffers */
377 if (align_offset != 0)
378 break;
379
Cristian Stoica5f2b4242014-08-08 14:27:50 +0300380 if (!template[i].np)
381 continue;
Herbert Xuda7f0332008-07-31 17:08:25 +0800382
Cristian Stoica5f2b4242014-08-08 14:27:50 +0300383 j++;
Andrew Lutomirskie93acd62017-01-10 15:24:46 -0800384 memset(result, 0, digest_size);
Herbert Xuda7f0332008-07-31 17:08:25 +0800385
Cristian Stoica5f2b4242014-08-08 14:27:50 +0300386 temp = 0;
387 sg_init_table(sg, template[i].np);
388 ret = -EINVAL;
389 for (k = 0; k < template[i].np; k++) {
390 if (WARN_ON(offset_in_page(IDX[k]) +
391 template[i].tap[k] > PAGE_SIZE))
Herbert Xuda7f0332008-07-31 17:08:25 +0800392 goto out;
Cristian Stoica5f2b4242014-08-08 14:27:50 +0300393 sg_set_buf(&sg[k],
394 memcpy(xbuf[IDX[k] >> PAGE_SHIFT] +
395 offset_in_page(IDX[k]),
396 template[i].plaintext + temp,
397 template[i].tap[k]),
398 template[i].tap[k]);
399 temp += template[i].tap[k];
400 }
Herbert Xuda7f0332008-07-31 17:08:25 +0800401
Cristian Stoica5f2b4242014-08-08 14:27:50 +0300402 if (template[i].ksize) {
403 if (template[i].ksize > MAX_KEYLEN) {
404 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
405 j, algo, template[i].ksize, MAX_KEYLEN);
Herbert Xuda7f0332008-07-31 17:08:25 +0800406 ret = -EINVAL;
407 goto out;
408 }
Cristian Stoica5f2b4242014-08-08 14:27:50 +0300409 crypto_ahash_clear_flags(tfm, ~0);
410 memcpy(key, template[i].key, template[i].ksize);
411 ret = crypto_ahash_setkey(tfm, key, template[i].ksize);
412
413 if (ret) {
414 printk(KERN_ERR "alg: hash: setkey "
415 "failed on chunking test %d "
416 "for %s: ret=%d\n", j, algo, -ret);
417 goto out;
418 }
419 }
420
421 ahash_request_set_crypt(req, sg, result, template[i].psize);
422 ret = crypto_ahash_digest(req);
423 switch (ret) {
424 case 0:
425 break;
426 case -EINPROGRESS:
427 case -EBUSY:
Rabin Vincent8a45ac12015-01-09 16:25:28 +0100428 wait_for_completion(&tresult.completion);
429 reinit_completion(&tresult.completion);
430 ret = tresult.err;
431 if (!ret)
Cristian Stoica5f2b4242014-08-08 14:27:50 +0300432 break;
Cristian Stoica5f2b4242014-08-08 14:27:50 +0300433 /* fall through */
434 default:
435 printk(KERN_ERR "alg: hash: digest failed "
436 "on chunking test %d for %s: "
437 "ret=%d\n", j, algo, -ret);
438 goto out;
439 }
440
441 if (memcmp(result, template[i].digest,
442 crypto_ahash_digestsize(tfm))) {
443 printk(KERN_ERR "alg: hash: Chunking test %d "
444 "failed for %s\n", j, algo);
445 hexdump(result, crypto_ahash_digestsize(tfm));
446 ret = -EINVAL;
447 goto out;
Herbert Xuda7f0332008-07-31 17:08:25 +0800448 }
449 }
450
Wang, Rui Y018ba952016-02-03 18:26:57 +0800451 /* partial update exercise */
452 j = 0;
453 for (i = 0; i < tcount; i++) {
454 /* alignment tests are only done with continuous buffers */
455 if (align_offset != 0)
456 break;
457
458 if (template[i].np < 2)
459 continue;
460
461 j++;
Andrew Lutomirskie93acd62017-01-10 15:24:46 -0800462 memset(result, 0, digest_size);
Wang, Rui Y018ba952016-02-03 18:26:57 +0800463
464 ret = -EINVAL;
465 hash_buff = xbuf[0];
466 memcpy(hash_buff, template[i].plaintext,
467 template[i].tap[0]);
468 sg_init_one(&sg[0], hash_buff, template[i].tap[0]);
469
470 if (template[i].ksize) {
471 crypto_ahash_clear_flags(tfm, ~0);
472 if (template[i].ksize > MAX_KEYLEN) {
473 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
474 j, algo, template[i].ksize, MAX_KEYLEN);
475 ret = -EINVAL;
476 goto out;
477 }
478 memcpy(key, template[i].key, template[i].ksize);
479 ret = crypto_ahash_setkey(tfm, key, template[i].ksize);
480 if (ret) {
481 pr_err("alg: hash: setkey failed on test %d for %s: ret=%d\n",
482 j, algo, -ret);
483 goto out;
484 }
485 }
486
487 ahash_request_set_crypt(req, sg, result, template[i].tap[0]);
488 ret = wait_async_op(&tresult, crypto_ahash_init(req));
489 if (ret) {
490 pr_err("alt: hash: init failed on test %d for %s: ret=%d\n",
491 j, algo, -ret);
492 goto out;
493 }
494 ret = wait_async_op(&tresult, crypto_ahash_update(req));
495 if (ret) {
496 pr_err("alt: hash: update failed on test %d for %s: ret=%d\n",
497 j, algo, -ret);
498 goto out;
499 }
500
501 temp = template[i].tap[0];
502 for (k = 1; k < template[i].np; k++) {
503 ret = ahash_partial_update(&req, tfm, &template[i],
504 hash_buff, k, temp, &sg[0], algo, result,
505 &tresult);
506 if (ret) {
507 pr_err("hash: partial update failed on test %d for %s: ret=%d\n",
508 j, algo, -ret);
509 goto out_noreq;
510 }
511 temp += template[i].tap[k];
512 }
513 ret = wait_async_op(&tresult, crypto_ahash_final(req));
514 if (ret) {
515 pr_err("alt: hash: final failed on test %d for %s: ret=%d\n",
516 j, algo, -ret);
517 goto out;
518 }
519 if (memcmp(result, template[i].digest,
520 crypto_ahash_digestsize(tfm))) {
521 pr_err("alg: hash: Partial Test %d failed for %s\n",
522 j, algo);
523 hexdump(result, crypto_ahash_digestsize(tfm));
524 ret = -EINVAL;
525 goto out;
526 }
527 }
528
Herbert Xuda7f0332008-07-31 17:08:25 +0800529 ret = 0;
530
531out:
532 ahash_request_free(req);
533out_noreq:
Herbert Xuf8b0d4d2009-05-06 14:15:47 +0800534 testmgr_free_buf(xbuf);
535out_nobuf:
Horia Geanta29b77e52014-07-23 11:59:38 +0300536 kfree(key);
537 kfree(result);
Herbert Xuda7f0332008-07-31 17:08:25 +0800538 return ret;
539}
540
Jussi Kivilinnada5ffe12013-06-13 17:37:55 +0300541static int test_hash(struct crypto_ahash *tfm, struct hash_testvec *template,
542 unsigned int tcount, bool use_digest)
543{
544 unsigned int alignmask;
545 int ret;
546
547 ret = __test_hash(tfm, template, tcount, use_digest, 0);
548 if (ret)
549 return ret;
550
551 /* test unaligned buffers, check with one byte offset */
552 ret = __test_hash(tfm, template, tcount, use_digest, 1);
553 if (ret)
554 return ret;
555
556 alignmask = crypto_tfm_alg_alignmask(&tfm->base);
557 if (alignmask) {
558 /* Check if alignment mask for tfm is correctly set. */
559 ret = __test_hash(tfm, template, tcount, use_digest,
560 alignmask + 1);
561 if (ret)
562 return ret;
563 }
564
565 return 0;
566}
567
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300568static int __test_aead(struct crypto_aead *tfm, int enc,
569 struct aead_testvec *template, unsigned int tcount,
Jussi Kivilinna58dcf542013-06-13 17:37:50 +0300570 const bool diff_dst, const int align_offset)
Herbert Xuda7f0332008-07-31 17:08:25 +0800571{
572 const char *algo = crypto_tfm_alg_driver_name(crypto_aead_tfm(tfm));
573 unsigned int i, j, k, n, temp;
Herbert Xuf8b0d4d2009-05-06 14:15:47 +0800574 int ret = -ENOMEM;
Herbert Xuda7f0332008-07-31 17:08:25 +0800575 char *q;
576 char *key;
577 struct aead_request *req;
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300578 struct scatterlist *sg;
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300579 struct scatterlist *sgout;
580 const char *e, *d;
Herbert Xuda7f0332008-07-31 17:08:25 +0800581 struct tcrypt_result result;
Cristian Stoica424a5da2015-01-28 11:03:05 +0200582 unsigned int authsize, iv_len;
Herbert Xuda7f0332008-07-31 17:08:25 +0800583 void *input;
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300584 void *output;
Herbert Xuda7f0332008-07-31 17:08:25 +0800585 void *assoc;
Tadeusz Struk9bac0192014-05-19 09:51:33 -0700586 char *iv;
Herbert Xuf8b0d4d2009-05-06 14:15:47 +0800587 char *xbuf[XBUFSIZE];
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300588 char *xoutbuf[XBUFSIZE];
Herbert Xuf8b0d4d2009-05-06 14:15:47 +0800589 char *axbuf[XBUFSIZE];
590
Tadeusz Struk9bac0192014-05-19 09:51:33 -0700591 iv = kzalloc(MAX_IVLEN, GFP_KERNEL);
592 if (!iv)
593 return ret;
Horia Geanta29b77e52014-07-23 11:59:38 +0300594 key = kmalloc(MAX_KEYLEN, GFP_KERNEL);
595 if (!key)
596 goto out_noxbuf;
Herbert Xuf8b0d4d2009-05-06 14:15:47 +0800597 if (testmgr_alloc_buf(xbuf))
598 goto out_noxbuf;
599 if (testmgr_alloc_buf(axbuf))
600 goto out_noaxbuf;
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300601 if (diff_dst && testmgr_alloc_buf(xoutbuf))
602 goto out_nooutbuf;
603
604 /* avoid "the frame size is larger than 1024 bytes" compiler warning */
Herbert Xu8a525fc2015-05-27 16:03:43 +0800605 sg = kmalloc(sizeof(*sg) * 8 * (diff_dst ? 4 : 2), GFP_KERNEL);
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300606 if (!sg)
607 goto out_nosg;
Herbert Xu8a525fc2015-05-27 16:03:43 +0800608 sgout = &sg[16];
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300609
610 if (diff_dst)
611 d = "-ddst";
612 else
613 d = "";
614
Herbert Xuda7f0332008-07-31 17:08:25 +0800615 if (enc == ENCRYPT)
616 e = "encryption";
617 else
618 e = "decryption";
619
620 init_completion(&result.completion);
621
622 req = aead_request_alloc(tfm, GFP_KERNEL);
623 if (!req) {
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300624 pr_err("alg: aead%s: Failed to allocate request for %s\n",
625 d, algo);
Herbert Xuda7f0332008-07-31 17:08:25 +0800626 goto out;
627 }
628
629 aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
630 tcrypt_complete, &result);
631
Jerome Marchandabfa7f42016-02-03 13:58:12 +0100632 iv_len = crypto_aead_ivsize(tfm);
633
Herbert Xuda7f0332008-07-31 17:08:25 +0800634 for (i = 0, j = 0; i < tcount; i++) {
Cristian Stoica05b1d332014-07-28 13:11:23 +0300635 if (template[i].np)
636 continue;
Herbert Xuda7f0332008-07-31 17:08:25 +0800637
Cristian Stoica05b1d332014-07-28 13:11:23 +0300638 j++;
Herbert Xuda7f0332008-07-31 17:08:25 +0800639
Cristian Stoica05b1d332014-07-28 13:11:23 +0300640 /* some templates have no input data but they will
641 * touch input
642 */
643 input = xbuf[0];
644 input += align_offset;
645 assoc = axbuf[0];
646
647 ret = -EINVAL;
648 if (WARN_ON(align_offset + template[i].ilen >
649 PAGE_SIZE || template[i].alen > PAGE_SIZE))
650 goto out;
651
652 memcpy(input, template[i].input, template[i].ilen);
653 memcpy(assoc, template[i].assoc, template[i].alen);
654 if (template[i].iv)
Cristian Stoica424a5da2015-01-28 11:03:05 +0200655 memcpy(iv, template[i].iv, iv_len);
Cristian Stoica05b1d332014-07-28 13:11:23 +0300656 else
Cristian Stoica424a5da2015-01-28 11:03:05 +0200657 memset(iv, 0, iv_len);
Cristian Stoica05b1d332014-07-28 13:11:23 +0300658
659 crypto_aead_clear_flags(tfm, ~0);
660 if (template[i].wk)
661 crypto_aead_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
662
663 if (template[i].klen > MAX_KEYLEN) {
664 pr_err("alg: aead%s: setkey failed on test %d for %s: key size %d > %d\n",
665 d, j, algo, template[i].klen,
666 MAX_KEYLEN);
Herbert Xufd57f222009-05-29 16:05:42 +1000667 ret = -EINVAL;
Cristian Stoica05b1d332014-07-28 13:11:23 +0300668 goto out;
669 }
670 memcpy(key, template[i].key, template[i].klen);
Herbert Xufd57f222009-05-29 16:05:42 +1000671
Cristian Stoica05b1d332014-07-28 13:11:23 +0300672 ret = crypto_aead_setkey(tfm, key, template[i].klen);
Yanjiang Jin0fae0c12016-07-29 16:32:09 +0800673 if (template[i].fail == !ret) {
Cristian Stoica05b1d332014-07-28 13:11:23 +0300674 pr_err("alg: aead%s: setkey failed on test %d for %s: flags=%x\n",
675 d, j, algo, crypto_aead_get_flags(tfm));
676 goto out;
677 } else if (ret)
678 continue;
Herbert Xuda7f0332008-07-31 17:08:25 +0800679
Cristian Stoica05b1d332014-07-28 13:11:23 +0300680 authsize = abs(template[i].rlen - template[i].ilen);
681 ret = crypto_aead_setauthsize(tfm, authsize);
682 if (ret) {
683 pr_err("alg: aead%s: Failed to set authsize to %u on test %d for %s\n",
684 d, authsize, j, algo);
685 goto out;
686 }
Herbert Xuda7f0332008-07-31 17:08:25 +0800687
Herbert Xu8a525fc2015-05-27 16:03:43 +0800688 k = !!template[i].alen;
689 sg_init_table(sg, k + 1);
690 sg_set_buf(&sg[0], assoc, template[i].alen);
691 sg_set_buf(&sg[k], input,
692 template[i].ilen + (enc ? authsize : 0));
693 output = input;
694
Cristian Stoica05b1d332014-07-28 13:11:23 +0300695 if (diff_dst) {
Herbert Xu8a525fc2015-05-27 16:03:43 +0800696 sg_init_table(sgout, k + 1);
697 sg_set_buf(&sgout[0], assoc, template[i].alen);
698
Cristian Stoica05b1d332014-07-28 13:11:23 +0300699 output = xoutbuf[0];
700 output += align_offset;
Herbert Xu8a525fc2015-05-27 16:03:43 +0800701 sg_set_buf(&sgout[k], output,
702 template[i].rlen + (enc ? 0 : authsize));
Cristian Stoica05b1d332014-07-28 13:11:23 +0300703 }
704
Cristian Stoica05b1d332014-07-28 13:11:23 +0300705 aead_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
706 template[i].ilen, iv);
707
Herbert Xu8a525fc2015-05-27 16:03:43 +0800708 aead_request_set_ad(req, template[i].alen);
Cristian Stoica05b1d332014-07-28 13:11:23 +0300709
710 ret = enc ? crypto_aead_encrypt(req) : crypto_aead_decrypt(req);
711
712 switch (ret) {
713 case 0:
714 if (template[i].novrfy) {
715 /* verification was supposed to fail */
716 pr_err("alg: aead%s: %s failed on test %d for %s: ret was 0, expected -EBADMSG\n",
717 d, e, j, algo);
718 /* so really, we got a bad message */
719 ret = -EBADMSG;
Horia Geanta29b77e52014-07-23 11:59:38 +0300720 goto out;
721 }
Cristian Stoica05b1d332014-07-28 13:11:23 +0300722 break;
723 case -EINPROGRESS:
724 case -EBUSY:
Rabin Vincent8a45ac12015-01-09 16:25:28 +0100725 wait_for_completion(&result.completion);
726 reinit_completion(&result.completion);
727 ret = result.err;
728 if (!ret)
Herbert Xuda7f0332008-07-31 17:08:25 +0800729 break;
Cristian Stoica05b1d332014-07-28 13:11:23 +0300730 case -EBADMSG:
731 if (template[i].novrfy)
732 /* verification failure was expected */
733 continue;
734 /* fall through */
735 default:
736 pr_err("alg: aead%s: %s failed on test %d for %s: ret=%d\n",
737 d, e, j, algo, -ret);
738 goto out;
739 }
Herbert Xuda7f0332008-07-31 17:08:25 +0800740
Cristian Stoica05b1d332014-07-28 13:11:23 +0300741 q = output;
742 if (memcmp(q, template[i].result, template[i].rlen)) {
743 pr_err("alg: aead%s: Test %d failed on %s for %s\n",
744 d, j, e, algo);
745 hexdump(q, template[i].rlen);
746 ret = -EINVAL;
747 goto out;
Herbert Xuda7f0332008-07-31 17:08:25 +0800748 }
749 }
750
751 for (i = 0, j = 0; i < tcount; i++) {
Jussi Kivilinna58dcf542013-06-13 17:37:50 +0300752 /* alignment tests are only done with continuous buffers */
753 if (align_offset != 0)
754 break;
755
Cristian Stoica05b1d332014-07-28 13:11:23 +0300756 if (!template[i].np)
757 continue;
Herbert Xuda7f0332008-07-31 17:08:25 +0800758
Cristian Stoica05b1d332014-07-28 13:11:23 +0300759 j++;
Herbert Xuda7f0332008-07-31 17:08:25 +0800760
Cristian Stoica05b1d332014-07-28 13:11:23 +0300761 if (template[i].iv)
Jerome Marchandabfa7f42016-02-03 13:58:12 +0100762 memcpy(iv, template[i].iv, iv_len);
Cristian Stoica05b1d332014-07-28 13:11:23 +0300763 else
764 memset(iv, 0, MAX_IVLEN);
765
766 crypto_aead_clear_flags(tfm, ~0);
767 if (template[i].wk)
768 crypto_aead_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
769 if (template[i].klen > MAX_KEYLEN) {
770 pr_err("alg: aead%s: setkey failed on test %d for %s: key size %d > %d\n",
771 d, j, algo, template[i].klen, MAX_KEYLEN);
772 ret = -EINVAL;
773 goto out;
774 }
775 memcpy(key, template[i].key, template[i].klen);
776
777 ret = crypto_aead_setkey(tfm, key, template[i].klen);
Yanjiang Jin0fae0c12016-07-29 16:32:09 +0800778 if (template[i].fail == !ret) {
Cristian Stoica05b1d332014-07-28 13:11:23 +0300779 pr_err("alg: aead%s: setkey failed on chunk test %d for %s: flags=%x\n",
780 d, j, algo, crypto_aead_get_flags(tfm));
781 goto out;
782 } else if (ret)
783 continue;
784
785 authsize = abs(template[i].rlen - template[i].ilen);
786
787 ret = -EINVAL;
Herbert Xu8a525fc2015-05-27 16:03:43 +0800788 sg_init_table(sg, template[i].anp + template[i].np);
Cristian Stoica05b1d332014-07-28 13:11:23 +0300789 if (diff_dst)
Herbert Xu8a525fc2015-05-27 16:03:43 +0800790 sg_init_table(sgout, template[i].anp + template[i].np);
791
792 ret = -EINVAL;
793 for (k = 0, temp = 0; k < template[i].anp; k++) {
794 if (WARN_ON(offset_in_page(IDX[k]) +
795 template[i].atap[k] > PAGE_SIZE))
796 goto out;
797 sg_set_buf(&sg[k],
798 memcpy(axbuf[IDX[k] >> PAGE_SHIFT] +
799 offset_in_page(IDX[k]),
800 template[i].assoc + temp,
801 template[i].atap[k]),
802 template[i].atap[k]);
803 if (diff_dst)
804 sg_set_buf(&sgout[k],
805 axbuf[IDX[k] >> PAGE_SHIFT] +
806 offset_in_page(IDX[k]),
807 template[i].atap[k]);
808 temp += template[i].atap[k];
809 }
810
Cristian Stoica05b1d332014-07-28 13:11:23 +0300811 for (k = 0, temp = 0; k < template[i].np; k++) {
812 if (WARN_ON(offset_in_page(IDX[k]) +
813 template[i].tap[k] > PAGE_SIZE))
814 goto out;
815
816 q = xbuf[IDX[k] >> PAGE_SHIFT] + offset_in_page(IDX[k]);
817 memcpy(q, template[i].input + temp, template[i].tap[k]);
Herbert Xu8a525fc2015-05-27 16:03:43 +0800818 sg_set_buf(&sg[template[i].anp + k],
819 q, template[i].tap[k]);
Cristian Stoica05b1d332014-07-28 13:11:23 +0300820
821 if (diff_dst) {
822 q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
823 offset_in_page(IDX[k]);
824
825 memset(q, 0, template[i].tap[k]);
826
Herbert Xu8a525fc2015-05-27 16:03:43 +0800827 sg_set_buf(&sgout[template[i].anp + k],
828 q, template[i].tap[k]);
Cristian Stoica05b1d332014-07-28 13:11:23 +0300829 }
830
831 n = template[i].tap[k];
832 if (k == template[i].np - 1 && enc)
833 n += authsize;
834 if (offset_in_page(q) + n < PAGE_SIZE)
835 q[n] = 0;
836
837 temp += template[i].tap[k];
838 }
839
840 ret = crypto_aead_setauthsize(tfm, authsize);
841 if (ret) {
842 pr_err("alg: aead%s: Failed to set authsize to %u on chunk test %d for %s\n",
843 d, authsize, j, algo);
844 goto out;
845 }
846
847 if (enc) {
Herbert Xu8a525fc2015-05-27 16:03:43 +0800848 if (WARN_ON(sg[template[i].anp + k - 1].offset +
849 sg[template[i].anp + k - 1].length +
850 authsize > PAGE_SIZE)) {
Horia Geanta29b77e52014-07-23 11:59:38 +0300851 ret = -EINVAL;
852 goto out;
853 }
Herbert Xuda7f0332008-07-31 17:08:25 +0800854
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300855 if (diff_dst)
Herbert Xu8a525fc2015-05-27 16:03:43 +0800856 sgout[template[i].anp + k - 1].length +=
857 authsize;
858 sg[template[i].anp + k - 1].length += authsize;
Cristian Stoica05b1d332014-07-28 13:11:23 +0300859 }
860
861 aead_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
862 template[i].ilen,
863 iv);
864
Herbert Xu8a525fc2015-05-27 16:03:43 +0800865 aead_request_set_ad(req, template[i].alen);
Cristian Stoica05b1d332014-07-28 13:11:23 +0300866
867 ret = enc ? crypto_aead_encrypt(req) : crypto_aead_decrypt(req);
868
869 switch (ret) {
870 case 0:
871 if (template[i].novrfy) {
872 /* verification was supposed to fail */
873 pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret was 0, expected -EBADMSG\n",
874 d, e, j, algo);
875 /* so really, we got a bad message */
876 ret = -EBADMSG;
877 goto out;
878 }
879 break;
880 case -EINPROGRESS:
881 case -EBUSY:
Rabin Vincent8a45ac12015-01-09 16:25:28 +0100882 wait_for_completion(&result.completion);
883 reinit_completion(&result.completion);
884 ret = result.err;
885 if (!ret)
Cristian Stoica05b1d332014-07-28 13:11:23 +0300886 break;
Cristian Stoica05b1d332014-07-28 13:11:23 +0300887 case -EBADMSG:
888 if (template[i].novrfy)
889 /* verification failure was expected */
890 continue;
891 /* fall through */
892 default:
893 pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret=%d\n",
894 d, e, j, algo, -ret);
895 goto out;
896 }
897
898 ret = -EINVAL;
899 for (k = 0, temp = 0; k < template[i].np; k++) {
900 if (diff_dst)
901 q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
902 offset_in_page(IDX[k]);
903 else
Herbert Xuda7f0332008-07-31 17:08:25 +0800904 q = xbuf[IDX[k] >> PAGE_SHIFT] +
905 offset_in_page(IDX[k]);
906
Cristian Stoica05b1d332014-07-28 13:11:23 +0300907 n = template[i].tap[k];
908 if (k == template[i].np - 1)
909 n += enc ? authsize : -authsize;
Herbert Xuda7f0332008-07-31 17:08:25 +0800910
Cristian Stoica05b1d332014-07-28 13:11:23 +0300911 if (memcmp(q, template[i].result + temp, n)) {
912 pr_err("alg: aead%s: Chunk test %d failed on %s at page %u for %s\n",
913 d, j, e, k, algo);
914 hexdump(q, n);
Herbert Xuda7f0332008-07-31 17:08:25 +0800915 goto out;
916 }
917
Cristian Stoica05b1d332014-07-28 13:11:23 +0300918 q += n;
919 if (k == template[i].np - 1 && !enc) {
920 if (!diff_dst &&
921 memcmp(q, template[i].input +
922 temp + n, authsize))
923 n = authsize;
Horia Geanta8ec25c52013-11-28 15:11:18 +0200924 else
Cristian Stoica05b1d332014-07-28 13:11:23 +0300925 n = 0;
926 } else {
927 for (n = 0; offset_in_page(q + n) && q[n]; n++)
928 ;
Herbert Xuda7f0332008-07-31 17:08:25 +0800929 }
Cristian Stoica05b1d332014-07-28 13:11:23 +0300930 if (n) {
931 pr_err("alg: aead%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n",
932 d, j, e, k, algo, n);
933 hexdump(q, n);
Herbert Xuda7f0332008-07-31 17:08:25 +0800934 goto out;
935 }
936
Cristian Stoica05b1d332014-07-28 13:11:23 +0300937 temp += template[i].tap[k];
Herbert Xuda7f0332008-07-31 17:08:25 +0800938 }
939 }
940
941 ret = 0;
942
943out:
944 aead_request_free(req);
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300945 kfree(sg);
946out_nosg:
947 if (diff_dst)
948 testmgr_free_buf(xoutbuf);
949out_nooutbuf:
Herbert Xuf8b0d4d2009-05-06 14:15:47 +0800950 testmgr_free_buf(axbuf);
951out_noaxbuf:
952 testmgr_free_buf(xbuf);
953out_noxbuf:
Horia Geanta29b77e52014-07-23 11:59:38 +0300954 kfree(key);
Tadeusz Struk9bac0192014-05-19 09:51:33 -0700955 kfree(iv);
Herbert Xuda7f0332008-07-31 17:08:25 +0800956 return ret;
957}
958
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300959static int test_aead(struct crypto_aead *tfm, int enc,
960 struct aead_testvec *template, unsigned int tcount)
961{
Jussi Kivilinna58dcf542013-06-13 17:37:50 +0300962 unsigned int alignmask;
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300963 int ret;
964
965 /* test 'dst == src' case */
Jussi Kivilinna58dcf542013-06-13 17:37:50 +0300966 ret = __test_aead(tfm, enc, template, tcount, false, 0);
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300967 if (ret)
968 return ret;
969
970 /* test 'dst != src' case */
Jussi Kivilinna58dcf542013-06-13 17:37:50 +0300971 ret = __test_aead(tfm, enc, template, tcount, true, 0);
972 if (ret)
973 return ret;
974
975 /* test unaligned buffers, check with one byte offset */
976 ret = __test_aead(tfm, enc, template, tcount, true, 1);
977 if (ret)
978 return ret;
979
980 alignmask = crypto_tfm_alg_alignmask(&tfm->base);
981 if (alignmask) {
982 /* Check if alignment mask for tfm is correctly set. */
983 ret = __test_aead(tfm, enc, template, tcount, true,
984 alignmask + 1);
985 if (ret)
986 return ret;
987 }
988
989 return 0;
Jussi Kivilinnad8a32ac2012-09-21 10:26:52 +0300990}
991
Herbert Xu1aa4ecd2008-08-17 17:01:56 +1000992static int test_cipher(struct crypto_cipher *tfm, int enc,
Herbert Xuda7f0332008-07-31 17:08:25 +0800993 struct cipher_testvec *template, unsigned int tcount)
994{
Herbert Xu1aa4ecd2008-08-17 17:01:56 +1000995 const char *algo = crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm));
996 unsigned int i, j, k;
Herbert Xu1aa4ecd2008-08-17 17:01:56 +1000997 char *q;
998 const char *e;
999 void *data;
Herbert Xuf8b0d4d2009-05-06 14:15:47 +08001000 char *xbuf[XBUFSIZE];
1001 int ret = -ENOMEM;
1002
1003 if (testmgr_alloc_buf(xbuf))
1004 goto out_nobuf;
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10001005
1006 if (enc == ENCRYPT)
1007 e = "encryption";
1008 else
1009 e = "decryption";
1010
1011 j = 0;
1012 for (i = 0; i < tcount; i++) {
1013 if (template[i].np)
1014 continue;
1015
Stephan Mueller10faa8c2016-08-25 15:15:01 +02001016 if (fips_enabled && template[i].fips_skip)
1017 continue;
1018
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10001019 j++;
1020
Herbert Xufd57f222009-05-29 16:05:42 +10001021 ret = -EINVAL;
1022 if (WARN_ON(template[i].ilen > PAGE_SIZE))
1023 goto out;
1024
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10001025 data = xbuf[0];
1026 memcpy(data, template[i].input, template[i].ilen);
1027
1028 crypto_cipher_clear_flags(tfm, ~0);
1029 if (template[i].wk)
1030 crypto_cipher_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
1031
1032 ret = crypto_cipher_setkey(tfm, template[i].key,
1033 template[i].klen);
Yanjiang Jin0fae0c12016-07-29 16:32:09 +08001034 if (template[i].fail == !ret) {
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10001035 printk(KERN_ERR "alg: cipher: setkey failed "
1036 "on test %d for %s: flags=%x\n", j,
1037 algo, crypto_cipher_get_flags(tfm));
1038 goto out;
1039 } else if (ret)
1040 continue;
1041
1042 for (k = 0; k < template[i].ilen;
1043 k += crypto_cipher_blocksize(tfm)) {
1044 if (enc)
1045 crypto_cipher_encrypt_one(tfm, data + k,
1046 data + k);
1047 else
1048 crypto_cipher_decrypt_one(tfm, data + k,
1049 data + k);
1050 }
1051
1052 q = data;
1053 if (memcmp(q, template[i].result, template[i].rlen)) {
1054 printk(KERN_ERR "alg: cipher: Test %d failed "
1055 "on %s for %s\n", j, e, algo);
1056 hexdump(q, template[i].rlen);
1057 ret = -EINVAL;
1058 goto out;
1059 }
1060 }
1061
1062 ret = 0;
1063
1064out:
Herbert Xuf8b0d4d2009-05-06 14:15:47 +08001065 testmgr_free_buf(xbuf);
1066out_nobuf:
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10001067 return ret;
1068}
1069
Herbert Xu12773d92015-08-20 15:21:46 +08001070static int __test_skcipher(struct crypto_skcipher *tfm, int enc,
Jussi Kivilinna08d6af82012-09-21 10:26:47 +03001071 struct cipher_testvec *template, unsigned int tcount,
Jussi Kivilinna3a338f22013-06-13 17:37:45 +03001072 const bool diff_dst, const int align_offset)
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10001073{
Herbert Xuda7f0332008-07-31 17:08:25 +08001074 const char *algo =
Herbert Xu12773d92015-08-20 15:21:46 +08001075 crypto_tfm_alg_driver_name(crypto_skcipher_tfm(tfm));
Herbert Xuda7f0332008-07-31 17:08:25 +08001076 unsigned int i, j, k, n, temp;
Herbert Xuda7f0332008-07-31 17:08:25 +08001077 char *q;
Herbert Xu12773d92015-08-20 15:21:46 +08001078 struct skcipher_request *req;
Herbert Xuda7f0332008-07-31 17:08:25 +08001079 struct scatterlist sg[8];
Jussi Kivilinna08d6af82012-09-21 10:26:47 +03001080 struct scatterlist sgout[8];
1081 const char *e, *d;
Herbert Xuda7f0332008-07-31 17:08:25 +08001082 struct tcrypt_result result;
1083 void *data;
1084 char iv[MAX_IVLEN];
Herbert Xuf8b0d4d2009-05-06 14:15:47 +08001085 char *xbuf[XBUFSIZE];
Jussi Kivilinna08d6af82012-09-21 10:26:47 +03001086 char *xoutbuf[XBUFSIZE];
Herbert Xuf8b0d4d2009-05-06 14:15:47 +08001087 int ret = -ENOMEM;
Andrey Ryabinin84cba172015-09-10 13:11:55 +03001088 unsigned int ivsize = crypto_skcipher_ivsize(tfm);
Herbert Xuf8b0d4d2009-05-06 14:15:47 +08001089
1090 if (testmgr_alloc_buf(xbuf))
1091 goto out_nobuf;
Herbert Xuda7f0332008-07-31 17:08:25 +08001092
Jussi Kivilinna08d6af82012-09-21 10:26:47 +03001093 if (diff_dst && testmgr_alloc_buf(xoutbuf))
1094 goto out_nooutbuf;
1095
1096 if (diff_dst)
1097 d = "-ddst";
1098 else
1099 d = "";
1100
Herbert Xuda7f0332008-07-31 17:08:25 +08001101 if (enc == ENCRYPT)
1102 e = "encryption";
1103 else
1104 e = "decryption";
1105
1106 init_completion(&result.completion);
1107
Herbert Xu12773d92015-08-20 15:21:46 +08001108 req = skcipher_request_alloc(tfm, GFP_KERNEL);
Herbert Xuda7f0332008-07-31 17:08:25 +08001109 if (!req) {
Jussi Kivilinna08d6af82012-09-21 10:26:47 +03001110 pr_err("alg: skcipher%s: Failed to allocate request for %s\n",
1111 d, algo);
Herbert Xuda7f0332008-07-31 17:08:25 +08001112 goto out;
1113 }
1114
Herbert Xu12773d92015-08-20 15:21:46 +08001115 skcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
1116 tcrypt_complete, &result);
Herbert Xuda7f0332008-07-31 17:08:25 +08001117
1118 j = 0;
1119 for (i = 0; i < tcount; i++) {
Cristian Stoicabbb9a7d2014-08-08 14:27:52 +03001120 if (template[i].np && !template[i].also_non_np)
1121 continue;
1122
Stephan Mueller10faa8c2016-08-25 15:15:01 +02001123 if (fips_enabled && template[i].fips_skip)
1124 continue;
1125
Herbert Xuda7f0332008-07-31 17:08:25 +08001126 if (template[i].iv)
Andrey Ryabinin84cba172015-09-10 13:11:55 +03001127 memcpy(iv, template[i].iv, ivsize);
Herbert Xuda7f0332008-07-31 17:08:25 +08001128 else
1129 memset(iv, 0, MAX_IVLEN);
1130
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001131 j++;
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001132 ret = -EINVAL;
1133 if (WARN_ON(align_offset + template[i].ilen > PAGE_SIZE))
1134 goto out;
1135
1136 data = xbuf[0];
1137 data += align_offset;
1138 memcpy(data, template[i].input, template[i].ilen);
1139
Herbert Xu12773d92015-08-20 15:21:46 +08001140 crypto_skcipher_clear_flags(tfm, ~0);
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001141 if (template[i].wk)
Herbert Xu12773d92015-08-20 15:21:46 +08001142 crypto_skcipher_set_flags(tfm,
1143 CRYPTO_TFM_REQ_WEAK_KEY);
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001144
Herbert Xu12773d92015-08-20 15:21:46 +08001145 ret = crypto_skcipher_setkey(tfm, template[i].key,
1146 template[i].klen);
Yanjiang Jin0fae0c12016-07-29 16:32:09 +08001147 if (template[i].fail == !ret) {
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001148 pr_err("alg: skcipher%s: setkey failed on test %d for %s: flags=%x\n",
Herbert Xu12773d92015-08-20 15:21:46 +08001149 d, j, algo, crypto_skcipher_get_flags(tfm));
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001150 goto out;
1151 } else if (ret)
1152 continue;
1153
1154 sg_init_one(&sg[0], data, template[i].ilen);
1155 if (diff_dst) {
1156 data = xoutbuf[0];
Jussi Kivilinna3a338f22013-06-13 17:37:45 +03001157 data += align_offset;
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001158 sg_init_one(&sgout[0], data, template[i].ilen);
1159 }
Herbert Xuda7f0332008-07-31 17:08:25 +08001160
Herbert Xu12773d92015-08-20 15:21:46 +08001161 skcipher_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
1162 template[i].ilen, iv);
1163 ret = enc ? crypto_skcipher_encrypt(req) :
1164 crypto_skcipher_decrypt(req);
Herbert Xuda7f0332008-07-31 17:08:25 +08001165
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001166 switch (ret) {
1167 case 0:
1168 break;
1169 case -EINPROGRESS:
1170 case -EBUSY:
Rabin Vincent8a45ac12015-01-09 16:25:28 +01001171 wait_for_completion(&result.completion);
1172 reinit_completion(&result.completion);
1173 ret = result.err;
1174 if (!ret)
Herbert Xuda7f0332008-07-31 17:08:25 +08001175 break;
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001176 /* fall through */
1177 default:
1178 pr_err("alg: skcipher%s: %s failed on test %d for %s: ret=%d\n",
1179 d, e, j, algo, -ret);
1180 goto out;
1181 }
Herbert Xuda7f0332008-07-31 17:08:25 +08001182
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001183 q = data;
1184 if (memcmp(q, template[i].result, template[i].rlen)) {
Boris BREZILLON8a826a32015-06-16 11:46:46 +02001185 pr_err("alg: skcipher%s: Test %d failed (invalid result) on %s for %s\n",
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001186 d, j, e, algo);
1187 hexdump(q, template[i].rlen);
1188 ret = -EINVAL;
1189 goto out;
Herbert Xuda7f0332008-07-31 17:08:25 +08001190 }
Boris BREZILLON8a826a32015-06-16 11:46:46 +02001191
1192 if (template[i].iv_out &&
1193 memcmp(iv, template[i].iv_out,
1194 crypto_skcipher_ivsize(tfm))) {
1195 pr_err("alg: skcipher%s: Test %d failed (invalid output IV) on %s for %s\n",
1196 d, j, e, algo);
1197 hexdump(iv, crypto_skcipher_ivsize(tfm));
1198 ret = -EINVAL;
1199 goto out;
1200 }
Herbert Xuda7f0332008-07-31 17:08:25 +08001201 }
1202
1203 j = 0;
1204 for (i = 0; i < tcount; i++) {
Jussi Kivilinna3a338f22013-06-13 17:37:45 +03001205 /* alignment tests are only done with continuous buffers */
1206 if (align_offset != 0)
1207 break;
Herbert Xuda7f0332008-07-31 17:08:25 +08001208
Cristian Stoicabbb9a7d2014-08-08 14:27:52 +03001209 if (!template[i].np)
1210 continue;
1211
Stephan Mueller10faa8c2016-08-25 15:15:01 +02001212 if (fips_enabled && template[i].fips_skip)
1213 continue;
1214
Herbert Xuda7f0332008-07-31 17:08:25 +08001215 if (template[i].iv)
Andrey Ryabinin84cba172015-09-10 13:11:55 +03001216 memcpy(iv, template[i].iv, ivsize);
Herbert Xuda7f0332008-07-31 17:08:25 +08001217 else
1218 memset(iv, 0, MAX_IVLEN);
1219
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001220 j++;
Herbert Xu12773d92015-08-20 15:21:46 +08001221 crypto_skcipher_clear_flags(tfm, ~0);
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001222 if (template[i].wk)
Herbert Xu12773d92015-08-20 15:21:46 +08001223 crypto_skcipher_set_flags(tfm,
1224 CRYPTO_TFM_REQ_WEAK_KEY);
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001225
Herbert Xu12773d92015-08-20 15:21:46 +08001226 ret = crypto_skcipher_setkey(tfm, template[i].key,
1227 template[i].klen);
Yanjiang Jin0fae0c12016-07-29 16:32:09 +08001228 if (template[i].fail == !ret) {
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001229 pr_err("alg: skcipher%s: setkey failed on chunk test %d for %s: flags=%x\n",
Herbert Xu12773d92015-08-20 15:21:46 +08001230 d, j, algo, crypto_skcipher_get_flags(tfm));
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001231 goto out;
1232 } else if (ret)
1233 continue;
1234
1235 temp = 0;
1236 ret = -EINVAL;
1237 sg_init_table(sg, template[i].np);
1238 if (diff_dst)
1239 sg_init_table(sgout, template[i].np);
1240 for (k = 0; k < template[i].np; k++) {
1241 if (WARN_ON(offset_in_page(IDX[k]) +
1242 template[i].tap[k] > PAGE_SIZE))
Herbert Xuda7f0332008-07-31 17:08:25 +08001243 goto out;
Herbert Xuda7f0332008-07-31 17:08:25 +08001244
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001245 q = xbuf[IDX[k] >> PAGE_SHIFT] + offset_in_page(IDX[k]);
1246
1247 memcpy(q, template[i].input + temp, template[i].tap[k]);
1248
1249 if (offset_in_page(q) + template[i].tap[k] < PAGE_SIZE)
1250 q[template[i].tap[k]] = 0;
1251
1252 sg_set_buf(&sg[k], q, template[i].tap[k]);
1253 if (diff_dst) {
1254 q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
1255 offset_in_page(IDX[k]);
1256
1257 sg_set_buf(&sgout[k], q, template[i].tap[k]);
1258
1259 memset(q, 0, template[i].tap[k]);
1260 if (offset_in_page(q) +
1261 template[i].tap[k] < PAGE_SIZE)
1262 q[template[i].tap[k]] = 0;
1263 }
1264
1265 temp += template[i].tap[k];
1266 }
1267
Herbert Xu12773d92015-08-20 15:21:46 +08001268 skcipher_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
1269 template[i].ilen, iv);
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001270
Herbert Xu12773d92015-08-20 15:21:46 +08001271 ret = enc ? crypto_skcipher_encrypt(req) :
1272 crypto_skcipher_decrypt(req);
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001273
1274 switch (ret) {
1275 case 0:
1276 break;
1277 case -EINPROGRESS:
1278 case -EBUSY:
Rabin Vincent8a45ac12015-01-09 16:25:28 +01001279 wait_for_completion(&result.completion);
1280 reinit_completion(&result.completion);
1281 ret = result.err;
1282 if (!ret)
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001283 break;
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001284 /* fall through */
1285 default:
1286 pr_err("alg: skcipher%s: %s failed on chunk test %d for %s: ret=%d\n",
1287 d, e, j, algo, -ret);
1288 goto out;
1289 }
1290
1291 temp = 0;
1292 ret = -EINVAL;
1293 for (k = 0; k < template[i].np; k++) {
Jussi Kivilinna08d6af82012-09-21 10:26:47 +03001294 if (diff_dst)
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001295 q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
1296 offset_in_page(IDX[k]);
1297 else
Herbert Xuda7f0332008-07-31 17:08:25 +08001298 q = xbuf[IDX[k] >> PAGE_SHIFT] +
1299 offset_in_page(IDX[k]);
1300
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001301 if (memcmp(q, template[i].result + temp,
1302 template[i].tap[k])) {
1303 pr_err("alg: skcipher%s: Chunk test %d failed on %s at page %u for %s\n",
1304 d, j, e, k, algo);
1305 hexdump(q, template[i].tap[k]);
Herbert Xuda7f0332008-07-31 17:08:25 +08001306 goto out;
1307 }
1308
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001309 q += template[i].tap[k];
1310 for (n = 0; offset_in_page(q + n) && q[n]; n++)
1311 ;
1312 if (n) {
1313 pr_err("alg: skcipher%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n",
1314 d, j, e, k, algo, n);
1315 hexdump(q, n);
1316 goto out;
Herbert Xuda7f0332008-07-31 17:08:25 +08001317 }
Cristian Stoicaa1aa44a2014-08-08 14:27:51 +03001318 temp += template[i].tap[k];
Herbert Xuda7f0332008-07-31 17:08:25 +08001319 }
1320 }
1321
1322 ret = 0;
1323
1324out:
Herbert Xu12773d92015-08-20 15:21:46 +08001325 skcipher_request_free(req);
Jussi Kivilinna08d6af82012-09-21 10:26:47 +03001326 if (diff_dst)
1327 testmgr_free_buf(xoutbuf);
1328out_nooutbuf:
Herbert Xuf8b0d4d2009-05-06 14:15:47 +08001329 testmgr_free_buf(xbuf);
1330out_nobuf:
Herbert Xuda7f0332008-07-31 17:08:25 +08001331 return ret;
1332}
1333
Herbert Xu12773d92015-08-20 15:21:46 +08001334static int test_skcipher(struct crypto_skcipher *tfm, int enc,
Jussi Kivilinna08d6af82012-09-21 10:26:47 +03001335 struct cipher_testvec *template, unsigned int tcount)
1336{
Jussi Kivilinna3a338f22013-06-13 17:37:45 +03001337 unsigned int alignmask;
Jussi Kivilinna08d6af82012-09-21 10:26:47 +03001338 int ret;
1339
1340 /* test 'dst == src' case */
Jussi Kivilinna3a338f22013-06-13 17:37:45 +03001341 ret = __test_skcipher(tfm, enc, template, tcount, false, 0);
Jussi Kivilinna08d6af82012-09-21 10:26:47 +03001342 if (ret)
1343 return ret;
1344
1345 /* test 'dst != src' case */
Jussi Kivilinna3a338f22013-06-13 17:37:45 +03001346 ret = __test_skcipher(tfm, enc, template, tcount, true, 0);
1347 if (ret)
1348 return ret;
1349
1350 /* test unaligned buffers, check with one byte offset */
1351 ret = __test_skcipher(tfm, enc, template, tcount, true, 1);
1352 if (ret)
1353 return ret;
1354
1355 alignmask = crypto_tfm_alg_alignmask(&tfm->base);
1356 if (alignmask) {
1357 /* Check if alignment mask for tfm is correctly set. */
1358 ret = __test_skcipher(tfm, enc, template, tcount, true,
1359 alignmask + 1);
1360 if (ret)
1361 return ret;
1362 }
1363
1364 return 0;
Jussi Kivilinna08d6af82012-09-21 10:26:47 +03001365}
1366
Herbert Xuda7f0332008-07-31 17:08:25 +08001367static int test_comp(struct crypto_comp *tfm, struct comp_testvec *ctemplate,
1368 struct comp_testvec *dtemplate, int ctcount, int dtcount)
1369{
1370 const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm));
1371 unsigned int i;
1372 char result[COMP_BUF_SIZE];
1373 int ret;
1374
1375 for (i = 0; i < ctcount; i++) {
Geert Uytterhoevenc79cf912009-03-29 15:44:19 +08001376 int ilen;
1377 unsigned int dlen = COMP_BUF_SIZE;
Herbert Xuda7f0332008-07-31 17:08:25 +08001378
1379 memset(result, 0, sizeof (result));
1380
1381 ilen = ctemplate[i].inlen;
1382 ret = crypto_comp_compress(tfm, ctemplate[i].input,
1383 ilen, result, &dlen);
1384 if (ret) {
1385 printk(KERN_ERR "alg: comp: compression failed "
1386 "on test %d for %s: ret=%d\n", i + 1, algo,
1387 -ret);
1388 goto out;
1389 }
1390
Geert Uytterhoevenb812eb02008-11-28 20:51:28 +08001391 if (dlen != ctemplate[i].outlen) {
1392 printk(KERN_ERR "alg: comp: Compression test %d "
1393 "failed for %s: output len = %d\n", i + 1, algo,
1394 dlen);
1395 ret = -EINVAL;
1396 goto out;
1397 }
1398
Herbert Xuda7f0332008-07-31 17:08:25 +08001399 if (memcmp(result, ctemplate[i].output, dlen)) {
1400 printk(KERN_ERR "alg: comp: Compression test %d "
1401 "failed for %s\n", i + 1, algo);
1402 hexdump(result, dlen);
1403 ret = -EINVAL;
1404 goto out;
1405 }
1406 }
1407
1408 for (i = 0; i < dtcount; i++) {
Geert Uytterhoevenc79cf912009-03-29 15:44:19 +08001409 int ilen;
1410 unsigned int dlen = COMP_BUF_SIZE;
Herbert Xuda7f0332008-07-31 17:08:25 +08001411
1412 memset(result, 0, sizeof (result));
1413
1414 ilen = dtemplate[i].inlen;
1415 ret = crypto_comp_decompress(tfm, dtemplate[i].input,
1416 ilen, result, &dlen);
1417 if (ret) {
1418 printk(KERN_ERR "alg: comp: decompression failed "
1419 "on test %d for %s: ret=%d\n", i + 1, algo,
1420 -ret);
1421 goto out;
1422 }
1423
Geert Uytterhoevenb812eb02008-11-28 20:51:28 +08001424 if (dlen != dtemplate[i].outlen) {
1425 printk(KERN_ERR "alg: comp: Decompression test %d "
1426 "failed for %s: output len = %d\n", i + 1, algo,
1427 dlen);
1428 ret = -EINVAL;
1429 goto out;
1430 }
1431
Herbert Xuda7f0332008-07-31 17:08:25 +08001432 if (memcmp(result, dtemplate[i].output, dlen)) {
1433 printk(KERN_ERR "alg: comp: Decompression test %d "
1434 "failed for %s\n", i + 1, algo);
1435 hexdump(result, dlen);
1436 ret = -EINVAL;
1437 goto out;
1438 }
1439 }
1440
1441 ret = 0;
1442
1443out:
1444 return ret;
1445}
1446
Giovanni Cabiddud7db7a82016-10-21 13:19:54 +01001447static int test_acomp(struct crypto_acomp *tfm, struct comp_testvec *ctemplate,
1448 struct comp_testvec *dtemplate, int ctcount, int dtcount)
1449{
1450 const char *algo = crypto_tfm_alg_driver_name(crypto_acomp_tfm(tfm));
1451 unsigned int i;
Eric Biggerseb095592016-11-23 10:24:35 -08001452 char *output;
Giovanni Cabiddud7db7a82016-10-21 13:19:54 +01001453 int ret;
1454 struct scatterlist src, dst;
1455 struct acomp_req *req;
1456 struct tcrypt_result result;
1457
Eric Biggerseb095592016-11-23 10:24:35 -08001458 output = kmalloc(COMP_BUF_SIZE, GFP_KERNEL);
1459 if (!output)
1460 return -ENOMEM;
1461
Giovanni Cabiddud7db7a82016-10-21 13:19:54 +01001462 for (i = 0; i < ctcount; i++) {
1463 unsigned int dlen = COMP_BUF_SIZE;
1464 int ilen = ctemplate[i].inlen;
Laura Abbott02608e02016-12-21 12:32:54 -08001465 void *input_vec;
Giovanni Cabiddud7db7a82016-10-21 13:19:54 +01001466
Eric Biggersd2110222016-12-30 14:12:00 -06001467 input_vec = kmemdup(ctemplate[i].input, ilen, GFP_KERNEL);
Laura Abbott02608e02016-12-21 12:32:54 -08001468 if (!input_vec) {
1469 ret = -ENOMEM;
1470 goto out;
1471 }
1472
Eric Biggerseb095592016-11-23 10:24:35 -08001473 memset(output, 0, dlen);
Giovanni Cabiddud7db7a82016-10-21 13:19:54 +01001474 init_completion(&result.completion);
Laura Abbott02608e02016-12-21 12:32:54 -08001475 sg_init_one(&src, input_vec, ilen);
Giovanni Cabiddud7db7a82016-10-21 13:19:54 +01001476 sg_init_one(&dst, output, dlen);
1477
1478 req = acomp_request_alloc(tfm);
1479 if (!req) {
1480 pr_err("alg: acomp: request alloc failed for %s\n",
1481 algo);
Laura Abbott02608e02016-12-21 12:32:54 -08001482 kfree(input_vec);
Giovanni Cabiddud7db7a82016-10-21 13:19:54 +01001483 ret = -ENOMEM;
1484 goto out;
1485 }
1486
1487 acomp_request_set_params(req, &src, &dst, ilen, dlen);
1488 acomp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
1489 tcrypt_complete, &result);
1490
1491 ret = wait_async_op(&result, crypto_acomp_compress(req));
1492 if (ret) {
1493 pr_err("alg: acomp: compression failed on test %d for %s: ret=%d\n",
1494 i + 1, algo, -ret);
Laura Abbott02608e02016-12-21 12:32:54 -08001495 kfree(input_vec);
Giovanni Cabiddud7db7a82016-10-21 13:19:54 +01001496 acomp_request_free(req);
1497 goto out;
1498 }
1499
1500 if (req->dlen != ctemplate[i].outlen) {
1501 pr_err("alg: acomp: Compression test %d failed for %s: output len = %d\n",
1502 i + 1, algo, req->dlen);
1503 ret = -EINVAL;
Laura Abbott02608e02016-12-21 12:32:54 -08001504 kfree(input_vec);
Giovanni Cabiddud7db7a82016-10-21 13:19:54 +01001505 acomp_request_free(req);
1506 goto out;
1507 }
1508
1509 if (memcmp(output, ctemplate[i].output, req->dlen)) {
1510 pr_err("alg: acomp: Compression test %d failed for %s\n",
1511 i + 1, algo);
1512 hexdump(output, req->dlen);
1513 ret = -EINVAL;
Laura Abbott02608e02016-12-21 12:32:54 -08001514 kfree(input_vec);
Giovanni Cabiddud7db7a82016-10-21 13:19:54 +01001515 acomp_request_free(req);
1516 goto out;
1517 }
1518
Laura Abbott02608e02016-12-21 12:32:54 -08001519 kfree(input_vec);
Giovanni Cabiddud7db7a82016-10-21 13:19:54 +01001520 acomp_request_free(req);
1521 }
1522
1523 for (i = 0; i < dtcount; i++) {
1524 unsigned int dlen = COMP_BUF_SIZE;
1525 int ilen = dtemplate[i].inlen;
Laura Abbott02608e02016-12-21 12:32:54 -08001526 void *input_vec;
Giovanni Cabiddud7db7a82016-10-21 13:19:54 +01001527
Eric Biggersd2110222016-12-30 14:12:00 -06001528 input_vec = kmemdup(dtemplate[i].input, ilen, GFP_KERNEL);
Laura Abbott02608e02016-12-21 12:32:54 -08001529 if (!input_vec) {
1530 ret = -ENOMEM;
1531 goto out;
1532 }
1533
Eric Biggerseb095592016-11-23 10:24:35 -08001534 memset(output, 0, dlen);
Giovanni Cabiddud7db7a82016-10-21 13:19:54 +01001535 init_completion(&result.completion);
Laura Abbott02608e02016-12-21 12:32:54 -08001536 sg_init_one(&src, input_vec, ilen);
Giovanni Cabiddud7db7a82016-10-21 13:19:54 +01001537 sg_init_one(&dst, output, dlen);
1538
1539 req = acomp_request_alloc(tfm);
1540 if (!req) {
1541 pr_err("alg: acomp: request alloc failed for %s\n",
1542 algo);
Laura Abbott02608e02016-12-21 12:32:54 -08001543 kfree(input_vec);
Giovanni Cabiddud7db7a82016-10-21 13:19:54 +01001544 ret = -ENOMEM;
1545 goto out;
1546 }
1547
1548 acomp_request_set_params(req, &src, &dst, ilen, dlen);
1549 acomp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
1550 tcrypt_complete, &result);
1551
1552 ret = wait_async_op(&result, crypto_acomp_decompress(req));
1553 if (ret) {
1554 pr_err("alg: acomp: decompression failed on test %d for %s: ret=%d\n",
1555 i + 1, algo, -ret);
Laura Abbott02608e02016-12-21 12:32:54 -08001556 kfree(input_vec);
Giovanni Cabiddud7db7a82016-10-21 13:19:54 +01001557 acomp_request_free(req);
1558 goto out;
1559 }
1560
1561 if (req->dlen != dtemplate[i].outlen) {
1562 pr_err("alg: acomp: Decompression test %d failed for %s: output len = %d\n",
1563 i + 1, algo, req->dlen);
1564 ret = -EINVAL;
Laura Abbott02608e02016-12-21 12:32:54 -08001565 kfree(input_vec);
Giovanni Cabiddud7db7a82016-10-21 13:19:54 +01001566 acomp_request_free(req);
1567 goto out;
1568 }
1569
1570 if (memcmp(output, dtemplate[i].output, req->dlen)) {
1571 pr_err("alg: acomp: Decompression test %d failed for %s\n",
1572 i + 1, algo);
1573 hexdump(output, req->dlen);
1574 ret = -EINVAL;
Laura Abbott02608e02016-12-21 12:32:54 -08001575 kfree(input_vec);
Giovanni Cabiddud7db7a82016-10-21 13:19:54 +01001576 acomp_request_free(req);
1577 goto out;
1578 }
1579
Laura Abbott02608e02016-12-21 12:32:54 -08001580 kfree(input_vec);
Giovanni Cabiddud7db7a82016-10-21 13:19:54 +01001581 acomp_request_free(req);
1582 }
1583
1584 ret = 0;
1585
1586out:
Eric Biggerseb095592016-11-23 10:24:35 -08001587 kfree(output);
Giovanni Cabiddud7db7a82016-10-21 13:19:54 +01001588 return ret;
1589}
1590
Jarod Wilson7647d6c2009-05-04 19:44:50 +08001591static int test_cprng(struct crypto_rng *tfm, struct cprng_testvec *template,
1592 unsigned int tcount)
1593{
1594 const char *algo = crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm));
Felipe Contrerasfa4ef8a2009-10-27 19:04:42 +08001595 int err = 0, i, j, seedsize;
Jarod Wilson7647d6c2009-05-04 19:44:50 +08001596 u8 *seed;
1597 char result[32];
1598
1599 seedsize = crypto_rng_seedsize(tfm);
1600
1601 seed = kmalloc(seedsize, GFP_KERNEL);
1602 if (!seed) {
1603 printk(KERN_ERR "alg: cprng: Failed to allocate seed space "
1604 "for %s\n", algo);
1605 return -ENOMEM;
1606 }
1607
1608 for (i = 0; i < tcount; i++) {
1609 memset(result, 0, 32);
1610
1611 memcpy(seed, template[i].v, template[i].vlen);
1612 memcpy(seed + template[i].vlen, template[i].key,
1613 template[i].klen);
1614 memcpy(seed + template[i].vlen + template[i].klen,
1615 template[i].dt, template[i].dtlen);
1616
1617 err = crypto_rng_reset(tfm, seed, seedsize);
1618 if (err) {
1619 printk(KERN_ERR "alg: cprng: Failed to reset rng "
1620 "for %s\n", algo);
1621 goto out;
1622 }
1623
1624 for (j = 0; j < template[i].loops; j++) {
1625 err = crypto_rng_get_bytes(tfm, result,
1626 template[i].rlen);
Stephan Mueller19e60e12015-03-10 17:00:36 +01001627 if (err < 0) {
Jarod Wilson7647d6c2009-05-04 19:44:50 +08001628 printk(KERN_ERR "alg: cprng: Failed to obtain "
1629 "the correct amount of random data for "
Stephan Mueller19e60e12015-03-10 17:00:36 +01001630 "%s (requested %d)\n", algo,
1631 template[i].rlen);
Jarod Wilson7647d6c2009-05-04 19:44:50 +08001632 goto out;
1633 }
1634 }
1635
1636 err = memcmp(result, template[i].result,
1637 template[i].rlen);
1638 if (err) {
1639 printk(KERN_ERR "alg: cprng: Test %d failed for %s\n",
1640 i, algo);
1641 hexdump(result, template[i].rlen);
1642 err = -EINVAL;
1643 goto out;
1644 }
1645 }
1646
1647out:
1648 kfree(seed);
1649 return err;
1650}
1651
Herbert Xuda7f0332008-07-31 17:08:25 +08001652static int alg_test_aead(const struct alg_test_desc *desc, const char *driver,
1653 u32 type, u32 mask)
1654{
1655 struct crypto_aead *tfm;
1656 int err = 0;
1657
Herbert Xueed93e02016-11-22 20:08:31 +08001658 tfm = crypto_alloc_aead(driver, type, mask);
Herbert Xuda7f0332008-07-31 17:08:25 +08001659 if (IS_ERR(tfm)) {
1660 printk(KERN_ERR "alg: aead: Failed to load transform for %s: "
1661 "%ld\n", driver, PTR_ERR(tfm));
1662 return PTR_ERR(tfm);
1663 }
1664
1665 if (desc->suite.aead.enc.vecs) {
1666 err = test_aead(tfm, ENCRYPT, desc->suite.aead.enc.vecs,
1667 desc->suite.aead.enc.count);
1668 if (err)
1669 goto out;
1670 }
1671
1672 if (!err && desc->suite.aead.dec.vecs)
1673 err = test_aead(tfm, DECRYPT, desc->suite.aead.dec.vecs,
1674 desc->suite.aead.dec.count);
1675
1676out:
1677 crypto_free_aead(tfm);
1678 return err;
1679}
1680
1681static int alg_test_cipher(const struct alg_test_desc *desc,
1682 const char *driver, u32 type, u32 mask)
1683{
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10001684 struct crypto_cipher *tfm;
Herbert Xuda7f0332008-07-31 17:08:25 +08001685 int err = 0;
1686
Herbert Xueed93e02016-11-22 20:08:31 +08001687 tfm = crypto_alloc_cipher(driver, type, mask);
Herbert Xuda7f0332008-07-31 17:08:25 +08001688 if (IS_ERR(tfm)) {
1689 printk(KERN_ERR "alg: cipher: Failed to load transform for "
1690 "%s: %ld\n", driver, PTR_ERR(tfm));
1691 return PTR_ERR(tfm);
1692 }
1693
1694 if (desc->suite.cipher.enc.vecs) {
1695 err = test_cipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
1696 desc->suite.cipher.enc.count);
1697 if (err)
1698 goto out;
1699 }
1700
1701 if (desc->suite.cipher.dec.vecs)
1702 err = test_cipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
1703 desc->suite.cipher.dec.count);
1704
1705out:
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10001706 crypto_free_cipher(tfm);
1707 return err;
1708}
1709
1710static int alg_test_skcipher(const struct alg_test_desc *desc,
1711 const char *driver, u32 type, u32 mask)
1712{
Herbert Xu12773d92015-08-20 15:21:46 +08001713 struct crypto_skcipher *tfm;
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10001714 int err = 0;
1715
Herbert Xueed93e02016-11-22 20:08:31 +08001716 tfm = crypto_alloc_skcipher(driver, type, mask);
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10001717 if (IS_ERR(tfm)) {
1718 printk(KERN_ERR "alg: skcipher: Failed to load transform for "
1719 "%s: %ld\n", driver, PTR_ERR(tfm));
1720 return PTR_ERR(tfm);
1721 }
1722
1723 if (desc->suite.cipher.enc.vecs) {
1724 err = test_skcipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
1725 desc->suite.cipher.enc.count);
1726 if (err)
1727 goto out;
1728 }
1729
1730 if (desc->suite.cipher.dec.vecs)
1731 err = test_skcipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
1732 desc->suite.cipher.dec.count);
1733
1734out:
Herbert Xu12773d92015-08-20 15:21:46 +08001735 crypto_free_skcipher(tfm);
Herbert Xuda7f0332008-07-31 17:08:25 +08001736 return err;
1737}
1738
1739static int alg_test_comp(const struct alg_test_desc *desc, const char *driver,
1740 u32 type, u32 mask)
1741{
Giovanni Cabiddud7db7a82016-10-21 13:19:54 +01001742 struct crypto_comp *comp;
1743 struct crypto_acomp *acomp;
Herbert Xuda7f0332008-07-31 17:08:25 +08001744 int err;
Giovanni Cabiddud7db7a82016-10-21 13:19:54 +01001745 u32 algo_type = type & CRYPTO_ALG_TYPE_ACOMPRESS_MASK;
Herbert Xuda7f0332008-07-31 17:08:25 +08001746
Giovanni Cabiddud7db7a82016-10-21 13:19:54 +01001747 if (algo_type == CRYPTO_ALG_TYPE_ACOMPRESS) {
1748 acomp = crypto_alloc_acomp(driver, type, mask);
1749 if (IS_ERR(acomp)) {
1750 pr_err("alg: acomp: Failed to load transform for %s: %ld\n",
1751 driver, PTR_ERR(acomp));
1752 return PTR_ERR(acomp);
1753 }
1754 err = test_acomp(acomp, desc->suite.comp.comp.vecs,
1755 desc->suite.comp.decomp.vecs,
1756 desc->suite.comp.comp.count,
1757 desc->suite.comp.decomp.count);
1758 crypto_free_acomp(acomp);
1759 } else {
1760 comp = crypto_alloc_comp(driver, type, mask);
1761 if (IS_ERR(comp)) {
1762 pr_err("alg: comp: Failed to load transform for %s: %ld\n",
1763 driver, PTR_ERR(comp));
1764 return PTR_ERR(comp);
1765 }
1766
1767 err = test_comp(comp, desc->suite.comp.comp.vecs,
1768 desc->suite.comp.decomp.vecs,
1769 desc->suite.comp.comp.count,
1770 desc->suite.comp.decomp.count);
1771
1772 crypto_free_comp(comp);
Herbert Xuda7f0332008-07-31 17:08:25 +08001773 }
Herbert Xuda7f0332008-07-31 17:08:25 +08001774 return err;
1775}
1776
1777static int alg_test_hash(const struct alg_test_desc *desc, const char *driver,
1778 u32 type, u32 mask)
1779{
1780 struct crypto_ahash *tfm;
1781 int err;
1782
Herbert Xueed93e02016-11-22 20:08:31 +08001783 tfm = crypto_alloc_ahash(driver, type, mask);
Herbert Xuda7f0332008-07-31 17:08:25 +08001784 if (IS_ERR(tfm)) {
1785 printk(KERN_ERR "alg: hash: Failed to load transform for %s: "
1786 "%ld\n", driver, PTR_ERR(tfm));
1787 return PTR_ERR(tfm);
1788 }
1789
David S. Millera8f1a052010-05-19 14:12:03 +10001790 err = test_hash(tfm, desc->suite.hash.vecs,
1791 desc->suite.hash.count, true);
1792 if (!err)
1793 err = test_hash(tfm, desc->suite.hash.vecs,
1794 desc->suite.hash.count, false);
Herbert Xuda7f0332008-07-31 17:08:25 +08001795
1796 crypto_free_ahash(tfm);
1797 return err;
1798}
1799
Herbert Xu8e3ee852008-11-07 14:58:52 +08001800static int alg_test_crc32c(const struct alg_test_desc *desc,
1801 const char *driver, u32 type, u32 mask)
1802{
1803 struct crypto_shash *tfm;
1804 u32 val;
1805 int err;
1806
1807 err = alg_test_hash(desc, driver, type, mask);
1808 if (err)
1809 goto out;
1810
Herbert Xueed93e02016-11-22 20:08:31 +08001811 tfm = crypto_alloc_shash(driver, type, mask);
Herbert Xu8e3ee852008-11-07 14:58:52 +08001812 if (IS_ERR(tfm)) {
1813 printk(KERN_ERR "alg: crc32c: Failed to load transform for %s: "
1814 "%ld\n", driver, PTR_ERR(tfm));
1815 err = PTR_ERR(tfm);
1816 goto out;
1817 }
1818
1819 do {
Jan-Simon Möller4c5c3022012-07-02 13:48:30 +02001820 SHASH_DESC_ON_STACK(shash, tfm);
1821 u32 *ctx = (u32 *)shash_desc_ctx(shash);
Herbert Xu8e3ee852008-11-07 14:58:52 +08001822
Jan-Simon Möller4c5c3022012-07-02 13:48:30 +02001823 shash->tfm = tfm;
1824 shash->flags = 0;
Herbert Xu8e3ee852008-11-07 14:58:52 +08001825
Jan-Simon Möller4c5c3022012-07-02 13:48:30 +02001826 *ctx = le32_to_cpu(420553207);
1827 err = crypto_shash_final(shash, (u8 *)&val);
Herbert Xu8e3ee852008-11-07 14:58:52 +08001828 if (err) {
1829 printk(KERN_ERR "alg: crc32c: Operation failed for "
1830 "%s: %d\n", driver, err);
1831 break;
1832 }
1833
1834 if (val != ~420553207) {
1835 printk(KERN_ERR "alg: crc32c: Test failed for %s: "
1836 "%d\n", driver, val);
1837 err = -EINVAL;
1838 }
1839 } while (0);
1840
1841 crypto_free_shash(tfm);
1842
1843out:
1844 return err;
1845}
1846
Jarod Wilson7647d6c2009-05-04 19:44:50 +08001847static int alg_test_cprng(const struct alg_test_desc *desc, const char *driver,
1848 u32 type, u32 mask)
1849{
1850 struct crypto_rng *rng;
1851 int err;
1852
Herbert Xueed93e02016-11-22 20:08:31 +08001853 rng = crypto_alloc_rng(driver, type, mask);
Jarod Wilson7647d6c2009-05-04 19:44:50 +08001854 if (IS_ERR(rng)) {
1855 printk(KERN_ERR "alg: cprng: Failed to load transform for %s: "
1856 "%ld\n", driver, PTR_ERR(rng));
1857 return PTR_ERR(rng);
1858 }
1859
1860 err = test_cprng(rng, desc->suite.cprng.vecs, desc->suite.cprng.count);
1861
1862 crypto_free_rng(rng);
1863
1864 return err;
1865}
1866
Stephan Mueller64d1cdf2014-05-31 17:25:36 +02001867
1868static int drbg_cavs_test(struct drbg_testvec *test, int pr,
1869 const char *driver, u32 type, u32 mask)
1870{
1871 int ret = -EAGAIN;
1872 struct crypto_rng *drng;
1873 struct drbg_test_data test_data;
1874 struct drbg_string addtl, pers, testentropy;
1875 unsigned char *buf = kzalloc(test->expectedlen, GFP_KERNEL);
1876
1877 if (!buf)
1878 return -ENOMEM;
1879
Herbert Xueed93e02016-11-22 20:08:31 +08001880 drng = crypto_alloc_rng(driver, type, mask);
Stephan Mueller64d1cdf2014-05-31 17:25:36 +02001881 if (IS_ERR(drng)) {
Jarod Wilson2fc0d252014-07-29 15:47:56 -04001882 printk(KERN_ERR "alg: drbg: could not allocate DRNG handle for "
Stephan Mueller64d1cdf2014-05-31 17:25:36 +02001883 "%s\n", driver);
1884 kzfree(buf);
1885 return -ENOMEM;
1886 }
1887
1888 test_data.testentropy = &testentropy;
1889 drbg_string_fill(&testentropy, test->entropy, test->entropylen);
1890 drbg_string_fill(&pers, test->pers, test->perslen);
1891 ret = crypto_drbg_reset_test(drng, &pers, &test_data);
1892 if (ret) {
1893 printk(KERN_ERR "alg: drbg: Failed to reset rng\n");
1894 goto outbuf;
1895 }
1896
1897 drbg_string_fill(&addtl, test->addtla, test->addtllen);
1898 if (pr) {
1899 drbg_string_fill(&testentropy, test->entpra, test->entprlen);
1900 ret = crypto_drbg_get_bytes_addtl_test(drng,
1901 buf, test->expectedlen, &addtl, &test_data);
1902 } else {
1903 ret = crypto_drbg_get_bytes_addtl(drng,
1904 buf, test->expectedlen, &addtl);
1905 }
Stephan Mueller19e60e12015-03-10 17:00:36 +01001906 if (ret < 0) {
Jarod Wilson2fc0d252014-07-29 15:47:56 -04001907 printk(KERN_ERR "alg: drbg: could not obtain random data for "
Stephan Mueller64d1cdf2014-05-31 17:25:36 +02001908 "driver %s\n", driver);
1909 goto outbuf;
1910 }
1911
1912 drbg_string_fill(&addtl, test->addtlb, test->addtllen);
1913 if (pr) {
1914 drbg_string_fill(&testentropy, test->entprb, test->entprlen);
1915 ret = crypto_drbg_get_bytes_addtl_test(drng,
1916 buf, test->expectedlen, &addtl, &test_data);
1917 } else {
1918 ret = crypto_drbg_get_bytes_addtl(drng,
1919 buf, test->expectedlen, &addtl);
1920 }
Stephan Mueller19e60e12015-03-10 17:00:36 +01001921 if (ret < 0) {
Jarod Wilson2fc0d252014-07-29 15:47:56 -04001922 printk(KERN_ERR "alg: drbg: could not obtain random data for "
Stephan Mueller64d1cdf2014-05-31 17:25:36 +02001923 "driver %s\n", driver);
1924 goto outbuf;
1925 }
1926
1927 ret = memcmp(test->expected, buf, test->expectedlen);
1928
1929outbuf:
1930 crypto_free_rng(drng);
1931 kzfree(buf);
1932 return ret;
1933}
1934
1935
1936static int alg_test_drbg(const struct alg_test_desc *desc, const char *driver,
1937 u32 type, u32 mask)
1938{
1939 int err = 0;
1940 int pr = 0;
1941 int i = 0;
1942 struct drbg_testvec *template = desc->suite.drbg.vecs;
1943 unsigned int tcount = desc->suite.drbg.count;
1944
1945 if (0 == memcmp(driver, "drbg_pr_", 8))
1946 pr = 1;
1947
1948 for (i = 0; i < tcount; i++) {
1949 err = drbg_cavs_test(&template[i], pr, driver, type, mask);
1950 if (err) {
1951 printk(KERN_ERR "alg: drbg: Test %d failed for %s\n",
1952 i, driver);
1953 err = -EINVAL;
1954 break;
1955 }
1956 }
1957 return err;
1958
1959}
1960
Salvatore Benedetto802c7f12016-06-22 17:49:14 +01001961static int do_test_kpp(struct crypto_kpp *tfm, struct kpp_testvec *vec,
1962 const char *alg)
1963{
1964 struct kpp_request *req;
1965 void *input_buf = NULL;
1966 void *output_buf = NULL;
1967 struct tcrypt_result result;
1968 unsigned int out_len_max;
1969 int err = -ENOMEM;
1970 struct scatterlist src, dst;
1971
1972 req = kpp_request_alloc(tfm, GFP_KERNEL);
1973 if (!req)
1974 return err;
1975
1976 init_completion(&result.completion);
1977
1978 err = crypto_kpp_set_secret(tfm, vec->secret, vec->secret_size);
1979 if (err < 0)
1980 goto free_req;
1981
1982 out_len_max = crypto_kpp_maxsize(tfm);
1983 output_buf = kzalloc(out_len_max, GFP_KERNEL);
1984 if (!output_buf) {
1985 err = -ENOMEM;
1986 goto free_req;
1987 }
1988
1989 /* Use appropriate parameter as base */
1990 kpp_request_set_input(req, NULL, 0);
1991 sg_init_one(&dst, output_buf, out_len_max);
1992 kpp_request_set_output(req, &dst, out_len_max);
1993 kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
1994 tcrypt_complete, &result);
1995
1996 /* Compute public key */
1997 err = wait_async_op(&result, crypto_kpp_generate_public_key(req));
1998 if (err) {
1999 pr_err("alg: %s: generate public key test failed. err %d\n",
2000 alg, err);
2001 goto free_output;
2002 }
2003 /* Verify calculated public key */
2004 if (memcmp(vec->expected_a_public, sg_virt(req->dst),
2005 vec->expected_a_public_size)) {
2006 pr_err("alg: %s: generate public key test failed. Invalid output\n",
2007 alg);
2008 err = -EINVAL;
2009 goto free_output;
2010 }
2011
2012 /* Calculate shared secret key by using counter part (b) public key. */
2013 input_buf = kzalloc(vec->b_public_size, GFP_KERNEL);
2014 if (!input_buf) {
2015 err = -ENOMEM;
2016 goto free_output;
2017 }
2018
2019 memcpy(input_buf, vec->b_public, vec->b_public_size);
2020 sg_init_one(&src, input_buf, vec->b_public_size);
2021 sg_init_one(&dst, output_buf, out_len_max);
2022 kpp_request_set_input(req, &src, vec->b_public_size);
2023 kpp_request_set_output(req, &dst, out_len_max);
2024 kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
2025 tcrypt_complete, &result);
2026 err = wait_async_op(&result, crypto_kpp_compute_shared_secret(req));
2027 if (err) {
2028 pr_err("alg: %s: compute shard secret test failed. err %d\n",
2029 alg, err);
2030 goto free_all;
2031 }
2032 /*
2033 * verify shared secret from which the user will derive
2034 * secret key by executing whatever hash it has chosen
2035 */
2036 if (memcmp(vec->expected_ss, sg_virt(req->dst),
2037 vec->expected_ss_size)) {
2038 pr_err("alg: %s: compute shared secret test failed. Invalid output\n",
2039 alg);
2040 err = -EINVAL;
2041 }
2042
2043free_all:
2044 kfree(input_buf);
2045free_output:
2046 kfree(output_buf);
2047free_req:
2048 kpp_request_free(req);
2049 return err;
2050}
2051
2052static int test_kpp(struct crypto_kpp *tfm, const char *alg,
2053 struct kpp_testvec *vecs, unsigned int tcount)
2054{
2055 int ret, i;
2056
2057 for (i = 0; i < tcount; i++) {
2058 ret = do_test_kpp(tfm, vecs++, alg);
2059 if (ret) {
2060 pr_err("alg: %s: test failed on vector %d, err=%d\n",
2061 alg, i + 1, ret);
2062 return ret;
2063 }
2064 }
2065 return 0;
2066}
2067
2068static int alg_test_kpp(const struct alg_test_desc *desc, const char *driver,
2069 u32 type, u32 mask)
2070{
2071 struct crypto_kpp *tfm;
2072 int err = 0;
2073
Herbert Xueed93e02016-11-22 20:08:31 +08002074 tfm = crypto_alloc_kpp(driver, type, mask);
Salvatore Benedetto802c7f12016-06-22 17:49:14 +01002075 if (IS_ERR(tfm)) {
2076 pr_err("alg: kpp: Failed to load tfm for %s: %ld\n",
2077 driver, PTR_ERR(tfm));
2078 return PTR_ERR(tfm);
2079 }
2080 if (desc->suite.kpp.vecs)
2081 err = test_kpp(tfm, desc->alg, desc->suite.kpp.vecs,
2082 desc->suite.kpp.count);
2083
2084 crypto_free_kpp(tfm);
2085 return err;
2086}
2087
Herbert Xu50d2b6432016-06-29 19:32:20 +08002088static int test_akcipher_one(struct crypto_akcipher *tfm,
2089 struct akcipher_testvec *vecs)
Tadeusz Struk946cc462015-06-16 10:31:06 -07002090{
Herbert Xudf27b262016-05-05 16:42:49 +08002091 char *xbuf[XBUFSIZE];
Tadeusz Struk946cc462015-06-16 10:31:06 -07002092 struct akcipher_request *req;
2093 void *outbuf_enc = NULL;
2094 void *outbuf_dec = NULL;
2095 struct tcrypt_result result;
2096 unsigned int out_len_max, out_len = 0;
2097 int err = -ENOMEM;
Tadeusz Struk22287b02015-10-08 09:26:55 -07002098 struct scatterlist src, dst, src_tab[2];
Tadeusz Struk946cc462015-06-16 10:31:06 -07002099
Herbert Xudf27b262016-05-05 16:42:49 +08002100 if (testmgr_alloc_buf(xbuf))
2101 return err;
2102
Tadeusz Struk946cc462015-06-16 10:31:06 -07002103 req = akcipher_request_alloc(tfm, GFP_KERNEL);
2104 if (!req)
Herbert Xudf27b262016-05-05 16:42:49 +08002105 goto free_xbuf;
Tadeusz Struk946cc462015-06-16 10:31:06 -07002106
2107 init_completion(&result.completion);
Tadeusz Struk22287b02015-10-08 09:26:55 -07002108
2109 if (vecs->public_key_vec)
2110 err = crypto_akcipher_set_pub_key(tfm, vecs->key,
2111 vecs->key_len);
2112 else
2113 err = crypto_akcipher_set_priv_key(tfm, vecs->key,
2114 vecs->key_len);
Tadeusz Struk946cc462015-06-16 10:31:06 -07002115 if (err)
2116 goto free_req;
2117
Salvatore Benedetto57763f52016-07-04 10:52:34 +01002118 err = -ENOMEM;
Tadeusz Struk22287b02015-10-08 09:26:55 -07002119 out_len_max = crypto_akcipher_maxsize(tfm);
Tadeusz Struk946cc462015-06-16 10:31:06 -07002120 outbuf_enc = kzalloc(out_len_max, GFP_KERNEL);
2121 if (!outbuf_enc)
2122 goto free_req;
2123
Herbert Xudf27b262016-05-05 16:42:49 +08002124 if (WARN_ON(vecs->m_size > PAGE_SIZE))
2125 goto free_all;
2126
2127 memcpy(xbuf[0], vecs->m, vecs->m_size);
2128
Tadeusz Struk22287b02015-10-08 09:26:55 -07002129 sg_init_table(src_tab, 2);
Herbert Xudf27b262016-05-05 16:42:49 +08002130 sg_set_buf(&src_tab[0], xbuf[0], 8);
2131 sg_set_buf(&src_tab[1], xbuf[0] + 8, vecs->m_size - 8);
Tadeusz Struk22287b02015-10-08 09:26:55 -07002132 sg_init_one(&dst, outbuf_enc, out_len_max);
2133 akcipher_request_set_crypt(req, src_tab, &dst, vecs->m_size,
2134 out_len_max);
Tadeusz Struk946cc462015-06-16 10:31:06 -07002135 akcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
2136 tcrypt_complete, &result);
2137
2138 /* Run RSA encrypt - c = m^e mod n;*/
2139 err = wait_async_op(&result, crypto_akcipher_encrypt(req));
2140 if (err) {
Herbert Xu50d2b6432016-06-29 19:32:20 +08002141 pr_err("alg: akcipher: encrypt test failed. err %d\n", err);
Tadeusz Struk946cc462015-06-16 10:31:06 -07002142 goto free_all;
2143 }
Tadeusz Struk22287b02015-10-08 09:26:55 -07002144 if (req->dst_len != vecs->c_size) {
Herbert Xu50d2b6432016-06-29 19:32:20 +08002145 pr_err("alg: akcipher: encrypt test failed. Invalid output len\n");
Tadeusz Struk946cc462015-06-16 10:31:06 -07002146 err = -EINVAL;
2147 goto free_all;
2148 }
2149 /* verify that encrypted message is equal to expected */
Herbert Xudf27b262016-05-05 16:42:49 +08002150 if (memcmp(vecs->c, outbuf_enc, vecs->c_size)) {
Herbert Xu50d2b6432016-06-29 19:32:20 +08002151 pr_err("alg: akcipher: encrypt test failed. Invalid output\n");
2152 hexdump(outbuf_enc, vecs->c_size);
Tadeusz Struk946cc462015-06-16 10:31:06 -07002153 err = -EINVAL;
2154 goto free_all;
2155 }
2156 /* Don't invoke decrypt for vectors with public key */
2157 if (vecs->public_key_vec) {
2158 err = 0;
2159 goto free_all;
2160 }
2161 outbuf_dec = kzalloc(out_len_max, GFP_KERNEL);
2162 if (!outbuf_dec) {
2163 err = -ENOMEM;
2164 goto free_all;
2165 }
Herbert Xudf27b262016-05-05 16:42:49 +08002166
2167 if (WARN_ON(vecs->c_size > PAGE_SIZE))
2168 goto free_all;
2169
2170 memcpy(xbuf[0], vecs->c, vecs->c_size);
2171
2172 sg_init_one(&src, xbuf[0], vecs->c_size);
Tadeusz Struk22287b02015-10-08 09:26:55 -07002173 sg_init_one(&dst, outbuf_dec, out_len_max);
Tadeusz Struk946cc462015-06-16 10:31:06 -07002174 init_completion(&result.completion);
Tadeusz Struk22287b02015-10-08 09:26:55 -07002175 akcipher_request_set_crypt(req, &src, &dst, vecs->c_size, out_len_max);
Tadeusz Struk946cc462015-06-16 10:31:06 -07002176
2177 /* Run RSA decrypt - m = c^d mod n;*/
2178 err = wait_async_op(&result, crypto_akcipher_decrypt(req));
2179 if (err) {
Herbert Xu50d2b6432016-06-29 19:32:20 +08002180 pr_err("alg: akcipher: decrypt test failed. err %d\n", err);
Tadeusz Struk946cc462015-06-16 10:31:06 -07002181 goto free_all;
2182 }
2183 out_len = req->dst_len;
Herbert Xu50d2b6432016-06-29 19:32:20 +08002184 if (out_len < vecs->m_size) {
2185 pr_err("alg: akcipher: decrypt test failed. "
2186 "Invalid output len %u\n", out_len);
Tadeusz Struk946cc462015-06-16 10:31:06 -07002187 err = -EINVAL;
2188 goto free_all;
2189 }
2190 /* verify that decrypted message is equal to the original msg */
Herbert Xu50d2b6432016-06-29 19:32:20 +08002191 if (memchr_inv(outbuf_dec, 0, out_len - vecs->m_size) ||
2192 memcmp(vecs->m, outbuf_dec + out_len - vecs->m_size,
2193 vecs->m_size)) {
2194 pr_err("alg: akcipher: decrypt test failed. Invalid output\n");
2195 hexdump(outbuf_dec, out_len);
Tadeusz Struk946cc462015-06-16 10:31:06 -07002196 err = -EINVAL;
2197 }
2198free_all:
2199 kfree(outbuf_dec);
2200 kfree(outbuf_enc);
2201free_req:
2202 akcipher_request_free(req);
Herbert Xudf27b262016-05-05 16:42:49 +08002203free_xbuf:
2204 testmgr_free_buf(xbuf);
Tadeusz Struk946cc462015-06-16 10:31:06 -07002205 return err;
2206}
2207
Herbert Xu50d2b6432016-06-29 19:32:20 +08002208static int test_akcipher(struct crypto_akcipher *tfm, const char *alg,
2209 struct akcipher_testvec *vecs, unsigned int tcount)
Tadeusz Struk946cc462015-06-16 10:31:06 -07002210{
Herbert Xu15226e42016-07-18 18:20:10 +08002211 const char *algo =
2212 crypto_tfm_alg_driver_name(crypto_akcipher_tfm(tfm));
Tadeusz Struk946cc462015-06-16 10:31:06 -07002213 int ret, i;
2214
2215 for (i = 0; i < tcount; i++) {
Herbert Xu50d2b6432016-06-29 19:32:20 +08002216 ret = test_akcipher_one(tfm, vecs++);
2217 if (!ret)
2218 continue;
2219
Herbert Xu15226e42016-07-18 18:20:10 +08002220 pr_err("alg: akcipher: test %d failed for %s, err=%d\n",
2221 i + 1, algo, ret);
Herbert Xu50d2b6432016-06-29 19:32:20 +08002222 return ret;
Tadeusz Struk946cc462015-06-16 10:31:06 -07002223 }
2224 return 0;
2225}
2226
Tadeusz Struk946cc462015-06-16 10:31:06 -07002227static int alg_test_akcipher(const struct alg_test_desc *desc,
2228 const char *driver, u32 type, u32 mask)
2229{
2230 struct crypto_akcipher *tfm;
2231 int err = 0;
2232
Herbert Xueed93e02016-11-22 20:08:31 +08002233 tfm = crypto_alloc_akcipher(driver, type, mask);
Tadeusz Struk946cc462015-06-16 10:31:06 -07002234 if (IS_ERR(tfm)) {
2235 pr_err("alg: akcipher: Failed to load tfm for %s: %ld\n",
2236 driver, PTR_ERR(tfm));
2237 return PTR_ERR(tfm);
2238 }
2239 if (desc->suite.akcipher.vecs)
2240 err = test_akcipher(tfm, desc->alg, desc->suite.akcipher.vecs,
2241 desc->suite.akcipher.count);
2242
2243 crypto_free_akcipher(tfm);
2244 return err;
2245}
2246
Youquan, Song863b5572009-12-23 19:45:20 +08002247static int alg_test_null(const struct alg_test_desc *desc,
2248 const char *driver, u32 type, u32 mask)
2249{
2250 return 0;
2251}
2252
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002253#define __VECS(tv) { .vecs = tv, .count = ARRAY_SIZE(tv) }
2254
Herbert Xuda7f0332008-07-31 17:08:25 +08002255/* Please keep this list sorted by algorithm name. */
2256static const struct alg_test_desc alg_test_descs[] = {
2257 {
Jarod Wilsone08ca2d2009-05-04 19:46:29 +08002258 .alg = "ansi_cprng",
2259 .test = alg_test_cprng,
2260 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002261 .cprng = __VECS(ansi_cprng_aes_tv_template)
Jarod Wilsone08ca2d2009-05-04 19:46:29 +08002262 }
2263 }, {
Horia Geantabca4feb2014-03-14 17:46:51 +02002264 .alg = "authenc(hmac(md5),ecb(cipher_null))",
2265 .test = alg_test_aead,
Horia Geantabca4feb2014-03-14 17:46:51 +02002266 .suite = {
2267 .aead = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002268 .enc = __VECS(hmac_md5_ecb_cipher_null_enc_tv_template),
2269 .dec = __VECS(hmac_md5_ecb_cipher_null_dec_tv_template)
Horia Geantabca4feb2014-03-14 17:46:51 +02002270 }
2271 }
2272 }, {
Herbert Xua4198fd2015-07-30 17:53:23 +08002273 .alg = "authenc(hmac(sha1),cbc(aes))",
Horia Geantae46e9a42012-07-03 19:16:54 +03002274 .test = alg_test_aead,
Horia Geantae46e9a42012-07-03 19:16:54 +03002275 .suite = {
2276 .aead = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002277 .enc = __VECS(hmac_sha1_aes_cbc_enc_tv_temp)
Nitesh Lal5208ed22014-05-21 17:09:08 +05302278 }
2279 }
2280 }, {
Herbert Xua4198fd2015-07-30 17:53:23 +08002281 .alg = "authenc(hmac(sha1),cbc(des))",
Nitesh Lal5208ed22014-05-21 17:09:08 +05302282 .test = alg_test_aead,
Nitesh Lal5208ed22014-05-21 17:09:08 +05302283 .suite = {
2284 .aead = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002285 .enc = __VECS(hmac_sha1_des_cbc_enc_tv_temp)
Nitesh Lal5208ed22014-05-21 17:09:08 +05302286 }
2287 }
2288 }, {
Herbert Xua4198fd2015-07-30 17:53:23 +08002289 .alg = "authenc(hmac(sha1),cbc(des3_ede))",
Nitesh Lal5208ed22014-05-21 17:09:08 +05302290 .test = alg_test_aead,
Marcus Meissnered1afac2016-02-05 14:23:33 +01002291 .fips_allowed = 1,
Nitesh Lal5208ed22014-05-21 17:09:08 +05302292 .suite = {
2293 .aead = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002294 .enc = __VECS(hmac_sha1_des3_ede_cbc_enc_tv_temp)
Horia Geantae46e9a42012-07-03 19:16:54 +03002295 }
2296 }
2297 }, {
Marcus Meissnerfb16abc2016-02-06 11:53:07 +01002298 .alg = "authenc(hmac(sha1),ctr(aes))",
2299 .test = alg_test_null,
2300 .fips_allowed = 1,
2301 }, {
Horia Geantabca4feb2014-03-14 17:46:51 +02002302 .alg = "authenc(hmac(sha1),ecb(cipher_null))",
2303 .test = alg_test_aead,
Horia Geantabca4feb2014-03-14 17:46:51 +02002304 .suite = {
2305 .aead = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002306 .enc = __VECS(hmac_sha1_ecb_cipher_null_enc_tv_temp),
2307 .dec = __VECS(hmac_sha1_ecb_cipher_null_dec_tv_temp)
Nitesh Lal5208ed22014-05-21 17:09:08 +05302308 }
2309 }
2310 }, {
Marcus Meissner88886902016-02-19 13:34:28 +01002311 .alg = "authenc(hmac(sha1),rfc3686(ctr(aes)))",
2312 .test = alg_test_null,
2313 .fips_allowed = 1,
2314 }, {
Herbert Xua4198fd2015-07-30 17:53:23 +08002315 .alg = "authenc(hmac(sha224),cbc(des))",
Nitesh Lal5208ed22014-05-21 17:09:08 +05302316 .test = alg_test_aead,
Nitesh Lal5208ed22014-05-21 17:09:08 +05302317 .suite = {
2318 .aead = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002319 .enc = __VECS(hmac_sha224_des_cbc_enc_tv_temp)
Nitesh Lal5208ed22014-05-21 17:09:08 +05302320 }
2321 }
2322 }, {
Herbert Xua4198fd2015-07-30 17:53:23 +08002323 .alg = "authenc(hmac(sha224),cbc(des3_ede))",
Nitesh Lal5208ed22014-05-21 17:09:08 +05302324 .test = alg_test_aead,
Marcus Meissnered1afac2016-02-05 14:23:33 +01002325 .fips_allowed = 1,
Nitesh Lal5208ed22014-05-21 17:09:08 +05302326 .suite = {
2327 .aead = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002328 .enc = __VECS(hmac_sha224_des3_ede_cbc_enc_tv_temp)
Horia Geantabca4feb2014-03-14 17:46:51 +02002329 }
2330 }
2331 }, {
Herbert Xua4198fd2015-07-30 17:53:23 +08002332 .alg = "authenc(hmac(sha256),cbc(aes))",
Horia Geantae46e9a42012-07-03 19:16:54 +03002333 .test = alg_test_aead,
Marcus Meissnered1afac2016-02-05 14:23:33 +01002334 .fips_allowed = 1,
Horia Geantae46e9a42012-07-03 19:16:54 +03002335 .suite = {
2336 .aead = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002337 .enc = __VECS(hmac_sha256_aes_cbc_enc_tv_temp)
Nitesh Lal5208ed22014-05-21 17:09:08 +05302338 }
2339 }
2340 }, {
Herbert Xua4198fd2015-07-30 17:53:23 +08002341 .alg = "authenc(hmac(sha256),cbc(des))",
Nitesh Lal5208ed22014-05-21 17:09:08 +05302342 .test = alg_test_aead,
Nitesh Lal5208ed22014-05-21 17:09:08 +05302343 .suite = {
2344 .aead = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002345 .enc = __VECS(hmac_sha256_des_cbc_enc_tv_temp)
Nitesh Lal5208ed22014-05-21 17:09:08 +05302346 }
2347 }
2348 }, {
Herbert Xua4198fd2015-07-30 17:53:23 +08002349 .alg = "authenc(hmac(sha256),cbc(des3_ede))",
Nitesh Lal5208ed22014-05-21 17:09:08 +05302350 .test = alg_test_aead,
Marcus Meissnered1afac2016-02-05 14:23:33 +01002351 .fips_allowed = 1,
Nitesh Lal5208ed22014-05-21 17:09:08 +05302352 .suite = {
2353 .aead = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002354 .enc = __VECS(hmac_sha256_des3_ede_cbc_enc_tv_temp)
Nitesh Lal5208ed22014-05-21 17:09:08 +05302355 }
2356 }
2357 }, {
Marcus Meissnerfb16abc2016-02-06 11:53:07 +01002358 .alg = "authenc(hmac(sha256),ctr(aes))",
2359 .test = alg_test_null,
2360 .fips_allowed = 1,
2361 }, {
Marcus Meissner88886902016-02-19 13:34:28 +01002362 .alg = "authenc(hmac(sha256),rfc3686(ctr(aes)))",
2363 .test = alg_test_null,
2364 .fips_allowed = 1,
2365 }, {
Herbert Xua4198fd2015-07-30 17:53:23 +08002366 .alg = "authenc(hmac(sha384),cbc(des))",
Nitesh Lal5208ed22014-05-21 17:09:08 +05302367 .test = alg_test_aead,
Nitesh Lal5208ed22014-05-21 17:09:08 +05302368 .suite = {
2369 .aead = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002370 .enc = __VECS(hmac_sha384_des_cbc_enc_tv_temp)
Nitesh Lal5208ed22014-05-21 17:09:08 +05302371 }
2372 }
2373 }, {
Herbert Xua4198fd2015-07-30 17:53:23 +08002374 .alg = "authenc(hmac(sha384),cbc(des3_ede))",
Nitesh Lal5208ed22014-05-21 17:09:08 +05302375 .test = alg_test_aead,
Marcus Meissnered1afac2016-02-05 14:23:33 +01002376 .fips_allowed = 1,
Nitesh Lal5208ed22014-05-21 17:09:08 +05302377 .suite = {
2378 .aead = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002379 .enc = __VECS(hmac_sha384_des3_ede_cbc_enc_tv_temp)
Horia Geantae46e9a42012-07-03 19:16:54 +03002380 }
2381 }
2382 }, {
Marcus Meissnerfb16abc2016-02-06 11:53:07 +01002383 .alg = "authenc(hmac(sha384),ctr(aes))",
2384 .test = alg_test_null,
2385 .fips_allowed = 1,
2386 }, {
Marcus Meissner88886902016-02-19 13:34:28 +01002387 .alg = "authenc(hmac(sha384),rfc3686(ctr(aes)))",
2388 .test = alg_test_null,
2389 .fips_allowed = 1,
2390 }, {
Herbert Xua4198fd2015-07-30 17:53:23 +08002391 .alg = "authenc(hmac(sha512),cbc(aes))",
Marcus Meissnered1afac2016-02-05 14:23:33 +01002392 .fips_allowed = 1,
Horia Geantae46e9a42012-07-03 19:16:54 +03002393 .test = alg_test_aead,
Horia Geantae46e9a42012-07-03 19:16:54 +03002394 .suite = {
2395 .aead = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002396 .enc = __VECS(hmac_sha512_aes_cbc_enc_tv_temp)
Nitesh Lal5208ed22014-05-21 17:09:08 +05302397 }
2398 }
2399 }, {
Herbert Xua4198fd2015-07-30 17:53:23 +08002400 .alg = "authenc(hmac(sha512),cbc(des))",
Nitesh Lal5208ed22014-05-21 17:09:08 +05302401 .test = alg_test_aead,
Nitesh Lal5208ed22014-05-21 17:09:08 +05302402 .suite = {
2403 .aead = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002404 .enc = __VECS(hmac_sha512_des_cbc_enc_tv_temp)
Nitesh Lal5208ed22014-05-21 17:09:08 +05302405 }
2406 }
2407 }, {
Herbert Xua4198fd2015-07-30 17:53:23 +08002408 .alg = "authenc(hmac(sha512),cbc(des3_ede))",
Nitesh Lal5208ed22014-05-21 17:09:08 +05302409 .test = alg_test_aead,
Marcus Meissnered1afac2016-02-05 14:23:33 +01002410 .fips_allowed = 1,
Nitesh Lal5208ed22014-05-21 17:09:08 +05302411 .suite = {
2412 .aead = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002413 .enc = __VECS(hmac_sha512_des3_ede_cbc_enc_tv_temp)
Horia Geantae46e9a42012-07-03 19:16:54 +03002414 }
2415 }
2416 }, {
Marcus Meissnerfb16abc2016-02-06 11:53:07 +01002417 .alg = "authenc(hmac(sha512),ctr(aes))",
2418 .test = alg_test_null,
2419 .fips_allowed = 1,
2420 }, {
Marcus Meissner88886902016-02-19 13:34:28 +01002421 .alg = "authenc(hmac(sha512),rfc3686(ctr(aes)))",
2422 .test = alg_test_null,
2423 .fips_allowed = 1,
2424 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08002425 .alg = "cbc(aes)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002426 .test = alg_test_skcipher,
Jarod Wilsona1915d52009-05-15 15:16:03 +10002427 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08002428 .suite = {
2429 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002430 .enc = __VECS(aes_cbc_enc_tv_template),
2431 .dec = __VECS(aes_cbc_dec_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08002432 }
2433 }
2434 }, {
2435 .alg = "cbc(anubis)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002436 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002437 .suite = {
2438 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002439 .enc = __VECS(anubis_cbc_enc_tv_template),
2440 .dec = __VECS(anubis_cbc_dec_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08002441 }
2442 }
2443 }, {
2444 .alg = "cbc(blowfish)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002445 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002446 .suite = {
2447 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002448 .enc = __VECS(bf_cbc_enc_tv_template),
2449 .dec = __VECS(bf_cbc_dec_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08002450 }
2451 }
2452 }, {
2453 .alg = "cbc(camellia)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002454 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002455 .suite = {
2456 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002457 .enc = __VECS(camellia_cbc_enc_tv_template),
2458 .dec = __VECS(camellia_cbc_dec_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08002459 }
2460 }
2461 }, {
Johannes Goetzfrieda2c58262012-07-11 19:37:21 +02002462 .alg = "cbc(cast5)",
2463 .test = alg_test_skcipher,
2464 .suite = {
2465 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002466 .enc = __VECS(cast5_cbc_enc_tv_template),
2467 .dec = __VECS(cast5_cbc_dec_tv_template)
Johannes Goetzfrieda2c58262012-07-11 19:37:21 +02002468 }
2469 }
2470 }, {
Johannes Goetzfried9b8b0402012-07-11 19:38:29 +02002471 .alg = "cbc(cast6)",
2472 .test = alg_test_skcipher,
2473 .suite = {
2474 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002475 .enc = __VECS(cast6_cbc_enc_tv_template),
2476 .dec = __VECS(cast6_cbc_dec_tv_template)
Johannes Goetzfried9b8b0402012-07-11 19:38:29 +02002477 }
2478 }
2479 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08002480 .alg = "cbc(des)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002481 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002482 .suite = {
2483 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002484 .enc = __VECS(des_cbc_enc_tv_template),
2485 .dec = __VECS(des_cbc_dec_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08002486 }
2487 }
2488 }, {
2489 .alg = "cbc(des3_ede)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002490 .test = alg_test_skcipher,
Jarod Wilsona1915d52009-05-15 15:16:03 +10002491 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08002492 .suite = {
2493 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002494 .enc = __VECS(des3_ede_cbc_enc_tv_template),
2495 .dec = __VECS(des3_ede_cbc_dec_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08002496 }
2497 }
2498 }, {
Jussi Kivilinna9d259172011-10-18 00:02:53 +03002499 .alg = "cbc(serpent)",
2500 .test = alg_test_skcipher,
2501 .suite = {
2502 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002503 .enc = __VECS(serpent_cbc_enc_tv_template),
2504 .dec = __VECS(serpent_cbc_dec_tv_template)
Jussi Kivilinna9d259172011-10-18 00:02:53 +03002505 }
2506 }
2507 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08002508 .alg = "cbc(twofish)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002509 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002510 .suite = {
2511 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002512 .enc = __VECS(tf_cbc_enc_tv_template),
2513 .dec = __VECS(tf_cbc_dec_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08002514 }
2515 }
2516 }, {
Ard Biesheuvel092acf02017-02-03 14:49:35 +00002517 .alg = "cbcmac(aes)",
2518 .fips_allowed = 1,
2519 .test = alg_test_hash,
2520 .suite = {
2521 .hash = __VECS(aes_cbcmac_tv_template)
2522 }
2523 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08002524 .alg = "ccm(aes)",
2525 .test = alg_test_aead,
Jarod Wilsona1915d52009-05-15 15:16:03 +10002526 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08002527 .suite = {
2528 .aead = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002529 .enc = __VECS(aes_ccm_enc_tv_template),
2530 .dec = __VECS(aes_ccm_dec_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08002531 }
2532 }
2533 }, {
Martin Willi3590ebf2015-06-01 13:43:57 +02002534 .alg = "chacha20",
2535 .test = alg_test_skcipher,
2536 .suite = {
2537 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002538 .enc = __VECS(chacha20_enc_tv_template),
2539 .dec = __VECS(chacha20_enc_tv_template),
Martin Willi3590ebf2015-06-01 13:43:57 +02002540 }
2541 }
2542 }, {
Jussi Kivilinna93b5e862013-04-08 10:48:44 +03002543 .alg = "cmac(aes)",
Stephan Mueller8f183752015-08-19 08:42:07 +02002544 .fips_allowed = 1,
Jussi Kivilinna93b5e862013-04-08 10:48:44 +03002545 .test = alg_test_hash,
2546 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002547 .hash = __VECS(aes_cmac128_tv_template)
Jussi Kivilinna93b5e862013-04-08 10:48:44 +03002548 }
2549 }, {
2550 .alg = "cmac(des3_ede)",
Stephan Mueller8f183752015-08-19 08:42:07 +02002551 .fips_allowed = 1,
Jussi Kivilinna93b5e862013-04-08 10:48:44 +03002552 .test = alg_test_hash,
2553 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002554 .hash = __VECS(des3_ede_cmac64_tv_template)
Jussi Kivilinna93b5e862013-04-08 10:48:44 +03002555 }
2556 }, {
Jussi Kivilinnae4483702013-04-07 16:43:56 +03002557 .alg = "compress_null",
2558 .test = alg_test_null,
2559 }, {
Ard Biesheuvelebb34722015-05-04 11:00:17 +02002560 .alg = "crc32",
2561 .test = alg_test_hash,
2562 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002563 .hash = __VECS(crc32_tv_template)
Ard Biesheuvelebb34722015-05-04 11:00:17 +02002564 }
2565 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08002566 .alg = "crc32c",
Herbert Xu8e3ee852008-11-07 14:58:52 +08002567 .test = alg_test_crc32c,
Jarod Wilsona1915d52009-05-15 15:16:03 +10002568 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08002569 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002570 .hash = __VECS(crc32c_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08002571 }
2572 }, {
Herbert Xu684115212013-09-07 12:56:26 +10002573 .alg = "crct10dif",
2574 .test = alg_test_hash,
2575 .fips_allowed = 1,
2576 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002577 .hash = __VECS(crct10dif_tv_template)
Herbert Xu684115212013-09-07 12:56:26 +10002578 }
2579 }, {
Jarod Wilsonf7cb80f2009-05-06 17:29:17 +08002580 .alg = "ctr(aes)",
2581 .test = alg_test_skcipher,
Jarod Wilsona1915d52009-05-15 15:16:03 +10002582 .fips_allowed = 1,
Jarod Wilsonf7cb80f2009-05-06 17:29:17 +08002583 .suite = {
2584 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002585 .enc = __VECS(aes_ctr_enc_tv_template),
2586 .dec = __VECS(aes_ctr_dec_tv_template)
Jarod Wilsonf7cb80f2009-05-06 17:29:17 +08002587 }
2588 }
2589 }, {
Jussi Kivilinna85b63e32011-10-10 23:03:03 +03002590 .alg = "ctr(blowfish)",
2591 .test = alg_test_skcipher,
2592 .suite = {
2593 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002594 .enc = __VECS(bf_ctr_enc_tv_template),
2595 .dec = __VECS(bf_ctr_dec_tv_template)
Jussi Kivilinna85b63e32011-10-10 23:03:03 +03002596 }
2597 }
2598 }, {
Jussi Kivilinna08406052012-03-05 20:26:21 +02002599 .alg = "ctr(camellia)",
2600 .test = alg_test_skcipher,
2601 .suite = {
2602 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002603 .enc = __VECS(camellia_ctr_enc_tv_template),
2604 .dec = __VECS(camellia_ctr_dec_tv_template)
Jussi Kivilinna08406052012-03-05 20:26:21 +02002605 }
2606 }
2607 }, {
Johannes Goetzfrieda2c58262012-07-11 19:37:21 +02002608 .alg = "ctr(cast5)",
2609 .test = alg_test_skcipher,
2610 .suite = {
2611 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002612 .enc = __VECS(cast5_ctr_enc_tv_template),
2613 .dec = __VECS(cast5_ctr_dec_tv_template)
Johannes Goetzfrieda2c58262012-07-11 19:37:21 +02002614 }
2615 }
2616 }, {
Johannes Goetzfried9b8b0402012-07-11 19:38:29 +02002617 .alg = "ctr(cast6)",
2618 .test = alg_test_skcipher,
2619 .suite = {
2620 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002621 .enc = __VECS(cast6_ctr_enc_tv_template),
2622 .dec = __VECS(cast6_ctr_dec_tv_template)
Johannes Goetzfried9b8b0402012-07-11 19:38:29 +02002623 }
2624 }
2625 }, {
Jussi Kivilinna8163fc32012-10-20 14:53:07 +03002626 .alg = "ctr(des)",
2627 .test = alg_test_skcipher,
2628 .suite = {
2629 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002630 .enc = __VECS(des_ctr_enc_tv_template),
2631 .dec = __VECS(des_ctr_dec_tv_template)
Jussi Kivilinna8163fc32012-10-20 14:53:07 +03002632 }
2633 }
2634 }, {
Jussi Kivilinnae080b172012-10-20 14:53:12 +03002635 .alg = "ctr(des3_ede)",
2636 .test = alg_test_skcipher,
2637 .suite = {
2638 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002639 .enc = __VECS(des3_ede_ctr_enc_tv_template),
2640 .dec = __VECS(des3_ede_ctr_dec_tv_template)
Jussi Kivilinnae080b172012-10-20 14:53:12 +03002641 }
2642 }
2643 }, {
Jussi Kivilinna9d259172011-10-18 00:02:53 +03002644 .alg = "ctr(serpent)",
2645 .test = alg_test_skcipher,
2646 .suite = {
2647 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002648 .enc = __VECS(serpent_ctr_enc_tv_template),
2649 .dec = __VECS(serpent_ctr_dec_tv_template)
Jussi Kivilinna9d259172011-10-18 00:02:53 +03002650 }
2651 }
2652 }, {
Jussi Kivilinna573da622011-10-10 23:03:12 +03002653 .alg = "ctr(twofish)",
2654 .test = alg_test_skcipher,
2655 .suite = {
2656 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002657 .enc = __VECS(tf_ctr_enc_tv_template),
2658 .dec = __VECS(tf_ctr_dec_tv_template)
Jussi Kivilinna573da622011-10-10 23:03:12 +03002659 }
2660 }
2661 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08002662 .alg = "cts(cbc(aes))",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002663 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002664 .suite = {
2665 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002666 .enc = __VECS(cts_mode_enc_tv_template),
2667 .dec = __VECS(cts_mode_dec_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08002668 }
2669 }
2670 }, {
2671 .alg = "deflate",
2672 .test = alg_test_comp,
Milan Broz08189042012-12-06 17:16:28 +08002673 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08002674 .suite = {
2675 .comp = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002676 .comp = __VECS(deflate_comp_tv_template),
2677 .decomp = __VECS(deflate_decomp_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08002678 }
2679 }
2680 }, {
Salvatore Benedetto802c7f12016-06-22 17:49:14 +01002681 .alg = "dh",
2682 .test = alg_test_kpp,
2683 .fips_allowed = 1,
2684 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002685 .kpp = __VECS(dh_tv_template)
Salvatore Benedetto802c7f12016-06-22 17:49:14 +01002686 }
2687 }, {
Jussi Kivilinnae4483702013-04-07 16:43:56 +03002688 .alg = "digest_null",
2689 .test = alg_test_null,
2690 }, {
Stephan Mueller64d1cdf2014-05-31 17:25:36 +02002691 .alg = "drbg_nopr_ctr_aes128",
2692 .test = alg_test_drbg,
2693 .fips_allowed = 1,
2694 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002695 .drbg = __VECS(drbg_nopr_ctr_aes128_tv_template)
Stephan Mueller64d1cdf2014-05-31 17:25:36 +02002696 }
2697 }, {
2698 .alg = "drbg_nopr_ctr_aes192",
2699 .test = alg_test_drbg,
2700 .fips_allowed = 1,
2701 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002702 .drbg = __VECS(drbg_nopr_ctr_aes192_tv_template)
Stephan Mueller64d1cdf2014-05-31 17:25:36 +02002703 }
2704 }, {
2705 .alg = "drbg_nopr_ctr_aes256",
2706 .test = alg_test_drbg,
2707 .fips_allowed = 1,
2708 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002709 .drbg = __VECS(drbg_nopr_ctr_aes256_tv_template)
Stephan Mueller64d1cdf2014-05-31 17:25:36 +02002710 }
2711 }, {
2712 /*
2713 * There is no need to specifically test the DRBG with every
2714 * backend cipher -- covered by drbg_nopr_hmac_sha256 test
2715 */
2716 .alg = "drbg_nopr_hmac_sha1",
2717 .fips_allowed = 1,
2718 .test = alg_test_null,
2719 }, {
2720 .alg = "drbg_nopr_hmac_sha256",
2721 .test = alg_test_drbg,
2722 .fips_allowed = 1,
2723 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002724 .drbg = __VECS(drbg_nopr_hmac_sha256_tv_template)
Stephan Mueller64d1cdf2014-05-31 17:25:36 +02002725 }
2726 }, {
2727 /* covered by drbg_nopr_hmac_sha256 test */
2728 .alg = "drbg_nopr_hmac_sha384",
2729 .fips_allowed = 1,
2730 .test = alg_test_null,
2731 }, {
2732 .alg = "drbg_nopr_hmac_sha512",
2733 .test = alg_test_null,
2734 .fips_allowed = 1,
2735 }, {
2736 .alg = "drbg_nopr_sha1",
2737 .fips_allowed = 1,
2738 .test = alg_test_null,
2739 }, {
2740 .alg = "drbg_nopr_sha256",
2741 .test = alg_test_drbg,
2742 .fips_allowed = 1,
2743 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002744 .drbg = __VECS(drbg_nopr_sha256_tv_template)
Stephan Mueller64d1cdf2014-05-31 17:25:36 +02002745 }
2746 }, {
2747 /* covered by drbg_nopr_sha256 test */
2748 .alg = "drbg_nopr_sha384",
2749 .fips_allowed = 1,
2750 .test = alg_test_null,
2751 }, {
2752 .alg = "drbg_nopr_sha512",
2753 .fips_allowed = 1,
2754 .test = alg_test_null,
2755 }, {
2756 .alg = "drbg_pr_ctr_aes128",
2757 .test = alg_test_drbg,
2758 .fips_allowed = 1,
2759 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002760 .drbg = __VECS(drbg_pr_ctr_aes128_tv_template)
Stephan Mueller64d1cdf2014-05-31 17:25:36 +02002761 }
2762 }, {
2763 /* covered by drbg_pr_ctr_aes128 test */
2764 .alg = "drbg_pr_ctr_aes192",
2765 .fips_allowed = 1,
2766 .test = alg_test_null,
2767 }, {
2768 .alg = "drbg_pr_ctr_aes256",
2769 .fips_allowed = 1,
2770 .test = alg_test_null,
2771 }, {
2772 .alg = "drbg_pr_hmac_sha1",
2773 .fips_allowed = 1,
2774 .test = alg_test_null,
2775 }, {
2776 .alg = "drbg_pr_hmac_sha256",
2777 .test = alg_test_drbg,
2778 .fips_allowed = 1,
2779 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002780 .drbg = __VECS(drbg_pr_hmac_sha256_tv_template)
Stephan Mueller64d1cdf2014-05-31 17:25:36 +02002781 }
2782 }, {
2783 /* covered by drbg_pr_hmac_sha256 test */
2784 .alg = "drbg_pr_hmac_sha384",
2785 .fips_allowed = 1,
2786 .test = alg_test_null,
2787 }, {
2788 .alg = "drbg_pr_hmac_sha512",
2789 .test = alg_test_null,
2790 .fips_allowed = 1,
2791 }, {
2792 .alg = "drbg_pr_sha1",
2793 .fips_allowed = 1,
2794 .test = alg_test_null,
2795 }, {
2796 .alg = "drbg_pr_sha256",
2797 .test = alg_test_drbg,
2798 .fips_allowed = 1,
2799 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002800 .drbg = __VECS(drbg_pr_sha256_tv_template)
Stephan Mueller64d1cdf2014-05-31 17:25:36 +02002801 }
2802 }, {
2803 /* covered by drbg_pr_sha256 test */
2804 .alg = "drbg_pr_sha384",
2805 .fips_allowed = 1,
2806 .test = alg_test_null,
2807 }, {
2808 .alg = "drbg_pr_sha512",
2809 .fips_allowed = 1,
2810 .test = alg_test_null,
2811 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08002812 .alg = "ecb(aes)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002813 .test = alg_test_skcipher,
Jarod Wilsona1915d52009-05-15 15:16:03 +10002814 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08002815 .suite = {
2816 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002817 .enc = __VECS(aes_enc_tv_template),
2818 .dec = __VECS(aes_dec_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08002819 }
2820 }
2821 }, {
2822 .alg = "ecb(anubis)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002823 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002824 .suite = {
2825 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002826 .enc = __VECS(anubis_enc_tv_template),
2827 .dec = __VECS(anubis_dec_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08002828 }
2829 }
2830 }, {
2831 .alg = "ecb(arc4)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002832 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002833 .suite = {
2834 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002835 .enc = __VECS(arc4_enc_tv_template),
2836 .dec = __VECS(arc4_dec_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08002837 }
2838 }
2839 }, {
2840 .alg = "ecb(blowfish)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002841 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002842 .suite = {
2843 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002844 .enc = __VECS(bf_enc_tv_template),
2845 .dec = __VECS(bf_dec_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08002846 }
2847 }
2848 }, {
2849 .alg = "ecb(camellia)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002850 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002851 .suite = {
2852 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002853 .enc = __VECS(camellia_enc_tv_template),
2854 .dec = __VECS(camellia_dec_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08002855 }
2856 }
2857 }, {
2858 .alg = "ecb(cast5)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002859 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002860 .suite = {
2861 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002862 .enc = __VECS(cast5_enc_tv_template),
2863 .dec = __VECS(cast5_dec_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08002864 }
2865 }
2866 }, {
2867 .alg = "ecb(cast6)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002868 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002869 .suite = {
2870 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002871 .enc = __VECS(cast6_enc_tv_template),
2872 .dec = __VECS(cast6_dec_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08002873 }
2874 }
2875 }, {
Jussi Kivilinnae4483702013-04-07 16:43:56 +03002876 .alg = "ecb(cipher_null)",
2877 .test = alg_test_null,
2878 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08002879 .alg = "ecb(des)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002880 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002881 .suite = {
2882 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002883 .enc = __VECS(des_enc_tv_template),
2884 .dec = __VECS(des_dec_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08002885 }
2886 }
2887 }, {
2888 .alg = "ecb(des3_ede)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002889 .test = alg_test_skcipher,
Jarod Wilsona1915d52009-05-15 15:16:03 +10002890 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08002891 .suite = {
2892 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002893 .enc = __VECS(des3_ede_enc_tv_template),
2894 .dec = __VECS(des3_ede_dec_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08002895 }
2896 }
2897 }, {
Jussi Kivilinna66e5bd02013-01-19 13:31:36 +02002898 .alg = "ecb(fcrypt)",
2899 .test = alg_test_skcipher,
2900 .suite = {
2901 .cipher = {
2902 .enc = {
2903 .vecs = fcrypt_pcbc_enc_tv_template,
2904 .count = 1
2905 },
2906 .dec = {
2907 .vecs = fcrypt_pcbc_dec_tv_template,
2908 .count = 1
2909 }
2910 }
2911 }
2912 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08002913 .alg = "ecb(khazad)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002914 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002915 .suite = {
2916 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002917 .enc = __VECS(khazad_enc_tv_template),
2918 .dec = __VECS(khazad_dec_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08002919 }
2920 }
2921 }, {
2922 .alg = "ecb(seed)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002923 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002924 .suite = {
2925 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002926 .enc = __VECS(seed_enc_tv_template),
2927 .dec = __VECS(seed_dec_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08002928 }
2929 }
2930 }, {
2931 .alg = "ecb(serpent)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002932 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002933 .suite = {
2934 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002935 .enc = __VECS(serpent_enc_tv_template),
2936 .dec = __VECS(serpent_dec_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08002937 }
2938 }
2939 }, {
2940 .alg = "ecb(tea)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002941 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002942 .suite = {
2943 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002944 .enc = __VECS(tea_enc_tv_template),
2945 .dec = __VECS(tea_dec_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08002946 }
2947 }
2948 }, {
2949 .alg = "ecb(tnepres)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002950 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002951 .suite = {
2952 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002953 .enc = __VECS(tnepres_enc_tv_template),
2954 .dec = __VECS(tnepres_dec_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08002955 }
2956 }
2957 }, {
2958 .alg = "ecb(twofish)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002959 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002960 .suite = {
2961 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002962 .enc = __VECS(tf_enc_tv_template),
2963 .dec = __VECS(tf_dec_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08002964 }
2965 }
2966 }, {
2967 .alg = "ecb(xeta)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002968 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002969 .suite = {
2970 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002971 .enc = __VECS(xeta_enc_tv_template),
2972 .dec = __VECS(xeta_dec_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08002973 }
2974 }
2975 }, {
2976 .alg = "ecb(xtea)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10002977 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08002978 .suite = {
2979 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002980 .enc = __VECS(xtea_enc_tv_template),
2981 .dec = __VECS(xtea_dec_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08002982 }
2983 }
2984 }, {
Salvatore Benedetto3c4b2392016-06-22 17:49:15 +01002985 .alg = "ecdh",
2986 .test = alg_test_kpp,
2987 .fips_allowed = 1,
2988 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002989 .kpp = __VECS(ecdh_tv_template)
Salvatore Benedetto3c4b2392016-06-22 17:49:15 +01002990 }
2991 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08002992 .alg = "gcm(aes)",
2993 .test = alg_test_aead,
Jarod Wilsona1915d52009-05-15 15:16:03 +10002994 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08002995 .suite = {
2996 .aead = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00002997 .enc = __VECS(aes_gcm_enc_tv_template),
2998 .dec = __VECS(aes_gcm_dec_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08002999 }
3000 }
3001 }, {
Youquan, Song507069c2009-11-23 20:23:04 +08003002 .alg = "ghash",
3003 .test = alg_test_hash,
Jarod Wilson18c0ebd2011-01-29 15:14:35 +11003004 .fips_allowed = 1,
Youquan, Song507069c2009-11-23 20:23:04 +08003005 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003006 .hash = __VECS(ghash_tv_template)
Youquan, Song507069c2009-11-23 20:23:04 +08003007 }
3008 }, {
Sonic Zhanga482b082012-05-25 17:54:13 +08003009 .alg = "hmac(crc32)",
3010 .test = alg_test_hash,
3011 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003012 .hash = __VECS(bfin_crc_tv_template)
Sonic Zhanga482b082012-05-25 17:54:13 +08003013 }
3014 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08003015 .alg = "hmac(md5)",
3016 .test = alg_test_hash,
3017 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003018 .hash = __VECS(hmac_md5_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08003019 }
3020 }, {
3021 .alg = "hmac(rmd128)",
3022 .test = alg_test_hash,
3023 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003024 .hash = __VECS(hmac_rmd128_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08003025 }
3026 }, {
3027 .alg = "hmac(rmd160)",
3028 .test = alg_test_hash,
3029 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003030 .hash = __VECS(hmac_rmd160_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08003031 }
3032 }, {
3033 .alg = "hmac(sha1)",
3034 .test = alg_test_hash,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003035 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003036 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003037 .hash = __VECS(hmac_sha1_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08003038 }
3039 }, {
3040 .alg = "hmac(sha224)",
3041 .test = alg_test_hash,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003042 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003043 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003044 .hash = __VECS(hmac_sha224_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08003045 }
3046 }, {
3047 .alg = "hmac(sha256)",
3048 .test = alg_test_hash,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003049 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003050 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003051 .hash = __VECS(hmac_sha256_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08003052 }
3053 }, {
raveendra padasalagi98eca722016-07-01 11:16:54 +05303054 .alg = "hmac(sha3-224)",
3055 .test = alg_test_hash,
3056 .fips_allowed = 1,
3057 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003058 .hash = __VECS(hmac_sha3_224_tv_template)
raveendra padasalagi98eca722016-07-01 11:16:54 +05303059 }
3060 }, {
3061 .alg = "hmac(sha3-256)",
3062 .test = alg_test_hash,
3063 .fips_allowed = 1,
3064 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003065 .hash = __VECS(hmac_sha3_256_tv_template)
raveendra padasalagi98eca722016-07-01 11:16:54 +05303066 }
3067 }, {
3068 .alg = "hmac(sha3-384)",
3069 .test = alg_test_hash,
3070 .fips_allowed = 1,
3071 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003072 .hash = __VECS(hmac_sha3_384_tv_template)
raveendra padasalagi98eca722016-07-01 11:16:54 +05303073 }
3074 }, {
3075 .alg = "hmac(sha3-512)",
3076 .test = alg_test_hash,
3077 .fips_allowed = 1,
3078 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003079 .hash = __VECS(hmac_sha3_512_tv_template)
raveendra padasalagi98eca722016-07-01 11:16:54 +05303080 }
3081 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08003082 .alg = "hmac(sha384)",
3083 .test = alg_test_hash,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003084 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003085 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003086 .hash = __VECS(hmac_sha384_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08003087 }
3088 }, {
3089 .alg = "hmac(sha512)",
3090 .test = alg_test_hash,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003091 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003092 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003093 .hash = __VECS(hmac_sha512_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08003094 }
3095 }, {
Stephan Muellerbb5530e2015-05-25 15:10:20 +02003096 .alg = "jitterentropy_rng",
3097 .fips_allowed = 1,
3098 .test = alg_test_null,
3099 }, {
Stephan Mueller35351982015-09-21 20:59:56 +02003100 .alg = "kw(aes)",
3101 .test = alg_test_skcipher,
3102 .fips_allowed = 1,
3103 .suite = {
3104 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003105 .enc = __VECS(aes_kw_enc_tv_template),
3106 .dec = __VECS(aes_kw_dec_tv_template)
Stephan Mueller35351982015-09-21 20:59:56 +02003107 }
3108 }
3109 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08003110 .alg = "lrw(aes)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003111 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08003112 .suite = {
3113 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003114 .enc = __VECS(aes_lrw_enc_tv_template),
3115 .dec = __VECS(aes_lrw_dec_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08003116 }
3117 }
3118 }, {
Jussi Kivilinna08406052012-03-05 20:26:21 +02003119 .alg = "lrw(camellia)",
3120 .test = alg_test_skcipher,
3121 .suite = {
3122 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003123 .enc = __VECS(camellia_lrw_enc_tv_template),
3124 .dec = __VECS(camellia_lrw_dec_tv_template)
Jussi Kivilinna08406052012-03-05 20:26:21 +02003125 }
3126 }
3127 }, {
Johannes Goetzfried9b8b0402012-07-11 19:38:29 +02003128 .alg = "lrw(cast6)",
3129 .test = alg_test_skcipher,
3130 .suite = {
3131 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003132 .enc = __VECS(cast6_lrw_enc_tv_template),
3133 .dec = __VECS(cast6_lrw_dec_tv_template)
Johannes Goetzfried9b8b0402012-07-11 19:38:29 +02003134 }
3135 }
3136 }, {
Jussi Kivilinnad7bfc0f2011-10-18 13:32:34 +03003137 .alg = "lrw(serpent)",
3138 .test = alg_test_skcipher,
3139 .suite = {
3140 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003141 .enc = __VECS(serpent_lrw_enc_tv_template),
3142 .dec = __VECS(serpent_lrw_dec_tv_template)
Jussi Kivilinnad7bfc0f2011-10-18 13:32:34 +03003143 }
3144 }
3145 }, {
Jussi Kivilinna0b2a1552011-10-18 13:32:50 +03003146 .alg = "lrw(twofish)",
3147 .test = alg_test_skcipher,
3148 .suite = {
3149 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003150 .enc = __VECS(tf_lrw_enc_tv_template),
3151 .dec = __VECS(tf_lrw_dec_tv_template)
Jussi Kivilinna0b2a1552011-10-18 13:32:50 +03003152 }
3153 }
3154 }, {
KOVACS Krisztian1443cc92014-08-22 10:44:36 +02003155 .alg = "lz4",
3156 .test = alg_test_comp,
3157 .fips_allowed = 1,
3158 .suite = {
3159 .comp = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003160 .comp = __VECS(lz4_comp_tv_template),
3161 .decomp = __VECS(lz4_decomp_tv_template)
KOVACS Krisztian1443cc92014-08-22 10:44:36 +02003162 }
3163 }
3164 }, {
3165 .alg = "lz4hc",
3166 .test = alg_test_comp,
3167 .fips_allowed = 1,
3168 .suite = {
3169 .comp = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003170 .comp = __VECS(lz4hc_comp_tv_template),
3171 .decomp = __VECS(lz4hc_decomp_tv_template)
KOVACS Krisztian1443cc92014-08-22 10:44:36 +02003172 }
3173 }
3174 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08003175 .alg = "lzo",
3176 .test = alg_test_comp,
Milan Broz08189042012-12-06 17:16:28 +08003177 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003178 .suite = {
3179 .comp = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003180 .comp = __VECS(lzo_comp_tv_template),
3181 .decomp = __VECS(lzo_decomp_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08003182 }
3183 }
3184 }, {
3185 .alg = "md4",
3186 .test = alg_test_hash,
3187 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003188 .hash = __VECS(md4_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08003189 }
3190 }, {
3191 .alg = "md5",
3192 .test = alg_test_hash,
3193 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003194 .hash = __VECS(md5_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08003195 }
3196 }, {
3197 .alg = "michael_mic",
3198 .test = alg_test_hash,
3199 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003200 .hash = __VECS(michael_mic_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08003201 }
3202 }, {
Puneet Saxenaba0e14a2011-05-04 15:04:10 +10003203 .alg = "ofb(aes)",
3204 .test = alg_test_skcipher,
3205 .fips_allowed = 1,
3206 .suite = {
3207 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003208 .enc = __VECS(aes_ofb_enc_tv_template),
3209 .dec = __VECS(aes_ofb_dec_tv_template)
Puneet Saxenaba0e14a2011-05-04 15:04:10 +10003210 }
3211 }
3212 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08003213 .alg = "pcbc(fcrypt)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003214 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08003215 .suite = {
3216 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003217 .enc = __VECS(fcrypt_pcbc_enc_tv_template),
3218 .dec = __VECS(fcrypt_pcbc_dec_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08003219 }
3220 }
3221 }, {
Martin Willieee9dc62015-06-01 13:43:59 +02003222 .alg = "poly1305",
3223 .test = alg_test_hash,
3224 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003225 .hash = __VECS(poly1305_tv_template)
Martin Willieee9dc62015-06-01 13:43:59 +02003226 }
3227 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08003228 .alg = "rfc3686(ctr(aes))",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003229 .test = alg_test_skcipher,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003230 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003231 .suite = {
3232 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003233 .enc = __VECS(aes_ctr_rfc3686_enc_tv_template),
3234 .dec = __VECS(aes_ctr_rfc3686_dec_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08003235 }
3236 }
3237 }, {
Herbert Xu3f31a742015-07-09 07:17:34 +08003238 .alg = "rfc4106(gcm(aes))",
Adrian Hoban69435b92010-11-04 15:02:04 -04003239 .test = alg_test_aead,
Jarod Wilsondb71f292015-01-23 12:42:15 -05003240 .fips_allowed = 1,
Adrian Hoban69435b92010-11-04 15:02:04 -04003241 .suite = {
3242 .aead = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003243 .enc = __VECS(aes_gcm_rfc4106_enc_tv_template),
3244 .dec = __VECS(aes_gcm_rfc4106_dec_tv_template)
Adrian Hoban69435b92010-11-04 15:02:04 -04003245 }
3246 }
3247 }, {
Herbert Xu544c4362015-07-14 16:53:22 +08003248 .alg = "rfc4309(ccm(aes))",
Jarod Wilson5d667322009-05-04 19:23:40 +08003249 .test = alg_test_aead,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003250 .fips_allowed = 1,
Jarod Wilson5d667322009-05-04 19:23:40 +08003251 .suite = {
3252 .aead = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003253 .enc = __VECS(aes_ccm_rfc4309_enc_tv_template),
3254 .dec = __VECS(aes_ccm_rfc4309_dec_tv_template)
Jarod Wilson5d667322009-05-04 19:23:40 +08003255 }
3256 }
3257 }, {
Herbert Xubb687452015-06-16 13:54:24 +08003258 .alg = "rfc4543(gcm(aes))",
Jussi Kivilinnae9b74412013-04-07 16:43:51 +03003259 .test = alg_test_aead,
3260 .suite = {
3261 .aead = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003262 .enc = __VECS(aes_gcm_rfc4543_enc_tv_template),
3263 .dec = __VECS(aes_gcm_rfc4543_dec_tv_template),
Jussi Kivilinnae9b74412013-04-07 16:43:51 +03003264 }
3265 }
3266 }, {
Martin Williaf2b76b2015-06-01 13:44:01 +02003267 .alg = "rfc7539(chacha20,poly1305)",
3268 .test = alg_test_aead,
3269 .suite = {
3270 .aead = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003271 .enc = __VECS(rfc7539_enc_tv_template),
3272 .dec = __VECS(rfc7539_dec_tv_template),
Martin Williaf2b76b2015-06-01 13:44:01 +02003273 }
3274 }
3275 }, {
Martin Willi59007582015-06-01 13:44:03 +02003276 .alg = "rfc7539esp(chacha20,poly1305)",
3277 .test = alg_test_aead,
3278 .suite = {
3279 .aead = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003280 .enc = __VECS(rfc7539esp_enc_tv_template),
3281 .dec = __VECS(rfc7539esp_dec_tv_template),
Martin Willi59007582015-06-01 13:44:03 +02003282 }
3283 }
3284 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08003285 .alg = "rmd128",
3286 .test = alg_test_hash,
3287 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003288 .hash = __VECS(rmd128_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08003289 }
3290 }, {
3291 .alg = "rmd160",
3292 .test = alg_test_hash,
3293 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003294 .hash = __VECS(rmd160_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08003295 }
3296 }, {
3297 .alg = "rmd256",
3298 .test = alg_test_hash,
3299 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003300 .hash = __VECS(rmd256_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08003301 }
3302 }, {
3303 .alg = "rmd320",
3304 .test = alg_test_hash,
3305 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003306 .hash = __VECS(rmd320_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08003307 }
3308 }, {
Tadeusz Struk946cc462015-06-16 10:31:06 -07003309 .alg = "rsa",
3310 .test = alg_test_akcipher,
3311 .fips_allowed = 1,
3312 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003313 .akcipher = __VECS(rsa_tv_template)
Tadeusz Struk946cc462015-06-16 10:31:06 -07003314 }
3315 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08003316 .alg = "salsa20",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003317 .test = alg_test_skcipher,
Herbert Xuda7f0332008-07-31 17:08:25 +08003318 .suite = {
3319 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003320 .enc = __VECS(salsa20_stream_enc_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08003321 }
3322 }
3323 }, {
3324 .alg = "sha1",
3325 .test = alg_test_hash,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003326 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003327 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003328 .hash = __VECS(sha1_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08003329 }
3330 }, {
3331 .alg = "sha224",
3332 .test = alg_test_hash,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003333 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003334 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003335 .hash = __VECS(sha224_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08003336 }
3337 }, {
3338 .alg = "sha256",
3339 .test = alg_test_hash,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003340 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003341 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003342 .hash = __VECS(sha256_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08003343 }
3344 }, {
raveendra padasalagi79cc6ab2016-06-17 10:30:36 +05303345 .alg = "sha3-224",
3346 .test = alg_test_hash,
3347 .fips_allowed = 1,
3348 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003349 .hash = __VECS(sha3_224_tv_template)
raveendra padasalagi79cc6ab2016-06-17 10:30:36 +05303350 }
3351 }, {
3352 .alg = "sha3-256",
3353 .test = alg_test_hash,
3354 .fips_allowed = 1,
3355 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003356 .hash = __VECS(sha3_256_tv_template)
raveendra padasalagi79cc6ab2016-06-17 10:30:36 +05303357 }
3358 }, {
3359 .alg = "sha3-384",
3360 .test = alg_test_hash,
3361 .fips_allowed = 1,
3362 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003363 .hash = __VECS(sha3_384_tv_template)
raveendra padasalagi79cc6ab2016-06-17 10:30:36 +05303364 }
3365 }, {
3366 .alg = "sha3-512",
3367 .test = alg_test_hash,
3368 .fips_allowed = 1,
3369 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003370 .hash = __VECS(sha3_512_tv_template)
raveendra padasalagi79cc6ab2016-06-17 10:30:36 +05303371 }
3372 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08003373 .alg = "sha384",
3374 .test = alg_test_hash,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003375 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003376 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003377 .hash = __VECS(sha384_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08003378 }
3379 }, {
3380 .alg = "sha512",
3381 .test = alg_test_hash,
Jarod Wilsona1915d52009-05-15 15:16:03 +10003382 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003383 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003384 .hash = __VECS(sha512_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08003385 }
3386 }, {
3387 .alg = "tgr128",
3388 .test = alg_test_hash,
3389 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003390 .hash = __VECS(tgr128_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08003391 }
3392 }, {
3393 .alg = "tgr160",
3394 .test = alg_test_hash,
3395 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003396 .hash = __VECS(tgr160_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08003397 }
3398 }, {
3399 .alg = "tgr192",
3400 .test = alg_test_hash,
3401 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003402 .hash = __VECS(tgr192_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08003403 }
3404 }, {
Shane Wangf1939f72009-09-02 20:05:22 +10003405 .alg = "vmac(aes)",
3406 .test = alg_test_hash,
3407 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003408 .hash = __VECS(aes_vmac128_tv_template)
Shane Wangf1939f72009-09-02 20:05:22 +10003409 }
3410 }, {
Herbert Xuda7f0332008-07-31 17:08:25 +08003411 .alg = "wp256",
3412 .test = alg_test_hash,
3413 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003414 .hash = __VECS(wp256_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08003415 }
3416 }, {
3417 .alg = "wp384",
3418 .test = alg_test_hash,
3419 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003420 .hash = __VECS(wp384_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08003421 }
3422 }, {
3423 .alg = "wp512",
3424 .test = alg_test_hash,
3425 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003426 .hash = __VECS(wp512_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08003427 }
3428 }, {
3429 .alg = "xcbc(aes)",
3430 .test = alg_test_hash,
3431 .suite = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003432 .hash = __VECS(aes_xcbc128_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08003433 }
3434 }, {
3435 .alg = "xts(aes)",
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003436 .test = alg_test_skcipher,
Jarod Wilson2918aa82011-01-29 15:14:01 +11003437 .fips_allowed = 1,
Herbert Xuda7f0332008-07-31 17:08:25 +08003438 .suite = {
3439 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003440 .enc = __VECS(aes_xts_enc_tv_template),
3441 .dec = __VECS(aes_xts_dec_tv_template)
Herbert Xuda7f0332008-07-31 17:08:25 +08003442 }
3443 }
Geert Uytterhoeven0c01aed2009-03-04 15:42:15 +08003444 }, {
Jussi Kivilinna08406052012-03-05 20:26:21 +02003445 .alg = "xts(camellia)",
3446 .test = alg_test_skcipher,
3447 .suite = {
3448 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003449 .enc = __VECS(camellia_xts_enc_tv_template),
3450 .dec = __VECS(camellia_xts_dec_tv_template)
Jussi Kivilinna08406052012-03-05 20:26:21 +02003451 }
3452 }
3453 }, {
Johannes Goetzfried9b8b0402012-07-11 19:38:29 +02003454 .alg = "xts(cast6)",
3455 .test = alg_test_skcipher,
3456 .suite = {
3457 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003458 .enc = __VECS(cast6_xts_enc_tv_template),
3459 .dec = __VECS(cast6_xts_dec_tv_template)
Johannes Goetzfried9b8b0402012-07-11 19:38:29 +02003460 }
3461 }
3462 }, {
Jussi Kivilinna18be20b92011-10-18 13:33:17 +03003463 .alg = "xts(serpent)",
3464 .test = alg_test_skcipher,
3465 .suite = {
3466 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003467 .enc = __VECS(serpent_xts_enc_tv_template),
3468 .dec = __VECS(serpent_xts_dec_tv_template)
Jussi Kivilinna18be20b92011-10-18 13:33:17 +03003469 }
3470 }
3471 }, {
Jussi Kivilinnaaed265b2011-10-18 13:33:33 +03003472 .alg = "xts(twofish)",
3473 .test = alg_test_skcipher,
3474 .suite = {
3475 .cipher = {
Ard Biesheuvel21c8e722017-01-12 13:40:39 +00003476 .enc = __VECS(tf_xts_enc_tv_template),
3477 .dec = __VECS(tf_xts_dec_tv_template)
Jussi Kivilinnaaed265b2011-10-18 13:33:33 +03003478 }
3479 }
Herbert Xuda7f0332008-07-31 17:08:25 +08003480 }
3481};
3482
Jussi Kivilinna57147582013-06-13 17:37:40 +03003483static bool alg_test_descs_checked;
3484
3485static void alg_test_descs_check_order(void)
3486{
3487 int i;
3488
3489 /* only check once */
3490 if (alg_test_descs_checked)
3491 return;
3492
3493 alg_test_descs_checked = true;
3494
3495 for (i = 1; i < ARRAY_SIZE(alg_test_descs); i++) {
3496 int diff = strcmp(alg_test_descs[i - 1].alg,
3497 alg_test_descs[i].alg);
3498
3499 if (WARN_ON(diff > 0)) {
3500 pr_warn("testmgr: alg_test_descs entries in wrong order: '%s' before '%s'\n",
3501 alg_test_descs[i - 1].alg,
3502 alg_test_descs[i].alg);
3503 }
3504
3505 if (WARN_ON(diff == 0)) {
3506 pr_warn("testmgr: duplicate alg_test_descs entry: '%s'\n",
3507 alg_test_descs[i].alg);
3508 }
3509 }
3510}
3511
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003512static int alg_find_test(const char *alg)
Herbert Xuda7f0332008-07-31 17:08:25 +08003513{
3514 int start = 0;
3515 int end = ARRAY_SIZE(alg_test_descs);
3516
3517 while (start < end) {
3518 int i = (start + end) / 2;
3519 int diff = strcmp(alg_test_descs[i].alg, alg);
3520
3521 if (diff > 0) {
3522 end = i;
3523 continue;
3524 }
3525
3526 if (diff < 0) {
3527 start = i + 1;
3528 continue;
3529 }
3530
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003531 return i;
Herbert Xuda7f0332008-07-31 17:08:25 +08003532 }
3533
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003534 return -1;
3535}
3536
3537int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
3538{
3539 int i;
Herbert Xua68f6612009-07-02 16:32:12 +08003540 int j;
Neil Hormand12d6b62008-10-12 20:36:51 +08003541 int rc;
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003542
Richard W.M. Jones9e5c9fe2016-05-03 10:00:17 +01003543 if (!fips_enabled && notests) {
3544 printk_once(KERN_INFO "alg: self-tests disabled\n");
3545 return 0;
3546 }
3547
Jussi Kivilinna57147582013-06-13 17:37:40 +03003548 alg_test_descs_check_order();
3549
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003550 if ((type & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_CIPHER) {
3551 char nalg[CRYPTO_MAX_ALG_NAME];
3552
3553 if (snprintf(nalg, sizeof(nalg), "ecb(%s)", alg) >=
3554 sizeof(nalg))
3555 return -ENAMETOOLONG;
3556
3557 i = alg_find_test(nalg);
3558 if (i < 0)
3559 goto notest;
3560
Jarod Wilsona3bef3a2009-05-15 15:17:05 +10003561 if (fips_enabled && !alg_test_descs[i].fips_allowed)
3562 goto non_fips_alg;
3563
Jarod Wilson941fb322009-05-04 19:49:23 +08003564 rc = alg_test_cipher(alg_test_descs + i, driver, type, mask);
3565 goto test_done;
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003566 }
3567
3568 i = alg_find_test(alg);
Herbert Xua68f6612009-07-02 16:32:12 +08003569 j = alg_find_test(driver);
3570 if (i < 0 && j < 0)
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003571 goto notest;
3572
Herbert Xua68f6612009-07-02 16:32:12 +08003573 if (fips_enabled && ((i >= 0 && !alg_test_descs[i].fips_allowed) ||
3574 (j >= 0 && !alg_test_descs[j].fips_allowed)))
Jarod Wilsona3bef3a2009-05-15 15:17:05 +10003575 goto non_fips_alg;
3576
Herbert Xua68f6612009-07-02 16:32:12 +08003577 rc = 0;
3578 if (i >= 0)
3579 rc |= alg_test_descs[i].test(alg_test_descs + i, driver,
3580 type, mask);
Cristian Stoica032c8ca2013-07-18 18:57:07 +03003581 if (j >= 0 && j != i)
Herbert Xua68f6612009-07-02 16:32:12 +08003582 rc |= alg_test_descs[j].test(alg_test_descs + j, driver,
3583 type, mask);
3584
Jarod Wilson941fb322009-05-04 19:49:23 +08003585test_done:
Neil Hormand12d6b62008-10-12 20:36:51 +08003586 if (fips_enabled && rc)
3587 panic("%s: %s alg self test failed in fips mode!\n", driver, alg);
3588
Jarod Wilson29ecd4a2009-05-04 19:51:17 +08003589 if (fips_enabled && !rc)
Masanari Iida3e8cffd2014-10-07 00:37:54 +09003590 pr_info("alg: self-tests for %s (%s) passed\n", driver, alg);
Jarod Wilson29ecd4a2009-05-04 19:51:17 +08003591
Neil Hormand12d6b62008-10-12 20:36:51 +08003592 return rc;
Herbert Xu1aa4ecd2008-08-17 17:01:56 +10003593
3594notest:
Herbert Xuda7f0332008-07-31 17:08:25 +08003595 printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver);
3596 return 0;
Jarod Wilsona3bef3a2009-05-15 15:17:05 +10003597non_fips_alg:
3598 return -EINVAL;
Herbert Xuda7f0332008-07-31 17:08:25 +08003599}
Alexander Shishkin0b767f92010-06-03 20:53:43 +10003600
Herbert Xu326a6342010-08-06 09:40:28 +08003601#endif /* CONFIG_CRYPTO_MANAGER_DISABLE_TESTS */
Alexander Shishkin0b767f92010-06-03 20:53:43 +10003602
Herbert Xuda7f0332008-07-31 17:08:25 +08003603EXPORT_SYMBOL_GPL(alg_test);