projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[CRYPTO] digest: Store temporary digest in tfm
[deliverable/linux.git] / crypto / tcrypt.c
CommitLineData
ef2736fc 1/*
1da177e4
LT		 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
ef2736fc 12 * Software Foundation; either version 2 of the License, or (at your option)
1da177e4
LT		 13 * any later version.
14 *
ebfd9bcf
HW		 15 * 2004-08-09 Added cipher speed tests (Reyk Floeter <reyk@vantronix.net>)
16 * 2003-09-14 Rewritten by Kartikey Mahendra Bhatt
17 *
1da177e4
LT		 18 */
19
20#include <linux/init.h>
21#include <linux/module.h>
22#include <linux/mm.h>
23#include <linux/slab.h>
378f058c 24#include <linux/scatterlist.h>
1da177e4
LT		 25#include <linux/string.h>
26#include <linux/crypto.h>
27#include <linux/highmem.h>
28#include <linux/moduleparam.h>
ebfd9bcf 29#include <linux/jiffies.h>
6a17944c
HX		 30#include <linux/timex.h>
31#include <linux/interrupt.h>
1da177e4
LT		 32#include "tcrypt.h"
33
34/*
35 * Need to kmalloc() memory for testing kmap().
36 */
ebfd9bcf 37#define TVMEMSIZE 16384
1da177e4
LT		 38#define XBUFSIZE 32768
39
40/*
41 * Indexes into the xbuf to simulate cross-page access.
42 */
43#define IDX1 37
44#define IDX2 32400
45#define IDX3 1
46#define IDX4 8193
47#define IDX5 22222
48#define IDX6 17101
49#define IDX7 27333
50#define IDX8 3000
51
52/*
53* Used by test_cipher()
54*/
55#define ENCRYPT 1
56#define DECRYPT 0
57#define MODE_ECB 1
58#define MODE_CBC 0
59
60static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
61
ebfd9bcf
HW		 62/*
63 * Used by test_cipher_speed()
64 */
6a17944c 65static unsigned int sec;
ebfd9bcf 66
1da177e4
LT		 67static int mode;
68static char *xbuf;
69static char *tvmem;
70
71static char *check[] = {
72 "des", "md5", "des3_ede", "rot13", "sha1", "sha256", "blowfish",
ef2736fc
HX		 73 "twofish", "serpent", "sha384", "sha512", "md4", "aes", "cast6",
74 "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
fb4f10ed 75 "khazad", "wp512", "wp384", "wp256", "tnepres", "xeta", NULL
1da177e4
LT		 76};
77
ef2736fc 78static void hexdump(unsigned char *buf, unsigned int len)
1da177e4
LT		 79{
80 while (len--)
81 printk("%02x", *buf++);
82
83 printk("\n");
84}
85
ef2736fc
HX		 86static void test_hash(char *algo, struct hash_testvec *template,
87 unsigned int tcount)
1da177e4 88{
ef2736fc
HX		 89 unsigned int i, j, k, temp;
90 struct scatterlist sg[8];
91 char result[64];
92 struct crypto_tfm *tfm;
93 struct hash_testvec *hash_tv;
94 unsigned int tsize;
95
96 printk("\ntesting %s\n", algo);
97
98 tsize = sizeof(struct hash_testvec);
1da177e4 99 tsize *= tcount;
ef2736fc 100
1da177e4
LT		 101 if (tsize > TVMEMSIZE) {
102 printk("template (%u) too big for tvmem (%u)\n", tsize, TVMEMSIZE);
103 return;
104 }
105
106 memcpy(tvmem, template, tsize);
ef2736fc 107 hash_tv = (void *)tvmem;
1da177e4
LT		 108 tfm = crypto_alloc_tfm(algo, 0);
109 if (tfm == NULL) {
110 printk("failed to load transform for %s\n", algo);
111 return;
112 }
113
114 for (i = 0; i < tcount; i++) {
ef2736fc
HX		 115 printk("test %u:\n", i + 1);
116 memset(result, 0, 64);
1da177e4 117
378f058c 118 sg_set_buf(&sg[0], hash_tv[i].plaintext, hash_tv[i].psize);
1da177e4 119
ef2736fc 120 crypto_digest_init(tfm);
560c06ae 121 crypto_digest_setkey(tfm, hash_tv[i].key, hash_tv[i].ksize);
ef2736fc
HX		 122 crypto_digest_update(tfm, sg, 1);
123 crypto_digest_final(tfm, result);
1da177e4 124
ef2736fc 125 hexdump(result, crypto_tfm_alg_digestsize(tfm));
1da177e4 126 printk("%s\n",
ef2736fc
HX		 127 memcmp(result, hash_tv[i].digest,
128 crypto_tfm_alg_digestsize(tfm)) ?
129 "fail" : "pass");
1da177e4
LT		 130 }
131
ef2736fc 132 printk("testing %s across pages\n", algo);
1da177e4
LT		 133
134 /* setup the dummy buffer first */
ef2736fc 135 memset(xbuf, 0, XBUFSIZE);
1da177e4
LT		 136
137 j = 0;
138 for (i = 0; i < tcount; i++) {
139 if (hash_tv[i].np) {
140 j++;
ef2736fc
HX		 141 printk("test %u:\n", j);
142 memset(result, 0, 64);
1da177e4
LT		 143
144 temp = 0;
145 for (k = 0; k < hash_tv[i].np; k++) {
ef2736fc
HX		 146 memcpy(&xbuf[IDX[k]],
147 hash_tv[i].plaintext + temp,
148 hash_tv[i].tap[k]);
1da177e4 149 temp += hash_tv[i].tap[k];
378f058c
DH		 150 sg_set_buf(&sg[k], &xbuf[IDX[k]],
151 hash_tv[i].tap[k]);
1da177e4
LT		 152 }
153
ef2736fc
HX		 154 crypto_digest_digest(tfm, sg, hash_tv[i].np, result);
155
156 hexdump(result, crypto_tfm_alg_digestsize(tfm));
1da177e4 157 printk("%s\n",
ef2736fc
HX		 158 memcmp(result, hash_tv[i].digest,
159 crypto_tfm_alg_digestsize(tfm)) ?
160 "fail" : "pass");
1da177e4
LT		 161 }
162 }
ef2736fc
HX		 163
164 crypto_free_tfm(tfm);
1da177e4
LT		 165}
166
167
168#ifdef CONFIG_CRYPTO_HMAC
169
ef2736fc
HX		 170static void test_hmac(char *algo, struct hmac_testvec *template,
171 unsigned int tcount)
1da177e4 172{
1da177e4
LT		 173 unsigned int i, j, k, temp;
174 struct scatterlist sg[8];
175 char result[64];
176 struct crypto_tfm *tfm;
177 struct hmac_testvec *hmac_tv;
178 unsigned int tsize, klen;
179
180 tfm = crypto_alloc_tfm(algo, 0);
181 if (tfm == NULL) {
182 printk("failed to load transform for %s\n", algo);
183 return;
184 }
185
186 printk("\ntesting hmac_%s\n", algo);
ef2736fc
HX		 187
188 tsize = sizeof(struct hmac_testvec);
1da177e4
LT		 189 tsize *= tcount;
190 if (tsize > TVMEMSIZE) {
191 printk("template (%u) too big for tvmem (%u)\n", tsize,
192 TVMEMSIZE);
193 goto out;
194 }
195
196 memcpy(tvmem, template, tsize);
ef2736fc 197 hmac_tv = (void *)tvmem;
1da177e4
LT		 198
199 for (i = 0; i < tcount; i++) {
200 printk("test %u:\n", i + 1);
201 memset(result, 0, sizeof (result));
202
1da177e4 203 klen = hmac_tv[i].ksize;
378f058c 204 sg_set_buf(&sg[0], hmac_tv[i].plaintext, hmac_tv[i].psize);
1da177e4
LT		 205
206 crypto_hmac(tfm, hmac_tv[i].key, &klen, sg, 1, result);
207
208 hexdump(result, crypto_tfm_alg_digestsize(tfm));
209 printk("%s\n",
210 memcmp(result, hmac_tv[i].digest,
211 crypto_tfm_alg_digestsize(tfm)) ? "fail" :
212 "pass");
213 }
214
215 printk("\ntesting hmac_%s across pages\n", algo);
216
217 memset(xbuf, 0, XBUFSIZE);
ef2736fc 218
1da177e4
LT		 219 j = 0;
220 for (i = 0; i < tcount; i++) {
221 if (hmac_tv[i].np) {
222 j++;
ef2736fc
HX		 223 printk("test %u:\n",j);
224 memset(result, 0, 64);
1da177e4
LT		 225
226 temp = 0;
227 klen = hmac_tv[i].ksize;
228 for (k = 0; k < hmac_tv[i].np; k++) {
ef2736fc
HX		 229 memcpy(&xbuf[IDX[k]],
230 hmac_tv[i].plaintext + temp,
231 hmac_tv[i].tap[k]);
1da177e4 232 temp += hmac_tv[i].tap[k];
378f058c
DH		 233 sg_set_buf(&sg[k], &xbuf[IDX[k]],
234 hmac_tv[i].tap[k]);
1da177e4
LT		 235 }
236
ef2736fc
HX		 237 crypto_hmac(tfm, hmac_tv[i].key, &klen, sg,
238 hmac_tv[i].np, result);
1da177e4 239 hexdump(result, crypto_tfm_alg_digestsize(tfm));
ef2736fc 240
1da177e4 241 printk("%s\n",
ef2736fc
HX		 242 memcmp(result, hmac_tv[i].digest,
243 crypto_tfm_alg_digestsize(tfm)) ?
244 "fail" : "pass");
1da177e4
LT		 245 }
246 }
247out:
248 crypto_free_tfm(tfm);
249}
250
251#endif /* CONFIG_CRYPTO_HMAC */
252
ef2736fc
HX		 253static void test_cipher(char *algo, int mode, int enc,
254 struct cipher_testvec *template, unsigned int tcount)
1da177e4
LT		 255{
256 unsigned int ret, i, j, k, temp;
257 unsigned int tsize;
378f058c 258 char *q;
1da177e4
LT		 259 struct crypto_tfm *tfm;
260 char *key;
261 struct cipher_testvec *cipher_tv;
262 struct scatterlist sg[8];
3cc3816f 263 const char *e, *m;
1da177e4
LT		 264
265 if (enc == ENCRYPT)
3cc3816f 266 e = "encryption";
1da177e4 267 else
3cc3816f 268 e = "decryption";
1da177e4 269 if (mode == MODE_ECB)
3cc3816f 270 m = "ECB";
1da177e4 271 else
3cc3816f 272 m = "CBC";
1da177e4 273
ef2736fc 274 printk("\ntesting %s %s %s\n", algo, m, e);
1da177e4 275
ef2736fc 276 tsize = sizeof (struct cipher_testvec);
1da177e4 277 tsize *= tcount;
ef2736fc 278
1da177e4
LT		 279 if (tsize > TVMEMSIZE) {
280 printk("template (%u) too big for tvmem (%u)\n", tsize,
281 TVMEMSIZE);
282 return;
283 }
284
285 memcpy(tvmem, template, tsize);
ef2736fc
HX		 286 cipher_tv = (void *)tvmem;
287
288 if (mode)
289 tfm = crypto_alloc_tfm(algo, 0);
290 else
291 tfm = crypto_alloc_tfm(algo, CRYPTO_TFM_MODE_CBC);
1da177e4 292
1da177e4
LT		 293 if (tfm == NULL) {
294 printk("failed to load transform for %s %s\n", algo, m);
295 return;
296 }
ef2736fc 297
1da177e4
LT		 298 j = 0;
299 for (i = 0; i < tcount; i++) {
300 if (!(cipher_tv[i].np)) {
ef2736fc 301 j++;
1da177e4
LT		 302 printk("test %u (%d bit key):\n",
303 j, cipher_tv[i].klen * 8);
304
305 tfm->crt_flags = 0;
ef2736fc 306 if (cipher_tv[i].wk)
1da177e4
LT		 307 tfm->crt_flags |= CRYPTO_TFM_REQ_WEAK_KEY;
308 key = cipher_tv[i].key;
ef2736fc 309
1da177e4
LT		 310 ret = crypto_cipher_setkey(tfm, key, cipher_tv[i].klen);
311 if (ret) {
312 printk("setkey() failed flags=%x\n", tfm->crt_flags);
ef2736fc 313
1da177e4
LT		 314 if (!cipher_tv[i].fail)
315 goto out;
ef2736fc 316 }
1da177e4 317
378f058c
DH		 318 sg_set_buf(&sg[0], cipher_tv[i].input,
319 cipher_tv[i].ilen);
ef2736fc 320
1da177e4
LT		 321 if (!mode) {
322 crypto_cipher_set_iv(tfm, cipher_tv[i].iv,
ef2736fc 323 crypto_tfm_alg_ivsize(tfm));
1da177e4 324 }
ef2736fc 325
1da177e4
LT		 326 if (enc)
327 ret = crypto_cipher_encrypt(tfm, sg, sg, cipher_tv[i].ilen);
328 else
329 ret = crypto_cipher_decrypt(tfm, sg, sg, cipher_tv[i].ilen);
ef2736fc
HX		 330
331
1da177e4
LT		 332 if (ret) {
333 printk("%s () failed flags=%x\n", e, tfm->crt_flags);
334 goto out;
ef2736fc
HX		 335 }
336
1da177e4
LT		 337 q = kmap(sg[0].page) + sg[0].offset;
338 hexdump(q, cipher_tv[i].rlen);
ef2736fc
HX		 339
340 printk("%s\n",
341 memcmp(q, cipher_tv[i].result,
342 cipher_tv[i].rlen) ? "fail" : "pass");
1da177e4
LT		 343 }
344 }
ef2736fc
HX		 345
346 printk("\ntesting %s %s %s across pages (chunking)\n", algo, m, e);
1da177e4 347 memset(xbuf, 0, XBUFSIZE);
ef2736fc 348
1da177e4
LT		 349 j = 0;
350 for (i = 0; i < tcount; i++) {
351 if (cipher_tv[i].np) {
ef2736fc 352 j++;
1da177e4
LT		 353 printk("test %u (%d bit key):\n",
354 j, cipher_tv[i].klen * 8);
355
ef2736fc
HX		 356 tfm->crt_flags = 0;
357 if (cipher_tv[i].wk)
1da177e4
LT		 358 tfm->crt_flags |= CRYPTO_TFM_REQ_WEAK_KEY;
359 key = cipher_tv[i].key;
ef2736fc
HX		 360
361 ret = crypto_cipher_setkey(tfm, key, cipher_tv[i].klen);
1da177e4
LT		 362 if (ret) {
363 printk("setkey() failed flags=%x\n", tfm->crt_flags);
ef2736fc 364
1da177e4
LT		 365 if (!cipher_tv[i].fail)
366 goto out;
367 }
368
369 temp = 0;
370 for (k = 0; k < cipher_tv[i].np; k++) {
ef2736fc
HX		 371 memcpy(&xbuf[IDX[k]],
372 cipher_tv[i].input + temp,
373 cipher_tv[i].tap[k]);
1da177e4 374 temp += cipher_tv[i].tap[k];
378f058c
DH		 375 sg_set_buf(&sg[k], &xbuf[IDX[k]],
376 cipher_tv[i].tap[k]);
1da177e4 377 }
ef2736fc 378
1da177e4
LT		 379 if (!mode) {
380 crypto_cipher_set_iv(tfm, cipher_tv[i].iv,
ef2736fc 381 crypto_tfm_alg_ivsize(tfm));
1da177e4 382 }
ef2736fc 383
1da177e4
LT		 384 if (enc)
385 ret = crypto_cipher_encrypt(tfm, sg, sg, cipher_tv[i].ilen);
386 else
387 ret = crypto_cipher_decrypt(tfm, sg, sg, cipher_tv[i].ilen);
ef2736fc 388
1da177e4
LT		 389 if (ret) {
390 printk("%s () failed flags=%x\n", e, tfm->crt_flags);
391 goto out;
392 }
393
394 temp = 0;
395 for (k = 0; k < cipher_tv[i].np; k++) {
396 printk("page %u\n", k);
397 q = kmap(sg[k].page) + sg[k].offset;
398 hexdump(q, cipher_tv[i].tap[k]);
ef2736fc
HX		 399 printk("%s\n",
400 memcmp(q, cipher_tv[i].result + temp,
401 cipher_tv[i].tap[k]) ? "fail" :
1da177e4
LT		 402 "pass");
403 temp += cipher_tv[i].tap[k];
404 }
405 }
406 }
407
408out:
409 crypto_free_tfm(tfm);
410}
411
6a17944c
HX		 412static int test_cipher_jiffies(struct crypto_tfm *tfm, int enc, char *p,
413 int blen, int sec)
414{
6df5b9f4 415 struct scatterlist sg[1];
6a17944c
HX		 416 unsigned long start, end;
417 int bcount;
418 int ret;
419
6df5b9f4 420 sg_set_buf(sg, p, blen);
6a17944c
HX		 421
422 for (start = jiffies, end = start + sec * HZ, bcount = 0;
423 time_before(jiffies, end); bcount++) {
424 if (enc)
425 ret = crypto_cipher_encrypt(tfm, sg, sg, blen);
426 else
427 ret = crypto_cipher_decrypt(tfm, sg, sg, blen);
428
429 if (ret)
430 return ret;
431 }
432
433 printk("%d operations in %d seconds (%ld bytes)\n",
434 bcount, sec, (long)bcount * blen);
435 return 0;
436}
437
438static int test_cipher_cycles(struct crypto_tfm *tfm, int enc, char *p,
439 int blen)
440{
6df5b9f4 441 struct scatterlist sg[1];
6a17944c
HX		 442 unsigned long cycles = 0;
443 int ret = 0;
444 int i;
445
6df5b9f4 446 sg_set_buf(sg, p, blen);
6a17944c
HX		 447
448 local_bh_disable();
449 local_irq_disable();
450
451 /* Warm-up run. */
452 for (i = 0; i < 4; i++) {
453 if (enc)
454 ret = crypto_cipher_encrypt(tfm, sg, sg, blen);
455 else
456 ret = crypto_cipher_decrypt(tfm, sg, sg, blen);
457
458 if (ret)
459 goto out;
460 }
461
462 /* The real thing. */
463 for (i = 0; i < 8; i++) {
464 cycles_t start, end;
465
466 start = get_cycles();
467 if (enc)
468 ret = crypto_cipher_encrypt(tfm, sg, sg, blen);
469 else
470 ret = crypto_cipher_decrypt(tfm, sg, sg, blen);
471 end = get_cycles();
472
473 if (ret)
474 goto out;
475
476 cycles += end - start;
477 }
478
479out:
480 local_irq_enable();
481 local_bh_enable();
482
483 if (ret == 0)
484 printk("1 operation in %lu cycles (%d bytes)\n",
485 (cycles + 4) / 8, blen);
486
487 return ret;
488}
489
ebfd9bcf 490static void test_cipher_speed(char *algo, int mode, int enc, unsigned int sec,
dce907c0
HX		 491 struct cipher_testvec *template,
492 unsigned int tcount, struct cipher_speed *speed)
ebfd9bcf 493{
dce907c0 494 unsigned int ret, i, j, iv_len;
ebfd9bcf
HW		 495 unsigned char *key, *p, iv[128];
496 struct crypto_tfm *tfm;
ebfd9bcf
HW		 497 const char *e, *m;
498
499 if (enc == ENCRYPT)
500 e = "encryption";
501 else
502 e = "decryption";
503 if (mode == MODE_ECB)
504 m = "ECB";
505 else
506 m = "CBC";
507
508 printk("\ntesting speed of %s %s %s\n", algo, m, e);
509
510 if (mode)
511 tfm = crypto_alloc_tfm(algo, 0);
512 else
513 tfm = crypto_alloc_tfm(algo, CRYPTO_TFM_MODE_CBC);
514
515 if (tfm == NULL) {
516 printk("failed to load transform for %s %s\n", algo, m);
517 return;
518 }
519
520 for (i = 0; speed[i].klen != 0; i++) {
521 if ((speed[i].blen + speed[i].klen) > TVMEMSIZE) {
522 printk("template (%u) too big for tvmem (%u)\n",
523 speed[i].blen + speed[i].klen, TVMEMSIZE);
524 goto out;
525 }
526
527 printk("test %u (%d bit key, %d byte blocks): ", i,
528 speed[i].klen * 8, speed[i].blen);
529
530 memset(tvmem, 0xff, speed[i].klen + speed[i].blen);
531
532 /* set key, plain text and IV */
533 key = (unsigned char *)tvmem;
dce907c0
HX		 534 for (j = 0; j < tcount; j++) {
535 if (template[j].klen == speed[i].klen) {
536 key = template[j].key;
537 break;
538 }
539 }
ebfd9bcf
HW		 540 p = (unsigned char *)tvmem + speed[i].klen;
541
542 ret = crypto_cipher_setkey(tfm, key, speed[i].klen);
543 if (ret) {
544 printk("setkey() failed flags=%x\n", tfm->crt_flags);
545 goto out;
546 }
547
548 if (!mode) {
549 iv_len = crypto_tfm_alg_ivsize(tfm);
550 memset(&iv, 0xff, iv_len);
551 crypto_cipher_set_iv(tfm, iv, iv_len);
552 }
553
6a17944c
HX		 554 if (sec)
555 ret = test_cipher_jiffies(tfm, enc, p, speed[i].blen,
556 sec);
557 else
558 ret = test_cipher_cycles(tfm, enc, p, speed[i].blen);
ebfd9bcf 559
6a17944c
HX		 560 if (ret) {
561 printk("%s() failed flags=%x\n", e, tfm->crt_flags);
562 break;
ebfd9bcf 563 }
ebfd9bcf
HW		 564 }
565
566out:
567 crypto_free_tfm(tfm);
568}
569
e8057928
ML		 570static void test_digest_jiffies(struct crypto_tfm *tfm, char *p, int blen,
571 int plen, char *out, int sec)
572{
573 struct scatterlist sg[1];
574 unsigned long start, end;
575 int bcount, pcount;
576
577 for (start = jiffies, end = start + sec * HZ, bcount = 0;
578 time_before(jiffies, end); bcount++) {
579 crypto_digest_init(tfm);
580 for (pcount = 0; pcount < blen; pcount += plen) {
581 sg_set_buf(sg, p + pcount, plen);
582 crypto_digest_update(tfm, sg, 1);
583 }
584 /* we assume there is enough space in 'out' for the result */
585 crypto_digest_final(tfm, out);
586 }
587
588 printk("%6u opers/sec, %9lu bytes/sec\n",
589 bcount / sec, ((long)bcount * blen) / sec);
590
591 return;
592}
593
594static void test_digest_cycles(struct crypto_tfm *tfm, char *p, int blen,
595 int plen, char *out)
596{
597 struct scatterlist sg[1];
598 unsigned long cycles = 0;
599 int i, pcount;
600
601 local_bh_disable();
602 local_irq_disable();
603
604 /* Warm-up run. */
605 for (i = 0; i < 4; i++) {
606 crypto_digest_init(tfm);
607 for (pcount = 0; pcount < blen; pcount += plen) {
608 sg_set_buf(sg, p + pcount, plen);
609 crypto_digest_update(tfm, sg, 1);
610 }
611 crypto_digest_final(tfm, out);
612 }
613
614 /* The real thing. */
615 for (i = 0; i < 8; i++) {
616 cycles_t start, end;
617
618 crypto_digest_init(tfm);
619
620 start = get_cycles();
621
622 for (pcount = 0; pcount < blen; pcount += plen) {
623 sg_set_buf(sg, p + pcount, plen);
624 crypto_digest_update(tfm, sg, 1);
625 }
626 crypto_digest_final(tfm, out);
627
628 end = get_cycles();
629
630 cycles += end - start;
631 }
632
633 local_irq_enable();
634 local_bh_enable();
635
636 printk("%6lu cycles/operation, %4lu cycles/byte\n",
637 cycles / 8, cycles / (8 * blen));
638
639 return;
640}
641
642static void test_digest_speed(char *algo, unsigned int sec,
643 struct digest_speed *speed)
644{
645 struct crypto_tfm *tfm;
646 char output[1024];
647 int i;
648
649 printk("\ntesting speed of %s\n", algo);
650
651 tfm = crypto_alloc_tfm(algo, 0);
652
653 if (tfm == NULL) {
654 printk("failed to load transform for %s\n", algo);
655 return;
656 }
657
658 if (crypto_tfm_alg_digestsize(tfm) > sizeof(output)) {
659 printk("digestsize(%u) > outputbuffer(%zu)\n",
660 crypto_tfm_alg_digestsize(tfm), sizeof(output));
661 goto out;
662 }
663
664 for (i = 0; speed[i].blen != 0; i++) {
665 if (speed[i].blen > TVMEMSIZE) {
666 printk("template (%u) too big for tvmem (%u)\n",
667 speed[i].blen, TVMEMSIZE);
668 goto out;
669 }
670
671 printk("test%3u (%5u byte blocks,%5u bytes per update,%4u updates): ",
672 i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
673
674 memset(tvmem, 0xff, speed[i].blen);
675
676 if (sec)
677 test_digest_jiffies(tfm, tvmem, speed[i].blen, speed[i].plen, output, sec);
678 else
679 test_digest_cycles(tfm, tvmem, speed[i].blen, speed[i].plen, output);
680 }
681
682out:
683 crypto_free_tfm(tfm);
684}
685
ef2736fc 686static void test_deflate(void)
1da177e4
LT		 687{
688 unsigned int i;
689 char result[COMP_BUF_SIZE];
690 struct crypto_tfm *tfm;
691 struct comp_testvec *tv;
692 unsigned int tsize;
693
694 printk("\ntesting deflate compression\n");
695
696 tsize = sizeof (deflate_comp_tv_template);
697 if (tsize > TVMEMSIZE) {
698 printk("template (%u) too big for tvmem (%u)\n", tsize,
699 TVMEMSIZE);
700 return;
701 }
702
703 memcpy(tvmem, deflate_comp_tv_template, tsize);
ef2736fc 704 tv = (void *)tvmem;
1da177e4
LT		 705
706 tfm = crypto_alloc_tfm("deflate", 0);
707 if (tfm == NULL) {
708 printk("failed to load transform for deflate\n");
709 return;
710 }
711
712 for (i = 0; i < DEFLATE_COMP_TEST_VECTORS; i++) {
713 int ilen, ret, dlen = COMP_BUF_SIZE;
ef2736fc 714
1da177e4
LT		 715 printk("test %u:\n", i + 1);
716 memset(result, 0, sizeof (result));
717
718 ilen = tv[i].inlen;
719 ret = crypto_comp_compress(tfm, tv[i].input,
720 ilen, result, &dlen);
721 if (ret) {
722 printk("fail: ret=%d\n", ret);
723 continue;
724 }
725 hexdump(result, dlen);
726 printk("%s (ratio %d:%d)\n",
727 memcmp(result, tv[i].output, dlen) ? "fail" : "pass",
728 ilen, dlen);
729 }
730
731 printk("\ntesting deflate decompression\n");
732
733 tsize = sizeof (deflate_decomp_tv_template);
734 if (tsize > TVMEMSIZE) {
735 printk("template (%u) too big for tvmem (%u)\n", tsize,
736 TVMEMSIZE);
737 goto out;
738 }
739
740 memcpy(tvmem, deflate_decomp_tv_template, tsize);
ef2736fc 741 tv = (void *)tvmem;
1da177e4
LT		 742
743 for (i = 0; i < DEFLATE_DECOMP_TEST_VECTORS; i++) {
744 int ilen, ret, dlen = COMP_BUF_SIZE;
ef2736fc 745
1da177e4
LT		 746 printk("test %u:\n", i + 1);
747 memset(result, 0, sizeof (result));
748
749 ilen = tv[i].inlen;
750 ret = crypto_comp_decompress(tfm, tv[i].input,
751 ilen, result, &dlen);
752 if (ret) {
753 printk("fail: ret=%d\n", ret);
754 continue;
755 }
756 hexdump(result, dlen);
757 printk("%s (ratio %d:%d)\n",
758 memcmp(result, tv[i].output, dlen) ? "fail" : "pass",
759 ilen, dlen);
760 }
761out:
762 crypto_free_tfm(tfm);
763}
764
ef2736fc 765static void test_crc32c(void)
1da177e4
LT		 766{
767#define NUMVEC 6
768#define VECSIZE 40
769
770 int i, j, pass;
771 u32 crc;
772 u8 b, test_vec[NUMVEC][VECSIZE];
773 static u32 vec_results[NUMVEC] = {
774 0x0e2c157f, 0xe980ebf6, 0xde74bded,
775 0xd579c862, 0xba979ad0, 0x2b29d913
776 };
777 static u32 tot_vec_results = 0x24c5d375;
ef2736fc 778
1da177e4
LT		 779 struct scatterlist sg[NUMVEC];
780 struct crypto_tfm *tfm;
781 char *fmtdata = "testing crc32c initialized to %08x: %s\n";
782#define SEEDTESTVAL 0xedcba987
783 u32 seed;
784
785 printk("\ntesting crc32c\n");
786
787 tfm = crypto_alloc_tfm("crc32c", 0);
788 if (tfm == NULL) {
789 printk("failed to load transform for crc32c\n");
790 return;
791 }
ef2736fc 792
1da177e4
LT		 793 crypto_digest_init(tfm);
794 crypto_digest_final(tfm, (u8*)&crc);
795 printk(fmtdata, crc, (crc == 0) ? "pass" : "ERROR");
ef2736fc 796
1da177e4
LT		 797 /*
798 * stuff test_vec with known values, simple incrementing
799 * byte values.
800 */
801 b = 0;
802 for (i = 0; i < NUMVEC; i++) {
ef2736fc 803 for (j = 0; j < VECSIZE; j++)
1da177e4 804 test_vec[i][j] = ++b;
378f058c 805 sg_set_buf(&sg[i], test_vec[i], VECSIZE);
1da177e4
LT		 806 }
807
808 seed = SEEDTESTVAL;
809 (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32));
25cdbcd9 810 crypto_digest_init(tfm);
1da177e4
LT		 811 crypto_digest_final(tfm, (u8*)&crc);
812 printk("testing crc32c setkey returns %08x : %s\n", crc, (crc == (SEEDTESTVAL ^ ~(u32)0)) ?
813 "pass" : "ERROR");
ef2736fc 814
1da177e4
LT		 815 printk("testing crc32c using update/final:\n");
816
817 pass = 1; /* assume all is well */
ef2736fc 818
1da177e4
LT		 819 for (i = 0; i < NUMVEC; i++) {
820 seed = ~(u32)0;
821 (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32));
25cdbcd9 822 crypto_digest_init(tfm);
1da177e4
LT		 823 crypto_digest_update(tfm, &sg[i], 1);
824 crypto_digest_final(tfm, (u8*)&crc);
825 if (crc == vec_results[i]) {
826 printk(" %08x:OK", crc);
827 } else {
828 printk(" %08x:BAD, wanted %08x\n", crc, vec_results[i]);
829 pass = 0;
830 }
831 }
832
833 printk("\ntesting crc32c using incremental accumulator:\n");
834 crc = 0;
835 for (i = 0; i < NUMVEC; i++) {
836 seed = (crc ^ ~(u32)0);
837 (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32));
25cdbcd9 838 crypto_digest_init(tfm);
1da177e4
LT		 839 crypto_digest_update(tfm, &sg[i], 1);
840 crypto_digest_final(tfm, (u8*)&crc);
841 }
842 if (crc == tot_vec_results) {
843 printk(" %08x:OK", crc);
844 } else {
845 printk(" %08x:BAD, wanted %08x\n", crc, tot_vec_results);
846 pass = 0;
847 }
848
849 printk("\ntesting crc32c using digest:\n");
850 seed = ~(u32)0;
851 (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32));
25cdbcd9 852 crypto_digest_init(tfm);
1da177e4
LT		 853 crypto_digest_digest(tfm, sg, NUMVEC, (u8*)&crc);
854 if (crc == tot_vec_results) {
855 printk(" %08x:OK", crc);
856 } else {
857 printk(" %08x:BAD, wanted %08x\n", crc, tot_vec_results);
858 pass = 0;
859 }
ef2736fc 860
1da177e4
LT		 861 printk("\n%s\n", pass ? "pass" : "ERROR");
862
863 crypto_free_tfm(tfm);
864 printk("crc32c test complete\n");
865}
866
ef2736fc 867static void test_available(void)
1da177e4
LT		 868{
869 char **name = check;
ef2736fc 870
1da177e4
LT		 871 while (*name) {
872 printk("alg %s ", *name);
873 printk((crypto_alg_available(*name, 0)) ?
874 "found\n" : "not found\n");
875 name++;
ef2736fc 876 }
1da177e4
LT		 877}
878
ef2736fc 879static void do_test(void)
1da177e4
LT		 880{
881 switch (mode) {
882
883 case 0:
884 test_hash("md5", md5_tv_template, MD5_TEST_VECTORS);
ef2736fc 885
1da177e4 886 test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS);
ef2736fc 887
1da177e4
LT		 888 //DES
889 test_cipher ("des", MODE_ECB, ENCRYPT, des_enc_tv_template, DES_ENC_TEST_VECTORS);
ef2736fc
HX		 890 test_cipher ("des", MODE_ECB, DECRYPT, des_dec_tv_template, DES_DEC_TEST_VECTORS);
891 test_cipher ("des", MODE_CBC, ENCRYPT, des_cbc_enc_tv_template, DES_CBC_ENC_TEST_VECTORS);
892 test_cipher ("des", MODE_CBC, DECRYPT, des_cbc_dec_tv_template, DES_CBC_DEC_TEST_VECTORS);
893
1da177e4
LT		 894 //DES3_EDE
895 test_cipher ("des3_ede", MODE_ECB, ENCRYPT, des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS);
ef2736fc
HX		 896 test_cipher ("des3_ede", MODE_ECB, DECRYPT, des3_ede_dec_tv_template, DES3_EDE_DEC_TEST_VECTORS);
897
1da177e4 898 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
ef2736fc 899
1da177e4 900 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
ef2736fc 901
1da177e4
LT		 902 //BLOWFISH
903 test_cipher ("blowfish", MODE_ECB, ENCRYPT, bf_enc_tv_template, BF_ENC_TEST_VECTORS);
904 test_cipher ("blowfish", MODE_ECB, DECRYPT, bf_dec_tv_template, BF_DEC_TEST_VECTORS);
905 test_cipher ("blowfish", MODE_CBC, ENCRYPT, bf_cbc_enc_tv_template, BF_CBC_ENC_TEST_VECTORS);
906 test_cipher ("blowfish", MODE_CBC, DECRYPT, bf_cbc_dec_tv_template, BF_CBC_DEC_TEST_VECTORS);
ef2736fc 907
1da177e4
LT		 908 //TWOFISH
909 test_cipher ("twofish", MODE_ECB, ENCRYPT, tf_enc_tv_template, TF_ENC_TEST_VECTORS);
910 test_cipher ("twofish", MODE_ECB, DECRYPT, tf_dec_tv_template, TF_DEC_TEST_VECTORS);
911 test_cipher ("twofish", MODE_CBC, ENCRYPT, tf_cbc_enc_tv_template, TF_CBC_ENC_TEST_VECTORS);
912 test_cipher ("twofish", MODE_CBC, DECRYPT, tf_cbc_dec_tv_template, TF_CBC_DEC_TEST_VECTORS);
ef2736fc 913
1da177e4
LT		 914 //SERPENT
915 test_cipher ("serpent", MODE_ECB, ENCRYPT, serpent_enc_tv_template, SERPENT_ENC_TEST_VECTORS);
916 test_cipher ("serpent", MODE_ECB, DECRYPT, serpent_dec_tv_template, SERPENT_DEC_TEST_VECTORS);
ef2736fc 917
1da177e4
LT		 918 //TNEPRES
919 test_cipher ("tnepres", MODE_ECB, ENCRYPT, tnepres_enc_tv_template, TNEPRES_ENC_TEST_VECTORS);
920 test_cipher ("tnepres", MODE_ECB, DECRYPT, tnepres_dec_tv_template, TNEPRES_DEC_TEST_VECTORS);
921
922 //AES
923 test_cipher ("aes", MODE_ECB, ENCRYPT, aes_enc_tv_template, AES_ENC_TEST_VECTORS);
924 test_cipher ("aes", MODE_ECB, DECRYPT, aes_dec_tv_template, AES_DEC_TEST_VECTORS);
05f29fcd
JG		 925 test_cipher ("aes", MODE_CBC, ENCRYPT, aes_cbc_enc_tv_template, AES_CBC_ENC_TEST_VECTORS);
926 test_cipher ("aes", MODE_CBC, DECRYPT, aes_cbc_dec_tv_template, AES_CBC_DEC_TEST_VECTORS);
1da177e4
LT		 927
928 //CAST5
929 test_cipher ("cast5", MODE_ECB, ENCRYPT, cast5_enc_tv_template, CAST5_ENC_TEST_VECTORS);
930 test_cipher ("cast5", MODE_ECB, DECRYPT, cast5_dec_tv_template, CAST5_DEC_TEST_VECTORS);
ef2736fc 931
1da177e4
LT		 932 //CAST6
933 test_cipher ("cast6", MODE_ECB, ENCRYPT, cast6_enc_tv_template, CAST6_ENC_TEST_VECTORS);
934 test_cipher ("cast6", MODE_ECB, DECRYPT, cast6_dec_tv_template, CAST6_DEC_TEST_VECTORS);
935
936 //ARC4
937 test_cipher ("arc4", MODE_ECB, ENCRYPT, arc4_enc_tv_template, ARC4_ENC_TEST_VECTORS);
938 test_cipher ("arc4", MODE_ECB, DECRYPT, arc4_dec_tv_template, ARC4_DEC_TEST_VECTORS);
939
940 //TEA
941 test_cipher ("tea", MODE_ECB, ENCRYPT, tea_enc_tv_template, TEA_ENC_TEST_VECTORS);
942 test_cipher ("tea", MODE_ECB, DECRYPT, tea_dec_tv_template, TEA_DEC_TEST_VECTORS);
943
944
945 //XTEA
946 test_cipher ("xtea", MODE_ECB, ENCRYPT, xtea_enc_tv_template, XTEA_ENC_TEST_VECTORS);
947 test_cipher ("xtea", MODE_ECB, DECRYPT, xtea_dec_tv_template, XTEA_DEC_TEST_VECTORS);
948
949 //KHAZAD
950 test_cipher ("khazad", MODE_ECB, ENCRYPT, khazad_enc_tv_template, KHAZAD_ENC_TEST_VECTORS);
951 test_cipher ("khazad", MODE_ECB, DECRYPT, khazad_dec_tv_template, KHAZAD_DEC_TEST_VECTORS);
952
953 //ANUBIS
954 test_cipher ("anubis", MODE_ECB, ENCRYPT, anubis_enc_tv_template, ANUBIS_ENC_TEST_VECTORS);
955 test_cipher ("anubis", MODE_ECB, DECRYPT, anubis_dec_tv_template, ANUBIS_DEC_TEST_VECTORS);
956 test_cipher ("anubis", MODE_CBC, ENCRYPT, anubis_cbc_enc_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS);
957 test_cipher ("anubis", MODE_CBC, DECRYPT, anubis_cbc_dec_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS);
958
fb4f10ed
AG		 959 //XETA
960 test_cipher ("xeta", MODE_ECB, ENCRYPT, xeta_enc_tv_template, XETA_ENC_TEST_VECTORS);
961 test_cipher ("xeta", MODE_ECB, DECRYPT, xeta_dec_tv_template, XETA_DEC_TEST_VECTORS);
962
1da177e4
LT		 963 test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS);
964 test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS);
965 test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS);
966 test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS);
967 test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS);
968 test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS);
969 test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS);
970 test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS);
971 test_deflate();
972 test_crc32c();
973#ifdef CONFIG_CRYPTO_HMAC
974 test_hmac("md5", hmac_md5_tv_template, HMAC_MD5_TEST_VECTORS);
ef2736fc 975 test_hmac("sha1", hmac_sha1_tv_template, HMAC_SHA1_TEST_VECTORS);
1da177e4 976 test_hmac("sha256", hmac_sha256_tv_template, HMAC_SHA256_TEST_VECTORS);
ef2736fc 977#endif
1da177e4
LT		 978
979 test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS);
980 break;
981
982 case 1:
983 test_hash("md5", md5_tv_template, MD5_TEST_VECTORS);
984 break;
985
986 case 2:
987 test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS);
988 break;
989
990 case 3:
991 test_cipher ("des", MODE_ECB, ENCRYPT, des_enc_tv_template, DES_ENC_TEST_VECTORS);
992 test_cipher ("des", MODE_ECB, DECRYPT, des_dec_tv_template, DES_DEC_TEST_VECTORS);
993 test_cipher ("des", MODE_CBC, ENCRYPT, des_cbc_enc_tv_template, DES_CBC_ENC_TEST_VECTORS);
994 test_cipher ("des", MODE_CBC, DECRYPT, des_cbc_dec_tv_template, DES_CBC_DEC_TEST_VECTORS);
995 break;
996
997 case 4:
998 test_cipher ("des3_ede", MODE_ECB, ENCRYPT, des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS);
ef2736fc 999 test_cipher ("des3_ede", MODE_ECB, DECRYPT, des3_ede_dec_tv_template, DES3_EDE_DEC_TEST_VECTORS);
1da177e4
LT		 1000 break;
1001
1002 case 5:
1003 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
1004 break;
ef2736fc 1005
1da177e4
LT		 1006 case 6:
1007 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
1008 break;
ef2736fc 1009
1da177e4
LT		 1010 case 7:
1011 test_cipher ("blowfish", MODE_ECB, ENCRYPT, bf_enc_tv_template, BF_ENC_TEST_VECTORS);
1012 test_cipher ("blowfish", MODE_ECB, DECRYPT, bf_dec_tv_template, BF_DEC_TEST_VECTORS);
1013 test_cipher ("blowfish", MODE_CBC, ENCRYPT, bf_cbc_enc_tv_template, BF_CBC_ENC_TEST_VECTORS);
1014 test_cipher ("blowfish", MODE_CBC, DECRYPT, bf_cbc_dec_tv_template, BF_CBC_DEC_TEST_VECTORS);
1015 break;
1016
1017 case 8:
1018 test_cipher ("twofish", MODE_ECB, ENCRYPT, tf_enc_tv_template, TF_ENC_TEST_VECTORS);
1019 test_cipher ("twofish", MODE_ECB, DECRYPT, tf_dec_tv_template, TF_DEC_TEST_VECTORS);
1020 test_cipher ("twofish", MODE_CBC, ENCRYPT, tf_cbc_enc_tv_template, TF_CBC_ENC_TEST_VECTORS);
1021 test_cipher ("twofish", MODE_CBC, DECRYPT, tf_cbc_dec_tv_template, TF_CBC_DEC_TEST_VECTORS);
1022 break;
ef2736fc 1023
1da177e4
LT		 1024 case 9:
1025 test_cipher ("serpent", MODE_ECB, ENCRYPT, serpent_enc_tv_template, SERPENT_ENC_TEST_VECTORS);
1026 test_cipher ("serpent", MODE_ECB, DECRYPT, serpent_dec_tv_template, SERPENT_DEC_TEST_VECTORS);
1027 break;
1028
1029 case 10:
1030 test_cipher ("aes", MODE_ECB, ENCRYPT, aes_enc_tv_template, AES_ENC_TEST_VECTORS);
ef2736fc 1031 test_cipher ("aes", MODE_ECB, DECRYPT, aes_dec_tv_template, AES_DEC_TEST_VECTORS);
05f29fcd
JG		 1032 test_cipher ("aes", MODE_CBC, ENCRYPT, aes_cbc_enc_tv_template, AES_CBC_ENC_TEST_VECTORS);
1033 test_cipher ("aes", MODE_CBC, DECRYPT, aes_cbc_dec_tv_template, AES_CBC_DEC_TEST_VECTORS);
1da177e4
LT		 1034 break;
1035
1036 case 11:
1037 test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS);
1038 break;
ef2736fc 1039
1da177e4
LT		 1040 case 12:
1041 test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS);
1042 break;
1043
1044 case 13:
1045 test_deflate();
1046 break;
1047
1048 case 14:
1049 test_cipher ("cast5", MODE_ECB, ENCRYPT, cast5_enc_tv_template, CAST5_ENC_TEST_VECTORS);
1050 test_cipher ("cast5", MODE_ECB, DECRYPT, cast5_dec_tv_template, CAST5_DEC_TEST_VECTORS);
1051 break;
1052
1053 case 15:
1054 test_cipher ("cast6", MODE_ECB, ENCRYPT, cast6_enc_tv_template, CAST6_ENC_TEST_VECTORS);
1055 test_cipher ("cast6", MODE_ECB, DECRYPT, cast6_dec_tv_template, CAST6_DEC_TEST_VECTORS);
1056 break;
1057
1058 case 16:
1059 test_cipher ("arc4", MODE_ECB, ENCRYPT, arc4_enc_tv_template, ARC4_ENC_TEST_VECTORS);
1060 test_cipher ("arc4", MODE_ECB, DECRYPT, arc4_dec_tv_template, ARC4_DEC_TEST_VECTORS);
1061 break;
1062
1063 case 17:
1064 test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS);
1065 break;
1066
1067 case 18:
1068 test_crc32c();
1069 break;
1070
1071 case 19:
1072 test_cipher ("tea", MODE_ECB, ENCRYPT, tea_enc_tv_template, TEA_ENC_TEST_VECTORS);
1073 test_cipher ("tea", MODE_ECB, DECRYPT, tea_dec_tv_template, TEA_DEC_TEST_VECTORS);
1074 break;
1075
1076 case 20:
1077 test_cipher ("xtea", MODE_ECB, ENCRYPT, xtea_enc_tv_template, XTEA_ENC_TEST_VECTORS);
1078 test_cipher ("xtea", MODE_ECB, DECRYPT, xtea_dec_tv_template, XTEA_DEC_TEST_VECTORS);
1079 break;
1080
1081 case 21:
1082 test_cipher ("khazad", MODE_ECB, ENCRYPT, khazad_enc_tv_template, KHAZAD_ENC_TEST_VECTORS);
1083 test_cipher ("khazad", MODE_ECB, DECRYPT, khazad_dec_tv_template, KHAZAD_DEC_TEST_VECTORS);
1084 break;
1085
1086 case 22:
1087 test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS);
1088 break;
1089
1090 case 23:
1091 test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS);
1092 break;
1093
1094 case 24:
1095 test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS);
1096 break;
1097
1098 case 25:
1099 test_cipher ("tnepres", MODE_ECB, ENCRYPT, tnepres_enc_tv_template, TNEPRES_ENC_TEST_VECTORS);
1100 test_cipher ("tnepres", MODE_ECB, DECRYPT, tnepres_dec_tv_template, TNEPRES_DEC_TEST_VECTORS);
1101 break;
1102
1103 case 26:
1104 test_cipher ("anubis", MODE_ECB, ENCRYPT, anubis_enc_tv_template, ANUBIS_ENC_TEST_VECTORS);
1105 test_cipher ("anubis", MODE_ECB, DECRYPT, anubis_dec_tv_template, ANUBIS_DEC_TEST_VECTORS);
1106 test_cipher ("anubis", MODE_CBC, ENCRYPT, anubis_cbc_enc_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS);
1107 test_cipher ("anubis", MODE_CBC, DECRYPT, anubis_cbc_dec_tv_template, ANUBIS_CBC_ENC_TEST_VECTORS);
1108 break;
1109
1110 case 27:
1111 test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS);
1112 break;
1113
1114 case 28:
1115
1116 test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS);
1117 break;
1118
1119 case 29:
1120 test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS);
1121 break;
fb4f10ed
AG		 1122
1123 case 30:
1124 test_cipher ("xeta", MODE_ECB, ENCRYPT, xeta_enc_tv_template, XETA_ENC_TEST_VECTORS);
1125 test_cipher ("xeta", MODE_ECB, DECRYPT, xeta_dec_tv_template, XETA_DEC_TEST_VECTORS);
1126 break;
1da177e4
LT		 1127
1128#ifdef CONFIG_CRYPTO_HMAC
1129 case 100:
1130 test_hmac("md5", hmac_md5_tv_template, HMAC_MD5_TEST_VECTORS);
1131 break;
ef2736fc 1132
1da177e4 1133 case 101:
ef2736fc 1134 test_hmac("sha1", hmac_sha1_tv_template, HMAC_SHA1_TEST_VECTORS);
1da177e4 1135 break;
ef2736fc 1136
1da177e4
LT		 1137 case 102:
1138 test_hmac("sha256", hmac_sha256_tv_template, HMAC_SHA256_TEST_VECTORS);
1139 break;
1140
1141#endif
1142
ebfd9bcf 1143 case 200:
dce907c0
HX		 1144 test_cipher_speed("aes", MODE_ECB, ENCRYPT, sec, NULL, 0,
1145 aes_speed_template);
1146 test_cipher_speed("aes", MODE_ECB, DECRYPT, sec, NULL, 0,
1147 aes_speed_template);
1148 test_cipher_speed("aes", MODE_CBC, ENCRYPT, sec, NULL, 0,
1149 aes_speed_template);
1150 test_cipher_speed("aes", MODE_CBC, DECRYPT, sec, NULL, 0,
1151 aes_speed_template);
ebfd9bcf
HW		 1152 break;
1153
1154 case 201:
dce907c0
HX		 1155 test_cipher_speed("des3_ede", MODE_ECB, ENCRYPT, sec,
1156 des3_ede_enc_tv_template,
1157 DES3_EDE_ENC_TEST_VECTORS,
1158 des3_ede_speed_template);
1159 test_cipher_speed("des3_ede", MODE_ECB, DECRYPT, sec,
1160 des3_ede_dec_tv_template,
1161 DES3_EDE_DEC_TEST_VECTORS,
1162 des3_ede_speed_template);
1163 test_cipher_speed("des3_ede", MODE_CBC, ENCRYPT, sec,
1164 des3_ede_enc_tv_template,
1165 DES3_EDE_ENC_TEST_VECTORS,
1166 des3_ede_speed_template);
1167 test_cipher_speed("des3_ede", MODE_CBC, DECRYPT, sec,
1168 des3_ede_dec_tv_template,
1169 DES3_EDE_DEC_TEST_VECTORS,
1170 des3_ede_speed_template);
ebfd9bcf
HW		 1171 break;
1172
1173 case 202:
dce907c0
HX		 1174 test_cipher_speed("twofish", MODE_ECB, ENCRYPT, sec, NULL, 0,
1175 twofish_speed_template);
1176 test_cipher_speed("twofish", MODE_ECB, DECRYPT, sec, NULL, 0,
1177 twofish_speed_template);
1178 test_cipher_speed("twofish", MODE_CBC, ENCRYPT, sec, NULL, 0,
1179 twofish_speed_template);
1180 test_cipher_speed("twofish", MODE_CBC, DECRYPT, sec, NULL, 0,
1181 twofish_speed_template);
ebfd9bcf
HW		 1182 break;
1183
1184 case 203:
dce907c0
HX		 1185 test_cipher_speed("blowfish", MODE_ECB, ENCRYPT, sec, NULL, 0,
1186 blowfish_speed_template);
1187 test_cipher_speed("blowfish", MODE_ECB, DECRYPT, sec, NULL, 0,
1188 blowfish_speed_template);
1189 test_cipher_speed("blowfish", MODE_CBC, ENCRYPT, sec, NULL, 0,
1190 blowfish_speed_template);
1191 test_cipher_speed("blowfish", MODE_CBC, DECRYPT, sec, NULL, 0,
1192 blowfish_speed_template);
ebfd9bcf
HW		 1193 break;
1194
1195 case 204:
dce907c0
HX		 1196 test_cipher_speed("des", MODE_ECB, ENCRYPT, sec, NULL, 0,
1197 des_speed_template);
1198 test_cipher_speed("des", MODE_ECB, DECRYPT, sec, NULL, 0,
1199 des_speed_template);
1200 test_cipher_speed("des", MODE_CBC, ENCRYPT, sec, NULL, 0,
1201 des_speed_template);
1202 test_cipher_speed("des", MODE_CBC, DECRYPT, sec, NULL, 0,
1203 des_speed_template);
ebfd9bcf
HW		 1204 break;
1205
e8057928
ML		 1206 case 300:
1207 /* fall through */
1208
1209 case 301:
1210 test_digest_speed("md4", sec, generic_digest_speed_template);
1211 if (mode > 300 && mode < 400) break;
1212
1213 case 302:
1214 test_digest_speed("md5", sec, generic_digest_speed_template);
1215 if (mode > 300 && mode < 400) break;
1216
1217 case 303:
1218 test_digest_speed("sha1", sec, generic_digest_speed_template);
1219 if (mode > 300 && mode < 400) break;
1220
1221 case 304:
1222 test_digest_speed("sha256", sec, generic_digest_speed_template);
1223 if (mode > 300 && mode < 400) break;
1224
1225 case 305:
1226 test_digest_speed("sha384", sec, generic_digest_speed_template);
1227 if (mode > 300 && mode < 400) break;
1228
1229 case 306:
1230 test_digest_speed("sha512", sec, generic_digest_speed_template);
1231 if (mode > 300 && mode < 400) break;
1232
1233 case 307:
1234 test_digest_speed("wp256", sec, generic_digest_speed_template);
1235 if (mode > 300 && mode < 400) break;
1236
1237 case 308:
1238 test_digest_speed("wp384", sec, generic_digest_speed_template);
1239 if (mode > 300 && mode < 400) break;
1240
1241 case 309:
1242 test_digest_speed("wp512", sec, generic_digest_speed_template);
1243 if (mode > 300 && mode < 400) break;
1244
1245 case 310:
1246 test_digest_speed("tgr128", sec, generic_digest_speed_template);
1247 if (mode > 300 && mode < 400) break;
1248
1249 case 311:
1250 test_digest_speed("tgr160", sec, generic_digest_speed_template);
1251 if (mode > 300 && mode < 400) break;
1252
1253 case 312:
1254 test_digest_speed("tgr192", sec, generic_digest_speed_template);
1255 if (mode > 300 && mode < 400) break;
1256
1257 case 399:
1258 break;
1259
1da177e4
LT		 1260 case 1000:
1261 test_available();
1262 break;
ef2736fc 1263
1da177e4
LT		 1264 default:
1265 /* useful for debugging */
1266 printk("not testing anything\n");
1267 break;
1268 }
1269}
1270
ef2736fc 1271static int __init init(void)
1da177e4
LT		 1272{
1273 tvmem = kmalloc(TVMEMSIZE, GFP_KERNEL);
1274 if (tvmem == NULL)
1275 return -ENOMEM;
1276
1277 xbuf = kmalloc(XBUFSIZE, GFP_KERNEL);
1278 if (xbuf == NULL) {
1279 kfree(tvmem);
1280 return -ENOMEM;
1281 }
1282
1283 do_test();
1284
1285 kfree(xbuf);
1286 kfree(tvmem);
14fdf477
ML		 1287
1288 /* We intentionaly return -EAGAIN to prevent keeping
1289 * the module. It does all its work from init()
1290 * and doesn't offer any runtime functionality
1291 * => we don't need it in the memory, do we?
1292 * -- mludvig
1293 */
1294 return -EAGAIN;
1da177e4
LT		 1295}
1296
1297/*
1298 * If an init function is provided, an exit function must also be provided
1299 * to allow module unload.
1300 */
1301static void __exit fini(void) { }
1302
1303module_init(init);
1304module_exit(fini);
1305
1306module_param(mode, int, 0);
ebfd9bcf 1307module_param(sec, uint, 0);
6a17944c
HX		 1308MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
1309 "(defaults to zero which uses CPU cycles instead)");
1da177e4
LT		 1310
1311MODULE_LICENSE("GPL");
1312MODULE_DESCRIPTION("Quick & dirty crypto testing module");
1313MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");
Linux kernel - Deliverables
This page took 0.186268 seconds and 5 git commands to generate.