?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
staging: hv: Fix error checking in channel.c
[linux/fpc-iii.git] / crypto / testmgr.c
blobc494d7610be14336262e126434cde7b8b530fae4
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 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License as published by the Free
11 * Software Foundation; either version 2 of the License, or (at your option)
12 * any later version.
13 *
14 */
15
16 #include <crypto/hash.h>
17 #include <linux/err.h>
18 #include <linux/module.h>
19 #include <linux/scatterlist.h>
20 #include <linux/slab.h>
21 #include <linux/string.h>
22 #include <crypto/rng.h>
23
24 #include "internal.h"
25 #include "testmgr.h"
26
27 /*
28 * Need slab memory for testing (size in number of pages).
29 */
30 #define XBUFSIZE 8
31
32 /*
33 * Indexes into the xbuf to simulate cross-page access.
34 */
35 #define IDX1 32
36 #define IDX2 32400
37 #define IDX3 1
38 #define IDX4 8193
39 #define IDX5 22222
40 #define IDX6 17101
41 #define IDX7 27333
42 #define IDX8 3000
43
44 /*
45 * Used by test_cipher()
46 */
47 #define ENCRYPT 1
48 #define DECRYPT 0
49
50 struct tcrypt_result {
51 struct completion completion;
52 int err;
53 };
54
55 struct aead_test_suite {
56 struct {
57 struct aead_testvec *vecs;
58 unsigned int count;
59 } enc, dec;
60 };
61
62 struct cipher_test_suite {
63 struct {
64 struct cipher_testvec *vecs;
65 unsigned int count;
66 } enc, dec;
67 };
68
69 struct comp_test_suite {
70 struct {
71 struct comp_testvec *vecs;
72 unsigned int count;
73 } comp, decomp;
74 };
75
76 struct pcomp_test_suite {
77 struct {
78 struct pcomp_testvec *vecs;
79 unsigned int count;
80 } comp, decomp;
81 };
82
83 struct hash_test_suite {
84 struct hash_testvec *vecs;
85 unsigned int count;
86 };
87
88 struct cprng_test_suite {
89 struct cprng_testvec *vecs;
90 unsigned int count;
91 };
92
93 struct alg_test_desc {
94 const char *alg;
95 int (*test)(const struct alg_test_desc *desc, const char *driver,
96 u32 type, u32 mask);
97 int fips_allowed; /* set if alg is allowed in fips mode */
98
99 union {
100 struct aead_test_suite aead;
101 struct cipher_test_suite cipher;
102 struct comp_test_suite comp;
103 struct pcomp_test_suite pcomp;
104 struct hash_test_suite hash;
105 struct cprng_test_suite cprng;
106 } suite;
107 };
108
109 static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
110
111 static void hexdump(unsigned char *buf, unsigned int len)
112 {
113 print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET,
114 16, 1,
115 buf, len, false);
116 }
117
118 static void tcrypt_complete(struct crypto_async_request *req, int err)
119 {
120 struct tcrypt_result *res = req->data;
121
122 if (err == -EINPROGRESS)
123 return;
124
125 res->err = err;
126 complete(&res->completion);
127 }
128
129 static int testmgr_alloc_buf(char *buf[XBUFSIZE])
130 {
131 int i;
132
133 for (i = 0; i < XBUFSIZE; i++) {
134 buf[i] = (void *)__get_free_page(GFP_KERNEL);
135 if (!buf[i])
136 goto err_free_buf;
137 }
138
139 return 0;
140
141 err_free_buf:
142 while (i-- > 0)
143 free_page((unsigned long)buf[i]);
144
145 return -ENOMEM;
146 }
147
148 static void testmgr_free_buf(char *buf[XBUFSIZE])
149 {
150 int i;
151
152 for (i = 0; i < XBUFSIZE; i++)
153 free_page((unsigned long)buf[i]);
154 }
155
156 static int test_hash(struct crypto_ahash *tfm, struct hash_testvec *template,
157 unsigned int tcount)
158 {
159 const char *algo = crypto_tfm_alg_driver_name(crypto_ahash_tfm(tfm));
160 unsigned int i, j, k, temp;
161 struct scatterlist sg[8];
162 char result[64];
163 struct ahash_request *req;
164 struct tcrypt_result tresult;
165 void *hash_buff;
166 char *xbuf[XBUFSIZE];
167 int ret = -ENOMEM;
168
169 if (testmgr_alloc_buf(xbuf))
170 goto out_nobuf;
171
172 init_completion(&tresult.completion);
173
174 req = ahash_request_alloc(tfm, GFP_KERNEL);
175 if (!req) {
176 printk(KERN_ERR "alg: hash: Failed to allocate request for "
177 "%s\n", algo);
178 goto out_noreq;
179 }
180 ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
181 tcrypt_complete, &tresult);
182
183 j = 0;
184 for (i = 0; i < tcount; i++) {
185 if (template[i].np)
186 continue;
187
188 j++;
189 memset(result, 0, 64);
190
191 hash_buff = xbuf[0];
192
193 memcpy(hash_buff, template[i].plaintext, template[i].psize);
194 sg_init_one(&sg[0], hash_buff, template[i].psize);
195
196 if (template[i].ksize) {
197 crypto_ahash_clear_flags(tfm, ~0);
198 ret = crypto_ahash_setkey(tfm, template[i].key,
199 template[i].ksize);
200 if (ret) {
201 printk(KERN_ERR "alg: hash: setkey failed on "
202 "test %d for %s: ret=%d\n", j, algo,
203 -ret);
204 goto out;
205 }
206 }
207
208 ahash_request_set_crypt(req, sg, result, template[i].psize);
209 ret = crypto_ahash_digest(req);
210 switch (ret) {
211 case 0:
212 break;
213 case -EINPROGRESS:
214 case -EBUSY:
215 ret = wait_for_completion_interruptible(
216 &tresult.completion);
217 if (!ret && !(ret = tresult.err)) {
218 INIT_COMPLETION(tresult.completion);
219 break;
220 }
221 /* fall through */
222 default:
223 printk(KERN_ERR "alg: hash: digest failed on test %d "
224 "for %s: ret=%d\n", j, algo, -ret);
225 goto out;
226 }
227
228 if (memcmp(result, template[i].digest,
229 crypto_ahash_digestsize(tfm))) {
230 printk(KERN_ERR "alg: hash: Test %d failed for %s\n",
231 j, algo);
232 hexdump(result, crypto_ahash_digestsize(tfm));
233 ret = -EINVAL;
234 goto out;
235 }
236 }
237
238 j = 0;
239 for (i = 0; i < tcount; i++) {
240 if (template[i].np) {
241 j++;
242 memset(result, 0, 64);
243
244 temp = 0;
245 sg_init_table(sg, template[i].np);
246 ret = -EINVAL;
247 for (k = 0; k < template[i].np; k++) {
248 if (WARN_ON(offset_in_page(IDX[k]) +
249 template[i].tap[k] > PAGE_SIZE))
250 goto out;
251 sg_set_buf(&sg[k],
252 memcpy(xbuf[IDX[k] >> PAGE_SHIFT] +
253 offset_in_page(IDX[k]),
254 template[i].plaintext + temp,
255 template[i].tap[k]),
256 template[i].tap[k]);
257 temp += template[i].tap[k];
258 }
259
260 if (template[i].ksize) {
261 crypto_ahash_clear_flags(tfm, ~0);
262 ret = crypto_ahash_setkey(tfm, template[i].key,
263 template[i].ksize);
264
265 if (ret) {
266 printk(KERN_ERR "alg: hash: setkey "
267 "failed on chunking test %d "
268 "for %s: ret=%d\n", j, algo,
269 -ret);
270 goto out;
271 }
272 }
273
274 ahash_request_set_crypt(req, sg, result,
275 template[i].psize);
276 ret = crypto_ahash_digest(req);
277 switch (ret) {
278 case 0:
279 break;
280 case -EINPROGRESS:
281 case -EBUSY:
282 ret = wait_for_completion_interruptible(
283 &tresult.completion);
284 if (!ret && !(ret = tresult.err)) {
285 INIT_COMPLETION(tresult.completion);
286 break;
287 }
288 /* fall through */
289 default:
290 printk(KERN_ERR "alg: hash: digest failed "
291 "on chunking test %d for %s: "
292 "ret=%d\n", j, algo, -ret);
293 goto out;
294 }
295
296 if (memcmp(result, template[i].digest,
297 crypto_ahash_digestsize(tfm))) {
298 printk(KERN_ERR "alg: hash: Chunking test %d "
299 "failed for %s\n", j, algo);
300 hexdump(result, crypto_ahash_digestsize(tfm));
301 ret = -EINVAL;
302 goto out;
303 }
304 }
305 }
306
307 ret = 0;
308
309 out:
310 ahash_request_free(req);
311 out_noreq:
312 testmgr_free_buf(xbuf);
313 out_nobuf:
314 return ret;
315 }
316
317 static int test_aead(struct crypto_aead *tfm, int enc,
318 struct aead_testvec *template, unsigned int tcount)
319 {
320 const char *algo = crypto_tfm_alg_driver_name(crypto_aead_tfm(tfm));
321 unsigned int i, j, k, n, temp;
322 int ret = -ENOMEM;
323 char *q;
324 char *key;
325 struct aead_request *req;
326 struct scatterlist sg[8];
327 struct scatterlist asg[8];
328 const char *e;
329 struct tcrypt_result result;
330 unsigned int authsize;
331 void *input;
332 void *assoc;
333 char iv[MAX_IVLEN];
334 char *xbuf[XBUFSIZE];
335 char *axbuf[XBUFSIZE];
336
337 if (testmgr_alloc_buf(xbuf))
338 goto out_noxbuf;
339 if (testmgr_alloc_buf(axbuf))
340 goto out_noaxbuf;
341
342 if (enc == ENCRYPT)
343 e = "encryption";
344 else
345 e = "decryption";
346
347 init_completion(&result.completion);
348
349 req = aead_request_alloc(tfm, GFP_KERNEL);
350 if (!req) {
351 printk(KERN_ERR "alg: aead: Failed to allocate request for "
352 "%s\n", algo);
353 goto out;
354 }
355
356 aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
357 tcrypt_complete, &result);
358
359 for (i = 0, j = 0; i < tcount; i++) {
360 if (!template[i].np) {
361 j++;
362
363 /* some tepmplates have no input data but they will
364 * touch input
365 */
366 input = xbuf[0];
367 assoc = axbuf[0];
368
369 ret = -EINVAL;
370 if (WARN_ON(template[i].ilen > PAGE_SIZE ||
371 template[i].alen > PAGE_SIZE))
372 goto out;
373
374 memcpy(input, template[i].input, template[i].ilen);
375 memcpy(assoc, template[i].assoc, template[i].alen);
376 if (template[i].iv)
377 memcpy(iv, template[i].iv, MAX_IVLEN);
378 else
379 memset(iv, 0, MAX_IVLEN);
380
381 crypto_aead_clear_flags(tfm, ~0);
382 if (template[i].wk)
383 crypto_aead_set_flags(
384 tfm, CRYPTO_TFM_REQ_WEAK_KEY);
385
386 key = template[i].key;
387
388 ret = crypto_aead_setkey(tfm, key,
389 template[i].klen);
390 if (!ret == template[i].fail) {
391 printk(KERN_ERR "alg: aead: setkey failed on "
392 "test %d for %s: flags=%x\n", j, algo,
393 crypto_aead_get_flags(tfm));
394 goto out;
395 } else if (ret)
396 continue;
397
398 authsize = abs(template[i].rlen - template[i].ilen);
399 ret = crypto_aead_setauthsize(tfm, authsize);
400 if (ret) {
401 printk(KERN_ERR "alg: aead: Failed to set "
402 "authsize to %u on test %d for %s\n",
403 authsize, j, algo);
404 goto out;
405 }
406
407 sg_init_one(&sg[0], input,
408 template[i].ilen + (enc ? authsize : 0));
409
410 sg_init_one(&asg[0], assoc, template[i].alen);
411
412 aead_request_set_crypt(req, sg, sg,
413 template[i].ilen, iv);
414
415 aead_request_set_assoc(req, asg, template[i].alen);
416
417 ret = enc ?
418 crypto_aead_encrypt(req) :
419 crypto_aead_decrypt(req);
420
421 switch (ret) {
422 case 0:
423 if (template[i].novrfy) {
424 /* verification was supposed to fail */
425 printk(KERN_ERR "alg: aead: %s failed "
426 "on test %d for %s: ret was 0, "
427 "expected -EBADMSG\n",
428 e, j, algo);
429 /* so really, we got a bad message */
430 ret = -EBADMSG;
431 goto out;
432 }
433 break;
434 case -EINPROGRESS:
435 case -EBUSY:
436 ret = wait_for_completion_interruptible(
437 &result.completion);
438 if (!ret && !(ret = result.err)) {
439 INIT_COMPLETION(result.completion);
440 break;
441 }
442 case -EBADMSG:
443 if (template[i].novrfy)
444 /* verification failure was expected */
445 continue;
446 /* fall through */
447 default:
448 printk(KERN_ERR "alg: aead: %s failed on test "
449 "%d for %s: ret=%d\n", e, j, algo, -ret);
450 goto out;
451 }
452
453 q = input;
454 if (memcmp(q, template[i].result, template[i].rlen)) {
455 printk(KERN_ERR "alg: aead: Test %d failed on "
456 "%s for %s\n", j, e, algo);
457 hexdump(q, template[i].rlen);
458 ret = -EINVAL;
459 goto out;
460 }
461 }
462 }
463
464 for (i = 0, j = 0; i < tcount; i++) {
465 if (template[i].np) {
466 j++;
467
468 if (template[i].iv)
469 memcpy(iv, template[i].iv, MAX_IVLEN);
470 else
471 memset(iv, 0, MAX_IVLEN);
472
473 crypto_aead_clear_flags(tfm, ~0);
474 if (template[i].wk)
475 crypto_aead_set_flags(
476 tfm, CRYPTO_TFM_REQ_WEAK_KEY);
477 key = template[i].key;
478
479 ret = crypto_aead_setkey(tfm, key, template[i].klen);
480 if (!ret == template[i].fail) {
481 printk(KERN_ERR "alg: aead: setkey failed on "
482 "chunk test %d for %s: flags=%x\n", j,
483 algo, crypto_aead_get_flags(tfm));
484 goto out;
485 } else if (ret)
486 continue;
487
488 authsize = abs(template[i].rlen - template[i].ilen);
489
490 ret = -EINVAL;
491 sg_init_table(sg, template[i].np);
492 for (k = 0, temp = 0; k < template[i].np; k++) {
493 if (WARN_ON(offset_in_page(IDX[k]) +
494 template[i].tap[k] > PAGE_SIZE))
495 goto out;
496
497 q = xbuf[IDX[k] >> PAGE_SHIFT] +
498 offset_in_page(IDX[k]);
499
500 memcpy(q, template[i].input + temp,
501 template[i].tap[k]);
502
503 n = template[i].tap[k];
504 if (k == template[i].np - 1 && enc)
505 n += authsize;
506 if (offset_in_page(q) + n < PAGE_SIZE)
507 q[n] = 0;
508
509 sg_set_buf(&sg[k], q, template[i].tap[k]);
510 temp += template[i].tap[k];
511 }
512
513 ret = crypto_aead_setauthsize(tfm, authsize);
514 if (ret) {
515 printk(KERN_ERR "alg: aead: Failed to set "
516 "authsize to %u on chunk test %d for "
517 "%s\n", authsize, j, algo);
518 goto out;
519 }
520
521 if (enc) {
522 if (WARN_ON(sg[k - 1].offset +
523 sg[k - 1].length + authsize >
524 PAGE_SIZE)) {
525 ret = -EINVAL;
526 goto out;
527 }
528
529 sg[k - 1].length += authsize;
530 }
531
532 sg_init_table(asg, template[i].anp);
533 ret = -EINVAL;
534 for (k = 0, temp = 0; k < template[i].anp; k++) {
535 if (WARN_ON(offset_in_page(IDX[k]) +
536 template[i].atap[k] > PAGE_SIZE))
537 goto out;
538 sg_set_buf(&asg[k],
539 memcpy(axbuf[IDX[k] >> PAGE_SHIFT] +
540 offset_in_page(IDX[k]),
541 template[i].assoc + temp,
542 template[i].atap[k]),
543 template[i].atap[k]);
544 temp += template[i].atap[k];
545 }
546
547 aead_request_set_crypt(req, sg, sg,
548 template[i].ilen,
549 iv);
550
551 aead_request_set_assoc(req, asg, template[i].alen);
552
553 ret = enc ?
554 crypto_aead_encrypt(req) :
555 crypto_aead_decrypt(req);
556
557 switch (ret) {
558 case 0:
559 if (template[i].novrfy) {
560 /* verification was supposed to fail */
561 printk(KERN_ERR "alg: aead: %s failed "
562 "on chunk test %d for %s: ret "
563 "was 0, expected -EBADMSG\n",
564 e, j, algo);
565 /* so really, we got a bad message */
566 ret = -EBADMSG;
567 goto out;
568 }
569 break;
570 case -EINPROGRESS:
571 case -EBUSY:
572 ret = wait_for_completion_interruptible(
573 &result.completion);
574 if (!ret && !(ret = result.err)) {
575 INIT_COMPLETION(result.completion);
576 break;
577 }
578 case -EBADMSG:
579 if (template[i].novrfy)
580 /* verification failure was expected */
581 continue;
582 /* fall through */
583 default:
584 printk(KERN_ERR "alg: aead: %s failed on "
585 "chunk test %d for %s: ret=%d\n", e, j,
586 algo, -ret);
587 goto out;
588 }
589
590 ret = -EINVAL;
591 for (k = 0, temp = 0; k < template[i].np; k++) {
592 q = xbuf[IDX[k] >> PAGE_SHIFT] +
593 offset_in_page(IDX[k]);
594
595 n = template[i].tap[k];
596 if (k == template[i].np - 1)
597 n += enc ? authsize : -authsize;
598
599 if (memcmp(q, template[i].result + temp, n)) {
600 printk(KERN_ERR "alg: aead: Chunk "
601 "test %d failed on %s at page "
602 "%u for %s\n", j, e, k, algo);
603 hexdump(q, n);
604 goto out;
605 }
606
607 q += n;
608 if (k == template[i].np - 1 && !enc) {
609 if (memcmp(q, template[i].input +
610 temp + n, authsize))
611 n = authsize;
612 else
613 n = 0;
614 } else {
615 for (n = 0; offset_in_page(q + n) &&
616 q[n]; n++)
617 ;
618 }
619 if (n) {
620 printk(KERN_ERR "alg: aead: Result "
621 "buffer corruption in chunk "
622 "test %d on %s at page %u for "
623 "%s: %u bytes:\n", j, e, k,
624 algo, n);
625 hexdump(q, n);
626 goto out;
627 }
628
629 temp += template[i].tap[k];
630 }
631 }
632 }
633
634 ret = 0;
635
636 out:
637 aead_request_free(req);
638 testmgr_free_buf(axbuf);
639 out_noaxbuf:
640 testmgr_free_buf(xbuf);
641 out_noxbuf:
642 return ret;
643 }
644
645 static int test_cipher(struct crypto_cipher *tfm, int enc,
646 struct cipher_testvec *template, unsigned int tcount)
647 {
648 const char *algo = crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm));
649 unsigned int i, j, k;
650 char *q;
651 const char *e;
652 void *data;
653 char *xbuf[XBUFSIZE];
654 int ret = -ENOMEM;
655
656 if (testmgr_alloc_buf(xbuf))
657 goto out_nobuf;
658
659 if (enc == ENCRYPT)
660 e = "encryption";
661 else
662 e = "decryption";
663
664 j = 0;
665 for (i = 0; i < tcount; i++) {
666 if (template[i].np)
667 continue;
668
669 j++;
670
671 ret = -EINVAL;
672 if (WARN_ON(template[i].ilen > PAGE_SIZE))
673 goto out;
674
675 data = xbuf[0];
676 memcpy(data, template[i].input, template[i].ilen);
677
678 crypto_cipher_clear_flags(tfm, ~0);
679 if (template[i].wk)
680 crypto_cipher_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
681
682 ret = crypto_cipher_setkey(tfm, template[i].key,
683 template[i].klen);
684 if (!ret == template[i].fail) {
685 printk(KERN_ERR "alg: cipher: setkey failed "
686 "on test %d for %s: flags=%x\n", j,
687 algo, crypto_cipher_get_flags(tfm));
688 goto out;
689 } else if (ret)
690 continue;
691
692 for (k = 0; k < template[i].ilen;
693 k += crypto_cipher_blocksize(tfm)) {
694 if (enc)
695 crypto_cipher_encrypt_one(tfm, data + k,
696 data + k);
697 else
698 crypto_cipher_decrypt_one(tfm, data + k,
699 data + k);
700 }
701
702 q = data;
703 if (memcmp(q, template[i].result, template[i].rlen)) {
704 printk(KERN_ERR "alg: cipher: Test %d failed "
705 "on %s for %s\n", j, e, algo);
706 hexdump(q, template[i].rlen);
707 ret = -EINVAL;
708 goto out;
709 }
710 }
711
712 ret = 0;
713
714 out:
715 testmgr_free_buf(xbuf);
716 out_nobuf:
717 return ret;
718 }
719
720 static int test_skcipher(struct crypto_ablkcipher *tfm, int enc,
721 struct cipher_testvec *template, unsigned int tcount)
722 {
723 const char *algo =
724 crypto_tfm_alg_driver_name(crypto_ablkcipher_tfm(tfm));
725 unsigned int i, j, k, n, temp;
726 char *q;
727 struct ablkcipher_request *req;
728 struct scatterlist sg[8];
729 const char *e;
730 struct tcrypt_result result;
731 void *data;
732 char iv[MAX_IVLEN];
733 char *xbuf[XBUFSIZE];
734 int ret = -ENOMEM;
735
736 if (testmgr_alloc_buf(xbuf))
737 goto out_nobuf;
738
739 if (enc == ENCRYPT)
740 e = "encryption";
741 else
742 e = "decryption";
743
744 init_completion(&result.completion);
745
746 req = ablkcipher_request_alloc(tfm, GFP_KERNEL);
747 if (!req) {
748 printk(KERN_ERR "alg: skcipher: Failed to allocate request "
749 "for %s\n", algo);
750 goto out;
751 }
752
753 ablkcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
754 tcrypt_complete, &result);
755
756 j = 0;
757 for (i = 0; i < tcount; i++) {
758 if (template[i].iv)
759 memcpy(iv, template[i].iv, MAX_IVLEN);
760 else
761 memset(iv, 0, MAX_IVLEN);
762
763 if (!(template[i].np)) {
764 j++;
765
766 ret = -EINVAL;
767 if (WARN_ON(template[i].ilen > PAGE_SIZE))
768 goto out;
769
770 data = xbuf[0];
771 memcpy(data, template[i].input, template[i].ilen);
772
773 crypto_ablkcipher_clear_flags(tfm, ~0);
774 if (template[i].wk)
775 crypto_ablkcipher_set_flags(
776 tfm, CRYPTO_TFM_REQ_WEAK_KEY);
777
778 ret = crypto_ablkcipher_setkey(tfm, template[i].key,
779 template[i].klen);
780 if (!ret == template[i].fail) {
781 printk(KERN_ERR "alg: skcipher: setkey failed "
782 "on test %d for %s: flags=%x\n", j,
783 algo, crypto_ablkcipher_get_flags(tfm));
784 goto out;
785 } else if (ret)
786 continue;
787
788 sg_init_one(&sg[0], data, template[i].ilen);
789
790 ablkcipher_request_set_crypt(req, sg, sg,
791 template[i].ilen, iv);
792 ret = enc ?
793 crypto_ablkcipher_encrypt(req) :
794 crypto_ablkcipher_decrypt(req);
795
796 switch (ret) {
797 case 0:
798 break;
799 case -EINPROGRESS:
800 case -EBUSY:
801 ret = wait_for_completion_interruptible(
802 &result.completion);
803 if (!ret && !((ret = result.err))) {
804 INIT_COMPLETION(result.completion);
805 break;
806 }
807 /* fall through */
808 default:
809 printk(KERN_ERR "alg: skcipher: %s failed on "
810 "test %d for %s: ret=%d\n", e, j, algo,
811 -ret);
812 goto out;
813 }
814
815 q = data;
816 if (memcmp(q, template[i].result, template[i].rlen)) {
817 printk(KERN_ERR "alg: skcipher: Test %d "
818 "failed on %s for %s\n", j, e, algo);
819 hexdump(q, template[i].rlen);
820 ret = -EINVAL;
821 goto out;
822 }
823 }
824 }
825
826 j = 0;
827 for (i = 0; i < tcount; i++) {
828
829 if (template[i].iv)
830 memcpy(iv, template[i].iv, MAX_IVLEN);
831 else
832 memset(iv, 0, MAX_IVLEN);
833
834 if (template[i].np) {
835 j++;
836
837 crypto_ablkcipher_clear_flags(tfm, ~0);
838 if (template[i].wk)
839 crypto_ablkcipher_set_flags(
840 tfm, CRYPTO_TFM_REQ_WEAK_KEY);
841
842 ret = crypto_ablkcipher_setkey(tfm, template[i].key,
843 template[i].klen);
844 if (!ret == template[i].fail) {
845 printk(KERN_ERR "alg: skcipher: setkey failed "
846 "on chunk test %d for %s: flags=%x\n",
847 j, algo,
848 crypto_ablkcipher_get_flags(tfm));
849 goto out;
850 } else if (ret)
851 continue;
852
853 temp = 0;
854 ret = -EINVAL;
855 sg_init_table(sg, template[i].np);
856 for (k = 0; k < template[i].np; k++) {
857 if (WARN_ON(offset_in_page(IDX[k]) +
858 template[i].tap[k] > PAGE_SIZE))
859 goto out;
860
861 q = xbuf[IDX[k] >> PAGE_SHIFT] +
862 offset_in_page(IDX[k]);
863
864 memcpy(q, template[i].input + temp,
865 template[i].tap[k]);
866
867 if (offset_in_page(q) + template[i].tap[k] <
868 PAGE_SIZE)
869 q[template[i].tap[k]] = 0;
870
871 sg_set_buf(&sg[k], q, template[i].tap[k]);
872
873 temp += template[i].tap[k];
874 }
875
876 ablkcipher_request_set_crypt(req, sg, sg,
877 template[i].ilen, iv);
878
879 ret = enc ?
880 crypto_ablkcipher_encrypt(req) :
881 crypto_ablkcipher_decrypt(req);
882
883 switch (ret) {
884 case 0:
885 break;
886 case -EINPROGRESS:
887 case -EBUSY:
888 ret = wait_for_completion_interruptible(
889 &result.completion);
890 if (!ret && !((ret = result.err))) {
891 INIT_COMPLETION(result.completion);
892 break;
893 }
894 /* fall through */
895 default:
896 printk(KERN_ERR "alg: skcipher: %s failed on "
897 "chunk test %d for %s: ret=%d\n", e, j,
898 algo, -ret);
899 goto out;
900 }
901
902 temp = 0;
903 ret = -EINVAL;
904 for (k = 0; k < template[i].np; k++) {
905 q = xbuf[IDX[k] >> PAGE_SHIFT] +
906 offset_in_page(IDX[k]);
907
908 if (memcmp(q, template[i].result + temp,
909 template[i].tap[k])) {
910 printk(KERN_ERR "alg: skcipher: Chunk "
911 "test %d failed on %s at page "
912 "%u for %s\n", j, e, k, algo);
913 hexdump(q, template[i].tap[k]);
914 goto out;
915 }
916
917 q += template[i].tap[k];
918 for (n = 0; offset_in_page(q + n) && q[n]; n++)
919 ;
920 if (n) {
921 printk(KERN_ERR "alg: skcipher: "
922 "Result buffer corruption in "
923 "chunk test %d on %s at page "
924 "%u for %s: %u bytes:\n", j, e,
925 k, algo, n);
926 hexdump(q, n);
927 goto out;
928 }
929 temp += template[i].tap[k];
930 }
931 }
932 }
933
934 ret = 0;
935
936 out:
937 ablkcipher_request_free(req);
938 testmgr_free_buf(xbuf);
939 out_nobuf:
940 return ret;
941 }
942
943 static int test_comp(struct crypto_comp *tfm, struct comp_testvec *ctemplate,
944 struct comp_testvec *dtemplate, int ctcount, int dtcount)
945 {
946 const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm));
947 unsigned int i;
948 char result[COMP_BUF_SIZE];
949 int ret;
950
951 for (i = 0; i < ctcount; i++) {
952 int ilen;
953 unsigned int dlen = COMP_BUF_SIZE;
954
955 memset(result, 0, sizeof (result));
956
957 ilen = ctemplate[i].inlen;
958 ret = crypto_comp_compress(tfm, ctemplate[i].input,
959 ilen, result, &dlen);
960 if (ret) {
961 printk(KERN_ERR "alg: comp: compression failed "
962 "on test %d for %s: ret=%d\n", i + 1, algo,
963 -ret);
964 goto out;
965 }
966
967 if (dlen != ctemplate[i].outlen) {
968 printk(KERN_ERR "alg: comp: Compression test %d "
969 "failed for %s: output len = %d\n", i + 1, algo,
970 dlen);
971 ret = -EINVAL;
972 goto out;
973 }
974
975 if (memcmp(result, ctemplate[i].output, dlen)) {
976 printk(KERN_ERR "alg: comp: Compression test %d "
977 "failed for %s\n", i + 1, algo);
978 hexdump(result, dlen);
979 ret = -EINVAL;
980 goto out;
981 }
982 }
983
984 for (i = 0; i < dtcount; i++) {
985 int ilen;
986 unsigned int dlen = COMP_BUF_SIZE;
987
988 memset(result, 0, sizeof (result));
989
990 ilen = dtemplate[i].inlen;
991 ret = crypto_comp_decompress(tfm, dtemplate[i].input,
992 ilen, result, &dlen);
993 if (ret) {
994 printk(KERN_ERR "alg: comp: decompression failed "
995 "on test %d for %s: ret=%d\n", i + 1, algo,
996 -ret);
997 goto out;
998 }
999
1000 if (dlen != dtemplate[i].outlen) {
1001 printk(KERN_ERR "alg: comp: Decompression test %d "
1002 "failed for %s: output len = %d\n", i + 1, algo,
1003 dlen);
1004 ret = -EINVAL;
1005 goto out;
1006 }
1007
1008 if (memcmp(result, dtemplate[i].output, dlen)) {
1009 printk(KERN_ERR "alg: comp: Decompression test %d "
1010 "failed for %s\n", i + 1, algo);
1011 hexdump(result, dlen);
1012 ret = -EINVAL;
1013 goto out;
1014 }
1015 }
1016
1017 ret = 0;
1018
1019 out:
1020 return ret;
1021 }
1022
1023 static int test_pcomp(struct crypto_pcomp *tfm,
1024 struct pcomp_testvec *ctemplate,
1025 struct pcomp_testvec *dtemplate, int ctcount,
1026 int dtcount)
1027 {
1028 const char *algo = crypto_tfm_alg_driver_name(crypto_pcomp_tfm(tfm));
1029 unsigned int i;
1030 char result[COMP_BUF_SIZE];
1031 int res;
1032
1033 for (i = 0; i < ctcount; i++) {
1034 struct comp_request req;
1035 unsigned int produced = 0;
1036
1037 res = crypto_compress_setup(tfm, ctemplate[i].params,
1038 ctemplate[i].paramsize);
1039 if (res) {
1040 pr_err("alg: pcomp: compression setup failed on test "
1041 "%d for %s: error=%d\n", i + 1, algo, res);
1042 return res;
1043 }
1044
1045 res = crypto_compress_init(tfm);
1046 if (res) {
1047 pr_err("alg: pcomp: compression init failed on test "
1048 "%d for %s: error=%d\n", i + 1, algo, res);
1049 return res;
1050 }
1051
1052 memset(result, 0, sizeof(result));
1053
1054 req.next_in = ctemplate[i].input;
1055 req.avail_in = ctemplate[i].inlen / 2;
1056 req.next_out = result;
1057 req.avail_out = ctemplate[i].outlen / 2;
1058
1059 res = crypto_compress_update(tfm, &req);
1060 if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1061 pr_err("alg: pcomp: compression update failed on test "
1062 "%d for %s: error=%d\n", i + 1, algo, res);
1063 return res;
1064 }
1065 if (res > 0)
1066 produced += res;
1067
1068 /* Add remaining input data */
1069 req.avail_in += (ctemplate[i].inlen + 1) / 2;
1070
1071 res = crypto_compress_update(tfm, &req);
1072 if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1073 pr_err("alg: pcomp: compression update failed on test "
1074 "%d for %s: error=%d\n", i + 1, algo, res);
1075 return res;
1076 }
1077 if (res > 0)
1078 produced += res;
1079
1080 /* Provide remaining output space */
1081 req.avail_out += COMP_BUF_SIZE - ctemplate[i].outlen / 2;
1082
1083 res = crypto_compress_final(tfm, &req);
1084 if (res < 0) {
1085 pr_err("alg: pcomp: compression final failed on test "
1086 "%d for %s: error=%d\n", i + 1, algo, res);
1087 return res;
1088 }
1089 produced += res;
1090
1091 if (COMP_BUF_SIZE - req.avail_out != ctemplate[i].outlen) {
1092 pr_err("alg: comp: Compression test %d failed for %s: "
1093 "output len = %d (expected %d)\n", i + 1, algo,
1094 COMP_BUF_SIZE - req.avail_out,
1095 ctemplate[i].outlen);
1096 return -EINVAL;
1097 }
1098
1099 if (produced != ctemplate[i].outlen) {
1100 pr_err("alg: comp: Compression test %d failed for %s: "
1101 "returned len = %u (expected %d)\n", i + 1,
1102 algo, produced, ctemplate[i].outlen);
1103 return -EINVAL;
1104 }
1105
1106 if (memcmp(result, ctemplate[i].output, ctemplate[i].outlen)) {
1107 pr_err("alg: pcomp: Compression test %d failed for "
1108 "%s\n", i + 1, algo);
1109 hexdump(result, ctemplate[i].outlen);
1110 return -EINVAL;
1111 }
1112 }
1113
1114 for (i = 0; i < dtcount; i++) {
1115 struct comp_request req;
1116 unsigned int produced = 0;
1117
1118 res = crypto_decompress_setup(tfm, dtemplate[i].params,
1119 dtemplate[i].paramsize);
1120 if (res) {
1121 pr_err("alg: pcomp: decompression setup failed on "
1122 "test %d for %s: error=%d\n", i + 1, algo, res);
1123 return res;
1124 }
1125
1126 res = crypto_decompress_init(tfm);
1127 if (res) {
1128 pr_err("alg: pcomp: decompression init failed on test "
1129 "%d for %s: error=%d\n", i + 1, algo, res);
1130 return res;
1131 }
1132
1133 memset(result, 0, sizeof(result));
1134
1135 req.next_in = dtemplate[i].input;
1136 req.avail_in = dtemplate[i].inlen / 2;
1137 req.next_out = result;
1138 req.avail_out = dtemplate[i].outlen / 2;
1139
1140 res = crypto_decompress_update(tfm, &req);
1141 if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1142 pr_err("alg: pcomp: decompression update failed on "
1143 "test %d for %s: error=%d\n", i + 1, algo, res);
1144 return res;
1145 }
1146 if (res > 0)
1147 produced += res;
1148
1149 /* Add remaining input data */
1150 req.avail_in += (dtemplate[i].inlen + 1) / 2;
1151
1152 res = crypto_decompress_update(tfm, &req);
1153 if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1154 pr_err("alg: pcomp: decompression update failed on "
1155 "test %d for %s: error=%d\n", i + 1, algo, res);
1156 return res;
1157 }
1158 if (res > 0)
1159 produced += res;
1160
1161 /* Provide remaining output space */
1162 req.avail_out += COMP_BUF_SIZE - dtemplate[i].outlen / 2;
1163
1164 res = crypto_decompress_final(tfm, &req);
1165 if (res < 0 && (res != -EAGAIN || req.avail_in)) {
1166 pr_err("alg: pcomp: decompression final failed on "
1167 "test %d for %s: error=%d\n", i + 1, algo, res);
1168 return res;
1169 }
1170 if (res > 0)
1171 produced += res;
1172
1173 if (COMP_BUF_SIZE - req.avail_out != dtemplate[i].outlen) {
1174 pr_err("alg: comp: Decompression test %d failed for "
1175 "%s: output len = %d (expected %d)\n", i + 1,
1176 algo, COMP_BUF_SIZE - req.avail_out,
1177 dtemplate[i].outlen);
1178 return -EINVAL;
1179 }
1180
1181 if (produced != dtemplate[i].outlen) {
1182 pr_err("alg: comp: Decompression test %d failed for "
1183 "%s: returned len = %u (expected %d)\n", i + 1,
1184 algo, produced, dtemplate[i].outlen);
1185 return -EINVAL;
1186 }
1187
1188 if (memcmp(result, dtemplate[i].output, dtemplate[i].outlen)) {
1189 pr_err("alg: pcomp: Decompression test %d failed for "
1190 "%s\n", i + 1, algo);
1191 hexdump(result, dtemplate[i].outlen);
1192 return -EINVAL;
1193 }
1194 }
1195
1196 return 0;
1197 }
1198
1199
1200 static int test_cprng(struct crypto_rng *tfm, struct cprng_testvec *template,
1201 unsigned int tcount)
1202 {
1203 const char *algo = crypto_tfm_alg_driver_name(crypto_rng_tfm(tfm));
1204 int err = 0, i, j, seedsize;
1205 u8 *seed;
1206 char result[32];
1207
1208 seedsize = crypto_rng_seedsize(tfm);
1209
1210 seed = kmalloc(seedsize, GFP_KERNEL);
1211 if (!seed) {
1212 printk(KERN_ERR "alg: cprng: Failed to allocate seed space "
1213 "for %s\n", algo);
1214 return -ENOMEM;
1215 }
1216
1217 for (i = 0; i < tcount; i++) {
1218 memset(result, 0, 32);
1219
1220 memcpy(seed, template[i].v, template[i].vlen);
1221 memcpy(seed + template[i].vlen, template[i].key,
1222 template[i].klen);
1223 memcpy(seed + template[i].vlen + template[i].klen,
1224 template[i].dt, template[i].dtlen);
1225
1226 err = crypto_rng_reset(tfm, seed, seedsize);
1227 if (err) {
1228 printk(KERN_ERR "alg: cprng: Failed to reset rng "
1229 "for %s\n", algo);
1230 goto out;
1231 }
1232
1233 for (j = 0; j < template[i].loops; j++) {
1234 err = crypto_rng_get_bytes(tfm, result,
1235 template[i].rlen);
1236 if (err != template[i].rlen) {
1237 printk(KERN_ERR "alg: cprng: Failed to obtain "
1238 "the correct amount of random data for "
1239 "%s (requested %d, got %d)\n", algo,
1240 template[i].rlen, err);
1241 goto out;
1242 }
1243 }
1244
1245 err = memcmp(result, template[i].result,
1246 template[i].rlen);
1247 if (err) {
1248 printk(KERN_ERR "alg: cprng: Test %d failed for %s\n",
1249 i, algo);
1250 hexdump(result, template[i].rlen);
1251 err = -EINVAL;
1252 goto out;
1253 }
1254 }
1255
1256 out:
1257 kfree(seed);
1258 return err;
1259 }
1260
1261 static int alg_test_aead(const struct alg_test_desc *desc, const char *driver,
1262 u32 type, u32 mask)
1263 {
1264 struct crypto_aead *tfm;
1265 int err = 0;
1266
1267 tfm = crypto_alloc_aead(driver, type, mask);
1268 if (IS_ERR(tfm)) {
1269 printk(KERN_ERR "alg: aead: Failed to load transform for %s: "
1270 "%ld\n", driver, PTR_ERR(tfm));
1271 return PTR_ERR(tfm);
1272 }
1273
1274 if (desc->suite.aead.enc.vecs) {
1275 err = test_aead(tfm, ENCRYPT, desc->suite.aead.enc.vecs,
1276 desc->suite.aead.enc.count);
1277 if (err)
1278 goto out;
1279 }
1280
1281 if (!err && desc->suite.aead.dec.vecs)
1282 err = test_aead(tfm, DECRYPT, desc->suite.aead.dec.vecs,
1283 desc->suite.aead.dec.count);
1284
1285 out:
1286 crypto_free_aead(tfm);
1287 return err;
1288 }
1289
1290 static int alg_test_cipher(const struct alg_test_desc *desc,
1291 const char *driver, u32 type, u32 mask)
1292 {
1293 struct crypto_cipher *tfm;
1294 int err = 0;
1295
1296 tfm = crypto_alloc_cipher(driver, type, mask);
1297 if (IS_ERR(tfm)) {
1298 printk(KERN_ERR "alg: cipher: Failed to load transform for "
1299 "%s: %ld\n", driver, PTR_ERR(tfm));
1300 return PTR_ERR(tfm);
1301 }
1302
1303 if (desc->suite.cipher.enc.vecs) {
1304 err = test_cipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
1305 desc->suite.cipher.enc.count);
1306 if (err)
1307 goto out;
1308 }
1309
1310 if (desc->suite.cipher.dec.vecs)
1311 err = test_cipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
1312 desc->suite.cipher.dec.count);
1313
1314 out:
1315 crypto_free_cipher(tfm);
1316 return err;
1317 }
1318
1319 static int alg_test_skcipher(const struct alg_test_desc *desc,
1320 const char *driver, u32 type, u32 mask)
1321 {
1322 struct crypto_ablkcipher *tfm;
1323 int err = 0;
1324
1325 tfm = crypto_alloc_ablkcipher(driver, type, mask);
1326 if (IS_ERR(tfm)) {
1327 printk(KERN_ERR "alg: skcipher: Failed to load transform for "
1328 "%s: %ld\n", driver, PTR_ERR(tfm));
1329 return PTR_ERR(tfm);
1330 }
1331
1332 if (desc->suite.cipher.enc.vecs) {
1333 err = test_skcipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
1334 desc->suite.cipher.enc.count);
1335 if (err)
1336 goto out;
1337 }
1338
1339 if (desc->suite.cipher.dec.vecs)
1340 err = test_skcipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
1341 desc->suite.cipher.dec.count);
1342
1343 out:
1344 crypto_free_ablkcipher(tfm);
1345 return err;
1346 }
1347
1348 static int alg_test_comp(const struct alg_test_desc *desc, const char *driver,
1349 u32 type, u32 mask)
1350 {
1351 struct crypto_comp *tfm;
1352 int err;
1353
1354 tfm = crypto_alloc_comp(driver, type, mask);
1355 if (IS_ERR(tfm)) {
1356 printk(KERN_ERR "alg: comp: Failed to load transform for %s: "
1357 "%ld\n", driver, PTR_ERR(tfm));
1358 return PTR_ERR(tfm);
1359 }
1360
1361 err = test_comp(tfm, desc->suite.comp.comp.vecs,
1362 desc->suite.comp.decomp.vecs,
1363 desc->suite.comp.comp.count,
1364 desc->suite.comp.decomp.count);
1365
1366 crypto_free_comp(tfm);
1367 return err;
1368 }
1369
1370 static int alg_test_pcomp(const struct alg_test_desc *desc, const char *driver,
1371 u32 type, u32 mask)
1372 {
1373 struct crypto_pcomp *tfm;
1374 int err;
1375
1376 tfm = crypto_alloc_pcomp(driver, type, mask);
1377 if (IS_ERR(tfm)) {
1378 pr_err("alg: pcomp: Failed to load transform for %s: %ld\n",
1379 driver, PTR_ERR(tfm));
1380 return PTR_ERR(tfm);
1381 }
1382
1383 err = test_pcomp(tfm, desc->suite.pcomp.comp.vecs,
1384 desc->suite.pcomp.decomp.vecs,
1385 desc->suite.pcomp.comp.count,
1386 desc->suite.pcomp.decomp.count);
1387
1388 crypto_free_pcomp(tfm);
1389 return err;
1390 }
1391
1392 static int alg_test_hash(const struct alg_test_desc *desc, const char *driver,
1393 u32 type, u32 mask)
1394 {
1395 struct crypto_ahash *tfm;
1396 int err;
1397
1398 tfm = crypto_alloc_ahash(driver, type, mask);
1399 if (IS_ERR(tfm)) {
1400 printk(KERN_ERR "alg: hash: Failed to load transform for %s: "
1401 "%ld\n", driver, PTR_ERR(tfm));
1402 return PTR_ERR(tfm);
1403 }
1404
1405 err = test_hash(tfm, desc->suite.hash.vecs, desc->suite.hash.count);
1406
1407 crypto_free_ahash(tfm);
1408 return err;
1409 }
1410
1411 static int alg_test_crc32c(const struct alg_test_desc *desc,
1412 const char *driver, u32 type, u32 mask)
1413 {
1414 struct crypto_shash *tfm;
1415 u32 val;
1416 int err;
1417
1418 err = alg_test_hash(desc, driver, type, mask);
1419 if (err)
1420 goto out;
1421
1422 tfm = crypto_alloc_shash(driver, type, mask);
1423 if (IS_ERR(tfm)) {
1424 printk(KERN_ERR "alg: crc32c: Failed to load transform for %s: "
1425 "%ld\n", driver, PTR_ERR(tfm));
1426 err = PTR_ERR(tfm);
1427 goto out;
1428 }
1429
1430 do {
1431 struct {
1432 struct shash_desc shash;
1433 char ctx[crypto_shash_descsize(tfm)];
1434 } sdesc;
1435
1436 sdesc.shash.tfm = tfm;
1437 sdesc.shash.flags = 0;
1438
1439 *(u32 *)sdesc.ctx = le32_to_cpu(420553207);
1440 err = crypto_shash_final(&sdesc.shash, (u8 *)&val);
1441 if (err) {
1442 printk(KERN_ERR "alg: crc32c: Operation failed for "
1443 "%s: %d\n", driver, err);
1444 break;
1445 }
1446
1447 if (val != ~420553207) {
1448 printk(KERN_ERR "alg: crc32c: Test failed for %s: "
1449 "%d\n", driver, val);
1450 err = -EINVAL;
1451 }
1452 } while (0);
1453
1454 crypto_free_shash(tfm);
1455
1456 out:
1457 return err;
1458 }
1459
1460 static int alg_test_cprng(const struct alg_test_desc *desc, const char *driver,
1461 u32 type, u32 mask)
1462 {
1463 struct crypto_rng *rng;
1464 int err;
1465
1466 rng = crypto_alloc_rng(driver, type, mask);
1467 if (IS_ERR(rng)) {
1468 printk(KERN_ERR "alg: cprng: Failed to load transform for %s: "
1469 "%ld\n", driver, PTR_ERR(rng));
1470 return PTR_ERR(rng);
1471 }
1472
1473 err = test_cprng(rng, desc->suite.cprng.vecs, desc->suite.cprng.count);
1474
1475 crypto_free_rng(rng);
1476
1477 return err;
1478 }
1479
1480 static int alg_test_null(const struct alg_test_desc *desc,
1481 const char *driver, u32 type, u32 mask)
1482 {
1483 return 0;
1484 }
1485
1486 /* Please keep this list sorted by algorithm name. */
1487 static const struct alg_test_desc alg_test_descs[] = {
1488 {
1489 .alg = "__driver-cbc-aes-aesni",
1490 .test = alg_test_null,
1491 .suite = {
1492 .cipher = {
1493 .enc = {
1494 .vecs = NULL,
1495 .count = 0
1496 },
1497 .dec = {
1498 .vecs = NULL,
1499 .count = 0
1500 }
1501 }
1502 }
1503 }, {
1504 .alg = "__driver-ecb-aes-aesni",
1505 .test = alg_test_null,
1506 .suite = {
1507 .cipher = {
1508 .enc = {
1509 .vecs = NULL,
1510 .count = 0
1511 },
1512 .dec = {
1513 .vecs = NULL,
1514 .count = 0
1515 }
1516 }
1517 }
1518 }, {
1519 .alg = "__ghash-pclmulqdqni",
1520 .test = alg_test_null,
1521 .suite = {
1522 .hash = {
1523 .vecs = NULL,
1524 .count = 0
1525 }
1526 }
1527 }, {
1528 .alg = "ansi_cprng",
1529 .test = alg_test_cprng,
1530 .fips_allowed = 1,
1531 .suite = {
1532 .cprng = {
1533 .vecs = ansi_cprng_aes_tv_template,
1534 .count = ANSI_CPRNG_AES_TEST_VECTORS
1535 }
1536 }
1537 }, {
1538 .alg = "cbc(aes)",
1539 .test = alg_test_skcipher,
1540 .fips_allowed = 1,
1541 .suite = {
1542 .cipher = {
1543 .enc = {
1544 .vecs = aes_cbc_enc_tv_template,
1545 .count = AES_CBC_ENC_TEST_VECTORS
1546 },
1547 .dec = {
1548 .vecs = aes_cbc_dec_tv_template,
1549 .count = AES_CBC_DEC_TEST_VECTORS
1550 }
1551 }
1552 }
1553 }, {
1554 .alg = "cbc(anubis)",
1555 .test = alg_test_skcipher,
1556 .suite = {
1557 .cipher = {
1558 .enc = {
1559 .vecs = anubis_cbc_enc_tv_template,
1560 .count = ANUBIS_CBC_ENC_TEST_VECTORS
1561 },
1562 .dec = {
1563 .vecs = anubis_cbc_dec_tv_template,
1564 .count = ANUBIS_CBC_DEC_TEST_VECTORS
1565 }
1566 }
1567 }
1568 }, {
1569 .alg = "cbc(blowfish)",
1570 .test = alg_test_skcipher,
1571 .suite = {
1572 .cipher = {
1573 .enc = {
1574 .vecs = bf_cbc_enc_tv_template,
1575 .count = BF_CBC_ENC_TEST_VECTORS
1576 },
1577 .dec = {
1578 .vecs = bf_cbc_dec_tv_template,
1579 .count = BF_CBC_DEC_TEST_VECTORS
1580 }
1581 }
1582 }
1583 }, {
1584 .alg = "cbc(camellia)",
1585 .test = alg_test_skcipher,
1586 .suite = {
1587 .cipher = {
1588 .enc = {
1589 .vecs = camellia_cbc_enc_tv_template,
1590 .count = CAMELLIA_CBC_ENC_TEST_VECTORS
1591 },
1592 .dec = {
1593 .vecs = camellia_cbc_dec_tv_template,
1594 .count = CAMELLIA_CBC_DEC_TEST_VECTORS
1595 }
1596 }
1597 }
1598 }, {
1599 .alg = "cbc(des)",
1600 .test = alg_test_skcipher,
1601 .suite = {
1602 .cipher = {
1603 .enc = {
1604 .vecs = des_cbc_enc_tv_template,
1605 .count = DES_CBC_ENC_TEST_VECTORS
1606 },
1607 .dec = {
1608 .vecs = des_cbc_dec_tv_template,
1609 .count = DES_CBC_DEC_TEST_VECTORS
1610 }
1611 }
1612 }
1613 }, {
1614 .alg = "cbc(des3_ede)",
1615 .test = alg_test_skcipher,
1616 .fips_allowed = 1,
1617 .suite = {
1618 .cipher = {
1619 .enc = {
1620 .vecs = des3_ede_cbc_enc_tv_template,
1621 .count = DES3_EDE_CBC_ENC_TEST_VECTORS
1622 },
1623 .dec = {
1624 .vecs = des3_ede_cbc_dec_tv_template,
1625 .count = DES3_EDE_CBC_DEC_TEST_VECTORS
1626 }
1627 }
1628 }
1629 }, {
1630 .alg = "cbc(twofish)",
1631 .test = alg_test_skcipher,
1632 .suite = {
1633 .cipher = {
1634 .enc = {
1635 .vecs = tf_cbc_enc_tv_template,
1636 .count = TF_CBC_ENC_TEST_VECTORS
1637 },
1638 .dec = {
1639 .vecs = tf_cbc_dec_tv_template,
1640 .count = TF_CBC_DEC_TEST_VECTORS
1641 }
1642 }
1643 }
1644 }, {
1645 .alg = "ccm(aes)",
1646 .test = alg_test_aead,
1647 .fips_allowed = 1,
1648 .suite = {
1649 .aead = {
1650 .enc = {
1651 .vecs = aes_ccm_enc_tv_template,
1652 .count = AES_CCM_ENC_TEST_VECTORS
1653 },
1654 .dec = {
1655 .vecs = aes_ccm_dec_tv_template,
1656 .count = AES_CCM_DEC_TEST_VECTORS
1657 }
1658 }
1659 }
1660 }, {
1661 .alg = "crc32c",
1662 .test = alg_test_crc32c,
1663 .fips_allowed = 1,
1664 .suite = {
1665 .hash = {
1666 .vecs = crc32c_tv_template,
1667 .count = CRC32C_TEST_VECTORS
1668 }
1669 }
1670 }, {
1671 .alg = "cryptd(__driver-ecb-aes-aesni)",
1672 .test = alg_test_null,
1673 .suite = {
1674 .cipher = {
1675 .enc = {
1676 .vecs = NULL,
1677 .count = 0
1678 },
1679 .dec = {
1680 .vecs = NULL,
1681 .count = 0
1682 }
1683 }
1684 }
1685 }, {
1686 .alg = "cryptd(__ghash-pclmulqdqni)",
1687 .test = alg_test_null,
1688 .suite = {
1689 .hash = {
1690 .vecs = NULL,
1691 .count = 0
1692 }
1693 }
1694 }, {
1695 .alg = "ctr(aes)",
1696 .test = alg_test_skcipher,
1697 .fips_allowed = 1,
1698 .suite = {
1699 .cipher = {
1700 .enc = {
1701 .vecs = aes_ctr_enc_tv_template,
1702 .count = AES_CTR_ENC_TEST_VECTORS
1703 },
1704 .dec = {
1705 .vecs = aes_ctr_dec_tv_template,
1706 .count = AES_CTR_DEC_TEST_VECTORS
1707 }
1708 }
1709 }
1710 }, {
1711 .alg = "cts(cbc(aes))",
1712 .test = alg_test_skcipher,
1713 .suite = {
1714 .cipher = {
1715 .enc = {
1716 .vecs = cts_mode_enc_tv_template,
1717 .count = CTS_MODE_ENC_TEST_VECTORS
1718 },
1719 .dec = {
1720 .vecs = cts_mode_dec_tv_template,
1721 .count = CTS_MODE_DEC_TEST_VECTORS
1722 }
1723 }
1724 }
1725 }, {
1726 .alg = "deflate",
1727 .test = alg_test_comp,
1728 .suite = {
1729 .comp = {
1730 .comp = {
1731 .vecs = deflate_comp_tv_template,
1732 .count = DEFLATE_COMP_TEST_VECTORS
1733 },
1734 .decomp = {
1735 .vecs = deflate_decomp_tv_template,
1736 .count = DEFLATE_DECOMP_TEST_VECTORS
1737 }
1738 }
1739 }
1740 }, {
1741 .alg = "ecb(__aes-aesni)",
1742 .test = alg_test_null,
1743 .suite = {
1744 .cipher = {
1745 .enc = {
1746 .vecs = NULL,
1747 .count = 0
1748 },
1749 .dec = {
1750 .vecs = NULL,
1751 .count = 0
1752 }
1753 }
1754 }
1755 }, {
1756 .alg = "ecb(aes)",
1757 .test = alg_test_skcipher,
1758 .fips_allowed = 1,
1759 .suite = {
1760 .cipher = {
1761 .enc = {
1762 .vecs = aes_enc_tv_template,
1763 .count = AES_ENC_TEST_VECTORS
1764 },
1765 .dec = {
1766 .vecs = aes_dec_tv_template,
1767 .count = AES_DEC_TEST_VECTORS
1768 }
1769 }
1770 }
1771 }, {
1772 .alg = "ecb(anubis)",
1773 .test = alg_test_skcipher,
1774 .suite = {
1775 .cipher = {
1776 .enc = {
1777 .vecs = anubis_enc_tv_template,
1778 .count = ANUBIS_ENC_TEST_VECTORS
1779 },
1780 .dec = {
1781 .vecs = anubis_dec_tv_template,
1782 .count = ANUBIS_DEC_TEST_VECTORS
1783 }
1784 }
1785 }
1786 }, {
1787 .alg = "ecb(arc4)",
1788 .test = alg_test_skcipher,
1789 .suite = {
1790 .cipher = {
1791 .enc = {
1792 .vecs = arc4_enc_tv_template,
1793 .count = ARC4_ENC_TEST_VECTORS
1794 },
1795 .dec = {
1796 .vecs = arc4_dec_tv_template,
1797 .count = ARC4_DEC_TEST_VECTORS
1798 }
1799 }
1800 }
1801 }, {
1802 .alg = "ecb(blowfish)",
1803 .test = alg_test_skcipher,
1804 .suite = {
1805 .cipher = {
1806 .enc = {
1807 .vecs = bf_enc_tv_template,
1808 .count = BF_ENC_TEST_VECTORS
1809 },
1810 .dec = {
1811 .vecs = bf_dec_tv_template,
1812 .count = BF_DEC_TEST_VECTORS
1813 }
1814 }
1815 }
1816 }, {
1817 .alg = "ecb(camellia)",
1818 .test = alg_test_skcipher,
1819 .suite = {
1820 .cipher = {
1821 .enc = {
1822 .vecs = camellia_enc_tv_template,
1823 .count = CAMELLIA_ENC_TEST_VECTORS
1824 },
1825 .dec = {
1826 .vecs = camellia_dec_tv_template,
1827 .count = CAMELLIA_DEC_TEST_VECTORS
1828 }
1829 }
1830 }
1831 }, {
1832 .alg = "ecb(cast5)",
1833 .test = alg_test_skcipher,
1834 .suite = {
1835 .cipher = {
1836 .enc = {
1837 .vecs = cast5_enc_tv_template,
1838 .count = CAST5_ENC_TEST_VECTORS
1839 },
1840 .dec = {
1841 .vecs = cast5_dec_tv_template,
1842 .count = CAST5_DEC_TEST_VECTORS
1843 }
1844 }
1845 }
1846 }, {
1847 .alg = "ecb(cast6)",
1848 .test = alg_test_skcipher,
1849 .suite = {
1850 .cipher = {
1851 .enc = {
1852 .vecs = cast6_enc_tv_template,
1853 .count = CAST6_ENC_TEST_VECTORS
1854 },
1855 .dec = {
1856 .vecs = cast6_dec_tv_template,
1857 .count = CAST6_DEC_TEST_VECTORS
1858 }
1859 }
1860 }
1861 }, {
1862 .alg = "ecb(des)",
1863 .test = alg_test_skcipher,
1864 .fips_allowed = 1,
1865 .suite = {
1866 .cipher = {
1867 .enc = {
1868 .vecs = des_enc_tv_template,
1869 .count = DES_ENC_TEST_VECTORS
1870 },
1871 .dec = {
1872 .vecs = des_dec_tv_template,
1873 .count = DES_DEC_TEST_VECTORS
1874 }
1875 }
1876 }
1877 }, {
1878 .alg = "ecb(des3_ede)",
1879 .test = alg_test_skcipher,
1880 .fips_allowed = 1,
1881 .suite = {
1882 .cipher = {
1883 .enc = {
1884 .vecs = des3_ede_enc_tv_template,
1885 .count = DES3_EDE_ENC_TEST_VECTORS
1886 },
1887 .dec = {
1888 .vecs = des3_ede_dec_tv_template,
1889 .count = DES3_EDE_DEC_TEST_VECTORS
1890 }
1891 }
1892 }
1893 }, {
1894 .alg = "ecb(khazad)",
1895 .test = alg_test_skcipher,
1896 .suite = {
1897 .cipher = {
1898 .enc = {
1899 .vecs = khazad_enc_tv_template,
1900 .count = KHAZAD_ENC_TEST_VECTORS
1901 },
1902 .dec = {
1903 .vecs = khazad_dec_tv_template,
1904 .count = KHAZAD_DEC_TEST_VECTORS
1905 }
1906 }
1907 }
1908 }, {
1909 .alg = "ecb(seed)",
1910 .test = alg_test_skcipher,
1911 .suite = {
1912 .cipher = {
1913 .enc = {
1914 .vecs = seed_enc_tv_template,
1915 .count = SEED_ENC_TEST_VECTORS
1916 },
1917 .dec = {
1918 .vecs = seed_dec_tv_template,
1919 .count = SEED_DEC_TEST_VECTORS
1920 }
1921 }
1922 }
1923 }, {
1924 .alg = "ecb(serpent)",
1925 .test = alg_test_skcipher,
1926 .suite = {
1927 .cipher = {
1928 .enc = {
1929 .vecs = serpent_enc_tv_template,
1930 .count = SERPENT_ENC_TEST_VECTORS
1931 },
1932 .dec = {
1933 .vecs = serpent_dec_tv_template,
1934 .count = SERPENT_DEC_TEST_VECTORS
1935 }
1936 }
1937 }
1938 }, {
1939 .alg = "ecb(tea)",
1940 .test = alg_test_skcipher,
1941 .suite = {
1942 .cipher = {
1943 .enc = {
1944 .vecs = tea_enc_tv_template,
1945 .count = TEA_ENC_TEST_VECTORS
1946 },
1947 .dec = {
1948 .vecs = tea_dec_tv_template,
1949 .count = TEA_DEC_TEST_VECTORS
1950 }
1951 }
1952 }
1953 }, {
1954 .alg = "ecb(tnepres)",
1955 .test = alg_test_skcipher,
1956 .suite = {
1957 .cipher = {
1958 .enc = {
1959 .vecs = tnepres_enc_tv_template,
1960 .count = TNEPRES_ENC_TEST_VECTORS
1961 },
1962 .dec = {
1963 .vecs = tnepres_dec_tv_template,
1964 .count = TNEPRES_DEC_TEST_VECTORS
1965 }
1966 }
1967 }
1968 }, {
1969 .alg = "ecb(twofish)",
1970 .test = alg_test_skcipher,
1971 .suite = {
1972 .cipher = {
1973 .enc = {
1974 .vecs = tf_enc_tv_template,
1975 .count = TF_ENC_TEST_VECTORS
1976 },
1977 .dec = {
1978 .vecs = tf_dec_tv_template,
1979 .count = TF_DEC_TEST_VECTORS
1980 }
1981 }
1982 }
1983 }, {
1984 .alg = "ecb(xeta)",
1985 .test = alg_test_skcipher,
1986 .suite = {
1987 .cipher = {
1988 .enc = {
1989 .vecs = xeta_enc_tv_template,
1990 .count = XETA_ENC_TEST_VECTORS
1991 },
1992 .dec = {
1993 .vecs = xeta_dec_tv_template,
1994 .count = XETA_DEC_TEST_VECTORS
1995 }
1996 }
1997 }
1998 }, {
1999 .alg = "ecb(xtea)",
2000 .test = alg_test_skcipher,
2001 .suite = {
2002 .cipher = {
2003 .enc = {
2004 .vecs = xtea_enc_tv_template,
2005 .count = XTEA_ENC_TEST_VECTORS
2006 },
2007 .dec = {
2008 .vecs = xtea_dec_tv_template,
2009 .count = XTEA_DEC_TEST_VECTORS
2010 }
2011 }
2012 }
2013 }, {
2014 .alg = "gcm(aes)",
2015 .test = alg_test_aead,
2016 .fips_allowed = 1,
2017 .suite = {
2018 .aead = {
2019 .enc = {
2020 .vecs = aes_gcm_enc_tv_template,
2021 .count = AES_GCM_ENC_TEST_VECTORS
2022 },
2023 .dec = {
2024 .vecs = aes_gcm_dec_tv_template,
2025 .count = AES_GCM_DEC_TEST_VECTORS
2026 }
2027 }
2028 }
2029 }, {
2030 .alg = "ghash",
2031 .test = alg_test_hash,
2032 .suite = {
2033 .hash = {
2034 .vecs = ghash_tv_template,
2035 .count = GHASH_TEST_VECTORS
2036 }
2037 }
2038 }, {
2039 .alg = "hmac(md5)",
2040 .test = alg_test_hash,
2041 .suite = {
2042 .hash = {
2043 .vecs = hmac_md5_tv_template,
2044 .count = HMAC_MD5_TEST_VECTORS
2045 }
2046 }
2047 }, {
2048 .alg = "hmac(rmd128)",
2049 .test = alg_test_hash,
2050 .suite = {
2051 .hash = {
2052 .vecs = hmac_rmd128_tv_template,
2053 .count = HMAC_RMD128_TEST_VECTORS
2054 }
2055 }
2056 }, {
2057 .alg = "hmac(rmd160)",
2058 .test = alg_test_hash,
2059 .suite = {
2060 .hash = {
2061 .vecs = hmac_rmd160_tv_template,
2062 .count = HMAC_RMD160_TEST_VECTORS
2063 }
2064 }
2065 }, {
2066 .alg = "hmac(sha1)",
2067 .test = alg_test_hash,
2068 .fips_allowed = 1,
2069 .suite = {
2070 .hash = {
2071 .vecs = hmac_sha1_tv_template,
2072 .count = HMAC_SHA1_TEST_VECTORS
2073 }
2074 }
2075 }, {
2076 .alg = "hmac(sha224)",
2077 .test = alg_test_hash,
2078 .fips_allowed = 1,
2079 .suite = {
2080 .hash = {
2081 .vecs = hmac_sha224_tv_template,
2082 .count = HMAC_SHA224_TEST_VECTORS
2083 }
2084 }
2085 }, {
2086 .alg = "hmac(sha256)",
2087 .test = alg_test_hash,
2088 .fips_allowed = 1,
2089 .suite = {
2090 .hash = {
2091 .vecs = hmac_sha256_tv_template,
2092 .count = HMAC_SHA256_TEST_VECTORS
2093 }
2094 }
2095 }, {
2096 .alg = "hmac(sha384)",
2097 .test = alg_test_hash,
2098 .fips_allowed = 1,
2099 .suite = {
2100 .hash = {
2101 .vecs = hmac_sha384_tv_template,
2102 .count = HMAC_SHA384_TEST_VECTORS
2103 }
2104 }
2105 }, {
2106 .alg = "hmac(sha512)",
2107 .test = alg_test_hash,
2108 .fips_allowed = 1,
2109 .suite = {
2110 .hash = {
2111 .vecs = hmac_sha512_tv_template,
2112 .count = HMAC_SHA512_TEST_VECTORS
2113 }
2114 }
2115 }, {
2116 .alg = "lrw(aes)",
2117 .test = alg_test_skcipher,
2118 .suite = {
2119 .cipher = {
2120 .enc = {
2121 .vecs = aes_lrw_enc_tv_template,
2122 .count = AES_LRW_ENC_TEST_VECTORS
2123 },
2124 .dec = {
2125 .vecs = aes_lrw_dec_tv_template,
2126 .count = AES_LRW_DEC_TEST_VECTORS
2127 }
2128 }
2129 }
2130 }, {
2131 .alg = "lzo",
2132 .test = alg_test_comp,
2133 .suite = {
2134 .comp = {
2135 .comp = {
2136 .vecs = lzo_comp_tv_template,
2137 .count = LZO_COMP_TEST_VECTORS
2138 },
2139 .decomp = {
2140 .vecs = lzo_decomp_tv_template,
2141 .count = LZO_DECOMP_TEST_VECTORS
2142 }
2143 }
2144 }
2145 }, {
2146 .alg = "md4",
2147 .test = alg_test_hash,
2148 .suite = {
2149 .hash = {
2150 .vecs = md4_tv_template,
2151 .count = MD4_TEST_VECTORS
2152 }
2153 }
2154 }, {
2155 .alg = "md5",
2156 .test = alg_test_hash,
2157 .suite = {
2158 .hash = {
2159 .vecs = md5_tv_template,
2160 .count = MD5_TEST_VECTORS
2161 }
2162 }
2163 }, {
2164 .alg = "michael_mic",
2165 .test = alg_test_hash,
2166 .suite = {
2167 .hash = {
2168 .vecs = michael_mic_tv_template,
2169 .count = MICHAEL_MIC_TEST_VECTORS
2170 }
2171 }
2172 }, {
2173 .alg = "pcbc(fcrypt)",
2174 .test = alg_test_skcipher,
2175 .suite = {
2176 .cipher = {
2177 .enc = {
2178 .vecs = fcrypt_pcbc_enc_tv_template,
2179 .count = FCRYPT_ENC_TEST_VECTORS
2180 },
2181 .dec = {
2182 .vecs = fcrypt_pcbc_dec_tv_template,
2183 .count = FCRYPT_DEC_TEST_VECTORS
2184 }
2185 }
2186 }
2187 }, {
2188 .alg = "rfc3686(ctr(aes))",
2189 .test = alg_test_skcipher,
2190 .fips_allowed = 1,
2191 .suite = {
2192 .cipher = {
2193 .enc = {
2194 .vecs = aes_ctr_rfc3686_enc_tv_template,
2195 .count = AES_CTR_3686_ENC_TEST_VECTORS
2196 },
2197 .dec = {
2198 .vecs = aes_ctr_rfc3686_dec_tv_template,
2199 .count = AES_CTR_3686_DEC_TEST_VECTORS
2200 }
2201 }
2202 }
2203 }, {
2204 .alg = "rfc4309(ccm(aes))",
2205 .test = alg_test_aead,
2206 .fips_allowed = 1,
2207 .suite = {
2208 .aead = {
2209 .enc = {
2210 .vecs = aes_ccm_rfc4309_enc_tv_template,
2211 .count = AES_CCM_4309_ENC_TEST_VECTORS
2212 },
2213 .dec = {
2214 .vecs = aes_ccm_rfc4309_dec_tv_template,
2215 .count = AES_CCM_4309_DEC_TEST_VECTORS
2216 }
2217 }
2218 }
2219 }, {
2220 .alg = "rmd128",
2221 .test = alg_test_hash,
2222 .suite = {
2223 .hash = {
2224 .vecs = rmd128_tv_template,
2225 .count = RMD128_TEST_VECTORS
2226 }
2227 }
2228 }, {
2229 .alg = "rmd160",
2230 .test = alg_test_hash,
2231 .suite = {
2232 .hash = {
2233 .vecs = rmd160_tv_template,
2234 .count = RMD160_TEST_VECTORS
2235 }
2236 }
2237 }, {
2238 .alg = "rmd256",
2239 .test = alg_test_hash,
2240 .suite = {
2241 .hash = {
2242 .vecs = rmd256_tv_template,
2243 .count = RMD256_TEST_VECTORS
2244 }
2245 }
2246 }, {
2247 .alg = "rmd320",
2248 .test = alg_test_hash,
2249 .suite = {
2250 .hash = {
2251 .vecs = rmd320_tv_template,
2252 .count = RMD320_TEST_VECTORS
2253 }
2254 }
2255 }, {
2256 .alg = "salsa20",
2257 .test = alg_test_skcipher,
2258 .suite = {
2259 .cipher = {
2260 .enc = {
2261 .vecs = salsa20_stream_enc_tv_template,
2262 .count = SALSA20_STREAM_ENC_TEST_VECTORS
2263 }
2264 }
2265 }
2266 }, {
2267 .alg = "sha1",
2268 .test = alg_test_hash,
2269 .fips_allowed = 1,
2270 .suite = {
2271 .hash = {
2272 .vecs = sha1_tv_template,
2273 .count = SHA1_TEST_VECTORS
2274 }
2275 }
2276 }, {
2277 .alg = "sha224",
2278 .test = alg_test_hash,
2279 .fips_allowed = 1,
2280 .suite = {
2281 .hash = {
2282 .vecs = sha224_tv_template,
2283 .count = SHA224_TEST_VECTORS
2284 }
2285 }
2286 }, {
2287 .alg = "sha256",
2288 .test = alg_test_hash,
2289 .fips_allowed = 1,
2290 .suite = {
2291 .hash = {
2292 .vecs = sha256_tv_template,
2293 .count = SHA256_TEST_VECTORS
2294 }
2295 }
2296 }, {
2297 .alg = "sha384",
2298 .test = alg_test_hash,
2299 .fips_allowed = 1,
2300 .suite = {
2301 .hash = {
2302 .vecs = sha384_tv_template,
2303 .count = SHA384_TEST_VECTORS
2304 }
2305 }
2306 }, {
2307 .alg = "sha512",
2308 .test = alg_test_hash,
2309 .fips_allowed = 1,
2310 .suite = {
2311 .hash = {
2312 .vecs = sha512_tv_template,
2313 .count = SHA512_TEST_VECTORS
2314 }
2315 }
2316 }, {
2317 .alg = "tgr128",
2318 .test = alg_test_hash,
2319 .suite = {
2320 .hash = {
2321 .vecs = tgr128_tv_template,
2322 .count = TGR128_TEST_VECTORS
2323 }
2324 }
2325 }, {
2326 .alg = "tgr160",
2327 .test = alg_test_hash,
2328 .suite = {
2329 .hash = {
2330 .vecs = tgr160_tv_template,
2331 .count = TGR160_TEST_VECTORS
2332 }
2333 }
2334 }, {
2335 .alg = "tgr192",
2336 .test = alg_test_hash,
2337 .suite = {
2338 .hash = {
2339 .vecs = tgr192_tv_template,
2340 .count = TGR192_TEST_VECTORS
2341 }
2342 }
2343 }, {
2344 .alg = "vmac(aes)",
2345 .test = alg_test_hash,
2346 .suite = {
2347 .hash = {
2348 .vecs = aes_vmac128_tv_template,
2349 .count = VMAC_AES_TEST_VECTORS
2350 }
2351 }
2352 }, {
2353 .alg = "wp256",
2354 .test = alg_test_hash,
2355 .suite = {
2356 .hash = {
2357 .vecs = wp256_tv_template,
2358 .count = WP256_TEST_VECTORS
2359 }
2360 }
2361 }, {
2362 .alg = "wp384",
2363 .test = alg_test_hash,
2364 .suite = {
2365 .hash = {
2366 .vecs = wp384_tv_template,
2367 .count = WP384_TEST_VECTORS
2368 }
2369 }
2370 }, {
2371 .alg = "wp512",
2372 .test = alg_test_hash,
2373 .suite = {
2374 .hash = {
2375 .vecs = wp512_tv_template,
2376 .count = WP512_TEST_VECTORS
2377 }
2378 }
2379 }, {
2380 .alg = "xcbc(aes)",
2381 .test = alg_test_hash,
2382 .suite = {
2383 .hash = {
2384 .vecs = aes_xcbc128_tv_template,
2385 .count = XCBC_AES_TEST_VECTORS
2386 }
2387 }
2388 }, {
2389 .alg = "xts(aes)",
2390 .test = alg_test_skcipher,
2391 .suite = {
2392 .cipher = {
2393 .enc = {
2394 .vecs = aes_xts_enc_tv_template,
2395 .count = AES_XTS_ENC_TEST_VECTORS
2396 },
2397 .dec = {
2398 .vecs = aes_xts_dec_tv_template,
2399 .count = AES_XTS_DEC_TEST_VECTORS
2400 }
2401 }
2402 }
2403 }, {
2404 .alg = "zlib",
2405 .test = alg_test_pcomp,
2406 .suite = {
2407 .pcomp = {
2408 .comp = {
2409 .vecs = zlib_comp_tv_template,
2410 .count = ZLIB_COMP_TEST_VECTORS
2411 },
2412 .decomp = {
2413 .vecs = zlib_decomp_tv_template,
2414 .count = ZLIB_DECOMP_TEST_VECTORS
2415 }
2416 }
2417 }
2418 }
2419 };
2420
2421 static int alg_find_test(const char *alg)
2422 {
2423 int start = 0;
2424 int end = ARRAY_SIZE(alg_test_descs);
2425
2426 while (start < end) {
2427 int i = (start + end) / 2;
2428 int diff = strcmp(alg_test_descs[i].alg, alg);
2429
2430 if (diff > 0) {
2431 end = i;
2432 continue;
2433 }
2434
2435 if (diff < 0) {
2436 start = i + 1;
2437 continue;
2438 }
2439
2440 return i;
2441 }
2442
2443 return -1;
2444 }
2445
2446 int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
2447 {
2448 int i;
2449 int j;
2450 int rc;
2451
2452 if ((type & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_CIPHER) {
2453 char nalg[CRYPTO_MAX_ALG_NAME];
2454
2455 if (snprintf(nalg, sizeof(nalg), "ecb(%s)", alg) >=
2456 sizeof(nalg))
2457 return -ENAMETOOLONG;
2458
2459 i = alg_find_test(nalg);
2460 if (i < 0)
2461 goto notest;
2462
2463 if (fips_enabled && !alg_test_descs[i].fips_allowed)
2464 goto non_fips_alg;
2465
2466 rc = alg_test_cipher(alg_test_descs + i, driver, type, mask);
2467 goto test_done;
2468 }
2469
2470 i = alg_find_test(alg);
2471 j = alg_find_test(driver);
2472 if (i < 0 && j < 0)
2473 goto notest;
2474
2475 if (fips_enabled && ((i >= 0 && !alg_test_descs[i].fips_allowed) ||
2476 (j >= 0 && !alg_test_descs[j].fips_allowed)))
2477 goto non_fips_alg;
2478
2479 rc = 0;
2480 if (i >= 0)
2481 rc |= alg_test_descs[i].test(alg_test_descs + i, driver,
2482 type, mask);
2483 if (j >= 0)
2484 rc |= alg_test_descs[j].test(alg_test_descs + j, driver,
2485 type, mask);
2486
2487 test_done:
2488 if (fips_enabled && rc)
2489 panic("%s: %s alg self test failed in fips mode!\n", driver, alg);
2490
2491 if (fips_enabled && !rc)
2492 printk(KERN_INFO "alg: self-tests for %s (%s) passed\n",
2493 driver, alg);
2494
2495 return rc;
2496
2497 notest:
2498 printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver);
2499 return 0;
2500 non_fips_alg:
2501 return -EINVAL;
2502 }
2503 EXPORT_SYMBOL_GPL(alg_test);
Linux with added FPC-III support