contrib/bearssl/test/test_speed.c

   1 /*
   2  * Copyright (c) 2016 Thomas Pornin <pornin@bolet.org>
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining
   5  * a copy of this software and associated documentation files (the
   6  * "Software"), to deal in the Software without restriction, including
   7  * without limitation the rights to use, copy, modify, merge, publish,
   8  * distribute, sublicense, and/or sell copies of the Software, and to
   9  * permit persons to whom the Software is furnished to do so, subject to
  10  * the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be
  13  * included in all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  16  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  18  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  19  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  20  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  21  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  22  * SOFTWARE.
  23  */
  24
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <time.h>
  29 #include "inner.h"
  30
  31 #define HASH_SIZE(cname)   br_ ## cname ## _SIZE
  32
  33 #define SPEED_HASH(Name, cname) \
  34 static void \
  35 test_speed_ ## cname(void) \
  36 { \
  37         unsigned char buf[8192]; \
  38         unsigned char tmp[HASH_SIZE(cname)]; \
  39         br_ ## cname ## _context mc; \
  40         int i; \
  41         long num; \
  42  \
  43         memset(buf, 'T', sizeof buf); \
  44         for (i = 0; i < 10; i ++) { \
  45                 br_ ## cname ## _init(&mc); \
  46                 br_ ## cname ## _update(&mc, buf, sizeof buf); \
  47                 br_ ## cname ## _out(&mc, tmp); \
  48         } \
  49         num = 10; \
  50         for (;;) { \
  51                 clock_t begin, end; \
  52                 double tt; \
  53                 long k; \
  54  \
  55                 br_ ## cname ## _init(&mc); \
  56                 begin = clock(); \
  57                 for (k = num; k > 0; k --) { \
  58                         br_ ## cname ## _update(&mc, buf, sizeof buf); \
  59                 } \
  60                 end = clock(); \
  61                 br_ ## cname ## _out(&mc, tmp); \
  62                 tt = (double)(end - begin) / CLOCKS_PER_SEC; \
  63                 if (tt >= 2.0) { \
  64                         printf("%-30s %8.2f MB/s\n", #Name, \
  65                                 ((double)sizeof buf) * (double)num \
  66                                 / (tt * 1000000.0)); \
  67                         fflush(stdout); \
  68                         return; \
  69                 } \
  70                 num <<= 1; \
  71         } \
  72 }
  73
  74 #define BLOCK_SIZE(cname)   br_ ## cname ## _BLOCK_SIZE
  75
  76 #define SPEED_BLOCKCIPHER_CBC(Name, fname, cname, klen, dir) \
  77 static void \
  78 test_speed_ ## fname(void) \
  79 { \
  80         unsigned char key[klen]; \
  81         unsigned char buf[8192 - (8192 % BLOCK_SIZE(cname))]; \
  82         unsigned char iv[BLOCK_SIZE(cname)]; \
  83         const br_block_cbc ## dir ## _class *vt; \
  84         br_ ## cname ## _cbc ## dir ## _keys ec; \
  85         int i; \
  86         long num; \
  87  \
  88         memset(key, 'T', sizeof key); \
  89         memset(buf, 'P', sizeof buf); \
  90         memset(iv, 'X', sizeof iv); \
  91         vt = br_ ## cname ## _cbc ## dir ## _get_vtable(); \
  92         if (vt == NULL) { \
  93                 printf("%-30s UNAVAILABLE\n", #Name); \
  94                 fflush(stdout); \
  95                 return; \
  96         } \
  97         for (i = 0; i < 10; i ++) { \
  98                 vt->init(&ec.vtable, key, sizeof key); \
  99                 vt->run(&ec.vtable, iv, buf, sizeof buf); \
 100         } \
 101         num = 10; \
 102         for (;;) { \
 103                 clock_t begin, end; \
 104                 double tt; \
 105                 long k; \
 106  \
 107                 vt->init(&ec.vtable, key, sizeof key); \
 108                 begin = clock(); \
 109                 for (k = num; k > 0; k --) { \
 110                         vt->run(&ec.vtable, iv, buf, sizeof buf); \
 111                 } \
 112                 end = clock(); \
 113                 tt = (double)(end - begin) / CLOCKS_PER_SEC; \
 114                 if (tt >= 2.0) { \
 115                         printf("%-30s %8.2f MB/s\n", #Name, \
 116                                 ((double)sizeof buf) * (double)num \
 117                                 / (tt * 1000000.0)); \
 118                         fflush(stdout); \
 119                         return; \
 120                 } \
 121                 num <<= 1; \
 122         } \
 123 }
 124
 125 #define SPEED_BLOCKCIPHER_CTR(Name, fname, cname, klen) \
 126 static void \
 127 test_speed_ ## fname(void) \
 128 { \
 129         unsigned char key[klen]; \
 130         unsigned char buf[8192 - (8192 % BLOCK_SIZE(cname))]; \
 131         unsigned char iv[BLOCK_SIZE(cname) - 4]; \
 132         const br_block_ctr_class *vt; \
 133         br_ ## cname ## _ctr_keys ec; \
 134         int i; \
 135         long num; \
 136  \
 137         memset(key, 'T', sizeof key); \
 138         memset(buf, 'P', sizeof buf); \
 139         memset(iv, 'X', sizeof iv); \
 140         vt = br_ ## cname ## _ctr_get_vtable(); \
 141         if (vt == NULL) { \
 142                 printf("%-30s UNAVAILABLE\n", #Name); \
 143                 fflush(stdout); \
 144                 return; \
 145         } \
 146         for (i = 0; i < 10; i ++) { \
 147                 vt->init(&ec.vtable, key, sizeof key); \
 148                 vt->run(&ec.vtable, iv, 1, buf, sizeof buf); \
 149         } \
 150         num = 10; \
 151         for (;;) { \
 152                 clock_t begin, end; \
 153                 double tt; \
 154                 long k; \
 155  \
 156                 vt->init(&ec.vtable, key, sizeof key); \
 157                 begin = clock(); \
 158                 for (k = num; k > 0; k --) { \
 159                         vt->run(&ec.vtable, iv, 1, buf, sizeof buf); \
 160                 } \
 161                 end = clock(); \
 162                 tt = (double)(end - begin) / CLOCKS_PER_SEC; \
 163                 if (tt >= 2.0) { \
 164                         printf("%-30s %8.2f MB/s\n", #Name, \
 165                                 ((double)sizeof buf) * (double)num \
 166                                 / (tt * 1000000.0)); \
 167                         fflush(stdout); \
 168                         return; \
 169                 } \
 170                 num <<= 1; \
 171         } \
 172 }
 173
 174 #define SPEED_CHACHA20(Name, fname) \
 175 static void \
 176 test_speed_ ## fname(void) \
 177 { \
 178         br_chacha20_run bc; \
 179         unsigned char key[32]; \
 180         unsigned char buf[8192]; \
 181         unsigned char iv[12]; \
 182         int i; \
 183         long num; \
 184  \
 185         bc = br_ ## fname ## _get(); \
 186         if (bc == 0) { \
 187                 printf("%-30s UNAVAILABLE\n", #Name); \
 188                 fflush(stdout); \
 189                 return; \
 190         } \
 191         memset(key, 'T', sizeof key); \
 192         memset(buf, 'P', sizeof buf); \
 193         memset(iv, 'X', sizeof iv); \
 194         for (i = 0; i < 10; i ++) { \
 195                 bc(key, iv, i, buf, sizeof buf); \
 196         } \
 197         num = 10; \
 198         for (;;) { \
 199                 clock_t begin, end; \
 200                 double tt; \
 201                 long k; \
 202  \
 203                 begin = clock(); \
 204                 for (k = num; k > 0; k --) { \
 205                         bc(key, iv, (uint32_t)k, buf, sizeof buf); \
 206                 } \
 207                 end = clock(); \
 208                 tt = (double)(end - begin) / CLOCKS_PER_SEC; \
 209                 if (tt >= 2.0) { \
 210                         printf("%-30s %8.2f MB/s\n", #Name, \
 211                                 ((double)sizeof buf) * (double)num \
 212                                 / (tt * 1000000.0)); \
 213                         fflush(stdout); \
 214                         return; \
 215                 } \
 216                 num <<= 1; \
 217         } \
 218 }
 219
 220 SPEED_HASH(MD5, md5)
 221 SPEED_HASH(SHA-1, sha1)
 222 SPEED_HASH(SHA-256, sha256)
 223 SPEED_HASH(SHA-512, sha512)
 224
 225 /*
 226  * There are no vtable selection functions for the portable implementations,
 227  * so we define some custom macros.
 228  */
 229 #define br_aes_big_cbcenc_get_vtable()     (&br_aes_big_cbcenc_vtable)
 230 #define br_aes_big_cbcdec_get_vtable()     (&br_aes_big_cbcdec_vtable)
 231 #define br_aes_big_ctr_get_vtable()        (&br_aes_big_ctr_vtable)
 232 #define br_aes_big_ctrcbc_get_vtable()     (&br_aes_big_ctrcbc_vtable)
 233 #define br_aes_small_cbcenc_get_vtable()   (&br_aes_small_cbcenc_vtable)
 234 #define br_aes_small_cbcdec_get_vtable()   (&br_aes_small_cbcdec_vtable)
 235 #define br_aes_small_ctr_get_vtable()      (&br_aes_small_ctr_vtable)
 236 #define br_aes_small_ctrcbc_get_vtable()   (&br_aes_small_ctrcbc_vtable)
 237 #define br_aes_ct_cbcenc_get_vtable()      (&br_aes_ct_cbcenc_vtable)
 238 #define br_aes_ct_cbcdec_get_vtable()      (&br_aes_ct_cbcdec_vtable)
 239 #define br_aes_ct_ctr_get_vtable()         (&br_aes_ct_ctr_vtable)
 240 #define br_aes_ct_ctrcbc_get_vtable()      (&br_aes_ct_ctrcbc_vtable)
 241 #define br_aes_ct64_cbcenc_get_vtable()    (&br_aes_ct64_cbcenc_vtable)
 242 #define br_aes_ct64_cbcdec_get_vtable()    (&br_aes_ct64_cbcdec_vtable)
 243 #define br_aes_ct64_ctr_get_vtable()       (&br_aes_ct64_ctr_vtable)
 244 #define br_aes_ct64_ctrcbc_get_vtable()    (&br_aes_ct64_ctrcbc_vtable)
 245 #define br_chacha20_ct_get()               (&br_chacha20_ct_run)
 246
 247 #define SPEED_AES(iname) \
 248 SPEED_BLOCKCIPHER_CBC(AES-128 CBC encrypt (iname), aes128_ ## iname ## _cbcenc, aes_ ## iname, 16, enc) \
 249 SPEED_BLOCKCIPHER_CBC(AES-128 CBC decrypt (iname), aes128_ ## iname ## _cbcdec, aes_ ## iname, 16, dec) \
 250 SPEED_BLOCKCIPHER_CBC(AES-192 CBC encrypt (iname), aes192_ ## iname ## _cbcenc, aes_ ## iname, 24, enc) \
 251 SPEED_BLOCKCIPHER_CBC(AES-192 CBC decrypt (iname), aes192_ ## iname ## _cbcdec, aes_ ## iname, 24, dec) \
 252 SPEED_BLOCKCIPHER_CBC(AES-256 CBC encrypt (iname), aes256_ ## iname ## _cbcenc, aes_ ## iname, 32, enc) \
 253 SPEED_BLOCKCIPHER_CBC(AES-256 CBC decrypt (iname), aes256_ ## iname ## _cbcdec, aes_ ## iname, 32, dec) \
 254 SPEED_BLOCKCIPHER_CTR(AES-128 CTR (iname), aes128_ ## iname ## _ctr, aes_ ## iname, 16) \
 255 SPEED_BLOCKCIPHER_CTR(AES-192 CTR (iname), aes192_ ## iname ## _ctr, aes_ ## iname, 24) \
 256 SPEED_BLOCKCIPHER_CTR(AES-256 CTR (iname), aes256_ ## iname ## _ctr, aes_ ## iname, 32)
 257
 258 SPEED_AES(big)
 259 SPEED_AES(small)
 260 SPEED_AES(ct)
 261 SPEED_AES(ct64)
 262 SPEED_AES(x86ni)
 263 SPEED_AES(pwr8)
 264
 265 #define br_des_tab_cbcenc_get_vtable()     (&br_des_tab_cbcenc_vtable)
 266 #define br_des_tab_cbcdec_get_vtable()     (&br_des_tab_cbcdec_vtable)
 267 #define br_des_ct_cbcenc_get_vtable()      (&br_des_ct_cbcenc_vtable)
 268 #define br_des_ct_cbcdec_get_vtable()      (&br_des_ct_cbcdec_vtable)
 269
 270 #define SPEED_DES(iname) \
 271 SPEED_BLOCKCIPHER_CBC(DES CBC encrypt (iname), des_ ## iname ## _cbcenc, des_ ## iname, 8, enc) \
 272 SPEED_BLOCKCIPHER_CBC(DES CBC decrypt (iname), des_ ## iname ## _cbcdec, des_ ## iname, 8, dec) \
 273 SPEED_BLOCKCIPHER_CBC(3DES CBC encrypt (iname), 3des_ ## iname ## _cbcenc, des_ ## iname, 24, enc) \
 274 SPEED_BLOCKCIPHER_CBC(3DES CBC decrypt (iname), 3des_ ## iname ## _cbcdec, des_ ## iname, 24, dec)
 275
 276 SPEED_DES(tab)
 277 SPEED_DES(ct)
 278
 279 SPEED_CHACHA20(ChaCha20 (ct), chacha20_ct)
 280 SPEED_CHACHA20(ChaCha20 (sse2), chacha20_sse2)
 281
 282 static void
 283 test_speed_ghash_inner(char *name, br_ghash gh)
 284 {
 285         unsigned char buf[8192], h[16], y[16];
 286         int i;
 287         long num;
 288
 289         memset(buf, 'T', sizeof buf);
 290         memset(h, 'P', sizeof h);
 291         memset(y, 0, sizeof y);
 292         for (i = 0; i < 10; i ++) {
 293                 gh(y, h, buf, sizeof buf);
 294         }
 295         num = 10;
 296         for (;;) {
 297                 clock_t begin, end;
 298                 double tt;
 299                 long k;
 300
 301                 begin = clock();
 302                 for (k = num; k > 0; k --) {
 303                         gh(y, h, buf, sizeof buf);
 304                 }
 305                 end = clock();
 306                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
 307                 if (tt >= 2.0) {
 308                         printf("%-30s %8.2f MB/s\n", name,
 309                                 ((double)sizeof buf) * (double)num
 310                                 / (tt * 1000000.0));
 311                         fflush(stdout);
 312                         return;
 313                 }
 314                 num <<= 1;
 315         }
 316 }
 317
 318 static void
 319 test_speed_ghash_ctmul(void)
 320 {
 321         test_speed_ghash_inner("GHASH (ctmul)", &br_ghash_ctmul);
 322 }
 323
 324 static void
 325 test_speed_ghash_ctmul32(void)
 326 {
 327         test_speed_ghash_inner("GHASH (ctmul32)", &br_ghash_ctmul32);
 328 }
 329
 330 static void
 331 test_speed_ghash_ctmul64(void)
 332 {
 333         test_speed_ghash_inner("GHASH (ctmul64)", &br_ghash_ctmul64);
 334 }
 335
 336 static void
 337 test_speed_ghash_pclmul(void)
 338 {
 339         br_ghash gh;
 340
 341         gh = br_ghash_pclmul_get();
 342         if (gh == 0) {
 343                 printf("%-30s UNAVAILABLE\n", "GHASH (pclmul)");
 344                 fflush(stdout);
 345         } else {
 346                 test_speed_ghash_inner("GHASH (pclmul)", gh);
 347         }
 348 }
 349
 350 static void
 351 test_speed_ghash_pwr8(void)
 352 {
 353         br_ghash gh;
 354
 355         gh = br_ghash_pwr8_get();
 356         if (gh == 0) {
 357                 printf("%-30s UNAVAILABLE\n", "GHASH (pwr8)");
 358                 fflush(stdout);
 359         } else {
 360                 test_speed_ghash_inner("GHASH (pwr8)", gh);
 361         }
 362 }
 363
 364 static uint32_t
 365 fake_chacha20(const void *key, const void *iv,
 366         uint32_t cc, void *data, size_t len)
 367 {
 368         (void)key;
 369         (void)iv;
 370         (void)data;
 371         (void)len;
 372         return cc + (uint32_t)((len + 63) >> 6);
 373 }
 374
 375 /*
 376  * To speed-test Poly1305, we run it with a do-nothing stub instead of
 377  * ChaCha20.
 378  */
 379 static void
 380 test_speed_poly1305_inner(char *name, br_poly1305_run pl)
 381 {
 382         unsigned char buf[8192], key[32], iv[12], aad[13], tag[16];
 383         int i;
 384         long num;
 385
 386         memset(key, 'K', sizeof key);
 387         memset(iv, 'I', sizeof iv);
 388         memset(aad, 'A', sizeof aad);
 389         memset(buf, 'T', sizeof buf);
 390         for (i = 0; i < 10; i ++) {
 391                 pl(key, iv, buf, sizeof buf,
 392                         aad, sizeof aad, tag, &fake_chacha20, 0);
 393         }
 394         num = 10;
 395         for (;;) {
 396                 clock_t begin, end;
 397                 double tt;
 398                 long k;
 399
 400                 begin = clock();
 401                 for (k = num; k > 0; k --) {
 402                         pl(key, iv, buf, sizeof buf,
 403                                 aad, sizeof aad, tag, &fake_chacha20, 0);
 404                 }
 405                 end = clock();
 406                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
 407                 if (tt >= 2.0) {
 408                         printf("%-30s %8.2f MB/s\n", name,
 409                                 ((double)sizeof buf) * (double)num
 410                                 / (tt * 1000000.0));
 411                         fflush(stdout);
 412                         return;
 413                 }
 414                 num <<= 1;
 415         }
 416 }
 417
 418 static void
 419 test_speed_poly1305_ctmul(void)
 420 {
 421         test_speed_poly1305_inner("Poly1305 (ctmul)", &br_poly1305_ctmul_run);
 422 }
 423
 424 static void
 425 test_speed_poly1305_ctmul32(void)
 426 {
 427         test_speed_poly1305_inner("Poly1305 (ctmul32)",
 428                 &br_poly1305_ctmul32_run);
 429 }
 430
 431 static void
 432 test_speed_poly1305_ctmulq(void)
 433 {
 434         br_poly1305_run bp;
 435
 436         bp = br_poly1305_ctmulq_get();
 437         if (bp == 0) {
 438                 printf("%-30s UNAVAILABLE\n", "Poly1305 (ctmulq)");
 439         } else {
 440                 test_speed_poly1305_inner("Poly1305 (ctmulq)", bp);
 441         }
 442 }
 443
 444 static void
 445 test_speed_poly1305_i15(void)
 446 {
 447         test_speed_poly1305_inner("Poly1305 (i15)", &br_poly1305_i15_run);
 448 }
 449
 450 static void
 451 test_speed_eax_inner(char *name,
 452         const br_block_ctrcbc_class *vt, size_t key_len)
 453 {
 454         unsigned char buf[8192], key[32], nonce[16], aad[16], tag[16];
 455         int i;
 456         long num;
 457         br_aes_gen_ctrcbc_keys ac;
 458         br_eax_context ec;
 459
 460         if (vt == NULL) {
 461                 printf("%-30s UNAVAILABLE\n", name);
 462                 fflush(stdout);
 463                 return;
 464         }
 465         memset(key, 'K', key_len);
 466         memset(nonce, 'N', sizeof nonce);
 467         memset(aad, 'A', sizeof aad);
 468         memset(buf, 'T', sizeof buf);
 469         for (i = 0; i < 10; i ++) {
 470                 vt->init(&ac.vtable, key, key_len);
 471                 br_eax_init(&ec, &ac.vtable);
 472                 br_eax_reset(&ec, nonce, sizeof nonce);
 473                 br_eax_aad_inject(&ec, aad, sizeof aad);
 474                 br_eax_flip(&ec);
 475                 br_eax_run(&ec, 1, buf, sizeof buf);
 476                 br_eax_get_tag(&ec, tag);
 477         }
 478         num = 10;
 479         for (;;) {
 480                 clock_t begin, end;
 481                 double tt;
 482                 long k;
 483
 484                 begin = clock();
 485                 for (k = num; k > 0; k --) {
 486                         vt->init(&ac.vtable, key, key_len);
 487                         br_eax_init(&ec, &ac.vtable);
 488                         br_eax_reset(&ec, nonce, sizeof nonce);
 489                         br_eax_aad_inject(&ec, aad, sizeof aad);
 490                         br_eax_flip(&ec);
 491                         br_eax_run(&ec, 1, buf, sizeof buf);
 492                         br_eax_get_tag(&ec, tag);
 493                 }
 494                 end = clock();
 495                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
 496                 if (tt >= 2.0) {
 497                         printf("%-30s %8.2f MB/s\n", name,
 498                                 ((double)sizeof buf) * (double)num
 499                                 / (tt * 1000000.0));
 500                         fflush(stdout);
 501                         return;
 502                 }
 503                 num <<= 1;
 504         }
 505 }
 506
 507 #define SPEED_EAX(Algo, algo, keysize, impl) \
 508 static void \
 509 test_speed_eax_ ## algo ## keysize ## _ ## impl(void) \
 510 { \
 511         test_speed_eax_inner("EAX " #Algo "-" #keysize "(" #impl ")", \
 512                 br_ ## algo ## _ ## impl ##  _ctrcbc_get_vtable() \
 513                 , (keysize) >> 3); \
 514 }
 515
 516 SPEED_EAX(AES, aes, 128, big)
 517 SPEED_EAX(AES, aes, 128, small)
 518 SPEED_EAX(AES, aes, 128, ct)
 519 SPEED_EAX(AES, aes, 128, ct64)
 520 SPEED_EAX(AES, aes, 128, x86ni)
 521 SPEED_EAX(AES, aes, 128, pwr8)
 522 SPEED_EAX(AES, aes, 192, big)
 523 SPEED_EAX(AES, aes, 192, small)
 524 SPEED_EAX(AES, aes, 192, ct)
 525 SPEED_EAX(AES, aes, 192, ct64)
 526 SPEED_EAX(AES, aes, 192, x86ni)
 527 SPEED_EAX(AES, aes, 192, pwr8)
 528 SPEED_EAX(AES, aes, 256, big)
 529 SPEED_EAX(AES, aes, 256, small)
 530 SPEED_EAX(AES, aes, 256, ct)
 531 SPEED_EAX(AES, aes, 256, ct64)
 532 SPEED_EAX(AES, aes, 256, x86ni)
 533 SPEED_EAX(AES, aes, 256, pwr8)
 534
 535 static void
 536 test_speed_shake_inner(int security_level)
 537 {
 538         unsigned char buf[8192];
 539         br_shake_context sc;
 540         int i;
 541         long num;
 542
 543         memset(buf, 'D', sizeof buf);
 544         br_shake_init(&sc, security_level);
 545         for (i = 0; i < 10; i ++) {
 546                 br_shake_inject(&sc, buf, sizeof buf);
 547         }
 548         num = 10;
 549         for (;;) {
 550                 clock_t begin, end;
 551                 double tt;
 552                 long k;
 553
 554                 begin = clock();
 555                 for (k = num; k > 0; k --) {
 556                         br_shake_inject(&sc, buf, sizeof buf);
 557                 }
 558                 end = clock();
 559                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
 560                 if (tt >= 2.0) {
 561                         printf("SHAKE%-3d (inject)              %8.2f MB/s\n",
 562                                 security_level,
 563                                 ((double)sizeof buf) * (double)num
 564                                 / (tt * 1000000.0));
 565                         fflush(stdout);
 566                         break;
 567                 }
 568                 num <<= 1;
 569         }
 570
 571         br_shake_flip(&sc);
 572         for (i = 0; i < 10; i ++) {
 573                 br_shake_produce(&sc, buf, sizeof buf);
 574         }
 575
 576         num = 10;
 577         for (;;) {
 578                 clock_t begin, end;
 579                 double tt;
 580                 long k;
 581
 582                 begin = clock();
 583                 for (k = num; k > 0; k --) {
 584                         br_shake_produce(&sc, buf, sizeof buf);
 585                 }
 586                 end = clock();
 587                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
 588                 if (tt >= 2.0) {
 589                         printf("SHAKE%-3d (produce)             %8.2f MB/s\n",
 590                                 security_level,
 591                                 ((double)sizeof buf) * (double)num
 592                                 / (tt * 1000000.0));
 593                         fflush(stdout);
 594                         break;
 595                 }
 596                 num <<= 1;
 597         }
 598 }
 599
 600 static void
 601 test_speed_shake128(void)
 602 {
 603         test_speed_shake_inner(128);
 604 }
 605
 606 static void
 607 test_speed_shake256(void)
 608 {
 609         test_speed_shake_inner(256);
 610 }
 611
 612 static const unsigned char RSA_N[] = {
 613         0xE9, 0xF2, 0x4A, 0x2F, 0x96, 0xDF, 0x0A, 0x23,
 614         0x01, 0x85, 0xF1, 0x2C, 0xB2, 0xA8, 0xEF, 0x23,
 615         0xCE, 0x2E, 0xB0, 0x4E, 0x18, 0x31, 0x95, 0x5B,
 616         0x98, 0x2D, 0x9B, 0x8C, 0xE3, 0x1A, 0x2B, 0x96,
 617         0xB5, 0xC7, 0xEE, 0xED, 0x72, 0x43, 0x2D, 0xFE,
 618         0x7F, 0x61, 0x33, 0xEA, 0x14, 0xFC, 0xDE, 0x80,
 619         0x17, 0x42, 0xF0, 0xF3, 0xC3, 0xC7, 0x89, 0x47,
 620         0x76, 0x5B, 0xFA, 0x33, 0xC4, 0x8C, 0x94, 0xDE,
 621         0x6A, 0x75, 0xD8, 0x1A, 0xF4, 0x49, 0xBC, 0xF3,
 622         0xB7, 0x9E, 0x2C, 0x8D, 0xEC, 0x5A, 0xEE, 0xBF,
 623         0x4B, 0x5A, 0x7F, 0xEF, 0x21, 0x39, 0xDB, 0x1D,
 624         0x83, 0x5E, 0x7E, 0x2F, 0xAA, 0x5E, 0xBA, 0x28,
 625         0xC3, 0xA2, 0x53, 0x19, 0xFB, 0x2F, 0x78, 0x6B,
 626         0x14, 0x60, 0x49, 0x3C, 0xCC, 0x1B, 0xE9, 0x1E,
 627         0x3D, 0x10, 0xA4, 0xEB, 0x7F, 0x66, 0x98, 0xF6,
 628         0xC3, 0xAC, 0x35, 0xF5, 0x01, 0x84, 0xFF, 0x7D,
 629         0x1F, 0x72, 0xBE, 0xB4, 0xD1, 0x89, 0xC8, 0xDD,
 630         0x44, 0xE7, 0xB5, 0x2E, 0x2C, 0xE1, 0x85, 0xF5,
 631         0x15, 0x50, 0xA9, 0x08, 0xC7, 0x67, 0xD9, 0x2B,
 632         0x6C, 0x11, 0xB3, 0xEB, 0x28, 0x8D, 0xF4, 0xCC,
 633         0xE3, 0xC3, 0xC5, 0x04, 0x0E, 0x7C, 0x8D, 0xDB,
 634         0x39, 0x06, 0x6A, 0x74, 0x75, 0xDF, 0xA8, 0x0F,
 635         0xDA, 0x67, 0x5A, 0x73, 0x1E, 0xFD, 0x8E, 0x4C,
 636         0xEE, 0x17, 0xEE, 0x1E, 0x67, 0xDB, 0x98, 0x70,
 637         0x60, 0xF7, 0xB9, 0xB5, 0x1F, 0x19, 0x93, 0xD6,
 638         0x3F, 0x2F, 0x1F, 0xB6, 0x5B, 0x59, 0xAA, 0x85,
 639         0xBB, 0x25, 0xE4, 0x13, 0xEF, 0xE7, 0xB9, 0x87,
 640         0x9C, 0x3F, 0x5E, 0xE4, 0x08, 0xA3, 0x51, 0xCF,
 641         0x8B, 0xAD, 0xF4, 0xE6, 0x1A, 0x5F, 0x51, 0xDD,
 642         0xA8, 0xBE, 0xE8, 0xD1, 0x20, 0x19, 0x61, 0x6C,
 643         0x18, 0xAB, 0xCA, 0x0A, 0xD9, 0x82, 0xA6, 0x94,
 644         0xD5, 0x69, 0x2A, 0xF6, 0x43, 0x66, 0x31, 0x09
 645 };
 646
 647 static const unsigned char RSA_E[] = {
 648         0x01, 0x00, 0x01
 649 };
 650
 651 static const unsigned char RSA_P[] = {
 652         0xFD, 0x39, 0x40, 0x56, 0x20, 0x80, 0xC5, 0x81,
 653         0x4C, 0x5F, 0x0C, 0x1A, 0x52, 0x84, 0x03, 0x2F,
 654         0xCE, 0x82, 0xB0, 0xD8, 0x30, 0x23, 0x7F, 0x77,
 655         0x45, 0xC2, 0x01, 0xC4, 0x68, 0x96, 0x0D, 0xA7,
 656         0x22, 0xA9, 0x6C, 0xA9, 0x1A, 0x33, 0xE5, 0x2F,
 657         0xB5, 0x07, 0x9A, 0xF9, 0xEA, 0x33, 0xA5, 0xC8,
 658         0x96, 0x60, 0x6A, 0xCA, 0xEB, 0xE5, 0x6E, 0x09,
 659         0x46, 0x7E, 0x2D, 0xEF, 0x93, 0x7D, 0x56, 0xED,
 660         0x75, 0x70, 0x3B, 0x96, 0xC4, 0xD5, 0xDB, 0x0B,
 661         0x3F, 0x69, 0xDF, 0x06, 0x18, 0x76, 0xF4, 0xCF,
 662         0xF8, 0x84, 0x22, 0xDF, 0xBD, 0x71, 0x62, 0x7B,
 663         0x67, 0x99, 0xBC, 0x09, 0x95, 0x54, 0xA4, 0x98,
 664         0x83, 0xF5, 0xA9, 0xCF, 0x09, 0xA5, 0x1F, 0x61,
 665         0x25, 0xB4, 0x70, 0x6C, 0x91, 0xB8, 0xB3, 0xD0,
 666         0xCE, 0x9C, 0x45, 0x65, 0x9B, 0xEF, 0xD4, 0x70,
 667         0xBE, 0x86, 0xD2, 0x98, 0x5D, 0xEB, 0xE3, 0xFF
 668 };
 669
 670 static const unsigned char RSA_Q[] = {
 671         0xEC, 0x82, 0xEE, 0x63, 0x5F, 0x40, 0x52, 0xDB,
 672         0x38, 0x7A, 0x37, 0x6A, 0x54, 0x5B, 0xD9, 0xA0,
 673         0x73, 0xB4, 0xBB, 0x52, 0xB2, 0x84, 0x07, 0xD0,
 674         0xCC, 0x82, 0x0D, 0x20, 0xB3, 0xFA, 0xD5, 0xB6,
 675         0x25, 0x92, 0x35, 0x4D, 0xB4, 0xC7, 0x36, 0x48,
 676         0xCE, 0x5E, 0x21, 0x4A, 0xA6, 0x74, 0x65, 0xF4,
 677         0x7D, 0x1D, 0xBC, 0x3B, 0xE2, 0xF4, 0x3E, 0x11,
 678         0x58, 0x10, 0x6C, 0x04, 0x46, 0x9E, 0x8D, 0x57,
 679         0xE0, 0x04, 0xE2, 0xEC, 0x47, 0xCF, 0xB3, 0x2A,
 680         0xFD, 0x4C, 0x55, 0x18, 0xDB, 0xDE, 0x3B, 0xDC,
 681         0xF4, 0x5B, 0xDA, 0xF3, 0x1A, 0xC8, 0x41, 0x6F,
 682         0x73, 0x3B, 0xFE, 0x3C, 0xA0, 0xDB, 0xBA, 0x6E,
 683         0x65, 0xA5, 0xE8, 0x02, 0xA5, 0x6C, 0xEA, 0x03,
 684         0xF6, 0x99, 0xF7, 0xCB, 0x4B, 0xB7, 0x11, 0x51,
 685         0x93, 0x88, 0x3F, 0xF9, 0x06, 0x85, 0xA9, 0x1E,
 686         0xCA, 0x64, 0xF8, 0x11, 0xA5, 0x1A, 0xCA, 0xF7
 687 };
 688
 689 static const unsigned char RSA_DP[] = {
 690         0x77, 0x95, 0xE0, 0x02, 0x4C, 0x9B, 0x43, 0xAA,
 691         0xCA, 0x4C, 0x60, 0xC4, 0xD5, 0x8F, 0x2E, 0x8A,
 692         0x17, 0x36, 0xB5, 0x19, 0x83, 0xB2, 0x5F, 0xF2,
 693         0x0D, 0xE9, 0x8F, 0x38, 0x18, 0x44, 0x34, 0xF2,
 694         0x67, 0x76, 0x27, 0xB0, 0xBC, 0x85, 0x21, 0x89,
 695         0x24, 0x2F, 0x11, 0x4B, 0x51, 0x05, 0x4F, 0x17,
 696         0xA9, 0x9C, 0xA3, 0x12, 0x6D, 0xD1, 0x0D, 0xE4,
 697         0x27, 0x7C, 0x53, 0x69, 0x3E, 0xF8, 0x04, 0x63,
 698         0x64, 0x00, 0xBA, 0xC3, 0x7A, 0xF5, 0x9B, 0xDA,
 699         0x75, 0xFA, 0x23, 0xAF, 0x17, 0x42, 0xA6, 0x5E,
 700         0xC8, 0xF8, 0x6E, 0x17, 0xC7, 0xB9, 0x92, 0x4E,
 701         0xC1, 0x20, 0x63, 0x23, 0x0B, 0x78, 0xCB, 0xBA,
 702         0x93, 0x27, 0x23, 0x28, 0x79, 0x5F, 0x97, 0xB0,
 703         0x23, 0x44, 0x51, 0x8B, 0x94, 0x4D, 0xEB, 0xED,
 704         0x82, 0x85, 0x5E, 0x68, 0x9B, 0xF9, 0xE9, 0x13,
 705         0xCD, 0x86, 0x92, 0x52, 0x0E, 0x98, 0xE6, 0x35
 706 };
 707
 708 static const unsigned char RSA_DQ[] = {
 709         0xD8, 0xDD, 0x71, 0xB3, 0x62, 0xBA, 0xBB, 0x7E,
 710         0xD1, 0xF9, 0x96, 0xE8, 0x83, 0xB3, 0xB9, 0x08,
 711         0x9C, 0x30, 0x03, 0x77, 0xDF, 0xC2, 0x9A, 0xDC,
 712         0x05, 0x39, 0xD6, 0xC9, 0xBE, 0xDE, 0x68, 0xA9,
 713         0xDD, 0x27, 0x84, 0x82, 0xDD, 0x19, 0xB1, 0x97,
 714         0xEE, 0xCA, 0x77, 0x22, 0x59, 0x20, 0xEF, 0xFF,
 715         0xCF, 0xDD, 0xBD, 0x24, 0xF8, 0x84, 0xD6, 0x88,
 716         0xD6, 0xC4, 0x30, 0x17, 0x77, 0x9D, 0x98, 0xA3,
 717         0x14, 0x01, 0xC7, 0x05, 0xBB, 0x0F, 0x23, 0x0D,
 718         0x6F, 0x37, 0x57, 0xEC, 0x34, 0x67, 0x41, 0x62,
 719         0xE8, 0x19, 0x75, 0xD9, 0x66, 0x1C, 0x6B, 0x8B,
 720         0xC3, 0x11, 0x26, 0x9C, 0xF7, 0x2E, 0xA3, 0x72,
 721         0xE8, 0xF7, 0xC8, 0x96, 0xEC, 0x92, 0xC2, 0xBD,
 722         0xA1, 0x98, 0x2A, 0x93, 0x99, 0xB8, 0xA2, 0x43,
 723         0xB7, 0xD0, 0xBE, 0x40, 0x1C, 0x8F, 0xE0, 0xB4,
 724         0x20, 0x07, 0x97, 0x43, 0xAE, 0xAD, 0xB3, 0x9F
 725 };
 726
 727 static const unsigned char RSA_IQ[] = {
 728         0xB7, 0xE2, 0x60, 0xA9, 0x62, 0xEC, 0xEC, 0x0B,
 729         0x57, 0x02, 0x96, 0xF9, 0x36, 0x35, 0x2C, 0x37,
 730         0xAF, 0xC2, 0xEE, 0x71, 0x49, 0x26, 0x8E, 0x0F,
 731         0x27, 0xB1, 0xFA, 0x0F, 0xEA, 0xDC, 0xF0, 0x8B,
 732         0x53, 0x6C, 0xB2, 0x46, 0x27, 0xCD, 0x29, 0xA2,
 733         0x35, 0x0F, 0x5D, 0x8A, 0x3F, 0x20, 0x8C, 0x13,
 734         0x3D, 0xA1, 0xFF, 0x85, 0x91, 0x99, 0xE8, 0x50,
 735         0xED, 0xF1, 0x29, 0x00, 0xEE, 0x24, 0x90, 0xB5,
 736         0x5F, 0x3A, 0x74, 0x26, 0xD7, 0xA2, 0x24, 0x8D,
 737         0x89, 0x88, 0xD8, 0x35, 0x22, 0x22, 0x8A, 0x66,
 738         0x5D, 0x5C, 0xDE, 0x83, 0x8C, 0xFA, 0x27, 0xE6,
 739         0xB9, 0xEB, 0x72, 0x08, 0xCD, 0x53, 0x4B, 0x93,
 740         0x0F, 0xAD, 0xC3, 0xF8, 0x7C, 0xFE, 0x84, 0xD7,
 741         0x08, 0xF3, 0xBE, 0x3D, 0x60, 0x1E, 0x95, 0x8D,
 742         0x44, 0x5B, 0x65, 0x7E, 0xC1, 0x30, 0xC3, 0x84,
 743         0xC0, 0xB0, 0xFE, 0xBF, 0x28, 0x54, 0x1E, 0xC4
 744 };
 745
 746 static const br_rsa_public_key RSA_PK = {
 747         (void *)RSA_N, sizeof RSA_N,
 748         (void *)RSA_E, sizeof RSA_E
 749 };
 750
 751 static const br_rsa_private_key RSA_SK = {
 752         2048,
 753         (void *)RSA_P, sizeof RSA_P,
 754         (void *)RSA_Q, sizeof RSA_Q,
 755         (void *)RSA_DP, sizeof RSA_DP,
 756         (void *)RSA_DQ, sizeof RSA_DQ,
 757         (void *)RSA_IQ, sizeof RSA_IQ
 758 };
 759
 760 static void
 761 test_speed_rsa_inner(char *name,
 762         br_rsa_public fpub, br_rsa_private fpriv, br_rsa_keygen kgen)
 763 {
 764         unsigned char tmp[sizeof RSA_N];
 765         int i;
 766         long num;
 767         /*
 768         br_hmac_drbg_context rng;
 769         */
 770         br_aesctr_drbg_context rng;
 771         const br_block_ctr_class *ictr;
 772
 773         memset(tmp, 'R', sizeof tmp);
 774         tmp[0] = 0;
 775         for (i = 0; i < 10; i ++) {
 776                 if (!fpriv(tmp, &RSA_SK)) {
 777                         abort();
 778                 }
 779         }
 780         num = 10;
 781         for (;;) {
 782                 clock_t begin, end;
 783                 double tt;
 784                 long k;
 785
 786                 begin = clock();
 787                 for (k = num; k > 0; k --) {
 788                         fpriv(tmp, &RSA_SK);
 789                 }
 790                 end = clock();
 791                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
 792                 if (tt >= 2.0) {
 793                         printf("%-30s %8.2f priv/s\n", name,
 794                                 (double)num / tt);
 795                         fflush(stdout);
 796                         break;
 797                 }
 798                 num <<= 1;
 799         }
 800         for (i = 0; i < 10; i ++) {
 801                 if (!fpub(tmp, sizeof tmp, &RSA_PK)) {
 802                         abort();
 803                 }
 804         }
 805         num = 10;
 806         for (;;) {
 807                 clock_t begin, end;
 808                 double tt;
 809                 long k;
 810
 811                 begin = clock();
 812                 for (k = num; k > 0; k --) {
 813                         fpub(tmp, sizeof tmp, &RSA_PK);
 814                 }
 815                 end = clock();
 816                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
 817                 if (tt >= 2.0) {
 818                         printf("%-30s %8.2f pub/s\n", name,
 819                                 (double)num / tt);
 820                         fflush(stdout);
 821                         break;
 822                 }
 823                 num <<= 1;
 824         }
 825
 826         if (kgen == 0) {
 827                 printf("%-30s KEYGEN UNAVAILABLE\n", name);
 828                 fflush(stdout);
 829                 return;
 830         }
 831         /*
 832         br_hmac_drbg_init(&rng, &br_sha256_vtable, "RSA keygen seed", 15);
 833         */
 834         ictr = br_aes_x86ni_ctr_get_vtable();
 835         if (ictr == NULL) {
 836                 ictr = br_aes_pwr8_ctr_get_vtable();
 837                 if (ictr == NULL) {
 838 #if BR_64
 839                         ictr = &br_aes_ct64_ctr_vtable;
 840 #else
 841                         ictr = &br_aes_ct_ctr_vtable;
 842 #endif
 843                 }
 844         }
 845         br_aesctr_drbg_init(&rng, ictr, "RSA keygen seed", 15);
 846
 847         num = 10;
 848         for (;;) {
 849                 clock_t begin, end;
 850                 double tt;
 851                 long k;
 852
 853                 begin = clock();
 854                 for (k = num; k > 0; k --) {
 855                         br_rsa_private_key sk;
 856                         unsigned char kbuf[BR_RSA_KBUF_PRIV_SIZE(1024)];
 857
 858                         kgen(&rng.vtable, &sk, kbuf, NULL, NULL, 1024, 0);
 859                 }
 860                 end = clock();
 861                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
 862                 if (tt >= 10.0) {
 863                         printf("%-30s %8.2f kgen[1024]/s\n", name,
 864                                 (double)num / tt);
 865                         fflush(stdout);
 866                         break;
 867                 }
 868                 num <<= 1;
 869         }
 870
 871         num = 10;
 872         for (;;) {
 873                 clock_t begin, end;
 874                 double tt;
 875                 long k;
 876
 877                 begin = clock();
 878                 for (k = num; k > 0; k --) {
 879                         br_rsa_private_key sk;
 880                         unsigned char kbuf[BR_RSA_KBUF_PRIV_SIZE(2048)];
 881
 882                         kgen(&rng.vtable, &sk, kbuf, NULL, NULL, 2048, 0);
 883                 }
 884                 end = clock();
 885                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
 886                 if (tt >= 10.0) {
 887                         printf("%-30s %8.2f kgen[2048]/s\n", name,
 888                                 (double)num / tt);
 889                         fflush(stdout);
 890                         break;
 891                 }
 892                 num <<= 1;
 893         }
 894 }
 895
 896 static void
 897 test_speed_rsa_i15(void)
 898 {
 899         test_speed_rsa_inner("RSA i15",
 900                 &br_rsa_i15_public, &br_rsa_i15_private, &br_rsa_i15_keygen);
 901 }
 902
 903 static void
 904 test_speed_rsa_i31(void)
 905 {
 906         test_speed_rsa_inner("RSA i31",
 907                 &br_rsa_i31_public, &br_rsa_i31_private, &br_rsa_i31_keygen);
 908 }
 909
 910 static void
 911 test_speed_rsa_i32(void)
 912 {
 913         test_speed_rsa_inner("RSA i32",
 914                 &br_rsa_i32_public, &br_rsa_i32_private, 0);
 915 }
 916
 917 static void
 918 test_speed_rsa_i62(void)
 919 {
 920         br_rsa_public pub;
 921         br_rsa_private priv;
 922         br_rsa_keygen kgen;
 923
 924         pub = br_rsa_i62_public_get();
 925         priv = br_rsa_i62_private_get();
 926         kgen = br_rsa_i62_keygen_get();
 927         if (pub) {
 928                 test_speed_rsa_inner("RSA i62", pub, priv, kgen);
 929         } else {
 930                 printf("%-30s UNAVAILABLE\n", "RSA i62");
 931         }
 932 }
 933
 934 static void
 935 test_speed_ec_inner_1(const char *name,
 936         const br_ec_impl *impl, const br_ec_curve_def *cd)
 937 {
 938         unsigned char bx[80], U[160];
 939         uint32_t x[22], n[22];
 940         size_t nlen, ulen;
 941         int i;
 942         long num;
 943
 944         nlen = cd->order_len;
 945         br_i31_decode(n, cd->order, nlen);
 946         memset(bx, 'T', sizeof bx);
 947         br_i31_decode_reduce(x, bx, sizeof bx, n);
 948         br_i31_encode(bx, nlen, x);
 949         ulen = cd->generator_len;
 950         memcpy(U, cd->generator, ulen);
 951         for (i = 0; i < 10; i ++) {
 952                 impl->mul(U, ulen, bx, nlen, cd->curve);
 953         }
 954         num = 10;
 955         for (;;) {
 956                 clock_t begin, end;
 957                 double tt;
 958                 long k;
 959
 960                 begin = clock();
 961                 for (k = num; k > 0; k --) {
 962                         impl->mul(U, ulen, bx, nlen, cd->curve);
 963                 }
 964                 end = clock();
 965                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
 966                 if (tt >= 2.0) {
 967                         printf("%-30s %8.2f mul/s\n", name,
 968                                 (double)num / tt);
 969                         fflush(stdout);
 970                         break;
 971                 }
 972                 num <<= 1;
 973         }
 974 }
 975
 976 static void
 977 test_speed_ec_inner_2(const char *name,
 978         const br_ec_impl *impl, const br_ec_curve_def *cd)
 979 {
 980         unsigned char bx[80], U[160];
 981         uint32_t x[22], n[22];
 982         size_t nlen;
 983         int i;
 984         long num;
 985
 986         nlen = cd->order_len;
 987         br_i31_decode(n, cd->order, nlen);
 988         memset(bx, 'T', sizeof bx);
 989         br_i31_decode_reduce(x, bx, sizeof bx, n);
 990         br_i31_encode(bx, nlen, x);
 991         for (i = 0; i < 10; i ++) {
 992                 impl->mulgen(U, bx, nlen, cd->curve);
 993         }
 994         num = 10;
 995         for (;;) {
 996                 clock_t begin, end;
 997                 double tt;
 998                 long k;
 999
1000                 begin = clock();
1001                 for (k = num; k > 0; k --) {
1002                         impl->mulgen(U, bx, nlen, cd->curve);
1003                 }
1004                 end = clock();
1005                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
1006                 if (tt >= 2.0) {
1007                         printf("%-30s %8.2f mul/s\n", name,
1008                                 (double)num / tt);
1009                         fflush(stdout);
1010                         break;
1011                 }
1012                 num <<= 1;
1013         }
1014 }
1015
1016 static void
1017 test_speed_ec_inner(const char *name,
1018         const br_ec_impl *impl, const br_ec_curve_def *cd)
1019 {
1020         char tmp[50];
1021
1022         test_speed_ec_inner_1(name, impl, cd);
1023         sprintf(tmp, "%s (FP)", name);
1024         test_speed_ec_inner_2(tmp, impl, cd);
1025 }
1026
1027 static void
1028 test_speed_ec_p256_m15(void)
1029 {
1030         test_speed_ec_inner("EC p256_m15",
1031                 &br_ec_p256_m15, &br_secp256r1);
1032 }
1033
1034 static void
1035 test_speed_ec_p256_m31(void)
1036 {
1037         test_speed_ec_inner("EC p256_m31",
1038                 &br_ec_p256_m31, &br_secp256r1);
1039 }
1040
1041 static void
1042 test_speed_ec_p256_m62(void)
1043 {
1044         const br_ec_impl *ec;
1045
1046         ec = br_ec_p256_m62_get();
1047         if (ec != NULL) {
1048                 test_speed_ec_inner("EC p256_m62", ec, &br_secp256r1);
1049         } else {
1050                 printf("%-30s UNAVAILABLE\n", "EC p256_m62");
1051         }
1052 }
1053
1054 static void
1055 test_speed_ec_p256_m64(void)
1056 {
1057         const br_ec_impl *ec;
1058
1059         ec = br_ec_p256_m64_get();
1060         if (ec != NULL) {
1061                 test_speed_ec_inner("EC p256_m64", ec, &br_secp256r1);
1062         } else {
1063                 printf("%-30s UNAVAILABLE\n", "EC p256_m64");
1064         }
1065 }
1066
1067 static void
1068 test_speed_ec_prime_i15(void)
1069 {
1070         test_speed_ec_inner("EC prime_i15 P-256",
1071                 &br_ec_prime_i15, &br_secp256r1);
1072         test_speed_ec_inner("EC prime_i15 P-384",
1073                 &br_ec_prime_i15, &br_secp384r1);
1074         test_speed_ec_inner("EC prime_i15 P-521",
1075                 &br_ec_prime_i15, &br_secp521r1);
1076 }
1077
1078 static void
1079 test_speed_ec_prime_i31(void)
1080 {
1081         test_speed_ec_inner("EC prime_i31 P-256",
1082                 &br_ec_prime_i31, &br_secp256r1);
1083         test_speed_ec_inner("EC prime_i31 P-384",
1084                 &br_ec_prime_i31, &br_secp384r1);
1085         test_speed_ec_inner("EC prime_i31 P-521",
1086                 &br_ec_prime_i31, &br_secp521r1);
1087 }
1088
1089 static void
1090 test_speed_ec_c25519_i15(void)
1091 {
1092         test_speed_ec_inner("EC c25519_i15",
1093                 &br_ec_c25519_i15, &br_curve25519);
1094 }
1095
1096 static void
1097 test_speed_ec_c25519_i31(void)
1098 {
1099         test_speed_ec_inner("EC c25519_i31",
1100                 &br_ec_c25519_i31, &br_curve25519);
1101 }
1102
1103 static void
1104 test_speed_ec_c25519_m15(void)
1105 {
1106         test_speed_ec_inner("EC c25519_m15",
1107                 &br_ec_c25519_m15, &br_curve25519);
1108 }
1109
1110 static void
1111 test_speed_ec_c25519_m31(void)
1112 {
1113         test_speed_ec_inner("EC c25519_m31",
1114                 &br_ec_c25519_m31, &br_curve25519);
1115 }
1116
1117 static void
1118 test_speed_ec_c25519_m62(void)
1119 {
1120         const br_ec_impl *ec;
1121
1122         ec = br_ec_c25519_m62_get();
1123         if (ec != NULL) {
1124                 test_speed_ec_inner("EC c25519_m62", ec, &br_curve25519);
1125         } else {
1126                 printf("%-30s UNAVAILABLE\n", "EC c25519_m62");
1127         }
1128 }
1129
1130 static void
1131 test_speed_ec_c25519_m64(void)
1132 {
1133         const br_ec_impl *ec;
1134
1135         ec = br_ec_c25519_m64_get();
1136         if (ec != NULL) {
1137                 test_speed_ec_inner("EC c25519_m64", ec, &br_curve25519);
1138         } else {
1139                 printf("%-30s UNAVAILABLE\n", "EC c25519_m64");
1140         }
1141 }
1142
1143 static void
1144 test_speed_ecdsa_inner(const char *name,
1145         const br_ec_impl *impl, const br_ec_curve_def *cd,
1146         br_ecdsa_sign sign, br_ecdsa_vrfy vrfy)
1147 {
1148         unsigned char bx[80], U[160], hv[32], sig[160];
1149         uint32_t x[22], n[22];
1150         size_t nlen, ulen, sig_len;
1151         int i;
1152         long num;
1153         br_ec_private_key sk;
1154         br_ec_public_key pk;
1155
1156         nlen = cd->order_len;
1157         br_i31_decode(n, cd->order, nlen);
1158         memset(bx, 'T', sizeof bx);
1159         br_i31_decode_reduce(x, bx, sizeof bx, n);
1160         br_i31_encode(bx, nlen, x);
1161         ulen = cd->generator_len;
1162         memcpy(U, cd->generator, ulen);
1163         impl->mul(U, ulen, bx, nlen, cd->curve);
1164         sk.curve = cd->curve;
1165         sk.x = bx;
1166         sk.xlen = nlen;
1167         pk.curve = cd->curve;
1168         pk.q = U;
1169         pk.qlen = ulen;
1170
1171         memset(hv, 'H', sizeof hv);
1172         sig_len = sign(impl, &br_sha256_vtable, hv, &sk, sig);
1173         if (vrfy(impl, hv, sizeof hv, &pk, sig, sig_len) != 1) {
1174                 fprintf(stderr, "self-test sign/verify failed\n");
1175                 exit(EXIT_FAILURE);
1176         }
1177
1178         for (i = 0; i < 10; i ++) {
1179                 hv[1] ++;
1180                 sign(impl, &br_sha256_vtable, hv, &sk, sig);
1181                 vrfy(impl, hv, sizeof hv, &pk, sig, sig_len);
1182         }
1183
1184         num = 10;
1185         for (;;) {
1186                 clock_t begin, end;
1187                 double tt;
1188                 long k;
1189
1190                 begin = clock();
1191                 for (k = num; k > 0; k --) {
1192                         hv[1] ++;
1193                         sig_len = sign(impl, &br_sha256_vtable, hv, &sk, sig);
1194                 }
1195                 end = clock();
1196                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
1197                 if (tt >= 2.0) {
1198                         printf("%-30s %8.2f sign/s\n", name,
1199                                 (double)num / tt);
1200                         fflush(stdout);
1201                         break;
1202                 }
1203                 num <<= 1;
1204         }
1205
1206         num = 10;
1207         for (;;) {
1208                 clock_t begin, end;
1209                 double tt;
1210                 long k;
1211
1212                 begin = clock();
1213                 for (k = num; k > 0; k --) {
1214                         vrfy(impl, hv, sizeof hv, &pk, sig, sig_len);
1215                 }
1216                 end = clock();
1217                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
1218                 if (tt >= 2.0) {
1219                         printf("%-30s %8.2f verify/s\n", name,
1220                                 (double)num / tt);
1221                         fflush(stdout);
1222                         break;
1223                 }
1224                 num <<= 1;
1225         }
1226 }
1227
1228 static void
1229 test_speed_ecdsa_p256_m15(void)
1230 {
1231         test_speed_ecdsa_inner("ECDSA m15 P-256",
1232                 &br_ec_p256_m15, &br_secp256r1,
1233                 &br_ecdsa_i15_sign_asn1,
1234                 &br_ecdsa_i15_vrfy_asn1);
1235 }
1236
1237 static void
1238 test_speed_ecdsa_p256_m31(void)
1239 {
1240         test_speed_ecdsa_inner("ECDSA m31 P-256",
1241                 &br_ec_p256_m31, &br_secp256r1,
1242                 &br_ecdsa_i31_sign_asn1,
1243                 &br_ecdsa_i31_vrfy_asn1);
1244 }
1245
1246 static void
1247 test_speed_ecdsa_p256_m62(void)
1248 {
1249         const br_ec_impl *ec;
1250
1251         ec = br_ec_p256_m62_get();
1252         if (ec != NULL) {
1253                 test_speed_ecdsa_inner("ECDSA m62 P-256",
1254                         ec, &br_secp256r1,
1255                         &br_ecdsa_i31_sign_asn1,
1256                         &br_ecdsa_i31_vrfy_asn1);
1257         } else {
1258                 printf("%-30s UNAVAILABLE\n", "ECDSA m62 P-256");
1259         }
1260 }
1261
1262 static void
1263 test_speed_ecdsa_p256_m64(void)
1264 {
1265         const br_ec_impl *ec;
1266
1267         ec = br_ec_p256_m64_get();
1268         if (ec != NULL) {
1269                 test_speed_ecdsa_inner("ECDSA m64 P-256",
1270                         ec, &br_secp256r1,
1271                         &br_ecdsa_i31_sign_asn1,
1272                         &br_ecdsa_i31_vrfy_asn1);
1273         } else {
1274                 printf("%-30s UNAVAILABLE\n", "ECDSA m64 P-256");
1275         }
1276 }
1277
1278 static void
1279 test_speed_ecdsa_i15(void)
1280 {
1281         test_speed_ecdsa_inner("ECDSA i15 P-256",
1282                 &br_ec_prime_i15, &br_secp256r1,
1283                 &br_ecdsa_i15_sign_asn1,
1284                 &br_ecdsa_i15_vrfy_asn1);
1285         test_speed_ecdsa_inner("ECDSA i15 P-384",
1286                 &br_ec_prime_i15, &br_secp384r1,
1287                 &br_ecdsa_i15_sign_asn1,
1288                 &br_ecdsa_i15_vrfy_asn1);
1289         test_speed_ecdsa_inner("ECDSA i15 P-521",
1290                 &br_ec_prime_i15, &br_secp521r1,
1291                 &br_ecdsa_i15_sign_asn1,
1292                 &br_ecdsa_i15_vrfy_asn1);
1293 }
1294
1295 static void
1296 test_speed_ecdsa_i31(void)
1297 {
1298         test_speed_ecdsa_inner("ECDSA i31 P-256",
1299                 &br_ec_prime_i31, &br_secp256r1,
1300                 &br_ecdsa_i31_sign_asn1,
1301                 &br_ecdsa_i31_vrfy_asn1);
1302         test_speed_ecdsa_inner("ECDSA i31 P-384",
1303                 &br_ec_prime_i31, &br_secp384r1,
1304                 &br_ecdsa_i31_sign_asn1,
1305                 &br_ecdsa_i31_vrfy_asn1);
1306         test_speed_ecdsa_inner("ECDSA i31 P-521",
1307                 &br_ec_prime_i31, &br_secp521r1,
1308                 &br_ecdsa_i31_sign_asn1,
1309                 &br_ecdsa_i31_vrfy_asn1);
1310 }
1311
1312 static void
1313 test_speed_i31(void)
1314 {
1315         static const unsigned char bp[] = {
1316                 /* A 521-bit prime integer (order of the P-521 curve). */
1317                 0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1318                 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1319                 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1320                 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1321                 0xFF, 0xFA, 0x51, 0x86, 0x87, 0x83, 0xBF, 0x2F,
1322                 0x96, 0x6B, 0x7F, 0xCC, 0x01, 0x48, 0xF7, 0x09,
1323                 0xA5, 0xD0, 0x3B, 0xB5, 0xC9, 0xB8, 0x89, 0x9C,
1324                 0x47, 0xAE, 0xBB, 0x6F, 0xB7, 0x1E, 0x91, 0x38,
1325                 0x64, 0x09
1326         };
1327
1328         unsigned char tmp[60 + sizeof bp];
1329         uint32_t p[20], x[20], y[20], z[20], uu[60], p0i;
1330         int i;
1331         long num;
1332
1333         br_i31_decode(p, bp, sizeof bp);
1334         p0i = br_i31_ninv31(p[1]);
1335         memset(tmp, 'T', sizeof tmp);
1336         br_i31_decode_reduce(x, tmp, sizeof tmp, p);
1337         memset(tmp, 'U', sizeof tmp);
1338         br_i31_decode_reduce(y, tmp, sizeof tmp, p);
1339
1340         for (i = 0; i < 10; i ++) {
1341                 br_i31_to_monty(x, p);
1342         }
1343         num = 10;
1344         for (;;) {
1345                 clock_t begin, end;
1346                 double tt;
1347                 long k;
1348
1349                 begin = clock();
1350                 for (k = num; k > 0; k --) {
1351                         br_i31_to_monty(x, p);
1352                 }
1353                 end = clock();
1354                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
1355                 if (tt >= 2.0) {
1356                         printf("%-30s %8.2f ops/s\n", "i31 to_monty",
1357                                 (double)num / tt);
1358                         fflush(stdout);
1359                         break;
1360                 }
1361                 num <<= 1;
1362         }
1363
1364         for (i = 0; i < 10; i ++) {
1365                 br_i31_from_monty(x, p, p0i);
1366         }
1367         num = 10;
1368         for (;;) {
1369                 clock_t begin, end;
1370                 double tt;
1371                 long k;
1372
1373                 begin = clock();
1374                 for (k = num; k > 0; k --) {
1375                         br_i31_from_monty(x, p, p0i);
1376                 }
1377                 end = clock();
1378                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
1379                 if (tt >= 2.0) {
1380                         printf("%-30s %8.2f ops/s\n", "i31 from_monty",
1381                                 (double)num / tt);
1382                         fflush(stdout);
1383                         break;
1384                 }
1385                 num <<= 1;
1386         }
1387
1388         for (i = 0; i < 10; i ++) {
1389                 br_i31_montymul(z, x, y, p, p0i);
1390         }
1391         num = 10;
1392         for (;;) {
1393                 clock_t begin, end;
1394                 double tt;
1395                 long k;
1396
1397                 begin = clock();
1398                 for (k = num; k > 0; k --) {
1399                         br_i31_montymul(z, x, y, p, p0i);
1400                 }
1401                 end = clock();
1402                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
1403                 if (tt >= 2.0) {
1404                         printf("%-30s %8.2f ops/s\n", "i31 montymul",
1405                                 (double)num / tt);
1406                         fflush(stdout);
1407                         break;
1408                 }
1409                 num <<= 1;
1410         }
1411
1412         for (i = 0; i < 10; i ++) {
1413                 br_i31_moddiv(x, y, p, p0i, uu);
1414         }
1415         num = 10;
1416         for (;;) {
1417                 clock_t begin, end;
1418                 double tt;
1419                 long k;
1420
1421                 begin = clock();
1422                 for (k = num; k > 0; k --) {
1423                         br_i31_moddiv(x, y, p, p0i, uu);
1424                 }
1425                 end = clock();
1426                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
1427                 if (tt >= 2.0) {
1428                         printf("%-30s %8.2f ops/s\n", "i31 moddiv",
1429                                 (double)num / tt);
1430                         fflush(stdout);
1431                         break;
1432                 }
1433                 num <<= 1;
1434         }
1435 }
1436
1437 #if 0
1438
1439 static unsigned char P2048[] = {
1440         0xFD, 0xB6, 0xE0, 0x3E, 0x00, 0x49, 0x4C, 0xF0, 0x69, 0x3A, 0xDD, 0x7D,
1441         0xF8, 0xA2, 0x41, 0xB0, 0x6C, 0x67, 0xC5, 0xBA, 0xB8, 0x46, 0x80, 0xF5,
1442         0xBF, 0xAB, 0x98, 0xFC, 0x84, 0x73, 0xA5, 0x63, 0xC9, 0x52, 0x12, 0xDA,
1443         0x4C, 0xC1, 0x5B, 0x9D, 0x8D, 0xDF, 0xCD, 0xFE, 0xC5, 0xAD, 0x5A, 0x6F,
1444         0xDD, 0x02, 0xD9, 0xEC, 0x71, 0xEF, 0xEB, 0xB6, 0x95, 0xED, 0x94, 0x25,
1445         0x0E, 0x63, 0xDD, 0x6A, 0x52, 0xC7, 0x93, 0xAF, 0x85, 0x9D, 0x2C, 0xBE,
1446         0x5C, 0xBE, 0x35, 0xD8, 0xDD, 0x39, 0xEF, 0x1B, 0xB1, 0x49, 0x67, 0xB2,
1447         0x33, 0xC9, 0x7C, 0xE1, 0x51, 0x79, 0x51, 0x59, 0xCA, 0x6E, 0x2A, 0xDF,
1448         0x0D, 0x76, 0x1C, 0xE7, 0xA5, 0xC0, 0x1E, 0x6C, 0x56, 0x3A, 0x32, 0xE5,
1449         0xB5, 0xC5, 0xD4, 0xDB, 0xFE, 0xFF, 0xF8, 0xF2, 0x96, 0xA9, 0xC9, 0x65,
1450         0x59, 0x9E, 0x01, 0x79, 0x9D, 0x38, 0x68, 0x0F, 0xAD, 0x43, 0x3A, 0xD6,
1451         0x84, 0x0A, 0xE2, 0xEF, 0x96, 0xC1, 0x6D, 0x89, 0x74, 0x19, 0x63, 0x82,
1452         0x3B, 0xA0, 0x9C, 0xBA, 0x78, 0xDE, 0xDC, 0xC2, 0xE7, 0xD4, 0xFA, 0xD6,
1453         0x19, 0x21, 0x29, 0xAE, 0x5E, 0xF4, 0x38, 0x81, 0xC6, 0x9E, 0x0E, 0x3C,
1454         0xCD, 0xC0, 0xDC, 0x93, 0x5D, 0xFD, 0x9A, 0x5C, 0xAB, 0x54, 0x1F, 0xFF,
1455         0x9C, 0x12, 0x1B, 0x4C, 0xDF, 0x2D, 0x9C, 0x85, 0xF9, 0x68, 0x15, 0x89,
1456         0x42, 0x9B, 0x6C, 0x45, 0x89, 0x3A, 0xBC, 0xE9, 0x19, 0x91, 0xBE, 0x0C,
1457         0xEF, 0x90, 0xCC, 0xF6, 0xD6, 0xF0, 0x3D, 0x5C, 0xF5, 0xE5, 0x0F, 0x2F,
1458         0x02, 0x8A, 0x83, 0x4B, 0x93, 0x2F, 0x14, 0x12, 0x1F, 0x56, 0x9A, 0x12,
1459         0x58, 0x88, 0xAE, 0x60, 0xB8, 0x5A, 0xE4, 0xA1, 0xBF, 0x4A, 0x81, 0x84,
1460         0xAB, 0xBB, 0xE4, 0xD0, 0x1D, 0x41, 0xD9, 0x0A, 0xAB, 0x1E, 0x47, 0x5B,
1461         0x31, 0xAC, 0x2B, 0x73
1462 };
1463
1464 static unsigned char G2048[] = {
1465         0x02
1466 };
1467
1468 static void
1469 test_speed_modpow(void)
1470 {
1471         uint32_t mx[65], mp[65], me[65], t1[65], t2[65], len;
1472         unsigned char e[64];
1473         int i;
1474         long num;
1475
1476         len = br_int_decode(mp, sizeof mp / sizeof mp[0],
1477                 P2048, sizeof P2048);
1478         if (len != 65) {
1479                 abort();
1480         }
1481         memset(e, 'P', sizeof e);
1482         if (!br_int_decode(me, sizeof me / sizeof me[0], e, sizeof e)) {
1483                 abort();
1484         }
1485         if (!br_modint_decode(mx, mp, G2048, sizeof G2048)) {
1486                 abort();
1487         }
1488         for (i = 0; i < 10; i ++) {
1489                 br_modint_to_monty(mx, mp);
1490                 br_modint_montypow(mx, me, mp, t1, t2);
1491                 br_modint_from_monty(mx, mp);
1492         }
1493         num = 10;
1494         for (;;) {
1495                 clock_t begin, end;
1496                 double tt;
1497                 long k;
1498
1499                 begin = clock();
1500                 for (k = num; k > 0; k --) {
1501                         br_modint_to_monty(mx, mp);
1502                         br_modint_montypow(mx, me, mp, t1, t2);
1503                         br_modint_from_monty(mx, mp);
1504                 }
1505                 end = clock();
1506                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
1507                 if (tt >= 2.0) {
1508                         printf("%-30s %8.2f exp/s\n", "pow[2048:256]",
1509                                 (double)num / tt);
1510                         fflush(stdout);
1511                         return;
1512                 }
1513                 num <<= 1;
1514         }
1515 }
1516
1517 static void
1518 test_speed_moddiv(void)
1519 {
1520         uint32_t mx[65], my[65], mp[65], t1[65], t2[65], t3[65], len;
1521         unsigned char x[255], y[255];
1522         int i;
1523         long num;
1524
1525         len = br_int_decode(mp, sizeof mp / sizeof mp[0],
1526                 P2048, sizeof P2048);
1527         if (len != 65) {
1528                 abort();
1529         }
1530         memset(x, 'T', sizeof x);
1531         memset(y, 'P', sizeof y);
1532         if (!br_modint_decode(mx, mp, x, sizeof x)) {
1533                 abort();
1534         }
1535         if (!br_modint_decode(my, mp, y, sizeof y)) {
1536                 abort();
1537         }
1538         for (i = 0; i < 10; i ++) {
1539                 br_modint_div(mx, my, mp, t1, t2, t3);
1540         }
1541         num = 10;
1542         for (;;) {
1543                 clock_t begin, end;
1544                 double tt;
1545                 long k;
1546
1547                 begin = clock();
1548                 for (k = num; k > 0; k --) {
1549                         br_modint_div(mx, my, mp, t1, t2, t3);
1550                 }
1551                 end = clock();
1552                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
1553                 if (tt >= 2.0) {
1554                         printf("%-30s %8.2f div/s\n", "div[2048]",
1555                                 (double)num / tt);
1556                         fflush(stdout);
1557                         return;
1558                 }
1559                 num <<= 1;
1560         }
1561 }
1562 #endif
1563
1564 #define STU(x)   { test_speed_ ## x, #x }
1565
1566 static const struct {
1567         void (*fn)(void);
1568         char *name;
1569 } tfns[] = {
1570         STU(md5),
1571         STU(sha1),
1572         STU(sha256),
1573         STU(sha512),
1574
1575         STU(aes128_big_cbcenc),
1576         STU(aes128_big_cbcdec),
1577         STU(aes192_big_cbcenc),
1578         STU(aes192_big_cbcdec),
1579         STU(aes256_big_cbcenc),
1580         STU(aes256_big_cbcdec),
1581         STU(aes128_big_ctr),
1582         STU(aes192_big_ctr),
1583         STU(aes256_big_ctr),
1584
1585         STU(aes128_small_cbcenc),
1586         STU(aes128_small_cbcdec),
1587         STU(aes192_small_cbcenc),
1588         STU(aes192_small_cbcdec),
1589         STU(aes256_small_cbcenc),
1590         STU(aes256_small_cbcdec),
1591         STU(aes128_small_ctr),
1592         STU(aes192_small_ctr),
1593         STU(aes256_small_ctr),
1594
1595         STU(aes128_ct_cbcenc),
1596         STU(aes128_ct_cbcdec),
1597         STU(aes192_ct_cbcenc),
1598         STU(aes192_ct_cbcdec),
1599         STU(aes256_ct_cbcenc),
1600         STU(aes256_ct_cbcdec),
1601         STU(aes128_ct_ctr),
1602         STU(aes192_ct_ctr),
1603         STU(aes256_ct_ctr),
1604
1605         STU(aes128_ct64_cbcenc),
1606         STU(aes128_ct64_cbcdec),
1607         STU(aes192_ct64_cbcenc),
1608         STU(aes192_ct64_cbcdec),
1609         STU(aes256_ct64_cbcenc),
1610         STU(aes256_ct64_cbcdec),
1611         STU(aes128_ct64_ctr),
1612         STU(aes192_ct64_ctr),
1613         STU(aes256_ct64_ctr),
1614
1615         STU(aes128_x86ni_cbcenc),
1616         STU(aes128_x86ni_cbcdec),
1617         STU(aes192_x86ni_cbcenc),
1618         STU(aes192_x86ni_cbcdec),
1619         STU(aes256_x86ni_cbcenc),
1620         STU(aes256_x86ni_cbcdec),
1621         STU(aes128_x86ni_ctr),
1622         STU(aes192_x86ni_ctr),
1623         STU(aes256_x86ni_ctr),
1624
1625         STU(aes128_pwr8_cbcenc),
1626         STU(aes128_pwr8_cbcdec),
1627         STU(aes192_pwr8_cbcenc),
1628         STU(aes192_pwr8_cbcdec),
1629         STU(aes256_pwr8_cbcenc),
1630         STU(aes256_pwr8_cbcdec),
1631         STU(aes128_pwr8_ctr),
1632         STU(aes192_pwr8_ctr),
1633         STU(aes256_pwr8_ctr),
1634
1635         STU(des_tab_cbcenc),
1636         STU(des_tab_cbcdec),
1637         STU(3des_tab_cbcenc),
1638         STU(3des_tab_cbcdec),
1639
1640         STU(des_ct_cbcenc),
1641         STU(des_ct_cbcdec),
1642         STU(3des_ct_cbcenc),
1643         STU(3des_ct_cbcdec),
1644
1645         STU(chacha20_ct),
1646         STU(chacha20_sse2),
1647
1648         STU(ghash_ctmul),
1649         STU(ghash_ctmul32),
1650         STU(ghash_ctmul64),
1651         STU(ghash_pclmul),
1652         STU(ghash_pwr8),
1653
1654         STU(poly1305_ctmul),
1655         STU(poly1305_ctmul32),
1656         STU(poly1305_ctmulq),
1657         STU(poly1305_i15),
1658
1659         STU(eax_aes128_big),
1660         STU(eax_aes192_big),
1661         STU(eax_aes256_big),
1662         STU(eax_aes128_small),
1663         STU(eax_aes192_small),
1664         STU(eax_aes256_small),
1665         STU(eax_aes128_ct),
1666         STU(eax_aes192_ct),
1667         STU(eax_aes256_ct),
1668         STU(eax_aes128_ct64),
1669         STU(eax_aes192_ct64),
1670         STU(eax_aes256_ct64),
1671         STU(eax_aes128_x86ni),
1672         STU(eax_aes192_x86ni),
1673         STU(eax_aes256_x86ni),
1674         STU(eax_aes128_pwr8),
1675         STU(eax_aes192_pwr8),
1676         STU(eax_aes256_pwr8),
1677
1678         STU(shake128),
1679         STU(shake256),
1680
1681         STU(rsa_i15),
1682         STU(rsa_i31),
1683         STU(rsa_i32),
1684         STU(rsa_i62),
1685         STU(ec_prime_i15),
1686         STU(ec_prime_i31),
1687         STU(ec_p256_m15),
1688         STU(ec_p256_m31),
1689         STU(ec_p256_m62),
1690         STU(ec_p256_m64),
1691         STU(ec_c25519_i15),
1692         STU(ec_c25519_i31),
1693         STU(ec_c25519_m15),
1694         STU(ec_c25519_m31),
1695         STU(ec_c25519_m62),
1696         STU(ec_c25519_m64),
1697         STU(ecdsa_p256_m15),
1698         STU(ecdsa_p256_m31),
1699         STU(ecdsa_p256_m62),
1700         STU(ecdsa_p256_m64),
1701         STU(ecdsa_i15),
1702         STU(ecdsa_i31),
1703
1704         STU(i31)
1705 };
1706
1707 static int
1708 eq_name(const char *s1, const char *s2)
1709 {
1710         for (;;) {
1711                 int c1, c2;
1712
1713                 for (;;) {
1714                         c1 = *s1 ++;
1715                         if (c1 >= 'A' && c1 <= 'Z') {
1716                                 c1 += 'a' - 'A';
1717                         } else {
1718                                 switch (c1) {
1719                                 case '-': case '_': case '.': case ' ':
1720                                         continue;
1721                                 }
1722                         }
1723                         break;
1724                 }
1725                 for (;;) {
1726                         c2 = *s2 ++;
1727                         if (c2 >= 'A' && c2 <= 'Z') {
1728                                 c2 += 'a' - 'A';
1729                         } else {
1730                                 switch (c2) {
1731                                 case '-': case '_': case '.': case ' ':
1732                                         continue;
1733                                 }
1734                         }
1735                         break;
1736                 }
1737                 if (c1 != c2) {
1738                         return 0;
1739                 }
1740                 if (c1 == 0) {
1741                         return 1;
1742                 }
1743         }
1744 }
1745
1746 int
1747 main(int argc, char *argv[])
1748 {
1749         size_t u;
1750
1751         if (argc <= 1) {
1752                 printf("usage: testspeed all | name...\n");
1753                 printf("individual test names:\n");
1754                 for (u = 0; u < (sizeof tfns) / (sizeof tfns[0]); u ++) {
1755                         printf("   %s\n", tfns[u].name);
1756                 }
1757         } else {
1758                 for (u = 0; u < (sizeof tfns) / (sizeof tfns[0]); u ++) {
1759                         int i;
1760
1761                         for (i = 1; i < argc; i ++) {
1762                                 if (eq_name(argv[i], tfns[u].name)
1763                                         || eq_name(argv[i], "all"))
1764                                 {
1765                                         tfns[u].fn();
1766                                         break;
1767                                 }
1768                         }
1769                 }
1770         }
1771         return 0;
1772 }