_ Git - BearSSL/blob - 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 ## _vtable; \
  92         for (i = 0; i < 10; i ++) { \
  93                 vt->init(&ec.vtable, key, sizeof key); \
  94                 vt->run(&ec.vtable, iv, buf, sizeof buf); \
  95         } \
  96         num = 10; \
  97         for (;;) { \
  98                 clock_t begin, end; \
  99                 double tt; \
 100                 long k; \
 101  \
 102                 vt->init(&ec.vtable, key, sizeof key); \
 103                 begin = clock(); \
 104                 for (k = num; k > 0; k --) { \
 105                         vt->run(&ec.vtable, iv, buf, sizeof buf); \
 106                 } \
 107                 end = clock(); \
 108                 tt = (double)(end - begin) / CLOCKS_PER_SEC; \
 109                 if (tt >= 2.0) { \
 110                         printf("%-30s %8.2f MB/s\n", #Name, \
 111                                 ((double)sizeof buf) * (double)num \
 112                                 / (tt * 1000000.0)); \
 113                         fflush(stdout); \
 114                         return; \
 115                 } \
 116                 num <<= 1; \
 117         } \
 118 }
 119
 120 #define SPEED_BLOCKCIPHER_CTR(Name, fname, cname, klen) \
 121 static void \
 122 test_speed_ ## fname(void) \
 123 { \
 124         unsigned char key[klen]; \
 125         unsigned char buf[8192 - (8192 % BLOCK_SIZE(cname))]; \
 126         unsigned char iv[BLOCK_SIZE(cname) - 4]; \
 127         const br_block_ctr_class *vt; \
 128         br_ ## cname ## _ctr_keys ec; \
 129         int i; \
 130         long num; \
 131  \
 132         memset(key, 'T', sizeof key); \
 133         memset(buf, 'P', sizeof buf); \
 134         memset(iv, 'X', sizeof iv); \
 135         vt = &br_ ## cname ## _ctr_vtable; \
 136         for (i = 0; i < 10; i ++) { \
 137                 vt->init(&ec.vtable, key, sizeof key); \
 138                 vt->run(&ec.vtable, iv, 1, buf, sizeof buf); \
 139         } \
 140         num = 10; \
 141         for (;;) { \
 142                 clock_t begin, end; \
 143                 double tt; \
 144                 long k; \
 145  \
 146                 vt->init(&ec.vtable, key, sizeof key); \
 147                 begin = clock(); \
 148                 for (k = num; k > 0; k --) { \
 149                         vt->run(&ec.vtable, iv, 1, buf, sizeof buf); \
 150                 } \
 151                 end = clock(); \
 152                 tt = (double)(end - begin) / CLOCKS_PER_SEC; \
 153                 if (tt >= 2.0) { \
 154                         printf("%-30s %8.2f MB/s\n", #Name, \
 155                                 ((double)sizeof buf) * (double)num \
 156                                 / (tt * 1000000.0)); \
 157                         fflush(stdout); \
 158                         return; \
 159                 } \
 160                 num <<= 1; \
 161         } \
 162 }
 163
 164 #define SPEED_CHACHA20(Name, fname) \
 165 static void \
 166 test_speed_ ## fname(void) \
 167 { \
 168         unsigned char key[32]; \
 169         unsigned char buf[8192]; \
 170         unsigned char iv[12]; \
 171         int i; \
 172         long num; \
 173  \
 174         memset(key, 'T', sizeof key); \
 175         memset(buf, 'P', sizeof buf); \
 176         memset(iv, 'X', sizeof iv); \
 177         for (i = 0; i < 10; i ++) { \
 178                 br_ ## fname ## _run(key, iv, i, buf, sizeof buf); \
 179         } \
 180         num = 10; \
 181         for (;;) { \
 182                 clock_t begin, end; \
 183                 double tt; \
 184                 long k; \
 185  \
 186                 begin = clock(); \
 187                 for (k = num; k > 0; k --) { \
 188                         br_ ## fname ## _run(key, iv, \
 189                                 (uint32_t)k, buf, sizeof buf); \
 190                 } \
 191                 end = clock(); \
 192                 tt = (double)(end - begin) / CLOCKS_PER_SEC; \
 193                 if (tt >= 2.0) { \
 194                         printf("%-30s %8.2f MB/s\n", #Name, \
 195                                 ((double)sizeof buf) * (double)num \
 196                                 / (tt * 1000000.0)); \
 197                         fflush(stdout); \
 198                         return; \
 199                 } \
 200                 num <<= 1; \
 201         } \
 202 }
 203
 204 SPEED_HASH(MD5, md5)
 205 SPEED_HASH(SHA-1, sha1)
 206 SPEED_HASH(SHA-256, sha256)
 207 SPEED_HASH(SHA-512, sha512)
 208
 209 #define SPEED_AES(iname) \
 210 SPEED_BLOCKCIPHER_CBC(AES-128 CBC encrypt (iname), aes128_ ## iname ## _cbcenc, aes_ ## iname, 16, enc) \
 211 SPEED_BLOCKCIPHER_CBC(AES-128 CBC decrypt (iname), aes128_ ## iname ## _cbcdec, aes_ ## iname, 16, dec) \
 212 SPEED_BLOCKCIPHER_CBC(AES-192 CBC encrypt (iname), aes192_ ## iname ## _cbcenc, aes_ ## iname, 24, enc) \
 213 SPEED_BLOCKCIPHER_CBC(AES-192 CBC decrypt (iname), aes192_ ## iname ## _cbcdec, aes_ ## iname, 24, dec) \
 214 SPEED_BLOCKCIPHER_CBC(AES-256 CBC encrypt (iname), aes256_ ## iname ## _cbcenc, aes_ ## iname, 32, enc) \
 215 SPEED_BLOCKCIPHER_CBC(AES-256 CBC decrypt (iname), aes256_ ## iname ## _cbcdec, aes_ ## iname, 32, dec) \
 216 SPEED_BLOCKCIPHER_CTR(AES-128 CTR (iname), aes128_ ## iname ## _ctr, aes_ ## iname, 16) \
 217 SPEED_BLOCKCIPHER_CTR(AES-192 CTR (iname), aes192_ ## iname ## _ctr, aes_ ## iname, 24) \
 218 SPEED_BLOCKCIPHER_CTR(AES-256 CTR (iname), aes256_ ## iname ## _ctr, aes_ ## iname, 32)
 219
 220 SPEED_AES(big)
 221 SPEED_AES(small)
 222 SPEED_AES(ct)
 223 SPEED_AES(ct64)
 224
 225 #define SPEED_DES(iname) \
 226 SPEED_BLOCKCIPHER_CBC(DES CBC encrypt (iname), des_ ## iname ## _cbcenc, des_ ## iname, 8, enc) \
 227 SPEED_BLOCKCIPHER_CBC(DES CBC decrypt (iname), des_ ## iname ## _cbcdec, des_ ## iname, 8, dec) \
 228 SPEED_BLOCKCIPHER_CBC(3DES CBC encrypt (iname), 3des_ ## iname ## _cbcenc, des_ ## iname, 24, enc) \
 229 SPEED_BLOCKCIPHER_CBC(3DES CBC decrypt (iname), 3des_ ## iname ## _cbcdec, des_ ## iname, 24, dec)
 230
 231 SPEED_DES(tab)
 232 SPEED_DES(ct)
 233
 234 SPEED_CHACHA20(ChaCha20, chacha20_ct)
 235
 236 static void
 237 test_speed_ghash_inner(char *name, br_ghash gh)
 238 {
 239         unsigned char buf[8192], h[16], y[16];
 240         int i;
 241         long num;
 242
 243         memset(buf, 'T', sizeof buf);
 244         memset(h, 'P', sizeof h);
 245         memset(y, 0, sizeof y);
 246         for (i = 0; i < 10; i ++) {
 247                 gh(y, h, buf, sizeof buf);
 248         }
 249         num = 10;
 250         for (;;) {
 251                 clock_t begin, end;
 252                 double tt;
 253                 long k;
 254
 255                 begin = clock();
 256                 for (k = num; k > 0; k --) {
 257                         gh(y, h, buf, sizeof buf);
 258                 }
 259                 end = clock();
 260                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
 261                 if (tt >= 2.0) {
 262                         printf("%-30s %8.2f MB/s\n", name,
 263                                 ((double)sizeof buf) * (double)num
 264                                 / (tt * 1000000.0));
 265                         fflush(stdout);
 266                         return;
 267                 }
 268                 num <<= 1;
 269         }
 270 }
 271
 272 static void
 273 test_speed_ghash_ctmul(void)
 274 {
 275         test_speed_ghash_inner("GHASH (ctmul)", &br_ghash_ctmul);
 276 }
 277
 278 static void
 279 test_speed_ghash_ctmul32(void)
 280 {
 281         test_speed_ghash_inner("GHASH (ctmul32)", &br_ghash_ctmul32);
 282 }
 283
 284 static void
 285 test_speed_ghash_ctmul64(void)
 286 {
 287         test_speed_ghash_inner("GHASH (ctmul64)", &br_ghash_ctmul64);
 288 }
 289
 290 static uint32_t
 291 fake_chacha20(const void *key, const void *iv,
 292         uint32_t cc, void *data, size_t len)
 293 {
 294         (void)key;
 295         (void)iv;
 296         (void)data;
 297         (void)len;
 298         return cc + (uint32_t)((len + 63) >> 6);
 299 }
 300
 301 /*
 302  * To speed-test Poly1305, we run it with a do-nothing stub instead of
 303  * ChaCha20.
 304  */
 305 static void
 306 test_speed_poly1305_inner(char *name, br_poly1305_run pl)
 307 {
 308         unsigned char buf[8192], key[32], iv[12], aad[13], tag[16];
 309         int i;
 310         long num;
 311
 312         memset(key, 'K', sizeof key);
 313         memset(iv, 'I', sizeof iv);
 314         memset(aad, 'A', sizeof aad);
 315         memset(buf, 'T', sizeof buf);
 316         for (i = 0; i < 10; i ++) {
 317                 pl(key, iv, buf, sizeof buf,
 318                         aad, sizeof aad, tag, &fake_chacha20, 0);
 319         }
 320         num = 10;
 321         for (;;) {
 322                 clock_t begin, end;
 323                 double tt;
 324                 long k;
 325
 326                 begin = clock();
 327                 for (k = num; k > 0; k --) {
 328                         pl(key, iv, buf, sizeof buf,
 329                                 aad, sizeof aad, tag, &fake_chacha20, 0);
 330                 }
 331                 end = clock();
 332                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
 333                 if (tt >= 2.0) {
 334                         printf("%-30s %8.2f MB/s\n", name,
 335                                 ((double)sizeof buf) * (double)num
 336                                 / (tt * 1000000.0));
 337                         fflush(stdout);
 338                         return;
 339                 }
 340                 num <<= 1;
 341         }
 342 }
 343
 344 static void
 345 test_speed_poly1305_ctmul(void)
 346 {
 347         test_speed_poly1305_inner("Poly1305 (ctmul)", &br_poly1305_ctmul_run);
 348 }
 349
 350 static void
 351 test_speed_poly1305_ctmul32(void)
 352 {
 353         test_speed_poly1305_inner("Poly1305 (ctmul32)",
 354                 &br_poly1305_ctmul32_run);
 355 }
 356
 357 static void
 358 test_speed_poly1305_i15(void)
 359 {
 360         test_speed_poly1305_inner("Poly1305 (i15)", &br_poly1305_i15_run);
 361 }
 362
 363 static const unsigned char RSA_N[] = {
 364         0xE9, 0xF2, 0x4A, 0x2F, 0x96, 0xDF, 0x0A, 0x23,
 365         0x01, 0x85, 0xF1, 0x2C, 0xB2, 0xA8, 0xEF, 0x23,
 366         0xCE, 0x2E, 0xB0, 0x4E, 0x18, 0x31, 0x95, 0x5B,
 367         0x98, 0x2D, 0x9B, 0x8C, 0xE3, 0x1A, 0x2B, 0x96,
 368         0xB5, 0xC7, 0xEE, 0xED, 0x72, 0x43, 0x2D, 0xFE,
 369         0x7F, 0x61, 0x33, 0xEA, 0x14, 0xFC, 0xDE, 0x80,
 370         0x17, 0x42, 0xF0, 0xF3, 0xC3, 0xC7, 0x89, 0x47,
 371         0x76, 0x5B, 0xFA, 0x33, 0xC4, 0x8C, 0x94, 0xDE,
 372         0x6A, 0x75, 0xD8, 0x1A, 0xF4, 0x49, 0xBC, 0xF3,
 373         0xB7, 0x9E, 0x2C, 0x8D, 0xEC, 0x5A, 0xEE, 0xBF,
 374         0x4B, 0x5A, 0x7F, 0xEF, 0x21, 0x39, 0xDB, 0x1D,
 375         0x83, 0x5E, 0x7E, 0x2F, 0xAA, 0x5E, 0xBA, 0x28,
 376         0xC3, 0xA2, 0x53, 0x19, 0xFB, 0x2F, 0x78, 0x6B,
 377         0x14, 0x60, 0x49, 0x3C, 0xCC, 0x1B, 0xE9, 0x1E,
 378         0x3D, 0x10, 0xA4, 0xEB, 0x7F, 0x66, 0x98, 0xF6,
 379         0xC3, 0xAC, 0x35, 0xF5, 0x01, 0x84, 0xFF, 0x7D,
 380         0x1F, 0x72, 0xBE, 0xB4, 0xD1, 0x89, 0xC8, 0xDD,
 381         0x44, 0xE7, 0xB5, 0x2E, 0x2C, 0xE1, 0x85, 0xF5,
 382         0x15, 0x50, 0xA9, 0x08, 0xC7, 0x67, 0xD9, 0x2B,
 383         0x6C, 0x11, 0xB3, 0xEB, 0x28, 0x8D, 0xF4, 0xCC,
 384         0xE3, 0xC3, 0xC5, 0x04, 0x0E, 0x7C, 0x8D, 0xDB,
 385         0x39, 0x06, 0x6A, 0x74, 0x75, 0xDF, 0xA8, 0x0F,
 386         0xDA, 0x67, 0x5A, 0x73, 0x1E, 0xFD, 0x8E, 0x4C,
 387         0xEE, 0x17, 0xEE, 0x1E, 0x67, 0xDB, 0x98, 0x70,
 388         0x60, 0xF7, 0xB9, 0xB5, 0x1F, 0x19, 0x93, 0xD6,
 389         0x3F, 0x2F, 0x1F, 0xB6, 0x5B, 0x59, 0xAA, 0x85,
 390         0xBB, 0x25, 0xE4, 0x13, 0xEF, 0xE7, 0xB9, 0x87,
 391         0x9C, 0x3F, 0x5E, 0xE4, 0x08, 0xA3, 0x51, 0xCF,
 392         0x8B, 0xAD, 0xF4, 0xE6, 0x1A, 0x5F, 0x51, 0xDD,
 393         0xA8, 0xBE, 0xE8, 0xD1, 0x20, 0x19, 0x61, 0x6C,
 394         0x18, 0xAB, 0xCA, 0x0A, 0xD9, 0x82, 0xA6, 0x94,
 395         0xD5, 0x69, 0x2A, 0xF6, 0x43, 0x66, 0x31, 0x09
 396 };
 397
 398 static const unsigned char RSA_E[] = {
 399         0x01, 0x00, 0x01
 400 };
 401
 402 static const unsigned char RSA_P[] = {
 403         0xFD, 0x39, 0x40, 0x56, 0x20, 0x80, 0xC5, 0x81,
 404         0x4C, 0x5F, 0x0C, 0x1A, 0x52, 0x84, 0x03, 0x2F,
 405         0xCE, 0x82, 0xB0, 0xD8, 0x30, 0x23, 0x7F, 0x77,
 406         0x45, 0xC2, 0x01, 0xC4, 0x68, 0x96, 0x0D, 0xA7,
 407         0x22, 0xA9, 0x6C, 0xA9, 0x1A, 0x33, 0xE5, 0x2F,
 408         0xB5, 0x07, 0x9A, 0xF9, 0xEA, 0x33, 0xA5, 0xC8,
 409         0x96, 0x60, 0x6A, 0xCA, 0xEB, 0xE5, 0x6E, 0x09,
 410         0x46, 0x7E, 0x2D, 0xEF, 0x93, 0x7D, 0x56, 0xED,
 411         0x75, 0x70, 0x3B, 0x96, 0xC4, 0xD5, 0xDB, 0x0B,
 412         0x3F, 0x69, 0xDF, 0x06, 0x18, 0x76, 0xF4, 0xCF,
 413         0xF8, 0x84, 0x22, 0xDF, 0xBD, 0x71, 0x62, 0x7B,
 414         0x67, 0x99, 0xBC, 0x09, 0x95, 0x54, 0xA4, 0x98,
 415         0x83, 0xF5, 0xA9, 0xCF, 0x09, 0xA5, 0x1F, 0x61,
 416         0x25, 0xB4, 0x70, 0x6C, 0x91, 0xB8, 0xB3, 0xD0,
 417         0xCE, 0x9C, 0x45, 0x65, 0x9B, 0xEF, 0xD4, 0x70,
 418         0xBE, 0x86, 0xD2, 0x98, 0x5D, 0xEB, 0xE3, 0xFF
 419 };
 420
 421 static const unsigned char RSA_Q[] = {
 422         0xEC, 0x82, 0xEE, 0x63, 0x5F, 0x40, 0x52, 0xDB,
 423         0x38, 0x7A, 0x37, 0x6A, 0x54, 0x5B, 0xD9, 0xA0,
 424         0x73, 0xB4, 0xBB, 0x52, 0xB2, 0x84, 0x07, 0xD0,
 425         0xCC, 0x82, 0x0D, 0x20, 0xB3, 0xFA, 0xD5, 0xB6,
 426         0x25, 0x92, 0x35, 0x4D, 0xB4, 0xC7, 0x36, 0x48,
 427         0xCE, 0x5E, 0x21, 0x4A, 0xA6, 0x74, 0x65, 0xF4,
 428         0x7D, 0x1D, 0xBC, 0x3B, 0xE2, 0xF4, 0x3E, 0x11,
 429         0x58, 0x10, 0x6C, 0x04, 0x46, 0x9E, 0x8D, 0x57,
 430         0xE0, 0x04, 0xE2, 0xEC, 0x47, 0xCF, 0xB3, 0x2A,
 431         0xFD, 0x4C, 0x55, 0x18, 0xDB, 0xDE, 0x3B, 0xDC,
 432         0xF4, 0x5B, 0xDA, 0xF3, 0x1A, 0xC8, 0x41, 0x6F,
 433         0x73, 0x3B, 0xFE, 0x3C, 0xA0, 0xDB, 0xBA, 0x6E,
 434         0x65, 0xA5, 0xE8, 0x02, 0xA5, 0x6C, 0xEA, 0x03,
 435         0xF6, 0x99, 0xF7, 0xCB, 0x4B, 0xB7, 0x11, 0x51,
 436         0x93, 0x88, 0x3F, 0xF9, 0x06, 0x85, 0xA9, 0x1E,
 437         0xCA, 0x64, 0xF8, 0x11, 0xA5, 0x1A, 0xCA, 0xF7
 438 };
 439
 440 static const unsigned char RSA_DP[] = {
 441         0x77, 0x95, 0xE0, 0x02, 0x4C, 0x9B, 0x43, 0xAA,
 442         0xCA, 0x4C, 0x60, 0xC4, 0xD5, 0x8F, 0x2E, 0x8A,
 443         0x17, 0x36, 0xB5, 0x19, 0x83, 0xB2, 0x5F, 0xF2,
 444         0x0D, 0xE9, 0x8F, 0x38, 0x18, 0x44, 0x34, 0xF2,
 445         0x67, 0x76, 0x27, 0xB0, 0xBC, 0x85, 0x21, 0x89,
 446         0x24, 0x2F, 0x11, 0x4B, 0x51, 0x05, 0x4F, 0x17,
 447         0xA9, 0x9C, 0xA3, 0x12, 0x6D, 0xD1, 0x0D, 0xE4,
 448         0x27, 0x7C, 0x53, 0x69, 0x3E, 0xF8, 0x04, 0x63,
 449         0x64, 0x00, 0xBA, 0xC3, 0x7A, 0xF5, 0x9B, 0xDA,
 450         0x75, 0xFA, 0x23, 0xAF, 0x17, 0x42, 0xA6, 0x5E,
 451         0xC8, 0xF8, 0x6E, 0x17, 0xC7, 0xB9, 0x92, 0x4E,
 452         0xC1, 0x20, 0x63, 0x23, 0x0B, 0x78, 0xCB, 0xBA,
 453         0x93, 0x27, 0x23, 0x28, 0x79, 0x5F, 0x97, 0xB0,
 454         0x23, 0x44, 0x51, 0x8B, 0x94, 0x4D, 0xEB, 0xED,
 455         0x82, 0x85, 0x5E, 0x68, 0x9B, 0xF9, 0xE9, 0x13,
 456         0xCD, 0x86, 0x92, 0x52, 0x0E, 0x98, 0xE6, 0x35
 457 };
 458
 459 static const unsigned char RSA_DQ[] = {
 460         0xD8, 0xDD, 0x71, 0xB3, 0x62, 0xBA, 0xBB, 0x7E,
 461         0xD1, 0xF9, 0x96, 0xE8, 0x83, 0xB3, 0xB9, 0x08,
 462         0x9C, 0x30, 0x03, 0x77, 0xDF, 0xC2, 0x9A, 0xDC,
 463         0x05, 0x39, 0xD6, 0xC9, 0xBE, 0xDE, 0x68, 0xA9,
 464         0xDD, 0x27, 0x84, 0x82, 0xDD, 0x19, 0xB1, 0x97,
 465         0xEE, 0xCA, 0x77, 0x22, 0x59, 0x20, 0xEF, 0xFF,
 466         0xCF, 0xDD, 0xBD, 0x24, 0xF8, 0x84, 0xD6, 0x88,
 467         0xD6, 0xC4, 0x30, 0x17, 0x77, 0x9D, 0x98, 0xA3,
 468         0x14, 0x01, 0xC7, 0x05, 0xBB, 0x0F, 0x23, 0x0D,
 469         0x6F, 0x37, 0x57, 0xEC, 0x34, 0x67, 0x41, 0x62,
 470         0xE8, 0x19, 0x75, 0xD9, 0x66, 0x1C, 0x6B, 0x8B,
 471         0xC3, 0x11, 0x26, 0x9C, 0xF7, 0x2E, 0xA3, 0x72,
 472         0xE8, 0xF7, 0xC8, 0x96, 0xEC, 0x92, 0xC2, 0xBD,
 473         0xA1, 0x98, 0x2A, 0x93, 0x99, 0xB8, 0xA2, 0x43,
 474         0xB7, 0xD0, 0xBE, 0x40, 0x1C, 0x8F, 0xE0, 0xB4,
 475         0x20, 0x07, 0x97, 0x43, 0xAE, 0xAD, 0xB3, 0x9F
 476 };
 477
 478 static const unsigned char RSA_IQ[] = {
 479         0xB7, 0xE2, 0x60, 0xA9, 0x62, 0xEC, 0xEC, 0x0B,
 480         0x57, 0x02, 0x96, 0xF9, 0x36, 0x35, 0x2C, 0x37,
 481         0xAF, 0xC2, 0xEE, 0x71, 0x49, 0x26, 0x8E, 0x0F,
 482         0x27, 0xB1, 0xFA, 0x0F, 0xEA, 0xDC, 0xF0, 0x8B,
 483         0x53, 0x6C, 0xB2, 0x46, 0x27, 0xCD, 0x29, 0xA2,
 484         0x35, 0x0F, 0x5D, 0x8A, 0x3F, 0x20, 0x8C, 0x13,
 485         0x3D, 0xA1, 0xFF, 0x85, 0x91, 0x99, 0xE8, 0x50,
 486         0xED, 0xF1, 0x29, 0x00, 0xEE, 0x24, 0x90, 0xB5,
 487         0x5F, 0x3A, 0x74, 0x26, 0xD7, 0xA2, 0x24, 0x8D,
 488         0x89, 0x88, 0xD8, 0x35, 0x22, 0x22, 0x8A, 0x66,
 489         0x5D, 0x5C, 0xDE, 0x83, 0x8C, 0xFA, 0x27, 0xE6,
 490         0xB9, 0xEB, 0x72, 0x08, 0xCD, 0x53, 0x4B, 0x93,
 491         0x0F, 0xAD, 0xC3, 0xF8, 0x7C, 0xFE, 0x84, 0xD7,
 492         0x08, 0xF3, 0xBE, 0x3D, 0x60, 0x1E, 0x95, 0x8D,
 493         0x44, 0x5B, 0x65, 0x7E, 0xC1, 0x30, 0xC3, 0x84,
 494         0xC0, 0xB0, 0xFE, 0xBF, 0x28, 0x54, 0x1E, 0xC4
 495 };
 496
 497 static const br_rsa_public_key RSA_PK = {
 498         (void *)RSA_N, sizeof RSA_N,
 499         (void *)RSA_E, sizeof RSA_E
 500 };
 501
 502 static const br_rsa_private_key RSA_SK = {
 503         2048,
 504         (void *)RSA_P, sizeof RSA_P,
 505         (void *)RSA_Q, sizeof RSA_Q,
 506         (void *)RSA_DP, sizeof RSA_DP,
 507         (void *)RSA_DQ, sizeof RSA_DQ,
 508         (void *)RSA_IQ, sizeof RSA_IQ
 509 };
 510
 511 static void
 512 test_speed_rsa_inner(char *name,
 513         br_rsa_public fpub, br_rsa_private fpriv)
 514 {
 515         unsigned char tmp[sizeof RSA_N];
 516         int i;
 517         long num;
 518
 519         memset(tmp, 'R', sizeof tmp);
 520         tmp[0] = 0;
 521         for (i = 0; i < 10; i ++) {
 522                 if (!fpriv(tmp, &RSA_SK)) {
 523                         abort();
 524                 }
 525         }
 526         num = 10;
 527         for (;;) {
 528                 clock_t begin, end;
 529                 double tt;
 530                 long k;
 531
 532                 begin = clock();
 533                 for (k = num; k > 0; k --) {
 534                         fpriv(tmp, &RSA_SK);
 535                 }
 536                 end = clock();
 537                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
 538                 if (tt >= 2.0) {
 539                         printf("%-30s %8.2f priv/s\n", name,
 540                                 (double)num / tt);
 541                         fflush(stdout);
 542                         break;
 543                 }
 544                 num <<= 1;
 545         }
 546         for (i = 0; i < 10; i ++) {
 547                 if (!fpub(tmp, sizeof tmp, &RSA_PK)) {
 548                         abort();
 549                 }
 550         }
 551         num = 10;
 552         for (;;) {
 553                 clock_t begin, end;
 554                 double tt;
 555                 long k;
 556
 557                 begin = clock();
 558                 for (k = num; k > 0; k --) {
 559                         fpub(tmp, sizeof tmp, &RSA_PK);
 560                 }
 561                 end = clock();
 562                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
 563                 if (tt >= 2.0) {
 564                         printf("%-30s %8.2f pub/s\n", name,
 565                                 (double)num / tt);
 566                         fflush(stdout);
 567                         break;
 568                 }
 569                 num <<= 1;
 570         }
 571 }
 572
 573 static void
 574 test_speed_rsa_i15(void)
 575 {
 576         test_speed_rsa_inner("RSA i15",
 577                 &br_rsa_i15_public, &br_rsa_i15_private);
 578 }
 579
 580 static void
 581 test_speed_rsa_i31(void)
 582 {
 583         test_speed_rsa_inner("RSA i31",
 584                 &br_rsa_i31_public, &br_rsa_i31_private);
 585 }
 586
 587 static void
 588 test_speed_rsa_i32(void)
 589 {
 590         test_speed_rsa_inner("RSA i32",
 591                 &br_rsa_i32_public, &br_rsa_i32_private);
 592 }
 593
 594 static void
 595 test_speed_ec_inner_1(const char *name,
 596         const br_ec_impl *impl, const br_ec_curve_def *cd)
 597 {
 598         unsigned char bx[80], U[160];
 599         uint32_t x[22], n[22];
 600         size_t nlen, ulen;
 601         int i;
 602         long num;
 603
 604         nlen = cd->order_len;
 605         br_i31_decode(n, cd->order, nlen);
 606         memset(bx, 'T', sizeof bx);
 607         br_i31_decode_reduce(x, bx, sizeof bx, n);
 608         br_i31_encode(bx, nlen, x);
 609         ulen = cd->generator_len;
 610         memcpy(U, cd->generator, ulen);
 611         for (i = 0; i < 10; i ++) {
 612                 impl->mul(U, ulen, bx, nlen, cd->curve);
 613         }
 614         num = 10;
 615         for (;;) {
 616                 clock_t begin, end;
 617                 double tt;
 618                 long k;
 619
 620                 begin = clock();
 621                 for (k = num; k > 0; k --) {
 622                         impl->mul(U, ulen, bx, nlen, cd->curve);
 623                 }
 624                 end = clock();
 625                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
 626                 if (tt >= 2.0) {
 627                         printf("%-30s %8.2f mul/s\n", name,
 628                                 (double)num / tt);
 629                         fflush(stdout);
 630                         break;
 631                 }
 632                 num <<= 1;
 633         }
 634 }
 635
 636 static void
 637 test_speed_ec_inner_2(const char *name,
 638         const br_ec_impl *impl, const br_ec_curve_def *cd)
 639 {
 640         unsigned char bx[80], U[160];
 641         uint32_t x[22], n[22];
 642         size_t nlen;
 643         int i;
 644         long num;
 645
 646         nlen = cd->order_len;
 647         br_i31_decode(n, cd->order, nlen);
 648         memset(bx, 'T', sizeof bx);
 649         br_i31_decode_reduce(x, bx, sizeof bx, n);
 650         br_i31_encode(bx, nlen, x);
 651         for (i = 0; i < 10; i ++) {
 652                 impl->mulgen(U, bx, nlen, cd->curve);
 653         }
 654         num = 10;
 655         for (;;) {
 656                 clock_t begin, end;
 657                 double tt;
 658                 long k;
 659
 660                 begin = clock();
 661                 for (k = num; k > 0; k --) {
 662                         impl->mulgen(U, bx, nlen, cd->curve);
 663                 }
 664                 end = clock();
 665                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
 666                 if (tt >= 2.0) {
 667                         printf("%-30s %8.2f mul/s\n", name,
 668                                 (double)num / tt);
 669                         fflush(stdout);
 670                         break;
 671                 }
 672                 num <<= 1;
 673         }
 674 }
 675
 676 static void
 677 test_speed_ec_inner(const char *name,
 678         const br_ec_impl *impl, const br_ec_curve_def *cd)
 679 {
 680         char tmp[50];
 681
 682         test_speed_ec_inner_1(name, impl, cd);
 683         sprintf(tmp, "%s (FP)", name);
 684         test_speed_ec_inner_2(tmp, impl, cd);
 685 }
 686
 687 static void
 688 test_speed_ec_p256_i15(void)
 689 {
 690         test_speed_ec_inner("EC i15/spec P-256",
 691                 &br_ec_p256_i15, &br_secp256r1);
 692 }
 693
 694 static void
 695 test_speed_ec_prime_i15(void)
 696 {
 697         test_speed_ec_inner("EC i15 P-256", &br_ec_prime_i15, &br_secp256r1);
 698         test_speed_ec_inner("EC i15 P-384", &br_ec_prime_i15, &br_secp384r1);
 699         test_speed_ec_inner("EC i15 P-521", &br_ec_prime_i15, &br_secp521r1);
 700 }
 701
 702 static void
 703 test_speed_ec_prime_i31(void)
 704 {
 705         test_speed_ec_inner("EC i31 P-256", &br_ec_prime_i31, &br_secp256r1);
 706         test_speed_ec_inner("EC i31 P-384", &br_ec_prime_i31, &br_secp384r1);
 707         test_speed_ec_inner("EC i31 P-521", &br_ec_prime_i31, &br_secp521r1);
 708 }
 709
 710 static void
 711 test_speed_ecdsa_inner(const char *name,
 712         const br_ec_impl *impl, const br_ec_curve_def *cd,
 713         br_ecdsa_sign sign, br_ecdsa_vrfy vrfy)
 714 {
 715         unsigned char bx[80], U[160], hv[32], sig[160];
 716         uint32_t x[22], n[22];
 717         size_t nlen, ulen, sig_len;
 718         int i;
 719         long num;
 720         br_ec_private_key sk;
 721         br_ec_public_key pk;
 722
 723         nlen = cd->order_len;
 724         br_i31_decode(n, cd->order, nlen);
 725         memset(bx, 'T', sizeof bx);
 726         br_i31_decode_reduce(x, bx, sizeof bx, n);
 727         br_i31_encode(bx, nlen, x);
 728         ulen = cd->generator_len;
 729         memcpy(U, cd->generator, ulen);
 730         impl->mul(U, ulen, bx, nlen, cd->curve);
 731         sk.curve = cd->curve;
 732         sk.x = bx;
 733         sk.xlen = nlen;
 734         pk.curve = cd->curve;
 735         pk.q = U;
 736         pk.qlen = ulen;
 737
 738         memset(hv, 'H', sizeof hv);
 739         sig_len = sign(impl, &br_sha256_vtable, hv, &sk, sig);
 740         if (vrfy(impl, hv, sizeof hv, &pk, sig, sig_len) != 1) {
 741                 fprintf(stderr, "self-test sign/verify failed\n");
 742                 exit(EXIT_FAILURE);
 743         }
 744
 745         for (i = 0; i < 10; i ++) {
 746                 hv[1] ++;
 747                 sign(impl, &br_sha256_vtable, hv, &sk, sig);
 748                 vrfy(impl, hv, sizeof hv, &pk, sig, sig_len);
 749         }
 750
 751         num = 10;
 752         for (;;) {
 753                 clock_t begin, end;
 754                 double tt;
 755                 long k;
 756
 757                 begin = clock();
 758                 for (k = num; k > 0; k --) {
 759                         hv[1] ++;
 760                         sig_len = sign(impl, &br_sha256_vtable, hv, &sk, sig);
 761                 }
 762                 end = clock();
 763                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
 764                 if (tt >= 2.0) {
 765                         printf("%-30s %8.2f sign/s\n", name,
 766                                 (double)num / tt);
 767                         fflush(stdout);
 768                         break;
 769                 }
 770                 num <<= 1;
 771         }
 772
 773         num = 10;
 774         for (;;) {
 775                 clock_t begin, end;
 776                 double tt;
 777                 long k;
 778
 779                 begin = clock();
 780                 for (k = num; k > 0; k --) {
 781                         vrfy(impl, hv, sizeof hv, &pk, sig, sig_len);
 782                 }
 783                 end = clock();
 784                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
 785                 if (tt >= 2.0) {
 786                         printf("%-30s %8.2f verify/s\n", name,
 787                                 (double)num / tt);
 788                         fflush(stdout);
 789                         break;
 790                 }
 791                 num <<= 1;
 792         }
 793 }
 794
 795 static void
 796 test_speed_ecdsa_p256_i15(void)
 797 {
 798         test_speed_ecdsa_inner("ECDSA i15 P-256 (spec)",
 799                 &br_ec_p256_i15, &br_secp256r1,
 800                 &br_ecdsa_i15_sign_asn1,
 801                 &br_ecdsa_i15_vrfy_asn1);
 802 }
 803
 804 static void
 805 test_speed_ecdsa_i15(void)
 806 {
 807         test_speed_ecdsa_inner("ECDSA i15 P-256",
 808                 &br_ec_prime_i15, &br_secp256r1,
 809                 &br_ecdsa_i15_sign_asn1,
 810                 &br_ecdsa_i15_vrfy_asn1);
 811         test_speed_ecdsa_inner("ECDSA i15 P-384",
 812                 &br_ec_prime_i15, &br_secp384r1,
 813                 &br_ecdsa_i15_sign_asn1,
 814                 &br_ecdsa_i15_vrfy_asn1);
 815         test_speed_ecdsa_inner("ECDSA i15 P-521",
 816                 &br_ec_prime_i15, &br_secp521r1,
 817                 &br_ecdsa_i15_sign_asn1,
 818                 &br_ecdsa_i15_vrfy_asn1);
 819 }
 820
 821 static void
 822 test_speed_ecdsa_i31(void)
 823 {
 824         test_speed_ecdsa_inner("ECDSA i31 P-256",
 825                 &br_ec_prime_i31, &br_secp256r1,
 826                 &br_ecdsa_i31_sign_asn1,
 827                 &br_ecdsa_i31_vrfy_asn1);
 828         test_speed_ecdsa_inner("ECDSA i31 P-384",
 829                 &br_ec_prime_i31, &br_secp384r1,
 830                 &br_ecdsa_i31_sign_asn1,
 831                 &br_ecdsa_i31_vrfy_asn1);
 832         test_speed_ecdsa_inner("ECDSA i31 P-521",
 833                 &br_ec_prime_i31, &br_secp521r1,
 834                 &br_ecdsa_i31_sign_asn1,
 835                 &br_ecdsa_i31_vrfy_asn1);
 836 }
 837
 838 #if 0
 839 /* obsolete */
 840 static void
 841 test_speed_ec_prime_i31_inner(const char *name,
 842         const unsigned char *bg, const br_ec_prime_i31_curve *cc)
 843 {
 844         unsigned char bx[80], point[160];
 845         uint32_t x[BR_EC_I31_LEN];
 846         br_ec_prime_i31_jacobian P;
 847         uint32_t xbl;
 848         size_t plen;
 849         int i;
 850         long num;
 851
 852         xbl = cc->p[0];
 853         xbl -= (xbl >> 5);
 854         plen = (xbl + 7) >> 3;
 855         memset(bx, 'T', sizeof bx);
 856         br_i31_decode_reduce(x, bx, sizeof bx, cc->p);
 857         br_i31_encode(bx, plen, x);
 858         br_ec_prime_i31_decode(&P, bg, 1 + (plen << 1), cc);
 859         for (i = 0; i < 10; i ++) {
 860                 br_ec_prime_i31_mul(&P, bx, plen, cc);
 861                 br_ec_prime_i31_encode(point, &P, cc);
 862         }
 863         num = 10;
 864         for (;;) {
 865                 clock_t begin, end;
 866                 double tt;
 867                 long k;
 868
 869                 begin = clock();
 870                 for (k = num; k > 0; k --) {
 871                         br_ec_prime_i31_mul(&P, bx, plen, cc);
 872                         br_ec_prime_i31_encode(point, &P, cc);
 873                 }
 874                 end = clock();
 875                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
 876                 if (tt >= 2.0) {
 877                         printf("%-30s %8.2f mul/s\n", name,
 878                                 (double)num / tt);
 879                         fflush(stdout);
 880                         break;
 881                 }
 882                 num <<= 1;
 883         }
 884 }
 885
 886 static void
 887 test_speed_ec_prime_i31(void)
 888 {
 889         test_speed_ec_prime_i31_inner("EC i31 P-256",
 890                 br_g_secp256r1, &br_ec_prime_i31_secp256r1);
 891         test_speed_ec_prime_i31_inner("EC i31 P-384",
 892                 br_g_secp384r1, &br_ec_prime_i31_secp384r1);
 893         test_speed_ec_prime_i31_inner("EC i31 P-521",
 894                 br_g_secp521r1, &br_ec_prime_i31_secp521r1);
 895 }
 896
 897 static void
 898 test_speed_ec_prime_i32_inner(const char *name,
 899         const unsigned char *bg, const br_ec_prime_i32_curve *cc)
 900 {
 901         unsigned char bx[80], point[160];
 902         uint32_t x[BR_EC_I32_LEN];
 903         br_ec_prime_i32_jacobian P;
 904         size_t plen;
 905         int i;
 906         long num;
 907
 908         plen = (cc->p[0] + 7) >> 3;
 909         memset(bx, 'T', sizeof bx);
 910         br_i32_decode_reduce(x, bx, sizeof bx, cc->p);
 911         br_i32_encode(bx, plen, x);
 912         br_ec_prime_i32_decode(&P, bg, 1 + (plen << 1), cc);
 913         for (i = 0; i < 10; i ++) {
 914                 br_ec_prime_i32_mul(&P, bx, plen, cc);
 915                 br_ec_prime_i32_encode(point, &P, cc);
 916         }
 917         num = 10;
 918         for (;;) {
 919                 clock_t begin, end;
 920                 double tt;
 921                 long k;
 922
 923                 begin = clock();
 924                 for (k = num; k > 0; k --) {
 925                         br_ec_prime_i32_mul(&P, bx, plen, cc);
 926                         br_ec_prime_i32_encode(point, &P, cc);
 927                 }
 928                 end = clock();
 929                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
 930                 if (tt >= 2.0) {
 931                         printf("%-30s %8.2f mul/s\n", name,
 932                                 (double)num / tt);
 933                         fflush(stdout);
 934                         break;
 935                 }
 936                 num <<= 1;
 937         }
 938 }
 939
 940 static void
 941 test_speed_ec_prime_i32(void)
 942 {
 943         test_speed_ec_prime_i32_inner("EC i32 P-256",
 944                 br_g_secp256r1, &br_ec_prime_i32_secp256r1);
 945         test_speed_ec_prime_i32_inner("EC i32 P-384",
 946                 br_g_secp384r1, &br_ec_prime_i32_secp384r1);
 947         test_speed_ec_prime_i32_inner("EC i32 P-521",
 948                 br_g_secp521r1, &br_ec_prime_i32_secp521r1);
 949 }
 950 #endif
 951
 952 static void
 953 test_speed_i31(void)
 954 {
 955         static const unsigned char bp[] = {
 956                 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
 957                 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
 958                 0xBC, 0xE6, 0xFA, 0xAD, 0xA7, 0x17, 0x9E, 0x84,
 959                 0xF3, 0xB9, 0xCA, 0xC2, 0xFC, 0x63, 0x25, 0x51
 960         };
 961
 962         unsigned char tmp[60 + sizeof bp];
 963         uint32_t p[10], x[10], y[10], z[10], p0i;
 964         int i;
 965         long num;
 966
 967         br_i31_decode(p, bp, sizeof bp);
 968         p0i = br_i31_ninv31(p[1]);
 969         memset(tmp, 'T', sizeof tmp);
 970         br_i31_decode_reduce(x, tmp, sizeof tmp, p);
 971         memset(tmp, 'U', sizeof tmp);
 972         br_i31_decode_reduce(y, tmp, sizeof tmp, p);
 973
 974         for (i = 0; i < 10; i ++) {
 975                 br_i31_to_monty(x, p);
 976         }
 977         num = 10;
 978         for (;;) {
 979                 clock_t begin, end;
 980                 double tt;
 981                 long k;
 982
 983                 begin = clock();
 984                 for (k = num; k > 0; k --) {
 985                         br_i31_to_monty(x, p);
 986                 }
 987                 end = clock();
 988                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
 989                 if (tt >= 2.0) {
 990                         printf("%-30s %8.2f ops/s\n", "i31 to_monty",
 991                                 (double)num / tt);
 992                         fflush(stdout);
 993                         break;
 994                 }
 995                 num <<= 1;
 996         }
 997
 998         for (i = 0; i < 10; i ++) {
 999                 br_i31_from_monty(x, p, p0i);
1000         }
1001         num = 10;
1002         for (;;) {
1003                 clock_t begin, end;
1004                 double tt;
1005                 long k;
1006
1007                 begin = clock();
1008                 for (k = num; k > 0; k --) {
1009                         br_i31_from_monty(x, p, p0i);
1010                 }
1011                 end = clock();
1012                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
1013                 if (tt >= 2.0) {
1014                         printf("%-30s %8.2f ops/s\n", "i31 from_monty",
1015                                 (double)num / tt);
1016                         fflush(stdout);
1017                         break;
1018                 }
1019                 num <<= 1;
1020         }
1021
1022         for (i = 0; i < 10; i ++) {
1023                 br_i31_montymul(z, x, y, p, p0i);
1024         }
1025         num = 10;
1026         for (;;) {
1027                 clock_t begin, end;
1028                 double tt;
1029                 long k;
1030
1031                 begin = clock();
1032                 for (k = num; k > 0; k --) {
1033                         br_i31_montymul(z, x, y, p, p0i);
1034                 }
1035                 end = clock();
1036                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
1037                 if (tt >= 2.0) {
1038                         printf("%-30s %8.2f ops/s\n", "i31 montymul",
1039                                 (double)num / tt);
1040                         fflush(stdout);
1041                         break;
1042                 }
1043                 num <<= 1;
1044         }
1045 }
1046
1047 #if 0
1048
1049 static unsigned char P2048[] = {
1050         0xFD, 0xB6, 0xE0, 0x3E, 0x00, 0x49, 0x4C, 0xF0, 0x69, 0x3A, 0xDD, 0x7D,
1051         0xF8, 0xA2, 0x41, 0xB0, 0x6C, 0x67, 0xC5, 0xBA, 0xB8, 0x46, 0x80, 0xF5,
1052         0xBF, 0xAB, 0x98, 0xFC, 0x84, 0x73, 0xA5, 0x63, 0xC9, 0x52, 0x12, 0xDA,
1053         0x4C, 0xC1, 0x5B, 0x9D, 0x8D, 0xDF, 0xCD, 0xFE, 0xC5, 0xAD, 0x5A, 0x6F,
1054         0xDD, 0x02, 0xD9, 0xEC, 0x71, 0xEF, 0xEB, 0xB6, 0x95, 0xED, 0x94, 0x25,
1055         0x0E, 0x63, 0xDD, 0x6A, 0x52, 0xC7, 0x93, 0xAF, 0x85, 0x9D, 0x2C, 0xBE,
1056         0x5C, 0xBE, 0x35, 0xD8, 0xDD, 0x39, 0xEF, 0x1B, 0xB1, 0x49, 0x67, 0xB2,
1057         0x33, 0xC9, 0x7C, 0xE1, 0x51, 0x79, 0x51, 0x59, 0xCA, 0x6E, 0x2A, 0xDF,
1058         0x0D, 0x76, 0x1C, 0xE7, 0xA5, 0xC0, 0x1E, 0x6C, 0x56, 0x3A, 0x32, 0xE5,
1059         0xB5, 0xC5, 0xD4, 0xDB, 0xFE, 0xFF, 0xF8, 0xF2, 0x96, 0xA9, 0xC9, 0x65,
1060         0x59, 0x9E, 0x01, 0x79, 0x9D, 0x38, 0x68, 0x0F, 0xAD, 0x43, 0x3A, 0xD6,
1061         0x84, 0x0A, 0xE2, 0xEF, 0x96, 0xC1, 0x6D, 0x89, 0x74, 0x19, 0x63, 0x82,
1062         0x3B, 0xA0, 0x9C, 0xBA, 0x78, 0xDE, 0xDC, 0xC2, 0xE7, 0xD4, 0xFA, 0xD6,
1063         0x19, 0x21, 0x29, 0xAE, 0x5E, 0xF4, 0x38, 0x81, 0xC6, 0x9E, 0x0E, 0x3C,
1064         0xCD, 0xC0, 0xDC, 0x93, 0x5D, 0xFD, 0x9A, 0x5C, 0xAB, 0x54, 0x1F, 0xFF,
1065         0x9C, 0x12, 0x1B, 0x4C, 0xDF, 0x2D, 0x9C, 0x85, 0xF9, 0x68, 0x15, 0x89,
1066         0x42, 0x9B, 0x6C, 0x45, 0x89, 0x3A, 0xBC, 0xE9, 0x19, 0x91, 0xBE, 0x0C,
1067         0xEF, 0x90, 0xCC, 0xF6, 0xD6, 0xF0, 0x3D, 0x5C, 0xF5, 0xE5, 0x0F, 0x2F,
1068         0x02, 0x8A, 0x83, 0x4B, 0x93, 0x2F, 0x14, 0x12, 0x1F, 0x56, 0x9A, 0x12,
1069         0x58, 0x88, 0xAE, 0x60, 0xB8, 0x5A, 0xE4, 0xA1, 0xBF, 0x4A, 0x81, 0x84,
1070         0xAB, 0xBB, 0xE4, 0xD0, 0x1D, 0x41, 0xD9, 0x0A, 0xAB, 0x1E, 0x47, 0x5B,
1071         0x31, 0xAC, 0x2B, 0x73
1072 };
1073
1074 static unsigned char G2048[] = {
1075         0x02
1076 };
1077
1078 static void
1079 test_speed_modpow(void)
1080 {
1081         uint32_t mx[65], mp[65], me[65], t1[65], t2[65], len;
1082         unsigned char e[64];
1083         int i;
1084         long num;
1085
1086         len = br_int_decode(mp, sizeof mp / sizeof mp[0],
1087                 P2048, sizeof P2048);
1088         if (len != 65) {
1089                 abort();
1090         }
1091         memset(e, 'P', sizeof e);
1092         if (!br_int_decode(me, sizeof me / sizeof me[0], e, sizeof e)) {
1093                 abort();
1094         }
1095         if (!br_modint_decode(mx, mp, G2048, sizeof G2048)) {
1096                 abort();
1097         }
1098         for (i = 0; i < 10; i ++) {
1099                 br_modint_to_monty(mx, mp);
1100                 br_modint_montypow(mx, me, mp, t1, t2);
1101                 br_modint_from_monty(mx, mp);
1102         }
1103         num = 10;
1104         for (;;) {
1105                 clock_t begin, end;
1106                 double tt;
1107                 long k;
1108
1109                 begin = clock();
1110                 for (k = num; k > 0; k --) {
1111                         br_modint_to_monty(mx, mp);
1112                         br_modint_montypow(mx, me, mp, t1, t2);
1113                         br_modint_from_monty(mx, mp);
1114                 }
1115                 end = clock();
1116                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
1117                 if (tt >= 2.0) {
1118                         printf("%-30s %8.2f exp/s\n", "pow[2048:256]",
1119                                 (double)num / tt);
1120                         fflush(stdout);
1121                         return;
1122                 }
1123                 num <<= 1;
1124         }
1125 }
1126
1127 static void
1128 test_speed_moddiv(void)
1129 {
1130         uint32_t mx[65], my[65], mp[65], t1[65], t2[65], t3[65], len;
1131         unsigned char x[255], y[255];
1132         int i;
1133         long num;
1134
1135         len = br_int_decode(mp, sizeof mp / sizeof mp[0],
1136                 P2048, sizeof P2048);
1137         if (len != 65) {
1138                 abort();
1139         }
1140         memset(x, 'T', sizeof x);
1141         memset(y, 'P', sizeof y);
1142         if (!br_modint_decode(mx, mp, x, sizeof x)) {
1143                 abort();
1144         }
1145         if (!br_modint_decode(my, mp, y, sizeof y)) {
1146                 abort();
1147         }
1148         for (i = 0; i < 10; i ++) {
1149                 br_modint_div(mx, my, mp, t1, t2, t3);
1150         }
1151         num = 10;
1152         for (;;) {
1153                 clock_t begin, end;
1154                 double tt;
1155                 long k;
1156
1157                 begin = clock();
1158                 for (k = num; k > 0; k --) {
1159                         br_modint_div(mx, my, mp, t1, t2, t3);
1160                 }
1161                 end = clock();
1162                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
1163                 if (tt >= 2.0) {
1164                         printf("%-30s %8.2f div/s\n", "div[2048]",
1165                                 (double)num / tt);
1166                         fflush(stdout);
1167                         return;
1168                 }
1169                 num <<= 1;
1170         }
1171 }
1172 #endif
1173
1174 #define STU(x)   { test_speed_ ## x, #x }
1175
1176 static const struct {
1177         void (*fn)(void);
1178         char *name;
1179 } tfns[] = {
1180         STU(md5),
1181         STU(sha1),
1182         STU(sha256),
1183         STU(sha512),
1184
1185         STU(aes128_big_cbcenc),
1186         STU(aes128_big_cbcdec),
1187         STU(aes192_big_cbcenc),
1188         STU(aes192_big_cbcdec),
1189         STU(aes256_big_cbcenc),
1190         STU(aes256_big_cbcdec),
1191         STU(aes128_big_ctr),
1192         STU(aes192_big_ctr),
1193         STU(aes256_big_ctr),
1194
1195         STU(aes128_small_cbcenc),
1196         STU(aes128_small_cbcdec),
1197         STU(aes192_small_cbcenc),
1198         STU(aes192_small_cbcdec),
1199         STU(aes256_small_cbcenc),
1200         STU(aes256_small_cbcdec),
1201         STU(aes128_small_ctr),
1202         STU(aes192_small_ctr),
1203         STU(aes256_small_ctr),
1204
1205         STU(aes128_ct_cbcenc),
1206         STU(aes128_ct_cbcdec),
1207         STU(aes192_ct_cbcenc),
1208         STU(aes192_ct_cbcdec),
1209         STU(aes256_ct_cbcenc),
1210         STU(aes256_ct_cbcdec),
1211         STU(aes128_ct_ctr),
1212         STU(aes192_ct_ctr),
1213         STU(aes256_ct_ctr),
1214
1215         STU(aes128_ct64_cbcenc),
1216         STU(aes128_ct64_cbcdec),
1217         STU(aes192_ct64_cbcenc),
1218         STU(aes192_ct64_cbcdec),
1219         STU(aes256_ct64_cbcenc),
1220         STU(aes256_ct64_cbcdec),
1221         STU(aes128_ct64_ctr),
1222         STU(aes192_ct64_ctr),
1223         STU(aes256_ct64_ctr),
1224
1225         STU(des_tab_cbcenc),
1226         STU(des_tab_cbcdec),
1227         STU(3des_tab_cbcenc),
1228         STU(3des_tab_cbcdec),
1229
1230         STU(des_ct_cbcenc),
1231         STU(des_ct_cbcdec),
1232         STU(3des_ct_cbcenc),
1233         STU(3des_ct_cbcdec),
1234
1235         STU(chacha20_ct),
1236
1237         STU(ghash_ctmul),
1238         STU(ghash_ctmul32),
1239         STU(ghash_ctmul64),
1240
1241         STU(poly1305_ctmul),
1242         STU(poly1305_ctmul32),
1243         STU(poly1305_i15),
1244
1245         STU(rsa_i15),
1246         STU(rsa_i31),
1247         STU(rsa_i32),
1248         STU(ec_p256_i15),
1249         STU(ec_prime_i15),
1250         STU(ec_prime_i31),
1251         STU(ecdsa_p256_i15),
1252         STU(ecdsa_i15),
1253         STU(ecdsa_i31),
1254
1255         STU(i31)
1256 };
1257
1258 static int
1259 eq_name(const char *s1, const char *s2)
1260 {
1261         for (;;) {
1262                 int c1, c2;
1263
1264                 for (;;) {
1265                         c1 = *s1 ++;
1266                         if (c1 >= 'A' && c1 <= 'Z') {
1267                                 c1 += 'a' - 'A';
1268                         } else {
1269                                 switch (c1) {
1270                                 case '-': case '_': case '.': case ' ':
1271                                         continue;
1272                                 }
1273                         }
1274                         break;
1275                 }
1276                 for (;;) {
1277                         c2 = *s2 ++;
1278                         if (c2 >= 'A' && c2 <= 'Z') {
1279                                 c2 += 'a' - 'A';
1280                         } else {
1281                                 switch (c2) {
1282                                 case '-': case '_': case '.': case ' ':
1283                                         continue;
1284                                 }
1285                         }
1286                         break;
1287                 }
1288                 if (c1 != c2) {
1289                         return 0;
1290                 }
1291                 if (c1 == 0) {
1292                         return 1;
1293                 }
1294         }
1295 }
1296
1297 int
1298 main(int argc, char *argv[])
1299 {
1300         size_t u;
1301
1302         if (argc <= 1) {
1303                 printf("usage: testspeed all | name...\n");
1304                 printf("individual test names:\n");
1305                 for (u = 0; u < (sizeof tfns) / (sizeof tfns[0]); u ++) {
1306                         printf("   %s\n", tfns[u].name);
1307                 }
1308         } else {
1309                 for (u = 0; u < (sizeof tfns) / (sizeof tfns[0]); u ++) {
1310                         int i;
1311
1312                         for (i = 1; i < argc; i ++) {
1313                                 if (eq_name(argv[i], tfns[u].name)
1314                                         || eq_name(argv[i], "all"))
1315                                 {
1316                                         tfns[u].fn();
1317                                         break;
1318                                 }
1319                         }
1320                 }
1321         }
1322         return 0;
1323 }