?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
iwmc3200wifi: Improve rx debug
[linux/fpc-iii.git] / crypto / testmgr.c
blob6d5b746637be226da5d9aac78af39a9851188464
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, 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 /* Please keep this list sorted by algorithm name. */
1481 static const struct alg_test_desc alg_test_descs[] = {
1482 {
1483 .alg = "ansi_cprng",
1484 .test = alg_test_cprng,
1485 .fips_allowed = 1,
1486 .suite = {
1487 .cprng = {
1488 .vecs = ansi_cprng_aes_tv_template,
1489 .count = ANSI_CPRNG_AES_TEST_VECTORS
1490 }
1491 }
1492 }, {
1493 .alg = "cbc(aes)",
1494 .test = alg_test_skcipher,
1495 .fips_allowed = 1,
1496 .suite = {
1497 .cipher = {
1498 .enc = {
1499 .vecs = aes_cbc_enc_tv_template,
1500 .count = AES_CBC_ENC_TEST_VECTORS
1501 },
1502 .dec = {
1503 .vecs = aes_cbc_dec_tv_template,
1504 .count = AES_CBC_DEC_TEST_VECTORS
1505 }
1506 }
1507 }
1508 }, {
1509 .alg = "cbc(anubis)",
1510 .test = alg_test_skcipher,
1511 .suite = {
1512 .cipher = {
1513 .enc = {
1514 .vecs = anubis_cbc_enc_tv_template,
1515 .count = ANUBIS_CBC_ENC_TEST_VECTORS
1516 },
1517 .dec = {
1518 .vecs = anubis_cbc_dec_tv_template,
1519 .count = ANUBIS_CBC_DEC_TEST_VECTORS
1520 }
1521 }
1522 }
1523 }, {
1524 .alg = "cbc(blowfish)",
1525 .test = alg_test_skcipher,
1526 .suite = {
1527 .cipher = {
1528 .enc = {
1529 .vecs = bf_cbc_enc_tv_template,
1530 .count = BF_CBC_ENC_TEST_VECTORS
1531 },
1532 .dec = {
1533 .vecs = bf_cbc_dec_tv_template,
1534 .count = BF_CBC_DEC_TEST_VECTORS
1535 }
1536 }
1537 }
1538 }, {
1539 .alg = "cbc(camellia)",
1540 .test = alg_test_skcipher,
1541 .suite = {
1542 .cipher = {
1543 .enc = {
1544 .vecs = camellia_cbc_enc_tv_template,
1545 .count = CAMELLIA_CBC_ENC_TEST_VECTORS
1546 },
1547 .dec = {
1548 .vecs = camellia_cbc_dec_tv_template,
1549 .count = CAMELLIA_CBC_DEC_TEST_VECTORS
1550 }
1551 }
1552 }
1553 }, {
1554 .alg = "cbc(des)",
1555 .test = alg_test_skcipher,
1556 .suite = {
1557 .cipher = {
1558 .enc = {
1559 .vecs = des_cbc_enc_tv_template,
1560 .count = DES_CBC_ENC_TEST_VECTORS
1561 },
1562 .dec = {
1563 .vecs = des_cbc_dec_tv_template,
1564 .count = DES_CBC_DEC_TEST_VECTORS
1565 }
1566 }
1567 }
1568 }, {
1569 .alg = "cbc(des3_ede)",
1570 .test = alg_test_skcipher,
1571 .fips_allowed = 1,
1572 .suite = {
1573 .cipher = {
1574 .enc = {
1575 .vecs = des3_ede_cbc_enc_tv_template,
1576 .count = DES3_EDE_CBC_ENC_TEST_VECTORS
1577 },
1578 .dec = {
1579 .vecs = des3_ede_cbc_dec_tv_template,
1580 .count = DES3_EDE_CBC_DEC_TEST_VECTORS
1581 }
1582 }
1583 }
1584 }, {
1585 .alg = "cbc(twofish)",
1586 .test = alg_test_skcipher,
1587 .suite = {
1588 .cipher = {
1589 .enc = {
1590 .vecs = tf_cbc_enc_tv_template,
1591 .count = TF_CBC_ENC_TEST_VECTORS
1592 },
1593 .dec = {
1594 .vecs = tf_cbc_dec_tv_template,
1595 .count = TF_CBC_DEC_TEST_VECTORS
1596 }
1597 }
1598 }
1599 }, {
1600 .alg = "ccm(aes)",
1601 .test = alg_test_aead,
1602 .fips_allowed = 1,
1603 .suite = {
1604 .aead = {
1605 .enc = {
1606 .vecs = aes_ccm_enc_tv_template,
1607 .count = AES_CCM_ENC_TEST_VECTORS
1608 },
1609 .dec = {
1610 .vecs = aes_ccm_dec_tv_template,
1611 .count = AES_CCM_DEC_TEST_VECTORS
1612 }
1613 }
1614 }
1615 }, {
1616 .alg = "crc32c",
1617 .test = alg_test_crc32c,
1618 .fips_allowed = 1,
1619 .suite = {
1620 .hash = {
1621 .vecs = crc32c_tv_template,
1622 .count = CRC32C_TEST_VECTORS
1623 }
1624 }
1625 }, {
1626 .alg = "ctr(aes)",
1627 .test = alg_test_skcipher,
1628 .fips_allowed = 1,
1629 .suite = {
1630 .cipher = {
1631 .enc = {
1632 .vecs = aes_ctr_enc_tv_template,
1633 .count = AES_CTR_ENC_TEST_VECTORS
1634 },
1635 .dec = {
1636 .vecs = aes_ctr_dec_tv_template,
1637 .count = AES_CTR_DEC_TEST_VECTORS
1638 }
1639 }
1640 }
1641 }, {
1642 .alg = "cts(cbc(aes))",
1643 .test = alg_test_skcipher,
1644 .suite = {
1645 .cipher = {
1646 .enc = {
1647 .vecs = cts_mode_enc_tv_template,
1648 .count = CTS_MODE_ENC_TEST_VECTORS
1649 },
1650 .dec = {
1651 .vecs = cts_mode_dec_tv_template,
1652 .count = CTS_MODE_DEC_TEST_VECTORS
1653 }
1654 }
1655 }
1656 }, {
1657 .alg = "deflate",
1658 .test = alg_test_comp,
1659 .suite = {
1660 .comp = {
1661 .comp = {
1662 .vecs = deflate_comp_tv_template,
1663 .count = DEFLATE_COMP_TEST_VECTORS
1664 },
1665 .decomp = {
1666 .vecs = deflate_decomp_tv_template,
1667 .count = DEFLATE_DECOMP_TEST_VECTORS
1668 }
1669 }
1670 }
1671 }, {
1672 .alg = "ecb(aes)",
1673 .test = alg_test_skcipher,
1674 .fips_allowed = 1,
1675 .suite = {
1676 .cipher = {
1677 .enc = {
1678 .vecs = aes_enc_tv_template,
1679 .count = AES_ENC_TEST_VECTORS
1680 },
1681 .dec = {
1682 .vecs = aes_dec_tv_template,
1683 .count = AES_DEC_TEST_VECTORS
1684 }
1685 }
1686 }
1687 }, {
1688 .alg = "ecb(anubis)",
1689 .test = alg_test_skcipher,
1690 .suite = {
1691 .cipher = {
1692 .enc = {
1693 .vecs = anubis_enc_tv_template,
1694 .count = ANUBIS_ENC_TEST_VECTORS
1695 },
1696 .dec = {
1697 .vecs = anubis_dec_tv_template,
1698 .count = ANUBIS_DEC_TEST_VECTORS
1699 }
1700 }
1701 }
1702 }, {
1703 .alg = "ecb(arc4)",
1704 .test = alg_test_skcipher,
1705 .suite = {
1706 .cipher = {
1707 .enc = {
1708 .vecs = arc4_enc_tv_template,
1709 .count = ARC4_ENC_TEST_VECTORS
1710 },
1711 .dec = {
1712 .vecs = arc4_dec_tv_template,
1713 .count = ARC4_DEC_TEST_VECTORS
1714 }
1715 }
1716 }
1717 }, {
1718 .alg = "ecb(blowfish)",
1719 .test = alg_test_skcipher,
1720 .suite = {
1721 .cipher = {
1722 .enc = {
1723 .vecs = bf_enc_tv_template,
1724 .count = BF_ENC_TEST_VECTORS
1725 },
1726 .dec = {
1727 .vecs = bf_dec_tv_template,
1728 .count = BF_DEC_TEST_VECTORS
1729 }
1730 }
1731 }
1732 }, {
1733 .alg = "ecb(camellia)",
1734 .test = alg_test_skcipher,
1735 .suite = {
1736 .cipher = {
1737 .enc = {
1738 .vecs = camellia_enc_tv_template,
1739 .count = CAMELLIA_ENC_TEST_VECTORS
1740 },
1741 .dec = {
1742 .vecs = camellia_dec_tv_template,
1743 .count = CAMELLIA_DEC_TEST_VECTORS
1744 }
1745 }
1746 }
1747 }, {
1748 .alg = "ecb(cast5)",
1749 .test = alg_test_skcipher,
1750 .suite = {
1751 .cipher = {
1752 .enc = {
1753 .vecs = cast5_enc_tv_template,
1754 .count = CAST5_ENC_TEST_VECTORS
1755 },
1756 .dec = {
1757 .vecs = cast5_dec_tv_template,
1758 .count = CAST5_DEC_TEST_VECTORS
1759 }
1760 }
1761 }
1762 }, {
1763 .alg = "ecb(cast6)",
1764 .test = alg_test_skcipher,
1765 .suite = {
1766 .cipher = {
1767 .enc = {
1768 .vecs = cast6_enc_tv_template,
1769 .count = CAST6_ENC_TEST_VECTORS
1770 },
1771 .dec = {
1772 .vecs = cast6_dec_tv_template,
1773 .count = CAST6_DEC_TEST_VECTORS
1774 }
1775 }
1776 }
1777 }, {
1778 .alg = "ecb(des)",
1779 .test = alg_test_skcipher,
1780 .fips_allowed = 1,
1781 .suite = {
1782 .cipher = {
1783 .enc = {
1784 .vecs = des_enc_tv_template,
1785 .count = DES_ENC_TEST_VECTORS
1786 },
1787 .dec = {
1788 .vecs = des_dec_tv_template,
1789 .count = DES_DEC_TEST_VECTORS
1790 }
1791 }
1792 }
1793 }, {
1794 .alg = "ecb(des3_ede)",
1795 .test = alg_test_skcipher,
1796 .fips_allowed = 1,
1797 .suite = {
1798 .cipher = {
1799 .enc = {
1800 .vecs = des3_ede_enc_tv_template,
1801 .count = DES3_EDE_ENC_TEST_VECTORS
1802 },
1803 .dec = {
1804 .vecs = des3_ede_dec_tv_template,
1805 .count = DES3_EDE_DEC_TEST_VECTORS
1806 }
1807 }
1808 }
1809 }, {
1810 .alg = "ecb(khazad)",
1811 .test = alg_test_skcipher,
1812 .suite = {
1813 .cipher = {
1814 .enc = {
1815 .vecs = khazad_enc_tv_template,
1816 .count = KHAZAD_ENC_TEST_VECTORS
1817 },
1818 .dec = {
1819 .vecs = khazad_dec_tv_template,
1820 .count = KHAZAD_DEC_TEST_VECTORS
1821 }
1822 }
1823 }
1824 }, {
1825 .alg = "ecb(seed)",
1826 .test = alg_test_skcipher,
1827 .suite = {
1828 .cipher = {
1829 .enc = {
1830 .vecs = seed_enc_tv_template,
1831 .count = SEED_ENC_TEST_VECTORS
1832 },
1833 .dec = {
1834 .vecs = seed_dec_tv_template,
1835 .count = SEED_DEC_TEST_VECTORS
1836 }
1837 }
1838 }
1839 }, {
1840 .alg = "ecb(serpent)",
1841 .test = alg_test_skcipher,
1842 .suite = {
1843 .cipher = {
1844 .enc = {
1845 .vecs = serpent_enc_tv_template,
1846 .count = SERPENT_ENC_TEST_VECTORS
1847 },
1848 .dec = {
1849 .vecs = serpent_dec_tv_template,
1850 .count = SERPENT_DEC_TEST_VECTORS
1851 }
1852 }
1853 }
1854 }, {
1855 .alg = "ecb(tea)",
1856 .test = alg_test_skcipher,
1857 .suite = {
1858 .cipher = {
1859 .enc = {
1860 .vecs = tea_enc_tv_template,
1861 .count = TEA_ENC_TEST_VECTORS
1862 },
1863 .dec = {
1864 .vecs = tea_dec_tv_template,
1865 .count = TEA_DEC_TEST_VECTORS
1866 }
1867 }
1868 }
1869 }, {
1870 .alg = "ecb(tnepres)",
1871 .test = alg_test_skcipher,
1872 .suite = {
1873 .cipher = {
1874 .enc = {
1875 .vecs = tnepres_enc_tv_template,
1876 .count = TNEPRES_ENC_TEST_VECTORS
1877 },
1878 .dec = {
1879 .vecs = tnepres_dec_tv_template,
1880 .count = TNEPRES_DEC_TEST_VECTORS
1881 }
1882 }
1883 }
1884 }, {
1885 .alg = "ecb(twofish)",
1886 .test = alg_test_skcipher,
1887 .suite = {
1888 .cipher = {
1889 .enc = {
1890 .vecs = tf_enc_tv_template,
1891 .count = TF_ENC_TEST_VECTORS
1892 },
1893 .dec = {
1894 .vecs = tf_dec_tv_template,
1895 .count = TF_DEC_TEST_VECTORS
1896 }
1897 }
1898 }
1899 }, {
1900 .alg = "ecb(xeta)",
1901 .test = alg_test_skcipher,
1902 .suite = {
1903 .cipher = {
1904 .enc = {
1905 .vecs = xeta_enc_tv_template,
1906 .count = XETA_ENC_TEST_VECTORS
1907 },
1908 .dec = {
1909 .vecs = xeta_dec_tv_template,
1910 .count = XETA_DEC_TEST_VECTORS
1911 }
1912 }
1913 }
1914 }, {
1915 .alg = "ecb(xtea)",
1916 .test = alg_test_skcipher,
1917 .suite = {
1918 .cipher = {
1919 .enc = {
1920 .vecs = xtea_enc_tv_template,
1921 .count = XTEA_ENC_TEST_VECTORS
1922 },
1923 .dec = {
1924 .vecs = xtea_dec_tv_template,
1925 .count = XTEA_DEC_TEST_VECTORS
1926 }
1927 }
1928 }
1929 }, {
1930 .alg = "gcm(aes)",
1931 .test = alg_test_aead,
1932 .fips_allowed = 1,
1933 .suite = {
1934 .aead = {
1935 .enc = {
1936 .vecs = aes_gcm_enc_tv_template,
1937 .count = AES_GCM_ENC_TEST_VECTORS
1938 },
1939 .dec = {
1940 .vecs = aes_gcm_dec_tv_template,
1941 .count = AES_GCM_DEC_TEST_VECTORS
1942 }
1943 }
1944 }
1945 }, {
1946 .alg = "hmac(md5)",
1947 .test = alg_test_hash,
1948 .suite = {
1949 .hash = {
1950 .vecs = hmac_md5_tv_template,
1951 .count = HMAC_MD5_TEST_VECTORS
1952 }
1953 }
1954 }, {
1955 .alg = "hmac(rmd128)",
1956 .test = alg_test_hash,
1957 .suite = {
1958 .hash = {
1959 .vecs = hmac_rmd128_tv_template,
1960 .count = HMAC_RMD128_TEST_VECTORS
1961 }
1962 }
1963 }, {
1964 .alg = "hmac(rmd160)",
1965 .test = alg_test_hash,
1966 .suite = {
1967 .hash = {
1968 .vecs = hmac_rmd160_tv_template,
1969 .count = HMAC_RMD160_TEST_VECTORS
1970 }
1971 }
1972 }, {
1973 .alg = "hmac(sha1)",
1974 .test = alg_test_hash,
1975 .fips_allowed = 1,
1976 .suite = {
1977 .hash = {
1978 .vecs = hmac_sha1_tv_template,
1979 .count = HMAC_SHA1_TEST_VECTORS
1980 }
1981 }
1982 }, {
1983 .alg = "hmac(sha224)",
1984 .test = alg_test_hash,
1985 .fips_allowed = 1,
1986 .suite = {
1987 .hash = {
1988 .vecs = hmac_sha224_tv_template,
1989 .count = HMAC_SHA224_TEST_VECTORS
1990 }
1991 }
1992 }, {
1993 .alg = "hmac(sha256)",
1994 .test = alg_test_hash,
1995 .fips_allowed = 1,
1996 .suite = {
1997 .hash = {
1998 .vecs = hmac_sha256_tv_template,
1999 .count = HMAC_SHA256_TEST_VECTORS
2000 }
2001 }
2002 }, {
2003 .alg = "hmac(sha384)",
2004 .test = alg_test_hash,
2005 .fips_allowed = 1,
2006 .suite = {
2007 .hash = {
2008 .vecs = hmac_sha384_tv_template,
2009 .count = HMAC_SHA384_TEST_VECTORS
2010 }
2011 }
2012 }, {
2013 .alg = "hmac(sha512)",
2014 .test = alg_test_hash,
2015 .fips_allowed = 1,
2016 .suite = {
2017 .hash = {
2018 .vecs = hmac_sha512_tv_template,
2019 .count = HMAC_SHA512_TEST_VECTORS
2020 }
2021 }
2022 }, {
2023 .alg = "lrw(aes)",
2024 .test = alg_test_skcipher,
2025 .suite = {
2026 .cipher = {
2027 .enc = {
2028 .vecs = aes_lrw_enc_tv_template,
2029 .count = AES_LRW_ENC_TEST_VECTORS
2030 },
2031 .dec = {
2032 .vecs = aes_lrw_dec_tv_template,
2033 .count = AES_LRW_DEC_TEST_VECTORS
2034 }
2035 }
2036 }
2037 }, {
2038 .alg = "lzo",
2039 .test = alg_test_comp,
2040 .suite = {
2041 .comp = {
2042 .comp = {
2043 .vecs = lzo_comp_tv_template,
2044 .count = LZO_COMP_TEST_VECTORS
2045 },
2046 .decomp = {
2047 .vecs = lzo_decomp_tv_template,
2048 .count = LZO_DECOMP_TEST_VECTORS
2049 }
2050 }
2051 }
2052 }, {
2053 .alg = "md4",
2054 .test = alg_test_hash,
2055 .suite = {
2056 .hash = {
2057 .vecs = md4_tv_template,
2058 .count = MD4_TEST_VECTORS
2059 }
2060 }
2061 }, {
2062 .alg = "md5",
2063 .test = alg_test_hash,
2064 .suite = {
2065 .hash = {
2066 .vecs = md5_tv_template,
2067 .count = MD5_TEST_VECTORS
2068 }
2069 }
2070 }, {
2071 .alg = "michael_mic",
2072 .test = alg_test_hash,
2073 .suite = {
2074 .hash = {
2075 .vecs = michael_mic_tv_template,
2076 .count = MICHAEL_MIC_TEST_VECTORS
2077 }
2078 }
2079 }, {
2080 .alg = "pcbc(fcrypt)",
2081 .test = alg_test_skcipher,
2082 .suite = {
2083 .cipher = {
2084 .enc = {
2085 .vecs = fcrypt_pcbc_enc_tv_template,
2086 .count = FCRYPT_ENC_TEST_VECTORS
2087 },
2088 .dec = {
2089 .vecs = fcrypt_pcbc_dec_tv_template,
2090 .count = FCRYPT_DEC_TEST_VECTORS
2091 }
2092 }
2093 }
2094 }, {
2095 .alg = "rfc3686(ctr(aes))",
2096 .test = alg_test_skcipher,
2097 .fips_allowed = 1,
2098 .suite = {
2099 .cipher = {
2100 .enc = {
2101 .vecs = aes_ctr_rfc3686_enc_tv_template,
2102 .count = AES_CTR_3686_ENC_TEST_VECTORS
2103 },
2104 .dec = {
2105 .vecs = aes_ctr_rfc3686_dec_tv_template,
2106 .count = AES_CTR_3686_DEC_TEST_VECTORS
2107 }
2108 }
2109 }
2110 }, {
2111 .alg = "rfc4309(ccm(aes))",
2112 .test = alg_test_aead,
2113 .fips_allowed = 1,
2114 .suite = {
2115 .aead = {
2116 .enc = {
2117 .vecs = aes_ccm_rfc4309_enc_tv_template,
2118 .count = AES_CCM_4309_ENC_TEST_VECTORS
2119 },
2120 .dec = {
2121 .vecs = aes_ccm_rfc4309_dec_tv_template,
2122 .count = AES_CCM_4309_DEC_TEST_VECTORS
2123 }
2124 }
2125 }
2126 }, {
2127 .alg = "rmd128",
2128 .test = alg_test_hash,
2129 .suite = {
2130 .hash = {
2131 .vecs = rmd128_tv_template,
2132 .count = RMD128_TEST_VECTORS
2133 }
2134 }
2135 }, {
2136 .alg = "rmd160",
2137 .test = alg_test_hash,
2138 .suite = {
2139 .hash = {
2140 .vecs = rmd160_tv_template,
2141 .count = RMD160_TEST_VECTORS
2142 }
2143 }
2144 }, {
2145 .alg = "rmd256",
2146 .test = alg_test_hash,
2147 .suite = {
2148 .hash = {
2149 .vecs = rmd256_tv_template,
2150 .count = RMD256_TEST_VECTORS
2151 }
2152 }
2153 }, {
2154 .alg = "rmd320",
2155 .test = alg_test_hash,
2156 .suite = {
2157 .hash = {
2158 .vecs = rmd320_tv_template,
2159 .count = RMD320_TEST_VECTORS
2160 }
2161 }
2162 }, {
2163 .alg = "salsa20",
2164 .test = alg_test_skcipher,
2165 .suite = {
2166 .cipher = {
2167 .enc = {
2168 .vecs = salsa20_stream_enc_tv_template,
2169 .count = SALSA20_STREAM_ENC_TEST_VECTORS
2170 }
2171 }
2172 }
2173 }, {
2174 .alg = "sha1",
2175 .test = alg_test_hash,
2176 .fips_allowed = 1,
2177 .suite = {
2178 .hash = {
2179 .vecs = sha1_tv_template,
2180 .count = SHA1_TEST_VECTORS
2181 }
2182 }
2183 }, {
2184 .alg = "sha224",
2185 .test = alg_test_hash,
2186 .fips_allowed = 1,
2187 .suite = {
2188 .hash = {
2189 .vecs = sha224_tv_template,
2190 .count = SHA224_TEST_VECTORS
2191 }
2192 }
2193 }, {
2194 .alg = "sha256",
2195 .test = alg_test_hash,
2196 .fips_allowed = 1,
2197 .suite = {
2198 .hash = {
2199 .vecs = sha256_tv_template,
2200 .count = SHA256_TEST_VECTORS
2201 }
2202 }
2203 }, {
2204 .alg = "sha384",
2205 .test = alg_test_hash,
2206 .fips_allowed = 1,
2207 .suite = {
2208 .hash = {
2209 .vecs = sha384_tv_template,
2210 .count = SHA384_TEST_VECTORS
2211 }
2212 }
2213 }, {
2214 .alg = "sha512",
2215 .test = alg_test_hash,
2216 .fips_allowed = 1,
2217 .suite = {
2218 .hash = {
2219 .vecs = sha512_tv_template,
2220 .count = SHA512_TEST_VECTORS
2221 }
2222 }
2223 }, {
2224 .alg = "tgr128",
2225 .test = alg_test_hash,
2226 .suite = {
2227 .hash = {
2228 .vecs = tgr128_tv_template,
2229 .count = TGR128_TEST_VECTORS
2230 }
2231 }
2232 }, {
2233 .alg = "tgr160",
2234 .test = alg_test_hash,
2235 .suite = {
2236 .hash = {
2237 .vecs = tgr160_tv_template,
2238 .count = TGR160_TEST_VECTORS
2239 }
2240 }
2241 }, {
2242 .alg = "tgr192",
2243 .test = alg_test_hash,
2244 .suite = {
2245 .hash = {
2246 .vecs = tgr192_tv_template,
2247 .count = TGR192_TEST_VECTORS
2248 }
2249 }
2250 }, {
2251 .alg = "vmac(aes)",
2252 .test = alg_test_hash,
2253 .suite = {
2254 .hash = {
2255 .vecs = aes_vmac128_tv_template,
2256 .count = VMAC_AES_TEST_VECTORS
2257 }
2258 }
2259 }, {
2260 .alg = "wp256",
2261 .test = alg_test_hash,
2262 .suite = {
2263 .hash = {
2264 .vecs = wp256_tv_template,
2265 .count = WP256_TEST_VECTORS
2266 }
2267 }
2268 }, {
2269 .alg = "wp384",
2270 .test = alg_test_hash,
2271 .suite = {
2272 .hash = {
2273 .vecs = wp384_tv_template,
2274 .count = WP384_TEST_VECTORS
2275 }
2276 }
2277 }, {
2278 .alg = "wp512",
2279 .test = alg_test_hash,
2280 .suite = {
2281 .hash = {
2282 .vecs = wp512_tv_template,
2283 .count = WP512_TEST_VECTORS
2284 }
2285 }
2286 }, {
2287 .alg = "xcbc(aes)",
2288 .test = alg_test_hash,
2289 .suite = {
2290 .hash = {
2291 .vecs = aes_xcbc128_tv_template,
2292 .count = XCBC_AES_TEST_VECTORS
2293 }
2294 }
2295 }, {
2296 .alg = "xts(aes)",
2297 .test = alg_test_skcipher,
2298 .suite = {
2299 .cipher = {
2300 .enc = {
2301 .vecs = aes_xts_enc_tv_template,
2302 .count = AES_XTS_ENC_TEST_VECTORS
2303 },
2304 .dec = {
2305 .vecs = aes_xts_dec_tv_template,
2306 .count = AES_XTS_DEC_TEST_VECTORS
2307 }
2308 }
2309 }
2310 }, {
2311 .alg = "zlib",
2312 .test = alg_test_pcomp,
2313 .suite = {
2314 .pcomp = {
2315 .comp = {
2316 .vecs = zlib_comp_tv_template,
2317 .count = ZLIB_COMP_TEST_VECTORS
2318 },
2319 .decomp = {
2320 .vecs = zlib_decomp_tv_template,
2321 .count = ZLIB_DECOMP_TEST_VECTORS
2322 }
2323 }
2324 }
2325 }
2326 };
2327
2328 static int alg_find_test(const char *alg)
2329 {
2330 int start = 0;
2331 int end = ARRAY_SIZE(alg_test_descs);
2332
2333 while (start < end) {
2334 int i = (start + end) / 2;
2335 int diff = strcmp(alg_test_descs[i].alg, alg);
2336
2337 if (diff > 0) {
2338 end = i;
2339 continue;
2340 }
2341
2342 if (diff < 0) {
2343 start = i + 1;
2344 continue;
2345 }
2346
2347 return i;
2348 }
2349
2350 return -1;
2351 }
2352
2353 int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
2354 {
2355 int i;
2356 int j;
2357 int rc;
2358
2359 if ((type & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_CIPHER) {
2360 char nalg[CRYPTO_MAX_ALG_NAME];
2361
2362 if (snprintf(nalg, sizeof(nalg), "ecb(%s)", alg) >=
2363 sizeof(nalg))
2364 return -ENAMETOOLONG;
2365
2366 i = alg_find_test(nalg);
2367 if (i < 0)
2368 goto notest;
2369
2370 if (fips_enabled && !alg_test_descs[i].fips_allowed)
2371 goto non_fips_alg;
2372
2373 rc = alg_test_cipher(alg_test_descs + i, driver, type, mask);
2374 goto test_done;
2375 }
2376
2377 i = alg_find_test(alg);
2378 j = alg_find_test(driver);
2379 if (i < 0 && j < 0)
2380 goto notest;
2381
2382 if (fips_enabled && ((i >= 0 && !alg_test_descs[i].fips_allowed) ||
2383 (j >= 0 && !alg_test_descs[j].fips_allowed)))
2384 goto non_fips_alg;
2385
2386 rc = 0;
2387 if (i >= 0)
2388 rc |= alg_test_descs[i].test(alg_test_descs + i, driver,
2389 type, mask);
2390 if (j >= 0)
2391 rc |= alg_test_descs[j].test(alg_test_descs + j, driver,
2392 type, mask);
2393
2394 test_done:
2395 if (fips_enabled && rc)
2396 panic("%s: %s alg self test failed in fips mode!\n", driver, alg);
2397
2398 if (fips_enabled && !rc)
2399 printk(KERN_INFO "alg: self-tests for %s (%s) passed\n",
2400 driver, alg);
2401
2402 return rc;
2403
2404 notest:
2405 printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver);
2406 return 0;
2407 non_fips_alg:
2408 return -EINVAL;
2409 }
2410 EXPORT_SYMBOL_GPL(alg_test);
Linux with added FPC-III support