Root/crypto/tcrypt.c

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 * Copyright (c) 2007 Nokia Siemens Networks
10 *
11 * This program is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License as published by the Free
13 * Software Foundation; either version 2 of the License, or (at your option)
14 * any later version.
15 *
16 */
17
18#include <crypto/hash.h>
19#include <linux/err.h>
20#include <linux/init.h>
21#include <linux/gfp.h>
22#include <linux/module.h>
23#include <linux/scatterlist.h>
24#include <linux/string.h>
25#include <linux/moduleparam.h>
26#include <linux/jiffies.h>
27#include <linux/timex.h>
28#include <linux/interrupt.h>
29#include "tcrypt.h"
30#include "internal.h"
31
32/*
33 * Need slab memory for testing (size in number of pages).
34 */
35#define TVMEMSIZE 4
36
37/*
38* Used by test_cipher_speed()
39*/
40#define ENCRYPT 1
41#define DECRYPT 0
42
43/*
44 * Used by test_cipher_speed()
45 */
46static unsigned int sec;
47
48static char *alg = NULL;
49static u32 type;
50static u32 mask;
51static int mode;
52static char *tvmem[TVMEMSIZE];
53
54static char *check[] = {
55    "des", "md5", "des3_ede", "rot13", "sha1", "sha224", "sha256",
56    "blowfish", "twofish", "serpent", "sha384", "sha512", "md4", "aes",
57    "cast6", "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
58    "khazad", "wp512", "wp384", "wp256", "tnepres", "xeta", "fcrypt",
59    "camellia", "seed", "salsa20", "rmd128", "rmd160", "rmd256", "rmd320",
60    "lzo", "cts", "zlib", NULL
61};
62
63static int test_cipher_jiffies(struct blkcipher_desc *desc, int enc,
64                   struct scatterlist *sg, int blen, int sec)
65{
66    unsigned long start, end;
67    int bcount;
68    int ret;
69
70    for (start = jiffies, end = start + sec * HZ, bcount = 0;
71         time_before(jiffies, end); bcount++) {
72        if (enc)
73            ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
74        else
75            ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
76
77        if (ret)
78            return ret;
79    }
80
81    printk("%d operations in %d seconds (%ld bytes)\n",
82           bcount, sec, (long)bcount * blen);
83    return 0;
84}
85
86static int test_cipher_cycles(struct blkcipher_desc *desc, int enc,
87                  struct scatterlist *sg, int blen)
88{
89    unsigned long cycles = 0;
90    int ret = 0;
91    int i;
92
93    local_bh_disable();
94    local_irq_disable();
95
96    /* Warm-up run. */
97    for (i = 0; i < 4; i++) {
98        if (enc)
99            ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
100        else
101            ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
102
103        if (ret)
104            goto out;
105    }
106
107    /* The real thing. */
108    for (i = 0; i < 8; i++) {
109        cycles_t start, end;
110
111        start = get_cycles();
112        if (enc)
113            ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
114        else
115            ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
116        end = get_cycles();
117
118        if (ret)
119            goto out;
120
121        cycles += end - start;
122    }
123
124out:
125    local_irq_enable();
126    local_bh_enable();
127
128    if (ret == 0)
129        printk("1 operation in %lu cycles (%d bytes)\n",
130               (cycles + 4) / 8, blen);
131
132    return ret;
133}
134
135static u32 block_sizes[] = { 16, 64, 256, 1024, 8192, 0 };
136
137static void test_cipher_speed(const char *algo, int enc, unsigned int sec,
138                  struct cipher_speed_template *template,
139                  unsigned int tcount, u8 *keysize)
140{
141    unsigned int ret, i, j, iv_len;
142    const char *key, iv[128];
143    struct crypto_blkcipher *tfm;
144    struct blkcipher_desc desc;
145    const char *e;
146    u32 *b_size;
147
148    if (enc == ENCRYPT)
149            e = "encryption";
150    else
151        e = "decryption";
152
153    printk("\ntesting speed of %s %s\n", algo, e);
154
155    tfm = crypto_alloc_blkcipher(algo, 0, CRYPTO_ALG_ASYNC);
156
157    if (IS_ERR(tfm)) {
158        printk("failed to load transform for %s: %ld\n", algo,
159               PTR_ERR(tfm));
160        return;
161    }
162    desc.tfm = tfm;
163    desc.flags = 0;
164
165    i = 0;
166    do {
167
168        b_size = block_sizes;
169        do {
170            struct scatterlist sg[TVMEMSIZE];
171
172            if ((*keysize + *b_size) > TVMEMSIZE * PAGE_SIZE) {
173                printk("template (%u) too big for "
174                       "tvmem (%lu)\n", *keysize + *b_size,
175                       TVMEMSIZE * PAGE_SIZE);
176                goto out;
177            }
178
179            printk("test %u (%d bit key, %d byte blocks): ", i,
180                    *keysize * 8, *b_size);
181
182            memset(tvmem[0], 0xff, PAGE_SIZE);
183
184            /* set key, plain text and IV */
185            key = tvmem[0];
186            for (j = 0; j < tcount; j++) {
187                if (template[j].klen == *keysize) {
188                    key = template[j].key;
189                    break;
190                }
191            }
192
193            ret = crypto_blkcipher_setkey(tfm, key, *keysize);
194            if (ret) {
195                printk("setkey() failed flags=%x\n",
196                        crypto_blkcipher_get_flags(tfm));
197                goto out;
198            }
199
200            sg_init_table(sg, TVMEMSIZE);
201            sg_set_buf(sg, tvmem[0] + *keysize,
202                   PAGE_SIZE - *keysize);
203            for (j = 1; j < TVMEMSIZE; j++) {
204                sg_set_buf(sg + j, tvmem[j], PAGE_SIZE);
205                memset (tvmem[j], 0xff, PAGE_SIZE);
206            }
207
208            iv_len = crypto_blkcipher_ivsize(tfm);
209            if (iv_len) {
210                memset(&iv, 0xff, iv_len);
211                crypto_blkcipher_set_iv(tfm, iv, iv_len);
212            }
213
214            if (sec)
215                ret = test_cipher_jiffies(&desc, enc, sg,
216                              *b_size, sec);
217            else
218                ret = test_cipher_cycles(&desc, enc, sg,
219                             *b_size);
220
221            if (ret) {
222                printk("%s() failed flags=%x\n", e, desc.flags);
223                break;
224            }
225            b_size++;
226            i++;
227        } while (*b_size);
228        keysize++;
229    } while (*keysize);
230
231out:
232    crypto_free_blkcipher(tfm);
233}
234
235static int test_hash_jiffies_digest(struct hash_desc *desc,
236                    struct scatterlist *sg, int blen,
237                    char *out, int sec)
238{
239    unsigned long start, end;
240    int bcount;
241    int ret;
242
243    for (start = jiffies, end = start + sec * HZ, bcount = 0;
244         time_before(jiffies, end); bcount++) {
245        ret = crypto_hash_digest(desc, sg, blen, out);
246        if (ret)
247            return ret;
248    }
249
250    printk("%6u opers/sec, %9lu bytes/sec\n",
251           bcount / sec, ((long)bcount * blen) / sec);
252
253    return 0;
254}
255
256static int test_hash_jiffies(struct hash_desc *desc, struct scatterlist *sg,
257                 int blen, int plen, char *out, int sec)
258{
259    unsigned long start, end;
260    int bcount, pcount;
261    int ret;
262
263    if (plen == blen)
264        return test_hash_jiffies_digest(desc, sg, blen, out, sec);
265
266    for (start = jiffies, end = start + sec * HZ, bcount = 0;
267         time_before(jiffies, end); bcount++) {
268        ret = crypto_hash_init(desc);
269        if (ret)
270            return ret;
271        for (pcount = 0; pcount < blen; pcount += plen) {
272            ret = crypto_hash_update(desc, sg, plen);
273            if (ret)
274                return ret;
275        }
276        /* we assume there is enough space in 'out' for the result */
277        ret = crypto_hash_final(desc, out);
278        if (ret)
279            return ret;
280    }
281
282    printk("%6u opers/sec, %9lu bytes/sec\n",
283           bcount / sec, ((long)bcount * blen) / sec);
284
285    return 0;
286}
287
288static int test_hash_cycles_digest(struct hash_desc *desc,
289                   struct scatterlist *sg, int blen, char *out)
290{
291    unsigned long cycles = 0;
292    int i;
293    int ret;
294
295    local_bh_disable();
296    local_irq_disable();
297
298    /* Warm-up run. */
299    for (i = 0; i < 4; i++) {
300        ret = crypto_hash_digest(desc, sg, blen, out);
301        if (ret)
302            goto out;
303    }
304
305    /* The real thing. */
306    for (i = 0; i < 8; i++) {
307        cycles_t start, end;
308
309        start = get_cycles();
310
311        ret = crypto_hash_digest(desc, sg, blen, out);
312        if (ret)
313            goto out;
314
315        end = get_cycles();
316
317        cycles += end - start;
318    }
319
320out:
321    local_irq_enable();
322    local_bh_enable();
323
324    if (ret)
325        return ret;
326
327    printk("%6lu cycles/operation, %4lu cycles/byte\n",
328           cycles / 8, cycles / (8 * blen));
329
330    return 0;
331}
332
333static int test_hash_cycles(struct hash_desc *desc, struct scatterlist *sg,
334                int blen, int plen, char *out)
335{
336    unsigned long cycles = 0;
337    int i, pcount;
338    int ret;
339
340    if (plen == blen)
341        return test_hash_cycles_digest(desc, sg, blen, out);
342
343    local_bh_disable();
344    local_irq_disable();
345
346    /* Warm-up run. */
347    for (i = 0; i < 4; i++) {
348        ret = crypto_hash_init(desc);
349        if (ret)
350            goto out;
351        for (pcount = 0; pcount < blen; pcount += plen) {
352            ret = crypto_hash_update(desc, sg, plen);
353            if (ret)
354                goto out;
355        }
356        ret = crypto_hash_final(desc, out);
357        if (ret)
358            goto out;
359    }
360
361    /* The real thing. */
362    for (i = 0; i < 8; i++) {
363        cycles_t start, end;
364
365        start = get_cycles();
366
367        ret = crypto_hash_init(desc);
368        if (ret)
369            goto out;
370        for (pcount = 0; pcount < blen; pcount += plen) {
371            ret = crypto_hash_update(desc, sg, plen);
372            if (ret)
373                goto out;
374        }
375        ret = crypto_hash_final(desc, out);
376        if (ret)
377            goto out;
378
379        end = get_cycles();
380
381        cycles += end - start;
382    }
383
384out:
385    local_irq_enable();
386    local_bh_enable();
387
388    if (ret)
389        return ret;
390
391    printk("%6lu cycles/operation, %4lu cycles/byte\n",
392           cycles / 8, cycles / (8 * blen));
393
394    return 0;
395}
396
397static void test_hash_speed(const char *algo, unsigned int sec,
398                struct hash_speed *speed)
399{
400    struct scatterlist sg[TVMEMSIZE];
401    struct crypto_hash *tfm;
402    struct hash_desc desc;
403    static char output[1024];
404    int i;
405    int ret;
406
407    printk(KERN_INFO "\ntesting speed of %s\n", algo);
408
409    tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC);
410
411    if (IS_ERR(tfm)) {
412        printk(KERN_ERR "failed to load transform for %s: %ld\n", algo,
413               PTR_ERR(tfm));
414        return;
415    }
416
417    desc.tfm = tfm;
418    desc.flags = 0;
419
420    if (crypto_hash_digestsize(tfm) > sizeof(output)) {
421        printk(KERN_ERR "digestsize(%u) > outputbuffer(%zu)\n",
422               crypto_hash_digestsize(tfm), sizeof(output));
423        goto out;
424    }
425
426    sg_init_table(sg, TVMEMSIZE);
427    for (i = 0; i < TVMEMSIZE; i++) {
428        sg_set_buf(sg + i, tvmem[i], PAGE_SIZE);
429        memset(tvmem[i], 0xff, PAGE_SIZE);
430    }
431
432    for (i = 0; speed[i].blen != 0; i++) {
433        if (speed[i].blen > TVMEMSIZE * PAGE_SIZE) {
434            printk(KERN_ERR
435                   "template (%u) too big for tvmem (%lu)\n",
436                   speed[i].blen, TVMEMSIZE * PAGE_SIZE);
437            goto out;
438        }
439
440        printk(KERN_INFO "test%3u "
441               "(%5u byte blocks,%5u bytes per update,%4u updates): ",
442               i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
443
444        if (sec)
445            ret = test_hash_jiffies(&desc, sg, speed[i].blen,
446                        speed[i].plen, output, sec);
447        else
448            ret = test_hash_cycles(&desc, sg, speed[i].blen,
449                           speed[i].plen, output);
450
451        if (ret) {
452            printk(KERN_ERR "hashing failed ret=%d\n", ret);
453            break;
454        }
455    }
456
457out:
458    crypto_free_hash(tfm);
459}
460
461static void test_available(void)
462{
463    char **name = check;
464
465    while (*name) {
466        printk("alg %s ", *name);
467        printk(crypto_has_alg(*name, 0, 0) ?
468               "found\n" : "not found\n");
469        name++;
470    }
471}
472
473static inline int tcrypt_test(const char *alg)
474{
475    int ret;
476
477    ret = alg_test(alg, alg, 0, 0);
478    /* non-fips algs return -EINVAL in fips mode */
479    if (fips_enabled && ret == -EINVAL)
480        ret = 0;
481    return ret;
482}
483
484static int do_test(int m)
485{
486    int i;
487    int ret = 0;
488
489    switch (m) {
490    case 0:
491        for (i = 1; i < 200; i++)
492            ret += do_test(i);
493        break;
494
495    case 1:
496        ret += tcrypt_test("md5");
497        break;
498
499    case 2:
500        ret += tcrypt_test("sha1");
501        break;
502
503    case 3:
504        ret += tcrypt_test("ecb(des)");
505        ret += tcrypt_test("cbc(des)");
506        break;
507
508    case 4:
509        ret += tcrypt_test("ecb(des3_ede)");
510        ret += tcrypt_test("cbc(des3_ede)");
511        break;
512
513    case 5:
514        ret += tcrypt_test("md4");
515        break;
516
517    case 6:
518        ret += tcrypt_test("sha256");
519        break;
520
521    case 7:
522        ret += tcrypt_test("ecb(blowfish)");
523        ret += tcrypt_test("cbc(blowfish)");
524        break;
525
526    case 8:
527        ret += tcrypt_test("ecb(twofish)");
528        ret += tcrypt_test("cbc(twofish)");
529        break;
530
531    case 9:
532        ret += tcrypt_test("ecb(serpent)");
533        break;
534
535    case 10:
536        ret += tcrypt_test("ecb(aes)");
537        ret += tcrypt_test("cbc(aes)");
538        ret += tcrypt_test("lrw(aes)");
539        ret += tcrypt_test("xts(aes)");
540        ret += tcrypt_test("ctr(aes)");
541        ret += tcrypt_test("rfc3686(ctr(aes))");
542        break;
543
544    case 11:
545        ret += tcrypt_test("sha384");
546        break;
547
548    case 12:
549        ret += tcrypt_test("sha512");
550        break;
551
552    case 13:
553        ret += tcrypt_test("deflate");
554        break;
555
556    case 14:
557        ret += tcrypt_test("ecb(cast5)");
558        break;
559
560    case 15:
561        ret += tcrypt_test("ecb(cast6)");
562        break;
563
564    case 16:
565        ret += tcrypt_test("ecb(arc4)");
566        break;
567
568    case 17:
569        ret += tcrypt_test("michael_mic");
570        break;
571
572    case 18:
573        ret += tcrypt_test("crc32c");
574        break;
575
576    case 19:
577        ret += tcrypt_test("ecb(tea)");
578        break;
579
580    case 20:
581        ret += tcrypt_test("ecb(xtea)");
582        break;
583
584    case 21:
585        ret += tcrypt_test("ecb(khazad)");
586        break;
587
588    case 22:
589        ret += tcrypt_test("wp512");
590        break;
591
592    case 23:
593        ret += tcrypt_test("wp384");
594        break;
595
596    case 24:
597        ret += tcrypt_test("wp256");
598        break;
599
600    case 25:
601        ret += tcrypt_test("ecb(tnepres)");
602        break;
603
604    case 26:
605        ret += tcrypt_test("ecb(anubis)");
606        ret += tcrypt_test("cbc(anubis)");
607        break;
608
609    case 27:
610        ret += tcrypt_test("tgr192");
611        break;
612
613    case 28:
614
615        ret += tcrypt_test("tgr160");
616        break;
617
618    case 29:
619        ret += tcrypt_test("tgr128");
620        break;
621
622    case 30:
623        ret += tcrypt_test("ecb(xeta)");
624        break;
625
626    case 31:
627        ret += tcrypt_test("pcbc(fcrypt)");
628        break;
629
630    case 32:
631        ret += tcrypt_test("ecb(camellia)");
632        ret += tcrypt_test("cbc(camellia)");
633        break;
634    case 33:
635        ret += tcrypt_test("sha224");
636        break;
637
638    case 34:
639        ret += tcrypt_test("salsa20");
640        break;
641
642    case 35:
643        ret += tcrypt_test("gcm(aes)");
644        break;
645
646    case 36:
647        ret += tcrypt_test("lzo");
648        break;
649
650    case 37:
651        ret += tcrypt_test("ccm(aes)");
652        break;
653
654    case 38:
655        ret += tcrypt_test("cts(cbc(aes))");
656        break;
657
658        case 39:
659        ret += tcrypt_test("rmd128");
660        break;
661
662        case 40:
663        ret += tcrypt_test("rmd160");
664        break;
665
666    case 41:
667        ret += tcrypt_test("rmd256");
668        break;
669
670    case 42:
671        ret += tcrypt_test("rmd320");
672        break;
673
674    case 43:
675        ret += tcrypt_test("ecb(seed)");
676        break;
677
678    case 44:
679        ret += tcrypt_test("zlib");
680        break;
681
682    case 45:
683        ret += tcrypt_test("rfc4309(ccm(aes))");
684        break;
685
686    case 100:
687        ret += tcrypt_test("hmac(md5)");
688        break;
689
690    case 101:
691        ret += tcrypt_test("hmac(sha1)");
692        break;
693
694    case 102:
695        ret += tcrypt_test("hmac(sha256)");
696        break;
697
698    case 103:
699        ret += tcrypt_test("hmac(sha384)");
700        break;
701
702    case 104:
703        ret += tcrypt_test("hmac(sha512)");
704        break;
705
706    case 105:
707        ret += tcrypt_test("hmac(sha224)");
708        break;
709
710    case 106:
711        ret += tcrypt_test("xcbc(aes)");
712        break;
713
714    case 107:
715        ret += tcrypt_test("hmac(rmd128)");
716        break;
717
718    case 108:
719        ret += tcrypt_test("hmac(rmd160)");
720        break;
721
722    case 109:
723        ret += tcrypt_test("vmac(aes)");
724        break;
725
726    case 150:
727        ret += tcrypt_test("ansi_cprng");
728        break;
729
730    case 200:
731        test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
732                speed_template_16_24_32);
733        test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
734                speed_template_16_24_32);
735        test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
736                speed_template_16_24_32);
737        test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
738                speed_template_16_24_32);
739        test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
740                speed_template_32_40_48);
741        test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
742                speed_template_32_40_48);
743        test_cipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
744                speed_template_32_48_64);
745        test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
746                speed_template_32_48_64);
747        break;
748
749    case 201:
750        test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec,
751                des3_speed_template, DES3_SPEED_VECTORS,
752                speed_template_24);
753        test_cipher_speed("ecb(des3_ede)", DECRYPT, sec,
754                des3_speed_template, DES3_SPEED_VECTORS,
755                speed_template_24);
756        test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec,
757                des3_speed_template, DES3_SPEED_VECTORS,
758                speed_template_24);
759        test_cipher_speed("cbc(des3_ede)", DECRYPT, sec,
760                des3_speed_template, DES3_SPEED_VECTORS,
761                speed_template_24);
762        break;
763
764    case 202:
765        test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
766                speed_template_16_24_32);
767        test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
768                speed_template_16_24_32);
769        test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
770                speed_template_16_24_32);
771        test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
772                speed_template_16_24_32);
773        break;
774
775    case 203:
776        test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
777                  speed_template_8_32);
778        test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
779                  speed_template_8_32);
780        test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
781                  speed_template_8_32);
782        test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
783                  speed_template_8_32);
784        break;
785
786    case 204:
787        test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
788                  speed_template_8);
789        test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
790                  speed_template_8);
791        test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
792                  speed_template_8);
793        test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
794                  speed_template_8);
795        break;
796
797    case 205:
798        test_cipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
799                speed_template_16_24_32);
800        test_cipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
801                speed_template_16_24_32);
802        test_cipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
803                speed_template_16_24_32);
804        test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
805                speed_template_16_24_32);
806        break;
807
808    case 206:
809        test_cipher_speed("salsa20", ENCRYPT, sec, NULL, 0,
810                  speed_template_16_32);
811        break;
812
813    case 300:
814        /* fall through */
815
816    case 301:
817        test_hash_speed("md4", sec, generic_hash_speed_template);
818        if (mode > 300 && mode < 400) break;
819
820    case 302:
821        test_hash_speed("md5", sec, generic_hash_speed_template);
822        if (mode > 300 && mode < 400) break;
823
824    case 303:
825        test_hash_speed("sha1", sec, generic_hash_speed_template);
826        if (mode > 300 && mode < 400) break;
827
828    case 304:
829        test_hash_speed("sha256", sec, generic_hash_speed_template);
830        if (mode > 300 && mode < 400) break;
831
832    case 305:
833        test_hash_speed("sha384", sec, generic_hash_speed_template);
834        if (mode > 300 && mode < 400) break;
835
836    case 306:
837        test_hash_speed("sha512", sec, generic_hash_speed_template);
838        if (mode > 300 && mode < 400) break;
839
840    case 307:
841        test_hash_speed("wp256", sec, generic_hash_speed_template);
842        if (mode > 300 && mode < 400) break;
843
844    case 308:
845        test_hash_speed("wp384", sec, generic_hash_speed_template);
846        if (mode > 300 && mode < 400) break;
847
848    case 309:
849        test_hash_speed("wp512", sec, generic_hash_speed_template);
850        if (mode > 300 && mode < 400) break;
851
852    case 310:
853        test_hash_speed("tgr128", sec, generic_hash_speed_template);
854        if (mode > 300 && mode < 400) break;
855
856    case 311:
857        test_hash_speed("tgr160", sec, generic_hash_speed_template);
858        if (mode > 300 && mode < 400) break;
859
860    case 312:
861        test_hash_speed("tgr192", sec, generic_hash_speed_template);
862        if (mode > 300 && mode < 400) break;
863
864    case 313:
865        test_hash_speed("sha224", sec, generic_hash_speed_template);
866        if (mode > 300 && mode < 400) break;
867
868    case 314:
869        test_hash_speed("rmd128", sec, generic_hash_speed_template);
870        if (mode > 300 && mode < 400) break;
871
872    case 315:
873        test_hash_speed("rmd160", sec, generic_hash_speed_template);
874        if (mode > 300 && mode < 400) break;
875
876    case 316:
877        test_hash_speed("rmd256", sec, generic_hash_speed_template);
878        if (mode > 300 && mode < 400) break;
879
880    case 317:
881        test_hash_speed("rmd320", sec, generic_hash_speed_template);
882        if (mode > 300 && mode < 400) break;
883
884    case 399:
885        break;
886
887    case 1000:
888        test_available();
889        break;
890    }
891
892    return ret;
893}
894
895static int do_alg_test(const char *alg, u32 type, u32 mask)
896{
897    return crypto_has_alg(alg, type, mask ?: CRYPTO_ALG_TYPE_MASK) ?
898           0 : -ENOENT;
899}
900
901static int __init tcrypt_mod_init(void)
902{
903    int err = -ENOMEM;
904    int i;
905
906    for (i = 0; i < TVMEMSIZE; i++) {
907        tvmem[i] = (void *)__get_free_page(GFP_KERNEL);
908        if (!tvmem[i])
909            goto err_free_tv;
910    }
911
912    if (alg)
913        err = do_alg_test(alg, type, mask);
914    else
915        err = do_test(mode);
916
917    if (err) {
918        printk(KERN_ERR "tcrypt: one or more tests failed!\n");
919        goto err_free_tv;
920    }
921
922    /* We intentionaly return -EAGAIN to prevent keeping the module,
923     * unless we're running in fips mode. It does all its work from
924     * init() and doesn't offer any runtime functionality, but in
925     * the fips case, checking for a successful load is helpful.
926     * => we don't need it in the memory, do we?
927     * -- mludvig
928     */
929    if (!fips_enabled)
930        err = -EAGAIN;
931
932err_free_tv:
933    for (i = 0; i < TVMEMSIZE && tvmem[i]; i++)
934        free_page((unsigned long)tvmem[i]);
935
936    return err;
937}
938
939/*
940 * If an init function is provided, an exit function must also be provided
941 * to allow module unload.
942 */
943static void __exit tcrypt_mod_fini(void) { }
944
945module_init(tcrypt_mod_init);
946module_exit(tcrypt_mod_fini);
947
948module_param(alg, charp, 0);
949module_param(type, uint, 0);
950module_param(mask, uint, 0);
951module_param(mode, int, 0);
952module_param(sec, uint, 0);
953MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
954              "(defaults to zero which uses CPU cycles instead)");
955
956MODULE_LICENSE("GPL");
957MODULE_DESCRIPTION("Quick & dirty crypto testing module");
958MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");
959

Archive Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9



interactive