aboutsummaryrefslogtreecommitdiffstats
path: root/crypto/testmgr.c
diff options
context:
space:
mode:
authorIngo Molnar <mingo@elte.hu>2008-10-15 07:46:29 -0400
committerIngo Molnar <mingo@elte.hu>2008-10-15 07:46:29 -0400
commitb2aaf8f74cdc84a9182f6cabf198b7763bcb9d40 (patch)
tree53ccb1c2c14751fe69cf93102e76e97021f6df07 /crypto/testmgr.c
parent4f962d4d65923d7b722192e729840cfb79af0a5a (diff)
parent278429cff8809958d25415ba0ed32b59866ab1a8 (diff)
Merge branch 'linus' into stackprotector
Conflicts: arch/x86/kernel/Makefile include/asm-x86/pda.h
Diffstat (limited to 'crypto/testmgr.c')
-rw-r--r--crypto/testmgr.c1868
1 files changed, 1868 insertions, 0 deletions
diff --git a/crypto/testmgr.c b/crypto/testmgr.c
new file mode 100644
index 000000000000..b828c6cf1b1d
--- /dev/null
+++ b/crypto/testmgr.c
@@ -0,0 +1,1868 @@
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
23#include "internal.h"
24#include "testmgr.h"
25
26/*
27 * Need slab memory for testing (size in number of pages).
28 */
29#define XBUFSIZE 8
30
31/*
32 * Indexes into the xbuf to simulate cross-page access.
33 */
34#define IDX1 32
35#define IDX2 32400
36#define IDX3 1
37#define IDX4 8193
38#define IDX5 22222
39#define IDX6 17101
40#define IDX7 27333
41#define IDX8 3000
42
43/*
44* Used by test_cipher()
45*/
46#define ENCRYPT 1
47#define DECRYPT 0
48
49struct tcrypt_result {
50 struct completion completion;
51 int err;
52};
53
54struct aead_test_suite {
55 struct {
56 struct aead_testvec *vecs;
57 unsigned int count;
58 } enc, dec;
59};
60
61struct cipher_test_suite {
62 struct {
63 struct cipher_testvec *vecs;
64 unsigned int count;
65 } enc, dec;
66};
67
68struct comp_test_suite {
69 struct {
70 struct comp_testvec *vecs;
71 unsigned int count;
72 } comp, decomp;
73};
74
75struct hash_test_suite {
76 struct hash_testvec *vecs;
77 unsigned int count;
78};
79
80struct alg_test_desc {
81 const char *alg;
82 int (*test)(const struct alg_test_desc *desc, const char *driver,
83 u32 type, u32 mask);
84
85 union {
86 struct aead_test_suite aead;
87 struct cipher_test_suite cipher;
88 struct comp_test_suite comp;
89 struct hash_test_suite hash;
90 } suite;
91};
92
93static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
94
95static char *xbuf[XBUFSIZE];
96static char *axbuf[XBUFSIZE];
97
98static void hexdump(unsigned char *buf, unsigned int len)
99{
100 print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET,
101 16, 1,
102 buf, len, false);
103}
104
105static void tcrypt_complete(struct crypto_async_request *req, int err)
106{
107 struct tcrypt_result *res = req->data;
108
109 if (err == -EINPROGRESS)
110 return;
111
112 res->err = err;
113 complete(&res->completion);
114}
115
116static int test_hash(struct crypto_ahash *tfm, struct hash_testvec *template,
117 unsigned int tcount)
118{
119 const char *algo = crypto_tfm_alg_driver_name(crypto_ahash_tfm(tfm));
120 unsigned int i, j, k, temp;
121 struct scatterlist sg[8];
122 char result[64];
123 struct ahash_request *req;
124 struct tcrypt_result tresult;
125 int ret;
126 void *hash_buff;
127
128 init_completion(&tresult.completion);
129
130 req = ahash_request_alloc(tfm, GFP_KERNEL);
131 if (!req) {
132 printk(KERN_ERR "alg: hash: Failed to allocate request for "
133 "%s\n", algo);
134 ret = -ENOMEM;
135 goto out_noreq;
136 }
137 ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
138 tcrypt_complete, &tresult);
139
140 for (i = 0; i < tcount; i++) {
141 memset(result, 0, 64);
142
143 hash_buff = xbuf[0];
144
145 memcpy(hash_buff, template[i].plaintext, template[i].psize);
146 sg_init_one(&sg[0], hash_buff, template[i].psize);
147
148 if (template[i].ksize) {
149 crypto_ahash_clear_flags(tfm, ~0);
150 ret = crypto_ahash_setkey(tfm, template[i].key,
151 template[i].ksize);
152 if (ret) {
153 printk(KERN_ERR "alg: hash: setkey failed on "
154 "test %d for %s: ret=%d\n", i + 1, algo,
155 -ret);
156 goto out;
157 }
158 }
159
160 ahash_request_set_crypt(req, sg, result, template[i].psize);
161 ret = crypto_ahash_digest(req);
162 switch (ret) {
163 case 0:
164 break;
165 case -EINPROGRESS:
166 case -EBUSY:
167 ret = wait_for_completion_interruptible(
168 &tresult.completion);
169 if (!ret && !(ret = tresult.err)) {
170 INIT_COMPLETION(tresult.completion);
171 break;
172 }
173 /* fall through */
174 default:
175 printk(KERN_ERR "alg: hash: digest failed on test %d "
176 "for %s: ret=%d\n", i + 1, algo, -ret);
177 goto out;
178 }
179
180 if (memcmp(result, template[i].digest,
181 crypto_ahash_digestsize(tfm))) {
182 printk(KERN_ERR "alg: hash: Test %d failed for %s\n",
183 i + 1, algo);
184 hexdump(result, crypto_ahash_digestsize(tfm));
185 ret = -EINVAL;
186 goto out;
187 }
188 }
189
190 j = 0;
191 for (i = 0; i < tcount; i++) {
192 if (template[i].np) {
193 j++;
194 memset(result, 0, 64);
195
196 temp = 0;
197 sg_init_table(sg, template[i].np);
198 for (k = 0; k < template[i].np; k++) {
199 sg_set_buf(&sg[k],
200 memcpy(xbuf[IDX[k] >> PAGE_SHIFT] +
201 offset_in_page(IDX[k]),
202 template[i].plaintext + temp,
203 template[i].tap[k]),
204 template[i].tap[k]);
205 temp += template[i].tap[k];
206 }
207
208 if (template[i].ksize) {
209 crypto_ahash_clear_flags(tfm, ~0);
210 ret = crypto_ahash_setkey(tfm, template[i].key,
211 template[i].ksize);
212
213 if (ret) {
214 printk(KERN_ERR "alg: hash: setkey "
215 "failed on chunking test %d "
216 "for %s: ret=%d\n", j, algo,
217 -ret);
218 goto out;
219 }
220 }
221
222 ahash_request_set_crypt(req, sg, result,
223 template[i].psize);
224 ret = crypto_ahash_digest(req);
225 switch (ret) {
226 case 0:
227 break;
228 case -EINPROGRESS:
229 case -EBUSY:
230 ret = wait_for_completion_interruptible(
231 &tresult.completion);
232 if (!ret && !(ret = tresult.err)) {
233 INIT_COMPLETION(tresult.completion);
234 break;
235 }
236 /* fall through */
237 default:
238 printk(KERN_ERR "alg: hash: digest failed "
239 "on chunking test %d for %s: "
240 "ret=%d\n", j, algo, -ret);
241 goto out;
242 }
243
244 if (memcmp(result, template[i].digest,
245 crypto_ahash_digestsize(tfm))) {
246 printk(KERN_ERR "alg: hash: Chunking test %d "
247 "failed for %s\n", j, algo);
248 hexdump(result, crypto_ahash_digestsize(tfm));
249 ret = -EINVAL;
250 goto out;
251 }
252 }
253 }
254
255 ret = 0;
256
257out:
258 ahash_request_free(req);
259out_noreq:
260 return ret;
261}
262
263static int test_aead(struct crypto_aead *tfm, int enc,
264 struct aead_testvec *template, unsigned int tcount)
265{
266 const char *algo = crypto_tfm_alg_driver_name(crypto_aead_tfm(tfm));
267 unsigned int i, j, k, n, temp;
268 int ret = 0;
269 char *q;
270 char *key;
271 struct aead_request *req;
272 struct scatterlist sg[8];
273 struct scatterlist asg[8];
274 const char *e;
275 struct tcrypt_result result;
276 unsigned int authsize;
277 void *input;
278 void *assoc;
279 char iv[MAX_IVLEN];
280
281 if (enc == ENCRYPT)
282 e = "encryption";
283 else
284 e = "decryption";
285
286 init_completion(&result.completion);
287
288 req = aead_request_alloc(tfm, GFP_KERNEL);
289 if (!req) {
290 printk(KERN_ERR "alg: aead: Failed to allocate request for "
291 "%s\n", algo);
292 ret = -ENOMEM;
293 goto out;
294 }
295
296 aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
297 tcrypt_complete, &result);
298
299 for (i = 0, j = 0; i < tcount; i++) {
300 if (!template[i].np) {
301 j++;
302
303 /* some tepmplates have no input data but they will
304 * touch input
305 */
306 input = xbuf[0];
307 assoc = axbuf[0];
308
309 memcpy(input, template[i].input, template[i].ilen);
310 memcpy(assoc, template[i].assoc, template[i].alen);
311 if (template[i].iv)
312 memcpy(iv, template[i].iv, MAX_IVLEN);
313 else
314 memset(iv, 0, MAX_IVLEN);
315
316 crypto_aead_clear_flags(tfm, ~0);
317 if (template[i].wk)
318 crypto_aead_set_flags(
319 tfm, CRYPTO_TFM_REQ_WEAK_KEY);
320
321 key = template[i].key;
322
323 ret = crypto_aead_setkey(tfm, key,
324 template[i].klen);
325 if (!ret == template[i].fail) {
326 printk(KERN_ERR "alg: aead: setkey failed on "
327 "test %d for %s: flags=%x\n", j, algo,
328 crypto_aead_get_flags(tfm));
329 goto out;
330 } else if (ret)
331 continue;
332
333 authsize = abs(template[i].rlen - template[i].ilen);
334 ret = crypto_aead_setauthsize(tfm, authsize);
335 if (ret) {
336 printk(KERN_ERR "alg: aead: Failed to set "
337 "authsize to %u on test %d for %s\n",
338 authsize, j, algo);
339 goto out;
340 }
341
342 sg_init_one(&sg[0], input,
343 template[i].ilen + (enc ? authsize : 0));
344
345 sg_init_one(&asg[0], assoc, template[i].alen);
346
347 aead_request_set_crypt(req, sg, sg,
348 template[i].ilen, iv);
349
350 aead_request_set_assoc(req, asg, template[i].alen);
351
352 ret = enc ?
353 crypto_aead_encrypt(req) :
354 crypto_aead_decrypt(req);
355
356 switch (ret) {
357 case 0:
358 break;
359 case -EINPROGRESS:
360 case -EBUSY:
361 ret = wait_for_completion_interruptible(
362 &result.completion);
363 if (!ret && !(ret = result.err)) {
364 INIT_COMPLETION(result.completion);
365 break;
366 }
367 /* fall through */
368 default:
369 printk(KERN_ERR "alg: aead: %s failed on test "
370 "%d for %s: ret=%d\n", e, j, algo, -ret);
371 goto out;
372 }
373
374 q = input;
375 if (memcmp(q, template[i].result, template[i].rlen)) {
376 printk(KERN_ERR "alg: aead: Test %d failed on "
377 "%s for %s\n", j, e, algo);
378 hexdump(q, template[i].rlen);
379 ret = -EINVAL;
380 goto out;
381 }
382 }
383 }
384
385 for (i = 0, j = 0; i < tcount; i++) {
386 if (template[i].np) {
387 j++;
388
389 if (template[i].iv)
390 memcpy(iv, template[i].iv, MAX_IVLEN);
391 else
392 memset(iv, 0, MAX_IVLEN);
393
394 crypto_aead_clear_flags(tfm, ~0);
395 if (template[i].wk)
396 crypto_aead_set_flags(
397 tfm, CRYPTO_TFM_REQ_WEAK_KEY);
398 key = template[i].key;
399
400 ret = crypto_aead_setkey(tfm, key, template[i].klen);
401 if (!ret == template[i].fail) {
402 printk(KERN_ERR "alg: aead: setkey failed on "
403 "chunk test %d for %s: flags=%x\n", j,
404 algo, crypto_aead_get_flags(tfm));
405 goto out;
406 } else if (ret)
407 continue;
408
409 authsize = abs(template[i].rlen - template[i].ilen);
410
411 ret = -EINVAL;
412 sg_init_table(sg, template[i].np);
413 for (k = 0, temp = 0; k < template[i].np; k++) {
414 if (WARN_ON(offset_in_page(IDX[k]) +
415 template[i].tap[k] > PAGE_SIZE))
416 goto out;
417
418 q = xbuf[IDX[k] >> PAGE_SHIFT] +
419 offset_in_page(IDX[k]);
420
421 memcpy(q, template[i].input + temp,
422 template[i].tap[k]);
423
424 n = template[i].tap[k];
425 if (k == template[i].np - 1 && enc)
426 n += authsize;
427 if (offset_in_page(q) + n < PAGE_SIZE)
428 q[n] = 0;
429
430 sg_set_buf(&sg[k], q, template[i].tap[k]);
431 temp += template[i].tap[k];
432 }
433
434 ret = crypto_aead_setauthsize(tfm, authsize);
435 if (ret) {
436 printk(KERN_ERR "alg: aead: Failed to set "
437 "authsize to %u on chunk test %d for "
438 "%s\n", authsize, j, algo);
439 goto out;
440 }
441
442 if (enc) {
443 if (WARN_ON(sg[k - 1].offset +
444 sg[k - 1].length + authsize >
445 PAGE_SIZE)) {
446 ret = -EINVAL;
447 goto out;
448 }
449
450 sg[k - 1].length += authsize;
451 }
452
453 sg_init_table(asg, template[i].anp);
454 for (k = 0, temp = 0; k < template[i].anp; k++) {
455 sg_set_buf(&asg[k],
456 memcpy(axbuf[IDX[k] >> PAGE_SHIFT] +
457 offset_in_page(IDX[k]),
458 template[i].assoc + temp,
459 template[i].atap[k]),
460 template[i].atap[k]);
461 temp += template[i].atap[k];
462 }
463
464 aead_request_set_crypt(req, sg, sg,
465 template[i].ilen,
466 iv);
467
468 aead_request_set_assoc(req, asg, template[i].alen);
469
470 ret = enc ?
471 crypto_aead_encrypt(req) :
472 crypto_aead_decrypt(req);
473
474 switch (ret) {
475 case 0:
476 break;
477 case -EINPROGRESS:
478 case -EBUSY:
479 ret = wait_for_completion_interruptible(
480 &result.completion);
481 if (!ret && !(ret = result.err)) {
482 INIT_COMPLETION(result.completion);
483 break;
484 }
485 /* fall through */
486 default:
487 printk(KERN_ERR "alg: aead: %s failed on "
488 "chunk test %d for %s: ret=%d\n", e, j,
489 algo, -ret);
490 goto out;
491 }
492
493 ret = -EINVAL;
494 for (k = 0, temp = 0; k < template[i].np; k++) {
495 q = xbuf[IDX[k] >> PAGE_SHIFT] +
496 offset_in_page(IDX[k]);
497
498 n = template[i].tap[k];
499 if (k == template[i].np - 1)
500 n += enc ? authsize : -authsize;
501
502 if (memcmp(q, template[i].result + temp, n)) {
503 printk(KERN_ERR "alg: aead: Chunk "
504 "test %d failed on %s at page "
505 "%u for %s\n", j, e, k, algo);
506 hexdump(q, n);
507 goto out;
508 }
509
510 q += n;
511 if (k == template[i].np - 1 && !enc) {
512 if (memcmp(q, template[i].input +
513 temp + n, authsize))
514 n = authsize;
515 else
516 n = 0;
517 } else {
518 for (n = 0; offset_in_page(q + n) &&
519 q[n]; n++)
520 ;
521 }
522 if (n) {
523 printk(KERN_ERR "alg: aead: Result "
524 "buffer corruption in chunk "
525 "test %d on %s at page %u for "
526 "%s: %u bytes:\n", j, e, k,
527 algo, n);
528 hexdump(q, n);
529 goto out;
530 }
531
532 temp += template[i].tap[k];
533 }
534 }
535 }
536
537 ret = 0;
538
539out:
540 aead_request_free(req);
541 return ret;
542}
543
544static int test_cipher(struct crypto_cipher *tfm, int enc,
545 struct cipher_testvec *template, unsigned int tcount)
546{
547 const char *algo = crypto_tfm_alg_driver_name(crypto_cipher_tfm(tfm));
548 unsigned int i, j, k;
549 int ret;
550 char *q;
551 const char *e;
552 void *data;
553
554 if (enc == ENCRYPT)
555 e = "encryption";
556 else
557 e = "decryption";
558
559 j = 0;
560 for (i = 0; i < tcount; i++) {
561 if (template[i].np)
562 continue;
563
564 j++;
565
566 data = xbuf[0];
567 memcpy(data, template[i].input, template[i].ilen);
568
569 crypto_cipher_clear_flags(tfm, ~0);
570 if (template[i].wk)
571 crypto_cipher_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
572
573 ret = crypto_cipher_setkey(tfm, template[i].key,
574 template[i].klen);
575 if (!ret == template[i].fail) {
576 printk(KERN_ERR "alg: cipher: setkey failed "
577 "on test %d for %s: flags=%x\n", j,
578 algo, crypto_cipher_get_flags(tfm));
579 goto out;
580 } else if (ret)
581 continue;
582
583 for (k = 0; k < template[i].ilen;
584 k += crypto_cipher_blocksize(tfm)) {
585 if (enc)
586 crypto_cipher_encrypt_one(tfm, data + k,
587 data + k);
588 else
589 crypto_cipher_decrypt_one(tfm, data + k,
590 data + k);
591 }
592
593 q = data;
594 if (memcmp(q, template[i].result, template[i].rlen)) {
595 printk(KERN_ERR "alg: cipher: Test %d failed "
596 "on %s for %s\n", j, e, algo);
597 hexdump(q, template[i].rlen);
598 ret = -EINVAL;
599 goto out;
600 }
601 }
602
603 ret = 0;
604
605out:
606 return ret;
607}
608
609static int test_skcipher(struct crypto_ablkcipher *tfm, int enc,
610 struct cipher_testvec *template, unsigned int tcount)
611{
612 const char *algo =
613 crypto_tfm_alg_driver_name(crypto_ablkcipher_tfm(tfm));
614 unsigned int i, j, k, n, temp;
615 int ret;
616 char *q;
617 struct ablkcipher_request *req;
618 struct scatterlist sg[8];
619 const char *e;
620 struct tcrypt_result result;
621 void *data;
622 char iv[MAX_IVLEN];
623
624 if (enc == ENCRYPT)
625 e = "encryption";
626 else
627 e = "decryption";
628
629 init_completion(&result.completion);
630
631 req = ablkcipher_request_alloc(tfm, GFP_KERNEL);
632 if (!req) {
633 printk(KERN_ERR "alg: skcipher: Failed to allocate request "
634 "for %s\n", algo);
635 ret = -ENOMEM;
636 goto out;
637 }
638
639 ablkcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
640 tcrypt_complete, &result);
641
642 j = 0;
643 for (i = 0; i < tcount; i++) {
644 if (template[i].iv)
645 memcpy(iv, template[i].iv, MAX_IVLEN);
646 else
647 memset(iv, 0, MAX_IVLEN);
648
649 if (!(template[i].np)) {
650 j++;
651
652 data = xbuf[0];
653 memcpy(data, template[i].input, template[i].ilen);
654
655 crypto_ablkcipher_clear_flags(tfm, ~0);
656 if (template[i].wk)
657 crypto_ablkcipher_set_flags(
658 tfm, CRYPTO_TFM_REQ_WEAK_KEY);
659
660 ret = crypto_ablkcipher_setkey(tfm, template[i].key,
661 template[i].klen);
662 if (!ret == template[i].fail) {
663 printk(KERN_ERR "alg: skcipher: setkey failed "
664 "on test %d for %s: flags=%x\n", j,
665 algo, crypto_ablkcipher_get_flags(tfm));
666 goto out;
667 } else if (ret)
668 continue;
669
670 sg_init_one(&sg[0], data, template[i].ilen);
671
672 ablkcipher_request_set_crypt(req, sg, sg,
673 template[i].ilen, iv);
674 ret = enc ?
675 crypto_ablkcipher_encrypt(req) :
676 crypto_ablkcipher_decrypt(req);
677
678 switch (ret) {
679 case 0:
680 break;
681 case -EINPROGRESS:
682 case -EBUSY:
683 ret = wait_for_completion_interruptible(
684 &result.completion);
685 if (!ret && !((ret = result.err))) {
686 INIT_COMPLETION(result.completion);
687 break;
688 }
689 /* fall through */
690 default:
691 printk(KERN_ERR "alg: skcipher: %s failed on "
692 "test %d for %s: ret=%d\n", e, j, algo,
693 -ret);
694 goto out;
695 }
696
697 q = data;
698 if (memcmp(q, template[i].result, template[i].rlen)) {
699 printk(KERN_ERR "alg: skcipher: Test %d "
700 "failed on %s for %s\n", j, e, algo);
701 hexdump(q, template[i].rlen);
702 ret = -EINVAL;
703 goto out;
704 }
705 }
706 }
707
708 j = 0;
709 for (i = 0; i < tcount; i++) {
710
711 if (template[i].iv)
712 memcpy(iv, template[i].iv, MAX_IVLEN);
713 else
714 memset(iv, 0, MAX_IVLEN);
715
716 if (template[i].np) {
717 j++;
718
719 crypto_ablkcipher_clear_flags(tfm, ~0);
720 if (template[i].wk)
721 crypto_ablkcipher_set_flags(
722 tfm, CRYPTO_TFM_REQ_WEAK_KEY);
723
724 ret = crypto_ablkcipher_setkey(tfm, template[i].key,
725 template[i].klen);
726 if (!ret == template[i].fail) {
727 printk(KERN_ERR "alg: skcipher: setkey failed "
728 "on chunk test %d for %s: flags=%x\n",
729 j, algo,
730 crypto_ablkcipher_get_flags(tfm));
731 goto out;
732 } else if (ret)
733 continue;
734
735 temp = 0;
736 ret = -EINVAL;
737 sg_init_table(sg, template[i].np);
738 for (k = 0; k < template[i].np; k++) {
739 if (WARN_ON(offset_in_page(IDX[k]) +
740 template[i].tap[k] > PAGE_SIZE))
741 goto out;
742
743 q = xbuf[IDX[k] >> PAGE_SHIFT] +
744 offset_in_page(IDX[k]);
745
746 memcpy(q, template[i].input + temp,
747 template[i].tap[k]);
748
749 if (offset_in_page(q) + template[i].tap[k] <
750 PAGE_SIZE)
751 q[template[i].tap[k]] = 0;
752
753 sg_set_buf(&sg[k], q, template[i].tap[k]);
754
755 temp += template[i].tap[k];
756 }
757
758 ablkcipher_request_set_crypt(req, sg, sg,
759 template[i].ilen, iv);
760
761 ret = enc ?
762 crypto_ablkcipher_encrypt(req) :
763 crypto_ablkcipher_decrypt(req);
764
765 switch (ret) {
766 case 0:
767 break;
768 case -EINPROGRESS:
769 case -EBUSY:
770 ret = wait_for_completion_interruptible(
771 &result.completion);
772 if (!ret && !((ret = result.err))) {
773 INIT_COMPLETION(result.completion);
774 break;
775 }
776 /* fall through */
777 default:
778 printk(KERN_ERR "alg: skcipher: %s failed on "
779 "chunk test %d for %s: ret=%d\n", e, j,
780 algo, -ret);
781 goto out;
782 }
783
784 temp = 0;
785 ret = -EINVAL;
786 for (k = 0; k < template[i].np; k++) {
787 q = xbuf[IDX[k] >> PAGE_SHIFT] +
788 offset_in_page(IDX[k]);
789
790 if (memcmp(q, template[i].result + temp,
791 template[i].tap[k])) {
792 printk(KERN_ERR "alg: skcipher: Chunk "
793 "test %d failed on %s at page "
794 "%u for %s\n", j, e, k, algo);
795 hexdump(q, template[i].tap[k]);
796 goto out;
797 }
798
799 q += template[i].tap[k];
800 for (n = 0; offset_in_page(q + n) && q[n]; n++)
801 ;
802 if (n) {
803 printk(KERN_ERR "alg: skcipher: "
804 "Result buffer corruption in "
805 "chunk test %d on %s at page "
806 "%u for %s: %u bytes:\n", j, e,
807 k, algo, n);
808 hexdump(q, n);
809 goto out;
810 }
811 temp += template[i].tap[k];
812 }
813 }
814 }
815
816 ret = 0;
817
818out:
819 ablkcipher_request_free(req);
820 return ret;
821}
822
823static int test_comp(struct crypto_comp *tfm, struct comp_testvec *ctemplate,
824 struct comp_testvec *dtemplate, int ctcount, int dtcount)
825{
826 const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm));
827 unsigned int i;
828 char result[COMP_BUF_SIZE];
829 int ret;
830
831 for (i = 0; i < ctcount; i++) {
832 int ilen, dlen = COMP_BUF_SIZE;
833
834 memset(result, 0, sizeof (result));
835
836 ilen = ctemplate[i].inlen;
837 ret = crypto_comp_compress(tfm, ctemplate[i].input,
838 ilen, result, &dlen);
839 if (ret) {
840 printk(KERN_ERR "alg: comp: compression failed "
841 "on test %d for %s: ret=%d\n", i + 1, algo,
842 -ret);
843 goto out;
844 }
845
846 if (memcmp(result, ctemplate[i].output, dlen)) {
847 printk(KERN_ERR "alg: comp: Compression test %d "
848 "failed for %s\n", i + 1, algo);
849 hexdump(result, dlen);
850 ret = -EINVAL;
851 goto out;
852 }
853 }
854
855 for (i = 0; i < dtcount; i++) {
856 int ilen, ret, dlen = COMP_BUF_SIZE;
857
858 memset(result, 0, sizeof (result));
859
860 ilen = dtemplate[i].inlen;
861 ret = crypto_comp_decompress(tfm, dtemplate[i].input,
862 ilen, result, &dlen);
863 if (ret) {
864 printk(KERN_ERR "alg: comp: decompression failed "
865 "on test %d for %s: ret=%d\n", i + 1, algo,
866 -ret);
867 goto out;
868 }
869
870 if (memcmp(result, dtemplate[i].output, dlen)) {
871 printk(KERN_ERR "alg: comp: Decompression test %d "
872 "failed for %s\n", i + 1, algo);
873 hexdump(result, dlen);
874 ret = -EINVAL;
875 goto out;
876 }
877 }
878
879 ret = 0;
880
881out:
882 return ret;
883}
884
885static int alg_test_aead(const struct alg_test_desc *desc, const char *driver,
886 u32 type, u32 mask)
887{
888 struct crypto_aead *tfm;
889 int err = 0;
890
891 tfm = crypto_alloc_aead(driver, type, mask);
892 if (IS_ERR(tfm)) {
893 printk(KERN_ERR "alg: aead: Failed to load transform for %s: "
894 "%ld\n", driver, PTR_ERR(tfm));
895 return PTR_ERR(tfm);
896 }
897
898 if (desc->suite.aead.enc.vecs) {
899 err = test_aead(tfm, ENCRYPT, desc->suite.aead.enc.vecs,
900 desc->suite.aead.enc.count);
901 if (err)
902 goto out;
903 }
904
905 if (!err && desc->suite.aead.dec.vecs)
906 err = test_aead(tfm, DECRYPT, desc->suite.aead.dec.vecs,
907 desc->suite.aead.dec.count);
908
909out:
910 crypto_free_aead(tfm);
911 return err;
912}
913
914static int alg_test_cipher(const struct alg_test_desc *desc,
915 const char *driver, u32 type, u32 mask)
916{
917 struct crypto_cipher *tfm;
918 int err = 0;
919
920 tfm = crypto_alloc_cipher(driver, type, mask);
921 if (IS_ERR(tfm)) {
922 printk(KERN_ERR "alg: cipher: Failed to load transform for "
923 "%s: %ld\n", driver, PTR_ERR(tfm));
924 return PTR_ERR(tfm);
925 }
926
927 if (desc->suite.cipher.enc.vecs) {
928 err = test_cipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
929 desc->suite.cipher.enc.count);
930 if (err)
931 goto out;
932 }
933
934 if (desc->suite.cipher.dec.vecs)
935 err = test_cipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
936 desc->suite.cipher.dec.count);
937
938out:
939 crypto_free_cipher(tfm);
940 return err;
941}
942
943static int alg_test_skcipher(const struct alg_test_desc *desc,
944 const char *driver, u32 type, u32 mask)
945{
946 struct crypto_ablkcipher *tfm;
947 int err = 0;
948
949 tfm = crypto_alloc_ablkcipher(driver, type, mask);
950 if (IS_ERR(tfm)) {
951 printk(KERN_ERR "alg: skcipher: Failed to load transform for "
952 "%s: %ld\n", driver, PTR_ERR(tfm));
953 return PTR_ERR(tfm);
954 }
955
956 if (desc->suite.cipher.enc.vecs) {
957 err = test_skcipher(tfm, ENCRYPT, desc->suite.cipher.enc.vecs,
958 desc->suite.cipher.enc.count);
959 if (err)
960 goto out;
961 }
962
963 if (desc->suite.cipher.dec.vecs)
964 err = test_skcipher(tfm, DECRYPT, desc->suite.cipher.dec.vecs,
965 desc->suite.cipher.dec.count);
966
967out:
968 crypto_free_ablkcipher(tfm);
969 return err;
970}
971
972static int alg_test_comp(const struct alg_test_desc *desc, const char *driver,
973 u32 type, u32 mask)
974{
975 struct crypto_comp *tfm;
976 int err;
977
978 tfm = crypto_alloc_comp(driver, type, mask);
979 if (IS_ERR(tfm)) {
980 printk(KERN_ERR "alg: comp: Failed to load transform for %s: "
981 "%ld\n", driver, PTR_ERR(tfm));
982 return PTR_ERR(tfm);
983 }
984
985 err = test_comp(tfm, desc->suite.comp.comp.vecs,
986 desc->suite.comp.decomp.vecs,
987 desc->suite.comp.comp.count,
988 desc->suite.comp.decomp.count);
989
990 crypto_free_comp(tfm);
991 return err;
992}
993
994static int alg_test_hash(const struct alg_test_desc *desc, const char *driver,
995 u32 type, u32 mask)
996{
997 struct crypto_ahash *tfm;
998 int err;
999
1000 tfm = crypto_alloc_ahash(driver, type, mask);
1001 if (IS_ERR(tfm)) {
1002 printk(KERN_ERR "alg: hash: Failed to load transform for %s: "
1003 "%ld\n", driver, PTR_ERR(tfm));
1004 return PTR_ERR(tfm);
1005 }
1006
1007 err = test_hash(tfm, desc->suite.hash.vecs, desc->suite.hash.count);
1008
1009 crypto_free_ahash(tfm);
1010 return err;
1011}
1012
1013/* Please keep this list sorted by algorithm name. */
1014static const struct alg_test_desc alg_test_descs[] = {
1015 {
1016 .alg = "cbc(aes)",
1017 .test = alg_test_skcipher,
1018 .suite = {
1019 .cipher = {
1020 .enc = {
1021 .vecs = aes_cbc_enc_tv_template,
1022 .count = AES_CBC_ENC_TEST_VECTORS
1023 },
1024 .dec = {
1025 .vecs = aes_cbc_dec_tv_template,
1026 .count = AES_CBC_DEC_TEST_VECTORS
1027 }
1028 }
1029 }
1030 }, {
1031 .alg = "cbc(anubis)",
1032 .test = alg_test_skcipher,
1033 .suite = {
1034 .cipher = {
1035 .enc = {
1036 .vecs = anubis_cbc_enc_tv_template,
1037 .count = ANUBIS_CBC_ENC_TEST_VECTORS
1038 },
1039 .dec = {
1040 .vecs = anubis_cbc_dec_tv_template,
1041 .count = ANUBIS_CBC_DEC_TEST_VECTORS
1042 }
1043 }
1044 }
1045 }, {
1046 .alg = "cbc(blowfish)",
1047 .test = alg_test_skcipher,
1048 .suite = {
1049 .cipher = {
1050 .enc = {
1051 .vecs = bf_cbc_enc_tv_template,
1052 .count = BF_CBC_ENC_TEST_VECTORS
1053 },
1054 .dec = {
1055 .vecs = bf_cbc_dec_tv_template,
1056 .count = BF_CBC_DEC_TEST_VECTORS
1057 }
1058 }
1059 }
1060 }, {
1061 .alg = "cbc(camellia)",
1062 .test = alg_test_skcipher,
1063 .suite = {
1064 .cipher = {
1065 .enc = {
1066 .vecs = camellia_cbc_enc_tv_template,
1067 .count = CAMELLIA_CBC_ENC_TEST_VECTORS
1068 },
1069 .dec = {
1070 .vecs = camellia_cbc_dec_tv_template,
1071 .count = CAMELLIA_CBC_DEC_TEST_VECTORS
1072 }
1073 }
1074 }
1075 }, {
1076 .alg = "cbc(des)",
1077 .test = alg_test_skcipher,
1078 .suite = {
1079 .cipher = {
1080 .enc = {
1081 .vecs = des_cbc_enc_tv_template,
1082 .count = DES_CBC_ENC_TEST_VECTORS
1083 },
1084 .dec = {
1085 .vecs = des_cbc_dec_tv_template,
1086 .count = DES_CBC_DEC_TEST_VECTORS
1087 }
1088 }
1089 }
1090 }, {
1091 .alg = "cbc(des3_ede)",
1092 .test = alg_test_skcipher,
1093 .suite = {
1094 .cipher = {
1095 .enc = {
1096 .vecs = des3_ede_cbc_enc_tv_template,
1097 .count = DES3_EDE_CBC_ENC_TEST_VECTORS
1098 },
1099 .dec = {
1100 .vecs = des3_ede_cbc_dec_tv_template,
1101 .count = DES3_EDE_CBC_DEC_TEST_VECTORS
1102 }
1103 }
1104 }
1105 }, {
1106 .alg = "cbc(twofish)",
1107 .test = alg_test_skcipher,
1108 .suite = {
1109 .cipher = {
1110 .enc = {
1111 .vecs = tf_cbc_enc_tv_template,
1112 .count = TF_CBC_ENC_TEST_VECTORS
1113 },
1114 .dec = {
1115 .vecs = tf_cbc_dec_tv_template,
1116 .count = TF_CBC_DEC_TEST_VECTORS
1117 }
1118 }
1119 }
1120 }, {
1121 .alg = "ccm(aes)",
1122 .test = alg_test_aead,
1123 .suite = {
1124 .aead = {
1125 .enc = {
1126 .vecs = aes_ccm_enc_tv_template,
1127 .count = AES_CCM_ENC_TEST_VECTORS
1128 },
1129 .dec = {
1130 .vecs = aes_ccm_dec_tv_template,
1131 .count = AES_CCM_DEC_TEST_VECTORS
1132 }
1133 }
1134 }
1135 }, {
1136 .alg = "crc32c",
1137 .test = alg_test_hash,
1138 .suite = {
1139 .hash = {
1140 .vecs = crc32c_tv_template,
1141 .count = CRC32C_TEST_VECTORS
1142 }
1143 }
1144 }, {
1145 .alg = "cts(cbc(aes))",
1146 .test = alg_test_skcipher,
1147 .suite = {
1148 .cipher = {
1149 .enc = {
1150 .vecs = cts_mode_enc_tv_template,
1151 .count = CTS_MODE_ENC_TEST_VECTORS
1152 },
1153 .dec = {
1154 .vecs = cts_mode_dec_tv_template,
1155 .count = CTS_MODE_DEC_TEST_VECTORS
1156 }
1157 }
1158 }
1159 }, {
1160 .alg = "deflate",
1161 .test = alg_test_comp,
1162 .suite = {
1163 .comp = {
1164 .comp = {
1165 .vecs = deflate_comp_tv_template,
1166 .count = DEFLATE_COMP_TEST_VECTORS
1167 },
1168 .decomp = {
1169 .vecs = deflate_decomp_tv_template,
1170 .count = DEFLATE_DECOMP_TEST_VECTORS
1171 }
1172 }
1173 }
1174 }, {
1175 .alg = "ecb(aes)",
1176 .test = alg_test_skcipher,
1177 .suite = {
1178 .cipher = {
1179 .enc = {
1180 .vecs = aes_enc_tv_template,
1181 .count = AES_ENC_TEST_VECTORS
1182 },
1183 .dec = {
1184 .vecs = aes_dec_tv_template,
1185 .count = AES_DEC_TEST_VECTORS
1186 }
1187 }
1188 }
1189 }, {
1190 .alg = "ecb(anubis)",
1191 .test = alg_test_skcipher,
1192 .suite = {
1193 .cipher = {
1194 .enc = {
1195 .vecs = anubis_enc_tv_template,
1196 .count = ANUBIS_ENC_TEST_VECTORS
1197 },
1198 .dec = {
1199 .vecs = anubis_dec_tv_template,
1200 .count = ANUBIS_DEC_TEST_VECTORS
1201 }
1202 }
1203 }
1204 }, {
1205 .alg = "ecb(arc4)",
1206 .test = alg_test_skcipher,
1207 .suite = {
1208 .cipher = {
1209 .enc = {
1210 .vecs = arc4_enc_tv_template,
1211 .count = ARC4_ENC_TEST_VECTORS
1212 },
1213 .dec = {
1214 .vecs = arc4_dec_tv_template,
1215 .count = ARC4_DEC_TEST_VECTORS
1216 }
1217 }
1218 }
1219 }, {
1220 .alg = "ecb(blowfish)",
1221 .test = alg_test_skcipher,
1222 .suite = {
1223 .cipher = {
1224 .enc = {
1225 .vecs = bf_enc_tv_template,
1226 .count = BF_ENC_TEST_VECTORS
1227 },
1228 .dec = {
1229 .vecs = bf_dec_tv_template,
1230 .count = BF_DEC_TEST_VECTORS
1231 }
1232 }
1233 }
1234 }, {
1235 .alg = "ecb(camellia)",
1236 .test = alg_test_skcipher,
1237 .suite = {
1238 .cipher = {
1239 .enc = {
1240 .vecs = camellia_enc_tv_template,
1241 .count = CAMELLIA_ENC_TEST_VECTORS
1242 },
1243 .dec = {
1244 .vecs = camellia_dec_tv_template,
1245 .count = CAMELLIA_DEC_TEST_VECTORS
1246 }
1247 }
1248 }
1249 }, {
1250 .alg = "ecb(cast5)",
1251 .test = alg_test_skcipher,
1252 .suite = {
1253 .cipher = {
1254 .enc = {
1255 .vecs = cast5_enc_tv_template,
1256 .count = CAST5_ENC_TEST_VECTORS
1257 },
1258 .dec = {
1259 .vecs = cast5_dec_tv_template,
1260 .count = CAST5_DEC_TEST_VECTORS
1261 }
1262 }
1263 }
1264 }, {
1265 .alg = "ecb(cast6)",
1266 .test = alg_test_skcipher,
1267 .suite = {
1268 .cipher = {
1269 .enc = {
1270 .vecs = cast6_enc_tv_template,
1271 .count = CAST6_ENC_TEST_VECTORS
1272 },
1273 .dec = {
1274 .vecs = cast6_dec_tv_template,
1275 .count = CAST6_DEC_TEST_VECTORS
1276 }
1277 }
1278 }
1279 }, {
1280 .alg = "ecb(des)",
1281 .test = alg_test_skcipher,
1282 .suite = {
1283 .cipher = {
1284 .enc = {
1285 .vecs = des_enc_tv_template,
1286 .count = DES_ENC_TEST_VECTORS
1287 },
1288 .dec = {
1289 .vecs = des_dec_tv_template,
1290 .count = DES_DEC_TEST_VECTORS
1291 }
1292 }
1293 }
1294 }, {
1295 .alg = "ecb(des3_ede)",
1296 .test = alg_test_skcipher,
1297 .suite = {
1298 .cipher = {
1299 .enc = {
1300 .vecs = des3_ede_enc_tv_template,
1301 .count = DES3_EDE_ENC_TEST_VECTORS
1302 },
1303 .dec = {
1304 .vecs = des3_ede_dec_tv_template,
1305 .count = DES3_EDE_DEC_TEST_VECTORS
1306 }
1307 }
1308 }
1309 }, {
1310 .alg = "ecb(khazad)",
1311 .test = alg_test_skcipher,
1312 .suite = {
1313 .cipher = {
1314 .enc = {
1315 .vecs = khazad_enc_tv_template,
1316 .count = KHAZAD_ENC_TEST_VECTORS
1317 },
1318 .dec = {
1319 .vecs = khazad_dec_tv_template,
1320 .count = KHAZAD_DEC_TEST_VECTORS
1321 }
1322 }
1323 }
1324 }, {
1325 .alg = "ecb(seed)",
1326 .test = alg_test_skcipher,
1327 .suite = {
1328 .cipher = {
1329 .enc = {
1330 .vecs = seed_enc_tv_template,
1331 .count = SEED_ENC_TEST_VECTORS
1332 },
1333 .dec = {
1334 .vecs = seed_dec_tv_template,
1335 .count = SEED_DEC_TEST_VECTORS
1336 }
1337 }
1338 }
1339 }, {
1340 .alg = "ecb(serpent)",
1341 .test = alg_test_skcipher,
1342 .suite = {
1343 .cipher = {
1344 .enc = {
1345 .vecs = serpent_enc_tv_template,
1346 .count = SERPENT_ENC_TEST_VECTORS
1347 },
1348 .dec = {
1349 .vecs = serpent_dec_tv_template,
1350 .count = SERPENT_DEC_TEST_VECTORS
1351 }
1352 }
1353 }
1354 }, {
1355 .alg = "ecb(tea)",
1356 .test = alg_test_skcipher,
1357 .suite = {
1358 .cipher = {
1359 .enc = {
1360 .vecs = tea_enc_tv_template,
1361 .count = TEA_ENC_TEST_VECTORS
1362 },
1363 .dec = {
1364 .vecs = tea_dec_tv_template,
1365 .count = TEA_DEC_TEST_VECTORS
1366 }
1367 }
1368 }
1369 }, {
1370 .alg = "ecb(tnepres)",
1371 .test = alg_test_skcipher,
1372 .suite = {
1373 .cipher = {
1374 .enc = {
1375 .vecs = tnepres_enc_tv_template,
1376 .count = TNEPRES_ENC_TEST_VECTORS
1377 },
1378 .dec = {
1379 .vecs = tnepres_dec_tv_template,
1380 .count = TNEPRES_DEC_TEST_VECTORS
1381 }
1382 }
1383 }
1384 }, {
1385 .alg = "ecb(twofish)",
1386 .test = alg_test_skcipher,
1387 .suite = {
1388 .cipher = {
1389 .enc = {
1390 .vecs = tf_enc_tv_template,
1391 .count = TF_ENC_TEST_VECTORS
1392 },
1393 .dec = {
1394 .vecs = tf_dec_tv_template,
1395 .count = TF_DEC_TEST_VECTORS
1396 }
1397 }
1398 }
1399 }, {
1400 .alg = "ecb(xeta)",
1401 .test = alg_test_skcipher,
1402 .suite = {
1403 .cipher = {
1404 .enc = {
1405 .vecs = xeta_enc_tv_template,
1406 .count = XETA_ENC_TEST_VECTORS
1407 },
1408 .dec = {
1409 .vecs = xeta_dec_tv_template,
1410 .count = XETA_DEC_TEST_VECTORS
1411 }
1412 }
1413 }
1414 }, {
1415 .alg = "ecb(xtea)",
1416 .test = alg_test_skcipher,
1417 .suite = {
1418 .cipher = {
1419 .enc = {
1420 .vecs = xtea_enc_tv_template,
1421 .count = XTEA_ENC_TEST_VECTORS
1422 },
1423 .dec = {
1424 .vecs = xtea_dec_tv_template,
1425 .count = XTEA_DEC_TEST_VECTORS
1426 }
1427 }
1428 }
1429 }, {
1430 .alg = "gcm(aes)",
1431 .test = alg_test_aead,
1432 .suite = {
1433 .aead = {
1434 .enc = {
1435 .vecs = aes_gcm_enc_tv_template,
1436 .count = AES_GCM_ENC_TEST_VECTORS
1437 },
1438 .dec = {
1439 .vecs = aes_gcm_dec_tv_template,
1440 .count = AES_GCM_DEC_TEST_VECTORS
1441 }
1442 }
1443 }
1444 }, {
1445 .alg = "hmac(md5)",
1446 .test = alg_test_hash,
1447 .suite = {
1448 .hash = {
1449 .vecs = hmac_md5_tv_template,
1450 .count = HMAC_MD5_TEST_VECTORS
1451 }
1452 }
1453 }, {
1454 .alg = "hmac(rmd128)",
1455 .test = alg_test_hash,
1456 .suite = {
1457 .hash = {
1458 .vecs = hmac_rmd128_tv_template,
1459 .count = HMAC_RMD128_TEST_VECTORS
1460 }
1461 }
1462 }, {
1463 .alg = "hmac(rmd160)",
1464 .test = alg_test_hash,
1465 .suite = {
1466 .hash = {
1467 .vecs = hmac_rmd160_tv_template,
1468 .count = HMAC_RMD160_TEST_VECTORS
1469 }
1470 }
1471 }, {
1472 .alg = "hmac(sha1)",
1473 .test = alg_test_hash,
1474 .suite = {
1475 .hash = {
1476 .vecs = hmac_sha1_tv_template,
1477 .count = HMAC_SHA1_TEST_VECTORS
1478 }
1479 }
1480 }, {
1481 .alg = "hmac(sha224)",
1482 .test = alg_test_hash,
1483 .suite = {
1484 .hash = {
1485 .vecs = hmac_sha224_tv_template,
1486 .count = HMAC_SHA224_TEST_VECTORS
1487 }
1488 }
1489 }, {
1490 .alg = "hmac(sha256)",
1491 .test = alg_test_hash,
1492 .suite = {
1493 .hash = {
1494 .vecs = hmac_sha256_tv_template,
1495 .count = HMAC_SHA256_TEST_VECTORS
1496 }
1497 }
1498 }, {
1499 .alg = "hmac(sha384)",
1500 .test = alg_test_hash,
1501 .suite = {
1502 .hash = {
1503 .vecs = hmac_sha384_tv_template,
1504 .count = HMAC_SHA384_TEST_VECTORS
1505 }
1506 }
1507 }, {
1508 .alg = "hmac(sha512)",
1509 .test = alg_test_hash,
1510 .suite = {
1511 .hash = {
1512 .vecs = hmac_sha512_tv_template,
1513 .count = HMAC_SHA512_TEST_VECTORS
1514 }
1515 }
1516 }, {
1517 .alg = "lrw(aes)",
1518 .test = alg_test_skcipher,
1519 .suite = {
1520 .cipher = {
1521 .enc = {
1522 .vecs = aes_lrw_enc_tv_template,
1523 .count = AES_LRW_ENC_TEST_VECTORS
1524 },
1525 .dec = {
1526 .vecs = aes_lrw_dec_tv_template,
1527 .count = AES_LRW_DEC_TEST_VECTORS
1528 }
1529 }
1530 }
1531 }, {
1532 .alg = "lzo",
1533 .test = alg_test_comp,
1534 .suite = {
1535 .comp = {
1536 .comp = {
1537 .vecs = lzo_comp_tv_template,
1538 .count = LZO_COMP_TEST_VECTORS
1539 },
1540 .decomp = {
1541 .vecs = lzo_decomp_tv_template,
1542 .count = LZO_DECOMP_TEST_VECTORS
1543 }
1544 }
1545 }
1546 }, {
1547 .alg = "md4",
1548 .test = alg_test_hash,
1549 .suite = {
1550 .hash = {
1551 .vecs = md4_tv_template,
1552 .count = MD4_TEST_VECTORS
1553 }
1554 }
1555 }, {
1556 .alg = "md5",
1557 .test = alg_test_hash,
1558 .suite = {
1559 .hash = {
1560 .vecs = md5_tv_template,
1561 .count = MD5_TEST_VECTORS
1562 }
1563 }
1564 }, {
1565 .alg = "michael_mic",
1566 .test = alg_test_hash,
1567 .suite = {
1568 .hash = {
1569 .vecs = michael_mic_tv_template,
1570 .count = MICHAEL_MIC_TEST_VECTORS
1571 }
1572 }
1573 }, {
1574 .alg = "pcbc(fcrypt)",
1575 .test = alg_test_skcipher,
1576 .suite = {
1577 .cipher = {
1578 .enc = {
1579 .vecs = fcrypt_pcbc_enc_tv_template,
1580 .count = FCRYPT_ENC_TEST_VECTORS
1581 },
1582 .dec = {
1583 .vecs = fcrypt_pcbc_dec_tv_template,
1584 .count = FCRYPT_DEC_TEST_VECTORS
1585 }
1586 }
1587 }
1588 }, {
1589 .alg = "rfc3686(ctr(aes))",
1590 .test = alg_test_skcipher,
1591 .suite = {
1592 .cipher = {
1593 .enc = {
1594 .vecs = aes_ctr_enc_tv_template,
1595 .count = AES_CTR_ENC_TEST_VECTORS
1596 },
1597 .dec = {
1598 .vecs = aes_ctr_dec_tv_template,
1599 .count = AES_CTR_DEC_TEST_VECTORS
1600 }
1601 }
1602 }
1603 }, {
1604 .alg = "rmd128",
1605 .test = alg_test_hash,
1606 .suite = {
1607 .hash = {
1608 .vecs = rmd128_tv_template,
1609 .count = RMD128_TEST_VECTORS
1610 }
1611 }
1612 }, {
1613 .alg = "rmd160",
1614 .test = alg_test_hash,
1615 .suite = {
1616 .hash = {
1617 .vecs = rmd160_tv_template,
1618 .count = RMD160_TEST_VECTORS
1619 }
1620 }
1621 }, {
1622 .alg = "rmd256",
1623 .test = alg_test_hash,
1624 .suite = {
1625 .hash = {
1626 .vecs = rmd256_tv_template,
1627 .count = RMD256_TEST_VECTORS
1628 }
1629 }
1630 }, {
1631 .alg = "rmd320",
1632 .test = alg_test_hash,
1633 .suite = {
1634 .hash = {
1635 .vecs = rmd320_tv_template,
1636 .count = RMD320_TEST_VECTORS
1637 }
1638 }
1639 }, {
1640 .alg = "salsa20",
1641 .test = alg_test_skcipher,
1642 .suite = {
1643 .cipher = {
1644 .enc = {
1645 .vecs = salsa20_stream_enc_tv_template,
1646 .count = SALSA20_STREAM_ENC_TEST_VECTORS
1647 }
1648 }
1649 }
1650 }, {
1651 .alg = "sha1",
1652 .test = alg_test_hash,
1653 .suite = {
1654 .hash = {
1655 .vecs = sha1_tv_template,
1656 .count = SHA1_TEST_VECTORS
1657 }
1658 }
1659 }, {
1660 .alg = "sha224",
1661 .test = alg_test_hash,
1662 .suite = {
1663 .hash = {
1664 .vecs = sha224_tv_template,
1665 .count = SHA224_TEST_VECTORS
1666 }
1667 }
1668 }, {
1669 .alg = "sha256",
1670 .test = alg_test_hash,
1671 .suite = {
1672 .hash = {
1673 .vecs = sha256_tv_template,
1674 .count = SHA256_TEST_VECTORS
1675 }
1676 }
1677 }, {
1678 .alg = "sha384",
1679 .test = alg_test_hash,
1680 .suite = {
1681 .hash = {
1682 .vecs = sha384_tv_template,
1683 .count = SHA384_TEST_VECTORS
1684 }
1685 }
1686 }, {
1687 .alg = "sha512",
1688 .test = alg_test_hash,
1689 .suite = {
1690 .hash = {
1691 .vecs = sha512_tv_template,
1692 .count = SHA512_TEST_VECTORS
1693 }
1694 }
1695 }, {
1696 .alg = "tgr128",
1697 .test = alg_test_hash,
1698 .suite = {
1699 .hash = {
1700 .vecs = tgr128_tv_template,
1701 .count = TGR128_TEST_VECTORS
1702 }
1703 }
1704 }, {
1705 .alg = "tgr160",
1706 .test = alg_test_hash,
1707 .suite = {
1708 .hash = {
1709 .vecs = tgr160_tv_template,
1710 .count = TGR160_TEST_VECTORS
1711 }
1712 }
1713 }, {
1714 .alg = "tgr192",
1715 .test = alg_test_hash,
1716 .suite = {
1717 .hash = {
1718 .vecs = tgr192_tv_template,
1719 .count = TGR192_TEST_VECTORS
1720 }
1721 }
1722 }, {
1723 .alg = "wp256",
1724 .test = alg_test_hash,
1725 .suite = {
1726 .hash = {
1727 .vecs = wp256_tv_template,
1728 .count = WP256_TEST_VECTORS
1729 }
1730 }
1731 }, {
1732 .alg = "wp384",
1733 .test = alg_test_hash,
1734 .suite = {
1735 .hash = {
1736 .vecs = wp384_tv_template,
1737 .count = WP384_TEST_VECTORS
1738 }
1739 }
1740 }, {
1741 .alg = "wp512",
1742 .test = alg_test_hash,
1743 .suite = {
1744 .hash = {
1745 .vecs = wp512_tv_template,
1746 .count = WP512_TEST_VECTORS
1747 }
1748 }
1749 }, {
1750 .alg = "xcbc(aes)",
1751 .test = alg_test_hash,
1752 .suite = {
1753 .hash = {
1754 .vecs = aes_xcbc128_tv_template,
1755 .count = XCBC_AES_TEST_VECTORS
1756 }
1757 }
1758 }, {
1759 .alg = "xts(aes)",
1760 .test = alg_test_skcipher,
1761 .suite = {
1762 .cipher = {
1763 .enc = {
1764 .vecs = aes_xts_enc_tv_template,
1765 .count = AES_XTS_ENC_TEST_VECTORS
1766 },
1767 .dec = {
1768 .vecs = aes_xts_dec_tv_template,
1769 .count = AES_XTS_DEC_TEST_VECTORS
1770 }
1771 }
1772 }
1773 }
1774};
1775
1776static int alg_find_test(const char *alg)
1777{
1778 int start = 0;
1779 int end = ARRAY_SIZE(alg_test_descs);
1780
1781 while (start < end) {
1782 int i = (start + end) / 2;
1783 int diff = strcmp(alg_test_descs[i].alg, alg);
1784
1785 if (diff > 0) {
1786 end = i;
1787 continue;
1788 }
1789
1790 if (diff < 0) {
1791 start = i + 1;
1792 continue;
1793 }
1794
1795 return i;
1796 }
1797
1798 return -1;
1799}
1800
1801int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
1802{
1803 int i;
1804
1805 if ((type & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_CIPHER) {
1806 char nalg[CRYPTO_MAX_ALG_NAME];
1807
1808 if (snprintf(nalg, sizeof(nalg), "ecb(%s)", alg) >=
1809 sizeof(nalg))
1810 return -ENAMETOOLONG;
1811
1812 i = alg_find_test(nalg);
1813 if (i < 0)
1814 goto notest;
1815
1816 return alg_test_cipher(alg_test_descs + i, driver, type, mask);
1817 }
1818
1819 i = alg_find_test(alg);
1820 if (i < 0)
1821 goto notest;
1822
1823 return alg_test_descs[i].test(alg_test_descs + i, driver,
1824 type, mask);
1825
1826notest:
1827 printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver);
1828 return 0;
1829}
1830EXPORT_SYMBOL_GPL(alg_test);
1831
1832int __init testmgr_init(void)
1833{
1834 int i;
1835
1836 for (i = 0; i < XBUFSIZE; i++) {
1837 xbuf[i] = (void *)__get_free_page(GFP_KERNEL);
1838 if (!xbuf[i])
1839 goto err_free_xbuf;
1840 }
1841
1842 for (i = 0; i < XBUFSIZE; i++) {
1843 axbuf[i] = (void *)__get_free_page(GFP_KERNEL);
1844 if (!axbuf[i])
1845 goto err_free_axbuf;
1846 }
1847
1848 return 0;
1849
1850err_free_axbuf:
1851 for (i = 0; i < XBUFSIZE && axbuf[i]; i++)
1852 free_page((unsigned long)axbuf[i]);
1853err_free_xbuf:
1854 for (i = 0; i < XBUFSIZE && xbuf[i]; i++)
1855 free_page((unsigned long)xbuf[i]);
1856
1857 return -ENOMEM;
1858}
1859
1860void testmgr_exit(void)
1861{
1862 int i;
1863
1864 for (i = 0; i < XBUFSIZE; i++)
1865 free_page((unsigned long)axbuf[i]);
1866 for (i = 0; i < XBUFSIZE; i++)
1867 free_page((unsigned long)xbuf[i]);
1868}
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-19 02:55:32 -0500