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