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_sg_init(struct scatterlist *sg)
398{
399    int i;
400
401    sg_init_table(sg, TVMEMSIZE);
402    for (i = 0; i < TVMEMSIZE; i++) {
403        sg_set_buf(sg + i, tvmem[i], PAGE_SIZE);
404        memset(tvmem[i], 0xff, PAGE_SIZE);
405    }
406}
407
408static void test_hash_speed(const char *algo, unsigned int sec,
409                struct hash_speed *speed)
410{
411    struct scatterlist sg[TVMEMSIZE];
412    struct crypto_hash *tfm;
413    struct hash_desc desc;
414    static char output[1024];
415    int i;
416    int ret;
417
418    printk(KERN_INFO "\ntesting speed of %s\n", algo);
419
420    tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC);
421
422    if (IS_ERR(tfm)) {
423        printk(KERN_ERR "failed to load transform for %s: %ld\n", algo,
424               PTR_ERR(tfm));
425        return;
426    }
427
428    desc.tfm = tfm;
429    desc.flags = 0;
430
431    if (crypto_hash_digestsize(tfm) > sizeof(output)) {
432        printk(KERN_ERR "digestsize(%u) > outputbuffer(%zu)\n",
433               crypto_hash_digestsize(tfm), sizeof(output));
434        goto out;
435    }
436
437    test_hash_sg_init(sg);
438    for (i = 0; speed[i].blen != 0; i++) {
439        if (speed[i].blen > TVMEMSIZE * PAGE_SIZE) {
440            printk(KERN_ERR
441                   "template (%u) too big for tvmem (%lu)\n",
442                   speed[i].blen, TVMEMSIZE * PAGE_SIZE);
443            goto out;
444        }
445
446        if (speed[i].klen)
447            crypto_hash_setkey(tfm, tvmem[0], speed[i].klen);
448
449        printk(KERN_INFO "test%3u "
450               "(%5u byte blocks,%5u bytes per update,%4u updates): ",
451               i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
452
453        if (sec)
454            ret = test_hash_jiffies(&desc, sg, speed[i].blen,
455                        speed[i].plen, output, sec);
456        else
457            ret = test_hash_cycles(&desc, sg, speed[i].blen,
458                           speed[i].plen, output);
459
460        if (ret) {
461            printk(KERN_ERR "hashing failed ret=%d\n", ret);
462            break;
463        }
464    }
465
466out:
467    crypto_free_hash(tfm);
468}
469
470struct tcrypt_result {
471    struct completion completion;
472    int err;
473};
474
475static void tcrypt_complete(struct crypto_async_request *req, int err)
476{
477    struct tcrypt_result *res = req->data;
478
479    if (err == -EINPROGRESS)
480        return;
481
482    res->err = err;
483    complete(&res->completion);
484}
485
486static inline int do_one_ahash_op(struct ahash_request *req, int ret)
487{
488    if (ret == -EINPROGRESS || ret == -EBUSY) {
489        struct tcrypt_result *tr = req->base.data;
490
491        ret = wait_for_completion_interruptible(&tr->completion);
492        if (!ret)
493            ret = tr->err;
494        INIT_COMPLETION(tr->completion);
495    }
496    return ret;
497}
498
499static int test_ahash_jiffies_digest(struct ahash_request *req, int blen,
500                     char *out, int sec)
501{
502    unsigned long start, end;
503    int bcount;
504    int ret;
505
506    for (start = jiffies, end = start + sec * HZ, bcount = 0;
507         time_before(jiffies, end); bcount++) {
508        ret = do_one_ahash_op(req, crypto_ahash_digest(req));
509        if (ret)
510            return ret;
511    }
512
513    printk("%6u opers/sec, %9lu bytes/sec\n",
514           bcount / sec, ((long)bcount * blen) / sec);
515
516    return 0;
517}
518
519static int test_ahash_jiffies(struct ahash_request *req, int blen,
520                  int plen, char *out, int sec)
521{
522    unsigned long start, end;
523    int bcount, pcount;
524    int ret;
525
526    if (plen == blen)
527        return test_ahash_jiffies_digest(req, blen, out, sec);
528
529    for (start = jiffies, end = start + sec * HZ, bcount = 0;
530         time_before(jiffies, end); bcount++) {
531        ret = crypto_ahash_init(req);
532        if (ret)
533            return ret;
534        for (pcount = 0; pcount < blen; pcount += plen) {
535            ret = do_one_ahash_op(req, crypto_ahash_update(req));
536            if (ret)
537                return ret;
538        }
539        /* we assume there is enough space in 'out' for the result */
540        ret = do_one_ahash_op(req, crypto_ahash_final(req));
541        if (ret)
542            return ret;
543    }
544
545    pr_cont("%6u opers/sec, %9lu bytes/sec\n",
546        bcount / sec, ((long)bcount * blen) / sec);
547
548    return 0;
549}
550
551static int test_ahash_cycles_digest(struct ahash_request *req, int blen,
552                    char *out)
553{
554    unsigned long cycles = 0;
555    int ret, i;
556
557    /* Warm-up run. */
558    for (i = 0; i < 4; i++) {
559        ret = do_one_ahash_op(req, crypto_ahash_digest(req));
560        if (ret)
561            goto out;
562    }
563
564    /* The real thing. */
565    for (i = 0; i < 8; i++) {
566        cycles_t start, end;
567
568        start = get_cycles();
569
570        ret = do_one_ahash_op(req, crypto_ahash_digest(req));
571        if (ret)
572            goto out;
573
574        end = get_cycles();
575
576        cycles += end - start;
577    }
578
579out:
580    if (ret)
581        return ret;
582
583    pr_cont("%6lu cycles/operation, %4lu cycles/byte\n",
584        cycles / 8, cycles / (8 * blen));
585
586    return 0;
587}
588
589static int test_ahash_cycles(struct ahash_request *req, int blen,
590                 int plen, char *out)
591{
592    unsigned long cycles = 0;
593    int i, pcount, ret;
594
595    if (plen == blen)
596        return test_ahash_cycles_digest(req, blen, out);
597
598    /* Warm-up run. */
599    for (i = 0; i < 4; i++) {
600        ret = crypto_ahash_init(req);
601        if (ret)
602            goto out;
603        for (pcount = 0; pcount < blen; pcount += plen) {
604            ret = do_one_ahash_op(req, crypto_ahash_update(req));
605            if (ret)
606                goto out;
607        }
608        ret = do_one_ahash_op(req, crypto_ahash_final(req));
609        if (ret)
610            goto out;
611    }
612
613    /* The real thing. */
614    for (i = 0; i < 8; i++) {
615        cycles_t start, end;
616
617        start = get_cycles();
618
619        ret = crypto_ahash_init(req);
620        if (ret)
621            goto out;
622        for (pcount = 0; pcount < blen; pcount += plen) {
623            ret = do_one_ahash_op(req, crypto_ahash_update(req));
624            if (ret)
625                goto out;
626        }
627        ret = do_one_ahash_op(req, crypto_ahash_final(req));
628        if (ret)
629            goto out;
630
631        end = get_cycles();
632
633        cycles += end - start;
634    }
635
636out:
637    if (ret)
638        return ret;
639
640    pr_cont("%6lu cycles/operation, %4lu cycles/byte\n",
641        cycles / 8, cycles / (8 * blen));
642
643    return 0;
644}
645
646static void test_ahash_speed(const char *algo, unsigned int sec,
647                 struct hash_speed *speed)
648{
649    struct scatterlist sg[TVMEMSIZE];
650    struct tcrypt_result tresult;
651    struct ahash_request *req;
652    struct crypto_ahash *tfm;
653    static char output[1024];
654    int i, ret;
655
656    printk(KERN_INFO "\ntesting speed of async %s\n", algo);
657
658    tfm = crypto_alloc_ahash(algo, 0, 0);
659    if (IS_ERR(tfm)) {
660        pr_err("failed to load transform for %s: %ld\n",
661               algo, PTR_ERR(tfm));
662        return;
663    }
664
665    if (crypto_ahash_digestsize(tfm) > sizeof(output)) {
666        pr_err("digestsize(%u) > outputbuffer(%zu)\n",
667               crypto_ahash_digestsize(tfm), sizeof(output));
668        goto out;
669    }
670
671    test_hash_sg_init(sg);
672    req = ahash_request_alloc(tfm, GFP_KERNEL);
673    if (!req) {
674        pr_err("ahash request allocation failure\n");
675        goto out;
676    }
677
678    init_completion(&tresult.completion);
679    ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
680                   tcrypt_complete, &tresult);
681
682    for (i = 0; speed[i].blen != 0; i++) {
683        if (speed[i].blen > TVMEMSIZE * PAGE_SIZE) {
684            pr_err("template (%u) too big for tvmem (%lu)\n",
685                   speed[i].blen, TVMEMSIZE * PAGE_SIZE);
686            break;
687        }
688
689        pr_info("test%3u "
690            "(%5u byte blocks,%5u bytes per update,%4u updates): ",
691            i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
692
693        ahash_request_set_crypt(req, sg, output, speed[i].plen);
694
695        if (sec)
696            ret = test_ahash_jiffies(req, speed[i].blen,
697                         speed[i].plen, output, sec);
698        else
699            ret = test_ahash_cycles(req, speed[i].blen,
700                        speed[i].plen, output);
701
702        if (ret) {
703            pr_err("hashing failed ret=%d\n", ret);
704            break;
705        }
706    }
707
708    ahash_request_free(req);
709
710out:
711    crypto_free_ahash(tfm);
712}
713
714static void test_available(void)
715{
716    char **name = check;
717
718    while (*name) {
719        printk("alg %s ", *name);
720        printk(crypto_has_alg(*name, 0, 0) ?
721               "found\n" : "not found\n");
722        name++;
723    }
724}
725
726static inline int tcrypt_test(const char *alg)
727{
728    int ret;
729
730    ret = alg_test(alg, alg, 0, 0);
731    /* non-fips algs return -EINVAL in fips mode */
732    if (fips_enabled && ret == -EINVAL)
733        ret = 0;
734    return ret;
735}
736
737static int do_test(int m)
738{
739    int i;
740    int ret = 0;
741
742    switch (m) {
743    case 0:
744        for (i = 1; i < 200; i++)
745            ret += do_test(i);
746        break;
747
748    case 1:
749        ret += tcrypt_test("md5");
750        break;
751
752    case 2:
753        ret += tcrypt_test("sha1");
754        break;
755
756    case 3:
757        ret += tcrypt_test("ecb(des)");
758        ret += tcrypt_test("cbc(des)");
759        break;
760
761    case 4:
762        ret += tcrypt_test("ecb(des3_ede)");
763        ret += tcrypt_test("cbc(des3_ede)");
764        break;
765
766    case 5:
767        ret += tcrypt_test("md4");
768        break;
769
770    case 6:
771        ret += tcrypt_test("sha256");
772        break;
773
774    case 7:
775        ret += tcrypt_test("ecb(blowfish)");
776        ret += tcrypt_test("cbc(blowfish)");
777        break;
778
779    case 8:
780        ret += tcrypt_test("ecb(twofish)");
781        ret += tcrypt_test("cbc(twofish)");
782        break;
783
784    case 9:
785        ret += tcrypt_test("ecb(serpent)");
786        break;
787
788    case 10:
789        ret += tcrypt_test("ecb(aes)");
790        ret += tcrypt_test("cbc(aes)");
791        ret += tcrypt_test("lrw(aes)");
792        ret += tcrypt_test("xts(aes)");
793        ret += tcrypt_test("ctr(aes)");
794        ret += tcrypt_test("rfc3686(ctr(aes))");
795        break;
796
797    case 11:
798        ret += tcrypt_test("sha384");
799        break;
800
801    case 12:
802        ret += tcrypt_test("sha512");
803        break;
804
805    case 13:
806        ret += tcrypt_test("deflate");
807        break;
808
809    case 14:
810        ret += tcrypt_test("ecb(cast5)");
811        break;
812
813    case 15:
814        ret += tcrypt_test("ecb(cast6)");
815        break;
816
817    case 16:
818        ret += tcrypt_test("ecb(arc4)");
819        break;
820
821    case 17:
822        ret += tcrypt_test("michael_mic");
823        break;
824
825    case 18:
826        ret += tcrypt_test("crc32c");
827        break;
828
829    case 19:
830        ret += tcrypt_test("ecb(tea)");
831        break;
832
833    case 20:
834        ret += tcrypt_test("ecb(xtea)");
835        break;
836
837    case 21:
838        ret += tcrypt_test("ecb(khazad)");
839        break;
840
841    case 22:
842        ret += tcrypt_test("wp512");
843        break;
844
845    case 23:
846        ret += tcrypt_test("wp384");
847        break;
848
849    case 24:
850        ret += tcrypt_test("wp256");
851        break;
852
853    case 25:
854        ret += tcrypt_test("ecb(tnepres)");
855        break;
856
857    case 26:
858        ret += tcrypt_test("ecb(anubis)");
859        ret += tcrypt_test("cbc(anubis)");
860        break;
861
862    case 27:
863        ret += tcrypt_test("tgr192");
864        break;
865
866    case 28:
867
868        ret += tcrypt_test("tgr160");
869        break;
870
871    case 29:
872        ret += tcrypt_test("tgr128");
873        break;
874
875    case 30:
876        ret += tcrypt_test("ecb(xeta)");
877        break;
878
879    case 31:
880        ret += tcrypt_test("pcbc(fcrypt)");
881        break;
882
883    case 32:
884        ret += tcrypt_test("ecb(camellia)");
885        ret += tcrypt_test("cbc(camellia)");
886        break;
887    case 33:
888        ret += tcrypt_test("sha224");
889        break;
890
891    case 34:
892        ret += tcrypt_test("salsa20");
893        break;
894
895    case 35:
896        ret += tcrypt_test("gcm(aes)");
897        break;
898
899    case 36:
900        ret += tcrypt_test("lzo");
901        break;
902
903    case 37:
904        ret += tcrypt_test("ccm(aes)");
905        break;
906
907    case 38:
908        ret += tcrypt_test("cts(cbc(aes))");
909        break;
910
911        case 39:
912        ret += tcrypt_test("rmd128");
913        break;
914
915        case 40:
916        ret += tcrypt_test("rmd160");
917        break;
918
919    case 41:
920        ret += tcrypt_test("rmd256");
921        break;
922
923    case 42:
924        ret += tcrypt_test("rmd320");
925        break;
926
927    case 43:
928        ret += tcrypt_test("ecb(seed)");
929        break;
930
931    case 44:
932        ret += tcrypt_test("zlib");
933        break;
934
935    case 45:
936        ret += tcrypt_test("rfc4309(ccm(aes))");
937        break;
938
939    case 100:
940        ret += tcrypt_test("hmac(md5)");
941        break;
942
943    case 101:
944        ret += tcrypt_test("hmac(sha1)");
945        break;
946
947    case 102:
948        ret += tcrypt_test("hmac(sha256)");
949        break;
950
951    case 103:
952        ret += tcrypt_test("hmac(sha384)");
953        break;
954
955    case 104:
956        ret += tcrypt_test("hmac(sha512)");
957        break;
958
959    case 105:
960        ret += tcrypt_test("hmac(sha224)");
961        break;
962
963    case 106:
964        ret += tcrypt_test("xcbc(aes)");
965        break;
966
967    case 107:
968        ret += tcrypt_test("hmac(rmd128)");
969        break;
970
971    case 108:
972        ret += tcrypt_test("hmac(rmd160)");
973        break;
974
975    case 109:
976        ret += tcrypt_test("vmac(aes)");
977        break;
978
979    case 150:
980        ret += tcrypt_test("ansi_cprng");
981        break;
982
983    case 200:
984        test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
985                speed_template_16_24_32);
986        test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
987                speed_template_16_24_32);
988        test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
989                speed_template_16_24_32);
990        test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
991                speed_template_16_24_32);
992        test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
993                speed_template_32_40_48);
994        test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
995                speed_template_32_40_48);
996        test_cipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
997                speed_template_32_48_64);
998        test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
999                speed_template_32_48_64);
1000        break;
1001
1002    case 201:
1003        test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec,
1004                des3_speed_template, DES3_SPEED_VECTORS,
1005                speed_template_24);
1006        test_cipher_speed("ecb(des3_ede)", DECRYPT, sec,
1007                des3_speed_template, DES3_SPEED_VECTORS,
1008                speed_template_24);
1009        test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec,
1010                des3_speed_template, DES3_SPEED_VECTORS,
1011                speed_template_24);
1012        test_cipher_speed("cbc(des3_ede)", DECRYPT, sec,
1013                des3_speed_template, DES3_SPEED_VECTORS,
1014                speed_template_24);
1015        break;
1016
1017    case 202:
1018        test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
1019                speed_template_16_24_32);
1020        test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
1021                speed_template_16_24_32);
1022        test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
1023                speed_template_16_24_32);
1024        test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
1025                speed_template_16_24_32);
1026        break;
1027
1028    case 203:
1029        test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
1030                  speed_template_8_32);
1031        test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
1032                  speed_template_8_32);
1033        test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
1034                  speed_template_8_32);
1035        test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
1036                  speed_template_8_32);
1037        break;
1038
1039    case 204:
1040        test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
1041                  speed_template_8);
1042        test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
1043                  speed_template_8);
1044        test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
1045                  speed_template_8);
1046        test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
1047                  speed_template_8);
1048        break;
1049
1050    case 205:
1051        test_cipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
1052                speed_template_16_24_32);
1053        test_cipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
1054                speed_template_16_24_32);
1055        test_cipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
1056                speed_template_16_24_32);
1057        test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
1058                speed_template_16_24_32);
1059        break;
1060
1061    case 206:
1062        test_cipher_speed("salsa20", ENCRYPT, sec, NULL, 0,
1063                  speed_template_16_32);
1064        break;
1065
1066    case 300:
1067        /* fall through */
1068
1069    case 301:
1070        test_hash_speed("md4", sec, generic_hash_speed_template);
1071        if (mode > 300 && mode < 400) break;
1072
1073    case 302:
1074        test_hash_speed("md5", sec, generic_hash_speed_template);
1075        if (mode > 300 && mode < 400) break;
1076
1077    case 303:
1078        test_hash_speed("sha1", sec, generic_hash_speed_template);
1079        if (mode > 300 && mode < 400) break;
1080
1081    case 304:
1082        test_hash_speed("sha256", sec, generic_hash_speed_template);
1083        if (mode > 300 && mode < 400) break;
1084
1085    case 305:
1086        test_hash_speed("sha384", sec, generic_hash_speed_template);
1087        if (mode > 300 && mode < 400) break;
1088
1089    case 306:
1090        test_hash_speed("sha512", sec, generic_hash_speed_template);
1091        if (mode > 300 && mode < 400) break;
1092
1093    case 307:
1094        test_hash_speed("wp256", sec, generic_hash_speed_template);
1095        if (mode > 300 && mode < 400) break;
1096
1097    case 308:
1098        test_hash_speed("wp384", sec, generic_hash_speed_template);
1099        if (mode > 300 && mode < 400) break;
1100
1101    case 309:
1102        test_hash_speed("wp512", sec, generic_hash_speed_template);
1103        if (mode > 300 && mode < 400) break;
1104
1105    case 310:
1106        test_hash_speed("tgr128", sec, generic_hash_speed_template);
1107        if (mode > 300 && mode < 400) break;
1108
1109    case 311:
1110        test_hash_speed("tgr160", sec, generic_hash_speed_template);
1111        if (mode > 300 && mode < 400) break;
1112
1113    case 312:
1114        test_hash_speed("tgr192", sec, generic_hash_speed_template);
1115        if (mode > 300 && mode < 400) break;
1116
1117    case 313:
1118        test_hash_speed("sha224", sec, generic_hash_speed_template);
1119        if (mode > 300 && mode < 400) break;
1120
1121    case 314:
1122        test_hash_speed("rmd128", sec, generic_hash_speed_template);
1123        if (mode > 300 && mode < 400) break;
1124
1125    case 315:
1126        test_hash_speed("rmd160", sec, generic_hash_speed_template);
1127        if (mode > 300 && mode < 400) break;
1128
1129    case 316:
1130        test_hash_speed("rmd256", sec, generic_hash_speed_template);
1131        if (mode > 300 && mode < 400) break;
1132
1133    case 317:
1134        test_hash_speed("rmd320", sec, generic_hash_speed_template);
1135        if (mode > 300 && mode < 400) break;
1136
1137    case 318:
1138        test_hash_speed("ghash-generic", sec, hash_speed_template_16);
1139        if (mode > 300 && mode < 400) break;
1140
1141    case 399:
1142        break;
1143
1144    case 400:
1145        /* fall through */
1146
1147    case 401:
1148        test_ahash_speed("md4", sec, generic_hash_speed_template);
1149        if (mode > 400 && mode < 500) break;
1150
1151    case 402:
1152        test_ahash_speed("md5", sec, generic_hash_speed_template);
1153        if (mode > 400 && mode < 500) break;
1154
1155    case 403:
1156        test_ahash_speed("sha1", sec, generic_hash_speed_template);
1157        if (mode > 400 && mode < 500) break;
1158
1159    case 404:
1160        test_ahash_speed("sha256", sec, generic_hash_speed_template);
1161        if (mode > 400 && mode < 500) break;
1162
1163    case 405:
1164        test_ahash_speed("sha384", sec, generic_hash_speed_template);
1165        if (mode > 400 && mode < 500) break;
1166
1167    case 406:
1168        test_ahash_speed("sha512", sec, generic_hash_speed_template);
1169        if (mode > 400 && mode < 500) break;
1170
1171    case 407:
1172        test_ahash_speed("wp256", sec, generic_hash_speed_template);
1173        if (mode > 400 && mode < 500) break;
1174
1175    case 408:
1176        test_ahash_speed("wp384", sec, generic_hash_speed_template);
1177        if (mode > 400 && mode < 500) break;
1178
1179    case 409:
1180        test_ahash_speed("wp512", sec, generic_hash_speed_template);
1181        if (mode > 400 && mode < 500) break;
1182
1183    case 410:
1184        test_ahash_speed("tgr128", sec, generic_hash_speed_template);
1185        if (mode > 400 && mode < 500) break;
1186
1187    case 411:
1188        test_ahash_speed("tgr160", sec, generic_hash_speed_template);
1189        if (mode > 400 && mode < 500) break;
1190
1191    case 412:
1192        test_ahash_speed("tgr192", sec, generic_hash_speed_template);
1193        if (mode > 400 && mode < 500) break;
1194
1195    case 413:
1196        test_ahash_speed("sha224", sec, generic_hash_speed_template);
1197        if (mode > 400 && mode < 500) break;
1198
1199    case 414:
1200        test_ahash_speed("rmd128", sec, generic_hash_speed_template);
1201        if (mode > 400 && mode < 500) break;
1202
1203    case 415:
1204        test_ahash_speed("rmd160", sec, generic_hash_speed_template);
1205        if (mode > 400 && mode < 500) break;
1206
1207    case 416:
1208        test_ahash_speed("rmd256", sec, generic_hash_speed_template);
1209        if (mode > 400 && mode < 500) break;
1210
1211    case 417:
1212        test_ahash_speed("rmd320", sec, generic_hash_speed_template);
1213        if (mode > 400 && mode < 500) break;
1214
1215    case 499:
1216        break;
1217
1218    case 1000:
1219        test_available();
1220        break;
1221    }
1222
1223    return ret;
1224}
1225
1226static int do_alg_test(const char *alg, u32 type, u32 mask)
1227{
1228    return crypto_has_alg(alg, type, mask ?: CRYPTO_ALG_TYPE_MASK) ?
1229           0 : -ENOENT;
1230}
1231
1232static int __init tcrypt_mod_init(void)
1233{
1234    int err = -ENOMEM;
1235    int i;
1236
1237    for (i = 0; i < TVMEMSIZE; i++) {
1238        tvmem[i] = (void *)__get_free_page(GFP_KERNEL);
1239        if (!tvmem[i])
1240            goto err_free_tv;
1241    }
1242
1243    if (alg)
1244        err = do_alg_test(alg, type, mask);
1245    else
1246        err = do_test(mode);
1247
1248    if (err) {
1249        printk(KERN_ERR "tcrypt: one or more tests failed!\n");
1250        goto err_free_tv;
1251    }
1252
1253    /* We intentionaly return -EAGAIN to prevent keeping the module,
1254     * unless we're running in fips mode. It does all its work from
1255     * init() and doesn't offer any runtime functionality, but in
1256     * the fips case, checking for a successful load is helpful.
1257     * => we don't need it in the memory, do we?
1258     * -- mludvig
1259     */
1260    if (!fips_enabled)
1261        err = -EAGAIN;
1262
1263err_free_tv:
1264    for (i = 0; i < TVMEMSIZE && tvmem[i]; i++)
1265        free_page((unsigned long)tvmem[i]);
1266
1267    return err;
1268}
1269
1270/*
1271 * If an init function is provided, an exit function must also be provided
1272 * to allow module unload.
1273 */
1274static void __exit tcrypt_mod_fini(void) { }
1275
1276module_init(tcrypt_mod_init);
1277module_exit(tcrypt_mod_fini);
1278
1279module_param(alg, charp, 0);
1280module_param(type, uint, 0);
1281module_param(mask, uint, 0);
1282module_param(mode, int, 0);
1283module_param(sec, uint, 0);
1284MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
1285              "(defaults to zero which uses CPU cycles instead)");
1286
1287MODULE_LICENSE("GPL");
1288MODULE_DESCRIPTION("Quick & dirty crypto testing module");
1289MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");
1290

Archive Download this file



interactive