?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
More meth updates.
[linux-2.6/linux-mips.git] / crypto / tcrypt.c
blobe3011b2f56f353e45db6f9ea8e017bd5a8c58aea
1 /*
2 * Quick & dirty crypto testing module.
3 *
4 * This will only exist until we have a better testing mechanism
5 * (e.g. a char device).
6 *
7 * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
8 * Copyright (c) 2002 Jean-Francois Dive <jef@linuxbe.org>
9 *
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by the Free
12 * Software Foundation; either version 2 of the License, or (at your option)
13 * any later version.
14 *
15 */
16 #include <linux/init.h>
17 #include <linux/module.h>
18 #include <linux/string.h>
19 #include <linux/mm.h>
20 #include <linux/slab.h>
21 #include <asm/scatterlist.h>
22 #include <linux/string.h>
23 #include <linux/crypto.h>
24 #include <linux/highmem.h>
25 #include "tcrypt.h"
26
27 /*
28 * Need to kmalloc() memory for testing kmap().
29 */
30 #define TVMEMSIZE 4096
31 #define XBUFSIZE 32768
32
33 /*
34 * Indexes into the xbuf to simulate cross-page access.
35 */
36 #define IDX1 37
37 #define IDX2 32400
38 #define IDX3 1
39 #define IDX4 8193
40 #define IDX5 22222
41 #define IDX6 17101
42 #define IDX7 27333
43 #define IDX8 3000
44
45 static int mode = 0;
46 static char *xbuf;
47 static char *tvmem;
48
49 static char *check[] = {
50 "des", "md5", "des3_ede", "rot13", "sha1", "sha256", "blowfish",
51 "twofish", "serpent", "sha384", "sha512", "md4", "aes", "deflate",
52 NULL
53 };
54
55 static void
56 hexdump(unsigned char *buf, unsigned int len)
57 {
58 while (len--)
59 printk("%02x", *buf++);
60
61 printk("\n");
62 }
63
64 static void
65 test_md5(void)
66 {
67 char *p;
68 unsigned int i;
69 struct scatterlist sg[2];
70 char result[128];
71 struct crypto_tfm *tfm;
72 struct md5_testvec *md5_tv;
73 unsigned int tsize;
74
75 printk("\ntesting md5\n");
76
77 tsize = sizeof (md5_tv_template);
78 if (tsize > TVMEMSIZE) {
79 printk("template (%u) too big for tvmem (%u)\n", tsize,
80 TVMEMSIZE);
81 return;
82 }
83
84 memcpy(tvmem, md5_tv_template, tsize);
85 md5_tv = (void *) tvmem;
86
87 tfm = crypto_alloc_tfm("md5", 0);
88 if (tfm == NULL) {
89 printk("failed to load transform for md5\n");
90 return;
91 }
92
93 for (i = 0; i < MD5_TEST_VECTORS; i++) {
94 printk("test %u:\n", i + 1);
95 memset(result, 0, sizeof (result));
96
97 p = md5_tv[i].plaintext;
98 sg[0].page = virt_to_page(p);
99 sg[0].offset = ((long) p & ~PAGE_MASK);
100 sg[0].length = strlen(md5_tv[i].plaintext);
101
102 crypto_digest_init(tfm);
103 crypto_digest_update(tfm, sg, 1);
104 crypto_digest_final(tfm, result);
105
106 hexdump(result, crypto_tfm_alg_digestsize(tfm));
107 printk("%s\n",
108 memcmp(result, md5_tv[i].digest,
109 crypto_tfm_alg_digestsize(tfm)) ? "fail" :
110 "pass");
111 }
112
113 printk("\ntesting md5 across pages\n");
114
115 /* setup the dummy buffer first */
116 memset(xbuf, 0, XBUFSIZE);
117 memcpy(&xbuf[IDX1], "abcdefghijklm", 13);
118 memcpy(&xbuf[IDX2], "nopqrstuvwxyz", 13);
119
120 p = &xbuf[IDX1];
121 sg[0].page = virt_to_page(p);
122 sg[0].offset = ((long) p & ~PAGE_MASK);
123 sg[0].length = 13;
124
125 p = &xbuf[IDX2];
126 sg[1].page = virt_to_page(p);
127 sg[1].offset = ((long) p & ~PAGE_MASK);
128 sg[1].length = 13;
129
130 memset(result, 0, sizeof (result));
131 crypto_digest_digest(tfm, sg, 2, result);
132 hexdump(result, crypto_tfm_alg_digestsize(tfm));
133
134 printk("%s\n",
135 memcmp(result, md5_tv[4].digest,
136 crypto_tfm_alg_digestsize(tfm)) ? "fail" : "pass");
137 crypto_free_tfm(tfm);
138 }
139
140 #ifdef CONFIG_CRYPTO_HMAC
141 static void
142 test_hmac_md5(void)
143 {
144 char *p;
145 unsigned int i, klen;
146 struct scatterlist sg[2];
147 char result[128];
148 struct crypto_tfm *tfm;
149 struct hmac_md5_testvec *hmac_md5_tv;
150 unsigned int tsize;
151
152 tfm = crypto_alloc_tfm("md5", 0);
153 if (tfm == NULL) {
154 printk("failed to load transform for md5\n");
155 return;
156 }
157
158 printk("\ntesting hmac_md5\n");
159
160 tsize = sizeof (hmac_md5_tv_template);
161 if (tsize > TVMEMSIZE) {
162 printk("template (%u) too big for tvmem (%u)\n", tsize,
163 TVMEMSIZE);
164 goto out;
165 }
166
167 memcpy(tvmem, hmac_md5_tv_template, tsize);
168 hmac_md5_tv = (void *) tvmem;
169
170 for (i = 0; i < HMAC_MD5_TEST_VECTORS; i++) {
171 printk("test %u:\n", i + 1);
172 memset(result, 0, sizeof (result));
173
174 p = hmac_md5_tv[i].plaintext;
175 sg[0].page = virt_to_page(p);
176 sg[0].offset = ((long) p & ~PAGE_MASK);
177 sg[0].length = strlen(hmac_md5_tv[i].plaintext);
178
179 klen = strlen(hmac_md5_tv[i].key);
180 crypto_hmac(tfm, hmac_md5_tv[i].key, &klen, sg, 1, result);
181
182 hexdump(result, crypto_tfm_alg_digestsize(tfm));
183 printk("%s\n",
184 memcmp(result, hmac_md5_tv[i].digest,
185 crypto_tfm_alg_digestsize(tfm)) ? "fail" :
186 "pass");
187 }
188
189 printk("\ntesting hmac_md5 across pages\n");
190
191 memset(xbuf, 0, XBUFSIZE);
192
193 memcpy(&xbuf[IDX1], "what do ya want ", 16);
194 memcpy(&xbuf[IDX2], "for nothing?", 12);
195
196 p = &xbuf[IDX1];
197 sg[0].page = virt_to_page(p);
198 sg[0].offset = ((long) p & ~PAGE_MASK);
199 sg[0].length = 16;
200
201 p = &xbuf[IDX2];
202 sg[1].page = virt_to_page(p);
203 sg[1].offset = ((long) p & ~PAGE_MASK);
204 sg[1].length = 12;
205
206 memset(result, 0, sizeof (result));
207 klen = strlen(hmac_md5_tv[7].key);
208 crypto_hmac(tfm, hmac_md5_tv[7].key, &klen, sg, 2, result);
209 hexdump(result, crypto_tfm_alg_digestsize(tfm));
210
211 printk("%s\n",
212 memcmp(result, hmac_md5_tv[7].digest,
213 crypto_tfm_alg_digestsize(tfm)) ? "fail" : "pass");
214 out:
215 crypto_free_tfm(tfm);
216 }
217
218 static void
219 test_hmac_sha1(void)
220 {
221 char *p;
222 unsigned int i, klen;
223 struct crypto_tfm *tfm;
224 struct hmac_sha1_testvec *hmac_sha1_tv;
225 struct scatterlist sg[2];
226 unsigned int tsize;
227 char result[SHA1_DIGEST_SIZE];
228
229 tfm = crypto_alloc_tfm("sha1", 0);
230 if (tfm == NULL) {
231 printk("failed to load transform for sha1\n");
232 return;
233 }
234
235 printk("\ntesting hmac_sha1\n");
236
237 tsize = sizeof (hmac_sha1_tv_template);
238 if (tsize > TVMEMSIZE) {
239 printk("template (%u) too big for tvmem (%u)\n", tsize,
240 TVMEMSIZE);
241 goto out;
242 }
243
244 memcpy(tvmem, hmac_sha1_tv_template, tsize);
245 hmac_sha1_tv = (void *) tvmem;
246
247 for (i = 0; i < HMAC_SHA1_TEST_VECTORS; i++) {
248 printk("test %u:\n", i + 1);
249 memset(result, 0, sizeof (result));
250
251 p = hmac_sha1_tv[i].plaintext;
252 sg[0].page = virt_to_page(p);
253 sg[0].offset = ((long) p & ~PAGE_MASK);
254 sg[0].length = strlen(hmac_sha1_tv[i].plaintext);
255
256 klen = strlen(hmac_sha1_tv[i].key);
257
258 crypto_hmac(tfm, hmac_sha1_tv[i].key, &klen, sg, 1, result);
259
260 hexdump(result, sizeof (result));
261 printk("%s\n",
262 memcmp(result, hmac_sha1_tv[i].digest,
263 crypto_tfm_alg_digestsize(tfm)) ? "fail" :
264 "pass");
265 }
266
267 printk("\ntesting hmac_sha1 across pages\n");
268
269 /* setup the dummy buffer first */
270 memset(xbuf, 0, XBUFSIZE);
271
272 memcpy(&xbuf[IDX1], "what do ya want ", 16);
273 memcpy(&xbuf[IDX2], "for nothing?", 12);
274
275 p = &xbuf[IDX1];
276 sg[0].page = virt_to_page(p);
277 sg[0].offset = ((long) p & ~PAGE_MASK);
278 sg[0].length = 16;
279
280 p = &xbuf[IDX2];
281 sg[1].page = virt_to_page(p);
282 sg[1].offset = ((long) p & ~PAGE_MASK);
283 sg[1].length = 12;
284
285 memset(result, 0, sizeof (result));
286 klen = strlen(hmac_sha1_tv[7].key);
287 crypto_hmac(tfm, hmac_sha1_tv[7].key, &klen, sg, 2, result);
288 hexdump(result, crypto_tfm_alg_digestsize(tfm));
289
290 printk("%s\n",
291 memcmp(result, hmac_sha1_tv[7].digest,
292 crypto_tfm_alg_digestsize(tfm)) ? "fail" : "pass");
293 out:
294 crypto_free_tfm(tfm);
295 }
296
297 static void
298 test_hmac_sha256(void)
299 {
300 char *p;
301 unsigned int i, klen;
302 struct crypto_tfm *tfm;
303 struct hmac_sha256_testvec *hmac_sha256_tv;
304 struct scatterlist sg[2];
305 unsigned int tsize;
306 char result[SHA256_DIGEST_SIZE];
307
308 tfm = crypto_alloc_tfm("sha256", 0);
309 if (tfm == NULL) {
310 printk("failed to load transform for sha256\n");
311 return;
312 }
313
314 printk("\ntesting hmac_sha256\n");
315
316 tsize = sizeof (hmac_sha256_tv_template);
317 if (tsize > TVMEMSIZE) {
318 printk("template (%u) too big for tvmem (%u)\n", tsize,
319 TVMEMSIZE);
320 goto out;
321 }
322
323 memcpy(tvmem, hmac_sha256_tv_template, tsize);
324 hmac_sha256_tv = (void *) tvmem;
325
326 for (i = 0; i < HMAC_SHA256_TEST_VECTORS; i++) {
327 printk("test %u:\n", i + 1);
328 memset(result, 0, sizeof (result));
329
330 p = hmac_sha256_tv[i].plaintext;
331 sg[0].page = virt_to_page(p);
332 sg[0].offset = ((long) p & ~PAGE_MASK);
333 sg[0].length = strlen(hmac_sha256_tv[i].plaintext);
334
335 klen = strlen(hmac_sha256_tv[i].key);
336
337 hexdump(hmac_sha256_tv[i].key, strlen(hmac_sha256_tv[i].key));
338 crypto_hmac(tfm, hmac_sha256_tv[i].key, &klen, sg, 1, result);
339 hexdump(result, crypto_tfm_alg_digestsize(tfm));
340 printk("%s\n",
341 memcmp(result, hmac_sha256_tv[i].digest,
342 crypto_tfm_alg_digestsize(tfm)) ? "fail" : "pass");
343 }
344
345 out:
346 crypto_free_tfm(tfm);
347 }
348
349 #endif /* CONFIG_CRYPTO_HMAC */
350
351 static void
352 test_md4(void)
353 {
354 char *p;
355 unsigned int i;
356 struct scatterlist sg[1];
357 char result[128];
358 struct crypto_tfm *tfm;
359 struct md4_testvec *md4_tv;
360 unsigned int tsize;
361
362 printk("\ntesting md4\n");
363
364 tsize = sizeof (md4_tv_template);
365 if (tsize > TVMEMSIZE) {
366 printk("template (%u) too big for tvmem (%u)\n", tsize,
367 TVMEMSIZE);
368 return;
369 }
370
371 memcpy(tvmem, md4_tv_template, tsize);
372 md4_tv = (void *) tvmem;
373
374 tfm = crypto_alloc_tfm("md4", 0);
375 if (tfm == NULL) {
376 printk("failed to load transform for md4\n");
377 return;
378 }
379
380 for (i = 0; i < MD4_TEST_VECTORS; i++) {
381 printk("test %u:\n", i + 1);
382 memset(result, 0, sizeof (result));
383
384 p = md4_tv[i].plaintext;
385 sg[0].page = virt_to_page(p);
386 sg[0].offset = ((long) p & ~PAGE_MASK);
387 sg[0].length = strlen(md4_tv[i].plaintext);
388
389 crypto_digest_digest(tfm, sg, 1, result);
390
391 hexdump(result, crypto_tfm_alg_digestsize(tfm));
392 printk("%s\n",
393 memcmp(result, md4_tv[i].digest,
394 crypto_tfm_alg_digestsize(tfm)) ? "fail" :
395 "pass");
396 }
397
398 crypto_free_tfm(tfm);
399 }
400
401 static void
402 test_sha1(void)
403 {
404 char *p;
405 unsigned int i;
406 struct crypto_tfm *tfm;
407 struct sha1_testvec *sha1_tv;
408 struct scatterlist sg[2];
409 unsigned int tsize;
410 char result[SHA1_DIGEST_SIZE];
411
412 printk("\ntesting sha1\n");
413
414 tsize = sizeof (sha1_tv_template);
415 if (tsize > TVMEMSIZE) {
416 printk("template (%u) too big for tvmem (%u)\n", tsize,
417 TVMEMSIZE);
418 return;
419 }
420
421 memcpy(tvmem, sha1_tv_template, tsize);
422 sha1_tv = (void *) tvmem;
423
424 tfm = crypto_alloc_tfm("sha1", 0);
425 if (tfm == NULL) {
426 printk("failed to load transform for sha1\n");
427 return;
428 }
429
430 for (i = 0; i < SHA1_TEST_VECTORS; i++) {
431 printk("test %u:\n", i + 1);
432 memset(result, 0, sizeof (result));
433
434 p = sha1_tv[i].plaintext;
435 sg[0].page = virt_to_page(p);
436 sg[0].offset = ((long) p & ~PAGE_MASK);
437 sg[0].length = strlen(sha1_tv[i].plaintext);
438
439 crypto_digest_init(tfm);
440 crypto_digest_update(tfm, sg, 1);
441 crypto_digest_final(tfm, result);
442
443 hexdump(result, crypto_tfm_alg_digestsize(tfm));
444 printk("%s\n",
445 memcmp(result, sha1_tv[i].digest,
446 crypto_tfm_alg_digestsize(tfm)) ? "fail" :
447 "pass");
448 }
449
450 printk("\ntesting sha1 across pages\n");
451
452 /* setup the dummy buffer first */
453 memset(xbuf, 0, XBUFSIZE);
454 memcpy(&xbuf[IDX1], "abcdbcdecdefdefgefghfghighij", 28);
455 memcpy(&xbuf[IDX2], "hijkijkljklmklmnlmnomnopnopq", 28);
456
457 p = &xbuf[IDX1];
458 sg[0].page = virt_to_page(p);
459 sg[0].offset = ((long) p & ~PAGE_MASK);
460 sg[0].length = 28;
461
462 p = &xbuf[IDX2];
463 sg[1].page = virt_to_page(p);
464 sg[1].offset = ((long) p & ~PAGE_MASK);
465 sg[1].length = 28;
466
467 memset(result, 0, sizeof (result));
468 crypto_digest_digest(tfm, sg, 2, result);
469 hexdump(result, crypto_tfm_alg_digestsize(tfm));
470 printk("%s\n",
471 memcmp(result, sha1_tv[1].digest,
472 crypto_tfm_alg_digestsize(tfm)) ? "fail" : "pass");
473 crypto_free_tfm(tfm);
474 }
475
476 static void
477 test_sha256(void)
478 {
479 char *p;
480 unsigned int i;
481 struct crypto_tfm *tfm;
482 struct sha256_testvec *sha256_tv;
483 struct scatterlist sg[2];
484 unsigned int tsize;
485 char result[SHA256_DIGEST_SIZE];
486
487 printk("\ntesting sha256\n");
488
489 tsize = sizeof (sha256_tv_template);
490 if (tsize > TVMEMSIZE) {
491 printk("template (%u) too big for tvmem (%u)\n", tsize,
492 TVMEMSIZE);
493 return;
494 }
495
496 memcpy(tvmem, sha256_tv_template, tsize);
497 sha256_tv = (void *) tvmem;
498
499 tfm = crypto_alloc_tfm("sha256", 0);
500 if (tfm == NULL) {
501 printk("failed to load transform for sha256\n");
502 return;
503 }
504
505 for (i = 0; i < SHA256_TEST_VECTORS; i++) {
506 printk("test %u:\n", i + 1);
507 memset(result, 0, sizeof (result));
508
509 p = sha256_tv[i].plaintext;
510 sg[0].page = virt_to_page(p);
511 sg[0].offset = ((long) p & ~PAGE_MASK);
512 sg[0].length = strlen(sha256_tv[i].plaintext);
513
514 crypto_digest_init(tfm);
515 crypto_digest_update(tfm, sg, 1);
516 crypto_digest_final(tfm, result);
517
518 hexdump(result, crypto_tfm_alg_digestsize(tfm));
519 printk("%s\n",
520 memcmp(result, sha256_tv[i].digest,
521 crypto_tfm_alg_digestsize(tfm)) ? "fail" :
522 "pass");
523 }
524
525 printk("\ntesting sha256 across pages\n");
526
527 /* setup the dummy buffer first */
528 memset(xbuf, 0, XBUFSIZE);
529 memcpy(&xbuf[IDX1], "abcdbcdecdefdefgefghfghighij", 28);
530 memcpy(&xbuf[IDX2], "hijkijkljklmklmnlmnomnopnopq", 28);
531
532 p = &xbuf[IDX1];
533 sg[0].page = virt_to_page(p);
534 sg[0].offset = ((long) p & ~PAGE_MASK);
535 sg[0].length = 28;
536
537 p = &xbuf[IDX2];
538 sg[1].page = virt_to_page(p);
539 sg[1].offset = ((long) p & ~PAGE_MASK);
540 sg[1].length = 28;
541
542 memset(result, 0, sizeof (result));
543 crypto_digest_digest(tfm, sg, 2, result);
544 hexdump(result, crypto_tfm_alg_digestsize(tfm));
545 printk("%s\n",
546 memcmp(result, sha256_tv[1].digest,
547 crypto_tfm_alg_digestsize(tfm)) ? "fail" : "pass");
548
549 crypto_free_tfm(tfm);
550 }
551
552 static void
553 test_sha384(void)
554 {
555 char *p;
556 unsigned int i;
557 struct crypto_tfm *tfm;
558 struct sha384_testvec *sha384_tv;
559 struct scatterlist sg[2];
560 unsigned int tsize;
561 char result[SHA384_DIGEST_SIZE];
562
563 printk("\ntesting sha384\n");
564
565 tsize = sizeof (sha384_tv_template);
566 if (tsize > TVMEMSIZE) {
567 printk("template (%u) too big for tvmem (%u)\n", tsize,
568 TVMEMSIZE);
569 return;
570 }
571
572 memcpy(tvmem, sha384_tv_template, tsize);
573 sha384_tv = (void *) tvmem;
574
575 tfm = crypto_alloc_tfm("sha384", 0);
576 if (tfm == NULL) {
577 printk("failed to load transform for sha384\n");
578 return;
579 }
580
581 for (i = 0; i < SHA384_TEST_VECTORS; i++) {
582 printk("test %u:\n", i + 1);
583 memset(result, 0, sizeof (result));
584
585 p = sha384_tv[i].plaintext;
586 sg[0].page = virt_to_page(p);
587 sg[0].offset = ((long) p & ~PAGE_MASK);
588 sg[0].length = strlen(sha384_tv[i].plaintext);
589
590 crypto_digest_init(tfm);
591 crypto_digest_update(tfm, sg, 1);
592 crypto_digest_final(tfm, result);
593
594 hexdump(result, crypto_tfm_alg_digestsize(tfm));
595 printk("%s\n",
596 memcmp(result, sha384_tv[i].digest,
597 crypto_tfm_alg_digestsize(tfm)) ? "fail" :
598 "pass");
599 }
600
601 crypto_free_tfm(tfm);
602 }
603
604 static void
605 test_sha512(void)
606 {
607 char *p;
608 unsigned int i;
609 struct crypto_tfm *tfm;
610 struct sha512_testvec *sha512_tv;
611 struct scatterlist sg[2];
612 unsigned int tsize;
613 char result[SHA512_DIGEST_SIZE];
614
615 printk("\ntesting sha512\n");
616
617 tsize = sizeof (sha512_tv_template);
618 if (tsize > TVMEMSIZE) {
619 printk("template (%u) too big for tvmem (%u)\n", tsize,
620 TVMEMSIZE);
621 return;
622 }
623
624 memcpy(tvmem, sha512_tv_template, tsize);
625 sha512_tv = (void *) tvmem;
626
627 tfm = crypto_alloc_tfm("sha512", 0);
628 if (tfm == NULL) {
629 printk("failed to load transform for sha512\n");
630 return;
631 }
632
633 for (i = 0; i < SHA512_TEST_VECTORS; i++) {
634 printk("test %u:\n", i + 1);
635 memset(result, 0, sizeof (result));
636
637 p = sha512_tv[i].plaintext;
638 sg[0].page = virt_to_page(p);
639 sg[0].offset = ((long) p & ~PAGE_MASK);
640 sg[0].length = strlen(sha512_tv[i].plaintext);
641
642 crypto_digest_init(tfm);
643 crypto_digest_update(tfm, sg, 1);
644 crypto_digest_final(tfm, result);
645
646 hexdump(result, crypto_tfm_alg_digestsize(tfm));
647 printk("%s\n",
648 memcmp(result, sha512_tv[i].digest,
649 crypto_tfm_alg_digestsize(tfm)) ? "fail" :
650 "pass");
651 }
652
653 crypto_free_tfm(tfm);
654 }
655
656 void
657 test_des(void)
658 {
659 unsigned int ret, i, len;
660 unsigned int tsize;
661 char *p, *q;
662 struct crypto_tfm *tfm;
663 char *key;
664 char res[8];
665 struct des_tv *des_tv;
666 struct scatterlist sg[8];
667
668 printk("\ntesting des encryption\n");
669
670 tsize = sizeof (des_enc_tv_template);
671 if (tsize > TVMEMSIZE) {
672 printk("template (%u) too big for tvmem (%u)\n", tsize,
673 TVMEMSIZE);
674 return;
675 }
676
677 memcpy(tvmem, des_enc_tv_template, tsize);
678 des_tv = (void *) tvmem;
679
680 tfm = crypto_alloc_tfm("des", 0);
681 if (tfm == NULL) {
682 printk("failed to load transform for des (default ecb)\n");
683 return;
684 }
685
686 for (i = 0; i < DES_ENC_TEST_VECTORS; i++) {
687 printk("test %u:\n", i + 1);
688
689 key = des_tv[i].key;
690 tfm->crt_flags |= CRYPTO_TFM_REQ_WEAK_KEY;
691
692 ret = crypto_cipher_setkey(tfm, key, 8);
693 if (ret) {
694 printk("setkey() failed flags=%x\n", tfm->crt_flags);
695
696 if (!des_tv[i].fail)
697 goto out;
698 }
699
700 len = des_tv[i].len;
701
702 p = des_tv[i].plaintext;
703 sg[0].page = virt_to_page(p);
704 sg[0].offset = ((long) p & ~PAGE_MASK);
705 sg[0].length = len;
706 ret = crypto_cipher_encrypt(tfm, sg, sg, len);
707 if (ret) {
708 printk("encrypt() failed flags=%x\n", tfm->crt_flags);
709 goto out;
710 }
711
712 q = kmap(sg[0].page) + sg[0].offset;
713 hexdump(q, len);
714
715 printk("%s\n",
716 memcmp(q, des_tv[i].result, len) ? "fail" : "pass");
717
718 }
719
720 printk("\ntesting des ecb encryption across pages\n");
721
722 i = 5;
723 key = des_tv[i].key;
724 tfm->crt_flags = 0;
725
726 hexdump(key, 8);
727
728 ret = crypto_cipher_setkey(tfm, key, 8);
729 if (ret) {
730 printk("setkey() failed flags=%x\n", tfm->crt_flags);
731 goto out;
732 }
733
734 /* setup the dummy buffer first */
735 memset(xbuf, 0, sizeof (xbuf));
736 memcpy(&xbuf[IDX1], des_tv[i].plaintext, 8);
737 memcpy(&xbuf[IDX2], des_tv[i].plaintext + 8, 8);
738
739 p = &xbuf[IDX1];
740 sg[0].page = virt_to_page(p);
741 sg[0].offset = ((long) p & ~PAGE_MASK);
742 sg[0].length = 8;
743
744 p = &xbuf[IDX2];
745 sg[1].page = virt_to_page(p);
746 sg[1].offset = ((long) p & ~PAGE_MASK);
747 sg[1].length = 8;
748
749 ret = crypto_cipher_encrypt(tfm, sg, sg, 16);
750 if (ret) {
751 printk("encrypt() failed flags=%x\n", tfm->crt_flags);
752 goto out;
753 }
754
755 printk("page 1\n");
756 q = kmap(sg[0].page) + sg[0].offset;
757 hexdump(q, 8);
758 printk("%s\n", memcmp(q, des_tv[i].result, 8) ? "fail" : "pass");
759
760 printk("page 2\n");
761 q = kmap(sg[1].page) + sg[1].offset;
762 hexdump(q, 8);
763 printk("%s\n", memcmp(q, des_tv[i].result + 8, 8) ? "fail" : "pass");
764
765 printk("\ntesting des ecb encryption chunking scenario A\n");
766
767 /*
768 * Scenario A:
769 *
770 * F1 F2 F3
771 * [8 + 6] [2 + 8] [8]
772 * ^^^^^^ ^
773 * a b c
774 *
775 * Chunking should begin at a, then end with b, and
776 * continue encrypting at an offset of 2 until c.
777 *
778 */
779 i = 7;
780
781 key = des_tv[i].key;
782 tfm->crt_flags = 0;
783
784 ret = crypto_cipher_setkey(tfm, key, 8);
785 if (ret) {
786 printk("setkey() failed flags=%x\n", tfm->crt_flags);
787 goto out;
788 }
789
790 /* setup the dummy buffer first */
791 memset(xbuf, 0, sizeof (xbuf));
792
793 /* Frag 1: 8 + 6 */
794 memcpy(&xbuf[IDX3], des_tv[i].plaintext, 14);
795
796 /* Frag 2: 2 + 8 */
797 memcpy(&xbuf[IDX4], des_tv[i].plaintext + 14, 10);
798
799 /* Frag 3: 8 */
800 memcpy(&xbuf[IDX5], des_tv[i].plaintext + 24, 8);
801
802 p = &xbuf[IDX3];
803 sg[0].page = virt_to_page(p);
804 sg[0].offset = ((long) p & ~PAGE_MASK);
805 sg[0].length = 14;
806
807 p = &xbuf[IDX4];
808 sg[1].page = virt_to_page(p);
809 sg[1].offset = ((long) p & ~PAGE_MASK);
810 sg[1].length = 10;
811
812 p = &xbuf[IDX5];
813 sg[2].page = virt_to_page(p);
814 sg[2].offset = ((long) p & ~PAGE_MASK);
815 sg[2].length = 8;
816
817 ret = crypto_cipher_encrypt(tfm, sg, sg, 32);
818
819 if (ret) {
820 printk("decrypt() failed flags=%x\n", tfm->crt_flags);
821 goto out;
822 }
823
824 printk("page 1\n");
825 q = kmap(sg[0].page) + sg[0].offset;
826 hexdump(q, 14);
827 printk("%s\n", memcmp(q, des_tv[i].result, 14) ? "fail" : "pass");
828
829 printk("page 2\n");
830 q = kmap(sg[1].page) + sg[1].offset;
831 hexdump(q, 10);
832 printk("%s\n", memcmp(q, des_tv[i].result + 14, 10) ? "fail" : "pass");
833
834 printk("page 3\n");
835 q = kmap(sg[2].page) + sg[2].offset;
836 hexdump(q, 8);
837 printk("%s\n", memcmp(q, des_tv[i].result + 24, 8) ? "fail" : "pass");
838
839 printk("\ntesting des ecb encryption chunking scenario B\n");
840
841 /*
842 * Scenario B:
843 *
844 * F1 F2 F3 F4
845 * [2] [1] [3] [2 + 8 + 8]
846 */
847 i = 7;
848
849 key = des_tv[i].key;
850 tfm->crt_flags = 0;
851
852 ret = crypto_cipher_setkey(tfm, key, 8);
853 if (ret) {
854 printk("setkey() failed flags=%x\n", tfm->crt_flags);
855 goto out;
856 }
857
858 /* setup the dummy buffer first */
859 memset(xbuf, 0, sizeof (xbuf));
860
861 /* Frag 1: 2 */
862 memcpy(&xbuf[IDX3], des_tv[i].plaintext, 2);
863
864 /* Frag 2: 1 */
865 memcpy(&xbuf[IDX4], des_tv[i].plaintext + 2, 1);
866
867 /* Frag 3: 3 */
868 memcpy(&xbuf[IDX5], des_tv[i].plaintext + 3, 3);
869
870 /* Frag 4: 2 + 8 + 8 */
871 memcpy(&xbuf[IDX6], des_tv[i].plaintext + 6, 18);
872
873 p = &xbuf[IDX3];
874 sg[0].page = virt_to_page(p);
875 sg[0].offset = ((long) p & ~PAGE_MASK);
876 sg[0].length = 2;
877
878 p = &xbuf[IDX4];
879 sg[1].page = virt_to_page(p);
880 sg[1].offset = ((long) p & ~PAGE_MASK);
881 sg[1].length = 1;
882
883 p = &xbuf[IDX5];
884 sg[2].page = virt_to_page(p);
885 sg[2].offset = ((long) p & ~PAGE_MASK);
886 sg[2].length = 3;
887
888 p = &xbuf[IDX6];
889 sg[3].page = virt_to_page(p);
890 sg[3].offset = ((long) p & ~PAGE_MASK);
891 sg[3].length = 18;
892
893 ret = crypto_cipher_encrypt(tfm, sg, sg, 24);
894
895 if (ret) {
896 printk("encrypt() failed flags=%x\n", tfm->crt_flags);
897 goto out;
898 }
899
900 printk("page 1\n");
901 q = kmap(sg[0].page) + sg[0].offset;
902 hexdump(q, 2);
903 printk("%s\n", memcmp(q, des_tv[i].result, 2) ? "fail" : "pass");
904
905 printk("page 2\n");
906 q = kmap(sg[1].page) + sg[1].offset;
907 hexdump(q, 1);
908 printk("%s\n", memcmp(q, des_tv[i].result + 2, 1) ? "fail" : "pass");
909
910 printk("page 3\n");
911 q = kmap(sg[2].page) + sg[2].offset;
912 hexdump(q, 3);
913 printk("%s\n", memcmp(q, des_tv[i].result + 3, 3) ? "fail" : "pass");
914
915 printk("page 4\n");
916 q = kmap(sg[3].page) + sg[3].offset;
917 hexdump(q, 18);
918 printk("%s\n", memcmp(q, des_tv[i].result + 6, 18) ? "fail" : "pass");
919
920 printk("\ntesting des ecb encryption chunking scenario C\n");
921
922 /*
923 * Scenario B:
924 *
925 * F1 F2 F3 F4 F5
926 * [2] [2] [2] [2] [8]
927 */
928 i = 7;
929
930 key = des_tv[i].key;
931 tfm->crt_flags = 0;
932
933 ret = crypto_cipher_setkey(tfm, key, 8);
934 if (ret) {
935 printk("setkey() failed flags=%x\n", tfm->crt_flags);
936 goto out;
937 }
938
939 /* setup the dummy buffer first */
940 memset(xbuf, 0, sizeof (xbuf));
941
942 /* Frag 1: 2 */
943 memcpy(&xbuf[IDX3], des_tv[i].plaintext, 2);
944
945 /* Frag 2: 2 */
946 memcpy(&xbuf[IDX4], des_tv[i].plaintext + 2, 2);
947
948 /* Frag 3: 2 */
949 memcpy(&xbuf[IDX5], des_tv[i].plaintext + 4, 2);
950
951 /* Frag 4: 2 */
952 memcpy(&xbuf[IDX6], des_tv[i].plaintext + 6, 2);
953
954 /* Frag 5: 8 */
955 memcpy(&xbuf[IDX7], des_tv[i].plaintext + 8, 8);
956
957 p = &xbuf[IDX3];
958 sg[0].page = virt_to_page(p);
959 sg[0].offset = ((long) p & ~PAGE_MASK);
960 sg[0].length = 2;
961
962 p = &xbuf[IDX4];
963 sg[1].page = virt_to_page(p);
964 sg[1].offset = ((long) p & ~PAGE_MASK);
965 sg[1].length = 2;
966
967 p = &xbuf[IDX5];
968 sg[2].page = virt_to_page(p);
969 sg[2].offset = ((long) p & ~PAGE_MASK);
970 sg[2].length = 2;
971
972 p = &xbuf[IDX6];
973 sg[3].page = virt_to_page(p);
974 sg[3].offset = ((long) p & ~PAGE_MASK);
975 sg[3].length = 2;
976
977 p = &xbuf[IDX7];
978 sg[4].page = virt_to_page(p);
979 sg[4].offset = ((long) p & ~PAGE_MASK);
980 sg[4].length = 8;
981
982 ret = crypto_cipher_encrypt(tfm, sg, sg, 16);
983
984 if (ret) {
985 printk("encrypt() failed flags=%x\n", tfm->crt_flags);
986 goto out;
987 }
988
989 printk("page 1\n");
990 q = kmap(sg[0].page) + sg[0].offset;
991 hexdump(q, 2);
992 printk("%s\n", memcmp(q, des_tv[i].result, 2) ? "fail" : "pass");
993
994 printk("page 2\n");
995 q = kmap(sg[1].page) + sg[1].offset;
996 hexdump(q, 2);
997 printk("%s\n", memcmp(q, des_tv[i].result + 2, 2) ? "fail" : "pass");
998
999 printk("page 3\n");
1000 q = kmap(sg[2].page) + sg[2].offset;
1001 hexdump(q, 2);
1002 printk("%s\n", memcmp(q, des_tv[i].result + 4, 2) ? "fail" : "pass");
1003
1004 printk("page 4\n");
1005 q = kmap(sg[3].page) + sg[3].offset;
1006 hexdump(q, 2);
1007 printk("%s\n", memcmp(q, des_tv[i].result + 6, 2) ? "fail" : "pass");
1008
1009 printk("page 5\n");
1010 q = kmap(sg[4].page) + sg[4].offset;
1011 hexdump(q, 8);
1012 printk("%s\n", memcmp(q, des_tv[i].result + 8, 8) ? "fail" : "pass");
1013
1014 printk("\ntesting des ecb encryption chunking scenario D\n");
1015
1016 /*
1017 * Scenario D, torture test, one byte per frag.
1018 */
1019 i = 7;
1020 key = des_tv[i].key;
1021 tfm->crt_flags = 0;
1022
1023 ret = crypto_cipher_setkey(tfm, key, 8);
1024 if (ret) {
1025 printk("setkey() failed flags=%x\n", tfm->crt_flags);
1026 goto out;
1027 }
1028
1029 /* setup the dummy buffer first */
1030 memset(xbuf, 0, XBUFSIZE);
1031
1032 xbuf[IDX1] = des_tv[i].plaintext[0];
1033 xbuf[IDX2] = des_tv[i].plaintext[1];
1034 xbuf[IDX3] = des_tv[i].plaintext[2];
1035 xbuf[IDX4] = des_tv[i].plaintext[3];
1036 xbuf[IDX5] = des_tv[i].plaintext[4];
1037 xbuf[IDX6] = des_tv[i].plaintext[5];
1038 xbuf[IDX7] = des_tv[i].plaintext[6];
1039 xbuf[IDX8] = des_tv[i].plaintext[7];
1040
1041 p = &xbuf[IDX1];
1042 sg[0].page = virt_to_page(p);
1043 sg[0].offset = ((long) p & ~PAGE_MASK);
1044 sg[0].length = 1;
1045
1046 p = &xbuf[IDX2];
1047 sg[1].page = virt_to_page(p);
1048 sg[1].offset = ((long) p & ~PAGE_MASK);
1049 sg[1].length = 1;
1050
1051 p = &xbuf[IDX3];
1052 sg[2].page = virt_to_page(p);
1053 sg[2].offset = ((long) p & ~PAGE_MASK);
1054 sg[2].length = 1;
1055
1056 p = &xbuf[IDX4];
1057 sg[3].page = virt_to_page(p);
1058 sg[3].offset = ((long) p & ~PAGE_MASK);
1059 sg[3].length = 1;
1060
1061 p = &xbuf[IDX5];
1062 sg[4].page = virt_to_page(p);
1063 sg[4].offset = ((long) p & ~PAGE_MASK);
1064 sg[4].length = 1;
1065
1066 p = &xbuf[IDX6];
1067 sg[5].page = virt_to_page(p);
1068 sg[5].offset = ((long) p & ~PAGE_MASK);
1069 sg[5].length = 1;
1070
1071 p = &xbuf[IDX7];
1072 sg[6].page = virt_to_page(p);
1073 sg[6].offset = ((long) p & ~PAGE_MASK);
1074 sg[6].length = 1;
1075
1076 p = &xbuf[IDX8];
1077 sg[7].page = virt_to_page(p);
1078 sg[7].offset = ((long) p & ~PAGE_MASK);
1079 sg[7].length = 1;
1080
1081 ret = crypto_cipher_encrypt(tfm, sg, sg, 8);
1082 if (ret) {
1083 printk("encrypt() failed flags=%x\n", tfm->crt_flags);
1084 goto out;
1085 }
1086
1087 for (i = 0; i < 8; i++)
1088 res[i] = *(char *) (kmap(sg[i].page) + sg[i].offset);
1089
1090 hexdump(res, 8);
1091 printk("%s\n", memcmp(res, des_tv[7].result, 8) ? "fail" : "pass");
1092
1093 printk("\ntesting des decryption\n");
1094
1095 tsize = sizeof (des_dec_tv_template);
1096 if (tsize > TVMEMSIZE) {
1097 printk("template (%u) too big for tvmem (%u)\n", tsize,
1098 TVMEMSIZE);
1099 return;
1100 }
1101 memcpy(tvmem, des_dec_tv_template, tsize);
1102 des_tv = (void *) tvmem;
1103
1104 for (i = 0; i < DES_DEC_TEST_VECTORS; i++) {
1105 printk("test %u:\n", i + 1);
1106
1107 key = des_tv[i].key;
1108
1109 tfm->crt_flags = 0;
1110 ret = crypto_cipher_setkey(tfm, key, 8);
1111 if (ret) {
1112 printk("setkey() failed flags=%x\n", tfm->crt_flags);
1113 goto out;
1114 }
1115
1116 len = des_tv[i].len;
1117
1118 p = des_tv[i].plaintext;
1119 sg[0].page = virt_to_page(p);
1120 sg[0].offset = ((long) p & ~PAGE_MASK);
1121 sg[0].length = len;
1122
1123 ret = crypto_cipher_decrypt(tfm, sg, sg, sg[0].length);
1124 if (ret) {
1125 printk("des_decrypt() failed flags=%x\n",
1126 tfm->crt_flags);
1127 goto out;
1128 }
1129
1130 q = kmap(sg[0].page) + sg[0].offset;
1131 hexdump(q, len);
1132
1133 printk("%s\n",
1134 memcmp(q, des_tv[i].result, len) ? "fail" : "pass");
1135
1136 }
1137
1138 printk("\ntesting des ecb decryption across pages\n");
1139
1140 i = 6;
1141
1142 key = des_tv[i].key;
1143 tfm->crt_flags = 0;
1144
1145 ret = crypto_cipher_setkey(tfm, key, 8);
1146 if (ret) {
1147 printk("setkey() failed flags=%x\n", tfm->crt_flags);
1148 goto out;
1149 }
1150
1151 /* setup the dummy buffer first */
1152 memset(xbuf, 0, sizeof (xbuf));
1153 memcpy(&xbuf[IDX1], des_tv[i].plaintext, 8);
1154 memcpy(&xbuf[IDX2], des_tv[i].plaintext + 8, 8);
1155
1156 p = &xbuf[IDX1];
1157 sg[0].page = virt_to_page(p);
1158 sg[0].offset = ((long) p & ~PAGE_MASK);
1159 sg[0].length = 8;
1160
1161 p = &xbuf[IDX2];
1162 sg[1].page = virt_to_page(p);
1163 sg[1].offset = ((long) p & ~PAGE_MASK);
1164 sg[1].length = 8;
1165
1166 ret = crypto_cipher_decrypt(tfm, sg, sg, 16);
1167 if (ret) {
1168 printk("decrypt() failed flags=%x\n", tfm->crt_flags);
1169 goto out;
1170 }
1171
1172 printk("page 1\n");
1173 q = kmap(sg[0].page) + sg[0].offset;
1174 hexdump(q, 8);
1175 printk("%s\n", memcmp(q, des_tv[i].result, 8) ? "fail" : "pass");
1176
1177 printk("page 2\n");
1178 q = kmap(sg[1].page) + sg[1].offset;
1179 hexdump(q, 8);
1180 printk("%s\n", memcmp(q, des_tv[i].result + 8, 8) ? "fail" : "pass");
1181
1182 /*
1183 * Scenario E:
1184 *
1185 * F1 F2 F3
1186 * [3] [5 + 7] [1]
1187 *
1188 */
1189 printk("\ntesting des ecb decryption chunking scenario E\n");
1190 i = 2;
1191
1192 key = des_tv[i].key;
1193 tfm->crt_flags = 0;
1194
1195 ret = crypto_cipher_setkey(tfm, key, 8);
1196 if (ret) {
1197 printk("setkey() failed flags=%x\n", tfm->crt_flags);
1198 goto out;
1199 }
1200
1201 /* setup the dummy buffer first */
1202 memset(xbuf, 0, sizeof (xbuf));
1203
1204 memcpy(&xbuf[IDX1], des_tv[i].plaintext, 3);
1205 memcpy(&xbuf[IDX2], des_tv[i].plaintext + 3, 12);
1206 memcpy(&xbuf[IDX3], des_tv[i].plaintext + 15, 1);
1207
1208 p = &xbuf[IDX1];
1209 sg[0].page = virt_to_page(p);
1210 sg[0].offset = ((long) p & ~PAGE_MASK);
1211 sg[0].length = 3;
1212
1213 p = &xbuf[IDX2];
1214 sg[1].page = virt_to_page(p);
1215 sg[1].offset = ((long) p & ~PAGE_MASK);
1216 sg[1].length = 12;
1217
1218 p = &xbuf[IDX3];
1219 sg[2].page = virt_to_page(p);
1220 sg[2].offset = ((long) p & ~PAGE_MASK);
1221 sg[2].length = 1;
1222
1223 ret = crypto_cipher_decrypt(tfm, sg, sg, 16);
1224
1225 if (ret) {
1226 printk("decrypt() failed flags=%x\n", tfm->crt_flags);
1227 goto out;
1228 }
1229
1230 printk("page 1\n");
1231 q = kmap(sg[0].page) + sg[0].offset;
1232 hexdump(q, 3);
1233 printk("%s\n", memcmp(q, des_tv[i].result, 3) ? "fail" : "pass");
1234
1235 printk("page 2\n");
1236 q = kmap(sg[1].page) + sg[1].offset;
1237 hexdump(q, 12);
1238 printk("%s\n", memcmp(q, des_tv[i].result + 3, 12) ? "fail" : "pass");
1239
1240 printk("page 3\n");
1241 q = kmap(sg[2].page) + sg[2].offset;
1242 hexdump(q, 1);
1243 printk("%s\n", memcmp(q, des_tv[i].result + 15, 1) ? "fail" : "pass");
1244
1245 crypto_free_tfm(tfm);
1246
1247 tfm = crypto_alloc_tfm("des", CRYPTO_TFM_MODE_CBC);
1248 if (tfm == NULL) {
1249 printk("failed to load transform for des cbc\n");
1250 return;
1251 }
1252
1253 printk("\ntesting des cbc encryption\n");
1254
1255 tsize = sizeof (des_cbc_enc_tv_template);
1256 if (tsize > TVMEMSIZE) {
1257 printk("template (%u) too big for tvmem (%u)\n", tsize,
1258 TVMEMSIZE);
1259 return;
1260 }
1261 memcpy(tvmem, des_cbc_enc_tv_template, tsize);
1262 des_tv = (void *) tvmem;
1263
1264 crypto_cipher_set_iv(tfm, des_tv[i].iv, crypto_tfm_alg_ivsize(tfm));
1265 crypto_cipher_get_iv(tfm, res, crypto_tfm_alg_ivsize(tfm));
1266
1267 if (memcmp(res, des_tv[i].iv, sizeof(res))) {
1268 printk("crypto_cipher_[set|get]_iv() failed\n");
1269 goto out;
1270 }
1271
1272 for (i = 0; i < DES_CBC_ENC_TEST_VECTORS; i++) {
1273 printk("test %u:\n", i + 1);
1274
1275 key = des_tv[i].key;
1276
1277 ret = crypto_cipher_setkey(tfm, key, 8);
1278 if (ret) {
1279 printk("setkey() failed flags=%x\n", tfm->crt_flags);
1280 goto out;
1281 }
1282
1283 len = des_tv[i].len;
1284 p = des_tv[i].plaintext;
1285
1286 sg[0].page = virt_to_page(p);
1287 sg[0].offset = ((long) p & ~PAGE_MASK);
1288 sg[0].length = len;
1289
1290 crypto_cipher_set_iv(tfm, des_tv[i].iv,
1291 crypto_tfm_alg_ivsize(tfm));
1292
1293 ret = crypto_cipher_encrypt(tfm, sg, sg, len);
1294 if (ret) {
1295 printk("des_cbc_encrypt() failed flags=%x\n",
1296 tfm->crt_flags);
1297 goto out;
1298 }
1299
1300 q = kmap(sg[0].page) + sg[0].offset;
1301 hexdump(q, len);
1302
1303 printk("%s\n",
1304 memcmp(q, des_tv[i].result, len) ? "fail" : "pass");
1305 }
1306
1307 crypto_free_tfm(tfm);
1308
1309 /*
1310 * Scenario F:
1311 *
1312 * F1 F2
1313 * [8 + 5] [3 + 8]
1314 *
1315 */
1316 printk("\ntesting des cbc encryption chunking scenario F\n");
1317 i = 4;
1318
1319 tfm = crypto_alloc_tfm("des", CRYPTO_TFM_MODE_CBC);
1320 if (tfm == NULL) {
1321 printk("failed to load transform for CRYPTO_ALG_DES_CCB\n");
1322 return;
1323 }
1324
1325 tfm->crt_flags = 0;
1326 key = des_tv[i].key;
1327
1328 ret = crypto_cipher_setkey(tfm, key, 8);
1329 if (ret) {
1330 printk("setkey() failed flags=%x\n", tfm->crt_flags);
1331 goto out;
1332 }
1333
1334 /* setup the dummy buffer first */
1335 memset(xbuf, 0, sizeof (xbuf));
1336
1337 memcpy(&xbuf[IDX1], des_tv[i].plaintext, 13);
1338 memcpy(&xbuf[IDX2], des_tv[i].plaintext + 13, 11);
1339
1340 p = &xbuf[IDX1];
1341 sg[0].page = virt_to_page(p);
1342 sg[0].offset = ((long) p & ~PAGE_MASK);
1343 sg[0].length = 13;
1344
1345 p = &xbuf[IDX2];
1346 sg[1].page = virt_to_page(p);
1347 sg[1].offset = ((long) p & ~PAGE_MASK);
1348 sg[1].length = 11;
1349
1350 crypto_cipher_set_iv(tfm, des_tv[i].iv, crypto_tfm_alg_ivsize(tfm));
1351
1352 ret = crypto_cipher_encrypt(tfm, sg, sg, 24);
1353 if (ret) {
1354 printk("des_cbc_decrypt() failed flags=%x\n", tfm->crt_flags);
1355 goto out;
1356 }
1357
1358 printk("page 1\n");
1359 q = kmap(sg[0].page) + sg[0].offset;
1360 hexdump(q, 13);
1361 printk("%s\n", memcmp(q, des_tv[i].result, 13) ? "fail" : "pass");
1362
1363 printk("page 2\n");
1364 q = kmap(sg[1].page) + sg[1].offset;
1365 hexdump(q, 11);
1366 printk("%s\n", memcmp(q, des_tv[i].result + 13, 11) ? "fail" : "pass");
1367
1368 tsize = sizeof (des_cbc_dec_tv_template);
1369 if (tsize > TVMEMSIZE) {
1370 printk("template (%u) too big for tvmem (%u)\n", tsize,
1371 TVMEMSIZE);
1372 return;
1373 }
1374 memcpy(tvmem, des_cbc_dec_tv_template, tsize);
1375 des_tv = (void *) tvmem;
1376
1377 printk("\ntesting des cbc decryption\n");
1378
1379 for (i = 0; i < DES_CBC_DEC_TEST_VECTORS; i++) {
1380 printk("test %u:\n", i + 1);
1381
1382 tfm->crt_flags = 0;
1383 key = des_tv[i].key;
1384
1385 ret = crypto_cipher_setkey(tfm, key, 8);
1386 if (ret) {
1387 printk("setkey() failed flags=%x\n", tfm->crt_flags);
1388 goto out;
1389 }
1390
1391 len = des_tv[i].len;
1392 p = des_tv[i].plaintext;
1393
1394 sg[0].page = virt_to_page(p);
1395 sg[0].offset = ((long) p & ~PAGE_MASK);
1396 sg[0].length = len;
1397
1398 crypto_cipher_set_iv(tfm, des_tv[i].iv,
1399 crypto_tfm_alg_blocksize(tfm));
1400
1401 ret = crypto_cipher_decrypt(tfm, sg, sg, len);
1402 if (ret) {
1403 printk("des_cbc_decrypt() failed flags=%x\n",
1404 tfm->crt_flags);
1405 goto out;
1406 }
1407
1408 hexdump(tfm->crt_cipher.cit_iv, 8);
1409
1410 q = kmap(sg[0].page) + sg[0].offset;
1411 hexdump(q, len);
1412
1413 printk("%s\n",
1414 memcmp(q, des_tv[i].result, len) ? "fail" : "pass");
1415 }
1416
1417 /*
1418 * Scenario G:
1419 *
1420 * F1 F2
1421 * [4] [4]
1422 *
1423 */
1424 printk("\ntesting des cbc decryption chunking scenario G\n");
1425 i = 3;
1426
1427 tfm->crt_flags = 0;
1428 key = des_tv[i].key;
1429
1430 ret = crypto_cipher_setkey(tfm, key, 8);
1431 if (ret) {
1432 printk("setkey() failed flags=%x\n", tfm->crt_flags);
1433 goto out;
1434 }
1435
1436 /* setup the dummy buffer first */
1437 memset(xbuf, 0, sizeof (xbuf));
1438 memcpy(&xbuf[IDX1], des_tv[i].plaintext, 4);
1439 memcpy(&xbuf[IDX2], des_tv[i].plaintext + 4, 4);
1440
1441 p = &xbuf[IDX1];
1442 sg[0].page = virt_to_page(p);
1443 sg[0].offset = ((long) p & ~PAGE_MASK);
1444 sg[0].length = 4;
1445
1446 p = &xbuf[IDX2];
1447 sg[1].page = virt_to_page(p);
1448 sg[1].offset = ((long) p & ~PAGE_MASK);
1449 sg[1].length = 4;
1450
1451 crypto_cipher_set_iv(tfm, des_tv[i].iv, crypto_tfm_alg_ivsize(tfm));
1452
1453 ret = crypto_cipher_decrypt(tfm, sg, sg, 8);
1454 if (ret) {
1455 printk("des_cbc_decrypt() failed flags=%x\n", tfm->crt_flags);
1456 goto out;
1457 }
1458
1459 printk("page 1\n");
1460 q = kmap(sg[0].page) + sg[0].offset;
1461 hexdump(q, 4);
1462 printk("%s\n", memcmp(q, des_tv[i].result, 4) ? "fail" : "pass");
1463
1464 printk("page 2\n");
1465 q = kmap(sg[1].page) + sg[1].offset;
1466 hexdump(q, 4);
1467 printk("%s\n", memcmp(q, des_tv[i].result + 4, 4) ? "fail" : "pass");
1468
1469 out:
1470 crypto_free_tfm(tfm);
1471 }
1472
1473 void
1474 test_des3_ede(void)
1475 {
1476 unsigned int ret, i, len;
1477 unsigned int tsize;
1478 char *p, *q;
1479 struct crypto_tfm *tfm;
1480 char *key;
1481 /*char res[8]; */
1482 struct des_tv *des_tv;
1483 struct scatterlist sg[8];
1484
1485 printk("\ntesting des3 ede encryption\n");
1486
1487 tsize = sizeof (des3_ede_enc_tv_template);
1488 if (tsize > TVMEMSIZE) {
1489 printk("template (%u) too big for tvmem (%u)\n", tsize,
1490 TVMEMSIZE);
1491 return;
1492 }
1493
1494 memcpy(tvmem, des3_ede_enc_tv_template, tsize);
1495 des_tv = (void *) tvmem;
1496
1497 tfm = crypto_alloc_tfm("des3_ede", CRYPTO_TFM_MODE_ECB);
1498 if (tfm == NULL) {
1499 printk("failed to load transform for 3des ecb\n");
1500 return;
1501 }
1502
1503 for (i = 0; i < DES3_EDE_ENC_TEST_VECTORS; i++) {
1504 printk("test %u:\n", i + 1);
1505
1506 key = des_tv[i].key;
1507 ret = crypto_cipher_setkey(tfm, key, 24);
1508 if (ret) {
1509 printk("setkey() failed flags=%x\n", tfm->crt_flags);
1510
1511 if (!des_tv[i].fail)
1512 goto out;
1513 }
1514
1515 len = des_tv[i].len;
1516
1517 p = des_tv[i].plaintext;
1518 sg[0].page = virt_to_page(p);
1519 sg[0].offset = ((long) p & ~PAGE_MASK);
1520 sg[0].length = len;
1521 ret = crypto_cipher_encrypt(tfm, sg, sg, len);
1522 if (ret) {
1523 printk("encrypt() failed flags=%x\n", tfm->crt_flags);
1524 goto out;
1525 }
1526
1527 q = kmap(sg[0].page) + sg[0].offset;
1528 hexdump(q, len);
1529
1530 printk("%s\n",
1531 memcmp(q, des_tv[i].result, len) ? "fail" : "pass");
1532 }
1533
1534 printk("\ntesting des3 ede decryption\n");
1535
1536 tsize = sizeof (des3_ede_dec_tv_template);
1537 if (tsize > TVMEMSIZE) {
1538 printk("template (%u) too big for tvmem (%u)\n", tsize,
1539 TVMEMSIZE);
1540 return;
1541 }
1542
1543 memcpy(tvmem, des3_ede_dec_tv_template, tsize);
1544 des_tv = (void *) tvmem;
1545
1546 for (i = 0; i < DES3_EDE_DEC_TEST_VECTORS; i++) {
1547 printk("test %u:\n", i + 1);
1548
1549 key = des_tv[i].key;
1550 ret = crypto_cipher_setkey(tfm, key, 24);
1551 if (ret) {
1552 printk("setkey() failed flags=%x\n", tfm->crt_flags);
1553
1554 if (!des_tv[i].fail)
1555 goto out;
1556 }
1557
1558 len = des_tv[i].len;
1559
1560 p = des_tv[i].plaintext;
1561 sg[0].page = virt_to_page(p);
1562 sg[0].offset = ((long) p & ~PAGE_MASK);
1563 sg[0].length = len;
1564 ret = crypto_cipher_decrypt(tfm, sg, sg, len);
1565 if (ret) {
1566 printk("decrypt() failed flags=%x\n", tfm->crt_flags);
1567 goto out;
1568 }
1569
1570 q = kmap(sg[0].page) + sg[0].offset;
1571 hexdump(q, len);
1572
1573 printk("%s\n",
1574 memcmp(q, des_tv[i].result, len) ? "fail" : "pass");
1575 }
1576
1577 out:
1578 crypto_free_tfm(tfm);
1579 }
1580
1581 void
1582 test_blowfish(void)
1583 {
1584 unsigned int ret, i;
1585 unsigned int tsize;
1586 char *p, *q;
1587 struct crypto_tfm *tfm;
1588 char *key;
1589 struct bf_tv *bf_tv;
1590 struct scatterlist sg[1];
1591
1592 printk("\ntesting blowfish encryption\n");
1593
1594 tsize = sizeof (bf_enc_tv_template);
1595 if (tsize > TVMEMSIZE) {
1596 printk("template (%u) too big for tvmem (%u)\n", tsize,
1597 TVMEMSIZE);
1598 return;
1599 }
1600
1601 memcpy(tvmem, bf_enc_tv_template, tsize);
1602 bf_tv = (void *) tvmem;
1603
1604 tfm = crypto_alloc_tfm("blowfish", 0);
1605 if (tfm == NULL) {
1606 printk("failed to load transform for blowfish (default ecb)\n");
1607 return;
1608 }
1609
1610 for (i = 0; i < BF_ENC_TEST_VECTORS; i++) {
1611 printk("test %u (%d bit key):\n",
1612 i + 1, bf_tv[i].keylen * 8);
1613 key = bf_tv[i].key;
1614
1615 ret = crypto_cipher_setkey(tfm, key, bf_tv[i].keylen);
1616 if (ret) {
1617 printk("setkey() failed flags=%x\n", tfm->crt_flags);
1618
1619 if (!bf_tv[i].fail)
1620 goto out;
1621 }
1622
1623 p = bf_tv[i].plaintext;
1624 sg[0].page = virt_to_page(p);
1625 sg[0].offset = ((long) p & ~PAGE_MASK);
1626 sg[0].length = bf_tv[i].plen;
1627 ret = crypto_cipher_encrypt(tfm, sg, sg, sg[0].length);
1628 if (ret) {
1629 printk("encrypt() failed flags=%x\n", tfm->crt_flags);
1630 goto out;
1631 }
1632
1633 q = kmap(sg[0].page) + sg[0].offset;
1634 hexdump(q, bf_tv[i].rlen);
1635
1636 printk("%s\n", memcmp(q, bf_tv[i].result, bf_tv[i].rlen) ?
1637 "fail" : "pass");
1638 }
1639
1640 printk("\ntesting blowfish decryption\n");
1641
1642 tsize = sizeof (bf_dec_tv_template);
1643 if (tsize > TVMEMSIZE) {
1644 printk("template (%u) too big for tvmem (%u)\n", tsize,
1645 TVMEMSIZE);
1646 return;
1647 }
1648
1649 memcpy(tvmem, bf_dec_tv_template, tsize);
1650 bf_tv = (void *) tvmem;
1651
1652 for (i = 0; i < BF_DEC_TEST_VECTORS; i++) {
1653 printk("test %u (%d bit key):\n",
1654 i + 1, bf_tv[i].keylen * 8);
1655 key = bf_tv[i].key;
1656
1657 ret = crypto_cipher_setkey(tfm, key, bf_tv[i].keylen);
1658 if (ret) {
1659 printk("setkey() failed flags=%x\n", tfm->crt_flags);
1660
1661 if (!bf_tv[i].fail)
1662 goto out;
1663 }
1664
1665 p = bf_tv[i].plaintext;
1666 sg[0].page = virt_to_page(p);
1667 sg[0].offset = ((long) p & ~PAGE_MASK);
1668 sg[0].length = bf_tv[i].plen;
1669 ret = crypto_cipher_decrypt(tfm, sg, sg, sg[0].length);
1670 if (ret) {
1671 printk("decrypt() failed flags=%x\n", tfm->crt_flags);
1672 goto out;
1673 }
1674
1675 q = kmap(sg[0].page) + sg[0].offset;
1676 hexdump(q, bf_tv[i].rlen);
1677
1678 printk("%s\n", memcmp(q, bf_tv[i].result, bf_tv[i].rlen) ?
1679 "fail" : "pass");
1680 }
1681
1682 crypto_free_tfm(tfm);
1683
1684 tfm = crypto_alloc_tfm("blowfish", CRYPTO_TFM_MODE_CBC);
1685 if (tfm == NULL) {
1686 printk("failed to load transform for blowfish cbc\n");
1687 return;
1688 }
1689
1690 printk("\ntesting blowfish cbc encryption\n");
1691
1692 tsize = sizeof (bf_cbc_enc_tv_template);
1693 if (tsize > TVMEMSIZE) {
1694 printk("template (%u) too big for tvmem (%u)\n", tsize,
1695 TVMEMSIZE);
1696 goto out;
1697 }
1698 memcpy(tvmem, bf_cbc_enc_tv_template, tsize);
1699 bf_tv = (void *) tvmem;
1700
1701 for (i = 0; i < BF_CBC_ENC_TEST_VECTORS; i++) {
1702 printk("test %u (%d bit key):\n",
1703 i + 1, bf_tv[i].keylen * 8);
1704
1705 key = bf_tv[i].key;
1706
1707 ret = crypto_cipher_setkey(tfm, key, bf_tv[i].keylen);
1708 if (ret) {
1709 printk("setkey() failed flags=%x\n", tfm->crt_flags);
1710 goto out;
1711 }
1712
1713 p = bf_tv[i].plaintext;
1714
1715 sg[0].page = virt_to_page(p);
1716 sg[0].offset = ((long) p & ~PAGE_MASK);
1717 sg[0].length = bf_tv[i].plen;
1718
1719 crypto_cipher_set_iv(tfm, bf_tv[i].iv,
1720 crypto_tfm_alg_ivsize(tfm));
1721
1722 ret = crypto_cipher_encrypt(tfm, sg, sg, sg[0].length);
1723 if (ret) {
1724 printk("blowfish_cbc_encrypt() failed flags=%x\n",
1725 tfm->crt_flags);
1726 goto out;
1727 }
1728
1729 q = kmap(sg[0].page) + sg[0].offset;
1730 hexdump(q, bf_tv[i].rlen);
1731
1732 printk("%s\n", memcmp(q, bf_tv[i].result, bf_tv[i].rlen)
1733 ? "fail" : "pass");
1734 }
1735
1736 printk("\ntesting blowfish cbc decryption\n");
1737
1738 tsize = sizeof (bf_cbc_dec_tv_template);
1739 if (tsize > TVMEMSIZE) {
1740 printk("template (%u) too big for tvmem (%u)\n", tsize,
1741 TVMEMSIZE);
1742 goto out;
1743 }
1744 memcpy(tvmem, bf_cbc_dec_tv_template, tsize);
1745 bf_tv = (void *) tvmem;
1746
1747 for (i = 0; i < BF_CBC_ENC_TEST_VECTORS; i++) {
1748 printk("test %u (%d bit key):\n",
1749 i + 1, bf_tv[i].keylen * 8);
1750 key = bf_tv[i].key;
1751
1752 ret = crypto_cipher_setkey(tfm, key, bf_tv[i].keylen);
1753 if (ret) {
1754 printk("setkey() failed flags=%x\n", tfm->crt_flags);
1755 goto out;
1756 }
1757
1758 p = bf_tv[i].plaintext;
1759
1760 sg[0].page = virt_to_page(p);
1761 sg[0].offset = ((long) p & ~PAGE_MASK);
1762 sg[0].length = bf_tv[i].plen;
1763
1764 crypto_cipher_set_iv(tfm, bf_tv[i].iv,
1765 crypto_tfm_alg_ivsize(tfm));
1766
1767 ret = crypto_cipher_decrypt(tfm, sg, sg, sg[0].length);
1768 if (ret) {
1769 printk("blowfish_cbc_decrypt() failed flags=%x\n",
1770 tfm->crt_flags);
1771 goto out;
1772 }
1773
1774 q = kmap(sg[0].page) + sg[0].offset;
1775 hexdump(q, bf_tv[i].rlen);
1776
1777 printk("%s\n", memcmp(q, bf_tv[i].result, bf_tv[i].rlen)
1778 ? "fail" : "pass");
1779 }
1780
1781 out:
1782 crypto_free_tfm(tfm);
1783 }
1784
1785
1786 void
1787 test_twofish(void)
1788 {
1789 unsigned int ret, i;
1790 unsigned int tsize;
1791 char *p, *q;
1792 struct crypto_tfm *tfm;
1793 char *key;
1794 struct tf_tv *tf_tv;
1795 struct scatterlist sg[1];
1796
1797 printk("\ntesting twofish encryption\n");
1798
1799 tsize = sizeof (tf_enc_tv_template);
1800 if (tsize > TVMEMSIZE) {
1801 printk("template (%u) too big for tvmem (%u)\n", tsize,
1802 TVMEMSIZE);
1803 return;
1804 }
1805
1806 memcpy(tvmem, tf_enc_tv_template, tsize);
1807 tf_tv = (void *) tvmem;
1808
1809 tfm = crypto_alloc_tfm("twofish", 0);
1810 if (tfm == NULL) {
1811 printk("failed to load transform for blowfish (default ecb)\n");
1812 return;
1813 }
1814
1815 for (i = 0; i < TF_ENC_TEST_VECTORS; i++) {
1816 printk("test %u (%d bit key):\n",
1817 i + 1, tf_tv[i].keylen * 8);
1818 key = tf_tv[i].key;
1819
1820 ret = crypto_cipher_setkey(tfm, key, tf_tv[i].keylen);
1821 if (ret) {
1822 printk("setkey() failed flags=%x\n", tfm->crt_flags);
1823
1824 if (!tf_tv[i].fail)
1825 goto out;
1826 }
1827
1828 p = tf_tv[i].plaintext;
1829 sg[0].page = virt_to_page(p);
1830 sg[0].offset = ((long) p & ~PAGE_MASK);
1831 sg[0].length = tf_tv[i].plen;
1832 ret = crypto_cipher_encrypt(tfm, sg, sg, sg[0].length);
1833 if (ret) {
1834 printk("encrypt() failed flags=%x\n", tfm->crt_flags);
1835 goto out;
1836 }
1837
1838 q = kmap(sg[0].page) + sg[0].offset;
1839 hexdump(q, tf_tv[i].rlen);
1840
1841 printk("%s\n", memcmp(q, tf_tv[i].result, tf_tv[i].rlen) ?
1842 "fail" : "pass");
1843 }
1844
1845 printk("\ntesting twofish decryption\n");
1846
1847 tsize = sizeof (tf_dec_tv_template);
1848 if (tsize > TVMEMSIZE) {
1849 printk("template (%u) too big for tvmem (%u)\n", tsize,
1850 TVMEMSIZE);
1851 return;
1852 }
1853
1854 memcpy(tvmem, tf_dec_tv_template, tsize);
1855 tf_tv = (void *) tvmem;
1856
1857 for (i = 0; i < TF_DEC_TEST_VECTORS; i++) {
1858 printk("test %u (%d bit key):\n",
1859 i + 1, tf_tv[i].keylen * 8);
1860 key = tf_tv[i].key;
1861
1862 ret = crypto_cipher_setkey(tfm, key, tf_tv[i].keylen);
1863 if (ret) {
1864 printk("setkey() failed flags=%x\n", tfm->crt_flags);
1865
1866 if (!tf_tv[i].fail)
1867 goto out;
1868 }
1869
1870 p = tf_tv[i].plaintext;
1871 sg[0].page = virt_to_page(p);
1872 sg[0].offset = ((long) p & ~PAGE_MASK);
1873 sg[0].length = tf_tv[i].plen;
1874 ret = crypto_cipher_decrypt(tfm, sg, sg, sg[0].length);
1875 if (ret) {
1876 printk("decrypt() failed flags=%x\n", tfm->crt_flags);
1877 goto out;
1878 }
1879
1880 q = kmap(sg[0].page) + sg[0].offset;
1881 hexdump(q, tf_tv[i].rlen);
1882
1883 printk("%s\n", memcmp(q, tf_tv[i].result, tf_tv[i].rlen) ?
1884 "fail" : "pass");
1885 }
1886
1887 crypto_free_tfm(tfm);
1888
1889 tfm = crypto_alloc_tfm("twofish", CRYPTO_TFM_MODE_CBC);
1890 if (tfm == NULL) {
1891 printk("failed to load transform for twofish cbc\n");
1892 return;
1893 }
1894
1895 printk("\ntesting twofish cbc encryption\n");
1896
1897 tsize = sizeof (tf_cbc_enc_tv_template);
1898 if (tsize > TVMEMSIZE) {
1899 printk("template (%u) too big for tvmem (%u)\n", tsize,
1900 TVMEMSIZE);
1901 goto out;
1902 }
1903 memcpy(tvmem, tf_cbc_enc_tv_template, tsize);
1904 tf_tv = (void *) tvmem;
1905
1906 for (i = 0; i < TF_CBC_ENC_TEST_VECTORS; i++) {
1907 printk("test %u (%d bit key):\n",
1908 i + 1, tf_tv[i].keylen * 8);
1909
1910 key = tf_tv[i].key;
1911
1912 ret = crypto_cipher_setkey(tfm, key, tf_tv[i].keylen);
1913 if (ret) {
1914 printk("setkey() failed flags=%x\n", tfm->crt_flags);
1915 goto out;
1916 }
1917
1918 p = tf_tv[i].plaintext;
1919
1920 sg[0].page = virt_to_page(p);
1921 sg[0].offset = ((long) p & ~PAGE_MASK);
1922 sg[0].length = tf_tv[i].plen;
1923
1924 crypto_cipher_set_iv(tfm, tf_tv[i].iv,
1925 crypto_tfm_alg_ivsize(tfm));
1926
1927 ret = crypto_cipher_encrypt(tfm, sg, sg, sg[0].length);
1928 if (ret) {
1929 printk("blowfish_cbc_encrypt() failed flags=%x\n",
1930 tfm->crt_flags);
1931 goto out;
1932 }
1933
1934 q = kmap(sg[0].page) + sg[0].offset;
1935 hexdump(q, tf_tv[i].rlen);
1936
1937 printk("%s\n", memcmp(q, tf_tv[i].result, tf_tv[i].rlen)
1938 ? "fail" : "pass");
1939 }
1940
1941 printk("\ntesting twofish cbc decryption\n");
1942
1943 tsize = sizeof (tf_cbc_dec_tv_template);
1944 if (tsize > TVMEMSIZE) {
1945 printk("template (%u) too big for tvmem (%u)\n", tsize,
1946 TVMEMSIZE);
1947 goto out;
1948 }
1949 memcpy(tvmem, tf_cbc_dec_tv_template, tsize);
1950 tf_tv = (void *) tvmem;
1951
1952 for (i = 0; i < TF_CBC_DEC_TEST_VECTORS; i++) {
1953 printk("test %u (%d bit key):\n",
1954 i + 1, tf_tv[i].keylen * 8);
1955
1956 key = tf_tv[i].key;
1957
1958 ret = crypto_cipher_setkey(tfm, key, tf_tv[i].keylen);
1959 if (ret) {
1960 printk("setkey() failed flags=%x\n", tfm->crt_flags);
1961 goto out;
1962 }
1963
1964 p = tf_tv[i].plaintext;
1965
1966 sg[0].page = virt_to_page(p);
1967 sg[0].offset = ((long) p & ~PAGE_MASK);
1968 sg[0].length = tf_tv[i].plen;
1969
1970 crypto_cipher_set_iv(tfm, tf_tv[i].iv,
1971 crypto_tfm_alg_ivsize(tfm));
1972
1973 ret = crypto_cipher_decrypt(tfm, sg, sg, sg[0].length);
1974 if (ret) {
1975 printk("blowfish_cbc_decrypt() failed flags=%x\n",
1976 tfm->crt_flags);
1977 goto out;
1978 }
1979
1980 q = kmap(sg[0].page) + sg[0].offset;
1981 hexdump(q, tf_tv[i].rlen);
1982
1983 printk("%s\n", memcmp(q, tf_tv[i].result, tf_tv[i].rlen)
1984 ? "fail" : "pass");
1985 }
1986
1987 out:
1988 crypto_free_tfm(tfm);
1989 }
1990
1991 void
1992 test_serpent(void)
1993 {
1994 unsigned int ret, i, tsize;
1995 u8 *p, *q, *key;
1996 struct crypto_tfm *tfm;
1997 struct serpent_tv *serp_tv;
1998 struct scatterlist sg[1];
1999
2000 printk("\ntesting serpent encryption\n");
2001
2002 tfm = crypto_alloc_tfm("serpent", 0);
2003 if (tfm == NULL) {
2004 printk("failed to load transform for serpent (default ecb)\n");
2005 return;
2006 }
2007
2008 tsize = sizeof (serpent_enc_tv_template);
2009 if (tsize > TVMEMSIZE) {
2010 printk("template (%u) too big for tvmem (%u)\n", tsize,
2011 TVMEMSIZE);
2012 return;
2013 }
2014
2015 memcpy(tvmem, serpent_enc_tv_template, tsize);
2016 serp_tv = (void *) tvmem;
2017 for (i = 0; i < SERPENT_ENC_TEST_VECTORS; i++) {
2018 printk("test %u (%d bit key):\n", i + 1, serp_tv[i].keylen * 8);
2019 key = serp_tv[i].key;
2020
2021 ret = crypto_cipher_setkey(tfm, key, serp_tv[i].keylen);
2022 if (ret) {
2023 printk("setkey() failed flags=%x\n", tfm->crt_flags);
2024
2025 if (!serp_tv[i].fail)
2026 goto out;
2027 }
2028
2029 p = serp_tv[i].plaintext;
2030 sg[0].page = virt_to_page(p);
2031 sg[0].offset = ((long) p & ~PAGE_MASK);
2032 sg[0].length = sizeof(serp_tv[i].plaintext);
2033 ret = crypto_cipher_encrypt(tfm, sg, sg, sg[0].length);
2034 if (ret) {
2035 printk("encrypt() failed flags=%x\n", tfm->crt_flags);
2036 goto out;
2037 }
2038
2039 q = kmap(sg[0].page) + sg[0].offset;
2040 hexdump(q, sizeof(serp_tv[i].result));
2041
2042 printk("%s\n", memcmp(q, serp_tv[i].result,
2043 sizeof(serp_tv[i].result)) ? "fail" : "pass");
2044 }
2045
2046 printk("\ntesting serpent decryption\n");
2047
2048 tsize = sizeof (serpent_dec_tv_template);
2049 if (tsize > TVMEMSIZE) {
2050 printk("template (%u) too big for tvmem (%u)\n", tsize,
2051 TVMEMSIZE);
2052 return;
2053 }
2054
2055 memcpy(tvmem, serpent_dec_tv_template, tsize);
2056 serp_tv = (void *) tvmem;
2057 for (i = 0; i < SERPENT_DEC_TEST_VECTORS; i++) {
2058 printk("test %u (%d bit key):\n", i + 1, serp_tv[i].keylen * 8);
2059 key = serp_tv[i].key;
2060
2061 ret = crypto_cipher_setkey(tfm, key, serp_tv[i].keylen);
2062 if (ret) {
2063 printk("setkey() failed flags=%x\n", tfm->crt_flags);
2064
2065 if (!serp_tv[i].fail)
2066 goto out;
2067 }
2068
2069 p = serp_tv[i].plaintext;
2070 sg[0].page = virt_to_page(p);
2071 sg[0].offset = ((long) p & ~PAGE_MASK);
2072 sg[0].length = sizeof(serp_tv[i].plaintext);
2073 ret = crypto_cipher_decrypt(tfm, sg, sg, sg[0].length);
2074 if (ret) {
2075 printk("decrypt() failed flags=%x\n", tfm->crt_flags);
2076 goto out;
2077 }
2078
2079 q = kmap(sg[0].page) + sg[0].offset;
2080 hexdump(q, sizeof(serp_tv[i].result));
2081
2082 printk("%s\n", memcmp(q, serp_tv[i].result,
2083 sizeof(serp_tv[i].result)) ? "fail" : "pass");
2084 }
2085
2086 out:
2087 crypto_free_tfm(tfm);
2088 }
2089
2090 void
2091 test_aes(void)
2092 {
2093 unsigned int ret, i;
2094 unsigned int tsize;
2095 char *p, *q;
2096 struct crypto_tfm *tfm;
2097 char *key;
2098 struct aes_tv *aes_tv;
2099 struct scatterlist sg[1];
2100
2101 printk("\ntesting aes encryption\n");
2102
2103 tsize = sizeof (aes_enc_tv_template);
2104 if (tsize > TVMEMSIZE) {
2105 printk("template (%u) too big for tvmem (%u)\n", tsize,
2106 TVMEMSIZE);
2107 return;
2108 }
2109
2110 memcpy(tvmem, aes_enc_tv_template, tsize);
2111 aes_tv = (void *) tvmem;
2112
2113 tfm = crypto_alloc_tfm("aes", 0);
2114 if (tfm == NULL) {
2115 printk("failed to load transform for aes (default ecb)\n");
2116 return;
2117 }
2118
2119 for (i = 0; i < AES_ENC_TEST_VECTORS; i++) {
2120 printk("test %u (%d bit key):\n",
2121 i + 1, aes_tv[i].keylen * 8);
2122 key = aes_tv[i].key;
2123
2124 ret = crypto_cipher_setkey(tfm, key, aes_tv[i].keylen);
2125 if (ret) {
2126 printk("setkey() failed flags=%x\n", tfm->crt_flags);
2127
2128 if (!aes_tv[i].fail)
2129 goto out;
2130 }
2131
2132 p = aes_tv[i].plaintext;
2133 sg[0].page = virt_to_page(p);
2134 sg[0].offset = ((long) p & ~PAGE_MASK);
2135 sg[0].length = aes_tv[i].plen;
2136 ret = crypto_cipher_encrypt(tfm, sg, sg, sg[0].length);
2137 if (ret) {
2138 printk("encrypt() failed flags=%x\n", tfm->crt_flags);
2139 goto out;
2140 }
2141
2142 q = kmap(sg[0].page) + sg[0].offset;
2143 hexdump(q, aes_tv[i].rlen);
2144
2145 printk("%s\n", memcmp(q, aes_tv[i].result, aes_tv[i].rlen) ?
2146 "fail" : "pass");
2147 }
2148
2149 printk("\ntesting aes decryption\n");
2150
2151 tsize = sizeof (aes_dec_tv_template);
2152 if (tsize > TVMEMSIZE) {
2153 printk("template (%u) too big for tvmem (%u)\n", tsize,
2154 TVMEMSIZE);
2155 return;
2156 }
2157
2158 memcpy(tvmem, aes_dec_tv_template, tsize);
2159 aes_tv = (void *) tvmem;
2160
2161 for (i = 0; i < AES_DEC_TEST_VECTORS; i++) {
2162 printk("test %u (%d bit key):\n",
2163 i + 1, aes_tv[i].keylen * 8);
2164 key = aes_tv[i].key;
2165
2166 ret = crypto_cipher_setkey(tfm, key, aes_tv[i].keylen);
2167 if (ret) {
2168 printk("setkey() failed flags=%x\n", tfm->crt_flags);
2169
2170 if (!aes_tv[i].fail)
2171 goto out;
2172 }
2173
2174 p = aes_tv[i].plaintext;
2175 sg[0].page = virt_to_page(p);
2176 sg[0].offset = ((long) p & ~PAGE_MASK);
2177 sg[0].length = aes_tv[i].plen;
2178 ret = crypto_cipher_decrypt(tfm, sg, sg, sg[0].length);
2179 if (ret) {
2180 printk("decrypt() failed flags=%x\n", tfm->crt_flags);
2181 goto out;
2182 }
2183
2184 q = kmap(sg[0].page) + sg[0].offset;
2185 hexdump(q, aes_tv[i].rlen);
2186
2187 printk("%s\n", memcmp(q, aes_tv[i].result, aes_tv[i].rlen) ?
2188 "fail" : "pass");
2189 }
2190
2191 out:
2192 crypto_free_tfm(tfm);
2193 }
2194
2195 static void
2196 test_deflate(void)
2197 {
2198 unsigned int i;
2199 char result[COMP_BUF_SIZE];
2200 struct crypto_tfm *tfm;
2201 struct comp_testvec *tv;
2202 unsigned int tsize;
2203
2204 printk("\ntesting deflate compression\n");
2205
2206 tsize = sizeof (deflate_comp_tv_template);
2207 if (tsize > TVMEMSIZE) {
2208 printk("template (%u) too big for tvmem (%u)\n", tsize,
2209 TVMEMSIZE);
2210 return;
2211 }
2212
2213 memcpy(tvmem, deflate_comp_tv_template, tsize);
2214 tv = (void *) tvmem;
2215
2216 tfm = crypto_alloc_tfm("deflate", 0);
2217 if (tfm == NULL) {
2218 printk("failed to load transform for deflate\n");
2219 return;
2220 }
2221
2222 for (i = 0; i < DEFLATE_COMP_TEST_VECTORS; i++) {
2223 int ilen, ret, dlen = COMP_BUF_SIZE;
2224
2225 printk("test %u:\n", i + 1);
2226 memset(result, 0, sizeof (result));
2227
2228 ilen = tv[i].inlen;
2229 ret = crypto_comp_compress(tfm, tv[i].input,
2230 ilen, result, &dlen);
2231 if (ret) {
2232 printk("fail: ret=%d\n", ret);
2233 continue;
2234 }
2235 hexdump(result, dlen);
2236 printk("%s (ratio %d:%d)\n",
2237 memcmp(result, tv[i].output, dlen) ? "fail" : "pass",
2238 ilen, dlen);
2239 }
2240
2241 printk("\ntesting deflate decompression\n");
2242
2243 tsize = sizeof (deflate_decomp_tv_template);
2244 if (tsize > TVMEMSIZE) {
2245 printk("template (%u) too big for tvmem (%u)\n", tsize,
2246 TVMEMSIZE);
2247 goto out;
2248 }
2249
2250 memcpy(tvmem, deflate_decomp_tv_template, tsize);
2251 tv = (void *) tvmem;
2252
2253 for (i = 0; i < DEFLATE_DECOMP_TEST_VECTORS; i++) {
2254 int ilen, ret, dlen = COMP_BUF_SIZE;
2255
2256 printk("test %u:\n", i + 1);
2257 memset(result, 0, sizeof (result));
2258
2259 ilen = tv[i].inlen;
2260 ret = crypto_comp_decompress(tfm, tv[i].input,
2261 ilen, result, &dlen);
2262 if (ret) {
2263 printk("fail: ret=%d\n", ret);
2264 continue;
2265 }
2266 hexdump(result, dlen);
2267 printk("%s (ratio %d:%d)\n",
2268 memcmp(result, tv[i].output, dlen) ? "fail" : "pass",
2269 ilen, dlen);
2270 }
2271 out:
2272 crypto_free_tfm(tfm);
2273 }
2274
2275 static void
2276 test_available(void)
2277 {
2278 char **name = check;
2279
2280 while (*name) {
2281 printk("alg %s ", *name);
2282 printk((crypto_alg_available(*name, 0)) ?
2283 "found\n" : "not found\n");
2284 name++;
2285 }
2286 }
2287
2288 static void
2289 do_test(void)
2290 {
2291 switch (mode) {
2292
2293 case 0:
2294 test_md5();
2295 test_sha1();
2296 test_des();
2297 test_des3_ede();
2298 test_md4();
2299 test_sha256();
2300 test_blowfish();
2301 test_twofish();
2302 test_serpent();
2303 test_aes();
2304 test_sha384();
2305 test_sha512();
2306 test_deflate();
2307 #ifdef CONFIG_CRYPTO_HMAC
2308 test_hmac_md5();
2309 test_hmac_sha1();
2310 test_hmac_sha256();
2311 #endif
2312 break;
2313
2314 case 1:
2315 test_md5();
2316 break;
2317
2318 case 2:
2319 test_sha1();
2320 break;
2321
2322 case 3:
2323 test_des();
2324 break;
2325
2326 case 4:
2327 test_des3_ede();
2328 break;
2329
2330 case 5:
2331 test_md4();
2332 break;
2333
2334 case 6:
2335 test_sha256();
2336 break;
2337
2338 case 7:
2339 test_blowfish();
2340 break;
2341
2342 case 8:
2343 test_twofish();
2344 break;
2345
2346 case 9:
2347 test_serpent();
2348 break;
2349
2350 case 10:
2351 test_aes();
2352 break;
2353
2354 case 11:
2355 test_sha384();
2356 break;
2357
2358 case 12:
2359 test_sha512();
2360 break;
2361
2362 case 13:
2363 test_deflate();
2364 break;
2365
2366 #ifdef CONFIG_CRYPTO_HMAC
2367 case 100:
2368 test_hmac_md5();
2369 break;
2370
2371 case 101:
2372 test_hmac_sha1();
2373 break;
2374
2375 case 102:
2376 test_hmac_sha256();
2377 break;
2378
2379 #endif
2380
2381 case 1000:
2382 test_available();
2383 break;
2384
2385 default:
2386 /* useful for debugging */
2387 printk("not testing anything\n");
2388 break;
2389 }
2390 }
2391
2392 static int __init
2393 init(void)
2394 {
2395 tvmem = kmalloc(TVMEMSIZE, GFP_KERNEL);
2396 if (tvmem == NULL)
2397 return -ENOMEM;
2398
2399 xbuf = kmalloc(XBUFSIZE, GFP_KERNEL);
2400 if (xbuf == NULL) {
2401 kfree(tvmem);
2402 return -ENOMEM;
2403 }
2404
2405 do_test();
2406
2407 kfree(xbuf);
2408 kfree(tvmem);
2409 return 0;
2410 }
2411
2412 module_init(init);
2413
2414 MODULE_PARM(mode, "i");
2415
2416 MODULE_LICENSE("GPL");
2417 MODULE_DESCRIPTION("Quick & dirty crypto testing module");
2418 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");
Mirror of the linux-mips.org kernel tree