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