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