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 <[email protected]>
   8  * Copyright (c) 2002 Jean-Francois Dive <[email protected]>
   9  * Copyright (c) 2007 Nokia Siemens Networks
  10  *
  11  * Updated RFC4106 AES-GCM testing.
  12  *    Authors: Aidan O'Mahony ([email protected])
  13  *             Adrian Hoban <[email protected]>
  14  *             Gabriele Paoloni <[email protected]>
  15  *             Tadeusz Struk ([email protected])
  16  *             Copyright (c) 2010, Intel Corporation.
  17  *
  18  * This program is free software; you can redistribute it and/or modify it
  19  * under the terms of the GNU General Public License as published by the Free
  20  * Software Foundation; either version 2 of the License, or (at your option)
  21  * any later version.
  22  *
  23  */
  24
  25 #include <crypto/hash.h>
  26 #include <linux/err.h>
  27 #include <linux/init.h>
  28 #include <linux/gfp.h>
  29 #include <linux/module.h>
  30 #include <linux/scatterlist.h>
  31 #include <linux/string.h>
  32 #include <linux/moduleparam.h>
  33 #include <linux/jiffies.h>
  34 #include <linux/timex.h>
  35 #include <linux/interrupt.h>
  36 #include "tcrypt.h"
  37 #include "internal.h"
  38
  39 /*
  40  * Need slab memory for testing (size in number of pages).
  41  */
  42 #define TVMEMSIZE       4
  43
  44 /*
  45 * Used by test_cipher_speed()
  46 */
  47 #define ENCRYPT 1
  48 #define DECRYPT 0
  49
  50 /*
  51  * return a string with the driver name
  52  */
  53 #define get_driver_name(tfm_type, tfm) crypto_tfm_alg_driver_name(tfm_type ## _tfm(tfm))
  54
  55 /*
  56  * Used by test_cipher_speed()
  57  */
  58 static unsigned int sec;
  59
  60 static char *alg = NULL;
  61 static u32 type;
  62 static u32 mask;
  63 static int mode;
  64 static char *tvmem[TVMEMSIZE];
  65
  66 static char *check[] = {
  67         "des", "md5", "des3_ede", "rot13", "sha1", "sha224", "sha256",
  68         "blowfish", "twofish", "serpent", "sha384", "sha512", "md4", "aes",
  69         "cast6", "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
  70         "khazad", "wp512", "wp384", "wp256", "tnepres", "xeta",  "fcrypt",
  71         "camellia", "seed", "salsa20", "rmd128", "rmd160", "rmd256", "rmd320",
  72         "lzo", "cts", "zlib", NULL
  73 };
  74
  75 static int test_cipher_jiffies(struct blkcipher_desc *desc, int enc,
  76                                struct scatterlist *sg, int blen, int secs)
  77 {
  78         unsigned long start, end;
  79         int bcount;
  80         int ret;
  81
  82         for (start = jiffies, end = start + secs * HZ, bcount = 0;
  83              time_before(jiffies, end); bcount++) {
  84                 if (enc)
  85                         ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
  86                 else
  87                         ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
  88
  89                 if (ret)
  90                         return ret;
  91         }
  92
  93         printk("%d operations in %d seconds (%ld bytes)\n",
  94                bcount, secs, (long)bcount * blen);
  95         return 0;
  96 }
  97
  98 static int test_cipher_cycles(struct blkcipher_desc *desc, int enc,
  99                               struct scatterlist *sg, int blen)
 100 {
 101         unsigned long cycles = 0;
 102         int ret = 0;
 103         int i;
 104
 105         local_irq_disable();
 106
 107         /* Warm-up run. */
 108         for (i = 0; i < 4; i++) {
 109                 if (enc)
 110                         ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
 111                 else
 112                         ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
 113
 114                 if (ret)
 115                         goto out;
 116         }
 117
 118         /* The real thing. */
 119         for (i = 0; i < 8; i++) {
 120                 cycles_t start, end;
 121
 122                 start = get_cycles();
 123                 if (enc)
 124                         ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
 125                 else
 126                         ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
 127                 end = get_cycles();
 128
 129                 if (ret)
 130                         goto out;
 131
 132                 cycles += end - start;
 133         }
 134
 135 out:
 136         local_irq_enable();
 137
 138         if (ret == 0)
 139                 printk("1 operation in %lu cycles (%d bytes)\n",
 140                        (cycles + 4) / 8, blen);
 141
 142         return ret;
 143 }
 144
 145 static int test_aead_jiffies(struct aead_request *req, int enc,
 146                                 int blen, int secs)
 147 {
 148         unsigned long start, end;
 149         int bcount;
 150         int ret;
 151
 152         for (start = jiffies, end = start + secs * HZ, bcount = 0;
 153              time_before(jiffies, end); bcount++) {
 154                 if (enc)
 155                         ret = crypto_aead_encrypt(req);
 156                 else
 157                         ret = crypto_aead_decrypt(req);
 158
 159                 if (ret)
 160                         return ret;
 161         }
 162
 163         printk("%d operations in %d seconds (%ld bytes)\n",
 164                bcount, secs, (long)bcount * blen);
 165         return 0;
 166 }
 167
 168 static int test_aead_cycles(struct aead_request *req, int enc, int blen)
 169 {
 170         unsigned long cycles = 0;
 171         int ret = 0;
 172         int i;
 173
 174         local_irq_disable();
 175
 176         /* Warm-up run. */
 177         for (i = 0; i < 4; i++) {
 178                 if (enc)
 179                         ret = crypto_aead_encrypt(req);
 180                 else
 181                         ret = crypto_aead_decrypt(req);
 182
 183                 if (ret)
 184                         goto out;
 185         }
 186
 187         /* The real thing. */
 188         for (i = 0; i < 8; i++) {
 189                 cycles_t start, end;
 190
 191                 start = get_cycles();
 192                 if (enc)
 193                         ret = crypto_aead_encrypt(req);
 194                 else
 195                         ret = crypto_aead_decrypt(req);
 196                 end = get_cycles();
 197
 198                 if (ret)
 199                         goto out;
 200
 201                 cycles += end - start;
 202         }
 203
 204 out:
 205         local_irq_enable();
 206
 207         if (ret == 0)
 208                 printk("1 operation in %lu cycles (%d bytes)\n",
 209                        (cycles + 4) / 8, blen);
 210
 211         return ret;
 212 }
 213
 214 static u32 block_sizes[] = { 16, 64, 256, 1024, 8192, 0 };
 215 static u32 aead_sizes[] = { 16, 64, 256, 512, 1024, 2048, 4096, 8192, 0 };
 216
 217 #define XBUFSIZE 8
 218 #define MAX_IVLEN 32
 219
 220 static int testmgr_alloc_buf(char *buf[XBUFSIZE])
 221 {
 222         int i;
 223
 224         for (i = 0; i < XBUFSIZE; i++) {
 225                 buf[i] = (void *)__get_free_page(GFP_KERNEL);
 226                 if (!buf[i])
 227                         goto err_free_buf;
 228         }
 229
 230         return 0;
 231
 232 err_free_buf:
 233         while (i-- > 0)
 234                 free_page((unsigned long)buf[i]);
 235
 236         return -ENOMEM;
 237 }
 238
 239 static void testmgr_free_buf(char *buf[XBUFSIZE])
 240 {
 241         int i;
 242
 243         for (i = 0; i < XBUFSIZE; i++)
 244                 free_page((unsigned long)buf[i]);
 245 }
 246
 247 static void sg_init_aead(struct scatterlist *sg, char *xbuf[XBUFSIZE],
 248                         unsigned int buflen)
 249 {
 250         int np = (buflen + PAGE_SIZE - 1)/PAGE_SIZE;
 251         int k, rem;
 252
 253         np = (np > XBUFSIZE) ? XBUFSIZE : np;
 254         rem = buflen % PAGE_SIZE;
 255         if (np > XBUFSIZE) {
 256                 rem = PAGE_SIZE;
 257                 np = XBUFSIZE;
 258         }
 259         sg_init_table(sg, np);
 260         for (k = 0; k < np; ++k) {
 261                 if (k == (np-1))
 262                         sg_set_buf(&sg[k], xbuf[k], rem);
 263                 else
 264                         sg_set_buf(&sg[k], xbuf[k], PAGE_SIZE);
 265         }
 266 }
 267
 268 static void test_aead_speed(const char *algo, int enc, unsigned int secs,
 269                             struct aead_speed_template *template,
 270                             unsigned int tcount, u8 authsize,
 271                             unsigned int aad_size, u8 *keysize)
 272 {
 273         unsigned int i, j;
 274         struct crypto_aead *tfm;
 275         int ret = -ENOMEM;
 276         const char *key;
 277         struct aead_request *req;
 278         struct scatterlist *sg;
 279         struct scatterlist *asg;
 280         struct scatterlist *sgout;
 281         const char *e;
 282         void *assoc;
 283         char iv[MAX_IVLEN];
 284         char *xbuf[XBUFSIZE];
 285         char *xoutbuf[XBUFSIZE];
 286         char *axbuf[XBUFSIZE];
 287         unsigned int *b_size;
 288         unsigned int iv_len;
 289
 290         if (aad_size >= PAGE_SIZE) {
 291                 pr_err("associate data length (%u) too big\n", aad_size);
 292                 return;
 293         }
 294
 295         if (enc == ENCRYPT)
 296                 e = "encryption";
 297         else
 298                 e = "decryption";
 299
 300         if (testmgr_alloc_buf(xbuf))
 301                 goto out_noxbuf;
 302         if (testmgr_alloc_buf(axbuf))
 303                 goto out_noaxbuf;
 304         if (testmgr_alloc_buf(xoutbuf))
 305                 goto out_nooutbuf;
 306
 307         sg = kmalloc(sizeof(*sg) * 8 * 3, GFP_KERNEL);
 308         if (!sg)
 309                 goto out_nosg;
 310         asg = &sg[8];
 311         sgout = &asg[8];
 312
 313         tfm = crypto_alloc_aead(algo, 0, 0);
 314
 315         if (IS_ERR(tfm)) {
 316                 pr_err("alg: aead: Failed to load transform for %s: %ld\n", algo,
 317                        PTR_ERR(tfm));
 318                 goto out_notfm;
 319         }
 320
 321         printk(KERN_INFO "\ntesting speed of %s (%s) %s\n", algo,
 322                         get_driver_name(crypto_aead, tfm), e);
 323
 324         req = aead_request_alloc(tfm, GFP_KERNEL);
 325         if (!req) {
 326                 pr_err("alg: aead: Failed to allocate request for %s\n",
 327                        algo);
 328                 goto out_noreq;
 329         }
 330
 331         i = 0;
 332         do {
 333                 b_size = aead_sizes;
 334                 do {
 335                         assoc = axbuf[0];
 336                         memset(assoc, 0xff, aad_size);
 337                         sg_init_one(&asg[0], assoc, aad_size);
 338
 339                         if ((*keysize + *b_size) > TVMEMSIZE * PAGE_SIZE) {
 340                                 pr_err("template (%u) too big for tvmem (%lu)\n",
 341                                        *keysize + *b_size,
 342                                         TVMEMSIZE * PAGE_SIZE);
 343                                 goto out;
 344                         }
 345
 346                         key = tvmem[0];
 347                         for (j = 0; j < tcount; j++) {
 348                                 if (template[j].klen == *keysize) {
 349                                         key = template[j].key;
 350                                         break;
 351                                 }
 352                         }
 353                         ret = crypto_aead_setkey(tfm, key, *keysize);
 354                         ret = crypto_aead_setauthsize(tfm, authsize);
 355
 356                         iv_len = crypto_aead_ivsize(tfm);
 357                         if (iv_len)
 358                                 memset(&iv, 0xff, iv_len);
 359
 360                         crypto_aead_clear_flags(tfm, ~0);
 361                         printk(KERN_INFO "test %u (%d bit key, %d byte blocks): ",
 362                                         i, *keysize * 8, *b_size);
 363
 364
 365                         memset(tvmem[0], 0xff, PAGE_SIZE);
 366
 367                         if (ret) {
 368                                 pr_err("setkey() failed flags=%x\n",
 369                                                 crypto_aead_get_flags(tfm));
 370                                 goto out;
 371                         }
 372
 373                         sg_init_aead(&sg[0], xbuf,
 374                                     *b_size + (enc ? authsize : 0));
 375
 376                         sg_init_aead(&sgout[0], xoutbuf,
 377                                     *b_size + (enc ? authsize : 0));
 378
 379                         aead_request_set_crypt(req, sg, sgout, *b_size, iv);
 380                         aead_request_set_assoc(req, asg, aad_size);
 381
 382                         if (secs)
 383                                 ret = test_aead_jiffies(req, enc, *b_size,
 384                                                         secs);
 385                         else
 386                                 ret = test_aead_cycles(req, enc, *b_size);
 387
 388                         if (ret) {
 389                                 pr_err("%s() failed return code=%d\n", e, ret);
 390                                 break;
 391                         }
 392                         b_size++;
 393                         i++;
 394                 } while (*b_size);
 395                 keysize++;
 396         } while (*keysize);
 397
 398 out:
 399         aead_request_free(req);
 400 out_noreq:
 401         crypto_free_aead(tfm);
 402 out_notfm:
 403         kfree(sg);
 404 out_nosg:
 405         testmgr_free_buf(xoutbuf);
 406 out_nooutbuf:
 407         testmgr_free_buf(axbuf);
 408 out_noaxbuf:
 409         testmgr_free_buf(xbuf);
 410 out_noxbuf:
 411         return;
 412 }
 413
 414 static void test_cipher_speed(const char *algo, int enc, unsigned int secs,
 415                               struct cipher_speed_template *template,
 416                               unsigned int tcount, u8 *keysize)
 417 {
 418         unsigned int ret, i, j, iv_len;
 419         const char *key;
 420         char iv[128];
 421         struct crypto_blkcipher *tfm;
 422         struct blkcipher_desc desc;
 423         const char *e;
 424         u32 *b_size;
 425
 426         if (enc == ENCRYPT)
 427                 e = "encryption";
 428         else
 429                 e = "decryption";
 430
 431         tfm = crypto_alloc_blkcipher(algo, 0, CRYPTO_ALG_ASYNC);
 432
 433         if (IS_ERR(tfm)) {
 434                 printk("failed to load transform for %s: %ld\n", algo,
 435                        PTR_ERR(tfm));
 436                 return;
 437         }
 438         desc.tfm = tfm;
 439         desc.flags = 0;
 440
 441         printk(KERN_INFO "\ntesting speed of %s (%s) %s\n", algo,
 442                         get_driver_name(crypto_blkcipher, tfm), e);
 443
 444         i = 0;
 445         do {
 446
 447                 b_size = block_sizes;
 448                 do {
 449                         struct scatterlist sg[TVMEMSIZE];
 450
 451                         if ((*keysize + *b_size) > TVMEMSIZE * PAGE_SIZE) {
 452                                 printk("template (%u) too big for "
 453                                        "tvmem (%lu)\n", *keysize + *b_size,
 454                                        TVMEMSIZE * PAGE_SIZE);
 455                                 goto out;
 456                         }
 457
 458                         printk("test %u (%d bit key, %d byte blocks): ", i,
 459                                         *keysize * 8, *b_size);
 460
 461                         memset(tvmem[0], 0xff, PAGE_SIZE);
 462
 463                         /* set key, plain text and IV */
 464                         key = tvmem[0];
 465                         for (j = 0; j < tcount; j++) {
 466                                 if (template[j].klen == *keysize) {
 467                                         key = template[j].key;
 468                                         break;
 469                                 }
 470                         }
 471
 472                         ret = crypto_blkcipher_setkey(tfm, key, *keysize);
 473                         if (ret) {
 474                                 printk("setkey() failed flags=%x\n",
 475                                                 crypto_blkcipher_get_flags(tfm));
 476                                 goto out;
 477                         }
 478
 479                         sg_init_table(sg, TVMEMSIZE);
 480                         sg_set_buf(sg, tvmem[0] + *keysize,
 481                                    PAGE_SIZE - *keysize);
 482                         for (j = 1; j < TVMEMSIZE; j++) {
 483                                 sg_set_buf(sg + j, tvmem[j], PAGE_SIZE);
 484                                 memset (tvmem[j], 0xff, PAGE_SIZE);
 485                         }
 486
 487                         iv_len = crypto_blkcipher_ivsize(tfm);
 488                         if (iv_len) {
 489                                 memset(&iv, 0xff, iv_len);
 490                                 crypto_blkcipher_set_iv(tfm, iv, iv_len);
 491                         }
 492
 493                         if (secs)
 494                                 ret = test_cipher_jiffies(&desc, enc, sg,
 495                                                           *b_size, secs);
 496                         else
 497                                 ret = test_cipher_cycles(&desc, enc, sg,
 498                                                          *b_size);
 499
 500                         if (ret) {
 501                                 printk("%s() failed flags=%x\n", e, desc.flags);
 502                                 break;
 503                         }
 504                         b_size++;
 505                         i++;
 506                 } while (*b_size);
 507                 keysize++;
 508         } while (*keysize);
 509
 510 out:
 511         crypto_free_blkcipher(tfm);
 512 }
 513
 514 static int test_hash_jiffies_digest(struct hash_desc *desc,
 515                                     struct scatterlist *sg, int blen,
 516                                     char *out, int secs)
 517 {
 518         unsigned long start, end;
 519         int bcount;
 520         int ret;
 521
 522         for (start = jiffies, end = start + secs * HZ, bcount = 0;
 523              time_before(jiffies, end); bcount++) {
 524                 ret = crypto_hash_digest(desc, sg, blen, out);
 525                 if (ret)
 526                         return ret;
 527         }
 528
 529         printk("%6u opers/sec, %9lu bytes/sec\n",
 530                bcount / secs, ((long)bcount * blen) / secs);
 531
 532         return 0;
 533 }
 534
 535 static int test_hash_jiffies(struct hash_desc *desc, struct scatterlist *sg,
 536                              int blen, int plen, char *out, int secs)
 537 {
 538         unsigned long start, end;
 539         int bcount, pcount;
 540         int ret;
 541
 542         if (plen == blen)
 543                 return test_hash_jiffies_digest(desc, sg, blen, out, secs);
 544
 545         for (start = jiffies, end = start + secs * HZ, bcount = 0;
 546              time_before(jiffies, end); bcount++) {
 547                 ret = crypto_hash_init(desc);
 548                 if (ret)
 549                         return ret;
 550                 for (pcount = 0; pcount < blen; pcount += plen) {
 551                         ret = crypto_hash_update(desc, sg, plen);
 552                         if (ret)
 553                                 return ret;
 554                 }
 555                 /* we assume there is enough space in 'out' for the result */
 556                 ret = crypto_hash_final(desc, out);
 557                 if (ret)
 558                         return ret;
 559         }
 560
 561         printk("%6u opers/sec, %9lu bytes/sec\n",
 562                bcount / secs, ((long)bcount * blen) / secs);
 563
 564         return 0;
 565 }
 566
 567 static int test_hash_cycles_digest(struct hash_desc *desc,
 568                                    struct scatterlist *sg, int blen, char *out)
 569 {
 570         unsigned long cycles = 0;
 571         int i;
 572         int ret;
 573
 574         local_irq_disable();
 575
 576         /* Warm-up run. */
 577         for (i = 0; i < 4; i++) {
 578                 ret = crypto_hash_digest(desc, sg, blen, out);
 579                 if (ret)
 580                         goto out;
 581         }
 582
 583         /* The real thing. */
 584         for (i = 0; i < 8; i++) {
 585                 cycles_t start, end;
 586
 587                 start = get_cycles();
 588
 589                 ret = crypto_hash_digest(desc, sg, blen, out);
 590                 if (ret)
 591                         goto out;
 592
 593                 end = get_cycles();
 594
 595                 cycles += end - start;
 596         }
 597
 598 out:
 599         local_irq_enable();
 600
 601         if (ret)
 602                 return ret;
 603
 604         printk("%6lu cycles/operation, %4lu cycles/byte\n",
 605                cycles / 8, cycles / (8 * blen));
 606
 607         return 0;
 608 }
 609
 610 static int test_hash_cycles(struct hash_desc *desc, struct scatterlist *sg,
 611                             int blen, int plen, char *out)
 612 {
 613         unsigned long cycles = 0;
 614         int i, pcount;
 615         int ret;
 616
 617         if (plen == blen)
 618                 return test_hash_cycles_digest(desc, sg, blen, out);
 619
 620         local_irq_disable();
 621
 622         /* Warm-up run. */
 623         for (i = 0; i < 4; i++) {
 624                 ret = crypto_hash_init(desc);
 625                 if (ret)
 626                         goto out;
 627                 for (pcount = 0; pcount < blen; pcount += plen) {
 628                         ret = crypto_hash_update(desc, sg, plen);
 629                         if (ret)
 630                                 goto out;
 631                 }
 632                 ret = crypto_hash_final(desc, out);
 633                 if (ret)
 634                         goto out;
 635         }
 636
 637         /* The real thing. */
 638         for (i = 0; i < 8; i++) {
 639                 cycles_t start, end;
 640
 641                 start = get_cycles();
 642
 643                 ret = crypto_hash_init(desc);
 644                 if (ret)
 645                         goto out;
 646                 for (pcount = 0; pcount < blen; pcount += plen) {
 647                         ret = crypto_hash_update(desc, sg, plen);
 648                         if (ret)
 649                                 goto out;
 650                 }
 651                 ret = crypto_hash_final(desc, out);
 652                 if (ret)
 653                         goto out;
 654
 655                 end = get_cycles();
 656
 657                 cycles += end - start;
 658         }
 659
 660 out:
 661         local_irq_enable();
 662
 663         if (ret)
 664                 return ret;
 665
 666         printk("%6lu cycles/operation, %4lu cycles/byte\n",
 667                cycles / 8, cycles / (8 * blen));
 668
 669         return 0;
 670 }
 671
 672 static void test_hash_sg_init(struct scatterlist *sg)
 673 {
 674         int i;
 675
 676         sg_init_table(sg, TVMEMSIZE);
 677         for (i = 0; i < TVMEMSIZE; i++) {
 678                 sg_set_buf(sg + i, tvmem[i], PAGE_SIZE);
 679                 memset(tvmem[i], 0xff, PAGE_SIZE);
 680         }
 681 }
 682
 683 static void test_hash_speed(const char *algo, unsigned int secs,
 684                             struct hash_speed *speed)
 685 {
 686         struct scatterlist sg[TVMEMSIZE];
 687         struct crypto_hash *tfm;
 688         struct hash_desc desc;
 689         static char output[1024];
 690         int i;
 691         int ret;
 692
 693         tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC);
 694
 695         if (IS_ERR(tfm)) {
 696                 printk(KERN_ERR "failed to load transform for %s: %ld\n", algo,
 697                        PTR_ERR(tfm));
 698                 return;
 699         }
 700
 701         printk(KERN_INFO "\ntesting speed of %s (%s)\n", algo,
 702                         get_driver_name(crypto_hash, tfm));
 703
 704         desc.tfm = tfm;
 705         desc.flags = 0;
 706
 707         if (crypto_hash_digestsize(tfm) > sizeof(output)) {
 708                 printk(KERN_ERR "digestsize(%u) > outputbuffer(%zu)\n",
 709                        crypto_hash_digestsize(tfm), sizeof(output));
 710                 goto out;
 711         }
 712
 713         test_hash_sg_init(sg);
 714         for (i = 0; speed[i].blen != 0; i++) {
 715                 if (speed[i].blen > TVMEMSIZE * PAGE_SIZE) {
 716                         printk(KERN_ERR
 717                                "template (%u) too big for tvmem (%lu)\n",
 718                                speed[i].blen, TVMEMSIZE * PAGE_SIZE);
 719                         goto out;
 720                 }
 721
 722                 if (speed[i].klen)
 723                         crypto_hash_setkey(tfm, tvmem[0], speed[i].klen);
 724
 725                 printk(KERN_INFO "test%3u "
 726                        "(%5u byte blocks,%5u bytes per update,%4u updates): ",
 727                        i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
 728
 729                 if (secs)
 730                         ret = test_hash_jiffies(&desc, sg, speed[i].blen,
 731                                                 speed[i].plen, output, secs);
 732                 else
 733                         ret = test_hash_cycles(&desc, sg, speed[i].blen,
 734                                                speed[i].plen, output);
 735
 736                 if (ret) {
 737                         printk(KERN_ERR "hashing failed ret=%d\n", ret);
 738                         break;
 739                 }
 740         }
 741
 742 out:
 743         crypto_free_hash(tfm);
 744 }
 745
 746 struct tcrypt_result {
 747         struct completion completion;
 748         int err;
 749 };
 750
 751 static void tcrypt_complete(struct crypto_async_request *req, int err)
 752 {
 753         struct tcrypt_result *res = req->data;
 754
 755         if (err == -EINPROGRESS)
 756                 return;
 757
 758         res->err = err;
 759         complete(&res->completion);
 760 }
 761
 762 static inline int do_one_ahash_op(struct ahash_request *req, int ret)
 763 {
 764         if (ret == -EINPROGRESS || ret == -EBUSY) {
 765                 struct tcrypt_result *tr = req->base.data;
 766
 767                 ret = wait_for_completion_interruptible(&tr->completion);
 768                 if (!ret)
 769                         ret = tr->err;
 770                 reinit_completion(&tr->completion);
 771         }
 772         return ret;
 773 }
 774
 775 static int test_ahash_jiffies_digest(struct ahash_request *req, int blen,
 776                                      char *out, int secs)
 777 {
 778         unsigned long start, end;
 779         int bcount;
 780         int ret;
 781
 782         for (start = jiffies, end = start + secs * HZ, bcount = 0;
 783              time_before(jiffies, end); bcount++) {
 784                 ret = do_one_ahash_op(req, crypto_ahash_digest(req));
 785                 if (ret)
 786                         return ret;
 787         }
 788
 789         printk("%6u opers/sec, %9lu bytes/sec\n",
 790                bcount / secs, ((long)bcount * blen) / secs);
 791
 792         return 0;
 793 }
 794
 795 static int test_ahash_jiffies(struct ahash_request *req, int blen,
 796                               int plen, char *out, int secs)
 797 {
 798         unsigned long start, end;
 799         int bcount, pcount;
 800         int ret;
 801
 802         if (plen == blen)
 803                 return test_ahash_jiffies_digest(req, blen, out, secs);
 804
 805         for (start = jiffies, end = start + secs * HZ, bcount = 0;
 806              time_before(jiffies, end); bcount++) {
 807                 ret = crypto_ahash_init(req);
 808                 if (ret)
 809                         return ret;
 810                 for (pcount = 0; pcount < blen; pcount += plen) {
 811                         ret = do_one_ahash_op(req, crypto_ahash_update(req));
 812                         if (ret)
 813                                 return ret;
 814                 }
 815                 /* we assume there is enough space in 'out' for the result */
 816                 ret = do_one_ahash_op(req, crypto_ahash_final(req));
 817                 if (ret)
 818                         return ret;
 819         }
 820
 821         pr_cont("%6u opers/sec, %9lu bytes/sec\n",
 822                 bcount / secs, ((long)bcount * blen) / secs);
 823
 824         return 0;
 825 }
 826
 827 static int test_ahash_cycles_digest(struct ahash_request *req, int blen,
 828                                     char *out)
 829 {
 830         unsigned long cycles = 0;
 831         int ret, i;
 832
 833         /* Warm-up run. */
 834         for (i = 0; i < 4; i++) {
 835                 ret = do_one_ahash_op(req, crypto_ahash_digest(req));
 836                 if (ret)
 837                         goto out;
 838         }
 839
 840         /* The real thing. */
 841         for (i = 0; i < 8; i++) {
 842                 cycles_t start, end;
 843
 844                 start = get_cycles();
 845
 846                 ret = do_one_ahash_op(req, crypto_ahash_digest(req));
 847                 if (ret)
 848                         goto out;
 849
 850                 end = get_cycles();
 851
 852                 cycles += end - start;
 853         }
 854
 855 out:
 856         if (ret)
 857                 return ret;
 858
 859         pr_cont("%6lu cycles/operation, %4lu cycles/byte\n",
 860                 cycles / 8, cycles / (8 * blen));
 861
 862         return 0;
 863 }
 864
 865 static int test_ahash_cycles(struct ahash_request *req, int blen,
 866                              int plen, char *out)
 867 {
 868         unsigned long cycles = 0;
 869         int i, pcount, ret;
 870
 871         if (plen == blen)
 872                 return test_ahash_cycles_digest(req, blen, out);
 873
 874         /* Warm-up run. */
 875         for (i = 0; i < 4; i++) {
 876                 ret = crypto_ahash_init(req);
 877                 if (ret)
 878                         goto out;
 879                 for (pcount = 0; pcount < blen; pcount += plen) {
 880                         ret = do_one_ahash_op(req, crypto_ahash_update(req));
 881                         if (ret)
 882                                 goto out;
 883                 }
 884                 ret = do_one_ahash_op(req, crypto_ahash_final(req));
 885                 if (ret)
 886                         goto out;
 887         }
 888
 889         /* The real thing. */
 890         for (i = 0; i < 8; i++) {
 891                 cycles_t start, end;
 892
 893                 start = get_cycles();
 894
 895                 ret = crypto_ahash_init(req);
 896                 if (ret)
 897                         goto out;
 898                 for (pcount = 0; pcount < blen; pcount += plen) {
 899                         ret = do_one_ahash_op(req, crypto_ahash_update(req));
 900                         if (ret)
 901                                 goto out;
 902                 }
 903                 ret = do_one_ahash_op(req, crypto_ahash_final(req));
 904                 if (ret)
 905                         goto out;
 906
 907                 end = get_cycles();
 908
 909                 cycles += end - start;
 910         }
 911
 912 out:
 913         if (ret)
 914                 return ret;
 915
 916         pr_cont("%6lu cycles/operation, %4lu cycles/byte\n",
 917                 cycles / 8, cycles / (8 * blen));
 918
 919         return 0;
 920 }
 921
 922 static void test_ahash_speed(const char *algo, unsigned int secs,
 923                              struct hash_speed *speed)
 924 {
 925         struct scatterlist sg[TVMEMSIZE];
 926         struct tcrypt_result tresult;
 927         struct ahash_request *req;
 928         struct crypto_ahash *tfm;
 929         static char output[1024];
 930         int i, ret;
 931
 932         tfm = crypto_alloc_ahash(algo, 0, 0);
 933         if (IS_ERR(tfm)) {
 934                 pr_err("failed to load transform for %s: %ld\n",
 935                        algo, PTR_ERR(tfm));
 936                 return;
 937         }
 938
 939         printk(KERN_INFO "\ntesting speed of async %s (%s)\n", algo,
 940                         get_driver_name(crypto_ahash, tfm));
 941
 942         if (crypto_ahash_digestsize(tfm) > sizeof(output)) {
 943                 pr_err("digestsize(%u) > outputbuffer(%zu)\n",
 944                        crypto_ahash_digestsize(tfm), sizeof(output));
 945                 goto out;
 946         }
 947
 948         test_hash_sg_init(sg);
 949         req = ahash_request_alloc(tfm, GFP_KERNEL);
 950         if (!req) {
 951                 pr_err("ahash request allocation failure\n");
 952                 goto out;
 953         }
 954
 955         init_completion(&tresult.completion);
 956         ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
 957                                    tcrypt_complete, &tresult);
 958
 959         for (i = 0; speed[i].blen != 0; i++) {
 960                 if (speed[i].blen > TVMEMSIZE * PAGE_SIZE) {
 961                         pr_err("template (%u) too big for tvmem (%lu)\n",
 962                                speed[i].blen, TVMEMSIZE * PAGE_SIZE);
 963                         break;
 964                 }
 965
 966                 pr_info("test%3u "
 967                         "(%5u byte blocks,%5u bytes per update,%4u updates): ",
 968                         i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
 969
 970                 ahash_request_set_crypt(req, sg, output, speed[i].plen);
 971
 972                 if (secs)
 973                         ret = test_ahash_jiffies(req, speed[i].blen,
 974                                                  speed[i].plen, output, secs);
 975                 else
 976                         ret = test_ahash_cycles(req, speed[i].blen,
 977                                                 speed[i].plen, output);
 978
 979                 if (ret) {
 980                         pr_err("hashing failed ret=%d\n", ret);
 981                         break;
 982                 }
 983         }
 984
 985         ahash_request_free(req);
 986
 987 out:
 988         crypto_free_ahash(tfm);
 989 }
 990
 991 static inline int do_one_acipher_op(struct ablkcipher_request *req, int ret)
 992 {
 993         if (ret == -EINPROGRESS || ret == -EBUSY) {
 994                 struct tcrypt_result *tr = req->base.data;
 995
 996                 ret = wait_for_completion_interruptible(&tr->completion);
 997                 if (!ret)
 998                         ret = tr->err;
 999                 reinit_completion(&tr->completion);
1000         }
1001
1002         return ret;
1003 }
1004
1005 static int test_acipher_jiffies(struct ablkcipher_request *req, int enc,
1006                                 int blen, int secs)
1007 {
1008         unsigned long start, end;
1009         int bcount;
1010         int ret;
1011
1012         for (start = jiffies, end = start + secs * HZ, bcount = 0;
1013              time_before(jiffies, end); bcount++) {
1014                 if (enc)
1015                         ret = do_one_acipher_op(req,
1016                                                 crypto_ablkcipher_encrypt(req));
1017                 else
1018                         ret = do_one_acipher_op(req,
1019                                                 crypto_ablkcipher_decrypt(req));
1020
1021                 if (ret)
1022                         return ret;
1023         }
1024
1025         pr_cont("%d operations in %d seconds (%ld bytes)\n",
1026                 bcount, secs, (long)bcount * blen);
1027         return 0;
1028 }
1029
1030 static int test_acipher_cycles(struct ablkcipher_request *req, int enc,
1031                                int blen)
1032 {
1033         unsigned long cycles = 0;
1034         int ret = 0;
1035         int i;
1036
1037         /* Warm-up run. */
1038         for (i = 0; i < 4; i++) {
1039                 if (enc)
1040                         ret = do_one_acipher_op(req,
1041                                                 crypto_ablkcipher_encrypt(req));
1042                 else
1043                         ret = do_one_acipher_op(req,
1044                                                 crypto_ablkcipher_decrypt(req));
1045
1046                 if (ret)
1047                         goto out;
1048         }
1049
1050         /* The real thing. */
1051         for (i = 0; i < 8; i++) {
1052                 cycles_t start, end;
1053
1054                 start = get_cycles();
1055                 if (enc)
1056                         ret = do_one_acipher_op(req,
1057                                                 crypto_ablkcipher_encrypt(req));
1058                 else
1059                         ret = do_one_acipher_op(req,
1060                                                 crypto_ablkcipher_decrypt(req));
1061                 end = get_cycles();
1062
1063                 if (ret)
1064                         goto out;
1065
1066                 cycles += end - start;
1067         }
1068
1069 out:
1070         if (ret == 0)
1071                 pr_cont("1 operation in %lu cycles (%d bytes)\n",
1072                         (cycles + 4) / 8, blen);
1073
1074         return ret;
1075 }
1076
1077 static void test_acipher_speed(const char *algo, int enc, unsigned int secs,
1078                                struct cipher_speed_template *template,
1079                                unsigned int tcount, u8 *keysize)
1080 {
1081         unsigned int ret, i, j, k, iv_len;
1082         struct tcrypt_result tresult;
1083         const char *key;
1084         char iv[128];
1085         struct ablkcipher_request *req;
1086         struct crypto_ablkcipher *tfm;
1087         const char *e;
1088         u32 *b_size;
1089
1090         if (enc == ENCRYPT)
1091                 e = "encryption";
1092         else
1093                 e = "decryption";
1094
1095         init_completion(&tresult.completion);
1096
1097         tfm = crypto_alloc_ablkcipher(algo, 0, 0);
1098
1099         if (IS_ERR(tfm)) {
1100                 pr_err("failed to load transform for %s: %ld\n", algo,
1101                        PTR_ERR(tfm));
1102                 return;
1103         }
1104
1105         pr_info("\ntesting speed of async %s (%s) %s\n", algo,
1106                         get_driver_name(crypto_ablkcipher, tfm), e);
1107
1108         req = ablkcipher_request_alloc(tfm, GFP_KERNEL);
1109         if (!req) {
1110                 pr_err("tcrypt: skcipher: Failed to allocate request for %s\n",
1111                        algo);
1112                 goto out;
1113         }
1114
1115         ablkcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
1116                                         tcrypt_complete, &tresult);
1117
1118         i = 0;
1119         do {
1120                 b_size = block_sizes;
1121
1122                 do {
1123                         struct scatterlist sg[TVMEMSIZE];
1124
1125                         if ((*keysize + *b_size) > TVMEMSIZE * PAGE_SIZE) {
1126                                 pr_err("template (%u) too big for "
1127                                        "tvmem (%lu)\n", *keysize + *b_size,
1128                                        TVMEMSIZE * PAGE_SIZE);
1129                                 goto out_free_req;
1130                         }
1131
1132                         pr_info("test %u (%d bit key, %d byte blocks): ", i,
1133                                 *keysize * 8, *b_size);
1134
1135                         memset(tvmem[0], 0xff, PAGE_SIZE);
1136
1137                         /* set key, plain text and IV */
1138                         key = tvmem[0];
1139                         for (j = 0; j < tcount; j++) {
1140                                 if (template[j].klen == *keysize) {
1141                                         key = template[j].key;
1142                                         break;
1143                                 }
1144                         }
1145
1146                         crypto_ablkcipher_clear_flags(tfm, ~0);
1147
1148                         ret = crypto_ablkcipher_setkey(tfm, key, *keysize);
1149                         if (ret) {
1150                                 pr_err("setkey() failed flags=%x\n",
1151                                         crypto_ablkcipher_get_flags(tfm));
1152                                 goto out_free_req;
1153                         }
1154
1155                         sg_init_table(sg, TVMEMSIZE);
1156
1157                         k = *keysize + *b_size;
1158                         if (k > PAGE_SIZE) {
1159                                 sg_set_buf(sg, tvmem[0] + *keysize,
1160                                    PAGE_SIZE - *keysize);
1161                                 k -= PAGE_SIZE;
1162                                 j = 1;
1163                                 while (k > PAGE_SIZE) {
1164                                         sg_set_buf(sg + j, tvmem[j], PAGE_SIZE);
1165                                         memset(tvmem[j], 0xff, PAGE_SIZE);
1166                                         j++;
1167                                         k -= PAGE_SIZE;
1168                                 }
1169                                 sg_set_buf(sg + j, tvmem[j], k);
1170                                 memset(tvmem[j], 0xff, k);
1171                         } else {
1172                                 sg_set_buf(sg, tvmem[0] + *keysize, *b_size);
1173                         }
1174
1175                         iv_len = crypto_ablkcipher_ivsize(tfm);
1176                         if (iv_len)
1177                                 memset(&iv, 0xff, iv_len);
1178
1179                         ablkcipher_request_set_crypt(req, sg, sg, *b_size, iv);
1180
1181                         if (secs)
1182                                 ret = test_acipher_jiffies(req, enc,
1183                                                            *b_size, secs);
1184                         else
1185                                 ret = test_acipher_cycles(req, enc,
1186                                                           *b_size);
1187
1188                         if (ret) {
1189                                 pr_err("%s() failed flags=%x\n", e,
1190                                         crypto_ablkcipher_get_flags(tfm));
1191                                 break;
1192                         }
1193                         b_size++;
1194                         i++;
1195                 } while (*b_size);
1196                 keysize++;
1197         } while (*keysize);
1198
1199 out_free_req:
1200         ablkcipher_request_free(req);
1201 out:
1202         crypto_free_ablkcipher(tfm);
1203 }
1204
1205 static void test_available(void)
1206 {
1207         char **name = check;
1208
1209         while (*name) {
1210                 printk("alg %s ", *name);
1211                 printk(crypto_has_alg(*name, 0, 0) ?
1212                        "found\n" : "not found\n");
1213                 name++;
1214         }
1215 }
1216
1217 static inline int tcrypt_test(const char *alg)
1218 {
1219         int ret;
1220
1221         ret = alg_test(alg, alg, 0, 0);
1222         /* non-fips algs return -EINVAL in fips mode */
1223         if (fips_enabled && ret == -EINVAL)
1224                 ret = 0;
1225         return ret;
1226 }
1227
1228 static int do_test(int m)
1229 {
1230         int i;
1231         int ret = 0;
1232
1233         switch (m) {
1234         case 0:
1235                 for (i = 1; i < 200; i++)
1236                         ret += do_test(i);
1237                 break;
1238
1239         case 1:
1240                 ret += tcrypt_test("md5");
1241                 break;
1242
1243         case 2:
1244                 ret += tcrypt_test("sha1");
1245                 break;
1246
1247         case 3:
1248                 ret += tcrypt_test("ecb(des)");
1249                 ret += tcrypt_test("cbc(des)");
1250                 ret += tcrypt_test("ctr(des)");
1251                 break;
1252
1253         case 4:
1254                 ret += tcrypt_test("ecb(des3_ede)");
1255                 ret += tcrypt_test("cbc(des3_ede)");
1256                 ret += tcrypt_test("ctr(des3_ede)");
1257                 break;
1258
1259         case 5:
1260                 ret += tcrypt_test("md4");
1261                 break;
1262
1263         case 6:
1264                 ret += tcrypt_test("sha256");
1265                 break;
1266
1267         case 7:
1268                 ret += tcrypt_test("ecb(blowfish)");
1269                 ret += tcrypt_test("cbc(blowfish)");
1270                 ret += tcrypt_test("ctr(blowfish)");
1271                 break;
1272
1273         case 8:
1274                 ret += tcrypt_test("ecb(twofish)");
1275                 ret += tcrypt_test("cbc(twofish)");
1276                 ret += tcrypt_test("ctr(twofish)");
1277                 ret += tcrypt_test("lrw(twofish)");
1278                 ret += tcrypt_test("xts(twofish)");
1279                 break;
1280
1281         case 9:
1282                 ret += tcrypt_test("ecb(serpent)");
1283                 ret += tcrypt_test("cbc(serpent)");
1284                 ret += tcrypt_test("ctr(serpent)");
1285                 ret += tcrypt_test("lrw(serpent)");
1286                 ret += tcrypt_test("xts(serpent)");
1287                 break;
1288
1289         case 10:
1290                 ret += tcrypt_test("ecb(aes)");
1291                 ret += tcrypt_test("cbc(aes)");
1292                 ret += tcrypt_test("lrw(aes)");
1293                 ret += tcrypt_test("xts(aes)");
1294                 ret += tcrypt_test("ctr(aes)");
1295                 ret += tcrypt_test("rfc3686(ctr(aes))");
1296                 break;
1297
1298         case 11:
1299                 ret += tcrypt_test("sha384");
1300                 break;
1301
1302         case 12:
1303                 ret += tcrypt_test("sha512");
1304                 break;
1305
1306         case 13:
1307                 ret += tcrypt_test("deflate");
1308                 break;
1309
1310         case 14:
1311                 ret += tcrypt_test("ecb(cast5)");
1312                 ret += tcrypt_test("cbc(cast5)");
1313                 ret += tcrypt_test("ctr(cast5)");
1314                 break;
1315
1316         case 15:
1317                 ret += tcrypt_test("ecb(cast6)");
1318                 ret += tcrypt_test("cbc(cast6)");
1319                 ret += tcrypt_test("ctr(cast6)");
1320                 ret += tcrypt_test("lrw(cast6)");
1321                 ret += tcrypt_test("xts(cast6)");
1322                 break;
1323
1324         case 16:
1325                 ret += tcrypt_test("ecb(arc4)");
1326                 break;
1327
1328         case 17:
1329                 ret += tcrypt_test("michael_mic");
1330                 break;
1331
1332         case 18:
1333                 ret += tcrypt_test("crc32c");
1334                 break;
1335
1336         case 19:
1337                 ret += tcrypt_test("ecb(tea)");
1338                 break;
1339
1340         case 20:
1341                 ret += tcrypt_test("ecb(xtea)");
1342                 break;
1343
1344         case 21:
1345                 ret += tcrypt_test("ecb(khazad)");
1346                 break;
1347
1348         case 22:
1349                 ret += tcrypt_test("wp512");
1350                 break;
1351
1352         case 23:
1353                 ret += tcrypt_test("wp384");
1354                 break;
1355
1356         case 24:
1357                 ret += tcrypt_test("wp256");
1358                 break;
1359
1360         case 25:
1361                 ret += tcrypt_test("ecb(tnepres)");
1362                 break;
1363
1364         case 26:
1365                 ret += tcrypt_test("ecb(anubis)");
1366                 ret += tcrypt_test("cbc(anubis)");
1367                 break;
1368
1369         case 27:
1370                 ret += tcrypt_test("tgr192");
1371                 break;
1372
1373         case 28:
1374                 ret += tcrypt_test("tgr160");
1375                 break;
1376
1377         case 29:
1378                 ret += tcrypt_test("tgr128");
1379                 break;
1380
1381         case 30:
1382                 ret += tcrypt_test("ecb(xeta)");
1383                 break;
1384
1385         case 31:
1386                 ret += tcrypt_test("pcbc(fcrypt)");
1387                 break;
1388
1389         case 32:
1390                 ret += tcrypt_test("ecb(camellia)");
1391                 ret += tcrypt_test("cbc(camellia)");
1392                 ret += tcrypt_test("ctr(camellia)");
1393                 ret += tcrypt_test("lrw(camellia)");
1394                 ret += tcrypt_test("xts(camellia)");
1395                 break;
1396
1397         case 33:
1398                 ret += tcrypt_test("sha224");
1399                 break;
1400
1401         case 34:
1402                 ret += tcrypt_test("salsa20");
1403                 break;
1404
1405         case 35:
1406                 ret += tcrypt_test("gcm(aes)");
1407                 break;
1408
1409         case 36:
1410                 ret += tcrypt_test("lzo");
1411                 break;
1412
1413         case 37:
1414                 ret += tcrypt_test("ccm(aes)");
1415                 break;
1416
1417         case 38:
1418                 ret += tcrypt_test("cts(cbc(aes))");
1419                 break;
1420
1421         case 39:
1422                 ret += tcrypt_test("rmd128");
1423                 break;
1424
1425         case 40:
1426                 ret += tcrypt_test("rmd160");
1427                 break;
1428
1429         case 41:
1430                 ret += tcrypt_test("rmd256");
1431                 break;
1432
1433         case 42:
1434                 ret += tcrypt_test("rmd320");
1435                 break;
1436
1437         case 43:
1438                 ret += tcrypt_test("ecb(seed)");
1439                 break;
1440
1441         case 44:
1442                 ret += tcrypt_test("zlib");
1443                 break;
1444
1445         case 45:
1446                 ret += tcrypt_test("rfc4309(ccm(aes))");
1447                 break;
1448
1449         case 46:
1450                 ret += tcrypt_test("ghash");
1451                 break;
1452
1453         case 47:
1454                 ret += tcrypt_test("crct10dif");
1455                 break;
1456
1457         case 100:
1458                 ret += tcrypt_test("hmac(md5)");
1459                 break;
1460
1461         case 101:
1462                 ret += tcrypt_test("hmac(sha1)");
1463                 break;
1464
1465         case 102:
1466                 ret += tcrypt_test("hmac(sha256)");
1467                 break;
1468
1469         case 103:
1470                 ret += tcrypt_test("hmac(sha384)");
1471                 break;
1472
1473         case 104:
1474                 ret += tcrypt_test("hmac(sha512)");
1475                 break;
1476
1477         case 105:
1478                 ret += tcrypt_test("hmac(sha224)");
1479                 break;
1480
1481         case 106:
1482                 ret += tcrypt_test("xcbc(aes)");
1483                 break;
1484
1485         case 107:
1486                 ret += tcrypt_test("hmac(rmd128)");
1487                 break;
1488
1489         case 108:
1490                 ret += tcrypt_test("hmac(rmd160)");
1491                 break;
1492
1493         case 109:
1494                 ret += tcrypt_test("vmac(aes)");
1495                 break;
1496
1497         case 110:
1498                 ret += tcrypt_test("hmac(crc32)");
1499                 break;
1500
1501         case 150:
1502                 ret += tcrypt_test("ansi_cprng");
1503                 break;
1504
1505         case 151:
1506                 ret += tcrypt_test("rfc4106(gcm(aes))");
1507                 break;
1508
1509         case 152:
1510                 ret += tcrypt_test("rfc4543(gcm(aes))");
1511                 break;
1512
1513         case 153:
1514                 ret += tcrypt_test("cmac(aes)");
1515                 break;
1516
1517         case 154:
1518                 ret += tcrypt_test("cmac(des3_ede)");
1519                 break;
1520
1521         case 155:
1522                 ret += tcrypt_test("authenc(hmac(sha1),cbc(aes))");
1523                 break;
1524
1525         case 156:
1526                 ret += tcrypt_test("authenc(hmac(md5),ecb(cipher_null))");
1527                 break;
1528
1529         case 157:
1530                 ret += tcrypt_test("authenc(hmac(sha1),ecb(cipher_null))");
1531                 break;
1532         case 181:
1533                 ret += tcrypt_test("authenc(hmac(sha1),cbc(des))");
1534                 break;
1535         case 182:
1536                 ret += tcrypt_test("authenc(hmac(sha1),cbc(des3_ede))");
1537                 break;
1538         case 183:
1539                 ret += tcrypt_test("authenc(hmac(sha224),cbc(des))");
1540                 break;
1541         case 184:
1542                 ret += tcrypt_test("authenc(hmac(sha224),cbc(des3_ede))");
1543                 break;
1544         case 185:
1545                 ret += tcrypt_test("authenc(hmac(sha256),cbc(des))");
1546                 break;
1547         case 186:
1548                 ret += tcrypt_test("authenc(hmac(sha256),cbc(des3_ede))");
1549                 break;
1550         case 187:
1551                 ret += tcrypt_test("authenc(hmac(sha384),cbc(des))");
1552                 break;
1553         case 188:
1554                 ret += tcrypt_test("authenc(hmac(sha384),cbc(des3_ede))");
1555                 break;
1556         case 189:
1557                 ret += tcrypt_test("authenc(hmac(sha512),cbc(des))");
1558                 break;
1559         case 190:
1560                 ret += tcrypt_test("authenc(hmac(sha512),cbc(des3_ede))");
1561                 break;
1562         case 200:
1563                 test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
1564                                 speed_template_16_24_32);
1565                 test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
1566                                 speed_template_16_24_32);
1567                 test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
1568                                 speed_template_16_24_32);
1569                 test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
1570                                 speed_template_16_24_32);
1571                 test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
1572                                 speed_template_32_40_48);
1573                 test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
1574                                 speed_template_32_40_48);
1575                 test_cipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
1576                                 speed_template_32_48_64);
1577                 test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
1578                                 speed_template_32_48_64);
1579                 test_cipher_speed("ctr(aes)", ENCRYPT, sec, NULL, 0,
1580                                 speed_template_16_24_32);
1581                 test_cipher_speed("ctr(aes)", DECRYPT, sec, NULL, 0,
1582                                 speed_template_16_24_32);
1583                 break;
1584
1585         case 201:
1586                 test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec,
1587                                 des3_speed_template, DES3_SPEED_VECTORS,
1588                                 speed_template_24);
1589                 test_cipher_speed("ecb(des3_ede)", DECRYPT, sec,
1590                                 des3_speed_template, DES3_SPEED_VECTORS,
1591                                 speed_template_24);
1592                 test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec,
1593                                 des3_speed_template, DES3_SPEED_VECTORS,
1594                                 speed_template_24);
1595                 test_cipher_speed("cbc(des3_ede)", DECRYPT, sec,
1596                                 des3_speed_template, DES3_SPEED_VECTORS,
1597                                 speed_template_24);
1598                 test_cipher_speed("ctr(des3_ede)", ENCRYPT, sec,
1599                                 des3_speed_template, DES3_SPEED_VECTORS,
1600                                 speed_template_24);
1601                 test_cipher_speed("ctr(des3_ede)", DECRYPT, sec,
1602                                 des3_speed_template, DES3_SPEED_VECTORS,
1603                                 speed_template_24);
1604                 break;
1605
1606         case 202:
1607                 test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
1608                                 speed_template_16_24_32);
1609                 test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
1610                                 speed_template_16_24_32);
1611                 test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
1612                                 speed_template_16_24_32);
1613                 test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
1614                                 speed_template_16_24_32);
1615                 test_cipher_speed("ctr(twofish)", ENCRYPT, sec, NULL, 0,
1616                                 speed_template_16_24_32);
1617                 test_cipher_speed("ctr(twofish)", DECRYPT, sec, NULL, 0,
1618                                 speed_template_16_24_32);
1619                 test_cipher_speed("lrw(twofish)", ENCRYPT, sec, NULL, 0,
1620                                 speed_template_32_40_48);
1621                 test_cipher_speed("lrw(twofish)", DECRYPT, sec, NULL, 0,
1622                                 speed_template_32_40_48);
1623                 test_cipher_speed("xts(twofish)", ENCRYPT, sec, NULL, 0,
1624                                 speed_template_32_48_64);
1625                 test_cipher_speed("xts(twofish)", DECRYPT, sec, NULL, 0,
1626                                 speed_template_32_48_64);
1627                 break;
1628
1629         case 203:
1630                 test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
1631                                   speed_template_8_32);
1632                 test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
1633                                   speed_template_8_32);
1634                 test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
1635                                   speed_template_8_32);
1636                 test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
1637                                   speed_template_8_32);
1638                 test_cipher_speed("ctr(blowfish)", ENCRYPT, sec, NULL, 0,
1639                                   speed_template_8_32);
1640                 test_cipher_speed("ctr(blowfish)", DECRYPT, sec, NULL, 0,
1641                                   speed_template_8_32);
1642                 break;
1643
1644         case 204:
1645                 test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
1646                                   speed_template_8);
1647                 test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
1648                                   speed_template_8);
1649                 test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
1650                                   speed_template_8);
1651                 test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
1652                                   speed_template_8);
1653                 break;
1654
1655         case 205:
1656                 test_cipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
1657                                 speed_template_16_24_32);
1658                 test_cipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
1659                                 speed_template_16_24_32);
1660                 test_cipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
1661                                 speed_template_16_24_32);
1662                 test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
1663                                 speed_template_16_24_32);
1664                 test_cipher_speed("ctr(camellia)", ENCRYPT, sec, NULL, 0,
1665                                 speed_template_16_24_32);
1666                 test_cipher_speed("ctr(camellia)", DECRYPT, sec, NULL, 0,
1667                                 speed_template_16_24_32);
1668                 test_cipher_speed("lrw(camellia)", ENCRYPT, sec, NULL, 0,
1669                                 speed_template_32_40_48);
1670                 test_cipher_speed("lrw(camellia)", DECRYPT, sec, NULL, 0,
1671                                 speed_template_32_40_48);
1672                 test_cipher_speed("xts(camellia)", ENCRYPT, sec, NULL, 0,
1673                                 speed_template_32_48_64);
1674                 test_cipher_speed("xts(camellia)", DECRYPT, sec, NULL, 0,
1675                                 speed_template_32_48_64);
1676                 break;
1677
1678         case 206:
1679                 test_cipher_speed("salsa20", ENCRYPT, sec, NULL, 0,
1680                                   speed_template_16_32);
1681                 break;
1682
1683         case 207:
1684                 test_cipher_speed("ecb(serpent)", ENCRYPT, sec, NULL, 0,
1685                                   speed_template_16_32);
1686                 test_cipher_speed("ecb(serpent)", DECRYPT, sec, NULL, 0,
1687                                   speed_template_16_32);
1688                 test_cipher_speed("cbc(serpent)", ENCRYPT, sec, NULL, 0,
1689                                   speed_template_16_32);
1690                 test_cipher_speed("cbc(serpent)", DECRYPT, sec, NULL, 0,
1691                                   speed_template_16_32);
1692                 test_cipher_speed("ctr(serpent)", ENCRYPT, sec, NULL, 0,
1693                                   speed_template_16_32);
1694                 test_cipher_speed("ctr(serpent)", DECRYPT, sec, NULL, 0,
1695                                   speed_template_16_32);
1696                 test_cipher_speed("lrw(serpent)", ENCRYPT, sec, NULL, 0,
1697                                   speed_template_32_48);
1698                 test_cipher_speed("lrw(serpent)", DECRYPT, sec, NULL, 0,
1699                                   speed_template_32_48);
1700                 test_cipher_speed("xts(serpent)", ENCRYPT, sec, NULL, 0,
1701                                   speed_template_32_64);
1702                 test_cipher_speed("xts(serpent)", DECRYPT, sec, NULL, 0,
1703                                   speed_template_32_64);
1704                 break;
1705
1706         case 208:
1707                 test_cipher_speed("ecb(arc4)", ENCRYPT, sec, NULL, 0,
1708                                   speed_template_8);
1709                 break;
1710
1711         case 209:
1712                 test_cipher_speed("ecb(cast5)", ENCRYPT, sec, NULL, 0,
1713                                   speed_template_8_16);
1714                 test_cipher_speed("ecb(cast5)", DECRYPT, sec, NULL, 0,
1715                                   speed_template_8_16);
1716                 test_cipher_speed("cbc(cast5)", ENCRYPT, sec, NULL, 0,
1717                                   speed_template_8_16);
1718                 test_cipher_speed("cbc(cast5)", DECRYPT, sec, NULL, 0,
1719                                   speed_template_8_16);
1720                 test_cipher_speed("ctr(cast5)", ENCRYPT, sec, NULL, 0,
1721                                   speed_template_8_16);
1722                 test_cipher_speed("ctr(cast5)", DECRYPT, sec, NULL, 0,
1723                                   speed_template_8_16);
1724                 break;
1725
1726         case 210:
1727                 test_cipher_speed("ecb(cast6)", ENCRYPT, sec, NULL, 0,
1728                                   speed_template_16_32);
1729                 test_cipher_speed("ecb(cast6)", DECRYPT, sec, NULL, 0,
1730                                   speed_template_16_32);
1731                 test_cipher_speed("cbc(cast6)", ENCRYPT, sec, NULL, 0,
1732                                   speed_template_16_32);
1733                 test_cipher_speed("cbc(cast6)", DECRYPT, sec, NULL, 0,
1734                                   speed_template_16_32);
1735                 test_cipher_speed("ctr(cast6)", ENCRYPT, sec, NULL, 0,
1736                                   speed_template_16_32);
1737                 test_cipher_speed("ctr(cast6)", DECRYPT, sec, NULL, 0,
1738                                   speed_template_16_32);
1739                 test_cipher_speed("lrw(cast6)", ENCRYPT, sec, NULL, 0,
1740                                   speed_template_32_48);
1741                 test_cipher_speed("lrw(cast6)", DECRYPT, sec, NULL, 0,
1742                                   speed_template_32_48);
1743                 test_cipher_speed("xts(cast6)", ENCRYPT, sec, NULL, 0,
1744                                   speed_template_32_64);
1745                 test_cipher_speed("xts(cast6)", DECRYPT, sec, NULL, 0,
1746                                   speed_template_32_64);
1747                 break;
1748
1749         case 211:
1750                 test_aead_speed("rfc4106(gcm(aes))", ENCRYPT, sec,
1751                                 NULL, 0, 16, 8, aead_speed_template_20);
1752                 break;
1753
1754         case 300:
1755                 /* fall through */
1756
1757         case 301:
1758                 test_hash_speed("md4", sec, generic_hash_speed_template);
1759                 if (mode > 300 && mode < 400) break;
1760
1761         case 302:
1762                 test_hash_speed("md5", sec, generic_hash_speed_template);
1763                 if (mode > 300 && mode < 400) break;
1764
1765         case 303:
1766                 test_hash_speed("sha1", sec, generic_hash_speed_template);
1767                 if (mode > 300 && mode < 400) break;
1768
1769         case 304:
1770                 test_hash_speed("sha256", sec, generic_hash_speed_template);
1771                 if (mode > 300 && mode < 400) break;
1772
1773         case 305:
1774                 test_hash_speed("sha384", sec, generic_hash_speed_template);
1775                 if (mode > 300 && mode < 400) break;
1776
1777         case 306:
1778                 test_hash_speed("sha512", sec, generic_hash_speed_template);
1779                 if (mode > 300 && mode < 400) break;
1780
1781         case 307:
1782                 test_hash_speed("wp256", sec, generic_hash_speed_template);
1783                 if (mode > 300 && mode < 400) break;
1784
1785         case 308:
1786                 test_hash_speed("wp384", sec, generic_hash_speed_template);
1787                 if (mode > 300 && mode < 400) break;
1788
1789         case 309:
1790                 test_hash_speed("wp512", sec, generic_hash_speed_template);
1791                 if (mode > 300 && mode < 400) break;
1792
1793         case 310:
1794                 test_hash_speed("tgr128", sec, generic_hash_speed_template);
1795                 if (mode > 300 && mode < 400) break;
1796
1797         case 311:
1798                 test_hash_speed("tgr160", sec, generic_hash_speed_template);
1799                 if (mode > 300 && mode < 400) break;
1800
1801         case 312:
1802                 test_hash_speed("tgr192", sec, generic_hash_speed_template);
1803                 if (mode > 300 && mode < 400) break;
1804
1805         case 313:
1806                 test_hash_speed("sha224", sec, generic_hash_speed_template);
1807                 if (mode > 300 && mode < 400) break;
1808
1809         case 314:
1810                 test_hash_speed("rmd128", sec, generic_hash_speed_template);
1811                 if (mode > 300 && mode < 400) break;
1812
1813         case 315:
1814                 test_hash_speed("rmd160", sec, generic_hash_speed_template);
1815                 if (mode > 300 && mode < 400) break;
1816
1817         case 316:
1818                 test_hash_speed("rmd256", sec, generic_hash_speed_template);
1819                 if (mode > 300 && mode < 400) break;
1820
1821         case 317:
1822                 test_hash_speed("rmd320", sec, generic_hash_speed_template);
1823                 if (mode > 300 && mode < 400) break;
1824
1825         case 318:
1826                 test_hash_speed("ghash-generic", sec, hash_speed_template_16);
1827                 if (mode > 300 && mode < 400) break;
1828
1829         case 319:
1830                 test_hash_speed("crc32c", sec, generic_hash_speed_template);
1831                 if (mode > 300 && mode < 400) break;
1832
1833         case 320:
1834                 test_hash_speed("crct10dif", sec, generic_hash_speed_template);
1835                 if (mode > 300 && mode < 400) break;
1836
1837         case 399:
1838                 break;
1839
1840         case 400:
1841                 /* fall through */
1842
1843         case 401:
1844                 test_ahash_speed("md4", sec, generic_hash_speed_template);
1845                 if (mode > 400 && mode < 500) break;
1846
1847         case 402:
1848                 test_ahash_speed("md5", sec, generic_hash_speed_template);
1849                 if (mode > 400 && mode < 500) break;
1850
1851         case 403:
1852                 test_ahash_speed("sha1", sec, generic_hash_speed_template);
1853                 if (mode > 400 && mode < 500) break;
1854
1855         case 404:
1856                 test_ahash_speed("sha256", sec, generic_hash_speed_template);
1857                 if (mode > 400 && mode < 500) break;
1858
1859         case 405:
1860                 test_ahash_speed("sha384", sec, generic_hash_speed_template);
1861                 if (mode > 400 && mode < 500) break;
1862
1863         case 406:
1864                 test_ahash_speed("sha512", sec, generic_hash_speed_template);
1865                 if (mode > 400 && mode < 500) break;
1866
1867         case 407:
1868                 test_ahash_speed("wp256", sec, generic_hash_speed_template);
1869                 if (mode > 400 && mode < 500) break;
1870
1871         case 408:
1872                 test_ahash_speed("wp384", sec, generic_hash_speed_template);
1873                 if (mode > 400 && mode < 500) break;
1874
1875         case 409:
1876                 test_ahash_speed("wp512", sec, generic_hash_speed_template);
1877                 if (mode > 400 && mode < 500) break;
1878
1879         case 410:
1880                 test_ahash_speed("tgr128", sec, generic_hash_speed_template);
1881                 if (mode > 400 && mode < 500) break;
1882
1883         case 411:
1884                 test_ahash_speed("tgr160", sec, generic_hash_speed_template);
1885                 if (mode > 400 && mode < 500) break;
1886
1887         case 412:
1888                 test_ahash_speed("tgr192", sec, generic_hash_speed_template);
1889                 if (mode > 400 && mode < 500) break;
1890
1891         case 413:
1892                 test_ahash_speed("sha224", sec, generic_hash_speed_template);
1893                 if (mode > 400 && mode < 500) break;
1894
1895         case 414:
1896                 test_ahash_speed("rmd128", sec, generic_hash_speed_template);
1897                 if (mode > 400 && mode < 500) break;
1898
1899         case 415:
1900                 test_ahash_speed("rmd160", sec, generic_hash_speed_template);
1901                 if (mode > 400 && mode < 500) break;
1902
1903         case 416:
1904                 test_ahash_speed("rmd256", sec, generic_hash_speed_template);
1905                 if (mode > 400 && mode < 500) break;
1906
1907         case 417:
1908                 test_ahash_speed("rmd320", sec, generic_hash_speed_template);
1909                 if (mode > 400 && mode < 500) break;
1910
1911         case 499:
1912                 break;
1913
1914         case 500:
1915                 test_acipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
1916                                    speed_template_16_24_32);
1917                 test_acipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
1918                                    speed_template_16_24_32);
1919                 test_acipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
1920                                    speed_template_16_24_32);
1921                 test_acipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
1922                                    speed_template_16_24_32);
1923                 test_acipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
1924                                    speed_template_32_40_48);
1925                 test_acipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
1926                                    speed_template_32_40_48);
1927                 test_acipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
1928                                    speed_template_32_48_64);
1929                 test_acipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
1930                                    speed_template_32_48_64);
1931                 test_acipher_speed("ctr(aes)", ENCRYPT, sec, NULL, 0,
1932                                    speed_template_16_24_32);
1933                 test_acipher_speed("ctr(aes)", DECRYPT, sec, NULL, 0,
1934                                    speed_template_16_24_32);
1935                 test_acipher_speed("cfb(aes)", ENCRYPT, sec, NULL, 0,
1936                                    speed_template_16_24_32);
1937                 test_acipher_speed("cfb(aes)", DECRYPT, sec, NULL, 0,
1938                                    speed_template_16_24_32);
1939                 test_acipher_speed("ofb(aes)", ENCRYPT, sec, NULL, 0,
1940                                    speed_template_16_24_32);
1941                 test_acipher_speed("ofb(aes)", DECRYPT, sec, NULL, 0,
1942                                    speed_template_16_24_32);
1943                 test_acipher_speed("rfc3686(ctr(aes))", ENCRYPT, sec, NULL, 0,
1944                                    speed_template_20_28_36);
1945                 test_acipher_speed("rfc3686(ctr(aes))", DECRYPT, sec, NULL, 0,
1946                                    speed_template_20_28_36);
1947                 break;
1948
1949         case 501:
1950                 test_acipher_speed("ecb(des3_ede)", ENCRYPT, sec,
1951                                    des3_speed_template, DES3_SPEED_VECTORS,
1952                                    speed_template_24);
1953                 test_acipher_speed("ecb(des3_ede)", DECRYPT, sec,
1954                                    des3_speed_template, DES3_SPEED_VECTORS,
1955                                    speed_template_24);
1956                 test_acipher_speed("cbc(des3_ede)", ENCRYPT, sec,
1957                                    des3_speed_template, DES3_SPEED_VECTORS,
1958                                    speed_template_24);
1959                 test_acipher_speed("cbc(des3_ede)", DECRYPT, sec,
1960                                    des3_speed_template, DES3_SPEED_VECTORS,
1961                                    speed_template_24);
1962                 test_acipher_speed("cfb(des3_ede)", ENCRYPT, sec,
1963                                    des3_speed_template, DES3_SPEED_VECTORS,
1964                                    speed_template_24);
1965                 test_acipher_speed("cfb(des3_ede)", DECRYPT, sec,
1966                                    des3_speed_template, DES3_SPEED_VECTORS,
1967                                    speed_template_24);
1968                 test_acipher_speed("ofb(des3_ede)", ENCRYPT, sec,
1969                                    des3_speed_template, DES3_SPEED_VECTORS,
1970                                    speed_template_24);
1971                 test_acipher_speed("ofb(des3_ede)", DECRYPT, sec,
1972                                    des3_speed_template, DES3_SPEED_VECTORS,
1973                                    speed_template_24);
1974                 break;
1975
1976         case 502:
1977                 test_acipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
1978                                    speed_template_8);
1979                 test_acipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
1980                                    speed_template_8);
1981                 test_acipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
1982                                    speed_template_8);
1983                 test_acipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
1984                                    speed_template_8);
1985                 test_acipher_speed("cfb(des)", ENCRYPT, sec, NULL, 0,
1986                                    speed_template_8);
1987                 test_acipher_speed("cfb(des)", DECRYPT, sec, NULL, 0,
1988                                    speed_template_8);
1989                 test_acipher_speed("ofb(des)", ENCRYPT, sec, NULL, 0,
1990                                    speed_template_8);
1991                 test_acipher_speed("ofb(des)", DECRYPT, sec, NULL, 0,
1992                                    speed_template_8);
1993                 break;
1994
1995         case 503:
1996                 test_acipher_speed("ecb(serpent)", ENCRYPT, sec, NULL, 0,
1997                                    speed_template_16_32);
1998                 test_acipher_speed("ecb(serpent)", DECRYPT, sec, NULL, 0,
1999                                    speed_template_16_32);
2000                 test_acipher_speed("cbc(serpent)", ENCRYPT, sec, NULL, 0,
2001                                    speed_template_16_32);
2002                 test_acipher_speed("cbc(serpent)", DECRYPT, sec, NULL, 0,
2003                                    speed_template_16_32);
2004                 test_acipher_speed("ctr(serpent)", ENCRYPT, sec, NULL, 0,
2005                                    speed_template_16_32);
2006                 test_acipher_speed("ctr(serpent)", DECRYPT, sec, NULL, 0,
2007                                    speed_template_16_32);
2008                 test_acipher_speed("lrw(serpent)", ENCRYPT, sec, NULL, 0,
2009                                    speed_template_32_48);
2010                 test_acipher_speed("lrw(serpent)", DECRYPT, sec, NULL, 0,
2011                                    speed_template_32_48);
2012                 test_acipher_speed("xts(serpent)", ENCRYPT, sec, NULL, 0,
2013                                    speed_template_32_64);
2014                 test_acipher_speed("xts(serpent)", DECRYPT, sec, NULL, 0,
2015                                    speed_template_32_64);
2016                 break;
2017
2018         case 504:
2019                 test_acipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
2020                                    speed_template_16_24_32);
2021                 test_acipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
2022                                    speed_template_16_24_32);
2023                 test_acipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
2024                                    speed_template_16_24_32);
2025                 test_acipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
2026                                    speed_template_16_24_32);
2027                 test_acipher_speed("ctr(twofish)", ENCRYPT, sec, NULL, 0,
2028                                    speed_template_16_24_32);
2029                 test_acipher_speed("ctr(twofish)", DECRYPT, sec, NULL, 0,
2030                                    speed_template_16_24_32);
2031                 test_acipher_speed("lrw(twofish)", ENCRYPT, sec, NULL, 0,
2032                                    speed_template_32_40_48);
2033                 test_acipher_speed("lrw(twofish)", DECRYPT, sec, NULL, 0,
2034                                    speed_template_32_40_48);
2035                 test_acipher_speed("xts(twofish)", ENCRYPT, sec, NULL, 0,
2036                                    speed_template_32_48_64);
2037                 test_acipher_speed("xts(twofish)", DECRYPT, sec, NULL, 0,
2038                                    speed_template_32_48_64);
2039                 break;
2040
2041         case 505:
2042                 test_acipher_speed("ecb(arc4)", ENCRYPT, sec, NULL, 0,
2043                                    speed_template_8);
2044                 break;
2045
2046         case 506:
2047                 test_acipher_speed("ecb(cast5)", ENCRYPT, sec, NULL, 0,
2048                                    speed_template_8_16);
2049                 test_acipher_speed("ecb(cast5)", DECRYPT, sec, NULL, 0,
2050                                    speed_template_8_16);
2051                 test_acipher_speed("cbc(cast5)", ENCRYPT, sec, NULL, 0,
2052                                    speed_template_8_16);
2053                 test_acipher_speed("cbc(cast5)", DECRYPT, sec, NULL, 0,
2054                                    speed_template_8_16);
2055                 test_acipher_speed("ctr(cast5)", ENCRYPT, sec, NULL, 0,
2056                                    speed_template_8_16);
2057                 test_acipher_speed("ctr(cast5)", DECRYPT, sec, NULL, 0,
2058                                    speed_template_8_16);
2059                 break;
2060
2061         case 507:
2062                 test_acipher_speed("ecb(cast6)", ENCRYPT, sec, NULL, 0,
2063                                    speed_template_16_32);
2064                 test_acipher_speed("ecb(cast6)", DECRYPT, sec, NULL, 0,
2065                                    speed_template_16_32);
2066                 test_acipher_speed("cbc(cast6)", ENCRYPT, sec, NULL, 0,
2067                                    speed_template_16_32);
2068                 test_acipher_speed("cbc(cast6)", DECRYPT, sec, NULL, 0,
2069                                    speed_template_16_32);
2070                 test_acipher_speed("ctr(cast6)", ENCRYPT, sec, NULL, 0,
2071                                    speed_template_16_32);
2072                 test_acipher_speed("ctr(cast6)", DECRYPT, sec, NULL, 0,
2073                                    speed_template_16_32);
2074                 test_acipher_speed("lrw(cast6)", ENCRYPT, sec, NULL, 0,
2075                                    speed_template_32_48);
2076                 test_acipher_speed("lrw(cast6)", DECRYPT, sec, NULL, 0,
2077                                    speed_template_32_48);
2078                 test_acipher_speed("xts(cast6)", ENCRYPT, sec, NULL, 0,
2079                                    speed_template_32_64);
2080                 test_acipher_speed("xts(cast6)", DECRYPT, sec, NULL, 0,
2081                                    speed_template_32_64);
2082                 break;
2083
2084         case 508:
2085                 test_acipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
2086                                    speed_template_16_32);
2087                 test_acipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
2088                                    speed_template_16_32);
2089                 test_acipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
2090                                    speed_template_16_32);
2091                 test_acipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
2092                                    speed_template_16_32);
2093                 test_acipher_speed("ctr(camellia)", ENCRYPT, sec, NULL, 0,
2094                                    speed_template_16_32);
2095                 test_acipher_speed("ctr(camellia)", DECRYPT, sec, NULL, 0,
2096                                    speed_template_16_32);
2097                 test_acipher_speed("lrw(camellia)", ENCRYPT, sec, NULL, 0,
2098                                    speed_template_32_48);
2099                 test_acipher_speed("lrw(camellia)", DECRYPT, sec, NULL, 0,
2100                                    speed_template_32_48);
2101                 test_acipher_speed("xts(camellia)", ENCRYPT, sec, NULL, 0,
2102                                    speed_template_32_64);
2103                 test_acipher_speed("xts(camellia)", DECRYPT, sec, NULL, 0,
2104                                    speed_template_32_64);
2105                 break;
2106
2107         case 509:
2108                 test_acipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
2109                                    speed_template_8_32);
2110                 test_acipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
2111                                    speed_template_8_32);
2112                 test_acipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
2113                                    speed_template_8_32);
2114                 test_acipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
2115                                    speed_template_8_32);
2116                 test_acipher_speed("ctr(blowfish)", ENCRYPT, sec, NULL, 0,
2117                                    speed_template_8_32);
2118                 test_acipher_speed("ctr(blowfish)", DECRYPT, sec, NULL, 0,
2119                                    speed_template_8_32);
2120                 break;
2121
2122         case 1000:
2123                 test_available();
2124                 break;
2125         }
2126
2127         return ret;
2128 }
2129
2130 static int do_alg_test(const char *alg, u32 type, u32 mask)
2131 {
2132         return crypto_has_alg(alg, type, mask ?: CRYPTO_ALG_TYPE_MASK) ?
2133                0 : -ENOENT;
2134 }
2135
2136 static int __init tcrypt_mod_init(void)
2137 {
2138         int err = -ENOMEM;
2139         int i;
2140
2141         for (i = 0; i < TVMEMSIZE; i++) {
2142                 tvmem[i] = (void *)__get_free_page(GFP_KERNEL);
2143                 if (!tvmem[i])
2144                         goto err_free_tv;
2145         }
2146
2147         if (alg)
2148                 err = do_alg_test(alg, type, mask);
2149         else
2150                 err = do_test(mode);
2151
2152         if (err) {
2153                 printk(KERN_ERR "tcrypt: one or more tests failed!\n");
2154                 goto err_free_tv;
2155         }
2156
2157         /* We intentionaly return -EAGAIN to prevent keeping the module,
2158          * unless we're running in fips mode. It does all its work from
2159          * init() and doesn't offer any runtime functionality, but in
2160          * the fips case, checking for a successful load is helpful.
2161          * => we don't need it in the memory, do we?
2162          *                                        -- mludvig
2163          */
2164         if (!fips_enabled)
2165                 err = -EAGAIN;
2166
2167 err_free_tv:
2168         for (i = 0; i < TVMEMSIZE && tvmem[i]; i++)
2169                 free_page((unsigned long)tvmem[i]);
2170
2171         return err;
2172 }
2173
2174 /*
2175  * If an init function is provided, an exit function must also be provided
2176  * to allow module unload.
2177  */
2178 static void __exit tcrypt_mod_fini(void) { }
2179
2180 module_init(tcrypt_mod_init);
2181 module_exit(tcrypt_mod_fini);
2182
2183 module_param(alg, charp, 0);
2184 module_param(type, uint, 0);
2185 module_param(mask, uint, 0);
2186 module_param(mode, int, 0);
2187 module_param(sec, uint, 0);
2188 MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
2189                       "(defaults to zero which uses CPU cycles instead)");
2190
2191 MODULE_LICENSE("GPL");
2192 MODULE_DESCRIPTION("Quick & dirty crypto testing module");
2193 MODULE_AUTHOR("James Morris <[email protected]>");