]> Git Repo - linux.git/blame - crypto/testmgr.c
projects / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
crypto: mediatek - don't return garbage err on successful return
[linux.git] / crypto / testmgr.c
CommitLineData
da7f033d
HX		 1/*
2 * Algorithm testing framework and tests.
3 *
4 * Copyright (c) 2002 James Morris <[email protected]>
5 * Copyright (c) 2002 Jean-Francois Dive <[email protected]>
6 * Copyright (c) 2007 Nokia Siemens Networks
7 * Copyright (c) 2008 Herbert Xu <[email protected]>
8 *
69435b94
AH		 9 * Updated RFC4106 AES-GCM testing.
10 * Authors: Aidan O'Mahony ([email protected])
11 * Adrian Hoban <[email protected]>
12 * Gabriele Paoloni <[email protected]>
13 * Tadeusz Struk ([email protected])
14 * Copyright (c) 2010, Intel Corporation.
15 *
da7f033d
HX		 16 * 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
1ce33115 23#include <crypto/aead.h>
da7f033d 24#include <crypto/hash.h>
12773d93 25#include <crypto/skcipher.h>
da7f033d 26#include <linux/err.h>
1c41b882 27#include <linux/fips.h>
da7f033d
HX		 28#include <linux/module.h>
29#include <linux/scatterlist.h>
30#include <linux/slab.h>
31#include <linux/string.h>
7647d6ce 32#include <crypto/rng.h>
64d1cdfb 33#include <crypto/drbg.h>
946cc463 34#include <crypto/akcipher.h>
802c7f1c 35#include <crypto/kpp.h>
d7db7a88 36#include <crypto/acompress.h>
da7f033d
HX		 37
38#include "internal.h"
0b767f96 39
9e5c9fe4
RJ		 40static bool notests;
41module_param(notests, bool, 0644);
42MODULE_PARM_DESC(notests, "disable crypto self-tests");
43
326a6346 44#ifdef CONFIG_CRYPTO_MANAGER_DISABLE_TESTS
0b767f96
AS		 45
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
da7f033d
HX		 54#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
04b46fbd 66#define IDX3 1511
da7f033d
HX		 67#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
7647d6ce
JW		 110struct cprng_test_suite {
111 struct cprng_testvec *vecs;
112 unsigned int count;
113};
114
64d1cdfb
SM		 115struct drbg_test_suite {
116 struct drbg_testvec *vecs;
117 unsigned int count;
118};
119
946cc463
TS		 120struct akcipher_test_suite {
121 struct akcipher_testvec *vecs;
122 unsigned int count;
123};
124
802c7f1c
SB		 125struct kpp_test_suite {
126 struct kpp_testvec *vecs;
127 unsigned int count;
128};
129
da7f033d
HX		 130struct alg_test_desc {
131 const char *alg;
132 int (*test)(const struct alg_test_desc *desc, const char *driver,
133 u32 type, u32 mask);
a1915d51 134 int fips_allowed; /* set if alg is allowed in fips mode */
da7f033d
HX		 135
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;
7647d6ce 141 struct cprng_test_suite cprng;
64d1cdfb 142 struct drbg_test_suite drbg;
946cc463 143 struct akcipher_test_suite akcipher;
802c7f1c 144 struct kpp_test_suite kpp;
da7f033d
HX		 145 } suite;
146};
147
148static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
149
da7f033d
HX		 150static 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
f8b0d4d0
HX		 168static 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
d4c85f9b 195static int wait_async_op(struct tcrypt_result *tr, int ret)
a8f1a052
DM		 196{
197 if (ret == -EINPROGRESS || ret == -EBUSY) {
8a45ac12 198 wait_for_completion(&tr->completion);
16735d02 199 reinit_completion(&tr->completion);
8a45ac12 200 ret = tr->err;
a8f1a052
DM		 201 }
202 return ret;
203}
204
018ba95c
WR		 205static 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;
7bcb87bc 213 const char guard[] = { 0x00, 0xba, 0xad, 0x00 };
018ba95c
WR		 214
215 req = *preq;
216 statesize = crypto_ahash_statesize(
217 crypto_ahash_reqtfm(req));
7bcb87bc 218 state = kmalloc(statesize + sizeof(guard), GFP_KERNEL);
018ba95c
WR		 219 if (!state) {
220 pr_err("alt: hash: Failed to alloc state for %s\n", algo);
221 goto out_nostate;
222 }
7bcb87bc 223 memcpy(state + statesize, guard, sizeof(guard));
018ba95c 224 ret = crypto_ahash_export(req, state);
7bcb87bc 225 WARN_ON(memcmp(state + statesize, guard, sizeof(guard)));
018ba95c
WR		 226 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
da5ffe11
JK		 263static int __test_hash(struct crypto_ahash *tfm, struct hash_testvec *template,
264 unsigned int tcount, bool use_digest,
265 const int align_offset)
da7f033d
HX		 266{
267 const char *algo = crypto_tfm_alg_driver_name(crypto_ahash_tfm(tfm));
268 unsigned int i, j, k, temp;
269 struct scatterlist sg[8];
29b77e5d
HG		 270 char *result;
271 char *key;
da7f033d
HX		 272 struct ahash_request *req;
273 struct tcrypt_result tresult;
da7f033d 274 void *hash_buff;
f8b0d4d0
HX		 275 char *xbuf[XBUFSIZE];
276 int ret = -ENOMEM;
277
29b77e5d
HG		 278 result = kmalloc(MAX_DIGEST_SIZE, GFP_KERNEL);
279 if (!result)
280 return ret;
281 key = kmalloc(MAX_KEYLEN, GFP_KERNEL);
282 if (!key)
283 goto out_nobuf;
f8b0d4d0
HX		 284 if (testmgr_alloc_buf(xbuf))
285 goto out_nobuf;
da7f033d
HX		 286
287 init_completion(&tresult.completion);
288
289 req = ahash_request_alloc(tfm, GFP_KERNEL);
290 if (!req) {
291 printk(KERN_ERR "alg: hash: Failed to allocate request for "
292 "%s\n", algo);
da7f033d
HX		 293 goto out_noreq;
294 }
295 ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
296 tcrypt_complete, &tresult);
297
a0cfae59 298 j = 0;
da7f033d 299 for (i = 0; i < tcount; i++) {
a0cfae59
HX		 300 if (template[i].np)
301 continue;
302
da5ffe11
JK		 303 ret = -EINVAL;
304 if (WARN_ON(align_offset + template[i].psize > PAGE_SIZE))
305 goto out;
306
a0cfae59 307 j++;
29b77e5d 308 memset(result, 0, MAX_DIGEST_SIZE);
da7f033d
HX		 309
310 hash_buff = xbuf[0];
da5ffe11 311 hash_buff += align_offset;
da7f033d
HX		 312
313 memcpy(hash_buff, template[i].plaintext, template[i].psize);
314 sg_init_one(&sg[0], hash_buff, template[i].psize);
315
316 if (template[i].ksize) {
317 crypto_ahash_clear_flags(tfm, ~0);
29b77e5d
HG		 318 if (template[i].ksize > MAX_KEYLEN) {
319 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
320 j, algo, template[i].ksize, MAX_KEYLEN);
321 ret = -EINVAL;
322 goto out;
323 }
324 memcpy(key, template[i].key, template[i].ksize);
325 ret = crypto_ahash_setkey(tfm, key, template[i].ksize);
da7f033d
HX		 326 if (ret) {
327 printk(KERN_ERR "alg: hash: setkey failed on "
a0cfae59 328 "test %d for %s: ret=%d\n", j, algo,
da7f033d
HX		 329 -ret);
330 goto out;
331 }
332 }
333
334 ahash_request_set_crypt(req, sg, result, template[i].psize);
a8f1a052 335 if (use_digest) {
d4c85f9b 336 ret = wait_async_op(&tresult, crypto_ahash_digest(req));
a8f1a052
DM		 337 if (ret) {
338 pr_err("alg: hash: digest failed on test %d "
339 "for %s: ret=%d\n", j, algo, -ret);
340 goto out;
341 }
342 } else {
d4c85f9b 343 ret = wait_async_op(&tresult, crypto_ahash_init(req));
a8f1a052
DM		 344 if (ret) {
345 pr_err("alt: hash: init failed on test %d "
346 "for %s: ret=%d\n", j, algo, -ret);
347 goto out;
348 }
d4c85f9b 349 ret = wait_async_op(&tresult, crypto_ahash_update(req));
a8f1a052
DM		 350 if (ret) {
351 pr_err("alt: hash: update failed on test %d "
352 "for %s: ret=%d\n", j, algo, -ret);
353 goto out;
354 }
d4c85f9b 355 ret = wait_async_op(&tresult, crypto_ahash_final(req));
a8f1a052
DM		 356 if (ret) {
357 pr_err("alt: hash: final failed on test %d "
358 "for %s: ret=%d\n", j, algo, -ret);
359 goto out;
da7f033d 360 }
da7f033d
HX		 361 }
362
363 if (memcmp(result, template[i].digest,
364 crypto_ahash_digestsize(tfm))) {
365 printk(KERN_ERR "alg: hash: Test %d failed for %s\n",
a0cfae59 366 j, algo);
da7f033d
HX		 367 hexdump(result, crypto_ahash_digestsize(tfm));
368 ret = -EINVAL;
369 goto out;
370 }
371 }
372
373 j = 0;
374 for (i = 0; i < tcount; i++) {
da5ffe11
JK		 375 /* alignment tests are only done with continuous buffers */
376 if (align_offset != 0)
377 break;
378
5f2b424e
CS		 379 if (!template[i].np)
380 continue;
da7f033d 381
5f2b424e
CS		 382 j++;
383 memset(result, 0, MAX_DIGEST_SIZE);
da7f033d 384
5f2b424e
CS		 385 temp = 0;
386 sg_init_table(sg, template[i].np);
387 ret = -EINVAL;
388 for (k = 0; k < template[i].np; k++) {
389 if (WARN_ON(offset_in_page(IDX[k]) +
390 template[i].tap[k] > PAGE_SIZE))
391 goto out;
392 sg_set_buf(&sg[k],
393 memcpy(xbuf[IDX[k] >> PAGE_SHIFT] +
394 offset_in_page(IDX[k]),
395 template[i].plaintext + temp,
396 template[i].tap[k]),
397 template[i].tap[k]);
398 temp += template[i].tap[k];
399 }
da7f033d 400
5f2b424e
CS		 401 if (template[i].ksize) {
402 if (template[i].ksize > MAX_KEYLEN) {
403 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
404 j, algo, template[i].ksize, MAX_KEYLEN);
405 ret = -EINVAL;
da7f033d
HX		 406 goto out;
407 }
5f2b424e
CS		 408 crypto_ahash_clear_flags(tfm, ~0);
409 memcpy(key, template[i].key, template[i].ksize);
410 ret = crypto_ahash_setkey(tfm, key, template[i].ksize);
da7f033d 411
5f2b424e
CS		 412 if (ret) {
413 printk(KERN_ERR "alg: hash: setkey "
414 "failed on chunking test %d "
415 "for %s: ret=%d\n", j, algo, -ret);
da7f033d
HX		 416 goto out;
417 }
418 }
5f2b424e
CS		 419
420 ahash_request_set_crypt(req, sg, result, template[i].psize);
421 ret = crypto_ahash_digest(req);
422 switch (ret) {
423 case 0:
424 break;
425 case -EINPROGRESS:
426 case -EBUSY:
8a45ac12
RV		 427 wait_for_completion(&tresult.completion);
428 reinit_completion(&tresult.completion);
429 ret = tresult.err;
430 if (!ret)
5f2b424e 431 break;
5f2b424e
CS		 432 /* fall through */
433 default:
434 printk(KERN_ERR "alg: hash: digest failed "
435 "on chunking test %d for %s: "
436 "ret=%d\n", j, algo, -ret);
437 goto out;
438 }
439
440 if (memcmp(result, template[i].digest,
441 crypto_ahash_digestsize(tfm))) {
442 printk(KERN_ERR "alg: hash: Chunking test %d "
443 "failed for %s\n", j, algo);
444 hexdump(result, crypto_ahash_digestsize(tfm));
445 ret = -EINVAL;
018ba95c
WR		 446 goto out;
447 }
448 }
449
450 /* partial update exercise */
451 j = 0;
452 for (i = 0; i < tcount; i++) {
453 /* alignment tests are only done with continuous buffers */
454 if (align_offset != 0)
455 break;
456
457 if (template[i].np < 2)
458 continue;
459
460 j++;
461 memset(result, 0, MAX_DIGEST_SIZE);
462
463 ret = -EINVAL;
464 hash_buff = xbuf[0];
465 memcpy(hash_buff, template[i].plaintext,
466 template[i].tap[0]);
467 sg_init_one(&sg[0], hash_buff, template[i].tap[0]);
468
469 if (template[i].ksize) {
470 crypto_ahash_clear_flags(tfm, ~0);
471 if (template[i].ksize > MAX_KEYLEN) {
472 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n",
473 j, algo, template[i].ksize, MAX_KEYLEN);
474 ret = -EINVAL;
475 goto out;
476 }
477 memcpy(key, template[i].key, template[i].ksize);
478 ret = crypto_ahash_setkey(tfm, key, template[i].ksize);
479 if (ret) {
480 pr_err("alg: hash: setkey failed on test %d for %s: ret=%d\n",
481 j, algo, -ret);
482 goto out;
483 }
484 }
485
486 ahash_request_set_crypt(req, sg, result, template[i].tap[0]);
487 ret = wait_async_op(&tresult, crypto_ahash_init(req));
488 if (ret) {
489 pr_err("alt: hash: init failed on test %d for %s: ret=%d\n",
490 j, algo, -ret);
491 goto out;
492 }
493 ret = wait_async_op(&tresult, crypto_ahash_update(req));
494 if (ret) {
495 pr_err("alt: hash: update failed on test %d for %s: ret=%d\n",
496 j, algo, -ret);
497 goto out;
498 }
499
500 temp = template[i].tap[0];
501 for (k = 1; k < template[i].np; k++) {
502 ret = ahash_partial_update(&req, tfm, &template[i],
503 hash_buff, k, temp, &sg[0], algo, result,
504 &tresult);
505 if (ret) {
506 pr_err("hash: partial update failed on test %d for %s: ret=%d\n",
507 j, algo, -ret);
508 goto out_noreq;
509 }
510 temp += template[i].tap[k];
511 }
512 ret = wait_async_op(&tresult, crypto_ahash_final(req));
513 if (ret) {
514 pr_err("alt: hash: final failed on test %d for %s: ret=%d\n",
515 j, algo, -ret);
516 goto out;
517 }
518 if (memcmp(result, template[i].digest,
519 crypto_ahash_digestsize(tfm))) {
520 pr_err("alg: hash: Partial Test %d failed for %s\n",
521 j, algo);
522 hexdump(result, crypto_ahash_digestsize(tfm));
523 ret = -EINVAL;
5f2b424e
CS		 524 goto out;
525 }
da7f033d
HX		 526 }
527
528 ret = 0;
529
530out:
531 ahash_request_free(req);
532out_noreq:
f8b0d4d0
HX		 533 testmgr_free_buf(xbuf);
534out_nobuf:
29b77e5d
HG		 535 kfree(key);
536 kfree(result);
da7f033d
HX		 537 return ret;
538}
539
da5ffe11
JK		 540static int test_hash(struct crypto_ahash *tfm, struct hash_testvec *template,
541 unsigned int tcount, bool use_digest)
542{
543 unsigned int alignmask;
544 int ret;
545
546 ret = __test_hash(tfm, template, tcount, use_digest, 0);
547 if (ret)
548 return ret;
549
550 /* test unaligned buffers, check with one byte offset */
551 ret = __test_hash(tfm, template, tcount, use_digest, 1);
552 if (ret)
553 return ret;
554
555 alignmask = crypto_tfm_alg_alignmask(&tfm->base);
556 if (alignmask) {
557 /* Check if alignment mask for tfm is correctly set. */
558 ret = __test_hash(tfm, template, tcount, use_digest,
559 alignmask + 1);
560 if (ret)
561 return ret;
562 }
563
564 return 0;
565}
566
d8a32ac2
JK		 567static int __test_aead(struct crypto_aead *tfm, int enc,
568 struct aead_testvec *template, unsigned int tcount,
58dcf548 569 const bool diff_dst, const int align_offset)
da7f033d
HX		 570{
571 const char *algo = crypto_tfm_alg_driver_name(crypto_aead_tfm(tfm));
572 unsigned int i, j, k, n, temp;
f8b0d4d0 573 int ret = -ENOMEM;
da7f033d
HX		 574 char *q;
575 char *key;
576 struct aead_request *req;
d8a32ac2 577 struct scatterlist *sg;
d8a32ac2
JK		 578 struct scatterlist *sgout;
579 const char *e, *d;
da7f033d 580 struct tcrypt_result result;
424a5da6 581 unsigned int authsize, iv_len;
da7f033d 582 void *input;
d8a32ac2 583 void *output;
da7f033d 584 void *assoc;
9bac019d 585 char *iv;
f8b0d4d0 586 char *xbuf[XBUFSIZE];
d8a32ac2 587 char *xoutbuf[XBUFSIZE];
f8b0d4d0
HX		 588 char *axbuf[XBUFSIZE];
589
9bac019d
TS		 590 iv = kzalloc(MAX_IVLEN, GFP_KERNEL);
591 if (!iv)
592 return ret;
29b77e5d
HG		 593 key = kmalloc(MAX_KEYLEN, GFP_KERNEL);
594 if (!key)
595 goto out_noxbuf;
f8b0d4d0
HX		 596 if (testmgr_alloc_buf(xbuf))
597 goto out_noxbuf;
598 if (testmgr_alloc_buf(axbuf))
599 goto out_noaxbuf;
d8a32ac2
JK		 600 if (diff_dst && testmgr_alloc_buf(xoutbuf))
601 goto out_nooutbuf;
602
603 /* avoid "the frame size is larger than 1024 bytes" compiler warning */
8a525fcd 604 sg = kmalloc(sizeof(*sg) * 8 * (diff_dst ? 4 : 2), GFP_KERNEL);
d8a32ac2
JK		 605 if (!sg)
606 goto out_nosg;
8a525fcd 607 sgout = &sg[16];
d8a32ac2
JK		 608
609 if (diff_dst)
610 d = "-ddst";
611 else
612 d = "";
613
da7f033d
HX		 614 if (enc == ENCRYPT)
615 e = "encryption";
616 else
617 e = "decryption";
618
619 init_completion(&result.completion);
620
621 req = aead_request_alloc(tfm, GFP_KERNEL);
622 if (!req) {
d8a32ac2
JK		 623 pr_err("alg: aead%s: Failed to allocate request for %s\n",
624 d, algo);
da7f033d
HX		 625 goto out;
626 }
627
628 aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
629 tcrypt_complete, &result);
630
abfa7f43
JM		 631 iv_len = crypto_aead_ivsize(tfm);
632
da7f033d 633 for (i = 0, j = 0; i < tcount; i++) {
05b1d338
CS		 634 if (template[i].np)
635 continue;
da7f033d 636
05b1d338 637 j++;
fd57f22a 638
05b1d338
CS		 639 /* some templates have no input data but they will
640 * touch input
641 */
642 input = xbuf[0];
643 input += align_offset;
644 assoc = axbuf[0];
da7f033d 645
05b1d338
CS		 646 ret = -EINVAL;
647 if (WARN_ON(align_offset + template[i].ilen >
648 PAGE_SIZE || template[i].alen > PAGE_SIZE))
649 goto out;
da7f033d 650
05b1d338
CS		 651 memcpy(input, template[i].input, template[i].ilen);
652 memcpy(assoc, template[i].assoc, template[i].alen);
653 if (template[i].iv)
424a5da6 654 memcpy(iv, template[i].iv, iv_len);
05b1d338 655 else
424a5da6 656 memset(iv, 0, iv_len);
05b1d338
CS		 657
658 crypto_aead_clear_flags(tfm, ~0);
659 if (template[i].wk)
660 crypto_aead_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
661
662 if (template[i].klen > MAX_KEYLEN) {
663 pr_err("alg: aead%s: setkey failed on test %d for %s: key size %d > %d\n",
664 d, j, algo, template[i].klen,
665 MAX_KEYLEN);
666 ret = -EINVAL;
667 goto out;
668 }
669 memcpy(key, template[i].key, template[i].klen);
da7f033d 670
05b1d338 671 ret = crypto_aead_setkey(tfm, key, template[i].klen);
0fae0c1e 672 if (template[i].fail == !ret) {
05b1d338
CS		 673 pr_err("alg: aead%s: setkey failed on test %d for %s: flags=%x\n",
674 d, j, algo, crypto_aead_get_flags(tfm));
675 goto out;
676 } else if (ret)
677 continue;
da7f033d 678
05b1d338
CS		 679 authsize = abs(template[i].rlen - template[i].ilen);
680 ret = crypto_aead_setauthsize(tfm, authsize);
681 if (ret) {
682 pr_err("alg: aead%s: Failed to set authsize to %u on test %d for %s\n",
683 d, authsize, j, algo);
684 goto out;
685 }
da7f033d 686
8a525fcd
HX		 687 k = !!template[i].alen;
688 sg_init_table(sg, k + 1);
689 sg_set_buf(&sg[0], assoc, template[i].alen);
690 sg_set_buf(&sg[k], input,
691 template[i].ilen + (enc ? authsize : 0));
692 output = input;
693
05b1d338 694 if (diff_dst) {
8a525fcd
HX		 695 sg_init_table(sgout, k + 1);
696 sg_set_buf(&sgout[0], assoc, template[i].alen);
697
05b1d338
CS		 698 output = xoutbuf[0];
699 output += align_offset;
8a525fcd
HX		 700 sg_set_buf(&sgout[k], output,
701 template[i].rlen + (enc ? 0 : authsize));
05b1d338 702 }
d8a32ac2 703
05b1d338
CS		 704 aead_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
705 template[i].ilen, iv);
da7f033d 706
8a525fcd 707 aead_request_set_ad(req, template[i].alen);
da7f033d 708
05b1d338 709 ret = enc ? crypto_aead_encrypt(req) : crypto_aead_decrypt(req);
da7f033d 710
05b1d338
CS		 711 switch (ret) {
712 case 0:
713 if (template[i].novrfy) {
714 /* verification was supposed to fail */
715 pr_err("alg: aead%s: %s failed on test %d for %s: ret was 0, expected -EBADMSG\n",
716 d, e, j, algo);
717 /* so really, we got a bad message */
718 ret = -EBADMSG;
da7f033d
HX		 719 goto out;
720 }
05b1d338
CS		 721 break;
722 case -EINPROGRESS:
723 case -EBUSY:
8a45ac12
RV		 724 wait_for_completion(&result.completion);
725 reinit_completion(&result.completion);
726 ret = result.err;
727 if (!ret)
05b1d338 728 break;
05b1d338
CS		 729 case -EBADMSG:
730 if (template[i].novrfy)
731 /* verification failure was expected */
732 continue;
733 /* fall through */
734 default:
735 pr_err("alg: aead%s: %s failed on test %d for %s: ret=%d\n",
736 d, e, j, algo, -ret);
737 goto out;
738 }
739
740 q = output;
741 if (memcmp(q, template[i].result, template[i].rlen)) {
742 pr_err("alg: aead%s: Test %d failed on %s for %s\n",
743 d, j, e, algo);
744 hexdump(q, template[i].rlen);
745 ret = -EINVAL;
746 goto out;
da7f033d
HX		 747 }
748 }
749
750 for (i = 0, j = 0; i < tcount; i++) {
58dcf548
JK		 751 /* alignment tests are only done with continuous buffers */
752 if (align_offset != 0)
753 break;
754
05b1d338
CS		 755 if (!template[i].np)
756 continue;
da7f033d 757
05b1d338 758 j++;
da7f033d 759
05b1d338 760 if (template[i].iv)
abfa7f43 761 memcpy(iv, template[i].iv, iv_len);
05b1d338
CS		 762 else
763 memset(iv, 0, MAX_IVLEN);
764
765 crypto_aead_clear_flags(tfm, ~0);
766 if (template[i].wk)
767 crypto_aead_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
768 if (template[i].klen > MAX_KEYLEN) {
769 pr_err("alg: aead%s: setkey failed on test %d for %s: key size %d > %d\n",
770 d, j, algo, template[i].klen, MAX_KEYLEN);
771 ret = -EINVAL;
772 goto out;
773 }
774 memcpy(key, template[i].key, template[i].klen);
da7f033d 775
05b1d338 776 ret = crypto_aead_setkey(tfm, key, template[i].klen);
0fae0c1e 777 if (template[i].fail == !ret) {
05b1d338
CS		 778 pr_err("alg: aead%s: setkey failed on chunk test %d for %s: flags=%x\n",
779 d, j, algo, crypto_aead_get_flags(tfm));
780 goto out;
781 } else if (ret)
782 continue;
da7f033d 783
05b1d338 784 authsize = abs(template[i].rlen - template[i].ilen);
da7f033d 785
05b1d338 786 ret = -EINVAL;
8a525fcd 787 sg_init_table(sg, template[i].anp + template[i].np);
05b1d338 788 if (diff_dst)
8a525fcd
HX		 789 sg_init_table(sgout, template[i].anp + template[i].np);
790
791 ret = -EINVAL;
792 for (k = 0, temp = 0; k < template[i].anp; k++) {
793 if (WARN_ON(offset_in_page(IDX[k]) +
794 template[i].atap[k] > PAGE_SIZE))
795 goto out;
796 sg_set_buf(&sg[k],
797 memcpy(axbuf[IDX[k] >> PAGE_SHIFT] +
798 offset_in_page(IDX[k]),
799 template[i].assoc + temp,
800 template[i].atap[k]),
801 template[i].atap[k]);
802 if (diff_dst)
803 sg_set_buf(&sgout[k],
804 axbuf[IDX[k] >> PAGE_SHIFT] +
805 offset_in_page(IDX[k]),
806 template[i].atap[k]);
807 temp += template[i].atap[k];
808 }
809
05b1d338
CS		 810 for (k = 0, temp = 0; k < template[i].np; k++) {
811 if (WARN_ON(offset_in_page(IDX[k]) +
812 template[i].tap[k] > PAGE_SIZE))
813 goto out;
da7f033d 814
05b1d338
CS		 815 q = xbuf[IDX[k] >> PAGE_SHIFT] + offset_in_page(IDX[k]);
816 memcpy(q, template[i].input + temp, template[i].tap[k]);
8a525fcd
HX		 817 sg_set_buf(&sg[template[i].anp + k],
818 q, template[i].tap[k]);
da7f033d 819
05b1d338
CS		 820 if (diff_dst) {
821 q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
822 offset_in_page(IDX[k]);
d8a32ac2 823
05b1d338 824 memset(q, 0, template[i].tap[k]);
d8a32ac2 825
8a525fcd
HX		 826 sg_set_buf(&sgout[template[i].anp + k],
827 q, template[i].tap[k]);
05b1d338 828 }
d8a32ac2 829
05b1d338
CS		 830 n = template[i].tap[k];
831 if (k == template[i].np - 1 && enc)
832 n += authsize;
833 if (offset_in_page(q) + n < PAGE_SIZE)
834 q[n] = 0;
d8a32ac2 835
05b1d338
CS		 836 temp += template[i].tap[k];
837 }
8ec25c51 838
05b1d338
CS		 839 ret = crypto_aead_setauthsize(tfm, authsize);
840 if (ret) {
841 pr_err("alg: aead%s: Failed to set authsize to %u on chunk test %d for %s\n",
842 d, authsize, j, algo);
843 goto out;
844 }
da7f033d 845
05b1d338 846 if (enc) {
8a525fcd
HX		 847 if (WARN_ON(sg[template[i].anp + k - 1].offset +
848 sg[template[i].anp + k - 1].length +
849 authsize > PAGE_SIZE)) {
05b1d338 850 ret = -EINVAL;
da7f033d
HX		 851 goto out;
852 }
853
05b1d338 854 if (diff_dst)
8a525fcd
HX		 855 sgout[template[i].anp + k - 1].length +=
856 authsize;
857 sg[template[i].anp + k - 1].length += authsize;
05b1d338 858 }
da7f033d 859
05b1d338
CS		 860 aead_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
861 template[i].ilen,
862 iv);
da7f033d 863
8a525fcd 864 aead_request_set_ad(req, template[i].alen);
da7f033d 865
05b1d338 866 ret = enc ? crypto_aead_encrypt(req) : crypto_aead_decrypt(req);
da7f033d 867
05b1d338
CS		 868 switch (ret) {
869 case 0:
870 if (template[i].novrfy) {
871 /* verification was supposed to fail */
872 pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret was 0, expected -EBADMSG\n",
873 d, e, j, algo);
874 /* so really, we got a bad message */
875 ret = -EBADMSG;
da7f033d
HX		 876 goto out;
877 }
05b1d338
CS		 878 break;
879 case -EINPROGRESS:
880 case -EBUSY:
8a45ac12
RV		 881 wait_for_completion(&result.completion);
882 reinit_completion(&result.completion);
883 ret = result.err;
884 if (!ret)
05b1d338 885 break;
05b1d338
CS		 886 case -EBADMSG:
887 if (template[i].novrfy)
888 /* verification failure was expected */
889 continue;
890 /* fall through */
891 default:
892 pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret=%d\n",
893 d, e, j, algo, -ret);
894 goto out;
895 }
da7f033d 896
05b1d338
CS		 897 ret = -EINVAL;
898 for (k = 0, temp = 0; k < template[i].np; k++) {
899 if (diff_dst)
900 q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
901 offset_in_page(IDX[k]);
902 else
903 q = xbuf[IDX[k] >> PAGE_SHIFT] +
904 offset_in_page(IDX[k]);
da7f033d 905
05b1d338
CS		 906 n = template[i].tap[k];
907 if (k == template[i].np - 1)
908 n += enc ? authsize : -authsize;
da7f033d 909
05b1d338
CS		 910 if (memcmp(q, template[i].result + temp, n)) {
911 pr_err("alg: aead%s: Chunk test %d failed on %s at page %u for %s\n",
912 d, j, e, k, algo);
913 hexdump(q, n);
914 goto out;
915 }
da7f033d 916
05b1d338
CS		 917 q += n;
918 if (k == template[i].np - 1 && !enc) {
919 if (!diff_dst &&
920 memcmp(q, template[i].input +
921 temp + n, authsize))
922 n = authsize;
923 else
924 n = 0;
925 } else {
926 for (n = 0; offset_in_page(q + n) && q[n]; n++)
927 ;
928 }
929 if (n) {
930 pr_err("alg: aead%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n",
931 d, j, e, k, algo, n);
932 hexdump(q, n);
933 goto out;
da7f033d 934 }
05b1d338
CS		 935
936 temp += template[i].tap[k];
da7f033d
HX		 937 }
938 }
939
940 ret = 0;
941
942out:
943 aead_request_free(req);
d8a32ac2
JK		 944 kfree(sg);
945out_nosg:
946 if (diff_dst)
947 testmgr_free_buf(xoutbuf);
948out_nooutbuf:
f8b0d4d0
HX		 949 testmgr_free_buf(axbuf);
950out_noaxbuf:
951 testmgr_free_buf(xbuf);
952out_noxbuf:
29b77e5d 953 kfree(key);
9bac019d 954 kfree(iv);
da7f033d
HX		 955 return ret;
956}
957
d8a32ac2
JK		 958static int test_aead(struct crypto_aead *tfm, int enc,
959 struct aead_testvec *template, unsigned int tcount)
960{
58dcf548 961 unsigned int alignmask;
d8a32ac2
JK		 962 int ret;
963
964 /* test 'dst == src' case */
58dcf548 965 ret = __test_aead(tfm, enc, template, tcount, false, 0);
d8a32ac2
JK		 966 if (ret)
967 return ret;
968
969 /* test 'dst != src' case */
58dcf548
JK		 970 ret = __test_aead(tfm, enc, template, tcount, true, 0);
971 if (ret)
972 return ret;
973
974 /* test unaligned buffers, check with one byte offset */
975 ret = __test_aead(tfm, enc, template, tcount, true, 1);
976 if (ret)
977 return ret;
978
979 alignmask = crypto_tfm_alg_alignmask(&tfm->base);
980 if (alignmask) {
981 /* Check if alignment mask for tfm is correctly set. */
982 ret = __test_aead(tfm, enc, template, tcount, true,
983 alignmask + 1);
984 if (ret)
985 return ret;
986 }
987
988 return 0;
d8a32ac2
JK		 989}
990
1aa4ecd9 991static int test_cipher(struct crypto_cipher *tfm, int enc,
da7f033d 992 struct cipher_testvec *template, unsigned int tcount)
1aa4ecd9
HX		 993{
994 const char *algo = crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm));
995 unsigned int i, j, k;
1aa4ecd9
HX		 996 char *q;
997 const char *e;
998 void *data;
f8b0d4d0
HX		 999 char *xbuf[XBUFSIZE];
1000 int ret = -ENOMEM;
1001
1002 if (testmgr_alloc_buf(xbuf))
1003 goto out_nobuf;
1aa4ecd9
HX		 1004
1005 if (enc == ENCRYPT)
1006 e = "encryption";
1007 else
1008 e = "decryption";
1009
1010 j = 0;
1011 for (i = 0; i < tcount; i++) {
1012 if (template[i].np)
1013 continue;
1014
10faa8c0
SM		 1015 if (fips_enabled && template[i].fips_skip)
1016 continue;
1017
1aa4ecd9
HX		 1018 j++;
1019
fd57f22a
HX		 1020 ret = -EINVAL;
1021 if (WARN_ON(template[i].ilen > PAGE_SIZE))
1022 goto out;
1023
1aa4ecd9
HX		 1024 data = xbuf[0];
1025 memcpy(data, template[i].input, template[i].ilen);
1026
1027 crypto_cipher_clear_flags(tfm, ~0);
1028 if (template[i].wk)
1029 crypto_cipher_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
1030
1031 ret = crypto_cipher_setkey(tfm, template[i].key,
1032 template[i].klen);
0fae0c1e 1033 if (template[i].fail == !ret) {
1aa4ecd9
HX		 1034 printk(KERN_ERR "alg: cipher: setkey failed "
1035 "on test %d for %s: flags=%x\n", j,
1036 algo, crypto_cipher_get_flags(tfm));
1037 goto out;
1038 } else if (ret)
1039 continue;
1040
1041 for (k = 0; k < template[i].ilen;
1042 k += crypto_cipher_blocksize(tfm)) {
1043 if (enc)
1044 crypto_cipher_encrypt_one(tfm, data + k,
1045 data + k);
1046 else
1047 crypto_cipher_decrypt_one(tfm, data + k,
1048 data + k);
1049 }
1050
1051 q = data;
1052 if (memcmp(q, template[i].result, template[i].rlen)) {
1053 printk(KERN_ERR "alg: cipher: Test %d failed "
1054 "on %s for %s\n", j, e, algo);
1055 hexdump(q, template[i].rlen);
1056 ret = -EINVAL;
1057 goto out;
1058 }
1059 }
1060
1061 ret = 0;
1062
1063out:
f8b0d4d0
HX		 1064 testmgr_free_buf(xbuf);
1065out_nobuf:
1aa4ecd9
HX		 1066 return ret;
1067}
1068
12773d93 1069static int __test_skcipher(struct crypto_skcipher *tfm, int enc,
08d6af8c 1070 struct cipher_testvec *template, unsigned int tcount,
3a338f20 1071 const bool diff_dst, const int align_offset)
da7f033d
HX		 1072{
1073 const char *algo =
12773d93 1074 crypto_tfm_alg_driver_name(crypto_skcipher_tfm(tfm));
da7f033d 1075 unsigned int i, j, k, n, temp;
da7f033d 1076 char *q;
12773d93 1077 struct skcipher_request *req;
da7f033d 1078 struct scatterlist sg[8];
08d6af8c
JK		 1079 struct scatterlist sgout[8];
1080 const char *e, *d;
da7f033d
HX		 1081 struct tcrypt_result result;
1082 void *data;
1083 char iv[MAX_IVLEN];
f8b0d4d0 1084 char *xbuf[XBUFSIZE];
08d6af8c 1085 char *xoutbuf[XBUFSIZE];
f8b0d4d0 1086 int ret = -ENOMEM;
84cba178 1087 unsigned int ivsize = crypto_skcipher_ivsize(tfm);
f8b0d4d0
HX		 1088
1089 if (testmgr_alloc_buf(xbuf))
1090 goto out_nobuf;
da7f033d 1091
08d6af8c
JK		 1092 if (diff_dst && testmgr_alloc_buf(xoutbuf))
1093 goto out_nooutbuf;
1094
1095 if (diff_dst)
1096 d = "-ddst";
1097 else
1098 d = "";
1099
da7f033d
HX		 1100 if (enc == ENCRYPT)
1101 e = "encryption";
1102 else
1103 e = "decryption";
1104
1105 init_completion(&result.completion);
1106
12773d93 1107 req = skcipher_request_alloc(tfm, GFP_KERNEL);
da7f033d 1108 if (!req) {
08d6af8c
JK		 1109 pr_err("alg: skcipher%s: Failed to allocate request for %s\n",
1110 d, algo);
da7f033d
HX		 1111 goto out;
1112 }
1113
12773d93
HX		 1114 skcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
1115 tcrypt_complete, &result);
da7f033d
HX		 1116
1117 j = 0;
1118 for (i = 0; i < tcount; i++) {
bbb9a7dd
CS		 1119 if (template[i].np && !template[i].also_non_np)
1120 continue;
1121
10faa8c0
SM		 1122 if (fips_enabled && template[i].fips_skip)
1123 continue;
1124
da7f033d 1125 if (template[i].iv)
84cba178 1126 memcpy(iv, template[i].iv, ivsize);
da7f033d
HX		 1127 else
1128 memset(iv, 0, MAX_IVLEN);
1129
a1aa44a2 1130 j++;
a1aa44a2
CS		 1131 ret = -EINVAL;
1132 if (WARN_ON(align_offset + template[i].ilen > PAGE_SIZE))
1133 goto out;
da7f033d 1134
a1aa44a2
CS		 1135 data = xbuf[0];
1136 data += align_offset;
1137 memcpy(data, template[i].input, template[i].ilen);
1138
12773d93 1139 crypto_skcipher_clear_flags(tfm, ~0);
a1aa44a2 1140 if (template[i].wk)
12773d93
HX		 1141 crypto_skcipher_set_flags(tfm,
1142 CRYPTO_TFM_REQ_WEAK_KEY);
da7f033d 1143
12773d93
HX		 1144 ret = crypto_skcipher_setkey(tfm, template[i].key,
1145 template[i].klen);
0fae0c1e 1146 if (template[i].fail == !ret) {
a1aa44a2 1147 pr_err("alg: skcipher%s: setkey failed on test %d for %s: flags=%x\n",
12773d93 1148 d, j, algo, crypto_skcipher_get_flags(tfm));
a1aa44a2
CS		 1149 goto out;
1150 } else if (ret)
1151 continue;
1152
1153 sg_init_one(&sg[0], data, template[i].ilen);
1154 if (diff_dst) {
1155 data = xoutbuf[0];
1156 data += align_offset;
1157 sg_init_one(&sgout[0], data, template[i].ilen);
1158 }
da7f033d 1159
12773d93
HX		 1160 skcipher_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
1161 template[i].ilen, iv);
1162 ret = enc ? crypto_skcipher_encrypt(req) :
1163 crypto_skcipher_decrypt(req);
a1aa44a2
CS		 1164
1165 switch (ret) {
1166 case 0:
1167 break;
1168 case -EINPROGRESS:
1169 case -EBUSY:
8a45ac12
RV		 1170 wait_for_completion(&result.completion);
1171 reinit_completion(&result.completion);
1172 ret = result.err;
1173 if (!ret)
da7f033d 1174 break;
a1aa44a2
CS		 1175 /* fall through */
1176 default:
1177 pr_err("alg: skcipher%s: %s failed on test %d for %s: ret=%d\n",
1178 d, e, j, algo, -ret);
1179 goto out;
1180 }
da7f033d 1181
a1aa44a2
CS		 1182 q = data;
1183 if (memcmp(q, template[i].result, template[i].rlen)) {
8a826a34 1184 pr_err("alg: skcipher%s: Test %d failed (invalid result) on %s for %s\n",
a1aa44a2
CS		 1185 d, j, e, algo);
1186 hexdump(q, template[i].rlen);
1187 ret = -EINVAL;
1188 goto out;
da7f033d 1189 }
8a826a34
BB		 1190
1191 if (template[i].iv_out &&
1192 memcmp(iv, template[i].iv_out,
1193 crypto_skcipher_ivsize(tfm))) {
1194 pr_err("alg: skcipher%s: Test %d failed (invalid output IV) on %s for %s\n",
1195 d, j, e, algo);
1196 hexdump(iv, crypto_skcipher_ivsize(tfm));
1197 ret = -EINVAL;
1198 goto out;
1199 }
da7f033d
HX		 1200 }
1201
1202 j = 0;
1203 for (i = 0; i < tcount; i++) {
3a338f20
JK		 1204 /* alignment tests are only done with continuous buffers */
1205 if (align_offset != 0)
1206 break;
da7f033d 1207
bbb9a7dd
CS		 1208 if (!template[i].np)
1209 continue;
1210
10faa8c0
SM		 1211 if (fips_enabled && template[i].fips_skip)
1212 continue;
1213
da7f033d 1214 if (template[i].iv)
84cba178 1215 memcpy(iv, template[i].iv, ivsize);
da7f033d
HX		 1216 else
1217 memset(iv, 0, MAX_IVLEN);
1218
a1aa44a2 1219 j++;
12773d93 1220 crypto_skcipher_clear_flags(tfm, ~0);
a1aa44a2 1221 if (template[i].wk)
12773d93
HX		 1222 crypto_skcipher_set_flags(tfm,
1223 CRYPTO_TFM_REQ_WEAK_KEY);
da7f033d 1224
12773d93
HX		 1225 ret = crypto_skcipher_setkey(tfm, template[i].key,
1226 template[i].klen);
0fae0c1e 1227 if (template[i].fail == !ret) {
a1aa44a2 1228 pr_err("alg: skcipher%s: setkey failed on chunk test %d for %s: flags=%x\n",
12773d93 1229 d, j, algo, crypto_skcipher_get_flags(tfm));
a1aa44a2
CS		 1230 goto out;
1231 } else if (ret)
1232 continue;
da7f033d 1233
a1aa44a2
CS		 1234 temp = 0;
1235 ret = -EINVAL;
1236 sg_init_table(sg, template[i].np);
1237 if (diff_dst)
1238 sg_init_table(sgout, template[i].np);
1239 for (k = 0; k < template[i].np; k++) {
1240 if (WARN_ON(offset_in_page(IDX[k]) +
1241 template[i].tap[k] > PAGE_SIZE))
da7f033d 1242 goto out;
da7f033d 1243
a1aa44a2 1244 q = xbuf[IDX[k] >> PAGE_SHIFT] + offset_in_page(IDX[k]);
da7f033d 1245
a1aa44a2
CS		 1246 memcpy(q, template[i].input + temp, template[i].tap[k]);
1247
1248 if (offset_in_page(q) + template[i].tap[k] < PAGE_SIZE)
1249 q[template[i].tap[k]] = 0;
1250
1251 sg_set_buf(&sg[k], q, template[i].tap[k]);
1252 if (diff_dst) {
1253 q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
da7f033d
HX		 1254 offset_in_page(IDX[k]);
1255
a1aa44a2 1256 sg_set_buf(&sgout[k], q, template[i].tap[k]);
da7f033d 1257
a1aa44a2
CS		 1258 memset(q, 0, template[i].tap[k]);
1259 if (offset_in_page(q) +
1260 template[i].tap[k] < PAGE_SIZE)
da7f033d 1261 q[template[i].tap[k]] = 0;
a1aa44a2 1262 }
da7f033d 1263
a1aa44a2
CS		 1264 temp += template[i].tap[k];
1265 }
08d6af8c 1266
12773d93
HX		 1267 skcipher_request_set_crypt(req, sg, (diff_dst) ? sgout : sg,
1268 template[i].ilen, iv);
08d6af8c 1269
12773d93
HX		 1270 ret = enc ? crypto_skcipher_encrypt(req) :
1271 crypto_skcipher_decrypt(req);
da7f033d 1272
a1aa44a2
CS		 1273 switch (ret) {
1274 case 0:
1275 break;
1276 case -EINPROGRESS:
1277 case -EBUSY:
8a45ac12
RV		 1278 wait_for_completion(&result.completion);
1279 reinit_completion(&result.completion);
1280 ret = result.err;
1281 if (!ret)
a1aa44a2 1282 break;
a1aa44a2
CS		 1283 /* fall through */
1284 default:
1285 pr_err("alg: skcipher%s: %s failed on chunk test %d for %s: ret=%d\n",
1286 d, e, j, algo, -ret);
1287 goto out;
1288 }
da7f033d 1289
a1aa44a2
CS		 1290 temp = 0;
1291 ret = -EINVAL;
1292 for (k = 0; k < template[i].np; k++) {
1293 if (diff_dst)
1294 q = xoutbuf[IDX[k] >> PAGE_SHIFT] +
1295 offset_in_page(IDX[k]);
1296 else
1297 q = xbuf[IDX[k] >> PAGE_SHIFT] +
1298 offset_in_page(IDX[k]);
da7f033d 1299
a1aa44a2
CS		 1300 if (memcmp(q, template[i].result + temp,
1301 template[i].tap[k])) {
1302 pr_err("alg: skcipher%s: Chunk test %d failed on %s at page %u for %s\n",
1303 d, j, e, k, algo);
1304 hexdump(q, template[i].tap[k]);
da7f033d
HX		 1305 goto out;
1306 }
1307
a1aa44a2
CS		 1308 q += template[i].tap[k];
1309 for (n = 0; offset_in_page(q + n) && q[n]; n++)
1310 ;
1311 if (n) {
1312 pr_err("alg: skcipher%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n",
1313 d, j, e, k, algo, n);
1314 hexdump(q, n);
1315 goto out;
da7f033d 1316 }
a1aa44a2 1317 temp += template[i].tap[k];
da7f033d
HX		 1318 }
1319 }
1320
1321 ret = 0;
1322
1323out:
12773d93 1324 skcipher_request_free(req);
08d6af8c
JK		 1325 if (diff_dst)
1326 testmgr_free_buf(xoutbuf);
1327out_nooutbuf:
f8b0d4d0
HX		 1328 testmgr_free_buf(xbuf);
1329out_nobuf:
da7f033d
HX		 1330 return ret;
1331}
1332
12773d93 1333static int test_skcipher(struct crypto_skcipher *tfm, int enc,
08d6af8c
JK		 1334 struct cipher_testvec *template, unsigned int tcount)
1335{
3a338f20 1336 unsigned int alignmask;
08d6af8c
JK		 1337 int ret;
1338
1339 /* test 'dst == src' case */
3a338f20 1340 ret = __test_skcipher(tfm, enc, template, tcount, false, 0);
08d6af8c
JK		 1341 if (ret)
1342 return ret;
1343
1344 /* test 'dst != src' case */
3a338f20
JK		 1345 ret = __test_skcipher(tfm, enc, template, tcount, true, 0);
1346 if (ret)
1347 return ret;
1348
1349 /* test unaligned buffers, check with one byte offset */
1350 ret = __test_skcipher(tfm, enc, template, tcount, true, 1);
1351 if (ret)
1352 return ret;
1353
1354 alignmask = crypto_tfm_alg_alignmask(&tfm->base);
1355 if (alignmask) {
1356 /* Check if alignment mask for tfm is correctly set. */
1357 ret = __test_skcipher(tfm, enc, template, tcount, true,
1358 alignmask + 1);
1359 if (ret)
1360 return ret;
1361 }
1362
1363 return 0;
08d6af8c
JK		 1364}
1365
da7f033d
HX		 1366static int test_comp(struct crypto_comp *tfm, struct comp_testvec *ctemplate,
1367 struct comp_testvec *dtemplate, int ctcount, int dtcount)
1368{
1369 const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm));
1370 unsigned int i;
1371 char result[COMP_BUF_SIZE];
1372 int ret;
1373
1374 for (i = 0; i < ctcount; i++) {
c79cf910
GU		 1375 int ilen;
1376 unsigned int dlen = COMP_BUF_SIZE;
da7f033d
HX		 1377
1378 memset(result, 0, sizeof (result));
1379
1380 ilen = ctemplate[i].inlen;
1381 ret = crypto_comp_compress(tfm, ctemplate[i].input,
1382 ilen, result, &dlen);
1383 if (ret) {
1384 printk(KERN_ERR "alg: comp: compression failed "
1385 "on test %d for %s: ret=%d\n", i + 1, algo,
1386 -ret);
1387 goto out;
1388 }
1389
b812eb00
GU		 1390 if (dlen != ctemplate[i].outlen) {
1391 printk(KERN_ERR "alg: comp: Compression test %d "
1392 "failed for %s: output len = %d\n", i + 1, algo,
1393 dlen);
1394 ret = -EINVAL;
1395 goto out;
1396 }
1397
da7f033d
HX		 1398 if (memcmp(result, ctemplate[i].output, dlen)) {
1399 printk(KERN_ERR "alg: comp: Compression test %d "
1400 "failed for %s\n", i + 1, algo);
1401 hexdump(result, dlen);
1402 ret = -EINVAL;
1403 goto out;
1404 }
1405 }
1406
1407 for (i = 0; i < dtcount; i++) {
c79cf910
GU		 1408 int ilen;
1409 unsigned int dlen = COMP_BUF_SIZE;
da7f033d
HX		 1410
1411 memset(result, 0, sizeof (result));
1412
1413 ilen = dtemplate[i].inlen;
1414 ret = crypto_comp_decompress(tfm, dtemplate[i].input,
1415 ilen, result, &dlen);
1416 if (ret) {
1417 printk(KERN_ERR "alg: comp: decompression failed "
1418 "on test %d for %s: ret=%d\n", i + 1, algo,
1419 -ret);
1420 goto out;
1421 }
1422
b812eb00
GU		 1423 if (dlen != dtemplate[i].outlen) {
1424 printk(KERN_ERR "alg: comp: Decompression test %d "
1425 "failed for %s: output len = %d\n", i + 1, algo,
1426 dlen);
1427 ret = -EINVAL;
1428 goto out;
1429 }
1430
da7f033d
HX		 1431 if (memcmp(result, dtemplate[i].output, dlen)) {
1432 printk(KERN_ERR "alg: comp: Decompression test %d "
1433 "failed for %s\n", i + 1, algo);
1434 hexdump(result, dlen);
1435 ret = -EINVAL;
1436 goto out;
1437 }
1438 }
1439
1440 ret = 0;
1441
1442out:
1443 return ret;
1444}
1445
d7db7a88
GC		 1446static int test_acomp(struct crypto_acomp *tfm, struct comp_testvec *ctemplate,
1447 struct comp_testvec *dtemplate, int ctcount, int dtcount)
1448{
1449 const char *algo = crypto_tfm_alg_driver_name(crypto_acomp_tfm(tfm));
1450 unsigned int i;
eb095593 1451 char *output;
d7db7a88
GC		 1452 int ret;
1453 struct scatterlist src, dst;
1454 struct acomp_req *req;
1455 struct tcrypt_result result;
1456
eb095593
EB		 1457 output = kmalloc(COMP_BUF_SIZE, GFP_KERNEL);
1458 if (!output)
1459 return -ENOMEM;
1460
d7db7a88
GC		 1461 for (i = 0; i < ctcount; i++) {
1462 unsigned int dlen = COMP_BUF_SIZE;
1463 int ilen = ctemplate[i].inlen;
02608e02 1464 void *input_vec;
d7db7a88 1465
d2110224 1466 input_vec = kmemdup(ctemplate[i].input, ilen, GFP_KERNEL);
02608e02
LA		 1467 if (!input_vec) {
1468 ret = -ENOMEM;
1469 goto out;
1470 }
1471
eb095593 1472 memset(output, 0, dlen);
d7db7a88 1473 init_completion(&result.completion);
02608e02 1474 sg_init_one(&src, input_vec, ilen);
d7db7a88
GC		 1475 sg_init_one(&dst, output, dlen);
1476
1477 req = acomp_request_alloc(tfm);
1478 if (!req) {
1479 pr_err("alg: acomp: request alloc failed for %s\n",
1480 algo);
02608e02 1481 kfree(input_vec);
d7db7a88
GC		 1482 ret = -ENOMEM;
1483 goto out;
1484 }
1485
1486 acomp_request_set_params(req, &src, &dst, ilen, dlen);
1487 acomp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
1488 tcrypt_complete, &result);
1489
1490 ret = wait_async_op(&result, crypto_acomp_compress(req));
1491 if (ret) {
1492 pr_err("alg: acomp: compression failed on test %d for %s: ret=%d\n",
1493 i + 1, algo, -ret);
02608e02 1494 kfree(input_vec);
d7db7a88
GC		 1495 acomp_request_free(req);
1496 goto out;
1497 }
1498
1499 if (req->dlen != ctemplate[i].outlen) {
1500 pr_err("alg: acomp: Compression test %d failed for %s: output len = %d\n",
1501 i + 1, algo, req->dlen);
1502 ret = -EINVAL;
02608e02 1503 kfree(input_vec);
d7db7a88
GC		 1504 acomp_request_free(req);
1505 goto out;
1506 }
1507
1508 if (memcmp(output, ctemplate[i].output, req->dlen)) {
1509 pr_err("alg: acomp: Compression test %d failed for %s\n",
1510 i + 1, algo);
1511 hexdump(output, req->dlen);
1512 ret = -EINVAL;
02608e02 1513 kfree(input_vec);
d7db7a88
GC		 1514 acomp_request_free(req);
1515 goto out;
1516 }
1517
02608e02 1518 kfree(input_vec);
d7db7a88
GC		 1519 acomp_request_free(req);
1520 }
1521
1522 for (i = 0; i < dtcount; i++) {
1523 unsigned int dlen = COMP_BUF_SIZE;
1524 int ilen = dtemplate[i].inlen;
02608e02
LA		 1525 void *input_vec;
1526
d2110224 1527 input_vec = kmemdup(dtemplate[i].input, ilen, GFP_KERNEL);
02608e02
LA		 1528 if (!input_vec) {
1529 ret = -ENOMEM;
1530 goto out;
1531 }
d7db7a88 1532
eb095593 1533 memset(output, 0, dlen);
d7db7a88 1534 init_completion(&result.completion);
02608e02 1535 sg_init_one(&src, input_vec, ilen);
d7db7a88
GC		 1536 sg_init_one(&dst, output, dlen);
1537
1538 req = acomp_request_alloc(tfm);
1539 if (!req) {
1540 pr_err("alg: acomp: request alloc failed for %s\n",
1541 algo);
02608e02 1542 kfree(input_vec);
d7db7a88
GC		 1543 ret = -ENOMEM;
1544 goto out;
1545 }
1546
1547 acomp_request_set_params(req, &src, &dst, ilen, dlen);
1548 acomp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
1549 tcrypt_complete, &result);
1550
1551 ret = wait_async_op(&result, crypto_acomp_decompress(req));
1552 if (ret) {
1553 pr_err("alg: acomp: decompression failed on test %d for %s: ret=%d\n",
1554 i + 1, algo, -ret);
02608e02 1555 kfree(input_vec);
d7db7a88
GC		 1556 acomp_request_free(req);
1557 goto out;
1558 }
1559
1560 if (req->dlen != dtemplate[i].outlen) {
1561 pr_err("alg: acomp: Decompression test %d failed for %s: output len = %d\n",
1562 i + 1, algo, req->dlen);
1563 ret = -EINVAL;
02608e02 1564 kfree(input_vec);
d7db7a88
GC		 1565 acomp_request_free(req);
1566 goto out;
1567 }
1568
1569 if (memcmp(output, dtemplate[i].output, req->dlen)) {
1570 pr_err("alg: acomp: Decompression test %d failed for %s\n",
1571 i + 1, algo);
1572 hexdump(output, req->dlen);
1573 ret = -EINVAL;
02608e02 1574 kfree(input_vec);
d7db7a88
GC		 1575 acomp_request_free(req);
1576 goto out;
1577 }
1578
02608e02 1579 kfree(input_vec);
d7db7a88
GC		 1580 acomp_request_free(req);
1581 }
1582
1583 ret = 0;
1584
1585out:
eb095593 1586 kfree(output);
d7db7a88
GC		 1587 return ret;
1588}
1589
7647d6ce
JW		 1590static int test_cprng(struct crypto_rng *tfm, struct cprng_testvec *template,
1591 unsigned int tcount)
1592{
1593 const char *algo = crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm));
fa4ef8a6 1594 int err = 0, i, j, seedsize;
7647d6ce
JW		 1595 u8 *seed;
1596 char result[32];
1597
1598 seedsize = crypto_rng_seedsize(tfm);
1599
1600 seed = kmalloc(seedsize, GFP_KERNEL);
1601 if (!seed) {
1602 printk(KERN_ERR "alg: cprng: Failed to allocate seed space "
1603 "for %s\n", algo);
1604 return -ENOMEM;
1605 }
1606
1607 for (i = 0; i < tcount; i++) {
1608 memset(result, 0, 32);
1609
1610 memcpy(seed, template[i].v, template[i].vlen);
1611 memcpy(seed + template[i].vlen, template[i].key,
1612 template[i].klen);
1613 memcpy(seed + template[i].vlen + template[i].klen,
1614 template[i].dt, template[i].dtlen);
1615
1616 err = crypto_rng_reset(tfm, seed, seedsize);
1617 if (err) {
1618 printk(KERN_ERR "alg: cprng: Failed to reset rng "
1619 "for %s\n", algo);
1620 goto out;
1621 }
1622
1623 for (j = 0; j < template[i].loops; j++) {
1624 err = crypto_rng_get_bytes(tfm, result,
1625 template[i].rlen);
19e60e13 1626 if (err < 0) {
7647d6ce
JW		 1627 printk(KERN_ERR "alg: cprng: Failed to obtain "
1628 "the correct amount of random data for "
19e60e13
SM		 1629 "%s (requested %d)\n", algo,
1630 template[i].rlen);
7647d6ce
JW		 1631 goto out;
1632 }
1633 }
1634
1635 err = memcmp(result, template[i].result,
1636 template[i].rlen);
1637 if (err) {
1638 printk(KERN_ERR "alg: cprng: Test %d failed for %s\n",
1639 i, algo);
1640 hexdump(result, template[i].rlen);
1641 err = -EINVAL;
1642 goto out;
1643 }
1644 }
1645
1646out:
1647 kfree(seed);
1648 return err;
1649}
1650
da7f033d
HX		 1651static int alg_test_aead(const struct alg_test_desc *desc, const char *driver,
1652 u32 type, u32 mask)
1653{
1654 struct crypto_aead *tfm;
1655 int err = 0;
1656
eed93e0c 1657 tfm = crypto_alloc_aead(driver, type, mask);
da7f033d
HX		 1658 if (IS_ERR(tfm)) {
1659 printk(KERN_ERR "alg: aead: Failed to load transform for %s: "
1660 "%ld\n", driver, PTR_ERR(tfm));
1661 return PTR_ERR(tfm);
1662 }
1663
1664 if (desc->suite.aead.enc.vecs) {
1665 err = test_aead(tfm, ENCRYPT, desc->suite.aead.enc.vecs,
1666 desc->suite.aead.enc.count);
1667 if (err)
1668 goto out;
1669 }
1670
1671 if (!err && desc->suite.aead.dec.vecs)
1672 err = test_aead(tfm, DECRYPT, desc->suite.aead.dec.vecs,
1673 desc->suite.aead.dec.count);
1674
1675out:
1676 crypto_free_aead(tfm);
1677 return err;
1678}
1679
1680static int alg_test_cipher(const struct alg_test_desc *desc,
1681 const char *driver, u32 type, u32 mask)
1682{
1aa4ecd9 1683 struct crypto_cipher *tfm;
da7f033d
HX		 1684 int err = 0;
1685
eed93e0c 1686 tfm = crypto_alloc_cipher(driver, type, mask);
da7f033d
HX		 1687 if (IS_ERR(tfm)) {
1688 printk(KERN_ERR "alg: cipher: Failed to load transform for "
1689 "%s: %ld\n", driver, PTR_ERR(tfm));
1690 return PTR_ERR(tfm);
1691 }
1692
1693 if (desc->suite.cipher.enc.vecs) {
1694 err = test_cipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
1695 desc->suite.cipher.enc.count);
1696 if (err)
1697 goto out;
1698 }
1699
1700 if (desc->suite.cipher.dec.vecs)
1701 err = test_cipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
1702 desc->suite.cipher.dec.count);
1703
1aa4ecd9
HX		 1704out:
1705 crypto_free_cipher(tfm);
1706 return err;
1707}
1708
1709static int alg_test_skcipher(const struct alg_test_desc *desc,
1710 const char *driver, u32 type, u32 mask)
1711{
12773d93 1712 struct crypto_skcipher *tfm;
1aa4ecd9
HX		 1713 int err = 0;
1714
eed93e0c 1715 tfm = crypto_alloc_skcipher(driver, type, mask);
1aa4ecd9
HX		 1716 if (IS_ERR(tfm)) {
1717 printk(KERN_ERR "alg: skcipher: Failed to load transform for "
1718 "%s: %ld\n", driver, PTR_ERR(tfm));
1719 return PTR_ERR(tfm);
1720 }
1721
1722 if (desc->suite.cipher.enc.vecs) {
1723 err = test_skcipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
1724 desc->suite.cipher.enc.count);
1725 if (err)
1726 goto out;
1727 }
1728
1729 if (desc->suite.cipher.dec.vecs)
1730 err = test_skcipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
1731 desc->suite.cipher.dec.count);
1732
da7f033d 1733out:
12773d93 1734 crypto_free_skcipher(tfm);
da7f033d
HX		 1735 return err;
1736}
1737
1738static int alg_test_comp(const struct alg_test_desc *desc, const char *driver,
1739 u32 type, u32 mask)
1740{
d7db7a88
GC		 1741 struct crypto_comp *comp;
1742 struct crypto_acomp *acomp;
da7f033d 1743 int err;
d7db7a88
GC		 1744 u32 algo_type = type & CRYPTO_ALG_TYPE_ACOMPRESS_MASK;
1745
1746 if (algo_type == CRYPTO_ALG_TYPE_ACOMPRESS) {
1747 acomp = crypto_alloc_acomp(driver, type, mask);
1748 if (IS_ERR(acomp)) {
1749 pr_err("alg: acomp: Failed to load transform for %s: %ld\n",
1750 driver, PTR_ERR(acomp));
1751 return PTR_ERR(acomp);
1752 }
1753 err = test_acomp(acomp, desc->suite.comp.comp.vecs,
1754 desc->suite.comp.decomp.vecs,
1755 desc->suite.comp.comp.count,
1756 desc->suite.comp.decomp.count);
1757 crypto_free_acomp(acomp);
1758 } else {
1759 comp = crypto_alloc_comp(driver, type, mask);
1760 if (IS_ERR(comp)) {
1761 pr_err("alg: comp: Failed to load transform for %s: %ld\n",
1762 driver, PTR_ERR(comp));
1763 return PTR_ERR(comp);
1764 }
da7f033d 1765
d7db7a88
GC		 1766 err = test_comp(comp, desc->suite.comp.comp.vecs,
1767 desc->suite.comp.decomp.vecs,
1768 desc->suite.comp.comp.count,
1769 desc->suite.comp.decomp.count);
da7f033d 1770
d7db7a88
GC		 1771 crypto_free_comp(comp);
1772 }
da7f033d
HX		 1773 return err;
1774}
1775
1776static int alg_test_hash(const struct alg_test_desc *desc, const char *driver,
1777 u32 type, u32 mask)
1778{
1779 struct crypto_ahash *tfm;
1780 int err;
1781
eed93e0c 1782 tfm = crypto_alloc_ahash(driver, type, mask);
da7f033d
HX		 1783 if (IS_ERR(tfm)) {
1784 printk(KERN_ERR "alg: hash: Failed to load transform for %s: "
1785 "%ld\n", driver, PTR_ERR(tfm));
1786 return PTR_ERR(tfm);
1787 }
1788
a8f1a052
DM		 1789 err = test_hash(tfm, desc->suite.hash.vecs,
1790 desc->suite.hash.count, true);
1791 if (!err)
1792 err = test_hash(tfm, desc->suite.hash.vecs,
1793 desc->suite.hash.count, false);
da7f033d
HX		 1794
1795 crypto_free_ahash(tfm);
1796 return err;
1797}
1798
8e3ee85e
HX		 1799static int alg_test_crc32c(const struct alg_test_desc *desc,
1800 const char *driver, u32 type, u32 mask)
1801{
1802 struct crypto_shash *tfm;
1803 u32 val;
1804 int err;
1805
1806 err = alg_test_hash(desc, driver, type, mask);
1807 if (err)
1808 goto out;
1809
eed93e0c 1810 tfm = crypto_alloc_shash(driver, type, mask);
8e3ee85e
HX		 1811 if (IS_ERR(tfm)) {
1812 printk(KERN_ERR "alg: crc32c: Failed to load transform for %s: "
1813 "%ld\n", driver, PTR_ERR(tfm));
1814 err = PTR_ERR(tfm);
1815 goto out;
1816 }
1817
1818 do {
4c5c3024
JSM		 1819 SHASH_DESC_ON_STACK(shash, tfm);
1820 u32 *ctx = (u32 *)shash_desc_ctx(shash);
8e3ee85e 1821
4c5c3024
JSM		 1822 shash->tfm = tfm;
1823 shash->flags = 0;
8e3ee85e 1824
4c5c3024
JSM		 1825 *ctx = le32_to_cpu(420553207);
1826 err = crypto_shash_final(shash, (u8 *)&val);
8e3ee85e
HX		 1827 if (err) {
1828 printk(KERN_ERR "alg: crc32c: Operation failed for "
1829 "%s: %d\n", driver, err);
1830 break;
1831 }
1832
1833 if (val != ~420553207) {
1834 printk(KERN_ERR "alg: crc32c: Test failed for %s: "
1835 "%d\n", driver, val);
1836 err = -EINVAL;
1837 }
1838 } while (0);
1839
1840 crypto_free_shash(tfm);
1841
1842out:
1843 return err;
1844}
1845
7647d6ce
JW		 1846static int alg_test_cprng(const struct alg_test_desc *desc, const char *driver,
1847 u32 type, u32 mask)
1848{
1849 struct crypto_rng *rng;
1850 int err;
1851
eed93e0c 1852 rng = crypto_alloc_rng(driver, type, mask);
7647d6ce
JW		 1853 if (IS_ERR(rng)) {
1854 printk(KERN_ERR "alg: cprng: Failed to load transform for %s: "
1855 "%ld\n", driver, PTR_ERR(rng));
1856 return PTR_ERR(rng);
1857 }
1858
1859 err = test_cprng(rng, desc->suite.cprng.vecs, desc->suite.cprng.count);
1860
1861 crypto_free_rng(rng);
1862
1863 return err;
1864}
1865
64d1cdfb
SM		 1866
1867static int drbg_cavs_test(struct drbg_testvec *test, int pr,
1868 const char *driver, u32 type, u32 mask)
1869{
1870 int ret = -EAGAIN;
1871 struct crypto_rng *drng;
1872 struct drbg_test_data test_data;
1873 struct drbg_string addtl, pers, testentropy;
1874 unsigned char *buf = kzalloc(test->expectedlen, GFP_KERNEL);
1875
1876 if (!buf)
1877 return -ENOMEM;
1878
eed93e0c 1879 drng = crypto_alloc_rng(driver, type, mask);
64d1cdfb 1880 if (IS_ERR(drng)) {
2fc0d258 1881 printk(KERN_ERR "alg: drbg: could not allocate DRNG handle for "
64d1cdfb
SM		 1882 "%s\n", driver);
1883 kzfree(buf);
1884 return -ENOMEM;
1885 }
1886
1887 test_data.testentropy = &testentropy;
1888 drbg_string_fill(&testentropy, test->entropy, test->entropylen);
1889 drbg_string_fill(&pers, test->pers, test->perslen);
1890 ret = crypto_drbg_reset_test(drng, &pers, &test_data);
1891 if (ret) {
1892 printk(KERN_ERR "alg: drbg: Failed to reset rng\n");
1893 goto outbuf;
1894 }
1895
1896 drbg_string_fill(&addtl, test->addtla, test->addtllen);
1897 if (pr) {
1898 drbg_string_fill(&testentropy, test->entpra, test->entprlen);
1899 ret = crypto_drbg_get_bytes_addtl_test(drng,
1900 buf, test->expectedlen, &addtl, &test_data);
1901 } else {
1902 ret = crypto_drbg_get_bytes_addtl(drng,
1903 buf, test->expectedlen, &addtl);
1904 }
19e60e13 1905 if (ret < 0) {
2fc0d258 1906 printk(KERN_ERR "alg: drbg: could not obtain random data for "
64d1cdfb
SM		 1907 "driver %s\n", driver);
1908 goto outbuf;
1909 }
1910
1911 drbg_string_fill(&addtl, test->addtlb, test->addtllen);
1912 if (pr) {
1913 drbg_string_fill(&testentropy, test->entprb, test->entprlen);
1914 ret = crypto_drbg_get_bytes_addtl_test(drng,
1915 buf, test->expectedlen, &addtl, &test_data);
1916 } else {
1917 ret = crypto_drbg_get_bytes_addtl(drng,
1918 buf, test->expectedlen, &addtl);
1919 }
19e60e13 1920 if (ret < 0) {
2fc0d258 1921 printk(KERN_ERR "alg: drbg: could not obtain random data for "
64d1cdfb
SM		 1922 "driver %s\n", driver);
1923 goto outbuf;
1924 }
1925
1926 ret = memcmp(test->expected, buf, test->expectedlen);
1927
1928outbuf:
1929 crypto_free_rng(drng);
1930 kzfree(buf);
1931 return ret;
1932}
1933
1934
1935static int alg_test_drbg(const struct alg_test_desc *desc, const char *driver,
1936 u32 type, u32 mask)
1937{
1938 int err = 0;
1939 int pr = 0;
1940 int i = 0;
1941 struct drbg_testvec *template = desc->suite.drbg.vecs;
1942 unsigned int tcount = desc->suite.drbg.count;
1943
1944 if (0 == memcmp(driver, "drbg_pr_", 8))
1945 pr = 1;
1946
1947 for (i = 0; i < tcount; i++) {
1948 err = drbg_cavs_test(&template[i], pr, driver, type, mask);
1949 if (err) {
1950 printk(KERN_ERR "alg: drbg: Test %d failed for %s\n",
1951 i, driver);
1952 err = -EINVAL;
1953 break;
1954 }
1955 }
1956 return err;
1957
1958}
1959
802c7f1c
SB		 1960static int do_test_kpp(struct crypto_kpp *tfm, struct kpp_testvec *vec,
1961 const char *alg)
1962{
1963 struct kpp_request *req;
1964 void *input_buf = NULL;
1965 void *output_buf = NULL;
1966 struct tcrypt_result result;
1967 unsigned int out_len_max;
1968 int err = -ENOMEM;
1969 struct scatterlist src, dst;
1970
1971 req = kpp_request_alloc(tfm, GFP_KERNEL);
1972 if (!req)
1973 return err;
1974
1975 init_completion(&result.completion);
1976
1977 err = crypto_kpp_set_secret(tfm, vec->secret, vec->secret_size);
1978 if (err < 0)
1979 goto free_req;
1980
1981 out_len_max = crypto_kpp_maxsize(tfm);
1982 output_buf = kzalloc(out_len_max, GFP_KERNEL);
1983 if (!output_buf) {
1984 err = -ENOMEM;
1985 goto free_req;
1986 }
1987
1988 /* Use appropriate parameter as base */
1989 kpp_request_set_input(req, NULL, 0);
1990 sg_init_one(&dst, output_buf, out_len_max);
1991 kpp_request_set_output(req, &dst, out_len_max);
1992 kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
1993 tcrypt_complete, &result);
1994
1995 /* Compute public key */
1996 err = wait_async_op(&result, crypto_kpp_generate_public_key(req));
1997 if (err) {
1998 pr_err("alg: %s: generate public key test failed. err %d\n",
1999 alg, err);
2000 goto free_output;
2001 }
2002 /* Verify calculated public key */
2003 if (memcmp(vec->expected_a_public, sg_virt(req->dst),
2004 vec->expected_a_public_size)) {
2005 pr_err("alg: %s: generate public key test failed. Invalid output\n",
2006 alg);
2007 err = -EINVAL;
2008 goto free_output;
2009 }
2010
2011 /* Calculate shared secret key by using counter part (b) public key. */
2012 input_buf = kzalloc(vec->b_public_size, GFP_KERNEL);
2013 if (!input_buf) {
2014 err = -ENOMEM;
2015 goto free_output;
2016 }
2017
2018 memcpy(input_buf, vec->b_public, vec->b_public_size);
2019 sg_init_one(&src, input_buf, vec->b_public_size);
2020 sg_init_one(&dst, output_buf, out_len_max);
2021 kpp_request_set_input(req, &src, vec->b_public_size);
2022 kpp_request_set_output(req, &dst, out_len_max);
2023 kpp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
2024 tcrypt_complete, &result);
2025 err = wait_async_op(&result, crypto_kpp_compute_shared_secret(req));
2026 if (err) {
2027 pr_err("alg: %s: compute shard secret test failed. err %d\n",
2028 alg, err);
2029 goto free_all;
2030 }
2031 /*
2032 * verify shared secret from which the user will derive
2033 * secret key by executing whatever hash it has chosen
2034 */
2035 if (memcmp(vec->expected_ss, sg_virt(req->dst),
2036 vec->expected_ss_size)) {
2037 pr_err("alg: %s: compute shared secret test failed. Invalid output\n",
2038 alg);
2039 err = -EINVAL;
2040 }
2041
2042free_all:
2043 kfree(input_buf);
2044free_output:
2045 kfree(output_buf);
2046free_req:
2047 kpp_request_free(req);
2048 return err;
2049}
2050
2051static int test_kpp(struct crypto_kpp *tfm, const char *alg,
2052 struct kpp_testvec *vecs, unsigned int tcount)
2053{
2054 int ret, i;
2055
2056 for (i = 0; i < tcount; i++) {
2057 ret = do_test_kpp(tfm, vecs++, alg);
2058 if (ret) {
2059 pr_err("alg: %s: test failed on vector %d, err=%d\n",
2060 alg, i + 1, ret);
2061 return ret;
2062 }
2063 }
2064 return 0;
2065}
2066
2067static int alg_test_kpp(const struct alg_test_desc *desc, const char *driver,
2068 u32 type, u32 mask)
2069{
2070 struct crypto_kpp *tfm;
2071 int err = 0;
2072
eed93e0c 2073 tfm = crypto_alloc_kpp(driver, type, mask);
802c7f1c
SB		 2074 if (IS_ERR(tfm)) {
2075 pr_err("alg: kpp: Failed to load tfm for %s: %ld\n",
2076 driver, PTR_ERR(tfm));
2077 return PTR_ERR(tfm);
2078 }
2079 if (desc->suite.kpp.vecs)
2080 err = test_kpp(tfm, desc->alg, desc->suite.kpp.vecs,
2081 desc->suite.kpp.count);
2082
2083 crypto_free_kpp(tfm);
2084 return err;
2085}
2086
50d2b643
HX		 2087static int test_akcipher_one(struct crypto_akcipher *tfm,
2088 struct akcipher_testvec *vecs)
946cc463 2089{
df27b26f 2090 char *xbuf[XBUFSIZE];
946cc463
TS		 2091 struct akcipher_request *req;
2092 void *outbuf_enc = NULL;
2093 void *outbuf_dec = NULL;
2094 struct tcrypt_result result;
2095 unsigned int out_len_max, out_len = 0;
2096 int err = -ENOMEM;
22287b0b 2097 struct scatterlist src, dst, src_tab[2];
946cc463 2098
df27b26f
HX		 2099 if (testmgr_alloc_buf(xbuf))
2100 return err;
2101
946cc463
TS		 2102 req = akcipher_request_alloc(tfm, GFP_KERNEL);
2103 if (!req)
df27b26f 2104 goto free_xbuf;
946cc463
TS		 2105
2106 init_completion(&result.completion);
946cc463 2107
22287b0b
TS		 2108 if (vecs->public_key_vec)
2109 err = crypto_akcipher_set_pub_key(tfm, vecs->key,
2110 vecs->key_len);
2111 else
2112 err = crypto_akcipher_set_priv_key(tfm, vecs->key,
2113 vecs->key_len);
2114 if (err)
946cc463 2115 goto free_req;
946cc463 2116
57763f5e 2117 err = -ENOMEM;
22287b0b 2118 out_len_max = crypto_akcipher_maxsize(tfm);
946cc463
TS		 2119 outbuf_enc = kzalloc(out_len_max, GFP_KERNEL);
2120 if (!outbuf_enc)
2121 goto free_req;
2122
df27b26f
HX		 2123 if (WARN_ON(vecs->m_size > PAGE_SIZE))
2124 goto free_all;
2125
2126 memcpy(xbuf[0], vecs->m, vecs->m_size);
2127
22287b0b 2128 sg_init_table(src_tab, 2);
df27b26f
HX		 2129 sg_set_buf(&src_tab[0], xbuf[0], 8);
2130 sg_set_buf(&src_tab[1], xbuf[0] + 8, vecs->m_size - 8);
22287b0b
TS		 2131 sg_init_one(&dst, outbuf_enc, out_len_max);
2132 akcipher_request_set_crypt(req, src_tab, &dst, vecs->m_size,
2133 out_len_max);
946cc463
TS		 2134 akcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
2135 tcrypt_complete, &result);
2136
2137 /* Run RSA encrypt - c = m^e mod n;*/
2138 err = wait_async_op(&result, crypto_akcipher_encrypt(req));
2139 if (err) {
50d2b643 2140 pr_err("alg: akcipher: encrypt test failed. err %d\n", err);
946cc463
TS		 2141 goto free_all;
2142 }
22287b0b 2143 if (req->dst_len != vecs->c_size) {
50d2b643 2144 pr_err("alg: akcipher: encrypt test failed. Invalid output len\n");
946cc463
TS		 2145 err = -EINVAL;
2146 goto free_all;
2147 }
2148 /* verify that encrypted message is equal to expected */
df27b26f 2149 if (memcmp(vecs->c, outbuf_enc, vecs->c_size)) {
50d2b643
HX		 2150 pr_err("alg: akcipher: encrypt test failed. Invalid output\n");
2151 hexdump(outbuf_enc, vecs->c_size);
946cc463
TS		 2152 err = -EINVAL;
2153 goto free_all;
2154 }
2155 /* Don't invoke decrypt for vectors with public key */
2156 if (vecs->public_key_vec) {
2157 err = 0;
2158 goto free_all;
2159 }
2160 outbuf_dec = kzalloc(out_len_max, GFP_KERNEL);
2161 if (!outbuf_dec) {
2162 err = -ENOMEM;
2163 goto free_all;
2164 }
df27b26f
HX		 2165
2166 if (WARN_ON(vecs->c_size > PAGE_SIZE))
2167 goto free_all;
2168
2169 memcpy(xbuf[0], vecs->c, vecs->c_size);
2170
2171 sg_init_one(&src, xbuf[0], vecs->c_size);
22287b0b 2172 sg_init_one(&dst, outbuf_dec, out_len_max);
946cc463 2173 init_completion(&result.completion);
22287b0b 2174 akcipher_request_set_crypt(req, &src, &dst, vecs->c_size, out_len_max);
946cc463
TS		 2175
2176 /* Run RSA decrypt - m = c^d mod n;*/
2177 err = wait_async_op(&result, crypto_akcipher_decrypt(req));
2178 if (err) {
50d2b643 2179 pr_err("alg: akcipher: decrypt test failed. err %d\n", err);
946cc463
TS		 2180 goto free_all;
2181 }
2182 out_len = req->dst_len;
50d2b643
HX		 2183 if (out_len < vecs->m_size) {
2184 pr_err("alg: akcipher: decrypt test failed. "
2185 "Invalid output len %u\n", out_len);
946cc463
TS		 2186 err = -EINVAL;
2187 goto free_all;
2188 }
2189 /* verify that decrypted message is equal to the original msg */
50d2b643
HX		 2190 if (memchr_inv(outbuf_dec, 0, out_len - vecs->m_size) ||
2191 memcmp(vecs->m, outbuf_dec + out_len - vecs->m_size,
2192 vecs->m_size)) {
2193 pr_err("alg: akcipher: decrypt test failed. Invalid output\n");
2194 hexdump(outbuf_dec, out_len);
946cc463
TS		 2195 err = -EINVAL;
2196 }
2197free_all:
2198 kfree(outbuf_dec);
2199 kfree(outbuf_enc);
2200free_req:
2201 akcipher_request_free(req);
df27b26f
HX		 2202free_xbuf:
2203 testmgr_free_buf(xbuf);
946cc463
TS		 2204 return err;
2205}
2206
50d2b643
HX		 2207static int test_akcipher(struct crypto_akcipher *tfm, const char *alg,
2208 struct akcipher_testvec *vecs, unsigned int tcount)
946cc463 2209{
15226e48
HX		 2210 const char *algo =
2211 crypto_tfm_alg_driver_name(crypto_akcipher_tfm(tfm));
946cc463
TS		 2212 int ret, i;
2213
2214 for (i = 0; i < tcount; i++) {
50d2b643
HX		 2215 ret = test_akcipher_one(tfm, vecs++);
2216 if (!ret)
2217 continue;
946cc463 2218
15226e48
HX		 2219 pr_err("alg: akcipher: test %d failed for %s, err=%d\n",
2220 i + 1, algo, ret);
50d2b643
HX		 2221 return ret;
2222 }
946cc463
TS		 2223 return 0;
2224}
2225
2226static int alg_test_akcipher(const struct alg_test_desc *desc,
2227 const char *driver, u32 type, u32 mask)
2228{
2229 struct crypto_akcipher *tfm;
2230 int err = 0;
2231
eed93e0c 2232 tfm = crypto_alloc_akcipher(driver, type, mask);
946cc463
TS		 2233 if (IS_ERR(tfm)) {
2234 pr_err("alg: akcipher: Failed to load tfm for %s: %ld\n",
2235 driver, PTR_ERR(tfm));
2236 return PTR_ERR(tfm);
2237 }
2238 if (desc->suite.akcipher.vecs)
2239 err = test_akcipher(tfm, desc->alg, desc->suite.akcipher.vecs,
2240 desc->suite.akcipher.count);
2241
2242 crypto_free_akcipher(tfm);
2243 return err;
2244}
2245
863b557a
YS		 2246static int alg_test_null(const struct alg_test_desc *desc,
2247 const char *driver, u32 type, u32 mask)
2248{
2249 return 0;
2250}
2251
da7f033d
HX		 2252/* Please keep this list sorted by algorithm name. */
2253static const struct alg_test_desc alg_test_descs[] = {
2254 {
e08ca2da
JW		 2255 .alg = "ansi_cprng",
2256 .test = alg_test_cprng,
2257 .suite = {
2258 .cprng = {
2259 .vecs = ansi_cprng_aes_tv_template,
2260 .count = ANSI_CPRNG_AES_TEST_VECTORS
2261 }
2262 }
bca4feb0
HG		 2263 }, {
2264 .alg = "authenc(hmac(md5),ecb(cipher_null))",
2265 .test = alg_test_aead,
bca4feb0
HG		 2266 .suite = {
2267 .aead = {
2268 .enc = {
2269 .vecs = hmac_md5_ecb_cipher_null_enc_tv_template,
2270 .count = HMAC_MD5_ECB_CIPHER_NULL_ENC_TEST_VECTORS
2271 },
2272 .dec = {
2273 .vecs = hmac_md5_ecb_cipher_null_dec_tv_template,
2274 .count = HMAC_MD5_ECB_CIPHER_NULL_DEC_TEST_VECTORS
2275 }
2276 }
2277 }
e46e9a46 2278 }, {
a4198fd4 2279 .alg = "authenc(hmac(sha1),cbc(aes))",
e46e9a46 2280 .test = alg_test_aead,
e46e9a46
HG		 2281 .suite = {
2282 .aead = {
2283 .enc = {
5208ed2c
NL		 2284 .vecs =
2285 hmac_sha1_aes_cbc_enc_tv_temp,
2286 .count =
2287 HMAC_SHA1_AES_CBC_ENC_TEST_VEC
2288 }
2289 }
2290 }
2291 }, {
a4198fd4 2292 .alg = "authenc(hmac(sha1),cbc(des))",
5208ed2c 2293 .test = alg_test_aead,
5208ed2c
NL		 2294 .suite = {
2295 .aead = {
2296 .enc = {
2297 .vecs =
2298 hmac_sha1_des_cbc_enc_tv_temp,
2299 .count =
2300 HMAC_SHA1_DES_CBC_ENC_TEST_VEC
2301 }
2302 }
2303 }
2304 }, {
a4198fd4 2305 .alg = "authenc(hmac(sha1),cbc(des3_ede))",
5208ed2c 2306 .test = alg_test_aead,
ed1afac9 2307 .fips_allowed = 1,
5208ed2c
NL		 2308 .suite = {
2309 .aead = {
2310 .enc = {
2311 .vecs =
2312 hmac_sha1_des3_ede_cbc_enc_tv_temp,
2313 .count =
2314 HMAC_SHA1_DES3_EDE_CBC_ENC_TEST_VEC
e46e9a46
HG		 2315 }
2316 }
2317 }
fb16abc2
MM		 2318 }, {
2319 .alg = "authenc(hmac(sha1),ctr(aes))",
2320 .test = alg_test_null,
2321 .fips_allowed = 1,
bca4feb0
HG		 2322 }, {
2323 .alg = "authenc(hmac(sha1),ecb(cipher_null))",
2324 .test = alg_test_aead,
bca4feb0
HG		 2325 .suite = {
2326 .aead = {
2327 .enc = {
5208ed2c
NL		 2328 .vecs =
2329 hmac_sha1_ecb_cipher_null_enc_tv_temp,
2330 .count =
2331 HMAC_SHA1_ECB_CIPHER_NULL_ENC_TEST_VEC
bca4feb0
HG		 2332 },
2333 .dec = {
5208ed2c
NL		 2334 .vecs =
2335 hmac_sha1_ecb_cipher_null_dec_tv_temp,
2336 .count =
2337 HMAC_SHA1_ECB_CIPHER_NULL_DEC_TEST_VEC
2338 }
2339 }
2340 }
8888690e
MM		 2341 }, {
2342 .alg = "authenc(hmac(sha1),rfc3686(ctr(aes)))",
2343 .test = alg_test_null,
2344 .fips_allowed = 1,
5208ed2c 2345 }, {
a4198fd4 2346 .alg = "authenc(hmac(sha224),cbc(des))",
5208ed2c 2347 .test = alg_test_aead,
5208ed2c
NL		 2348 .suite = {
2349 .aead = {
2350 .enc = {
2351 .vecs =
2352 hmac_sha224_des_cbc_enc_tv_temp,
2353 .count =
2354 HMAC_SHA224_DES_CBC_ENC_TEST_VEC
2355 }
2356 }
2357 }
2358 }, {
a4198fd4 2359 .alg = "authenc(hmac(sha224),cbc(des3_ede))",
5208ed2c 2360 .test = alg_test_aead,
ed1afac9 2361 .fips_allowed = 1,
5208ed2c
NL		 2362 .suite = {
2363 .aead = {
2364 .enc = {
2365 .vecs =
2366 hmac_sha224_des3_ede_cbc_enc_tv_temp,
2367 .count =
2368 HMAC_SHA224_DES3_EDE_CBC_ENC_TEST_VEC
bca4feb0
HG		 2369 }
2370 }
2371 }
e46e9a46 2372 }, {
a4198fd4 2373 .alg = "authenc(hmac(sha256),cbc(aes))",
e46e9a46 2374 .test = alg_test_aead,
ed1afac9 2375 .fips_allowed = 1,
e46e9a46
HG		 2376 .suite = {
2377 .aead = {
2378 .enc = {
5208ed2c
NL		 2379 .vecs =
2380 hmac_sha256_aes_cbc_enc_tv_temp,
2381 .count =
2382 HMAC_SHA256_AES_CBC_ENC_TEST_VEC
2383 }
2384 }
2385 }
2386 }, {
a4198fd4 2387 .alg = "authenc(hmac(sha256),cbc(des))",
5208ed2c 2388 .test = alg_test_aead,
5208ed2c
NL		 2389 .suite = {
2390 .aead = {
2391 .enc = {
2392 .vecs =
2393 hmac_sha256_des_cbc_enc_tv_temp,
2394 .count =
2395 HMAC_SHA256_DES_CBC_ENC_TEST_VEC
2396 }
2397 }
2398 }
2399 }, {
a4198fd4 2400 .alg = "authenc(hmac(sha256),cbc(des3_ede))",
5208ed2c 2401 .test = alg_test_aead,
ed1afac9 2402 .fips_allowed = 1,
5208ed2c
NL		 2403 .suite = {
2404 .aead = {
2405 .enc = {
2406 .vecs =
2407 hmac_sha256_des3_ede_cbc_enc_tv_temp,
2408 .count =
2409 HMAC_SHA256_DES3_EDE_CBC_ENC_TEST_VEC
2410 }
2411 }
2412 }
fb16abc2
MM		 2413 }, {
2414 .alg = "authenc(hmac(sha256),ctr(aes))",
2415 .test = alg_test_null,
2416 .fips_allowed = 1,
8888690e
MM		 2417 }, {
2418 .alg = "authenc(hmac(sha256),rfc3686(ctr(aes)))",
2419 .test = alg_test_null,
2420 .fips_allowed = 1,
5208ed2c 2421 }, {
a4198fd4 2422 .alg = "authenc(hmac(sha384),cbc(des))",
5208ed2c 2423 .test = alg_test_aead,
5208ed2c
NL		 2424 .suite = {
2425 .aead = {
2426 .enc = {
2427 .vecs =
2428 hmac_sha384_des_cbc_enc_tv_temp,
2429 .count =
2430 HMAC_SHA384_DES_CBC_ENC_TEST_VEC
2431 }
2432 }
2433 }
2434 }, {
a4198fd4 2435 .alg = "authenc(hmac(sha384),cbc(des3_ede))",
5208ed2c 2436 .test = alg_test_aead,
ed1afac9 2437 .fips_allowed = 1,
5208ed2c
NL		 2438 .suite = {
2439 .aead = {
2440 .enc = {
2441 .vecs =
2442 hmac_sha384_des3_ede_cbc_enc_tv_temp,
2443 .count =
2444 HMAC_SHA384_DES3_EDE_CBC_ENC_TEST_VEC
e46e9a46
HG		 2445 }
2446 }
2447 }
fb16abc2
MM		 2448 }, {
2449 .alg = "authenc(hmac(sha384),ctr(aes))",
2450 .test = alg_test_null,
2451 .fips_allowed = 1,
8888690e
MM		 2452 }, {
2453 .alg = "authenc(hmac(sha384),rfc3686(ctr(aes)))",
2454 .test = alg_test_null,
2455 .fips_allowed = 1,
e46e9a46 2456 }, {
a4198fd4 2457 .alg = "authenc(hmac(sha512),cbc(aes))",
ed1afac9 2458 .fips_allowed = 1,
e46e9a46 2459 .test = alg_test_aead,
e46e9a46
HG		 2460 .suite = {
2461 .aead = {
2462 .enc = {
5208ed2c
NL		 2463 .vecs =
2464 hmac_sha512_aes_cbc_enc_tv_temp,
2465 .count =
2466 HMAC_SHA512_AES_CBC_ENC_TEST_VEC
2467 }
2468 }
2469 }
2470 }, {
a4198fd4 2471 .alg = "authenc(hmac(sha512),cbc(des))",
5208ed2c 2472 .test = alg_test_aead,
5208ed2c
NL		 2473 .suite = {
2474 .aead = {
2475 .enc = {
2476 .vecs =
2477 hmac_sha512_des_cbc_enc_tv_temp,
2478 .count =
2479 HMAC_SHA512_DES_CBC_ENC_TEST_VEC
2480 }
2481 }
2482 }
2483 }, {
a4198fd4 2484 .alg = "authenc(hmac(sha512),cbc(des3_ede))",
5208ed2c 2485 .test = alg_test_aead,
ed1afac9 2486 .fips_allowed = 1,
5208ed2c
NL		 2487 .suite = {
2488 .aead = {
2489 .enc = {
2490 .vecs =
2491 hmac_sha512_des3_ede_cbc_enc_tv_temp,
2492 .count =
2493 HMAC_SHA512_DES3_EDE_CBC_ENC_TEST_VEC
e46e9a46
HG		 2494 }
2495 }
2496 }
fb16abc2
MM		 2497 }, {
2498 .alg = "authenc(hmac(sha512),ctr(aes))",
2499 .test = alg_test_null,
2500 .fips_allowed = 1,
8888690e
MM		 2501 }, {
2502 .alg = "authenc(hmac(sha512),rfc3686(ctr(aes)))",
2503 .test = alg_test_null,
2504 .fips_allowed = 1,
e08ca2da 2505 }, {
da7f033d 2506 .alg = "cbc(aes)",
1aa4ecd9 2507 .test = alg_test_skcipher,
a1915d51 2508 .fips_allowed = 1,
da7f033d
HX		 2509 .suite = {
2510 .cipher = {
2511 .enc = {
2512 .vecs = aes_cbc_enc_tv_template,
2513 .count = AES_CBC_ENC_TEST_VECTORS
2514 },
2515 .dec = {
2516 .vecs = aes_cbc_dec_tv_template,
2517 .count = AES_CBC_DEC_TEST_VECTORS
2518 }
2519 }
2520 }
2521 }, {
2522 .alg = "cbc(anubis)",
1aa4ecd9 2523 .test = alg_test_skcipher,
da7f033d
HX		 2524 .suite = {
2525 .cipher = {
2526 .enc = {
2527 .vecs = anubis_cbc_enc_tv_template,
2528 .count = ANUBIS_CBC_ENC_TEST_VECTORS
2529 },
2530 .dec = {
2531 .vecs = anubis_cbc_dec_tv_template,
2532 .count = ANUBIS_CBC_DEC_TEST_VECTORS
2533 }
2534 }
2535 }
2536 }, {
2537 .alg = "cbc(blowfish)",
1aa4ecd9 2538 .test = alg_test_skcipher,
da7f033d
HX		 2539 .suite = {
2540 .cipher = {
2541 .enc = {
2542 .vecs = bf_cbc_enc_tv_template,
2543 .count = BF_CBC_ENC_TEST_VECTORS
2544 },
2545 .dec = {
2546 .vecs = bf_cbc_dec_tv_template,
2547 .count = BF_CBC_DEC_TEST_VECTORS
2548 }
2549 }
2550 }
2551 }, {
2552 .alg = "cbc(camellia)",
1aa4ecd9 2553 .test = alg_test_skcipher,
da7f033d
HX		 2554 .suite = {
2555 .cipher = {
2556 .enc = {
2557 .vecs = camellia_cbc_enc_tv_template,
2558 .count = CAMELLIA_CBC_ENC_TEST_VECTORS
2559 },
2560 .dec = {
2561 .vecs = camellia_cbc_dec_tv_template,
2562 .count = CAMELLIA_CBC_DEC_TEST_VECTORS
2563 }
2564 }
2565 }
a2c58260
JG		 2566 }, {
2567 .alg = "cbc(cast5)",
2568 .test = alg_test_skcipher,
2569 .suite = {
2570 .cipher = {
2571 .enc = {
2572 .vecs = cast5_cbc_enc_tv_template,
2573 .count = CAST5_CBC_ENC_TEST_VECTORS
2574 },
2575 .dec = {
2576 .vecs = cast5_cbc_dec_tv_template,
2577 .count = CAST5_CBC_DEC_TEST_VECTORS
2578 }
2579 }
2580 }
9b8b0405
JG		 2581 }, {
2582 .alg = "cbc(cast6)",
2583 .test = alg_test_skcipher,
2584 .suite = {
2585 .cipher = {
2586 .enc = {
2587 .vecs = cast6_cbc_enc_tv_template,
2588 .count = CAST6_CBC_ENC_TEST_VECTORS
2589 },
2590 .dec = {
2591 .vecs = cast6_cbc_dec_tv_template,
2592 .count = CAST6_CBC_DEC_TEST_VECTORS
2593 }
2594 }
2595 }
da7f033d
HX		 2596 }, {
2597 .alg = "cbc(des)",
1aa4ecd9 2598 .test = alg_test_skcipher,
da7f033d
HX		 2599 .suite = {
2600 .cipher = {
2601 .enc = {
2602 .vecs = des_cbc_enc_tv_template,
2603 .count = DES_CBC_ENC_TEST_VECTORS
2604 },
2605 .dec = {
2606 .vecs = des_cbc_dec_tv_template,
2607 .count = DES_CBC_DEC_TEST_VECTORS
2608 }
2609 }
2610 }
2611 }, {
2612 .alg = "cbc(des3_ede)",
1aa4ecd9 2613 .test = alg_test_skcipher,
a1915d51 2614 .fips_allowed = 1,
da7f033d
HX		 2615 .suite = {
2616 .cipher = {
2617 .enc = {
2618 .vecs = des3_ede_cbc_enc_tv_template,
2619 .count = DES3_EDE_CBC_ENC_TEST_VECTORS
2620 },
2621 .dec = {
2622 .vecs = des3_ede_cbc_dec_tv_template,
2623 .count = DES3_EDE_CBC_DEC_TEST_VECTORS
2624 }
2625 }
2626 }
9d25917d
JK		 2627 }, {
2628 .alg = "cbc(serpent)",
2629 .test = alg_test_skcipher,
2630 .suite = {
2631 .cipher = {
2632 .enc = {
2633 .vecs = serpent_cbc_enc_tv_template,
2634 .count = SERPENT_CBC_ENC_TEST_VECTORS
2635 },
2636 .dec = {
2637 .vecs = serpent_cbc_dec_tv_template,
2638 .count = SERPENT_CBC_DEC_TEST_VECTORS
2639 }
2640 }
2641 }
da7f033d
HX		 2642 }, {
2643 .alg = "cbc(twofish)",
1aa4ecd9 2644 .test = alg_test_skcipher,
da7f033d
HX		 2645 .suite = {
2646 .cipher = {
2647 .enc = {
2648 .vecs = tf_cbc_enc_tv_template,
2649 .count = TF_CBC_ENC_TEST_VECTORS
2650 },
2651 .dec = {
2652 .vecs = tf_cbc_dec_tv_template,
2653 .count = TF_CBC_DEC_TEST_VECTORS
2654 }
2655 }
2656 }
2657 }, {
2658 .alg = "ccm(aes)",
2659 .test = alg_test_aead,
a1915d51 2660 .fips_allowed = 1,
da7f033d
HX		 2661 .suite = {
2662 .aead = {
2663 .enc = {
2664 .vecs = aes_ccm_enc_tv_template,
2665 .count = AES_CCM_ENC_TEST_VECTORS
2666 },
2667 .dec = {
2668 .vecs = aes_ccm_dec_tv_template,
2669 .count = AES_CCM_DEC_TEST_VECTORS
2670 }
2671 }
2672 }
3590ebf2
MW		 2673 }, {
2674 .alg = "chacha20",
2675 .test = alg_test_skcipher,
2676 .suite = {
2677 .cipher = {
2678 .enc = {
2679 .vecs = chacha20_enc_tv_template,
2680 .count = CHACHA20_ENC_TEST_VECTORS
2681 },
2682 .dec = {
2683 .vecs = chacha20_enc_tv_template,
2684 .count = CHACHA20_ENC_TEST_VECTORS
2685 },
2686 }
2687 }
93b5e86a
JK		 2688 }, {
2689 .alg = "cmac(aes)",
8f183751 2690 .fips_allowed = 1,
93b5e86a
JK		 2691 .test = alg_test_hash,
2692 .suite = {
2693 .hash = {
2694 .vecs = aes_cmac128_tv_template,
2695 .count = CMAC_AES_TEST_VECTORS
2696 }
2697 }
2698 }, {
2699 .alg = "cmac(des3_ede)",
8f183751 2700 .fips_allowed = 1,
93b5e86a
JK		 2701 .test = alg_test_hash,
2702 .suite = {
2703 .hash = {
2704 .vecs = des3_ede_cmac64_tv_template,
2705 .count = CMAC_DES3_EDE_TEST_VECTORS
2706 }
2707 }
e448370d
JK		 2708 }, {
2709 .alg = "compress_null",
2710 .test = alg_test_null,
ebb3472f
AB		 2711 }, {
2712 .alg = "crc32",
2713 .test = alg_test_hash,
2714 .suite = {
2715 .hash = {
2716 .vecs = crc32_tv_template,
2717 .count = CRC32_TEST_VECTORS
2718 }
2719 }
da7f033d
HX		 2720 }, {
2721 .alg = "crc32c",
8e3ee85e 2722 .test = alg_test_crc32c,
a1915d51 2723 .fips_allowed = 1,
da7f033d
HX		 2724 .suite = {
2725 .hash = {
2726 .vecs = crc32c_tv_template,
2727 .count = CRC32C_TEST_VECTORS
2728 }
2729 }
68411521
HX		 2730 }, {
2731 .alg = "crct10dif",
2732 .test = alg_test_hash,
2733 .fips_allowed = 1,
2734 .suite = {
2735 .hash = {
2736 .vecs = crct10dif_tv_template,
2737 .count = CRCT10DIF_TEST_VECTORS
2738 }
2739 }
f7cb80f2
JW		 2740 }, {
2741 .alg = "ctr(aes)",
2742 .test = alg_test_skcipher,
a1915d51 2743 .fips_allowed = 1,
f7cb80f2
JW		 2744 .suite = {
2745 .cipher = {
2746 .enc = {
2747 .vecs = aes_ctr_enc_tv_template,
2748 .count = AES_CTR_ENC_TEST_VECTORS
2749 },
2750 .dec = {
2751 .vecs = aes_ctr_dec_tv_template,
2752 .count = AES_CTR_DEC_TEST_VECTORS
2753 }
2754 }
2755 }
85b63e34
JK		 2756 }, {
2757 .alg = "ctr(blowfish)",
2758 .test = alg_test_skcipher,
2759 .suite = {
2760 .cipher = {
2761 .enc = {
2762 .vecs = bf_ctr_enc_tv_template,
2763 .count = BF_CTR_ENC_TEST_VECTORS
2764 },
2765 .dec = {
2766 .vecs = bf_ctr_dec_tv_template,
2767 .count = BF_CTR_DEC_TEST_VECTORS
2768 }
2769 }
2770 }
0840605e
JK		 2771 }, {
2772 .alg = "ctr(camellia)",
2773 .test = alg_test_skcipher,
2774 .suite = {
2775 .cipher = {
2776 .enc = {
2777 .vecs = camellia_ctr_enc_tv_template,
2778 .count = CAMELLIA_CTR_ENC_TEST_VECTORS
2779 },
2780 .dec = {
2781 .vecs = camellia_ctr_dec_tv_template,
2782 .count = CAMELLIA_CTR_DEC_TEST_VECTORS
2783 }
2784 }
2785 }
a2c58260
JG		 2786 }, {
2787 .alg = "ctr(cast5)",
2788 .test = alg_test_skcipher,
2789 .suite = {
2790 .cipher = {
2791 .enc = {
2792 .vecs = cast5_ctr_enc_tv_template,
2793 .count = CAST5_CTR_ENC_TEST_VECTORS
2794 },
2795 .dec = {
2796 .vecs = cast5_ctr_dec_tv_template,
2797 .count = CAST5_CTR_DEC_TEST_VECTORS
2798 }
2799 }
2800 }
9b8b0405
JG		 2801 }, {
2802 .alg = "ctr(cast6)",
2803 .test = alg_test_skcipher,
2804 .suite = {
2805 .cipher = {
2806 .enc = {
2807 .vecs = cast6_ctr_enc_tv_template,
2808 .count = CAST6_CTR_ENC_TEST_VECTORS
2809 },
2810 .dec = {
2811 .vecs = cast6_ctr_dec_tv_template,
2812 .count = CAST6_CTR_DEC_TEST_VECTORS
2813 }
2814 }
2815 }
8163fc30
JK		 2816 }, {
2817 .alg = "ctr(des)",
2818 .test = alg_test_skcipher,
2819 .suite = {
2820 .cipher = {
2821 .enc = {
2822 .vecs = des_ctr_enc_tv_template,
2823 .count = DES_CTR_ENC_TEST_VECTORS
2824 },
2825 .dec = {
2826 .vecs = des_ctr_dec_tv_template,
2827 .count = DES_CTR_DEC_TEST_VECTORS
2828 }
2829 }
2830 }
e080b17a
JK		 2831 }, {
2832 .alg = "ctr(des3_ede)",
2833 .test = alg_test_skcipher,
2834 .suite = {
2835 .cipher = {
2836 .enc = {
2837 .vecs = des3_ede_ctr_enc_tv_template,
2838 .count = DES3_EDE_CTR_ENC_TEST_VECTORS
2839 },
2840 .dec = {
2841 .vecs = des3_ede_ctr_dec_tv_template,
2842 .count = DES3_EDE_CTR_DEC_TEST_VECTORS
2843 }
2844 }
2845 }
9d25917d
JK		 2846 }, {
2847 .alg = "ctr(serpent)",
2848 .test = alg_test_skcipher,
2849 .suite = {
2850 .cipher = {
2851 .enc = {
2852 .vecs = serpent_ctr_enc_tv_template,
2853 .count = SERPENT_CTR_ENC_TEST_VECTORS
2854 },
2855 .dec = {
2856 .vecs = serpent_ctr_dec_tv_template,
2857 .count = SERPENT_CTR_DEC_TEST_VECTORS
2858 }
2859 }
2860 }
573da620
JK		 2861 }, {
2862 .alg = "ctr(twofish)",
2863 .test = alg_test_skcipher,
2864 .suite = {
2865 .cipher = {
2866 .enc = {
2867 .vecs = tf_ctr_enc_tv_template,
2868 .count = TF_CTR_ENC_TEST_VECTORS
2869 },
2870 .dec = {
2871 .vecs = tf_ctr_dec_tv_template,
2872 .count = TF_CTR_DEC_TEST_VECTORS
2873 }
2874 }
2875 }
da7f033d
HX		 2876 }, {
2877 .alg = "cts(cbc(aes))",
1aa4ecd9 2878 .test = alg_test_skcipher,
da7f033d
HX		 2879 .suite = {
2880 .cipher = {
2881 .enc = {
2882 .vecs = cts_mode_enc_tv_template,
2883 .count = CTS_MODE_ENC_TEST_VECTORS
2884 },
2885 .dec = {
2886 .vecs = cts_mode_dec_tv_template,
2887 .count = CTS_MODE_DEC_TEST_VECTORS
2888 }
2889 }
2890 }
2891 }, {
2892 .alg = "deflate",
2893 .test = alg_test_comp,
0818904d 2894 .fips_allowed = 1,
da7f033d
HX		 2895 .suite = {
2896 .comp = {
2897 .comp = {
2898 .vecs = deflate_comp_tv_template,
2899 .count = DEFLATE_COMP_TEST_VECTORS
2900 },
2901 .decomp = {
2902 .vecs = deflate_decomp_tv_template,
2903 .count = DEFLATE_DECOMP_TEST_VECTORS
2904 }
2905 }
2906 }
802c7f1c
SB		 2907 }, {
2908 .alg = "dh",
2909 .test = alg_test_kpp,
2910 .fips_allowed = 1,
2911 .suite = {
2912 .kpp = {
2913 .vecs = dh_tv_template,
2914 .count = DH_TEST_VECTORS
2915 }
2916 }
e448370d
JK		 2917 }, {
2918 .alg = "digest_null",
2919 .test = alg_test_null,
64d1cdfb
SM		 2920 }, {
2921 .alg = "drbg_nopr_ctr_aes128",
2922 .test = alg_test_drbg,
2923 .fips_allowed = 1,
2924 .suite = {
2925 .drbg = {
2926 .vecs = drbg_nopr_ctr_aes128_tv_template,
2927 .count = ARRAY_SIZE(drbg_nopr_ctr_aes128_tv_template)
2928 }
2929 }
2930 }, {
2931 .alg = "drbg_nopr_ctr_aes192",
2932 .test = alg_test_drbg,
2933 .fips_allowed = 1,
2934 .suite = {
2935 .drbg = {
2936 .vecs = drbg_nopr_ctr_aes192_tv_template,
2937 .count = ARRAY_SIZE(drbg_nopr_ctr_aes192_tv_template)
2938 }
2939 }
2940 }, {
2941 .alg = "drbg_nopr_ctr_aes256",
2942 .test = alg_test_drbg,
2943 .fips_allowed = 1,
2944 .suite = {
2945 .drbg = {
2946 .vecs = drbg_nopr_ctr_aes256_tv_template,
2947 .count = ARRAY_SIZE(drbg_nopr_ctr_aes256_tv_template)
2948 }
2949 }
2950 }, {
2951 /*
2952 * There is no need to specifically test the DRBG with every
2953 * backend cipher -- covered by drbg_nopr_hmac_sha256 test
2954 */
2955 .alg = "drbg_nopr_hmac_sha1",
2956 .fips_allowed = 1,
2957 .test = alg_test_null,
2958 }, {
2959 .alg = "drbg_nopr_hmac_sha256",
2960 .test = alg_test_drbg,
2961 .fips_allowed = 1,
2962 .suite = {
2963 .drbg = {
2964 .vecs = drbg_nopr_hmac_sha256_tv_template,
2965 .count =
2966 ARRAY_SIZE(drbg_nopr_hmac_sha256_tv_template)
2967 }
2968 }
2969 }, {
2970 /* covered by drbg_nopr_hmac_sha256 test */
2971 .alg = "drbg_nopr_hmac_sha384",
2972 .fips_allowed = 1,
2973 .test = alg_test_null,
2974 }, {
2975 .alg = "drbg_nopr_hmac_sha512",
2976 .test = alg_test_null,
2977 .fips_allowed = 1,
2978 }, {
2979 .alg = "drbg_nopr_sha1",
2980 .fips_allowed = 1,
2981 .test = alg_test_null,
2982 }, {
2983 .alg = "drbg_nopr_sha256",
2984 .test = alg_test_drbg,
2985 .fips_allowed = 1,
2986 .suite = {
2987 .drbg = {
2988 .vecs = drbg_nopr_sha256_tv_template,
2989 .count = ARRAY_SIZE(drbg_nopr_sha256_tv_template)
2990 }
2991 }
2992 }, {
2993 /* covered by drbg_nopr_sha256 test */
2994 .alg = "drbg_nopr_sha384",
2995 .fips_allowed = 1,
2996 .test = alg_test_null,
2997 }, {
2998 .alg = "drbg_nopr_sha512",
2999 .fips_allowed = 1,
3000 .test = alg_test_null,
3001 }, {
3002 .alg = "drbg_pr_ctr_aes128",
3003 .test = alg_test_drbg,
3004 .fips_allowed = 1,
3005 .suite = {
3006 .drbg = {
3007 .vecs = drbg_pr_ctr_aes128_tv_template,
3008 .count = ARRAY_SIZE(drbg_pr_ctr_aes128_tv_template)
3009 }
3010 }
3011 }, {
3012 /* covered by drbg_pr_ctr_aes128 test */
3013 .alg = "drbg_pr_ctr_aes192",
3014 .fips_allowed = 1,
3015 .test = alg_test_null,
3016 }, {
3017 .alg = "drbg_pr_ctr_aes256",
3018 .fips_allowed = 1,
3019 .test = alg_test_null,
3020 }, {
3021 .alg = "drbg_pr_hmac_sha1",
3022 .fips_allowed = 1,
3023 .test = alg_test_null,
3024 }, {
3025 .alg = "drbg_pr_hmac_sha256",
3026 .test = alg_test_drbg,
3027 .fips_allowed = 1,
3028 .suite = {
3029 .drbg = {
3030 .vecs = drbg_pr_hmac_sha256_tv_template,
3031 .count = ARRAY_SIZE(drbg_pr_hmac_sha256_tv_template)
3032 }
3033 }
3034 }, {
3035 /* covered by drbg_pr_hmac_sha256 test */
3036 .alg = "drbg_pr_hmac_sha384",
3037 .fips_allowed = 1,
3038 .test = alg_test_null,
3039 }, {
3040 .alg = "drbg_pr_hmac_sha512",
3041 .test = alg_test_null,
3042 .fips_allowed = 1,
3043 }, {
3044 .alg = "drbg_pr_sha1",
3045 .fips_allowed = 1,
3046 .test = alg_test_null,
3047 }, {
3048 .alg = "drbg_pr_sha256",
3049 .test = alg_test_drbg,
3050 .fips_allowed = 1,
3051 .suite = {
3052 .drbg = {
3053 .vecs = drbg_pr_sha256_tv_template,
3054 .count = ARRAY_SIZE(drbg_pr_sha256_tv_template)
3055 }
3056 }
3057 }, {
3058 /* covered by drbg_pr_sha256 test */
3059 .alg = "drbg_pr_sha384",
3060 .fips_allowed = 1,
3061 .test = alg_test_null,
3062 }, {
3063 .alg = "drbg_pr_sha512",
3064 .fips_allowed = 1,
3065 .test = alg_test_null,
da7f033d
HX		 3066 }, {
3067 .alg = "ecb(aes)",
1aa4ecd9 3068 .test = alg_test_skcipher,
a1915d51 3069 .fips_allowed = 1,
da7f033d
HX		 3070 .suite = {
3071 .cipher = {
3072 .enc = {
3073 .vecs = aes_enc_tv_template,
3074 .count = AES_ENC_TEST_VECTORS
3075 },
3076 .dec = {
3077 .vecs = aes_dec_tv_template,
3078 .count = AES_DEC_TEST_VECTORS
3079 }
3080 }
3081 }
3082 }, {
3083 .alg = "ecb(anubis)",
1aa4ecd9 3084 .test = alg_test_skcipher,
da7f033d
HX		 3085 .suite = {
3086 .cipher = {
3087 .enc = {
3088 .vecs = anubis_enc_tv_template,
3089 .count = ANUBIS_ENC_TEST_VECTORS
3090 },
3091 .dec = {
3092 .vecs = anubis_dec_tv_template,
3093 .count = ANUBIS_DEC_TEST_VECTORS
3094 }
3095 }
3096 }
3097 }, {
3098 .alg = "ecb(arc4)",
1aa4ecd9 3099 .test = alg_test_skcipher,
da7f033d
HX		 3100 .suite = {
3101 .cipher = {
3102 .enc = {
3103 .vecs = arc4_enc_tv_template,
3104 .count = ARC4_ENC_TEST_VECTORS
3105 },
3106 .dec = {
3107 .vecs = arc4_dec_tv_template,
3108 .count = ARC4_DEC_TEST_VECTORS
3109 }
3110 }
3111 }
3112 }, {
3113 .alg = "ecb(blowfish)",
1aa4ecd9 3114 .test = alg_test_skcipher,
da7f033d
HX		 3115 .suite = {
3116 .cipher = {
3117 .enc = {
3118 .vecs = bf_enc_tv_template,
3119 .count = BF_ENC_TEST_VECTORS
3120 },
3121 .dec = {
3122 .vecs = bf_dec_tv_template,
3123 .count = BF_DEC_TEST_VECTORS
3124 }
3125 }
3126 }
3127 }, {
3128 .alg = "ecb(camellia)",
1aa4ecd9 3129 .test = alg_test_skcipher,
da7f033d
HX		 3130 .suite = {
3131 .cipher = {
3132 .enc = {
3133 .vecs = camellia_enc_tv_template,
3134 .count = CAMELLIA_ENC_TEST_VECTORS
3135 },
3136 .dec = {
3137 .vecs = camellia_dec_tv_template,
3138 .count = CAMELLIA_DEC_TEST_VECTORS
3139 }
3140 }
3141 }
3142 }, {
3143 .alg = "ecb(cast5)",
1aa4ecd9 3144 .test = alg_test_skcipher,
da7f033d
HX		 3145 .suite = {
3146 .cipher = {
3147 .enc = {
3148 .vecs = cast5_enc_tv_template,
3149 .count = CAST5_ENC_TEST_VECTORS
3150 },
3151 .dec = {
3152 .vecs = cast5_dec_tv_template,
3153 .count = CAST5_DEC_TEST_VECTORS
3154 }
3155 }
3156 }
3157 }, {
3158 .alg = "ecb(cast6)",
1aa4ecd9 3159 .test = alg_test_skcipher,
da7f033d
HX		 3160 .suite = {
3161 .cipher = {
3162 .enc = {
3163 .vecs = cast6_enc_tv_template,
3164 .count = CAST6_ENC_TEST_VECTORS
3165 },
3166 .dec = {
3167 .vecs = cast6_dec_tv_template,
3168 .count = CAST6_DEC_TEST_VECTORS
3169 }
3170 }
3171 }
e448370d
JK		 3172 }, {
3173 .alg = "ecb(cipher_null)",
3174 .test = alg_test_null,
da7f033d
HX		 3175 }, {
3176 .alg = "ecb(des)",
1aa4ecd9 3177 .test = alg_test_skcipher,
da7f033d
HX		 3178 .suite = {
3179 .cipher = {
3180 .enc = {
3181 .vecs = des_enc_tv_template,
3182 .count = DES_ENC_TEST_VECTORS
3183 },
3184 .dec = {
3185 .vecs = des_dec_tv_template,
3186 .count = DES_DEC_TEST_VECTORS
3187 }
3188 }
3189 }
3190 }, {
3191 .alg = "ecb(des3_ede)",
1aa4ecd9 3192 .test = alg_test_skcipher,
a1915d51 3193 .fips_allowed = 1,
da7f033d
HX		 3194 .suite = {
3195 .cipher = {
3196 .enc = {
3197 .vecs = des3_ede_enc_tv_template,
3198 .count = DES3_EDE_ENC_TEST_VECTORS
3199 },
3200 .dec = {
3201 .vecs = des3_ede_dec_tv_template,
3202 .count = DES3_EDE_DEC_TEST_VECTORS
3203 }
3204 }
3205 }
66e5bd00
JK		 3206 }, {
3207 .alg = "ecb(fcrypt)",
3208 .test = alg_test_skcipher,
3209 .suite = {
3210 .cipher = {
3211 .enc = {
3212 .vecs = fcrypt_pcbc_enc_tv_template,
3213 .count = 1
3214 },
3215 .dec = {
3216 .vecs = fcrypt_pcbc_dec_tv_template,
3217 .count = 1
3218 }
3219 }
3220 }
da7f033d
HX		 3221 }, {
3222 .alg = "ecb(khazad)",
1aa4ecd9 3223 .test = alg_test_skcipher,
da7f033d
HX		 3224 .suite = {
3225 .cipher = {
3226 .enc = {
3227 .vecs = khazad_enc_tv_template,
3228 .count = KHAZAD_ENC_TEST_VECTORS
3229 },
3230 .dec = {
3231 .vecs = khazad_dec_tv_template,
3232 .count = KHAZAD_DEC_TEST_VECTORS
3233 }
3234 }
3235 }
3236 }, {
3237 .alg = "ecb(seed)",
1aa4ecd9 3238 .test = alg_test_skcipher,
da7f033d
HX		 3239 .suite = {
3240 .cipher = {
3241 .enc = {
3242 .vecs = seed_enc_tv_template,
3243 .count = SEED_ENC_TEST_VECTORS
3244 },
3245 .dec = {
3246 .vecs = seed_dec_tv_template,
3247 .count = SEED_DEC_TEST_VECTORS
3248 }
3249 }
3250 }
3251 }, {
3252 .alg = "ecb(serpent)",
1aa4ecd9 3253 .test = alg_test_skcipher,
da7f033d
HX		 3254 .suite = {
3255 .cipher = {
3256 .enc = {
3257 .vecs = serpent_enc_tv_template,
3258 .count = SERPENT_ENC_TEST_VECTORS
3259 },
3260 .dec = {
3261 .vecs = serpent_dec_tv_template,
3262 .count = SERPENT_DEC_TEST_VECTORS
3263 }
3264 }
3265 }
3266 }, {
3267 .alg = "ecb(tea)",
1aa4ecd9 3268 .test = alg_test_skcipher,
da7f033d
HX		 3269 .suite = {
3270 .cipher = {
3271 .enc = {
3272 .vecs = tea_enc_tv_template,
3273 .count = TEA_ENC_TEST_VECTORS
3274 },
3275 .dec = {
3276 .vecs = tea_dec_tv_template,
3277 .count = TEA_DEC_TEST_VECTORS
3278 }
3279 }
3280 }
3281 }, {
3282 .alg = "ecb(tnepres)",
1aa4ecd9 3283 .test = alg_test_skcipher,
da7f033d
HX		 3284 .suite = {
3285 .cipher = {
3286 .enc = {
3287 .vecs = tnepres_enc_tv_template,
3288 .count = TNEPRES_ENC_TEST_VECTORS
3289 },
3290 .dec = {
3291 .vecs = tnepres_dec_tv_template,
3292 .count = TNEPRES_DEC_TEST_VECTORS
3293 }
3294 }
3295 }
3296 }, {
3297 .alg = "ecb(twofish)",
1aa4ecd9 3298 .test = alg_test_skcipher,
da7f033d
HX		 3299 .suite = {
3300 .cipher = {
3301 .enc = {
3302 .vecs = tf_enc_tv_template,
3303 .count = TF_ENC_TEST_VECTORS
3304 },
3305 .dec = {
3306 .vecs = tf_dec_tv_template,
3307 .count = TF_DEC_TEST_VECTORS
3308 }
3309 }
3310 }
3311 }, {
3312 .alg = "ecb(xeta)",
1aa4ecd9 3313 .test = alg_test_skcipher,
da7f033d
HX		 3314 .suite = {
3315 .cipher = {
3316 .enc = {
3317 .vecs = xeta_enc_tv_template,
3318 .count = XETA_ENC_TEST_VECTORS
3319 },
3320 .dec = {
3321 .vecs = xeta_dec_tv_template,
3322 .count = XETA_DEC_TEST_VECTORS
3323 }
3324 }
3325 }
3326 }, {
3327 .alg = "ecb(xtea)",
1aa4ecd9 3328 .test = alg_test_skcipher,
da7f033d
HX		 3329 .suite = {
3330 .cipher = {
3331 .enc = {
3332 .vecs = xtea_enc_tv_template,
3333 .count = XTEA_ENC_TEST_VECTORS
3334 },
3335 .dec = {
3336 .vecs = xtea_dec_tv_template,
3337 .count = XTEA_DEC_TEST_VECTORS
3338 }
3339 }
3340 }
3c4b2390
SB		 3341 }, {
3342 .alg = "ecdh",
3343 .test = alg_test_kpp,
3344 .fips_allowed = 1,
3345 .suite = {
3346 .kpp = {
3347 .vecs = ecdh_tv_template,
3348 .count = ECDH_TEST_VECTORS
3349 }
3350 }
da7f033d
HX		 3351 }, {
3352 .alg = "gcm(aes)",
3353 .test = alg_test_aead,
a1915d51 3354 .fips_allowed = 1,
da7f033d
HX		 3355 .suite = {
3356 .aead = {
3357 .enc = {
3358 .vecs = aes_gcm_enc_tv_template,
3359 .count = AES_GCM_ENC_TEST_VECTORS
3360 },
3361 .dec = {
3362 .vecs = aes_gcm_dec_tv_template,
3363 .count = AES_GCM_DEC_TEST_VECTORS
3364 }
3365 }
3366 }
507069c9
YS		 3367 }, {
3368 .alg = "ghash",
3369 .test = alg_test_hash,
18c0ebd2 3370 .fips_allowed = 1,
507069c9
YS		 3371 .suite = {
3372 .hash = {
3373 .vecs = ghash_tv_template,
3374 .count = GHASH_TEST_VECTORS
3375 }
3376 }
a482b081
SZ		 3377 }, {
3378 .alg = "hmac(crc32)",
3379 .test = alg_test_hash,
3380 .suite = {
3381 .hash = {
3382 .vecs = bfin_crc_tv_template,
3383 .count = BFIN_CRC_TEST_VECTORS
3384 }
3385 }
da7f033d
HX		 3386 }, {
3387 .alg = "hmac(md5)",
3388 .test = alg_test_hash,
3389 .suite = {
3390 .hash = {
3391 .vecs = hmac_md5_tv_template,
3392 .count = HMAC_MD5_TEST_VECTORS
3393 }
3394 }
3395 }, {
3396 .alg = "hmac(rmd128)",
3397 .test = alg_test_hash,
3398 .suite = {
3399 .hash = {
3400 .vecs = hmac_rmd128_tv_template,
3401 .count = HMAC_RMD128_TEST_VECTORS
3402 }
3403 }
3404 }, {
3405 .alg = "hmac(rmd160)",
3406 .test = alg_test_hash,
3407 .suite = {
3408 .hash = {
3409 .vecs = hmac_rmd160_tv_template,
3410 .count = HMAC_RMD160_TEST_VECTORS
3411 }
3412 }
3413 }, {
3414 .alg = "hmac(sha1)",
3415 .test = alg_test_hash,
a1915d51 3416 .fips_allowed = 1,
da7f033d
HX		 3417 .suite = {
3418 .hash = {
3419 .vecs = hmac_sha1_tv_template,
3420 .count = HMAC_SHA1_TEST_VECTORS
3421 }
3422 }
3423 }, {
3424 .alg = "hmac(sha224)",
3425 .test = alg_test_hash,
a1915d51 3426 .fips_allowed = 1,
da7f033d
HX		 3427 .suite = {
3428 .hash = {
3429 .vecs = hmac_sha224_tv_template,
3430 .count = HMAC_SHA224_TEST_VECTORS
3431 }
3432 }
3433 }, {
3434 .alg = "hmac(sha256)",
3435 .test = alg_test_hash,
a1915d51 3436 .fips_allowed = 1,
da7f033d
HX		 3437 .suite = {
3438 .hash = {
3439 .vecs = hmac_sha256_tv_template,
3440 .count = HMAC_SHA256_TEST_VECTORS
3441 }
3442 }
98eca72f 3443 }, {
3444 .alg = "hmac(sha3-224)",
3445 .test = alg_test_hash,
3446 .fips_allowed = 1,
3447 .suite = {
3448 .hash = {
3449 .vecs = hmac_sha3_224_tv_template,
3450 .count = HMAC_SHA3_224_TEST_VECTORS
3451 }
3452 }
3453 }, {
3454 .alg = "hmac(sha3-256)",
3455 .test = alg_test_hash,
3456 .fips_allowed = 1,
3457 .suite = {
3458 .hash = {
3459 .vecs = hmac_sha3_256_tv_template,
3460 .count = HMAC_SHA3_256_TEST_VECTORS
3461 }
3462 }
3463 }, {
3464 .alg = "hmac(sha3-384)",
3465 .test = alg_test_hash,
3466 .fips_allowed = 1,
3467 .suite = {
3468 .hash = {
3469 .vecs = hmac_sha3_384_tv_template,
3470 .count = HMAC_SHA3_384_TEST_VECTORS
3471 }
3472 }
3473 }, {
3474 .alg = "hmac(sha3-512)",
3475 .test = alg_test_hash,
3476 .fips_allowed = 1,
3477 .suite = {
3478 .hash = {
3479 .vecs = hmac_sha3_512_tv_template,
3480 .count = HMAC_SHA3_512_TEST_VECTORS
3481 }
3482 }
da7f033d
HX		 3483 }, {
3484 .alg = "hmac(sha384)",
3485 .test = alg_test_hash,
a1915d51 3486 .fips_allowed = 1,
da7f033d
HX		 3487 .suite = {
3488 .hash = {
3489 .vecs = hmac_sha384_tv_template,
3490 .count = HMAC_SHA384_TEST_VECTORS
3491 }
3492 }
3493 }, {
3494 .alg = "hmac(sha512)",
3495 .test = alg_test_hash,
a1915d51 3496 .fips_allowed = 1,
da7f033d
HX		 3497 .suite = {
3498 .hash = {
3499 .vecs = hmac_sha512_tv_template,
3500 .count = HMAC_SHA512_TEST_VECTORS
3501 }
3502 }
bb5530e4
SM		 3503 }, {
3504 .alg = "jitterentropy_rng",
3505 .fips_allowed = 1,
3506 .test = alg_test_null,
35351988
SM		 3507 }, {
3508 .alg = "kw(aes)",
3509 .test = alg_test_skcipher,
3510 .fips_allowed = 1,
3511 .suite = {
3512 .cipher = {
3513 .enc = {
3514 .vecs = aes_kw_enc_tv_template,
3515 .count = ARRAY_SIZE(aes_kw_enc_tv_template)
3516 },
3517 .dec = {
3518 .vecs = aes_kw_dec_tv_template,
3519 .count = ARRAY_SIZE(aes_kw_dec_tv_template)
3520 }
3521 }
3522 }
da7f033d
HX		 3523 }, {
3524 .alg = "lrw(aes)",
1aa4ecd9 3525 .test = alg_test_skcipher,
da7f033d
HX		 3526 .suite = {
3527 .cipher = {
3528 .enc = {
3529 .vecs = aes_lrw_enc_tv_template,
3530 .count = AES_LRW_ENC_TEST_VECTORS
3531 },
3532 .dec = {
3533 .vecs = aes_lrw_dec_tv_template,
3534 .count = AES_LRW_DEC_TEST_VECTORS
3535 }
3536 }
3537 }
0840605e
JK		 3538 }, {
3539 .alg = "lrw(camellia)",
3540 .test = alg_test_skcipher,
3541 .suite = {
3542 .cipher = {
3543 .enc = {
3544 .vecs = camellia_lrw_enc_tv_template,
3545 .count = CAMELLIA_LRW_ENC_TEST_VECTORS
3546 },
3547 .dec = {
3548 .vecs = camellia_lrw_dec_tv_template,
3549 .count = CAMELLIA_LRW_DEC_TEST_VECTORS
3550 }
3551 }
3552 }
9b8b0405
JG		 3553 }, {
3554 .alg = "lrw(cast6)",
3555 .test = alg_test_skcipher,
3556 .suite = {
3557 .cipher = {
3558 .enc = {
3559 .vecs = cast6_lrw_enc_tv_template,
3560 .count = CAST6_LRW_ENC_TEST_VECTORS
3561 },
3562 .dec = {
3563 .vecs = cast6_lrw_dec_tv_template,
3564 .count = CAST6_LRW_DEC_TEST_VECTORS
3565 }
3566 }
3567 }
d7bfc0fa
JK		 3568 }, {
3569 .alg = "lrw(serpent)",
3570 .test = alg_test_skcipher,
3571 .suite = {
3572 .cipher = {
3573 .enc = {
3574 .vecs = serpent_lrw_enc_tv_template,
3575 .count = SERPENT_LRW_ENC_TEST_VECTORS
3576 },
3577 .dec = {
3578 .vecs = serpent_lrw_dec_tv_template,
3579 .count = SERPENT_LRW_DEC_TEST_VECTORS
3580 }
3581 }
3582 }
0b2a1551
JK		 3583 }, {
3584 .alg = "lrw(twofish)",
3585 .test = alg_test_skcipher,
3586 .suite = {
3587 .cipher = {
3588 .enc = {
3589 .vecs = tf_lrw_enc_tv_template,
3590 .count = TF_LRW_ENC_TEST_VECTORS
3591 },
3592 .dec = {
3593 .vecs = tf_lrw_dec_tv_template,
3594 .count = TF_LRW_DEC_TEST_VECTORS
3595 }
3596 }
3597 }
1443cc9b
KK		 3598 }, {
3599 .alg = "lz4",
3600 .test = alg_test_comp,
3601 .fips_allowed = 1,
3602 .suite = {
3603 .comp = {
3604 .comp = {
3605 .vecs = lz4_comp_tv_template,
3606 .count = LZ4_COMP_TEST_VECTORS
3607 },
3608 .decomp = {
3609 .vecs = lz4_decomp_tv_template,
3610 .count = LZ4_DECOMP_TEST_VECTORS
3611 }
3612 }
3613 }
3614 }, {
3615 .alg = "lz4hc",
3616 .test = alg_test_comp,
3617 .fips_allowed = 1,
3618 .suite = {
3619 .comp = {
3620 .comp = {
3621 .vecs = lz4hc_comp_tv_template,
3622 .count = LZ4HC_COMP_TEST_VECTORS
3623 },
3624 .decomp = {
3625 .vecs = lz4hc_decomp_tv_template,
3626 .count = LZ4HC_DECOMP_TEST_VECTORS
3627 }
3628 }
3629 }
da7f033d
HX		 3630 }, {
3631 .alg = "lzo",
3632 .test = alg_test_comp,
0818904d 3633 .fips_allowed = 1,
da7f033d
HX		 3634 .suite = {
3635 .comp = {
3636 .comp = {
3637 .vecs = lzo_comp_tv_template,
3638 .count = LZO_COMP_TEST_VECTORS
3639 },
3640 .decomp = {
3641 .vecs = lzo_decomp_tv_template,
3642 .count = LZO_DECOMP_TEST_VECTORS
3643 }
3644 }
3645 }
3646 }, {
3647 .alg = "md4",
3648 .test = alg_test_hash,
3649 .suite = {
3650 .hash = {
3651 .vecs = md4_tv_template,
3652 .count = MD4_TEST_VECTORS
3653 }
3654 }
3655 }, {
3656 .alg = "md5",
3657 .test = alg_test_hash,
3658 .suite = {
3659 .hash = {
3660 .vecs = md5_tv_template,
3661 .count = MD5_TEST_VECTORS
3662 }
3663 }
3664 }, {
3665 .alg = "michael_mic",
3666 .test = alg_test_hash,
3667 .suite = {
3668 .hash = {
3669 .vecs = michael_mic_tv_template,
3670 .count = MICHAEL_MIC_TEST_VECTORS
3671 }
3672 }
ba0e14ac
PS		 3673 }, {
3674 .alg = "ofb(aes)",
3675 .test = alg_test_skcipher,
3676 .fips_allowed = 1,
3677 .suite = {
3678 .cipher = {
3679 .enc = {
3680 .vecs = aes_ofb_enc_tv_template,
3681 .count = AES_OFB_ENC_TEST_VECTORS
3682 },
3683 .dec = {
3684 .vecs = aes_ofb_dec_tv_template,
3685 .count = AES_OFB_DEC_TEST_VECTORS
3686 }
3687 }
3688 }
da7f033d
HX		 3689 }, {
3690 .alg = "pcbc(fcrypt)",
1aa4ecd9 3691 .test = alg_test_skcipher,
da7f033d
HX		 3692 .suite = {
3693 .cipher = {
3694 .enc = {
3695 .vecs = fcrypt_pcbc_enc_tv_template,
3696 .count = FCRYPT_ENC_TEST_VECTORS
3697 },
3698 .dec = {
3699 .vecs = fcrypt_pcbc_dec_tv_template,
3700 .count = FCRYPT_DEC_TEST_VECTORS
3701 }
3702 }
3703 }
eee9dc61
MW		 3704 }, {
3705 .alg = "poly1305",
3706 .test = alg_test_hash,
3707 .suite = {
3708 .hash = {
3709 .vecs = poly1305_tv_template,
3710 .count = POLY1305_TEST_VECTORS
3711 }
3712 }
da7f033d
HX		 3713 }, {
3714 .alg = "rfc3686(ctr(aes))",
1aa4ecd9 3715 .test = alg_test_skcipher,
a1915d51 3716 .fips_allowed = 1,
da7f033d
HX		 3717 .suite = {
3718 .cipher = {
3719 .enc = {
f7cb80f2
JW		 3720 .vecs = aes_ctr_rfc3686_enc_tv_template,
3721 .count = AES_CTR_3686_ENC_TEST_VECTORS
da7f033d
HX		 3722 },
3723 .dec = {
f7cb80f2
JW		 3724 .vecs = aes_ctr_rfc3686_dec_tv_template,
3725 .count = AES_CTR_3686_DEC_TEST_VECTORS
da7f033d
HX		 3726 }
3727 }
3728 }
5d667322 3729 }, {
3f31a740 3730 .alg = "rfc4106(gcm(aes))",
69435b94 3731 .test = alg_test_aead,
db71f29a 3732 .fips_allowed = 1,
69435b94
AH		 3733 .suite = {
3734 .aead = {
3735 .enc = {
3736 .vecs = aes_gcm_rfc4106_enc_tv_template,
3737 .count = AES_GCM_4106_ENC_TEST_VECTORS
3738 },
3739 .dec = {
3740 .vecs = aes_gcm_rfc4106_dec_tv_template,
3741 .count = AES_GCM_4106_DEC_TEST_VECTORS
3742 }
3743 }
3744 }
3745 }, {
544c436a 3746 .alg = "rfc4309(ccm(aes))",
5d667322 3747 .test = alg_test_aead,
a1915d51 3748 .fips_allowed = 1,
5d667322
JW		 3749 .suite = {
3750 .aead = {
3751 .enc = {
3752 .vecs = aes_ccm_rfc4309_enc_tv_template,
3753 .count = AES_CCM_4309_ENC_TEST_VECTORS
3754 },
3755 .dec = {
3756 .vecs = aes_ccm_rfc4309_dec_tv_template,
3757 .count = AES_CCM_4309_DEC_TEST_VECTORS
3758 }
3759 }
3760 }
e9b7441a 3761 }, {
bb68745e 3762 .alg = "rfc4543(gcm(aes))",
e9b7441a
JK		 3763 .test = alg_test_aead,
3764 .suite = {
3765 .aead = {
3766 .enc = {
3767 .vecs = aes_gcm_rfc4543_enc_tv_template,
3768 .count = AES_GCM_4543_ENC_TEST_VECTORS
3769 },
3770 .dec = {
3771 .vecs = aes_gcm_rfc4543_dec_tv_template,
3772 .count = AES_GCM_4543_DEC_TEST_VECTORS
3773 },
3774 }
3775 }
af2b76b5
MW		 3776 }, {
3777 .alg = "rfc7539(chacha20,poly1305)",
3778 .test = alg_test_aead,
3779 .suite = {
3780 .aead = {
3781 .enc = {
3782 .vecs = rfc7539_enc_tv_template,
3783 .count = RFC7539_ENC_TEST_VECTORS
3784 },
3785 .dec = {
3786 .vecs = rfc7539_dec_tv_template,
3787 .count = RFC7539_DEC_TEST_VECTORS
3788 },
3789 }
3790 }
5900758d
MW		 3791 }, {
3792 .alg = "rfc7539esp(chacha20,poly1305)",
3793 .test = alg_test_aead,
3794 .suite = {
3795 .aead = {
3796 .enc = {
3797 .vecs = rfc7539esp_enc_tv_template,
3798 .count = RFC7539ESP_ENC_TEST_VECTORS
3799 },
3800 .dec = {
3801 .vecs = rfc7539esp_dec_tv_template,
3802 .count = RFC7539ESP_DEC_TEST_VECTORS
3803 },
3804 }
3805 }
da7f033d
HX		 3806 }, {
3807 .alg = "rmd128",
3808 .test = alg_test_hash,
3809 .suite = {
3810 .hash = {
3811 .vecs = rmd128_tv_template,
3812 .count = RMD128_TEST_VECTORS
3813 }
3814 }
3815 }, {
3816 .alg = "rmd160",
3817 .test = alg_test_hash,
3818 .suite = {
3819 .hash = {
3820 .vecs = rmd160_tv_template,
3821 .count = RMD160_TEST_VECTORS
3822 }
3823 }
3824 }, {
3825 .alg = "rmd256",
3826 .test = alg_test_hash,
3827 .suite = {
3828 .hash = {
3829 .vecs = rmd256_tv_template,
3830 .count = RMD256_TEST_VECTORS
3831 }
3832 }
3833 }, {
3834 .alg = "rmd320",
3835 .test = alg_test_hash,
3836 .suite = {
3837 .hash = {
3838 .vecs = rmd320_tv_template,
3839 .count = RMD320_TEST_VECTORS
3840 }
3841 }
946cc463
TS		 3842 }, {
3843 .alg = "rsa",
3844 .test = alg_test_akcipher,
3845 .fips_allowed = 1,
3846 .suite = {
3847 .akcipher = {
3848 .vecs = rsa_tv_template,
3849 .count = RSA_TEST_VECTORS
3850 }
3851 }
da7f033d
HX		 3852 }, {
3853 .alg = "salsa20",
1aa4ecd9 3854 .test = alg_test_skcipher,
da7f033d
HX		 3855 .suite = {
3856 .cipher = {
3857 .enc = {
3858 .vecs = salsa20_stream_enc_tv_template,
3859 .count = SALSA20_STREAM_ENC_TEST_VECTORS
3860 }
3861 }
3862 }
3863 }, {
3864 .alg = "sha1",
3865 .test = alg_test_hash,
a1915d51 3866 .fips_allowed = 1,
da7f033d
HX		 3867 .suite = {
3868 .hash = {
3869 .vecs = sha1_tv_template,
3870 .count = SHA1_TEST_VECTORS
3871 }
3872 }
3873 }, {
3874 .alg = "sha224",
3875 .test = alg_test_hash,
a1915d51 3876 .fips_allowed = 1,
da7f033d
HX		 3877 .suite = {
3878 .hash = {
3879 .vecs = sha224_tv_template,
3880 .count = SHA224_TEST_VECTORS
3881 }
3882 }
3883 }, {
3884 .alg = "sha256",
3885 .test = alg_test_hash,
a1915d51 3886 .fips_allowed = 1,
da7f033d
HX		 3887 .suite = {
3888 .hash = {
3889 .vecs = sha256_tv_template,
3890 .count = SHA256_TEST_VECTORS
3891 }
3892 }
79cc6ab8 3893 }, {
3894 .alg = "sha3-224",
3895 .test = alg_test_hash,
3896 .fips_allowed = 1,
3897 .suite = {
3898 .hash = {
3899 .vecs = sha3_224_tv_template,
3900 .count = SHA3_224_TEST_VECTORS
3901 }
3902 }
3903 }, {
3904 .alg = "sha3-256",
3905 .test = alg_test_hash,
3906 .fips_allowed = 1,
3907 .suite = {
3908 .hash = {
3909 .vecs = sha3_256_tv_template,
3910 .count = SHA3_256_TEST_VECTORS
3911 }
3912 }
3913 }, {
3914 .alg = "sha3-384",
3915 .test = alg_test_hash,
3916 .fips_allowed = 1,
3917 .suite = {
3918 .hash = {
3919 .vecs = sha3_384_tv_template,
3920 .count = SHA3_384_TEST_VECTORS
3921 }
3922 }
3923 }, {
3924 .alg = "sha3-512",
3925 .test = alg_test_hash,
3926 .fips_allowed = 1,
3927 .suite = {
3928 .hash = {
3929 .vecs = sha3_512_tv_template,
3930 .count = SHA3_512_TEST_VECTORS
3931 }
3932 }
da7f033d
HX		 3933 }, {
3934 .alg = "sha384",
3935 .test = alg_test_hash,
a1915d51 3936 .fips_allowed = 1,
da7f033d
HX		 3937 .suite = {
3938 .hash = {
3939 .vecs = sha384_tv_template,
3940 .count = SHA384_TEST_VECTORS
3941 }
3942 }
3943 }, {
3944 .alg = "sha512",
3945 .test = alg_test_hash,
a1915d51 3946 .fips_allowed = 1,
da7f033d
HX		 3947 .suite = {
3948 .hash = {
3949 .vecs = sha512_tv_template,
3950 .count = SHA512_TEST_VECTORS
3951 }
3952 }
3953 }, {
3954 .alg = "tgr128",
3955 .test = alg_test_hash,
3956 .suite = {
3957 .hash = {
3958 .vecs = tgr128_tv_template,
3959 .count = TGR128_TEST_VECTORS
3960 }
3961 }
3962 }, {
3963 .alg = "tgr160",
3964 .test = alg_test_hash,
3965 .suite = {
3966 .hash = {
3967 .vecs = tgr160_tv_template,
3968 .count = TGR160_TEST_VECTORS
3969 }
3970 }
3971 }, {
3972 .alg = "tgr192",
3973 .test = alg_test_hash,
3974 .suite = {
3975 .hash = {
3976 .vecs = tgr192_tv_template,
3977 .count = TGR192_TEST_VECTORS
3978 }
3979 }
f1939f7c
SW		 3980 }, {
3981 .alg = "vmac(aes)",
3982 .test = alg_test_hash,
3983 .suite = {
3984 .hash = {
3985 .vecs = aes_vmac128_tv_template,
3986 .count = VMAC_AES_TEST_VECTORS
3987 }
3988 }
da7f033d
HX		 3989 }, {
3990 .alg = "wp256",
3991 .test = alg_test_hash,
3992 .suite = {
3993 .hash = {
3994 .vecs = wp256_tv_template,
3995 .count = WP256_TEST_VECTORS
3996 }
3997 }
3998 }, {
3999 .alg = "wp384",
4000 .test = alg_test_hash,
4001 .suite = {
4002 .hash = {
4003 .vecs = wp384_tv_template,
4004 .count = WP384_TEST_VECTORS
4005 }
4006 }
4007 }, {
4008 .alg = "wp512",
4009 .test = alg_test_hash,
4010 .suite = {
4011 .hash = {
4012 .vecs = wp512_tv_template,
4013 .count = WP512_TEST_VECTORS
4014 }
4015 }
4016 }, {
4017 .alg = "xcbc(aes)",
4018 .test = alg_test_hash,
4019 .suite = {
4020 .hash = {
4021 .vecs = aes_xcbc128_tv_template,
4022 .count = XCBC_AES_TEST_VECTORS
4023 }
4024 }
4025 }, {
4026 .alg = "xts(aes)",
1aa4ecd9 4027 .test = alg_test_skcipher,
2918aa8d 4028 .fips_allowed = 1,
da7f033d
HX		 4029 .suite = {
4030 .cipher = {
4031 .enc = {
4032 .vecs = aes_xts_enc_tv_template,
4033 .count = AES_XTS_ENC_TEST_VECTORS
4034 },
4035 .dec = {
4036 .vecs = aes_xts_dec_tv_template,
4037 .count = AES_XTS_DEC_TEST_VECTORS
4038 }
4039 }
4040 }
0840605e
JK		 4041 }, {
4042 .alg = "xts(camellia)",
4043 .test = alg_test_skcipher,
4044 .suite = {
4045 .cipher = {
4046 .enc = {
4047 .vecs = camellia_xts_enc_tv_template,
4048 .count = CAMELLIA_XTS_ENC_TEST_VECTORS
4049 },
4050 .dec = {
4051 .vecs = camellia_xts_dec_tv_template,
4052 .count = CAMELLIA_XTS_DEC_TEST_VECTORS
4053 }
4054 }
4055 }
9b8b0405
JG		 4056 }, {
4057 .alg = "xts(cast6)",
4058 .test = alg_test_skcipher,
4059 .suite = {
4060 .cipher = {
4061 .enc = {
4062 .vecs = cast6_xts_enc_tv_template,
4063 .count = CAST6_XTS_ENC_TEST_VECTORS
4064 },
4065 .dec = {
4066 .vecs = cast6_xts_dec_tv_template,
4067 .count = CAST6_XTS_DEC_TEST_VECTORS
4068 }
4069 }
4070 }
18be20b9
JK		 4071 }, {
4072 .alg = "xts(serpent)",
4073 .test = alg_test_skcipher,
4074 .suite = {
4075 .cipher = {
4076 .enc = {
4077 .vecs = serpent_xts_enc_tv_template,
4078 .count = SERPENT_XTS_ENC_TEST_VECTORS
4079 },
4080 .dec = {
4081 .vecs = serpent_xts_dec_tv_template,
4082 .count = SERPENT_XTS_DEC_TEST_VECTORS
4083 }
4084 }
4085 }
aed265b9
JK		 4086 }, {
4087 .alg = "xts(twofish)",
4088 .test = alg_test_skcipher,
4089 .suite = {
4090 .cipher = {
4091 .enc = {
4092 .vecs = tf_xts_enc_tv_template,
4093 .count = TF_XTS_ENC_TEST_VECTORS
4094 },
4095 .dec = {
4096 .vecs = tf_xts_dec_tv_template,
4097 .count = TF_XTS_DEC_TEST_VECTORS
4098 }
4099 }
4100 }
da7f033d
HX		 4101 }
4102};
4103
5714758b
JK		 4104static bool alg_test_descs_checked;
4105
4106static void alg_test_descs_check_order(void)
4107{
4108 int i;
4109
4110 /* only check once */
4111 if (alg_test_descs_checked)
4112 return;
4113
4114 alg_test_descs_checked = true;
4115
4116 for (i = 1; i < ARRAY_SIZE(alg_test_descs); i++) {
4117 int diff = strcmp(alg_test_descs[i - 1].alg,
4118 alg_test_descs[i].alg);
4119
4120 if (WARN_ON(diff > 0)) {
4121 pr_warn("testmgr: alg_test_descs entries in wrong order: '%s' before '%s'\n",
4122 alg_test_descs[i - 1].alg,
4123 alg_test_descs[i].alg);
4124 }
4125
4126 if (WARN_ON(diff == 0)) {
4127 pr_warn("testmgr: duplicate alg_test_descs entry: '%s'\n",
4128 alg_test_descs[i].alg);
4129 }
4130 }
4131}
4132
1aa4ecd9 4133static int alg_find_test(const char *alg)
da7f033d
HX		 4134{
4135 int start = 0;
4136 int end = ARRAY_SIZE(alg_test_descs);
4137
4138 while (start < end) {
4139 int i = (start + end) / 2;
4140 int diff = strcmp(alg_test_descs[i].alg, alg);
4141
4142 if (diff > 0) {
4143 end = i;
4144 continue;
4145 }
4146
4147 if (diff < 0) {
4148 start = i + 1;
4149 continue;
4150 }
4151
1aa4ecd9
HX		 4152 return i;
4153 }
4154
4155 return -1;
4156}
4157
4158int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
4159{
4160 int i;
a68f6610 4161 int j;
d12d6b6d 4162 int rc;
1aa4ecd9 4163
9e5c9fe4
RJ		 4164 if (!fips_enabled && notests) {
4165 printk_once(KERN_INFO "alg: self-tests disabled\n");
4166 return 0;
4167 }
4168
5714758b
JK		 4169 alg_test_descs_check_order();
4170
1aa4ecd9
HX		 4171 if ((type & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_CIPHER) {
4172 char nalg[CRYPTO_MAX_ALG_NAME];
4173
4174 if (snprintf(nalg, sizeof(nalg), "ecb(%s)", alg) >=
4175 sizeof(nalg))
4176 return -ENAMETOOLONG;
4177
4178 i = alg_find_test(nalg);
4179 if (i < 0)
4180 goto notest;
4181
a3bef3a3
JW		 4182 if (fips_enabled && !alg_test_descs[i].fips_allowed)
4183 goto non_fips_alg;
4184
941fb328
JW		 4185 rc = alg_test_cipher(alg_test_descs + i, driver, type, mask);
4186 goto test_done;
da7f033d
HX		 4187 }
4188
1aa4ecd9 4189 i = alg_find_test(alg);
a68f6610
HX		 4190 j = alg_find_test(driver);
4191 if (i < 0 && j < 0)
1aa4ecd9
HX		 4192 goto notest;
4193
a68f6610
HX		 4194 if (fips_enabled && ((i >= 0 && !alg_test_descs[i].fips_allowed) ||
4195 (j >= 0 && !alg_test_descs[j].fips_allowed)))
a3bef3a3
JW		 4196 goto non_fips_alg;
4197
a68f6610
HX		 4198 rc = 0;
4199 if (i >= 0)
4200 rc |= alg_test_descs[i].test(alg_test_descs + i, driver,
4201 type, mask);
032c8cac 4202 if (j >= 0 && j != i)
a68f6610
HX		 4203 rc |= alg_test_descs[j].test(alg_test_descs + j, driver,
4204 type, mask);
4205
941fb328 4206test_done:
d12d6b6d
NH		 4207 if (fips_enabled && rc)
4208 panic("%s: %s alg self test failed in fips mode!\n", driver, alg);
4209
29ecd4ab 4210 if (fips_enabled && !rc)
3e8cffd4 4211 pr_info("alg: self-tests for %s (%s) passed\n", driver, alg);
29ecd4ab 4212
d12d6b6d 4213 return rc;
1aa4ecd9
HX		 4214
4215notest:
da7f033d
HX		 4216 printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver);
4217 return 0;
a3bef3a3
JW		 4218non_fips_alg:
4219 return -EINVAL;
da7f033d 4220}
0b767f96 4221
326a6346 4222#endif /* CONFIG_CRYPTO_MANAGER_DISABLE_TESTS */
0b767f96 4223
da7f033d 4224EXPORT_SYMBOL_GPL(alg_test);
Empty description
This page took 0.85765 seconds and 4 git commands to generate.