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